@svelte-vitals/core 0.55.1 → 0.55.3

package/dist/internal.d.ts

@@ -1,6 +1,16 @@
-import { $ as formatMarkdownReport, A as A11yOccurrenceInfo, At as OrphanEffectFact, B as decodeFragmentId, C as compileOverrides, Ct as Value, D as withFailedRulesOff, Dt as ComponentFacts, E as settingSeverity, F as IDREF_ATTRS, Ft as skippedFileWarnings, G as stripTextDirective, H as isTopFragment, I as LandmarkInput, It as Runtime, J as ImageInfo, K as HeadingInfo, L as NAMING_ATTRS, Lt as withReadLimit, M as ANCESTRY_DEPENDENT_TAGS, Mt as SuppressionDirective, N as ASIDE_DEMOTING_TAGS, Nt as collectComponentFacts, O as withIndexableOff, Ot as EachBlockFact, P as BranchStep, Pt as emptyComponentFacts, Q as isClassicScriptType, R as ResolvedA11y, S as SEARCH_RESULT_RULES, T as selectRules, Tt as defaultProject, U as resolveLandmark, V as foldOccurrences, W as splitTokens, X as HeadTag, Y as ResolvedImages, Z as ResolvedHead, _ as isPlainObject, a as HealthResult, at as hasFailureAtOrAbove, b as validateRuleSetting, bt as Scope, c as ScoreResult, ct as Category, d as Rule, dt as Fix, et as formatGithubReport, f as RuleContext, ft as KitAlias, g as RuleOptionsSpec, h as RuleOptionSpec, ht as Result, i as formatJsonReport, it as effectiveSeverity, j as A11ySkipCause, jt as SourceSpan, k as KitModuleFacts, kt as EffectFact, l as computeHealth, lt as Config, m as isPenalized, mt as Project, ot as summarize, p as docsUrlFor, q as ResolvedHeadings, r as buildJsonReport, rt as classify, s as ScoreOptions, t as JsonReport, tt as Classification, u as computeScore, v as resolveRuleOptions, w as formatFailedRuleWarning, wt as defaultConfig, x as CompiledOverride, xt as Severity, y as shouldSkipRangeCheck, z as SECTIONING_TAGS } from "./json-TIGneC1p.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-DmLgFEwV.js";
 import { AST } from "svelte/compiler";
 //#region src/component-parse.d.ts
+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$2): Set<string>;
 /** What the per-file parsers produce — `ComponentFacts` minus `file`, with `suppressions` always present. */
 type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
   suppressions: SuppressionDirective[];
@@ -12,7 +22,472 @@ type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
  */
 export declare function parseComponentFacts(source: string, filename: string): ParsedFacts;
 //#endregion
+//#region ../../node_modules/.pnpm/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts
+// 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;
+}
+//#endregion
 //#region src/module-ast.d.ts
+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
@@ -20,6 +495,20 @@ export declare function parseComponentFacts(source: string, filename: string): P
  * Shared with the Kit-module parser (the security kit-module rules).
  */
 export declare function collectSuppressions(source: string): SuppressionDirective[];
+/**
+ * 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).
+ */
+type ParsedModule = {
+  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. */
@@ -61,6 +550,9 @@ export declare function unknownDirectiveIds(index: DirectiveIndex, rules: readon
 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
@@ -68,8 +560,12 @@ export declare function collectSourceFiles(rt: Runtime, cwd: string): Promise<st
  * be a project-local module: the caller's `aliases` list decides which non-relative
  * specifiers resolve, defaulting to `$lib` → `src/lib`; `./`/`../` resolve against the
  * importing file's directory; bare packages and other aliases are skipped (they can't
- * be resolved to a project-local path at all). Also undefined when a relative
- * specifier's `..` segments escape the project root (see `normalizePosix`), or when a
+ * be resolved to a project-local path at all). A path above the project root (a leading `../`
+ * run) resolves only inside a directory a `kit.alias` value itself names above the root
+ * (`$plugins: '../../plugins'` in a monorepo app): the user's config says the app builds from
+ * there, so it is read like `src/` — likewise inside a workspace package's directory an entry
+ * names as its `root` — and anywhere else above the root is undefined, as nothing says the app
+ * reaches it. Also undefined when a
  * matched alias's value is itself absolute (e.g. `/opt/shared/src`, or a posixified Windows
  * drive-letter path like `C:/shared/src`): an absolute target is outside the analyzed project by
  * definition, and without this check `normalizePosix` would quietly drop the leading empty
@@ -78,7 +574,7 @@ export declare function collectSourceFiles(rt: Runtime, cwd: string): Promise<st
  * Exported from the package's public barrel because `architecture/private-scope-import`
  * and `architecture/route-component-import` (inside `packages/core`) both need resolution
  * that is not restricted to runes modules, unlike `resolveRunesModuleSpecifier` — and
- * because `resolveComponentPath` (`packages/cli/src/providers/source/resolve.ts`), which
+ * because component resolution (`packages/cli/src/providers/source/resolve.ts`), which
  * drives transitive `<head>`/heading resolution, delegates its alias/`$lib`/relative
  * mapping here too, rather than duplicating it. This is the single site for every
  * repo-local specifier resolution in the repo.
