@svelte-vitals/core 0.55.0 → 0.55.2

package/dist/{json-DcTYXhKc.d.ts → json-BQf9Qb2D.d.ts}

@@ -46,6 +46,15 @@ interface EachBlockFact {
   line: number;
   /** Set when the block's key expression is its index binding or a trivial coercion of it — `(i)`, `(String(i))`, `(Number(i))`, `` (`${i}`) ``, `(i.toString())`, `(i + '')` — correctness/each-index-key. */
   indexKey?: boolean;
+  /**
+   * The import the block iterates, set on an unkeyed or index-keyed block over an imported binding
+   * (`xs`, or `ns.xs` of `import * as ns`) the component only reads. Core cannot see the module
+   * behind it; a collector that can drops the block when that export is a constant list.
+   */
+  importedList?: {
+    source: string;
+    imported: string;
+  };
 }
 /** An `$effect(...)` / `$effect.pre(...)` call in a component's instance script. */
 interface EffectFact {
@@ -172,6 +181,8 @@ interface AriaElementFact {
   /** Set when the element also carries a spread attribute — its full attribute set is
    *  unknowable, so required-prop presence checks must treat it as satisfied (a11y/required-aria-props). */
   hasSpread?: true;
+  /** Set when the element carries a `use:` action, which may set `role` at runtime (svelte-dnd-action's handles do). */
+  hasAction?: true;
 }
 /**
  * Every element in a component with its literal attribute names — the input for the rules that
@@ -238,12 +249,15 @@ interface ComponentFacts {
    * architecture/route-component-import). `type` marks a declaration that contributes **no runtime
    * value binding** — either `import type …`, or one whose every specifier is inline-typed
    * (`import { type A } from …`). A specifier-less side-effect import is not marked: it still loads
-   * the module. Optional, so existing external constructors of `ComponentFacts` are unaffected.
+   * the module. `named` marks a value declaration binding only named exports — no default,
+   * `default as`, or namespace — so it cannot render an imported component. Both optional, so
+   * existing external constructors of `ComponentFacts` are unaffected.
    */
   importSpans: {
     source: string;
     line: number;
     type?: true;
+    named?: true;
   }[];
   /** Value `import * as X from '<bare pkg>'` namespace imports (type-only excluded) — performance/namespace-import. */
   namespaceImports: {
@@ -374,6 +388,67 @@ declare function emptyComponentFacts(file: string): ComponentFacts;
  */
 declare function collectComponentFacts(rt: Runtime, cwd: string): Promise<ComponentFacts[]>;
 //#endregion
+//#region src/head.d.ts
+/**
+ * A normalized head tag. The mode-independent boundary (design §8): the static
+ * SourceHeadProvider (CLI, via the runtime-abstracted `HeadProvider` below) and
+ * the rendered collector (`@svelte-vitals/vite`, build-time Node) both emit
+ * these, so rules never need to know which mode produced them.
+ */
+interface HeadTag {
+  kind: 'title' | 'meta' | 'link' | 'jsonld' | 'script';
+  /** <meta name="...">. */
+  name?: string;
+  /** <meta property="..."> (e.g. og:image). */
+  property?: string;
+  /** <link rel="...">. */
+  rel?: string;
+  /** <link as="..."> keyword (e.g. 'font') when statically literal; undefined when absent or dynamically bound. */
+  as?: string;
+  /** True when a <link> has an `as` attribute at all (literal or dynamic). Distinguishes "no as" from "dynamic as". */
+  hasAs?: boolean;
+  /** True when a <link> has a `crossorigin` attribute (presence only; value is irrelevant to the checks). */
+  hasCrossorigin?: boolean;
+  /** True when a <meta name="robots"> literal content contains `noindex`/`none`. Undefined when dynamic or absent. */
+  noindex?: boolean;
+  /** Literal `<script type="application/ld+json">` content, set only when the script is static. Undefined when dynamic. */
+  jsonld?: string;
+  /** Literal visible text of a static <title> or <meta name="description"> content, set only when static. Undefined when dynamic. */
+  text?: string;
+  /** Literal `hreflang` of a `<link rel="alternate">` (e.g. 'en', 'en-US', 'x-default'). Undefined when dynamic/absent. */
+  hreflang?: string;
+  /** Literal href (link) / src (script) URL when static — used for third-party origin analysis (performance/preconnect). */
+  href?: string;
+  /** True for a render-blocking `<script src>` in <head> (no defer/async/module) (performance/render-blocking-script). */
+  blocking?: boolean;
+  /** Rendered only in the browser, by a component loaded with `import()` (static mode): absent from a server-rendered route's HTML. */
+  clientOnly?: true;
+  /** Where this tag was set relative to the route. Never 'none' (absence = no tag). */
+  presence: Exclude<Presence, 'none'>;
+  /** Whether the tag's value is static/dynamic/absent (design §4). */
+  value: Value;
+  /** Source file the tag came from (static mode); unset on a rendered head. */
+  file?: string;
+}
+/** Resolved effective head for a single route (design §8). */
+interface ResolvedHead {
+  /** Route path, e.g. '/blog/[slug]'. */
+  route: string;
+  /** Which provider produced this. */
+  source: 'static' | 'rendered';
+  /** Effective head tags after layout-chain composition. */
+  tags: HeadTag[];
+  /** Representative source file for the route (used for issue locations). */
+  file: string;
+}
+/**
+ * Whether a `type` attribute (undefined = absent) makes a `<script>` a classic,
+ * render-blocking-capable script. Per the HTML spec, absent and the literal empty string are
+ * classic; any other value is ASCII-whitespace-stripped and must match a JavaScript MIME type —
+ * so a whitespace-only `type` is a data block, not a classic script.
+ */
+declare function isClassicScriptType(type: string | undefined): boolean;
+//#endregion
 //#region src/types.d.ts
 type Severity = 'critical' | 'warning' | 'info';
 /** Where a head tag is set, relative to the route being evaluated (design §4). */
@@ -414,6 +489,13 @@ interface KitAlias {
    *   is how Kit stops the plain key from swallowing the nested specifiers.
    */
   match: 'prefix' | 'contents' | 'exact';
+  /** Appended after the matched rest of a `contents` specifier: the text after `*` in an exports pattern target (`./src/*.js`). */
+  suffix?: string;
+  /**
+   * The directory the entry's targets belong to, when it is wider than `replacement`: a workspace
+   * package's directory, so relative imports between its files resolve above the project root.
+   */
+  root?: string;
 }
 /** Project-wide facts precomputed by the runtime layer for project-scope rules (design §10). */
 interface Project {
@@ -454,6 +536,18 @@ interface Project {
    * list is never empty: `$lib` is always prepended.
    */
   kitAliases?: KitAlias[];
+  /**
+   * `kitAliases` plus the workspace packages the app's package.json declares, which component
+   * resolution (a route's composition, and each-key's imported lists) follows. Absent when the app
+   * declares none. Rules that resolve imports read `kitAliases`.
+   */
+  componentAliases?: KitAlias[];
+  /**
+   * `componentAliases` (else `kitAliases`) plus the Svelte packages installed in `node_modules` that
+   * the app declares. Only the `<head>`/heading walk reads it, so the a11y composition and each-key
+   * stay on `componentAliases`. Absent when no such package is installed.
+   */
+  headAliases?: KitAlias[];
   /**
    * Whether `src/app.html` opens with `<!doctype html>` (a11y/doctype). Set from the same read
    * as `htmlLang`; absent when the file wasn't read (missing or unreadable) — the rule stays
@@ -467,6 +561,11 @@ interface Project {
   }[];
   /** Distinct lowercased tag names inside `app.html`'s `<body>` (a11y/required-element's presence set; static mode). */
   appHtmlBodyTags?: string[];
+  /**
+   * The shell's own literal `<title>`, `<meta name|property>` (except charset/viewport) and
+   * `<link rel="canonical">`, rendered on every route beside `%sveltekit.head%` (static mode).
+   */
+  appHtmlHeadTags?: Omit<HeadTag, 'presence' | 'file'>[];
 }
 declare const defaultProject: Project;
 /** A concrete, agent-actionable remediation for a finding (design §10, issue #18). */
@@ -601,65 +700,6 @@ declare function formatMarkdownReport(results: Result[], config: Config, meta: {
   version: string;
 }): string;
 //#endregion
-//#region src/head.d.ts
-/**
- * A normalized head tag. The mode-independent boundary (design §8): the static
- * SourceHeadProvider (CLI, via the runtime-abstracted `HeadProvider` below) and
- * the rendered collector (`@svelte-vitals/vite`, build-time Node) both emit
- * these, so rules never need to know which mode produced them.
- */
-interface HeadTag {
-  kind: 'title' | 'meta' | 'link' | 'jsonld' | 'script';
-  /** <meta name="...">. */
-  name?: string;
-  /** <meta property="..."> (e.g. og:image). */
-  property?: string;
-  /** <link rel="...">. */
-  rel?: string;
-  /** <link as="..."> keyword (e.g. 'font') when statically literal; undefined when absent or dynamically bound. */
-  as?: string;
-  /** True when a <link> has an `as` attribute at all (literal or dynamic). Distinguishes "no as" from "dynamic as". */
-  hasAs?: boolean;
-  /** True when a <link> has a `crossorigin` attribute (presence only; value is irrelevant to the checks). */
-  hasCrossorigin?: boolean;
-  /** True when a <meta name="robots"> literal content contains `noindex`/`none`. Undefined when dynamic or absent. */
-  noindex?: boolean;
-  /** Literal `<script type="application/ld+json">` content, set only when the script is static. Undefined when dynamic. */
-  jsonld?: string;
-  /** Literal visible text of a static <title> or <meta name="description"> content, set only when static. Undefined when dynamic. */
-  text?: string;
-  /** Literal `hreflang` of a `<link rel="alternate">` (e.g. 'en', 'en-US', 'x-default'). Undefined when dynamic/absent. */
-  hreflang?: string;
-  /** Literal href (link) / src (script) URL when static — used for third-party origin analysis (performance/preconnect). */
-  href?: string;
-  /** True for a render-blocking `<script src>` in <head> (no defer/async/module) (performance/render-blocking-script). */
-  blocking?: boolean;
-  /** Where this tag was set relative to the route. Never 'none' (absence = no tag). */
-  presence: Exclude<Presence, 'none'>;
-  /** Whether the tag's value is static/dynamic/absent (design §4). */
-  value: Value;
-  /** Source file the tag came from (static mode); unset on a rendered head. */
-  file?: string;
-}
-/** Resolved effective head for a single route (design §8). */
-interface ResolvedHead {
-  /** Route path, e.g. '/blog/[slug]'. */
-  route: string;
-  /** Which provider produced this. */
-  source: 'static' | 'rendered';
-  /** Effective head tags after layout-chain composition. */
-  tags: HeadTag[];
-  /** Representative source file for the route (used for issue locations). */
-  file: string;
-}
-/**
- * Whether a `type` attribute (undefined = absent) makes a `<script>` a classic,
- * render-blocking-capable script. Per the HTML spec, absent and the literal empty string are
- * classic; any other value is ASCII-whitespace-stripped and must match a JavaScript MIME type —
- * so a whitespace-only `type` is a data block, not a classic script.
- */
-declare function isClassicScriptType(type: string | undefined): boolean;
-//#endregion
 //#region src/images.d.ts
 /**
  * A normalized <img> occurrence — the mode-independent boundary for Performance
@@ -674,52 +714,23 @@ interface ImageInfo {
   hasAlt: boolean;
   /** True when the <img> has a literal `loading="lazy"` (performance/lcp-image). Dynamic/spread → false. */
   lazy: boolean;
-  /** True when the <img> has a `srcset` attribute (performance/responsive-image). */
+  /** True when the <img>, or a `<source>` of its `<picture>`, has a `srcset` attribute (performance/responsive-image). */
   hasSrcset: boolean;
+  /** True when the <img>'s src is known to be an SVG (`isSvgSrc`; performance/responsive-image). */
+  svg?: boolean;
   /** 1-based source line, or 0 if unknown. */
   line: number;
   /** Source file the <img> came from. */
   file: string;
 }
+/** A `.svg` path (query and fragment ignored) or an inline `data:image/svg+xml` URI. */
+declare function isSvgSrc(src: string): boolean;
 /** Resolved <img> elements for a single route (page + layout chain). */
 interface ResolvedImages {
   route: string;
   images: ImageInfo[];
 }
 //#endregion
-//#region src/headings.d.ts
-/**
- * A normalized page-body heading occurrence — the mode-independent boundary for
- * the heading-hierarchy rule (mirrors images.ts). Both providers collect these
- * so seo/single-h1 never needs to know which mode produced them.
- */
-interface HeadingInfo {
-  /** Heading level 1–6 (the `n` in <hn>). */
-  level: number;
-  /** 1-based source line, or 0 if unknown (rendered mode does not track lines). */
-  line: number;
-  /** Source file the heading came from. */
-  file: string;
-}
-/** Resolved page-body headings for a single route (page + layout chain). */
-interface ResolvedHeadings {
-  route: string;
-  headings: HeadingInfo[];
-  /**
-   * Headings found in child components rendered (transitively) by this route's
-   * chain files — source mode only; absent in rendered mode. Kept separate from
-   * `headings` because their position in document order is unknown: safe for
-   * counting (seo/single-h1), unusable for outline order (seo/heading-level-skip).
-   */
-  componentHeadings?: HeadingInfo[];
-  /**
-   * This route renders a `<svelte:element>` that may be a heading whose level is not
-   * statically determinable (`this={`h${n}`}`, an identifier, …) — source mode only.
-   * Counting stays as-is; only the "no <h1> anywhere" claim becomes unsafe to make.
-   */
-  dynamicHeading?: boolean;
-}
-//#endregion
 //#region src/a11y.d.ts
 /** One step of a template branch address: which exclusive block, and which arm of it. */
 interface BranchStep {
@@ -871,6 +882,48 @@ declare function isTopFragment(id: string): boolean;
  */
 declare function stripTextDirective(fragment: string): string;
 //#endregion
+//#region src/headings.d.ts
+/**
+ * A normalized page-body heading occurrence — the mode-independent boundary for
+ * the heading-hierarchy rule (mirrors images.ts). Both providers collect these
+ * so seo/single-h1 never needs to know which mode produced them.
+ */
+interface HeadingInfo {
+  /** Heading level 1–6 (the `n` in <hn>). */
+  level: number;
+  /** 1-based source line, or 0 if unknown (rendered mode does not track lines). */
+  line: number;
+  /** Source file the heading came from. */
+  file: string;
+  /**
+   * The `{#if}`/`{#await}`/`<svelte:boundary>` arms it sits in (source mode; absent when
+   * unconditional), including those of the component usages and layout `{@render children()}`
+   * above it. Group numbers are route-wide: each file instance has its own range.
+   */
+  path?: BranchStep[];
+}
+/** Resolved page-body headings for a single route (page + layout chain). */
+interface ResolvedHeadings {
+  route: string;
+  headings: HeadingInfo[];
+  /**
+   * Headings found in child components rendered (transitively) by this route's
+   * chain files — source mode only; absent in rendered mode. Kept separate from
+   * `headings` because their position in document order is unknown: safe for
+   * counting (seo/single-h1), unusable for outline order (seo/heading-level-skip).
+   */
+  componentHeadings?: HeadingInfo[];
+  /**
+   * This route may render a heading whose level is not statically determinable: a
+   * `<svelte:element>` (`this={`h${n}`}`, an identifier, …), or a component that cannot be
+   * followed but is given a literal `h1` element prop (`<Heading tag="h1">`) — source mode only.
+   * Counting stays as-is; only the "no <h1> anywhere" claim becomes unsafe to make.
+   */
+  dynamicHeading?: boolean;
+  /** `dynamicHeading`, but from a component loaded with `import()` — source-mode collection folds it in only on routes never server-rendered. */
+  clientOnlyHeading?: boolean;
+}
+//#endregion
 //#region src/kit-module.d.ts
 /**
  * Facts parsed from one SvelteKit route/hooks file for the SSR shared-state rules
@@ -937,10 +990,14 @@ interface KitModuleFacts {
   ssrDisabled?: {
     line: number;
   };
+  /** Set when this file exports `ssr` as anything but a literal `false` (`true`, a computed value, a re-export) — it may turn SSR back on under a layout's `ssr = false` (see `appSsrDisabled`, `routeNeverSsr`). */
+  ssrEnabled?: true;
   /** Set when this file disables client-side rendering via `export const csr = false` (inline or same-file alias export). With no client runtime, a universal load only runs during SSR — performance/load-waterfall's browser-waterfall premise doesn't hold. */
   csrDisabled?: {
     line: number;
   };
+  /** Set when the exported `load` redirects or throws `error()` on every call — every path through its body reaches a `redirect()`/`error()` before any `return`, directly or through a same-file top-level function that always does (see `loadNeverRenders` in kit-module-parse.ts). A `+page` module carrying it means the route never renders its own page. */
+  loadNeverRenders?: true;
   /** Sequential-await analysis of the exported `load` function (performance/load-waterfall, performance/sequential-awaits): 1-based lines of await sites that depend on an earlier await's result, and of sites independent of all earlier awaits. Set only when at least one list is non-empty. */
   loadWaterfalls?: {
     dependentLines: number[];
@@ -953,6 +1010,10 @@ interface KitModuleFacts {
   /** Set when the file could not be READ — an environment problem, not a malformed module. */
   readFailed?: true;
 }
+/** The rule-context fields the per-route SSR resolution reads. */
+type SsrScope = Pick<RuleContext, 'kitModules' | 'components' | 'sourceFiles'>;
+/** Whether a `+page`/`+layout` file (module or component) belongs to a route that is never server-rendered. */
+declare function routeNeverSsr(file: string, scope: SsrScope): boolean;
 //#endregion
 //#region src/config-apply.d.ts
 /** The severity a setting selects: `'off'`, an explicit severity, or undefined (leave the built-in). */
@@ -969,12 +1030,12 @@ declare function selectRules(rules: Rule[], config: Config): Rule[];
 declare function withFailedRulesOff(config: Config, failedRuleIds: readonly string[]): Config;
 /**
  * The rules that only pay off for a page that appears in a search result, turned off by
- * `seo: { indexable: false }`. `seo/single-h1` and `seo/robots-txt` are deliberately absent:
- * a primary heading is document structure either way, and a `noindex` meta is only read after
- * the page is crawled, so robots.txt still does real work. Design:
+ * `seo: { indexable: false }` — plus `seo/indexability`, whose "is this noindex intentional?"
+ * the switch answers. Every other SEO rule is deliberately absent, and a test fails on an SEO
+ * rule classified neither way. Design:
  * docs/superpowers/specs/2026-09-21-noindex-seo-rules-design.md.
  */
-declare const SEARCH_RESULT_RULES: readonly ["seo/canonical-url", "seo/og-title", "seo/og-description", "seo/og-image", "seo/og-url", "seo/twitter-card", "seo/json-ld", "seo/sitemap-xml", "seo/sitemap-in-robots", "seo/title-length", "seo/description-length"];
+declare const SEARCH_RESULT_RULES: readonly ["seo/canonical-url", "seo/og-title", "seo/og-description", "seo/og-image", "seo/og-url", "seo/twitter-card", "seo/json-ld", "seo/sitemap-xml", "seo/sitemap-in-robots", "seo/title-length", "seo/description-length", "seo/description-presence", "seo/duplicate-title", "seo/duplicate-description", "seo/hreflang", "seo/ssr-disabled", "seo/indexability"];
 /**
  * Expand `seo: { indexable: false }` into the `'off'` entries a user writes by hand today, so
  * nothing downstream needs a second notion of "not counted". The caller's own map is spread
@@ -1286,4 +1347,4 @@ declare function formatJsonReport(results: Result[], config: Config, meta: {
   version: string;
 }, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>, skipped?: JsonReport['skipped']): string;
 //#endregion
-export { formatMarkdownReport as $, A11yOccurrenceInfo as A, OrphanEffectFact as At, decodeFragmentId as B, compileOverrides as C, Value as Ct, withFailedRulesOff as D, ComponentFacts as Dt, settingSeverity as E, defineConfig as Et, IDREF_ATTRS as F, skippedFileWarnings as Ft, stripTextDirective as G, isTopFragment as H, LandmarkInput as I, Runtime as It, ImageInfo as J, HeadingInfo as K, NAMING_ATTRS as L, withReadLimit as Lt, ANCESTRY_DEPENDENT_TAGS as M, SuppressionDirective as Mt, ASIDE_DEMOTING_TAGS as N, collectComponentFacts as Nt, withIndexableOff as O, EachBlockFact as Ot, BranchStep as P, emptyComponentFacts as Pt, isClassicScriptType as Q, ResolvedA11y as R, SEARCH_RESULT_RULES as S, TreatDynamicAs as St, selectRules as T, defaultProject as Tt, resolveLandmark as U, foldOccurrences as V, splitTokens as W, HeadTag as X, ResolvedImages as Y, ResolvedHead as Z, isPlainObject as _, RuleOverride as _t, HealthResult as a, hasFailureAtOrAbove as at, validateRuleSetting as b, Scope as bt, ScoreResult as c, Category as ct, Rule as d, Fix as dt, formatGithubReport as et, RuleContext as f, KitAlias as ft, RuleOptionsSpec as g, RuleOptions as gt, RuleOptionSpec as h, Result as ht, formatJsonReport as i, effectiveSeverity as it, A11ySkipCause as j, SourceSpan as jt, KitModuleFacts as k, EffectFact as kt, computeHealth as l, Config as lt, isPenalized as m, Project as mt, RuleEvidence as n, Summary as nt, ScoreModel as o, summarize as ot, docsUrlFor as p, Presence as pt, ResolvedHeadings as q, buildJsonReport as r, classify as rt, ScoreOptions as s, CATEGORIES as st, JsonReport as t, Classification as tt, computeScore as u, Detection as ut, resolveRuleOptions as v, RuleSetting as vt, formatFailedRuleWarning as w, defaultConfig as wt, CompiledOverride as x, Severity as xt, shouldSkipRangeCheck as y, RuleSettingObject as yt, SECTIONING_TAGS as z };
+export { formatGithubReport as $, routeNeverSsr as A, EachBlockFact as At, NAMING_ATTRS as B, compileOverrides as C, defaultConfig as Ct, withFailedRulesOff as D, ResolvedHead as Dt, settingSeverity as E, HeadTag as Et, ANCESTRY_DEPENDENT_TAGS as F, collectComponentFacts as Ft, isTopFragment as G, SECTIONING_TAGS as H, ASIDE_DEMOTING_TAGS as I, emptyComponentFacts as It, stripTextDirective as J, resolveLandmark as K, BranchStep as L, skippedFileWarnings as Lt, ResolvedHeadings as M, OrphanEffectFact as Mt, A11yOccurrenceInfo as N, SourceSpan as Nt, withIndexableOff as O, isClassicScriptType as Ot, A11ySkipCause as P, SuppressionDirective as Pt, formatMarkdownReport as Q, IDREF_ATTRS as R, Runtime as Rt, SEARCH_RESULT_RULES as S, Value as St, selectRules as T, defineConfig as Tt, decodeFragmentId as U, ResolvedA11y as V, foldOccurrences as W, ResolvedImages as X, ImageInfo as Y, isSvgSrc as Z, isPlainObject as _, RuleSetting as _t, HealthResult as a, summarize as at, validateRuleSetting as b, Severity as bt, ScoreResult as c, Config as ct, Rule as d, KitAlias as dt, Classification as et, RuleContext as f, Presence as ft, RuleOptionsSpec as g, RuleOverride as gt, RuleOptionSpec as h, RuleOptions as ht, formatJsonReport as i, hasFailureAtOrAbove as it, HeadingInfo as j, EffectFact as jt, KitModuleFacts as k, ComponentFacts as kt, computeHealth as l, Detection as lt, isPenalized as m, Result as mt, RuleEvidence as n, classify as nt, ScoreModel as o, CATEGORIES as ot, docsUrlFor as p, Project as pt, splitTokens as q, buildJsonReport as r, effectiveSeverity as rt, ScoreOptions as s, Category as st, JsonReport as t, Summary as tt, computeScore as u, Fix as ut, resolveRuleOptions as v, RuleSettingObject as vt, formatFailedRuleWarning as w, defaultProject as wt, CompiledOverride as x, TreatDynamicAs as xt, shouldSkipRangeCheck as y, Scope as yt, LandmarkInput as z, withReadLimit as zt };