@svelte-vitals/core 0.55.2 → 0.55.4

package/dist/internal.d.ts

@@ -1,12 +1,15 @@
-import { $ as formatGithubReport, A as routeNeverSsr, At as EachBlockFact, B as NAMING_ATTRS, C as compileOverrides, Ct as defaultConfig, D as withFailedRulesOff, Dt as ResolvedHead, E as settingSeverity, Et as HeadTag, F as ANCESTRY_DEPENDENT_TAGS, Ft as collectComponentFacts, G as isTopFragment, H as SECTIONING_TAGS, I as ASIDE_DEMOTING_TAGS, It as emptyComponentFacts, J as stripTextDirective, K as resolveLandmark, L as BranchStep, Lt as skippedFileWarnings, M as ResolvedHeadings, Mt as OrphanEffectFact, N as A11yOccurrenceInfo, Nt as SourceSpan, O as withIndexableOff, Ot as isClassicScriptType, P as A11ySkipCause, Pt as SuppressionDirective, Q as formatMarkdownReport, R as IDREF_ATTRS, Rt as Runtime, S as SEARCH_RESULT_RULES, St as Value, T as selectRules, U as decodeFragmentId, V as ResolvedA11y, W as foldOccurrences, X as ResolvedImages, Y as ImageInfo, Z as isSvgSrc, _ as isPlainObject, a as HealthResult, at as summarize, b as validateRuleSetting, bt as Severity, c as ScoreResult, ct as Config, d as Rule, dt as KitAlias, et as Classification, f as RuleContext, g as RuleOptionsSpec, h as RuleOptionSpec, i as formatJsonReport, it as hasFailureAtOrAbove, j as HeadingInfo, jt as EffectFact, k as KitModuleFacts, kt as ComponentFacts, l as computeHealth, m as isPenalized, mt as Result, nt as classify, p as docsUrlFor, pt as Project, q as splitTokens, r as buildJsonReport, rt as effectiveSeverity, s as ScoreOptions, st as Category, t as JsonReport, u as computeScore, ut as Fix, v as resolveRuleOptions, w as formatFailedRuleWarning, wt as defaultProject, x as CompiledOverride, y as shouldSkipRangeCheck, yt as Scope, z as LandmarkInput, zt as withReadLimit } from "./json-BQf9Qb2D.js";
+import { $ as ResolvedImages, A as KitModuleFacts, At as ResolvedHead, B as BranchStep, Bt as emptyComponentFacts, C as SEARCH_RESULT_RULES, Ct as Severity, D as settingSeverity, Dt as defaultProject, E as selectRules, Et as defaultConfig, F as ResolvedHeadings, Ft as EffectFact, G as SECTIONING_TAGS, H as LandmarkInput, Ht as Runtime, I as A11yOccurrenceInfo, It as OrphanEffectFact, J as isTopFragment, K as decodeFragmentId, L as A11ySkipCause, Lt as SourceSpan, M as pageRendersOnlyWhenBuilding, Mt as isClassicScriptType, N as routeNeverSsr, Nt as ComponentFacts, O as withFailedRulesOff, P as HeadingInfo, Pt as EachBlockFact, Q as ImageInfo, R as ANCESTRY_DEPENDENT_TAGS, Rt as SuppressionDirective, S as CompiledOverride, St as Scope, T as formatFailedRuleWarning, Tt as Value, U as NAMING_ATTRS, Ut as withReadLimit, V as IDREF_ATTRS, Vt as skippedFileWarnings, W as ResolvedA11y, X as splitTokens, Y as resolveLandmark, Z as stripTextDirective, _ as RuleOptionsSpec, _t as Result, a as formatJsonReportChunks, at as classify, b as shouldSkipRangeCheck, c as ScoreOptions, ct as summarize, d as computeScore, dt as Config, et as isSvgSrc, f as Rule, g as RuleOptionSpec, gt as Project, h as isPenalized, i as formatJsonReport, j as layoutNeverRenders, jt as hasRel, k as withIndexableOff, kt as HeadTag, l as ScoreResult, m as docsUrlFor, mt as KitAlias, nt as formatGithubReport, o as HealthResult, ot as effectiveSeverity, p as RuleContext, pt as Fix, q as foldOccurrences, r as buildJsonReport, rt as Classification, st as hasFailureAtOrAbove, t as JsonReport, tt as formatMarkdownReport, u as computeHealth, ut as Category, v as isPlainObject, w as compileOverrides, x as validateRuleSetting, y as resolveRuleOptions, z as ASIDE_DEMOTING_TAGS, zt as collectComponentFacts } from "./json-CWGGrAda.js";
 import { AST } from "svelte/compiler";
-//#region src/component-parse.d.ts
-type Node$1 = any;
+type Node$2 = any;
+/** A component's script `const` lists that nothing in its scripts or template can change. */
+export declare function collectComponentConstantLists(ast: Node$2, opts?: {
+  sets?: boolean;
+}): Set<string>;
 /**
  * Export names of a module's constant lists — `export const X = [ … ]`, or a local one exported by
  * name — that the module itself never writes (correctness/each-key, correctness/each-index-key).
  */
-export declare function collectConstantListExports(program: Node$1): Set<string>;
+export declare function collectConstantListExports(program: Node$2): Set<string>;
 /** What the per-file parsers produce — `ComponentFacts` minus `file`, with `suppressions` always present. */
 type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
   suppressions: SuppressionDirective[];
