@variance-authority/core 0.1.0

package/dist/format/sha256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","sourceRoot":"","sources":["../../src/format/sha256.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SHA-256, in portable TypeScript.\n *\n * `core` originally used `node:crypto`, which was wrong — and the reason is not\n * ergonomic. `propsDigest` has to run *inside the page*: a React prop can be a\n * function or an element, and neither survives serialization out to a host\n * process, so the digest must be taken where the value still exists. A `core`\n * that imports `node:crypto` cannot run there, which quietly contradicted the\n * remote-sub-renderer story in ADR-0002 and the DOM-free boundary in ADR-0001.\n * (The `lib: [\"ES2022\"]` guard is one-directional: it stops `core` reaching into\n * a browser, not `core` depending on Node.)\n *\n * `crypto.subtle.digest` is the obvious replacement and is not usable: it is\n * async, and hashing is synchronous throughout by design — making it async would\n * colour the entire normalizer for no benefit.\n *\n * So the algorithm lives here. It is fully specified by FIPS 180-4, so this\n * produces byte-identical output to any other correct implementation on any\n * runtime, which is exactly the determinism Principle 2 requires. Performance is\n * not a consideration until a gate in ADR-0004 fires; none has.\n */\n\nconst K = new Uint32Array([\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\n]);\n\nconst INITIAL = new Uint32Array([\n  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n\n/** Hash a UTF-8 string, returning lowercase hex. */\nexport function sha256Hex(input: string): string {\n  return sha256HexBytes(utf8Bytes(input));\n}\n\n/**\n * Hash raw bytes, returning lowercase hex.\n *\n * The string form is this with one encoding step in front of it, and not the\n * other way round: an image is bytes, and routing it through a string would mean\n * choosing an encoding that survives arbitrary octets — which is a second\n * decision, made in the wrong place, that changes the digest if it is ever\n * revisited.\n */\nexport function sha256HexBytes(bytes: Uint8Array): string {\n  const state = new Uint32Array(INITIAL);\n\n  // Padding: a single 1 bit, zeros, then the 64-bit big-endian bit length.\n  const bitLength = bytes.length * 8;\n  // Padding is minimal by definition: the smallest multiple of 64 that fits the\n  // message, the 0x80 byte, and the 8-byte length. Rounding up unconditionally\n  // would append a spare block whenever `length + 9` is already a multiple of\n  // 64, which is a different message and therefore a different digest.\n  const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;\n  const padded = new Uint8Array(paddedLength);\n  padded.set(bytes);\n  padded[bytes.length] = 0x80;\n\n  // Written as two 32-bit halves rather than a BigInt: inputs never approach\n  // 2^32 bits (512 MiB), and the high word is always zero in practice, but\n  // emitting it keeps the block format exactly as specified.\n  const view = new DataView(padded.buffer);\n  view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000), false);\n  view.setUint32(paddedLength - 4, bitLength >>> 0, false);\n\n  const w = new Uint32Array(64);\n\n  for (let offset = 0; offset < paddedLength; offset += 64) {\n    for (let i = 0; i < 16; i += 1) {\n      w[i] = view.getUint32(offset + i * 4, false);\n    }\n    for (let i = 16; i < 64; i += 1) {\n      const s0 = rotr(w[i - 15]!, 7) ^ rotr(w[i - 15]!, 18) ^ (w[i - 15]! >>> 3);\n      const s1 = rotr(w[i - 2]!, 17) ^ rotr(w[i - 2]!, 19) ^ (w[i - 2]! >>> 10);\n      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) >>> 0;\n    }\n\n    let [a, b, c, d, e, f, g, h] = state as unknown as number[];\n\n    for (let i = 0; i < 64; i += 1) {\n      const S1 = rotr(e!, 6) ^ rotr(e!, 11) ^ rotr(e!, 25);\n      const ch = (e! & f!) ^ (~e! & g!);\n      const temp1 = (h! + S1 + ch + K[i]! + w[i]!) >>> 0;\n      const S0 = rotr(a!, 2) ^ rotr(a!, 13) ^ rotr(a!, 22);\n      const maj = (a! & b!) ^ (a! & c!) ^ (b! & c!);\n      const temp2 = (S0 + maj) >>> 0;\n\n      h = g;\n      g = f;\n      f = e;\n      e = (d! + temp1) >>> 0;\n      d = c;\n      c = b;\n      b = a;\n      a = (temp1 + temp2) >>> 0;\n    }\n\n    state[0] = (state[0]! + a!) >>> 0;\n    state[1] = (state[1]! + b!) >>> 0;\n    state[2] = (state[2]! + c!) >>> 0;\n    state[3] = (state[3]! + d!) >>> 0;\n    state[4] = (state[4]! + e!) >>> 0;\n    state[5] = (state[5]! + f!) >>> 0;\n    state[6] = (state[6]! + g!) >>> 0;\n    state[7] = (state[7]! + h!) >>> 0;\n  }\n\n  let hex = '';\n  for (const word of state) {\n    hex += word.toString(16).padStart(8, '0');\n  }\n  return hex;\n}\n\nfunction rotr(value: number, bits: number): number {\n  return ((value >>> bits) | (value << (32 - bits))) >>> 0;\n}\n\n/**\n * Encode as UTF-8 without `TextEncoder`.\n *\n * `TextEncoder` is available everywhere this runs today, but hand-encoding keeps\n * `core` free of *every* host global, not merely the Node ones — which is the\n * property that just failed to hold. Lone surrogates are encoded as U+FFFD, the\n * same substitution `TextEncoder` makes, so a malformed string cannot produce\n * two different digests on two runtimes.\n */\nfunction utf8Bytes(input: string): Uint8Array {\n  const bytes: number[] = [];\n\n  for (let i = 0; i < input.length; i += 1) {\n    let code = input.charCodeAt(i);\n\n    if (code >= 0xd800 && code <= 0xdbff) {\n      const next = input.charCodeAt(i + 1);\n      if (next >= 0xdc00 && next <= 0xdfff) {\n        code = 0x10000 + ((code - 0xd800) << 10) + (next - 0xdc00);\n        i += 1;\n      } else {\n        code = 0xfffd;\n      }\n    } else if (code >= 0xdc00 && code <= 0xdfff) {\n      code = 0xfffd;\n    }\n\n    if (code < 0x80) {\n      bytes.push(code);\n    } else if (code < 0x800) {\n      bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));\n    } else if (code < 0x10000) {\n      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));\n    } else {\n      bytes.push(\n        0xf0 | (code >> 18),\n        0x80 | ((code >> 12) & 0x3f),\n        0x80 | ((code >> 6) & 0x3f),\n        0x80 | (code & 0x3f),\n      );\n    }\n  }\n\n  return Uint8Array.from(bytes);\n}\n"]}

package/dist/format/snapshot.d.ts

@@ -0,0 +1,263 @@
+import type { SubjectRef, Rect, Diagnostic } from './capture.js';
+import type { EnvironmentKey } from './environment.js';
+import type { Digest } from './hash.js';
+import type { ObservationProfile } from './profile.js';
+import type { Provenance } from './provenance.js';
+import type { Wiring } from './wiring.js';
+import type { Holding } from './holding.js';
+/**
+ * The normalized semantic snapshot: the verdict's input, and the thing a render
+ * hash addresses.
+ *
+ * Everything volatile is gone by this point. Ids have become structural aliases,
+ * class attributes have been dropped entirely, inapplicable CSS has been pruned,
+ * and the cascade has been resolved to winning values (ADR-0003). What remains is
+ * meant to be *read*: a snapshot a reviewer refuses to open is a snapshot that
+ * gets rubber-stamped.
+ */
+export interface SemanticSnapshot {
+    readonly formatVersion: 1;
+    readonly subject: SubjectRef;
+    readonly profile: ObservationProfile;
+    readonly environment: EnvironmentKey;
+    /** Content hash of `root` under `environment`. The identity of this state. */
+    readonly renderHash: Digest;
+    /**
+     * Structure and applicable style, hashed separately.
+     *
+     * These back the tier below full semantic comparison (ADR-0003): matching both
+     * settles a subject without resolving layout or taking a screenshot. Split
+     * rather than combined because the docket wants to say *which* held — "the DOM
+     * is identical, only styling moved" is the sentence that turns a diff into a
+     * token-band root.
+     */
+    readonly structureHash: Digest;
+    readonly styleHash: Digest;
+    readonly root: SemanticNode;
+    /**
+     * Where each winning declaration came from. Deliberately outside the hash.
+     *
+     * Pruning discards exactly what attribution needs — *which rule set this?* — so
+     * it is preserved here instead. Keeping it out of the hash is the point: moving
+     * a rule between files renames a source without changing a render, and must not
+     * invalidate a baseline.
+     */
+    readonly styleProvenance: readonly StyleProvenanceEntry[];
+    /**
+     * Subtrees the operator declared out of scope, resolved against *this* tree.
+     *
+     * Deliberately outside the hash, for the reason `styleProvenance` is: an ignore
+     * changes what a run says about a render, never the render. Folding it into the
+     * identity would invalidate every baseline in the repository the first time
+     * somebody masked a clock, which is the surest way to make a safety feature the
+     * thing people turn off.
+     *
+     * Present only when something was excluded, so a snapshot from a run with no
+     * ignores is byte-identical to one produced before this field existed.
+     */
+    readonly ignoreSites?: readonly IgnoreSite[];
+    /**
+     * What the collector or the normalizer could not do, carried forward.
+     *
+     * Outside the hash: a diagnostic describes the *observation*, not the render,
+     * and a snapshot that hashed its own warnings would invalidate whenever the
+     * warning text was reworded. But it must survive to the verdict — a subject
+     * whose capture half-failed is not a subject that legitimately `unchanged`,
+     * and silently discarding that fact is how a broken collector reads as a clean
+     * build.
+     */
+    readonly diagnostics: readonly Diagnostic[];
+}
+/**
+ * A node's stable address: child indices from the root, e.g. `0/2/1`.
+ *
+ * Positional because nothing else survives. Ids are volatile (that is why they
+ * were aliased away), and class names have been dropped. Position is honest about
+ * what it costs: inserting a sibling renumbers everything after it, so the differ
+ * matches nodes by shape and provenance before falling back to path (see
+ * `diff.ts`), and treats a path change alone as evidence of nothing.
+ */
+export type NodePath = string;
+export interface SemanticNode {
+    readonly path: NodePath;
+    readonly tag: string;
+    /** Structural alias, e.g. `#a0`. Absent when the node carried no id. */
+    readonly alias?: string;
+    readonly role?: string;
+    readonly name?: string;
+    /**
+     * Accessible description, resolved. See `RawAria.description` for why this is
+     * a field of its own rather than an attribute.
+     */
+    readonly description?: string;
+    readonly state?: Readonly<Record<string, string | boolean | number>>;
+    /** Semantic attributes surviving normalization. `class` is never among them. */
+    readonly attributes: Readonly<Record<string, string>>;
+    /** Winning values for allowlisted properties, canonicalized. */
+    readonly style: Readonly<Record<string, string>>;
+    /**
+     * Custom properties this node's winning declarations resolved through, as
+     * name → resolved value.
+     *
+     * Recording the name alongside the value is what lets a design-token change
+     * surface as one root with counted collateral instead of hundreds of unrelated
+     * colour diffs (spec §5, `token` band).
+     */
+    readonly tokens?: Readonly<Record<string, string>>;
+    /**
+     * Which token each styled property resolved through, including by inheritance.
+     *
+     * Outside the hash, like `styleProvenance` and for the same reason: swapping a
+     * literal for a token of the same value renames a source without changing a
+     * render. It exists so the differ can tell *which* property a token edit
+     * explains — `tokens` alone says a node uses tokens, not which of its values
+     * one drove.
+     */
+    readonly styleTokens?: Readonly<Record<string, string>>;
+    /** Present only under a profile with layout. Absent, never zeroed (ADR-0002). */
+    readonly rect?: Rect;
+    /** Text content, or its digest when policy declares the region volatile. */
+    readonly text?: string;
+    readonly provenance?: Provenance;
+    /**
+     * How the framework holds this node's component, when a framework adapter
+     * supplied it. See {@link Wiring}.
+     *
+     * On the node rather than on `Provenance`, though both come from the same
+     * adapter and the same fiber, because they answer to different readers.
+     * Provenance exists so a diff arrives carrying a name; wiring is a *dimension
+     * of the subject*, hashed into a band of its own, and a band's inputs belong
+     * beside the other bands' inputs — next to `style` and `attributes`, which is
+     * where `shapeOf` goes looking.
+     */
+    readonly wiring?: Wiring;
+    /**
+     * What that component was holding. **Outside every hash**, always.
+     *
+     * The field beside it is the contrast worth reading: `wiring` is a band and
+     * this is evidence. `Wiring` refuses state values because a hook's value is
+     * exactly what may legitimately differ between two readings of one page, and
+     * that refusal is right and is not softened here — a `holding` reaches the
+     * snapshot and reaches no digest, so a subject whose clock ticked has the same
+     * `renderHash` it had before this field existed.
+     *
+     * It rides outside on the same terms as `styleProvenance`, `styleTokens` and
+     * `ignoredBy`, by the same mechanism: `structureOf`, `styleOf` and `shapeOf`
+     * project the fields they hash **by name**, so a field none of them names
+     * cannot reach an identity. `holding.hash.test.ts` asserts that rather than
+     * trusting it, because the cost of being wrong is every baseline in a
+     * repository invalidating the first time a component held a timestamp.
+     */
+    readonly holding?: Holding;
+    /**
+     * `true` on the root of a subtree rendered through a portal.
+     *
+     * Recorded in the structure hash so that "the dialog moved from inline to
+     * portalled" is a change rather than a coincidence of identical content, and
+     * so the docket can say *where* something rendered, not only that it exists.
+     */
+    readonly portalled?: boolean;
+    /**
+     * Ignore rules this node was found under. Outside every hash, like its origin
+     * on `RawNode`. See {@link SemanticSnapshot.ignoreSites}.
+     */
+    readonly ignoredBy?: readonly string[];
+    readonly children: readonly SemanticNode[];
+}
+/**
+ * A subtree the operator excluded, resolved to a path and a box (spec 0024).
+ *
+ * Lives in `format` rather than beside the rules that consume it, because it is
+ * part of what a snapshot *is*: the collector produced it, it travels with the
+ * document over every wire this project has, and `core/judge` is only its first
+ * reader. A type the wire format needs cannot live in the policy layer.
+ */
+export interface IgnoreSite {
+    /** Root of the excluded subtree, in this snapshot's own path space. */
+    readonly path: NodePath;
+    /** Which rule put it here, matched exactly against `IgnoreRule.id`. */
+    readonly rule: string;
+    /**
+     * The box it occupied, for the raster tier.
+     *
+     * Absent under a profile with no layout — which is ADR-0002 rather than a
+     * failure: a profile that cannot measure a box cannot decide pixels either, so
+     * there is nothing for the box to subtract from.
+     */
+    readonly rect?: Rect;
+}
+/**
+ * A component's own content, hashed per band (ADR-0018).
+ *
+ * In `format` rather than beside `hashComponents`, which computes it, because a
+ * baseline carries these: a stored image plus the component hashes of the
+ * document that painted it is what lets a later run tell the component that
+ * *caused* a change from the components the change merely moved. That makes this
+ * part of the wire format every store and every transport has to preserve, and a
+ * type the wire needs cannot live in the layer that derives it.
+ */
+export interface ComponentHash {
+    readonly component: string;
+    /** Boundaries of this component in the subject, counted in document order. */
+    readonly instances: number;
+    /**
+     * Tree shape: tags, structural aliases, portalling, allowlisted attributes,
+     * and which child boundaries sit where. The `geometry` band's structural half.
+     *
+     * **Split out of a single `structure` digest on 2026-08-06.** It used to carry
+     * the accessible semantics and the text too, and the fusion was invisible
+     * until something needed to ask *which band moved* — at which point a baseline
+     * could say "this component changed" and never say whether a heading was
+     * renamed, a paragraph reworded, or a node inserted. Those are three different
+     * bands, three different readers, and one of them is the band a route-level
+     * test exists to ignore.
+     */
+    readonly structure: Digest;
+    /**
+     * Role, accessible name, and ARIA state. The `a11y` band.
+     *
+     * Its own digest because it is the band that must never be absorbed. Every
+     * sensitivity level asserts on it, including the ones that ignore everything
+     * else — and a level cannot assert on a band that is fused into another one.
+     */
+    readonly semantics: Digest;
+    /** Text runs, in document order. The `content` band. */
+    readonly text: Digest;
+    readonly style: Digest;
+    /**
+     * Absent under a profile without layout — absent, never empty (ADR-0002).
+     *
+     * An empty geometry digest would compare equal between a run that observed no
+     * movement and a run that could not observe movement at all, which is the
+     * false `unchanged` this system must never produce.
+     */
+    readonly geometry?: Digest;
+    /**
+     * The box each instance occupies, in document order. Never hashed.
+     *
+     * A digest can say a component is not what it was and can never say by how
+     * much. That is the gap a reviewer falls into: `Button — geometry, token` is
+     * true of a control that lost a shadow and of one that grew eight pixels and
+     * pushed the page down, and only the second explains why the subject is a
+     * different height. Four numbers per instance close it.
+     *
+     * Absent for a baseline written before this existed and for a profile with no
+     * layout — the same absence, and both mean *nobody measured*, never *it did
+     * not move*. A `null` entry is a boundary the browser laid out nothing for,
+     * kept in place so the list stays parallel to the instances it counts.
+     */
+    readonly boxes?: readonly (Rect | null)[];
+}
+export interface StyleProvenanceEntry {
+    readonly path: NodePath;
+    readonly property: string;
+    readonly sheet: string;
+    /** Generated segments replaced by placeholders, so it can name a root safely. */
+    readonly selector: string;
+    readonly tokenName?: string;
+    readonly source?: {
+        readonly file: string;
+        readonly line: number;
+    };
+}
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/format/snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot.js.map

package/dist/format/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../src/format/snapshot.ts"],"names":[],"mappings":"","sourcesContent":["import type { SubjectRef, Rect, Diagnostic } from './capture.js';\nimport type { EnvironmentKey } from './environment.js';\nimport type { Digest } from './hash.js';\nimport type { ObservationProfile } from './profile.js';\nimport type { Provenance } from './provenance.js';\nimport type { Wiring } from './wiring.js';\nimport type { Holding } from './holding.js';\n\n/**\n * The normalized semantic snapshot: the verdict's input, and the thing a render\n * hash addresses.\n *\n * Everything volatile is gone by this point. Ids have become structural aliases,\n * class attributes have been dropped entirely, inapplicable CSS has been pruned,\n * and the cascade has been resolved to winning values (ADR-0003). What remains is\n * meant to be *read*: a snapshot a reviewer refuses to open is a snapshot that\n * gets rubber-stamped.\n */\nexport interface SemanticSnapshot {\n  readonly formatVersion: 1;\n  readonly subject: SubjectRef;\n  readonly profile: ObservationProfile;\n  readonly environment: EnvironmentKey;\n\n  /** Content hash of `root` under `environment`. The identity of this state. */\n  readonly renderHash: Digest;\n\n  /**\n   * Structure and applicable style, hashed separately.\n   *\n   * These back the tier below full semantic comparison (ADR-0003): matching both\n   * settles a subject without resolving layout or taking a screenshot. Split\n   * rather than combined because the docket wants to say *which* held — \"the DOM\n   * is identical, only styling moved\" is the sentence that turns a diff into a\n   * token-band root.\n   */\n  readonly structureHash: Digest;\n  readonly styleHash: Digest;\n\n  readonly root: SemanticNode;\n\n  /**\n   * Where each winning declaration came from. Deliberately outside the hash.\n   *\n   * Pruning discards exactly what attribution needs — *which rule set this?* — so\n   * it is preserved here instead. Keeping it out of the hash is the point: moving\n   * a rule between files renames a source without changing a render, and must not\n   * invalidate a baseline.\n   */\n  readonly styleProvenance: readonly StyleProvenanceEntry[];\n\n  /**\n   * Subtrees the operator declared out of scope, resolved against *this* tree.\n   *\n   * Deliberately outside the hash, for the reason `styleProvenance` is: an ignore\n   * changes what a run says about a render, never the render. Folding it into the\n   * identity would invalidate every baseline in the repository the first time\n   * somebody masked a clock, which is the surest way to make a safety feature the\n   * thing people turn off.\n   *\n   * Present only when something was excluded, so a snapshot from a run with no\n   * ignores is byte-identical to one produced before this field existed.\n   */\n  readonly ignoreSites?: readonly IgnoreSite[];\n\n  /**\n   * What the collector or the normalizer could not do, carried forward.\n   *\n   * Outside the hash: a diagnostic describes the *observation*, not the render,\n   * and a snapshot that hashed its own warnings would invalidate whenever the\n   * warning text was reworded. But it must survive to the verdict — a subject\n   * whose capture half-failed is not a subject that legitimately `unchanged`,\n   * and silently discarding that fact is how a broken collector reads as a clean\n   * build.\n   */\n  readonly diagnostics: readonly Diagnostic[];\n}\n\n/**\n * A node's stable address: child indices from the root, e.g. `0/2/1`.\n *\n * Positional because nothing else survives. Ids are volatile (that is why they\n * were aliased away), and class names have been dropped. Position is honest about\n * what it costs: inserting a sibling renumbers everything after it, so the differ\n * matches nodes by shape and provenance before falling back to path (see\n * `diff.ts`), and treats a path change alone as evidence of nothing.\n */\nexport type NodePath = string;\n\nexport interface SemanticNode {\n  readonly path: NodePath;\n  readonly tag: string;\n\n  /** Structural alias, e.g. `#a0`. Absent when the node carried no id. */\n  readonly alias?: string;\n\n  readonly role?: string;\n  readonly name?: string;\n\n  /**\n   * Accessible description, resolved. See `RawAria.description` for why this is\n   * a field of its own rather than an attribute.\n   */\n  readonly description?: string;\n\n  readonly state?: Readonly<Record<string, string | boolean | number>>;\n\n  /** Semantic attributes surviving normalization. `class` is never among them. */\n  readonly attributes: Readonly<Record<string, string>>;\n\n  /** Winning values for allowlisted properties, canonicalized. */\n  readonly style: Readonly<Record<string, string>>;\n\n  /**\n   * Custom properties this node's winning declarations resolved through, as\n   * name → resolved value.\n   *\n   * Recording the name alongside the value is what lets a design-token change\n   * surface as one root with counted collateral instead of hundreds of unrelated\n   * colour diffs (spec §5, `token` band).\n   */\n  readonly tokens?: Readonly<Record<string, string>>;\n\n  /**\n   * Which token each styled property resolved through, including by inheritance.\n   *\n   * Outside the hash, like `styleProvenance` and for the same reason: swapping a\n   * literal for a token of the same value renames a source without changing a\n   * render. It exists so the differ can tell *which* property a token edit\n   * explains — `tokens` alone says a node uses tokens, not which of its values\n   * one drove.\n   */\n  readonly styleTokens?: Readonly<Record<string, string>>;\n\n  /** Present only under a profile with layout. Absent, never zeroed (ADR-0002). */\n  readonly rect?: Rect;\n\n  /** Text content, or its digest when policy declares the region volatile. */\n  readonly text?: string;\n\n  readonly provenance?: Provenance;\n\n  /**\n   * How the framework holds this node's component, when a framework adapter\n   * supplied it. See {@link Wiring}.\n   *\n   * On the node rather than on `Provenance`, though both come from the same\n   * adapter and the same fiber, because they answer to different readers.\n   * Provenance exists so a diff arrives carrying a name; wiring is a *dimension\n   * of the subject*, hashed into a band of its own, and a band's inputs belong\n   * beside the other bands' inputs — next to `style` and `attributes`, which is\n   * where `shapeOf` goes looking.\n   */\n  readonly wiring?: Wiring;\n\n  /**\n   * What that component was holding. **Outside every hash**, always.\n   *\n   * The field beside it is the contrast worth reading: `wiring` is a band and\n   * this is evidence. `Wiring` refuses state values because a hook's value is\n   * exactly what may legitimately differ between two readings of one page, and\n   * that refusal is right and is not softened here — a `holding` reaches the\n   * snapshot and reaches no digest, so a subject whose clock ticked has the same\n   * `renderHash` it had before this field existed.\n   *\n   * It rides outside on the same terms as `styleProvenance`, `styleTokens` and\n   * `ignoredBy`, by the same mechanism: `structureOf`, `styleOf` and `shapeOf`\n   * project the fields they hash **by name**, so a field none of them names\n   * cannot reach an identity. `holding.hash.test.ts` asserts that rather than\n   * trusting it, because the cost of being wrong is every baseline in a\n   * repository invalidating the first time a component held a timestamp.\n   */\n  readonly holding?: Holding;\n\n  /**\n   * `true` on the root of a subtree rendered through a portal.\n   *\n   * Recorded in the structure hash so that \"the dialog moved from inline to\n   * portalled\" is a change rather than a coincidence of identical content, and\n   * so the docket can say *where* something rendered, not only that it exists.\n   */\n  readonly portalled?: boolean;\n\n  /**\n   * Ignore rules this node was found under. Outside every hash, like its origin\n   * on `RawNode`. See {@link SemanticSnapshot.ignoreSites}.\n   */\n  readonly ignoredBy?: readonly string[];\n\n  readonly children: readonly SemanticNode[];\n}\n\n/**\n * A subtree the operator excluded, resolved to a path and a box (spec 0024).\n *\n * Lives in `format` rather than beside the rules that consume it, because it is\n * part of what a snapshot *is*: the collector produced it, it travels with the\n * document over every wire this project has, and `core/judge` is only its first\n * reader. A type the wire format needs cannot live in the policy layer.\n */\nexport interface IgnoreSite {\n  /** Root of the excluded subtree, in this snapshot's own path space. */\n  readonly path: NodePath;\n\n  /** Which rule put it here, matched exactly against `IgnoreRule.id`. */\n  readonly rule: string;\n\n  /**\n   * The box it occupied, for the raster tier.\n   *\n   * Absent under a profile with no layout — which is ADR-0002 rather than a\n   * failure: a profile that cannot measure a box cannot decide pixels either, so\n   * there is nothing for the box to subtract from.\n   */\n  readonly rect?: Rect;\n}\n\n/**\n * A component's own content, hashed per band (ADR-0018).\n *\n * In `format` rather than beside `hashComponents`, which computes it, because a\n * baseline carries these: a stored image plus the component hashes of the\n * document that painted it is what lets a later run tell the component that\n * *caused* a change from the components the change merely moved. That makes this\n * part of the wire format every store and every transport has to preserve, and a\n * type the wire needs cannot live in the layer that derives it.\n */\nexport interface ComponentHash {\n  readonly component: string;\n\n  /** Boundaries of this component in the subject, counted in document order. */\n  readonly instances: number;\n\n  /**\n   * Tree shape: tags, structural aliases, portalling, allowlisted attributes,\n   * and which child boundaries sit where. The `geometry` band's structural half.\n   *\n   * **Split out of a single `structure` digest on 2026-08-06.** It used to carry\n   * the accessible semantics and the text too, and the fusion was invisible\n   * until something needed to ask *which band moved* — at which point a baseline\n   * could say \"this component changed\" and never say whether a heading was\n   * renamed, a paragraph reworded, or a node inserted. Those are three different\n   * bands, three different readers, and one of them is the band a route-level\n   * test exists to ignore.\n   */\n  readonly structure: Digest;\n\n  /**\n   * Role, accessible name, and ARIA state. The `a11y` band.\n   *\n   * Its own digest because it is the band that must never be absorbed. Every\n   * sensitivity level asserts on it, including the ones that ignore everything\n   * else — and a level cannot assert on a band that is fused into another one.\n   */\n  readonly semantics: Digest;\n\n  /** Text runs, in document order. The `content` band. */\n  readonly text: Digest;\n\n  readonly style: Digest;\n\n  /**\n   * Absent under a profile without layout — absent, never empty (ADR-0002).\n   *\n   * An empty geometry digest would compare equal between a run that observed no\n   * movement and a run that could not observe movement at all, which is the\n   * false `unchanged` this system must never produce.\n   */\n  readonly geometry?: Digest;\n\n  /**\n   * The box each instance occupies, in document order. Never hashed.\n   *\n   * A digest can say a component is not what it was and can never say by how\n   * much. That is the gap a reviewer falls into: `Button — geometry, token` is\n   * true of a control that lost a shadow and of one that grew eight pixels and\n   * pushed the page down, and only the second explains why the subject is a\n   * different height. Four numbers per instance close it.\n   *\n   * Absent for a baseline written before this existed and for a profile with no\n   * layout — the same absence, and both mean *nobody measured*, never *it did\n   * not move*. A `null` entry is a boundary the browser laid out nothing for,\n   * kept in place so the list stays parallel to the instances it counts.\n   */\n  readonly boxes?: readonly (Rect | null)[];\n}\n\nexport interface StyleProvenanceEntry {\n  readonly path: NodePath;\n  readonly property: string;\n  readonly sheet: string;\n  /** Generated segments replaced by placeholders, so it can name a root safely. */\n  readonly selector: string;\n  readonly tokenName?: string;\n  readonly source?: { readonly file: string; readonly line: number };\n}\n"]}

package/dist/format/stabilize.d.ts

@@ -0,0 +1,190 @@
+import { type Digest } from './hash.js';
+import { type Tier } from './tier.js';
+import type { Intervention, ScreenshotOptions, SettleTarget } from './intervention.js';
+/**
+ * Interventions as separate, nameable tricks — not a fixed set of switches.
+ *
+ * A subject that is still changing cannot be compared, so every system of this
+ * kind reaches into the page: it holds animations, waits for fonts, hides a
+ * caret, suppresses scrollbars. Written as one struct of booleans that becomes a
+ * closed vocabulary: adding a trick edits a type every caller depends on, and a
+ * project with a need nobody anticipated has to fork.
+ *
+ * So each is a value. It carries an id, the tier that can actually observe what
+ * it fixes, what it costs, and how it is applied — and a *recipe* is any list of
+ * them. Two tricks may express the same intent through different mechanisms and
+ * remain separate values, because they produce different images and choosing
+ * between them is the caller's business.
+ *
+ * ## What this buys
+ *
+ * A recipe can be filtered by tier, so the structure-and-style rung waits for
+ * nothing; composed from another project's tricks alongside these; digested, so
+ * a baseline made under one recipe is `incomparable` with a run made under
+ * another rather than `changed`; and checked for tricks that fight each other.
+ *
+ * ## Where the damage lands
+ *
+ * Ordered by increasing cost, earliest sufficient option first:
+ *
+ * - **Outside the subject** — injected CSS, browser screenshot options. Nothing
+ *   in the product imports it and deleting the tool deletes the intervention.
+ * - **Runtime substitution** — wrapping `Promise`, replacing a suspense
+ *   boundary. Buys the same knowledge without touching a component and is
+ *   deliberately not shipped here: it moves the damage from design into
+ *   semantics, where a difference caused by the patch cannot be told apart from
+ *   a difference caused by the code. Expressible as a trick if a project decides
+ *   the trade is worth it — that is the point of an open set.
+ * - **A contract the subject implements** — a readiness marker. Real design
+ *   damage, and reserved for what the outside genuinely cannot know.
+ *
+ * ## Why this is in `format` and not in the raster package
+ *
+ * It was in `@variance-authority/raster` until 2026-08-06, on the reading that
+ * holding a page still is something you do before you photograph it. That
+ * reading was wrong in a way that cost correctness: an animation in flight is a
+ * *computed style value*, so it reaches the cheap representation too — and the
+ * allowlist excludes `animation-*` and `transition-*` precisely because it
+ * assumed a snapshot is taken with animation already disabled. Nothing disabled
+ * it. See {@link COLLECT_RECIPE} and ADR-0028.
+ *
+ * So a recipe is a render input on every tier, `EnvironmentInputs` carries its
+ * digest, and the vocabulary belongs beside the key it is part of.
+ */
+export type { Intervention, ScreenshotOptions, SettleTarget, Trick } from './intervention.js';
+/**
+ * Hand animations to the browser rather than emulating the hold in CSS.
+ *
+ * A browser disabling animations for a screenshot fast-forwards a finite
+ * animation to completion — the state a user comes to rest on — and cancels an
+ * infinite one to its initial frame, replaying it afterwards. That is the
+ * behaviour worth having, and CSS cannot express it.
+ */
+export declare const holdAnimations: Intervention;
+/**
+ * The same intent without a browser that can do it, and it is not equivalent.
+ *
+ * Pins every animation at its first frame, so a fade-in is captured at the
+ * moment it is invisible. `animation: none` is avoided deliberately — removing
+ * an animation drops whatever layout its keyframes contribute, which changes the
+ * page rather than stopping it.
+ */
+export declare const pinAnimations: Intervention;
+export declare const hideCaret: Intervention;
+export declare const hideScrollbars: Intervention;
+/**
+ * Drop the pixels of images the page itself called decorative, keeping their boxes.
+ *
+ * The other half of blanking, and it lives here because of what it needs to
+ * know. A driver rewriting responses (`@variance-authority/playwright`'s
+ * `blank` rules) can decide by URL and by intrinsic size, which answers "every
+ * illustration over 40,000 pixels" and answers it before the bytes are even
+ * fetched. It cannot answer `role="presentation"`, because a request carries no
+ * idea which element wanted it — that fact exists only in the document, so the
+ * trick that uses it is a stylesheet.
+ *
+ * `visibility:hidden` rather than `display:none`, and the distinction is the
+ * entire design: a hidden element still occupies exactly the box it would have,
+ * so a page whose column height comes from an image's intrinsic size is
+ * unchanged. `display:none` would collapse it and report a layout regression
+ * this tool caused.
+ *
+ * **Opt-in, and it belongs in no default recipe.** Every other trick here
+ * removes something that is not part of the assertion — a caret, a scrollbar, an
+ * animation mid-flight. This one removes page content, which is a judgement
+ * about what a suite is for, and a default that quietly stopped watching every
+ * `alt=""` image would hide real regressions under a green run.
+ */
+export declare const hidePresentationalImages: Intervention;
+export declare const waitForFonts: Intervention;
+export declare const waitForImages: Intervention;
+export declare const INTERVENTIONS: readonly Intervention[];
+export type Recipe = readonly Intervention[];
+/**
+ * Nothing at all, and correct for the tier that reads structure and declared style.
+ *
+ * A font that has not loaded cannot change which rules match or what they
+ * declare; an image that has not decoded cannot either. Waiting for both before
+ * a structure-and-style hash buys nothing and costs the wait per subject, on the
+ * rung the tier ladder exists to make cheap.
+ */
+export declare const SEMANTIC_RECIPE: Recipe;
+export declare const LAYOUT_RECIPE: Recipe;
+export declare const RASTER_RECIPE: Recipe;
+/**
+ * What is applied to a live page *before a subject is observed*, as opposed to
+ * before it is painted.
+ *
+ * The two are different recipes and it is not a preference. {@link
+ * holdAnimations} is a *screenshot option* — it asks the browser to settle
+ * animations for the image it is about to take — and there is no screenshot at
+ * collection time, so it would be a trick that silently does nothing. The CSS
+ * variant is the one that works where nobody is holding a camera, which is the
+ * whole reason both exist as separate values rather than as one switch.
+ *
+ * ## Why the cheap tier needs this at all
+ *
+ * The claim in [`ruleset.ts`](../rules/ruleset.ts) that `transition-*` and
+ * `animation-*` "describe a journey the snapshot does not contain" is only true
+ * if the snapshot is taken with the journey stopped. `transform`, `opacity`,
+ * `filter`, `color` and every geometric longhand *are* admitted, and an
+ * animation in flight moves all of them — so an unstabilized collection turns a
+ * 300ms fade into a component-attributed regression with a real file name on it,
+ * which is worse than an unexplained pixel diff because it is credible.
+ *
+ * Filtered by {@link forTier}, so jsdom applies none of it: with no layout
+ * engine and no animation clock there is nothing to hold still, and paying a
+ * `fonts.ready` wait per subject on the rung that exists to be cheap is exactly
+ * the trade {@link SEMANTIC_RECIPE} refuses.
+ */
+export declare const COLLECT_RECIPE: Recipe;
+/**
+ * Resolve a trick by the name a caller wrote down.
+ *
+ * The boundary a collection recipe crosses is a `page.evaluate`, and an
+ * `Intervention` does not survive it — `settle` is a function. Ids do survive,
+ * and the page holds this same registry, so a recipe travels as the list of
+ * names it is. A name nothing answers to is a caller error worth failing on
+ * rather than a trick to skip quietly: under-stabilizing is how a suite gets a
+ * flake it has already paid to prevent.
+ */
+export declare function interventionById(id: string): Intervention | undefined;
+/**
+ * A recipe from the names it travels as.
+ *
+ * Throws on a name nothing answers to, and names it. The quiet alternative —
+ * skip what cannot be resolved — turns a typo in a config into a suite that is
+ * one trick less stable than its operator believes, discovered later as a flake
+ * they have already paid to prevent. Failing here costs one run and one reading
+ * of the message.
+ */
+export declare function recipeOf(ids: readonly string[]): Recipe;
+/** Only the tricks a tier can observe the effect of. */
+export declare function forTier(recipe: Recipe, tier: Tier): Recipe;
+/**
+ * Tricks in a recipe that claim the same property.
+ *
+ * Returned rather than thrown, so a caller can decide — an override is a
+ * legitimate composition, and silently applying both is not. Two tricks over one
+ * property means one of them wins by accident of ordering, and which one is
+ * invisible in the result.
+ */
+export declare function conflicts(recipe: Recipe): readonly {
+    governs: string;
+    ids: readonly string[];
+}[];
+export declare function recipeCss(recipe: Recipe): string;
+export declare function recipeScreenshot(recipe: Recipe): ScreenshotOptions;
+export declare function settleRecipe(recipe: Recipe, target: SettleTarget): Promise<void>;
+/**
+ * The identity of a recipe.
+ *
+ * Sorted, so the order tricks were composed in does not change the identity —
+ * only which ones are present. Folded into `RenderIdentity`, which is what makes
+ * a cross-recipe comparison report `incomparable` instead of inventing a
+ * component to blame.
+ */
+export declare function recipeDigest(recipe: Recipe): Digest;
+/** The recipe as a sentence, so the gap between image and product stays visible. */
+export declare function describeRecipe(recipe: Recipe): string;
+//# sourceMappingURL=stabilize.d.ts.map