@hueest/xray 0.1.0 → 0.3.0

package/dist/plate-BIr62u7l.d.ts

@@ -0,0 +1,363 @@
+//#region src/diagnostics.d.ts
+/**
+ * Dev-only capture diagnostics: a small, serializable record of why a Plate may
+ * be incomplete or lower-fidelity, plus the one shared formatter both the
+ * browser console (`client.ts`) and the Vite server output (`index.ts`) print.
+ *
+ * Motivation: the serializer silently swallows a handful of capture omissions
+ * (an unreadable cross-origin stylesheet, skipped pseudo-elements, off-screen
+ * bones dropped at the fold, an over-the-limit subtree). Early adopters asking "why does this
+ * skeleton look wrong?" had to read the serializer source to find out. These
+ * diagnostics surface those omissions as data the capture process returns, so a
+ * caller can log them — without the core performing any console side effects.
+ *
+ * Strictly DEV-ONLY (see the plan's decisions and ADR 0008): this type is NOT a
+ * public package export and MUST NEVER reach the persisted Plate JSON, the
+ * `MergedPlate`, or the production adapter. It rides on the TRANSIENT
+ * `ViewIR.diagnostics` field only, which `captureView` populates and the
+ * dev client strips before posting (so committed `plates/<name>.json` stays
+ * byte-identical to a capture that produced no diagnostics).
+ *
+ * Centralized on purpose: a follow-up plan (capture-input-validation) reuses
+ * this same messaging for invalid posted/committed plates, so the code table
+ * and formatter are kept reusable. Browser and server share `formatDiagnostic`
+ * so their warning text cannot drift.
+ *
+ * @module
+ */
+/**
+ * One aggregated capture omission. Serializable on purpose: NO DOM nodes, NO
+ * CSS bodies, NO captured text — only a stable `code`, a human message, an
+ * optional aggregate `count`, and an optional short `detail` (e.g. a plate name
+ * or a node count, never user content). `count` aggregates occurrences: there
+ * is at most one record per code per capture, never one per skipped selector or
+ * node.
+ */
+interface CaptureDiagnostic {
+  code: DiagnosticCode;
+  message: string;
+  count?: number;
+  detail?: string;
+}
+/**
+ * The closed set of capture-omission codes. Each maps to one silent site in the
+ * serializer (or an existing oversized-capture warning folded into the same
+ * vocabulary). Kept as a const union so the message table is exhaustive.
+ */
+type DiagnosticCode = 'unreadable-stylesheet' | 'unreadable-import' | 'skipped-dynamic-pseudo' | 'skipped-pseudo-element' | 'unsupported-rule' | 'dropped-tag' | 'dropped-subset' | 'dropped-cropped' | 'too-large' | 'invalid-plate-file';
+//#endregion
+//#region src/plate.d.ts
+type LeafKind = 'text' | 'text-block' | 'media' | 'box';
+/**
+ * The shipped structural capture of a component's rendered DOM — the data a
+ * Skeleton renders from (see CONTEXT.md). Self-contained: pre-serialized chunks
+ * plus one scoped CSS string; depends on nothing in the consumer's build (ADR
+ * 0003). Built from the RenderNode tree at plugin load (see chunk.ts), so the
+ * adapter injects strings instead of walking a tree on the latency-critical
+ * first paint — and no per-framework serializer ships to the client (ADR 0008).
+ */
+interface Plate {
+  v: number;
+  /** Capture name; comes from the virtual-module specifier, never typed at a call site. */
+  name: string;
+  /**
+   * The root's children, pre-serialized (ADR 0008): a stitch-free run is one
+   * HTML `string`; a stitch is `{ r: name }`; a stitch-bearing element is
+   * `{ c: className, k: chunk[] }`. Null until first capture.
+   */
+  chunks: Chunk[] | null;
+  /** The root node's own content classes (its inherited font context), if any. */
+  rootCls?: string;
+  /** Layout-relevant CSS (incl. `@media`) scoped under the plate root, paint stripped. */
+  css: string;
+  /**
+   * Child plates named by the chunks' `{ r }` stitches, resolved through the
+   * import graph (ADR 0006). Populated by the loader's generated imports, never
+   * serialized into the plates JSON; absent in production when there are no
+   * stitches. In dev the live store takes precedence, so this need not be present.
+   */
+  refs?: Record<string, Plate>;
+}
+/**
+ * One serialized child of a plate root (or of a stitch-bearing node): a
+ * stitch-free HTML run (`string`), a stitch to a child plate (`{ r: name }`),
+ * a stitch-bearing element kept real so its inner stitches can mount
+ * (`{ c: className, k: chunk[] }`), or a templated uniform run (`{ t: html, n }`):
+ * the cell's HTML once plus a repeat count the adapter expands to N copies (Phase
+ * 2). The framework-neutral render contract: an adapter injects the strings,
+ * mounts a child plate at each stitch, and repeats each template (ADR 0008).
+ */
+type Chunk = string | {
+  r: string;
+} | {
+  c: string;
+  k: Chunk[];
+} | {
+  t: string;
+  n: number;
+};
+/**
+ * A plate after the in-browser Serialize (emit + merge/gate + classify) but
+ * before chunk serialization: the build-time RenderNode tree plus its scoped
+ * CSS. Produced by `serializePlateIR` (the structural part of `StoredPlate`) and
+ * the single-View `capture`, then serialized into the shipped `Plate` (chunks) at
+ * load (`serializePlate`). Never shipped to the client.
+ */
+interface MergedPlate {
+  v: number;
+  name: string;
+  tree: RenderNode | null;
+  css: string;
+}
+interface PlateNode {
+  /** Plate-local id; rules reference it pre-classify. Stripped from the shipped tree. */
+  id: number;
+  /** Present on paint leaves; absent on layout containers. */
+  leaf?: LeafKind;
+  /**
+   * A stitch: render the named child plate's skeleton here instead of own
+   * structure (ADR 0006). Mutually exclusive with `leaf`/`kids`. Resolved
+   * against `Plate.refs` (prod) or the live store (dev).
+   */
+  ref?: string;
+  /**
+   * A templated uniform run (Phase 2): render this node's subtree `count` times.
+   * The serializer emits the subtree's HTML once plus the count; the adapter
+   * expands it to N copies at render. Absent on ordinary nodes.
+   */
+  count?: number;
+  kids?: PlateNode[];
+}
+/**
+ * A node in the shipped tree, after classify (ADR 0007). Carries the
+ * content-addressed style classes it needs instead of an id — the CSS targets
+ * those classes, not a per-node `data-xr` value, so node scoping (the old
+ * `nodeKey`) is gone. `cls` is a space-joined class-token list.
+ */
+interface RenderNode {
+  leaf?: LeafKind;
+  ref?: string;
+  cls?: string;
+  /** A templated uniform run (Phase 2): serialize this subtree once + a count the adapter repeats. */
+  count?: number;
+  kids?: RenderNode[];
+}
+/**
+ * A captured style rule in id form — selectors are generated at render time,
+ * so view merging can remap node ids without string surgery. `ids: []`
+ * targets the plate root.
+ */
+interface PlateRule {
+  ids: number[];
+  decls: string[];
+  /** Media-condition stack, outermost first; conditions AND together. */
+  media?: string[];
+  /** `@container`-condition stack, outermost first; conditions AND together. Absent when none. */
+  container?: string[];
+  layered?: boolean;
+  spec: number;
+  order: number;
+}
+/**
+ * One capture of a component within one viewport view — `[min, max)` in px,
+ * either side open-ended when undefined. The id-form `{ tree, rules }` shape
+ * `emit` projects a measured View into (ADR 0004). NO LONGER the disk/wire shape
+ * after the ADR 0022 cutover — `StoredPlate` (below) is. Kept as the
+ * framework-neutral per-View capture shape, exported for consumers reading the
+ * id-form projection directly.
+ */
+interface ViewCapture {
+  /** Viewport width at capture time. */
+  width: number;
+  min?: number;
+  max?: number;
+  tree: PlateNode;
+  rules: PlateRule[];
+  /**
+   * TRANSIENT, dev-only capture diagnostics (why this view may be lower
+   * fidelity). Captured in the browser (mirrored onto `ViewIR.diagnostics`); the
+   * dev client logs it and posts it alongside the `StoredPlate` (so the Vite
+   * server can print the same text). It MUST NEVER be persisted: it is not part
+   * of the committed
+   * `StoredPlate` disk shape, the validator does not carry it, and the POST
+   * envelope keeps it in a SIBLING field that never reaches the stored artifact
+   * (ADR 0008). Absent in production (the prod adapter ships no capture). See
+   * diagnostics.ts and ADR 0008.
+   */
+  diagnostics?: CaptureDiagnostic[];
+}
+/**
+ * The committed `plates/<name>.json` shape AFTER the ADR 0022 cutover: the whole
+ * Plate already projected in the browser (the in-browser Serialize folds emit +
+ * the multi-View merge/gate + classify in one session), so disk holds ONE gated,
+ * content-addressed tree + css instead of per-View captures merged at load. It is
+ * a `MergedPlate` (the structural `{tree, css}` `serializePlate` consumes) PLUS the
+ * `breakpoints` the HUD coverage reads — the analysis-only geometry never crosses
+ * the wire (ADR 0021). The gen-side runs `serializePlate(stored) → Plate` (chunks)
+ * at module-load, leaving the Tailwind/Bundle passthrough a clean gen-side seam.
+ * Replaces `PlateFile` (+ `ViewCapture`) on disk and on the `/__xray` wire.
+ */
+interface StoredPlate extends MergedPlate {
+  /** Width thresholds (view boundaries); the HUD coverage derives its bands from these. */
+  breakpoints: number[];
+}
+/** The (unserialized) plate an import resolves to before anything has been captured. */
+declare function emptyPlate(name: string): MergedPlate;
+/**
+ * A dev-only sticky boolean toggle (get/set/subscribe), persisted per tab.
+ * Used for both "light box" (render every `<Skeleton>` regardless of readiness)
+ * and "capture" (whether browsing re-captures plates).
+ */
+interface ToggleStore {
+  get: () => boolean;
+  set: (value: boolean) => void;
+  subscribe: (onChange: () => void) => () => void;
+}
+/**
+ * Dev-only store of the freshest plate per name, updated in place when a
+ * capture lands. `<Skeleton>` reads through it so a new plate re-renders the
+ * site rather than reloading the module — which would remount the capture
+ * boundary and re-fire the capture, a feedback loop.
+ */
+interface PlateStore {
+  get: (name: string) => Plate | undefined;
+  subscribe: (name: string, onChange: () => void) => () => void;
+  /**
+   * Register a plate imported via the ref graph if the store has none yet — so a
+   * stitch resolves even before its child is re-captured, and survives a parent
+   * hot-swap (whose pushed plate carries no resolved `refs`). Never overwrites a
+   * live capture.
+   */
+  seed: (name: string, plate: Plate) => void;
+}
+/** A view interval `[min, max)`; an open end is undefined (ADR 0004). */
+interface Span {
+  min?: number;
+  max?: number;
+}
+/**
+ * Dev-only Fixture store (ADR 0015): stored render-INPUT `data` per Plate,
+ * recorded to and replayed from a `plates/<name>.fixture.json` sidecar. Entirely
+ * dev-only — devalue and this store never reach the production bundle.
+ *
+ * Two cooperating halves, both flowing through the render-prop `data` seam (ADR
+ * 0014):
+ * - The dev adapter (`react.dev.tsx`) calls `register(name, data)` at
+ *   `loading=false` with the live `data` it is about to render, so the latest
+ *   recordable input for each mounted Plate is always in scope for Record.
+ * - `record(name)` serializes that registered live `data` with devalue and POSTs
+ *   it to the sidecar (the HUD button and the `first-ready`/`always` modes call
+ *   it). `has(name)` reports whether a Fixture exists (HUD coverage marker), and
+ *   `read(name)` returns the parsed Fixture `data` for Replay to substitute in
+ *   front of the render prop.
+ *
+ * The store holds DECODED values (the dev client owns the devalue parse, since it
+ * has the live runtime); only the on-disk sidecar and the wire carry the opaque
+ * devalue string.
+ */
+interface FixtureStore {
+  /**
+   * Record the latest live `data` the dev adapter is about to render for `name`,
+   * so Record always has the current recordable input in scope. A `register` with
+   * the same value is cheap; the adapter calls it on every ready render. Returns a
+   * disposer the adapter runs on unmount so an unmounted Skeleton's `data` never
+   * lingers in the store: an unmounted instance must never be recorded or shadow a
+   * still-mounted one (ADR 0015). With several Skeletons of the same plate name
+   * mounted, the live value is the most-recently-registered still-mounted instance.
+   */
+  register: (name: string, data: unknown) => () => void;
+  /** True once a recorded Fixture exists for `name` (drives the HUD coverage marker). */
+  has: (name: string) => boolean;
+  /** The parsed Fixture `data` for `name`, or `undefined` when none is recorded. */
+  read: (name: string) => {
+    data: unknown;
+  } | undefined;
+  /**
+   * Serialize the registered live `data` for `name` with devalue and POST it to
+   * the sidecar. Returns a promise that resolves once the write is
+   * server-confirmed (so the HUD can surface a failed Record). Throws loudly when
+   * the live `data` is unrecordable (devalue's contract) or no live `data` was
+   * registered (a plain-children `<Skeleton>` has none).
+   */
+  record: (name: string) => Promise<void>;
+  /**
+   * Record every Skeleton that currently has live `data` registered (the HUD's
+   * single "Record fixture" button — one click captures the inputs of all mounted
+   * render-prop Skeletons). Resolves once all writes are server-confirmed; a
+   * rejected write surfaces to the HUD.
+   */
+  recordAll: () => Promise<void>;
+  /**
+   * Seed the store from the on-disk sidecars on boot: a `{ <name>: devalueString }`
+   * map (the opaque strings the server serves). The client decodes each with
+   * devalue. Existing entries are not clobbered, so a Fixture recorded this
+   * session survives a re-seed.
+   */
+  seed: (encoded: Record<string, string>) => void;
+  /** React subscription so the HUD re-renders when a Fixture is recorded or seeded. */
+  subscribe: (onChange: () => void) => () => void;
+}
+/** A plate's detected width thresholds and the spans actually captured, from disk. */
+interface PlateCoverage {
+  breakpoints: number[];
+  spans: Span[];
+}
+/**
+ * Dev-only per-plate coverage, sourced from the committed plate files (not the
+ * session): the breakpoints detected so far and which view spans are captured.
+ * The HUD renders every band — covered ones lit, the rest dim — and the
+ * capture-all sweep derives its target widths from the breakpoints.
+ */
+interface CoverageStore {
+  get: () => ReadonlyMap<string, PlateCoverage>;
+  set: (name: string, coverage: PlateCoverage) => void;
+  subscribe: (onChange: () => void) => () => void;
+}
+/**
+ * Dev-only capture hook, installed by the dev client before the app boots.
+ * Absent in production builds, so `<Skeleton>` carries zero capture weight.
+ * `captured` returns a dispose callback (stop observing this site).
+ */
+interface CaptureHook {
+  captured: (name: string, el: Element, opts?: {
+    delay?: number;
+    walker?: unknown;
+    mode?: 'auto' | 'manual';
+  }) => (() => void) | undefined;
+  /** Light Box toggle: force every `<Skeleton>` to its skeleton, read by `<Skeleton>`. */
+  lightbox?: ToggleStore;
+  /** Capture toggle: whether browsing re-captures plates, flipped from the HUD. */
+  capture?: ToggleStore;
+  /** Read side for `<Skeleton>`. */
+  plates?: PlateStore;
+  /** Write side for the dev client's HMR-event handler. Returns whether the plate changed. */
+  updatePlate?: (name: string, plate: Plate) => boolean;
+  /** Dev-only: run the HUD-triggered capture-all-views sweep via the extension (ADR 0010). */
+  captureAllViews?: () => Promise<void>;
+  /** Dev-only per-plate breakpoints + captured spans, from disk; fed by the bootstrap. */
+  coverage?: CoverageStore;
+  /**
+   * Replay toggle (ADR 0015): when active, the dev adapter substitutes a recorded
+   * Fixture's `data` for the live `data` at `loading=false`. The boolean is the
+   * coarse on/off the HUD owns per tab; the per-mode policy (`prefer` vs
+   * `missing-only`) is carried alongside in `replayMode`.
+   */
+  replay?: ToggleStore;
+  /** Dev-only Replay policy: how a Fixture substitutes for live `data` (ADR 0015). */
+  replayMode?: 'prefer' | 'missing-only';
+  /**
+   * Dev-only Record policy (ADR 0015): when the dev adapter records the live
+   * `data` it is about to render. `'manual'` (the default) records nothing
+   * automatically — only the HUD button does; `'first-ready'` records once when a
+   * Skeleton goes ready and has no Fixture yet; `'always'` records on every ready
+   * render.
+   */
+  recordMode?: 'manual' | 'first-ready' | 'always';
+  /** Dev-only Fixture record/replay store (ADR 0015); never present in production. */
+  fixtures?: FixtureStore;
+}
+declare global {
+  var __XRAY__: CaptureHook | undefined;
+}
+//#endregion
+export { RenderNode as a, emptyPlate as c, PlateNode as i, CaptureDiagnostic as l, MergedPlate as n, StoredPlate as o, Plate as r, ViewCapture as s, LeafKind as t };