@@ -17,9 +20,469 @@ type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
  * runes module's orphan-$effect facts (correctness/orphan-effect).
  */
 export declare function parseComponentFacts(source: string, filename: string): ParsedFacts;
-//#endregion
-//#region src/module-ast.d.ts
-type Node = any;
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+interface SourceLocation {
+  source?: string | null | undefined;
+  start: Position;
+  end: Position;
+}
+interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+    cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+type Node$1 = any;
+interface TSSatisfiesExpression {
+  type: 'TSSatisfiesExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+interface TSAsExpression {
+  type: 'TSAsExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+interface TSNonNullExpression {
+  type: 'TSNonNullExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+/** An estree `Expression`, optionally wrapped in one or more of the three TS wrappers above. */
+type TsExpression = Expression | TSSatisfiesExpression | TSAsExpression | TSNonNullExpression;
+/** Unwrap TS wrapper expressions (`x satisfies T`, `x as T`, `x!`) to the underlying expression. Shared with the Kit-module and Vite-config parsers. */
+export declare function unwrapTs(expr: TsExpression): Expression;
+export declare function unwrapTs(expr: TsExpression | undefined): Expression | undefined;
+/** Generic ESTree walk over a `<script>` program: visit every node with a `.type`. */
+export declare function walkEstree(node: Node$1, visit: (n: Node$1) => void): void;
 /**
  * Inline `svelte-vitals-disable-next-line` directives (issue #92). A plain text scan, not an
  * AST walk, so `<script>` (`//`) and template (`<!-- -->`) comments are covered uniformly. The
@@ -37,12 +500,10 @@ export declare function collectSuppressions(source: string): SuppressionDirectiv
  * runes-module facts (correctness/orphan-effect) and the Kit-module facts (the security kit-module rules).
  */
 type ParsedModule = {
-  program: Node | undefined;
+  program: Node$1 | undefined;
   wrapped: string;
 };
 export declare function parseModuleProgram(source: string, filename: string): ParsedModule;
-//#endregion
-//#region src/inline-directives.d.ts
 /** File-relative-path → the inline directives collected from that file. */
 type DirectiveIndex = ReadonlyMap<string, readonly SuppressionDirective[]>;
 /**
@@ -64,8 +525,6 @@ export declare function addFactsDirectives(index: Map<string, readonly Suppressi
  * not turn its directives into errors.
  */
 export declare function unknownDirectiveIds(index: DirectiveIndex, rules: readonly Rule[]): string[];
-//#endregion
-//#region src/source-files.d.ts
 /**
  * Every file under `src/`, as project-relative paths, sorted. Paths only — nothing is
  * read, so this is the cheaper of the two passes over `src/` (the component collector
@@ -80,8 +539,9 @@ export declare function unknownDirectiveIds(index: DirectiveIndex, rules: readon
  * those rules are concerned, and dot directories never appear at all (see `Runtime.glob`).
  */
 export declare function collectSourceFiles(rt: Runtime, cwd: string): Promise<string[]>;
-//#endregion
-//#region src/kit-module-parse.d.ts
+type Node = any;
+/** `parseFalseExports` over a parsed module. */
+export declare function collectFalseExports(program: Node): Set<string>;
 /**
  * Resolve an import specifier to a path relative to the analyzed project's root (the
  * cwd svelte-vitals runs from — not necessarily a repo root; in a monorepo the project
@@ -109,8 +569,6 @@ export declare function collectSourceFiles(rt: Runtime, cwd: string): Promise<st
  * repo-local specifier resolution in the repo.
  */
 export declare function resolveRepoLocalPath(spec: string, importerFile: string, aliases?: readonly KitAlias[]): string | undefined;
-//#endregion
-//#region src/kit-module-collect.d.ts
 /**
  * Scan SvelteKit route/hooks files for SSR shared-state facts (the security kit-module rules): route
  * `+page`/`+layout` server and universal modules, `+server` endpoints, and
@@ -122,8 +580,6 @@ export declare function resolveRepoLocalPath(spec: string, importerFile: string,
  * specifiers resolve through `$lib` → `src/lib` only.
  */
 export declare function collectKitModuleFacts(rt: Runtime, cwd: string, aliases?: readonly KitAlias[]): Promise<KitModuleFacts[]>;
-//#endregion
-//#region src/vite-config-parse.d.ts
 /**
  * The `build: { minify: false }` override, when present as a literal: returns the
  * `minify` property's 1-based line in the ORIGINAL source. Undefined for clean,
@@ -132,8 +588,6 @@ export declare function collectKitModuleFacts(rt: Runtime, cwd: string, aliases?
 export declare function findMinifyDisabled(source: string): {
   line: number;
 } | undefined;
-//#endregion
-//#region src/svelte-config-parse.d.ts
 /**
  * The project's compiled alias list, following SvelteKit's config precedence: options passed to
  * the `sveltekit()` Vite plugin make `svelte.config` irrelevant (Kit logs "svelte.config.js is
@@ -155,6 +609,8 @@ export declare function resolveKitAliases(viteConfig: {
  * which leaves the specifier unresolved as before.
  */
 export declare function withPackageImports(aliases: KitAlias[] | undefined, packageJsonSource: string | undefined): KitAlias[] | undefined;
+/** Whether `kit.router.type` is the literal `'hash'` in a config whose value is known. */
+export declare function findKitHashRouterInSvelteConfig(source: string): boolean;
 /**
  * The project's effective `kit.paths.base`, following SvelteKit's precedence: the `sveltekit()`
  * plugin config when it carries one, otherwise `svelte.config`. `file` is the config the base
@@ -170,8 +626,6 @@ export declare function resolveKitPathsBase(viteConfig: {
   value?: string;
   file: string;
 } | undefined;
-//#endregion
-//#region src/workspace-packages.d.ts
 /** A package the app declares, from its repository or its `node_modules`: `dir` is relative to the app. */
 interface WorkspacePackage {
   name: string;
@@ -208,8 +662,6 @@ export declare function declaredInstalledPackages(packageJsonSource: string | un
  * publish no Svelte marker get no entries: nothing they export is a component.
  */
 export declare function withInstalledPackages(aliases: KitAlias[] | undefined, packages: readonly WorkspacePackage[]): KitAlias[] | undefined;
-//#endregion
-//#region src/svelte-ast.d.ts
 /**
  * Parse a `.svelte` source, tolerating style blocks written in a CSS dialect.
  *
@@ -222,7 +674,7 @@ export declare function withInstalledPackages(aliases: KitAlias[] | undefined, p
  * the text scan's imprecision cannot reach it. A file that does not parse is already a hard failure,
  * which the retry can only improve on.
  */
-export declare function parseSvelte(source: string, filename: string): AST.Root;
+export declare function parseSvelte(raw: string, filename: string): AST.Root;
 /** A template fragment's child node relevant to value classification: literal text or a `{expr}`. */
 type TextOrExpr = AST.Text | AST.ExpressionTag;
 /**
@@ -253,8 +705,6 @@ export declare function findAttr(attributes: AST.Attribute[], name: string): AST
 export declare function attrValueOf(attr: AST.Attribute): Value;
 /** Literal static text of a single attribute node (e.g. a component prop), or undefined if dynamic/absent. */
 export declare function attrTextOf(attr: AST.Attribute): string | undefined;
-//#endregion
-//#region src/project-paths.d.ts
 /**
  * Source-file locations that satisfy the project-scope rules, shared by every
  * mode so the static (CLI) and rendered (plugin) collectors never drift. This
@@ -265,15 +715,16 @@ export declare const ROBOTS_SOURCE_PATHS: readonly ["static/robots.txt", "src/ro
 /** Locations that satisfy the sitemap.xml project rule (seo/sitemap-xml). */
 export declare const SITEMAP_SOURCE_PATHS: readonly ["static/sitemap.xml", "src/routes/sitemap.xml/+server.ts", "src/routes/sitemap.xml/+server.js"];
 /** The `+server` endpoints above, wherever (group) directories nest them — filter with `servesRootFile`. */
-export declare const ROOT_FILE_ENDPOINT_GLOB = "src/routes/**/{robots.txt,sitemap.xml}/+server.{ts,js}";
-/** Whether a `+server` endpoint serves `/<file>`: (group) directories add no URL segment. */
+export declare const ROOT_FILE_ENDPOINT_GLOB = "src/routes/**/{robots.txt,sitemap*.xml}/+server.{ts,js}";
+/**
+ * Whether a `+server` endpoint serves `/<file>`: (group) directories add no URL segment, and an optional
+ * parameter in the name (`sitemap[[page]].xml`) still answers the bare name.
+ */
 export declare function servesRootFile(rel: string, file: 'robots.txt' | 'sitemap.xml'): boolean;
 /** Vite's own config resolution order — only the first existing file is the one Vite loads. */
 export declare const VITE_CONFIG_FILES: readonly ["vite.config.js", "vite.config.mjs", "vite.config.ts", "vite.config.cjs", "vite.config.mts", "vite.config.cts"];
 /** SvelteKit's config resolution order (`@sveltejs/kit` checks js before ts). */
 export declare const SVELTE_CONFIG_FILES: readonly ["svelte.config.js", "svelte.config.ts"];
-//#endregion
-//#region src/engine.d.ts
 interface FailedRule {
   id: string;
   message: string;
@@ -305,55 +756,25 @@ export declare function runAnalysis(rules: Rule[], ctx: RuleContext, directives:
   failedRuleIds: string[];
   scoringConfig: Config;
 }>;
-//#endregion
-//#region src/rules/seo/title-presence.d.ts
 /**
  * seo/title-presence — every route should resolve a non-empty <title> (design §11).
  * A dynamic title (`{data.title}`) is the most common correct pattern and must
  * never be flagged as missing; it surfaces as value 'dynamic' (design §4).
  */
 export declare const seoTitlePresence: Rule;
-//#endregion
-//#region src/rules/seo/description-presence.d.ts
 export declare const seoDescriptionPresence: Rule;
-//#endregion
-//#region src/rules/seo/canonical-url.d.ts
 export declare const seoCanonicalUrl: Rule;
-//#endregion
-//#region src/rules/seo/og-image.d.ts
 export declare const seoOgImage: Rule;
-//#endregion
-//#region src/rules/seo/og-title.d.ts
 export declare const seoOgTitle: Rule;
-//#endregion
-//#region src/rules/seo/json-ld.d.ts
 export declare const seoJsonLd: Rule;
-//#endregion
-//#region src/rules/seo/robots-txt.d.ts
 export declare const seoRobotsTxt: Rule;
-//#endregion
-//#region src/rules/seo/sitemap-xml.d.ts
 export declare const seoSitemapXml: Rule;
-//#endregion
-//#region src/rules/seo/html-lang.d.ts
 export declare const seoHtmlLang: Rule;
-//#endregion
-//#region src/rules/perf/image-dimensions.d.ts
 export declare const performanceImageDimensions: Rule;
-//#endregion
-//#region src/rules/perf/image-loading-hint.d.ts
 export declare const performanceImageLoadingHint: Rule;
-//#endregion
-//#region src/rules/perf/responsive-image.d.ts
 export declare const performanceResponsiveImage: Rule;
-//#endregion
-//#region src/rules/perf/preload-missing-as.d.ts
 export declare const performancePreloadMissingAs: Rule;
-//#endregion
-//#region src/rules/perf/font-preload-crossorigin.d.ts
 export declare const performanceFontPreloadCrossorigin: Rule;
-//#endregion
-//#region src/rules/perf/lcp-image.d.ts
 /**
  * performance/lcp-image — LCP image not lazy-loaded. Lazy-loading the largest contentful paint
  * image delays it. Analysis approximates the LCP as the first <img> in document
@@ -361,8 +782,6 @@ export declare const performanceFontPreloadCrossorigin: Rule;
  * static (CLI) and rendered (vite) mode, since both providers collect <img>.
  */
 export declare const performanceLcpImage: Rule;
-//#endregion
-//#region src/rules/perf/render-blocking-script.d.ts
 /**
  * performance/render-blocking-script — Render-blocking <script> in <head>. A <script src> without
  * defer/async/type=module blocks the parser. SvelteKit's own scripts are
@@ -371,8 +790,6 @@ export declare const performanceLcpImage: Rule;
  * emits nothing (no signal), like the image rules.
  */
 export declare const performanceRenderBlockingScript: Rule;
-//#endregion
-//#region src/rules/perf/preconnect.d.ts
 /**
  * performance/preconnect — Preconnect for third-party origins. A resource from a well-known
  * third-party origin (e.g. Google Fonts) without a preconnect/dns-prefetch pays a
@@ -380,58 +797,26 @@ export declare const performanceRenderBlockingScript: Rule;
  * allowlist are checked; routes referencing none emit nothing.
  */
 export declare const performancePreconnect: Rule;
-//#endregion
-//#region src/rules/seo/indexability.d.ts
 export declare const seoIndexability: Rule;
-//#endregion
-//#region src/rules/seo/twitter-card.d.ts
 export declare const seoTwitterCard: Rule;
-//#endregion
-//#region src/rules/seo/og-description.d.ts
 export declare const seoOgDescription: Rule;
-//#endregion
-//#region src/rules/seo/og-url.d.ts
 export declare const seoOgUrl: Rule;
-//#endregion
-//#region src/rules/seo/viewport.d.ts
 export declare const seoViewport: Rule;
-//#endregion
-//#region src/rules/seo/sitemap-in-robots.d.ts
 export declare const seoSitemapInRobots: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-validity.d.ts
 export declare const seoJsonLdValidity: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-deprecated-type.d.ts
 export declare const seoJsonLdDeprecatedType: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-relative-url.d.ts
 export declare const seoJsonLdRelativeUrl: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-date-format.d.ts
 export declare const seoJsonLdDateFormat: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-placeholder.d.ts
 export declare const seoJsonLdPlaceholder: Rule;
-//#endregion
-//#region src/rules/seo/json-ld-required-props.d.ts
 export declare const seoJsonLdRequiredProps: Rule;
-//#endregion
-//#region src/rules/seo/title-length.d.ts
 export declare const seoTitleLength: Rule;
-//#endregion
-//#region src/rules/seo/description-length.d.ts
 export declare const seoDescriptionLength: Rule;
-//#endregion
-//#region src/rules/seo/charset.d.ts
 /**
  * seo/charset — Character encoding. The charset meta lives in `src/app.html`, so it is
  * only visible to rendered analysis (`appliesTo: rendered`), exactly like seo/viewport
  * (viewport). Static route analysis emits nothing instead of false-flagging it.
  */
 export declare const seoCharset: Rule;
-//#endregion
-//#region src/rules/seo/image-alt.d.ts
 /**
  * seo/image-alt — Image alt text. Reuses the <img> collection from both providers — the
  * static (CLI) source parser and the rendered (vite) HTML parser — like performance/image-dimensions, performance/image-loading-hint.
@@ -439,8 +824,6 @@ export declare const seoCharset: Rule;
  * passes; a spread `{...rest}` may supply alt, so it is not flagged.
  */
 export declare const seoImageAlt: Rule;
-//#endregion
-//#region src/rules/seo/hreflang.d.ts
 /**
  * seo/hreflang — hreflang / x-default validity. Opt-in: a route with no
  * `<link rel="alternate" hreflang>` emits nothing (monolingual sites are never
@@ -448,17 +831,9 @@ export declare const seoImageAlt: Rule;
  * two or more must declare an x-default. Works in both modes.
  */
 export declare const seoHreflang: Rule;
-//#endregion
-//#region src/rules/seo/single-h1.d.ts
 export declare const seoSingleH1: Rule;
-//#endregion
-//#region src/rules/seo/duplicate-title.d.ts
 export declare const seoDuplicateTitle: Rule;
-//#endregion
-//#region src/rules/seo/duplicate-description.d.ts
 export declare const seoDuplicateDescription: Rule;
-//#endregion
-//#region src/rules/seo/heading-level-skip.d.ts
 /**
  * seo/heading-level-skip — Skipped heading level. Walking a route's body headings in
  * document order, a level that jumps more than +1 over the previous heading (e.g.
@@ -466,26 +841,12 @@ export declare const seoDuplicateDescription: Rule;
  * <h1> stays seo/single-h1's concern). A route with no headings emits nothing.
  */
 export declare const seoHeadingLevelSkip: Rule;
-//#endregion
-//#region src/rules/seo/ssr-disabled.d.ts
 export declare const seoSsrDisabled: Rule;
-//#endregion
-//#region src/rules/correctness/each-key.d.ts
 export declare const correctnessEachKey: Rule;
-//#endregion
-//#region src/rules/correctness/each-index-key.d.ts
 export declare const correctnessEachIndexKey: Rule;
-//#endregion
-//#region src/rules/correctness/effect-as-derived.d.ts
 export declare const correctnessEffectAsDerived: Rule;
-//#endregion
-//#region src/rules/correctness/effect-as-onmount.d.ts
 export declare const correctnessEffectAsOnMount: Rule;
-//#endregion
-//#region src/rules/correctness/unmutated-state.d.ts
 export declare const correctnessUnmutatedState: Rule;
-//#endregion
-//#region src/rules/correctness/prop-mutation.d.ts
 /**
  * correctness/prop-mutation — mutating a prop directly is a silent bug in both Svelte modes,
  * for different reasons: in runes mode, a non-$bindable prop mutation doesn't propagate to the
@@ -495,8 +856,6 @@ export declare const correctnessUnmutatedState: Rule;
  * exactly one or the other — see `legacy` on `ComponentFacts.mutatedProps` (component-parse.ts).
  */
 export declare const correctnessPropMutation: Rule;
-//#endregion
-//#region src/rules/correctness/stale-prop-derivation.d.ts
 /**
  * correctness/stale-prop-derivation — a value computed from a prop without $derived (runes
  * mode) or $: (legacy mode) is evaluated once, at init, and silently stops tracking the
@@ -505,8 +864,6 @@ export declare const correctnessPropMutation: Rule;
  * `legacy` on `ComponentFacts.stalePropDerivations` (component-parse.ts).
  */
 export declare const correctnessStalePropDerivation: Rule;
-//#endregion
-//#region src/rules/correctness/nonreactive-builtin-state.d.ts
 /**
  * correctness/nonreactive-builtin-state — $state's deep proxy covers plain
  * objects and arrays only. A plain Map/Set/Date/URL/URLSearchParams in $state
@@ -515,8 +872,6 @@ export declare const correctnessStalePropDerivation: Rule;
  * drop-in reactive equivalents for exactly this.
  */
 export declare const correctnessNonreactiveBuiltinState: Rule;
-//#endregion
-//#region src/rules/correctness/checkable-bind-value.d.ts
 /**
  * correctness/checkable-bind-value — bind:value binds the DOM value property. A
  * checkbox/radio's user interaction toggles checkedness, which bind:value never observes. A
@@ -526,8 +881,6 @@ export declare const correctnessNonreactiveBuiltinState: Rule;
  * bindings.
  */
 export declare const correctnessCheckableBindValue: Rule;
-//#endregion
-//#region src/rules/correctness/autoplay-muted.d.ts
 /**
  * correctness/autoplay-muted — Chrome and Safari block autoplay with audio, and a blocked
  * `<video autoplay>` does not error: it silently never starts. The author sees it work in dev
@@ -537,11 +890,7 @@ export declare const correctnessCheckableBindValue: Rule;
  * and only a literal `autoplay` counts.
  */
 export declare const correctnessAutoplayMuted: Rule;
-//#endregion
-//#region src/rules/correctness/orphan-effect.d.ts
 export declare const correctnessOrphanEffect: Rule;
-//#endregion
-//#region src/rules/correctness/orphan-lifecycle.d.ts
 /**
  * correctness/orphan-lifecycle — svelte lifecycle/context calls guaranteed to run outside component
  * initialisation: module scope in runes modules / `<script module>`, the constructor of
@@ -549,8 +898,6 @@ export declare const correctnessOrphanEffect: Rule;
  * because the facts live on BOTH the component channel and the Kit-module channel.
  */
 export declare const correctnessOrphanLifecycle: Rule;
-//#endregion
-//#region src/rules/correctness/base-path-navigation.d.ts
 /**
  * correctness/base-path-navigation — root-relative navigation literals in a project that sets
  * `kit.paths.base`. A custom check because it is gated on a PROJECT fact and its own facts live
@@ -558,8 +905,6 @@ export declare const correctnessOrphanLifecycle: Rule;
  * With no base path configured the rule emits nothing at all — the gate is the whole point.
  */
 export declare const correctnessBasePathNavigation: Rule;
-//#endregion
-//#region src/rules/correctness/server-browser-global.d.ts
 /**
  * correctness/server-browser-global — browser globals read in server-executed MODULE code: module scope of
  * runes modules / `<script module>`, and Kit route/hooks files (top level, handler
@@ -568,32 +913,14 @@ export declare const correctnessBasePathNavigation: Rule;
  * (warning) territory. A custom check because the facts live on both channels.
  */
 export declare const correctnessServerBrowserGlobal: Rule;
-//#endregion
-//#region src/rules/correctness/instance-browser-global.d.ts
 export declare const correctnessInstanceBrowserGlobal: Rule;
-//#endregion
-//#region src/rules/security/raw-html.d.ts
 export declare const securityRawHtml: Rule;
-//#endregion
-//#region src/rules/security/javascript-url.d.ts
 export declare const securityJavascriptUrl: Rule;
-//#endregion
-//#region src/rules/security/handler-state-write.d.ts
 export declare const securityHandlerStateWrite: Rule;
-//#endregion
-//#region src/rules/security/server-module-state.d.ts
 export declare const securityServerModuleState: Rule;
-//#endregion
-//#region src/rules/security/shared-state-import.d.ts
 export declare const securitySharedStateImport: Rule;
-//#endregion
-//#region src/rules/architecture/component-size.d.ts
 export declare const architectureComponentSize: Rule;
-//#endregion
-//#region src/rules/architecture/prop-count.d.ts
 export declare const architecturePropCount: Rule;
-//#endregion
-//#region src/rules/architecture/private-scope-import.d.ts
 /**
  * architecture/private-scope-import — a unit inside a declared private scope must not be
  * imported from outside that scope (design 2026-07-28). L3: the scopes are declared by the
@@ -603,8 +930,6 @@ export declare const architecturePropCount: Rule;
  * results to the files that changed, and the author of the violation edited the importer.
  */
 export declare const architecturePrivateScopeImport: Rule;
-//#endregion
-//#region src/rules/architecture/unit-entry-file.d.ts
 /**
  * architecture/unit-entry-file — a directory declared to be a unit must contain a file named
  * after it (design 2026-07-28). L3: the declarations come from the project's own `units`,
@@ -615,8 +940,6 @@ export declare const architecturePrivateScopeImport: Rule;
  * the directory, because `filterToChangedFiles` keeps only locations git lists as changed.
  */
 export declare const architectureUnitEntryFile: Rule;
-//#endregion
-//#region src/rules/architecture/directory-naming.d.ts
 /**
  * architecture/directory-naming — a directory must be named in the casing its location declares
  * (design 2026-07-29). L3: the declarations come from the project's own `directories` and `exclude`
@@ -632,8 +955,6 @@ export declare const architectureUnitEntryFile: Rule;
  * hundreds of 100s from one `'src/routes/**'` declaration and dilute every real finding.
  */
 export declare const architectureDirectoryNaming: Rule;
-//#endregion
-//#region src/rules/architecture/reserved-directory-names.d.ts
 /**
  * architecture/reserved-directory-names — a directory's immediate subdirectories may only take names
  * the project declared for that position (design 2026-07-29, extended 2026-08-08 for lowercase units —
@@ -655,8 +976,6 @@ export declare const architectureDirectoryNaming: Rule;
  * hundreds of 100s from one broad declaration and dilute every real finding.
  */
 export declare const architectureReservedDirectoryNames: Rule;
-//#endregion
-//#region src/rules/architecture/reserved-name-placement.d.ts
 /**
  * architecture/reserved-name-placement — a reserved directory name may appear only in the places
  * declared for it (design 2026-08-06). L3: inert until a placement is declared.
@@ -674,20 +993,10 @@ export declare const architectureReservedDirectoryNames: Rule;
  * `route` at 100 and averages, and a directory has no pre-existing score key.
  */
 export declare const architectureReservedNamePlacement: Rule;
-//#endregion
-//#region src/rules/architecture/route-component-import.d.ts
 export declare const architectureRouteComponentImport: Rule;
-//#endregion
-//#region src/rules/architecture/doc-link-target.d.ts
 export declare const architectureDocLinkTarget: Rule;
-//#endregion
-//#region src/rules/perf/heavy-import.d.ts
 export declare const performanceHeavyImport: Rule;
-//#endregion
-//#region src/rules/perf/namespace-import.d.ts
 export declare const performanceNamespaceImport: Rule;
-//#endregion
-//#region src/rules/perf/minify-disabled.d.ts
 /**
  * performance/minify-disabled — a `build.minify: false` left in vite.config ships unminified JS/CSS
  * to production. Project-scope: the fact is produced by the CLI's static parse
@@ -695,25 +1004,19 @@ export declare const performanceNamespaceImport: Rule;
  * (exact). Emits a finding only when the fact is set — no pass result.
  */
 export declare const performanceMinifyDisabled: Rule;
-//#endregion
-//#region src/rules/perf/load-waterfall.d.ts
 /**
  * performance/load-waterfall — dependent await chains in universal loads. Server loads are exempt:
  * a dependent chain cannot be parallelized, and on the server there is no better
- * placement to suggest. csr = false files are exempt too — without a client
- * runtime the universal load only runs during SSR.
+ * placement to suggest. Loads on a route with `csr = false` (its own or a layout's) are exempt
+ * too — without a client runtime the universal load only runs during SSR.
  */
 export declare const performanceLoadWaterfall: Rule;
-//#endregion
-//#region src/rules/perf/sequential-awaits.d.ts
 /**
  * performance/sequential-awaits — independent sequential awaits in any load. Info severity: static
  * data flow cannot see side-effect ordering (e.g. a setup call an API relies
  * on), so the parallelize suggestion stays advisory.
  */
 export declare const performanceSequentialAwaits: Rule;
-//#endregion
-//#region src/rules/perf/state-raw.d.ts
 /**
  * performance/state-raw — deep $state proxies every property access; a binding
  * that is only ever reassigned never uses that machinery. Svelte's guidance:
@@ -722,46 +1025,20 @@ export declare const performanceSequentialAwaits: Rule;
  * the proxy condition.
  */
 export declare const performanceStateRaw: Rule;
-//#endregion
-//#region src/rules/perf/iframe-loading.d.ts
 /** Any literal `loading` value passes (the author made a choice); an expression value is
  *  unknowable and passes; a spread could supply `loading` and passes. */
 export declare const performanceIframeLoading: Rule;
-//#endregion
-//#region src/rules/a11y/invalid-role.d.ts
 export declare const a11yInvalidRole: Rule;
-//#endregion
-//#region src/rules/a11y/unknown-aria-attribute.d.ts
 export declare const a11yUnknownAriaAttribute: Rule;
-//#endregion
-//#region src/rules/a11y/required-aria-props.d.ts
 export declare const a11yRequiredAriaProps: Rule;
-//#endregion
-//#region src/rules/a11y/invalid-aria-value.d.ts
 export declare const a11yInvalidAriaValue: Rule;
-//#endregion
-//#region src/rules/a11y/interactive-nesting.d.ts
 export declare const a11yInteractiveNesting: Rule;
-//#endregion
-//#region src/rules/a11y/aria-hidden-focus.d.ts
 export declare const a11yAriaHiddenFocus: Rule;
-//#endregion
-//#region src/rules/a11y/accessible-name.d.ts
 export declare const a11yAccessibleName: Rule;
-//#endregion
-//#region src/rules/a11y/label-has-control.d.ts
 export declare const a11yLabelHasControl: Rule;
-//#endregion
-//#region src/rules/a11y/use-list.d.ts
 export declare const a11yUseList: Rule;
-//#endregion
-//#region src/rules/a11y/placeholder-label-option.d.ts
 export declare const a11yPlaceholderLabelOption: Rule;
-//#endregion
-//#region src/rules/a11y/require-datetime.d.ts
 export declare const a11yRequireDatetime: Rule;
-//#endregion
-//#region src/rules/a11y/positive-tabindex.d.ts
 /**
  * Literal values only — an expression-valued `tabindex` is unknowable and passes. The
  * Number()-based parse deliberately follows the Svelte compiler's a11y_positive_tabindex
@@ -772,8 +1049,6 @@ export declare const a11yRequireDatetime: Rule;
  * semantics.
  */
 export 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
@@ -782,8 +1057,6 @@ export declare const a11yPositiveTabindex: Rule;
  * presence wrong in both namespaces.
  */
 export 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
@@ -795,37 +1068,19 @@ export declare const a11yNoAccesskey: Rule;
  * page-load focus semantics.
  */
 export 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.
  */
 export declare const a11yNoDuplicateDt: Rule;
-//#endregion
-//#region src/rules/a11y/abbr-title.d.ts
 export declare const a11yAbbrTitle: Rule;
-//#endregion
-//#region src/rules/a11y/pattern-title.d.ts
 export declare const a11yPatternTitle: Rule;
-//#endregion
-//#region src/rules/a11y/deprecated-element.d.ts
 export declare const a11yDeprecatedElement: Rule;
-//#endregion
-//#region src/rules/a11y/deprecated-attr.d.ts
 export declare const a11yDeprecatedAttr: Rule;
-//#endregion
-//#region src/rules/a11y/disallowed-aria-props.d.ts
 export declare const a11yDisallowedAriaProps: Rule;
-//#endregion
-//#region src/rules/a11y/deprecated-aria.d.ts
 export declare const a11yDeprecatedAria: Rule;
-//#endregion
-//#region src/rules/a11y/disallowed-element.d.ts
 export declare const a11yDisallowedElement: Rule;
-//#endregion
-//#region src/rules/a11y/permitted-contents.d.ts
 /**
  * Content-model membership over the literal element tree
  * (design 2026-08-20-permitted-contents-rule-design.md; measured
@@ -833,8 +1088,6 @@ export declare const a11yDisallowedElement: Rule;
  * structure-bound children) is `warning`; category mismatches are `info`.
  */
 export declare const a11yPermittedContents: Rule;
-//#endregion
-//#region src/rules/a11y/required-element.d.ts
 /**
  * a11y/required-element — every route must contain the elements the project declares (design
  * 2026-08-19-config-driven-element-rules). Judged on the composed route: the layout chain, the page,
@@ -847,11 +1100,7 @@ export declare const a11yPermittedContents: Rule;
  * declared tag with the world open emits nothing.
  */
 export declare const a11yRequiredElement: Rule;
-//#endregion
-//#region src/rules/a11y/doctype.d.ts
 export declare const a11yDoctype: Rule;
-//#endregion
-//#region src/rules/a11y/duplicate-landmark.d.ts
 /**
  * a11y/duplicate-landmark — a composed route (layout chain + page) yields more than one
  * `main` / `banner` / `contentinfo` landmark. `ctx.a11y[].landmarks` already holds the
@@ -859,23 +1108,17 @@ export declare const a11yDoctype: Rule;
  * fixed KINDS order (it decides emission order and the PASS anchor).
  */
 export declare const a11yDuplicateLandmark: Rule;
-//#endregion
-//#region src/rules/a11y/top-level-landmark.d.ts
 /**
  * a11y/top-level-landmark — a landmark (`main`/`banner`/`complementary`/`contentinfo`) that
  * composition places inside another landmark. `ctx.a11y[].nestedLandmarks` already carries one
  * entry per nested occurrence, so this rule only reports them.
  */
 export declare const a11yTopLevelLandmark: Rule;
-//#endregion
-//#region src/rules/a11y/id-duplication.d.ts
 /**
  * a11y/id-duplication — a literal id repeated within a composed route. `ctx.a11y[].ids`
  * already holds the branch-aware-folded representatives per id, so this rule only counts them.
  */
 export declare const a11yIdDuplication: Rule;
-//#endregion
-//#region src/rules/a11y/no-missing-id-ref.d.ts
 /**
  * a11y/no-missing-id-ref — an id-reference attribute (`IDREF_ATTRS`: HTML's `for`/`list`/`headers`/
  * `form`/the popover and command targets, and every ARIA id-reference property) or a same-page
@@ -883,11 +1126,7 @@ export declare const a11yIdDuplication: Rule;
  * runs only on routes `ctx.a11y[].fullyResolved` marks fully resolved — see the rule docs.
  */
 export declare const a11yNoMissingIdRef: Rule;
-//#endregion
-//#region src/rules/a11y/unverified-id-ref.d.ts
 export declare const a11yUnverifiedIdRef: Rule;
-//#endregion
-//#region src/rules/index.d.ts
 export declare const allRules: Rule[];
 /** One configurable option of a rule, flattened for `svelte-vitals explain`'s output. */
 export interface RuleOptionInfo {
@@ -917,8 +1156,6 @@ export interface RuleInfo {
 }
 /** Look up a rule's static metadata, as `svelte-vitals explain` renders it (issue #24). Rule ids are matched exactly (case-sensitive, e.g. "seo/ssr-disabled"). */
 export declare function explainRule(id: string): RuleInfo | undefined;
-//#endregion
-//#region src/reporter/palette.d.ts
 /** String decorators for the console reporter. Injected so core stays pure/dep-free. */
 interface Palette {
   bold: (s: string) => string;
@@ -932,8 +1169,6 @@ interface Palette {
 export declare const noColorPalette: Palette;
 /** Green ≥ 90, yellow ≥ 70, red otherwise — for a 0–100 score. */
 export declare function scoreColor(p: Palette, score: number): (s: string) => string;
-//#endregion
-//#region src/reporter/console.d.ts
 interface ConsoleReportOptions {
   byRoute?: boolean;
   /** Mode label shown in the header (default 'static mode'). */
@@ -951,8 +1186,6 @@ interface ConsoleReportOptions {
  * set, adds a per-route score tree.
  */
 export declare function formatConsoleReport(results: Result[], config: Config, options?: ConsoleReportOptions): string;
-//#endregion
-//#region src/reporter/sanitize.d.ts
 /**
  * Strip ANSI/OSC escape sequences and C0/C1 control characters (except `\n`/`\t`) from a
  * string before it reaches a terminal. POSIX file/route names can contain almost any
@@ -972,18 +1205,12 @@ export declare function formatConsoleReport(results: Result[], config: Config, o
  * concrete non-CSI/OSC sequence turns out to matter.
  */
 export declare function terminalSafe(text: string): string;
-//#endregion
-//#region src/reporter/agent.d.ts
 /** Render failing findings as an agent-actionable Markdown remediation document (issue #18). */
 export declare function formatAgentReport(results: Result[], config: Config): string;
-//#endregion
-//#region src/reporter/sarif.d.ts
 /** Render penalized findings as a SARIF 2.1.0 log string (issue #18, design slice 5). */
 export declare function formatSarifReport(results: Result[], config: Config, meta: {
   version: string;
 }): string;
-//#endregion
-//#region src/reporter/app-shell.d.ts
 export declare function escapeHtml(s: string): string;
 /**
  * Return the URL only when it uses a safe http/https scheme, else null.
@@ -1036,5 +1263,4 @@ export declare function formatHtmlReport(results: Result[], config: Config, meta
   version: string;
   coreVersion?: string;
 }): string;
-//#endregion
-export { type A11yOccurrenceInfo, type A11ySkipCause, ANCESTRY_DEPENDENT_TAGS, ASIDE_DEMOTING_TAGS, type AppSnapshot, type BranchStep, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, type LandmarkInput, NAMING_ATTRS, type OrphanEffectFact, type Palette, type Project, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SEARCH_RESULT_RULES, SECTIONING_TAGS, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, type WorkspacePackage, buildJsonReport, classify, collectComponentFacts, compileOverrides, computeHealth, computeScore, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, foldOccurrences, formatFailedRuleWarning, formatGithubReport, formatJsonReport, formatMarkdownReport, hasFailureAtOrAbove, isClassicScriptType, isPenalized, isPlainObject, isSvgSrc, isTopFragment, resolveLandmark, resolveRuleOptions, routeNeverSsr, selectRules, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, validateRuleSetting, withFailedRulesOff, withIndexableOff, withReadLimit };
+export { type A11yOccurrenceInfo, type A11ySkipCause, ANCESTRY_DEPENDENT_TAGS, ASIDE_DEMOTING_TAGS, type AppSnapshot, type BranchStep, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, type LandmarkInput, NAMING_ATTRS, type OrphanEffectFact, type Palette, type Project, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SEARCH_RESULT_RULES, SECTIONING_TAGS, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, type WorkspacePackage, buildJsonReport, classify, collectComponentFacts, compileOverrides, computeHealth, computeScore, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, foldOccurrences, formatFailedRuleWarning, formatGithubReport, formatJsonReport, formatJsonReportChunks, formatMarkdownReport, hasFailureAtOrAbove, hasRel, isClassicScriptType, isPenalized, isPlainObject, isSvgSrc, isTopFragment, layoutNeverRenders, pageRendersOnlyWhenBuilding, resolveLandmark, resolveRuleOptions, routeNeverSsr, selectRules, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, validateRuleSetting, withFailedRulesOff, withIndexableOff, withReadLimit };