@@ -122,6 +618,16 @@ export declare function resolveKitAliases(viteConfig: {
 } | undefined, svelteConfig: {
   source: string;
 } | undefined): KitAlias[] | undefined;
+/**
+ * `aliases` followed by the project's package.json `imports` entries (`"#lib/*": "./src/lib/*"`),
+ * after Kit's own: Vite's alias plugin resolves before Node-style subpath imports. The entries are
+ * ordered by Node's precedence — exact keys, then patterns by longest prefix — because the alias
+ * resolver takes the first match. Only a project-relative target counts; anything else is skipped,
+ * 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
@@ -138,6 +644,44 @@ export declare function resolveKitPathsBase(viteConfig: {
   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;
+  dir: string;
+  /** The package's `package.json` source. */
+  manifest: string;
+}
+/**
+ * The app's dependencies that link a package of the same repository, name → range: a `workspace:`
+ * version range, or a `link:`/`file:` path. A `workspace:` range that renames (`workspace:other@*`)
+ * or names a path is left out, since the specifier would not be the package's own name.
+ */
+export declare function declaredLocalPackages(packageJsonSource: string | undefined): Map<string, string>;
+/** The `packages:` globs of a `pnpm-workspace.yaml`, in block (`- 'apps/*'`) or flow (`[a, b]`) form. */
+export declare function pnpmWorkspaceGlobs(yaml: string): string[];
+/** A root `package.json`'s `workspaces` globs (an array, or `{ packages }`); undefined when it declares none. */
+export declare function packageJsonWorkspaceGlobs(source: string | undefined): string[] | undefined;
+/**
+ * `aliases` widened with the app's workspace packages, the way the bundler sees them: an alias
+ * whose value points into `node_modules/<package>` names the package's own directory (the link a
+ * workspace install creates, readable whether or not it was installed), and every package's
+ * `exports` follows the aliases, as Vite resolves a bare specifier only after its alias plugin.
+ */
+export declare function withWorkspacePackages(aliases: KitAlias[] | undefined, packages: readonly WorkspacePackage[]): KitAlias[] | undefined;
+/**
+ * The app's dependencies that an install puts in `node_modules`: every declared name whose range is
+ * not a local protocol (`workspace:`, `link:`, `file:`, `portal:`). Those are the workspace
+ * resolver's, whose bounds must not be sidestepped through their `node_modules` link.
+ */
+export declare function declaredInstalledPackages(packageJsonSource: string | undefined): string[];
+/**
+ * `aliases` widened with the Svelte packages installed in `node_modules` (`dir` is the textual
+ * `node_modules/<name>` path, relative to the app), compiled like workspace packages. Packages that
+ * 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.
@@ -151,7 +695,7 @@ export declare function resolveKitPathsBase(viteConfig: {
  * 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;
 /**
@@ -193,6 +737,13 @@ export declare function attrTextOf(attr: AST.Attribute): string | undefined;
 export declare const ROBOTS_SOURCE_PATHS: readonly ["static/robots.txt", "src/routes/robots.txt/+server.ts", "src/routes/robots.txt/+server.js"];
 /** 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, 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). */
@@ -375,19 +926,6 @@ export declare const seoImageAlt: Rule;
 export declare const seoHreflang: Rule;
 //#endregion
 //#region src/rules/seo/single-h1.d.ts
-/**
- * seo/single-h1 — Heading hierarchy (single H1). Reads the per-route page-body headings
- * channel (collected by both providers), counting `headings` plus `componentHeadings`
- * (static mode only — headings found transitively in rendered child components) as one
- * combined list. Zero <h1> (no primary heading) is a `warning`: defensible, a page needs
- * a primary heading. Two or more is only `info`: a single <h1> is the conventional
- * signal, but no official source documents a ranking penalty for several (2026-08-09 v1
- * rule-validity review, P2 #11) — so it's flagged as a style nit, not a defect. Exactly
- * one passes. A route whose headings were not collected (channel unset) emits nothing, as does
- * one whose `dynamicHeading` flag says an undeterminable `<svelte:element>` may be its <h1>. A
- * global `rules: { 'seo/single-h1': <severity> }` override flattens both arms to one
- * severity (design, `applyRuleSeverities`).
- */
 export declare const seoSingleH1: Rule;
 //#endregion
 //#region src/rules/seo/duplicate-title.d.ts
@@ -638,8 +1176,8 @@ export declare const performanceMinifyDisabled: Rule;
 /**
  * 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
@@ -975,4 +1513,4 @@ export declare function formatHtmlReport(results: Result[], config: Config, meta
   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, buildJsonReport, classify, collectComponentFacts, compileOverrides, computeHealth, computeScore, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, foldOccurrences, formatFailedRuleWarning, formatGithubReport, formatJsonReport, formatMarkdownReport, hasFailureAtOrAbove, isClassicScriptType, isPenalized, isPlainObject, isTopFragment, resolveLandmark, resolveRuleOptions, 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 };