package/dist/plate-BRR6d8Se.js

@@ -0,0 +1,156 @@
+/** Marks the rendered skeleton root; carries the plate name. Also a dev capture marker. */
+const ROOT_ATTR = "data-xr-root";
+/**
+* Marks an OUTERMOST skeleton root that is a stitch continuation (ADR 0020): a
+* standalone `<Skeleton>` replacing a stitch a still-showing parent skeleton was
+* just rendering. BASE_CSS reveals such a root instantly (no `--xr-skeleton-delay`,
+* no fade) so the bones do not flash away and back. Never present on a nested
+* stitch (which inherits the parent's reveal and has no `@starting-style` of its
+* own) nor on an ordinary top-level skeleton (which keeps the normal delay).
+*/
+const ROOT_INSTANT_ATTR = "data-xr-instant";
+/**
+* Marks a `<Content>` capture boundary in dev; carries the plate name. A parent
+* capture treats it as a stitch — it references the child plate by name instead of
+* re-serializing the child's subtree (ADR 0006).
+*/
+const BOUNDARY_ATTR = "data-xr-boundary";
+const SPEC_LEAF = 9e6;
+const SPEC_INLINE = 1e7;
+const SPEC_GATE = 2e7;
+/** Fixed renderer-owned classes every rendered node carries. */
+const ROOT_CLASS = "xr-root";
+const NODE_CLASS = "xr-node";
+const LEAF_CLASS = "xr-leaf";
+/**
+* Renderer-owned base styles, emitted once by the outermost view (ADR 0007),
+* before a plate's node rules so a node's captured class wins by source order.
+* Everything visual is driven by inheritable custom properties, so consumers
+* theme by setting `--xr-*` in `:root` or on any ancestor — and per-plate via
+* `[data-xr-root="name"]` (the root carries its plate name). See ADR 0011 and
+* docs/architecture.md. Class-based and unlayered — `@layer` was rejected
+* (unlayered app CSS would beat layered skeleton rules, and it inverts
+* `!important`).
+*
+* Progressive enhancement (ADR 0011): the plain bone fill + opacity pulse use
+* only universally-supported CSS and are the floor. `light-dark()` is guarded
+* by `@supports` because an unsupported VALUE drops the whole declaration (an
+* invisible bone), and it is not Baseline-widely-available until 2026-11-13 —
+* drop the guard then. Features that merely no-op when absent (`@property`,
+* `prefers-contrast`, relative-color-as-fallback) carry no hard guard.
+*
+* Tokens (ADR 0017 taxonomy). The `--xr-bone-*` family styles an individual
+* Bone: `--xr-bone-color` (fill), `--xr-bone-highlight-color` (sheen),
+* `--xr-bone-border-radius` (+ `--xr-bone-text-border-radius` /
+* `--xr-bone-text-block-border-radius` / `--xr-bone-media-border-radius`),
+* `--xr-bone-animation-duration`, the pulse
+* range `--xr-bone-pulse-opacity-min`/`--xr-bone-pulse-opacity-max`,
+* `--xr-bone-animation` (mode: `xr-pulse` | `none` | a custom keyframe), and
+* `--xr-bone-fill` (override the leaf paint, e.g. a sheen gradient built from the
+* two bone color tokens). The `--xr-skeleton-*` family governs whole-skeleton
+* display timing (ADR 0016): `--xr-skeleton-delay` (grace before the skeleton
+* becomes visible), `--xr-skeleton-min-duration` (minimum visible time once
+* shown; read by the `useSkeletonTiming` hook, not used in CSS), and
+* `--xr-skeleton-transition-duration` (the reveal/swap fade). The private
+* channels `--xr-o` (pulse) and `--xr-reveal` (reveal) stay undocumented
+* `@property` plumbing, not a theming surface.
+*/
+const BASE_CSS = `
+/* One timeline per skeleton, not per leaf: the root animates one inherited
+   opacity property and every leaf reads it. Hundreds of independent infinite
+   opacity animations would pin the compositor and cook the CPU. */
+@property --xr-o { syntax: "<number>"; inherits: true; initial-value: 1 }
+/* The reveal channel (ADR 0016): a second inherited opacity factor the leaf
+   multiplies into --xr-o. Transitioning THIS (not opacity directly) sidesteps
+   the animation-vs-transition collision ADR 0012 flagged. initial-value 1 (NOT
+   0) is the degradation floor: without @starting-style the reveal can never be
+   driven 0->1, so it must REST at 1 (fully visible). The delay-hide below is
+   pure progressive enhancement layered on top. */
+@property --xr-reveal { syntax: "<number>"; inherits: true; initial-value: 1 }
+.${ROOT_CLASS} {
+  --xr-bone-highlight-color: #f4f4f5;
+  display: contents;
+  animation: var(--xr-bone-animation, xr-pulse) var(--xr-bone-animation-duration, 1.2s) ease-in-out infinite alternate;
+}
+/* No pointer-events:none — it blocks inspecting bones in devtools and buys
+   nothing (no real content to click). border-color: a node may capture
+   border-width for layout; its paint stays out. list-style: suppress a ::marker
+   a captured display:list-item would otherwise paint. */
+.${NODE_CLASS} { border-color: transparent; list-style: none }
+.${LEAF_CLASS} {
+  background: var(--xr-bone-fill, var(--xr-bone-color, #e4e4e7));
+  border-radius: var(--xr-bone-border-radius, 4px);
+  /* Composed opacity (ADR 0016): the pulse channel times the reveal channel.
+     Never transition opacity directly (the pulse animation owns it). */
+  opacity: calc(var(--xr-o) * var(--xr-reveal));
+}
+/* Per-kind defaults: a single text LINE reads as a rounded bar; a multi-line
+   text BLOCK as a soft rect (a tall pill misreads as a button); media carries
+   the author radius, defaulting to the same soft rect. Re-theme any kind via
+   [data-xr-root] .${LEAF_CLASS}-text { ... }. */
+.${LEAF_CLASS}-text { border-radius: var(--xr-bone-text-border-radius, 999px) }
+.${LEAF_CLASS}-text-block { border-radius: var(--xr-bone-text-block-border-radius, var(--xr-bone-border-radius, 4px)) }
+.${LEAF_CLASS}-media { border-radius: var(--xr-bone-media-border-radius, var(--xr-bone-border-radius, 4px)) }
+@keyframes xr-pulse {
+  from { --xr-o: var(--xr-bone-pulse-opacity-max, 1) }
+  to { --xr-o: var(--xr-bone-pulse-opacity-min, 0.5) }
+}
+/* Reveal delay-hide (ADR 0016), a progressive enhancement guarded so it can NEVER
+   strand a skeleton invisible (open Q3). @starting-style is the trigger: only a
+   browser that supports it enters this block at all, and such a browser also
+   honors @property + transitions, so the 0->1 reveal completes. The @supports
+   selector(...) probe is the broadest cross-engine @starting-style feature test
+   available. Without support the block is skipped entirely and --xr-reveal stays
+   at its initial-value 1 = fully visible instant skeleton. INSIDE the block we
+   start at 0 and transition to 1 after the delay: invisible for
+   --xr-skeleton-delay, then a --xr-skeleton-transition-duration fade-in; a fast
+   load unmounts before the delay elapses and the skeleton is never seen. */
+@supports (selector(:has(*))) {
+  /* The delay-hide applies to every root EXCEPT a stitch continuation (ADR 0020).
+     Scoping with :not([data-xr-instant]) keeps an ordinary top-level skeleton
+     byte-identical to before: it still mounts at --xr-reveal 0 and fades in after
+     the delay. The transition/initial-1 rest state matches the original. */
+  .${ROOT_CLASS}:not([${ROOT_INSTANT_ATTR}]) {
+    --xr-reveal: 1;
+    transition: --xr-reveal var(--xr-skeleton-transition-duration, 150ms) linear var(--xr-skeleton-delay, 250ms);
+  }
+  @starting-style { .${ROOT_CLASS}:not([${ROOT_INSTANT_ATTR}]) { --xr-reveal: 0 } }
+  /* A stitch continuation (ADR 0020) reveals INSTANTLY: it was already visible as a
+     stitch under a still-showing parent, so re-paying the delay would flash it away
+     and back. No @starting-style and no transition — it rests at fully visible from
+     its first frame, matching how the stitch inherited the parent's reveal. */
+  .${ROOT_CLASS}[${ROOT_INSTANT_ATTR}] { --xr-reveal: 1 }
+}
+/* Reduced motion (open Q2): keep the anti-flash delay + min-duration (they are
+   not motion), drop only the FADE — collapse the reveal transition to instant and
+   kill the pulse animation (as before). */
+@media (prefers-reduced-motion: reduce) {
+  .${ROOT_CLASS} { animation: none; --xr-skeleton-transition-duration: 0s }
+}
+/* Dark + high-contrast bone defaults. Guarded: light-dark() is an invalid value
+   without support and would drop the declaration — see the note above; remove
+   this @supports once widely available (2026-11-13). */
+@supports (color: light-dark(#000, #fff)) {
+  .${ROOT_CLASS} { --xr-bone-highlight-color: light-dark(#f4f4f5, #52525b) }
+  .${LEAF_CLASS} { background: var(--xr-bone-fill, var(--xr-bone-color, light-dark(#e4e4e7, #3f3f46))) }
+  @media (prefers-contrast: more) {
+    .${LEAF_CLASS} { background: var(--xr-bone-fill, var(--xr-bone-color, light-dark(#d4d4d8, #52525b))) }
+  }
+}
+/* Derive the sheen highlight from --xr-bone-color so re-theming one token updates
+   both. Relative color isn't widely available yet; the static highlight above is
+   the fallback (sheen just looks flatter), so no hard guard is needed. */
+@supports (color: oklch(from red l c h)) {
+  .${ROOT_CLASS} { --xr-bone-highlight-color: oklch(from var(--xr-bone-color, #e4e4e7) calc(l + 0.08) c h) }
+}`.trim();
+/** The (unserialized) plate an import resolves to before anything has been captured. */
+function emptyPlate(name) {
+	return {
+		v: 2,
+		name,
+		tree: null,
+		css: ""
+	};
+}
+//#endregion
+export { ROOT_ATTR as a, SPEC_GATE as c, emptyPlate as d, NODE_CLASS as i, SPEC_INLINE as l, BOUNDARY_ATTR as n, ROOT_CLASS as o, LEAF_CLASS as r, ROOT_INSTANT_ATTR as s, BASE_CSS as t, SPEC_LEAF as u };