`, itself `.sv` or `[data-sv]`) translated its own box while hidden, the same geometry feedback loop `sv-rise`'s self-tracked case already had fixed: the driver measures that same (now-moved) box to decide live/hidden, so near the exit line hiding moved it back INTO the activation band and flipped it live again, measured 65 spurious flips scrolling through and back. The child translate rule in `styles/core.css` and the compat fallback sheet now excludes a child that is itself tracked, the same `:where(:not(.sv):not([data-sv]))` shape `sv-rise` already used; it still fades via the opacity rule. Verifier fix: the exclusion added to the compat fallback sheet's RESET rules (the reduced-motion block, the `data-sv-motion="reduce"` twin, the `:focus-within` override) also stopped them matching the tracked child, which then kept its entrance opacity/transition instead of settling, measured opacity 0 with an 800ms transition under reduced motion. Each reset rule now also carries a plain (`:is()`/`:where()`-free, matching compat's own parse floor) unexcluded arm for the tracked case. - A keyboard focus landing inside `sv-view-fade`/`sv-view-rise` near the entry edge of the viewport could stay transparent: Chrome scrolls a partly-visible focus target just into view and stops (it never centers one it already counts as visible), so the native scroll-driven entrance animation can still be mid-range when the focused box lands on screen, measured opacity 0.00 (`sv-view-fade`) and 0.28 (`sv-view-rise`), with and without JavaScript (WCAG 2.4.7/2.4.11). `styles/core.css`'s `@supports (animation-timeline: view())` block now adds a `:focus-within` override that stops the animation and restores full opacity, no translate. - The home page's own hand-kept copy of the preset tier (`demo/index.html`) had no `:focus-within` override for its entrance presets, unlike the shipped `styles/core.css` since PR #112: its only focusable entrance child, the canvas code block in `#amb-section`, could be tabbed onto mid-fade while the section was not yet live. Added the same override to the page's own copy. - A self-tracked `sv-rise` (the tracked element carries the class itself, not a child, either with no separate ancestor tracker or nested inside one) translated its own box while hidden, and the driver measures that same box to decide live/hidden: near the exit line, going hidden moved the box back INTO the activation band, which made it live again, in a loop (a regression introduced with the compound self-tracked entrance selectors, unreleased). Measured: 34 spurious flips scrolling down through the exit line and 30 back up for the plain case, 32 each way for a self-tracked `sv-rise` nested inside another tracker. The self-tracked case (either shape) now fades in place, with no translate, in `styles/core.css` and the compat fallback sheet; a plain (untracked) child of the tracker still gets the full rise. - `styles/pin.css`'s no-JS resets for curtains, rail and deck are written with `:is()`: an engine with individual transforms but no `:is()` (Firefox 72-77, below the README floor of Firefox 78) drops the whole rule, so without JS a curtain stayed closed, a deck stayed stacked and a rail stayed offscreen. Plain-selector twins now sit next to each `:is()` rule. - `scrollvars/debug`'s HUD calibrated its refresh interval from the fastest frame delta in its opening second with no check that the window was quiet: a page sustained at 30fps from load (every other vsync missed on a 60Hz display) calibrated its own drop rate as "healthy", reporting 0 dropped frames. The HUD now only locks its calibration onto a delta fast enough to prove 50Hz or better; a sustained slow opening keeps showing "calibrating" instead of a false-healthy reading. - `styles/pin.css`'s page-switch layout release (stage release, curtains hidden, rail wrapped) is written behind `:where()`, so the whole rule dropped on an engine without `:where()`/`:is()` support, the same floor `scrollvars/compat`'s own fallback sheet targets. On that floor, switching to `data-sv-motion="reduce"` only reset the compat curtains' `transform` to `none`, their CLOSED position, so a curtain past its opening scroll position stayed covering the content for good and the stage never released. The compat fallback sheet now carries a `:where()`/`:is()`-free twin of the same three resets. - A self-tracked `sv-spread-in` (the tracked element IS the spread, no separate ancestor) never matched the scrub and transition rules, which required a separate `.sv`/`[data-sv]` ancestor: the cards stayed stacked at the container's center indefinitely, overlapping each other. The scrub, transition and both reduced-motion rules now also match the compound (self) case, the same gap already closed for the other entrance presets. - A focused marquee item could be translated well outside the visible strip, with no way to scroll it back into view: `:focus-within` only paused the track's slide, and a focused link mid-loop sat wherever the animation left it (WCAG 2.4.7/2.4.11). While the TRACK itself now holds focus, `.sv-marquee-track:focus-within` presents it statically and wrapped with the duplicate hidden, mirrored in the gallery's CSS pane. Keyed on the track, not `.sv-marquee`, so focusing a controlled marquee's pause button does not reflow the strip. - A focused control inside `.sv-drift` kept the scroll fade: a fully visible link at the viewport edge read opacity 0.51, never hidden but still dim under WCAG 2.4.7. `.sv-drift:focus-within` now restores full opacity, in `styles/core.css` and the compat fallback sheet. - `CaseStudyRail`'s fallback below the `cqw` container-query floor turned the stage into a horizontal scroller with no `tabindex` and non-interactive cards, leaving every card past the first unreachable by keyboard in engines that do not auto-focus scrollers (WCAG 2.1.1). It now wraps the rail in flow instead, like the no-JS layout. - The document scope's late-marquee `MutationObserver` pre-check, `hasUnleasedTrack()`, gated the WHOLE callback body, so on a page with NO marquee anywhere a plain `[data-sv-toggle]` trigger mounted after boot (an SPA menu button, the common route-mount shape) never ran `bootTrigger` at all: it carried no `aria-expanded` and no initial `--sv-state` until its own first click (WCAG 4.1.2, a regression introduced by the marquee-free perf pass that first added this pre-check). The callback now also runs when the batch's own `addedNodes` contain a new trigger, marquee or not, at the cost of one `matches()`/`querySelector()` pair per added element (a batch that adds no element at all, text or attribute-only, still costs nothing). Measured with `test/toggles-mutation-cost.mjs`, a 500-element unrelated insert on a marquee-free page: before, 0ms (skipped entirely, at the cost of the bug above); after, 0.138-0.172ms median over 7 runs on a quiet machine (load 0.9/1.4/1.8, well under the load-check rule's ceiling of 6). - The compound (self-tracked) entrance selectors added for `sv-rise`, `sv-fade`, `sv-slide-l` and `sv-slide-r` matched the entrance rules but not either reduced-motion override (the OS media query or the `data-sv-motion="reduce"` twin), in `styles/core.css` and the compat fallback sheet: a self-tracked entrance (the tracked element IS the preset, no separate ancestor) stayed hidden and then animated a full travel distance under reduce, a regression against README's and AGENTS.md's "every preset sheet honors reduced motion". Both overrides, in both sheets, now also match the compound case. - `sv-split-rise` never matched a self-tracked element (`

