@variance-authority/core 0.1.0

package/dist/relate/records.js

@@ -0,0 +1,112 @@
+/**
+ * One file's outgoing edges, and the fold that turns a pile of them into a graph.
+ *
+ * A record is what reading **one** file produced, and that is the unit on
+ * purpose. It makes the expensive half — open, parse, resolve — cacheable by
+ * content digest and parallelizable per file, and it leaves the graph a pure
+ * function of the records, so the structure can be rebuilt, sharded or merged
+ * without touching a disk. `core` performs no I/O (ADR-0006); whoever owns the
+ * disk produces these and hands them over.
+ *
+ * ## An empty record and an unreadable one are different facts
+ *
+ * A file with no imports and a file nothing could parse both produce a record
+ * with no edges, and treating them alike is the one mistake that turns this from
+ * a saving into a silent hole: the second one may import anything, including
+ * whatever just changed. So `unknown` carries the *reason* the edges are not
+ * known, and every consumer seeds its traversal with those files (ADR-0002 —
+ * absent is not empty, and here absent is not even absent, it is *unread*).
+ */
+import { idOf, nodeAt, relationsOf, } from './graph.js';
+import { dependentsOf, trailOf } from './reach.js';
+const file = (name) => ({ kind: 'file', name });
+const component = (name) => ({ kind: 'component', name });
+/**
+ * Fold file records into the graph.
+ *
+ * Every record contributes its own node even when it has no edges, so a changed
+ * file that imports nothing is still findable — otherwise the one file in the
+ * diff would be missing from the structure that exists to answer questions about
+ * it.
+ *
+ * A declaration becomes an edge from the **component to the file**, which is the
+ * direction the convention requires: the component depends on the file that
+ * declares it, so one walk against the arrows from a changed file reaches every
+ * importer and every component in the same pass.
+ */
+export function relationsOfFiles(records) {
+    const relations = [];
+    const isolated = [];
+    const unknown = [];
+    for (const record of records) {
+        const from = file(record.file);
+        isolated.push(from);
+        for (const edge of record.edges ?? []) {
+            relations.push({ from, to: file(edge.to), kind: edge.kind });
+        }
+        for (const name of record.declares ?? []) {
+            relations.push({ from: component(name), to: from, kind: 'declared-in' });
+        }
+        // The sentence travels with the node. Reduced to a flag here, the paragraph
+        // this record exists to produce could name a count and never a cause.
+        if (record.unknown !== undefined)
+            unknown.push([from, record.unknown]);
+    }
+    return relationsOf({ relations, isolated, unknown });
+}
+/**
+ * What a set of changed files could have moved.
+ *
+ * The seed set is the changed files **and every file whose edges are unknown**,
+ * which is the rule the whole structure rests on. An unreadable file might import
+ * the one that changed; seeding it means everything depending on *it* is observed
+ * too, and the cost is a collection rather than a green run over an unwatched
+ * surface.
+ *
+ * One breadth-first search, whatever the number of changed files.
+ */
+export function movedBy(relations, changed) {
+    const seeds = [];
+    const missing = [];
+    for (const path of changed) {
+        const id = idOf(relations, 'file', path);
+        if (id === undefined)
+            missing.push(path);
+        else
+            seeds.push(id);
+    }
+    const opaque = [];
+    for (let id = 0; id < relations.unknown.length; id += 1) {
+        if (relations.unknown[id] !== 1)
+            continue;
+        seeds.push(id);
+        const because = relations.reasons.get(id);
+        opaque.push({ file: relations.names[id], ...(because === undefined ? {} : { because }) });
+    }
+    const reach = dependentsOf(relations, seeds);
+    const files = [];
+    const components = [];
+    for (const id of reach.reached) {
+        const node = nodeAt(relations, id);
+        if (node === undefined)
+            continue;
+        (node.kind === 'file' ? files : components).push(node.name);
+    }
+    return { files, components, missing: missing.sort(byCodeUnit), opaque, reach };
+}
+/**
+ * How one file or component was reached, as the chain that reached it.
+ *
+ * The sentence a run prints when somebody asks why a subject was observed. Empty
+ * when the node was not reached at all.
+ */
+export function explain(relations, moved, node) {
+    const id = idOf(relations, node.kind, node.name);
+    if (id === undefined)
+        return [];
+    return trailOf(moved.reach, id).map((step) => relations.names[step]);
+}
+function byCodeUnit(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=records.js.map

package/dist/relate/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","sourceRoot":"","sources":["../../src/relate/records.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * One file's outgoing edges, and the fold that turns a pile of them into a graph.\n *\n * A record is what reading **one** file produced, and that is the unit on\n * purpose. It makes the expensive half — open, parse, resolve — cacheable by\n * content digest and parallelizable per file, and it leaves the graph a pure\n * function of the records, so the structure can be rebuilt, sharded or merged\n * without touching a disk. `core` performs no I/O (ADR-0006); whoever owns the\n * disk produces these and hands them over.\n *\n * ## An empty record and an unreadable one are different facts\n *\n * A file with no imports and a file nothing could parse both produce a record\n * with no edges, and treating them alike is the one mistake that turns this from\n * a saving into a silent hole: the second one may import anything, including\n * whatever just changed. So `unknown` carries the *reason* the edges are not\n * known, and every consumer seeds its traversal with those files (ADR-0002 —\n * absent is not empty, and here absent is not even absent, it is *unread*).\n */\n\nimport type { Digest } from '../format/hash.js';\nimport {\n  idOf,\n  nodeAt,\n  relationsOf,\n  type EdgeKind,\n  type Node,\n  type NodeId,\n  type Relation,\n  type Relations,\n} from './graph.js';\nimport { dependentsOf, trailOf, type Reach } from './reach.js';\n\nexport interface FileEdge {\n  /** Repository-relative, already resolved. A specifier is not an edge. */\n  readonly to: string;\n  readonly kind: EdgeKind;\n}\n\nexport interface FileRecord {\n  /** Repository-relative, so a graph is portable between machines and CI. */\n  readonly file: string;\n\n  /**\n   * The content digest this record was read from.\n   *\n   * Two jobs. It lets a second scan skip the parse for a file that has not moved,\n   * which is the difference between a scan that costs a second and one nobody\n   * leaves enabled. And it is the leaf of the Merkle fold in\n   * [`merkle.ts`](./merkle.ts) — a file with no digest is one nothing can prove\n   * unchanged, and is marked as such rather than assumed still.\n   */\n  readonly digest?: Digest;\n\n  /** Resolved outgoing edges. Absent and empty mean the same thing here. */\n  readonly edges?: readonly FileEdge[];\n\n  /** Component names this file declares, from `indexSource` or better. */\n  readonly declares?: readonly string[];\n\n  /**\n   * Specifiers that were read but did not resolve.\n   *\n   * Kept for the report rather than for the graph. A bare specifier that failed\n   * to resolve is usually a package that is not installed; a **relative** one\n   * that failed is a hole, and whoever produced the record says so by also\n   * setting `unknown`.\n   */\n  readonly unresolved?: readonly string[];\n\n  /**\n   * Why this file's outgoing edges could not be enumerated, when they could not.\n   *\n   * Present means *this file may depend on anything*. The sentence is carried\n   * rather than a flag, because it ends up in the paragraph explaining why a run\n   * observed more than the operator expected.\n   */\n  readonly unknown?: string;\n}\n\nconst file = (name: string): Node => ({ kind: 'file', name });\nconst component = (name: string): Node => ({ kind: 'component', name });\n\n/**\n * Fold file records into the graph.\n *\n * Every record contributes its own node even when it has no edges, so a changed\n * file that imports nothing is still findable — otherwise the one file in the\n * diff would be missing from the structure that exists to answer questions about\n * it.\n *\n * A declaration becomes an edge from the **component to the file**, which is the\n * direction the convention requires: the component depends on the file that\n * declares it, so one walk against the arrows from a changed file reaches every\n * importer and every component in the same pass.\n */\nexport function relationsOfFiles(records: Iterable<FileRecord>): Relations {\n  const relations: Relation[] = [];\n  const isolated: Node[] = [];\n  const unknown: (readonly [Node, string])[] = [];\n\n  for (const record of records) {\n    const from = file(record.file);\n    isolated.push(from);\n\n    for (const edge of record.edges ?? []) {\n      relations.push({ from, to: file(edge.to), kind: edge.kind });\n    }\n    for (const name of record.declares ?? []) {\n      relations.push({ from: component(name), to: from, kind: 'declared-in' });\n    }\n    // The sentence travels with the node. Reduced to a flag here, the paragraph\n    // this record exists to produce could name a count and never a cause.\n    if (record.unknown !== undefined) unknown.push([from, record.unknown]);\n  }\n\n  return relationsOf({ relations, isolated, unknown });\n}\n\nexport interface Hole {\n  /** The file whose outgoing edges could not be enumerated. */\n  readonly file: string;\n  /** Why, in the words of whoever read it. Absent when nobody said. */\n  readonly because?: string;\n}\n\nexport interface Reached {\n  /** Files the change could have moved, including the changed files themselves. */\n  readonly files: readonly string[];\n  /** Components declared in any of them. */\n  readonly components: readonly string[];\n\n  /**\n   * Changed paths the graph does not hold.\n   *\n   * Never silently ignored. A `README.md` belongs here and means nothing; a\n   * source file belongs here only because the scan never reached it, and the\n   * caller — which knows where it told the scan to look — is the one that can\n   * tell those apart.\n   */\n  readonly missing: readonly string[];\n\n  /**\n   * Files seeded because their own edges are unknown, rather than because\n   * anything reached them, each with the reason it could not be read.\n   *\n   * Counted separately so that \"we widened\" never hides inside \"we found\", and\n   * carrying its sentence so the widening is a work item rather than a tax: *four\n   * files could not be read* is something to live with, and ``src/legacy.js — a\n   * computed require()`` is something to fix.\n   */\n  readonly opaque: readonly Hole[];\n\n  /** The traversal, kept so a caller can ask how any one file was reached. */\n  readonly reach: Reach;\n}\n\n/**\n * What a set of changed files could have moved.\n *\n * The seed set is the changed files **and every file whose edges are unknown**,\n * which is the rule the whole structure rests on. An unreadable file might import\n * the one that changed; seeding it means everything depending on *it* is observed\n * too, and the cost is a collection rather than a green run over an unwatched\n * surface.\n *\n * One breadth-first search, whatever the number of changed files.\n */\nexport function movedBy(relations: Relations, changed: Iterable<string>): Reached {\n  const seeds: NodeId[] = [];\n  const missing: string[] = [];\n\n  for (const path of changed) {\n    const id = idOf(relations, 'file', path);\n    if (id === undefined) missing.push(path);\n    else seeds.push(id);\n  }\n\n  const opaque: Hole[] = [];\n  for (let id = 0; id < relations.unknown.length; id += 1) {\n    if (relations.unknown[id] !== 1) continue;\n    seeds.push(id);\n\n    const because = relations.reasons.get(id);\n    opaque.push({ file: relations.names[id]!, ...(because === undefined ? {} : { because }) });\n  }\n\n  const reach = dependentsOf(relations, seeds);\n  const files: string[] = [];\n  const components: string[] = [];\n\n  for (const id of reach.reached) {\n    const node = nodeAt(relations, id);\n    if (node === undefined) continue;\n    (node.kind === 'file' ? files : components).push(node.name);\n  }\n\n  return { files, components, missing: missing.sort(byCodeUnit), opaque, reach };\n}\n\n/**\n * How one file or component was reached, as the chain that reached it.\n *\n * The sentence a run prints when somebody asks why a subject was observed. Empty\n * when the node was not reached at all.\n */\nexport function explain(relations: Relations, moved: Reached, node: Node): readonly string[] {\n  const id = idOf(relations, node.kind, node.name);\n  if (id === undefined) return [];\n  return trailOf(moved.reach, id).map((step) => relations.names[step]!);\n}\n\nfunction byCodeUnit(a: string, b: string): number {\n  return a < b ? -1 : a > b ? 1 : 0;\n}\n"]}

package/dist/rules/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@variance-authority/core/rules` — the versioned opinions.
+ *
+ * What survives to be compared, and what a surviving value is turned into: the
+ * property allowlist, the applicability ruleset, variable resolution, shorthand
+ * expansion, colour and dimension canonicalization.
+ *
+ * Separate from the format because this is the part with a **version on it**.
+ * `RULESET_VERSION` and `ALLOWLIST_VERSION` are folded into the identity of every
+ * answer downstream, so changing a rule here makes stored results incomparable
+ * rather than silently comparable — and a reader who wants to know *why* two runs
+ * disagree ends up in this directory rather than anywhere else.
+ */
+export { normalize } from './normalize/index.js';
+export type { NormalizeOptions } from './normalize/index.js';
+export type { AliasMap, AliasResult, InheritContext, ResolvedStyle, DeclarationOrigin, } from './normalize/index.js';
+export { buildAliasMap, aliasAttributeValue, aliasStyleValue, resolveStyle, resolveVariables, INHERITED_PROPERTIES, EMPTY_CONTEXT, canonicalizeValue, canonicalizeTokens, canonicalizeDimension, canonicalizeColor, parseColor, formatColor, expandDeclaration, SHORTHAND_PROPERTIES, } from './normalize/index.js';
+export { RULESET_VERSION, ALLOWLIST_VERSION, STYLE_ALLOWLIST, ATTRIBUTE_ALLOWLIST, ID_REFERENCE_ATTRIBUTES, ID_REFERENCE_LIST_ATTRIBUTES, isAllowedProperty, isCustomProperty, admits, admitsAttribute, } from './ruleset.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@variance-authority/core/rules` — the versioned opinions.
+ *
+ * What survives to be compared, and what a surviving value is turned into: the
+ * property allowlist, the applicability ruleset, variable resolution, shorthand
+ * expansion, colour and dimension canonicalization.
+ *
+ * Separate from the format because this is the part with a **version on it**.
+ * `RULESET_VERSION` and `ALLOWLIST_VERSION` are folded into the identity of every
+ * answer downstream, so changing a rule here makes stored results incomparable
+ * rather than silently comparable — and a reader who wants to know *why* two runs
+ * disagree ends up in this directory rather than anywhere else.
+ */
+export { normalize } from './normalize/index.js';
+export { buildAliasMap, aliasAttributeValue, aliasStyleValue, resolveStyle, resolveVariables, INHERITED_PROPERTIES, EMPTY_CONTEXT, canonicalizeValue, canonicalizeTokens, canonicalizeDimension, canonicalizeColor, parseColor, formatColor, expandDeclaration, SHORTHAND_PROPERTIES, } from './normalize/index.js';
+export { RULESET_VERSION, ALLOWLIST_VERSION, STYLE_ALLOWLIST, ATTRIBUTE_ALLOWLIST, ID_REFERENCE_ATTRIBUTES, ID_REFERENCE_LIST_ATTRIBUTES, isAllowedProperty, isCustomProperty, admits, admitsAttribute, } from './ruleset.js';
+//# sourceMappingURL=index.js.map

package/dist/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AASjD,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,4BAA4B,EAC5B,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,EACN,eAAe,GAChB,MAAM,cAAc,CAAC","sourcesContent":["/**\n * `@variance-authority/core/rules` — the versioned opinions.\n *\n * What survives to be compared, and what a surviving value is turned into: the\n * property allowlist, the applicability ruleset, variable resolution, shorthand\n * expansion, colour and dimension canonicalization.\n *\n * Separate from the format because this is the part with a **version on it**.\n * `RULESET_VERSION` and `ALLOWLIST_VERSION` are folded into the identity of every\n * answer downstream, so changing a rule here makes stored results incomparable\n * rather than silently comparable — and a reader who wants to know *why* two runs\n * disagree ends up in this directory rather than anywhere else.\n */\n\nexport { normalize } from './normalize/index.js';\nexport type { NormalizeOptions } from './normalize/index.js';\nexport type {\n  AliasMap,\n  AliasResult,\n  InheritContext,\n  ResolvedStyle,\n  DeclarationOrigin,\n} from './normalize/index.js';\nexport {\n  buildAliasMap,\n  aliasAttributeValue,\n  aliasStyleValue,\n  resolveStyle,\n  resolveVariables,\n  INHERITED_PROPERTIES,\n  EMPTY_CONTEXT,\n  canonicalizeValue,\n  canonicalizeTokens,\n  canonicalizeDimension,\n  canonicalizeColor,\n  parseColor,\n  formatColor,\n  expandDeclaration,\n  SHORTHAND_PROPERTIES,\n} from './normalize/index.js';\n\nexport {\n  RULESET_VERSION,\n  ALLOWLIST_VERSION,\n  STYLE_ALLOWLIST,\n  ATTRIBUTE_ALLOWLIST,\n  ID_REFERENCE_ATTRIBUTES,\n  ID_REFERENCE_LIST_ATTRIBUTES,\n  isAllowedProperty,\n  isCustomProperty,\n  admits,\n  admitsAttribute,\n} from './ruleset.js';\n"]}

package/dist/rules/normalize/alias.d.ts

@@ -0,0 +1,50 @@
+import type { RawNode } from '../../format/capture.js';
+/**
+ * Structural id aliasing (ADR-0003).
+ *
+ * React's `useId` allocates in mount order, so mounting an unrelated component
+ * earlier renumbers every id on the page. Headless component libraries generate
+ * an id for every `label ↔ input` and `aria-*` association. None of those values
+ * mean anything; all of them churn.
+ *
+ * Masking them to a constant would work, and would also erase the difference
+ * between "the id was renumbered" and "the association was broken" — the second
+ * being a real accessibility regression. Aliasing keeps the relationship and
+ * discards only the value: every id becomes `#a0`, `#a1`, … in document order,
+ * and every reference is rewritten to match.
+ */
+export interface AliasMap {
+    /** Original id → `#aN`, for ids defined inside the subject subtree. */
+    readonly local: ReadonlyMap<string, string>;
+    /** Original id → `#extern:N`, for references that escape the subtree. */
+    readonly external: ReadonlyMap<string, string>;
+}
+export interface AliasResult extends AliasMap {
+    /** Ids referenced but never defined anywhere. A real defect, kept visible. */
+    readonly dangling: readonly string[];
+}
+/**
+ * Assign aliases by walking the subtree in document order.
+ *
+ * Two passes, because a reference may precede its definition — `aria-labelledby`
+ * pointing forward at a sibling is ordinary markup. Collecting every definition
+ * first is what keeps the alias of an id independent of where it is mentioned.
+ */
+export declare function buildAliasMap(root: RawNode, portals?: readonly RawNode[]): AliasResult;
+/**
+ * Rewrite one attribute value through the alias map.
+ *
+ * Only attributes that actually hold id references are touched. Aliasing
+ * anything else would rewrite ordinary values — `type="button"` has no id in it,
+ * and mapping it through would corrupt every attribute in the snapshot.
+ */
+export declare function aliasAttributeValue(map: AliasMap, name: string, value: string): string;
+/**
+ * Rewrite `url(#…)` fragments inside a style value.
+ *
+ * SVG filters, clip paths, masks, and gradients are referenced this way, and
+ * their ids are generated exactly as often as any other. A `filter: url(#blur-7)`
+ * that renumbers to `url(#blur-9)` paints identical pixels.
+ */
+export declare function aliasStyleValue(map: AliasMap, value: string): string;
+//# sourceMappingURL=alias.d.ts.map

package/dist/rules/normalize/alias.js

@@ -0,0 +1,111 @@
+import { ID_REFERENCE_ATTRIBUTES, ID_REFERENCE_LIST_ATTRIBUTES } from '../ruleset.js';
+const ID_LIST_ATTRIBUTES = new Set(ID_REFERENCE_LIST_ATTRIBUTES);
+const ID_REFERENCE = new Set(ID_REFERENCE_ATTRIBUTES);
+/**
+ * Assign aliases by walking the subtree in document order.
+ *
+ * Two passes, because a reference may precede its definition — `aria-labelledby`
+ * pointing forward at a sibling is ordinary markup. Collecting every definition
+ * first is what keeps the alias of an id independent of where it is mentioned.
+ */
+export function buildAliasMap(root, portals = []) {
+    const local = new Map();
+    const external = new Map();
+    const dangling = [];
+    // Portalled content is part of the subject (ADR-0007), so it shares one alias
+    // space with the container. A dialog whose `aria-labelledby` points at a title
+    // inside the portal must resolve, not report as dangling.
+    const roots = [root, ...portals];
+    const walkAll = (visit) => {
+        for (const each of roots)
+            walk(each, visit);
+    };
+    walkAll((node) => {
+        const id = node.attributes['id'];
+        if (id !== undefined && id.length > 0 && !local.has(id)) {
+            local.set(id, `#a${local.size}`);
+        }
+    });
+    walkAll((node) => {
+        for (const [name, value] of Object.entries(node.attributes)) {
+            for (const reference of referencesIn(name, value)) {
+                if (local.has(reference) || external.has(reference))
+                    continue;
+                // Escaping the subtree is not the same as pointing at nothing, but from
+                // inside the subject the two are indistinguishable — so both are aliased
+                // and flagged rather than normalized into invisibility.
+                external.set(reference, `#extern:${external.size}`);
+                dangling.push(reference);
+            }
+        }
+    });
+    return { local, external, dangling };
+}
+/**
+ * Rewrite one attribute value through the alias map.
+ *
+ * Only attributes that actually hold id references are touched. Aliasing
+ * anything else would rewrite ordinary values — `type="button"` has no id in it,
+ * and mapping it through would corrupt every attribute in the snapshot.
+ */
+export function aliasAttributeValue(map, name, value) {
+    if (!ID_REFERENCE.has(name) && name !== 'href' && name !== 'xlink:href')
+        return value;
+    if (name === 'id')
+        return map.local.get(value) ?? aliasOf(map, value);
+    if (ID_LIST_ATTRIBUTES.has(name)) {
+        return value
+            .trim()
+            .split(/\s+/)
+            .filter((part) => part.length > 0)
+            .map((part) => aliasOf(map, part))
+            .join(' ');
+    }
+    if (name === 'href' || name === 'xlink:href') {
+        return value.startsWith('#') ? aliasOf(map, value.slice(1)) : value;
+    }
+    return aliasOf(map, value);
+}
+/**
+ * Rewrite `url(#…)` fragments inside a style value.
+ *
+ * SVG filters, clip paths, masks, and gradients are referenced this way, and
+ * their ids are generated exactly as often as any other. A `filter: url(#blur-7)`
+ * that renumbers to `url(#blur-9)` paints identical pixels.
+ */
+export function aliasStyleValue(map, value) {
+    return value.replace(/url\(\s*(['"]?)#([^'")]+)\1\s*\)/g, (_match, quote, id) => {
+        return `url(${quote}${aliasOf(map, id)}${quote})`;
+    });
+}
+function aliasOf(map, id) {
+    return map.local.get(id) ?? map.external.get(id) ?? `#extern:?${id.length}`;
+}
+function referencesIn(name, value) {
+    if (name === 'id')
+        return [];
+    if (ID_LIST_ATTRIBUTES.has(name)) {
+        return value.trim().split(/\s+/).filter((part) => part.length > 0);
+    }
+    if (name === 'for' || name === 'form' || name === 'list') {
+        return value.length > 0 ? [value] : [];
+    }
+    if (name === 'href' || name === 'xlink:href') {
+        return value.startsWith('#') ? [value.slice(1)] : [];
+    }
+    // Only the `aria-*` attributes that actually hold IDREFs. `aria-label` and
+    // `aria-hidden` carry text and booleans; treating them as references would
+    // report a dangling-id diagnostic for every labelled node in the tree.
+    if (ID_REFERENCE.has(name)) {
+        return value.length > 0 ? [value] : [];
+    }
+    return [];
+}
+function walk(node, visit) {
+    visit(node);
+    for (const child of node.children)
+        walk(child, visit);
+    for (const child of node.shadowChildren ?? [])
+        walk(child, visit);
+}
+//# sourceMappingURL=alias.js.map

package/dist/rules/normalize/alias.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias.js","sourceRoot":"","sources":["../../../src/rules/normalize/alias.ts"],"names":[],"mappings":"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","sourcesContent":["import type { RawNode } from '../../format/capture.js';\nimport { ID_REFERENCE_ATTRIBUTES, ID_REFERENCE_LIST_ATTRIBUTES } from '../ruleset.js';\n\n/**\n * Structural id aliasing (ADR-0003).\n *\n * React's `useId` allocates in mount order, so mounting an unrelated component\n * earlier renumbers every id on the page. Headless component libraries generate\n * an id for every `label ↔ input` and `aria-*` association. None of those values\n * mean anything; all of them churn.\n *\n * Masking them to a constant would work, and would also erase the difference\n * between \"the id was renumbered\" and \"the association was broken\" — the second\n * being a real accessibility regression. Aliasing keeps the relationship and\n * discards only the value: every id becomes `#a0`, `#a1`, … in document order,\n * and every reference is rewritten to match.\n */\n\nexport interface AliasMap {\n  /** Original id → `#aN`, for ids defined inside the subject subtree. */\n  readonly local: ReadonlyMap<string, string>;\n  /** Original id → `#extern:N`, for references that escape the subtree. */\n  readonly external: ReadonlyMap<string, string>;\n}\n\nexport interface AliasResult extends AliasMap {\n  /** Ids referenced but never defined anywhere. A real defect, kept visible. */\n  readonly dangling: readonly string[];\n}\n\nconst ID_LIST_ATTRIBUTES = new Set(ID_REFERENCE_LIST_ATTRIBUTES);\nconst ID_REFERENCE = new Set(ID_REFERENCE_ATTRIBUTES);\n\n/**\n * Assign aliases by walking the subtree in document order.\n *\n * Two passes, because a reference may precede its definition — `aria-labelledby`\n * pointing forward at a sibling is ordinary markup. Collecting every definition\n * first is what keeps the alias of an id independent of where it is mentioned.\n */\nexport function buildAliasMap(root: RawNode, portals: readonly RawNode[] = []): AliasResult {\n  const local = new Map<string, string>();\n  const external = new Map<string, string>();\n  const dangling: string[] = [];\n\n  // Portalled content is part of the subject (ADR-0007), so it shares one alias\n  // space with the container. A dialog whose `aria-labelledby` points at a title\n  // inside the portal must resolve, not report as dangling.\n  const roots = [root, ...portals];\n  const walkAll = (visit: (node: RawNode) => void): void => {\n    for (const each of roots) walk(each, visit);\n  };\n\n  walkAll((node) => {\n    const id = node.attributes['id'];\n    if (id !== undefined && id.length > 0 && !local.has(id)) {\n      local.set(id, `#a${local.size}`);\n    }\n  });\n\n  walkAll((node) => {\n    for (const [name, value] of Object.entries(node.attributes)) {\n      for (const reference of referencesIn(name, value)) {\n        if (local.has(reference) || external.has(reference)) continue;\n        // Escaping the subtree is not the same as pointing at nothing, but from\n        // inside the subject the two are indistinguishable — so both are aliased\n        // and flagged rather than normalized into invisibility.\n        external.set(reference, `#extern:${external.size}`);\n        dangling.push(reference);\n      }\n    }\n  });\n\n  return { local, external, dangling };\n}\n\n/**\n * Rewrite one attribute value through the alias map.\n *\n * Only attributes that actually hold id references are touched. Aliasing\n * anything else would rewrite ordinary values — `type=\"button\"` has no id in it,\n * and mapping it through would corrupt every attribute in the snapshot.\n */\nexport function aliasAttributeValue(map: AliasMap, name: string, value: string): string {\n  if (!ID_REFERENCE.has(name) && name !== 'href' && name !== 'xlink:href') return value;\n\n  if (name === 'id') return map.local.get(value) ?? aliasOf(map, value);\n\n  if (ID_LIST_ATTRIBUTES.has(name)) {\n    return value\n      .trim()\n      .split(/\\s+/)\n      .filter((part) => part.length > 0)\n      .map((part) => aliasOf(map, part))\n      .join(' ');\n  }\n\n  if (name === 'href' || name === 'xlink:href') {\n    return value.startsWith('#') ? aliasOf(map, value.slice(1)) : value;\n  }\n\n  return aliasOf(map, value);\n}\n\n/**\n * Rewrite `url(#…)` fragments inside a style value.\n *\n * SVG filters, clip paths, masks, and gradients are referenced this way, and\n * their ids are generated exactly as often as any other. A `filter: url(#blur-7)`\n * that renumbers to `url(#blur-9)` paints identical pixels.\n */\nexport function aliasStyleValue(map: AliasMap, value: string): string {\n  return value.replace(/url\\(\\s*(['\"]?)#([^'\")]+)\\1\\s*\\)/g, (_match, quote: string, id: string) => {\n    return `url(${quote}${aliasOf(map, id)}${quote})`;\n  });\n}\n\nfunction aliasOf(map: AliasMap, id: string): string {\n  return map.local.get(id) ?? map.external.get(id) ?? `#extern:?${id.length}`;\n}\n\nfunction referencesIn(name: string, value: string): readonly string[] {\n  if (name === 'id') return [];\n\n  if (ID_LIST_ATTRIBUTES.has(name)) {\n    return value.trim().split(/\\s+/).filter((part) => part.length > 0);\n  }\n\n  if (name === 'for' || name === 'form' || name === 'list') {\n    return value.length > 0 ? [value] : [];\n  }\n\n  if (name === 'href' || name === 'xlink:href') {\n    return value.startsWith('#') ? [value.slice(1)] : [];\n  }\n\n  // Only the `aria-*` attributes that actually hold IDREFs. `aria-label` and\n  // `aria-hidden` carry text and booleans; treating them as references would\n  // report a dangling-id diagnostic for every labelled node in the tree.\n  if (ID_REFERENCE.has(name)) {\n    return value.length > 0 ? [value] : [];\n  }\n\n  return [];\n}\n\nfunction walk(node: RawNode, visit: (node: RawNode) => void): void {\n  visit(node);\n  for (const child of node.children) walk(child, visit);\n  for (const child of node.shadowChildren ?? []) walk(child, visit);\n}\n"]}

package/dist/rules/normalize/cascade.d.ts

@@ -0,0 +1,85 @@
+import type { MatchedRule } from '../../format/capture.js';
+/**
+ * Cascade resolution — ADR-0003 step 5.
+ *
+ * Losing declarations cannot reach a pixel, so they must not reach a hash. A
+ * specificity war that changes *which rule wins* without changing the *winning
+ * value* is a refactor, and refactors must not invalidate baselines.
+ *
+ * Under a profile with computed style the engine has already done this, and its
+ * answer is authoritative. This code runs anyway, for two reasons: it supplies
+ * the values under `declared-only` profiles, and under both profiles it supplies
+ * the attribution side-channel — *which rule set this?* — which computed style
+ * cannot answer at all.
+ */
+/**
+ * Properties that inherit.
+ *
+ * Restricted to the allowlist: inheriting a property the snapshot does not
+ * record would cost work and change nothing. Without this, a `color` set once on
+ * a container would be invisible on every descendant that renders text under a
+ * declared-only profile — the most common styling pattern there is.
+ */
+export declare const INHERITED_PROPERTIES: readonly string[];
+/** Values flowing into a node from its ancestors. */
+export interface InheritContext {
+    /** Resolved values of inheritable properties. */
+    readonly inherited: Readonly<Record<string, string>>;
+    /** Custom properties in scope. Every custom property inherits. */
+    readonly customProperties: Readonly<Record<string, string>>;
+    /**
+     * For each inherited property, the token its value came from.
+     *
+     * Inheritance would otherwise launder away the attribution: a heading that
+     * inherits `color` from a container styled with `var(--brand)` produces a
+     * delta with no token, no owner chain of its own, and therefore its own
+     * `unattributed` root. One token edit would fan out into a docket entry per
+     * inheriting text node — destroying precisely the "one root, N collateral"
+     * claim the token band exists to make.
+     */
+    readonly inheritedTokens?: Readonly<Record<string, string>>;
+}
+export declare const EMPTY_CONTEXT: InheritContext;
+export interface ResolvedStyle {
+    /** Winning, canonicalized values for allowlisted properties. */
+    readonly style: Readonly<Record<string, string>>;
+    /** Custom properties a winning value resolved through: name → resolved value. */
+    readonly tokens: Readonly<Record<string, string>>;
+    /** Where each winning declaration came from. Outside the hash by design. */
+    readonly origins: Readonly<Record<string, DeclarationOrigin>>;
+    /**
+     * Which token each property's value came from, including inherited ones.
+     *
+     * Needed because "this node uses tokens" is not specific enough to attribute a
+     * delta: a node may resolve `color` through a token while its `padding` comes
+     * from a literal, and only the first is collateral of a token edit.
+     */
+    readonly propertyTokens: Readonly<Record<string, string>>;
+    /** Context to pass to this node's children. */
+    readonly childContext: InheritContext;
+}
+export interface DeclarationOrigin {
+    readonly sheet: string;
+    readonly selector: string;
+    readonly source?: {
+        readonly file: string;
+        readonly line: number;
+    };
+    readonly tokenName?: string;
+}
+export interface ResolveInput {
+    readonly matchedRules: readonly MatchedRule[];
+    readonly inlineStyle?: Readonly<Record<string, string>>;
+    /** Engine-resolved values. When present these win over anything computed here. */
+    readonly computedStyle?: Readonly<Record<string, string>>;
+    readonly context: InheritContext;
+}
+export declare function resolveStyle(input: ResolveInput): ResolvedStyle;
+interface VariableResolution {
+    readonly value: string;
+    /** Custom property names consulted, in order of first appearance. */
+    readonly used: readonly string[];
+}
+export declare function resolveVariables(value: string, customProperties: Readonly<Record<string, string>>, depth?: number): VariableResolution;
+export {};
+//# sourceMappingURL=cascade.d.ts.map