@svelte-vitals/core 0.48.0 → 0.50.0

package/README.md

@@ -3,23 +3,23 @@
 [![npm](https://img.shields.io/npm/v/@svelte-vitals/core)](https://www.npmjs.com/package/@svelte-vitals/core)
 [![MIT](https://img.shields.io/npm/l/@svelte-vitals/core)](https://opensource.org/licenses/MIT)
 
-Runtime-agnostic core for [svelte-vitals](https://github.com/oekazuma/svelte-vitals): shared types, the rule engine, scorer, and reporters, plus the full rule set across six categories — SEO, Performance, Correctness, Security, Architecture, Accessibility.
+Runtime-agnostic core for [svelte-vitals](https://github.com/oekazuma/svelte-vitals): shared types, the rule engine, scorer, and reporters, plus the full rule set across six categories: SEO, Performance, Correctness, Security, Architecture, Accessibility.
 
-This package is **mode-independent** and contains no I/O — it operates on a normalized `ResolvedHead[]` intermediate representation, so the same rules run unchanged whether heads come from static source analysis (the `svelte-vitals` CLI) or from prerendered HTML (the `@svelte-vitals/vite` plugin). It has zero runtime dependencies and no `node:` imports.
+This package is **mode-independent** and contains no I/O. It operates on a normalized `ResolvedHead[]` intermediate representation, so the same rules run unchanged whether heads come from static source analysis (the `svelte-vitals` CLI) or from prerendered HTML (the `@svelte-vitals/vite` plugin). It has zero runtime dependencies and no `node:` imports.
 
-> Most users don't depend on this directly — install [`svelte-vitals`](https://www.npmjs.com/package/svelte-vitals) instead. This package is for building tools on top of the shared engine.
+> Most users don't depend on this directly; install [`svelte-vitals`](https://www.npmjs.com/package/svelte-vitals) instead. This package is for building tools on top of the shared engine.
 
 > **ESM-only** (Node 24.16+). Ships ES modules only; `require()` is unsupported by design.
 
 ## Entry points
 
-| Entry                          | Contents                                                                                                                                                                                              | Stability                                                                                                                         |
-| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
-| `@svelte-vitals/core`          | `defineConfig` and the config types; the `JsonReport` types for reading a report; `summarize`, `hasFailureAtOrAbove`, `formatGithubReport`, `formatMarkdownReport` for rendering one and gating on it | Follows semver. For the renderers, that covers the function — not the text it returns, which stays human-readable and may change. |
-| `@svelte-vitals/core/internal` | The engine, rules, fact collection, reporters, and scoring — what the CLI and the Vite plugin share                                                                                                   | **No guarantee. Anything here may change in any release, including a patch.**                                                     |
+| Entry                          | Contents                                                                                                                                                                                              | Stability                                                                                                                        |
+| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `@svelte-vitals/core`          | `defineConfig` and the config types; the `JsonReport` types for reading a report; `summarize`, `hasFailureAtOrAbove`, `formatGithubReport`, `formatMarkdownReport` for rendering one and gating on it | Follows semver. For the renderers, that covers the function, not the text it returns, which stays human-readable and may change. |
+| `@svelte-vitals/core/internal` | The engine, rules, fact collection, reporters, and scoring, which is what the CLI and the Vite plugin share                                                                                           | **No guarantee. Anything here may change in any release, including a patch.**                                                    |
 
 Reach for `/internal` only if you accept pinning an exact version. If something there is what you
-actually need, open an issue — the point of the split is that promoting a name into the stable
+actually need, open an issue. The point of the split is that promoting a name into the stable
 entry is an additive change.
 
 ## License

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { Ct as RuleSetting, Dt as TreatDynamicAs, Et as Severity, Ot as Value, St as RuleOverride, at as formatGithubReport, bt as Result, dt as summarize, ft as CATEGORIES, gt as Fix, ht as Detection, it as formatMarkdownReport, jt as defineConfig, mt as Config, n as RuleEvidence, o as ScoreModel, pt as Category, st as Summary, t as JsonReport, ut as hasFailureAtOrAbove, vt as Presence, wt as RuleSettingObject, xt as RuleOptions } from "./json-B551DazD.js";
+import { Ct as RuleSetting, Dt as TreatDynamicAs, Et as Severity, Ot as Value, St as RuleOverride, at as formatGithubReport, bt as Result, dt as summarize, ft as CATEGORIES, gt as Fix, ht as Detection, it as formatMarkdownReport, jt as defineConfig, mt as Config, n as RuleEvidence, o as ScoreModel, pt as Category, st as Summary, t as JsonReport, ut as hasFailureAtOrAbove, vt as Presence, wt as RuleSettingObject, xt as RuleOptions } from "./json-CcKHN-tx.js";
 export { CATEGORIES, type Category, type Config, type Detection, type Fix, type JsonReport, type Presence, type Result, type RuleEvidence, type RuleOptions, type RuleOverride, type RuleSetting, type RuleSettingObject, type ScoreModel, type Severity, type Summary, type TreatDynamicAs, type Value, defineConfig, formatGithubReport, formatMarkdownReport, hasFailureAtOrAbove, summarize };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { l as formatGithubReport, lr as defineConfig, nr as hasFailureAtOrAbove, or as CATEGORIES, rr as summarize, t as formatMarkdownReport } from "./markdown-BQwOMe_S.js";
+import { cr as hasFailureAtOrAbove, fr as CATEGORIES, hr as defineConfig, l as formatGithubReport, lr as summarize, t as formatMarkdownReport } from "./markdown-CEYpv4SU.js";
 export { CATEGORIES, defineConfig, formatGithubReport, formatMarkdownReport, hasFailureAtOrAbove, summarize };

package/dist/internal.d.ts

@@ -1,4 +1,4 @@
-import { $ as HeadTag, A as formatFailedRuleWarning, At as defaultProject, B as IDREF_ATTRS, C as shouldSkipRangeCheck, D as applyOverrides, E as CompiledOverride, Et as Severity, F as withFailedRulesOff, Ft as OrphanEffectFact, G as isTopFragment, H as ResolvedA11y, I as KitModuleFacts, It as SourceSpan, J as HeadingInfo, K as splitTokens, L as A11yOccurrenceInfo, Lt as SuppressionDirective, M as selectRules, Mt as ComponentFacts, N as settingOptions, Nt as EachBlockFact, O as applyRuleSeverities, Ot as Value, P as settingSeverity, Pt as EffectFact, Q as HeadProvider, R as A11ySkipCause, Rt as skippedFileWarnings, S as resolveRuleOptions, T as validateRuleSetting, Tt as Scope, U as decodeFragmentId, V as LANDMARK_ROLES, W as foldOccurrences, X as ImageInfo, Y as ResolvedHeadings, Z as ResolvedImages, _ as RuleOptionsSpec, _t as KitAlias, a as HealthResult, at as formatGithubReport, b as listOption, bt as Result, c as ScoreResult, ct as classify, d as scoresByCategory, dt as summarize, et as ResolvedHead, f as Rule, g as RuleOptionSpec, gt as Fix, h as isPenalized, i as formatJsonReport, it as formatMarkdownReport, j as overrideMatches, k as compileOverrides, kt as defaultConfig, l as computeHealth, lt as effectiveSeverity, m as docsUrlFor, mt as Config, nt as Runtime, ot as Classification, p as RuleContext, pt as Category, q as stripTextDirective, r as buildJsonReport, rt as withReadLimit, s as ScoreOptions, t as JsonReport, tt as READ_CONCURRENCY, u as computeScore, ut as hasFailureAtOrAbove, v as intOption, w as validateRuleOptions, x as mapOption, y as isMentionedAnywhere, yt as Project, z as BranchStep } from "./json-B551DazD.js";
+import { $ as HeadTag, A as formatFailedRuleWarning, At as defaultProject, B as IDREF_ATTRS, C as shouldSkipRangeCheck, D as applyOverrides, E as CompiledOverride, Et as Severity, F as withFailedRulesOff, Ft as OrphanEffectFact, G as isTopFragment, H as ResolvedA11y, I as KitModuleFacts, It as SourceSpan, J as HeadingInfo, K as splitTokens, L as A11yOccurrenceInfo, Lt as SuppressionDirective, M as selectRules, Mt as ComponentFacts, N as settingOptions, Nt as EachBlockFact, O as applyRuleSeverities, Ot as Value, P as settingSeverity, Pt as EffectFact, Q as HeadProvider, R as A11ySkipCause, Rt as skippedFileWarnings, S as resolveRuleOptions, T as validateRuleSetting, Tt as Scope, U as decodeFragmentId, V as LANDMARK_ROLES, W as foldOccurrences, X as ImageInfo, Y as ResolvedHeadings, Z as ResolvedImages, _ as RuleOptionsSpec, _t as KitAlias, a as HealthResult, at as formatGithubReport, b as listOption, bt as Result, c as ScoreResult, ct as classify, d as scoresByCategory, dt as summarize, et as ResolvedHead, f as Rule, g as RuleOptionSpec, gt as Fix, h as isPenalized, i as formatJsonReport, it as formatMarkdownReport, j as overrideMatches, k as compileOverrides, kt as defaultConfig, l as computeHealth, lt as effectiveSeverity, m as docsUrlFor, mt as Config, nt as Runtime, ot as Classification, p as RuleContext, pt as Category, q as stripTextDirective, r as buildJsonReport, rt as withReadLimit, s as ScoreOptions, t as JsonReport, tt as READ_CONCURRENCY, u as computeScore, ut as hasFailureAtOrAbove, v as intOption, w as validateRuleOptions, x as mapOption, y as isMentionedAnywhere, yt as Project, z as BranchStep } from "./json-CcKHN-tx.js";
 import { AST } from "svelte/compiler";
 //#region src/component-parse.d.ts
 /**
@@ -753,6 +753,9 @@ declare const a11yInvalidAriaValue: Rule;
 //#region src/rules/a11y/interactive-nesting.d.ts
 declare const a11yInteractiveNesting: Rule;
 //#endregion
+//#region src/rules/a11y/aria-hidden-focus.d.ts
+declare const a11yAriaHiddenFocus: Rule;
+//#endregion
 //#region src/rules/a11y/accessible-name.d.ts
 declare const a11yAccessibleName: Rule;
 //#endregion
@@ -780,6 +783,43 @@ declare const a11yRequireDatetime: Rule;
  */
 declare const a11yPositiveTabindex: Rule;
 //#endregion
+//#region src/rules/a11y/no-accesskey.d.ts
+/**
+ * a11y/no-accesskey — unlike most attribute rules, an expression-valued `accesskey` is reported
+ * too: the attribute's presence is the problem and its value never matters, so there is nothing
+ * unknowable about it. A spread-only carrier stays silent (the attribute never reaches `attrs`).
+ * SVG elements are judged along with HTML — `accesskey` is meaningless there, which makes its
+ * presence wrong in both namespaces.
+ */
+declare const a11yNoAccesskey: Rule;
+//#endregion
+//#region src/rules/a11y/no-autofocus.d.ts
+/**
+ * a11y/no-autofocus — only a literal `autofocus` counts (a bare boolean attribute parses to
+ * `value: ''`); an expression value could be `false` and passes as unknowable. The ancestor walk
+ * uses `ElementFact.parent`, which looks through logic blocks but breaks at every non-lexical
+ * construct (a component, `{#snippet}` body, `<svelte:element>`, custom element, `{@html}`,
+ * `{@render}`, `<slot>`) — past a break the dialog cannot be proven, so the element is reported;
+ * the docs page's Limitations section names these classes and the inline-suppression escape
+ * hatch. SVG elements are judged along with HTML: SVG2 honours `autofocus` with the same
+ * page-load focus semantics.
+ */
+declare const a11yNoAutofocus: Rule;
+//#endregion
+//#region src/rules/a11y/no-duplicate-dt.d.ts
+/**
+ * a11y/no-duplicate-dt — the candidate gathering (direct and div-wrapped `<dt>` children of a
+ * `<dl>`, fully-static names only, whitespace-normalized, case-sensitive) lives in the
+ * collector; see `collectDuplicateDts` in component-parse.ts for the exemption rationale.
+ */
+declare const a11yNoDuplicateDt: Rule;
+//#endregion
+//#region src/rules/a11y/abbr-title.d.ts
+declare const a11yAbbrTitle: Rule;
+//#endregion
+//#region src/rules/a11y/pattern-title.d.ts
+declare const a11yPatternTitle: Rule;
+//#endregion
 //#region src/rules/a11y/deprecated-element.d.ts
 declare const a11yDeprecatedElement: Rule;
 //#endregion
@@ -1013,7 +1053,11 @@ declare function formatSarifReport(results: Result[], config: Config, meta: {
 //#endregion
 //#region src/reporter/app-shell.d.ts
 type Band = 'good' | 'warn' | 'poor';
-declare const BAND_COLOR: Record<Band, string>;
+declare const BAND_COLOR: {
+  good: string;
+  warn: string;
+  poor: string;
+};
 declare function scoreBand(score: number): Band;
 declare function escapeHtml(s: string): string;
 /**
@@ -1075,4 +1119,4 @@ declare function formatHtmlReport(results: Result[], config: Config, meta: {
   coreVersion?: string;
 }): string;
 //#endregion
-export { type A11yOccurrenceInfo, type A11ySkipCause, APP_SCRIPT, APP_STYLE, type AppSnapshot, BAND_COLOR, type BranchStep, CHILD_NODE_KEYS, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadProvider, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, LANDMARK_ROLES, type OrphanEffectFact, type Palette, type Project, READ_CONCURRENCY, ROBOTS_SOURCE_PATHS, type RawKitAliases, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, RuleInfo, RuleOptionInfo, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SITEMAP_SOURCE_PATHS, SVELTE_CONFIG_FILES, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, VITE_CONFIG_FILES, type ViteKitConfigResult, a11yAccessibleName, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoMissingIdRef, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, allRules, applyInlineDirectives, applyOverrides, applyRuleSeverities, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentFacts, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, 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, performanceIframeLoading, 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, unknownDirectiveIds, validateRuleOptions, validateRuleSetting, valueFromNodes, withFailedRulesOff, withReadLimit };
+export { type A11yOccurrenceInfo, type A11ySkipCause, APP_SCRIPT, APP_STYLE, type AppSnapshot, BAND_COLOR, type BranchStep, CHILD_NODE_KEYS, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadProvider, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, LANDMARK_ROLES, type OrphanEffectFact, type Palette, type Project, READ_CONCURRENCY, ROBOTS_SOURCE_PATHS, type RawKitAliases, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, RuleInfo, RuleOptionInfo, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SITEMAP_SOURCE_PATHS, SVELTE_CONFIG_FILES, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, VITE_CONFIG_FILES, type ViteKitConfigResult, a11yAbbrTitle, a11yAccessibleName, a11yAriaHiddenFocus, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoAccesskey, a11yNoAutofocus, a11yNoDuplicateDt, a11yNoMissingIdRef, a11yPatternTitle, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, allRules, applyInlineDirectives, applyOverrides, applyRuleSeverities, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentFacts, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, 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, performanceIframeLoading, 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, unknownDirectiveIds, validateRuleOptions, validateRuleSetting, valueFromNodes, withFailedRulesOff, withReadLimit };

package/dist/internal.js

@@ -1,4 +1,4 @@
-import { $ as architecturePrivateScopeImport, $n as seoTitlePresence, $t as seoSingleH1, A as a11yRequireDatetime, An as overrideMatches, At as securityServerModuleState, B as performanceIframeLoading, Bn as performanceResponsiveImage, Bt as correctnessCheckableBindValue, C as a11yPermittedContents, Cn as shouldSkipRangeCheck, Ct as lineOf, D as a11yDeprecatedAttr, Dn as applyRuleSeverities, Dt as architecturePropCount, E as a11yDisallowedAriaProps, En as applyOverrides, Et as valueFromNodes, F as a11yInteractiveNesting, Fn as performanceRenderBlockingScript, Ft as correctnessServerBrowserGlobal, G as performanceNamespaceImport, Gn as seoSitemapXml, Gt as correctnessEffectAsOnMount, H as performanceSequentialAwaits, Hn as performanceImageDimensions, Ht as correctnessStalePropDerivation, I as a11yInvalidAriaValue, In as performanceLcpImage, It as correctnessBasePathNavigation, J as architectureRouteComponentImport, Jn as seoOgTitle, Jt as correctnessEachKey, K as performanceHeavyImport, Kn as seoRobotsTxt, Kt as correctnessEffectAsDerived, L as a11yRequiredAriaProps, Ln as performanceFontPreloadCrossorigin, Lt as correctnessOrphanLifecycle, M as a11yUseList, Mn as settingOptions, Mt as securityJavascriptUrl, N as a11yLabelHasControl, Nn as settingSeverity, Nt as securityRawHtml, O as a11yDeprecatedElement, On as compileOverrides, Ot as architectureComponentSize, P as a11yAccessibleName, Pn as withFailedRulesOff, Pt as correctnessInstanceBrowserGlobal, Q as architectureUnitEntryFile, Qn as headTagRule, Qt as seoDuplicateTitle, R as a11yUnknownAriaAttribute, Rn as performancePreloadMissingAs, Rt as correctnessOrphanEffect, S as a11yRequiredElement, Sn as resolveRuleOptions, St as findAttr, T as a11yDeprecatedAria, Tn as validateRuleSetting, Tt as textFromNodes, U as performanceLoadWaterfall, Un as imageRule, Ut as correctnessPropMutation, V as performanceStateRaw, Vn as performanceImageLoadingHint, Vt as correctnessNonreactiveBuiltinState, W as performanceMinifyDisabled, Wn as seoHtmlLang, Wt as correctnessUnmutatedState, X as architectureReservedDirectoryNames, Xn as seoCanonicalUrl, Xt as seoHeadingLevelSkip, Y as architectureReservedNamePlacement, Yn as seoOgImage, Yt as seoSsrDisabled, Z as architectureDirectoryNaming, Zn as seoDescriptionPresence, Zt as seoDuplicateDescription, _ as a11yNoMissingIdRef, _n as performancePreconnect, _t as CHILD_NODE_KEYS, a as formatJsonReport, an as seoJsonLdRequiredProps, ar as isPenalized, at as collectNamedImportAliases, b as a11yDuplicateLandmark, bn as listOption, bt as attrValue, c as scoresByCategory, cn as seoJsonLdRelativeUrl, cr as defaultProject, ct as parseModuleProgram, d as messageText, dn as seoSitemapInRobots, dt as LANDMARK_ROLES, en as seoHreflang, er as classify, et as collectTopLevelBindings, f as ruleMetaById, fn as seoViewport, ft as decodeFragmentId, g as a11yUnverifiedIdRef, gn as seoIndexability, gt as stripTextDirective, h as explainRule, hn as seoTwitterCard, ht as splitTokens, i as buildJsonReport, in as seoTitleLength, ir as docsUrlFor, it as resolveRunesModuleSpecifier, j as a11yPlaceholderLabelOption, jn as selectRules, jt as securityHandlerStateWrite, k as a11yPositiveTabindex, kn as formatFailedRuleWarning, kt as securitySharedStateImport, l as formatGithubReport, ln as seoJsonLdDeprecatedType, lt as unwrapTs, m as allRules, mn as seoOgDescription, mt as isTopFragment, n as mdEscape, nn as seoCharset, nr as hasFailureAtOrAbove, nt as parseKitModuleFacts, o as computeHealth, on as seoJsonLdPlaceholder, ot as collectSuppressions, p as severityToSarifLevel, pn as seoOgUrl, pt as foldOccurrences, q as architectureDocLinkTarget, qn as seoJsonLd, qt as correctnessEachIndexKey, r as terminalSafe, rn as seoDescriptionLength, rr as summarize, rt as resolveRepoLocalPath, s as computeScore, sn as seoJsonLdDateFormat, sr as defaultConfig, st as parseComponentFacts, t as formatMarkdownReport, tn as seoImageAlt, tr as effectiveSeverity, tt as parseInMemoryExports, u as SEVERITY_RANK, un as seoJsonLdValidity, ut as IDREF_ATTRS, v as a11yIdDuplication, vn as intOption, vt as attrText, w as a11yDisallowedElement, wn as validateRuleOptions, wt as parseSvelte, x as a11yDoctype, xn as mapOption, xt as attrValueOf, y as a11yTopLevelLandmark, yn as isMentionedAnywhere, yt as attrTextOf, z as a11yInvalidRole, zn as linkRule, zt as correctnessAutoplayMuted } from "./markdown-BQwOMe_S.js";
+import { $ as architectureDocLinkTarget, $n as seoJsonLd, $t as correctnessEachIndexKey, A as a11yAbbrTitle, An as validateRuleOptions, At as parseSvelte, B as a11yAriaHiddenFocus, Bn as withFailedRulesOff, Bt as correctnessInstanceBrowserGlobal, C as a11yPermittedContents, Cn as performancePreconnect, Ct as CHILD_NODE_KEYS, D as a11yDeprecatedAttr, Dn as mapOption, Dt as attrValueOf, E as a11yDisallowedAriaProps, En as listOption, Et as attrValue, F as a11yRequireDatetime, Fn as formatFailedRuleWarning, Ft as securitySharedStateImport, G as a11yInvalidRole, Gn as linkRule, Gt as correctnessAutoplayMuted, H as a11yInvalidAriaValue, Hn as performanceLcpImage, Ht as correctnessBasePathNavigation, I as a11yPlaceholderLabelOption, In as overrideMatches, It as securityServerModuleState, J as performanceSequentialAwaits, Jn as performanceImageDimensions, Jt as correctnessStalePropDerivation, K as performanceIframeLoading, Kn as performanceResponsiveImage, Kt as correctnessCheckableBindValue, L as a11yUseList, Ln as selectRules, Lt as securityHandlerStateWrite, M as a11yNoAutofocus, Mn as applyOverrides, Mt as valueFromNodes, N as a11yNoAccesskey, Nn as applyRuleSeverities, Nt as architecturePropCount, O as a11yDeprecatedElement, On as resolveRuleOptions, Ot as findAttr, P as a11yPositiveTabindex, Pn as compileOverrides, Pt as architectureComponentSize, Q as performanceHeavyImport, Qn as seoRobotsTxt, Qt as correctnessEffectAsDerived, R as a11yLabelHasControl, Rn as settingOptions, Rt as securityJavascriptUrl, S as a11yRequiredElement, Sn as seoIndexability, St as stripTextDirective, T as a11yDeprecatedAria, Tn as isMentionedAnywhere, Tt as attrTextOf, U as a11yRequiredAriaProps, Un as performanceFontPreloadCrossorigin, Ut as correctnessOrphanLifecycle, V as a11yInteractiveNesting, Vn as performanceRenderBlockingScript, Vt as correctnessServerBrowserGlobal, W as a11yUnknownAriaAttribute, Wn as performancePreloadMissingAs, Wt as correctnessOrphanEffect, X as performanceMinifyDisabled, Xn as seoHtmlLang, Xt as correctnessUnmutatedState, Y as performanceLoadWaterfall, Yn as imageRule, Yt as correctnessPropMutation, Z as performanceNamespaceImport, Zn as seoSitemapXml, Zt as correctnessEffectAsOnMount, _ as a11yNoMissingIdRef, _n as seoSitemapInRobots, _t as LANDMARK_ROLES, a as formatJsonReport, an as seoSingleH1, ar as seoTitlePresence, at as architecturePrivateScopeImport, b as a11yDuplicateLandmark, bn as seoOgDescription, bt as isTopFragment, c as scoresByCategory, cn as seoCharset, cr as hasFailureAtOrAbove, ct as parseKitModuleFacts, d as messageText, dn as seoJsonLdRequiredProps, dr as isPenalized, dt as collectNamedImportAliases, en as correctnessEachKey, er as seoOgTitle, et as architectureRouteComponentImport, f as ruleMetaById, fn as seoJsonLdPlaceholder, ft as collectSuppressions, g as a11yUnverifiedIdRef, gn as seoJsonLdValidity, gt as IDREF_ATTRS, h as explainRule, hn as seoJsonLdDeprecatedType, ht as unwrapTs, i as buildJsonReport, in as seoDuplicateTitle, ir as headTagRule, it as architectureUnitEntryFile, j as a11yNoDuplicateDt, jn as validateRuleSetting, jt as textFromNodes, k as a11yPatternTitle, kn as shouldSkipRangeCheck, kt as lineOf, l as formatGithubReport, ln as seoDescriptionLength, lr as summarize, lt as resolveRepoLocalPath, m as allRules, mn as seoJsonLdRelativeUrl, mr as defaultProject, mt as parseModuleProgram, n as mdEscape, nn as seoHeadingLevelSkip, nr as seoCanonicalUrl, nt as architectureReservedDirectoryNames, o as computeHealth, on as seoHreflang, or as classify, ot as collectTopLevelBindings, p as severityToSarifLevel, pn as seoJsonLdDateFormat, pr as defaultConfig, pt as parseComponentFacts, q as performanceStateRaw, qn as performanceImageLoadingHint, qt as correctnessNonreactiveBuiltinState, r as terminalSafe, rn as seoDuplicateDescription, rr as seoDescriptionPresence, rt as architectureDirectoryNaming, s as computeScore, sn as seoImageAlt, sr as effectiveSeverity, st as parseInMemoryExports, t as formatMarkdownReport, tn as seoSsrDisabled, tr as seoOgImage, tt as architectureReservedNamePlacement, u as SEVERITY_RANK, un as seoTitleLength, ur as docsUrlFor, ut as resolveRunesModuleSpecifier, v as a11yIdDuplication, vn as seoViewport, vt as decodeFragmentId, w as a11yDisallowedElement, wn as intOption, wt as attrText, x as a11yDoctype, xn as seoTwitterCard, xt as splitTokens, y as a11yTopLevelLandmark, yn as seoOgUrl, yt as foldOccurrences, z as a11yAccessibleName, zn as settingSeverity, zt as securityRawHtml } from "./markdown-CEYpv4SU.js";
 //#region src/inline-directives.ts
 /** The directive silencing `r`, if one sits on its line and names its rule (or names nothing). */
 function directiveFor(index, r) {
@@ -1707,4 +1707,4 @@ function formatHtmlReport(results, config, meta) {
 	return buildHtmlDocument(buildJsonReport(results, config, meta), meta);
 }
 //#endregion
-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, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoMissingIdRef, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, allRules, applyInlineDirectives, applyOverrides, applyRuleSeverities, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentFacts, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, 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, performanceIframeLoading, 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, unknownDirectiveIds, validateRuleOptions, validateRuleSetting, valueFromNodes, withFailedRulesOff, withReadLimit };
+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, a11yAbbrTitle, a11yAccessibleName, a11yAriaHiddenFocus, a11yDeprecatedAria, a11yDeprecatedAttr, a11yDeprecatedElement, a11yDisallowedAriaProps, a11yDisallowedElement, a11yDoctype, a11yDuplicateLandmark, a11yIdDuplication, a11yInteractiveNesting, a11yInvalidAriaValue, a11yInvalidRole, a11yLabelHasControl, a11yNoAccesskey, a11yNoAutofocus, a11yNoDuplicateDt, a11yNoMissingIdRef, a11yPatternTitle, a11yPermittedContents, a11yPlaceholderLabelOption, a11yPositiveTabindex, a11yRequireDatetime, a11yRequiredAriaProps, a11yRequiredElement, a11yTopLevelLandmark, a11yUnknownAriaAttribute, a11yUnverifiedIdRef, a11yUseList, allRules, applyInlineDirectives, applyOverrides, applyRuleSeverities, architectureComponentSize, architectureDirectoryNaming, architectureDocLinkTarget, architecturePrivateScopeImport, architecturePropCount, architectureReservedDirectoryNames, architectureReservedNamePlacement, architectureRouteComponentImport, architectureUnitEntryFile, attrText, attrTextOf, attrValue, attrValueOf, buildHtmlDocument, buildJsonReport, classify, collectComponentFacts, collectKitModuleFacts, collectSourceFiles, collectSuppressions, compileOverrides, computeHealth, computeScore, correctnessAutoplayMuted, 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, performanceIframeLoading, 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, unknownDirectiveIds, validateRuleOptions, validateRuleSetting, valueFromNodes, withFailedRulesOff, withReadLimit };

package/dist/{json-B551DazD.d.ts → json-CcKHN-tx.d.ts}

@@ -93,6 +93,16 @@ interface InteractiveNestingFact {
   /** 1-based source line of the descendant, or 0 if unknown. */
   line: number;
 }
+/** A keyboard-focusable element that a literal `aria-hidden="true"` hides from assistive
+ *  technology — carried on the element itself or on an ancestor (a11y/aria-hidden-focus). */
+interface AriaHiddenFocusFact {
+  /** The focusable element's tag. */
+  tag: string;
+  /** The nearest `aria-hidden="true"` ancestor's tag; absent when the element itself carries it. */
+  containerTag?: string;
+  /** 1-based source line of the focusable element, or 0 if unknown. */
+  line: number;
+}
 /** A `button`/`a href`/`input type="image"` with no computable accessible name (a11y/accessible-name). */
 interface UnnamedInteractiveFact {
   tag: string;
@@ -263,6 +273,8 @@ interface ComponentFacts {
   elements?: ElementFact[];
   /** Interactive elements nested inside another interactive container (a11y/interactive-nesting). */
   interactiveNestings?: InteractiveNestingFact[];
+  /** Keyboard-focusable elements hidden by a literal `aria-hidden="true"` (a11y/aria-hidden-focus). */
+  ariaHiddenFocusables?: AriaHiddenFocusFact[];
   /** `button`/`a href`/`input type="image"` elements with no computable accessible name (a11y/accessible-name). */
   unnamedInteractive?: UnnamedInteractiveFact[];
   /** `<label>` elements with neither a `for` attribute nor a wrapped labelable descendant (a11y/label-has-control). */
@@ -288,6 +300,11 @@ interface ComponentFacts {
   videosAutoplayNoMuted?: {
     line: number;
   }[];
+  /** `<dt>` elements whose static name duplicates an earlier sibling `<dt>` in the same `<dl>` (a11y/no-duplicate-dt). */
+  duplicateDts?: {
+    line: number;
+    text: string;
+  }[];
   /** Set when the file failed to read or parse and these facts are the empty fallback — the file was NOT analyzed. */
   parseFailed?: true;
   /** Set when the file could not be READ — an environment problem (permissions, a descriptor

package/dist/{markdown-BQwOMe_S.js → markdown-CEYpv4SU.js}

@@ -4344,7 +4344,8 @@ function collectElements(node, source, acc, inSvg, parent) {
 			tag,
 			line: lineOf(source, node.start),
 			attrs: node.attributes.filter((a) => a?.type === "Attribute" && typeof a.name === "string").map((a) => {
-				const value = a.value === true ? "" : attrValueOf(a) === "static" ? attrTextOf(a) ?? void 0 : void 0;
+				const cls = classifyAttrValue(a.value);
+				const value = "expression" in cls ? void 0 : cls.literal;
 				return {
 					name: String(a.name).toLowerCase(),
 					line: lineOf(source, a.start ?? node.start),
@@ -4463,6 +4464,54 @@ function collectInteractiveNestings(node, source, acc, stack) {
 	for (const key of CHILD_NODE_KEYS) if (key in node) collectInteractiveNestings(node[key], source, acc, stack);
 	if (opened) stack.pop();
 }
+/** Tags on which a `disabled` attribute actually removes focusability (it does nothing on `<a>`). */
+const DISABLEABLE_TAGS = /* @__PURE__ */ new Set([
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
+/**
+* Keyboard-focusable elements hidden by a literal `aria-hidden="true"` (a11y/aria-hidden-focus).
+* Same conventions as `collectInteractiveNestings`: only `RegularElement`, snippet bodies walk
+* with a fresh stack (they render at their `{@render}` site), and an expression `aria-hidden`
+* is unknowable — a toggled `aria-hidden={...}` never opens a container. Exempt as not
+* focusable: a `tabindex` that is negative (the documented remediation) or an expression (it
+* may resolve to -1), a `disabled` form control, and anything at or under an `inert` or
+* `hidden` element — an inert subtree leaves the tab order and a hidden one does not render,
+* so both carry down the walk as `unfocusable`.
+*/
+function collectAriaHiddenFocusables(node, source, acc, stack, unfocusable = false) {
+	if (Array.isArray(node)) {
+		for (const child of node) collectAriaHiddenFocusables(child, source, acc, stack, unfocusable);
+		return;
+	}
+	if (!node || typeof node !== "object") return;
+	if (node.type === "SnippetBlock") {
+		for (const key of CHILD_NODE_KEYS) if (key in node) collectAriaHiddenFocusables(node[key], source, acc, []);
+		return;
+	}
+	let opened = false;
+	if (node.type === "RegularElement" && Array.isArray(node.attributes)) {
+		const attrs = elementAttrs(node.attributes);
+		if (attrs.some((a) => a.name === "inert" || a.name === "hidden")) unfocusable = true;
+		const hiddenSelf = attrs.find((a) => a.name === "aria-hidden")?.literal?.trim().toLowerCase() === "true";
+		const tabindexAttr = attrs.find((a) => a.name === "tabindex");
+		const tabindex = literalTabindexValue(tabindexAttr?.literal);
+		const tabindexExempts = tabindexAttr !== void 0 && tabindexAttr.literal === void 0;
+		if (!unfocusable && !tabindexExempts && !(tabindex !== void 0 && tabindex < 0) && !(DISABLEABLE_TAGS.has(node.name) && attrs.some((a) => a.name === "disabled")) && isInteractiveElement(node.name, attrs) && (hiddenSelf || stack.length > 0)) acc.push({
+			tag: node.name,
+			...hiddenSelf ? {} : { containerTag: stack[stack.length - 1] },
+			line: lineOf(source, node.start)
+		});
+		if (hiddenSelf) {
+			stack.push(node.name);
+			opened = true;
+		}
+	}
+	for (const key of CHILD_NODE_KEYS) if (key in node) collectAriaHiddenFocusables(node[key], source, acc, stack, unfocusable);
+	if (opened) stack.pop();
+}
 /** `aria-label`/`aria-labelledby`/`title` present on this element: a literal non-empty value,
 *  or any expression (its rendered value is unknowable, but its *presence* is enough to name
 *  the element — a11y/accessible-name treats an expression name source as present). */
@@ -4486,11 +4535,6 @@ function hasNamingAttr(attributes) {
 function isCustomElement(node) {
 	return node.type === "RegularElement" && typeof node.name === "string" && node.name.includes("-");
 }
-/** Named/unknowable verdict for a candidate interactive element's descendant subtree
-*  (a11y/accessible-name). `named`: a non-whitespace text descendant, or a descendant `img`
-*  with a non-empty literal `alt`. `unknowable`: an expression-tag, `Component`, `{@render}`,
-*  or `{@html}` anywhere below — content the rule cannot statically resolve, so the element is
-*  skipped rather than risk a false positive. */
 function scanAccessibleNameSubtree(node, skip) {
 	if (Array.isArray(node)) {
 		const acc = {
@@ -4642,10 +4686,6 @@ function isLabelableDescendant(node) {
 	if (node.name !== "input") return true;
 	return attrText(node.attributes ?? [], "type")?.toLowerCase() !== "hidden";
 }
-/** Wrapped-control/unknowable verdict for a `<label>`'s subtree (a11y/label-has-control).
-*  `hasControl`: a descendant labelable element. `unknowable`: an expression-tag, `Component`,
-*  `{@render}`, or `{@html}` anywhere below — content the rule cannot statically resolve, so
-*  the label is skipped rather than risk a false positive. */
 function scanLabelSubtree(node) {
 	if (Array.isArray(node)) {
 		const acc = {
@@ -4880,6 +4920,84 @@ function collectTimesMissingDatetime(node, source, acc) {
 	for (const key of CHILD_NODE_KEYS) if (key in node) collectTimesMissingDatetime(node[key], source, acc);
 }
 /**
+* Fully-static text content of a node list: concatenated `Text` data, looked through static
+* regular elements (`<dt><code>HTTP</code></dt>` names "HTTP"), with comments contributing
+* nothing. `undefined` when anything dynamic appears anywhere below — an expression, a
+* component, a block, `{@html}`/`{@render}`, `<svelte:element>`, a `<slot>`, or a custom
+* element (its shadow root may supply content) — because the rendered text is then unknowable.
+*/
+function staticTextOf(nodes) {
+	let out = "";
+	for (const n of nodes) {
+		if (!n || typeof n !== "object") continue;
+		if (n.type === "Comment") continue;
+		if (n.type === "Text") {
+			out += String(n.data ?? "");
+			continue;
+		}
+		if (n.type === "RegularElement" && typeof n.name === "string" && !n.name.includes("-")) {
+			const inner = staticTextOf(n.fragment?.nodes ?? []);
+			if (inner === void 0) return void 0;
+			out += inner;
+			continue;
+		}
+		return;
+	}
+	return out;
+}
+/**
+* Duplicate `<dt>` names within one `<dl>` (a11y/no-duplicate-dt). Candidates are `<dt>`
+* elements that are direct children of the `<dl>`, or direct children of a direct `<div>`
+* child (the spec's div-wrapped name-value groups); a dt under a logic block or component is
+* not a candidate — its multiplicity or rendered content is unknowable, and unknowable names
+* can only ever add duplicates, never fabricate one between two static non-duplicates. A
+* candidate's name is its fully-static text content (`staticTextOf` above — static phrasing
+* markup like `<dt><code>HTTP</code></dt>` is looked through, comments contribute nothing),
+* trimmed and whitespace-collapsed; an empty name is not a candidate (two empty dts are a
+* missing-content defect, not a duplicate name).
+* Comparison is case-sensitive — the spec leaves the equality undefined, so only certain
+* duplicates are reported. Namespace is tracked like `collectElements`: a `<dl>` inside
+* `<svg>` never renders as an HTML definition list, so it is skipped; `<foreignObject>`
+* children return to HTML. Nested `<dl>`s get their own scope for free — the walk recurses
+* and a nested dl's dts are never the outer dl's direct children.
+*/
+function collectDuplicateDts(node, source, acc, inSvg) {
+	if (Array.isArray(node)) {
+		for (const child of node) collectDuplicateDts(child, source, acc, inSvg);
+		return;
+	}
+	if (!node || typeof node !== "object") return;
+	let next = inSvg;
+	if (node.type === "RegularElement" && typeof node.name === "string") {
+		const tag = node.name.toLowerCase();
+		if (tag === "svg") next = true;
+		else if (tag === "foreignobject") next = false;
+		if (!inSvg && tag === "dl") {
+			const seen = /* @__PURE__ */ new Set();
+			const judge = (dt) => {
+				const raw = staticTextOf(dt.fragment?.nodes ?? []);
+				if (raw === void 0) return;
+				const name = raw.trim().replace(/\s+/g, " ");
+				if (!name) return;
+				if (seen.has(name)) acc.push({
+					line: lineOf(source, dt.start),
+					text: name
+				});
+				else seen.add(name);
+			};
+			for (const child of node.fragment?.nodes ?? []) {
+				if (child?.type !== "RegularElement" || typeof child.name !== "string") continue;
+				const childTag = child.name.toLowerCase();
+				if (childTag === "dt") judge(child);
+				else if (childTag === "div") {
+					for (const inner of child.fragment?.nodes ?? []) if (inner?.type === "RegularElement" && typeof inner.name === "string" && inner.name.toLowerCase() === "dt") judge(inner);
+				}
+			}
+		}
+	}
+	for (const key of CHILD_NODE_KEYS) if (key in node) collectDuplicateDts(node[key], source, acc, next);
+}
+/**
 * `<video>` with a literal `autoplay` attribute and no `muted` in any form
 * (correctness/autoplay-muted). Presence is what autoplays, so any literal value counts
 * (`autoplay="false"` still autoplays); an expression value is unknowable and is skipped.
@@ -5597,15 +5715,6 @@ function collectBrowserGlobalRefs(program, source, extra) {
 }
 /** A Svelte runes module file — the whole file is one module-scope program (correctness/orphan-effect). */
 const MODULE_FILE_RE = /\.svelte\.(ts|js)$/;
-/**
-* Parse a plain TS/JS module source by wrapping it in a `<script lang="ts">` tag —
-* the Svelte script parser handles TS natively, so no extra parser dependency is
-* needed. Literal "<\/script" occurrences are neutralised with a same-length
-* placeholder first (string contents don't affect fact extraction; offsets are
-* preserved). Returns the ESTree Program and the wrapped source — wrapped line
-* numbers are +1 relative to the input, so callers subtract 1. Shared by the
-* runes-module facts (correctness/orphan-effect) and the Kit-module facts (the security kit-module rules).
-*/
 function parseModuleProgram(source, filename) {
 	const wrapped = `<script lang="ts">\n${source.replace(/<\/script/gi, "<_script")}\n<\/script>`;
 	return {
@@ -5751,6 +5860,8 @@ function parseComponentFacts(source, filename) {
 	collectElements(ast.fragment ?? ast, source, elements, ast.options?.namespace === "svg");
 	const interactiveNestings = [];
 	collectInteractiveNestings(ast.fragment ?? ast, source, interactiveNestings, []);
+	const ariaHiddenFocusables = [];
+	collectAriaHiddenFocusables(ast.fragment ?? ast, source, ariaHiddenFocusables, []);
 	const unnamedInteractive = [];
 	const labelTargets = {
 		ids: /* @__PURE__ */ new Set(),
@@ -5768,6 +5879,8 @@ function parseComponentFacts(source, filename) {
 	collectTimesMissingDatetime(ast.fragment ?? ast, source, timesMissingDatetime);
 	const videosAutoplayNoMuted = [];
 	collectVideosAutoplayNoMuted(ast.fragment ?? ast, source, videosAutoplayNoMuted, ast.options?.namespace === "svg");
+	const duplicateDts = [];
+	collectDuplicateDts(ast.fragment ?? ast, source, duplicateDts, ast.options?.namespace === "svg");
 	const basePathLinks = [];
 	collectHrefLinks(ast.fragment ?? ast, source, basePathLinks);
 	const gotoPrograms = [ast.module?.content, ast.instance?.content].filter(Boolean);
@@ -5975,12 +6088,14 @@ function parseComponentFacts(source, filename) {
 		ariaElements,
 		elements,
 		interactiveNestings,
+		ariaHiddenFocusables,
 		unnamedInteractive,
 		unassociatedLabels,
 		bulletTexts,
 		selectsMissingPlaceholder,
 		timesMissingDatetime,
-		videosAutoplayNoMuted
+		videosAutoplayNoMuted,
+		duplicateDts
 	};
 }
 //#endregion
@@ -8429,19 +8544,70 @@ const a11yInteractiveNesting = componentRule({
 	}))
 });
 //#endregion
+//#region src/rules/a11y/aria-hidden-focus.ts
+const a11yAriaHiddenFocus = componentRule({
+	id: "a11y/aria-hidden-focus",
+	title: "Focusable element hidden by aria-hidden",
+	category: "a11y",
+	label: "aria-hidden keeps focusables out",
+	rationale: "An element inside `aria-hidden=\"true\"` stays keyboard-reachable while assistive technology announces nothing for it — a screen reader user lands on a control that does not exist for them. The author cannot see this defect: `aria-hidden` changes nothing visually, so only assistive-technology users ever encounter it.",
+	recommendation: "Remove `aria-hidden`, or take the element out of the tab order too (`tabindex=\"-1\"`, `disabled`). To hide an inactive region such as a modal backdrop, prefer the `inert` attribute — it removes the subtree from both the accessibility tree and the tab order at once.",
+	applies: (c) => (c.ariaHiddenFocusables ?? []).length > 0,
+	bad: (c) => (c.ariaHiddenFocusables ?? []).map((f) => ({
+		line: f.line,
+		message: f.containerTag ? `<${f.tag}> inside <${f.containerTag} aria-hidden="true"> is still keyboard-focusable` : `<${f.tag} aria-hidden="true"> is still keyboard-focusable`
+	}))
+});
+//#endregion
 //#region src/rules/a11y/accessible-name.ts
+const NAMING_ATTRS = /* @__PURE__ */ new Set([
+	"title",
+	"aria-label",
+	"aria-labelledby"
+]);
+/**
+* The iframe arm reads the generic elements channel rather than the collector's
+* `unnamedInteractive` facts: an iframe has no name-from-content step (its children are fallback
+* content, never rendered), so the subtree scan the other targets need does not apply — and the
+* channel already carries the SVG-namespace flag (SVG has no iframe; the element never renders)
+* and the spread guard. Hidden or presentational iframes are skipped — `aria-hidden="true"`,
+* `hidden`, `role="presentation"`/`"none"` — the tracking/analytics-frame class where a name
+* helps nobody; an expression value in any of the skip attributes (and `hidden` in any form,
+* bare included) resolves unknowable → silence, this rule's convention throughout. The skip set
+* is deliberate to this arm only: a hidden focusable button is a different defect.
+*/
+function unnamedIframes(c) {
+	return (c.elements ?? []).filter((e) => {
+		if (e.tag !== "iframe" || e.inSvg || e.hasSpread) return false;
+		if (e.attrs.some((a) => NAMING_ATTRS.has(a.name) && (a.value === void 0 || a.value.trim() !== ""))) return false;
+		const attr = (name) => e.attrs.find((a) => a.name === name);
+		const ariaHidden = attr("aria-hidden");
+		if (ariaHidden && (ariaHidden.value === void 0 || ariaHidden.value.trim().toLowerCase() === "true")) return false;
+		if (attr("hidden")) return false;
+		const role = attr("role");
+		if (role) {
+			if (role.value === void 0) return false;
+			const resolved = resolveRole(splitTokens(role.value.toLowerCase()));
+			if (resolved === "presentation" || resolved === "none") return false;
+		}
+		return true;
+	});
+}
 const 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 or an aria-label/aria-labelledby; a button or link whose only content is an icon image is named by that image's alt, and an <input type=\"image\"> by its own alt.",
-	applies: (c) => (c.unnamedInteractive ?? []).length > 0,
-	bad: (c) => (c.unnamedInteractive ?? []).map((f) => ({
+	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; an iframe without one is announced as an unnamed frame, with no way to tell an embedded video from an ad slot before entering it.",
+	recommendation: "Give the element visible text or an aria-label/aria-labelledby; a button or link whose only content is an icon image is named by that image's alt, an <input type=\"image\"> by its own alt, and an <iframe> by its title.",
+	applies: (c) => (c.unnamedInteractive ?? []).length > 0 || unnamedIframes(c).length > 0,
+	bad: (c) => [...(c.unnamedInteractive ?? []).map((f) => ({
 		line: f.line,
 		message: `<${f.tag}> has no accessible name`
-	}))
+	})), ...unnamedIframes(c).map((e) => ({
+		line: e.line,
+		message: "<iframe> has no accessible name"
+	}))]
 });
 //#endregion
 //#region src/rules/a11y/label-has-control.ts
@@ -8538,6 +8704,185 @@ const a11yPositiveTabindex = componentRule({
 	})
 });
 //#endregion
+//#region src/rules/a11y/no-accesskey.ts
+/**
+* a11y/no-accesskey — unlike most attribute rules, an expression-valued `accesskey` is reported
+* too: the attribute's presence is the problem and its value never matters, so there is nothing
+* unknowable about it. A spread-only carrier stays silent (the attribute never reaches `attrs`).
+* SVG elements are judged along with HTML — `accesskey` is meaningless there, which makes its
+* presence wrong in both namespaces.
+*/
+const a11yNoAccesskey = componentRule({
+	id: "a11y/no-accesskey",
+	title: "Accesskey attribute",
+	category: "a11y",
+	severity: "warning",
+	label: "Accesskey attributes",
+	recommendation: "Remove the accesskey attribute. Provide visible, focusable controls instead; if a real keyboard shortcut is needed, implement it with a key handler and document it in the page.",
+	rationale: "The accesskey attribute assigns a page-level shortcut key, but the actual key combination varies by browser and OS, is undiscoverable to users, and routinely conflicts with screen reader and browser keyboard bindings. Long-standing accessibility guidance is to not use it.",
+	fix: { description: "Remove the accesskey attribute." },
+	applies: (c) => (c.elements ?? []).some((e) => e.attrs.some((a) => a.name === "accesskey")),
+	bad: (c) => (c.elements ?? []).filter((e) => e.attrs.some((a) => a.name === "accesskey")).map((e) => ({
+		line: e.line,
+		message: `accesskey on <${e.tag}> — the shortcut key varies by browser and OS, is undiscoverable, and conflicts with assistive-technology bindings`
+	}))
+});
+//#endregion
+//#region src/rules/a11y/no-autofocus.ts
+/**
+* `<dialog>` and popover containers run their focusing steps on show, not on page load, and both
+* honour an `autofocus` descendant — so autofocus there is the correct tool, not focus theft.
+* The popover check accepts the attribute in any form (bare, literal, expression): an expression
+* could resolve to a real popover value, and a generous carve-out trades a false negative for
+* never flagging the documented pattern (same trade as correctness/autoplay-muted's `muted`).
+* Neither container form counts in the SVG namespace — the focusing steps are defined for the
+* HTML `dialog` element and HTML elements with a `popover` attribute only; a `<dialog>` inside
+* `<foreignObject>` is back in HTML and still counts.
+*/
+function inShowTimeContainer(elements, start) {
+	let e = start;
+	while (e !== void 0) {
+		if (!e.inSvg && (e.tag === "dialog" || e.attrs.some((a) => a.name === "popover"))) return true;
+		e = e.parent === void 0 ? void 0 : elements[e.parent];
+	}
+	return false;
+}
+/**
+* a11y/no-autofocus — only a literal `autofocus` counts (a bare boolean attribute parses to
+* `value: ''`); an expression value could be `false` and passes as unknowable. The ancestor walk
+* uses `ElementFact.parent`, which looks through logic blocks but breaks at every non-lexical
+* construct (a component, `{#snippet}` body, `<svelte:element>`, custom element, `{@html}`,
+* `{@render}`, `<slot>`) — past a break the dialog cannot be proven, so the element is reported;
+* the docs page's Limitations section names these classes and the inline-suppression escape
+* hatch. SVG elements are judged along with HTML: SVG2 honours `autofocus` with the same
+* page-load focus semantics.
+*/
+const a11yNoAutofocus = componentRule({
+	id: "a11y/no-autofocus",
+	title: "Autofocus outside a dialog",
+	category: "a11y",
+	severity: "warning",
+	label: "Autofocus placement",
+	recommendation: "Remove the autofocus attribute and let focus start at the top of the page, or move the control into the <dialog> or popover it belongs to; focus moved in response to a user action belongs in an event handler.",
+	rationale: "autofocus moves focus on page load without the user asking, skipping everything before the target — screen reader users lose the page context they were building, and keyboard users are dropped mid-page. Inside a <dialog> or a popover it is the correct tool (their focusing steps run on show, not on load); anywhere else it is almost always a usability bug.",
+	fix: { description: "Remove the autofocus attribute, or move the element inside the <dialog>/popover container it is meant to focus." },
+	applies: (c) => literalAutofocusElements(c).length > 0,
+	bad: (c) => {
+		const elements = c.elements ?? [];
+		return literalAutofocusElements(c).filter((e) => !inShowTimeContainer(elements, e)).map((e) => ({
+			line: e.line,
+			message: `autofocus on <${e.tag}> steals focus when the page loads — keyboard and screen reader users lose their place`
+		}));
+	}
+});
+function literalAutofocusElements(c) {
+	return (c.elements ?? []).filter((e) => e.attrs.some((a) => a.name === "autofocus" && a.value !== void 0));
+}
+//#endregion
+//#region src/rules/a11y/no-duplicate-dt.ts
+/**
+* a11y/no-duplicate-dt — the candidate gathering (direct and div-wrapped `<dt>` children of a
+* `<dl>`, fully-static names only, whitespace-normalized, case-sensitive) lives in the
+* collector; see `collectDuplicateDts` in component-parse.ts for the exemption rationale.
+*/
+const a11yNoDuplicateDt = componentRule({
+	id: "a11y/no-duplicate-dt",
+	title: "Duplicate <dt> names in a <dl>",
+	category: "a11y",
+	severity: "info",
+	label: "Description-list names",
+	rationale: "Within a single dl element, there should not be more than one dt element for each name — the HTML spec calls this out explicitly, and a duplicated term usually means a copy-paste error where two descriptions were meant to share one dt.",
+	recommendation: "Merge the descriptions under a single <dt> — one dt may be followed by several <dd> — or rename the term if the entries are genuinely different.",
+	fix: { description: "Merge the duplicated terms into one <dt> followed by both <dd> descriptions, or rename one of them." },
+	applies: (c) => (c.duplicateDts ?? []).length > 0,
+	bad: (c) => (c.duplicateDts ?? []).map((d) => ({
+		line: d.line,
+		message: `Duplicate <dt> "${d.text}" in the same <dl>`
+	}))
+});
+//#endregion
+//#region src/rules/a11y/abbr-title.ts
+/**
+* a11y/abbr-title — a best-practice nudge, not a conformance check: the spec makes `title` on
+* `<abbr>` optional, and an expansion given in the surrounding prose is correct markup this
+* rule cannot see (the known false-positive class; the docs page names the inline-suppression
+* escape hatch for it). A blank literal `title=""` gives no expansion and is reported; an
+* expression value is unknowable and passes, the same predicate as a11y/accessible-name's
+* iframe check. SVG is skipped — `<abbr>` is not an SVG element.
+*/
+function untitledAbbrs(c) {
+	return (c.elements ?? []).filter((e) => e.tag === "abbr" && !e.inSvg && !e.hasSpread && !e.attrs.some((a) => a.name === "title" && (a.value === void 0 || a.value.trim() !== "")));
+}
+const a11yAbbrTitle = componentRule({
+	id: "a11y/abbr-title",
+	title: "Abbreviation without an expansion",
+	category: "a11y",
+	severity: "info",
+	label: "Abbreviation expansions",
+	rationale: "<abbr> marks an abbreviation, but without a title giving the expansion the element adds no information — visual users get no tooltip and assistive technology has nothing to expand. The spec keeps title optional (an expansion in the surrounding text is also fine), so this is a nudge toward the common case, not a conformance requirement.",
+	recommendation: "Add title with the expansion, or spell the term out in full at first use instead of using <abbr>. If the expansion is already given in the surrounding text, the markup is fine as written — silence the finding instead.",
+	fix: {
+		description: "Add a title attribute with the expansion, or spell the term out at first use.",
+		snippet: "<abbr title=\"HyperText Markup Language\">HTML</abbr>",
+		lang: "svelte"
+	},
+	applies: (c) => untitledAbbrs(c).length > 0,
+	bad: (c) => untitledAbbrs(c).map((e) => ({
+		line: e.line,
+		message: "<abbr> without a title gives readers no expansion of the abbreviation"
+	}))
+});
+//#endregion
+//#region src/rules/a11y/pattern-title.ts
+/** The input types the `pattern` attribute applies to, per the spec's applies-to table. */
+const PATTERN_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"search",
+	"url",
+	"tel",
+	"email",
+	"password"
+]);
+/**
+* a11y/pattern-title — only judged where `pattern` is effective: no `type` (defaults to Text)
+* or a literal type in the applies-to set. A literal type outside it (`type="number"`) makes
+* pattern inert, so requiring a title there would be wrong; an expression type or pattern is
+* unknowable and passes. An unknown type keyword (`type="txet"`) falls back to the Text state
+* where pattern does apply — skipping it is a deliberate, conservative false negative (docs
+* Limitations). A blank literal `title=""` describes nothing and is reported; an expression
+* title counts as present, the a11y/accessible-name predicate. SVG-namespace inputs never
+* render as form controls and are skipped.
+*/
+function patternInputsMissingTitle(c) {
+	return (c.elements ?? []).filter((e) => {
+		if (e.tag !== "input" || e.inSvg || e.hasSpread) return false;
+		const pattern = e.attrs.find((a) => a.name === "pattern");
+		if (pattern === void 0 || pattern.value === void 0) return false;
+		const type = e.attrs.find((a) => a.name === "type");
+		if (type !== void 0 && (type.value === void 0 || !PATTERN_TYPES.has(type.value.trim().toLowerCase()))) return false;
+		return !e.attrs.some((a) => a.name === "title" && (a.value === void 0 || a.value.trim() !== ""));
+	});
+}
+const a11yPatternTitle = componentRule({
+	id: "a11y/pattern-title",
+	title: "Pattern input without a format description",
+	category: "a11y",
+	severity: "info",
+	label: "Pattern descriptions",
+	rationale: "When an <input> has a pattern attribute, the spec says authors should include a title describing the expected format — browsers surface it in the validation error, and without it a failed submit tells the user only that the value is wrong, not what right looks like.",
+	recommendation: "Add a title describing the expected format in plain words (e.g. \"Letters, a dash, then digits\"), and mirror it in visible help text — title alone is unavailable to many users.",
+	fix: {
+		description: "Add a title attribute describing the expected format.",
+		snippet: "<input pattern=\"[A-Za-z]+-[0-9]+\" title=\"Letters, a dash, then digits\" />",
+		lang: "svelte"
+	},
+	applies: (c) => patternInputsMissingTitle(c).length > 0,
+	bad: (c) => patternInputsMissingTitle(c).map((e) => ({
+		line: e.line,
+		message: "<input pattern> without a title — a failed match tells the user nothing about the expected format"
+	}))
+});
+//#endregion
 //#region src/html-spec/index.ts
 /** The HTML element's spec row; `undefined` for SVG (`svg:*`) and unknown names. */
 function htmlElement(tag) {
@@ -8609,13 +8954,6 @@ const a11yDeprecatedAttr = componentRule({
 });
 //#endregion
 //#region src/rules/a11y/role-candidates.ts
-/**
-* Element-level ARIA facts that override the dataset's, with the reason each is data judgment
-* rather than data (design 2026-08-19-aria-role-table-rules, "the spec wins over the dataset").
-* `<hgroup>` is `generic` + naming-prohibited in the dataset; html-aria (TR and editor's draft) and
-* axe give it `role=group` with no prohibition. Replacing the whole fact closes every arm at once.
-* `<address>` is already `group` in the dataset and only its naming flag is wrong.
-*/
 const ELEMENT_FACT_OVERRIDES = {
 	hgroup: { implicitRole: "group" },
 	address: { implicitRole: "group" }
@@ -9560,12 +9898,18 @@ const allRules = [
 	a11yRequiredAriaProps,
 	a11yInvalidAriaValue,
 	a11yInteractiveNesting,
+	a11yAriaHiddenFocus,
 	a11yAccessibleName,
 	a11yLabelHasControl,
 	a11yUseList,
 	a11yPlaceholderLabelOption,
 	a11yRequireDatetime,
 	a11yPositiveTabindex,
+	a11yNoAccesskey,
+	a11yNoAutofocus,
+	a11yNoDuplicateDt,
+	a11yAbbrTitle,
+	a11yPatternTitle,
 	a11yDeprecatedElement,
 	a11yDeprecatedAttr,
 	a11yDisallowedAriaProps,
@@ -10027,4 +10371,4 @@ function formatMarkdownReport(results, config, meta) {
 	return lines.join("\n");
 }
 //#endregion
-export { architecturePrivateScopeImport as $, seoTitlePresence as $n, seoSingleH1 as $t, a11yRequireDatetime as A, overrideMatches as An, securityServerModuleState as At, performanceIframeLoading as B, performanceResponsiveImage as Bn, correctnessCheckableBindValue as Bt, a11yPermittedContents as C, shouldSkipRangeCheck as Cn, lineOf as Ct, a11yDeprecatedAttr as D, applyRuleSeverities as Dn, architecturePropCount as Dt, a11yDisallowedAriaProps as E, applyOverrides as En, valueFromNodes as Et, a11yInteractiveNesting as F, performanceRenderBlockingScript as Fn, correctnessServerBrowserGlobal as Ft, performanceNamespaceImport as G, seoSitemapXml as Gn, correctnessEffectAsOnMount as Gt, performanceSequentialAwaits as H, performanceImageDimensions as Hn, correctnessStalePropDerivation as Ht, a11yInvalidAriaValue as I, performanceLcpImage as In, correctnessBasePathNavigation as It, architectureRouteComponentImport as J, seoOgTitle as Jn, correctnessEachKey as Jt, performanceHeavyImport as K, seoRobotsTxt as Kn, correctnessEffectAsDerived as Kt, a11yRequiredAriaProps as L, performanceFontPreloadCrossorigin as Ln, correctnessOrphanLifecycle as Lt, a11yUseList as M, settingOptions as Mn, securityJavascriptUrl as Mt, a11yLabelHasControl as N, settingSeverity as Nn, securityRawHtml as Nt, a11yDeprecatedElement as O, compileOverrides as On, architectureComponentSize as Ot, a11yAccessibleName as P, withFailedRulesOff as Pn, correctnessInstanceBrowserGlobal as Pt, architectureUnitEntryFile as Q, headTagRule as Qn, seoDuplicateTitle as Qt, a11yUnknownAriaAttribute as R, performancePreloadMissingAs as Rn, correctnessOrphanEffect as Rt, a11yRequiredElement as S, resolveRuleOptions as Sn, findAttr as St, a11yDeprecatedAria as T, validateRuleSetting as Tn, textFromNodes as Tt, performanceLoadWaterfall as U, imageRule as Un, correctnessPropMutation as Ut, performanceStateRaw as V, performanceImageLoadingHint as Vn, correctnessNonreactiveBuiltinState as Vt, performanceMinifyDisabled as W, seoHtmlLang as Wn, correctnessUnmutatedState as Wt, architectureReservedDirectoryNames as X, seoCanonicalUrl as Xn, seoHeadingLevelSkip as Xt, architectureReservedNamePlacement as Y, seoOgImage as Yn, seoSsrDisabled as Yt, architectureDirectoryNaming as Z, seoDescriptionPresence as Zn, seoDuplicateDescription as Zt, a11yNoMissingIdRef as _, performancePreconnect as _n, CHILD_NODE_KEYS as _t, formatJsonReport as a, seoJsonLdRequiredProps as an, isPenalized as ar, collectNamedImportAliases as at, a11yDuplicateLandmark as b, listOption as bn, attrValue as bt, scoresByCategory as c, seoJsonLdRelativeUrl as cn, defaultProject as cr, parseModuleProgram as ct, messageText as d, seoSitemapInRobots as dn, LANDMARK_ROLES as dt, seoHreflang as en, classify as er, collectTopLevelBindings as et, ruleMetaById as f, seoViewport as fn, decodeFragmentId as ft, a11yUnverifiedIdRef as g, seoIndexability as gn, stripTextDirective as gt, explainRule as h, seoTwitterCard as hn, splitTokens as ht, buildJsonReport as i, seoTitleLength as in, docsUrlFor as ir, resolveRunesModuleSpecifier as it, a11yPlaceholderLabelOption as j, selectRules as jn, securityHandlerStateWrite as jt, a11yPositiveTabindex as k, formatFailedRuleWarning as kn, securitySharedStateImport as kt, formatGithubReport as l, seoJsonLdDeprecatedType as ln, defineConfig as lr, unwrapTs as lt, allRules as m, seoOgDescription as mn, isTopFragment as mt, mdEscape as n, seoCharset as nn, hasFailureAtOrAbove as nr, parseKitModuleFacts as nt, computeHealth as o, seoJsonLdPlaceholder as on, CATEGORIES as or, collectSuppressions as ot, severityToSarifLevel as p, seoOgUrl as pn, foldOccurrences as pt, architectureDocLinkTarget as q, seoJsonLd as qn, correctnessEachIndexKey as qt, terminalSafe as r, seoDescriptionLength as rn, summarize as rr, resolveRepoLocalPath as rt, computeScore as s, seoJsonLdDateFormat as sn, defaultConfig as sr, parseComponentFacts as st, formatMarkdownReport as t, seoImageAlt as tn, effectiveSeverity as tr, parseInMemoryExports as tt, SEVERITY_RANK as u, seoJsonLdValidity as un, IDREF_ATTRS as ut, a11yIdDuplication as v, intOption as vn, attrText as vt, a11yDisallowedElement as w, validateRuleOptions as wn, parseSvelte as wt, a11yDoctype as x, mapOption as xn, attrValueOf as xt, a11yTopLevelLandmark as y, isMentionedAnywhere as yn, attrTextOf as yt, a11yInvalidRole as z, linkRule as zn, correctnessAutoplayMuted as zt };
+export { architectureDocLinkTarget as $, seoJsonLd as $n, correctnessEachIndexKey as $t, a11yAbbrTitle as A, validateRuleOptions as An, parseSvelte as At, a11yAriaHiddenFocus as B, withFailedRulesOff as Bn, correctnessInstanceBrowserGlobal as Bt, a11yPermittedContents as C, performancePreconnect as Cn, CHILD_NODE_KEYS as Ct, a11yDeprecatedAttr as D, mapOption as Dn, attrValueOf as Dt, a11yDisallowedAriaProps as E, listOption as En, attrValue as Et, a11yRequireDatetime as F, formatFailedRuleWarning as Fn, securitySharedStateImport as Ft, a11yInvalidRole as G, linkRule as Gn, correctnessAutoplayMuted as Gt, a11yInvalidAriaValue as H, performanceLcpImage as Hn, correctnessBasePathNavigation as Ht, a11yPlaceholderLabelOption as I, overrideMatches as In, securityServerModuleState as It, performanceSequentialAwaits as J, performanceImageDimensions as Jn, correctnessStalePropDerivation as Jt, performanceIframeLoading as K, performanceResponsiveImage as Kn, correctnessCheckableBindValue as Kt, a11yUseList as L, selectRules as Ln, securityHandlerStateWrite as Lt, a11yNoAutofocus as M, applyOverrides as Mn, valueFromNodes as Mt, a11yNoAccesskey as N, applyRuleSeverities as Nn, architecturePropCount as Nt, a11yDeprecatedElement as O, resolveRuleOptions as On, findAttr as Ot, a11yPositiveTabindex as P, compileOverrides as Pn, architectureComponentSize as Pt, performanceHeavyImport as Q, seoRobotsTxt as Qn, correctnessEffectAsDerived as Qt, a11yLabelHasControl as R, settingOptions as Rn, securityJavascriptUrl as Rt, a11yRequiredElement as S, seoIndexability as Sn, stripTextDirective as St, a11yDeprecatedAria as T, isMentionedAnywhere as Tn, attrTextOf as Tt, a11yRequiredAriaProps as U, performanceFontPreloadCrossorigin as Un, correctnessOrphanLifecycle as Ut, a11yInteractiveNesting as V, performanceRenderBlockingScript as Vn, correctnessServerBrowserGlobal as Vt, a11yUnknownAriaAttribute as W, performancePreloadMissingAs as Wn, correctnessOrphanEffect as Wt, performanceMinifyDisabled as X, seoHtmlLang as Xn, correctnessUnmutatedState as Xt, performanceLoadWaterfall as Y, imageRule as Yn, correctnessPropMutation as Yt, performanceNamespaceImport as Z, seoSitemapXml as Zn, correctnessEffectAsOnMount as Zt, a11yNoMissingIdRef as _, seoSitemapInRobots as _n, LANDMARK_ROLES as _t, formatJsonReport as a, seoSingleH1 as an, seoTitlePresence as ar, architecturePrivateScopeImport as at, a11yDuplicateLandmark as b, seoOgDescription as bn, isTopFragment as bt, scoresByCategory as c, seoCharset as cn, hasFailureAtOrAbove as cr, parseKitModuleFacts as ct, messageText as d, seoJsonLdRequiredProps as dn, isPenalized as dr, collectNamedImportAliases as dt, correctnessEachKey as en, seoOgTitle as er, architectureRouteComponentImport as et, ruleMetaById as f, seoJsonLdPlaceholder as fn, CATEGORIES as fr, collectSuppressions as ft, a11yUnverifiedIdRef as g, seoJsonLdValidity as gn, IDREF_ATTRS as gt, explainRule as h, seoJsonLdDeprecatedType as hn, defineConfig as hr, unwrapTs as ht, buildJsonReport as i, seoDuplicateTitle as in, headTagRule as ir, architectureUnitEntryFile as it, a11yNoDuplicateDt as j, validateRuleSetting as jn, textFromNodes as jt, a11yPatternTitle as k, shouldSkipRangeCheck as kn, lineOf as kt, formatGithubReport as l, seoDescriptionLength as ln, summarize as lr, resolveRepoLocalPath as lt, allRules as m, seoJsonLdRelativeUrl as mn, defaultProject as mr, parseModuleProgram as mt, mdEscape as n, seoHeadingLevelSkip as nn, seoCanonicalUrl as nr, architectureReservedDirectoryNames as nt, computeHealth as o, seoHreflang as on, classify as or, collectTopLevelBindings as ot, severityToSarifLevel as p, seoJsonLdDateFormat as pn, defaultConfig as pr, parseComponentFacts as pt, performanceStateRaw as q, performanceImageLoadingHint as qn, correctnessNonreactiveBuiltinState as qt, terminalSafe as r, seoDuplicateDescription as rn, seoDescriptionPresence as rr, architectureDirectoryNaming as rt, computeScore as s, seoImageAlt as sn, effectiveSeverity as sr, parseInMemoryExports as st, formatMarkdownReport as t, seoSsrDisabled as tn, seoOgImage as tr, architectureReservedNamePlacement as tt, SEVERITY_RANK as u, seoTitleLength as un, docsUrlFor as ur, resolveRunesModuleSpecifier as ut, a11yIdDuplication as v, seoViewport as vn, decodeFragmentId as vt, a11yDisallowedElement as w, intOption as wn, attrText as wt, a11yDoctype as x, seoTwitterCard as xn, splitTokens as xt, a11yTopLevelLandmark as y, seoOgUrl as yn, foldOccurrences as yt, a11yAccessibleName as z, settingSeverity as zn, securityRawHtml as zt };

package/package.json

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