`, the tracked element IS the split preset): its entrance rule required a separate ancestor `.sv`/`[data-sv]`, so the spans stayed at opacity 1, fail-visible but never actually animating. The entrance rule and both reduced-motion overrides now also match the compound case. - The staggered-reveal and split-reveal gallery CSS panes pasted the entrance hide, transition and reduced-motion rules from `styles/core.css` but not its `:focus-within` override: a reader who used only the pasted CSS left a focused entrance child (or a focused split heading) waiting out its stagger delay and transition instead of appearing at once (WCAG 2.4.7). Both panes now carry the override, placed after the reduce blocks. - `demo/bench/harness/a11y-tree-gate.mjs`'s negative counterpart for the slider's status region read the status node's own accessible `name`, which Chrome always reports empty (the actual text sits on a child), so the check passed whether or not the announced text changed and proved nothing about the detector. Both the real check and its negative and positive counterparts now share one `statusSays()` helper that walks the whole status subtree, like the real check does. - `toggles()`'s `resolve()` looked up a `data-sv-target` class selector against the WHOLE scope: under a document scope (``, the css pane's own `toggles()`), two controlled marquees sharing the class selector `.sv-marquee-track` both resolved to the FIRST track on the page, so a second marquee's own pause button stayed hidden and, if clicked programmatically, paused the first marquee instead. A trigger inside a `.sv-marquee` wrapper now resolves its target inside that wrapper first, falling back to the scope for every other trigger. - The document scope's late-marquee `MutationObserver` pre-check asked only "is any live track unleased", so a track inserted in one task and its pause button in a LATER one (two separate mutation batches) found every track already leased on the button's own batch and returned early: the track never got `sv-ui`, and the button stayed hidden behind ui.css's `.sv-marquee-track.sv-ui + .sv-marquee-pause` guard forever. The pre-check now also passes when a live pause button's resolved track lacks `sv-ui`, still zero iterations on a marquee-free page. - The docs page's GSAP interop example used `gsap.ticker.add` to read `--sv-t` directly with `|| 0`, the same fail-hidden pattern already removed from the gallery's tailwind pane: on release the driver clears the property, sending a `.from({ opacity: 0 })` timeline back to its hidden start, with no reduced-motion guard, and reduced motion keeps `--sv-t` updating so GSAP keeps moving too. The snippet is dropped from the paragraph, which already links the guarded `gsap-scrub` recipe two lines below. - `useScenes`/`useSlider` "re-render only on a discrete index change" was repeated at AGENTS.md's own "why the numbers come out this way" section and twice in `docs/guide.md`, missed by the gate that only checked AGENTS.md's earlier sentence (already corrected). All three now say what is actually true: re-render only on discrete events (index, status, flow, motion). - AGENTS.md and the guide said any CSS mention of `--sv-page`/`--sv-v`, "a `var()` read, a declaration, even a comment", turns publishing on; the driver excludes its own inline writes on `` from that check (only a `var()` read there counts, never a bare declaration), or a rescan would read its own output as a consumer and never unpublish. Both surfaces now name the exception. - The React `` announced nothing when a person navigated to another slide: its rail carried `aria-live="polite"`, but navigation only ever wrote `scrollLeft`, a class and a custom property, none of which is text a live region reads out. A visually hidden `role="status"` region now sits outside the rail, reading "Slide N of M" after `next`/`prev`/`goTo`/a dot click, silent (`aria-live="off"`) while autoplay rotates on its own; the rail no longer carries `aria-live` itself. The vanilla `slider()` has no live region of its own and is unchanged. - The React ``'s rail rendered with no `tabIndex`, so before hydration, without JS, or after a failed enhancement, the server-rendered carousel was keyboard-reachable only in engines that focus a scrollable region themselves; Safari does not, leaving slides past the first unreachable. The rail now renders `tabIndex={0}` directly. `slider()` already leaves an existing `tabindex` attribute alone, so hydration does not double-write it. - `styles/core.css`'s focus override for a focused Split heading targeted `.sv-split-rise > span:focus-within`, a selector that can never match: the word spans are `aria-hidden` and never hold focus, only their container does. Focusing a `` heading left every span at opacity 0. Fixed to `.sv-split-rise:focus-within > span`, keying off the container's own `:focus-within`. - Every entrance preset selector (base hide, translate and the focus-visibility override, in `styles/core.css` and the compat fallback sheet) required the preset class to be a DESCENDANT of `.sv`/`[data-sv]`: a self-tracked element, where the tracked element IS the preset (`

