@svelte-vitals/core 0.50.0 → 0.51.0

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

@@ -1,9 +1,43 @@
-//#region src/component.d.ts
+//#region src/runtime.d.ts
 /**
- * Component-body facts for the Correctness category — the source-analysis boundary
- * (mirrors images.ts / headings.ts). Collected by the static (CLI) provider only;
- * the rendered provider can't see reactivity, so correctness rules no-op there.
+ * Runtime abstraction (design §8). Core defines only the interface; concrete
+ * adapters (Node / Deno / Bun) live in the CLI package and are the only place
+ * allowed to touch runtime-specific I/O APIs. Providers and rules use this
+ * interface exclusively, which keeps them runtime-agnostic and lets tests inject
+ * an in-memory implementation.
  */
+interface Runtime {
+  /** Read a UTF-8 text file. Rejects if the file does not exist. */
+  readFile(path: string): Promise<string>;
+  /** Whether a path exists. */
+  exists(path: string): Promise<boolean>;
+  /**
+   * Paths matching `pattern`, relative to `cwd`.
+   *
+   * **Dot files and dot directories are excluded**, and an adapter must keep it that way: the
+   * directory-shaped Architecture rules derive their directory set from these paths, and one of them
+   * enumerates a parent's children exhaustively, so a `.server/` appearing here would be reported as
+   * an undeclared name. Both shipped adapters rely on `node:fs` glob's default, which never
+   * matches dot entries.
+   *
+   * **Every returned path is a file, never a directory**, and an adapter must keep that true too:
+   * `architecture/reserved-directory-names`' unit test takes a directory's immediate children from
+   * this same inventory and asks whether one of them is a file named after the directory, so an
+   * adapter that let a directory through here would let a bare `Card/Card` satisfy that test as if it
+   * were an entry file. Both shipped adapters filter to files explicitly — `node:fs`'s glob
+   * matches directories too.
+   */
+  glob(pattern: string, cwd: string): Promise<string[]>;
+  /** Join path segments without depending on `node:path`. */
+  join(...parts: string[]): string;
+}
+/**
+ * `readFile` with at most `limit` reads in flight. A plain counter plus a queue of waiters —
+ * deliberately not a dependency, and pure enough to live in core.
+ */
+declare function withReadLimit(readFile: (path: string) => Promise<string>, limit?: number): (path: string) => Promise<string>;
+//#endregion
+//#region src/component.d.ts
 /** An `{#each}` block in a component template. */
 interface EachBlockFact {
   /** True when the block has a key, e.g. `{#each items as item (item.id)}`. */
@@ -324,6 +358,14 @@ declare function skippedFileWarnings(facts: readonly {
   parseFailed?: true;
   readFailed?: true;
 }[]): string[];
+/**
+ * Scan every `.svelte` component and `.svelte.ts`/`.svelte.js` runes module under `src/`
+ * for Correctness/Security/Architecture/Bundle-Performance/Accessibility facts. Independent
+ * of route resolution — covers `$lib` and non-route components too. A file that fails to
+ * read or parse contributes empty facts instead of aborting the whole scan (dev tooling
+ * must never throw).
+ */
+declare function collectComponentFacts(rt: Runtime, cwd: string): Promise<ComponentFacts[]>;
 //#endregion
 //#region src/types.d.ts
 type Severity = 'critical' | 'warning' | 'info';
@@ -548,55 +590,6 @@ declare function formatMarkdownReport(results: Result[], config: Config, meta: {
   version: string;
 }): string;
 //#endregion
-//#region src/runtime.d.ts
-/**
- * Runtime abstraction (design §8). Core defines only the interface; concrete
- * adapters (Node / Deno / Bun) live in the CLI package and are the only place
- * allowed to touch runtime-specific I/O APIs. Providers and rules use this
- * interface exclusively, which keeps them runtime-agnostic and lets tests inject
- * an in-memory implementation.
- */
-interface Runtime {
-  /** Read a UTF-8 text file. Rejects if the file does not exist. */
-  readFile(path: string): Promise<string>;
-  /** Whether a path exists. */
-  exists(path: string): Promise<boolean>;
-  /**
-   * Paths matching `pattern`, relative to `cwd`.
-   *
-   * **Dot files and dot directories are excluded**, and an adapter must keep it that way: the
-   * directory-shaped Architecture rules derive their directory set from these paths, and one of them
-   * enumerates a parent's children exhaustively, so a `.server/` appearing here would be reported as
-   * an undeclared name. Both shipped adapters pass `dot: false`.
-   *
-   * **Every returned path is a file, never a directory**, and an adapter must keep that true too:
-   * `architecture/reserved-directory-names`' unit test takes a directory's immediate children from
-   * this same inventory and asks whether one of them is a file named after the directory, so an
-   * adapter that let a directory through here would let a bare `Card/Card` satisfy that test as if it
-   * were an entry file. Both shipped adapters get this for free from their glob library's default,
-   * which returns files only unless asked to include directories.
-   */
-  glob(pattern: string, cwd: string): Promise<string[]>;
-  /** Join path segments without depending on `node:path`. */
-  join(...parts: string[]): string;
-}
-/**
- * How many file reads may be in flight at once. Analysis reads every `.svelte` file in a project
- * in parallel, which on a large project opens more descriptors than the process is allowed: at
- * `ulimit -n 1024` — a common container default — a 1 681-route project raised `EMFILE`, and
- * because a failed read lands in the same `catch` as a malformed component, 682 files were dropped
- * and the run still reported a normal score. The cap is what keeps the analysis whole.
- *
- * 64 is chosen to sit well under the stock 256 on macOS while leaving descriptors for everything
- * else the process holds open. It is not a throughput knob: reads are a few percent of the work.
- */
-declare const READ_CONCURRENCY = 64;
-/**
- * `readFile` with at most `limit` reads in flight. A plain counter plus a queue of waiters —
- * deliberately not a dependency, and pure enough to live in core.
- */
-declare function withReadLimit(readFile: (path: string) => Promise<string>, limit?: number): (path: string) => Promise<string>;
-//#endregion
 //#region src/head.d.ts
 /**
  * A normalized head tag. The mode-independent boundary (design §8): the static
@@ -649,14 +642,12 @@ interface ResolvedHead {
   file: string;
 }
 /**
- * Supplies ResolvedHead[] for a project through the runtime abstraction. The
- * static (CLI) mode implements this; rendered mode reads prerendered HTML at
- * build time and emits the same ResolvedHead[] without the runtime indirection.
+ * 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.
  */
-interface HeadProvider {
-  mode: 'static' | 'rendered';
-  collect(rt: Runtime, cwd: string, config?: Config): Promise<ResolvedHead[]>;
-}
+declare function isClassicScriptType(type: string | undefined): boolean;
 //#endregion
 //#region src/images.d.ts
 /**
@@ -803,8 +794,46 @@ declare function foldOccurrences<T extends Foldable>(nodes: T[]): Map<string, T[
 declare function decodeFragmentId(fragment: string): string;
 /** Whitespace-split tokens of a (possibly undefined) literal attribute value. */
 declare function splitTokens(value: string | undefined): string[];
-/** Explicit `role` values that map to the landmark kinds the route rules inspect. */
-declare const LANDMARK_ROLES: ReadonlySet<string>;
+/** Sectioning content (HTML-AAM): a `<header>`/`<footer>` below one of these is not a landmark. */
+declare const SECTIONING_TAGS: ReadonlySet<string>;
+/**
+ * Tags whose landmark-ness depends on sectioning ancestry. A provider that cannot see ancestry
+ * (the per-file AST walk) uses this same set to mark the deferral (topLevel) — reading it from
+ * here keeps the deferral set from drifting when the policy widens.
+ */
+declare const ANCESTRY_DEPENDENT_TAGS: ReadonlySet<string>;
+/** Attributes that give an element the accessible name the `<aside>` landmark decision reads. */
+declare const NAMING_ATTRS: readonly string[];
+/**
+ * HTML-AAM: an `<aside>` scoped to `body` or `main` is a `complementary` landmark; scoped to
+ * sectioning content it is one only when it has an accessible name. `main` is deliberately absent
+ * — it is a scope in which an `aside` *is* a landmark, unlike the sectioning set that decides
+ * `<header>`/`<footer>`.
+ */
+declare const ASIDE_DEMOTING_TAGS: ReadonlySet<string>;
+interface LandmarkInput {
+  /** Lowercased element tag name (HTML tag names are ASCII case-insensitive), or undefined when unknown. */
+  tag: string | undefined;
+  /**
+   * Whitespace tokens of the `role` attribute, or `undefined` when the attribute is absent. The
+   * distinction is load-bearing: a present attribute — even one resolving to no concrete role
+   * (empty, dynamic, unknown tokens) — suppresses the tag mapping instead of falling through to it.
+   */
+  roleTokens: readonly string[] | undefined;
+  /** Has an accessible name (`aria-label`/`aria-labelledby`); each provider decides what its dynamic values mean. */
+  named: boolean;
+  /** An ancestor is sectioning content. A provider that cannot see ancestry passes false and defers the demotion (topLevel approximation). */
+  insideSectioning: boolean;
+  /** An ancestor is in ASIDE_DEMOTING_TAGS — an `<aside>` below one needs a name to stay a landmark. */
+  insideAsideDemoting: boolean;
+}
+/**
+ * The landmark kind an element contributes ('main'|'banner'|'contentinfo'|'complementary'), or
+ * undefined. The one home for the decision both providers apply — the source AST walk and the
+ * rendered HTML walk each feed it their own tree's context. ARIA fallback role lists resolve to
+ * the first token naming a concrete role (resolveRole).
+ */
+declare function resolveLandmark(input: LandmarkInput): string | undefined;
 /**
  * Attributes whose (whitespace-tokenized) values reference element ids: the ARIA id-reference and
  * id-reference-list properties, and HTML's own (`for`, `list`, `headers`, `form`, the popover and
@@ -911,8 +940,6 @@ interface KitModuleFacts {
 //#region src/config-apply.d.ts
 /** The severity a setting selects: `'off'`, an explicit severity, or undefined (leave the built-in). */
 declare function settingSeverity(setting: RuleSetting | undefined): Severity | 'off' | undefined;
-/** The options a setting carries, or undefined for the string forms. */
-declare function settingOptions(setting: RuleSetting | undefined): RuleOptions | undefined;
 /** Drop rules disabled via config (design §6), including a `defaultOff` rule with no entry. */
 declare function selectRules(rules: Rule[], config: Config): Rule[];
 /**
@@ -928,8 +955,6 @@ declare function formatFailedRuleWarning(f: {
   id: string;
   message: string;
 }): string;
-/** Apply per-rule severity overrides to results (design §6). */
-declare function applyRuleSeverities(results: Result[], config: Config): Result[];
 /** An override entry with its globs compiled once. Build with `compileOverrides`. */
 interface CompiledOverride {
   routes: RegExp[];
@@ -941,31 +966,6 @@ interface CompiledOverride {
  * targets (every component, every route) must hoist this out of their loop.
  */
 declare function compileOverrides(config: Config): CompiledOverride[];
-/**
- * Whether an override entry applies to a target. THE single definition of that
- * question — the result post-pass and in-run option resolution both call it.
- * Sharing this matcher is necessary but not sufficient for a severity override
- * and an option override to select the same files: each caller must also pass
- * the same `target` (route and, critically, `file`) the other path effectively
- * matches against. See Finding 1, docs/superpowers/specs/2026-07-26-rule-options-design.md.
- */
-declare function overrideMatches(o: CompiledOverride, target: {
-  route?: string;
-  file?: string;
-}): boolean;
-/**
- * Apply route-/file-scoped overrides to results (design 2026-07-18). An entry
- * matches when any `route` glob matches the finding's route id or any `files`
- * glob matches its location (OR). `'off'` removes a matched result entirely —
- * passing seeds included, so scoring and "checks passed" counts behave as if
- * the rule never ran there. A severity value rewrites the result's severity.
- * Entries are evaluated in order (later entries win); within one entry, a
- * rule-id key beats a category key only when it specifies a `severity` — an
- * options-only rule-id key (no `severity`) contributes its options but leaves
- * the category key's severity in force, rather than shadowing it (design
- * 2026-07-26, Finding 2 / second review Finding E).
- */
-declare function applyOverrides(results: Result[], config: Config): Result[];
 //#endregion
 //#region src/rule-options.d.ts
 /**
@@ -997,37 +997,6 @@ type RuleOptionSpec = {
 };
 /** A rule's configurable options, keyed by option name. */
 type RuleOptionsSpec = Record<string, RuleOptionSpec>;
-/**
- * Typed reads of a resolved options object. `RuleOptions` values are `unknown`
- * (the map is open-ended by design), so without these every rule would carry
- * its own `o.max as number` cast and the "resolution guarantees the declared
- * kind" invariant would live in a dozen places instead of one. `resolveRuleOptions`
- * always seeds every declared key from the spec default and validation rejects a
- * wrongly-typed value up front, so a mismatch here means a rule read a key it
- * never declared — the `fallback` keeps that a wrong number rather than a crash.
- */
-declare function intOption(options: RuleOptions, key: string, fallback?: number): number;
-/** As `intOption`, for a `string-list` option. */
-declare function listOption(options: RuleOptions, key: string): string[];
-/** As `intOption`, for a `string-map` option. */
-declare function mapOption(options: RuleOptions, key: string): Record<string, string>;
-/**
- * Whether any config layer so much as mentions `ruleId` — its `rules` entry, or any `overrides`
- * entry's.
- *
- * A rule that is inert until declared can return early on `false` instead of resolving options once
- * per target and discarding the result. That waste is not hypothetical: the three directory-shaped
- * Architecture rules resolve per directory, so an unconfigured project pays it for every directory
- * under `src/` three times over, on every dev-server save. Measured 2026-07-30 over a synthetic tree
- * of 1,523 directories: 5.4 ms per analysis, for rules that are off by default and therefore produce
- * nothing.
- *
- * Deliberately conservative. It asks only whether the rule is *mentioned*, not whether the mention
- * resolves to a non-empty value, so a `'off'` severity with no options still answers `true` and the
- * caller does its normal work. A cheaper-but-wrong version of this would make a rule skip work it
- * owed; this one can only ever fail to save time.
- */
-declare function isMentionedAnywhere(config: Config, ruleId: string): boolean;
 /**
  * Effective options for a rule at a target: built-in defaults, then
  * `config.rules[ruleId].options`, then every matching `config.overrides` entry
@@ -1041,31 +1010,6 @@ declare function resolveRuleOptions(ruleId: string, spec: RuleOptionsSpec | unde
   route?: string;
   file?: string;
 }, compiled?: CompiledOverride[]): RuleOptions;
-/**
- * Problems with a user-supplied options object, as human-readable sentences
- * (empty = valid). Callers treat any result as fatal: a typo that silently
- * leaves the config inert is the failure this exists to prevent.
- *
- * `baseline`, when given, is the already-resolved value this `options` layer
- * is being merged onto — built-in defaults merged with any earlier layer(s)
- * (e.g. the global `config.rules[id].options`, when `options` is an
- * `overrides[]` entry). The min/max cross-check below compares against it
- * instead of the spec's own default, so a layer that only sets one side of a
- * range is checked against what it actually inherits (design 2026-07-26
- * review, Finding A). Omit it to check `options` against the spec defaults
- * alone, as when validating the global layer itself. A `baseline` that is
- * only partially resolved (missing `min` or `max`) is treated as "can't
- * determine that side" rather than silently comparing against `undefined` —
- * see the `typeof` guard below.
- *
- * `skipRangeCheck`, when true, skips the min/max cross-check entirely
- * regardless of `baseline`. A caller sets this when it statically cannot
- * rule out that some *other* config layer narrows the opposite side of the
- * range at the same target — see the CLI's and the Vite plugin's
- * `overrides[]` validation (design 2026-07-26 review, Finding A, third
- * pass).
- */
-declare function validateRuleOptions(ruleId: string, spec: RuleOptionsSpec | undefined, options: RuleOptions, baseline?: RuleOptions, skipRangeCheck?: boolean): string[];
 /**
  * Whether `validateRuleOptions` should skip the min/max cross-check for
  * `overrides[selfIndex].rules[key]` — the whole decision, so the CLI's
@@ -1208,8 +1152,6 @@ interface ScoreOptions {
 }
 /** Compute the headline score and its breakdown (design §12). */
 declare function computeScore(results: Result[], config: Config, options?: ScoreOptions): ScoreResult;
-/** Compute an independent score per category present in `results` (issue #10). */
-declare function scoresByCategory(results: Result[], config: Config, options?: ScoreOptions): Partial<Record<Category, ScoreResult>>;
 interface HealthResult {
   /** Weighted overall score across present categories (0–100). */
   health: number;
@@ -1305,4 +1247,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 { HeadTag as $, formatFailedRuleWarning as A, defaultProject as At, IDREF_ATTRS as B, shouldSkipRangeCheck as C, RuleSetting as Ct, applyOverrides as D, TreatDynamicAs as Dt, CompiledOverride as E, Severity as Et, withFailedRulesOff as F, OrphanEffectFact as Ft, isTopFragment as G, ResolvedA11y as H, KitModuleFacts as I, SourceSpan as It, HeadingInfo as J, splitTokens as K, A11yOccurrenceInfo as L, SuppressionDirective as Lt, selectRules as M, ComponentFacts as Mt, settingOptions as N, EachBlockFact as Nt, applyRuleSeverities as O, Value as Ot, settingSeverity as P, EffectFact as Pt, HeadProvider as Q, A11ySkipCause as R, skippedFileWarnings as Rt, resolveRuleOptions as S, RuleOverride as St, validateRuleSetting as T, Scope as Tt, decodeFragmentId as U, LANDMARK_ROLES as V, foldOccurrences as W, ImageInfo as X, ResolvedHeadings as Y, ResolvedImages as Z, RuleOptionsSpec as _, KitAlias as _t, HealthResult as a, formatGithubReport as at, listOption as b, Result as bt, ScoreResult as c, classify as ct, scoresByCategory as d, summarize as dt, ResolvedHead as et, Rule as f, CATEGORIES as ft, RuleOptionSpec as g, Fix as gt, isPenalized as h, Detection as ht, formatJsonReport as i, formatMarkdownReport as it, overrideMatches as j, defineConfig as jt, compileOverrides as k, defaultConfig as kt, computeHealth as l, effectiveSeverity as lt, docsUrlFor as m, Config as mt, RuleEvidence as n, Runtime as nt, ScoreModel as o, Classification as ot, RuleContext as p, Category as pt, stripTextDirective as q, buildJsonReport as r, withReadLimit as rt, ScoreOptions as s, Summary as st, JsonReport as t, READ_CONCURRENCY as tt, computeScore as u, hasFailureAtOrAbove as ut, intOption as v, Presence as vt, validateRuleOptions as w, RuleSettingObject as wt, mapOption as x, RuleOptions as xt, isMentionedAnywhere as y, Project as yt, BranchStep as z };
+export { Summary as $, ASIDE_DEMOTING_TAGS as A, collectComponentFacts as At, resolveLandmark as B, selectRules as C, defineConfig as Ct, A11yOccurrenceInfo as D, OrphanEffectFact as Dt, KitModuleFacts as E, EffectFact as Et, ResolvedA11y as F, ImageInfo as G, stripTextDirective as H, SECTIONING_TAGS as I, ResolvedHead as J, ResolvedImages as K, decodeFragmentId as L, IDREF_ATTRS as M, Runtime as Mt, LandmarkInput as N, withReadLimit as Nt, A11ySkipCause as O, SourceSpan as Ot, NAMING_ATTRS as P, Classification as Q, foldOccurrences as R, formatFailedRuleWarning as S, defaultProject as St, withFailedRulesOff as T, EachBlockFact as Tt, HeadingInfo as U, splitTokens as V, ResolvedHeadings as W, formatMarkdownReport as X, isClassicScriptType as Y, formatGithubReport as Z, resolveRuleOptions as _, Scope as _t, HealthResult as a, Category as at, CompiledOverride as b, Value as bt, ScoreResult as c, Fix as ct, Rule as d, Project as dt, classify as et, RuleContext as f, Result as ft, RuleOptionsSpec as g, RuleSettingObject as gt, RuleOptionSpec as h, RuleSetting as ht, formatJsonReport as i, CATEGORIES as it, BranchStep as j, skippedFileWarnings as jt, ANCESTRY_DEPENDENT_TAGS as k, SuppressionDirective as kt, computeHealth as l, KitAlias as lt, isPenalized as m, RuleOverride as mt, RuleEvidence as n, hasFailureAtOrAbove as nt, ScoreModel as o, Config as ot, docsUrlFor as p, RuleOptions as pt, HeadTag as q, buildJsonReport as r, summarize as rt, ScoreOptions as s, Detection as st, JsonReport as t, effectiveSeverity as tt, computeScore as u, Presence as ut, shouldSkipRangeCheck as v, Severity as vt, settingSeverity as w, ComponentFacts as wt, compileOverrides as x, defaultConfig as xt, validateRuleSetting as y, TreatDynamicAs as yt, isTopFragment as z };