`, or `data-sv` and `sv-rise` on the same node), never matched at all, so it stayed at its unstarted, partially-faded state indefinitely, focus included. Every rule now also matches the compound (self) case.
- `toggles()`'s document-scope `MutationObserver` callback wrote late boots (a route-mounted marquee's track and pause button) into the same standing `transaction`/`siblingWrites` journals a click uses, only ever reset by the NEXT click anywhere in the document. Under ``, a page navigated without a click (programmatic routing, popstate) kept every late-booted write strongly referenced indefinitely, and a throw partway through one delivery's batch left the earlier writes of that same batch in place, unlike setup and click, which both roll back. The callback now gets its own fresh journals per delivery, rolls back on a throw and resets in `finally`, exactly like `onClick`.
- A `[data-sv-toggle]` trigger mounted before its `data-sv-target` ever resolved (a menu button rendered ahead of the nav it controls, a common SPA mount order) never got `aria-expanded` or `--sv-state` even once the target arrived in a later mutation batch: `bootTrigger()` just returns on an unresolved target, and only newly inserted triggers were ever retried. The document scope now keeps a per-instance set of unresolved triggers, retried on every later batch until each one resolves (dropped once it does, or once it disconnects), so a trigger and its target arriving in two separate batches now agrees with the class from the first frame, matching the one-batch case already fixed. The deliberate setup-time skip (marked `sv-ui` only on first click when neither the trigger nor a `MutationObserver` can retry it) is unchanged. Retrying every pending trigger inside ONE shared transaction meant a single trigger's write throwing rolled back a SIBLING pending trigger's own successful resolution in the same delivery too, and stopped the retry loop outright, so any trigger later in iteration order never even got tried. Each pending trigger now retries in its own transaction: one failure cannot touch a sibling's writes or block the rest of the batch. A trigger whose target resolves but whose write keeps throwing (an already-resolved target will not heal itself; there is no backoff machinery) is dropped from the pending set and reported once, instead of being retried, and reported again, on every later mutation forever.
- Both `toggles()`'s document-scope `MutationObserver` callback and its click handler rolled back a failing write and then rethrew, which `life.guard` turns into a permanent `stop()` of the WHOLE document scope over one bad write: the click listener is removed and the `MutationObserver` disconnects for the rest of the page's life, contradicting the module's own "the document scope never stops" design. Both now report the error directly instead of rethrowing, so a later click on a working trigger, or a later-mounted trigger, still works.
- Removing an already-offscreen marquee's whole subtree (an SPA route swap taking its page away) got no `IntersectionObserver` delivery for it (an already non-intersecting target reports no further transition on removal) and never opened the document scope's `MutationObserver` pre-check either (no unleased track, no new trigger, no pending trigger): the lease, the shared `IntersectionObserver` and the `visibilitychange` listener sat alive over a detached subtree until the user's next click, tab switch or marquee registration. A removal-only batch (any mutation record whose `removedNodes` is non-empty) now sweeps every leased marquee for detachment itself, before the pre-check can bail; a page with no leased marquee at all pays nothing extra.
- `toggles()`'s document-scope `MutationObserver` callback booted every NEW trigger of one delivery inside one shared transaction: a write throwing on one trigger rolled back a sibling trigger's already-written state too, and stopped the loop outright, so any trigger later in the batch's iteration order never even got tried, all reading no `aria-expanded`/`--sv-state` even though only one of them ever failed. Each new trigger of a delivery now boots in its own transaction, the same isolation the pending-trigger retry already had: one failing write is dropped and reported once, and every sibling trigger of the same batch still boots normally.
- The shared marquee `IntersectionObserver` and `visibilitychange` callbacks ran with no failure boundary of their own: a throw from a patched or exotic element's `classList` (the only way either callback can throw at all) would have stopped the batch before settling any marquee after it. Both are now wrapped per marquee, so a throwing track is reported once and every other marquee in the same batch still settles, matching AGENTS.md's "one bad toggle should not disable every other toggle in the same scope" for these two shared, instance-independent callbacks. `sweepDetachedMarquees()`, called from both of those callbacks and from the document scope's `MutationObserver` (its own C2 removal sweep above), had the same gap one level deeper: a throw pruning one detached track reached the `MutationObserver`'s `life.guard` and stopped the WHOLE document scope, or skipped every OTHER entry of the same `IntersectionObserver` batch. Each pruned track is now guarded inside the sweep itself.

### Docs

- AGENTS.md said any custom `--sv-r` consumer, not only the ready-made `sv-range-rise` preset, settles to its end state below the `sv-range` floor, contradicting the more precise Sequenced scrub paragraph a few lines above (a custom consumer falls back to its own initial or inherited value instead). The floor sentence now names `sv-range-rise` and points to that paragraph.
- `docs/guide.md` and the generated docs page still called the slider's TRACK the live region after the rail lost `aria-live` in favor of a separate `role="status"` region outside it. Both now describe the status region instead.
- AGENTS.md and `docs/guide.md` said runtime failures "stop only that instance" across every stateful module, which used to be true of `toggles()` too (a throwing click killed its listener for good, on any instance, and the document scope's `MutationObserver` for late-boot as well). Both now carve out the exception described above, corrected in a follow-up pass to name every `toggles()` instance, not only the document scope: a probe against a scoped root's own click handler found the same report-and-continue behavior there.

## 1.19.0 (2026-09-27)

### Added

- Author-side evidence for the outstanding "path to 8/10" review items (docs and CI only, no public surface change): an accessibility-tree proxy gate (`demo/bench/harness/a11y-tree-gate.mjs`, wired into `npm run test:e2e`) that reads Chrome's accessibility tree over the Slider, Modal, Accordion, toggles, split text, Scenes fallback and the Marquee pause control, every check proved able to fail on its own deliberately broken analog; a dated, fill-in VoiceOver checklist for the author's manual macOS and iOS pass (`docs/guide.md`, Accessibility section); and a physical-device frame budget matrix (`docs/guide.md`, stamped from `demo/bench/lab/results/published/*.json` by the new `scripts/lab-tables.mjs`) with a frame budget declared before any number is read (`LAB_FRAME_BUDGET`, `scripts/docs-data.mjs`), linked from AGENTS.md's performance paragraph. Desktop Chrome and Firefox runs are committed; Safari desktop and iPhone Safari are explicit pending placeholders, not fabricated rows. The lab (`demo/bench/lab/run-drive.js`) now calibrates each run's vsync interval independently (an idle rAF window before the scroll starts), instead of deriving it from the same scroll frames the budget then judges; the two committed runs predate that field and are labelled self-calibrated in the table rather than silently upgraded. The table also reports each page's worst rep alongside its median.
- A served accessibility checklist fixture, `/a11y/` (`demo/a11y/index.html`, built by the new `scripts/a11y-build.mjs` in `npm run demo:sync`): the real kit (Slider, a real `` Modal, a `sv-pop` disclosure, Accordion, split text, a real `` in its stacked fallback, a controlled Marquee and RotatingWords with its pause control), mounted against the shipped `styles.css`, deployed at that path. The VoiceOver checklist in `docs/guide.md` now points every row at this page instead of gallery previews that could never pass it (a vanilla slider with no carousel semantics, a `` no page shipped, an Accordion no row named). `a11y-tree-gate.mjs` runs against the same page: shipped CSS loaded, the Slider's announced position checked after activating "next", and a real `` fallback checked under reduced motion, each with its own negative counterpart (docs and CI only, no public surface change).
- `scrollvars/debug`'s `debug()` gained three new options, all off by default except `hud` and `lint`, which is exactly what shipped before minus nothing (the tracked-element panel stays as it was): `hud` (default true) mounts a performance HUD (FPS, dropped and late frames against the measured refresh interval, the worst frame of the last 5 seconds, and, where `PerformanceObserver` supports `long-animation-frame` (Chrome), blocking time with the top script attribution; elsewhere it says so instead of showing zeros); `markers` (default false) draws, for every tracked element, ScrollTrigger-style start/end lines for its travel and, for pinned elements, its pin stretch, labelled and positioned in page coordinates so they scroll with the page and recompute on resize; `lint` (default true) scans same-origin stylesheets once for a `--sv-*` read landing in a property that cannot be composited (width, height, the inset family, margin, padding, font-size, filter, backdrop-filter, box-shadow, background-position, clip-path, mask), directly or through one level of custom-property indirection, and reports selector, property and why, once, in the overlay and the console; a cross-origin sheet is reported as skipped, never silently ignored. `DebugOptions` gained `hud`, `markers` and `lint` (minor, additive).
- A `.sv-marquee-track` now pauses itself off screen and with the tab in the background (one shared IntersectionObserver and one shared visibilitychange listener across a page's toggles() scopes and marquees), and resumes on return, independent of the user's own pause button. New class: `.sv-marquee-offscreen` (public, additive).
- The stamped `scrollvars/react` gzip size is now measured with esbuild's real code splitting, entry chunk only: the dev-only `?sv-debug` overlay (loaded on demand, never on a page that does not ask for it) is no longer counted toward it. The published number drops from its pre-split figure for this reason, a measurement fix, not because the React layer shrank; see the stamped number in `docs/guide.md` for the current one and `scripts/docs-data.mjs`'s `measureSizes()` for the split build.
- A public, installable skill for AI coding agents: `skills/scrollvars/SKILL.md`, generated in `npm run demo:sync` from AGENTS.md's own text (mental model, the fail-visible guard, imports, the fx gallery, the performance rules), so it can never hand-drift from the guide it wraps. Shipped in the npm package (`files`). `npx scrollvars skill [--global] [--force]` installs it for Claude Code (`.claude/skills/scrollvars`) and Codex (`.agents/skills/scrollvars`), matching the installed package version; refuses to overwrite a locally modified copy without `--force`, idempotent otherwise. Also installable with the open `npx skills add aduptive/scrollvars` convention (reads a repo's `skills//SKILL.md`). The site hero and the top of the README now carry the one install command. The release gate fails if the packed tarball lacks the skill or its version does not match `package.json`.
- `toggles()`'s document scope now acquires a `.sv-marquee-controlled` mounted after it starts (a route-mounted marquee under a live ``, most of the time): a `MutationObserver`, owned by that one long-lived instance only, wires the late track and its pause button through the same lease-counted paths setup uses, released on `stop()`. Measured at about 0.16ms of script per mutated frame on a page appending one such wrapper every frame for 120 frames (`demo/bench/harness/toggles-mutation-cost.mjs`); a custom-root scope (a `` component's own `toggles(node)`) gets no such observer, since it already owns its one track for its whole lifetime. A page with no marquee at all pays an O(1) check per mutation batch instead of a subtree scan: the callback walks the live `document.getElementsByClassName('sv-marquee-track')` collection (empty, zero iterations, on a marquee-free page) and only scans an inserted subtree when it holds a track not already leased, an identity check rather than a bare count, so a route swap that removes one marquee and inserts another in the same mutation batch still wires the new one even though the count never changed.

### Fixed

- The physical-device lab table (`scripts/lab-tables.mjs`) judged the MEDIAN repetition against a calibration averaged across the whole file, so one bad rep, an errored rep or a missing page could hide behind the others. Every repetition is now judged against its own `vsyncMs` (falling back per-rep to that rep's own median when the field predates calibration), and a page needs full coverage (every declared repetition present, each with usable deltas and its own animated check passing) to pass at all. `verdictForPage` is exported and covered by `test/lab-tables.test.mjs`. The table still displays the median and worst rep.
- `verdictForPage`'s coverage check counted `runs.length` against the declared repetition count, so rep ids `[0, 0, 1]` (the same repetition captured twice, the third never run) read as full coverage. It now counts DISTINCT rep ids. A rep whose deltas are all zero or negative, whose own `vsyncMs` is non-positive, or whose self-calibrated median vsync comes out non-positive now fails outright as unusable instead of passing against a degenerate (zero or negative) budget.
- The a11y-tree checklist proxy's "Slider announces the new current slide after activating next" check was a false positive: every slide's static "N of 3" label is in the tree from the first render, so the check passed whether or not "next" did anything. It now asserts the real per-activation signal, the active dot's `aria-current` moving from slide 1 to slide 2, proved able to fail against a no-op "next" counterpart. The VoiceOver checklist row for the Slider now names this signal explicitly.
- The `gsap-scrub` gallery recipe's `requires.min` (1.17.0) let older releases install a component that passes `onStatus` to ``, an API that shipped in 1.18.0; on an older install the prop silently lands on the DOM and the fail-visible settle never fires. Raised to 1.18.0. The `marquee` recipe's `requires.min` (1.9.0) had the same shape for the pause button, which shipped in 1.14.0; raised to 1.14.0.
- The GSAP tailwind pane's "zero-wrapper" alternative used `gsap.ticker.add` to read `--sv-pin` directly: on release the driver clears the property, `parseFloat('')` is `NaN`, and the `|| 0` fallback sends a `.from({ opacity: 0 })` timeline back to its hidden start, with no reduced-motion guard. Dropped in favor of the css pane's guarded `track()`/`onPin` callback, which already covers zero-wrapper pages.
- The installed RotatingWords pause button flipped its label ("Pause rotation" / "Resume rotation") while also carrying `aria-pressed`, which reads as a self-contradiction to a screen reader ("Resume rotation, toggle button, selected"). The label is now fixed ("Pause rotation"), matching the gallery preview, the kit's `` pause and the WAI-ARIA APG toggle-button pattern.
- A keyboard focus landing inside an entrance preset (`sv-rise`, `sv-fade`,
  `sv-slide-l`, `sv-slide-r`, `sv-auto`, `sv-split-rise`) stayed invisible
  until its stagger delay and transition ran, up to 1.7s for the eleventh
  staggered child: a WCAG 2.4.7 failure, since a focus indicator on an
  opacity-0 element is not visible. `styles/core.css` (and the compat
  fallback sheet) now carry a `:focus-within` override, placed after the
  entrance rules, that settles a focused entrance item or one that contains
  the focused control to fully visible at once, no delay, no transition.
- `docs/guide.md`'s `useScenes` hook example keyed its stacked branch's
  current scene by `i === scene`, the exact identity bug `` itself
  was fixed to avoid: the example now uses a plain index key throughout.
- `AGENTS.md` claimed React "never re-renders per frame, only on discrete
  index changes"; completion, attachment, flow and motion changes also
  re-render, none of them an index change. It also claimed the scoped
  clocks sheet "can only make [a page] faster where it is understood",
  contradicted by its own measurements two paragraphs above (a flat
  profile 4 percent slower, several gallery pages slower): both sentences
  now state only what is actually guaranteed. The guide carried the same
  scoped clocks sentence and is fixed the same way.
- The VoiceOver checklist (`docs/guide.md`) said RotatingWords had "no
  pause control yet"; the pause button shipped in both the preview and the
  installed component. The checklist now steps through it instead.
- ``'s stacked branch (reduced motion, a failed attach, a flowed
  stage) keyed its "current" fragment by `i === scene`: the driver keeps
  reporting scene changes while stacked, so React moved that key between
  scenes on every one, destroying a focused input or a playing video in a
  scene the reader had not left. The stacked branch now freezes which
  index carries "current" the moment the component goes stacked; no key
  in that branch depends on the live scene, and the active/stacked switch
  keeps the guarantee it already had (PR #92).
- `` and `` dropped `sv-live` on a completed `once` reveal
  the next time their own `className` prop changed: the driver settles a
  completed entry outside its tracked set and stops re-asserting the
  class, so a React className rewrite (which replaces the whole `class`
  attribute) wiped it. Both components now carry `sv-live` in their own
  rendered className once `onStatus('completed')` fires, resetting on the
  next `'attaching'`. A bare `useTrack` consumer has to do the same on its
  own element (documented in AGENTS.md).
- Every GSAP scrub recipe (the installed `GsapScrub` component, the
  rendered gallery preview, and the copy-paste CSS/React panes) only ever
  moved its timeline through `onPin`: under reduced motion, or once the
  tracker failed or was released, `onPin` never fires again, so a
  `.from({ opacity: 0 })` timeline stayed stuck at progress 0 forever, a
  fail-hidden. Every surface now settles to progress 1 on the effective
  motion preference and on a failed/released tracker, scrubbing only
  while attached (`requires.min` bumped to 1.17.0 for the `onMotionChange`
  import).
- `RotatingWords` rotated forever with no way to stop it (WCAG 2.2.2), and
  the marquee gallery's preview and CSS/Tailwind panes taught the bare,
  uncontrolled `.sv-marquee` shape with no pause button. `RotatingWords`
  now renders a keyboard-operable, persistent `aria-pressed` pause button;
  the marquee preview and panes render the controlled markup
  (`sv-marquee-controlled` plus `sv-marquee-pause`), matching the ``
  component. `hero-cinematic`'s own CSS/Tailwind panes (which also embed a
  bare marquee strip) got the same button.
- A `` whose own `error` event the driver observed
  (a 404, a reset connection, an unreachable host, while the sheet was
  still pending) kept publishing `--sv-page`/`--sv-v` on `` forever
  for every page with no consumer at all: `sheetReadsPageOutputs()`'s
  catch (an unreadable sheet is uncertainty, so it defaults to "assume it
  reads them") could not distinguish that observed failure from an opaque
  cross-origin sheet, so `found` latched true and the watch that would
  notice a later, corrected href never installed. An observed failure now
  turns outputs off; correcting the link's `href`/`rel`/`media`/`disabled`
  is judged again. A batch that corrects two links at once now forgets
  both, not only the first (the attribute-mutation watcher broke out of
  its records loop early).
  Deliberately NOT fixed the same way: a link whose sheet throws without
  the driver ever observing its `error` (measured in real Chrome, the
  sheet can already be a throwing object by the first frame that asks,
  before any listener attaches) keeps the conservative default, publishing
  for the rest of the session. A same-origin `` can throw on
  `cssRules` for a reason that is not a load failure at all: a 302
  redirect to a cross-origin CSS file keeps a same-origin `href`, fires
  `load`, and still throws (CORS opacity on the redirected response),
  common on reverse-proxied or versioned CDN setups; an earlier version of
  this fix read any same-origin throw as a failure and broke exactly that
  case. Wrongly publishing costs a per-frame write; wrongly silencing
  breaks rendering, so the conservative default wins whenever the driver
  itself never saw the failure.
- The gallery's GSAP React recipe (`gsap-scrub`) timed a `.from('.stage > *', ...)`
  selector against markup that renders `.sv-stage`: pasted as shown, the
  timeline animated nothing. It now scopes to the stage's own ref.
- AGENTS.md's `--sv-r` paragraph, `styles/pin.css`'s two comments and
  `docs/guide.md`'s explanation were wrong in two of the four engine
  cells (a round-1 fix that reworded the claim without checking each
  cell against the two floors, calc() division and `@property`): Chrome
  85-111 has `@property` but not the division, so `--sv-r` is registered
  and settles at its initial value, 1; Firefox 112-127 has the division
  but not `@property`, so `--sv-r` is unregistered and simply keeps
  animating, the same as full support; only below BOTH floors (Firefox
  under 112, Safari under 16.4) is the consumer's own declaration invalid
  at computed-value time, falling back to its own initial or inherited
  value, not to 1. Worded to carry the matrix in all four copies. The
  `--sv-page`/`--sv-v` VARS row also read as ambiguous between
  "(tracked and CSS) or setPageOutputs" and "tracked and (CSS or
  setPageOutputs)" (the latter is what the driver does); reworded to
  read one way only.
- The `data-sv-fit` overflow check compared the fit node's own height
  against the whole stage `clientHeight`, never counting where the fit
  node itself starts inside the stage (padding-top, a heading above it,
  its own margin): a box that fit its own height could still clip against
  `overflow: hidden` (WCAG 1.4.4/1.4.10). The check now adds the fit
  node's `offsetTop` (an offset-chain read, not a bounding rect) when the
  stage is its `offsetParent`, falling back to the old comparison for a
  consumer stage without the preset.
- A marquee track detached from the document while already off screen got
  no further IntersectionObserver delivery (no intersection transition to
  report), so the per-target prune in the IO callback never ran for it: it
  stayed in the lease bookkeeping, observed, until the next tab switch.
  The lease map is now swept for detached tracks on every IO delivery
  batch, every new marquee registration and the document scope's own
  click handler, no `MutationObserver` needed.
- Without native `inert` (Firefox 78-111, Safari 14.1-15.4, inside the
  README floor), `StickySteps` still applied `inert`/`aria-hidden` to
  inactive shots, and the pause-controlled `Marquee`'s duplicate strip
  still turned on: without real support the attribute is inert in name
  only, so links inside an invisible shot or an animated duplicate stayed
  in the tab order (WCAG 2.4.7/2.4.11). Both surfaces gate on
  `'inert' in HTMLElement.prototype` now: `StickySteps` (installed and
  gallery copies) stays static with every shot reachable, and `toggles()`
  never marks a controlled marquee track `sv-ui`, so `styles/ui.css` keeps
  its strip static and the duplicate hidden.
- `toggles()`'s marquee release closure captured its track directly; a
  Boot-owned document scope that never stops kept that closure, and the
  detached track it held, for the app's life. It now goes through the same
  `weakRef()` helper the markers use, falling back the same way where
  `WeakRef` is unavailable.
- `useScenes` carried its `flowed` flag from one lease into the next: a
  replacement target (any `useTrack` dependency change) with no
  `[data-sv-fit]` child and no flowed ancestor never gets a re-announced
  `onFlow`, so a lease that once overflowed stayed `active: false`
  forever, even once it fit cleanly. `flowed` now resets on
  `onStatus('attaching')`, before the new lease's own `onFlow` can land.
- Below the individual-transform floor with no `compat()`, only a stage
  carrying a static deck was released to flow: a plain pinned stage (the
  common Scenes/Sections shape) kept reporting `active` while pin.css
  released the stage underneath it anyway, so the pin span collapsed to
  about one pixel and `` rendered only its current scene, the
  rest unreachable. Every stage below the floor with no `compat()` now
  flows too (`data-sv-flow`, `onFlow(true)`), matching what a deck-bearing
  stage already did.
- `` rendered only the current scene outside the enhanced, pinned
  state: on the server, without JS, after a failed attach, and after a
  fit-to-flow release, the scene index sat at 0 (or jumped straight to it
  after a helper-pinned stage collapsed its span), so scenes 1..N-1 were
  never in the DOM, the same content-unreachable shape the reduced-motion
  fix above closed for one cause and left open for the others. `useScenes`
  now hands back `active` (attached, not flowed, not reduced), and
  `` renders every scene, stacked, whenever it is not active,
  matching what it already did for reduced motion; server and first
  client render agree, since `active` starts false. `ScenesState` gained
  `active` (minor, additive). The guide's `Story` example and four doc
  sentences now use it instead of `reduced` alone.
- Under reduced motion, a helper-pinned `` collapsed its
  pin span to about one pixel, so `--sv-scene`/`onScene` jumped from 0 to
  N-1 in one pixel and the guide's own example (`Slide {scene + 1}`) never
  rendered the middle scenes. `useScenes`/`` now hand back a
  `reduced` flag, and `` calls its render function once per scene
  and stacks the result under reduced motion, so every scene stays
  reachable. `ScenesState` gained `reduced` (minor, additive). Four doc
  sentences that claimed the pin/scene clocks keep scrubbing under reduced
  motion now say a helper-pinned section returns to flow and its pin/scene
  clocks finish at once, matching what the driver already did.
- Marquee's offscreen watch had first-registrant-owns semantics: a second
  `toggles()` scope registering the same `.sv-marquee-track` (the common
  `` + `` shape) never got its own release wired,
  so stopping the scope that registered first stranded the track observed
  forever (a leak on every client-side navigation away from its page), and
  stopping the OTHER scope stripped the offscreen class and observer from
  a track the first scope still needed. Fixed with a per-track lease
  count: unobserve, delete and remove the class only when the last lease
  goes, and a track that has left the document is pruned (unobserved, its
  lease dropped) on its next IntersectionObserver delivery or visibility
  pass, so a document-wide scope that never stops cannot keep a removed
  track leased forever. A lease also carries a generation number, so a
  track that is detached, pruned and later reattached under a new scope
  cannot have its fresh lease released by a stale stop() from before
  the prune.
- Emptying a populated slider (every slide removed) left `state().active`
  pointing at a detached node with `count: 0`, so repopulating at the same
  index fired no `onSlide`. An empty list now resets `active` to `-1` and
  releases the owned `--sv-slide`.
- A disabled `` enabled later never turned page
  outputs on: the consumer watch only observed `childList`, so an attribute
  change (`disabled` flipping) queued no rescan. It now also observes
  `disabled`/`rel`/`href`/`media` on every ``.
- A tracker under a hidden custom scroll root (`display: none`) wrote
  `--sv-t: NaN` and passed `NaN` to `onTravel`; `computeTravel` now holds at
  0 when the viewport and element height are both zero, the same guard
  `computeView` and `pinSpan` already had.
- Debug markers ignored the pinned stage's normal-flow origin (a heading or
  padding before the stage), so both lines were off by exactly that much;
  they also picked up a nested tracker's stage instead of their own.
  `pinLines` takes the origin now, and the overlay resolves the owned stage
  the same way the driver does.
- The debug HUD calibrated its refresh rate from the frames it was judging,
  so a sustained half-rate page (every other vsync) read as a 30Hz display
  with 0 dropped frames. It now calibrates once, over a quiet opening
  window, and judges every later frame against that frozen interval; a
  frame spanning a backgrounded tab is neither a calibration sample nor a
  dropped one.
- The debug panel used `backdrop-filter`, which re-rasters every scroll
  frame and would have the HUD in the same document measure that cost as
  the page's own. Solid background now, no filter.
- `npx scrollvars add` with no slug fetched the effect registry before
  printing usage, so an offline run reported a registry error instead of
  the command's own help text.
- The fx gallery's React panes had six uncast `style={{ '--sv-*': ... }}`
  object literals (`TS2353` in a strict consumer's `tsc`, the same shape a
  previous release already fixed in the installed components); all cast to
  `React.CSSProperties` now, and a new gate checks every pane.
- The marquee CSS pane's reduced-motion block only stopped the animation;
  the real stylesheet also releases the strip's width and hides the
  duplicate copy, or a pasted marquee under reduce keeps clipping content
  past the viewport edge. The pane now matches, and the pause covers
  `:focus-within` like the real sheet.
- The coverflow slider's CSS and Tailwind panes used `abs()` (Chrome 104,
  above this project's stated floor); rewritten to the installed
  component's `max(x, -1 * x)` equivalent, and the Tailwind pane gained a
  reduced-motion guard it never had.
- The docs page's browser-support text still described a rail that stayed
  unwrapped below the transform floor and a deck that clipped past the
  stage with `compat()` installed; both were fixed in earlier releases
  (the rail wraps in `pin.css`'s own net, a deck-holding stage returns to
  flow regardless of `compat()`). Rewritten from the current code.
- Three doc inaccuracies: "even a comment counts" toward page-output
  detection is true only for an inline `