Add web animation skills (iart-ai/web-animation-skills)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GYeokZtSmqg42ZGWsLXX2C

.agents/skills/60fps-animation/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: 60fps-animation
+description: This skill should be used when the user asks to "fix janky CSS animation", "make animation 60fps", "stop layout thrashing", "animate width/height/top/left smoothly", "convert animation to transform", "animate box-shadow performantly", "animate height auto", "FLIP animation", or "why is my scroll/hover animation choppy".
+version: 0.1.0
+---
+
+# Performant Web Animation
+
+Eliminate the #1 cause of janky web animation: animating properties that force the browser to recalculate layout (reflow) or repaint on every frame. The browser renders in stages — **layout → paint → composite**. Animating `width`, `height`, `top`, `left`, `margin`, `padding`, `box-shadow`, or `filter` re-runs layout and/or paint each frame, blocking the main thread. Animating **`transform`** and **`opacity`** runs entirely on the compositor (often the GPU), skipping layout and paint, which is what makes animation smooth at 60/120fps.
+
+## When to use
+
+Use when an animation stutters or drops frames, when a hover/scroll effect feels heavy, when animating size/position/shadow, when a layout change needs to animate smoothly (cards reordering, an element moving between containers), when animating `height: auto`, or when reviewing animation code for performance.
+
+## Core rule: animate only transform and opacity
+
+Map every "expensive" animation to a cheap equivalent.
+
+| Animating (expensive) | Triggers | Replace with (cheap) |
+|---|---|---|
+| `width` / `height` | Layout + Paint | `transform: scaleX()/scaleY()` (+ FLIP for true size) |
+| `top` / `left` / `margin` | Layout + Paint | `transform: translate()` |
+| `box-shadow` | Paint | Animate `opacity` of a pseudo-element holding the shadow |
+| `filter: blur()` | Paint (heavy) | Cross-fade two layers via `opacity`, or accept sparingly |
+| `background-position` | Paint | `transform: translate()` on a child layer |
+| `color` / `background` | Paint | Often acceptable; or cross-fade layers |
+
+### Position and size via transform
+
+```css
+/* BAD: animates layout every frame */
+.box { transition: left 300ms, width 300ms; left: 0; width: 100px; }
+.box:hover { left: 200px; width: 200px; }
+
+/* GOOD: compositor-only */
+.box {
+  transition: transform 300ms ease;
+  transform: translateX(0) scaleX(1);
+  transform-origin: left center;
+}
+.box:hover { transform: translateX(200px) scaleX(2); }
+```
+
+`scaleX` distorts inner content (text stretches). For true resizing without distortion, use **FLIP**.
+
+## Cheap box-shadow via pseudo-element opacity
+
+Animating `box-shadow` repaints a large blurred region every frame. Instead paint the shadow once on a `::after`, then animate only its `opacity`.
+
+```css
+.card { position: relative; }
+.card::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  box-shadow: 0 12px 28px rgba(0,0,0,0.35);
+  opacity: 0;
+  transition: opacity 300ms ease;
+  pointer-events: none;
+}
+.card:hover::after { opacity: 1; }
+```
+
+The blurred shadow is rasterized once; hovering only changes a compositor opacity — smooth at any frame rate.
+
+## FLIP: animate layout changes cheaply
+
+FLIP (First, Last, Invert, Play) animates a *layout* change (reorder, resize, move between containers) using only `transform`. Measure where the element was (First) and will be (Last), apply an inverting transform so it visually appears unmoved, then animate the transform back to identity (Play). The DOM ends in its real final layout; the motion is pure compositor work.
+
+```js
+function flip(el, mutate) {
+  const first = el.getBoundingClientRect();   // First
+  mutate();                                    // change the DOM/layout
+  const last = el.getBoundingClientRect();     // Last
+
+  const dx = first.left - last.left;
+  const dy = first.top - last.top;
+  const sx = first.width  / last.width;
+  const sy = first.height / last.height;
+
+  el.animate(
+    [
+      { transformOrigin: 'top left',
+        transform: `translate(${dx}px, ${dy}px) scale(${sx}, ${sy})` }, // Invert
+      { transformOrigin: 'top left', transform: 'none' },               // Play
+    ],
+    { duration: 300, easing: 'cubic-bezier(0.2, 0, 0, 1)' }
+  );
+}
+
+// usage: animate an element moving to a new grid position
+flip(card, () => targetContainer.appendChild(card));
+```
+
+The Web Animations API `animate()` runs the transform on the compositor. For many elements, batch all `getBoundingClientRect()` reads *before* any mutation (see layout thrashing below).
+
+## Animating height: auto
+
+`height: auto` is not interpolatable historically. Modern and fallback approaches:
+
+```css
+/* Modern (Chrome 129+/supporting browsers): opt size keywords into animation */
+.panel {
+  interpolate-size: allow-keywords;   /* enables animating to/from auto */
+  height: 0;
+  overflow: clip;
+  transition: height 300ms ease;
+}
+.panel.open { height: auto; }
+/* calc-size() also works: height: calc-size(auto, size); */
+```
+
+```css
+/* Robust fallback today: CSS grid 1fr -> 0fr */
+.wrapper {
+  display: grid;
+  grid-template-rows: 0fr;            /* collapsed */
+  transition: grid-template-rows 300ms ease;
+}
+.wrapper.open { grid-template-rows: 1fr; }
+.wrapper > .content { overflow: hidden; min-height: 0; }
+```
+
+The grid trick animates the track size (compositor-friendly enough and broadly supported) and needs no JS height measurement. Use `interpolate-size: allow-keywords` / `calc-size(auto, size)` where the target browsers support it; keep the grid technique as the cross-browser default.
+
+## Avoid layout thrashing (batch reads, then writes)
+
+Reading a layout property (`offsetWidth`, `getBoundingClientRect`, `scrollTop`, `getComputedStyle`) after a write forces a *synchronous* reflow. Interleaving reads and writes in a loop ("layout thrashing") can run dozens of forced reflows per frame.
+
+```js
+// BAD: read, write, read, write... forces reflow each iteration
+items.forEach((el) => {
+  const w = el.offsetWidth;          // read (forces layout)
+  el.style.width = w * 1.5 + 'px';   // write (invalidates layout)
+});
+
+// GOOD: batch all reads, then all writes
+const widths = items.map((el) => el.offsetWidth);  // all reads
+items.forEach((el, i) => {                          // all writes
+  el.style.width = widths[i] * 1.5 + 'px';
+});
+```
+
+For frame-synced work, read in a `requestAnimationFrame` callback and apply writes; libraries like fastdom formalize this read/write scheduling.
+
+## will-change: use sparingly
+
+`will-change: transform` promotes an element to its own compositor layer ahead of time, avoiding a hitch at animation start. But every promoted layer costs GPU memory, and over-use degrades performance.
+
+```css
+.menu { will-change: transform; }   /* only on elements about to animate */
+```
+
+Rules: apply just before the animation (e.g. on hover/parent state), remove it after (`will-change: auto`) when idle, never blanket-apply to many elements, and never leave it permanently on large/numerous nodes. A single `transform: translateZ(0)` hack does the same promotion but is harder to undo — prefer `will-change`.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+The deliverable is **one self-contained `.html`** that opens directly in a browser — the markup, the CSS/JS animation, and a freeze harness in one file. For this skill, verification is two-pronged: the frame must look right *and* be cheap to produce (compositor-only).
+
+**Output contract:**
+- One `.html`, deps via CDN if any, animation driven by CSS transitions/`@keyframes` or the Web Animations API.
+- A freeze mechanism so a screenshot lands on a deterministic frame:
+  - CSS `@keyframes` → `?t=N` sets `el.style.animationDelay = (-N)+'s'; el.style.animationPlayState = 'paused'`.
+  - WAAPI / JS → keep the animation object and `anim.pause(); anim.currentTime = N*1000`.
+
+**Verify loop — freeze → screenshot, then profile for jank:**
+1. Open headless at start / mid / end (`?t=0`, mid, end), screenshot each; confirm the motion is visually correct (no clipped/stretched text from `scaleX`, FLIP lands on the real layout, shadow/height transitions look right).
+2. **Confirm it's compositor-only** — the whole point of this skill. Either:
+   - DevTools → Performance: record the animation, check there is **no purple "Layout" or green "Paint"** band per frame (only "Composite Layers").
+   - Or headless trace: `npx playwright screenshot` for the visual, plus a CDP/`tracing` capture, and assert no `Layout`/`Paint` events fire during the animation window.
+3. Watch the FPS/“Frame Rendering Stats” overlay stays at 60 — dropped frames mean an expensive property slipped back in.
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/anim.html?t=0.3" frame.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors.
+2. Only `transform` / `opacity` animate per frame; DevTools shows no per-frame Layout/Paint.
+3. Screenshotted at start / mid / end — correct, no `scaleX` text distortion, FLIP lands true.
+4. Holds 60fps; `will-change` applied just-in-time and removed when idle (no leftover layers).
+5. `prefers-reduced-motion` honored.
+
+## Quick reference
+
+| Goal | Do this |
+|---|---|
+| Move element | `transform: translate()` |
+| Resize without distortion | FLIP with `transform` |
+| Shadow on hover | Animate `opacity` of shadow pseudo-element |
+| Expand to content height | grid `0fr→1fr`, or `interpolate-size: allow-keywords` |
+| Many elements moving | Batch `getBoundingClientRect` reads, then writes |
+| Smooth animation start | `will-change` just-in-time, remove when idle |
+| Verify it's compositor-only | DevTools Performance: no purple "Layout"/green "Paint" per frame |
+
+## Gotchas
+
+- `scaleX/scaleY` stretches text and children; use FLIP when content must stay crisp.
+- `transform` percentages are relative to the element's own box, not the parent — different from `left: %`.
+- Overusing `will-change` or `translateZ(0)` creates too many layers and *hurts* performance; promote only what animates.
+- `filter` and `backdrop-filter` are compositor-related but still expensive; animate their presence via opacity cross-fades rather than animating the blur radius.
+- The grid `1fr→0fr` content must have `overflow: hidden` and `min-height: 0` or it won't collapse.
+- Always gate non-essential motion behind `@media (prefers-reduced-motion: reduce)`.
+
+## Reference files
+
+- `references/patterns-and-profiling.md` — full runnable examples (accordion, reorder list, parallax), DevTools profiling walkthrough to confirm compositor-only frames, reduced-motion patterns, and a property-cost cheat sheet.

.agents/skills/60fps-animation/references/patterns-and-profiling.md

@@ -0,0 +1,132 @@
+# Patterns, profiling, and cost cheat sheet
+
+## Property cost cheat sheet
+
+| Property | Pipeline stage triggered | Verdict |
+|---|---|---|
+| `transform` | Composite only | Cheap — animate freely |
+| `opacity` | Composite only | Cheap — animate freely |
+| `filter` | Paint (+composite) | Expensive — avoid animating radius |
+| `box-shadow` | Paint (large area) | Expensive — use pseudo + opacity |
+| `width`, `height` | Layout + Paint | Avoid — use scale/FLIP |
+| `top`, `left`, `right`, `bottom` | Layout + Paint | Avoid — use translate |
+| `margin`, `padding` | Layout + Paint | Avoid |
+| `border-width` | Layout + Paint | Avoid |
+| `color`, `background-color` | Paint | Acceptable in moderation |
+| `background-position` | Paint | Prefer translate on child |
+| `clip-path` | Paint | Moderate; cheaper than filter |
+
+## Accordion with grid height (no JS measurement)
+
+```html
+<button class="acc-trigger" aria-expanded="false">Details</button>
+<div class="acc-wrap"><div class="acc-content">…content…</div></div>
+```
+
+```css
+.acc-wrap {
+  display: grid;
+  grid-template-rows: 0fr;
+  transition: grid-template-rows 280ms cubic-bezier(0.2,0,0,1);
+}
+.acc-wrap.open { grid-template-rows: 1fr; }
+.acc-content { overflow: hidden; min-height: 0; }
+
+@media (prefers-reduced-motion: reduce) {
+  .acc-wrap { transition: none; }
+}
+```
+
+```js
+trigger.addEventListener('click', () => {
+  const open = wrap.classList.toggle('open');
+  trigger.setAttribute('aria-expanded', String(open));
+});
+```
+
+## FLIP reorder list (batched reads)
+
+```js
+function flipReorder(container, mutate) {
+  const items = [...container.children];
+  const firsts = new Map(items.map((el) => [el, el.getBoundingClientRect()])); // all reads
+
+  mutate(); // e.g. sort/reinsert children
+
+  items.forEach((el) => {
+    const first = firsts.get(el);
+    const last = el.getBoundingClientRect();
+    const dx = first.left - last.left;
+    const dy = first.top - last.top;
+    if (dx || dy) {
+      el.animate(
+        [{ transform: `translate(${dx}px, ${dy}px)` }, { transform: 'none' }],
+        { duration: 300, easing: 'cubic-bezier(0.2,0,0,1)' }
+      );
+    }
+  });
+}
+```
+
+Reading every rect *before* mutating, and using `animate()` (compositor), keeps a 50-item reorder smooth.
+
+## Just-in-time will-change
+
+```js
+el.addEventListener('pointerenter', () => { el.style.willChange = 'transform'; });
+el.addEventListener('transitionend', () => { el.style.willChange = 'auto'; });
+```
+
+Promote on intent, demote when the animation ends, so layers don't accumulate.
+
+## Reduced-motion gate
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.001ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.001ms !important;
+    scroll-behavior: auto !important;
+  }
+}
+```
+
+For JS: `const reduce = matchMedia('(prefers-reduced-motion: reduce)').matches;` and skip/shorten animations when true.
+
+## Profiling: prove it's compositor-only
+
+1. Open DevTools > **Performance**. Record while the animation runs.
+2. Inspect the flame chart frames during the animation:
+   - **Purple "Layout"** or **green "Paint"** bars on every frame → still hitting layout/paint; the animation is not compositor-only. Find the offending property.
+   - Only **"Composite Layers"** / GPU work per frame → success.
+3. Use **Rendering** tab tools:
+   - **Paint flashing** — green flashes show repainted regions; a good transform/opacity animation flashes nothing.
+   - **Layer borders** — confirms which elements are on their own compositor layer (watch for too many from over-using `will-change`).
+   - **Frame Rendering Stats / FPS meter** — confirm a stable 60/120fps.
+4. The **Layers** panel shows layer count and memory; excessive layers indicate `will-change` overuse.
+
+## Parallax without scroll-jank
+
+Drive parallax with `transform: translate3d()` updated inside a single `requestAnimationFrame` loop reading `scrollY` once per frame — never read layout per element per frame.
+
+```js
+let ticking = false;
+addEventListener('scroll', () => {
+  if (!ticking) {
+    requestAnimationFrame(() => {
+      const y = window.scrollY;              // single read
+      layers.forEach((l, i) => {             // writes only
+        l.style.transform = `translate3d(0, ${y * (0.1 * (i + 1))}px, 0)`;
+      });
+      ticking = false;
+    });
+    ticking = true;
+  }
+}, { passive: true });
+```
+
+`{ passive: true }` lets the browser scroll without waiting on the handler.
+
+---
+Stay on transform and opacity, profile the jank away, and motion holds 60fps. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=60fps-animation)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/accessible-animation/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: accessible-animation
+description: This skill should be used when the user asks to "respect prefers-reduced-motion", "honor reduced motion", "make my animations accessible", "fix vestibular / motion-sickness issues", "add a useReducedMotion hook", "gate GSAP / Framer Motion / Lenis for reduced motion", or "meet WCAG 2.3.3 / C39". Provides tiered (not all-or-nothing) reduced-motion patterns in CSS and JS.
+version: 0.1.0
+---
+
+# Accessible Animation (Reduced Motion, Tiered)
+
+Honor `prefers-reduced-motion: reduce` as a *graceful degradation*, not a kill switch. The OS-level setting (macOS: Settings > Accessibility > Display > Reduce motion; Windows: Settings > Accessibility > Visual effects > Animation effects; iOS/Android equivalents) signals that *vestibular-triggering* motion causes nausea, dizziness, or migraines. The correct response is to remove the dangerous motion while keeping orientation cues.
+
+## When to use
+
+Use when adding or auditing animation in a web UI, when a user reports motion sickness or WCAG findings, or when integrating animation libraries (GSAP, Framer Motion, Lenis smooth scroll, Anime.js, CSS keyframes) into an accessible product.
+
+## The core principle: tier motion, do not nuke it
+
+Removing *all* animation is a common over-correction. An instant state change with no transition can be more disorienting (elements teleport) and removes useful affordances (focus rings, loading spinners that communicate progress). Sort every animation into three tiers:
+
+- **Tier 1 — Remove entirely (vestibular triggers).** Parallax; large-area slides/translates across the viewport; scale/zoom of large elements; 3D rotation and spin; continuous auto-playing carousels and marquees; smooth-scroll hijacking (Lenis/Locomotive); scroll-jacked pinned scenes; motion-path animation; anything that moves a large portion of the screen or implies depth/self-motion.
+- **Tier 2 — Soften / shorten.** Replace movement with a short opacity fade (≤200ms). Reduce distance and duration. Keep the *fact* of a transition (so elements don't teleport) but strip the displacement. Replace a 600ms slide-in-from-left with a 150ms cross-fade.
+- **Tier 3 — Always keep.** Opacity fades, color/background transitions, focus-ring transitions, loading indicators, and motion that is *essential* to meaning (WCAG allows essential animation). These rarely trigger vestibular responses because they imply no self-motion.
+
+## CSS layer: media-query gating
+
+Write motion as the default, then override under the reduce query. Prefer a global safety net plus targeted overrides.
+
+```css
+/* Global safety net: neutralize runaway motion but DO NOT set 0s blindly,
+   which can break JS that waits for transitionend/animationend. Use 0.01ms. */
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;   /* stop infinite spins/marquees */
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;          /* kill smooth scroll */
+  }
+}
+```
+
+The global net is a backstop. Layer *intentional, tiered* overrides on top so Tier 3 motion survives:
+
+```css
+.card {
+  transition: transform 400ms ease, opacity 400ms ease, background-color 200ms ease;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .card {
+    /* Tier 2: drop the transform (movement), keep opacity + color (Tier 3) */
+    transition: opacity 150ms ease, background-color 150ms ease;
+  }
+  .parallax-layer { transform: none !important; }        /* Tier 1: remove */
+  .hero-zoom      { animation: none !important; }        /* Tier 1: remove */
+}
+```
+
+Use the *positive* query `(prefers-reduced-motion: no-preference)` to opt motion IN, which is the safest pattern for elaborate effects:
+
+```css
+.hero { opacity: 1; } /* visible, static by default */
+@media (prefers-reduced-motion: no-preference) {
+  .hero { animation: zoom-in 1.2s ease both; } /* only animate when allowed */
+}
+```
+
+## JS layer: matchMedia gating
+
+CSS cannot gate JS-driven animation (GSAP timelines, Framer's `animate`, canvas/WebGL, Lenis). Read the same signal via `matchMedia` and react to live changes (users toggle the OS setting without reloading).
+
+```js
+const REDUCE_QUERY = '(prefers-reduced-motion: reduce)';
+
+export function prefersReducedMotion() {
+  return typeof window !== 'undefined'
+    && window.matchMedia
+    && window.matchMedia(REDUCE_QUERY).matches;
+}
+
+// Live updates: listen so toggling the OS setting takes effect immediately.
+export function onReducedMotionChange(cb) {
+  const mq = window.matchMedia(REDUCE_QUERY);
+  const handler = (e) => cb(e.matches);
+  mq.addEventListener('change', handler);          // modern API
+  return () => mq.removeEventListener('change', handler);
+}
+```
+
+### Library gating, applied as one reusable layer
+
+```js
+// GSAP — use matchMedia(): GSAP reverts conditional setups on change.
+import gsap from 'gsap';
+const mm = gsap.matchMedia();
+mm.add({
+  motionOK: '(prefers-reduced-motion: no-preference)',
+  motionReduce: '(prefers-reduced-motion: reduce)',
+}, (ctx) => {
+  const { motionOK } = ctx.conditions;
+  if (motionOK) {
+    gsap.from('.hero', { y: 80, opacity: 0, duration: 1 });   // Tier 1 move
+  } else {
+    gsap.from('.hero', { opacity: 0, duration: 0.15 });        // Tier 2 fade
+  }
+});
+
+// Lenis smooth scroll — do not instantiate at all when reduced.
+import Lenis from 'lenis';
+let lenis = null;
+if (!prefersReducedMotion()) {
+  lenis = new Lenis();
+  const raf = (t) => { lenis.raf(t); requestAnimationFrame(raf); };
+  requestAnimationFrame(raf);
+}
+```
+
+## React: a `useReducedMotion` hook
+
+```jsx
+import { useState, useEffect } from 'react';
+
+export function useReducedMotion() {
+  const query = '(prefers-reduced-motion: reduce)';
+  const get = () =>
+    typeof window !== 'undefined' && window.matchMedia
+      ? window.matchMedia(query).matches
+      : false;
+  const [reduced, setReduced] = useState(get);
+
+  useEffect(() => {
+    const mq = window.matchMedia(query);
+    const onChange = () => setReduced(mq.matches);
+    onChange();                                   // sync after hydration
+    mq.addEventListener('change', onChange);
+    return () => mq.removeEventListener('change', onChange);
+  }, []);
+
+  return reduced;
+}
+```
+
+```jsx
+// Framer Motion has its own useReducedMotion(); the hook above also works.
+import { motion } from 'framer-motion';
+function Card() {
+  const reduced = useReducedMotion();
+  return (
+    <motion.div
+      initial={reduced ? { opacity: 0 } : { opacity: 0, y: 40 }}
+      animate={{ opacity: 1, y: 0 }}
+      transition={{ duration: reduced ? 0.15 : 0.5 }}
+    />
+  );
+}
+```
+
+Initialize SSR-rendered state to `false` (motion) and re-sync in `useEffect` to avoid a hydration mismatch; the OS value is only known client-side.
+
+## WCAG mapping
+
+- **2.3.3 Animation from Interactions (AAA).** Motion triggered by interaction (scroll, hover) must be disable-able unless essential. Honoring `prefers-reduced-motion` is the standard technique.
+- **C39 (CSS technique).** Use the `prefers-reduced-motion` query to prevent motion. This is the named sufficient technique.
+- **2.2.2 Pause, Stop, Hide (A).** Any auto-playing motion lasting >5s must offer pause/stop. Auto-carousels and marquees fail this regardless of the media query — give a control too.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained demo the deliverable is **one HTML file that opens directly in a browser** — markup, CSS, and any JS (GSAP/`matchMedia` from CDN) inline, no build step. For *this* skill the verification is the point: you must screenshot **both** the normal and the reduced-motion path and confirm the tiering is correct.
+
+**Output contract:**
+- One `.html` file with the full motion AND its tiered reduced-motion overrides (CSS query + `matchMedia`/`gsap.matchMedia()` for JS-driven motion).
+- A seek harness to freeze a frame, plus a way to force the reduced-motion code path for screenshots.
+
+**Seek harness — freeze a frame, force the preference.** `?t=N` freezes the timeline; `?reduce=1` forces the reduced path even when the OS setting is off (CSS can't be toggled from JS, so query the same flag you gate JS on, and screenshot with the OS/browser preference emulated for the CSS layer):
+
+```html
+<script>
+  const q = new URLSearchParams(location.search);
+  const reduce = q.get("reduce") === "1"
+    || window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  // build motion conditionally on `reduce` (Tier-1 removed, Tier-2 softened, Tier-3 kept)
+  const t = q.get("t");
+  if (t !== null) { tl.pause(); tl.seek(parseFloat(t)); }      // GSAP; CSS: el.style.animationDelay=(-t)+"s"; playState="paused"
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — screenshot BOTH states:** capture the normal path AND the reduced path, mid-animation each, and confirm Tier-1 motion is gone, Tier-2 is a short fade, Tier-3 survives. Emulate the preference for the CSS layer (Playwright `--reduced-motion=reduce`; the agent's browser tool can emulate it too):
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/demo.html?t=0.6" normal.png
+npx playwright screenshot --reduced-motion=reduce --wait-for-timeout=500 "file://$PWD/demo.html?t=0.6&reduce=1" reduced.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, CDN (if any) loads.
+2. The freeze + `?reduce=1` (and `--reduced-motion=reduce`) reliably exercises both code paths.
+3. Screenshotted in BOTH states, mid-animation — normal looks intentional, reduced strips Tier-1/softens Tier-2.
+4. `prefers-reduced-motion` honored as *tiering*, not a kill switch — no teleporting, Tier-3 fades/focus rings/spinners kept; any >5s auto-motion still has a pause control (2.2.2).
+5. Easing is intentional in both paths — no accidental `linear`, durations sane (reduced fades ≤200ms, `0.01ms` not `0s`).
+
+## Quick reference
+
+| Motion type | Tier | Reduced behavior |
+|---|---|---|
+| Parallax / depth | 1 | Remove (`transform: none`) |
+| Large slide / translate | 1 | Remove or replace with fade |
+| Scale / zoom (large) | 1 | Remove |
+| Spin / 3D rotate | 1 | Remove (`animation: none`) |
+| Auto carousel / marquee | 1 | Stop + provide pause control (2.2.2) |
+| Smooth-scroll (Lenis) | 1 | Don't instantiate |
+| Small slide / pop-in | 2 | Cross-fade ≤200ms |
+| Opacity fade | 3 | Keep (shorten if long) |
+| Color / focus-ring transition | 3 | Keep |
+| Loading spinner | 3 | Keep (essential feedback) |
+
+## Gotchas
+
+- `animation-duration: 0s` can break code waiting on `animationend`/`transitionend`; use `0.01ms` so the event still fires.
+- The global `*` reset alone over-removes Tier 3 motion; always layer intentional overrides.
+- Forgetting `animation-iteration-count: 1` leaves infinite spins running at near-zero duration (CPU churn, still animating).
+- No media query covers JS/canvas/WebGL — gate those with `matchMedia` or the loop never stops.
+- Toggling the OS setting fires no page reload; without a `change` listener the page keeps its stale state.
+- SSR: reading `matchMedia` during render throws or mismatches; default to motion and sync in an effect.
+- Auto-playing motion needs a visible pause control even when reduced-motion is off (2.2.2 is Level A).
+
+## Reference files
+
+- `references/patterns.md` — Full GSAP `matchMedia` teardown, Framer Motion `MotionConfig`, Lenis start/stop on live toggle, a reusable `animateWithMotionPreference` wrapper, marquee with pause control, and a tier-classification audit checklist.

.agents/skills/accessible-animation/references/patterns.md

@@ -0,0 +1,196 @@
+# Reduced Motion — Detailed Patterns
+
+## Reusable wrapper: animate with motion preference
+
+A single helper that picks a "full" or "reduced" variant and stays live-reactive.
+
+```js
+const REDUCE = '(prefers-reduced-motion: reduce)';
+
+export function createMotionController() {
+  const mq = window.matchMedia(REDUCE);
+  const listeners = new Set();
+  mq.addEventListener('change', () => listeners.forEach((fn) => fn(mq.matches)));
+
+  return {
+    get reduced() { return mq.matches; },
+    subscribe(fn) { listeners.add(fn); fn(mq.matches); return () => listeners.delete(fn); },
+    // Pick a variant object: { full, reduced }
+    pick(variants) { return mq.matches ? variants.reduced : variants.full; },
+  };
+}
+
+// Usage
+const motion = createMotionController();
+const opts = motion.pick({
+  full:    { translateY: ['40px', '0'], opacity: [0, 1], duration: 500 },
+  reduced: { opacity: [0, 1], duration: 150 },
+});
+```
+
+## GSAP: full matchMedia with teardown
+
+`gsap.matchMedia()` automatically reverts (kills tweens, restores inline styles) when a condition stops matching, so toggling the OS setting cleans up correctly.
+
+```js
+import gsap from 'gsap';
+import { ScrollTrigger } from 'gsap/ScrollTrigger';
+gsap.registerPlugin(ScrollTrigger);
+
+const mm = gsap.matchMedia();
+
+mm.add({
+  motionOK: '(prefers-reduced-motion: no-preference)',
+  motionReduce: '(prefers-reduced-motion: reduce)',
+}, (ctx) => {
+  const { motionOK } = ctx.conditions;
+
+  if (motionOK) {
+    // Tier 1 parallax — only when allowed
+    gsap.to('.parallax-layer', {
+      yPercent: -30,
+      ease: 'none',
+      scrollTrigger: { trigger: '.section', scrub: true },
+    });
+    gsap.from('.card', {
+      y: 60, opacity: 0, stagger: 0.1,
+      scrollTrigger: { trigger: '.grid', start: 'top 80%' },
+    });
+  } else {
+    // Reduced: no parallax at all; cards cross-fade in place (Tier 2)
+    gsap.from('.card', {
+      opacity: 0, duration: 0.15, stagger: 0.03,
+      scrollTrigger: { trigger: '.grid', start: 'top 80%' },
+    });
+  }
+
+  return () => { /* optional extra cleanup; mm reverts tweens automatically */ };
+});
+
+// Tear everything down (e.g. SPA route change)
+// mm.revert();
+```
+
+## Framer Motion: MotionConfig for app-wide reduction
+
+`MotionConfig reducedMotion="user"` makes every child `motion` component automatically drop transform/layout animations while keeping opacity. Set it once at the root.
+
+```jsx
+import { MotionConfig, motion } from 'framer-motion';
+
+export function App() {
+  return (
+    <MotionConfig reducedMotion="user">
+      {/* All descendant motion components honor the OS setting */}
+      <motion.section
+        initial={{ opacity: 0, y: 80 }}   // y is auto-dropped when reduced
+        animate={{ opacity: 1, y: 0 }}
+        transition={{ duration: 0.6 }}
+      />
+    </MotionConfig>
+  );
+}
+```
+
+For per-component control, Framer's own hook:
+
+```jsx
+import { useReducedMotion } from 'framer-motion';
+
+function Hero() {
+  const reduced = useReducedMotion();
+  const variants = reduced
+    ? { hidden: { opacity: 0 }, show: { opacity: 1, transition: { duration: 0.15 } } }
+    : { hidden: { opacity: 0, scale: 0.9 }, show: { opacity: 1, scale: 1, transition: { duration: 0.8 } } };
+  return <motion.div variants={variants} initial="hidden" animate="show" />;
+}
+```
+
+## Lenis: start/stop on live toggle
+
+Lenis hijacks scroll (Tier 1). Destroy it when reduced motion turns on, recreate when it turns off.
+
+```js
+import Lenis from 'lenis';
+
+let lenis = null;
+let rafId = null;
+
+function startLenis() {
+  if (lenis) return;
+  lenis = new Lenis({ smoothWheel: true });
+  const loop = (t) => { lenis.raf(t); rafId = requestAnimationFrame(loop); };
+  rafId = requestAnimationFrame(loop);
+}
+function stopLenis() {
+  if (!lenis) return;
+  cancelAnimationFrame(rafId);
+  lenis.destroy();
+  lenis = null;
+  // Restore native scroll so the page is still usable
+  document.documentElement.style.removeProperty('scroll-behavior');
+}
+
+const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
+function sync() { mq.matches ? stopLenis() : startLenis(); }
+mq.addEventListener('change', sync);
+sync();
+```
+
+## Auto-carousel / marquee with a pause control (WCAG 2.2.2)
+
+Auto-playing motion longer than 5s needs a pause/stop control regardless of the media query. Reduced-motion users get it stopped by default; everyone gets the control.
+
+```html
+<div class="marquee" data-playing="true">
+  <button class="marquee__toggle" aria-pressed="false">Pause</button>
+  <ul class="marquee__track"><!-- items --></ul>
+</div>
+```
+
+```css
+.marquee__track { animation: scroll-left 20s linear infinite; }
+.marquee[data-playing="false"] .marquee__track { animation-play-state: paused; }
+@media (prefers-reduced-motion: reduce) {
+  .marquee__track { animation-play-state: paused; } /* paused by default */
+}
+@keyframes scroll-left { to { transform: translateX(-50%); } }
+```
+
+```js
+const root = document.querySelector('.marquee');
+const btn = root.querySelector('.marquee__toggle');
+// Respect the OS setting for the initial state
+if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) {
+  root.dataset.playing = 'false';
+  btn.textContent = 'Play';
+  btn.setAttribute('aria-pressed', 'true');
+}
+btn.addEventListener('click', () => {
+  const playing = root.dataset.playing === 'true';
+  root.dataset.playing = String(!playing);
+  btn.textContent = playing ? 'Play' : 'Pause';
+  btn.setAttribute('aria-pressed', String(playing));
+});
+```
+
+## Tier classification audit checklist
+
+For each animation in the codebase, ask in order:
+
+1. Is it essential to meaning (e.g. a progress bar, a diagram step)? -> Tier 3, keep.
+2. Does a large area move, scale, spin, or imply depth/self-motion (parallax, zoom hero, slide-over)? -> Tier 1, remove under reduce.
+3. Is it a small entrance with displacement (pop-in, slide-up)? -> Tier 2, replace displacement with a ≤200ms opacity fade.
+4. Is it only opacity/color/focus? -> Tier 3, keep (shorten if >300ms).
+5. Does it auto-play >5s (carousel, marquee, looping video bg)? -> Add a pause control (2.2.2) on top of any tier handling.
+
+## Testing
+
+- macOS: System Settings > Accessibility > Display > Reduce motion.
+- Windows 11: Settings > Accessibility > Visual effects > Animation effects (off).
+- Chrome DevTools: Rendering panel > "Emulate CSS media feature prefers-reduced-motion".
+- Verify the `change` listener: toggle the OS setting with the page open and confirm motion stops without reload.
+- Confirm `transitionend`/`animationend`-dependent flows still complete (the `0.01ms` rule).
+
+---
+Honor prefers-reduced-motion at every tier and motion stays inclusive by default. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=accessible-animation)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/ascii-animation/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: ascii-animation
+description: This skill should be used when the user asks to "make an ASCII animation", "build a terminal/CLI intro or loader", "convert an image or video to ASCII art", "add an ASCII shader/post-effect to a canvas or Three.js scene", "create retro/hacker text-character motion", or "animate text characters with a brightness ramp". Covers generative ASCII fields, image/video/3D-to-ASCII, and animated character art for both web and terminal.
+version: 0.1.0
+---
+
+# ASCII Animation
+
+Render motion entirely with text characters. ASCII output is extremely lightweight, distinctive, and works in browsers (`<pre>`/canvas), terminals (ANSI), and over any 3D scene (Three.js `AsciiEffect`).
+
+## When to use
+
+- Build terminal/CLI intros, loaders, banners, or a retro/hacker aesthetic.
+- Convert an image, video frame, or 3D scene into animated ASCII.
+- Add an ASCII post-effect over an existing canvas/WebGL render.
+- Create generative text fields (plasma, sine waves, noise, tunnels).
+
+## Core concept: the brightness ramp
+
+Map luminance (0..1) to a character whose ink density matches. Order characters dark-to-light. Pick the index with `Math.round(lum * (ramp.length - 1))`.
+
+Common ramps (dark to light):
+- Short (10): ` .:-=+*#%@`
+- Medium (16): ` .'\`^",:;Il!i><~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$`  truncated — see table below.
+- Standard 70-level (Paul Bourke), best for photos:
+  `` $@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:,"^`'.  `` (reverse for dark-on-light).
+
+Compute relative luminance from sRGB (perceptual):
+```js
+const lum = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255; // 0..1
+```
+
+Invert when drawing dark text on a light background: `lum = 1 - lum`.
+
+## Character cell aspect correction (the #1 gotcha)
+
+Monospace character cells are taller than wide — roughly **0.5 width:height**. Sampling a square pixel grid produces a vertically stretched image. Correct by sampling **fewer rows than columns**: for a target of `cols` characters wide, use `rows = Math.round(cols * (imgH / imgW) * fontAspect)` where `fontAspect ≈ 0.5`. Equivalently, when drawing to an offscreen canvas, set its height to `cols * aspect * 0.5`.
+
+## Web rendering: `<pre>` vs canvas
+
+- **`<pre>` + textContent**: simplest. One string with `\n` per row. Fine up to ~120×60 chars at 30fps. Set `white-space: pre; font-family: monospace; line-height: 1;`.
+- **Canvas `fillText`**: needed for per-character color, larger grids, or 60fps. Draw each char at `x * cellW, y * cellH`. Faster than thousands of DOM nodes.
+
+Generative `<pre>` field (plasma):
+```js
+const pre = document.querySelector('pre');
+const COLS = 100, ROWS = 50, ramp = ' .:-=+*#%@';
+function frame(t) {
+  let out = '';
+  for (let y = 0; y < ROWS; y++) {
+    for (let x = 0; x < COLS; x++) {
+      const v = Math.sin(x * 0.2 + t * 0.001)
+              + Math.sin(y * 0.3 + t * 0.0013)
+              + Math.sin((x + y) * 0.15 + t * 0.0007);
+      const lum = (v + 3) / 6;                    // normalize -3..3 to 0..1
+      out += ramp[Math.round(lum * (ramp.length - 1))];
+    }
+    out += '\n';
+  }
+  pre.textContent = out;
+  requestAnimationFrame(frame);
+}
+requestAnimationFrame(frame);
+```
+
+## Image / video to ASCII
+
+Draw the source to a small offscreen canvas at `cols × rows`, read pixels with `getImageContext().getImageData`, then map each pixel to a character. For video, repeat per frame from a `<video>` element.
+
+```js
+function videoToAscii(video, cols = 120) {
+  const aspect = video.videoHeight / video.videoWidth;
+  const rows = Math.round(cols * aspect * 0.5);   // cell aspect correction
+  const cv = document.createElement('canvas');
+  cv.width = cols; cv.height = rows;
+  const ctx = cv.getContext('2d', { willReadFrequently: true });
+  const ramp = ' .:-=+*#%@', pre = document.querySelector('pre');
+  (function tick() {
+    ctx.drawImage(video, 0, 0, cols, rows);
+    const { data } = ctx.getImageData(0, 0, cols, rows);
+    let out = '';
+    for (let i = 0; i < data.length; i += 4) {
+      const lum = (0.2126*data[i] + 0.7152*data[i+1] + 0.0722*data[i+2]) / 255;
+      out += ramp[Math.round(lum * (ramp.length - 1))];
+      if (((i / 4) + 1) % cols === 0) out += '\n';
+    }
+    pre.textContent = out;
+    requestAnimationFrame(tick);
+  })();
+}
+```
+
+For Node image→ASCII, see `scripts/img-to-ascii.mjs`.
+
+## 3D-to-ASCII with Three.js
+
+`AsciiEffect` wraps a renderer and renders any scene as ASCII into a DOM element. Render through the effect, not the renderer.
+
+```js
+import { AsciiEffect } from 'three/addons/effects/AsciiEffect.js';
+const effect = new AsciiEffect(renderer, ' .:-=+*#%@', { invert: true });
+effect.setSize(innerWidth, innerHeight);
+effect.domElement.style.color = '#0f0';
+effect.domElement.style.backgroundColor = 'black';
+document.body.appendChild(effect.domElement);
+// in loop: effect.render(scene, camera);  // NOT renderer.render
+```
+
+## Terminal / CLI animation
+
+Loop with ANSI escape codes: hide the cursor, move to home, print the frame, throttle to 12–24 fps. Show the cursor again on exit.
+
+```js
+const ESC = '\x1b[';
+process.stdout.write(ESC + '?25l');               // hide cursor
+function frame(t) {
+  process.stdout.write(ESC + 'H');                // cursor to top-left
+  // build and write rows...
+}
+const id = setInterval(() => frame(Date.now()), 1000 / 20);
+process.on('SIGINT', () => {
+  clearInterval(id);
+  process.stdout.write(ESC + '?25h' + ESC + '2J'); // show cursor, clear
+  process.exit();
+});
+```
+Use `ESC + '2J'` to clear the whole screen, `ESC + 'H'` for home (cheaper per frame than clearing). Color with `\x1b[38;2;R;G;Bm` (truecolor) and reset with `\x1b[0m`.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained web ASCII piece (generative field, image/video→ASCII, `AsciiEffect` scene) the deliverable is **one HTML file that opens directly in a browser** — the `<pre>`/canvas, the ramp, and the rAF loop inline (Three.js from CDN if used). No build step. One file is the right tier; don't reach for a bundler. (Terminal/CLI pieces verify differently — capture stdout or a screenshot of the terminal.)
+
+**Output contract:**
+- One `.html` file: the render target, the brightness ramp, and the `requestAnimationFrame` loop in one inline `<script>`.
+- Drive frames from an **injectable time** (not `Date.now()`/`performance.now()` directly) and seed any randomness, so a frame is reproducible.
+
+**Seek harness — freeze the rAF loop on a deterministic frame.** `?t=N` renders exactly one frame at simulated time `N` instead of looping, so a screenshot is reproducible. Feed `N` where the loop reads time, and fix the seed:
+
+```html
+<script>
+  const t = new URLSearchParams(location.search).get("t");
+  // your frame(time){…} reads `time`, not Date.now(); RNG uses a fixed seed
+  if (t !== null) { frame(parseFloat(t)); }        // render ONE frame, no rAF
+  else { (function loop(now){ frame(now); requestAnimationFrame(loop); })(0); }
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — render → freeze → screenshot → check:** render at a few simulated times (`?t=0`, `?t=1000`, `?t=2000`), screenshot each, and check **fidelity** (ramp reads dark→light correctly, motion evolves) plus **artifacts** (vertical stretch from missing cell-aspect correction, wrong invert on a light bg, clipped grid, FOUC before the monospace font loads — fonts settle the cell metrics, so wait). Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/ascii.html?t=1000" frame-mid.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, CDN (Three.js, if used) loads, monospace font applied.
+2. `?t=N` renders one deterministic frame (injected time + fixed seed), no live loop.
+3. Screenshotted at 3 simulated times — matches the brief, no vertical stretch or wrong-invert.
+4. `prefers-reduced-motion` honored — stop/slow the rAF loop, show a static frame.
+5. Easing is intentional — frame rate throttled on purpose (12–24fps for retro feel), ramp ordering deliberate.
+
+## Quick reference
+
+| Need | Approach |
+|------|----------|
+| Simple generative field | `<pre>` + `textContent`, sine/noise → ramp |
+| Photo fidelity | 70-level Bourke ramp, luminance from sRGB weights |
+| Per-char color / 60fps | Canvas `fillText` per cell |
+| Video | `<video>` → offscreen canvas → `getImageData` per frame |
+| 3D scene | Three.js `AsciiEffect.render(scene, camera)` |
+| Terminal | ANSI `\x1b[H` home + throttle 12–24fps, hide cursor |
+| Aspect fix | `rows = cols * imgAspect * 0.5` |
+
+## Reference files
+
+- `references/rendering.md` — Full brightness ramp tables (10/70/extended), pixel sampling math and cell aspect correction, `<pre>` vs canvas tradeoffs with code, ANSI terminal frame loop with truecolor, and complete `AsciiEffect` wiring.
+- `scripts/img-to-ascii.mjs` — Runnable Node script that converts a PNG/JPG file to ASCII text, with `--cols`, `--invert`, and `--ramp` flags.

.agents/skills/ascii-animation/references/rendering.md

@@ -0,0 +1,194 @@
+# ASCII Rendering Reference
+
+Detailed tables, sampling math, and complete renderers for ASCII animation.
+
+## Brightness ramp tables
+
+Order is **dark → light**. Index into the ramp with `Math.round(lum * (ramp.length - 1))` where `lum` is 0..1.
+
+### 10-level (compact, generative)
+```
+ .:-=+*#%@
+```
+Good for low-resolution generative fields and terminals. Distinct steps, low banding artifacts.
+
+### 70-level Paul Bourke ramp (photo fidelity)
+```
+$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:,"^`'. 
+```
+This is ordered **light → dark** (densest first). For luminance mapping, either reverse the string or use `index = Math.round((1 - lum) * (len - 1))`. Best results for grayscale photos; whitespace at the end represents black/empty.
+
+### 16-level extended (balance)
+```
+ .'`,^:";~-_+<>i!lI?/\|()1{}[]rcvunxzjftLCJUYXZO0Qoahkbdpqwm*WMB8&%$#@
+```
+Truncate or downsample to taste. For UI/loaders a hand-picked 8–12 char ramp usually looks cleaner than a 70-char ramp because the steps are visually distinct.
+
+### Block / shade characters (Unicode, smoother gradient)
+```
+ ░▒▓█
+```
+Or with the 1/8 block fills for vertical bars: `▁▂▃▄▅▆▇█`. Renders as a near-continuous gradient in monospace fonts; great for waveforms, meters, and smooth fades. Requires a font with box-drawing glyphs (most monospace fonts have them).
+
+## Luminance computation
+
+Perceptual (sRGB-weighted, recommended):
+```js
+const lum = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255; // 0..1
+```
+Fast average (acceptable for stylized output):
+```js
+const lum = (r + g + b) / (3 * 255);
+```
+Invert for dark-on-light surfaces: `lum = 1 - lum`. Apply gamma to spread midtones: `lum = Math.pow(lum, 0.8)` (lower exponent brightens).
+
+## Pixel sampling and cell aspect correction
+
+Monospace cells are about twice as tall as wide. Real cell aspect depends on the font: measure once.
+
+```js
+function measureCellAspect(fontFamily = 'monospace', fontPx = 16) {
+  const cv = document.createElement('canvas');
+  const ctx = cv.getContext('2d');
+  ctx.font = `${fontPx}px ${fontFamily}`;
+  const w = ctx.measureText('M').width;           // glyph advance width
+  const h = fontPx * 1.0;                          // with line-height: 1
+  return w / h;                                    // ~0.5 for most fonts
+}
+```
+
+Compute the character grid for a source image, correcting aspect so the picture is not vertically stretched:
+```js
+function gridSize(imgW, imgH, cols, cellAspect = 0.5) {
+  const rows = Math.round(cols * (imgH / imgW) * cellAspect);
+  return { cols, rows };
+}
+```
+Draw the source into an offscreen canvas at exactly `cols × rows`, then read all pixels once with `getImageData(0, 0, cols, rows)`. One `getImageData` call per frame is far cheaper than per-pixel reads.
+
+## `<pre>` vs canvas
+
+| Aspect | `<pre>` + textContent | Canvas `fillText` |
+|--------|----------------------|-------------------|
+| Setup  | trivial, one string  | per-cell draw loop |
+| Color  | single color (or per-span, slow) | per-char color cheap |
+| Max size | ~120×60 @ 30fps    | thousands of cells @ 60fps |
+| Selectable text | yes           | no |
+| Best for | generative fields, loaders | video, per-char color, large grids |
+
+`<pre>` styling that avoids gaps and stretching:
+```css
+pre { font-family: ui-monospace, monospace; line-height: 1; letter-spacing: 0;
+      margin: 0; white-space: pre; }
+```
+
+Canvas per-char color renderer:
+```js
+function drawAsciiCanvas(ctx, chars, colors, cols, rows, cellW, cellH) {
+  ctx.clearRect(0, 0, cols * cellW, rows * cellH);
+  ctx.textBaseline = 'top';
+  ctx.font = `${cellH}px monospace`;
+  for (let y = 0; y < rows; y++) {
+    for (let x = 0; x < cols; x++) {
+      const i = y * cols + x;
+      ctx.fillStyle = colors[i];                   // e.g. `rgb(r,g,b)`
+      ctx.fillText(chars[i], x * cellW, y * cellH);
+    }
+  }
+}
+```
+
+## ANSI terminal frame loop (Node)
+
+```js
+const ESC = '\x1b[';
+const out = process.stdout;
+
+function start(render, fps = 20) {
+  out.write(ESC + '?25l');                          // hide cursor
+  out.write(ESC + '2J');                            // clear screen once
+  const interval = 1000 / fps;
+  let start = Date.now();
+  const id = setInterval(() => {
+    const t = Date.now() - start;
+    out.write(ESC + 'H');                           // home (cheap, no full clear)
+    out.write(render(t, out.columns || 80, out.rows || 24));
+  }, interval);
+  const stop = () => {
+    clearInterval(id);
+    out.write(ESC + '0m' + ESC + '?25h' + ESC + '2J' + ESC + 'H');
+    process.exit(0);
+  };
+  process.on('SIGINT', stop);
+  return stop;
+}
+
+// Truecolor per character: foreground `\x1b[38;2;R;G;Bm`, reset `\x1b[0m`.
+function colored(ch, r, g, b) {
+  return `${ESC}38;2;${r};${g};${b}m${ch}${ESC}0m`;
+}
+
+// Example: plasma using full terminal size
+start((t, cols, rows) => {
+  const ramp = ' .:-=+*#%@';
+  let s = '';
+  for (let y = 0; y < rows - 1; y++) {
+    for (let x = 0; x < cols; x++) {
+      const v = Math.sin(x * 0.15 + t * 0.001)
+              + Math.sin(y * 0.25 + t * 0.0015)
+              + Math.sin((x + y) * 0.1 + t * 0.0008);
+      const lum = (v + 3) / 6;
+      s += ramp[Math.round(lum * (ramp.length - 1))];
+    }
+    s += '\n';
+  }
+  return s;
+});
+```
+Notes: writing `ESC + 'H'` (home) and overwriting is much smoother than clearing the screen every frame, which causes flicker. Avoid printing a trailing newline on the last row or the terminal scrolls. `out.columns`/`out.rows` give the live terminal size; recompute the grid on `process.stdout.on('resize', ...)`.
+
+## Three.js AsciiEffect — complete wiring
+
+```js
+import * as THREE from 'three';
+import { AsciiEffect } from 'three/addons/effects/AsciiEffect.js';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+
+const renderer = new THREE.WebGLRenderer();
+renderer.setSize(innerWidth, innerHeight);
+
+const effect = new AsciiEffect(renderer, ' .:-=+*#%@', { invert: true, resolution: 0.2 });
+effect.setSize(innerWidth, innerHeight);
+effect.domElement.style.color = 'white';
+effect.domElement.style.backgroundColor = 'black';
+document.body.appendChild(effect.domElement);      // append the EFFECT's DOM, not renderer.domElement
+
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(70, innerWidth / innerHeight, 1, 1000);
+camera.position.z = 4;
+scene.add(new THREE.PointLight(0xffffff, 3).position.set(5, 5, 5));
+scene.add(new THREE.AmbientLight(0x808080));
+const mesh = new THREE.Mesh(
+  new THREE.TorusKnotGeometry(1, 0.3, 100, 16),
+  new THREE.MeshStandardMaterial({ flatShading: true })
+);
+scene.add(mesh);
+
+const controls = new OrbitControls(camera, effect.domElement); // attach to effect DOM
+
+function animate(t) {
+  mesh.rotation.y = t * 0.0005;
+  effect.render(scene, camera);                    // render through the effect
+  requestAnimationFrame(animate);
+}
+requestAnimationFrame(animate);
+
+addEventListener('resize', () => {
+  camera.aspect = innerWidth / innerHeight; camera.updateProjectionMatrix();
+  effect.setSize(innerWidth, innerHeight);
+});
+```
+Key gotchas: append `effect.domElement` (not the renderer's canvas) and call `effect.render`, not `renderer.render`. `resolution` (default ~0.15) controls character density; lower = fewer, larger characters. Lighting matters — ASCII reads luminance, so use strong directional contrast and `flatShading` for crisp edges.
+
+---
+Map brightness to the right glyph ramp and the characters come alive. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=ascii-animation)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/ascii-animation/scripts/img-to-ascii.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// img-to-ascii.mjs — Convert a PNG/JPG image to ASCII text.
+//
+// Usage:
+//   node img-to-ascii.mjs <image> [--cols 120] [--invert] [--ramp " .:-=+*#%@"]
+//
+// Dependency: sharp (npm i sharp). Sharp decodes PNG/JPG/WebP and resizes.
+//
+// Notes:
+//  - Applies monospace cell-aspect correction (cells are ~2x taller than wide),
+//    so rows = cols * (imgH/imgW) * 0.5.
+//  - Luminance uses sRGB perceptual weights (0.2126/0.7152/0.0722).
+
+import sharp from 'sharp';
+
+function parseArgs(argv) {
+  const args = { cols: 120, invert: false, ramp: ' .:-=+*#%@', file: null };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--cols') args.cols = parseInt(argv[++i], 10);
+    else if (a === '--invert') args.invert = true;
+    else if (a === '--ramp') args.ramp = argv[++i];
+    else if (!a.startsWith('--')) args.file = a;
+  }
+  return args;
+}
+
+async function main() {
+  const { cols, invert, ramp, file } = parseArgs(process.argv);
+  if (!file) {
+    console.error('Usage: node img-to-ascii.mjs <image> [--cols N] [--invert] [--ramp "..."]');
+    process.exit(1);
+  }
+
+  const CELL_ASPECT = 0.5; // monospace width:height
+  const meta = await sharp(file).metadata();
+  const rows = Math.max(1, Math.round(cols * (meta.height / meta.width) * CELL_ASPECT));
+
+  // Resize to the character grid, drop alpha, get raw RGB bytes.
+  const { data } = await sharp(file)
+    .resize(cols, rows, { fit: 'fill' })
+    .removeAlpha()
+    .raw()
+    .toBuffer({ resolveWithObject: true });
+
+  const last = ramp.length - 1;
+  const lines = [];
+  for (let y = 0; y < rows; y++) {
+    let line = '';
+    for (let x = 0; x < cols; x++) {
+      const i = (y * cols + x) * 3;
+      let lum = (0.2126 * data[i] + 0.7152 * data[i + 1] + 0.0722 * data[i + 2]) / 255;
+      if (invert) lum = 1 - lum;
+      line += ramp[Math.round(lum * last)];
+    }
+    lines.push(line);
+  }
+  process.stdout.write(lines.join('\n') + '\n');
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

.agents/skills/glassmorphism/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: glassmorphism
+description: This skill should be used when the user asks to "add a glassmorphism effect", "frosted glass UI", "Apple liquid glass style", "frosted blur card", "translucent glass panel animation", "make a frosted nav bar", "build a glass modal/dialog", "animate a glass card on hover", or "add a refracting liquid-glass hero". Covers frosted translucent panels with backdrop-filter blur, edge/specular highlights, SVG liquid-glass refraction, motion on hover/scroll/enter, and accessible reduced-transparency fallbacks.
+version: 0.1.0
+---
+
+# Glassmorphism (Frosted & Liquid Glass)
+
+Translucent, frosted UI: panels you can see through, blurred so the backdrop reads as soft color, rimmed by a bright edge of light, floating on layered shadow. The 2026 "liquid glass" evolution adds refraction — the background visibly bends through the panel — plus moving specular highlights. The goal is depth and material, not just opacity.
+
+## When to use
+
+- Frosted cards, nav bars, sidebars, modals/dialogs, and toolbars over busy/photo backgrounds
+- Login/hero panels and overlays that should feel layered above the page
+- Apple-style "liquid glass" heroes: refracting, slowly churning surfaces with a specular sweep
+- Hover/scroll/enter motion on glass — frost deepening, highlight brightening, the panel lifting
+- Any place where content needs to read as floating glass while staying legible
+
+## The four ingredients of believable glass
+
+Glass is never one property. Every panel needs all four, or it reads as a plain translucent box:
+
+1. **Frost** — `backdrop-filter: blur()` plus `saturate()` to keep backdrop color vivid through the blur.
+2. **Translucency** — a `background` with alpha (~0.08–0.18), never fully opaque, never fully clear.
+3. **Edge of glass** — a hairline border *brighter* than the fill, ideally a lit top-left → dim bottom-right highlight, so the rim catches light.
+4. **Depth** — layered `box-shadow`: an ambient drop shadow to float it, plus an `inset` top highlight and bottom shade to round the surface.
+
+```css
+.glass {
+  background: rgba(255, 255, 255, 0.12);
+  backdrop-filter: blur(16px) saturate(160%);
+  -webkit-backdrop-filter: blur(16px) saturate(160%); /* Safari needs the prefix */
+  border-radius: 20px;
+  border: 1px solid rgba(255, 255, 255, 0.25);
+  box-shadow:
+    0 8px 32px rgba(0, 0, 0, 0.25),     /* float */
+    inset 0 1px 0 rgba(255, 255, 255, 0.35), /* top highlight */
+    inset 0 -1px 0 rgba(0, 0, 0, 0.12);      /* bottom shade */
+}
+```
+
+Frost tiers: light UI chrome `blur(8–12px)` / alpha `0.08–0.14`; heavy modal/login `blur(24–40px)` / alpha `0.10–0.18`. Dark glass: fill `rgba(0,0,0,0.3)`, softer top highlight.
+
+**`backdrop-filter` only blurs content that sits behind the element.** Over a flat background color it does nothing visible — glass needs a busy backdrop (image, gradient, video) to frost.
+
+## Specular edge highlight and anti-banding grain
+
+A flat border is dead. Draw a masked 1px ring with a lit corner via `::before`, and dither away gradient **banding** (stepped contour lines under heavy blur) with a faint `feTurbulence` noise overlay via `::after` at `opacity ≤ 0.06`. Full masked-border and inline-noise recipes are in `references/glass-recipes.md`.
+
+## Motion: animate the glass, not the geometry
+
+Animate the *qualities* of the glass — frost deepening, highlight brightening, the panel lifting — so it reads as the surface "leaning into the light."
+
+```css
+.glass {
+  transition: backdrop-filter .4s ease, background .4s ease,
+              box-shadow .4s ease, transform .4s cubic-bezier(.16,1,.3,1);
+}
+.glass:hover {
+  backdrop-filter: blur(24px) saturate(180%);
+  background: rgba(255,255,255,.18);
+  transform: translateY(-4px);
+  box-shadow: 0 16px 48px rgba(0,0,0,.3), inset 0 1px 0 rgba(255,255,255,.5);
+}
+```
+
+- **Entrance** (frost resolving from clear): pair a `[data-enter]` transition with `@starting-style { backdrop-filter: blur(0); opacity: 0; transform: translateY(16px) }`.
+- **Specular sweep**: a skewed white gradient animated across the surface on hover or as a slow ambient loop.
+- **Caveat**: animating the blur *radius* is the most expensive thing here — the backdrop is re-blurred every frame. If hover janks, animate `transform`/`box-shadow`/`background` (cheap) and keep the blur delta small or snap it.
+
+## Liquid glass — SVG refraction (the 2026 look)
+
+Bend the background through the panel like a thick lens: drive `feDisplacementMap` from animated `feTurbulence`, applied via `filter` (it distorts the element's own pixels) layered over a `backdrop-filter` frost.
+
+```html
+<svg width="0" height="0" style="position:absolute"><filter id="liquid-glass">
+  <feTurbulence type="fractalNoise" baseFrequency="0.008 0.012" numOctaves="2" seed="3" result="n">
+    <animate attributeName="baseFrequency" dur="18s"
+             values="0.008 0.012;0.012 0.008;0.008 0.012" repeatCount="indefinite"/>
+  </feTurbulence>
+  <feDisplacementMap in="SourceGraphic" in2="n" scale="22" xChannelSelector="R" yChannelSelector="G"/>
+</filter></svg>
+```
+
+`scale` = refraction strength (8–14 subtle, 20–30 pronounced, >40 molten). Lower `baseFrequency` = larger, slower waves (more liquid). Keep the `animate` `dur` long (12–20s) so it breathes. These filters are heavy — use on **one** hero element, not a grid.
+
+## Performance — backdrop-filter is expensive
+
+- Each glass element re-samples and blurs everything behind it. **Limit the count**; a dozen on screen tanks scroll FPS.
+- Promote heavy glass to its own layer (`transform: translateZ(0)` or `will-change: transform`), and remove `will-change` after the animation.
+- Don't stack `backdrop-filter` elements over each other — nested blur re-blurs the blur (quadratic cost).
+- Big radii (>40px) over large areas are the worst case; cap radius and panel size.
+
+## Accessibility — non-negotiable
+
+Glass is decoration; content must stay legible and the effect must be defeatable.
+
+```css
+@media (prefers-reduced-transparency: reduce) {
+  .glass { background: #1a1a2e; backdrop-filter: none; -webkit-backdrop-filter: none; }
+  .glass::after { display: none; }            /* drop grain */
+}
+@media (prefers-reduced-motion: reduce) {
+  .glass { transition: none; }
+  .liquid { filter: none; }                   /* stop the refraction churn */
+}
+@supports not (backdrop-filter: blur(1px)) {
+  .glass { background: rgba(30,30,50,.85); }  /* opaque-enough fallback */
+}
+```
+
+**Contrast over busy backgrounds**: translucent panels over photos can drop text below WCAG. Add a semi-opaque scrim or darkening gradient *under* the text, optionally `text-shadow: 0 1px 2px rgba(0,0,0,.4)`, and verify ≥ 4.5:1 body / ≥ 3:1 large against the *brightest* region of the backdrop.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained glass demo (card, nav, modal, liquid-glass hero) the deliverable is **one HTML file that opens directly in a browser** — markup, CSS, and (if liquid) one inline SVG filter, no build step. A single file is the right tier for a glass surface; don't reach for a bundler. The panel **must overlap a real backdrop** (drop in a photo or gradient) or there is nothing to frost and the demo lies.
+
+**Output contract:**
+- One `.html` file: a busy backdrop, your glass markup, the CSS (frost + edge highlight + grain + shadows), and any inline SVG `feDisplacementMap` filter.
+- A way to land on the **resolved state** *and* a **frozen frame** of any loop — glass verifies by both state (rest/hover/enter) and time (the sweep/refraction).
+- Include the freeze harness below so any moment can be pinned for inspection.
+
+**Seek harness — pin a deterministic state + frame.** `?state=hover` forces the hover look; `?t=N` freezes CSS animations and the SVG refraction at `N` seconds, so a screenshot lands on a still, deterministic frame:
+
+```html
+<script>
+  const p = new URLSearchParams(location.search);
+  const state = p.get("state");
+  if (state) document.documentElement.dataset.state = state;   // CSS keys off :root[data-state="hover"]
+  const t = p.get("t");
+  if (t !== null) {
+    document.getAnimations().forEach(a => { a.currentTime = parseFloat(t)*1000; a.pause(); }); // freeze CSS sweep
+    const svg = document.querySelector("svg");
+    svg?.pauseAnimations?.(); svg?.setCurrentTime?.(parseFloat(t));                            // freeze refraction
+  }
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — render → set state/freeze → screenshot → check:** open each meaningful state (`?state=rest`, `?state=hover`) and a frozen loop frame (`?t=2`), screenshot, and confirm the glass **reads as glass** — blur and edge highlight visibly present, no color banding, text contrast holds over the backdrop — plus check **artifacts** (flat box because the backdrop is plain color, missing `-webkit-` prefix in Safari, refraction too strong/molten, jank from animating blur). Then load `prefers-reduced-transparency` and confirm the **solid fallback renders** legibly. Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/glass.html?state=hover" hover.png
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/glass.html?t=2"          loop.png
+```
+
+To check the fallback headlessly, emulate the media feature (e.g. Playwright `--color-scheme`-style flags, or a `?reduced=1` query that toggles a class mirroring the media query) and screenshot that the panel is solid and readable.
+
+**Before you finish:**
+1. Opens standalone — no console errors; the glass overlaps a real busy backdrop, not a flat color.
+2. Reads as glass — blur + bright edge highlight both visible, layered shadow floats it, no banding (grain present).
+3. Text contrast holds over the brightest part of the backdrop (≥ 4.5:1 body).
+4. `?state=` / `?t=N` freeze lands a deterministic, settled frame.
+5. `prefers-reduced-transparency` → solid opaque panel; `prefers-reduced-motion` → refraction/sweep stopped; `@supports` fallback for no `backdrop-filter`.
+6. Performance sane — glass count limited, blur not animated on a janky path, liquid refraction on one element only.
+
+## Quick reference
+
+| Need | Approach |
+|------|----------|
+| Base frost | `backdrop-filter: blur(16px) saturate(160%)` + alpha bg |
+| Edge of glass | brighter `border` + masked `::before` lit-corner ring |
+| Float / depth | `box-shadow` drop + `inset` top highlight & bottom shade |
+| Kill banding | `feTurbulence` noise `::after`, `opacity ≤ .06` |
+| Hover motion | transition `transform`/`box-shadow`/`background`, small blur delta |
+| Entrance | `@starting-style { backdrop-filter: blur(0); opacity:0 }` |
+| Liquid refraction | `feDisplacementMap` ← animated `feTurbulence`, via `filter` |
+| Specular sweep | skewed white gradient animated across surface |
+| Safari | always pair `-webkit-backdrop-filter` |
+| Reduced transparency | solid opaque panel, drop grain |
+| No backdrop-filter | `@supports not (...)` opaque-enough fallback |
+
+## Reference files
+
+- `references/glass-recipes.md` — full copy-paste recipes: base glass card with tiers, the masked specular edge ring, anti-banding grain, hover/enter/scroll motion, the specular sweep, the SVG `feDisplacementMap`/`feTurbulence` liquid-glass filter with tuning knobs, performance rules, the reduced-transparency/reduced-motion/`@supports` fallbacks, contrast defenses, and the standalone freeze harness.

.agents/skills/glassmorphism/references/glass-recipes.md

@@ -0,0 +1,242 @@
+# Glassmorphism Recipes
+
+Copy-paste recipes for frosted translucent panels, the "edge of glass" highlight, animated liquid-glass refraction, and the reduced-transparency fallback. All standalone CSS + optional inline SVG — no build step.
+
+## 1. The base glass card
+
+The four ingredients of believable glass: **blur** (frost), **translucency** (you see through it), **edge highlight** (light catches the rim), **layered shadow** (it floats). Plus a touch of `saturate()` so the backdrop reads vivid through the frost.
+
+```css
+.glass {
+  /* translucency — never fully opaque, never fully clear */
+  background: rgba(255, 255, 255, 0.12);
+  /* frost: blur the backdrop, lift saturation so color survives the blur */
+  backdrop-filter: blur(16px) saturate(160%);
+  -webkit-backdrop-filter: blur(16px) saturate(160%); /* Safari still needs the prefix */
+  border-radius: 20px;
+  /* edge of glass: a hairline border slightly brighter than the fill */
+  border: 1px solid rgba(255, 255, 255, 0.25);
+  /* depth: ambient drop + a top inner highlight + a bottom inner shade */
+  box-shadow:
+    0 8px 32px rgba(0, 0, 0, 0.25),
+    inset 0 1px 0 rgba(255, 255, 255, 0.35),
+    inset 0 -1px 0 rgba(0, 0, 0, 0.12);
+}
+```
+
+Tuning by tier:
+- **Light frost** (UI chrome over content): `blur(8–12px)`, alpha `0.08–0.14`.
+- **Heavy frost** (modal scrim, login card): `blur(24–40px)`, alpha `0.10–0.18`.
+- Dark glass: swap the fill to `rgba(0,0,0,0.3)` and the top inner highlight to a softer white.
+
+`backdrop-filter` only has anything to blur if there is content **behind** the element — it must overlap a busy background (image, gradient, video). On a flat color it looks like a plain translucent box.
+
+## 2. The specular edge highlight (the rim of light)
+
+A single border is flat. Real glass catches a bright sweep along the top-left edge and falls off. Layer a soft conic/linear highlight via a pseudo-element with a masked border.
+
+```css
+.glass {
+  position: relative;
+  isolation: isolate; /* keep the highlight blend local */
+}
+.glass::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  padding: 1px;                       /* border thickness */
+  background: linear-gradient(
+    135deg,
+    rgba(255, 255, 255, 0.7),
+    rgba(255, 255, 255, 0) 40%,
+    rgba(255, 255, 255, 0) 60%,
+    rgba(255, 255, 255, 0.25)
+  );
+  /* mask trick: show only the 1px ring, punch out the interior */
+  -webkit-mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+          mask-composite: exclude;
+  pointer-events: none;
+}
+```
+
+This gives the panel a lit top-left corner and a dim bottom-right, the cue the brain reads as "curved glass under a light."
+
+## 3. Kill banding with grain
+
+Heavy `blur()` over a smooth gradient produces visible color **banding** (stepped contour lines). A faint noise overlay dithers it away.
+
+```css
+.glass::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  pointer-events: none;
+  opacity: 0.04;                       /* barely there */
+  mix-blend-mode: overlay;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
+}
+```
+
+`feTurbulence` generates the noise tile inline — no asset file. Keep opacity ≤ 0.06 or it reads as texture, not dither.
+
+## 4. Motion: animate the glass on hover / enter / scroll
+
+Animate the *qualities* of the glass, not its geometry. Frost deepening and the highlight brightening on hover reads as the panel "leaning into the light."
+
+```css
+.glass {
+  transition:
+    backdrop-filter 0.4s ease,
+    background 0.4s ease,
+    box-shadow 0.4s ease,
+    transform 0.4s cubic-bezier(0.16, 1, 0.3, 1);
+}
+.glass:hover {
+  backdrop-filter: blur(24px) saturate(180%);
+  background: rgba(255, 255, 255, 0.18);
+  transform: translateY(-4px);
+  box-shadow:
+    0 16px 48px rgba(0, 0, 0, 0.3),
+    inset 0 1px 0 rgba(255, 255, 255, 0.5);
+}
+```
+
+Caveat: animating `backdrop-filter` itself is the most expensive thing here — the backdrop is re-sampled and re-blurred every frame. If hover feels janky, animate only `transform` + `box-shadow` + `background` (cheaper) and snap the blur, or keep the blur change small.
+
+**Entrance** (frost resolving in) reads beautifully with `@starting-style`:
+
+```css
+.glass[data-enter] {
+  transition: opacity 0.5s ease, backdrop-filter 0.6s ease, transform 0.5s ease;
+}
+@starting-style {
+  .glass[data-enter] {
+    opacity: 0;
+    backdrop-filter: blur(0px) saturate(100%);
+    transform: translateY(16px) scale(0.98);
+  }
+}
+```
+
+**Specular sweep** — a moving glint across the surface on hover or as an ambient loop:
+
+```css
+.glass .sweep {
+  position: absolute; inset: 0; border-radius: inherit; overflow: hidden; pointer-events: none;
+}
+.glass .sweep::before {
+  content: ""; position: absolute; top: 0; left: -60%; width: 50%; height: 100%;
+  background: linear-gradient(105deg, transparent, rgba(255,255,255,0.35), transparent);
+  transform: skewX(-15deg);
+  animation: sweep 4s ease-in-out infinite;
+}
+@keyframes sweep { 0%,100% { left: -60%; } 50% { left: 110%; } }
+```
+
+## 5. Liquid glass — SVG refraction (the 2026 look)
+
+Apple-style "liquid glass" bends the background as if seen through a thick, wobbling lens. Drive a `feDisplacementMap` from animated `feTurbulence` and apply it via `filter` (note: `filter`, not `backdrop-filter` — it distorts the element's own rendered content; layer it over a `backdrop-filter` frost for the full effect).
+
+```html
+<svg width="0" height="0" style="position:absolute">
+  <filter id="liquid-glass">
+    <feTurbulence type="fractalNoise" baseFrequency="0.008 0.012"
+                  numOctaves="2" seed="3" result="noise">
+      <!-- animate the field so the refraction slowly churns -->
+      <animate attributeName="baseFrequency"
+               dur="18s" values="0.008 0.012; 0.012 0.008; 0.008 0.012"
+               repeatCount="indefinite"/>
+    </feTurbulence>
+    <feDisplacementMap in="SourceGraphic" in2="noise"
+                       scale="22" xChannelSelector="R" yChannelSelector="G"/>
+  </filter>
+</svg>
+```
+
+```css
+.liquid {
+  backdrop-filter: blur(6px) saturate(150%); /* light frost under the refraction */
+  filter: url(#liquid-glass);                 /* the lens distortion */
+}
+```
+
+Knobs:
+- `scale` on `feDisplacementMap` = refraction strength. 8–14 = subtle ripple; 20–30 = pronounced lens; >40 = molten.
+- Lower `baseFrequency` = larger, slower waves (more "liquid"); higher = tight, busy ripples.
+- Animate `baseFrequency` (above) or `scale` for a living surface. Keep `dur` long (12–20s) so it breathes rather than shimmers.
+
+Cost warning: SVG displacement filters are heavy and force off-GPU paths in some browsers. Use on **one** hero element, not a grid of cards. Test on a mid-range laptop; drop to plain `backdrop-filter` if frames stutter.
+
+## 6. Performance — backdrop-filter is expensive
+
+- Each `backdrop-filter` element re-samples and blurs everything behind it. **Limit the count** — a dozen glass cards on screen will tank scroll FPS.
+- Promote heavy glass to its own compositor layer: `transform: translateZ(0)` or `will-change: transform` (remove `will-change` after the animation; leaving it on wastes memory).
+- Avoid stacking `backdrop-filter` elements over each other (nested blur re-blurs the blur — quadratic cost).
+- Prefer animating `transform`/`opacity`/`box-shadow` over animating the blur radius. If you must animate blur, keep the radius delta small.
+- Big blur radii (>40px) over large areas are the single worst case; cap the radius and the panel size.
+
+## 7. Accessibility — non-negotiable
+
+Glass is decorative; the content on it must stay legible and the effect must be defeatable.
+
+**Honor reduced transparency and reduced motion** — fall back to a solid, opaque panel:
+
+```css
+@media (prefers-reduced-transparency: reduce) {
+  .glass {
+    background: #1a1a2e;            /* solid, accessible panel */
+    backdrop-filter: none;
+    -webkit-backdrop-filter: none;
+    border-color: rgba(255, 255, 255, 0.15);
+  }
+  .glass::after { display: none; }  /* drop grain/noise */
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .glass, .glass .sweep::before { transition: none; animation: none; }
+  .liquid { filter: none; }         /* stop the churning refraction */
+}
+```
+
+**Contrast over busy backgrounds.** Translucent panels over photos can drop text below WCAG contrast. Defenses:
+- Put a contrast floor *under* the text: a semi-opaque scrim or a darkening gradient inside the panel.
+- Add `text-shadow: 0 1px 2px rgba(0,0,0,0.4)` to body text on glass.
+- Target ≥ 4.5:1 for body text, ≥ 3:1 for large text — and verify against the *brightest* region of the backdrop, not the average.
+
+**Feature fallback** for browsers without `backdrop-filter`:
+
+```css
+@supports not (backdrop-filter: blur(1px)) {
+  .glass { background: rgba(30, 30, 50, 0.85); } /* opaque-enough fallback */
+}
+```
+
+## 8. Standalone freeze harness
+
+Glass demos verify by *state* (rest / hover / enter) and *time* (the sweep/refraction loop). Wire both so a screenshot lands deterministically:
+
+```html
+<script>
+  const p = new URLSearchParams(location.search);
+  const state = p.get("state");           // ?state=hover → force the hover look
+  if (state) document.documentElement.dataset.state = state;
+  const t = p.get("t");                    // ?t=2 → freeze CSS animations at 2s
+  if (t !== null) {
+    document.getAnimations().forEach(a => { a.currentTime = parseFloat(t) * 1000; a.pause(); });
+    // SVG SMIL (the <animate>): pin the refraction frame too
+    document.querySelector("svg")?.pauseAnimations?.();
+    document.querySelector("svg")?.setCurrentTime?.(parseFloat(t));
+  }
+  window.__ready = true;
+</script>
+```
+
+CSS drives the forced state: `:root[data-state="hover"] .glass { /* hover values */ }`.
+
+---
+Frosted glass that reads as glass — blur, edge light, and refraction, with a clean fallback. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=glassmorphism)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/gsap-web/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: gsap-web
+description: This skill should be used when the user asks to "build a scroll animation", "add ScrollTrigger", "pin a section while scrolling", "scrub an animation to scroll", "create a hero timeline", "do a horizontal scroll section", "split text and animate words", "animate a layout change with GSAP Flip", "sync ScrollTrigger with Lenis", "Lenis smooth scroll jittery", "ScrollTrigger markers drift", "ScrollTrigger pins break with Lenis/Locomotive", or "set up smooth scroll with GSAP pinning". Covers GSAP timelines, ScrollTrigger, SplitText, Flip, and Lenis/Locomotive smooth-scroll sync for code-driven web motion.
+version: 0.1.0
+---
+
+# GSAP for the Web
+
+GSAP (GreenSock Animation Platform) is the workhorse for code-driven web motion: sequenced timelines, scroll-driven storytelling, text reveals, and layout transitions. As of GSAP 3.12+, every plugin (ScrollTrigger, SplitText, Flip, MotionPath, MorphSVG, Draggable, Observer) is 100% free, including for commercial use.
+
+## When to use
+
+- Scroll-driven storytelling: pinned sections, parallax, progress scrubbing, horizontal scroll
+- Sequenced hero animations and complex multi-element timelines with precise overlap control
+- Text reveals split into chars/words/lines (SplitText)
+- Layout transitions where an element changes position/size/parent (Flip)
+- Any motion needing fine timing control, easing precision, or imperative orchestration
+
+## Install and register
+
+```js
+import gsap from "gsap";
+import { ScrollTrigger } from "gsap/ScrollTrigger";
+import { SplitText } from "gsap/SplitText";
+import { Flip } from "gsap/Flip";
+
+gsap.registerPlugin(ScrollTrigger, SplitText, Flip);
+```
+
+Plugins MUST be registered before use or they silently no-op. With a bundler, register once at app entry.
+
+## Core techniques
+
+### Timelines first
+
+Prefer one timeline over many independent tweens — it gives a single playhead, relative positioning, and easy reversal.
+
+```js
+const tl = gsap.timeline({ defaults: { ease: "power3.out", duration: 0.6 } });
+tl.from(".title", { yPercent: 100, opacity: 0 })
+  .from(".sub",   { y: 20, opacity: 0 }, "-=0.3")  // start 0.3s before prev ends
+  .from(".cta",   { scale: 0.9, opacity: 0 }, "<"); // align to prev tween START
+```
+
+Position parameter cheat sheet:
+- `"+=0.5"` / `"-=0.3"` — relative to the end of the timeline (gap / overlap)
+- `"<"` — start of the previous tween; `">"` — end of the previous tween
+- `"<0.2"` — 0.2s after the previous tween's start
+- `"myLabel"` — at a named label added via `tl.addLabel("myLabel")`
+
+Use `.from()` for entrances (animates FROM the given values TO current CSS), `.to()` for exits, `.fromTo()` when both ends must be explicit (most robust against re-runs).
+
+### gsap.to vs set vs quickTo
+
+```js
+gsap.set(el, { autoAlpha: 0 });           // instant, no tween (autoAlpha = opacity + visibility)
+const xTo = gsap.quickTo(el, "x", { duration: 0.4, ease: "power3" });
+window.addEventListener("pointermove", (e) => xTo(e.clientX)); // fast repeated updates
+```
+
+`autoAlpha` is preferred over raw `opacity` because it also toggles `visibility:hidden` at 0, removing the element from hit-testing.
+
+### ScrollTrigger basics
+
+```js
+gsap.to(".panel", {
+  xPercent: -100,
+  ease: "none",
+  scrollTrigger: {
+    trigger: ".wrap",
+    start: "top top",      // when trigger top hits viewport top
+    end: "+=2000",         // 2000px of scroll distance
+    pin: true,             // freeze .wrap while the tween plays
+    scrub: 1,              // tie progress to scrollbar (1 = 1s catch-up smoothing)
+    markers: true,         // dev-only visual markers — remove for prod
+  },
+});
+```
+
+Key semantics:
+- `start`/`end` take `"triggerPos viewportPos"` (e.g. `"top center"`) or `"+=px"`.
+- `scrub: true` locks animation progress to scroll exactly; `scrub: <number>` adds smoothing lag.
+- `toggleActions: "play pause resume reverse"` controls onEnter/onLeave/onEnterBack/onLeaveBack for non-scrubbed triggers.
+- Use `ease: "none"` for scrubbed tweens so motion tracks scroll linearly.
+
+### Smooth scroll (Lenis) + ScrollTrigger
+
+Pairing Lenis (or Locomotive) smooth scrolling with ScrollTrigger desyncs unless both run on one loop. Lenis smooths scroll on its own rAF while ScrollTrigger reads scroll on GSAP's ticker; when they tick independently ScrollTrigger samples a stale position. The fix: drive Lenis from GSAP's ticker and update ScrollTrigger on every Lenis scroll.
+
+```js
+import Lenis from "lenis";
+
+const lenis = new Lenis({ duration: 1.2, smoothWheel: true });
+
+lenis.on("scroll", ScrollTrigger.update);          // 1. update ScrollTrigger on every Lenis scroll
+gsap.ticker.add((t) => lenis.raf(t * 1000));       // 2. one loop: ticker drives Lenis (seconds → ms)
+gsap.ticker.lagSmoothing(0);                        // 3. stop GSAP catch-up jitter on heavy frames
+```
+
+Critical: `gsap.ticker` passes time in **seconds**, `lenis.raf()` wants **milliseconds** — multiply by 1000. Do NOT also run a standalone `requestAnimationFrame(raf)` loop for Lenis; that double-drives it.
+
+Common bugs:
+- **Jitter/stutter** — a leftover `requestAnimationFrame(raf)` loop competing with the ticker, or missing `lagSmoothing(0)`. Remove the rogue loop; set lag smoothing to 0.
+- **Markers drift** from their triggers — `ScrollTrigger.update` is not subscribed to `lenis.on("scroll", …)`.
+- **Pins break** — under Lenis do NOT set a `scrollerProxy` (it scrolls the document). Under Locomotive you MUST wire `scrollerProxy` + `pinType` and set `scroller:` on every trigger.
+- **Scroll stuck / flipped direction** — missing the `* 1000` unit conversion, or two loops out of order.
+
+Cleanup on SPA unmount: `gsap.ticker.remove(update)` + `lenis.destroy()`, else loops stack per navigation. Gate behind `prefers-reduced-motion` (skip Lenis, run native scroll). Full Lenis + Locomotive wiring, anchor-link routing, `data-lenis-prevent`, React (`useGSAP`/`useEffect`), and a symptom→cause table are in `references/scrolltrigger-lenis.md`.
+
+### SplitText (text reveal)
+
+```js
+const split = SplitText.create(".headline", { type: "lines, words", linesClass: "line" });
+gsap.from(split.lines, { yPercent: 100, opacity: 0, stagger: 0.08, duration: 0.7, ease: "power4.out" });
+```
+
+Gotchas:
+- Wrap line-mask reveals: set `overflow: hidden` on the line wrapper so `yPercent: 100` hides cleanly. Add `autoSplit: true` (GSAP 3.13+) to re-split on font load / resize.
+- Call `split.revert()` before re-splitting or on unmount to restore original DOM and avoid duplicated nodes.
+- Always split AFTER web fonts load (`document.fonts.ready.then(...)`) to prevent wrong line breaks.
+
+### Flip (layout transitions)
+
+Flip records state, lets the DOM change instantly, then animates the visual difference (FLIP technique). Ideal for grid<->list, expanding cards, and reparenting.
+
+```js
+const state = Flip.getState(".item");   // 1. capture BEFORE
+container.classList.toggle("grid");      // 2. mutate DOM/CSS (instant)
+Flip.from(state, {                        // 3. animate the delta
+  duration: 0.6, ease: "power2.inOut", stagger: 0.05,
+  absolute: true,                         // take items out of flow during move (prevents reflow jitter)
+});
+```
+
+### Easing quick guide
+
+- `power2/3.out` — entrances (fast then settle)
+- `power2.inOut` — moves between two on-screen states
+- `back.out(1.7)` — overshoot/pop (number = overshoot amount)
+- `elastic.out(1, 0.3)` — bouncy, use sparingly
+- `none` — scrubbed scroll tweens
+- `steps(n)` — sprite/stepped motion
+- Custom cubic-bezier equivalent: `CustomEase.create("x", "M0,0 C0.2,0 0,1 1,1")` (CustomEase is free)
+
+## Performance and cleanup
+
+- Animate `transform` (`x/y/xPercent/scale/rotation`) and `opacity` only — they are GPU-composited and skip layout/paint. Avoid animating `top/left/width/height`.
+- Set `will-change: transform` on heavy/pinned elements; remove after.
+- Batch many similar scroll reveals with `ScrollTrigger.batch()` instead of one trigger per element.
+- After a viewport/content change, call `ScrollTrigger.refresh()`.
+
+SPA / framework cleanup is mandatory — orphaned triggers cause memory leaks and ghost pinning. Use `gsap.context()` (or `useGSAP` from `@gsap/react`):
+
+```js
+useEffect(() => {
+  const ctx = gsap.context(() => {
+    // all gsap + ScrollTrigger code here
+  }, rootRef);
+  return () => ctx.revert(); // kills tweens, triggers, and reverts inline styles
+}, []);
+```
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained animation (hero, reveal, loop, micro-scene) the deliverable is **one HTML file that opens directly in a browser** — no build step, no framework, no render pipeline. Match the deliverable to the weight of the work: a single file is the right tier for web motion; don't reach for a bundler when one file does the job.
+
+**Output contract:**
+- One `.html` file: GSAP + plugins from CDN, your markup, and the animation in one inline `<script>`.
+- All motion on **one master timeline** (`const tl = gsap.timeline()`) — a single playhead you can seek.
+- Include the seek harness below so any moment can be frozen for inspection.
+
+**Seek harness — freeze an exact moment for screenshots.** The web parallel of a video player's frame-pin: `?t=N` seeks the master timeline to `N` seconds and pauses, so a screenshot lands on a still, deterministic frame.
+
+```html
+<script>
+  // ... build your master timeline as `tl` ...
+  const t = new URLSearchParams(location.search).get("t");
+  if (t !== null) { tl.pause(); tl.seek(parseFloat(t)); }  // frozen at t seconds
+  // no ?t → plays normally
+  window.__ready = true;            // ready signal for headless wait
+  console.log("duration", tl.duration());
+</script>
+```
+
+**Verify loop — render → freeze → screenshot → check:**
+1. Open the file at three moments across the timeline — start, mid, end:
+   `…/anim.html?t=0`, `?t=<dur/2>`, `?t=<dur>`. Read `tl.duration()` from the console for the end time.
+2. Screenshot each frozen frame.
+3. Check both **fidelity** (does it match the brief?) and **artifacts** (clipped text, elements off-canvas, FOUC before fonts load, jank at seams). Output should look intentional and finished.
+
+Any headless screenshot tool works — your agent's browser tool, or Playwright:
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/anim.html?t=1.2" frame-mid.png
+```
+
+**Before you finish:**
+1. Opens standalone in a browser — no console errors, no missing CDN.
+2. All animation on one master timeline; `?t=N` freezes correctly.
+3. Screenshotted at start / mid / end — matches the brief, no artifacts.
+4. `prefers-reduced-motion` honored (timeline simplified or skipped).
+5. Easing is intentional — no accidental `linear` on spatial motion.
+
+A complete runnable template with the harness wired in is in `examples/standalone-template.html`.
+
+## Quick reference
+
+| Goal | API |
+|------|-----|
+| Sequence with overlap | `tl.from(...).from(..., "-=0.3")` |
+| Pin while scrolling | `scrollTrigger:{ pin:true, end:"+=N" }` |
+| Scrub to scroll | `scrollTrigger:{ scrub:1, ease:"none" }` |
+| Reveal lines of text | `SplitText.create(el,{type:"lines"})` |
+| Animate layout change | `Flip.getState` → mutate → `Flip.from` |
+| Fast pointer follow | `gsap.quickTo(el,"x",{...})` |
+| Kill everything | `ScrollTrigger.getAll().forEach(t=>t.kill())` |
+
+## Reference files
+
+- `references/scrolltrigger-cookbook.md` — pin, scrub, horizontal scroll, snap, `ScrollTrigger.batch()` reveals, parallax, nested triggers, and SPA cleanup patterns with full code.
+- `references/scrolltrigger-lenis.md` — full ScrollTrigger + Lenis/Locomotive smooth-scroll sync: canonical wiring, `scrollerProxy`, anchor links, reduced-motion, React (`useGSAP`/`useEffect`), debugging checklist, and symptom→cause table.
+- `examples/hero-timeline.js` — a complete, runnable hero entrance timeline with SplitText, staggered reveals, and reduced-motion handling.
+- `examples/standalone-template.html` — the deliverable template: self-contained (CDN GSAP), one master timeline, the `?t=N` seek harness for screenshot verification, and reduced-motion handling.

.agents/skills/gsap-web/examples/hero-timeline.js

@@ -0,0 +1,67 @@
+/**
+ * hero-timeline.js — complete, runnable GSAP hero entrance.
+ *
+ * Markup expected:
+ *   <section class="hero">
+ *     <p class="hero__eyebrow">EYEBROW</p>
+ *     <h1 class="hero__title">Big bold headline that wraps</h1>
+ *     <p class="hero__sub">Supporting copy.</p>
+ *     <div class="hero__actions"><a class="btn">Primary</a><a class="btn btn--ghost">Secondary</a></div>
+ *     <img class="hero__art" src="art.svg" alt="" />
+ *   </section>
+ *
+ * CSS prerequisite: each split line wrapper needs overflow:hidden for the mask reveal:
+ *   .hero__title .line { overflow: hidden; }
+ *
+ * Install:  npm i gsap @gsap/react
+ */
+
+import gsap from "gsap";
+import { SplitText } from "gsap/SplitText";
+
+gsap.registerPlugin(SplitText);
+
+export function playHeroIntro(root = document) {
+  const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const q = gsap.utils.selector(root);
+
+  // Reduced motion: reveal everything instantly, no animation.
+  if (reduceMotion) {
+    gsap.set(q(".hero__eyebrow, .hero__sub, .hero__actions, .hero__art"), { autoAlpha: 1 });
+    gsap.set(q(".hero__title"), { autoAlpha: 1 });
+    return Promise.resolve();
+  }
+
+  // Wait for fonts so SplitText computes correct line breaks.
+  return document.fonts.ready.then(() => {
+    const titleEl = q(".hero__title")[0];
+    const split = new SplitText(titleEl, {
+      type: "lines",
+      linesClass: "line",
+      autoSplit: true, // GSAP 3.13+: re-split on resize/font swap
+    });
+
+    // Hidden start state (prevents flash of unstyled content).
+    gsap.set(q(".hero__eyebrow, .hero__sub, .hero__actions, .hero__art"), { autoAlpha: 0 });
+    gsap.set(titleEl, { autoAlpha: 1 });
+
+    const tl = gsap.timeline({
+      defaults: { ease: "power3.out", duration: 0.8 },
+      onComplete: () => split.revert(), // restore clean DOM once done (optional)
+    });
+
+    tl.from(".hero__eyebrow", { y: 16, autoAlpha: 0, duration: 0.5 })
+      .from(split.lines, { yPercent: 110, stagger: 0.12, duration: 0.9, ease: "power4.out" }, "-=0.2")
+      .from(".hero__sub", { y: 20, autoAlpha: 0 }, "-=0.6")
+      .from(".hero__actions .btn", { y: 12, autoAlpha: 0, stagger: 0.1, duration: 0.5 }, "-=0.4")
+      .from(".hero__art", { scale: 0.92, autoAlpha: 0, ease: "back.out(1.4)", duration: 1.1 }, "<0.1");
+
+    return tl;
+  });
+}
+
+// Auto-run on DOM ready when imported directly in a page.
+if (typeof window !== "undefined" && document.querySelector(".hero")) {
+  if (document.readyState !== "loading") playHeroIntro();
+  else document.addEventListener("DOMContentLoaded", () => playHeroIntro());
+}

.agents/skills/gsap-web/examples/standalone-template.html

@@ -0,0 +1,59 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>loading</title>
+  <!-- GSAP core from CDN — no build step. Add plugins the same way if needed:
+       https://cdnjs.cloudflare.com/ajax/libs/gsap/3.13.0/ScrollTrigger.min.js -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.13.0/gsap.min.js"></script>
+  <style>
+    :root { color-scheme: dark; }
+    * { margin: 0; box-sizing: border-box; }
+    body {
+      min-height: 100svh; display: grid; place-items: center;
+      background: radial-gradient(120% 120% at 50% 0%, #1b1f3b 0%, #0a0a12 60%);
+      font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
+      color: #f4f5ff; overflow: hidden;
+    }
+    .stage { text-align: center; padding: 6vmin; }
+    .title { font-size: clamp(2.5rem, 9vw, 6rem); font-weight: 800; letter-spacing: -0.03em; line-height: 1; }
+    .sub   { font-size: clamp(1rem, 3.2vw, 1.6rem); margin-top: 1.2rem; color: #aab; }
+    .cta   { display: inline-block; margin-top: 2.4rem; padding: 0.9rem 1.8rem;
+             border-radius: 999px; background: #5b6cff; color: #fff; font-weight: 600; }
+  </style>
+</head>
+<body>
+  <main class="stage">
+    <h1 class="title">Ship it.</h1>
+    <p class="sub">A standalone, screenshot-verifiable GSAP scene.</p>
+    <a class="cta" href="#">Get started</a>
+  </main>
+
+  <script>
+    const reduce = matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+    // ── One master timeline: a single playhead the harness can seek ──────────
+    const tl = gsap.timeline({ defaults: { ease: "power3.out", duration: 0.7 } });
+
+    if (reduce) {
+      // Reduced motion: no spatial movement — just make the final state visible.
+      gsap.set([".title", ".sub", ".cta"], { opacity: 1, y: 0 });
+    } else {
+      tl.from(".title", { yPercent: 110, opacity: 0, ease: "power4.out", duration: 0.9 })
+        .from(".sub",   { y: 24, opacity: 0 }, "-=0.45")
+        .from(".cta",   { scale: 0.9, opacity: 0, ease: "back.out(1.7)" }, "-=0.3");
+    }
+
+    // ── Seek harness: ?t=N freezes the timeline at N seconds for a clean shot ─
+    const t = new URLSearchParams(location.search).get("t");
+    if (t !== null) { tl.pause(); tl.seek(parseFloat(t)); }   // deterministic frozen frame
+    // no ?t → plays normally on load
+
+    // ── Ready signals for headless verification ──────────────────────────────
+    window.__ready = true;
+    document.title = "ready";
+    console.log("duration", tl.duration());   // end time for the ?t=<dur> shot
+  </script>
+</body>
+</html>

.agents/skills/gsap-web/references/scrolltrigger-cookbook.md

@@ -0,0 +1,181 @@
+# ScrollTrigger Cookbook
+
+Runnable patterns for GSAP 3.12+. Register first:
+
+```js
+import gsap from "gsap";
+import { ScrollTrigger } from "gsap/ScrollTrigger";
+gsap.registerPlugin(ScrollTrigger);
+```
+
+## 1. Pin a section and scrub a timeline through it
+
+The most common scrollytelling pattern: hold a section fixed and drive a multi-step timeline with scroll.
+
+```js
+const tl = gsap.timeline({
+  scrollTrigger: {
+    trigger: ".story",
+    start: "top top",
+    end: "+=3000",   // total scroll distance the pin lasts
+    pin: true,
+    scrub: 1,
+    anticipatePin: 1, // reduces a 1-frame jump when pinning fast scroll
+  },
+});
+
+tl.from(".story .step-1", { autoAlpha: 0, y: 60 })
+  .from(".story .step-2", { autoAlpha: 0, y: 60 })
+  .to(".story .bg", { scale: 1.2, ease: "none" }, 0); // runs across whole timeline
+```
+
+Tips:
+- Each tween occupies an equal slice of the pinned distance unless you set durations/positions.
+- `pinSpacing: true` (default) adds padding so content below does not jump. Set `false` only when overlaying.
+- If the pinned element is inside a transformed/`overflow` ancestor, pinning breaks — pin a top-level element or set `pinReparent: true`.
+
+## 2. Horizontal scroll (panels move sideways as the page scrolls vertically)
+
+```html
+<section class="h-wrap"><div class="track">
+  <div class="panel">1</div><div class="panel">2</div><div class="panel">3</div>
+</div></section>
+```
+
+```css
+.track { display: flex; width: max-content; }
+.panel { width: 100vw; height: 100vh; flex: 0 0 100vw; }
+```
+
+```js
+const track = document.querySelector(".track");
+gsap.to(track, {
+  x: () => -(track.scrollWidth - window.innerWidth), // function = recalculated on refresh
+  ease: "none",
+  scrollTrigger: {
+    trigger: ".h-wrap",
+    pin: true,
+    scrub: 1,
+    end: () => "+=" + (track.scrollWidth - window.innerWidth),
+    invalidateOnRefresh: true, // re-run the x function on resize
+  },
+});
+```
+
+`invalidateOnRefresh: true` plus function-based values is the correct way to stay responsive.
+
+## 3. Snap to sections
+
+```js
+gsap.to(".sections", {
+  scrollTrigger: {
+    trigger: ".sections",
+    pin: true,
+    scrub: 1,
+    end: "+=4000",
+    snap: {
+      snapTo: 1 / 4,        // 5 evenly spaced points (labels also possible: "labels")
+      duration: { min: 0.2, max: 0.6 },
+      delay: 0.05,
+      ease: "power1.inOut",
+    },
+  },
+});
+```
+
+To snap to timeline labels: build a labeled timeline and use `snap: "labelsDirectional"`.
+
+## 4. Batch reveals (performant many-element fade-in)
+
+Instead of creating one ScrollTrigger per card (expensive at scale), batch them:
+
+```js
+ScrollTrigger.batch(".card", {
+  start: "top 85%",
+  onEnter: (els) =>
+    gsap.from(els, { autoAlpha: 0, y: 40, stagger: 0.12, overwrite: true }),
+  onLeaveBack: (els) =>
+    gsap.to(els, { autoAlpha: 0, y: 40, stagger: 0.12, overwrite: true }),
+});
+```
+
+Set the initial hidden state to avoid a flash before JS runs: `gsap.set(".card", { autoAlpha: 0 })`.
+
+## 5. Parallax layers
+
+```js
+gsap.utils.toArray(".parallax").forEach((layer) => {
+  const depth = layer.dataset.depth || 0.3; // 0 = static, 1 = scrolls with page
+  gsap.to(layer, {
+    yPercent: -depth * 100,
+    ease: "none",
+    scrollTrigger: { trigger: layer.parentElement, scrub: true, start: "top bottom", end: "bottom top" },
+  });
+});
+```
+
+## 6. Linked timelines / containerAnimation (triggers inside horizontal scroll)
+
+To trigger animations off elements that move horizontally inside a pinned horizontal scroller, pass the horizontal tween as `containerAnimation`:
+
+```js
+const scrollTween = gsap.to(track, { x: -2000, ease: "none",
+  scrollTrigger: { trigger: ".h-wrap", pin: true, scrub: 1, end: "+=2000" } });
+
+gsap.from(".panel-2 .title", {
+  autoAlpha: 0, y: 50,
+  scrollTrigger: { trigger: ".panel-2 .title", containerAnimation: scrollTween, start: "left center" },
+});
+```
+
+Note `start: "left center"` uses horizontal keywords because the trigger moves horizontally.
+
+## 7. Refresh on dynamic content
+
+Images and lazy content change layout after triggers are computed. Refresh when ready:
+
+```js
+window.addEventListener("load", () => ScrollTrigger.refresh());
+imagesLoaded(document.body, () => ScrollTrigger.refresh()); // if using imagesLoaded lib
+```
+
+For accordions/tabs that change height, call `ScrollTrigger.refresh()` after the layout settles.
+
+## 8. SPA / React cleanup (critical)
+
+Orphaned ScrollTriggers cause ghost pins, leaks, and stacking bugs on route changes. Always scope and revert.
+
+React with `@gsap/react`:
+
+```jsx
+import { useGSAP } from "@gsap/react";
+
+function Section() {
+  const root = useRef(null);
+  useGSAP(() => {
+    gsap.from(".item", {
+      autoAlpha: 0, y: 40, stagger: 0.1,
+      scrollTrigger: { trigger: ".item", start: "top 80%" },
+    });
+  }, { scope: root }); // auto-reverts on unmount
+  return <div ref={root}>...</div>;
+}
+```
+
+Plain SPA / manual:
+
+```js
+const ctx = gsap.context(() => { /* all gsap code */ }, rootEl);
+// on teardown / route leave:
+ctx.revert();
+```
+
+Nuclear option (e.g. global router hook): `ScrollTrigger.getAll().forEach((t) => t.kill());`
+
+## Debugging checklist
+
+- Triggers fire at wrong scroll position → likely created before images loaded; call `ScrollTrigger.refresh()`.
+- Pinned element jumps to top-left → it has a transformed/`will-change`/`overflow:hidden` ancestor; pin higher up.
+- Animation plays once then never resets → set appropriate `toggleActions` or use `scrub`.
+- Horizontal scroll not responsive → use function-based `x`/`end` + `invalidateOnRefresh: true`.
+- Markers misaligned → leftover triggers from previous render; ensure cleanup runs.

.agents/skills/gsap-web/references/scrolltrigger-lenis.md

@@ -0,0 +1,255 @@
+# ScrollTrigger + Lenis / Locomotive smooth-scroll sync
+
+Wire GSAP ScrollTrigger together with Lenis (or Locomotive) smooth scrolling so there is no jitter, no marker drift, no broken pins, and no flipped/laggy scroll direction. Every one of those bugs has the same root cause: two animation loops running independently. Lenis transforms the scroll position on its own `requestAnimationFrame` loop while ScrollTrigger reads scroll on GSAP's ticker — when they tick separately, ScrollTrigger samples a stale position and everything desyncs. The fix is to run one loop: let GSAP's ticker drive Lenis, and tell ScrollTrigger to update on every Lenis scroll.
+
+## The one canonical wiring (Lenis)
+
+This is the entire correct setup. Do not add a separate `requestAnimationFrame` loop for Lenis — that is the most common mistake and the source of nearly all desync.
+
+```js
+import Lenis from 'lenis';
+import gsap from 'gsap';
+import { ScrollTrigger } from 'gsap/ScrollTrigger';
+
+gsap.registerPlugin(ScrollTrigger);
+
+const lenis = new Lenis({
+  duration: 1.2,
+  smoothWheel: true,
+  // do NOT enable Lenis's own rAF; GSAP's ticker drives it (below)
+});
+
+// 1. Update ScrollTrigger every time Lenis scrolls
+lenis.on('scroll', ScrollTrigger.update);
+
+// 2. Drive Lenis from GSAP's ticker (single shared loop).
+//    gsap.ticker time is in SECONDS; Lenis expects MILLISECONDS.
+gsap.ticker.add((time) => {
+  lenis.raf(time * 1000);
+});
+
+// 3. Disable GSAP's lag smoothing so ScrollTrigger never defers/
+//    catches up against Lenis (prevents jitter on heavy frames)
+gsap.ticker.lagSmoothing(0);
+```
+
+Three lines do all the work:
+
+1. `lenis.on('scroll', ScrollTrigger.update)` — ScrollTrigger recomputes positions the instant Lenis moves the page, so triggers/markers/pins track the smoothed scroll exactly.
+2. `gsap.ticker.add(time => lenis.raf(time * 1000))` — Lenis advances inside GSAP's loop, guaranteeing both run on the same frame and in the same order. Critical unit conversion: `gsap.ticker` passes seconds, `lenis.raf()` wants milliseconds, so multiply by 1000.
+3. `gsap.ticker.lagSmoothing(0)` — disables GSAP's catch-up behavior that, combined with Lenis, causes visible jitter when a frame is slow.
+
+After this, never call `requestAnimationFrame(raf)` for Lenis yourself. If any tutorial code has a standalone `function raf(time){ lenis.raf(time); requestAnimationFrame(raf) }` loop, delete it — it competes with the ticker and reintroduces jitter and direction lag.
+
+## Locomotive Scroll variant
+
+Locomotive needs `scrollerProxy` because it scrolls an inner element, not `window`. The principle is identical (one loop, update ScrollTrigger on scroll), but the proxy maps coordinates:
+
+```js
+const locoScroll = new LocomotiveScroll({
+  el: document.querySelector('[data-scroll-container]'),
+  smooth: true,
+});
+
+locoScroll.on('scroll', ScrollTrigger.update);
+
+ScrollTrigger.scrollerProxy('[data-scroll-container]', {
+  scrollTop(value) {
+    return arguments.length
+      ? locoScroll.scrollTo(value, { duration: 0, disableLerp: true })
+      : locoScroll.scroll.instance.scroll.y;
+  },
+  getBoundingClientRect() {
+    return { top: 0, left: 0, width: innerWidth, height: innerHeight };
+  },
+  pinType: document.querySelector('[data-scroll-container]').style.transform
+    ? 'transform' : 'fixed',
+});
+
+ScrollTrigger.addEventListener('refresh', () => locoScroll.update());
+ScrollTrigger.refresh();
+```
+
+Every ScrollTrigger then needs `scroller: '[data-scroll-container]'`. Lenis is simpler because it scrolls the real document, so no `scrollerProxy` is needed.
+
+## Pins, refresh, and resize
+
+- Pinned ScrollTriggers work without `scrollerProxy` under Lenis because Lenis scrolls the document body. If pins still jump, ensure no rogue rAF loop exists and that `ScrollTrigger.update` is wired.
+- On dynamic content/resize, call `ScrollTrigger.refresh()` after layout settles. With Lenis, also call `lenis.resize()` if container size changes.
+- For elements that should *not* be smoothed (e.g. a modal that scrolls natively), mark with `data-lenis-prevent` so Lenis ignores them.
+
+## Anchor links with smooth scroll
+
+Native `<a href="#section">` jumps bypass Lenis (instant jump, then Lenis fights it). Route anchors through `lenis.scrollTo`:
+
+```js
+document.querySelectorAll('a[href^="#"]').forEach((a) => {
+  a.addEventListener('click', (e) => {
+    const id = a.getAttribute('href');
+    if (id.length > 1) {
+      e.preventDefault();
+      lenis.scrollTo(id, { offset: 0 });  // accepts selector, element, or number
+    }
+  });
+});
+```
+
+If a sticky header overlaps the target, pass a negative offset or an offset callback:
+
+```js
+lenis.scrollTo(targetEl, { offset: -80 }); // 80px sticky header
+```
+
+## Reduced-motion gate
+
+Respect `prefers-reduced-motion`: skip smooth scrolling entirely (do not instantiate Lenis, or stop it) and let ScrollTrigger run on native scroll.
+
+```js
+const prefersReduced = matchMedia('(prefers-reduced-motion: reduce)').matches;
+
+let lenis;
+if (!prefersReduced) {
+  lenis = new Lenis({ duration: 1.2 });
+  lenis.on('scroll', ScrollTrigger.update);
+  gsap.ticker.add((time) => lenis.raf(time * 1000));
+  gsap.ticker.lagSmoothing(0);
+}
+// ScrollTrigger animations are defined normally and work with or without Lenis
+```
+
+## Cleanup (SPA / React / route changes)
+
+Destroy Lenis and remove the ticker callback on unmount, or stacked loops accumulate:
+
+```js
+function setup() {
+  const update = (time) => lenis.raf(time * 1000);
+  lenis.on('scroll', ScrollTrigger.update);
+  gsap.ticker.add(update);
+  gsap.ticker.lagSmoothing(0);
+  return () => {
+    gsap.ticker.remove(update);
+    lenis.destroy();
+    ScrollTrigger.getAll().forEach((t) => t.kill());
+  };
+}
+```
+
+## Debugging checklist (work top to bottom)
+
+1. **Is there a rogue rAF loop?** Search the codebase for `requestAnimationFrame` near `lenis.raf`. If Lenis is also driven by `gsap.ticker`, delete the standalone loop. Two loops = jitter, lag, flipped feel.
+2. **Unit conversion present?** Confirm `lenis.raf(time * 1000)` inside the ticker. Missing `* 1000` makes scroll feel stuck or wildly slow.
+3. **Is `ScrollTrigger.update` subscribed?** `lenis.on('scroll', ScrollTrigger.update)` must exist. Without it, markers and triggers drift behind the smoothed position.
+4. **Is `lagSmoothing(0)` set?** Without it, heavy frames cause GSAP to "catch up", visible as jitter.
+5. **Markers on for diagnosis.** Add `markers: true` to a trigger. If markers sit at the *native* scroll position but content moves with smoothed scroll, the update subscription is missing or a proxy is mis-set.
+6. **Pins jumping?** Confirm no proxy is set for Lenis (it scrolls the document). For Locomotive, confirm `pinType` and `scroller` are correct.
+7. **After dynamic content / fonts / images load**, call `ScrollTrigger.refresh()`. Stale measurements cause triggers to fire at wrong offsets.
+8. **Nested scroll areas** (modals, code blocks) misbehave? Add `data-lenis-prevent` to the scrollable child.
+9. **Cleanup on route change?** In SPAs, verify `gsap.ticker.remove(update)`, `lenis.destroy()`, and killing ScrollTriggers — otherwise each navigation stacks another loop.
+
+## Symptom → cause table
+
+| Symptom | Most likely cause |
+|---|---|
+| General jitter/stutter | Standalone rAF loop + ticker both driving Lenis |
+| Scroll stuck / barely moves | Missing `* 1000` unit conversion |
+| Markers offset from triggers | `ScrollTrigger.update` not bound to `lenis.on('scroll')` |
+| Jitter only on heavy frames | `lagSmoothing(0)` not set |
+| Pins jump / break | Proxy wrongly set under Lenis, or wrong `pinType` (Loco) |
+| Animations a frame behind | Two loops out of order; consolidate to one ticker |
+| Anchor links jump then snap back | Native `#hash` jump not routed via `lenis.scrollTo` |
+| Triggers fire at wrong scroll position | Missing `ScrollTrigger.refresh()` after content/layout change |
+| Worse after each route change | No cleanup; loops/triggers accumulating |
+| Inner scroll container won't scroll | Lenis intercepting; add `data-lenis-prevent` |
+
+## Complete React integration (useGSAP)
+
+```jsx
+'use client';
+import { useRef } from 'react';
+import Lenis from 'lenis';
+import gsap from 'gsap';
+import { ScrollTrigger } from 'gsap/ScrollTrigger';
+import { useGSAP } from '@gsap/react';
+
+gsap.registerPlugin(ScrollTrigger, useGSAP);
+
+export default function ScrollSection() {
+  const root = useRef(null);
+
+  useGSAP(() => {
+    const prefersReduced = matchMedia('(prefers-reduced-motion: reduce)').matches;
+
+    let lenis;
+    let update;
+    if (!prefersReduced) {
+      lenis = new Lenis({ duration: 1.2, smoothWheel: true });
+      lenis.on('scroll', ScrollTrigger.update);
+      update = (time) => lenis.raf(time * 1000);
+      gsap.ticker.add(update);
+      gsap.ticker.lagSmoothing(0);
+    }
+
+    gsap.to('.panel', {
+      xPercent: -100,
+      ease: 'none',
+      scrollTrigger: {
+        trigger: '.panel',
+        start: 'top top',
+        end: '+=1500',
+        scrub: true,
+        pin: true,
+        // markers: true, // enable while debugging
+      },
+    });
+
+    return () => {
+      if (lenis) {
+        gsap.ticker.remove(update);
+        lenis.destroy();
+      }
+    };
+  }, { scope: root });
+
+  return (
+    <div ref={root}>
+      <section className="panel">…</section>
+    </div>
+  );
+}
+```
+
+`useGSAP` auto-reverts GSAP tweens/ScrollTriggers created in its scope on unmount; the returned function additionally tears down Lenis and the ticker callback so nothing leaks across navigations.
+
+## Plain useEffect equivalent
+
+```jsx
+useEffect(() => {
+  const lenis = new Lenis({ duration: 1.2 });
+  lenis.on('scroll', ScrollTrigger.update);
+  const update = (t) => lenis.raf(t * 1000);
+  gsap.ticker.add(update);
+  gsap.ticker.lagSmoothing(0);
+
+  const ctx = gsap.context(() => {
+    // ...ScrollTrigger animations here...
+  });
+
+  return () => {
+    gsap.ticker.remove(update);
+    lenis.destroy();
+    ctx.revert();
+  };
+}, []);
+```
+
+## Excluding regions from smooth scroll
+
+```html
+<div class="code-block" data-lenis-prevent>…natively scrollable…</div>
+```
+
+`data-lenis-prevent` on a scrollable element makes Lenis ignore wheel/touch there, so inner scrolling works normally while the page stays smooth.
+
+---
+Sync ScrollTrigger to smooth scroll and the timeline tracks the page perfectly. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=gsap-web)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/lottie-animation/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: lottie-animation
+description: This skill should be used when the user asks to "add a Lottie animation", "play a .lottie or .json animation", "integrate a Bodymovin/After Effects animation on web or mobile", "control Lottie playback / segments", "make a scroll-driven Lottie", "recolor a Lottie at runtime", or "export an AE animation to Lottie". Covers dotLottie/lottie-web integration, playback control, interactivity, theming, and the AE export checklist.
+version: 0.1.0
+---
+
+# Lottie Animation
+
+The bridge from After Effects to product: vector animation shipped as JSON (or zipped `.lottie`), tiny and resolution-independent, played by a runtime on web, iOS, Android, and React Native. This skill covers integrating, controlling, and exporting Lottie.
+
+## When to use
+
+- Ship a designer's AE animation to web/iOS/Android/React Native
+- Looping illustrations, onboarding, empty states, animated icons
+- Scroll-driven or interaction-driven vector playback (hover, click, cursor)
+- Runtime theming/recoloring instead of re-exporting per brand
+
+## Formats: .json vs .lottie
+
+- `.json` — the raw Bodymovin output. Human-readable, larger.
+- `.lottie` — a zipped container (often 60–80% smaller) that can bundle multiple animations, images, and theming. Preferred for shipping. Player: `@lottiefiles/dotlottie-web` (modern, canvas + WASM) supersedes the older `lottie-web`.
+
+Prefer the **dotLottie** runtime for new work; use `lottie-web` only for legacy `.json` + SVG renderer needs.
+
+## Core workflow (web, dotLottie)
+
+```bash
+npm i @lottiefiles/dotlottie-web        # vanilla
+npm i @lottiefiles/dotlottie-react      # React wrapper
+```
+
+Vanilla:
+
+```js
+import { DotLottie } from "@lottiefiles/dotlottie-web";
+
+const dotLottie = new DotLottie({
+  canvas: document.querySelector("#lottie"),  // a <canvas> element
+  src: "/hero.lottie",                         // or .json
+  loop: true,
+  autoplay: true,
+  // speed: 1, mode: "forward" | "reverse" | "bounce", renderConfig: { autoResize: true }
+});
+```
+
+React:
+
+```jsx
+import { DotLottieReact } from "@lottiefiles/dotlottie-react";
+
+function Hero() {
+  return <DotLottieReact src="/hero.lottie" loop autoplay style={{ width: 320 }} />;
+}
+```
+
+Capture the instance to control it:
+
+```jsx
+const [dl, setDl] = useState(null);
+<DotLottieReact src="/icon.lottie" dotLottieRefCallback={setDl} />;
+// dl?.play(); dl?.pause(); dl?.setSpeed(2);
+```
+
+## Playback control
+
+```js
+dotLottie.play();
+dotLottie.pause();
+dotLottie.stop();
+dotLottie.setSpeed(1.5);
+dotLottie.setMode("bounce");        // forward | reverse | bounce | reverse-bounce
+dotLottie.setFrame(42);             // jump to a frame
+dotLottie.setSegment(30, 90);       // constrain playback to a frame range (e.g. a "loading" loop)
+```
+
+Events drive sequencing and UI:
+
+```js
+dotLottie.addEventListener("load", () => { /* totalFrames now available */ });
+dotLottie.addEventListener("complete", () => { /* non-looping playback finished */ });
+dotLottie.addEventListener("frame", ({ currentFrame }) => { /* per-frame */ });
+```
+
+State-machine style (e.g. button that plays "checked" segment then idles): play a segment, listen for `complete`, then `setSegment` to the idle loop.
+
+## Scroll-driven Lottie (no GSAP needed)
+
+Map scroll progress (0–1) to a frame. Pause autoplay and drive frames yourself.
+
+```js
+const dotLottie = new DotLottie({ canvas, src: "/scroll.lottie", autoplay: false });
+let total = 0;
+dotLottie.addEventListener("load", () => { total = dotLottie.totalFrames; });
+
+window.addEventListener("scroll", () => {
+  const el = canvas.closest(".scrolly");
+  const rect = el.getBoundingClientRect();
+  const p = clamp(-rect.top / (rect.height - window.innerHeight), 0, 1); // 0..1 through the section
+  dotLottie.setFrame(p * (total - 1));
+}, { passive: true });
+
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+```
+
+For richer interaction (hover-to-play, click toggles, cursor-follow) without writing the wiring, use `@lottiefiles/lottie-interactivity`, which maps `scroll`, `hover`, `click`, `play`, and `cursor` modes to frame ranges declaratively.
+
+## Runtime theming / recoloring
+
+Two paths:
+- **dotLottie themes**: a `.lottie` can embed named color themes; switch with `dotLottie.setTheme("dark")` / `loadTheme(...)`. Authored in LottieFiles tooling — no re-export to recolor.
+- **Manual color override**: load the JSON, walk `layers[].shapes[]` and patch `c.k` color arrays (normalized 0–1 RGBA), then init the player with the modified object. Brittle (depends on layer structure) — prefer themes or CSS-driven SVG-renderer (`lottie-web` `rendererSettings`) when you must restyle by class.
+
+## Mobile runtimes (parity)
+
+- iOS — `lottie-ios` (`LottieAnimationView`): `.play()`, `.currentProgress`, `.play(fromFrame:toFrame:)`.
+- Android — `lottie-android` (`LottieAnimationView` / Compose `LottieAnimation`): `setMinAndMaxFrame`, `progress`.
+- React Native — `lottie-react-native` (`<LottieView source={...} progress={anim} />`, drive `progress` with `Animated`).
+
+The same `.lottie`/`.json` plays across all; segments and progress concepts match the web API.
+
+## Optimization
+
+- Ship `.lottie` (zipped) over raw `.json`; lazy-load offscreen players and pause when not visible (`IntersectionObserver` → `play`/`pause`).
+- Prefer the canvas/WASM dotLottie renderer for many simultaneous animations; SVG renderer (lottie-web) is fine for one crisp icon but costs more DOM for complex files.
+- Keep AE comps small: fewer layers/keyframes, no large embedded rasters; flatten precomps where possible. File size tracks keyframe and path complexity, not duration.
+- Recolor at runtime (themes) instead of exporting a file per brand/theme.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained Lottie demo (looping illustration, animated icon, empty state) the deliverable is **one HTML file that opens directly in a browser** — the dotLottie/lottie-web runtime from CDN, a `<canvas>`, and your `.lottie`/`.json` (a relative file or a data URL). No build step. One file is the right tier for shipping a player; don't reach for a bundler.
+
+**Output contract:**
+- One `.html` file: the runtime via CDN (`@lottiefiles/dotlottie-web`), the canvas, and `autoplay:false` so the frame is yours to drive.
+- Include the seek harness so any frame can be frozen for a screenshot.
+
+**Seek harness — freeze an exact frame.** `?t=N` jumps to a frame and holds it so a screenshot lands on a still, deterministic frame. Lottie's playhead is in frames, so stop on the frame directly:
+
+```html
+<script>
+  const dl = new DotLottie({ canvas, src: "/icon.lottie", autoplay: false });
+  dl.addEventListener("load", () => {
+    const t = new URLSearchParams(location.search).get("t");
+    if (t !== null) dl.setFrame(parseFloat(t));      // freeze on frame N (lottie-web: anim.goToAndStop(N, true))
+    else dl.play();
+    console.log("totalFrames", dl.totalFrames);       // read for end-frame
+    window.__ready = true;
+  });
+</script>
+```
+
+**Verify loop — render → freeze → screenshot → check:** open the file at first / mid / last frame (`?t=0`, `?t=<total/2>`, `?t=<total-1>`; read `totalFrames` from the console), screenshot each, and check **fidelity** (colors/theme correct, segment loops where intended) plus **artifacts** (canvas blurry from missing `autoResize`/DPR, clipped composition, FOUC before the file loads, jank). Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=600 "file://$PWD/lottie.html?t=42" frame-mid.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, CDN runtime and the `.lottie`/`.json` load.
+2. `?t=N` (`setFrame`/`goToAndStop`) freezes the correct, deterministic frame.
+3. Screenshotted at first / mid / last frame — matches the brief, sharp, no clipping.
+4. `prefers-reduced-motion` honored — don't `autoplay` a loop; show a static frame or offer a play control.
+5. Easing is intentional — playback speed/segment chosen on purpose, motion baked in AE reads as designed.
+
+## Quick reference
+
+| Goal | Call |
+|------|------|
+| Play a range | `setSegment(start, end)` |
+| Jump to frame | `setFrame(n)` |
+| Reverse / bounce | `setMode("reverse"|"bounce")` |
+| Scroll-drive | `autoplay:false` + `setFrame(p*totalFrames)` |
+| Theme swap | `setTheme("dark")` |
+| Know length | `totalFrames` after `load` event |
+| Declarative interactivity | `@lottiefiles/lottie-interactivity` |
+
+## Reference files
+
+- `references/integration-and-export.md` — full dotLottie-web + React setup and event/segment control, `lottie-interactivity` mode configs, scroll/cursor patterns, runtime theming details, and the complete After Effects → Bodymovin export checklist with the list of unsupported AE features and how to work around them.

.agents/skills/lottie-animation/references/integration-and-export.md

@@ -0,0 +1,233 @@
+# Lottie Integration & Export (detailed)
+
+## 1. dotLottie-web full setup
+
+```bash
+npm i @lottiefiles/dotlottie-web
+```
+
+```js
+import { DotLottie } from "@lottiefiles/dotlottie-web";
+
+const dotLottie = new DotLottie({
+  canvas: document.querySelector("#lottie"),
+  src: "/assets/onboarding.lottie",   // .lottie or .json (URL or same-origin path)
+  autoplay: true,
+  loop: true,
+  speed: 1,
+  mode: "forward",                    // forward | reverse | bounce | reverse-bounce
+  useFrameInterpolation: true,        // smoother than the source frame rate
+  renderConfig: {
+    autoResize: true,                 // keep the canvas crisp on resize/DPR changes
+    devicePixelRatio: window.devicePixelRatio,
+  },
+});
+```
+
+The canvas MUST be a real `<canvas>` element. For responsiveness, size the canvas via CSS and keep `autoResize: true`; the runtime handles the backing store.
+
+### Lifecycle and events
+
+```js
+dotLottie.addEventListener("load",     () => console.log(dotLottie.totalFrames, dotLottie.duration));
+dotLottie.addEventListener("loadError", (e) => console.error("bad src", e));
+dotLottie.addEventListener("play",     () => {});
+dotLottie.addEventListener("pause",    () => {});
+dotLottie.addEventListener("complete", () => {});       // fires when a non-looping play finishes
+dotLottie.addEventListener("loop",     ({ loopCount }) => {});
+dotLottie.addEventListener("frame",    ({ currentFrame }) => {});
+
+// always clean up (SPA/unmount)
+dotLottie.destroy();
+```
+
+`totalFrames`, `duration`, and segment data are only valid AFTER the `load` event — read them there, not synchronously after construction.
+
+### Multi-animation .lottie files
+
+A single `.lottie` can hold several animations:
+
+```js
+dotLottie.addEventListener("load", () => {
+  console.log(dotLottie.manifest.animations); // list of animation ids
+});
+dotLottie.loadAnimation("success");           // switch by id without re-fetching
+```
+
+## 2. React wrapper
+
+```bash
+npm i @lottiefiles/dotlottie-react
+```
+
+```jsx
+import { DotLottieReact } from "@lottiefiles/dotlottie-react";
+import { useState, useEffect } from "react";
+
+function PlayButton() {
+  const [dl, setDl] = useState(null);
+  const [playing, setPlaying] = useState(true);
+
+  useEffect(() => {
+    if (!dl) return;
+    const onComplete = () => setPlaying(false);
+    dl.addEventListener("complete", onComplete);
+    return () => dl.removeEventListener("complete", onComplete);
+  }, [dl]);
+
+  return (
+    <DotLottieReact
+      src="/play.lottie"
+      autoplay
+      loop={false}
+      dotLottieRefCallback={setDl}     // capture instance for imperative control
+      onClick={() => (playing ? dl.pause() : dl.play(), setPlaying((p) => !p))}
+      style={{ width: 200, height: 200 }}
+    />
+  );
+}
+```
+
+Props mirror the constructor: `src, autoplay, loop, speed, mode, useFrameInterpolation, renderConfig, themeId, segment`.
+
+## 3. Segments and state machines
+
+```js
+// Loop only the "loading" portion (frames 30–90), then jump to a success segment.
+dotLottie.setSegment(30, 90);
+dotLottie.setLoop(true);
+dotLottie.play();
+
+function resolveSuccess() {
+  dotLottie.setLoop(false);
+  dotLottie.setSegment(91, 140);   // success burst
+  dotLottie.play();
+}
+```
+
+Pattern for icon toggles (e.g. like button): keep distinct frame ranges for each state in one file, and `setSegment` + `play` per interaction; listen for `complete` to settle into an idle range.
+
+dotLottie also supports embedded **state machines** (`.lottie` with a `state-machine` definition): `dotLottie.stateMachineLoad("sm_id"); dotLottie.stateMachineStart();` then fire inputs/events — useful for complex interactive icons authored in LottieFiles without writing JS state logic.
+
+## 4. lottie-interactivity (declarative)
+
+```bash
+npm i @lottiefiles/lottie-interactivity
+```
+
+Works with a `lottie-web`/dotLottie player instance (commonly the `<dotlottie-player>` / `<lottie-player>` web component):
+
+```html
+<dotlottie-player id="firstLottie" src="/scroll.lottie" style="width:300px"></dotlottie-player>
+<script>
+  LottieInteractivity.create({
+    player: "#firstLottie",
+    mode: "scroll",
+    actions: [
+      { visibility: [0, 0.3], type: "stop", frames: [0] },
+      { visibility: [0.3, 1.0], type: "seek", frames: [0, 120] }, // map scroll → frames 0..120
+    ],
+  });
+</script>
+```
+
+Modes:
+- `scroll` — tie frames to scroll position / element visibility (the canonical scrolly use).
+- `cursor` — drive frames from cursor position over the element (hover scrub).
+- `hover` — play on hover, control `loop`/`reset` on leave.
+- `click` — advance to the next sync state on each click.
+- `chain` — sequence multiple animations.
+
+Use `type: "seek"` to scrub frames, `type: "loop"` / `"play"` / `"stop"` for segment behaviors.
+
+## 5. Manual scroll mapping (full control, no extra lib)
+
+```js
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+let total = 0;
+dotLottie.addEventListener("load", () => { total = dotLottie.totalFrames - 1; });
+
+const section = document.querySelector(".scrolly");
+function update() {
+  const r = section.getBoundingClientRect();
+  const scrollable = r.height - window.innerHeight;
+  const p = clamp(-r.top / scrollable, 0, 1);
+  dotLottie.setFrame(p * total);
+}
+window.addEventListener("scroll", update, { passive: true });
+window.addEventListener("resize", update);
+```
+
+Pause when offscreen to save CPU:
+
+```js
+new IntersectionObserver(([e]) => e.isIntersecting ? dotLottie.unfreeze() : dotLottie.freeze())
+  .observe(canvas);
+```
+
+## 6. Runtime theming
+
+### Embedded themes (recommended)
+
+A `.lottie` authored with named color themes:
+
+```js
+dotLottie.addEventListener("load", () => {
+  console.log(dotLottie.manifest.themes); // available theme ids
+  dotLottie.setTheme("dark");             // swap colors with no re-fetch / re-export
+});
+// or per slot:
+dotLottie.setThemeData({ /* theme JSON */ });
+```
+
+### Manual color patching (last resort)
+
+```js
+const json = await fetch("/icon.json").then((r) => r.json());
+// Lottie colors are normalized 0..1 [r,g,b,a] arrays at shapes[].it[].c.k
+function recolor(layers, hex) {
+  const [r, g, b] = hexToRgb01(hex);
+  for (const layer of layers) {
+    for (const sh of layer.shapes ?? []) {
+      for (const it of sh.it ?? []) {
+        if (it.ty === "fl" || it.ty === "st") { it.c.k = [r, g, b, 1]; } // fill / stroke
+      }
+    }
+    if (layer.layers) recolor(layer.layers, hex); // precomps
+  }
+}
+recolor(json.layers, "#ff5500");
+new DotLottie({ canvas, data: JSON.stringify(json), autoplay: true });
+```
+
+This depends on the exact layer/shape structure and breaks if the file changes — prefer embedded themes, or use the `lottie-web` SVG renderer and target paths with CSS where the markup is stable.
+
+## 7. After Effects → Bodymovin export checklist
+
+Plugin: **Bodymovin** (or LottieFiles plugin). `Window → Extensions → Bodymovin`. Select the comp, set destination, configure, Render.
+
+Pre-export checklist:
+1. Comp set to a sensible size and frame rate (24/30/60); avoid huge resolutions — Lottie is vector, the canvas scales.
+2. Name layers/comps clearly — names survive into JSON and aid runtime theming/targeting.
+3. Convert text you want crisp/animated-by-path to shapes if it uses unsupported text features; otherwise enable "Glyphs"/"Fonts" in Bodymovin settings for live text.
+4. Trim the work area to exactly the frames you ship; trailing frames bloat the file.
+5. In Bodymovin settings: enable **Compress assets / .lottie** output for the zipped format; enable "Glyphs" if using text; toggle "Standalone"/"Demo" only as needed.
+6. Replace embedded raster images with vectors where possible; if rasters are required, they inflate `.json` (consider `.lottie` which bundles them).
+7. Test the exported file in the LottieFiles preview AND your target runtime before handoff — renderers differ.
+
+### Unsupported / partially-supported AE features (avoid or rework)
+
+- **Expressions** — not evaluated by runtimes. Bake expression-driven motion to keyframes (Bodymovin can pre-render some) or remove. Heavy-expression rigs are the #1 source of "looks wrong in product".
+- **Effects** — most AE effects (blurs, glows, distort, particle systems, CC effects) are NOT supported. Only a small set (e.g. some Gaussian blur, drop shadow, tint, fill via supported attributes) survive, and inconsistently across platforms. Recreate looks with shape layers, gradients, and mattes.
+- **3D layers / camera** — not supported; fake depth with 2D scaling/position.
+- **Time remapping / nested time stretch** — flaky; pre-compose and bake.
+- **Auto-Orient, certain merge-paths modes, some matte combinations** — test explicitly.
+- **Audio** — not part of Lottie.
+- **Adjustment layers, layer styles (bevel/emboss/inner shadow)** — largely unsupported; convert to shapes/gradients.
+- **Track mattes** — alpha/luma mattes generally work but increase cost; flatten when possible.
+- **Gradients on strokes / complex gradient feathering** — limited; verify.
+
+Workarounds summary: bake expressions to keyframes, replace effects with native shape/gradient/matte equivalents, flatten precomps, drop rasters, and verify on every target runtime (web/iOS/Android render slightly differently). Keep layer/keyframe count low for performance and file size.
+
+---
+Export clean from After Effects and the dotLottie plays light everywhere. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=lottie-animation)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/micro-interaction/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: micro-interaction
+description: This skill should be used when the user asks to "add a hover/press effect", "animate a toggle or switch", "build an animated like button", "make a toast/snackbar slide in", "animate a drawer or modal", "animate list reordering or add/remove", "do a shared-element layout transition", or "polish UI feedback". Covers UI motion with Framer Motion (motion/react) and modern CSS.
+version: 0.1.0
+---
+
+# Micro-interactions (UI Motion)
+
+Small, functional motion that makes an interface feel responsive and alive: hover/press/focus feedback, toggles, toasts, drawers, and list/layout animation. The goal is feedback and continuity, not decoration.
+
+## When to use
+
+- Hover/press/focus feedback; toggles, checkboxes, like/heart buttons
+- Toasts/snackbars, drawers, modals, tooltips, accordions (enter/exit)
+- List add/remove/reorder; shared-element ("magic move") layout transitions
+- Loading → success → error state transitions
+
+## Principles (apply to all of it)
+
+- Duration: UI micro-interactions live in **100–250ms**. Anything over ~400ms feels laggy for a click response.
+- Animate `transform` and `opacity` only — they are GPU-composited (no layout/paint). Avoid animating `width/height/top/left`; use `scale` or layout animation instead.
+- Give **instant** press feedback: `scale: 0.96` on tap with a fast spring.
+- Asymmetric timing: enter slightly slower (ease-out), exit faster (ease-in). Things should arrive gracefully and leave promptly.
+- Respect `prefers-reduced-motion`: gate non-essential motion; keep opacity changes, drop large movement.
+- Easing defaults: ease-out for entrances `cubic-bezier(0.16, 1, 0.3, 1)`; a tasteful overshoot is `cubic-bezier(0.34, 1.56, 0.64, 1)`; standard move `cubic-bezier(0.4, 0, 0.2, 1)`.
+
+## Framer Motion (motion/react) essentials
+
+As of v11+, the package is imported as `motion/react` (the `framer-motion` name still works).
+
+### Gestures and springs
+
+```jsx
+import { motion } from "motion/react";
+
+<motion.button
+  whileHover={{ scale: 1.03 }}
+  whileTap={{ scale: 0.96 }}
+  whileFocus={{ boxShadow: "0 0 0 3px rgba(59,130,246,.5)" }}
+  transition={{ type: "spring", stiffness: 400, damping: 30 }}
+/>
+```
+
+Spring intuition: higher `stiffness` = faster; higher `damping` = less bounce. `stiffness: 400, damping: 30` is a snappy UI default. For visible bounce, lower damping (e.g. `damping: 12`).
+
+### Enter / exit with AnimatePresence
+
+Exit animations require `AnimatePresence` wrapping conditionally-rendered children, each with a stable `key`.
+
+```jsx
+import { AnimatePresence, motion } from "motion/react";
+
+<AnimatePresence>
+  {open && (
+    <motion.div
+      key="panel"
+      initial={{ opacity: 0, y: 8 }}
+      animate={{ opacity: 1, y: 0 }}
+      exit={{ opacity: 0, y: 8 }}
+      transition={{ duration: 0.2, ease: [0.16, 1, 0.3, 1] }}
+    />
+  )}
+</AnimatePresence>
+```
+
+For toasts/lists, use `mode="popLayout"` so removed items don't hold space while exiting.
+
+### Layout animation (the superpower)
+
+`layout` automatically animates any layout change (position/size) using transforms — perfect for reordering, expanding cards, and grid<->list.
+
+```jsx
+<motion.li layout transition={{ type: "spring", stiffness: 500, damping: 40 }} />
+```
+
+Shared-element transition across components: give two elements the same `layoutId` and Framer Motion animates between them as one mounts and the other unmounts.
+
+```jsx
+{!open && <motion.div layoutId="card" onClick={() => setOpen(true)} />}
+<AnimatePresence>
+  {open && <motion.div layoutId="card" />} {/* "magic moves" from the source */}
+</AnimatePresence>
+```
+
+Gotcha: a plain `layout` element distorts `border-radius` and text during scale. Add `layout` to direct children that should counter-scale, and prefer `borderRadius`/`boxShadow` as motion values, or use `layout="position"` to animate position only.
+
+## Pure CSS path (no JS, including discrete properties)
+
+Modern CSS can animate enter/exit and even `display` toggles without a library.
+
+```css
+.toast {
+  transition: opacity 0.2s ease, transform 0.2s ease;
+  /* allow animating to/from display:none and from initial render */
+  transition-behavior: allow-discrete;
+}
+.toast[hidden] { display: none; }
+
+/* animate FROM these values on first render / when entering */
+@starting-style {
+  .toast { opacity: 0; transform: translateY(8px); }
+}
+```
+
+`@starting-style` defines the "before-open" values so an element animates in on first appearance; `transition-behavior: allow-discrete` lets `display` (and `overlay` for popovers/dialogs) participate so exit animations run before the element is removed. Baseline in Chrome/Edge/Safari; provide a no-animation fallback for older browsers.
+
+Always include a reduced-motion guard:
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.01ms !important;
+    transition-duration: 0.01ms !important;
+  }
+}
+```
+
+## State, not just decoration
+
+Loading → success → error should be one continuous motion (e.g. a button morphs spinner → checkmark), not a jump cut. Keep the element mounted and animate between states so the eye tracks the same object.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained interaction demo (toggle, like button, toast, drawer) the deliverable is **one HTML file that opens directly in a browser**. Pure-CSS interactions ship as-is; for a Framer Motion demo, load React + `motion` from CDN (`esm.sh`) into one inline module — no build step. One file is the right tier; don't reach for a bundler.
+
+**Output contract:**
+- One `.html` file: your markup plus either CSS transitions/`@starting-style` or an inline `<script type="module">` importing `motion` from CDN.
+- A way to land on the **resolved end state** for a screenshot — interactions are state-driven, not time-driven, so freeze the state rather than a clock.
+
+**Seek harness — pin a deterministic state.** A micro-interaction's "frames" are its states (idle / hover / pressed / open). `?state=open` applies the target state on load so a screenshot captures it settled:
+
+```html
+<script>
+  const s = new URLSearchParams(location.search).get("state");
+  if (s) document.documentElement.dataset.state = s;   // CSS keys off [data-state="open"]
+  // Framer Motion: set the controlled prop from `s` (e.g. const [open]=useState(s==="open"))
+  // For a CSS @keyframes loop instead, freeze it: el.style.animationDelay=(-N)+"s"; el.style.animationPlayState="paused";
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — render → set state → screenshot → check:** open each meaningful state (`?state=idle`, `?state=hover`, `?state=open`), screenshot, and check **fidelity** (press feedback reads instant, exit runs before unmount) plus **artifacts** (`layout` distorting `border-radius`/text, toast holding space after exit, FOUC, jank). Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=400 "file://$PWD/demo.html?state=open" open.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, CDN React/`motion` (if used) resolves.
+2. The `?state=` (or controlled-prop) freeze lands a deterministic, settled state.
+3. Screenshotted across states — idle / active / open — matches the brief, no artifacts.
+4. `prefers-reduced-motion` honored — large movement dropped, opacity/feedback kept.
+5. Easing is intentional — enter ease-out, exit ease-in, durations in the 100–250ms band.
+
+## Quick reference
+
+| Need | Approach |
+|------|----------|
+| Press feedback | `whileTap={{ scale: 0.96 }}` spring 400/30 |
+| Enter/exit | `AnimatePresence` + `initial/animate/exit` |
+| Reorder / resize | `layout` prop (spring) |
+| Magic move | shared `layoutId` |
+| Toast stack | `AnimatePresence mode="popLayout"` |
+| No-JS enter | `@starting-style` + transition |
+| Animate to display:none | `transition-behavior: allow-discrete` |
+| Accessibility | `prefers-reduced-motion` guard always |
+
+## Reference files
+
+- `references/framer-motion-recipes.md` — variants + stagger, `AnimatePresence` modes, `layout`/`layoutId` magic move, `Reorder` drag-to-sort, drag constraints, gesture composition, and `useReducedMotion`.
+- `references/css-recipes.md` — `@starting-style`, `transition-behavior: allow-discrete`, popover/dialog exit animation, keyframe spinners/toggles, `@property` for animatable custom properties, and `prefers-reduced-motion` patterns.

.agents/skills/micro-interaction/references/css-recipes.md

@@ -0,0 +1,142 @@
+# CSS Micro-interaction Recipes
+
+Modern CSS handles most UI motion with zero JavaScript, including enter/exit and `display` toggles. Baseline-available in current Chrome/Edge/Safari/Firefox (verify `@starting-style` and `allow-discrete` for your support floor; degrade to instant show/hide otherwise).
+
+## Enter animation on first render: @starting-style
+
+`@starting-style` supplies the values an element transitions FROM the first time it renders (or becomes shown). Without it, there is no "previous" state to transition from, so newly-inserted elements snap in.
+
+```css
+.menu {
+  opacity: 1;
+  transform: translateY(0);
+  transition: opacity 0.2s ease, transform 0.2s ease;
+}
+@starting-style {
+  .menu { opacity: 0; transform: translateY(-8px); }
+}
+```
+
+## Animating to/from display:none: transition-behavior: allow-discrete
+
+`display` and `content-visibility` are discrete properties — normally they flip instantly, killing exit animations. `allow-discrete` lets them flip at the correct moment (kept visible during exit, swapped at the end).
+
+```css
+.drawer {
+  transition:
+    transform 0.25s ease,
+    opacity 0.25s ease,
+    display 0.25s allow-discrete; /* keep displayed through the exit */
+}
+.drawer[hidden] {            /* closed state */
+  opacity: 0;
+  transform: translateX(100%);
+  display: none;
+}
+@starting-style {
+  .drawer:not([hidden]) { opacity: 0; transform: translateX(100%); }
+}
+```
+
+Shorthand alternative: `transition-behavior: allow-discrete;` applies to all discrete properties in the `transition` list.
+
+## Popover / dialog exit animation (top-layer)
+
+Native `popover` and `<dialog>` live in the top layer via the `overlay` property, which is also discrete — animate it too:
+
+```css
+[popover] {
+  opacity: 0;
+  transform: scale(0.95);
+  transition: opacity 0.2s, transform 0.2s, overlay 0.2s allow-discrete, display 0.2s allow-discrete;
+}
+[popover]:popover-open { opacity: 1; transform: scale(1); }
+@starting-style {
+  [popover]:popover-open { opacity: 0; transform: scale(0.95); }
+}
+```
+
+This gives a fully CSS-driven open AND close animation for `<button popovertarget>` popovers with no JS.
+
+## Press / hover / focus feedback
+
+```css
+.btn {
+  transition: transform 0.12s cubic-bezier(0.34, 1.56, 0.64, 1), box-shadow 0.2s ease;
+}
+.btn:hover  { transform: translateY(-1px); box-shadow: 0 4px 12px rgba(0,0,0,.15); }
+.btn:active { transform: translateY(0) scale(0.97); transition-duration: 0.06s; } /* snappy press */
+.btn:focus-visible { outline: 2px solid #3b82f6; outline-offset: 2px; }
+```
+
+Use `:focus-visible` (not `:focus`) so keyboard users get a ring but mouse clicks don't.
+
+## Animated toggle / switch
+
+```css
+.switch { width: 44px; height: 24px; border-radius: 999px; background: #cbd5e1;
+  transition: background 0.2s ease; }
+.switch[aria-checked="true"] { background: #22c55e; }
+.switch::after {
+  content: ""; width: 20px; height: 20px; border-radius: 50%; background: #fff;
+  transform: translateX(2px);
+  transition: transform 0.22s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+.switch[aria-checked="true"]::after { transform: translateX(22px); }
+```
+
+The `cubic-bezier(0.34, 1.56, 0.64, 1)` overshoot gives the knob a satisfying snap.
+
+## Loading spinner and pulse
+
+```css
+@keyframes spin { to { transform: rotate(360deg); } }
+.spinner { animation: spin 0.8s linear infinite; }
+
+@keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.5; } }
+.skeleton { animation: pulse 1.5s ease-in-out infinite; }
+```
+
+## Animatable custom properties with @property
+
+Plain CSS variables animate discretely. Register them with `@property` to give them a type so they interpolate smoothly — enables gradient angle, number counters, and themed motion.
+
+```css
+@property --angle { syntax: "<angle>"; inherits: false; initial-value: 0deg; }
+
+.gradient-border {
+  background: conic-gradient(from var(--angle), #6366f1, #ec4899, #6366f1);
+  transition: --angle 0.4s ease;
+}
+.gradient-border:hover { --angle: 360deg; }
+```
+
+## Accordion height (modern: interpolate-size)
+
+Animating `height: auto` historically required JS measurement. With `interpolate-size: allow-keywords`, transitions to/from intrinsic sizes work:
+
+```css
+:root { interpolate-size: allow-keywords; }
+.accordion__panel {
+  height: 0; overflow: hidden;
+  transition: height 0.3s ease;
+}
+.accordion__panel[data-open] { height: auto; }
+```
+
+Fallback for unsupported browsers: animate `grid-template-rows: 0fr -> 1fr` on a wrapper.
+
+## Reduced motion (always include)
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+  }
+}
+```
+
+Then selectively re-enable essential, low-motion feedback (e.g. opacity-only fades) inside the same query if needed. The principle: never remove feedback entirely, just remove large/spatial motion.

.agents/skills/micro-interaction/references/framer-motion-recipes.md

@@ -0,0 +1,187 @@
+# Framer Motion Recipes
+
+Import from `motion/react` (v11+). All examples are React + Framer Motion.
+
+```jsx
+import { motion, AnimatePresence, Reorder, useReducedMotion, useDragControls } from "motion/react";
+```
+
+## Variants and staggered children
+
+Variants are named animation states a parent can propagate to children, enabling orchestration like staggering without per-child timing math.
+
+```jsx
+const list = {
+  hidden: { opacity: 0 },
+  show: {
+    opacity: 1,
+    transition: { staggerChildren: 0.06, delayChildren: 0.1 },
+  },
+};
+const item = {
+  hidden: { opacity: 0, y: 12 },
+  show: { opacity: 1, y: 0, transition: { type: "spring", stiffness: 500, damping: 30 } },
+};
+
+<motion.ul variants={list} initial="hidden" animate="show">
+  {items.map((t) => (
+    <motion.li key={t.id} variants={item}>{t.label}</motion.li>
+  ))}
+</motion.ul>
+```
+
+`staggerDirection: -1` staggers from last to first. `when: "beforeChildren"` / `"afterChildren"` sequences parent vs children.
+
+## AnimatePresence modes
+
+```jsx
+<AnimatePresence mode="wait">   {/* outgoing finishes before incoming starts (route/tab switches) */}
+  <motion.div key={tab} initial={{opacity:0}} animate={{opacity:1}} exit={{opacity:0}} />
+</AnimatePresence>
+```
+
+Modes:
+- default (`"sync"`) — incoming and outgoing animate simultaneously.
+- `"wait"` — finish exit before enter (single-element swaps like tabs/pages).
+- `"popLayout"` — exiting items are popped from layout flow so siblings re-flow immediately (toast stacks, removing list items). Children must be capable of `layout`.
+
+Require a unique, stable `key` on each child. To run exit on initial mount too, that is not needed; to suppress enter animation on first render set `<AnimatePresence initial={false}>`.
+
+## Toast stack (popLayout + layout)
+
+```jsx
+function Toasts({ toasts }) {
+  return (
+    <div className="toast-region">
+      <AnimatePresence mode="popLayout">
+        {toasts.map((t) => (
+          <motion.div
+            key={t.id}
+            layout
+            initial={{ opacity: 0, y: 24, scale: 0.9 }}
+            animate={{ opacity: 1, y: 0, scale: 1 }}
+            exit={{ opacity: 0, scale: 0.9, transition: { duration: 0.15 } }}
+            transition={{ type: "spring", stiffness: 500, damping: 40 }}
+          >
+            {t.message}
+          </motion.div>
+        ))}
+      </AnimatePresence>
+    </div>
+  );
+}
+```
+
+`layout` makes remaining toasts slide up smoothly when one is dismissed.
+
+## Magic-move / shared-element layout
+
+```jsx
+function Gallery() {
+  const [active, setActive] = useState(null);
+  return (
+    <>
+      <div className="grid">
+        {photos.map((p) => (
+          <motion.img key={p.id} layoutId={`photo-${p.id}`} src={p.thumb}
+            onClick={() => setActive(p)} />
+        ))}
+      </div>
+      <AnimatePresence>
+        {active && (
+          <motion.div className="backdrop" onClick={() => setActive(null)}
+            initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}>
+            <motion.img layoutId={`photo-${active.id}`} src={active.full} />
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </>
+  );
+}
+```
+
+Matching `layoutId` makes the thumbnail visually fly to the lightbox and back.
+
+## Drag-to-reorder list
+
+`Reorder` handles pointer drag, axis locking, and live reordering with layout animation built in.
+
+```jsx
+function SortableList({ items, setItems }) {
+  return (
+    <Reorder.Group axis="y" values={items} onReorder={setItems}>
+      {items.map((item) => (
+        <Reorder.Item key={item} value={item}
+          whileDrag={{ scale: 1.03, boxShadow: "0 8px 24px rgba(0,0,0,.18)" }}>
+          {item}
+        </Reorder.Item>
+      ))}
+    </Reorder.Group>
+  );
+}
+```
+
+For a dedicated drag handle, use `useDragControls`:
+
+```jsx
+const controls = useDragControls();
+<Reorder.Item value={item} dragListener={false} dragControls={controls}>
+  <span className="handle" onPointerDown={(e) => controls.start(e)}>⠿</span>
+  {item.label}
+</Reorder.Item>
+```
+
+## Drag with constraints and elastic
+
+```jsx
+const ref = useRef(null);
+<div ref={ref} className="bounds">
+  <motion.div drag dragConstraints={ref} dragElastic={0.2}
+    dragTransition={{ bounceStiffness: 600, bounceDamping: 20 }} />
+</div>
+```
+
+`dragElastic` (0–1) controls how far past constraints it can be pulled; `dragSnapToOrigin` returns it on release.
+
+## Gesture composition (like button)
+
+```jsx
+function Like() {
+  const [liked, setLiked] = useState(false);
+  return (
+    <motion.button onClick={() => setLiked((v) => !v)} whileTap={{ scale: 0.85 }}>
+      <motion.span
+        animate={liked ? { scale: [1, 1.4, 1], color: "#ef4444" } : { scale: 1, color: "#9ca3af" }}
+        transition={{ duration: 0.35, ease: "easeOut" }}
+      >♥</motion.span>
+    </motion.button>
+  );
+}
+```
+
+Arrays of values (`scale: [1, 1.4, 1]`) are keyframes; control their spacing with `times: [0, 0.6, 1]`.
+
+## Respecting reduced motion
+
+```jsx
+function Panel() {
+  const reduce = useReducedMotion();
+  return (
+    <motion.div
+      initial={reduce ? false : { opacity: 0, y: 12 }}
+      animate={{ opacity: 1, y: 0 }}
+    />
+  );
+}
+```
+
+Wrap an app in `<MotionConfig reducedMotion="user">` to globally strip transform/layout animations for users who prefer reduced motion while keeping opacity.
+
+## Performance notes
+
+- Prefer `transform`/`opacity`; Framer Motion already uses transforms for `x/y/scale/rotate`.
+- For frequently-updated values (cursor follow, scroll), use `useMotionValue` + `useSpring` instead of React state to avoid re-renders.
+- `layout` is powerful but measure-heavy; avoid putting it on hundreds of simultaneously-animating nodes.
+
+---
+Tune the timing and easing and a micro-interaction feels effortless. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=micro-interaction)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/page-transition-animation/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: page-transition-animation
+description: This skill should be used when the user asks to "animate page or route transitions", "add a page transition or crossfade between views", "animate route changes in Next.js App Router", "use the View Transitions API", "AnimatePresence exit doesn't fire on navigation", or "Framer Motion exit animation not working / exit animation before unmount in Next.js". Covers enter/exit page-transition animation with the View Transitions API and Framer Motion, for Next.js App Router and general SPA routing.
+version: 0.1.0
+---
+
+# Page Transition Animation (Next.js App Router)
+
+Implement page enter/exit transitions in the Next.js **App Router**, and fix the single most common failure: **Framer Motion `AnimatePresence` exit animations never fire on navigation**. The reason is structural — in the App Router, when navigating, Next.js unmounts the old route's content and mounts the new one almost immediately. `AnimatePresence` can only animate an exit if the *exiting element stays mounted* under a *persistent* `AnimatePresence` wrapper long enough to run the animation. Because the router swaps children out from under it, the exit is skipped. Two approaches solve this: a pathname-keyed `AnimatePresence` with the **FrozenRouter** pattern, or the **View Transitions API** (native / `next-view-transitions`).
+
+## When to use
+
+Use when adding animated page transitions in a Next.js App Router app, when a Framer Motion `exit` prop does nothing on route change, when an old page disappears instantly instead of animating out, when choosing between Framer Motion and the View Transitions API for Next.js, or when debugging why `AnimatePresence` won't animate between routes.
+
+## Why exit doesn't fire (the core problem)
+
+`AnimatePresence` detects removal of a *direct keyed child*. On App Router navigation:
+
+1. The wrapper must persist across the navigation. If `AnimatePresence` lives in a component that itself unmounts, there is nothing left to run the exit.
+2. The child's `key` must change per route so AnimatePresence sees "old removed, new added".
+3. During the brief overlap, the *outgoing* subtree must still render its old content — but the App Router has already swapped the route context, so the outgoing tree would otherwise render the *new* page's data. This is what **FrozenRouter** fixes.
+
+## Solution A: template.tsx + keyed AnimatePresence + FrozenRouter
+
+`template.tsx` is the App Router's purpose-built hook for this: unlike `layout.tsx` (which persists), a **template remounts on every navigation**, giving each route a fresh instance — ideal for per-route enter animations. Combine it with a pathname-keyed `AnimatePresence` and FrozenRouter for clean exit + enter.
+
+```tsx
+// app/template.tsx
+'use client';
+import { AnimatePresence } from 'framer-motion';
+import { usePathname } from 'next/navigation';
+import { FrozenRouter } from './frozen-router';
+import { PageTransition } from './page-transition';
+
+export default function Template({ children }: { children: React.ReactNode }) {
+  const pathname = usePathname();
+  return (
+    <AnimatePresence mode="wait" initial={false}>
+      {/* key on pathname so AnimatePresence sees old removed / new added */}
+      <PageTransition key={pathname}>
+        {/* FrozenRouter keeps the OUTGOING tree rendering its old content
+            while it animates out */}
+        <FrozenRouter>{children}</FrozenRouter>
+      </PageTransition>
+    </AnimatePresence>
+  );
+}
+```
+
+```tsx
+// app/page-transition.tsx
+'use client';
+import { motion } from 'framer-motion';
+
+export function PageTransition({ children }: { children: React.ReactNode }) {
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: 12 }}
+      animate={{ opacity: 1, y: 0 }}
+      exit={{ opacity: 0, y: -12 }}
+      transition={{ duration: 0.3, ease: [0.22, 1, 0.36, 1] }}
+    >
+      {children}
+    </motion.div>
+  );
+}
+```
+
+```tsx
+// app/frozen-router.tsx
+'use client';
+import { useContext, useRef } from 'react';
+import {
+  LayoutRouterContext,
+} from 'next/dist/shared/lib/app-router-context.shared-runtime';
+
+// Freezes the router context so the exiting page keeps rendering its
+// OWN content during the exit animation instead of the next route's.
+export function FrozenRouter({ children }: { children: React.ReactNode }) {
+  const context = useContext(LayoutRouterContext ?? {});
+  const frozen = useRef(context).current;
+
+  return (
+    <LayoutRouterContext.Provider value={frozen}>
+      {children}
+    </LayoutRouterContext.Provider>
+  );
+}
+```
+
+How it fits together:
+
+- `mode="wait"` makes AnimatePresence fully finish the exit before mounting the new page. (Use the default mode if enter/exit should overlap/crossfade.)
+- `initial={false}` skips the enter animation on first load (optional).
+- `key={pathname}` is what makes AnimatePresence treat each route as a distinct presence.
+- `FrozenRouter` snapshots `LayoutRouterContext` so the outgoing subtree renders the *previous* route's content throughout the exit, instead of flashing the new route's content. Without it, exit either skips or shows the wrong content.
+
+Note: `LayoutRouterContext` is a Next.js internal; its import path can change between Next versions. If the import breaks after an upgrade, that path is the thing to update.
+
+## Solution B: native View Transitions API
+
+The View Transitions API animates between two DOM states with the browser capturing before/after snapshots — no per-element exit components.
+
+```css
+/* globals.css */
+@view-transition { navigation: auto; } /* opt MPA-style in (where supported) */
+
+::view-transition-old(root) { animation: fade 0.25s both reverse; }
+::view-transition-new(root) { animation: fade 0.25s both; }
+@keyframes fade { from { opacity: 0; } to { opacity: 1; } }
+```
+
+For SPA-style App Router navigations, wrap the router update:
+
+```ts
+if (document.startViewTransition) {
+  document.startViewTransition(() => router.push(href));
+} else {
+  router.push(href);
+}
+```
+
+### next-view-transitions library
+
+`next-view-transitions` integrates the View Transitions API with the App Router's client navigation so it works out of the box:
+
+```tsx
+// app/layout.tsx
+import { ViewTransitions } from 'next-view-transitions';
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <ViewTransitions>
+      <html lang="en"><body>{children}</body></html>
+    </ViewTransitions>
+  );
+}
+```
+
+```tsx
+// use the library's Link instead of next/link
+import { Link } from 'next-view-transitions';
+<Link href="/about">About</Link>;
+```
+
+Choose View Transitions for simple cross-page fades/morphs and shared-element transitions with minimal JS; choose Framer Motion when fine-grained, orchestrated, interruptible, or staggered exit animations are needed. View Transitions API browser support is still uneven, so provide a graceful fallback (the `if (document.startViewTransition)` guard).
+
+## AnimatePresence debug checklist
+
+When exit still won't fire, verify in order:
+
+1. **Wrapper stays mounted.** `AnimatePresence` must live in something persistent — ideally `template.tsx`, or a layout-level client component — not inside the page that's unmounting.
+2. **Stable, changing key.** The animated child needs `key={pathname}` (or similar) so removal is detected. No key, or a key that doesn't change → no exit.
+3. **Direct motion descendant.** The element with the `exit` prop must be a `motion.*` component and a child of `AnimatePresence` (a non-motion wrapper in between can block detection).
+4. **`mode="wait"`** if old and new should not overlap; without it both render simultaneously and may jump.
+5. **FrozenRouter present** if the outgoing page flashes the new route's content during exit.
+6. **`'use client'`** on every file using AnimatePresence/usePathname/motion.
+7. **Single child at a time** under `mode="wait"` — AnimatePresence expects one keyed presence to swap.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+The real target is a Next.js app, but to *prove the transition shape* (the enter/exit curve, direction, crossfade) you can ship **one HTML file that opens directly in a browser** — two stub "pages" you toggle, animated with `motion` from CDN or the native View Transitions API. One file is the right tier for validating motion before wiring the router; don't stand up Next just to eyeball a fade.
+
+**Output contract:**
+- One `.html` file: two view stubs and a toggle, animated with either an inline `<script type="module">` importing `motion`/React from CDN, or `document.startViewTransition` + `::view-transition-*` CSS.
+- A way to freeze the **resolved end state** — a route transition is state-driven (which view, mid-swap), so screenshot the state, not a clock.
+
+**Seek harness — pin a transition phase.** `?view=b` mounts the destination view (or `?phase=exit` to hold the outgoing tree mid-animation) so a screenshot lands on a settled phase:
+
+```html
+<script>
+  const p = new URLSearchParams(location.search);
+  document.documentElement.dataset.view = p.get("view") || "a";   // CSS/React keys off this
+  // Framer Motion: set the controlled key/route from ?view; for mode="wait" the resolved end is the new page
+  // View Transitions: screenshot the END state (snapshots are transient); or pause via emulate slow animations
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — render → set phase → screenshot → check:** open source, mid, and destination (`?view=a`, `?phase=exit`, `?view=b`), screenshot each, and check **fidelity** (exit actually runs, direction/crossfade matches the brief, no `mode="wait"` lag) plus **artifacts** (outgoing tree flashing the new page's content, double-mount, FOUC, jank). Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/transition.html?view=b" dest.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, CDN `motion`/React (if used) resolves, `startViewTransition` guarded.
+2. The `?view=`/`?phase=` freeze lands a deterministic transition phase.
+3. Screenshotted at source / mid / destination — matches the brief, no content flash or skipped exit.
+4. `prefers-reduced-motion` honored — slide/translate dropped to a short crossfade.
+5. Easing is intentional — entrances ease-out, exits ease-in, durations ~0.2–0.4s (not laggy under `mode="wait"`).
+
+## Quick reference
+
+| Need | Approach |
+|---|---|
+| Per-route enter animation | `app/template.tsx` (remounts each nav) |
+| Exit animation on nav | keyed `AnimatePresence mode="wait"` + FrozenRouter |
+| Outgoing page shows old content | FrozenRouter (snapshot `LayoutRouterContext`) |
+| Detect route change | `usePathname()` as the `key` |
+| Simple cross-page fade/morph | View Transitions API / next-view-transitions |
+| Shared element transition | `view-transition-name` CSS |
+| Skip first-load animation | `initial={false}` |
+
+## Gotchas
+
+- `layout.tsx` persists and will NOT remount per route — use `template.tsx` for per-route enter animations.
+- Omitting FrozenRouter makes the exiting page render the *new* route's content mid-animation (visible flash) or skip exit entirely.
+- `LayoutRouterContext` import path is a Next internal; it may change across versions — first thing to fix after an upgrade.
+- Without `key={pathname}`, AnimatePresence sees the same child and never triggers exit.
+- `mode="wait"` waits for exit before enter; overusing it on slow exits makes navigation feel laggy — tune durations (~0.2-0.4s).
+- View Transitions API lacks full browser support; always guard `document.startViewTransition`.
+- Every transition file needs `'use client'`; server components can't use AnimatePresence/usePathname.
+
+## Reference files
+
+- `references/full-examples.md` — directional/slide transitions, shared-element View Transitions with `view-transition-name`, a non-`mode="wait"` crossfade variant, loading-state transitions with `loading.tsx`, and a complete working App Router folder layout.

.agents/skills/page-transition-animation/references/full-examples.md

@@ -0,0 +1,176 @@
+# Full examples and variants
+
+## Working folder layout
+
+```
+app/
+  layout.tsx           # persistent shell (html/body, providers)
+  template.tsx         # remounts per route -> hosts AnimatePresence
+  page-transition.tsx  # motion wrapper (enter/exit variants)
+  frozen-router.tsx    # FrozenRouter (LayoutRouterContext snapshot)
+  page.tsx             # home
+  about/page.tsx
+  globals.css
+```
+
+## Directional slide transitions
+
+Track direction by comparing route depth or a route order map, then feed it to variants.
+
+```tsx
+// app/page-transition.tsx
+'use client';
+import { motion } from 'framer-motion';
+import { usePathname } from 'next/navigation';
+import { useRef } from 'react';
+
+const order = ['/', '/about', '/work', '/contact'];
+
+export function PageTransition({ children }: { children: React.ReactNode }) {
+  const pathname = usePathname();
+  const prev = useRef(pathname);
+  const dir =
+    order.indexOf(pathname) > order.indexOf(prev.current) ? 1 : -1;
+  prev.current = pathname;
+
+  return (
+    <motion.div
+      custom={dir}
+      variants={{
+        initial: (d: number) => ({ opacity: 0, x: 40 * d }),
+        animate: { opacity: 1, x: 0 },
+        exit: (d: number) => ({ opacity: 0, x: -40 * d }),
+      }}
+      initial="initial"
+      animate="animate"
+      exit="exit"
+      transition={{ duration: 0.3, ease: [0.22, 1, 0.36, 1] }}
+    >
+      {children}
+    </motion.div>
+  );
+}
+```
+
+## Crossfade variant (no mode="wait")
+
+Omit `mode="wait"` so old and new overlap. Stack them absolutely to avoid layout jump.
+
+```tsx
+// app/template.tsx
+'use client';
+import { AnimatePresence, motion } from 'framer-motion';
+import { usePathname } from 'next/navigation';
+import { FrozenRouter } from './frozen-router';
+
+export default function Template({ children }: { children: React.ReactNode }) {
+  const pathname = usePathname();
+  return (
+    <AnimatePresence initial={false}>
+      <motion.div
+        key={pathname}
+        style={{ gridArea: '1 / 1' }}      // overlap in a 1-cell grid parent
+        initial={{ opacity: 0 }}
+        animate={{ opacity: 1 }}
+        exit={{ opacity: 0 }}
+        transition={{ duration: 0.35 }}
+      >
+        <FrozenRouter>{children}</FrozenRouter>
+      </motion.div>
+    </AnimatePresence>
+  );
+}
+```
+
+Wrap the template output's parent in `display: grid` so both stacked children occupy `grid-area: 1 / 1`.
+
+## Shared-element transition (View Transitions API)
+
+Give the same logical element the same `view-transition-name` on both pages; the browser morphs between them.
+
+```tsx
+// list page
+<img src={cover} style={{ viewTransitionName: `cover-${id}` }} />
+// detail page
+<img src={cover} style={{ viewTransitionName: `cover-${id}` }} />
+```
+
+```css
+::view-transition-old(root),
+::view-transition-new(root) { animation-duration: 0.3s; }
+/* the named element animates automatically between its two positions */
+```
+
+With `next-view-transitions`, use its `<Link>` and the morph happens on navigation. Each `view-transition-name` must be unique on the page at a time.
+
+## loading.tsx + transitions
+
+`loading.tsx` shows an instant Suspense fallback during server work. To animate it, make the fallback a motion component; it mounts/unmounts within the same template-driven AnimatePresence flow.
+
+```tsx
+// app/work/loading.tsx
+'use client';
+import { motion } from 'framer-motion';
+export default function Loading() {
+  return (
+    <motion.div initial={{ opacity: 0 }} animate={{ opacity: 1 }}>
+      Loading…
+    </motion.div>
+  );
+}
+```
+
+## Reduced-motion
+
+```tsx
+'use client';
+import { useReducedMotion, motion } from 'framer-motion';
+
+export function PageTransition({ children }: { children: React.ReactNode }) {
+  const reduce = useReducedMotion();
+  return (
+    <motion.div
+      initial={reduce ? false : { opacity: 0, y: 12 }}
+      animate={{ opacity: 1, y: 0 }}
+      exit={reduce ? { opacity: 1 } : { opacity: 0, y: -12 }}
+      transition={{ duration: reduce ? 0 : 0.3 }}
+    >
+      {children}
+    </motion.div>
+  );
+}
+```
+
+For the View Transitions API, gate with CSS:
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  ::view-transition-old(root),
+  ::view-transition-new(root) { animation: none; }
+}
+```
+
+## FrozenRouter import note across versions
+
+The internal context import has shifted across Next versions, e.g.:
+
+```ts
+// commonly:
+import { LayoutRouterContext } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+```
+
+If an upgrade breaks the import, search `node_modules/next/dist/shared/lib/` for `app-router-context` and update the path. Because it is internal, pin awareness of this in any upgrade checklist.
+
+## Framer Motion vs View Transitions decision
+
+| Factor | Framer Motion | View Transitions API |
+|---|---|---|
+| Browser support | Broad (JS lib) | Uneven; needs fallback |
+| Orchestration/stagger | Excellent | Limited |
+| Interruptible exits | Yes | Limited |
+| Shared element morph | Manual (layoutId) | Native, simple |
+| Bundle cost | Adds library | Minimal/native |
+| Setup complexity | Medium (FrozenRouter) | Low (next-view-transitions) |
+
+---
+Freeze the outgoing route and exit transitions finally fire as intended. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=page-transition-animation)** — the AI motion agent for editable, on-brand motion graphics.

.agents/skills/svg-animation/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: svg-animation
+description: This skill should be used when the user asks to "animate an SVG", "make a line draw itself on", "do a stroke draw-on / signature animation", "morph one shape into another", "move an element along a path", "animate an icon/logo", or "animate an SVG gradient or filter". Covers stroke-dashoffset draw-on, path morphing, motion-along-path, and animated icons/gradients/filters via CSS, SMIL, and GSAP.
+version: 0.1.0
+---
+
+# SVG Animation
+
+Crisp, lightweight, infinitely scalable vector motion — ideal for icons, illustrations, logos, and data marks. SVG can be animated three ways: CSS (declarative, simple), SMIL (`<animate>` inside the SVG), and JS (GSAP/Web Animations, for control and morphing). Choose per task; the techniques below say which.
+
+## When to use
+
+- Stroke "draw-on" of icons, illustrations, signatures, maps
+- Shape/path morphing and animated icon state changes (menu ↔ close, play ↔ pause)
+- Moving an element along a path (motion path)
+- Animated gradients, filters (glow, displacement), and animated logos
+
+## Core techniques
+
+### Stroke draw-on (the staple)
+
+Draw the dash array as long as the path, offset it fully (invisible), then animate the offset to 0.
+
+```css
+.path {
+  stroke-dasharray: var(--len);
+  stroke-dashoffset: var(--len);
+  animation: draw 1.4s ease forwards;
+}
+@keyframes draw { to { stroke-dashoffset: 0; } }
+```
+
+Getting the length:
+- JS (most reliable): `const len = path.getTotalLength(); path.style.setProperty("--len", len);`
+- No-JS trick: set `pathLength="1"` on the `<path>`, then `stroke-dasharray: 1; stroke-dashoffset: 1;` and animate to `0`. This normalizes any path to a 0–1 length so no measurement is needed.
+
+Reverse (erase) by animating offset from 0 back to `len`. Stagger multiple paths with `animation-delay`. Direction of drawing follows the path's point order; reverse it in the editor or negate the offset sign if it draws "backwards".
+
+### Morphing one path into another
+
+Paths interpolate point-by-point, so a naive morph requires both `d` attributes to have the **same number and type of commands**. Two robust approaches:
+
+- **GSAP MorphSVG** (free as of GSAP 3.12) — handles mismatched point counts automatically and finds a good mapping:
+
+```js
+gsap.registerPlugin(MorphSVGPlugin);
+gsap.to("#start", { morphSVG: "#end", duration: 0.8, ease: "power2.inOut" });
+// Convert any shape to a morph-able path:
+MorphSVGPlugin.convertToPath("circle, rect, ellipse, line, polygon");
+```
+
+- **Flubber** (small standalone lib) — generates interpolators without GSAP, good with React/Framer Motion:
+
+```js
+import { interpolate } from "flubber";
+const interpolator = interpolate(pathA, pathB, { maxSegmentLength: 2 });
+// interpolator(0) === pathA, interpolator(1) === pathB; feed t into a tween.
+```
+
+For hand-authored morphs (icon toggles), keep both paths with identical command structure and animate `d` directly via Web Animations or CSS (`d` is animatable in modern browsers via `path("...")`).
+
+### Motion along a path
+
+- **GSAP MotionPath** (preferred — control, alignment, scrub):
+
+```js
+gsap.registerPlugin(MotionPathPlugin);
+gsap.to("#rocket", {
+  duration: 4, repeat: -1, ease: "none",
+  motionPath: { path: "#track", align: "#track", autoRotate: true, alignOrigin: [0.5, 0.5] },
+});
+```
+
+`autoRotate: true` orients the object to the path tangent; `align` makes coordinates relative to the path element.
+
+- **SMIL** (no JS):
+
+```svg
+<path id="track" d="M10,80 C40,10 120,10 150,80" fill="none"/>
+<circle r="6" fill="#3b82f6">
+  <animateMotion dur="3s" repeatCount="indefinite" rotate="auto">
+    <mpath href="#track"/>
+  </animateMotion>
+</circle>
+```
+
+- **CSS** offset-path (modern, declarative): `offset-path: path("M10,80 C..."); animation: move 3s linear infinite;` with `@keyframes move { to { offset-distance: 100%; } }` and `offset-rotate: auto`.
+
+### Animated gradients and filters
+
+Gradients: animate `gradientTransform` or stop offsets. A sheen sweep:
+
+```svg
+<linearGradient id="sheen">
+  <stop offset="0%"  stop-color="#fff" stop-opacity="0"/>
+  <stop offset="50%" stop-color="#fff" stop-opacity=".8"/>
+  <stop offset="100%" stop-color="#fff" stop-opacity="0"/>
+  <animateTransform attributeName="gradientTransform" type="translate"
+    from="-1 0" to="1 0" dur="2s" repeatCount="indefinite"/>
+</linearGradient>
+```
+
+Filters: animate `feDisplacementMap` `scale` for gooey/wobble, `feGaussianBlur` `stdDeviation` for focus pulls, or `feColorMatrix`/`feFlood` for glow. Filters are paint-heavy — animate sparingly and prefer `transform`/`opacity` where possible.
+
+## Implementation choice (pick fast)
+
+| Need | Use |
+|------|-----|
+| Single declarative draw/fade | CSS |
+| Self-contained, no JS bundle | SMIL (`<animate*>` in the SVG) |
+| Coordinated, scrubbable, scroll-tied | GSAP |
+| Mismatched-point morph | GSAP MorphSVG or Flubber |
+| Path following with rotation | GSAP MotionPath / CSS offset-path |
+
+SMIL caveat: not supported in IE/old Edge and historically deprecation-flagged; for max reach or scroll-syncing, prefer CSS or JS. SMIL is still fine for self-contained icon assets in evergreen browsers.
+
+## Authoring and optimization
+
+- Build/clean with **SVGO**: keep `viewBox`, drop editor metadata, but disable `cleanupIds`/`removeViewBox` and any plugin that renames IDs you reference from CSS/JS/SMIL. Disable `mergePaths` and `convertShapeToPath` if you animate individual sub-paths or shapes.
+- Inline the SVG in the DOM (not `<img src>`) so CSS/JS can reach its internals; `<img>`-embedded SVG can only self-animate via internal SMIL/CSS.
+- Set explicit `viewBox` and avoid fixed `width`/`height` so the asset scales fluidly.
+- For draw-on, ensure paths are actual strokes (`fill:none; stroke:...`), not filled outlines — dashoffset only affects strokes.
+- Respect `prefers-reduced-motion`: gate looping/large motion; keep a static final state.
+
+## Deliver & verify (standalone HTML)
+
+> **Packaged helper** (`scripts/`): `scripts/seek-shot.sh anim.html 0 1.5 3` freezes the `?t=N` harness and screenshots each moment; `scripts/contact-sheet.sh sheet.png frame-*.png` tiles them for one-glance review. See `scripts/README.md`.
+
+For a self-contained icon/logo/draw-on the deliverable is **one HTML file that opens directly in a browser** — inline the SVG in the markup, drive the animation with one mechanism, no build step. One file is the right tier for a vector asset; don't reach for a bundler.
+
+**Output contract:**
+- One `.html` file: inline `<svg>`, plus CSS `@keyframes` / a `<script>` with GSAP from CDN / SMIL `<animate*>` — pick one driver.
+- Include the seek harness matching that driver so any moment can be frozen for a screenshot.
+
+**Seek harness — freeze an exact moment.** `?t=N` seeks and pauses so a screenshot lands on a still frame. Use the mechanism that matches how the SVG animates:
+
+```html
+<script>
+  const t = new URLSearchParams(location.search).get("t");
+  if (t !== null) {
+    const N = parseFloat(t);
+    // SMIL: pause the SVG's own clock and scrub it
+    const svg = document.querySelector("svg");
+    svg.pauseAnimations(); svg.setCurrentTime(N);
+    // CSS @keyframes draw-on: el.style.animationDelay=(-N)+"s"; el.style.animationPlayState="paused";
+    // GSAP timeline: tl.pause(); tl.seek(N);
+  }
+  window.__ready = true;
+</script>
+```
+
+**Verify loop — render → freeze → screenshot → check:** open the file at start / mid / end (`?t=0`, `?t=<dur/2>`, `?t=<dur>`), screenshot each, and check **fidelity** (stroke draws in the right direction, morph endpoints clean) plus **artifacts** (path clipped by `viewBox`, stroke vanishing from a stale dashoffset, FOUC, jank at the morph seam). Any headless tool works:
+
+```bash
+npx playwright screenshot --wait-for-timeout=500 "file://$PWD/icon.html?t=0.7" frame-mid.png
+```
+
+**Before you finish:**
+1. Opens standalone — no console errors, inline SVG reachable, CDN (if any) loads.
+2. The seek mechanism for your driver freezes a deterministic frame.
+3. Screenshotted at start / mid / end — matches the brief, no clipping or off-`viewBox` strokes.
+4. `prefers-reduced-motion` honored — looping/large motion gated, static final state kept.
+5. Easing is intentional — `ease`/GSAP ease chosen on purpose, no accidental `linear` draw-on.
+
+## Reference files
+
+- `references/svg-techniques.md` — full dashoffset math and `getTotalLength` gotchas, the `pathLength="1"` normalization, GSAP MorphSVG vs Flubber decision guide with code, an icon-toggle morph (hamburger↔close), MotionPath/offset-path details, SMIL-vs-CSS-vs-JS tradeoffs, and an SVGO config tuned for animation.

.agents/skills/svg-animation/references/svg-techniques.md

@@ -0,0 +1,214 @@
+# SVG Animation Techniques (detailed)
+
+## 1. Stroke draw-on: the math
+
+`stroke-dasharray` defines a dash pattern; `stroke-dashoffset` shifts where the pattern starts. Set the dash equal to the whole path length and offset it by that same length → the visible dash is pushed entirely off the path (invisible). Animating offset to 0 slides the dash into view, revealing the stroke progressively.
+
+```
+visible fraction = 1 - (dashoffset / pathLength)
+```
+
+So offset = length → 0% drawn; offset = 0 → 100% drawn; offset = length/2 → 50% drawn (useful for scroll mapping: `offset = length * (1 - progress)`).
+
+### getTotalLength gotchas
+
+```js
+const path = document.querySelector("#sig");
+const len = path.getTotalLength();           // returns user units of the path geometry
+path.style.strokeDasharray = len;
+path.style.strokeDashoffset = len;
+requestAnimationFrame(() => {                 // next frame so the transition has a start value
+  path.style.transition = "stroke-dashoffset 1.6s ease";
+  path.style.strokeDashoffset = "0";
+});
+```
+
+- `getTotalLength()` measures the path's own coordinate system, ignoring CSS transforms/scaling — which is what you want for dasharray.
+- It only works on geometry elements (`path, line, polyline, polygon, circle, ellipse, rect`). For `<text>` draw-on you must convert text to paths first.
+- Rounding: browsers can clip the last sub-pixel; pad slightly (`len + 1`) if the end never fully closes.
+- Compound paths (multiple `M` subpaths in one `d`) draw all subpaths simultaneously. Split into separate `<path>`s with staggered `animation-delay` for sequential drawing.
+
+### No-JS normalization with pathLength
+
+`pathLength="1"` tells the browser to treat the path's length as exactly 1, regardless of real geometry. Then dash math is unit-free:
+
+```svg
+<path d="..." pathLength="1" fill="none" stroke="#111"
+      style="stroke-dasharray:1; stroke-dashoffset:1; animation:draw 1.4s ease forwards"/>
+```
+```css
+@keyframes draw { to { stroke-dashoffset: 0; } }
+```
+
+This is the cleanest pure-CSS draw-on and avoids hardcoding measured lengths that break when the path is edited. Use `pathLength="100"` if you prefer to think in percentages.
+
+### Scroll-driven draw-on (no library, via offset)
+
+```js
+const len = path.getTotalLength();
+path.style.strokeDasharray = len;
+function onScroll() {
+  const p = Math.min(1, Math.max(0, scrollProgress())); // 0..1
+  path.style.strokeDashoffset = len * (1 - p);
+}
+document.addEventListener("scroll", onScroll, { passive: true });
+```
+
+## 2. Morphing
+
+### Why naive morphs break
+
+Path interpolation walks the `d` command list of A and B in lockstep. If A has 4 cubic curves and B has 7, or A uses `L` where B uses `C`, the browser/animator either refuses or produces garbage. Fixes: match commands by hand, or use a library that resamples.
+
+### GSAP MorphSVG (best for arbitrary shapes)
+
+```js
+import gsap from "gsap";
+import { MorphSVGPlugin } from "gsap/MorphSVGPlugin";
+gsap.registerPlugin(MorphSVGPlugin);
+
+// any shape -> path so it can morph
+MorphSVGPlugin.convertToPath("#circ, #star");
+
+gsap.to("#circ", {
+  duration: 0.9, ease: "power2.inOut",
+  morphSVG: { shape: "#star", shapeIndex: "auto", type: "rotational" },
+});
+```
+
+- `shapeIndex` rotates the starting point mapping to minimize twisting; `"auto"` lets GSAP pick, or pass a number to tune.
+- `type: "rotational"` interpolates angles/lengths instead of raw coordinates — usually smoother for organic morphs.
+- `map: "size" | "position" | "complexity"` changes how sub-paths in compound shapes are matched.
+
+### Flubber (standalone, framework-friendly)
+
+```js
+import { interpolate, separate, combine } from "flubber";
+
+// 1 -> 1 shape
+const lerp = interpolate(pathA, pathB, { maxSegmentLength: 2 });
+
+// splitting one shape into many (or vice versa)
+const split = separate(oneShape, [shape1, shape2, shape3], { single: true });
+```
+
+Drive `lerp(t)` with any tween/`requestAnimationFrame`, or inside Framer Motion:
+
+```jsx
+import { motion, useMotionValue, useTransform, animate } from "motion/react";
+const progress = useMotionValue(0);
+const d = useTransform(progress, [0, 1], [0, 1], { clamp: false });
+const path = useTransform(d, (v) => interpolate(A, B)(v));
+// animate(progress, 1, { duration: 0.6 }) then <motion.path d={path} />
+```
+
+Use Flubber when you can't add GSAP or need React-native value plumbing; use MorphSVG for the highest-quality mapping and convenience.
+
+### Hand-authored icon toggle (hamburger ↔ close) — no morph library
+
+When you control both shapes, give them identical structure and animate transforms instead of `d`:
+
+```svg
+<svg viewBox="0 0 24 24" class="menu" aria-label="Menu">
+  <line class="top" x1="3" y1="6"  x2="21" y2="6"/>
+  <line class="mid" x1="3" y1="12" x2="21" y2="12"/>
+  <line class="bot" x1="3" y1="18" x2="21" y2="18"/>
+</svg>
+```
+```css
+.menu line { stroke:#111; stroke-width:2; transition: transform .25s ease, opacity .2s ease;
+  transform-origin: center; transform-box: fill-box; }
+.menu.open .top { transform: translateY(6px) rotate(45deg); }
+.menu.open .mid { opacity: 0; }
+.menu.open .bot { transform: translateY(-6px) rotate(-45deg); }
+```
+
+`transform-box: fill-box` makes `transform-origin: center` resolve to the element's own bounding box — essential for SVG rotation; without it the origin is the SVG viewport origin.
+
+## 3. Motion along a path — details
+
+### GSAP MotionPath
+
+```js
+gsap.to("#dot", {
+  duration: 5, repeat: -1, ease: "none",
+  motionPath: {
+    path: "#route",
+    align: "#route",          // coordinates relative to the path element
+    alignOrigin: [0.5, 0.5],  // pin the object's center to the path
+    autoRotate: true,         // or a number to add a constant offset angle
+    start: 0, end: 1,         // animate a sub-segment, e.g. 0.2..0.8
+  },
+});
+```
+
+Convert a series of points into a smooth path: `MotionPathPlugin.convertToPath(...)`, or pass `motionPath: [{x:0,y:0},{x:100,y:50},...]` and GSAP draws a curve through them.
+
+### CSS offset-path (declarative, modern)
+
+```css
+.dot {
+  offset-path: path("M10,80 C40,10 120,10 150,80");
+  offset-rotate: auto;                 /* face direction of travel */
+  animation: travel 3s linear infinite;
+}
+@keyframes travel { to { offset-distance: 100%; } }
+```
+
+Newer syntax also accepts `offset-path: url(#route)` referencing a `<path>` id and shapes like `ray()`. Good support in evergreen browsers; no JS needed.
+
+### SMIL animateMotion
+
+Self-contained inside the SVG; use `rotate="auto"` and `<mpath href="#id"/>`. Best for portable icon assets where you don't want external CSS/JS. Avoid when you need scroll-sync or broad legacy support.
+
+## 4. SMIL vs CSS vs JS — tradeoffs
+
+| Axis | SMIL | CSS | JS (GSAP/WAAPI) |
+|------|------|-----|-----------------|
+| Bundle cost | none (inline) | none | library (GSAP ~JS) |
+| Works in `<img>` SVG | yes | yes (internal) | no |
+| Reach (legacy IE/Edge) | no | partial | yes |
+| Scroll/scrub sync | hard | hard | easy |
+| Morph mismatched paths | no | no | yes (MorphSVG/Flubber) |
+| Timeline orchestration | limited | limited | full |
+| Animate `d`/gradients/filters | yes | partial | yes |
+
+Default: CSS for simple declarative effects, GSAP for anything coordinated/scrubbable/morphing, SMIL only for portable self-animating assets in evergreen targets.
+
+## 5. SVGO config tuned for animation
+
+Aggressive SVGO defaults will strip the very things you animate. Use a config like:
+
+```js
+// svgo.config.js
+module.exports = {
+  multipass: true,
+  plugins: [
+    { name: "preset-default", params: { overrides: {
+      removeViewBox: false,        // keep responsive scaling
+      cleanupIds: false,           // DO NOT rename ids referenced by CSS/JS/SMIL/gradients
+      mergePaths: false,           // keep sub-paths separate for staggered draw-on
+      convertShapeToPath: false,   // keep <circle>/<rect> if SMIL/CSS targets them
+      removeHiddenElems: false,    // keep elements you toggle visible via animation
+      inlineStyles: false,         // preserve class hooks
+    } } },
+    { name: "removeDimensions" },  // drop width/height, keep viewBox -> fluid scaling
+    { name: "prefixIds" },         // namespace ids if inlining many SVGs to avoid id collisions
+  ],
+};
+```
+
+If multiple inlined SVGs share gradient/filter ids, id collisions make the LAST definition win for everyone — `prefixIds` (or unique authoring) prevents this classic bug.
+
+## 6. Reduced motion
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  .path { animation: none; stroke-dashoffset: 0; } /* show final drawn state instantly */
+}
+```
+
+For looping decorative SVG (spinners, ambient gradients), pause or hide them under reduced-motion; for functional icon toggles, keep the state change but drop the easing duration.
+
+---
+Pick the right method per shape and SVG draws, morphs, and travels smoothly. Built by **[iart.ai](https://iart.ai/?utm_source=github&utm_medium=readme&utm_campaign=web-animation-skills&utm_content=skill_footer&utm_term=svg-animation)** — the AI motion agent for editable, on-brand motion graphics.

.claude/hooks/session-start.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Only run in Claude Code cloud sessions.
-if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
-  exit 0
-fi
-
-# Install the rea CLI (used by the reverse-engineer-anything skill) if missing.
-if ! command -v rea >/dev/null 2>&1; then
-  npm install --global rea-agents
-fi

.claude/settings.json

@@ -1,14 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

.claude/skills/60fps-animation

@@ -0,0 +1 @@
+../../.agents/skills/60fps-animation

.claude/skills/accessible-animation

@@ -0,0 +1 @@
+../../.agents/skills/accessible-animation

.claude/skills/ascii-animation

@@ -0,0 +1 @@
+../../.agents/skills/ascii-animation

.claude/skills/figma/SKILL.md

@@ -1,55 +0,0 @@
----
-name: figma
-description: Bring Figma into a HyperFrames video - rendered assets, brand tokens, components, storyboard frames as reconstructed motion (frames read as states, not slides), shaders and connector-assisted motion. Use when the person pastes a figma.com link or asks to use a Figma design, frame, logo or brand.
----
-
-**Plugin installs:** Before setup or freshness commands, follow [plugin execution rules](../hyperframes/references/plugin-installation.md) when this skill is inside a HyperFrames plugin.
-
-# Figma → HyperFrames
-
-Every import happens at build time and freezes a local file with its source recorded under `.media/`, so renders never call Figma and re-running a command re-imports only what changed. Assets, tokens and components go over REST with a token; motion and shader data need a Figma connector, or a native export from the person.
-
-## Access
-
-`FIGMA_TOKEN` in the shell or the project `.env`. Check it exists before the first command; if not, tell the person how to make one and stop: figma.com → Settings → Security → Personal access tokens, read-only **File content** and **File metadata**, plus **Library content** for `tokens` on non-Enterprise plans. They set it themselves; never ask them to paste it into the chat.
-
-| Error | Meaning |
-| --- | --- |
-| `BAD_TOKEN` (401) | Expired or revoked: make a new one |
-| `FORBIDDEN` (403) | The message names the missing scope, or the file isn't visible to the account |
-| `REQUIRES_ENTERPRISE` (403, variables) | Not a failure: the published-styles fallback already ran |
-| `RATE_LIMITED` (429) | Already retried with backoff; wait a minute or import fewer nodes per call |
-
-## Commands
-
-- A layer, logo or image: `npx hyperframes figma asset '<url or fileKey:nodeId>' [more refs] --format svg|png --scale 2 --description "<what it is>" [--entity "<brand mark>"]`. SVG for vectors and logos, PNG at 2x for raster. Several nodes of one file in one call render in a single request; `--entity` lets `/media-use` find a brand mark later.
-- Brand colours and type: `npx hyperframes figma tokens <fileKey>`. Run it before `component` and paste the printed entries into `data-composition-variables`. Without Enterprise it falls back to published styles. A connector can supply variables there instead: cache its raw response in `.media/figma-cache/` and write the bindings to `.media/figma-bindings.jsonl` (`{kind:"binding", figmaId, sourceFileKey, compositionVariableId:"figma:<name>", version}`).
-- A frame as editable HTML at exact geometry: `npx hyperframes figma component '<url or fileKey:nodeId>'`, packaged under `compositions/components/<name>/`. A fill bound to an imported token comes out as `var(--slug, #literal)`, so one variable re-brands every import; an unknown token stays a literal marked `data-figma-unresolved`: import that library's tokens and re-import. Ask once which file a library is; never match by hex.
-- Check hero components against Figma's pixels (`figma asset <same node> --format png`). Text drift is the usual cause; report drift you can't fix instead of hand-tweaking the import.
-
-## Motion (connector)
-
-Usage beacon: these phases have no CLI touchpoint, so run `npx hyperframes events --skill=figma-motion` when you begin and `npx hyperframes events --skill=figma-motion --event=skill_completed --outcome=success|error` when done. Same for shaders (`figma-shaders`) and storyboards (`figma-storyboard`).
-
-1. Fetch motion context for the parent frame in one recursive request; cache the raw JSON in `.media/figma-cache/`.
-2. Normalise with `motionContextToDocs(raw, { selectorFor, repeat })` from `@hyperframes/core/figma`, never by transcribing keyframes. It reads the motion.dev snippets (the CSS snippets stretch durations), drops loop-wrap tail keyframes and keeps bezier eases. `selectorFor` returns the ids from the component import.
-3. `motionToGsap(doc)` → `emitTimelineScript(spec)`, injected after the GSAP and CustomEase tags: paused, finite, a literal `window.__timelines` key. Named eases outside the mapped set fall back to linear; say so.
-4. Verify against Figma's own export: `node <SKILL_DIR>/scripts/verify-motion.mjs --reference <export.mp4> --render <render.mp4> --crop WxH+X+Y`. It compares motion between samples, so static drift cancels out, and fails under 15 dB (faithful ≈ 20+, diverging ≈ 5). Measure `--crop` from the render's card edges. A fail means fix the translation, not the threshold.
-5. A track that won't translate: export it, freeze the MP4 and place it as `<video class="clip">`.
-
-## Shaders
-
-Figma's export path flattens shaders to their base colour, and shader source is only reachable for library-published styles. Ask the person for a native export of that frame (PNG or MP4) and place it as an asset or clip.
-
-## Storyboards: frames are KEYFRAMES, not slides
-
-Two frames holding the same element describe that element's state through time: animate the element between the states. Playing the frames back to back as stills is the failure mode.
-
-1. Scenes are every frame-sized node in the section, named frames and loose full-frame rectangles alike: filter by size, not type or name. Order by `absoluteBoundingBox.x`.
-2. Match children across neighbouring frames by name first, then by similar size and position. Tween geometry between states; crossfade two exports in place when the pixels changed. Export one asset per element, not one still per frame. Unmatched children enter or exit at their scene's beat.
-3. Text nodes below the strip are motion notes for the scene above them, not on-screen copy. A note about motion inside a scene ("lines reveal one after another") means import that frame as a component and animate it.
-4. Export in batches of about 4 scene frames per call: past about 12 ids `/v1/images` times out.
-5. Frames that are one product UI in successive states: rebuild the UI as live DOM: code what changes state, freeze what doesn't, and treat each frame change as an interaction to perform (the cursor moves, clicks, the screen responds), not a tween to apply.
-6. Stills are the fallback, only for frames with no shared elements.
-
-Never leave a Figma URL in the composition.

.claude/skills/figma/scripts/verify-motion.mjs

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-/**
- * Objective fidelity gate for figma-motion imports (skill step 2b).
- *
- * Compares the HyperFrames render against Figma's own `export_video` output
- * using MOTION-ENERGY deltas: for each sample window [t, t+interval], the
- * frame difference ref(t+i)-ref(t) is compared (PSNR) against
- * render(t+i)-render(t). Static import divergence (fonts, rasterized edges,
- * subpixel geometry — the hybrid-fidelity ceiling) cancels out of both
- * deltas, so the score isolates choreography: trajectories, timing, easing.
- *
- * Calibration (SDS "Unlocked" card, 2026-07): a faithful translation scored
- * min 20.3dB / mean 27.7dB; a diverging one (invented retract keyframes,
- * wrong durations) scored min 5.0dB / mean 23.1dB. Default threshold 15dB
- * sits between with margin on both sides.
- *
- *   node verify-motion.mjs --reference figma-export.mp4 --render out.mp4 \
- *     [--crop WxH+X+Y] [--interval 0.2] [--min-motion-psnr 15]
- *
- * --crop selects the card region inside the (usually larger) composition
- * frame. Measure it from the render (the card's left/top edge + scaled
- * size), don't guess: a wrong crop reads as motion divergence.
- */
-import { execFileSync, spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-function arg(name, fallback) {
-  const i = process.argv.indexOf(`--${name}`);
-  return i > -1 ? process.argv[i + 1] : fallback;
-}
-const reference = arg("reference");
-const render = arg("render");
-if (!reference || !render) {
-  console.error(
-    "usage: verify-motion.mjs --reference ref.mp4 --render out.mp4 [--crop WxH+X+Y] [--interval 0.2] [--min-motion-psnr 15]",
-  );
-  process.exit(2);
-}
-const crop = arg("crop", null);
-const interval = Number(arg("interval", "0.2"));
-const minMotion = Number(arg("min-motion-psnr", "15"));
-
-const ffprobe = (file) =>
-  Number(
-    execFileSync("ffprobe", [
-      "-v",
-      "error",
-      "-show_entries",
-      "format=duration",
-      "-of",
-      "csv=p=0",
-      "--",
-      file,
-    ])
-      .toString()
-      .trim(),
-  );
-const refDur = ffprobe(reference);
-const renderDur = ffprobe(render);
-const end = Math.min(refDur, renderDur) - interval - 0.01;
-
-const dims = execFileSync("ffprobe", [
-  "-v",
-  "error",
-  "-select_streams",
-  "v",
-  "-show_entries",
-  "stream=width,height",
-  "-of",
-  "csv=p=0",
-  "--",
-  reference,
-])
-  .toString()
-  .trim()
-  .split(",")
-  .map(Number);
-const [rw, rh] = dims;
-
-let cropFilter = "";
-if (crop) {
-  const m = crop.match(/^(\d+)x(\d+)\+(\d+)\+(\d+)$/);
-  if (!m) {
-    console.error("bad --crop, expected WxH+X+Y");
-    process.exit(2);
-  }
-  cropFilter = `crop=${m[1]}:${m[2]}:${m[3]}:${m[4]},`;
-}
-
-const dir = mkdtempSync(join(tmpdir(), "verify-motion-"));
-const frame = (src, t, vf, dst) => {
-  const args = ["-y", "-v", "error", "-ss", String(t), "-i", src, "-frames:v", "1"];
-  if (vf) args.push("-vf", vf);
-  execFileSync("ffmpeg", args.concat(dst));
-};
-const diff = (a, b, dst) =>
-  execFileSync("ffmpeg", [
-    "-y",
-    "-v",
-    "error",
-    "-i",
-    a,
-    "-i",
-    b,
-    "-filter_complex",
-    "blend=all_mode=difference",
-    dst,
-  ]);
-const psnr = (a, b) => {
-  // spawnSync with array args (no shell): psnr stats land on stderr
-  const r = spawnSync("ffmpeg", ["-i", a, "-i", b, "-lavfi", "psnr", "-f", "null", "-"], {
-    encoding: "utf8",
-  });
-  const m = (r.stderr || "").match(/average:([\d.]+|inf)/);
-  return m ? (m[1] === "inf" ? 99 : Number(m[1])) : NaN;
-};
-
-const renderVf = `${cropFilter}scale=${rw}:${rh}`;
-const results = [];
-for (let t = 0; t <= end; t = Math.round((t + interval) * 1000) / 1000) {
-  const t1 = Math.round((t + interval) * 1000) / 1000;
-  frame(reference, t, null, join(dir, "ra.png"));
-  frame(reference, t1, null, join(dir, "rb.png"));
-  frame(render, t, renderVf, join(dir, "oa.png"));
-  frame(render, t1, renderVf, join(dir, "ob.png"));
-  diff(join(dir, "ra.png"), join(dir, "rb.png"), join(dir, "rd.png"));
-  diff(join(dir, "oa.png"), join(dir, "ob.png"), join(dir, "od.png"));
-  results.push({
-    t,
-    motion: psnr(join(dir, "rd.png"), join(dir, "od.png")),
-    abs: psnr(join(dir, "rb.png"), join(dir, "ob.png")),
-  });
-}
-rmSync(dir, { recursive: true, force: true });
-
-const min = Math.min(...results.map((r) => r.motion));
-const mean = results.reduce((s, r) => s + r.motion, 0) / results.length;
-for (const r of results)
-  console.log(
-    `window ${r.t.toFixed(2)}s→${(r.t + interval).toFixed(2)}s  motion-psnr=${r.motion.toFixed(2)}dB  (abs=${r.abs.toFixed(1)}dB)${r.motion < minMotion ? "  <-- BELOW THRESHOLD" : ""}`,
-  );
-console.log(
-  `\nwindows=${results.length} min-motion=${min.toFixed(2)}dB mean-motion=${mean.toFixed(2)}dB threshold=${minMotion}dB`,
-);
-if (min < minMotion) {
-  console.log(
-    "VERDICT: FAIL — choreography diverges from the Figma export (check timings, invented keyframes, durations)",
-  );
-  process.exit(1);
-}
-console.log("VERDICT: PASS — motion matches the Figma export within the static-fidelity ceiling");

.claude/skills/glassmorphism

@@ -0,0 +1 @@
+../../.agents/skills/glassmorphism

.claude/skills/gsap-web

@@ -0,0 +1 @@
+../../.agents/skills/gsap-web

.claude/skills/hyperframes-cli/SKILL.md

@@ -1,97 +0,0 @@
----
-name: hyperframes-cli
-description: The HyperFrames CLI by job - scaffold, check, look at frames, edit the timeline, preview, render locally or in the cloud, publish, project history - plus reading its JSON and recovering from build or render failures.
----
-
-**Plugin installs:** Before setup or freshness commands, follow [plugin execution rules](../hyperframes/references/plugin-installation.md) when this skill is inside a HyperFrames plugin.
-
-# HyperFrames CLI
-
-Run `npx hyperframes <command>` unless the project gives a wrapper; then use the wrapper. It needs Node.js 22+ and FFmpeg. Every command has `--help`; most take `--json`, and a failure prints `✗ …`, a `Fix:` line and exits non-zero.
-
-## Commands by job
-
-| Job | Commands |
-| --- | --- |
-| Start | `init <dir>` (blank; `--example <name>` only when asked), `capture <url>` |
-| Read a project | `info`, `compositions`, `timeline --json`, `docs <topic>` |
-| Check it | `lint` while writing; `check --json` as the gate (lint, runtime, layout, contrast) |
-| Look at it | `snapshot` (`--at <t,…>`, `--range START,END`, `--composition <id>`, `--zoom`, `--angle`, `--against <video>`), `keyframes`, `compare`, `audio` |
-| Edit the timeline | `timeline` with `move`, `trim`, `split`, `set`, `duplicate`, `delete`, `apply`, `undo`, `ids` |
-| Reuse | `catalog`, `add` (`/hyperframes-registry`) |
-| Media and sound | `media-treatment`, `grade-compare`, `remove-background`, `tts`, `transcribe`, `beats`, `normalize-audio` (`/media-use`) |
-| Show and ship | `preview`, `present` (`/slideshow`), `render`, `publish`, `cloud`, `lambda`, `cloudrun` |
-| Desktop app | `open`, `catch-up` |
-| Upkeep | `doctor`, `browser`, `upgrade`, `skills`, `usage`, `clean`, `feedback` |
-
-`validate`, `inspect` and `layout` are deprecated aliases of `check`; `events` is telemetry for skills' own scripts. Don't run them.
-
-## The loop
-
-1. Write, then `npx hyperframes lint` after the first pass and after structural changes.
-2. `npx hyperframes check --json` and fix every error. While a lint error remains the layout and contrast audits don't run; "0 samples" means nothing was checked. Contrast failures carry a `suggestedColor`. A finding at a single sample (an entrance in flight) is info; a 3 s+ video with no visible change fails `sweep_static`.
-3. `npx hyperframes snapshot` and read the PNGs (under `.hyperframes/artifacts/snapshots/`): that is how you see the video. With sub-compositions, snapshot a midpoint of every scene; tiny unstyled content or a missing hero is a mount defect (`../hyperframes/references/format.md`).
-4. `npx hyperframes preview --background`, check the URL answers 200, give the person the project URL and wait, unless they asked for the file or for no stops. Passing checks alone is not a reason to render.
-5. When it is time to render (step 4): `npx hyperframes render --quality looks --output out.mp4` (`draft` while iterating, `delivery` for the final). Confirm the file is non-empty and its `ffprobe` duration matches the root `data-duration`, then look at decoded frames.
-
-"This element" or the current selection: `npx hyperframes preview --context --json --context-fields selection`; `no-selection` means ask them to click it.
-
-## Edit the timeline
-
-These are the edits Studio itself makes, so the result stays in Studio's shape.
-
-- `timeline --json` lists clips with absolute `absStart`/`absEnd`, owning `file` and the `#id` ref the edit commands take (`timeline ids` stamps missing ids).
-- `timeline move|trim|split|set|duplicate|delete <ref> … --plan --json` previews one edit; run it again without `--plan`. `--start`, `--end`, `--duration` set one edge or the length.
-- An edit is refused when the clip would overlap a neighbour (`--overwrite`, or move the neighbour first) or end past its composition: raise the root's `data-duration` first. No command changes `data-duration`.
-- Several edits at once: a JSON file such as `[{"verb": "move", "ref": "#outro", "time": "9"}]`, then `timeline apply plan.json --json`. Each run prints a `receipt`; save it and `timeline undo receipt.json` reverts it.
-
-<!-- history (trial): remove this block together with the command -->
-
-## Project history
-
-Every write is kept and can be undone. At the start of a turn, `npx hyperframes history begin --who <you> --label "<plan>"`, then `history --since mine --who <you>` to see what the person changed; build on their edits. A check failed or they say it got worse: `history undo --who <you>`, never hand-edit back. End the turn with `history end`.
-
-<!-- /history (trial) -->
-
-## Render where
-
-| Need | Command |
-| --- | --- |
-| Local | `render --quality looks --output out.mp4` (`draft`, `delivery`) |
-| Reproducible container | `render --docker --strict --output out.mp4` |
-| Batch from variables | `render --batch rows.json --output "renders/{name}.mp4"` |
-| Hosted, no local Chrome or FFmpeg | `cloud render` (`references/cloud.md`) |
-| Your own AWS or GCP | `lambda render`, `cloudrun render` (`references/lambda.md`, `references/cloudrun.md`) |
-
-A 30 s film renders in a minute or two: run it in the foreground. Detach only a render longer than your tool's timeout (`HYPERFRAMES_RENDER_DETACHED=1`, its own group, output to a log) and wait with `until grep -qE 'Render (complete|failed)' render.log; do sleep 5; done`, never `pgrep -f`, which matches its own loop and waits until the tool times out.
-
-After a verified render, send one `feedback --rating`, plus a report for anything the person asked for that HyperFrames can't do, unless telemetry is off: `references/feedback.md`.
-
-## When a command fails
-
-| Symptom | Fix |
-| --- | --- |
-| Chrome missing or won't start | `npx hyperframes browser ensure`; `doctor --json` always exits 0, gate on `.ok` |
-| A heavy page isn't ready in time | Raise `--timeout` on `check` or `snapshot` |
-| Unusual codec looks blank | Keep `--proxy` on (the default) |
-| Render slow on Linux | The summary's second line says `screenshot` + `software gpu`: the slow path |
-| `capture` fails or writes `BLOCKED.md` | Take nothing from its partial files; retry into a new `-o` folder |
-| Disk tight | `clean --dry-run`, then `clean`; never delete `.hyperframes` (it holds history) |
-
-## References
-
-Read the row before running its command.
-
-| Commands | Read |
-| --- | --- |
-| `init`, `capture`, `skills` | `references/init-and-scaffold.md` |
-| `lint`, `check`, motion sidecars, `snapshot` | `references/lint-validate-inspect.md` |
-| `compare`, `grade-compare`, `render --batch` | `references/compare-and-batch.md` |
-| `beats` | `references/beats.md` |
-| `preview`, `play`, `render`, `publish`, Studio context | `references/preview-render.md` |
-| `doctor`, `browser` | `references/doctor-browser.md` |
-| `auth`, `cloud`, template variables | `references/cloud.md` |
-| `lambda`, `cloudrun` | `references/lambda.md`, `references/cloudrun.md` |
-| `info`, `upgrade`, `compositions`, `timeline`, `docs`, `usage`, telemetry | `references/upgrade-info-misc.md` |
-| `--strict` flags, run ids, `clean`, shader lint, JSON paths | `references/conventions.md` |
-| `keyframes` | `../hyperframes/references/motion.md` (Seeing motion) |

.claude/skills/hyperframes-cli/references/beats.md

@@ -1,15 +0,0 @@
-# Generate a project beat grid
-
-Use `hyperframes beats` when an existing HyperFrames project needs the Studio-compatible beat file for its music track. This is a CLI utility, not a complete video workflow.
-
-```bash
-npx hyperframes beats
-npx hyperframes beats ./my-video
-npx hyperframes beats ./my-video --json
-```
-
-The project must contain a local music `<audio>` source. Mark it with `data-timeline-role="music"`; an id containing `music`, `bgm`, or `soundtrack` is also recognized. The command decodes that file with ffmpeg, tracks its beats, and writes `beats/<audio-relative-path>.json`.
-
-If the track has no steady beat, the command fails and writes nothing. If ffmpeg is missing, run `npx hyperframes doctor`.
-
-For a whole video cut to a music track, see `/hyperframes` → `references/film.md`.

.claude/skills/hyperframes-cli/references/cloud.md

@@ -1,163 +0,0 @@
-# cloud — HeyGen-hosted rendering (zero-infra)
-
-`hyperframes cloud render` renders a composition on HeyGen's managed cloud. The CLI zips the project, uploads it, runs the render on HeyGen's infrastructure (Chromium + FFmpeg), and downloads the finished video. Nothing to deploy, and no Chrome/FFmpeg/AWS to manage; you pay per credit.
-
-```bash
-npx hyperframes auth login            # one-time sign-in
-npx hyperframes cloud render          # zip, upload, render, download
-```
-
-## When to use managed cloud, Lambda, Cloud Run, or local
-
-- **`hyperframes render`** (local): fastest iteration loop, use while authoring.
-- **`hyperframes cloud render`**: zero-infra. HeyGen runs the render and you pay per credit. This is the default answer to "render in the cloud" when you don't want to manage Chrome/FFmpeg/AWS.
-- **`hyperframes lambda render`**: bring-your-own-AWS distributed rendering with chunked parallelism. Only worth it when you've already invested in AWS (see `lambda.md`).
-- **`hyperframes cloudrun render`**: bring-your-own-GCP distributed rendering through Cloud Run and Workflows. Use only when GCP ownership is explicit (see `cloudrun.md`).
-
-## Authentication
-
-Cloud rendering needs a HeyGen credential, stored at `~/.heygen/credentials` (`0600`) and shared with the [`heygen` CLI](https://github.com/heygen-com/heygen-cli): sign in with one and the other picks up the session.
-
-```bash
-npx hyperframes auth login              # OAuth 2.0 + PKCE, opens the browser
-npx hyperframes auth login --api-key    # CI/headless: hidden prompt, or pipe: echo "$HEYGEN_API_KEY" | ... --api-key
-npx hyperframes auth status             # active credential source, identity, billing snapshot
-                                        #   exit 0 = signed in and verified; exit 1 = not signed in,
-                                        #   or the credential was rejected — signed-out exit 1 is the
-                                        #   normal offline state (scripts: `auth status || echo offline`),
-                                        #   not a command failure
-npx hyperframes auth refresh            # force-refresh an OAuth token before a long job
-npx hyperframes auth logout             # clear the stored credential
-```
-
-Credential resolution order (first match wins): `HEYGEN_API_KEY`, then `HYPERFRAMES_API_KEY`, then `HEYGEN_ACCESS_TOKEN` (an OAuth token a host app injects; never refreshed or saved), then `~/.heygen/credentials`. Point at a different backend with `HEYGEN_API_URL` (default `https://api.heygen.com`).
-
-## The render pipeline
-
-`cloud render` runs end-to-end:
-
-1. **Resolve the project**: a local directory (default `.`), or skip the upload with `--asset-id` / `--url`.
-2. **Auto-detect aspect ratio** from the entry HTML's `data-width`/`data-height`.
-3. **Zip** the project (same ignore set as `hyperframes publish`, including `.hyperframesignore`).
-4. **Upload** the zip through the direct-to-S3 asset flow, yielding an `asset_id`.
-5. **Submit** the render to `POST /v3/hyperframes/renders`, yielding a `render_id`.
-6. **Poll** `GET /v3/hyperframes/renders/{id}` until it completes or fails (skip with `--no-wait`).
-7. **Download** the signed video URL to disk.
-
-## Archive size and `.hyperframesignore`
-
-The direct-upload limit is 200 MB. HyperFrames automatically excludes root-level `renders/` and `snapshots/`, along with its existing development exclusions such as `.git`, `node_modules`, `dist`, `.next`, `coverage`, and dotfiles. Add project-specific gitignore-style rules to `<project>/.hyperframesignore` when other generated or intermediate assets are not required at render time. The same rules affect `hyperframes publish`.
-
-Inspect the exact archive without authenticating, uploading, spending credits, or starting a render:
-
-```bash
-npx hyperframes cloud render <project> --dry-run --json
-```
-
-The result reports compressed `size_bytes`, `file_count`, the 200 MB limit, and the ten largest included files.
-
-When a cloud upload reports a size-limit error, agents must use this workflow:
-
-1. Run the dry-run command and inspect the largest included files and directories.
-2. Classify obvious generated outputs first: old renders, extra snapshot/contact-sheet directories, caches, exported previews, and source media used only to produce final assets.
-3. Before excluding anything else, search `src`, `href`, `url()`, `data-composition-src`, JavaScript strings, manifests, and variable-driven paths across every HTML, CSS, and JavaScript entry.
-4. Preserve existing `.hyperframesignore` comments and rules. Add the narrowest verified-unneeded root-relative paths; prefer an exact directory or file over a broad wildcard.
-5. Never ignore `index.html`, the selected composition, mounted sub-compositions, fonts, images, audio, video, scripts, or manifests merely because they are large. Never ignore all of `assets/`.
-6. Rerun dry-run until the archive is below the limit, then run `npx hyperframes check`. Remember that `check` sees the source directory, so it cannot prove a dynamically computed asset path remains in the filtered archive; the reference audit is still required.
-
-Example:
-
-```gitignore
-# Additional generated verification passes
-/snapshots2/
-/snapshots3/
-
-# Master used only to produce the final background clips
-/assets/bg-pattern.mp4
-```
-
-Rules support comments, globs, and negation. A later rule can override a default, for example `!/snapshots/` when that directory intentionally contains render inputs.
-
-## Render options
-
-| Flag                   | Default                     | Meaning                                                                                                                        |
-| ---------------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
-| `--fps`                | `30`                        | Frames per second, 1–240.                                                                                                      |
-| `--quality`            | `standard`                  | `draft`, `standard`, or `high`.                                                                                                |
-| `--format`             | `mp4`                       | `mp4`, `webm`, or `mov` (webm/mov carry alpha).                                                                                |
-| `--resolution`         | `1080p`                     | `1080p` or `4k` (4k billed at 1.5×).                                                                                           |
-| `--aspect-ratio`       | auto                        | `16:9`, `9:16`, or `1:1`. Auto from a local project's `data-width`/`data-height`; defaults to `16:9` for `--asset-id`/`--url`. |
-| `--composition` / `-c` | `index.html`                | Entry HTML file inside the zip.                                                                                                |
-| `--output` / `-o`      | `renders/<render_id>.<ext>` | Local download destination.                                                                                                    |
-| `--dry-run`            | off                         | Build and inspect a local project zip without authenticating, uploading, or rendering.                                         |
-
-```bash
-npx hyperframes cloud render . \
-  --composition compositions/intro.html \
-  --output ./renders/intro.mp4
-
-npx hyperframes cloud render --quality high --fps 60
-```
-
-`--resolution 4k` cannot combine with `--format webm`/`mov`: the 4k supersampling path has no alpha channel. Render 4k as mp4, or render alpha at native resolution.
-
-## Templates and variables
-
-Cloud rendering supports [composition variables](../../hyperframes/references/format.md#variables): declare `data-composition-variables` on the composition, then fill them at render time.
-
-```bash
-npx hyperframes cloud render --variables '{"title":"Q4 Recap","theme":"dark"}'
-npx hyperframes cloud render --variables-file ./vars.json
-npx hyperframes cloud render --variables '{"title":"Q4 Recap"}' --strict-variables
-```
-
-For a **local project** the CLI validates `--variables` against the declared schema _before_ uploading. For `--asset-id`/`--url` the schema lives server-side, so mismatches surface as a `hyperframes_project_invalid` API error.
-
-**Upload once, re-render many** is the idiomatic template loop: render a local project to get its `asset_id`, then re-submit against that asset with new values (no re-zip, no re-upload).
-
-```bash
-npx hyperframes cloud render ./card-template                              # note the asset_id printed on upload
-npx hyperframes cloud render --asset-id asst_abc123 --variables '{"name":"Ada"}'
-npx hyperframes cloud render --asset-id asst_abc123 --variables '{"name":"Linus"}'
-```
-
-For high-volume personalized batches, both self-managed paths provide JSONL fan-out: AWS Lambda (`lambda.md`) and Google Cloud Run (`cloudrun.md`). The full variables schema (types, declarative bindings, sub-composition overrides, precedence) lives in [`/hyperframes` format.md](../../hyperframes/references/format.md#variables).
-
-## Fire-and-forget and webhooks
-
-By default the CLI blocks, polls, and downloads. Combine `--no-wait` (submit and exit with just the `render_id`) with `--callback-url` (HTTPS webhook on terminal status) for true fire-and-forget:
-
-```bash
-npx hyperframes cloud render --callback-url https://example.com/hf-hook --no-wait
-#    Poll later with: hyperframes cloud get hfr_def456
-```
-
-| Flag              | Meaning                                             |
-| ----------------- | --------------------------------------------------- |
-| `--no-wait`       | Submit and exit immediately; print the `render_id`. |
-| `--callback-url`  | HTTPS webhook fired when the render terminates.     |
-| `--callback-id`   | Opaque tracking ID echoed in webhook payloads.      |
-| `--poll-interval` | Poll cadence in seconds (default `2`).              |
-| `--max-wait`      | Max poll duration in minutes (default `60`).        |
-
-## Managing renders
-
-```bash
-npx hyperframes cloud list                 # recent renders (--limit, --token, --all)
-npx hyperframes cloud get hfr_def456       # full detail + short-lived signed video_url
-npx hyperframes cloud delete hfr_def456    # soft-delete (--no-confirm to skip the prompt)
-```
-
-`video_url` and `thumbnail_url` are short-lived presigned URLs, so re-fetch with `cloud get` rather than caching them.
-
-## Safe retries
-
-The CLI transparently retries a `401` by force-refreshing the OAuth token and replaying. That's harmless for reads, but the zip upload (`POST /v3/assets`) is **not** idempotent: a blind retry creates a duplicate asset and bills twice. Pass `--idempotency-key` so retries are safe:
-
-```bash
-npx hyperframes cloud render . --idempotency-key "$(uuidgen)"
-```
-
-The key is forwarded to both upload and submit (the server scopes idempotency per-endpoint, so reusing one value is safe). Use any opaque string in `[A-Za-z0-9_:.-]`, 1–255 chars.
-
-Full flag reference: docs `/deploy/cloud` and `/packages/cli#hyperframes-cloud`.

.claude/skills/hyperframes-cli/references/cloudrun.md

@@ -1,62 +0,0 @@
-# Cloud Run rendering on Google Cloud
-
-Use `hyperframes cloudrun` only when the user explicitly wants self-managed Google Cloud infrastructure. It deploys Cloud Run, Workflows, and Cloud Storage. For a managed default use `hyperframes cloud`; for AWS use `hyperframes lambda`.
-
-## Prerequisites
-
-- `gcloud` is authenticated and the target project has billing enabled.
-- Terraform 1.5 or newer is on `PATH`.
-- Docker or permission to use Cloud Build is available.
-
-## Lifecycle
-
-```bash
-npx hyperframes cloudrun deploy --project <gcp-project> --region us-central1
-npx hyperframes cloudrun sites create ./project
-npx hyperframes cloudrun render ./project --width 1920 --height 1080 --wait
-npx hyperframes cloudrun progress <execution-name>
-npx hyperframes cloudrun destroy --project <gcp-project>
-```
-
-`deploy` enables the required Google APIs, builds or accepts a container image, applies the bundled Terraform module, and stores the resulting coordinates in `~/.hyperframes/cloudrun-state.json`. Use deploy flags such as `--image`, `--repo`, `--cpu`, `--memory`, `--max-instances`, and `--timeout` only when the infrastructure needs those overrides.
-
-`sites create` uploads a content-addressed project archive for reuse by `render-batch`; pass its `--site-id` to that command to skip the batch upload. Single `cloudrun render` currently resolves the project from its directory and does not consume `--site-id`. Both render commands require `--width` and `--height`; supported output formats are `mp4`, `mov`, `png-sequence`, and `webm`. Use `--output-resolution 4k` to supersample an authored composition without changing its layout dimensions.
-
-Common render flags are `--fps 24|30|60`, `--quality draft|standard|high`, `--codec h264|h265` for MP4, `--chunk-size`, `--max-parallel-chunks`, `--target-chunk-frames`, `--render-id`, `--output-key`, `--wait`, and `--wait-interval-ms`. Use `--json` for machine-readable output.
-
-For a variable-driven single render:
-
-```bash
-npx hyperframes cloudrun render ./template \
-  --width 1920 --height 1080 \
-  --variables-file ./alice.json \
-  --strict-variables \
-  --wait
-```
-
-Use exactly one of `--variables` and `--variables-file`. Read [Variables](../../hyperframes/references/format.md#variables) for the composition-side contract.
-
-## JSONL batches
-
-```bash
-npx hyperframes cloudrun render-batch ./template \
-  --batch ./users.jsonl \
-  --width 1920 --height 1080 \
-  --max-concurrent 10 \
-  --site-id <site-id> \
-  --json
-```
-
-Each nonblank line must contain an `outputKey`; `variables` is optional:
-
-```json
-{ "outputKey": "renders/alice.mp4", "variables": { "name": "Alice" } }
-```
-
-- `--max-concurrent` defaults to `50` and limits in-flight executions. `--max-parallel-chunks` separately limits chunks inside one render.
-- `--dry-run` parses the file and prints `would-start` rows without starting executions.
-- The template uploads once unless `--site-id` is supplied.
-- Per-entry start errors remain visible and make the command exit nonzero.
-- Do not rely on `--strict-variables` for `cloudrun render-batch`: the current command accepts the flag but does not validate batch rows. Validate the JSONL variable objects against the composition schema before dispatch. The strict gate does work for single `cloudrun render`.
-
-`render` without `--wait` returns an execution name. Use `cloudrun progress <execution-name>` until it succeeds, then verify the reported GCS output. `destroy` removes the Terraform-managed stack and its scratch bucket; preserve any deliverables that must outlive the stack.

.claude/skills/hyperframes-cli/references/compare-and-batch.md

@@ -1,105 +0,0 @@
-# Compare and batch rendering
-
-Use these commands for deliberate visual comparison or variable-driven template output. They do not replace `lint`, `check`, final preview approval, or output verification.
-
-## Contents
-
-- [Compare projects or variants](#compare-projects-or-variants)
-- [Compare color grades](#compare-color-grades)
-- [Batch template renders](#batch-template-renders)
-
-## Compare projects or variants
-
-Render the same timestamp from two or more project directories or HTML files into one labeled contact sheet:
-
-```bash
-npx hyperframes compare <path-a> <path-b> [<path-c> ...] \
-  --at <seconds> \
-  --labels baseline,candidate \
-  --out compare.png \
-  --cols 2
-```
-
-Useful options:
-
-- `--at <seconds>` selects the shared comparison time.
-- `--labels <a,b,...>` labels cells in input order.
-- `--out <file>` chooses the sheet path.
-- `--cols <n>` controls its grid.
-- `--json` returns machine-readable results.
-- `--timeout <ms>` changes the per-variant render-ready timeout.
-
-One sheet accepts at most 16 variants. Extra inputs are truncated with a warning; split larger comparisons into several runs.
-
-`compare` is a visual review surface, not a quality gate. Run it when checking a baseline against a candidate, comparing implementation variants, or verifying that a repair preserves the intended look. Inspect the generated image; do not treat command success as visual approval.
-
-## Compare color grades
-
-Create grade candidates from a source frame:
-
-```bash
-npx hyperframes grade-compare \
-  --for frame.png \
-  --grades grades.json \
-  --project . \
-  --out grade-compare.png
-```
-
-`grades.json` is an array of labeled HyperFrames grading blocks:
-
-```json
-[{ "label": "warm", "grading": { "adjust": { "temperature": 0.2, "contrast": 0.1 } } }]
-```
-
-Or compare explicit LUT files:
-
-```bash
-npx hyperframes grade-compare \
-  --for source.mp4 \
-  --luts warm.cube,cool.cube \
-  --out grade-compare.png
-```
-
-- `--for` accepts an image or a video. For video input, the command extracts the first frame.
-- Supply exactly one candidate source: `--grades <json>` or `--luts <a.cube,b.cube>`.
-- A neutral baseline is included by default; pass `--no-baseline` only when the baseline is not a useful reference.
-- The command accepts at most 16 candidate grades. With the default neutral baseline, the sheet may contain 17 cells. Extra candidates are truncated with a warning; split larger sets into several runs.
-- `--timeout <ms>` changes the render-ready timeout for the generated comparison composition.
-- Use `--json` for machine-readable output.
-
-This command helps select a grade. It does not apply the selected grade to the composition or replace `/media-use` provenance and LUT validation.
-
-## Batch template renders
-
-`render --batch` accepts either a JSON array of variable objects or an object with a `rows` array:
-
-```json
-{
-  "rows": [
-    { "name": "alpha", "headline": "Hello" },
-    { "name": "beta", "headline": "Welcome" }
-  ]
-}
-```
-
-Declare the variables in the composition, then run:
-
-```bash
-npx hyperframes render \
-  --batch rows.json \
-  --output "renders/{name}.mp4" \
-  --batch-concurrency 1 \
-  --strict-variables
-```
-
-Batch rules:
-
-- Do not combine `--batch` with `--variables` or `--variables-file`; each row is the variable set for one render.
-- If `--output` is omitted, the generated filename includes `{index}` so rows remain unique.
-- Output templates support `{index}` and row keys containing letters, numbers, `_`, `.`, or `-`. A placeholder value must be a string, number, or boolean; `null`, objects, and arrays are invalid. Missing placeholders and output collisions are errors.
-- `--batch-concurrency` defaults to `1`. Raise it conservatively because each render already uses workers.
-- `--batch-fail-fast` stops scheduling after the first failure. Without it, independent rows keep running and failures remain visible in the manifest.
-- `--strict-variables` validates every row before rendering and aborts before output when the declared variable contract is violated.
-- `--json` emits progress events suitable for agents and CI.
-
-The command writes `manifest.json` in the common output directory and updates it throughout the run. It records each row's variables, status, output, error, and timing. Completion means the manifest has no failed rows and every completed output exists, is non-empty, and has a plausible duration.

.claude/skills/hyperframes-cli/references/conventions.md

@@ -1,17 +0,0 @@
-# CLI conventions for agents and CI
-
-- Prefer `--json` for agent and CI calls. Server-mode `render`, `preview`, and `play` do not provide ordinary JSON output; `preview --selection --json` and `preview --context --json` are query-mode exceptions.
-- `doctor --json` always exits zero. Gate on its payload:
-
-  ```bash
-  npx hyperframes doctor --json | jq -e '.ok' >/dev/null
-  ```
-
-- Non-TTY mode is automatic and scaffolds the centered blank. Pass `--example` only to start from a named example. Use `--non-interactive` to force flag-only mode on a TTY.
-- Use one `HYPERFRAMES_RUN_ID` for all commands in the same verification loop.
-- When disk is tight, run `npx hyperframes clean` (`--dry-run` to list first); it removes what dead renders left and idle caches that rebuild themselves, never outputs, sources or anything a running render uses. Write disposable QC frames to a temp dir, then remove only that owned directory. Managed snapshot runs retain the newest 10 plus current/latest/rendered evidence; active captures and runs younger than 24 hours are protected. Copy intentional before/after evidence outside managed storage before it ages out. Never delete `.hyperframes` wholesale: it also holds project history.
-- Use `--strict`, `--strict-all`, and `--strict-variables` when the corresponding warnings, variables, or CI conditions must gate the render.
-- For `shader_unbounded_cosine_pow`, clamp the cosine to `[0, 1]` before `pow(1 - cosine, exponent)`; a lower-only `max` is insufficient. Then preview and export on the affected GPU to confirm. Lint only recognizes static shader expressions, and software rendering can miss hardware-specific invalid pixels.
-- JSON paths redact the home directory as `$HOME`; do not try to reverse the redaction.
-- When a hosted cloud project approaches or exceeds the 200 MB upload limit, use `cloud render --dry-run --json` and follow the `.hyperframesignore` investigation in `references/cloud.md`. Never ignore an asset merely because it is large.
-- Never render merely because checks pass. Pause at the final preview and wait for approval.

.claude/skills/hyperframes-cli/references/doctor-browser.md

@@ -1,80 +0,0 @@
-# doctor, browser
-
-Environment diagnosis and bundled-Chrome management. Run these first when a render or preview fails.
-
-## doctor
-
-```bash
-npx hyperframes doctor
-npx hyperframes doctor --json     # CI / agent output (always exit 0; gate on payload `ok`)
-```
-
-Runs independent checks and reports each as ok/warn/fail:
-
-- **Version** — installed CLI vs latest on npm (hints upgrade when stale)
-- **Node.js** — ≥ 22 required
-- **CPU**, **Memory**, **Disk** — host resources
-- **Environment** — env vars that affect the renderer
-- **FFmpeg** / **FFprobe** — found, version, codecs
-- **Chrome** — bundled or system, version, path
-- **Docker** / **Docker running** — required only for `render --docker`
-- **/dev/shm** — inside containers only
-
-Run `doctor` first when:
-
-- `render` fails with a Chrome or FFmpeg error.
-- `preview` opens but the composition fails to load.
-- A fresh machine has never run HyperFrames.
-
-Common issues:
-
-- **Missing FFmpeg** — install via `brew install ffmpeg` (macOS) or your package manager, or [configure existing binaries](#configure-ffmpeg-without-a-package-manager).
-- **Missing bundled Chrome** — run `npx hyperframes browser ensure`.
-- **Low memory** — close other Chromes, reduce `--workers`, or use `--quality draft`.
-- **Chrome exits instantly inside an agent sandbox (macOS)** — seatbelt-style sandboxes
-  (e.g. codex `workspace-write`) block Chromium's Mach port bootstrap
-  (`MachPortRendezvous`; openai/codex#21292), so every Chrome — bundled, system, or
-  headless shell — dies at startup. This is a host-level block, not a HyperFrames or
-  Chrome install problem: compile checks and audio still pass, only rendering is
-  unavailable. State the blocker and deliver the checked composition; render outside the
-  sandbox or via `render --docker` / cloud rendering where available. **Do not build a
-  substitute rasterizer** (magick/PIL/SVG frame pipelines) — on a blocked-browser host
-  the deliverable IS the checked composition plus this blocker note, and rendering is
-  handed to `--docker`, cloud, or the user. Write your final summary the moment the
-  blocker is identified, BEFORE any optional fallback work: a later session failure must
-  not erase the report of work already done.
-
-### Configure FFmpeg without a package manager
-
-Get FFmpeg and FFprobe binaries for your operating system and architecture from the [FFmpeg download page](https://ffmpeg.org/download.html). Both must be executable. You can use them without Homebrew or a system-wide installation:
-
-```bash
-export HYPERFRAMES_FFMPEG_PATH="/absolute/path/to/ffmpeg"
-export HYPERFRAMES_FFPROBE_PATH="/absolute/path/to/ffprobe"
-npx hyperframes doctor --json
-```
-
-Set both variables in the environment that launches HyperFrames. On Windows, point them at `ffmpeg.exe` and `ffprobe.exe` using your shell's environment-variable syntax. A configured path takes precedence over automatic discovery; a missing configured file is reported as missing.
-
-Alternatively, put the binaries in `.hyperframes/bin/ffmpeg` and `.hyperframes/bin/ffprobe` (`.exe` on Windows), then run HyperFrames from that project's directory. Discovery checks `PATH` before this project-local directory, so use the environment variables when you need a particular build.
-
-Verify the **FFmpeg** and **FFprobe** entries in `doctor --json` report `ok: true` and the expected paths. To gate only these encoding dependencies with `jq`:
-
-```bash
-npx hyperframes doctor --json | jq -e \
-  '[.checks[] | select(.name == "FFmpeg" or .name == "FFprobe")] | length == 2 and all(.ok)'
-```
-
-The report's top-level `ok` also includes optional tools such as Docker and local voice providers; those failures do not require installing them for a local video render. Check Chrome separately with the browser commands below.
-
-## browser
-
-```bash
-npx hyperframes browser ensure    # find or download the pinned Chrome
-npx hyperframes browser path      # print the browser executable path (for scripting)
-npx hyperframes browser clear     # remove the cached Chrome download
-```
-
-Manage the Chrome build HyperFrames uses for rendering. The pinned version exists because pixel output drifts across Chrome versions — using the bundled build keeps rendered output reproducible across machines.
-
-Use `path` to embed the binary in scripts: `$(npx hyperframes browser path)`.

.claude/skills/hyperframes-cli/references/feedback.md

@@ -1,14 +0,0 @@
-# Feedback reports
-
-After verifying a successful render, send one feedback report unless telemetry is disabled or the user opted out:
-
-```bash
-npx hyperframes feedback --rating <0-10> --comment "<specific result or friction>"
-```
-
-Keep clean-run feedback concise. For any bug or friction, capture a **reproduction packet** before submitting; do not send only a symptom summary. Include the rerunnable command (relative to the project directory — feedback is submitted to a public channel, so do **not** paste absolute paths, home-directory prefixes, or user/machine identifiers), expected versus actual behavior, exact error (also strip absolute paths from stack traces — keep basename + line, drop the leading directory), whether output completed/fell back/failed, workaround, and repro-project status. For a rating ≤ 7 that describes a visual defect (black frame, flicker, corrupt output, wrong frame, blank output, other visual anomaly), also include a `COMPOSITION_STRUCTURE:` block — a privacy-preserving structural anatomy (element census + attribute presence + timeline shape) so maintainers can pattern-match against known bug families without the composition ZIP. Agents auto-fill this via the composition-census helper; the human user does not fill it by hand. If the issue did not reproduce again, say so and still include the last failing command and logs. Use `--file-issue` only with consent: it publishes a minimal reproduction to a public URL. The required packet format and privacy warning live in `references/preview-render.md`.
-
-Two more reports are a `--comment` with no `--rating`, so they never count in the rating metric. Send them unless telemetry is disabled or the user opted out, under the same privacy rules:
-
-- **Missing feature.** Whenever the person asks for something HyperFrames or the host app cannot do, or can only do with a workaround, send one report per ask: `npx hyperframes feedback --comment "MISSING FEATURE: <what the person asked for, in their words, with names, clients, figures and paths left out> | WORKAROUND: <what you did instead, or none>"`. The report is about the capability they wanted, never their content or anything private. A catalog search that found nothing goes to `--search-miss` instead.
-- **Host app.** When `HYPERFRAMES_CLIENT` is set, the CLI is running inside a host app. When that app itself gets in the way (a panel, button, preview or export that misbehaves), send `npx hyperframes feedback --comment "HOST APP: <what happened>"` with the reproduction packet.

.claude/skills/hyperframes-cli/references/init-and-scaffold.md

@@ -1,78 +0,0 @@
-# init, capture, skills
-
-<!-- registry-items: allow=blank,landscape-4k,portrait-4k,square-4k,media-use -->
-
-Scaffolding commands. Use these instead of creating files by hand — they set up the right file structure, copy media, run transcription, and install AI coding skills.
-
-## init
-
-```bash
-npx hyperframes init my-video                                    # centered blank (TTY: wizard)
-npx hyperframes init my-video --example warm-grain               # pick an example
-npx hyperframes init my-video --resolution portrait
-npx hyperframes init my-video --video clip.mp4                   # with video file
-npx hyperframes init my-video --audio track.mp3                  # with audio file
-npx hyperframes init my-video --tailwind                         # Tailwind v4 browser runtime
-npx hyperframes init my-video --non-interactive                  # CI — flag-only, same blank
-```
-
-**Default depends on TTY**: in a terminal, the CLI prompts for example/options (default: centered blank). Outside a TTY (CI, agents, piped output) it auto-switches to non-interactive and scaffolds that blank. Pass `--example` only to start from a named example. Pass `--non-interactive` to force flag-only mode on a TTY.
-
-Templates: `blank`, `warm-grain`, `play-mode`, `swiss-grid`, `vignelli`, `decision-tree`, `kinetic-type`, `product-promo`, `nyt-graph`. (The closed set of `hyperframes:example` items in `registry/registry.json` plus the bundled `blank` template. `hyperframes catalog` does not list examples — its `--type` takes only `block` or `component` — so this list has no live equivalent and is checked by `bun run lint:skills`.)
-
-Other useful flags:
-
-- `--resolution` — preset: `landscape` (1920×1080), `portrait` (1080×1920), `landscape-4k`, `portrait-4k`, `square` (1080×1080), `square-4k`. Aliases: `1080p`, `4k`, `uhd`, `1080p-square`, `4k-square`.
-- `--skill=<slug>` — record the owning skill (e.g. `hyperframes`) in `hyperframes.json`, so every later render of this project — re-renders, `npm run render`, `--batch` — is attributed to it on anonymous telemetry without re-passing the flag. You rarely pass it by hand.
-- `--skip-skills` — **temporarily ignored**: `init` always checks AI coding skills against GitHub while the skills.sh registry catches up. To opt out (CI/tests), set the `HYPERFRAMES_SKIP_SKILLS=1` env var instead.
-- `--skip-transcribe` — don't auto-transcribe `--audio` / `--video` with Whisper.
-- `--model`, `--language` — Whisper model / language for the auto-transcription.
-
-**Tailwind** (`--tailwind`): the scaffold pins the Tailwind v4 browser runtime, not Studio's Tailwind v3 setup.
-
-- Keep the pinned runtime; never swap in `cdn.tailwindcss.com`. Renders wait for `window.__tailwindReady` before frame 0. For offline or locked-down renders, compile to CSS and ship the stylesheet.
-- Theme and custom utilities go in `<style type="text/tailwindcss">` with `@theme` and `@utility`. No v3 `@tailwind base/components/utilities`, no `tailwind.config.js`; `@config` and `@plugin` abort the browser compile.
-- Write complete class tokens in the HTML. The runtime only sees classes it can scan, so never build a render-critical class name at seek time (`bg-${color}-500`); vary items through CSS variables (`style="--i: 2"`) or data variants.
-- Tailwind is for static layout and style; timing stays in GSAP or another seekable runtime.
-
-When `--audio` or `--video` is supplied, `init` transcribes the file with Whisper. For voice/model selection see the `media-use` skill.
-
-## capture
-
-```bash
-npx hyperframes capture https://stripe.com                  # scaffold from a website
-npx hyperframes capture https://linear.app -o linear-video  # custom output directory
-npx hyperframes capture https://example.com --json          # JSON output for agents
-npx hyperframes capture https://example.com --skip-assets   # skip image/SVG download
-npx hyperframes capture https://example.com --skip-vision   # skip optional AI captions
-npx hyperframes capture https://example.com --max-screenshots 12
-npx hyperframes capture https://example.com --timeout 60000 # page-load timeout in ms
-npx hyperframes capture https://example.com --capture-budget 90000 # post-navigation budget
-```
-
-Captures a live URL as an editable HyperFrames project: screenshots become layered scenes, assets are downloaded locally, and the result is a normal project you can `lint` / `preview` / `render`. Use this when the user supplies a URL as the starting point for a video.
-
-`--timeout` bounds page navigation; `--capture-budget` is the separate cooperative budget for work
-after navigation (fonts, assets, vision, and contact sheets). The latter is not a hard wall-clock
-watchdog and cannot interrupt native work already in flight. An outer caller deadline is therefore a
-third, distinct timeout. An outer caller timeout leaves the capture result unknown; it does not prove
-HyperFrames hung or that the navigation timeout should be increased. Preserve the last phase and
-classify the boundary that fired. `--skip-vision` disables only optional AI image captioning.
-
-For agents, use `--json`. The result includes `ok`, warnings, and `lastPhase`. The command also emits
-stable `HYPERFRAMES_CAPTURE_PHASE` records so a watchdog can report the last started, completed, or
-degraded phase without retaining sensitive payloads.
-
-Treat a non-zero exit, JSON `ok: false`, or an output `BLOCKED.md` as a **hard stop**. Do not render,
-build, or infer brand/design data from partial files in a blocked capture. A successful capture may
-degrade an optional phase within budget, but its structural output still has to be usable. Exit zero and file existence alone are not semantic success: require the current
-invocation's JSON `ok: true`, no `BLOCKED.md`, and artifacts usable for the video. Run each retry
-into a fresh output directory; never merge or reuse a blocked attempt's partial output.
-
-## skills
-
-```bash
-npx hyperframes skills    # install HyperFrames skills for AI coding tools
-```
-
-One-time setup that adds the HyperFrames skill pack (/hyperframes with its references, /hyperframes-cli, /hyperframes-registry, /media-use, /figma, /slideshow, /remotion-to-hyperframes) to the local AI coding environment so agents follow the framework conventions. Re-run after major HyperFrames upgrades.

.claude/skills/hyperframes-cli/references/lambda.md

@@ -1,185 +0,0 @@
-# Lambda rendering on AWS
-
-Use `hyperframes lambda` when the user explicitly wants self-managed AWS infrastructure or needs distributed rendering. It wraps `@hyperframes/aws-lambda` and AWS SAM.
-
-## Contents
-
-- [Choose Lambda or local rendering](#choose-lambda-or-local-rendering)
-- [Prerequisites](#prerequisites)
-- [Deploy](#deploy)
-- [Upload a reusable site](#upload-a-reusable-site)
-- [Render one composition](#render-one-composition)
-- [Render a JSONL batch](#render-a-jsonl-batch)
-- [Inspect progress](#inspect-progress)
-- [Destroy the stack](#destroy-the-stack)
-- [IAM policies](#iam-policies)
-- [State, cost, and cleanup](#state-cost-and-cleanup)
-
-The basic lifecycle is:
-
-```bash
-npx hyperframes lambda deploy
-npx hyperframes lambda render ./my-project --width 1920 --height 1080 --wait
-npx hyperframes lambda destroy
-```
-
-## Choose Lambda or local rendering
-
-- **Local `render`** — dev-loop iteration, single host, anything under a few minutes at 1080p.
-- **`lambda render`** — long videos, 4K, large parallel batches, or anything where local Chrome would time out / exhaust RAM. Pay-per-invocation, no idle cost.
-
-For one-off short renders Lambda is not worth the deploy overhead.
-
-## Prerequisites
-
-- AWS credentials configured (env vars, `~/.aws/credentials`, SSO, or IMDS).
-- AWS SAM CLI on `PATH`.
-- `bun` on `PATH` (builds the Lambda handler ZIP).
-
-## Deploy
-
-```bash
-npx hyperframes lambda deploy \
-  --stack-name=hyperframes-prod \
-  --region=us-east-1 \
-  --concurrency=8 \
-  --memory=10240
-```
-
-Builds `packages/aws-lambda/dist/handler.zip` and SAM-deploys the stack (Lambda + Step Functions + S3 + IAM). Idempotent — re-running on the same `--stack-name` is a no-op when nothing changed. Writes `<cwd>/.hyperframes/lambda-stack-<name>.json` so later subcommands don't need to call `describe-stacks`.
-
-| Flag              | Default                         | Description                            |
-| ----------------- | ------------------------------- | -------------------------------------- |
-| `--stack-name`    | `hyperframes-default`           | CloudFormation stack name              |
-| `--region`        | `AWS_REGION` env or `us-east-1` | AWS region                             |
-| `--profile`       | `AWS_PROFILE` env               | Named AWS credentials profile          |
-| `--concurrency`   | `8`                             | Lambda reserved concurrency            |
-| `--chrome-source` | `sparticuz`                     | `sparticuz` or `chrome-headless-shell` |
-| `--memory`        | `10240`                         | Lambda memory in MB                    |
-| `--skip-build`    | off                             | Reuse existing `handler.zip`           |
-
-## Upload a reusable site
-
-```bash
-npx hyperframes lambda sites create ./my-project
-# → siteId: abc1234deadbeef0  (stable across re-runs of the same tree)
-
-npx hyperframes lambda render ./my-project --site-id=abc1234deadbeef0 ...
-```
-
-Tars + uploads `<projectDir>` to S3 with a content-addressed key. Returns a stable `siteId` you can reuse — re-renders of the same tree skip the upload.
-
-## Render one composition
-
-```bash
-npx hyperframes lambda render ./my-project \
-  --width 1920 --height 1080 --fps 30 --format mp4 \
-  --chunk-size 240 --max-parallel-chunks 16 \
-  --wait
-```
-
-Starts a Step Functions execution. Returns immediately with a `renderId` unless `--wait` is set, in which case the CLI blocks until completion and streams per-chunk progress lines. Add `--json` for machine-parseable output.
-
-| Flag                    | Description                                                                                                                                                                                                                                                                                                                                                   |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--width` / `--height`  | Output dimensions in pixels                                                                                                                                                                                                                                                                                                                                   |
-| `--output-resolution`   | Supersampling preset (engages Chrome `deviceScaleFactor`) — `landscape` / `landscape-4k` / `portrait` / `portrait-4k` / `square` / `square-4k`, plus aliases (`1080p`, `4k`, `uhd`, `hd`, `1080p-portrait`, `4k-portrait`, `1080p-square`, `4k-square`). Use this to render an authored-at-1080p composition at 4K without re-laying-out — see footgun below. |
-| `--fps`                 | `24` / `30` / `60`                                                                                                                                                                                                                                                                                                                                            |
-| `--format`              | `mp4` / `mov` / `png-sequence` / `webm` (default `mp4`)                                                                                                                                                                                                                                                                                                       |
-| `--codec`               | `h264` / `h265` (mp4 only)                                                                                                                                                                                                                                                                                                                                    |
-| `--quality`             | `draft` / `standard` / `high`                                                                                                                                                                                                                                                                                                                                 |
-| `--chunk-size`          | Frames per chunk (default `240`)                                                                                                                                                                                                                                                                                                                              |
-| `--max-parallel-chunks` | Max concurrent chunks (default `16`)                                                                                                                                                                                                                                                                                                                          |
-| `--target-chunk-frames` | Cap frames per chunk and let the planner add chunks up to the parallel limit                                                                                                                                                                                                                                                                                  |
-| `--site-id`             | Reuse an existing site (skip upload)                                                                                                                                                                                                                                                                                                                          |
-| `--execution-name`      | Explicit Step Functions execution name                                                                                                                                                                                                                                                                                                                        |
-| `--output-key`          | Explicit final S3 object key                                                                                                                                                                                                                                                                                                                                  |
-| `--variables`           | Inline JSON object with composition variable values                                                                                                                                                                                                                                                                                                           |
-| `--variables-file`      | JSON file containing one composition variable object                                                                                                                                                                                                                                                                                                          |
-| `--strict-variables`    | Fail when supplied variables are undeclared or have the wrong type                                                                                                                                                                                                                                                                                            |
-| `--wait`                | Block until completion, stream progress                                                                                                                                                                                                                                                                                                                       |
-| `--wait-interval-ms`    | Poll cadence while waiting (default `5000`)                                                                                                                                                                                                                                                                                                                   |
-| `--json`                | Machine-parseable progress snapshot                                                                                                                                                                                                                                                                                                                           |
-
-**`--width` / `--height` footgun.** Setting `--width 3840 --height 2160` against a composition whose `data-width="1920"` silently produces 1080p — the runtime lays out the page at the composition's authored dimensions and the CLI flags are ignored for layout. To actually output at 4K, use `--output-resolution 4k` (supersamples via `deviceScaleFactor`). The CLI now prints a warning when CLI dimensions disagree with the composition's `data-width` / `data-height` and `--output-resolution` is not set; the warning is suppressed when `--json` is on or `index.html` isn't on disk (`--site-id` flows).
-
-For variable-driven templates, declare the schema in the composition and pass either `--variables` or `--variables-file`, never both. `--strict-variables` checks local project input before any render starts. Also read [Variables](../../hyperframes/references/format.md#variables).
-
-## Render a JSONL batch
-
-Use `render-batch` to upload one template once and start one Step Functions execution per nonblank JSONL line:
-
-```bash
-npx hyperframes lambda render-batch ./template \
-  --batch ./users.jsonl \
-  --width 1920 --height 1080 \
-  --max-concurrent 10 \
-  --strict-variables \
-  --json
-```
-
-Each line must be an object with a non-empty `outputKey`. Choose unique keys to prevent outputs from overwriting one another. `variables` and `executionName` are optional:
-
-```json
-{
-  "outputKey": "renders/alice.mp4",
-  "variables": { "name": "Alice" },
-  "executionName": "alice-video"
-}
-```
-
-Batch rules:
-
-- The project is uploaded once unless `--site-id` reuses an earlier upload.
-- `--max-concurrent` defaults to `50` and limits in-flight render executions. `--max-parallel-chunks` separately limits chunks inside each render.
-- `--strict-variables` checks every entry, reports all variable issues, and aborts before AWS calls.
-- `--dry-run` performs no upload or AWS render call. Every manifest row becomes `would-invoke`.
-- The emitted manifest preserves input order and records `inputLine`, `outputKey`, `executionArn`, and `status` (`started`, `would-invoke`, or `failed-to-start`), plus an error when applicable.
-- A per-entry start failure does not hide other rows. Human-output mode exits nonzero when a row fails to start. In `--json` mode the current CLI prints the manifest and exits zero, so gate on every row's `status`, not the process code alone. Dispatch success is not render completion; inspect each execution with `progress`.
-
-## Inspect progress
-
-```bash
-npx hyperframes lambda progress hf-render-abcd1234
-npx hyperframes lambda progress arn:aws:states:us-east-1:...:execution:...
-```
-
-Prints one snapshot — overall percent, frames rendered, Lambda invocations, accrued cost, and any errors. Accepts a bare `renderId` (resolved against the stack's state-machine ARN) or a full SFN execution ARN.
-
-## Destroy the stack
-
-```bash
-npx hyperframes lambda destroy
-```
-
-Calls `sam delete --no-prompts` and drops the local state file. **The render S3 bucket is configured `Retain`** so it survives stack destruction — empty + delete it via the AWS console / CLI if you want the storage back.
-
-### Non-retryable errors
-
-A subset of failures the Step Functions state machine short-circuits instead of running through its 4× 15-min retry budget. `progress` surfaces these immediately with the error class name; do not re-issue `lambda render` blindly when you see one.
-
-- **`ChromeBinaryUnavailableError`** — `@sparticuz/chromium` returned an empty/missing executable path. A prior chunk hit `Sandbox.Timedout` mid-extraction and the warm instance is wedged until the execution environment recycles. Remedy: bump a Lambda env var (forces a new exec env) or `lambda deploy` again. Not a transient render failure; retries will burn budget on the same wedged instance.
-- **`FFMPEG_VERSION_MISMATCH`** / **`PLAN_HASH_MISMATCH`** — planner / executor version drift. Re-deploy.
-
-## IAM policies
-
-Print or validate the minimum IAM permissions the CLI needs.
-
-```bash
-npx hyperframes lambda policies user                                  # inline policy for an IAM user
-npx hyperframes lambda policies role                                  # { TrustRelationship, InlinePolicy }
-npx hyperframes lambda policies validate ./infra/iam/hf-deploy.json   # CI gate
-```
-
-`validate` reads a JSON policy doc and checks the union of its `Effect: Allow` actions (expanding `s3:*` / `s3:Get*` / `*` wildcards) against the CLI's required action set. Missing actions print to stderr; the command exits non-zero. Wire it into CI to catch policy drift before the next deploy fails.
-
-The default action set is deliberately broad (`Resource: "*"`) because CloudFormation creates new ARNs on every adopter's first deploy. Tighten `Resource` after that first run if security posture requires it.
-
-## State, cost, and cleanup
-
-`hyperframes lambda` stores per-stack metadata under `<cwd>/.hyperframes/lambda-stack-<name>.json` (bucket name, state-machine ARN, region). Not secret, but AWS-account-identifying. Commit it to a repo or `.gitignore` it per your workflow.
-
-- `lambda destroy` removes the SAM stack but **leaves the S3 bucket** (`Retain`). Delete it manually if you want the storage back.
-- Lambda billing is per-invocation + duration. `progress` reports the accrued cost.
-- `--concurrency` caps parallel Lambda invocations — keep it aligned with your account quota.
-- `--chunk-size` and `--max-parallel-chunks` trade off per-chunk overhead against parallelism; larger chunks reduce coordinator overhead, smaller chunks parallelize more aggressively.

.claude/skills/hyperframes-cli/references/lint-validate-inspect.md

@@ -1,155 +0,0 @@
-# lint, check, snapshot
-
-Use `lint` for fast static feedback while iterating. Use `check` as the required final gate: it reruns the same linter, then audits runtime, layout, motion, and contrast in one browser session. Do not chain a redundant standalone `lint` immediately before `check`. `snapshot` is the standalone utility for capturing still frames and zoomed crops. `validate`, `inspect`, and `layout` still run but are deprecated: `check` covers all of them in one invocation.
-
-## Discipline (motion-heavy work)
-
-When the composition is animation-driven, run the checks before you reach for `preview` or `render`:
-
-- Run `lint` after the first HTML pass for early feedback. It is an iteration aid, not a separate final gate.
-- Run `check --snapshots` at the first full pass: the overview frames and per-finding crops show you what the auditor saw.
-- Look at the PNGs before tuning automated warnings: your eye catches what the auditor misses, and the auditor catches what your eye misses.
-- Treat layout errors as defects unless a snapshot proves the layering is intentional, in which case mark it with `data-layout-allow-overflow` / `data-layout-allow-overlap` / `data-layout-allow-occlusion` / `data-layout-allow-caption-zone` (caption band only).
-- State motion intent in a `*.motion.json` sidecar so `check` verifies it automatically (entrances firing under seek, stagger order, in-frame, liveness). This is the closest automated proxy for "watch the MP4" and catches render-vs-preview bugs the eye misses (see **Motion verification** below).
-
-## lint
-
-```bash
-npx hyperframes lint                  # current directory
-npx hyperframes lint ./my-project     # specific project
-npx hyperframes lint --verbose        # info-level findings
-npx hyperframes lint --json           # machine-readable
-```
-
-Lints `index.html` and all files in `compositions/`. Reports errors (must fix), warnings (should fix), and info (with `--verbose`). Catches missing `data-composition-id`, overlapping tracks on the same `data-track-index`, unregistered timelines, and GSAP/CSS transform conflicts.
-
-`<video>`/`<audio>` work at any nesting depth, including inside a `compositions/*.html` sub-composition or a wrapper `<div>`: the runtime discovers media with a flat DOM query and seeks/decodes it wherever it lives (`packages/core/src/runtime/{media,startResolver}.ts`). After a render, `snapshot` each scene that has a video and confirm the panel actually shows footage (a blank/black panel where a clip should play is a real bug, not a placeholder).
-
-## check
-
-```bash
-npx hyperframes check                    # current directory: the full browser gate
-npx hyperframes check ./my-project       # specific project
-npx hyperframes check --json             # agent-readable envelope {ok, browserSkipped, lint, runtime, layout, motion, contrast, craft, hdr, snapshots}
-npx hyperframes check --snapshots        # also write overview frames (annotated) + per-finding crops
-npx hyperframes check --samples 15       # denser timeline sweep (default 9)
-npx hyperframes check --at 1.5,4,7.25    # explicit hero-frame timestamps
-npx hyperframes check --at-transitions   # also sample every tween start/end boundary
-npx hyperframes check --tolerance 4      # allowed overflow px before reporting (default 2)
-npx hyperframes check --timeout 30000    # initial render-ready + navigation minimum in ms (defaults: 3000 / 10000)
-npx hyperframes check --no-contrast      # skip the WCAG audit while iterating
-npx hyperframes check --strict           # exit non-zero on warnings too (default: only errors)
-```
-
-One command, one Chrome boot. `check` runs the linter first and skips the browser entirely when lint reports errors. When the browser never ran (lint errors, a linter crash, or a browser launch failure), `browserSkipped` is `true` and the `layout`, `motion` and `contrast` sections are empty, not clean. Otherwise it loads the bundled composition once, wires runtime listeners before navigation, and sweeps one seek grid running every audit per sample:
-
-- **Runtime**: JavaScript console errors, unhandled exceptions, failed network requests (media-file `ERR_ABORTED` filtered out), HTTP 4xx/5xx.
-- **Layout**: text extending outside its container or the canvas, text clipped by its own box, held text overlaps and occlusion (with an approximate covered fraction), children escaping clipping containers. Text under a transparent `<video>` (a `remove-background` cutout) is measured per word against the frame's alpha: partial cover is info with the share hidden, a word 80% hidden or two neighbouring words each half hidden is an error, and a frame that cannot be read falls back to opaque with a `video_alpha_unread` note.
-- **Motion**: `*.motion.json` sidecar assertions against the same seeked timeline (see below).
-- **Contrast**: WCAG AA on visible text, sampled at 5 grid points. Failures are **errors** and each finding carries the sampled fg/bg colors, measured vs required ratio, and a suggested compliant color in the same palette direction, so most contrast fixes need no screenshot at all.
-- **Craft**: warnings only, even under `--strict` (a film may break one on purpose), measured on an 8 fps sweep of the whole film and skipped under `--range`. Each message names the fix and the reference to read.
-  - `line_unread`: a reading-size line (≥ 30 px tall at 1080) on screen under its floor: 0.4 s for 1–2 words, otherwise ¾ of 0.5 s + 0.3 s a word (3 words 1.05 s, 6 words 1.73 s); the film's last line needs 2 s. Edges are re-measured to ~0.01 s. Captions-track text and `data-layout-ignore` are exempt.
-  - `dead_stretch`: more than 3 s where the `keepsMoving` classifier sees nothing change. The final 3 s and any time a `data-hold` element is on screen are exempt; it stays quiet when `sweep_static` fires or a whole-composition `keepsMoving` assertion sets the limit.
-  - `text_below_floor`: text under 2.6% of the frame's short side (28 px on 1080) held 0.5 s or more, one finding per file listing every element.
-  - `first_frame_empty`: frame 0 paints nothing but the background (no text, image, video, canvas or svg); it is the thumbnail on social players.
-  - `film_silent`: a film over 15 s with no unmuted `<audio>` or audible `<video>`.
-
-Every finding carries a selector, the element's `data-*` identity, the composition source file, a bbox, and the sample time: jump straight from the JSON to the HTML you must edit and re-run.
-
-**Severity is persistence-aware.** A dynamic issue observed at a single grid sample (an entrance/exit transient) demotes to info and never gates. Issues held across samples gate the exit code, a held `content_overlap` is an error, and a held, partially-visible `canvas_overflow` breaching ≥5% of the canvas promotes to warning. Coordinate-frame findings (`escaped_container`, `panel_out_of_canvas`, `connector_detached`) flag geometry computed in one frame but rendered in another — an element far outside its offset parent, a painted panel stuck across the canvas edge, a connector line detached from every node. Text drawn into a `<canvas>` has no DOM box, so `canvas_overflow` cannot see it; `canvas_content_at_edge` warns when a canvas's pixels show sharp content (drawn text, hard shapes) along the frame edge — mark intentional full-bleed art (particles, photos) with `data-layout-allow-overflow`. If a 3s+ composition shows no visible change across every sample, `check` fails with `sweep_static`: a frame that never changes while a GSAP timeline or tween, or a CSS or Web animation, holds the same time without ever finishing means the seek is not driving the page, so it refuses to pass. Any other frame that never changes (a still title card, an audio-only advance) is a warning that `--strict` fails; a composition meant to be still can take `data-no-timeline` on its root to skip it. The fingerprint includes per-element opacity, so opacity-only reveals (code typing, staggered fades) count as motion — but only while they're still in flight at the sampled times. The classic trap is a reveal that completes early and then holds a static frame for the rest of the duration: every sample lands on the settled state and check warns that nothing on screen moved (`--strict` fails it). Spread the reveal across the timeline or give the hold a real next action (the cursor heading to the next control, the camera's next move); don't bolt on a slow drift, a blinking caret or a loop just to appease the check.
-
-**Escape hatches** (mark intent in the HTML, then re-run):
-
-- `data-layout-allow-overflow` — overflow is intentional (entrance/exit travel).
-- `data-layout-allow-overlap` — deliberate text layering (e.g. a demo cursor label over a heading). Applies only to the marked text block; it is not inherited. Mark the specific layering participant, never a scene/root wrapper, so unrelated descendant collisions remain auditable.
-- `data-layout-allow-occlusion` — an element is meant to cover text.
-- `data-layout-allow-caption-zone` — intentional lower-third / caption-band copy under `--caption-zone`. Applies to the marked element and every descendant (`closest`); silences only `caption_zone_collision` (not overflow/overlap/occlusion). Prefer the narrowest wrapper that owns the intentional band copy.
-- `data-layout-ignore` — decorative element that should never be audited.
-- `data-hold` — deliberate stillness: while this element is on screen, `dead_stretch` does not count the time.
-
-**Opt-in pipeline gates** (used by orchestrators; off by default):
-
-```bash
-npx hyperframes check --caption-zone "x0=0;y0=.82;x1=1;y1=1;severity=error;seek=.25,1"
-npx hyperframes check --frame-check     # media (img/svg/video/canvas) out-of-frame detection
-```
-
-`--caption-zone` takes fractional band geometry (`x0/y0/x1/y1` required, 0-1 fractions of the composition's own canvas, portrait included) with optional `severity` and comma-separated `seek` fractions; it flags a text element's DOM box (`getBoundingClientRect`) that overlaps the band. Waive intentional lower-third copy with `data-layout-allow-caption-zone` on the element or its nearest wrapper (see Escape hatches). `--frame-check` reports media elements breaching the canvas beyond `max(120px, 6% of the min canvas dimension)`.
-
-**Fixing contrast errors** — thresholds are 4.5:1 for normal text, 3:1 for large text (24px+, or 19px+ bold). The finding's `suggestedColor` already picks the nearest compliant color in the right direction (brighten on dark backgrounds, darken on light); apply it or adjust within the palette family, then re-run `check`.
-
-## Motion verification (`*.motion.json` sidecar)
-
-`check` verifies **motion intent** against the same seeked timeline the renderer uses — the closest automated proxy for "render the MP4 and watch it". It catches render-vs-preview bugs layout sampling can't: an entrance reveal the seek lands past, a broken stagger order, an element drifting off-frame mid-tween, a frozen shot.
-
-Drop a `*.motion.json` sidecar next to the composition (matching the html basename when several compositions share a dir). `check` discovers it automatically — no flag, no authoring-framework changes. With no sidecar, `check` behaves exactly as before.
-
-```json
-{
-  "duration": 6,
-  "assertions": [
-    { "kind": "appearsBy", "selector": "#headline", "bySec": 0.5 },
-    { "kind": "before", "a": "#headline", "b": "#cta" },
-    { "kind": "staysInFrame", "selector": ".card" },
-    { "kind": "keepsMoving", "withinSelector": ".scene" }
-  ]
-}
-```
-
-| Assertion                      | Fails (code) when                                                                                                           |
-| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------- |
-| `appearsBy(selector, bySec)`   | not visible (opacity ≥ 0.5) by `bySec` — `motion_appears_late`                                                              |
-| `before(a, b)`                 | `a` does not first appear strictly before `b` — `motion_out_of_order`                                                       |
-| `staysInFrame(selector)`       | once visible, its box leaves the canvas — `motion_off_frame`                                                                |
-| `keepsMoving(withinSelector?)` | a fully-static window exceeds `maxStaticSec` (default 2s); the film's final 3 s (an end card) never count — `motion_frozen` |
-
-`duration`, `withinSelector`, and `maxStaticSec` are optional. Findings are **errors by default** and appear in the same human and `--json` output as layout findings. A selector that matches nothing is reported as `motion_selector_missing` rather than silently passing — a typo'd selector fails loudly. Use this in the feedback loop instead of eyeballing the render: assert what the motion is supposed to do, and let `check` tell you when the seek diverges from intent.
-
-## snapshot
-
-```bash
-npx hyperframes snapshot                       # 5 key frames as PNG
-npx hyperframes snapshot ./my-project          # specific project
-npx hyperframes snapshot --frames 10           # evenly-spaced N frames
-npx hyperframes snapshot --range 3:5 --frames 8 # 8 frames within root-timeline seconds 3–5
-npx hyperframes snapshot --composition intro --frames 8 # 8 frames within this data-composition-id
-npx hyperframes snapshot --review              # beat sheet, seam strips, phone sheet
-npx hyperframes snapshot --review --json       # same, with paths and times as JSON
-```
-
-Still PNGs. Each run writes `.hyperframes/artifacts/snapshots/<id>/` unless `--output` is set. `snapshot` is the standalone capture; `check --snapshots` is the gate.
-
-One of `--at`, `--range START:END` (seconds), or `--composition <data-composition-id>` (not a CSS selector). `--frames` defaults to 5. Range and composition sample just before the end and add no extra end frame; `--at` adds one unless `--no-end`.
-
-`--review` picks the frames that show a film over time. Scenes are the composition's top-level timed clips and sub-composition hosts, as `timeline` lists them (captions and audio excluded); `--composition` scopes to one. It writes `review-beats.jpg` (each scene at its start + 0.3 s and at its middle, and each timed `data-beat="name"` element at its start + 0.3 s, labelled with time and id), `review-seam-NN.jpg` (frames at −0.2, −0.1, 0, +0.1, +0.2 s around every cut) and `review-phone.jpg` (the beat frames 360 px wide, to judge legibility at phone size), beside the `beat-*.png` and `seam-*.png` stills. With fewer than two scenes the beats spread evenly. `--json` prints `{ok, outputDir, frames[{path,time,role,label}], contactSheets, review{window, scenes, beats, seams[{time,from,to,times,paths,sheet}], sheets, notes}}`.
-
-### Keep verification clean and inspect the actual pixels
-
-Inspect full-resolution frames in the opening 30 seconds, each mounted scene, and every reported problem interval. Contact sheets locate moments; use close-ups to judge thin edges, glass, particles, and WebGL geometry. Check the live preview and decoded render at matching times. Canvas shader defects can survive a successful DOM/layout audit. Record the browser/GPU and capture path when results differ across machines; isolate the failing material or pass before changing rendering defaults.
-
-Managed snapshot storage keeps the newest 10 run folders, the newest evidence for the current revision and retained rendered revisions, and the latest snapshot. Live captures and folders younger than 24 hours are also preserved. Automatic cleanup removes whole eligible old UUID folders, including contact sheets and descriptions; arbitrary `--output` folders are untouched. Save intentional before/after evidence outside this managed storage.
-
-For disposable checks, allocate a temporary output folder and remove that folder after inspecting it. Use `hyperframes clean --dry-run` to inspect broader cleanup. `clean --snapshots` explicitly discards snapshot evidence; use it only when that evidence is no longer needed. Never recommend removing all of `.hyperframes`, which also contains project history and other state.
-
-### Zooming into a reported finding
-
-`hyperframes check --snapshots` already writes a `finding-NN-<code>.png` crop for every error finding that carries a bbox, but the same zoom is available standalone once you know what to look at:
-
-```bash
-npx hyperframes check --snapshots               # reports a finding, e.g. content_overlap on "#cta"
-npx hyperframes snapshot --zoom "#cta"           # crop the element to verify the defect, at 3x density
-npx hyperframes snapshot --zoom "100,50,400,300" --zoom-scale 2   # or an exact pixel region
-# fix the composition HTML, then re-check:
-npx hyperframes check
-```
-
-`--zoom` takes a CSS selector or an exact `x,y,w,h` pixel region and always produces a real high-density crop (a raised `deviceScaleFactor`, never CSS zoom or a viewport resize), so the composition's layout — and its render determinism — is untouched. A selector matching nothing is a loud error, not a silent full-frame fallback, and a frame where the target has no visible box (collapsed or animated off-canvas) is skipped with a note instead of written as a sliver.
-
-## Deprecated: validate, inspect, layout
-
-All three keep working, print a deprecation notice on stderr, and mark `_meta.deprecated: true` in `--json`. Their functionality lives in `check`:
-
-- `validate` (runtime errors + contrast) → `check` (contrast failures are now gating errors with fix payloads, not warnings).
-- `inspect` / `layout` (layout sweep + motion sidecar) → `check` (same flags: `--samples`, `--at`, `--at-transitions`, `--tolerance`, `--strict`).
-
-Migrate scripts by replacing the sequence with the single `check` invocation; scaffolded projects' `npm run check` already points there.

.claude/skills/hyperframes-cli/references/preview-render.md

@@ -1,199 +0,0 @@
-# preview, play, render, publish
-
-Serve, render, and share commands.
-
-## preview
-
-```bash
-npx hyperframes preview                   # foreground on a TTY; persistent in agent shells
-npx hyperframes preview --background      # explicit persistent session
-npx hyperframes preview --foreground --json # ready JSON, then remain attached
-npx hyperframes preview --background --port 4567 # agent-safe custom port (default 3002)
-npx hyperframes preview --selection --json # print the current Studio selection and exit
-npx hyperframes preview --context --json  # print compact agent context from Studio
-```
-
-Hot-reloads on file changes. Opens Studio in the browser automatically — the full timeline editor, where the user can play the video and edit anything by hand before rendering. This is the review surface, not just a viewer.
-
-When handing a project back to the user, use the Studio project URL, not the source `index.html` path:
-
-```text
-http://localhost:<port>/#project/<project-name>
-```
-
-Use the actual port and project directory name; treat `index.html` as source-code context, not the preview surface. For example, after `npx hyperframes preview --background --port 3017` in `codex-openai-video`, report `http://localhost:3017/#project/codex-openai-video`.
-
-Two ways a handed URL turns out dead — check both before handing it back: the URL is missing its `#project/<project-name>` hash (Studio loads but has no project to open), or the server is not actually running. Bare `preview` automatically creates a managed persistent session in a non-TTY agent shell; `--background` remains the clearest explicit form. Verify the printed URL returns HTTP 200, keep it alive for the whole review, and stop it explicitly with `npx hyperframes preview --stop` afterward. Use the printed URL as-is: HyperFrames URL-encodes project names that contain route metacharacters.
-
-### Agent context from Studio selection
-
-`preview --context` and `preview --selection` are the agent bridge into a running Studio session. They do **not** start a new server; they find the active preview server for the current project, read agent-useful state from Studio, print it, and exit.
-
-Use it when the user gives deictic edit instructions like "change this", "move the selected element", "make the card I clicked bigger", or "fix the current selection":
-
-```bash
-npx hyperframes preview --context --json --context-fields selection
-```
-
-The compact context payload includes the selected element's source file, composition path, current timeline time, `data-hf-id` / selector target, bounding box, text content, and a thumbnail URL for the selected element. Prefer `selection.target.hfId` when present; fall back to `selection.target.selector` only when no stable `data-hf-id` exists. If `selection` is `null`, inspect `errors.selection.code` (for example, `no-selection`).
-
-Keep agent context small by asking only for the slices you need:
-
-```bash
-npx hyperframes preview --context --json --context-fields selection
-npx hyperframes preview --context --json --context-fields lint
-npx hyperframes preview --context --json --context-fields selection,lint
-```
-
-Use `--context-detail full` only when the edit genuinely needs heavy selection fields such as `computedStyles`, `inlineStyles`, `dataAttributes`, or editable text-field metadata:
-
-```bash
-npx hyperframes preview --context --json --context-fields selection --context-detail full
-```
-
-`preview --selection --json` remains available when you explicitly want the full selected-element payload and do not need lint/server context.
-
-Failure modes:
-
-| Code                       | Meaning                                                                    |
-| -------------------------- | -------------------------------------------------------------------------- |
-| `preview-not-running`      | Start Studio first with `npx hyperframes preview --background`.            |
-| `ambiguous-preview-server` | Multiple matching Studio servers are open; rerun with one listed `--port`. |
-| `preview-port-mismatch`    | The requested `--port` is not one of the matching Studio servers.          |
-| `no-selection`             | Studio is open, but the user has not selected an element yet.              |
-| `selection-unavailable`    | The running preview server does not expose selection context cleanly.      |
-
-If there is no selection, ask the user to click the target element in Studio and rerun the command. If the server error lists candidate ports, rerun the same command with `--port <candidate>`. Do not infer the target from a screenshot when the CLI can give a stable element target.
-
-## play (lightweight player)
-
-```bash
-npx hyperframes play                  # current project, port 3003
-npx hyperframes play ./my-video       # specific project
-npx hyperframes play --port 8080      # custom port
-```
-
-`play` serves the composition through the embeddable `<hyperframes-player>` web component instead of the full Studio UI. Use it when sharing a preview link or when Studio is heavier than needed (no editor, no panels). `play` reports the plain `http://localhost:<port>` URL — no `#project/<name>` fragment (that's a Studio routing convention only `preview` uses).
-
-The player's `playback-rate` attribute (preview speed control, drives the timeline's `timeScale`) is clamped to `[0.1, 5]`; values `≤ 0` or non-finite fall back to `1`. This is a preview/playback knob, not a composition `data-*` attribute — authored motion still renders at `1×`.
-
-### Launching with an external browser (preview + play)
-
-Both `preview` and `play` can open inside an explicit Chromium-compatible browser instead of the OS default. Two use cases: isolated Chromium profile, or external CDP attach (DevTools / Playwright / Puppeteer / browser-MCP). **HyperFrames itself does not own CDP automation** — this only exposes the endpoint; whatever connects to it is your problem. Not to be confused with `--browser-gpu` (a `render` flag controlling Chrome GPU access during capture).
-
-| Flag                      | Type            | Notes                                                                                                                                                                                           |
-| ------------------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `--browser-path`          | path            | Absolute path to a Chromium-compatible executable (`/usr/bin/chromium`, `/Applications/Brave Browser.app/...`).                                                                                 |
-| `--user-data-dir`         | path            | Chromium-compatible profile directory. Requires `--browser-path`. Use a throwaway directory to keep state out of your main profile.                                                             |
-| `--remote-debugging-port` | integer 1-65535 | Open a Chromium CDP endpoint on the given port. **Requires both** `--browser-path` and `--user-data-dir` — refused otherwise, so a CDP endpoint cannot leak into your main profile by accident. |
-
-```bash
-# Open preview in an isolated Chromium profile
-npx hyperframes preview --background --browser-path /usr/bin/chromium --user-data-dir /tmp/hf-profile
-
-# Same plus a CDP endpoint on :9222 (attach DevTools / Playwright / etc.)
-npx hyperframes play --browser-path /usr/bin/chromium --user-data-dir /tmp/hf-profile --remote-debugging-port 9222
-```
-
-Validation runs before any server boots, so an invalid value exits cleanly without leaving a listening socket behind.
-
-## render
-
-> Render after the user has reviewed in `preview` and approved, or when they asked for the file or to work without stopping. Passing checks alone is not a reason to render.
-
-```bash
-npx hyperframes render                                # standard MP4 from cwd
-npx hyperframes render ./my-video --output ./out.mp4  # render from outside the project dir
-npx hyperframes render --output final.mp4             # named output (no timestamp)
-npx hyperframes render -c compositions/intro.html -o intro.mp4  # render a specific sub-composition file
-npx hyperframes render --quality draft                # fast iteration
-npx hyperframes render --quality looks                # first real encode (default)
-npx hyperframes render --fps 60 --quality delivery    # final delivery
-npx hyperframes render --format webm                  # transparent WebM
-npx hyperframes render --docker                       # byte-identical
-```
-
-> Default `--output` is `renders/<project-name>_<YYYY-MM-DD>_<HH-MM-SS>.<ext>` — timestamped per render so successive runs don't clobber each other. Pass `--output` to get a stable name.
-
-| Flag                                 | Options                                                                                            | Default                        | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ------------------------------------ | -------------------------------------------------------------------------------------------------- | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `dir` (positional)                   | path                                                                                               | cwd                            | Project directory. Omit to use current working directory.                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--composition`, `-c`                | path to composition file                                                                           | `index.html`                   | Render a specific composition file (e.g. `compositions/intro.html`) instead of the project's `index.html`.                                                                                                                                                                                                                                                                                                                                    |
-| `--output`, `-o`                     | path                                                                                               | `renders/<project>_<ts>.<ext>` | Output path. Default is timestamped (`<project-name>_YYYY-MM-DD_HH-MM-SS.<ext>`).                                                                                                                                                                                                                                                                                                                                                             |
-| `--fps`                              | 24, 30, 60                                                                                         | 30                             | 60fps doubles render time                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `--quality`                          | draft, looks, delivery, standard, high                                                             | looks                          | `looks` is CRF 16 on the standard preset. `delivery` is `high`. draft for iterating                                                                                                                                                                                                                                                                                                                                                           |
-| `--format`                           | mp4, webm, mov, gif, png-sequence, hls                                                             | mp4                            | WebM/MOV render with transparency; gif for inline autoplay in GitHub PRs/READMEs/docs (two-pass palette encode, fps capped at 30 — prefer `--fps 15` — no audio, 1-bit transparency only, HDR falls back to SDR); png-sequence writes RGBA frames to a directory (AE/Nuke/Fusion ingest); hls writes an HLS VOD directory (master.m3u8 + video/audio playlists + MPEG-TS segments), SDR only, rejects `--gpu`, unavailable on lambda/cloudrun |
-| `--gif-loop`                         | 0-65535                                                                                            | 0                              | GIF loop count; `0` loops forever. Only with `--format gif`.                                                                                                                                                                                                                                                                                                                                                                                  |
-| `--hls-segment-seconds`              | 1-60                                                                                               | 4                              | HLS target segment length in whole seconds; also locks the encoder GOP so every segment starts on a keyframe. Only with `--format hls`.                                                                                                                                                                                                                                                                                                       |
-| `--resolution`                       | landscape, portrait, landscape-4k, portrait-4k, square, square-4k (+ aliases `1080p`, `4k`, `uhd`) | —                              | Supersample via Chrome `deviceScaleFactor`. Aspect ratio must match composition; scale must be an integer. Not with `--hdr`.                                                                                                                                                                                                                                                                                                                  |
-| `--crf`                              | 0-51                                                                                               | —                              | Encoder CRF (lower = higher quality). Mutually exclusive with `--video-bitrate`.                                                                                                                                                                                                                                                                                                                                                              |
-| `--video-bitrate`                    | e.g. `10M`, `5000k`                                                                                | —                              | Target bitrate. Mutually exclusive with `--crf`.                                                                                                                                                                                                                                                                                                                                                                                              |
-| `--hdr`                              | flag                                                                                               | off                            | Force HDR output even with SDR sources. MP4 only.                                                                                                                                                                                                                                                                                                                                                                                             |
-| `--sdr`                              | flag                                                                                               | off                            | Force SDR even with HDR sources.                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `--workers`                          | number or `auto`                                                                                   | auto                           | Each worker spawns Chrome (~256 MB)                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `--docker`                           | flag                                                                                               | off                            | Reproducible output across hosts                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `--gpu`                              | flag                                                                                               | off                            | GPU-accelerated FFmpeg encoding (NVENC / VideoToolbox / VAAPI / QSV)                                                                                                                                                                                                                                                                                                                                                                          |
-| `--browser-gpu` / `--no-browser-gpu` | flag                                                                                               | auto (local), off (docker)     | Host GPU for Chrome/WebGL capture                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `--browser-timeout`                  | seconds (0.001–86400)                                                                              | 60                             | Puppeteer page-navigation timeout for the entry HTML. Raise when heavy compositions (many videos / fonts / remote assets) can't reach `domcontentloaded` within the 60s default.                                                                                                                                                                                                                                                              |
-| `--quiet`                            | flag                                                                                               | off                            | Suppress verbose output                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `--strict`                           | flag                                                                                               | off                            | Fail on lint errors                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `--strict-all`                       | flag                                                                                               | off                            | Fail on lint errors AND warnings                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `--variables`                        | JSON object                                                                                        | —                              | Override values declared in `data-composition-variables`                                                                                                                                                                                                                                                                                                                                                                                      |
-| `--variables-file`                   | path                                                                                               | —                              | JSON file with variable values (alternative to `--variables`)                                                                                                                                                                                                                                                                                                                                                                                 |
-| `--strict-variables`                 | flag                                                                                               | off                            | Fail render on undeclared keys or type mismatches in `--variables`                                                                                                                                                                                                                                                                                                                                                                            |
-
-**Quality guidance:** `draft` while iterating, `looks` (the default) for the first real encode, `delivery` for final delivery. `standard` and `high` still work.
-
-**Read the summary's second line.** After the output path and size, `render` prints the capture path, GPU mode, and per-stage timings, e.g. `beginframe capture · software gpu · compile 0.7s · setup 1.1s · capture 8.1s · encode 5.8s`. `capture` is the frame loop and `setup` is calibration plus session init; the capture path reads `a|b` when parallel workers diverged, and `encode (during capture)` means the streaming encoder overlapped the loop, so do not add it to the wall time. Local GPU `auto` (the default) requests BeginFrame. If the line still says `screenshot capture` with `software gpu` on Linux, a hint under it says BeginFrame did not run (needs chrome-headless-shell, no `--resolution` upscale). It only appears when the GPU was auto-probed, never under `--docker` or `--no-browser-gpu`, where software GL is the point. Heavy compositions can stall on software GL. Do not reach for `--debug` just to learn which path ran.
-
-**Parametrized renders:** the composition declares its variables on the `<html>` root with **`data-composition-variables`** — a JSON **array of declarations** (`{id, type, label, default}` per entry) that defines the schema. Scripts inside read the resolved values via `window.__hyperframes.getVariables()`. The CLI `--variables '{"title":"Q4 Report"}'` is a JSON **object keyed by id** that overrides those declared defaults for one render; missing keys fall through, so the same composition runs unchanged in dev preview and in production. Sub-comp hosts can also override per-instance with `data-variable-values`. See `../../hyperframes/references/format.md` for the full pattern.
-
-### feedback (report after rendering)
-
-After a render is verified, send one feedback line per task. This is the maintainers' primary signal — a render that finishes silently tells them nothing.
-
-```bash
-npx hyperframes feedback --rating 10                              # clean run, no notes
-npx hyperframes feedback --rating 6 --comment "bg <video> renders grey in multi-scene; worked around with --format png-sequence"
-```
-
-`--rating` is an integer from 0-10; `--comment` is free text. A `--comment` with no `--rating` is a ratingless report (`MISSING FEATURE:` and `HOST APP:` in `SKILL.md`) that never counts in the rating metric. Feedback is anonymous and attaches a `doctorSummary` (OS/Node/CPU/mem/ffmpeg) automatically, so don't repeat those fields. A clean run needs only a short result. Before sending any bug, workaround, or confusing behavior, collect this compact reproduction packet:
-
-```text
-REPRO COMMAND: <HF_*/PRODUCER_* env> npx hyperframes <exact command>   # run from the project directory; do NOT paste absolute paths
-EXPECTED / ACTUAL: <expected behavior> / <observed behavior and isolated trigger>
-EXACT ERROR: <verbatim error or warning; include frame/timestamp for visual defects>
-OUTCOME: <output correct | output corrupt | fallback succeeded | hard exit | command hung>
-WORKAROUND: <exact workaround, or none>
-COMPOSITION_STRUCTURE:
-  elements: video=<n> audio=<n> img=<n> svg=<n> canvas=<n> subComps=<n>
-  attributes: <comma-joined subset of clip-path, filter, mix-blend-mode, transform, mask, position:fixed, overflow:hidden, z-index, data-has-audio, data-duration, data-start, data-composition-src, background-image:url, mask-image:url — or "(none present)">
-  timeline: <flat | nested (<n> sub-comps)>; driver=<gsap | data-timeline | gsap+data-timeline | none>
-  delta: <what differs between the working workaround-render and the broken default render>
-  defect: <spatial location + frame index range, e.g. top-left / frames 0-30 — omit for non-visual defects>
-```
-
-`COMPOSITION_STRUCTURE:` is a privacy-preserving structural anatomy: counts + presence flags only, no file paths, no src URLs, no user text. It lets maintainers pattern-match the report against known bug families (e.g. "sub-comp mount + clip-path", "GSAP timeline + z-index") without receiving the composition ZIP. Required for any rating ≤ 7 that describes a visual defect (black frame, flicker, corrupt output, wrong frame, blank output, other visual anomaly); optional but appreciated on higher ratings. Agents on this skill can auto-fill the block by calling `buildCompositionCensus(html)` and `renderCompositionCensusBlock(census)` from `packages/cli/src/utils/compositionCensus.ts` against the composition HTML they already have access to — the human user does not fill this out by hand.
-
-**Feedback is submitted to a public channel — anonymize before sending.** Redact absolute paths (which leak user home directory + machine identity), any user or project names embedded in paths, secrets, and credentials. Path arguments in the command should stay relative to the project directory (`./renders/out.mp4`, not `/Users/<user>/Documents/…/out.mp4`; `.hf-tmp/`, not `/home/<user>/projects/<real-name>/.hf-tmp/`). Similarly strip absolute paths from `EXACT ERROR:` stack traces and log excerpts — keep the file basename and line number, drop the leading directory. Preserve flags and relevant `HF_*` / `PRODUCER_*` variables verbatim. If the failure no longer reproduces, include the last failing command and log excerpt (redacted the same way). Share a project link only when one is already available and safe to share.
-
-The `hyperframes feedback` command soft-warns when a non-10 `--comment` is missing `REPRO COMMAND:`, and when a rating-≤-7 visual-defect comment is missing `COMPOSITION_STRUCTURE:`. The warnings print above the submission ack and do not block — some legitimate reports (a one-line "cloudrun quota bumped yesterday, fine now") won't fit the mold. Fix the packet and rerun to silence them.
-
-Hit a reproducible bug? Add `--file-issue` (optionally `--dir <project>` and `--yes` for non-interactive shells) to also publish a minimal repro to a public URL and open a pre-filled GitHub `bug` issue draft for a maintainer to file. This publishes the project publicly, so it is opt-in and consent-gated; the issue is never auto-submitted.
-
-## publish
-
-```bash
-npx hyperframes publish              # upload current project privately, return stable URL
-npx hyperframes publish ./my-video   # specific project
-npx hyperframes publish --public     # allow anyone with the URL to view the claimed project
-npx hyperframes publish --yes        # skip the confirmation prompt (scripts/CI)
-```
-
-Uploads the project's source (HTML + assets) and returns a stable hosted URL that renders in the browser. A fresh publish is private by default and requires authentication plus access to view. Use `--public` to allow anyone with the URL to view the claimed project. Updating a project in place keeps its existing visibility: re-publishing without `--public` never turns a public project private. `--yes` only skips the confirmation prompt; it does not change visibility. A signed-out publish returns an authentication-required claim URL rather than a public playback URL. Lint findings are surfaced before upload but do not block.
-
-## Where to render, and skill attribution
-
-Use cloud rendering when the user wants hosted rendering without local Chrome, FFmpeg, or AWS. Use Lambda only when AWS ownership is a requirement. Use Cloud Run only when GCP ownership is a requirement. Read the matching reference before running any cloud path.
-
-Skill attribution is automatic — the examples above need no `--skill`. A project scaffolded with `hyperframes init --skill=<slug>` records its owning skill in `hyperframes.json`, and every later render inherits it on anonymous telemetry: re-renders, `npm run render`, and `--batch` alike. Pass `--skill=<slug>` explicitly only to stamp a project that was not scaffolded with one (its first render then persists it).

.claude/skills/hyperframes-cli/references/upgrade-info-misc.md

@@ -1,142 +0,0 @@
-# info, upgrade, compositions, timeline, docs, benchmark, telemetry, asset preprocessing
-
-Catch-all reference for commands that don't fit the main dev loop.
-
-## info
-
-```bash
-npx hyperframes info                   # project metadata
-npx hyperframes info ./my-video        # specific project
-npx hyperframes info --json
-```
-
-Prints **project** metadata: name, resolution, duration, element counts by type, track count, and total project size. Project-level — not environment. For environment health use `doctor`.
-
-## upgrade
-
-```bash
-npx hyperframes upgrade                # check + interactive prompt
-npx hyperframes upgrade --check        # check and exit, no prompt (agent-friendly)
-npx hyperframes upgrade --check --json # machine-readable: current / latest / updateAvailable
-npx hyperframes upgrade --yes          # print upgrade commands without prompting
-```
-
-Compares the installed CLI version against npm latest.
-
-`--project [dir]` bumps a **project's** pinned scripts instead of the global install: it rewrites every `npx …hyperframes@<version>…` in `<dir>/package.json` (default cwd) to npm-latest. Always invoke it unpinned (`npx hyperframes@latest upgrade --project`) — a project scaffolded on an old CLI stays frozen otherwise. `--project . --check` reports the delta without writing; add `--json` for `{ changed, from, to, path }`. Pass the dir explicitly whenever another flag follows `--project` — on older releases a bare `--project` consumes the next flag as its directory value.
-
-## timeline
-
-```bash
-npx hyperframes timeline [project-dir]          # tracks and clips as a table with bars
-npx hyperframes timeline [project-dir] --json
-```
-
-Reach for `timeline` instead of opening `index.html` and each `data-composition-src` file when you need to know what is on the timeline: which clips exist, when they start and end, what they play, and how loud. It reads the project's files statically (no browser).
-
-Text output is `timeline <N>s`, then one block per track kind (`video`, `graphics`, `captions`, `audio`) with one row per clip of that kind, ordered by absolute start:
-
-```
-graphics (2: 1 top-level, 1 nested)
-  |██████                                  | sec-connector 0-6.7s src=compositions/connector-morph.html
-  |██████████████                          | box 15.67-17.99s (local 0-2.32s) nested in sec-connector compositions/connector-morph.html
-audio (1)
-  | █                                      | vo 1.6-3.6s src=vo.mp3 vol=0.5 group=vo volume[0:0.2 2:1]
-```
-
-- The bar is 40 columns over the whole timeline. Times are seconds.
-- `src=`, `vol=`, `rate=` (playback rate, only when not 1), `group=` (audio group), and `<target>[t:v ...]` (automation lane points, `t` in seconds from the clip start) appear only when the clip has them.
-- The header counts every clip of that kind, nested ones included: `video (6: 2 top-level, 4 nested)`. The list is in absolute order, so the Nth row is the Nth clip of that kind on the main timeline. A clip inside a sub-composition prints its absolute start-end, then `(local <start>-<end>s)` (time inside that sub-composition), then `nested in <host row id> <file that declares it>`. Only one level of nesting is read: a sub-composition inside a sub-composition is listed as a row saying `children=unread`, and the clips inside it are not counted.
-- With no `data-duration`/`data-end`, a media row still gets a resolved length and says where it came from: `duration=media` means ffprobe measured the source (with playback start and rate applied); `duration=default` means an `img` got the 3s default; `duration=inferred` means a composition host summed its children; `pending: <reason>` (dotted bar, `duration` 0) means the source could not be probed (missing file, remote `src`, ffprobe error). A non-media leaf with nothing to resolve prints no source.
-- `lanes unreadable: ...` means the clip's `data-automation` or `data-fx-chain` did not parse; fix the attribute.
-
-`--json` prints `{ timeline: { duration, tracks: [{ kind, rows: [...] }] } }`. A track's `rows` are every clip of that kind, nested ones included, by `absStart`; read them, never only the top level. Each row has `id`, `kind` (tag), `trackKind`, `start`, `duration`, `end` (local to the row's own file), **`absStart`, `absEnd`, `file`** (main-timeline time and the project-relative file that declares the clip — use these, not `start`/`end`, to compare clips across nesting), `trackIndex`, `src`, `sourceFile`, `volume`, `lanes`, `playbackRate`, `audioGroup`, `durationAuthored`, **`durationSource`** (`"authored" | "media" | "default" | "inner" | "pending"`, or `null` for a non-media leaf with nothing to resolve), **`pendingReason`** (why nothing resolved; `null` unless `durationSource` is `"pending"`), `laneError`, **`index`** (the row's position in its kind's `rows`; a position, not an id), **`nested`** (declared inside a sub-composition), **`host`** (plain id of the row that hosts a nested clip, else `null`), **`hostRow`** (`{kind, index}` of that host row), and `children` (`{kind, index}` pointers to the sub-composition's clips, one level; every clip is already a full row in its kind's `rows`, so nothing needs following).
-
-### Query one-liners (jq, node fallback if jq is absent)
-
-```bash
-TL=$(npx hyperframes timeline --json)
-# 1. what plays at absolute time T=12.5
-jq --argjson t 12.5 '[.timeline.tracks[].rows[] | select(.absStart<=$t and .absEnd>$t)]' <<<"$TL"
-node -e 'const t=12.5,j=JSON.parse(require("fs").readFileSync(0,"utf8"));j.timeline.tracks.forEach(tr=>tr.rows.forEach(x=>{if(x.absStart<=t&&x.absEnd>t)console.log(x.id,x.file)}))' <<<"$TL"
-# 2. find a clip by id or src -> file, track, absStart, absEnd
-jq --arg q tsfx-pet2 '[.timeline.tracks[].rows[] | select(.id==$q or .src==$q)] | .[] | {file,trackKind,absStart,absEnd}' <<<"$TL"
-node -e 'const q="tsfx-pet2",j=JSON.parse(require("fs").readFileSync(0,"utf8"));j.timeline.tracks.forEach(tr=>tr.rows.forEach(x=>{if(x.id===q||x.src===q)console.log(x.file,x.trackKind,x.absStart,x.absEnd)}))' <<<"$TL"
-# 3. every clip of one kind, nested included, in absolute order
-jq --arg k video '.timeline.tracks[] | select(.kind==$k).rows[] | {id,absStart,absEnd}' <<<"$TL"
-node -e 'const k="video",j=JSON.parse(require("fs").readFileSync(0,"utf8"));j.timeline.tracks.find(t=>t.kind===k).rows.forEach(r=>console.log(r.id,r.absStart,r.absEnd))' <<<"$TL"
-# 4. gaps and overlaps within a kind (positive = gap, negative = overlap)
-jq --arg k video '(.timeline.tracks[] | select(.kind==$k).rows) as $r|[range(0;($r|length)-1)|{a:$r[.].id,b:$r[.+1].id,delta:($r[.+1].absStart-$r[.].absEnd)}]' <<<"$TL"
-node -e 'const k="video",j=JSON.parse(require("fs").readFileSync(0,"utf8"));const r=j.timeline.tracks.find(t=>t.kind===k).rows;for(let i=0;i<r.length-1;i++)console.log(r[i].id,r[i+1].id,r[i+1].absStart-r[i].absEnd)' <<<"$TL"
-# 5. the Nth clip of a kind by absolute start (N=2)
-jq --arg k video --argjson n 2 '.timeline.tracks[] | select(.kind==$k).rows[$n-1] | {index,id,absStart,file,nested}' <<<"$TL"
-node -e 'const k="video",n=2,j=JSON.parse(require("fs").readFileSync(0,"utf8"));const r=j.timeline.tracks.find(t=>t.kind===k).rows[n-1];console.log(r.index,r.id,r.absStart,r.file)' <<<"$TL"
-```
-
-## compositions, docs
-
-```bash
-npx hyperframes compositions           # list compositions in project
-npx hyperframes compositions --json
-npx hyperframes docs                   # list available topics
-npx hyperframes docs rendering         # print one topic inline in the terminal
-```
-
-`compositions` lists every `data-composition-id` in the project (including sub-comps) with duration, resolution, and element count.
-
-`docs` prints inline documentation **in the terminal** — it does not open a browser. Topics: `data-attributes`, `examples`, `rendering`, `gsap`, `troubleshooting`, `compositions`. Run without a topic to see the list.
-
-## benchmark
-
-```bash
-npx hyperframes benchmark              # run the preset matrix in current project
-npx hyperframes benchmark ./my-video   # specific project
-npx hyperframes benchmark --runs 5     # repeat each config N times (default 3)
-npx hyperframes benchmark --json
-```
-
-Renders the project with 5 preset configurations — `30fps draft 2w`, `30fps standard 2w`, `30fps high 2w`, `30fps standard 4w`, `60fps standard 4w` — and prints a comparison of render speed and output file size. Use it to find the fastest acceptable preset for your machine. Not a single-render-with-stage-breakdown.
-
-## telemetry
-
-```bash
-npx hyperframes telemetry status      # show telemetry state
-npx hyperframes telemetry disable     # disable anonymous usage telemetry
-npx hyperframes telemetry enable      # re-enable telemetry
-```
-
-Telemetry is anonymous usage counters only. Disable globally with `HYPERFRAMES_NO_TELEMETRY=1` if env-var control is preferred over the subcommand.
-
-Events include two fingerprint properties used to distinguish managed-sandbox runs from real laptops — no PII, no env-var **values**, only existence checks:
-
-- **`sandbox_runtime`**: `gvisor` / `firecracker` / `docker` / `kvm` / `wsl` / `null`. gVisor via kernel string + `/proc/version`. Firecracker via `/dev/vsock` + DMI sys_vendor. Docker via `/.dockerenv` + cgroup.
-- **`agent_runtime`**: `claude_code` / `codex` / `cursor` / `copilot_agent` / `jules` / `replit` / `devin` / `aider` / `gemini_cli` / `hermes` / `openclaw` / `null`. Detected by the existence of well-known vendor env vars; the values themselves are never read.
-- **`client`**: set only when an app launched the CLI with a `HYPERFRAMES_CLIENT` tag (`<app>/<version>/<channel>`), sent as-is when it is a short slug.
-
-## Asset Preprocessing
-
-```bash
-npx hyperframes tts
-npx hyperframes transcribe
-npx hyperframes remove-background
-```
-
-These produce assets (narration audio, word-level transcripts, transparent video) that get dropped into a composition. Each may download its own model on first run.
-
-For voice selection, Whisper model rules, output format choice, and the TTS → transcript → captions chain, invoke the `media-use` skill. This skill stays focused on the dev loop.
-
-## Remaining harness usage
-
-Run `npx hyperframes usage --json` at the start of a video workflow and again at milestones such as after drafting and before rendering. A fresh read at handoff can serve as the start read. Use `--harness claude-code`, `--harness codex`, or `--harness grok` to select explicitly.
-
-Known results contain `status: "known"`, `harness`, `planTier`, `session`, `weekly`, and `spend`. Each available window contains `usedPercent`, `remainingPercent`, and `resetsAt`; an unavailable window is `null`. `planTier` is the readable subscription tier when available, otherwise `null`. Claude Code reports its shared five-hour and weekly windows; a spend-metered plan (such as Enterprise) has neither and reports `spend`, the share of its billing-period spend limit already used, with `resetsAt: null`. Codex reports its shared session and weekly windows when available. Grok reports its included weekly allowance with `session: null`. Only Claude Code reports `spend`; it is `null` elsewhere. When no window is available the result is `status: "unknown"` with `reason: "no_usage_windows"`.
-
-Unknown results contain `status: "unknown"` and a token-free `reason`. Missing, expired, unsupported, ambiguous, or unreadable logins and unavailable provider responses return unknown. Report the unknown state without guessing allowance. The command reads existing credentials without refreshing or rewriting them and emits no tokens or telemetry. Usage is a snapshot; it does not reserve allowance or estimate the next video's cost. Keep scope and workflow choices with the user.
-
-## Remaining harness usage
-
-Run `npx hyperframes usage --json` at the start of a video workflow and again at milestones such as after drafting and before rendering. A fresh read at handoff can serve as the start read. Use `--harness claude-code`, `--harness codex`, or `--harness grok` to select explicitly.
-
-Known results contain `status: "known"`, `harness`, `planTier`, `session`, `weekly`, and `spend`. Each available window contains `usedPercent`, `remainingPercent`, and `resetsAt`; an unavailable window is `null`. `planTier` is the readable subscription tier when available, otherwise `null`. Claude Code reports its shared five-hour and weekly windows; a spend-metered plan (such as Enterprise) has neither and reports `spend`, the share of its billing-period spend limit already used, with `resetsAt: null`. Codex reports its shared session and weekly windows when available. Grok reports its included weekly allowance with `session: null`. Only Claude Code reports `spend`; it is `null` elsewhere. When no window is available the result is `status: "unknown"` with `reason: "no_usage_windows"`.
-
-Unknown results contain `status: "unknown"` and a token-free `reason`. Missing, expired, unsupported, ambiguous, or unreadable logins and unavailable provider responses return unknown. Report the unknown state without guessing allowance. The command reads existing credentials without refreshing or rewriting them and emits no tokens or telemetry. Usage is a snapshot; it does not reserve allowance or estimate the next video's cost. Keep scope and workflow choices with the user.

.claude/skills/hyperframes-registry/SKILL.md

@@ -1,56 +0,0 @@
----
-name: hyperframes-registry
-description: About 450 ready-made HyperFrames blocks and components installed as editable source - transitions, overlays, titles, kinetic type, captions, charts, map overlays, 3D, camera moves. Use it before hand-building any named visual (CRT scanlines, glitch, film grain, a chart); also for hyperframes add and catalog.
----
-
-**Plugin installs:** Before setup or freshness commands, follow [plugin execution rules](../hyperframes/references/plugin-installation.md) when this skill is inside a HyperFrames plugin.
-
-# HyperFrames registry
-
-Starting from an item is faster and usually better than writing the effect yourself, and an installed item is ordinary source in your project: change it, cut it down, restyle it.
-
-## Find and install
-
-```bash
-npx hyperframes catalog --query "<what the beat should do, in English>" --json
-npx hyperframes add <name> --json        # prints the written files and the mount snippet
-```
-
-- Query in English even when the video is not: the catalog is indexed in English, and another script returns `No searchable words in query`, which is not a gap.
-- Search is local and sends nothing. The default `words` tier only finds items that reuse your words; `--on-device` ranks by meaning after a one-time ~33 MB download. Offer that download and let the person decide; never enable it silently. The `--json` envelope names the tier that answered.
-- Narrow with `--type block|component` and `--tag <tag>`. `add <tag>` installs every block with that tag; dependencies install first. `add` needs the network even for an item installed before; search works offline from the cached manifest.
-- Nothing fits: report it before you hand-build, on either tier. `catalog --query` prints the line pre-filled (`report_gap` in `--json`): `npx hyperframes feedback --search-miss "<query>" --wanted "<the move you needed>" --tier <tier>`. Describe the effect, not an item name you imagined.
-
-Tiers, `dropped` and `unindexed`, stale indexes, offline behaviour: `references/search.md`.
-
-## What's in it
-
-| Blocks: a scene with its own timeline | Examples |
-| --- | --- |
-| Transitions | `beat-freeze-cut`, `chromatic-radial-split`, `cinematic-zoom` |
-| Overlays and lower thirds | `camcorder-hud`, `editorial-flash-overlay`, `lt-clean-bar` |
-| Title cards and kinetic type | `canopy-part-title`, `code-slice-hero` |
-| Social, chat and UI cards | `ai-chat-reveal`, `chatgpt-exchange` |
-| Code, charts, data and maps | `code-diff`, `bar-chart-race`, `data-chart` |
-| 3D, shader and backgrounds | `app-showcase`, `aurora`, `blob` |
-
-| Components: a snippet merged into your scene | Examples |
-| --- | --- |
-| Motion primitives and text effects | `agent-cursor`, `blur-in`, `bottom-up-letters` |
-| Caption styles | `caption-clip-wipe`, `caption-editorial-emphasis` |
-| Camera moves | `camera-shake`, `camera-scan-gate` |
-| Product demo and UI props | `before-after-wipe`, `browser-device-stage` |
-| Textures, particles and effects | `ascii-render-pass`, `grain-overlay` |
-
-## Wiring
-
-- **Block**: installs to `compositions/<name>.html`. Mount it with `data-composition-src`, `data-composition-id` matching the block's own id, `data-start` and the `data-duration` you need; the snippet `add` prints is the starting point. `references/wiring-blocks.md`.
-- **Component**: installs to `compositions/components/<name>.html`. Copy its markup, `<style>` and script into your scene, and follow its comment block if it hooks into your timeline. `references/wiring-components.md`.
-- Take the largest unit that fits, then edit it. Keep an installed item's ids prefixed as they are, so two items can't collide.
-- An item keeps its own variables; set them for one mount with `data-variable-values` on its host (`add --vars '{"title":"…"}'` writes that), and point its colour and font variables at your brand's.
-- Beat-synced blocks take hit times from `npx hyperframes beats --json`: the beat times minus the mount's `data-start`.
-- Install paths come from `hyperframes.json` (`references/install-locations.md`).
-
-## Contributing
-
-Authoring a new block or component for an upstream PR: `references/contributing.md`, starter templates in `references/templates.md`, quality bar in `references/component-quality-bar.md`.

.claude/skills/hyperframes-registry/examples/add-block.md

@@ -1,51 +0,0 @@
-# Worked Example: Adding a Block
-
-## Scenario
-
-User has an existing HyperFrames project and wants to add an animated chart alongside their video content.
-
-## Steps
-
-### 1. Install the block
-
-```bash
-hyperframes add data-chart
-```
-
-### 2. Wire into index.html
-
-```html
-<div id="stage" data-composition-id="main" data-width="1920" data-height="1080" data-duration="30">
-  <video
-    id="speaker"
-    src="speaker.mp4"
-    data-start="0"
-    data-duration="30"
-    data-track-index="0"
-    style="position: absolute; width: 60%; height: 100%; left: 0; top: 0; object-fit: cover;"
-  ></video>
-
-  <!-- Data chart appears at 5s in the right 40% of the screen -->
-  <div
-    data-composition-id="data-chart"
-    data-composition-src="compositions/data-chart.html"
-    data-start="5"
-    data-duration="15"
-    data-track-index="1"
-    data-width="1920"
-    data-height="1080"
-    style="position: absolute; right: 0; top: 0; width: 40%; height: 100%;"
-  ></div>
-</div>
-```
-
-### 3. Lint and preview
-
-```bash
-hyperframes lint
-hyperframes preview
-```
-
-### 4. Customize (optional)
-
-Edit `compositions/data-chart.html` — data arrays are at the top of the script, colors are in the CSS rules scoped under `[data-composition-id="data-chart"]`.

.claude/skills/hyperframes-registry/examples/add-component.md

@@ -1,73 +0,0 @@
-# Worked Example: Adding a Component
-
-## Scenario
-
-User wants to add a shimmer light sweep effect to their title text.
-
-## Steps
-
-### 1. Install the component
-
-```bash
-hyperframes add shimmer-sweep
-```
-
-### 2. Read the snippet
-
-Open `compositions/components/shimmer-sweep.html` and read the comment header.
-
-### 3. Wire into your composition
-
-**HTML** — wrap target elements:
-
-```html
-<div class="shimmer-sweep-target" style="--shimmer-color: rgba(255, 255, 255, 0.5)">
-  <h1 class="title">AI-Powered Video</h1>
-</div>
-```
-
-**CSS** — paste the `.shimmer-sweep-target` and `.shimmer-mask` rules from the snippet.
-
-**JS** — paste the auto-injection script (before timeline code):
-
-```js
-document.querySelectorAll(".shimmer-sweep-target").forEach((el) => {
-  if (!el.querySelector(".shimmer-mask")) {
-    const mask = document.createElement("div");
-    mask.className = "shimmer-mask";
-    el.appendChild(mask);
-  }
-});
-```
-
-**Timeline** — add the sweep:
-
-```js
-tl.fromTo(
-  ".shimmer-sweep-target",
-  {
-    "--shimmer-pos": "-20%",
-  },
-  {
-    "--shimmer-pos": "120%",
-    duration: 1.2,
-    ease: "power2.inOut",
-    stagger: 0.15,
-  },
-  1.5,
-);
-```
-
-### 4. Lint and preview
-
-```bash
-hyperframes lint
-hyperframes preview
-```
-
-### 5. Customize
-
-- `--shimmer-color`: highlight color per element
-- `--shimmer-width`: light band width (default 20%)
-- `--shimmer-angle`: sweep direction (default 120deg)
-- Timeline `duration`, `ease`, `stagger`: control speed and feel

.claude/skills/hyperframes-registry/references/component-quality-bar.md

@@ -1,250 +0,0 @@
-# Component quality bar
-
-What a catalog component has to be for us to keep shipping it. Every criterion here comes from a
-defect found and verified on this branch, not from taste.
-
-A registry component is a motion primitive an author installs into their own composition and
-ships. The catalog page is marketing; the installed file is the product. Every criterion below is
-therefore evaluated against **the item's own `<name>.html`, mounted alone**, never against
-`demo.html` and never against the catalog page, because both of those carry scaffolding the author
-does not receive.
-
-Read this before auditing, scoring or cutting anything. It exists so several people auditing in
-parallel reach the same verdict on the same item.
-
-## The one rule
-
-> An item earns its place when the file the author installs, mounted by itself on the ground it
-> was designed for, renders the subject its name promises and moves the way its description says.
-> Anything that fails that and cannot be fixed into something no other item already does is cut.
-
-## How an audit runs
-
-Two passes, in this order. The mechanical pass is free and runs across every item in seconds; the
-visual pass costs a browser and eyes, so it is spent only on what the mechanical pass could not
-decide. A mechanical signal is a **candidate**, never a verdict.
-
-| Pass           | Cost           | Decides                                                                                  |
-| -------------- | -------------- | ---------------------------------------------------------------------------------------- |
-| **Mechanical** | grep and hash  | duplicates, missing timeline, banned hexes, empty markup, name gaps, unbounded variables |
-| **Visual**     | render and eye | renders at all, implements its description, legible, deterministic                       |
-
-`hyperframes check` is not a visual gate. It passes compositions that render nothing: a blank plot
-produces no error, no warning and no layout finding, because an empty render is a valid render. No
-criterion below may rest on `check` alone.
-
-### The mount harness
-
-Three ways to get a false verdict from a working item, all of them the harness's fault. Build the
-shell like this or the audit invents defects.
-
-1. **Two shapes of item, two ways to mount.** If the file, with HTML comments stripped, contains a
-   `data-composition-id`, it is a sub-composition: mount it with
-   `data-composition-src="./<name>.html"` on a clip. If it does not, it is a snippet: paste it
-   inline inside a `class="clip"` div. Inlining a sub-composition nests a document in a document
-   and renders black, which reads exactly like a dead item.
-2. **Use the item's own ground.** Take the background off its `demo.html` body rule. A snippet
-   whose ink defaults to `#18181b` is a 16:1 headline on its own `#f7f7f8` and an invisible 1.5:1
-   smudge on a dark stage. The stage is not evidence.
-3. **Load GSAP and register a paused root timeline**, then snapshot with
-   `hyperframes snapshot . --at 0.05,1.2,2.5,4.0 --no-end` and read the contact sheet.
-
-An item whose own `data-duration` is shorter than the shell's will be blank in the last frames.
-That is arithmetic, not a defect.
-
-## Fatal, cut the item
-
-Fatal means there is nothing worth keeping underneath the defect: no edit short of writing a
-different item fixes it, or the fix produces something the catalog already ships. Cite the named
-evidence; a fatal verdict without it does not count.
-
-**F1. Does not implement its own description.** The markup contains no trace of the subject the
-item is named and described for. Not "renders badly", but "the thing is absent from the file".
-`ecosystem-constellation`, `hero-device-assemble` and `terminal-to-browser-deploy` are the same
-file holding empty card divs with different headings.
-_Check:_ read the markup, then swap the name for any other item's name. If nothing in the file
-would have to change, the name is a label on a generic shell.
-_Evidence:_ the named subject has no element (no nodes in a constellation, no terminal in a
-terminal deploy).
-
-**F2. Redundant duplicate.** Same **motion fingerprint** and same **markup skeleton** as another
-item that survives. Fingerprint is the gsap call list with selectors neutralised, keeping props,
-durations and eases; skeleton is the tag sequence with classes and text stripped. One wipe
-currently ships eight times with the same properties, durations and easings; one word-stagger
-ships seven times.
-_Evidence:_ both hashes match a sibling, and the sibling wins the tie-break below.
-
-**F3. Renders nothing.** Frames are blank, or the named subject never appears, with the item
-mounted correctly on its own ground and its recipe applied.
-_Evidence:_ four blank frames plus the cause, in the item rather than the harness: a missing
-sibling asset, a `ReferenceError` in the console, a subject that never enters the viewport. A
-frame-capture artifact that renders correctly live is a false alarm, so confirm on a real page
-before recording it.
-
-**F4. The description is a different item.** The frames show the promised event never happening: a
-wipe that never reveals its second panel, a chart that draws no series. Not a wording gap.
-
-**F5. Cannot be made seekable.** Frame N genuinely depends on frame N-1 with no closed form and no
-bounded replay, and making it seekable would make it a different effect. Rare. Most accumulators
-have a trivial rewrite, so reach for this only after establishing there is none; a seeded,
-index-derived replacement for `Math.random()` is X7, not F5.
-_Evidence:_ two snapshots of the same timestamp reached by different seek paths differ.
-
-## Fixable, keep and repair
-
-Real defects, but the item has a reason to exist that nothing else covers and the repair is
-bounded. Log the specific fix, never "needs polish".
-
-**X1. No timeline of its own.** No `__timelines` registration, so the installed artifact renders a
-still frame while the catalog page looks fine, because the generator transplants the demo's
-timeline into the preview. 97 of the 213 new components are in this state.
-_Repair:_ fold the trailing `Timeline integration:` recipe into a real `<script>` that builds a
-paused timeline and registers it. Roughly 10 to 15 minutes for a single-element item.
-_Escalates to fatal_ only when there is no motion anywhere to fold in, which usually means F1 too.
-
-**X2. Name claims a technique the code lacks.** Grep the code region, never the doc header: the
-header's prose is full of the exact words you are looking for, and will report a match on an item
-that has none.
-| Name pattern | Must contain |
-| -------------------------------- | -------------------------------------------------- |
-| `spring-*` | `elastic`, `back.`, `bounce` or a custom spring ease |
-| `mask-*`, `*-mask*` | `mask` or `clip-path` |
-| `frosted*`, `*glass*` | `backdrop-filter` |
-| `*3d*`, `*depth*`, `*orbit*`, `*camera*` | `perspective`, `rotateX`, `rotateY`, `translateZ` |
-| `*-draw`, `*-trace`, `*stroke*` | `stroke-dash` or `pathLength` |
-_Repair:_ add the technique, or rename the item. Renaming is often the honest fix.
-
-**X3. Illegible.** At 1920x1080 on its own ground: text under 4.5:1, or a subject whose smallest
-meaningful feature is under about 24px.
-_Repair:_ one value step, per `placeholder-material.md`. Text never sits below L1.
-
-**X4. Placeholder gradients.** The purple and blue palette standing in for content.
-_Repair:_ the monochrome ramp. Already done across the catalog, so a new instance is a regression,
-not a legacy defect.
-
-**X5. Hardcoded ink, no theme token.** A literal colour on the item's own text or subject with no
-`var(--...)` fallback chain, so it disappears when an author drops it on the opposite theme.
-_Repair:_ route it through the theme token with the literal as fallback.
-
-**X6. No markup of its own.** The file is a `<style>` and a `<script>` and nothing else, so
-mounting it renders an empty box.
-_Repair:_ ship sample markup, or declare it an attachment snippet in `registry-item.json` and give
-the demo a host element.
-
-**X7. Unseeded randomness.** Scatter derived from `Math.random()` rather than the element index.
-_Repair:_ derive from the index.
-
-**X8. Declared bounds it cannot honour.** A number variable with no `min`/`max`, so the control
-offers values the item cannot express, or a default it can never return to.
-_Repair:_ declare real bounds, or use a numeric field instead of a slider.
-
-## Duplicates, which one survives
-
-A group is the set of items sharing both hashes from F2. Exactly one survives, chosen in order:
-
-1. **The one whose name describes what the shared motion actually does.** A group where one member
-   is a directional wipe and the rest borrowed it keeps the directional wipe.
-2. **Then the one with subject-specific markup.** More elements that only make sense for that
-   name, not more elements.
-3. **Then the one already on `origin/main`.** Removing a shipped item breaks installs.
-4. **Never a member whose name claims something the shared implementation does not do.**
-   `frosted-glass-wipe` has no `backdrop-filter`, `spring-scale-in` has no spring, `mask-reveal-up`
-   has no mask, so none of those three is the survivor. Such a member is F2 and X2 at once, and X2
-   cannot be fixed without breaking the group. If no member is honest, keep the plainest name.
-
-**If every member of a group fails F1, the group is cut entire.** Do not preserve a survivor to
-soften the count. Twelve names on one empty card shell is one bad item, not twelve, and keeping one
-of them keeps the bad item.
-
-Same motion with genuinely different subjects is not a duplicate. A bar chart, a line chart and a
-dashboard populate can share a stagger; the subject is the item.
-
-## Never cut
-
-Protection is per criterion, not blanket. A protected item still answers every other row.
-
-**N1. Load-bearing colour** is exempt from X4 only. `chromatic-aberration-wipe` (the RGB split is
-the effect), `confetti` (multi-hue is the celebration), `matrix-decode` (green is its identity),
-`mesh-gradient-bg` (the gradient is the subject), `multi-device-splay`. `us-map`'s gradient is a
-sequential choropleth scale, which is colour carrying data.
-
-**N2. Real product depiction** is exempt from X4 and F1. A Figma logo inside a Figma mock is not
-slop; the HyperFrames wordmark in `logo-brand-close` is the subject. Judge the placeholder content,
-not the depicted product.
-
-**N3. Deliberate static** is exempt from X1. An item whose description promises no motion is not
-failing X1. A style snippet or a passive overlay is allowed to sit still.
-
-**N4. Environment sets** are exempt from F3. An item that is a backdrop rather than a shot is not
-failing F3 for being calm. Measured PSNR between frames separates the two: sets score 45 or higher,
-things that genuinely run score 17 to 24. Judge against the description.
-
-**N5. A rest state that is the recipe's `from` state** is exempt from F3. `confetti` ships
-`.particle` spans sitting at opacity 0 until the timeline fans them out. Still is not dead.
-
-**N6. Attachment snippets** are exempt from F3. A text splitter has no markup by design. Grade X6.
-
-**N7. The 36 items already on `origin/main`** are out of audit scope.
-
-## Mechanical first pass
-
-| Signal              | How                                                                                   | Maps to |
-| ------------------- | ------------------------------------------------------------------------------------- | ------- |
-| No timeline         | `grep -L __timelines` over each composition                                           | X1      |
-| Duplicate           | motion fingerprint AND markup skeleton hashes, matched pairwise                       | F2      |
-| Empty shell         | markup skeleton matches an unrelated item, or is `<h3>` + `<p>` + generic panels only | F1      |
-| No markup at all    | element count of the comment-, style- and script-stripped file is 0                   | X6      |
-| Placeholder palette | grep the six banned hexes                                                             | X4      |
-| Name gap            | the X2 table, grepped over the code region only                                       | X2      |
-| Unbounded number    | read `min`/`max` in `registry-item.json`                                              | X8      |
-| Non-determinism     | grep `Math.random`, `Date.now`, `performance.now`, `requestAnimationFrame`            | X7, F5  |
-
-## Visual pass, required for a verdict
-
-Render at least four frames across the duration from the **composition**, not the demo, mounted per
-the harness rules above, and look at them. Then, for anything not scoring clean, confirm on the
-real catalog page before recording it.
-
-Record per item: the criteria it fails, the evidence you saw, and fatal or fixable. An unviewed
-item is not a pass.
-
-## Calibration
-
-Ten items scored with this rubric, frames rendered and looked at. Three of them corrected the
-rubric rather than the other way round.
-
-| Item                         | Expected   | Frames actually showed                                                                                                    | Verdict            |
-| ---------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------ |
-| `ecosystem-constellation`    | fatal      | Sidebar with three pill buttons and three empty white panels. No nodes, no edges. Identical at all four timestamps.       | **Cut** F1, F2, F4 |
-| `terminal-to-browser-deploy` | fatal      | Pixel-identical to the above, only the `<h3>` and one subtitle differ. No terminal, no browser.                           | **Cut** F1, F2, F4 |
-| `frosted-glass-wipe`         | fatal      | One card reading "Before", static, forever; the "After" panel stays clipped. Recipe byte-identical to `directional-wipe`. | **Cut** F2, F4, X2 |
-| `char-slam-explode`          | pass       | Letters scattered at 0.05s, assembled into "Impact" by 1.2s, held. Real per-character motion.                             | **Keep**           |
-| `echo-trail`                 | pass       | Card travels left to right with a decaying blurred echo trail behind it. Legible on its own light ground.                 | **Keep**           |
-| `logo-brand-close`           | pass       | "H" resolves into the full wordmark, tagline and URL land after it. Staged, legible.                                      | **Keep**           |
-| `blur-in`                    | borderline | Still, but the still is the correct rest state: legible headline, unique implementation, theme-token ink.                 | **Keep**, X1       |
-| `spring-scale-in`            | borderline | Legible on its own `#f7f7f8`. Ease is `power3.out`, no spring anywhere. Shares its recipe with six others.                | **Cut** F2, X2     |
-| `confetti`                   | borderline | Card and mesh, no particles visible. Source ships `.particle` spans the recipe fans out from opacity 0.                   | **Keep**, X1       |
-| `bottom-up-letters`          | borderline | Four blank frames. The file is a splitter with no markup at all.                                                          | **Keep**, X6       |
-
-Three corrections the calibration forced, all of them false cuts:
-
-- `spring-scale-in` first scored X3 at roughly 1.5:1. That was the harness's dark stage, not the
-  item. Hence "use the item's own ground".
-- `confetti` first scored F3. Its rest state is its recipe's `from` state. Hence N5.
-- `char-slam-explode` first scored F3 with four black frames. It is a sub-composition and was being
-  inlined. Hence the two-shapes rule.
-
-A rubric that cuts a working item is wrong even when the verdict is convenient.
-
-## Checklist
-
-Per item, in order. Stop at the first fatal.
-
-- [ ] Mounted the right way for its shape, on its own ground, with GSAP and a paused root.
-- [ ] F1: the markup contains the named subject.
-- [ ] F2: motion fingerprint and markup skeleton are not both shared with a survivor.
-- [ ] F3: it renders something with the recipe applied, or it is protected by N3 to N6.
-- [ ] F4: the frames show the event the description promises.
-- [ ] F5: frame N is computed from N.
-- [ ] X1 through X8 logged with the specific fix.
-- [ ] Verdict cites the evidence the criterion names, not an impression.

.claude/skills/hyperframes-registry/references/contributing.md

@@ -1,180 +0,0 @@
-# Contributing a Block or Component to the Registry
-
-Guide the user from idea to merged PR for a new registry block or component.
-
-## Workflow
-
-```
-1. Clarify → 2. Scaffold → 3. Build → 4. Validate → 5. Preview → 6. Ship
-```
-
-### Step 1: Clarify
-
-Ask what they're building. The registry has two item types:
-
-- **Block** (`registry/blocks/`, type `hyperframes:block`) — a full standalone composition with fixed dimensions and duration. Caption styles, VFX effects, title cards, lower thirds.
-- **Component** (`registry/components/`, type `hyperframes:component`) — a reusable snippet with no fixed dimensions or duration. CSS effects, text treatments, overlays that adapt to any composition size.
-
-Then ask:
-
-- One-sentence description of the effect
-- Visual reference (URL, screenshot, or description)
-- Who uses this and when?
-
-### Step 2: Scaffold
-
-Create the registry structure:
-
-**For blocks:**
-
-```
-registry/blocks/{block-name}/
-  {block-name}.html
-  registry-item.json
-```
-
-**For components:**
-
-```
-registry/components/{component-name}/
-  {component-name}.html
-  registry-item.json
-```
-
-**Naming convention:**
-
-| Item name        | ID prefix | Example IDs            |
-| ---------------- | --------- | ---------------------- |
-| `cap-hormozi`    | `hz`      | `hz-cg-0`, `hz-cw-3`   |
-| `cap-typewriter` | `tw`      | `tw-cg-0`, `tw-ch-0-5` |
-| `vfx-chrome`     | `vc`      | `vc-canvas`            |
-
-Use a 2-3 letter prefix. ALL element IDs must use this prefix to avoid collisions in sub-compositions.
-
-**registry-item.json** — use the canonical templates in [templates.md](templates.md) (block and component variants, both with all required fields).
-
-### Step 3: Build
-
-Apply the correct template based on type. See [templates.md](templates.md) for copy-paste starters.
-
-#### Caption blocks
-
-**Non-negotiable caption rules:**
-
-- Font: **96px minimum** for proportional fonts. **64-72px acceptable for monospace** (wider characters need less size).
-- Readability: `-webkit-text-stroke: 2-3px` OR multi-layer `text-shadow`
-- Overflow: call `window.__hyperframes.fitTextFontSize()` on every group
-- Karaoke: highlight active word via `tl.to(wordEl, { color/scale }, WORDS[wi].start)`
-- Hard kill: `tl.set(groupEl, { opacity: 0, visibility: "hidden" }, g.end)` on EVERY group
-- **Never use `tl.from(el, { opacity: 0 })` at the same position as `tl.set(el, { opacity: 1 })`** — the from clobbers the set. Use `tl.to` instead.
-
-**Per-character animation** (typewriter, scramble):
-
-- Wrap each character in `<span>` with ID `{prefix}-ch-{group}-{char}`
-- Stagger via `tl.set` at computed intervals from word timestamps
-- Cursors/decorative elements: use `tl.set` at intervals — NOT CSS animation (not seekable)
-
-**Positioning variants:**
-
-- Centered: `display: flex; align-items: center; justify-content: center;`
-- Lower-third: `position: absolute; bottom: 100px; left: 0; width: 100%; text-align: center;`
-- Left-aligned: `position: absolute; bottom: 100px; left: 120px; text-align: left;`
-
-#### VFX blocks (Three.js)
-
-- Use `three@0.147.0` from CDN (global script)
-- `tl.eventCallback("onUpdate", renderScene); renderScene();` — NO requestAnimationFrame
-- State proxy pattern: GSAP animates plain JS object, render function reads it
-- Seeded PRNG (`mulberry32`) for randomness
-
-#### All types
-
-- **Load files the block ships through `__hyperframes.assetUrl("assets/...")`** whenever a script
-  builds the path (textures, fonts, JSON, models). Attributes like `src` and `href` are rebased
-  when the block is mounted; strings in a script are not, so a bare `"assets/..."` 404s once the
-  block lives under `compositions/<name>/`. A separate `.js` file gets the URLs from the block's
-  inline script. A block whose assets install to the project's own `assets/` (target
-  `compositions/<name>.html`) keeps plain project-root paths; `assetUrl` would look beside the file.
-- **Placeholder content is monochrome** — read
-  [placeholder-material.md](placeholder-material.md) before choosing a single colour. Stand-in
-  screens, images, cards, avatars, logos and chart series use four alpha steps of the
-  composition's ink; accent marks one element and never a placeholder.
-- `data-composition-id` MUST match `window.__timelines["id"]`
-- All element IDs prefixed with block abbreviation
-- `gsap.timeline({ paused: true })` — always paused
-- No `Math.random()`, no `Date.now()`
-
-### Step 4: Validate
-
-```bash
-hyperframes lint                    # 0 errors required
-hyperframes check --no-contrast  # 0 console errors required
-```
-
-### Step 5: Preview
-
-```bash
-# Render preview video
-hyperframes render -o preview.mp4
-
-# Snapshot for visual QA
-hyperframes snapshot --at "1.0,3.0,5.0,7.0"
-
-# Publish to hyperframes.dev for review
-npx hyperframes publish
-```
-
-**Catalog preview image** — For the default PNG preview, save your snapshot at `docs/images/catalog/{kind}/{name}.png` in the repository checkout (`{kind}` is `blocks` or `components`). After upload, the catalog serves it from `https://static.heygen.ai/hyperframes-oss/docs/images/catalog/{kind}/{name}.png`. If `registry-item.json` declares `preview`, the card uses its `poster` URL; a `preview` without `poster` has no image fallback.
-
-- **HeyGen internal contributors:** run `scripts/upload-docs-images.sh` from the repository root (requires AWS profile `engineering-767398024897`)
-- **External contributors:** attach the preview MP4 to your PR description. A maintainer will generate and upload the catalog image before merging.
-
-### Step 6: Ship
-
-**All steps are required. Missing any one produces a broken catalog entry.**
-
-`{kind}` is `blocks` or `components` depending on what you built in Step 1.
-
-```bash
-# 1. Create branch
-git checkout -b feat/registry-{name}
-
-# 2. Format HTML
-npx oxfmt registry/{kind}/{name}/*.html
-
-# 3. Regenerate registry/registry.json from the item directories.
-#    Do not hand-edit it: an entry added by hand survives until the next
-#    regeneration and then vanishes, and one left behind for a directory that
-#    no longer exists is worse, because `hyperframes add <name>` resolves the
-#    name and then fails on missing files.
-npx tsx scripts/generate-registry-items.ts
-
-# 4. Generate catalog docs page
-npx tsx scripts/generate-catalog-pages.ts
-
-# 5. Publish to hyperframes.dev so reviewers can preview
-npx hyperframes publish
-
-# 6. Stage everything
-git add registry/{kind}/{name}/ registry/registry.json docs/catalog/
-
-# 7. Commit
-git commit -m "feat(registry): add {name} — {one sentence}"
-
-# 8. Push and open PR with hyperframes.dev link
-git push origin feat/registry-{name}
-gh pr create --title "feat(registry): {name}" --body "preview: {hyperframes.dev-url}"
-```
-
-**If you don't have a GitHub account:** you need one to open a PR. Sign up at https://github.com/signup, then run `gh auth login`.
-
-## Quality Gate
-
-- [ ] `hyperframes lint` → 0 errors
-- [ ] `hyperframes check` → 0 console errors
-- [ ] `npx oxfmt --check` passes
-- [ ] `registry/registry.json` updated with new entry
-- [ ] `scripts/generate-catalog-pages.ts` run (docs page generated)
-- [ ] `npx hyperframes publish` run (claim your project URL)
-- [ ] Preview MP4 attached to PR (external) or catalog PNG uploaded (internal)
-- [ ] All IDs unique and prefixed

.claude/skills/hyperframes-registry/references/demo-html-pattern.md

@@ -1,54 +0,0 @@
-# The demo.html Convention
-
-## Why components ship demo.html
-
-Every component in the registry ships a companion `demo.html` file alongside its snippet. The demo serves two purposes:
-
-1. **Preview fixture** — the CI preview pipeline renders the demo to generate thumbnail images and preview videos for the catalog docs page.
-
-2. **Usage example** — the demo shows the component effect applied to representative content, serving as a working reference.
-
-## Demo structure
-
-A demo is a complete, standalone HTML composition:
-
-```html
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=1920, height=1080" />
-    <title>Component Name — Demo</title>
-    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-    <style>
-      /* reset + canvas size */
-    </style>
-  </head>
-  <body>
-    <div data-composition-id="<name>-demo" data-width="1920" data-height="1080" data-duration="N">
-      <!-- Demo content showing the effect -->
-      <!-- Component snippet inlined here -->
-    </div>
-    <script>
-      // GSAP timeline demonstrating the effect
-      window.__timelines = window.__timelines || {};
-      window.__timelines["<name>-demo"] = tl;
-    </script>
-  </body>
-</html>
-```
-
-Key conventions:
-
-- `data-composition-id` is `<component-name>-demo` to avoid collisions
-- The demo is self-contained — all CSS and JS from the snippet is inlined
-- The GSAP timeline is registered on `window.__timelines`
-- Duration should be long enough to showcase the effect (typically 5-8 seconds)
-
-## Blocks don't need demo.html
-
-Blocks are already standalone compositions that can be rendered directly. Only components need the demo wrapper.
-
-## Demos are not installed
-
-The `demo.html` is NOT installed by `hyperframes add` — it exists only in the registry for preview generation and as a reference.

.claude/skills/hyperframes-registry/references/discovery.md

@@ -1,217 +0,0 @@
-# Registry discovery
-
-<!-- registry-items: allow=data-composition-id,data-start,data-track-index -->
-
-## Use the catalog command first
-
-```bash
-npx hyperframes catalog
-npx hyperframes catalog --type block
-npx hyperframes catalog --type component
-npx hyperframes catalog --type block --tag social
-npx hyperframes catalog --json
-npx hyperframes catalog --human-friendly
-```
-
-- Default output is a readable table. It does not install anything.
-- `--type` accepts `block` or `component`; `--tag` may narrow either result.
-- `--json` is the deterministic agent and CI surface. Select a name, then run `npx hyperframes add <name>`.
-- `--human-friendly` opens a picker and installs the selected item immediately.
-
-## Read the registry manifest as a fallback
-
-When the CLI is unavailable, the top-level `registry.json` lists all available items:
-
-```bash
-curl -s https://raw.githubusercontent.com/heygen-com/hyperframes/main/registry/registry.json
-```
-
-Each entry has `name` and `type` (`hyperframes:example`, `hyperframes:block`, or `hyperframes:component`).
-
-## Reading an item's manifest
-
-Each item has a `registry-item.json` with full metadata:
-
-```
-<base>/<type-dir>/<name>/registry-item.json
-```
-
-Where `<type-dir>` is `examples`, `blocks`, or `components`.
-
-## Item manifest fields
-
-| Field                  | Type     | Required | Description                                    |
-| ---------------------- | -------- | -------- | ---------------------------------------------- |
-| `name`                 | string   | yes      | Kebab-case identifier                          |
-| `type`                 | string   | yes      | `hyperframes:block` or `hyperframes:component` |
-| `title`                | string   | yes      | Human-readable title                           |
-| `description`          | string   | yes      | One-line description                           |
-| `tags`                 | string[] | no       | Filter tags (e.g., `["data", "chart"]`)        |
-| `dimensions`           | object   | blocks   | `{ width, height }` — blocks only              |
-| `duration`             | number   | blocks   | Duration in seconds — blocks only              |
-| `files`                | array    | yes      | Files to install (`path`, `target`, `type`)    |
-| `registryDependencies` | string[] | no       | Other registry items this depends on           |
-
-## Available items
-
-### Blocks
-
-For an always-current list run `npx hyperframes catalog --type block`. **The search is the source of truth; the tables below are a hand-maintained sample and under-cover by design** — they group 97 of the registry's 180 blocks by category, so a block missing from them is not evidence the registry lacks it. Only an empty `npx hyperframes catalog --query "<what you want>" --json` is that evidence. Do not grow these tables toward the full set; search instead. **Block name ≠ shader name**: shader-transition blocks (e.g. `domain-warp-dissolve`) wrap a HyperShader runtime whose internal name omits the `-dissolve`/`-warp` suffix — see the showcase HTML installed alongside the block for the canonical name.
-
-#### Shader transitions (14)
-
-Single-shader blocks; each installs one HyperShader runtime + a showcase composition. Use ≤2 per video.
-
-| Name                     | Description                                                              |
-| ------------------------ | ------------------------------------------------------------------------ |
-| `chromatic-radial-split` | Chromatic aberration radial split                                        |
-| `cinematic-zoom`         | Dramatic zoom blur                                                       |
-| `cross-warp-morph`       | Cross-warped morphing                                                    |
-| `domain-warp-dissolve`   | Fractal noise domain warping                                             |
-| `flash-through-white`    | White flash crossfade (rarely a neutral default — see SKILL.md guidance) |
-| `glitch`                 | Digital glitch artifacts                                                 |
-| `gravitational-lens`     | Gravitational lensing distortion                                         |
-| `light-leak`             | Cinematic light leak overlay                                             |
-| `ridged-burn`            | Ridged turbulence burn                                                   |
-| `ripple-waves`           | Concentric ripple wave distortion                                        |
-| `sdf-iris`               | Signed-distance-field iris reveal                                        |
-| `swirl-vortex`           | Swirling vortex distortion                                               |
-| `thermal-distortion`     | Heat-haze thermal distortion                                             |
-| `whip-pan`               | Fast camera whip-pan                                                     |
-
-#### Transition galleries (13)
-
-Showcase compositions grouping multiple CSS / GSAP transition styles by family. Use as reference for picking a CSS scene transition; not meant to embed as-is.
-
-| Name                      | Description                         |
-| ------------------------- | ----------------------------------- |
-| `transitions-3d`          | 3D perspective flip and rotate      |
-| `transitions-blur`        | Blur-based scene transitions        |
-| `transitions-cover`       | Cover / uncover slide               |
-| `transitions-destruction` | Destructive break-apart             |
-| `transitions-dissolve`    | Dissolve and fade                   |
-| `transitions-distortion`  | Warp and distortion                 |
-| `transitions-grid`        | Grid-based tile                     |
-| `transitions-light`       | Light-based glow and flash          |
-| `transitions-mechanical`  | Mechanical shutter and iris         |
-| `transitions-other`       | Misc creative (VHS, gravity, morph) |
-| `transitions-push`        | Push and slide                      |
-| `transitions-radial`      | Radial wipe and reveal              |
-| `transitions-scale`       | Scale and zoom                      |
-
-#### Liquid Glass (7)
-
-WebGPU + html-in-canvas frosted-glass surfaces. **Require Brave / Chrome canary** with WebGPU enabled — set `PRODUCER_HEADLESS_SHELL_PATH` to point at the browser; engine auto-passes `--enable-unsafe-webgpu`. See `/hyperframes` → `references/runtimes.md`.
-
-| Name                        | Description                                                                             |
-| --------------------------- | --------------------------------------------------------------------------------------- |
-| `ios26-liquid-glass`        | 3D iPhone (GLTF) + iOS 26 home screen, glass app icons, shader wallpaper, notifications |
-| `macos-tahoe-liquid-glass`  | 3D MacBook (GLTF) + macOS Tahoe-style desktop, glass menu bar, Finder, dock             |
-| `liquid-glass-widgets`      | Frosted stat cards, showcase panel, pill chips over aurora shader                       |
-| `liquid-glass-notification` | Frosted notification cards floating over aurora shader                                  |
-| `vfx-liquid-glass`          | Bare VFX composition shell for liquid-glass effects                                     |
-
-#### VFX (6)
-
-HTML-in-canvas + WebGL composition blocks. See `/hyperframes` → `references/runtimes.md` for the underlying runtimes.
-
-| Name                    | Description                                                                                             |
-| ----------------------- | ------------------------------------------------------------------------------------------------------- |
-| `vfx-iphone-device`     | GLTF iPhone 15 Pro Max + MacBook Pro with live HTML-in-canvas screens, glass-lens morph, 360° turntable |
-| `vfx-liquid-background` | Organic liquid sim — vertex displacement on subdivided plane, HTML floats above                         |
-| `vfx-magnetic`          | VFX shell (magnetic field-line treatment)                                                               |
-| `vfx-portal`            | VFX shell (portal reveal)                                                                               |
-| `vfx-shatter`           | VFX shell (shatter into fragments)                                                                      |
-| `vfx-text-cursor`       | Cursor glow + chromatic shadow rays + spectral edges on a black stage                                   |
-
-#### Showcases (6)
-
-Story-driven showcase compositions — narrated YouTube-style inserts. Most include bundled SFX.
-
-| Name                       | Description                                                       |
-| -------------------------- | ----------------------------------------------------------------- |
-| `app-showcase`             | Three floating smartphone screens, fitness app product showcase   |
-| `apple-money-count`        | Counter $0 → $10,000, green flash, money-icon burst, SFX          |
-| `blue-sweater-intro-video` | Warm AI-creator intro resolving into an X follow card             |
-| `north-korea-locked-down`  | Map zoom with red scribble circle, locked-down pop-up label       |
-| `nyc-paris-flight`         | Map animation, plane NYC → Paris, marker circle, landing pop, SFX |
-| `vpn-youtube-spot`         | App-store scroll, VPN install flow, SFX                           |
-
-#### Maps + data viz (8)
-
-D3 + GSAP animated geographies and charts.
-
-| Name                               | Description                                                                                        |
-| ---------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `us-map`                           | US choropleth, staggered state reveals, value labels, gradient legend                              |
-| `us-map-bubble`                    | US bubble map — proportional city markers, callouts, connection lines                              |
-| `us-map-flow`                      | US flow map — animated origin-destination arcs                                                     |
-| `us-map-hex`                       | US hex-grid map — each state as equal-weight hex with data fill                                    |
-| `spain-map`                        | Spain choropleth by autonomous community — D3 conic conformal                                      |
-| `world-map`                        | World choropleth + rotating globe inset, D3 Natural Earth                                          |
-| `data-chart`                       | Animated bar + line chart, staggered reveal, NYT-style typography                                  |
-| `flowchart` / `flowchart-vertical` | Decision tree, SVG connectors, sticky-note nodes, cursor + typing correction (vertical = portrait) |
-
-#### Social overlays (7)
-
-Platform-recognizable UI overlays. Stamp on top of a beat or use as a beat closer.
-
-| Name                 | Description                                      |
-| -------------------- | ------------------------------------------------ |
-| `instagram-follow`   | Profile card + follow button                     |
-| `tiktok-follow`      | Profile card + follow button                     |
-| `yt-lower-third`     | YouTube subscribe lower third with avatar        |
-| `x-post`             | X/Twitter post card with engagement metrics      |
-| `reddit-post`        | Post card with upvotes and comments              |
-| `spotify-card`       | Now-playing card with album art and progress bar |
-| `macos-notification` | macOS-style banner with app icon and message     |
-
-#### Branding + 3D UI (2)
-
-| Name           | Description                                                         |
-| -------------- | ------------------------------------------------------------------- |
-| `logo-outro`   | Piece-by-piece logo assembly, glow bloom, tagline fade-in, URL pill |
-| `ui-3d-reveal` | Perspective 3D reveal for UI elements                               |
-
-#### Code snippets (24)
-
-A code/terminal window that **types a code or shell session per-character**. Theme = visual chrome only; structure, wiring, and install are identical across all 24 — pick one by name, wire it like any block (`data-composition-id` + `data-start` + `data-track-index`, see `wiring-blocks.md`). Two chrome families:
-
-**Apple Terminal (12)** — macOS Terminal.app window typing a shell session. Profile = window colors:
-
-| Name                              | Look                             |
-| --------------------------------- | -------------------------------- |
-| `code-snippet-apple-terminal-pro` | Black bg, grey text, lime cursor |
-
-#### Code Animations (9)
-
-The richer, motion-first counterpart to the static `code-snippet-*` window themes above: each is a self-contained 1920×1080 block (~5–8s) with a paused, deterministic GSAP timeline that _animates_ code — typing, diffing, morphing, spotlighting, or GPU hero reveals — rather than typing a fixed snippet inside editor/terminal chrome. **Reuse-first**: `npx hyperframes add <name>`, then customize the baked code/diff content in place; hand-author only when no block covers the motion you need.
-
-**DOM / text reveal (6):**
-
-| Name             | Description                                                                                                                |
-| ---------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| `code-typing`    | Token-streamed typing reveal, caret tracks the frontier (no CSS animation) — live-coding on screen                         |
-| `code-diff`      | An edit shown as a colored diff: removed lines collapse red, added expand green — before/after at line level               |
-| `code-morph`     | One snippet transforms into another, tokens glide between positions (Shiki Magic Move) — a refactor / one state to another |
-| `code-highlight` | A highlight band sweeps a target line while surrounding context dims — spotlight one line                                  |
-| `code-scroll`    | Camera scrolls a long file to center + spotlight a target line — walk through a real module                                |
-
-**GPU / WebGL hero reveals (3):** heavier, for a title-card / hero code moment.
-
-| Name                     | Description                                                                                                     |
-| ------------------------ | --------------------------------------------------------------------------------------------------------------- |
-| `code-3d-extrude`        | Syntax-highlighted code on a lit beveled 3D slab that rotates through real space and settles (true WebGL depth) |
-| `code-shader-dissolve`   | Code resolves out of seeded noise with a chromatic dissolve front + edge glow, then holds crisp                 |
-| `code-particle-assemble` | Thousands of GPU points fly to the exact glyph pixels and resolve into readable syntax-highlighted code         |
-
-### Components
-
-| Name                 | Description                                                                                               | Tags                                             |
-| -------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
-| `grain-overlay`      | Animated film grain texture overlay                                                                       | texture, grain, overlay, film                    |
-| `shimmer-sweep`      | CSS gradient light sweep for AI accents                                                                   | text, shimmer, highlight, effect                 |
-| `morph-text`         | Gooey text morph cycling an editable word list (SVG threshold + GSAP blur)                                | text, text-effect, typography, morph, gooey      |
-| `grid-pixelate-wipe` | Grid dissolve transition between scenes                                                                   | transition, wipe, grid, pixelate                 |
-| `parallax-zoom`      | Center card scales up to fill the frame while siblings parallax outward (single `--pz-progress` 0→1)      | transition, zoom, parallax, grid, hero           |
-| `parallax-unzoom`    | Reverse of `parallax-zoom` — focus card shrinks from full frame as siblings parallax in (`--pu-progress`) | transition, reveal, unzoom, parallax, grid, hero |

.claude/skills/hyperframes-registry/references/install-locations.md

@@ -1,45 +0,0 @@
-# Install Locations
-
-## Default paths
-
-| Item type | Default install path                  | Configured by                       |
-| --------- | ------------------------------------- | ----------------------------------- |
-| Block     | `compositions/<name>.html`            | `hyperframes.json#paths.blocks`     |
-| Component | `compositions/components/<name>.html` | `hyperframes.json#paths.components` |
-
-## How path remapping works
-
-The `target` field in each item's `registry-item.json` specifies a default install path. The `add` command remaps the prefix based on `hyperframes.json#paths`:
-
-- Block targets starting with `compositions/` get remapped to `<paths.blocks>/`
-- Component targets starting with `compositions/components/` get remapped to `<paths.components>/`
-
-## hyperframes.json
-
-Created automatically by `hyperframes init`. If it doesn't exist when you run `add`, the CLI creates it with defaults:
-
-```json
-{
-  "$schema": "https://hyperframes.heygen.com/schema/hyperframes.json",
-  "registry": "https://raw.githubusercontent.com/heygen-com/hyperframes/main/registry",
-  "paths": {
-    "blocks": "compositions",
-    "components": "compositions/components",
-    "assets": "assets"
-  }
-}
-```
-
-## Custom layouts
-
-To install blocks into a `scenes/` directory instead of `compositions/`:
-
-```json
-{
-  "paths": {
-    "blocks": "scenes"
-  }
-}
-```
-
-Then `hyperframes add data-chart` writes to `scenes/data-chart.html` instead of `compositions/data-chart.html`. The snippet output reflects the remapped path.

.claude/skills/hyperframes-registry/references/placeholder-material.md

@@ -1,149 +0,0 @@
-# Placeholder material
-
-Registry items ship with stand-in content: a rectangle where the user's screenshot goes, a
-bar where their number goes, a chip where their teammate's face goes. That stand-in is
-**placeholder material**, and it is monochrome. No hue, no colour ramps, no purple-to-blue
-diagonal fill.
-
-The rule exists because placeholder colour is always arbitrary. A violet card, a blue logo
-tile and a rainbow avatar row assert a brand the composition does not have; across 250 items
-the same three arbitrary hues become the catalog's identity instead of the author's. Value
-says everything colour was saying here, and says it truthfully.
-
-## The one rule
-
-> Placeholder content carries no hue. It is built from four alpha steps of the composition's
-> own ink over the composition's own ground, plus a hairline. Accent marks one element per
-> composition, and never a placeholder.
-
-## The ramp
-
-Four fill steps and a hairline. All of them are the ink at an alpha, so the ramp inverts for
-free on dark themes and needs no second table.
-
-| Step   | Ink alpha | What it is for                                                               |
-| ------ | --------- | ---------------------------------------------------------------------------- |
-| `ink`  | 100%      | Real content: headline, number, label. Not placeholder.                      |
-| `L1`   | 72%       | The subject. Chart bars, a filled logo mark, a play glyph, a front avatar.   |
-| `L2`   | 45%       | Support. A comparison series, avatars behind the front one, secondary icons. |
-| `L3`   | 18%       | Media fill and skeleton text lines. "Content lives here."                    |
-| `L4`   | 8%        | Recessed plate interiors. The tray a card sits in.                           |
-| `hair` | 14%       | Every 1px boundary. Replaces the separation a gradient edge was doing.       |
-
-Write them the way the file already writes colour:
-
-```css
-/* theme-token primitives (--fg / --surface available) */
-background: color-mix(in srgb, var(--fg, #f8fafc) 18%, transparent);
-
-/* fixed-palette ports (local --hf-ink, no theme tokens) */
-background: rgba(17, 24, 39, 0.18);
-```
-
-**Four steps, not eight.** Grays go muddy when adjacent steps sit close together, so every
-step is at least 1.6x the alpha of the one below it. Reaching for a fifth value is the signal
-that the layout, not the palette, needs the work. Snap to the nearest step instead.
-
-Contrast, measured against both shipped grounds (`neutral` light `#fcfcfd`, `bold` dark
-`#1b1230`): L1 is 7.7:1 / 8.9:1, L2 is 3.1:1 / 4.4:1, L3 and L4 are below 3:1 by design.
-Therefore **text never goes below L1**, and L2 is the floor for any graphic a viewer has to
-compare (a chart series, a state indicator). L3 and L4 are for surfaces only.
-
-## Depth without colour
-
-In priority order. Reach for the first one that works.
-
-1. **Value step.** Nothing sits on the same step as its ground. One full step of separation
-   minimum. This alone resolves most stacking.
-2. **Hairline.** `1px` of `hair` on every plate boundary. A border separates two surfaces more
-   cleanly than a gradient ever did, and survives video compression that eats a soft edge.
-3. **Negative space.** Padding is elevation. A plate with `--space-2` inside it reads as raised
-   without any fill difference at all.
-4. **Texture, at the finest grain only.** A `repeating-linear-gradient` at `L3`-and-below,
-   period 2-4px, achromatic. This is the one thing value cannot say: a flat gray rectangle
-   reads as an empty box, the same rectangle finely hatched reads as a surface with content on
-   it. Use it to mark media, nothing else.
-
-Shadows are allowed and must be achromatic and diffuse: `0 Npx 3Npx rgba(0,0,0,0.18)`. Never a
-coloured glow; a glow is an accent wearing a shadow's clothes.
-
-## Reading each kind in black and white
-
-A gray rectangle has to still say _screen_ and not _image_. Shape, aspect, glyph and texture
-carry the meaning that hue was carrying badly.
-
-| Kind            | Signature                                                                                                                                |
-| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| Screen / device | Device aspect + `--radius` + `hair` + scanline texture at L3 + inset vignette. The chrome is the signal; the fill is L3 and stays quiet. |
-| Video footage   | Screen signature plus a centred play triangle in a ring at L1. The glyph is what makes it video rather than a static screen.             |
-| Image           | 4:3 or 3:2 plate at L3 with a horizon-and-disc glyph at L2, offset toward a corner, never centred. Offset is what reads as "photo".      |
-| Card            | Plate at L4, `hair` border, two skeleton rules at L3 (100% and 62% width). Two rules of unequal length is the whole idiom.               |
-| Avatar / person | **Circle** at L2 with initials knocked out in the ground colour. Stacks differ by step (L1 front, L2, L3), never by hue.                 |
-| Logo / brand    | **Rounded square** at L1 with the mark knocked out in the ground colour. Every mark on the same step: a logo wall means "many, equal".   |
-| Chart series    | Flat fills. Primary series L1, comparison series L2, gridlines `hair`. Never a gradient inside a bar.                                    |
-| Text block      | Rounded rules at L3, widths 100 / 86 / 62%. The ragged right edge is what reads as prose.                                                |
-
-Circle means person, rounded square means app or brand. Keeping those two shapes distinct is
-what lets both live at the same value step without ambiguity.
-
-Why no gradient inside a chart bar: a vertical light-to-dark fill makes every bar lighter at
-its top, so the tallest bar reads _palest_ exactly where the eye lands to compare heights. The
-decoration contradicts the data. Flat fills are both plainer and more honest.
-
-## Accent
-
-The accent enum stays. `green` rides `--brand`, `blue` rides `--accent`, `violet` rides
-`--accent-2`, exactly as before, and every declared `accent` or `tone` variable keeps working
-unchanged. What changes is where accent is allowed to land:
-
-> Accent marks at most **one** element per composition, and only where the accent _is_ the
-> meaning: the selected tier, the current step, the figure a count-up lands on, the ink of a
-> stroke being drawn. Placeholder content is never accent-coloured.
-
-Fixed-palette ports have no theme tokens, so they get the accent through their own
-variable with a neutral fallback:
-
-```css
-/* was: --hf-accent: #2563eb; */
---hf-accent: var(--accent, #18181b);
-```
-
-Unthemed, the item renders in pure black and white. Drop it into a themed composition and
-the author's accent lands on that one element and nowhere else. Where the accent is chosen by
-an enum, the lookup table maps to tokens, never to hex: `green` to `var(--brand, <neutral>)`,
-`blue` to `var(--accent, <neutral>)`, `violet` to `var(--accent-2, <neutral>)`. The enum's
-declared options and default are unchanged, so no mount breaks.
-
-"One element" means one role, not one node: an app mark repeated on three devices of the same
-mock is still one element.
-
-Killing accent outright was the alternative and it is worse. Accent is already load-bearing in
-exactly the cases where it is correct, and it is the only hook an author has for their own
-brand; removing it would push those cases into value tricks for a job one hue does better with
-one element. The failure was never that accent existed, it was that accent had become the
-default fill for every placeholder. Capping it at one element fixes the failure with no
-variable migration.
-
-## Gradients that stay
-
-The ban is on **hue-carrying fills**, not on the CSS function. These are material, not
-placeholder, and flattening them breaks the thing the item exists to do:
-
-- **Physical surfaces** — device bezels, brushed metal, glass, a screen's inner vignette.
-- **Sheens and sweeps** — `linear-gradient(90deg, transparent, rgba(255,255,255,0.75), transparent)`
-  driven across an element. That is motion, not decoration.
-- **Scrims and vignettes** — `rgba(0,0,0,α)` ramps that buy text contrast over media.
-- **Effects whose subject is the gradient** — aurora, liquid glass, chromatic aberration,
-  grain fields, shader transitions. The gradient is the product.
-
-All four are achromatic or physically motivated. If a gradient is neither, it is placeholder
-slop and it goes.
-
-## Checklist
-
-- [ ] No `#7c3aed`, `#2563eb`, `#6366f1`, `#8b5cf6`, `#a855f7`, `#4f46e5` anywhere in the item.
-- [ ] Every placeholder fill is `ink` at 72 / 45 / 18 / 8 / 14 percent, and nothing else.
-- [ ] At most one accent-coloured element, and it means something.
-- [ ] Text sits at L1 or above; L3 and L4 carry no text.
-- [ ] Every remaining gradient is a surface, a sweep, a scrim, or the effect itself.
-- [ ] `hyperframes check` passes, and a rendered frame was looked at.

.claude/skills/hyperframes-registry/references/search.md

@@ -1,67 +0,0 @@
-# Searching the catalog
-
-How `hyperframes catalog` ranks, what its `--json` envelope means, offline behaviour, and reporting a miss.
-
-Use the CLI as the primary discovery surface. **Search by intent before browsing:** the registry holds more items than you can scan by eye, so listing them and matching on names or tags is the slow path, and it fails whenever the author's wording differs from yours.
-
-```bash
-# Rank the whole catalog against what the beat should do
-npx hyperframes catalog --query "reveal a headline one line at a time"
-npx hyperframes add caption-clip-wipe
-```
-
-Search is local and sends nothing. By default it ranks on vocabulary shared with the item's name, title and description, so it only finds items that reuse your words; `--on-device` ranks by meaning instead, after a one-time model download. With `--json` the envelope names which tier answered, so check that rather than assuming a ranking happened.
-
-**Always query in English, whatever language the video is in.** The catalog is written in English and both tiers index it that way (the on-device model is English-only too). A query in another script produces no searchable terms and returns nothing at all. This is easy to get wrong on a Japanese or Chinese project, where the brief, the captions and the narration are all in that language and the query naturally follows: describe the _move_ in English, then write the on-screen copy in whatever language the video needs. If a query does come back with `No searchable words in query`, that is this rule, not a missing component, and it is not worth a gap report.
-
-Installability is applied after ranking, not before it: a name the vectors carry but this registry cannot serve is dropped from the results and counted in `dropped`, so a non-zero `dropped` means the two are different generations. The offline tier, the consent gate and refreshing a stale index are under "Search tiers" below.
-
-To browse or filter instead of search:
-
-```bash
-npx hyperframes catalog
-npx hyperframes catalog --type block
-npx hyperframes catalog --type component
-npx hyperframes catalog --type block --tag social
-npx hyperframes catalog --json
-npx hyperframes catalog --human-friendly
-```
-
-The normal table and `--json` modes only list matches; install a selected name with `hyperframes add <name>`. `--human-friendly` opens an interactive picker and installs the selected item immediately. In CI or agent workflows, prefer `--json` followed by an explicit `add`.
-
-### Report what the catalog does not have
-
-When the search comes back and nothing in it does the job, say so before you hand-author the move:
-
-```bash
-npx hyperframes feedback --search-miss "<the query you ran>" --wanted "<the move you needed>" --tier <the tier that answered>
-```
-
-`catalog --query` prints this line for you, pre-filled, and `--json` carries it as `report_gap` — so it is already in hand at the moment you decide nothing fits.
-
-**Report whenever nothing in the results does the job, on either tier.** Do not wait for the on-device tier to have answered: it needs a consented 33 MB download, so an agent run is on `words` unless it explicitly opted in, and gating on `on-device` would silence almost every report. The `--tier` value rides along so a vocabulary miss stays distinguishable from a meaning miss when these are read. Describe the effect you wanted, not the item name you imagined: what comes back is a list of moves worth building, and a report naming a non-existent item teaches nothing. This is the only path that sends a query anywhere, which is exactly why it is a separate deliberate command rather than something the search does on its own. It carries no rating and never lands in the rating metric.
-
-This is the whole demand signal for the catalog. Skipping it means the gap you hit gets guessed at from install counts instead, which cannot see a move nobody could install.
-
-If the CLI cannot reach the configured registry, inspect the raw manifest as a fallback:
-
-```bash
-curl -s https://raw.githubusercontent.com/heygen-com/hyperframes/main/registry/registry.json
-```
-
-A registry the CLI cannot reach does **not** empty the catalog for **discovery**: a previously fetched manifest keeps serving past its 24h refresh window whenever revalidation fails, so `catalog` and `catalog --query` still list and rank against the last copy on disk.
-
-**`add` still needs the network, even for an item you installed yesterday.** Only manifests are cached; the item's actual files are fetched on every install. So offline you can search, and you can see what an item is, but installing it fails at the file fetch. Do not promise a user an offline install.
-
-Each item's `registry-item.json` contains: name, type, title, description, tags, dimensions (blocks only), duration (blocks only), and file list.
-
-See [discovery.md](./discovery.md) for details on filtering by type and tags.
-
-## Search tiers
-
-- **Search the catalog before writing motion by hand.** `npx hyperframes catalog --query "<the beat, in plain English>"`. Search is entirely local: there is no hosted tier, no account, and the query text is never sent anywhere. By default it ranks on vocabulary shared with the item's name, title, description and tags, which misses any phrasing that does not reuse the catalog's own wording. Add `--on-device` to rank by meaning instead (see the offline tier below).
-- **Query in English even when the video is not.** Both tiers index an English catalog, so a query in another script produces no searchable terms and returns nothing. Describe the move in English; the on-screen copy stays in whatever language the video needs. `No searchable words in query` means exactly this and is not a missing component, so do not report it as a catalog gap.
-- **Read which tier answered; never infer it from results appearing.** With `--json` the envelope carries `query`, `tier` (`on-device` or `words`), `tier_detail`, `dropped`, `unindexed`, `shown`, `total` and `results`, plus `top_score` when the answering tier produces one and `warnings` when a tier was asked for and could not run, or when a search returned nothing and a better tier is still waiting on someone's consent. A weak result on `words` is expected; the same result on `on-device` is a bug. `top_score` is on-device only and has no threshold behind it: the ranker returns the whole catalog in some order for every query, so read it as evidence rather than as a pass or fail.
-- **`dropped` and `unindexed` are opposite skews between the registry and the on-device index, and rewording the query fixes neither.** `dropped` counts ranked names this registry cannot install, so the strongest matches are the ones being lost. `unindexed` counts registry moves the index cannot see at all, which no query can ever return. Refreshing the registry is not the answer to either: its manifest carries a 24h TTL and heals itself, while the vectors are a separately published artifact fetched into `~/.hyperframes/catalog/`. Re-running with `--on-device` refetches that index when `unindexed` is above zero, so that is the remedy to hand the user. A pure over-coverage skew (`dropped` above zero while `unindexed` is zero) does not trigger the refetch; clearing `~/.hyperframes/catalog/` is the only way out of that one. Both counts are of names rather than of results, so either can exceed `total`.
-- **When a search comes back with nothing worth installing, say so.** `npx hyperframes feedback --search-miss "<the query you ran>" --wanted "<the move you needed>" --tier <the tier that answered>`. You do not have to assemble that line: `catalog --query` prints it pre-filled, and every `--json` search envelope carries it as `report_gap` with the query and tier already correct — fill in `--wanted` and send. This is the only path that sends a query anywhere, and it is a separate deliberate command precisely so plain `catalog --query` keeps its promise of sending nothing. **Report on either tier**, whenever the results do not do the thing; do not hold out for the on-device tier, which needs a consented 33 MB download and is therefore off in most agent runs — waiting for it means never reporting at all. The tier rides along in the report, so a vocabulary miss stays distinguishable from a meaning miss without you having to judge which one you hit. What comes back is a list of moves the catalog does not have yet, read directly rather than guessed from install counts, so the phrasing that matters is the effect you wanted, not the item name you imagined. It carries no rating and never lands in the rating metric.
-- **Offer the offline tier; never enable it silently.** A one-time ~33 MB download (a quantized ONNX build of `bge-small-en-v1.5` plus its tokenizer, pinned to a fixed revision) and the catalog vectors from the registry, both cached under `~/.hyperframes/`, neither added to the project or any package. Once cached it ranks by meaning with nothing sent. Say the size out loud and let the person decide, then pass `--on-device` (with `-y` to skip the prompt) once they agree. The interactive offer only fires on a TTY. Under `--json` there is no prompt, but a search that found nothing puts the same ask in `warnings`, so read that array and put the decision to the user yourself. When the person asks what the download is, why this model, or what leaves the machine, point them to https://hyperframes.heygen.com/developers/catalog-search.

.claude/skills/hyperframes-registry/references/templates.md

@@ -1,417 +0,0 @@
-# Contribute Templates
-
-Copy-paste starter templates for each component type. These embed the proven patterns that pass `lint` and `check`.
-
-## Caption Template
-
-```html
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <link
-      href="https://fonts.googleapis.com/css2?family=Montserrat:wght@800;900&display=swap"
-      rel="stylesheet"
-    />
-    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-    <style>
-      *,
-      *::before,
-      *::after {
-        margin: 0;
-        padding: 0;
-        box-sizing: border-box;
-      }
-      body {
-        background: #111;
-        overflow: hidden;
-      }
-      #root-BLOCKNAME {
-        position: relative;
-        width: 1920px;
-        height: 1080px;
-        overflow: hidden;
-        background: #111;
-      }
-      .cap-container {
-        position: absolute;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-      }
-      .cg {
-        position: absolute;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        gap: 32px;
-        max-width: 1700px;
-        overflow: visible;
-        opacity: 0;
-        visibility: hidden;
-      }
-      .cw {
-        font-family: "Montserrat", sans-serif;
-        font-weight: 900;
-        font-size: 128px;
-        color: #ffffff;
-        text-transform: uppercase;
-        line-height: 1;
-        display: inline-block;
-        -webkit-text-stroke: 3px rgba(0, 0, 0, 0.8);
-        paint-order: stroke fill;
-        text-shadow: 0 4px 12px rgba(0, 0, 0, 0.5);
-      }
-    </style>
-  </head>
-  <body>
-    <div
-      id="root-BLOCKNAME"
-      data-composition-id="BLOCKNAME"
-      data-start="0"
-      data-duration="9"
-      data-width="1920"
-      data-height="1080"
-    >
-      <div class="cap-container" id="cc-BLOCKNAME"></div>
-      <div
-        id="drv-BLOCKNAME"
-        class="clip"
-        data-start="0"
-        data-duration="9"
-        data-track-index="0"
-        style="position:absolute;width:1px;height:1px;opacity:0;pointer-events:none"
-      ></div>
-    </div>
-    <script>
-      (function () {
-        window.__timelines = window.__timelines || {};
-
-        // REPLACE with actual transcript data
-        var WORDS = [
-          { text: "Welcome", start: 0.3, end: 0.65 },
-          { text: "to", start: 0.65, end: 0.8 },
-          { text: "the", start: 0.8, end: 0.95 },
-          { text: "future", start: 0.95, end: 1.4 },
-          // ... add all words
-        ];
-
-        var GROUPS = [
-          { start: 0.3, end: 1.3, wordStart: 0, wordEnd: 3, text: "Welcome to the future" },
-          // ... add all groups
-        ];
-
-        var container = document.getElementById("cc-BLOCKNAME");
-
-        GROUPS.forEach(function (g, gi) {
-          var groupEl = document.createElement("div");
-          groupEl.id = "PREFIX-cg-" + gi;
-          groupEl.className = "cg";
-
-          for (var wi = g.wordStart; wi <= g.wordEnd; wi++) {
-            var wordEl = document.createElement("span");
-            wordEl.id = "PREFIX-cw-" + wi;
-            wordEl.className = "cw";
-            wordEl.textContent = WORDS[wi].text;
-            groupEl.appendChild(wordEl);
-          }
-
-          // Pretext overflow prevention
-          if (window.__hyperframes && window.__hyperframes.fitTextFontSize) {
-            var _fit = window.__hyperframes.fitTextFontSize(g.text.toUpperCase(), {
-              fontFamily: "Montserrat",
-              fontWeight: 900,
-              maxWidth: 1550,
-              baseFontSize: 128,
-              minFontSize: 48,
-            });
-            if (_fit.fontSize < 128) {
-              for (var _fi = 0; _fi < groupEl.children.length; _fi++) {
-                groupEl.children[_fi].style.fontSize = _fit.fontSize + "px";
-              }
-            }
-          }
-          container.appendChild(groupEl);
-        });
-
-        var tl = gsap.timeline({ paused: true });
-
-        GROUPS.forEach(function (g, gi) {
-          var groupEl = document.getElementById("PREFIX-cg-" + gi);
-
-          // SHOW — set opacity to 1 (never use tl.from with opacity:0 here)
-          tl.set(groupEl, { opacity: 1, visibility: "visible" }, g.start);
-
-          // ENTRANCE — customize this per style
-          tl.from(groupEl, { scale: 1.3, duration: 0.15, ease: "back.out(2)" }, g.start);
-
-          // KARAOKE — highlight each word
-          for (var wi = g.wordStart; wi <= g.wordEnd; wi++) {
-            var wordEl = document.getElementById("PREFIX-cw-" + wi);
-            tl.to(wordEl, { color: "#FFD700", scale: 1.1, duration: 0.06 }, WORDS[wi].start);
-            tl.to(wordEl, { color: "#FFFFFF", scale: 1, duration: 0.08 }, WORDS[wi].end);
-          }
-
-          // EXIT
-          tl.to(groupEl, { opacity: 0, scale: 0.9, duration: 0.1 }, g.end - 0.1);
-
-          // HARD KILL (mandatory)
-          tl.set(groupEl, { opacity: 0, visibility: "hidden" }, g.end);
-        });
-
-        window.__timelines["BLOCKNAME"] = tl;
-      })();
-    </script>
-  </body>
-</html>
-```
-
-**Replace checklist:**
-
-- `BLOCKNAME` → your block name (e.g., `cap-swoosh`)
-- `PREFIX` → short unique prefix for IDs (e.g., `sw`)
-- Font family, weight, size → your style's typography
-- Entrance animation → your style's entrance
-- Karaoke highlight → your style's active word treatment
-- Colors → your style's palette
-
----
-
-## VFX Template
-
-```html
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/three@0.147.0/build/three.min.js"></script>
-    <style>
-      *,
-      *::before,
-      *::after {
-        margin: 0;
-        padding: 0;
-        box-sizing: border-box;
-      }
-      body {
-        background: #030308;
-        overflow: hidden;
-      }
-      #root-BLOCKNAME {
-        position: relative;
-        width: 1920px;
-        height: 1080px;
-        overflow: hidden;
-        background: #030308;
-      }
-      #canvas-BLOCKNAME {
-        position: absolute;
-        top: 0;
-        left: 0;
-        width: 1920px;
-        height: 1080px;
-      }
-    </style>
-  </head>
-  <body>
-    <div
-      id="root-BLOCKNAME"
-      data-composition-id="BLOCKNAME"
-      data-start="0"
-      data-duration="10"
-      data-width="1920"
-      data-height="1080"
-    >
-      <canvas id="canvas-BLOCKNAME" width="1920" height="1080"></canvas>
-      <div
-        id="drv-BLOCKNAME"
-        class="clip"
-        data-start="0"
-        data-duration="10"
-        data-track-index="0"
-        style="position:absolute;width:1px;height:1px;opacity:0;pointer-events:none"
-      ></div>
-    </div>
-    <script>
-      (function () {
-        window.__timelines = window.__timelines || {};
-
-        // Seeded PRNG — NEVER use Math.random()
-        function mulberry32(a) {
-          return function () {
-            a |= 0;
-            a = (a + 0x6d2b79f5) | 0;
-            var t = Math.imul(a ^ (a >>> 15), 1 | a);
-            t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-            return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-          };
-        }
-        var rng = mulberry32(42);
-
-        var W = 1920,
-          H = 1080;
-        var canvas = document.getElementById("canvas-BLOCKNAME");
-        var renderer = new THREE.WebGLRenderer({ canvas: canvas, antialias: true });
-        renderer.setSize(W, H);
-        renderer.setPixelRatio(1);
-        renderer.toneMapping = THREE.ACESFilmicToneMapping;
-        renderer.toneMappingExposure = 1.1;
-
-        var scene = new THREE.Scene();
-        scene.background = new THREE.Color(0x030308);
-        var camera = new THREE.PerspectiveCamera(50, W / H, 0.1, 100);
-        camera.position.set(0, 0, 8);
-
-        // YOUR SCENE SETUP HERE
-        // - lights
-        // - geometry
-        // - materials
-
-        // State proxy — GSAP animates this, render reads it
-        var st = {
-          rotY: 0,
-          camZ: 8,
-          // add your animated properties
-        };
-
-        var tl = gsap.timeline({ paused: true });
-
-        // YOUR TWEENS HERE
-        tl.to(st, { rotY: Math.PI * 2, duration: 10, ease: "none" }, 0);
-
-        window.__timelines["BLOCKNAME"] = tl;
-
-        function renderScene() {
-          // Apply state to Three.js objects
-          camera.position.z = st.camZ;
-          // mesh.rotation.y = st.rotY;
-
-          renderer.render(scene, camera);
-        }
-
-        // Render via onUpdate — NO requestAnimationFrame
-        tl.eventCallback("onUpdate", renderScene);
-        renderScene();
-      })();
-    </script>
-  </body>
-</html>
-```
-
-**Replace checklist:**
-
-- `BLOCKNAME` → your block name (e.g., `vfx-chrome-blob`)
-- Scene setup → your geometry, lights, materials
-- State proxy → your animated properties
-- Tweens → your animation timeline
-- renderScene → apply state to your Three.js objects
-
----
-
-## registry-item.json Templates
-
-**For blocks:**
-
-```json
-{
-  "$schema": "https://hyperframes.heygen.com/schema/registry-item.json",
-  "name": "BLOCKNAME",
-  "type": "hyperframes:block",
-  "title": "Human-Readable Title",
-  "description": "One sentence: what it does and who uses it",
-  "dimensions": { "width": 1920, "height": 1080 },
-  "duration": 10,
-  "tags": ["category", "subcategory"],
-  "files": [
-    {
-      "path": "BLOCKNAME.html",
-      "target": "compositions/BLOCKNAME.html",
-      "type": "hyperframes:composition"
-    }
-  ]
-}
-```
-
-**For components** (no `dimensions` or `duration`):
-
-```json
-{
-  "$schema": "https://hyperframes.heygen.com/schema/registry-item.json",
-  "name": "COMPONENTNAME",
-  "type": "hyperframes:component",
-  "title": "Human-Readable Title",
-  "description": "One sentence: what it does",
-  "tags": ["category"],
-  "files": [
-    {
-      "path": "COMPONENTNAME.html",
-      "target": "compositions/components/COMPONENTNAME.html",
-      "type": "hyperframes:snippet"
-    }
-  ]
-}
-```
-
-Tags by category:
-
-- Captions: `captions`, `viral`, `professional`, `karaoke`, `minimal`
-- VFX: `three-js`, `particles`, `shader`, `gpu`
-- Transitions: `transition`, `shader`, `wipe`, `dissolve`
-- Blocks: `lower-third`, `social`, `title-card`, `data-viz`
-- Components: `effect`, `overlay`, `text-treatment`
-
----
-
-## Component Template
-
-```html
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-    <style>
-      *,
-      *::before,
-      *::after {
-        margin: 0;
-        padding: 0;
-        box-sizing: border-box;
-      }
-      body {
-        background: transparent;
-        overflow: hidden;
-      }
-      .COMPNAME-wrap {
-        position: absolute;
-        inset: 0;
-        overflow: hidden;
-        pointer-events: none;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="COMPNAME-wrap">
-      <!-- Your reusable effect/overlay here -->
-    </div>
-    <script>
-      (function () {
-        // Component snippet — no data-composition-id, no __timelines.
-        // The parent composition controls timing.
-        // Keep all class names and IDs prefixed with COMPNAME.
-      })();
-    </script>
-  </body>
-</html>
-```
-
-**Replace checklist:**
-
-- `COMPNAME` → your component name (e.g., `shimmer-sweep`)
-- Background should be `transparent` so it overlays cleanly
-- No `data-composition-id` or `window.__timelines` — the parent owns timing

.claude/skills/hyperframes-registry/references/wiring-blocks.md

@@ -1,61 +0,0 @@
-# Wiring Blocks
-
-Blocks are standalone compositions with their own `data-composition-id`, dimensions, duration, and GSAP timeline. Include them in a host composition using `data-composition-src` on a `<div>`.
-
-## Basic wiring
-
-After `hyperframes add data-chart`, wire it into your `index.html`:
-
-```html
-<div id="stage" data-composition-id="main" data-width="1920" data-height="1080" data-duration="20">
-  <video id="a-roll" src="video.mp4" data-start="0" data-duration="20" data-track-index="0"></video>
-
-  <!-- Block: appears at 2s, plays for 15s, on layer 1 -->
-  <div
-    data-composition-id="data-chart"
-    data-composition-src="compositions/data-chart.html"
-    data-start="2"
-    data-duration="15"
-    data-track-index="1"
-    data-width="1920"
-    data-height="1080"
-  ></div>
-</div>
-```
-
-## Required attributes
-
-| Attribute              | Description                                                          |
-| ---------------------- | -------------------------------------------------------------------- |
-| `data-composition-src` | Path to the block HTML file (relative to index.html)                 |
-| `data-composition-id`  | Unique ID matching the block's internal composition ID               |
-| `data-start`           | When the block appears in the host timeline (seconds)                |
-| `data-duration`        | How long the block plays (seconds, at most the block's own duration) |
-| `data-track-index`     | Layer ordering — higher numbers render in front                      |
-| `data-width`           | Block canvas width (match the block's dimensions)                    |
-| `data-height`          | Block canvas height (match the block's dimensions)                   |
-
-## Timeline coordination
-
-The block's internal GSAP timeline runs independently from the host timeline. The HyperFrames runtime loads the sub-composition, finds its `window.__timelines` registration, and seeks the block in sync with the host, offset by `data-start`. You do NOT need to reference the block's timeline in your host's GSAP code.
-
-## Positioning blocks
-
-To position a block in a specific area of the screen, add CSS:
-
-```html
-<div
-  data-composition-id="data-chart"
-  data-composition-src="compositions/data-chart.html"
-  data-start="2"
-  data-duration="15"
-  data-track-index="1"
-  data-width="1920"
-  data-height="1080"
-  style="position: absolute; right: 0; top: 0; width: 40%; height: 100%;"
-></div>
-```
-
-## Multiple blocks
-
-Add additional `<div data-composition-src="...">` siblings with non-overlapping or overlapping `data-start` values — each block's timeline is independent and seeked in sync by the runtime.

.claude/skills/hyperframes-registry/references/wiring-components.md

@@ -1,39 +0,0 @@
-# Wiring Components
-
-Components are effect snippets — HTML, CSS, and optionally JS that you merge directly into an existing composition. Unlike blocks, components have no standalone timeline; they participate in the host composition's timeline.
-
-## General process
-
-1. Run `hyperframes add <component-name>`
-2. Open the installed file (e.g., `compositions/components/grain-overlay.html`)
-3. Read the comment header for usage instructions
-4. Copy the parts into your host composition:
-   - **HTML elements** — inside your `<div data-composition-id="...">`
-   - **CSS styles** — into your composition's `<style>` block
-   - **JS setup** — into your composition's `<script>`, before your timeline code
-   - **Timeline calls** — into your GSAP timeline (if the component exposes them)
-
-## Example: grain-overlay (CSS-only, no timeline integration)
-
-```html
-<!-- Paste the overlay div into your composition -->
-<div
-  id="grain-overlay"
-  style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; z-index: 100;"
->
-  <div class="grain-texture"></div>
-</div>
-```
-
-Then paste the CSS keyframes and `.grain-texture` rule into your styles. No GSAP timeline calls needed — the grain animates via CSS `@keyframes`.
-
-## Example: shimmer-sweep (needs timeline integration)
-
-See `examples/add-component.md` for the full shimmer-sweep walkthrough (HTML wrapping, CSS, JS setup, and timeline call).
-
-## Key principles
-
-- Components inherit the host composition's dimensions and duration
-- Place component HTML at the appropriate z-index relative to your content
-- Read the comment header in each snippet for customizable values
-- Run `hyperframes lint` after wiring to catch structural issues

.claude/skills/hyperframes/SKILL.md

@@ -1,74 +0,0 @@
----
-name: hyperframes
-description: Read first to make, edit, animate or render any video with HyperFrames (HTML rendered to video), including launch films, explainers, music videos, charts, maps, vertical clips, title cards, captions and overlays. Holds the render contract, the work loop and what each kind of video needs.
----
-
-**Plugin installs:** Before setup or freshness commands, follow [plugin execution rules](references/plugin-installation.md) when this skill is inside a HyperFrames plugin.
-
-# HyperFrames
-
-HyperFrames renders HTML to video by seeking a paused timeline frame by frame, so every render is identical; the person edits the same files in the Studio preview. Use it unless another framework or a plain browser recording is asked for. Run the CLI as `npx hyperframes <command>` (`/hyperframes-cli`); at the start of a new video, `npx hyperframes usage --json` reports the person's remaining plan usage (say "unknown" when it is).
-
-`index.html` is the root composition: it declares the video's variables and mounts one scene per sub-composition from `compositions/`. Media and fonts live in `assets/`. A new project: `npx hyperframes init <dir>`. A website as the subject: `npx hyperframes capture <url> --json`.
-
-Build what was asked: no voiceover or captions and no new aspect ratio unless the request or the source calls for them; a film over ~15 s that tells something gets music and sound on its visible actions unless the person asked for silence (`references/sound.md`). A new video is 1920×1080 at 30 fps. A question, a hold or a loose idea gets an answer or a proposal, not an edit. Before hand-writing a named effect, transition, caption style, chart or card, search the registry (`/hyperframes-registry`). Any media (a presenter or avatar, footage, voice, music): `/media-use`, which says when HeyGen is needed and what is free. Show real things from their source (the product's screens, the brand's logo, a real place's imagery); draw only what has none.
-
-## Contract
-
-`npx hyperframes check --json` reports most violations with a `Fix:` line.
-
-1. Every timed element has `class="clip"`, `data-start` and `data-duration` in seconds, and shows over `[start, start + duration)`: land an end state just before its end. `data-track-index` is only a Studio lane; paint order is `z-index`.
-2. The video's length is the root's `data-duration`: overrun is cut, an early end holds the last frame.
-3. Each composition builds one paused timeline and registers it after its tweens: `window.__timelines["<data-composition-id>"] = tl`.
-4. No `Date.now()`, unseeded `Math.random()`, network fetches, timers or `repeat: -1`. Everything visible is a function of timeline time.
-5. Never tween `display`, `visibility` or `autoAlpha` on a `.clip`; animate a child.
-6. No CSS `transform` on an element GSAP transforms; animate transforms, not `left`/`top`/`width`/`height`.
-7. Never `play()`, `pause()` or seek media. A `<video>` keeps its sound with `data-has-audio="true"`, else it is `muted`; music, voice, replacement sound and J/L cuts are a separate `<audio>`.
-8. Every `<audio>` has an `id` or it is left out of the mix. No `crossorigin` on media. Time a `<video>` or its wrapper, never both.
-9. Only the bundled fonts (`references/format.md`) resolve by name; any other family needs `@font-face` to a file in `assets/fonts/`.
-10. Asset paths are root-relative (`assets/...`), in sub-compositions too.
-11. Grades, grain, blur and vignettes on footage go through `npx hyperframes media-treatment` (`/media-use`), never CSS filters.
-12. A scene file puts its styles, markup and scripts inside `<template>` and styles its root as `#root`. Intended overflow or overlap: `data-layout-allow-overflow`, `data-layout-allow-overlap`.
-
-## Keep it editable
-
-Studio edits the tags you write.
-
-- One scene per sub-composition, short readable ids; the root holds only scene hosts, media and audio.
-- Timed elements are written in the HTML, not made by script, each with a stable `id`.
-- Copy, brand colours and swappable media are variables (`data-var-text`, `data-var-src`, `var(--id)`).
-- One kind per track: `data-track-kind="graphics"` on scene and overlay hosts, `captions` on the one host that holds every caption group.
-- Content stays inside the 90% action-safe box, captions and key text inside 80% title-safe; Studio draws the guides, never add them.
-
-## Work loop
-
-- An existing project: `npx hyperframes timeline --json` shows what plays when; before any change, `npx hyperframes history --since mine --who <you>` shows what the person changed since your last turn: build on it (`/hyperframes-cli`).
-- A new film over ~15 s that tells something: its type's file (below), then `references/story.md`: three storylines that are three different films, in words only; the person picks unless they asked for the file or no stops. Then `SPEC.md` (`references/spec.md`): every adjective as a number, the defaults banned by name, the shots by frame.
-- After your last edit: `npx hyperframes check --json`; fix every error, weigh every warning. A film: `npx hyperframes snapshot --review` and `references/review.md`, ending in `REVIEW.md`. A small edit: snapshot what you changed (`--at`, `--range`, `--composition`) and look before you reply.
-- Render when the person approves the Studio preview, asks for the file or asks for no stops, after your check and review pass; otherwise stop at the preview and wait.
-
-## The HyperFrames desktop app
-
-Call it "the HyperFrames desktop app", never "Studio"; offer it as the better way to keep editing, not the only one.
-
-- Before the delivery render of a new video, open the Studio preview, even in no-questions mode, and say they can edit there. If `preview` printed "Keep editing by chatting with Framey", add that the **Edit with Framey** button opens the app.
-- After the delivery render, pass on its Framey line in your own words: offer to run the `hyperframes open` it names or give its download link; else say nothing (autonomous: the delivery note).
-- When any command says to run `catch-up`, run `npx hyperframes catch-up [dir]` before your next change; what it lists is their work, not a new request.
-
-## What to read
-
-| The request | Read |
-| --- | --- |
-| Launch, promo, feature | `references/types/launch.md` |
-| Explainer, tutorial | `references/types/explainer.md` |
-| Music video | `references/types/music.md` |
-| Chart, numbers | `references/types/data.md` |
-| Vertical or social clip | `references/types/vertical.md` |
-| 3D, simulation, generative | `references/types/3d.md` |
-| Character, mascot, story short | `references/types/character.md` |
-| A real place or map; a website, PR or script; kinetic type | `references/film.md` |
-| Captions; cards over a talking head | `references/captions.md`; `references/overlays.md` |
-| Motion: eases, titles, cuts, punch-ins, speed, holds | `references/motion.md` |
-| Scenes, attributes, media, lint; GSAP, Lottie, 3D, canvas | `references/format.md`; `references/runtimes.md` |
-
-Decks: `/slideshow`. Remotion source: `/remotion-to-hyperframes`. Figma: `/figma`. Installing, refreshing or upgrading skills and the pinned CLI: `references/skill-lifecycle.md`.

.claude/skills/hyperframes/assets/frame-presets/biennale-yellow/FRAME.md

@@ -1,289 +0,0 @@
----
-version: alpha
-name: Biennale Yellow — Frame (video / frame layer)
-description: >
-  Video-first companion to Biennale Yellow's design.md. The unit is the frame (1920×1080). Atoms
-  are identical and sacred — warm parchment grounds, a single deep indigo ink, solar yellow deployed
-  as bloom / panel / tile underprint, Instrument Serif display + Archivo sans + JetBrains Mono data,
-  1px hairline rules as the only border, atmospheric depth (no shadows), and the bottom-right
-  pagenum. Composition + frame scale rewritten. Restraint is the rule; motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  paper: "#E9E5DB"
-  paper-deep: "#DCD6C4"
-  sun: "#F1EE2E"
-  sun-soft: "#F8F39B"
-  haze: "#F0DA7C"
-  ink: "#1B2566"
-  ember: "#E26B4A"
-
-typography:
-  # — reading + data ramp —
-  body:    { fontFamily: "Archivo", cqw: 0.85, weight: 400, lineHeight: 1.5, color: "ink" }
-  body-lede:{ fontFamily: "Archivo", cqw: 0.95, weight: 400, lineHeight: 1.55 }
-  micro-label:{ fontFamily: "Archivo", px: 13, weight: 600, tracking: "0.18em", upper: true }
-  rail-label:{ fontFamily: "Archivo", px: 13, weight: 600, tracking: "0.32em", upper: true }
-  mono-data:{ fontFamily: "JetBrains Mono", cqw: 0.73, weight: 400, tracking: "0.04em" }
-  pagenum: { fontFamily: "JetBrains Mono", px: 13, weight: 400, tracking: "0.08em", opacity: 0.75 }
-  # — display ramp (Instrument Serif 400, tight, negative tracking) —
-  ledger-title:{ fontFamily: "Instrument Serif", cqw: 1.55, weight: 400, lineHeight: 1.15 }
-  strand-title:{ fontFamily: "Instrument Serif", cqw: 1.7, weight: 400, lineHeight: 1.1 }
-  headline-sm:{ fontFamily: "Instrument Serif", cqw: 2.9, weight: 400, lineHeight: 1.0 }
-  headline:{ fontFamily: "Instrument Serif", cqw: 4.6, weight: 400, lineHeight: 1.06, tracking: "-0.005em" }
-  date-rail:{ fontFamily: "Instrument Serif", cqw: 5.0, weight: 400, lineHeight: 0.96, tracking: "-0.005em" }
-  display-it:{ fontFamily: "Instrument Serif", cqw: 7.0, weight: 400, italic: true, lineHeight: 1.04, tracking: "-0.005em" }
-  numeral-md:{ fontFamily: "Instrument Serif", cqw: 7.5, weight: 400, lineHeight: 0.92, tracking: "-0.01em" }
-  display:{ fontFamily: "Instrument Serif", cqw: 14.6, weight: 400, lineHeight: 0.86, tracking: "-0.018em" }
-  numeral-jumbo:{ fontFamily: "Instrument Serif", cqw: 28.0, weight: 400, lineHeight: 0.84, tracking: "-0.04em" }
-
-spacing:
-  pad-edge: "4cqw"
-  pad-region: "4.2cqw"
-  gap-region: "2.5cqw"
-
-components:
-  sun-bloom:
-    background: "radial gradient {colors.sun} core → {colors.sun-soft} → {colors.haze} → transparent on {colors.paper}"
-    size: "42–70% of the frame, off-center or behind the focal element"
-    description: "The primary depth layer. One per frame; a flat parchment frame reads as broken."
-  ember-bloom:
-    background: "radial {colors.ember} at 15–22% opacity"
-    placement: "corner opposite the sun-bloom"
-    description: "Subordinate counter-temperature balance; never dominant."
-  block-tile:
-    backgroundColor: "{colors.sun} at 40–70% opacity"
-    layout: "rectangles on an 8×4 grid behind cover/colophon"
-    description: "A layered poster underprint."
-  yellow-panel:
-    backgroundColor: "{colors.sun}"
-    textColor: "{colors.ink}"
-    rounded: "0"
-    border: "none (meets paper directly)"
-    description: "Full-bleed column/third — the strongest color statement, ink on top."
-  hairline-rule:
-    rule: "1px solid {colors.ink} (soft variant: {colors.ink} at 18–20%)"
-    description: "The ONLY border — header underlines, footer tops, ledger separators. No thicker rule exists."
-  strand-row:
-    borderBottom: "1px {colors.ink} 18–20%"
-    typography: "{typography.strand-title} + {typography.body}"
-    description: "Serif numeral + serif title + sans body. Numbered editorial lists."
-  ledger-row:
-    borderBottom: "1px {colors.ink} 18–20%"
-    typography: "{typography.mono-date} · {typography.ledger-title} · {typography.body} · {typography.mono-data}"
-    description: "4-col tabular — mono date · serif title · sans venue · mono duration (right)."
-  footer-band:
-    borderTop: "1px solid {colors.ink} per cell"
-    typography: "{typography.micro-label} + {typography.body-sm}"
-    description: "4-column metadata strip at the foot of cover/colophon."
-  vertical-rail:
-    typography: "{typography.rail-label}"
-    transform: "rotated up the left edge"
-    description: "Section marker on chapter/divider frames."
-  pagenum:
-    typography: "{typography.pagenum}"
-    color: "{colors.ink} at 75%"
-    placement: "bottom-right"
-    description: "The only persistent chrome."
----
-
-# Biennale Yellow — Frame (video / frame layer)
-
-## Overview
-
-Biennale Yellow at frame scale is a **literary-editorial system** in the register of an art
-biennale catalogue: warm parchment, a single deep indigo ink, and solar yellow as atmosphere. No
-cards, no buttons, no shadows, no rounded corners — the structural vocabulary is just **paper, ink,
-and yellow.** Depth is delivered by soft radial **sun blooms**, not elevation.
-
-The voice is three faces in rigid roles: **Instrument Serif** (weight 400, tight line-height,
-negative tracking) carries every display, numeral, and quote from 40px to 720px+; **Archivo** carries
-body and the wide-tracked uppercase micro-label; **JetBrains Mono** carries every date, figure, and
-the pagenum. Text is **always ink** — contrast comes from size and weight, never color. The mood
-sits between a folded museum brochure and a slow-reading literary quarterly: confident, atmospheric,
-deeply restrained.
-
-**Key characteristics at frame scale:**
-
-- **Warm parchment ground** on every frame; never white, never gray.
-- **Single ink** (`{colors.ink}`) for all type and all rules; **solar yellow** as bloom / panel / tile.
-- **Instrument Serif 400** display (tight, negative-tracked); **Archivo** body + micro-labels; **JetBrains Mono** data.
-- **1px hairline rules** are the only border — no thicker weight exists; **no shadows, no rounded corners**.
-- **Sun bloom** is the primary depth layer on every frame; an ember counter-bloom adds warm-cool tension.
-- **Editorial-restrained** — sparse reads as elegant; crowding breaks the catalogue feel.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one Instrument Serif moment dominates at 3–6× its neighbor; the sun bloom centers the eye.
-- **Silence** — frames read **55–60% empty**; the **ledger is the one dense exception** (density via quiet hairline repetition, not richness).
-- **Restraint** — **one ink color** for all type and rules; **one sun bloom** per frame (+ optional subordinate ember); never invert (no yellow text on ink).
-- **Reference** — aim at an **art-biennale catalogue / slow exhibition poster / literary quarterly**; failure looks like a **flat CMS template** (no bloom) or a **bordered-card deck**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad-edge` 4cqw (40–76px equivalent) — the elegance depends on edge negative space; only blooms, tiles, and panels bleed.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. Hairlines stay 1px; bloom sizes scale
-as `%` of the frame.
-
-## Colors
-
-Tokens identical to the source. `{colors.paper}` is the universal ground; `{colors.ink}` (deep
-indigo navy) is **every line of type and every rule** — there is no secondary text color.
-`{colors.sun}` deploys three ways: the **bloom** (radial atmosphere), the **yellow-panel**
-(full-bleed poster fill, ink on top), and the **block-tile** underprint. `{colors.sun-soft}`/`haze`
-are bloom mid/outer stops. `{colors.ember}` appears **only** as a 15–22% counter-bloom — never a
-fill, never text. **The system never inverts** — ink on sun is correct; yellow text on ink does not exist.
-
-## Typography
-
-Two ramps. The **reading/data ramp** (Archivo body 0.85cqw ink, micro-labels in px, JetBrains Mono
-data) carries copy + chrome; the **display ramp** (Instrument Serif `ledger-title` 1.55cqw →
-`numeral-jumbo` 28cqw) carries every headline, numeral, and quote.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; mono/labels in px are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `display`; 4–6 → `headline`; 7+ → `headline-sm`. The jumbo numeral is a divider's whole point — don't shrink it.
-- **Instrument Serif is weight 400 only** (its contrast is the weight signal), tight line-height (0.84–1.06), negative tracking; **micro-labels uppercase Archivo 600, ≥0.16em**; **mono for all numerals/dates**. No bold serif, no second text color, no mono in body/display.
-
-## Depth & Surface
-
-Atmospheric, not structural. Depth from:
-
-- **Sun bloom** — the primary layer: a layered radial (sun 70–95% core → sun-soft → haze 18–22% → paper 0%), 42–70% of the frame. One per frame.
-- **Ember bloom** — a 15–22% peach counter-bloom in the opposite corner; always subordinate.
-- **Block-tile underprint** — translucent yellow rectangles on an 8×4 grid (cover/colophon).
-- **Yellow panel** — the one "hard" color statement: a flooded column/third, ink on top.
-- **Hairline rules** — 1px ink for structural separation (soft 18–20% variant for dense rows).
-
-**Ceiling:** zero box-shadow, zero text-shadow, zero rounded corner, no border thicker than 1px.
-
-## Shapes
-
-- **0 radius on everything** — strict rectangles. Blooms are edgeless (they fade into paper).
-
-## Components
-
-- **sun-bloom / ember-bloom / block-tile** — the atmospheric depth set. **yellow-panel** — the poster-fill statement.
-- **hairline-rule** — the only border (1px ink; soft variant for dense rows).
-- **strand-row / ledger-row / footer-band** — the editorial list, tabular calendar, and metadata strip.
-- **vertical-rail** — rotated chapter marker. **pagenum** — the bottom-right mono chrome.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> A sun bloom + bottom-right pagenum on every frame; sparse is the default.
-
-### 1 · Cover (identity · move: display + sun bloom · left)
-
-**Ground** paper + a large sun-bloom (left-of-center) + an ember counter-bloom (opposite corner).
-**Composes** micro-label, display, date-rail, footer-band, pagenum. **Focal** a 2-line Instrument
-Serif `display` (italic key word) in ink, left, under a micro-label. **Chrome** a serif date-rail
-top-right; a 4-column footer-band at the foot. **Accent** the sun bloom + yellow. **Silence** the
-bloom holds the open space. **Fixed** ink type, one bloom, 1px footer rules, no shadow. **Free**
-title, date, footer cells. **Density** low.
-
-### 2 · Chapter Divider (section · move: jumbo numeral · vertical rail)
-
-**Ground** paper + a corner-anchored sun-bloom. **Composes** vertical-rail, numeral-jumbo,
-headline-sm. **Focal** a single huge Instrument Serif `numeral-jumbo` (≈28cqw) dominating, with a
-serif title beneath. **Chrome** a rotated vertical-rail label up the left edge; pagenum. **Accent**
-the bloom behind the numeral. **Silence** ~60%. **Fixed** serif 400, jumbo numeral, rail label.
-**Free** the ordinal, title, rail text. **Density** low.
-
-### 3 · Ledger (catalog · move: hairline tabular rows · the dense frame)
-
-**Ground** paper (bloom optional, subtle). **Composes** headline-sm + micro-label topbar, ledger-rows.
-**Focal** a 4-column tabular calendar — mono date · serif title · sans venue · mono duration —
-separated by hairline-soft rules under a 1px ink header rule. **Chrome** pagenum. **Accent** none —
-density through quiet repetition, not color. **Silence** tight — the density exception (achieved by
-repetition, not richness). **Fixed** hairline rules, mono dates, serif titles. **Free** rows, venues.
-**Density** dense-exception.
-
-### 4 · Manifesto / Quote (quote · move: italic serif · centered bloom)
-
-**Ground** paper + a centered sun-bloom. **Composes** numeral-lg quote mark, display-it, attribution.
-**Focal** a 2-line Instrument Serif **italic** `display-it` quote in ink, centered, under an
-oversized serif quote mark. **Chrome** a micro-label attribution. **Accent** the centered bloom.
-**Silence** ~60% — deliberately open. **Fixed** italic serif, one bloom, ink. **Free** quote,
-attribution. **Density** low.
-
-### 5 · Poster Panel (statement · move: yellow panel · split)
-
-**Ground** paper with a full-bleed `{colors.sun}` `yellow-panel` (column or third). **Composes**
-yellow-panel, micro-label, headline. **Focal** an Instrument Serif `headline` in ink sitting **on
-the sun panel** (ink-on-yellow — a signature). **Chrome** micro-label; pagenum. **Accent** the panel
-itself. **Silence** the paper side stays open. **Fixed** ink-on-sun, panel meets paper directly (no
-border), no shadow. **Free** headline, panel side/width. **Density** low.
-
-### 6 · Strand List (programme · move: numbered editorial rows · left)
-
-**Ground** paper + a subtle sun-bloom. **Composes** micro-label, headline-sm, strand-rows. **Focal**
-a numbered list — serif numeral + serif title + sans body, hairline-soft separators. **Chrome**
-micro-label; pagenum. **Accent** the bloom. **Silence** moderate; rows breathe. **Fixed** serif
-numerals, hairline-soft rules. **Free** items, copy. **Density** standard.
-
-## Composition Rules
-
-### Do
-
-- Start on **warm parchment**; add **one sun bloom** (optionally an ember counter-bloom) — atmosphere is the depth.
-- Set every line in **ink**; use **Instrument Serif 400** (tight, negative-tracked) for display, **Archivo** body, **JetBrains Mono** for all numerals/dates.
-- Make every separator a **1px ink hairline** (soft variant for dense rows); flood a **yellow panel** for poster moments (ink on top).
-- Keep micro-labels **uppercase Archivo 600, 0.16–0.32em**; pin the **pagenum** bottom-right.
-- Lean sparse; left/asymmetric on cover/chapter/list, centered on manifesto.
-
-### Don't
-
-- No drop shadows, no rounded corners, no bordered cards, no border thicker than 1px.
-- No second text color; no bold Instrument Serif; no inverted ink grounds.
-- No mono for body/display; no font substitutes.
-- Don't crowd the canvas — sparse reads as elegant; don't omit the bloom (flat parchment reads as a CMS template).
-- Don't blow a headline edge-to-edge — step the ramp down.
-
-## Aspect-Ratio Behavior
-
-| Treatment       | 16:9                                           | 9:16                       | 1:1                        |
-| --------------- | ---------------------------------------------- | -------------------------- | -------------------------- |
-| Cover           | display left, date-rail top-right, footer foot | display top, footer stacks | display upper, footer foot |
-| Chapter Divider | jumbo numeral, rail left                       | numeral centered, rail top | numeral centered           |
-| Ledger          | 4-col rows                                     | drop venue col → 3-col     | 3-col                      |
-| Manifesto       | centered italic                                | centered, taller           | centered                   |
-| Poster Panel    | side panel + paper                             | top/bottom panel band      | panel third                |
-| Strand List     | numbered rows                                  | rows (tighter)             | rows                       |
-
-`pad-edge` holds on the short edge; display clamps use the shorter axis so portrait doesn't blow out
-headlines. Keep load-bearing lines ≥ 1.4cqw. Ledger/strand fixed first columns may tighten on 9:16.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Programme titles, venues, and dates are content; the system supplies paper, ink, yellow.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, dates, durations, or counts at frame scale. Render slots as `— figure —`,
-`{metric}`, `NN JUN`, `N m`. Ledger dates/durations and chart values especially carry placeholders
-until the script supplies them. Chapter ordinals (01, 02…) are decorative.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one serif display moment dominates; the bloom centers the eye.
-- **Silence** — sparse frames 55–60% open; only the ledger runs dense (via repetition, not richness).
-- **One color** — ink for all text + rules; sun for bloom/panel/tile; ember counter-bloom only; no inversion.
-- **Type** — Instrument Serif 400 tight negative-tracked, fit-to-measure; micro-labels uppercase 0.16em+; mono numerals; ≥1.4cqw floor.
-- **Depth** — 0 shadow, 0 rounded corner, 1px hairlines only; one sun bloom present.
-- **Anchor** — left on cover/chapter/list, centered on manifesto; pagenum bottom-right.
-- **Fabrication** — every numeral/date traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the source's 280ms crossfade is a deck mechanic.
-- **Instrument Serif + Archivo + JetBrains Mono via Google Fonts.** CJK: Smiley Sans (display) / Noto Serif SC (body) / Noto Sans SC (labels); italic serif and mono tabular figures have no exact Hanzi equal — keep ledger dates Latin.
-- **9:16 / 1:1 are guidance**; the `min(vw,vh)` clamp pattern keeps display from blowing out — verify per ratio.
-- Sun/ember blooms, block tiles, yellow panels, and hairline rules are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/biennale-yellow/caption-skin.html

@@ -1,220 +0,0 @@
-<!--
-  Biennale Yellow — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a biennale literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a warm-parchment card on a single 1px hairline indigo-ink border — biennale's
-  ONLY border — square corners, NO shadow (biennale's depth is atmospheric, never cast).
-  Instrument Serif, sentence case, ink glyphs. Upcoming words sit in faint ink; the
-  current word gets a solar-yellow underprint (the brand's signature "sun as panel /
-  underprint", a hard square block, no blur) with ink reading on top; spoken words
-  settle to solid ink, underprint cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE parchment card — single 1px hairline ink border (biennale's only border),
-     square corners, NO shadow */
-  .caption-pill {
-    max-width: 78%;
-    padding: 20px 44px 24px;
-    background: var(--cap-canvas, #e9e5db);
-    border: 1px solid var(--cap-ink, #1b2566);
-    border-radius: 0;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.1em 0.34em;
-    font-family: var(--font-display, "Instrument Serif"), Georgia, serif;
-    font-weight: 400;
-    font-size: clamp(40px, 4.4vw, 58px);
-    line-height: 1.16;
-    letter-spacing: -0.01em;
-  }
-
-  /* upcoming — faint indigo ink, no underprint */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.06em;
-    color: color-mix(in srgb, var(--cap-ink, #1b2566) 42%, var(--cap-canvas, #e9e5db));
-  }
-  /* current word — THE solar-yellow underprint (box-shadow spread = a hard square
-     block w/o layout shift; no blur), indigo ink reading on top */
-  .caption-word.is-active {
-    color: var(--cap-ink, #1b2566);
-    background: var(--cap-accent, #f1ee2e);
-    box-shadow: 0 0 0 0.06em var(--cap-accent, #f1ee2e);
-  }
-  /* already spoken — solid indigo ink, underprint cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #1b2566);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — Instrument Serif italic, biennale's only display inflection */
-  .caption-word.cap-brand {
-    font-style: italic;
-  }
-  /* numerals / data — the mono voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "JetBrains Mono"), ui-monospace, monospace;
-    color: color-mix(in srgb, var(--cap-ink, #1b2566) 72%, var(--cap-canvas, #e9e5db));
-  }
-  /* emphasis — an ember-red hairline underline (the counter-temperature accent) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 2px;
-    text-decoration-color: var(--cap-accent-2, #e26b4a);
-    text-underline-offset: 0.1em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.97 }, { scale: 1, duration: 0.14, ease: "power2.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/blockframe/FRAME.md

@@ -1,275 +0,0 @@
----
-version: alpha
-name: BlockFrame — Frame (video / frame layer)
-description: >
-  Video-first companion to BlockFrame's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — 4px black borders + 8px hard offset shadows, the five-pastel candy palette
-  (pink/blue/green/yellow/cream) plus black/white/off-white, Inter 800–900 uppercase display +
-  Space Grotesk label chrome, square corners, label-pills, tilted decorations, star bursts, stripe
-  blocks, dot grids. Composition + frame scale rewritten. Motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  black: "#000000"
-  white: "#FFFFFF"
-  offwhite: "#FFFDF5"
-  pink: "#FE90E8"
-  blue: "#C0F7FE"
-  green: "#99E885"
-  yellow: "#F7CB46"
-  cream: "#FFDC8B"
-
-borders: { primary: "4px solid black", thin: "3px solid black" }
-shadows: { default: "8px 8px 0 black", small: "4px 4px 0 black", hover: "6px 6px 0 black", close-yellow: "12px 12px 0 yellow", close-white: "6px 6px 0 white" }
-
-typography:
-  # — reading + chrome ramp —
-  body:    { fontFamily: "Inter", cqw: 0.95, weight: 500, lineHeight: 1.6 }
-  card-title:{ fontFamily: "Inter", cqw: 1.15, weight: 700, upper: true, lineHeight: 1.2 }
-  label:   { fontFamily: "Space Grotesk", px: 13, weight: 600, tracking: "0.08em", upper: true }
-  counter: { fontFamily: "Space Grotesk", px: 14, weight: 700, tracking: "0.1em", upper: true }
-  # — display ramp (Inter 800–900, uppercase, negative tracking) —
-  heading-md:{ fontFamily: "Inter", cqw: 2.1, weight: 700, lineHeight: 1.1, tracking: "-0.01em", upper: true }
-  quote-text:{ fontFamily: "Inter", cqw: 2.7, weight: 900, lineHeight: 1.15, tracking: "-0.02em", upper: true }
-  stat-number:{ fontFamily: "Inter", cqw: 3.3, weight: 900, lineHeight: 1.0 }
-  heading-lg:{ fontFamily: "Inter", cqw: 3.3, weight: 800, lineHeight: 1.0, tracking: "-0.02em", upper: true }
-  close-title:{ fontFamily: "Inter", cqw: 4.2, weight: 900, lineHeight: 0.95, tracking: "-0.03em", upper: true }
-  heading-xl:{ fontFamily: "Inter", cqw: 5.0, weight: 900, lineHeight: 0.95, tracking: "-0.03em", upper: true }
-
-spacing:
-  slide-pad: "3.1cqw"   # 60px @1920
-  gap-md: "1.7cqw"
-
-components:
-  card-elevated:
-    backgroundColor: "{colors.white}"
-    border: "0.4cqw solid {colors.black}"
-    rounded: "0"
-    shadow: "0.8cqw 0.8cqw 0 {colors.black}"
-    description: "Primary card. Border/shadow coupled: 4px↔8px, 3px↔4px."
-  card-small:
-    backgroundColor: "{colors.white}"
-    border: "0.3cqw solid {colors.black}"
-    rounded: "0"
-    shadow: "0.4cqw 0.4cqw 0 {colors.black}"
-    description: "Stat cards, team cards, timeline steps."
-  label-pill:
-    border: "0.3cqw solid {colors.black}"
-    backgroundColor: "any pastel / {colors.white}"
-    rounded: "9999px"
-    shadow: "0.4cqw 0.4cqw 0 {colors.black}"
-    typography: "{typography.label}"
-    description: "The universal eyebrow — never plain text."
-  button-primary:
-    backgroundColor: "{colors.yellow}"
-    textColor: "{colors.black}"
-    border: "0.3cqw solid {colors.black}"
-    rounded: "0"
-    shadow: "0.4cqw 0.4cqw 0 {colors.black}"
-    typography: "Inter 700"
-    description: "The CTA."
-  star-burst:
-    backgroundColor: "any pastel"
-    border: "0.3cqw solid {colors.black}"
-    clip: "10-point clip-path star"
-    description: "Corner attention-grabber."
-  stripe-block:
-    backgroundImage: "45° {colors.black} + pastel diagonal stripes"
-    border: "0.3cqw solid {colors.black}"
-    description: "Poster decoration."
-  bg-dot-grid:
-    backgroundImage: "radial-dot ~1.2px dots, 24px grid, {colors.black}"
-    description: "Faint corner/ground overlay."
-  tilt-deco:
-    transform: "rotate(±2°–12°)"
-    description: "Rotated rectangle/badge/star. Stat cards alternate −2/+2°. The grid-puncture signature."
-  stat-deco-dot:
-    backgroundColor: "any pastel"
-    border: "2px solid {colors.black}"
-    rounded: "50%"
-    size: "12px"
-    description: "The ONLY round shape, pinned to stat cards."
-  close-frame:
-    backgroundColor: "{colors.black}"
-    textColor: "{colors.white}"
-    border: "0.4cqw solid {colors.white}"
-    rounded: "0"
-    shadow: "1.2cqw 1.2cqw 0 {colors.yellow}"
-    description: "Inverted closer — the only colored shadow."
----
-
-# BlockFrame — Frame (video / frame layer)
-
-## Overview
-
-BlockFrame at frame scale is a **maximalist neobrutalist** system on five laws: every region has a
-4px black border, every elevated element an 8px hard offset shadow, every corner square, every
-accent a saturated pastel, and every layout allowed to be a little crooked. The joy is the
-deliberate collision — bordered cards meeting bordered cards, shadows stacking, tilted decorations
-puncturing the grid.
-
-The voice is **Inter** at weight 800–900 in tight uppercase with negative tracking (display) +
-weight 500 sentence body, and **Space Grotesk** weight 600 uppercase 0.08em as the label/chrome
-voice. Five candy pastels (pink/blue/green/yellow/cream) cycle as full-bleed grounds across frames
-— the color cycling is the primary rhythm. Depth is **hard offset shadow** (8px/4px, solid black,
-zero blur, bottom-right); the close-frame's 12px yellow shadow is the one colored exception.
-
-**Key characteristics at frame scale:**
-
-- **4px black borders + 8px hard shadows** on primary cards; 3px + 4px on chrome (weights coupled).
-- **Five-pastel palette** cycled as full-bleed grounds; black/white/off-white structural.
-- **Inter 800–900 uppercase** negative-tracked display; **Space Grotesk** label chrome.
-- **Square corners** everywhere (only the stat-deco dot is round); **tilted decorations** puncture the grid.
-- **Label-pills** open every region; star bursts, stripe blocks, dot grids are reusable attention units.
-- **Comfortably dense** — packed reads as authoritative; empty corners read as broken.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one Inter display moment dominates at 3–6× its neighbor; cards read as a system, not rivals.
-- **Silence** — cover/quote/close keep air (decorations, not content); the **feature-card and stat grids are the dense exception**.
-- **Restraint** — the 4px→08px / 3px→4px coupling holds; black borders only (white on close); pastel ground **cycles** one per frame; no sixth pastel.
-- **Reference** — aim at a **zine / 1990s sticker-book / toy-packaging spread** (bordered blocks, tilted decorations); failure looks like a **flat, borderless, blurred-shadow web card grid**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `slide-pad` ~3.1cqw; decorations may bleed off edges.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. Borders/shadows scale in `cqw` so the
-4px↔8px coupling holds proportionally; corners stay square.
-
-## Colors
-
-Tokens identical to the source. `{colors.offwhite}` is the default ground, but frames **cycle**
-through `{colors.cream}`/`blue`/`pink`/`green`/`yellow` grounds — the cycle is the rhythm.
-`{colors.black}` is every border + structural text; `{colors.white}` is card fills. The five pastels
-are interchangeable with **no semantic meaning** — pair by juxtaposition (pink+blue+green trio,
-cream+yellow warm pair). `{colors.yellow}` is the CTA + the one colored (close) shadow;
-`{colors.black}` ground is the close surface. **No sixth pastel.**
-
-## Typography
-
-Two ramps. The **reading/chrome ramp** (Inter body 0.95cqw weight 500, Space Grotesk labels in px)
-carries copy + chrome; the **display ramp** (Inter `heading-md` 2.1cqw → `heading-xl` 5cqw, weight
-800–900 uppercase) carries every headline + stat.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; px labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `heading-xl`; 4–6 → `heading-lg`; 7+ → `heading-md`.
-- **Inter display is uppercase, weight 800–900, negative-tracked** (−0.01..−0.03em); body weight 500 sentence case; **Space Grotesk labels uppercase 0.08em**. No sentence-case display, no untracked display.
-
-## Depth & Surface
-
-Hard offset shadow, solid black, zero blur, bottom-right:
-
-- **0.8cqw (8px)** primary cards; **0.4cqw (4px)** chrome; **0.6cqw (6px)** hover.
-- **Border-based depth** — the 4px/3px borders do much of the lift; shadow makes it "elevated."
-- **Tilt** — ±2°–12° rotation breaks the grid for perceived dimension.
-- **Inverted close** — 12px YELLOW shadow (and 6px white on close-btn) — the only colored shadows.
-
-**Ceiling:** no blurred shadow, no rounded corner (save the stat-deco dot), no gradient depth.
-
-## Shapes
-
-- **0 radius everywhere** except the 12px stat-deco dot (50%). Square corners are the structural identity.
-
-## Components
-
-- **card-elevated / card-small** — the bordered+shadowed content cards (weight-coupled).
-- **label-pill** — the universal eyebrow (border+shadow+pastel). **button-primary** — yellow CTA.
-- **star-burst / stripe-block / bg-dot-grid / tilt-deco** — the reusable decoration units (one per frame min).
-- **stat-deco-dot** — the lone round shape. **close-frame** — the inverted black+white+yellow-shadow closer.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> Cycle the ground color; add ≥1 decoration per frame; open with a label-pill.
-
-### 1 · Cover (identity · move: decorations puncture · left)
-
-**Ground** `{colors.cream}` (or offwhite) + faint dot-grid. **Composes** label-pill, heading-xl, tilt-deco rect, star-burst, counter. **Focal** a 2–3 line Inter `heading-xl` uppercase, left, under a label-pill; tilted pastel rects + a star burst puncture the right. **Chrome** counter pill. **Accent** the decorations' pastels. **Silence** right third holds decorations. **Fixed** 4px/8px coupling, uppercase display, square. **Free** title, decoration placement/colors. **Density** comfortable.
-
-### 2 · Feature Cards (catalog · move: 3-up bordered grid · blue ground)
-
-**Ground** `{colors.blue}`, `slide-pad`. **Composes** label-pill, heading-lg, 3× card-elevated (icon-square + card-title + body). **Focal** three white bordered+shadowed cards. **Chrome** label-pill eyebrow. **Accent** the pastel icon-squares (pink/green/yellow). **Silence** tight — dense by design. **Fixed** 4px border + 8px shadow, square, uppercase card-titles. **Free** card content, icon hues. **Density** dense-exception.
-
-### 3 · Stat Grid (data · move: tilted stat cards · green ground)
-
-**Ground** `{colors.green}`, `slide-pad`. **Composes** label-pill, heading-lg, 3× card-small (tilted −2/+2°, stat-deco dot, stat-number + label). **Focal** three tilted bordered stat cards. **Accent** the deco-dots' pastels + black stat numerals. **Silence** moderate. **Fixed** alternating tilt, 3px+4px, round deco-dot only. **Free** figures (from script), dot hues. **Density** dense-exception.
-
-### 4 · Closing Plate (closer · move: inverted black · centered)
-
-**Ground** `{colors.black}`. **Composes** close-frame (4px white border, 12px yellow shadow), label-pill (inverted), close-title, star-burst. **Focal** a white `close-title` inside the white-bordered frame with the yellow offset shadow; a pink star punctures a corner. **Accent** the yellow shadow + pink star. **Silence** ~50%. **Fixed** white-on-black, 12px yellow shadow (only here), square. **Free** sign-off, star placement. **Density** low.
-
-### 5 · Quote (quote · move: bordered quote frame · pink ground)
-
-**Ground** `{colors.pink}` (or offwhite). **Composes** label-pill, quote-text in a card-elevated, attribution. **Focal** an Inter `quote-text` (900 uppercase) inside a white bordered+shadowed frame. **Accent** the ground + one decoration. **Silence** moderate. **Fixed** uppercase quote, 4px/8px. **Free** quote, ground. **Density** comfortable.
-
-### 6 · Timeline (process · move: stepped bordered cards · offwhite)
-
-**Ground** `{colors.offwhite}`. **Composes** label-pill, heading-lg, 3–4 card-small steps + step-connectors. **Focal** a row of bordered step cards linked by black connector bars, each a pastel + step-num. **Accent** the step pastels. **Silence** moderate. **Fixed** 3px+4px steps, square, connectors. **Free** steps, hues. **Density** standard.
-
-## Composition Rules
-
-### Do
-
-- Pair **4px borders with 8px shadows**, **3px with 4px** — the coupling is non-negotiable.
-- **Cycle pastel grounds** across frames; keep the deck visually rhythmic.
-- Set Inter display **uppercase, 800–900, negative-tracked**; open every region with a **label-pill**.
-- Render shadows **solid black, zero blur, bottom-right**; add **≥1 decoration** (tilt/star/stripe/dots) per frame.
-- Use **yellow** for CTAs; use the **inverted black + 12px yellow shadow** close-frame for the closer.
-- Tilt decorations ±2°–12°; lean left on most frames.
-
-### Don't
-
-- No rounded corners (save the stat-deco dot); no blurred shadows.
-- No colored borders (black only, save the close-frame white); no sixth pastel.
-- No sentence-case Inter display; no untracked display; no label as plain text.
-- Don't keep everything perfectly aligned (tilt is the signature); don't leave corners empty.
-- Don't blow a headline edge-to-edge — fit to measure.
-
-## Aspect-Ratio Behavior
-
-| Treatment     | 16:9                          | 9:16                         | 1:1                      |
-| ------------- | ----------------------------- | ---------------------------- | ------------------------ |
-| Cover         | title left, decorations right | title top, decorations below | title, fewer decorations |
-| Feature Cards | 3 across                      | 3 stacked                    | 2+1                      |
-| Stat Grid     | 3 tilted across               | 3 tilted stacked             | 2×2                      |
-| Closing       | centered close-frame          | centered, taller             | centered                 |
-| Quote         | quote frame                   | quote stacked                | centered                 |
-| Timeline      | horizontal steps              | vertical (connectors hidden) | 2×2                      |
-
-`slide-pad` holds on the short edge; re-step display above the 1.4cqw floor. Decoration count drops
-on tighter ratios so the frame stays bordered, not cluttered.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Pastel fills, decorations, and tilts are content-agnostic.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, stats, or counts at frame scale. Render slots as `— figure —`, `{metric}`,
-`N×`. Stat cards and charts carry placeholders until the script supplies values. Slide counters and
-list numbers are decorative.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one Inter display moment dominates; cards read as a system.
-- **Silence** — only feature/stat grids run dense; cover/quote/close keep air with decorations.
-- **Borders/shadows** — 4px↔8px / 3px↔4px coupling holds; solid black, zero blur.
-- **Color** — pastel ground cycles; black borders only (white on close); no sixth pastel.
-- **Type** — Inter uppercase 800–900 negative-tracked, fit-to-measure; Space Grotesk labels 0.08em; ≥1.4cqw floor.
-- **Shape** — square corners (only stat-deco dot round); ≥1 tilt/decoration per frame.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the source toggles slides via display, no transition.
-- **Inter + Space Grotesk via Google Fonts.** CJK: Noto Sans SC 900 (sentence case — the uppercase signal drops); lean harder on borders/shadows/decoration to carry the brutalist identity.
-- **9:16 / 1:1 are guidance**; verify the floor and that decoration count scales down.
-- Star bursts (clip-path), stripe blocks, dot grids, and tilts are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/blockframe/caption-skin.html

@@ -1,223 +0,0 @@
-<!--
-  BlockFrame — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a blockframe literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a white card carved by a 4px black border with an 8px hard offset shadow
-  (solid black, zero blur, bottom-right — blockframe's sacred depth), square corners.
-  Inter 900, UPPERCASE, negative-tracked. Upcoming words sit in faded ink; the current
-  word gets a saturated-yellow stamp-block — a hard square highlight (box-shadow spread,
-  no blur) with black ink reading on top, blockframe's signature stamp gesture; spoken
-  words settle to solid black ink, stamp cleared. The word pops in with a snappy
-  back.out overshoot — loud, a little crooked.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE bordered card — 4px black border + 8px hard offset shadow (solid black,
-     zero blur, bottom-right — blockframe's sacred depth), square corners */
-  .caption-pill {
-    max-width: 80%;
-    padding: 18px 40px 22px;
-    background: var(--cap-canvas, #ffffff);
-    border: 4px solid var(--cap-ink, #000000);
-    border-radius: 0;
-    box-shadow: 8px 8px 0 var(--cap-ink, #000000);
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.12em 0.32em;
-    font-family: var(--font-display, "Inter"), system-ui, sans-serif;
-    font-weight: 900;
-    text-transform: uppercase;
-    font-size: clamp(38px, 4.2vw, 56px);
-    line-height: 1.12;
-    letter-spacing: -0.02em;
-  }
-
-  /* upcoming — faded black ink, no stamp */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.1em;
-    color: color-mix(in srgb, var(--cap-ink, #000000) 40%, var(--cap-canvas, #ffffff));
-  }
-  /* current word — THE yellow stamp-block (box-shadow spread = a hard square block
-     w/o layout shift; no blur), black ink reading on top — blockframe's signature stamp */
-  .caption-word.is-active {
-    color: var(--cap-ink, #000000);
-    background: var(--cap-accent, #f7cb46);
-    box-shadow: 0 0 0 0.08em var(--cap-accent, #f7cb46);
-  }
-  /* already spoken — solid black ink, stamp cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #000000);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — heavier ink weight, blockframe's display is already 900 */
-  .caption-word.cap-brand {
-    color: var(--cap-ink, #000000);
-  }
-  /* numerals / data — the body voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "Inter"), ui-monospace, monospace;
-    color: color-mix(in srgb, var(--cap-ink, #000000) 74%, var(--cap-canvas, #ffffff));
-  }
-  /* emphasis — a cream hard underline bar (the second-chroma accent) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 4px;
-    text-decoration-color: var(--cap-accent-2, #ffdc8b);
-    text-underline-offset: 0.12em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.86 }, { scale: 1, duration: 0.2, ease: "back.out(2.4)" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/blue-professional/FRAME.md

@@ -1,307 +0,0 @@
----
-version: alpha
-name: Blue Professional — Frame (video / frame layer)
-description: >
-  Video-first companion to Blue Professional's design.md. The unit is the frame (1920×1080). Atoms
-  are identical and sacred — the warm cream canvas, a single saturated cobalt (#1e2bfa) as the only
-  accent, the three-step gray text ladder, Space Grotesk (display/numerals/chrome) + Inter (body),
-  soft cobalt-tinted cards (4% fill / 20% border / 10–14px radius) with NO shadows, pill chrome, and
-  the cobalt progress bar. Composition + frame scale rewritten. Motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  bg: "#fdfae7"
-  primary: "#1e2bfa"
-  text: "#111111"
-  text-muted: "#6b6b6b"
-  text-light: "#9a9a9a"
-  accent-light: "rgba(30,43,250,0.08)"
-  accent-medium: "rgba(30,43,250,0.15)"
-  border: "rgba(30,43,250,0.2)"
-  card-bg: "rgba(30,43,250,0.04)"
-  positive: "#059669"
-  negative: "#dc2626"
-
-radii:
-  pill: "100px"
-  card-lg: "14px"
-  card-md: "12px"
-  card-sm: "10px"
-  bar: "6px"
-  circle: "50%"
-
-typography:
-  # — reading ramp (Inter body + Space Grotesk chrome) —
-  body:    { fontFamily: "Inter", cqw: 0.85, weight: 400, lineHeight: 1.6, color: "text-muted" }
-  h4-eyebrow:{ fontFamily: "Space Grotesk", cqw: 0.8, weight: 600, tracking: "0.08em", upper: true, color: "primary" }
-  tag:     { fontFamily: "Space Grotesk", px: 12, weight: 500, color: "primary" }
-  counter: { fontFamily: "Space Grotesk", px: 13, weight: 500, tracking: "0.05em", color: "text-muted" }
-  # — display / numerical ramp (Space Grotesk, near-black headings / cobalt numerals) —
-  h3:      { fontFamily: "Space Grotesk", cqw: 1.25, weight: 500, lineHeight: 1.3, tracking: "-0.02em", color: "text" }
-  stat-num:{ fontFamily: "Space Grotesk", cqw: 1.9, weight: 700, lineHeight: 1.0, color: "primary" }
-  blockquote:{ fontFamily: "Space Grotesk", cqw: 2.4, weight: 500, lineHeight: 1.35, color: "text" }
-  h2:      { fontFamily: "Space Grotesk", cqw: 2.6, weight: 600, lineHeight: 1.1, tracking: "-0.02em", color: "text" }
-  metric-value:{ fontFamily: "Space Grotesk", cqw: 3.0, weight: 700, lineHeight: 1.0, color: "primary" }
-  h1:      { fontFamily: "Space Grotesk", cqw: 4.2, weight: 700, lineHeight: 1.08, tracking: "-0.02em", color: "text" }
-  quote-mark:{ fontFamily: "Space Grotesk", cqw: 8.0, weight: 700, lineHeight: 0.5, color: "primary", opacity: 0.15 }
-
-spacing:
-  pad-x: "5cqw"
-  pad-y-top: "5cqw"
-  gap-cards: "1.4cqw"
-  accent-line: "60px × 4px"
-
-components:
-  card-tinted:
-    backgroundColor: "{colors.card-bg}"
-    border: "1.5px solid {colors.border}"
-    rounded: "{radii.card-lg}"
-    shadow: "none"
-    description: "Universal content card. Never solid-colored, never opaque-bordered, NO shadow."
-  metric-card:
-    backgroundColor: "{colors.card-bg}"
-    border: "1.5px solid {colors.border}"
-    rounded: "{radii.card-lg}"
-    typography: "{typography.metric-value} ({colors.primary}) + {typography.metric-label} + {typography.metric-desc}"
-    description: "+ optional inline ↑/↓ change chip ({colors.positive}/{colors.negative} text, no fill)."
-  tag-pill:
-    backgroundColor: "{colors.accent-light}"
-    textColor: "{colors.primary}"
-    rounded: "{radii.pill}"
-    typography: "{typography.tag}"
-    description: "Top-right of the slide-header."
-  cta-button:
-    backgroundColor: "{colors.primary}"
-    textColor: "{colors.bg}"
-    rounded: "{radii.pill}"
-    typography: "Space Grotesk 600"
-    shadow: "soft cobalt on hover only — the system's only shadow"
-    description: "The one solid element."
-  accent-line:
-    backgroundColor: "{colors.primary}"
-    size: "60×4, 2px radius"
-    description: "Above cover titles / eyebrow separators."
-  bar-track:
-    backgroundColor: "{colors.accent-light}"
-    fill: "{colors.primary} (display:block so width resolves)"
-    rounded: "{radii.bar}"
-    description: "28px track; fill carries the value."
-  step-circle:
-    backgroundColor: "{colors.primary}"
-    textColor: "{colors.bg}"
-    rounded: "50%"
-    size: "56px"
-    description: "Sequential steps fade opacity 1.0→0.85→0.7→0.55."
-  split-highlight:
-    backgroundColor: "{colors.accent-light}"
-    borderLeft: "4px solid {colors.primary}"
-    rounded: "{radii.card-md}"
-    description: "Inline pull-quote callout."
-  slide-header:
-    typography: "{typography.h4-eyebrow} (cobalt) left, tag-pill right; {typography.h2} below"
-    description: "Top band of every content frame."
-  atmosphere:
-    elements: "clipped diagonal cobalt-tint panel, 3×3 cobalt dot grid, concentric closing rings"
-    description: "Cover/closing only. Never on content frames."
-  progress-bar:
-    backgroundColor: "{colors.primary}"
-    size: "3px tall, bottom edge, width grows with index"
-    description: "Persistent progress strip."
----
-
-# Blue Professional — Frame (video / frame layer)
-
-## Overview
-
-Blue Professional at frame scale is a **consulting-grade system: restraint with one strong
-commitment.** A warm cream canvas and a single saturated cobalt that carries every accent —
-eyebrow, metric, CTA, chart fill, progress bar. No secondary brand color, no pastels, just cream,
-cobalt, and a tight ladder of grays. The register is investment-research / McKinsey briefing:
-measured, data-dense without crowding, executive-readable at distance.
-
-The voice is two faces in fixed roles: **Space Grotesk** (display, every numeral, all chrome —
-eyebrows uppercase 0.08em) and **Inter** (body, muted gray, line 1.6). Headlines are near-black;
-cobalt is reserved for accent moments. Depth is **soft and tinted** — 4% cobalt card fills with 20%
-cobalt borders and 10–14px radii — never shadowed. The lack of harsh shadows is the premium signal.
-
-**Key characteristics at frame scale:**
-
-- **Warm cream ground** on every frame; **single cobalt** as the only accent.
-- **Space Grotesk** (display/numerals/chrome) + **Inter** (body) — near-black headlines, cobalt numerals.
-- **Tinted cards** — cobalt 4% fill, cobalt 20% 1.5px border, 10–14px radius, **no shadow**.
-- **Pill chrome** (100px) — tag pills + the one solid cobalt CTA; cobalt **progress bar**.
-- **Soft rounded corners everywhere** (no square corners save the progress bar).
-- **Atmosphere** (diagonal panel, dot grid, concentric rings) on cover/closing only.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one **near-black headline or cobalt numeral** dominates at 3–6× its neighbor.
-- **Silence** — content frames read **balanced, not crowded**; the **dashboard is the one dense exception**.
-- **Restraint** — a **single cobalt accent** carries everything; headlines stay near-black (never cobalt); no shadows (tinted cards do the lift); positive/negative inline-text only.
-- **Reference** — aim at an **investment-research / McKinsey quarterly briefing**; failure looks like a **heavy-outlined, multi-color dashboard**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad-x` 5cqw; bottom reserves room for the counter + progress bar.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. Card radii stay px (10–14px); the
-pill radius stays 100px; borders stay 1–1.5px.
-
-## Colors
-
-Tokens identical to the source. `{colors.bg}` cream is the universal ground; `{colors.primary}`
-cobalt is the **only** accent — every eyebrow, numeral, CTA, chart fill, progress bar, and the 4px
-highlight left-rule. Headlines are `{colors.text}` near-black (never cobalt); body is
-`{colors.text-muted}`; tertiary is `{colors.text-light}`. Cards fill `{colors.card-bg}` (4%) with
-`{colors.border}` (20%) borders. `{colors.positive}`/`{colors.negative}` appear **only inline** on
-directional change chips — never as fills. **No second accent color.**
-
-## Typography
-
-Two ramps. The **reading ramp** (Inter body 0.85cqw muted; Space Grotesk eyebrow uppercase 0.08em
-cobalt) carries copy + chrome; the **display/numerical ramp** (Space Grotesk `h3` 1.25cqw → `h1`
-4.2cqw near-black; numerals `stat-num`/`metric-value` in cobalt) carries headings and figures.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; px chrome (tag/counter) is colophon only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `h1`; 4–6 → `h2`; 7+ → `h3`. Cobalt numerals scale `metric-value`→`stat-num` by card size.
-- **Headlines near-black, −0.02em**; **eyebrows cobalt, uppercase, 0.08em**; **numerals cobalt 600–700**; **body Inter 400 muted, line 1.6**. No italic, no uppercase body, no cobalt headline.
-
-## Depth & Surface
-
-Soft and tinted — never offset. Depth from:
-
-- **Tinted cards** — 4% cobalt fill + 20% cobalt 1.5px border + 10–14px radius reads as lifted without offset.
-- **Border-left accent** — the 4px cobalt rule on split-highlight blocks pulls a callout forward.
-- **Rounded corners** — the 10–14px radius is part of the softness; square corners break it.
-
-**Ceiling:** zero box-shadow on content (the only shadow is a soft cobalt CTA _hover_); no opaque cobalt borders; no harsh outlines.
-
-## Shapes
-
-- **100px** — tag pills, CTA, nav buttons (pill chrome).
-- **14/12/10px** — cards by size (large metric / standard stat / detail + mini).
-- **6px** — bar tracks + fills. **50%** — step circles, nav circles, dots, closing rings.
-- **0** — only the progress bar. No square-cornered content.
-
-## Components
-
-- **card-tinted / metric-card** — the universal soft-tint content cards (no shadow).
-- **tag-pill / cta-button / accent-line** — the cobalt pill chrome + the one solid CTA + the 60×4 rule.
-- **bar-track / step-circle / split-highlight** — cobalt data + sequence + callout patterns.
-- **slide-header** (eyebrow + tag pill) — the structural rhythm; **atmosphere** (diagonal/dots/rings) on cover/closing only; **progress-bar** on every frame.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> Atmosphere only on cover/closing; content frames carry the slide-header rhythm.
-
-### 1 · Cover (identity · move: diagonal accent · left)
-
-**Ground** cream + the clipped diagonal cobalt-tint panel (right ~36%) + a 3×3 cobalt dot grid.
-**Composes** accent-line, meta, h1, body sub. **Focal** a 2-line Space Grotesk `h1` near-black, left,
-under a cobalt accent-line + meta. **Chrome** counter + progress bar. **Accent** the cobalt line +
-diagonal panel. **Silence** the diagonal panel holds the right third. **Fixed** near-black h1, cobalt
-accents, atmosphere here only. **Free** title, meta. **Density** low.
-
-### 2 · Dashboard (data · move: 3-up metric grid · the dense frame)
-
-**Ground** cream, `pad-x`. **Composes** slide-header (eyebrow + tag-pill), h2, 3× metric/tinted card.
-**Focal** a row of tinted cards — cobalt `metric-value` + Inter label + muted desc + optional
-green/red change chip. **Chrome** eyebrow left, tag-pill right; progress bar. **Accent** the cobalt
-numerals. **Silence** tight — the density exception. **Fixed** 4% tint cards, 20% borders, no shadow,
-cobalt numerals. **Free** figures (from script), labels. **Density** dense-exception.
-
-### 3 · Bar Ranking (data · move: cobalt bars · left)
-
-**Ground** cream, `pad-x`. **Composes** eyebrow, h2, bar-track rows. **Focal** 3–5 labeled
-cobalt-fill bars on cobalt-8% tracks with cobalt percentages. **Chrome** eyebrow; progress bar.
-**Accent** the cobalt fills + figures. **Silence** moderate. **Fixed** 6px tracks, cobalt fills.
-**Free** rows, values (from script). **Density** standard.
-
-### 4 · Pull Quote (quote · move: concentric rings · centered)
-
-**Ground** cream, centered, with faint concentric closing-rings behind. **Composes** quote-mark,
-blockquote, cite. **Focal** a Space Grotesk `blockquote` near-black under a 15%-opacity cobalt
-quote-mark; an uppercase cobalt-muted cite beneath. **Accent** the faint rings + quote-mark. **Silence**
-~55%. **Fixed** near-black quote, soft rings. **Free** quote, cite. **Density** low.
-
-### 5 · Split + Highlight (content · move: asymmetric split · left)
-
-**Ground** cream, two columns. **Composes** eyebrow, h2, body, split-highlight block. **Focal** an
-Inter body column beside a cobalt-8% highlight block (4px cobalt left rule) carrying an inline pull
-quote. **Accent** the highlight's left rule. **Silence** generous gutter. **Fixed** tinted highlight,
-4px cobalt rule. **Free** body, callout. **Density** standard.
-
-### 6 · Closing / CTA (closer · move: centered rings + CTA)
-
-**Ground** cream + concentric closing-rings. **Composes** accent-line, h1, body, cta-button. **Focal**
-a Space Grotesk `h1` near-black, centered, with the one solid cobalt `cta-button` pill below. **Accent**
-the CTA + rings. **Silence** ~60%. **Fixed** one CTA, near-black h1, soft rings. **Free** sign-off, CTA
-label. **Density** low.
-
-## Composition Rules
-
-### Do
-
-- Start every frame on **warm cream**; let **cobalt carry every accent** (eyebrow, numeral, CTA, bar, progress).
-- Set headlines **near-black, −0.02em**; eyebrows **cobalt uppercase 0.08em**; numerals **cobalt 600–700**.
-- Use **tinted cards** (4% fill, 20% border, 10–14px radius, no shadow); body Inter 400 muted, line 1.6.
-- Keep all chrome **pill-shaped (100px)**; one solid cobalt CTA per closing frame.
-- Reserve **atmosphere** (diagonal panel, dots, rings) for cover/closing; content frames keep the slide-header rhythm.
-- Lean left on cover/dashboard/split, centered on quote/closer.
-
-### Don't
-
-- No second accent color; no cobalt headlines.
-- No drop shadows on content (only the soft cobalt CTA hover); no opaque cobalt borders.
-- No square corners (save the progress bar); no font substitutes; no uppercase body.
-- Don't use the green/red change chips as general accents — directional comparisons only.
-- Don't fill space with heavier borders — add substance; don't blow a headline edge-to-edge.
-
-## Aspect-Ratio Behavior
-
-| Treatment         | 16:9                       | 9:16                           | 1:1                      |
-| ----------------- | -------------------------- | ------------------------------ | ------------------------ |
-| Cover             | title left, diagonal right | title top, diagonal band below | title upper, dots corner |
-| Dashboard         | 3 cards across             | 3 stacked                      | 2×2                      |
-| Bar Ranking       | 3–5 bars                   | 3–5 bars (tighter)             | 3 bars                   |
-| Pull Quote        | centered, rings behind     | centered, taller               | centered                 |
-| Split + Highlight | side-by-side               | stacked                        | stacked                  |
-| Closing / CTA     | centered + CTA             | centered + CTA                 | centered + CTA           |
-
-`pad-x` holds on the short edge; re-step display above the 1.4cqw floor. The diagonal cover panel
-becomes a top/bottom band on 9:16. Numerals stay Latin Arabic digits in CJK builds.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Figures, metrics, and quotes are content; the system supplies cream + cobalt + grays.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, financials, percentages, or dates at frame scale. Render slots as `— figure —`,
-`{metric}`, `+NN%`, `↑ —`. Metric cards, bar values, and stat cells especially carry placeholders
-until the script supplies them. Directional chips require a real comparison from the script.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one near-black headline or cobalt numeral dominates per frame.
-- **Silence** — content frames balanced, not crowded; only the dashboard runs dense.
-- **Single accent** — cobalt only; headlines near-black; positive/negative inline only.
-- **Type** — Space Grotesk headings −0.02em near-black, cobalt eyebrows 0.08em + numerals; Inter body muted line 1.6; ≥1.4cqw floor.
-- **Depth** — tinted cards (no shadow), soft rounded corners, 20% cobalt borders; no square content corners.
-- **Anchor** — left on cover/dashboard/split, centered on quote/closer; atmosphere on cover/closing only.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the source's 500ms translateX transitions + bar-fill animations are deck mechanics.
-- **Space Grotesk + Inter via Google Fonts.** CJK pairing (Noto Sans SC 700 display / Noto Serif SC 400 body) carries over; the eyebrow's uppercase+tracking signal weakens in CJK — pair it with the accent-line.
-- **9:16 / 1:1 are guidance**; verify the floor and that the diagonal panel reflows to a band.
-- Diagonal panel (clip-path), dot grid, concentric rings, and bars are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/blue-professional/caption-skin.html

@@ -1,222 +0,0 @@
-<!--
-  Blue Professional — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a blue-professional
-  literal fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a soft cobalt-tinted card on warm cream — a 4% cobalt fill inside a 1.5px
-  20%-cobalt border, soft 14px rounded corners, NO shadow (the system's premium signal
-  is the absence of cast depth; the tinted card does the lift). Space Grotesk, sentence
-  case, near-black glyphs. Upcoming words sit in muted gray; the current word becomes a
-  solid cobalt chip — the brand's signature single-accent gesture, a pill-rounded fill
-  with cream reading on top; spoken words settle to near-black ink, chip cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE tinted card — 4% cobalt fill, 1.5px 20%-cobalt border, soft 14px corners,
-     NO shadow (the tinted card does the lift; cast depth is forbidden) */
-  .caption-pill {
-    max-width: 78%;
-    padding: 20px 44px 24px;
-    background: color-mix(in srgb, var(--cap-accent, #1e2bfa) 4%, var(--cap-canvas, #fdfae7));
-    border: 1.5px solid color-mix(in srgb, var(--cap-accent, #1e2bfa) 20%, transparent);
-    border-radius: 14px;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.1em 0.34em;
-    font-family: var(--font-display, "Space Grotesk"), system-ui, sans-serif;
-    font-weight: 600;
-    font-size: clamp(40px, 4.4vw, 58px);
-    line-height: 1.16;
-    letter-spacing: -0.02em;
-  }
-
-  /* upcoming — muted gray, no chip */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.18em;
-    border-radius: 0.32em;
-    color: color-mix(in srgb, var(--cap-ink, #111111) 52%, var(--cap-canvas, #fdfae7));
-  }
-  /* current word — THE solid cobalt chip (the single-accent gesture; pill-rounded
-     fill, NO shadow), cream reading on top */
-  .caption-word.is-active {
-    color: var(--cap-canvas, #fdfae7);
-    background: var(--cap-accent, #1e2bfa);
-    box-shadow: none;
-  }
-  /* already spoken — solid near-black ink, chip cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #111111);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — cobalt, the system's one accent on a key word */
-  .caption-word.cap-brand {
-    color: var(--cap-accent, #1e2bfa);
-  }
-  /* numerals / data — cobalt 700, the figure voice */
-  .caption-word.cap-num {
-    font-family: var(--font-display, "Space Grotesk"), system-ui, sans-serif;
-    font-weight: 700;
-    color: var(--cap-accent, #1e2bfa);
-  }
-  /* emphasis — a directional-red hairline underline (inline only, never a fill) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 2px;
-    text-decoration-color: var(--cap-accent-2, #dc2626);
-    text-underline-offset: 0.1em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.985 }, { scale: 1, duration: 0.18, ease: "power1.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/bold-poster/FRAME.md

@@ -1,275 +0,0 @@
----
-version: alpha
-name: Bold Poster — Frame (video / frame layer)
-description: >
-  Video-first companion to Bold Poster's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — the four-color palette (white / brown-black ink / tomato red / off-white),
-  the three-face stack (Shrikhand display tilted at poster scale, Libre Baskerville serif body,
-  Space Grotesk mono chrome), the stacked text-shadow on red display, the 3px+1.5px double-border
-  grid, red leftbar cards, red em-dash bullets, and the red progress bar. Composition + frame scale
-  rewritten. Motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  bg: "#FFFFFF"
-  dark: "#1C1410"
-  red: "#D8000F"
-  light: "#F5F2EF"
-
-typography:
-  # — reading + chrome ramp —
-  body:    { fontFamily: "Libre Baskerville", cqw: 0.85, weight: 400, lineHeight: 1.75, color: "dark" }
-  body-cell:{ fontFamily: "Libre Baskerville", cqw: 0.7, weight: 400, lineHeight: 1.55 }
-  label:   { fontFamily: "Space Grotesk", px: 10, weight: 600, tracking: "2px", upper: true, color: "red" }
-  bullet-body:{ fontFamily: "Space Grotesk", cqw: 0.62, weight: 400, lineHeight: 1.45 }
-  # — display / hero ramp (Shrikhand 400, tilted) —
-  card-title:{ fontFamily: "Shrikhand", cqw: 1.9, weight: 400, lineHeight: 1.1, color: "dark" }
-  cell-number:{ fontFamily: "Shrikhand", cqw: 2.7, weight: 400, lineHeight: 1.0, color: "red" }
-  section-header:{ fontFamily: "Shrikhand", cqw: 3.3, weight: 400, lineHeight: 1.0, color: "dark" }
-  red-quote:{ fontFamily: "Shrikhand", cqw: 4.7, weight: 400, lineHeight: 1.15, color: "bg", shadow: "stacked" }
-  hero-title-bottom:{ fontFamily: "Shrikhand", cqw: 10.4, weight: 400, lineHeight: 0.9, color: "dark", rotate: "2deg" }
-  hero-title:{ fontFamily: "Shrikhand", cqw: 11.5, weight: 400, lineHeight: 0.88, color: "dark" }
-  hero-title-red:{ fontFamily: "Shrikhand", cqw: 13.5, weight: 400, lineHeight: 0.85, color: "red", rotate: "-4deg" }
-  close-big:{ fontFamily: "Shrikhand", cqw: 13.5, weight: 400, lineHeight: 0.88, color: "red", rotate: "-5deg" }
-  stat-big:{ fontFamily: "Shrikhand", cqw: 22.0, weight: 400, lineHeight: 0.82, color: "red", rotate: "-6deg" }
-
-spacing:
-  pad-slide: "3cqw 3.6cqw"
-  gap-grid: "1.5cqw 2cqw"
-
-components:
-  progress-bar:
-    backgroundColor: "{colors.red}"
-    size: "0.5cqw tall, bottom edge, width grows with index"
-    description: "The most prominent chrome."
-  hero-title-stack:
-    typography: "{typography.hero-title} + {typography.hero-title-red} + {typography.hero-title-bottom}"
-    transform: "≥4 tilt (−4°/+2°), ≥1 line in {colors.red}"
-    description: "A 3-line Shrikhand composition — the signature opener."
-  stat-big:
-    typography: "{typography.stat-big}"
-    color: "{colors.red} (or {colors.bg} on red with stacked shadow)"
-    transform: "rotate(-6deg)"
-    description: "Hero numeral at poster scale."
-  fin-grid:
-    border: "0.3cqw solid {colors.dark} outer"
-    rule: "0.15cqw solid {colors.dark} inner (touching at intersections)"
-    rounded: "0"
-    typography: "{typography.cell-number} ({colors.red}) + {typography.label} + {typography.body-cell}"
-    description: "The double-border tabular signature."
-  red-leftbar-card:
-    borderLeft: "4px solid {colors.red}"
-    padding: "0 0 0 ~1cqw"
-    rounded: "0"
-    shadow: "none"
-    typography: "{typography.card-title} + {typography.body} + red em-dash bullets"
-    description: "Editorial card cantilevered off a red left rule — no outline."
-  red-panel:
-    backgroundColor: "{colors.red}"
-    textColor: "{colors.bg}"
-    description: "Full-bleed statement surface; display carries the stacked text-shadow."
-  dark-panel:
-    backgroundColor: "{colors.dark}"
-    textColor: "{colors.bg}"
-    description: "Full-bleed dark statement surface; red accents."
-  stacked-text-shadow:
-    shadow: "2px 2px 0 rgba(28,20,16,.25), 4px 4px 0 rgba(28,20,16,.2), 6px 6px 0 rgba(28,20,16,.15)"
-    appliesTo: "red display text on red panels only"
-    description: "The ONLY shadow in the system — text-shadow, not box-shadow."
-  bullet:
-    marker: "red em-dash (—) or round (•) glyph at absolute-left"
-    color: "{colors.red}"
-    description: "No default disc bullets; capped at three."
----
-
-# Bold Poster — Frame (video / frame layer)
-
-## Overview
-
-Bold Poster at frame scale is a **populist editorial poster** — vintage Italian sports-magazine
-display, classical serif body, one saturated tomato red, grids ruled in ink. Every frame should
-feel _printed_: heavy display type at poster scale, locked to one red accent, on a white/off-white
-sheet (or a full red/dark statement panel), with decoration kept to a strict minimum.
-
-The voice is a three-face stack: **Shrikhand** (heavy slab-script, weight 400 only, routinely
-tilted −6°..+2°) carries every hero title, section header, stat, and card title; **Libre
-Baskerville** (literary serif) carries every body paragraph — it's what makes the system feel
-printed; **Space Grotesk** (uppercase, 2–3px tracked) is chrome only — labels, eyebrows, counters,
-bullet bodies. The plane is flat; the _only_ shadow is the stacked text-shadow on red display.
-
-**Key characteristics at frame scale:**
-
-- **Four colors only** — white / brown-black ink / tomato red / off-white. Red is the lone accent.
-- **Shrikhand display, tilted** (−6° stat, −5° close, −4° hero-red, +2° hero-bottom) — the signature movement.
-- **Libre Baskerville serif body** (line 1.75); **Space Grotesk** chrome (uppercase tracked).
-- **Double-border grids** (3px outer + 1.5px inner ink); **red leftbar cards**; **red em-dash bullets** (max 3).
-- **Stacked text-shadow** on red display — the only shadow; flat plane otherwise; square corners.
-- **Red progress bar** at the bottom edge of every frame.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — **one display moment dominates** at 3–6× everything else (the hero stack, `stat-big`, or `close-big`); nothing competes.
-- **Silence** — statement frames reserve **~50–60% negative space**; the **financial grid is the one dense exception**.
-- **Restraint** — **four colors only**, red the lone accent; one display moment per frame; the stacked text-shadow on red is the only shadow; bullets capped at three.
-- **Reference** — aim at a **vintage Italian sports-magazine cover / mid-century European annual report**; failure looks like a **rounded, soft-shadowed multi-accent slide**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad-slide` ~3cqw — deliberately tight so the poster type crowds the frame.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. Borders stay px; rotation transforms hold.
-
-## Colors
-
-Tokens identical to the source. `{colors.bg}` white is the default ground; `{colors.dark}` is body,
-borders, headers; `{colors.red}` is the only accent — every numeral, section rule, eyebrow,
-leftbar, bullet, progress bar, and the full statement-panel ground. `{colors.light}` off-white
-stripes alternating panels. **No fifth color** (no green/blue/yellow); categorical difference comes
-from position, label, and tilt. Red is never body text, never a tint, never an untexted fill.
-
-## Typography
-
-Two ramps. The **reading/chrome ramp** (Baskerville body 0.85cqw, Space Grotesk labels in px)
-carries copy + chrome; the **display ramp** (Shrikhand `section-header` 3.3cqw → `stat-big` 22cqw)
-carries every statement and numeral.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; mono labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤2 words → `stat-big`/`hero-title-red`; 3–4 → `hero-title`; 5+ → `section-header`. The hero is a stacked 3-line composition.
-- **Shrikhand is weight 400, tilted on statement/hero elements, red on numerals**; **Baskerville body at line ≥1.5**; **Space Grotesk chrome uppercase, 2–3px**. Inline `<strong>` switches face to Space Grotesk 600. No italic display, no untilted red hero.
-
-## Depth & Surface
-
-Flat plane. Depth from:
-
-- **Heavy borders** — 3px+1.5px double-border grids, 2px global-card outline, 4px red leftbar rules.
-- **Surface inversion** — full-bleed red or dark statement panels.
-- **Tilt** — rotated Shrikhand breaks the baseline for perceived dimension.
-- **The single shadow** — stacked text-shadow on red display only (text-shadow, three steps).
-
-**Ceiling:** no box-shadow, no rounded surface (square corners; only the hint pill is 4px), no gradient.
-
-## Shapes
-
-- **0 radius everywhere** except the hint pill (4px). Cards, cells, panels, callouts — sharp rectangles.
-
-## Components
-
-- **hero-title-stack** — the 3-line tilted opener. **stat-big** — the poster numeral.
-- **fin-grid** — the double-border tabular signature. **red-leftbar-card** — the cantilevered editorial card.
-- **red-panel / dark-panel** — statement surfaces. **stacked-text-shadow** — the one shadow.
-- **bullet** — red em-dash (max 3). **progress-bar** — the red bottom strip.
-
-## Frame Treatments
-
-> Recipe: ground · register · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> One display moment per frame; statement frames reserve massive negative space.
-
-### 1 · Hero Stack (identity · move: 3-line tilted stack · left)
-
-**Ground** white. **Composes** hero-title-stack, label, body tagline, progress-bar. **Focal** a
-3-line Shrikhand stack (e.g. ink / red-tilted / paper) — one red line, one+ tilted. **Chrome** mono
-eyebrow + Baskerville tagline; bottom progress bar + counter. **Accent** the red line. **Silence**
-right half open. **Fixed** Shrikhand 400, ≥1 tilt + ≥1 red, square. **Free** the words, line sizes.
-**Density** low.
-
-### 2 · Hero Stat (statement · move: poster numeral · red panel · centered)
-
-**Ground** full `{colors.red}`. **Composes** stat-big, label, body sub. **Focal** a `stat-big`
-numeral rotated −6° in white with the stacked shadow, centered, with a mono label above + Baskerville
-sub below. **Accent** the ink stacked-shadow on white. **Silence** ~60%. **Fixed** white-on-red +
-stacked shadow, −6° tilt. **Free** the figure (from script), label. **Density** low.
-
-### 3 · Financial Grid (data · move: double-border matrix · the dense frame)
-
-**Ground** white, `pad-slide`. **Composes** label, section-header, fin-grid. **Focal** a 3px-outer/
-1.5px-inner ink grid of cells (red Shrikhand numeral + mono label + Baskerville body). **Chrome** mono
-eyebrow; progress bar. **Accent** the red numerals. **Silence** tight — the density exception.
-**Fixed** double-border, red numerals, serif body. **Free** figures (from script), labels. **Density** dense-exception.
-
-### 4 · Pull Quote (quote · move: tilted/stacked display · red panel · left)
-
-**Ground** full `{colors.red}`. **Composes** red-quote, Baskerville cite. **Focal** a 2-line Shrikhand
-quote in white with the stacked shadow; a Baskerville cite beneath. **Accent** the stacked shadow.
-**Silence** ~50%. **Fixed** white-on-red + stacked shadow. **Free** quote, cite. **Density** low.
-
-### 5 · Editorial Cards (content · move: red leftbar cards · left)
-
-**Ground** white (or alternating off-white stripes). **Composes** label, section-header, 2–3×
-red-leftbar-card. **Focal** cards cantilevered off 4px red rules — Shrikhand title + Baskerville body
-
-- red em-dash bullets (max 3). **Accent** the red left rules + bullets. **Silence** moderate. **Fixed**
-  4px red leftbar, em-dash bullets, no outline. **Free** card content. **Density** standard.
-
-### 6 · Closing Statement (closer · move: tilted close-big · centered/left)
-
-**Ground** white or `{colors.dark}`. **Composes** close-big, label, body sub, progress-bar. **Focal**
-a Shrikhand `close-big` (rotated −5°, red) sign-off; mono eyebrow + Baskerville contact line. **Accent**
-the red tilted title. **Silence** ~60%. **Fixed** −5° tilt, red close-big. **Free** sign-off, contact.
-**Density** low.
-
-## Composition Rules
-
-### Do
-
-- Stack hero titles in 3 Shrikhand lines — at least one tilted, at least one red.
-- Make every numeral **red Shrikhand**; tilt statement display **−5° to −6°**.
-- Set eyebrows in **Space Grotesk 600 uppercase, 2–3px**, red; body in **Baskerville, line 1.75**.
-- Build data grids with the **3px outer + 1.5px inner double border**; use red leftbar cards elsewhere.
-- Use **red em-dash bullets, capped at three**; apply the stacked text-shadow on red display.
-- One display moment per frame; reserve negative space on statement frames.
-
-### Don't
-
-- No second accent color; no rounded corners (square only, save the hint pill).
-- No drop shadow — the stacked text-shadow on red is the only one.
-- No font substitutes; no Shrikhand body, no Baskerville labels, no Space Grotesk headlines.
-- No default disc bullets; no untilted red statement display.
-- Don't crowd a statement frame; don't blow a long line edge-to-edge (step down).
-
-## Aspect-Ratio Behavior
-
-| Treatment       | 16:9                      | 9:16                     | 1:1                  |
-| --------------- | ------------------------- | ------------------------ | -------------------- |
-| Hero Stack      | stack left, tagline below | stack centered, taller   | stack, tagline below |
-| Hero Stat       | numeral centered          | numeral centered, taller | centered             |
-| Financial Grid  | 3 cells across            | 2 across / stacked       | 2×2                  |
-| Pull Quote      | quote left                | quote stacked            | centered             |
-| Editorial Cards | 2–3 across                | stacked                  | stacked              |
-| Closing         | close-big centered        | close-big stacked        | centered             |
-
-`pad-slide` stays tight on the short edge; re-step display so the line stays ≤78cqw above the floor.
-Tilts hold; the progress bar spans the bottom on every ratio.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. The system supplies type, one red, and ink rules, not brands.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, financials, percentages, or dates at frame scale. Render slots as `— figure —`,
-`{metric}`, `+NN%`. Fin-grid cells and stat-big especially carry placeholders until the script
-supplies them. Catalogue numbers / progress are decorative.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one display moment dominates; nothing competes.
-- **Silence** — statement frames reserve ~50–60% negative space; only the fin-grid runs dense.
-- **Color** — four colors only; red is the lone accent; no red body text.
-- **Type** — Shrikhand 400 tilted on statements, red numerals, fit-to-measure; Baskerville body line 1.75; mono chrome uppercase 2–3px; ≥1.4cqw floor.
-- **Depth** — flat; the stacked text-shadow on red display is the only shadow; square corners.
-- **Bullets** — red em-dash, capped at three.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the source's 550ms slide transitions are deck mechanics.
-- **Shrikhand + Libre Baskerville + Space Grotesk via Google Fonts.** CJK: Noto Serif SC 900/400 + Noto Sans SC; Shrikhand's slab-script has no Hanzi equal — keep tilts + red + double-borders to carry the identity.
-- **9:16 / 1:1 are guidance**; verify the one big line ≤78cqw per ratio and that tilts don't clip.
-- Grids, leftbar cards, and the stacked shadow are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/bold-poster/caption-skin.html

@@ -1,229 +0,0 @@
-<!--
-  Bold Poster — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a bold-poster
-  literal fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a fresh-paper card with bold poster framing — a heavy 1.5px brown-black ink
-  rule plus a 4px tomato-red leftbar (the brand's cantilevered-card signature), SQUARE
-  corners, NO drop shadow (the system's only shadow is the stacked text-shadow on red
-  display). Serif body face, ink glyphs. Upcoming words sit in faint ink; the current
-  word slams into a tomato-red panel (the brand's signature surface inversion, a hard
-  square block on paper-white reading, no blur) with the stacked text-shadow on it;
-  spoken words settle to solid ink, panel cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE paper card — heavy 1.5px brown-black ink rule + a 4px tomato-red leftbar
-     (bold poster's cantilevered red-leftbar-card signature), square corners, NO
-     drop shadow (the only shadow in the system is the stacked text-shadow on red) */
-  .caption-pill {
-    max-width: 78%;
-    padding: 20px 44px 24px;
-    background: var(--cap-canvas, #ffffff);
-    border: 1.5px solid var(--cap-ink, #1c1410);
-    border-left: 4px solid var(--cap-accent, #d8000f);
-    border-radius: 0;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.1em 0.34em;
-    font-family: var(--font-display, "Shrikhand"), Georgia, serif;
-    font-weight: 400;
-    font-size: clamp(40px, 4.4vw, 58px);
-    line-height: 1.16;
-    letter-spacing: -0.01em;
-  }
-
-  /* upcoming — faint brown-black ink, no panel */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.06em;
-    color: color-mix(in srgb, var(--cap-ink, #1c1410) 42%, var(--cap-canvas, #ffffff));
-  }
-  /* current word — THE tomato-red panel (box-shadow spread = a hard square block
-     w/o layout shift; no blur), paper-white reading on top carrying the stacked
-     text-shadow — bold poster's surface-inversion + only-shadow signatures */
-  .caption-word.is-active {
-    color: var(--cap-canvas, #ffffff);
-    background: var(--cap-accent, #d8000f);
-    box-shadow: 0 0 0 0.06em var(--cap-accent, #d8000f);
-    text-shadow:
-      0.03em 0.03em 0 rgba(28, 20, 16, 0.25),
-      0.06em 0.06em 0 rgba(28, 20, 16, 0.2),
-      0.09em 0.09em 0 rgba(28, 20, 16, 0.15);
-  }
-  /* already spoken — solid brown-black ink, panel cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #1c1410);
-    background: transparent;
-    box-shadow: none;
-    text-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — Shrikhand display, bold poster's display face inflection */
-  .caption-word.cap-brand {
-    font-family: var(--font-display, "Shrikhand"), Georgia, serif;
-  }
-  /* numerals / data — the mono chrome voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "Libre Baskerville"), ui-monospace, monospace;
-    color: color-mix(in srgb, var(--cap-ink, #1c1410) 72%, var(--cap-canvas, #ffffff));
-  }
-  /* emphasis — a tomato-red em-dash-weight underline (the lone accent) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 2px;
-    text-decoration-color: var(--cap-accent-2, #f5f2ef);
-    text-underline-offset: 0.1em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.9 }, { scale: 1, duration: 0.16, ease: "back.out(2.2)" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/broadside/FRAME.md

@@ -1,284 +0,0 @@
----
-version: alpha
-name: Broadside — Frame (video / frame layer)
-description: >
-  Video-first companion to Broadside's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — the two-register surface system (dark ink-black / fire-orange), massive
-  Barlow in lowercase weight 900 treated as graphic primitive, IBM Plex Mono chrome (uppercase,
-  0.14em), the single fire-orange accent, the flat plane, and 1px hairline dividers. Composition +
-  frame scale rewritten for the frame. Motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  ink-black: "#111111"
-  ink-black-alt: "#1A1A18"
-  fire-orange: "#E85D26"
-  cream: "#F0ECE5"
-  cream-muted: "#888880"
-  cream-hint: "#505048"
-  border-dark: "#282826"
-  ink-on-orange-muted: "rgba(17,17,17,0.75)"
-  ink-on-orange-hint: "rgba(17,17,17,0.55)"
-  ink-on-orange-faint: "rgba(17,17,17,0.40)"
-  ink-on-orange-border: "rgba(17,17,17,0.20)"
-
-typography:
-  # — reading ramp —
-  body:    { fontFamily: "Barlow", cqw: 1.2, weight: 400, lineHeight: 1.6 }
-  lead:    { fontFamily: "Barlow", cqw: 1.6, weight: 400, lineHeight: 1.5 }
-  caption: { fontFamily: "Barlow", cqw: 0.9, weight: 400, lineHeight: 1.5 }
-  label:   { fontFamily: "IBM Plex Mono", cqw: 0.72, weight: 500, tracking: "0.14em", upper: true }
-  # — display / hero ramp (Barlow, lowercase, negative tracking) —
-  h3:      { fontFamily: "Barlow", cqw: 2.8, weight: 600, lineHeight: 1.2, lower: true }
-  quote-text:{ fontFamily: "Barlow", cqw: 3.8, weight: 700, lineHeight: 1.15, tracking: "-0.02em", lower: true }
-  h2:      { fontFamily: "Barlow", cqw: 4.5, weight: 700, lineHeight: 1.1, tracking: "-0.02em", lower: true }
-  stat-value:{ fontFamily: "Barlow", cqw: 5.5, weight: 900, lineHeight: 1.0, tracking: "-0.04em" }
-  h1:      { fontFamily: "Barlow", cqw: 7.5, weight: 800, lineHeight: 0.9, tracking: "-0.03em", lower: true }
-  fadelist-item:{ fontFamily: "Barlow", cqw: 7.5, weight: 900, lineHeight: 1.0, tracking: "-0.03em", lower: true }
-  quote-mark:{ fontFamily: "Barlow", cqw: 10.0, weight: 900, lineHeight: 0.6 }
-  fadelist-title:{ fontFamily: "Barlow", cqw: 10.5, weight: 900, lineHeight: 0.9, tracking: "-0.04em", lower: true }
-  display: { fontFamily: "Barlow", cqw: 13.0, weight: 900, lineHeight: 0.88, tracking: "-0.04em", lower: true }
-
-spacing:
-  pad-x: "5.5cqw"
-  pad-y: "5.5cqw"
-  gap-lg: "3.5cqw"
-  gap-md: "2cqw"
-  gap-sm: "1cqw"
-
-components:
-  registers:
-    dark: "ground {colors.ink-black}, text {colors.cream}, accent {colors.fire-orange}"
-    orange: "ground {colors.fire-orange}, text {colors.ink-black}"
-    description: "Two surfaces only — no cream/paper register. One register per frame."
-  slide-chrome:
-    rule: "1px solid {colors.border-dark} (dark) / 20% ink (orange)"
-    placement: "top + bottom bars (label left, number right)"
-    description: "SUPPRESSED on cover/chapter/statement/quote/end — declarative frames let type fill the field."
-  kicker:
-    typography: "{typography.label}"
-    color: "{colors.fire-orange} (dark) / 55% ink (orange)"
-    description: "Uppercase mono eyebrow."
-  rule:
-    backgroundColor: "{colors.fire-orange} (dark) / {colors.ink-black} (orange)"
-    size: "36×2px"
-    description: "Stub accent bar — the system's only ornament."
-  broadside-num:
-    typography: "{typography.label}"
-    placement: "top-left of orange cover/chapter, low opacity"
-    description: "Mono catalogue numeral."
-  stat-card:
-    borderTop: "1px solid {colors.border-dark}"
-    typography: "{typography.stat-value} (orange on dark / ink on orange) + {typography.body} + {typography.label}"
-    description: "Top-border-only block, no other borders."
-  bullet:
-    marker: "orange `/` mono via ::before"
-    typography: "{typography.lead}"
-    description: "Capped at THREE items."
-  bar-track:
-    borderLeft: "1px solid {colors.border-dark}"
-    bars: "{colors.cream-hint}, one .accent {colors.fire-orange}"
-    typography: "{typography.label} axis"
-    description: "Vertical bar chart, left axis only."
-  compare-panel:
-    layout: "two equal panels split by a 1px vertical rule"
-    payoff: "right panel may fill {colors.fire-orange}"
-    description: "Before/after."
-  fadelist:
-    typography: "{typography.fadelist-item} ×3 at opacity 1.0/0.5/0.22 + {typography.fadelist-title}"
-    description: "Three stacked words + one oversized title opposite."
----
-
-# Broadside — Frame (video / frame layer)
-
-## Overview
-
-Broadside at frame scale is a **protest-poster system where type is so large it stops reading as
-text and becomes graphic primitive.** Barlow `display` at 13cqw puts a single lowercase word
-nearly across the frame. The system runs in **two registers**: a dark ink-black ground with cream
-text for documentation, and a fire-orange ground with dark ink for declaration. Fire-orange is the
-_only_ color — accent on dark, environment on orange. The plane is flat; hierarchy is weight, size,
-and 1px hairlines.
-
-**Barlow** carries every text role from display to body — expressive range from weight (400–900)
-and size, not face contrast. **IBM Plex Mono** is chrome only (numbers, kickers, tags, axis labels,
-the `/` bullet marker), always uppercase and tracked. Display is **lowercase** — the system's most
-distinctive single decision, a deliberate inversion of the brutalist norm.
-
-**Key characteristics at frame scale:**
-
-- **Two registers** — dark (cream text) / orange (ink text). No cream/paper register.
-- **Massive lowercase Barlow 900**, negative-tracked, as graphic primitive (display 13cqw).
-- **Fire-orange is the only color** — accent on dark, full environment on orange.
-- **IBM Plex Mono chrome** — uppercase, 0.14em; the `/` bullet marker; mono catalogue numbers.
-- **Flat plane** — no shadow, no radius (save nav dots), no gradient; 1px hairlines carry structure.
-- **Low density** — one statement per frame, bullets capped at three, chrome suppressed on declarative frames.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — exactly **one display moment dominates** at 3–6× everything else; nothing competes.
-- **Silence** — declarative frames read **45–55% empty**; the **stat grid is the one dense exception**.
-- **Restraint** — **one register per frame**; **fire-orange is the only color** (accent on dark, environment on orange); one display moment; bullets capped at three.
-- **Reference** — aim at **broadside printing / a SPACE10 report / a Wim Crouwel grid with one loud color**; failure looks like a **multi-accent corporate slide deck**.
-
-- **Primary:** 1920×1080 (16:9). Type authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`; or carry the source's `vw` 1:1).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad-x`/`pad-y` 5.5cqw — deliberately tight so the massive type crowds the frame edge.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw` (a `vw`-sized frame inflates when not
-full-screen). 1px hairlines stay 1px.
-
-## Colors
-
-Tokens identical to the source, in two registers. **Dark:** `{colors.ink-black}` ground,
-`{colors.cream}` text, `{colors.fire-orange}` accent (kickers, accent stat, bullet `/`, lead bar,
-quote mark, rule stub). **Orange:** `{colors.fire-orange}` ground, `{colors.ink-black}` headlines +
-body, with the dark-ink overlays (75/55/40/20%) as the muted tones. Choose one register per frame
-and commit. **No second accent color** — on orange, emphasis is weight/opacity on the ink, never a
-new hue. Cream text on orange does not exist (ink-on-fire is absolute).
-
-## Typography
-
-Two ramps. The **reading ramp** (Barlow body 1.2cqw, mono label 0.72cqw) carries copy + chrome; the
-**display ramp** (Barlow `h2` 4.5cqw → `display` 13cqw, weight 700–900) carries every statement.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; mono labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤2 words → `display`; 3–4 → `h1`; 5+ → `h2`. Broadside packs only ONE display moment per frame.
-- **Barlow display is lowercase, weight 700–900, negative-tracked** (−0.04em largest, −0.02em h2). **Mono chrome is uppercase, 0.1em+.** No italic, no underline, no uppercase display.
-
-## Depth & Surface
-
-Flat plane, the only technique. Hierarchy from:
-
-- **Weight + size contrast** — the dominant signal (900 lowercase display).
-- **1px hairlines** — chrome bars, stat-card top, compare divider, bar-track left, chart baseline.
-- **Color shift** — orange on ink, ink on cream, cream-muted on cream.
-- **Negative space** — generous, intentional empty regions.
-
-**Ceiling:** no box-shadow, no elevation, no rounded surface (save nav dots), no gradient ground.
-
-## Shapes
-
-- **0 radius everywhere** except nav dots (50%). Cards, panels, tags, stat blocks, bars — sharp rectangles.
-
-## Components
-
-- **registers** — the two-surface system. **slide-chrome** — optional hairline bars, suppressed on declarative frames.
-- **kicker** (mono eyebrow) / **rule** (36×2 stub) / **broadside-num** (catalogue mark) — the chrome ornament set.
-- **stat-card** (top-border only) / **bullet** (orange `/`, max 3) / **bar-track** (one accent bar) / **compare-panel** (orange payoff) / **fadelist** (1.0/0.5/0.22 stack).
-
-## Frame Treatments
-
-> Recipe: ground · register · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> One statement per frame; chrome suppressed on declarative frames.
-
-### 1 · Cover (identity · move: massive type · ORANGE register · left)
-
-**Ground** fire-orange. **Composes** broadside-num, rule, kicker, display, lead. **Focal** a 1–2 word
-Barlow `display` (13cqw) lowercase in ink, left-anchored, over a small ink rule stub + mono kicker; a
-Barlow lead line beneath in 75% ink. **Chrome** mono catalogue number top-left, mono meta top-right
-(no chrome bars). **Accent** the ink itself is the pop on orange. **Silence** ~45%. **Fixed** ink-on-fire,
-lowercase 900, flat. **Free** the word, kicker, lead. **Density** low.
-
-### 2 · Statement (declarative · move: type IS composition · DARK register · left)
-
-**Ground** ink-black. **Composes** kicker, display. **Focal** a 2–4 word Barlow `display`/`h1`
-lowercase in cream, with ONE clause inked `{colors.fire-orange}`. **Chrome** mono kicker; no bars.
-**Accent** the orange clause. **Silence** ~55%. **Fixed** lowercase 900, one orange clause, flat.
-**Free** the statement, which clause is orange. **Density** low.
-
-### 3 · Stat Grid (data · move: top-border cards · DARK · the dense frame)
-
-**Ground** ink-black, chrome bars present. **Composes** slide-chrome, kicker, 3× stat-card. **Focal** a
-row of three top-border-only stat-cards — big Barlow-900 numeral in `{colors.fire-orange}`, Barlow
-label, mono note. **Chrome** top + bottom hairline bars (label + number). **Accent** the orange
-numerals. **Silence** moderate — the density exception. **Fixed** top-border-only cards, orange
-numerals, 1px hairlines. **Free** figures (from script), labels. **Density** dense-exception.
-
-### 4 · Fadelist (narrative · move: opacity stack · DARK)
-
-**Ground** ink-black. **Composes** fadelist (3 stacked Barlow-900 words at 1.0/0.5/0.22), fadelist-title.
-**Focal** the three-stage word stack opposite an oversized display title in `{colors.fire-orange}`
-(before/during/after). **Accent** the orange title. **Silence** moderate. **Fixed** the opacity
-ladder, lowercase 900. **Free** the three words, the title. **Density** low-moderate.
-
-### 5 · Pull Quote (quote · move: oversized mark · DARK · left)
-
-**Ground** ink-black, chrome suppressed. **Composes** quote-mark, quote-text, attribution. **Focal** a
-Barlow `quote-text` (700, lowercase) at ≤78cqw under an oversized fire-orange `quote-mark` (10cqw,
-line-height 0.6). **Chrome** mono attribution (name + role). **Accent** the orange quote mark. **Silence**
-~50%. **Fixed** orange mark, lowercase quote. **Free** quote, attribution. **Density** low.
-
-### 6 · Compare (argument · move: split + orange payoff · DARK→ORANGE)
-
-**Ground** ink-black left panel + fire-orange right (payoff) panel, 1px divider. **Composes**
-compare-panel pair, kicker, h3. **Focal** two panels — left documents (cream on dark), right declares
-(ink on orange). **Chrome** mono panel labels. **Accent** the orange payoff panel. **Silence** moderate.
-**Fixed** ink-on-fire right panel, 1px divider, flat. **Free** the before/after content. **Density** standard.
-
-## Composition Rules
-
-### Do
-
-- Set every Barlow display in **lowercase weight 900**, negative-tracked — the system's signature.
-- Use **fire-orange as full environment** on declarative frames, the **lone accent** on dark.
-- Keep chrome in **IBM Plex Mono uppercase, 0.14em**; use the `/` mono bullet marker.
-- **Cap bullets at three; one statement per frame**; build hierarchy from weight, size, 1px hairlines.
-- Suppress chrome bars on cover/chapter/statement/quote/end; let type fill the field.
-- Lean left on most frames; the type IS the composition.
-
-### Don't
-
-- Never uppercase Barlow display; never add a second accent color.
-- Never put cream text on orange (ink-on-fire is absolute); never a cream/paper register.
-- No drop shadow, no rounded surface (save nav dots), no gradient ground.
-- No serif companion; chrome is never Barlow.
-- Don't pack two display moments into one frame; don't blow a long line edge-to-edge — step down.
-
-## Aspect-Ratio Behavior
-
-| Treatment  | 16:9                       | 9:16                       | 1:1              |
-| ---------- | -------------------------- | -------------------------- | ---------------- |
-| Cover      | word left, lead below      | word top, lead below       | centered word    |
-| Statement  | display left               | display stacked taller     | display centered |
-| Stat Grid  | 3 across                   | 3 stacked                  | 2+1              |
-| Fadelist   | stack + title side-by-side | stack over title           | stack over title |
-| Pull Quote | mark + quote left          | mark top, quote below      | centered         |
-| Compare    | side-by-side panels        | stacked (dark over orange) | stacked          |
-
-`pad-x` holds tight on the short edge; re-step display so the one big line stays ≤78cqw and above the
-1.4cqw floor. Mono chrome stays Latin/digit-only.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder (the dashed `img-placeholder` at 55cqh). The system supplies type and one color, not brands.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, percentages, dates, or counts at frame scale. Render slots as `— figure —`,
-`{metric}`, `NN%`. Stat-card numerals and bar heights carry placeholders until the script supplies
-them. Catalogue numbers (No. 01) are decorative chrome and may be sequential.
-
-## Pre-Render Self-Audit
-
-- **Squint** — exactly one display moment dominates; nothing competes.
-- **Silence** — declarative frames ~45–55% empty; only the stat grid runs dense.
-- **Register** — one register per frame; ink-on-fire on orange, cream on dark; no second hue.
-- **Type** — Barlow lowercase 900 negative-tracked, fit-to-measure; mono chrome uppercase 0.14em; ≥1.4cqw floor.
-- **Depth** — 0 shadow, 0 radius (save nav dots); 1px hairlines only.
-- **Bullets** — capped at three, orange `/` marker.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the source's 0.8s deck slide + per-element entry animations are deck mechanics.
-- **Barlow + IBM Plex Mono via Google Fonts**; Noto Sans SC is the CJK fallback (the lowercase-display signal has no CJK equivalent — the two-register color system carries the identity, per the source).
-- **9:16 / 1:1 are guidance**; verify the one big line stays ≤78cqw and above the floor per ratio.
-- Bars, compare panels, and the dashed image placeholder are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/broadside/caption-skin.html

@@ -1,224 +0,0 @@
-<!--
-  Broadside — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a broadside literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a protest-poster lower third — an ink-black plate on a single 1px fire-orange
-  hairline, SHARP corners, NO shadow (broadside's plane is flat, never cast). Massive
-  lowercase Barlow 900 as graphic primitive, cream glyphs on ink. Upcoming words sit in
-  faint cream; the current word flips register — a hard flat fire-orange block with ink
-  reading on top (broadside's signature two-register flip, no blur), the brand's lone
-  accent; spoken words settle to solid cream, the orange block cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE ink-black plate — single 1px fire-orange hairline (broadside's lone accent),
-     SHARP corners (0 radius), NO shadow (the plane is flat) */
-  .caption-pill {
-    max-width: 80%;
-    padding: 18px 44px 22px;
-    background: var(--cap-ink, #111111);
-    border: 1px solid var(--cap-accent, #e85d26);
-    border-radius: 0;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.04em 0.3em;
-    font-family: var(--font-display, "Barlow"), system-ui, sans-serif;
-    font-weight: 900;
-    font-size: clamp(38px, 4.2vw, 56px);
-    line-height: 1.02;
-    letter-spacing: -0.03em;
-    text-transform: lowercase;
-  }
-
-  /* upcoming — faint cream, no block (massive lowercase Barlow 900 as graphic primitive) */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.08em;
-    color: color-mix(in srgb, var(--cap-canvas, #f0ece5) 42%, var(--cap-ink, #111111));
-  }
-  /* current word — THE register flip: a hard flat fire-orange block (box-shadow spread =
-     a sharp rectangle w/o layout shift; no blur), ink reading on top — the lone accent */
-  .caption-word.is-active {
-    color: var(--cap-ink, #111111);
-    background: var(--cap-accent, #e85d26);
-    box-shadow: 0 0 0 0.06em var(--cap-accent, #e85d26);
-  }
-  /* already spoken — solid cream, the orange block cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-canvas, #f0ece5);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — fire-orange ink, the cream-on-ink register's only inflection */
-  .caption-word.cap-brand {
-    color: var(--cap-accent, #e85d26);
-  }
-  /* numerals / data — the IBM Plex Mono chrome voice, uppercase + tracked, recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "IBM Plex Mono"), ui-monospace, monospace;
-    font-weight: 500;
-    text-transform: uppercase;
-    letter-spacing: 0.06em;
-    color: color-mix(in srgb, var(--cap-canvas, #f0ece5) 72%, var(--cap-ink, #111111));
-  }
-  /* emphasis — a fire-orange hairline underline (no second hue; the lone accent again) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 2px;
-    text-decoration-color: var(--cap-accent-2, #e85d26);
-    text-underline-offset: 0.1em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(32px, 5.2vw, 46px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.92 }, { scale: 1, duration: 0.1, ease: "power3.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/capsule/FRAME.md

@@ -1,284 +0,0 @@
----
-version: alpha
-name: Capsule — Frame (video / frame layer)
-description: >
-  Video-first companion to Capsule's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — the pill geometry (9999px small / 2rem cards) with a 2px ink outline on
-  everything, the sun-bleached cream canvas, the nine-color candy palette, Bodoni Moda + Space
-  Grotesk, soft hard-offset shadows (4/6/8/12px in 8% ink), floating decorative-pill wallpaper,
-  radial accent glows, and the grain overlay. Composition + frame scale rewritten. Motion out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  cream: "#F5F5F0"
-  ink: "#1A1A1A"
-  outline: "#1E1E1E"
-  white: "#FFFFFF"
-  coral: "#E85D4E"
-  lime: "#C4D94E"
-  lavender: "#C5B5E0"
-  sky: "#8BB4F7"
-  violet: "#A06CE8"
-  yellow: "#F2D160"
-  peach: "#F5B895"
-  mint: "#A8E6CF"
-  shadow: "rgba(26,26,26,0.08)"
-
-typography:
-  # — reading ramp (Space Grotesk) —
-  body:      { fontFamily: "Space Grotesk", cqw: 0.85, weight: 400, lineHeight: 1.6 }
-  subtitle:  { fontFamily: "Space Grotesk", cqw: 0.95, weight: 400, tracking: "0.18em", upper: true }
-  pill-text: { fontFamily: "Space Grotesk", cqw: 0.75, weight: 600, tracking: "0.12em", upper: true }
-  label:     { fontFamily: "Space Grotesk", px: 14, weight: 500, tracking: "0.1em", upper: true }
-  # — display / hero ramp (Bodoni Moda, ink, sentence case) —
-  card-headline:{ fontFamily: "Bodoni Moda", cqw: 1.9, weight: 700, lineHeight: 1.1 }
-  orbit-numeral:{ fontFamily: "Bodoni Moda", cqw: 2.6, weight: 700, lineHeight: 1.0 }
-  quote-display:{ fontFamily: "Bodoni Moda", cqw: 4.2, weight: 600, lineHeight: 1.3, tracking: "-0.01em" }
-  stat-number: { fontFamily: "Bodoni Moda", cqw: 3.6, weight: 800, lineHeight: 1.0, tracking: "-0.03em" }
-  section-headline:{ fontFamily: "Bodoni Moda", cqw: 4.0, weight: 700, lineHeight: 1.05, tracking: "-0.01em" }
-  headline:    { fontFamily: "Bodoni Moda", cqw: 5.0, weight: 700, lineHeight: 1.05, tracking: "-0.02em" }
-  closing-display:{ fontFamily: "Bodoni Moda", cqw: 8.5, weight: 800, lineHeight: 0.95, tracking: "-0.03em" }
-  display:     { fontFamily: "Bodoni Moda", cqw: 12.0, weight: 800, lineHeight: 0.88, tracking: "-0.03em" }
-
-spacing:
-  pad: "5cqw"
-  gap-md: "2cqw"
-  card-pad: "2cqw 1.6cqw"
-
-components:
-  pill:
-    rounded: "9999px (small) / 2rem (cards)"
-    border: "0.2cqw solid {colors.outline}"
-    backgroundColor: "any candy or {colors.white}"
-    description: "The universal container — every chip/button/label/stat tile/node/bar. No unstroked pill exists."
-  pill-card:
-    backgroundColor: "{colors.white}"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "2rem"
-    shadow: "0.4cqw 0.4cqw 0 {colors.shadow}"
-    typography: "{typography.card-headline} + {typography.body}"
-    description: "Holds a circular card-icon, Bodoni headline, Space Grotesk body."
-  stat-pill:
-    backgroundColor: "{colors.white}"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "2rem"
-    shadow: "0.3cqw 0.3cqw 0 {colors.shadow}"
-    typography: "{typography.stat-number} (COLORED) + {typography.pill-text}"
-    description: "The one place color touches a numeral; + a 40px accent bar."
-  title-pill:
-    backgroundColor: "{colors.yellow}"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "9999px"
-    shadow: "0.3cqw 0.3cqw 0 {colors.shadow}"
-    typography: "{typography.pill-text}"
-    description: "Sits above the display headline on cover/closing."
-  card-icon:
-    backgroundColor: "any candy"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "50%"
-    size: "60px"
-    typography: "Bodoni numeral/letter in {colors.ink}"
-    description: "Card mark."
-  floating-pill:
-    backgroundColor: "any candy"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "9999px / 50%"
-    transform: "rotate(−20°..+25°)"
-    shadow: "none"
-    typography: "{typography.pill-text}"
-    description: "Decorative wallpaper confetti, 5–8 per declarative frame. Flat — no shadow."
-  quote-highlight:
-    backgroundColor: "{colors.lime} / {colors.sky}"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "9999px"
-    description: "Inline candy pill wrapping a phrase inside a Bodoni quote — the emphasis mechanism, replacing bold/italic."
-  bar-track:
-    backgroundColor: "{colors.cream}"
-    border: "0.2cqw solid {colors.outline}"
-    rounded: "9999px"
-    fill: "child candy pill, value at right edge"
-    description: "36px pill chart track."
-  accent-line:
-    backgroundColor: "{colors.coral}"
-    rounded: "9999px"
-    size: "60×4 (80×4 closing)"
-    description: "Coral pill rule."
-  atmosphere:
-    background: "1–3 radial candy glows (6–15% opacity) over {colors.cream} + 4% grain overlay"
-    description: "Baseline canvas layers on every frame. Never absent."
----
-
-# Capsule — Frame (video / frame layer)
-
-## Overview
-
-Capsule at frame scale is a **playful editorial system where every container is a pill.** The
-`border-radius: 9999px` (small) / `2rem` (cards) rule plus a 2px ink outline wraps every chip,
-card, icon, bar, and node — inflated, friendly, graphically distinct. The canvas is sun-bleached
-cream warmed by soft radial candy glows and a permanent 4% grain overlay.
-
-The voice is a two-face conversation: **Bodoni Moda** (didone serif, weight 700–800, always ink,
-always sentence case) carries every headline, stat, and quote; **Space Grotesk** carries body and
-all uppercase tracked pill/label text. Nine candy accents fill pills interchangeably with no
-semantic meaning. Depth is a **soft hard-offset shadow** (4/6/8/12px in 8% ink) — lifted, not
-stamped — reserved for content-bearing containers; decorative floating pills are flat.
-
-**Key characteristics at frame scale:**
-
-- **Pill geometry everywhere** — 9999px small, 2rem cards — each wrapped in a 2px `{colors.outline}` stroke.
-- **Bodoni Moda** display (ink, sentence case) + **Space Grotesk** body/pills (uppercase, tracked).
-- **Nine candy accents**, interchangeable; color touches stat numerals + pill fills, never headlines.
-- **Soft offset shadows** (4/6/8/12px, 8% ink) on content containers only; floating pills are flat.
-- **Floating decorative-pill wallpaper** (5–8, tilted) + radial glows + 4% grain on declarative frames.
-- **Cream canvas** warmed by atmosphere — bare corners read as broken.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one Bodoni headline or stat dominates at **3–6× its nearest neighbor**.
-- **Silence** — declarative frames carry **atmosphere, not clutter** (pills as wallpaper, not content); the **pillar-cards and stat grid are the dense exception**.
-- **Restraint** — every pill carries the 2px outline; color touches **fills + stat numerals only** (never a headline); soft shadow on content-bearing pills only (floating pills are flat); no tenth accent.
-- **Reference** — aim at a **Memphis / ice-cream-parlor editorial spread**; failure looks like a **flat, sticker-less SaaS card grid**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad` (5cqw); floating pills may bleed off edges as wallpaper.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size` AND carries
-the radial-glow + grain atmosphere; ALL frame-relative units are `cqw`/`cqh` against it — never
-`vw`. Pill radii stay `9999px`/`2rem` (shape, not scale); shadow offsets scale in `cqw`.
-
-## Colors
-
-Tokens identical to the source. `{colors.cream}` is the ground; `{colors.ink}`/`{colors.outline}`
-is type + the universal 2px stroke; the nine candy accents fill pills with **no semantic mapping**
-— pair a warm (coral/yellow/peach) with a cool (sky/lavender/violet/mint) with a neutral-bright
-(lime); never two same-family adjacent. Color appears on **stat numerals and pill fills only** —
-never on a Bodoni headline. Shadow is always `{colors.shadow}` (8% ink). No tenth color.
-
-## Typography
-
-Two ramps. The **reading ramp** (Space Grotesk body 0.85cqw, uppercase tracked pill/label text)
-carries copy + chips; the **display ramp** (Bodoni `card-headline` 1.9cqw → `display` 12cqw, all
-700–800) carries every headline, stat, and quote.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; px labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `display`/`closing-display`; 4–6 → `headline`; 7+ → `section-headline`.
-- **Bodoni 700+ in ink, sentence case** (italic via `<em>` only, color allowed on the italic key word as a candy hue); **Space Grotesk pills/labels uppercase, 0.08em+ tracked**; negative-track Bodoni display.
-
-## Depth & Surface
-
-Soft hard-offset shadow is the only depth, in `{colors.shadow}` (8% ink), bottom-right:
-
-- **0.2cqw (4px)** small nodes; **0.3cqw (6px)** stat-pills, orbit pills, diagram nodes; **0.4cqw (8px)** pillar-cards; **0.6cqw (12px)** the visual frame.
-- The **2px outline** does most of the lift against cream; the shadow adds the float.
-- **Decorative floating pills cast no shadow** — this separates content from atmosphere at a glance.
-
-**Ceiling:** no blurred shadow, no re-colored shadow, no gradient depth.
-
-## Shapes
-
-- **9999px** — all small pills (chips, buttons, bars, nodes, floating pills, quote highlights, accent lines).
-- **2rem** — larger cards (pillar-card, stat-pill, chart container, visual frame).
-- **50%** — circular pills (card-icon 60px, step-node 56px, orbit-center 160px, nav dots).
-- **0** — only the grain overlay and the gradient region inside a visual frame. No sharp-cornered text container exists.
-
-## Components
-
-- **pill** — the universal 2px-outlined container. **pill-card / stat-pill / title-pill** — the white/yellow content pills with soft shadows.
-- **card-icon** — circular candy mark; **floating-pill** — flat tilted wallpaper confetti; **quote-highlight** — inline candy emphasis pill.
-- **bar-track** — pill-shaped chart bar; **accent-line** — coral pill rule; **atmosphere** — the baseline glow + grain on every frame.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> Atmosphere (glow + grain) on every frame; declarative frames carry floating-pill wallpaper.
-
-### 1 · Cover (identity · move: title pill + display · centered)
-
-**Ground** cream + atmosphere, floating-pill wallpaper. **Composes** title-pill, display, accent-line, floating-pills (5–8). **Focal** a 1–2 line Bodoni `display` headline in ink (italic key word in a candy hue), centered, under a yellow title-pill; a coral accent-line below. **Chrome** uppercase Space Grotesk sub. **Accent** the italic word + candy floating pills. **Silence** content centered; pills fill the edges. **Fixed** pill outlines, Bodoni ink, flat floating pills. **Free** title, which candy hues, pill words/positions. **Density** medium-atmospheric.
-
-### 2 · Pillar Cards (catalog · move: 3-up grid · left — the dense frame)
-
-**Ground** cream + atmosphere. **Composes** title-pill (lavender), section-headline, 3× pill-card. **Focal** three white 2rem pill-cards (circular candy card-icon, Bodoni card-headline, Space Grotesk body) with 0.4cqw shadows, under a Bodoni section-headline. **Chrome** a lavender header tag-pill. **Accent** the three card-icon fills (coral/sky/lime sequence). **Silence** tight — the density exception (no floating pills here). **Fixed** 2px outlines, soft shadows, ink headlines. **Free** card content, icon hues. **Density** dense-exception.
-
-### 3 · Stat Grid (data · move: stat pills · centered head)
-
-**Ground** cream + atmosphere. **Composes** section-headline, 3–4× stat-pill. **Focal** a row of white stat-pills, each a COLORED Bodoni stat-number + uppercase label + accent bar. **Accent** the colored numerals + bars (the one place color meets type). **Silence** moderate. **Fixed** 2rem pills, colored numerals only, soft shadow. **Free** figures (from script), hues. **Density** standard.
-
-### 4 · Pull Quote (quote · move: highlight pill · left)
-
-**Ground** cream + atmosphere, a few floating pills. **Composes** quote-display, quote-highlight, accent-line. **Focal** a Bodoni quote in ink with one phrase wrapped in a lime/sky `quote-highlight` pill (the emphasis mechanism — never bold). **Chrome** uppercase attribution. **Accent** the highlight pill. **Silence** ~50%. **Fixed** Bodoni 600, highlight-pill emphasis. **Free** quote, highlight color/phrase. **Density** sparse.
-
-### 5 · Orbit (concept · move: gravitational pills · centered)
-
-**Ground** cream + atmosphere. **Composes** orbit-center (160px lime circle, Bodoni ordinal), 4–6 orbit-pill satellites (candy, tilted, soft shadow). **Focal** the lime center anchored by orbiting candy pills. **Accent** the satellite hues. **Silence** moderate. **Fixed** circular center, outlined satellites with shadow. **Free** ordinal, satellite words/positions. **Density** medium.
-
-### 6 · Closing Plate (closer · move: title pill + display · centered)
-
-**Ground** cream + atmosphere, floating-pill wallpaper. **Composes** title-pill (yellow), closing-display, accent-line, floating-pills. **Focal** a Bodoni `closing-display` sign-off in ink (italic word in violet/candy), centered. **Accent** the italic word + pills. **Silence** content centered. **Fixed** Bodoni ink, flat pills. **Free** sign-off, pill words. **Density** medium-atmospheric.
-
-## Composition Rules
-
-### Do
-
-- Make every text container a **pill** (9999px / 2rem) with the **2px ink outline**.
-- Set **Bodoni headlines in ink, sentence case**; color lives on stat numerals + pill fills.
-- Use **soft offset shadows** (4/6/8/12px, 8% ink) on content containers; keep floating pills flat.
-- Float **5–8 candy pills** + radial glows + grain on declarative frames; bare corners read as broken.
-- Wrap inline emphasis in a **candy quote-highlight pill**, never bold/italic-alone.
-- Pair warm+cool+neutral-bright accents; lean centered on cover/closer, left on cards/quote.
-
-### Don't
-
-- No sharp-cornered text container; no unstroked pill.
-- No colored Bodoni headline; no uppercase Bodoni.
-- No blurred or re-colored shadow; no tenth accent color.
-- No shadow on decorative floating pills.
-- Don't blow a headline edge-to-edge — fit to measure.
-
-## Aspect-Ratio Behavior
-
-| Treatment    | 16:9                           | 9:16                        | 1:1                   |
-| ------------ | ------------------------------ | --------------------------- | --------------------- |
-| Cover        | display centered, pills around | display top, pills band     | centered, fewer pills |
-| Pillar Cards | head + 3-up                    | head + 3 stacked            | head + 2+1            |
-| Stat Grid    | 3–4 across                     | 2×2                         | 2×2                   |
-| Pull Quote   | quote left                     | quote top, highlight inline | centered              |
-| Orbit        | center + 4–6 satellites        | center + 3 satellites       | center + 4            |
-| Closing      | centered + pills               | centered, pills band        | centered              |
-
-`pad` holds on the short edge; re-step display above the 1.4cqw floor. Floating-pill count drops
-on tighter ratios so they stay wallpaper, not clutter.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Floating-pill words are neutral atmospheres ("VISION", "FUTURE", "NEXT"), never content-specific.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, stats, or counts at frame scale. Render slots as `— figure —`, `{metric}`,
-`N%`. Stat-pill numbers and bar-track widths carry placeholders until the script supplies values.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one Bodoni element dominates at 3–5× its neighbor.
-- **Silence** — declarative frames carry atmosphere not clutter; only pillar/stat grids run dense.
-- **Pills** — every container is a pill with a 2px outline; no sharp text container.
-- **Color** — candy on fills + stat numerals only; headlines ink; no tenth hue.
-- **Depth** — soft offset shadow on content only; floating pills flat; no blur.
-- **Type** — Bodoni ink sentence-case, fit-to-measure; pills uppercase tracked; ≥1.4cqw floor.
-- **Anchor** — centered on cover/closer/orbit, left on cards/quote; no 3 consecutive alike.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the 0.6s fade in the source is a deck mechanic.
-- **Bodoni Moda + Space Grotesk via Google Fonts.** CJK pairing (ZCOOL XiaoWei / Yozai) carries over from the source.
-- **9:16 / 1:1 are guidance**; verify the floor and that floating-pill count scales down.
-- The grain overlay, radial glows, floating pills, and bar fills are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/capsule/caption-skin.html

@@ -1,223 +0,0 @@
-<!--
-  Capsule — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a capsule literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a cream caption pill — fully-rounded (9999px), wrapped in capsule's universal
-  2px ink outline, lifted on a soft hard-offset shadow (no blur), Bodoni Moda glyphs in
-  ink, sentence case. Upcoming words sit in faint ink; the current word lights up as a
-  rounded candy highlight — a candy fill plus a box-shadow spread halo that follows the
-  pill radius (a soft candy capsule around the word, no blur, NO layout shift) with ink
-  reading on top; spoken words settle to solid ink, the candy highlight cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE caption capsule — cream pill, fully-rounded (9999px), capsule's universal 2px
-     ink outline, lifted on a soft hard-offset shadow (no blur, 8% ink) */
-  .caption-pill {
-    max-width: 80%;
-    padding: 18px 46px 20px;
-    background: var(--cap-canvas, #f5f5f0);
-    border: 2px solid var(--cap-ink, #1a1a1a);
-    border-radius: 9999px;
-    box-shadow: 8px 8px 0 color-mix(in srgb, var(--cap-ink, #1a1a1a) 8%, transparent);
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.12em 0.36em;
-    font-family: var(--font-display, "Bodoni Moda"), Georgia, serif;
-    font-weight: 700;
-    font-size: clamp(38px, 4.2vw, 56px);
-    line-height: 1.16;
-    letter-spacing: -0.02em;
-  }
-
-  /* upcoming — faint ink, no highlight */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.1em;
-    border-radius: 9999px;
-    color: color-mix(in srgb, var(--cap-ink, #1a1a1a) 42%, var(--cap-canvas, #f5f5f0));
-  }
-  /* current word — THE rounded candy highlight: a candy fill + a box-shadow spread
-     halo that follows the pill radius (a soft candy capsule around the word, no blur,
-     no layout shift), ink reading on top */
-  .caption-word.is-active {
-    color: var(--cap-ink, #1a1a1a);
-    background: var(--cap-accent, #e85d4e);
-    box-shadow: 0 0 0 0.14em var(--cap-accent, #e85d4e);
-  }
-  /* already spoken — solid ink, candy highlight cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #1a1a1a);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — Bodoni Moda italic, capsule's display inflection */
-  .caption-word.cap-brand {
-    font-style: italic;
-  }
-  /* numerals / data — the Space Grotesk voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "Space Grotesk"), ui-sans-serif, sans-serif;
-    color: color-mix(in srgb, var(--cap-ink, #1a1a1a) 72%, var(--cap-canvas, #f5f5f0));
-  }
-  /* emphasis — a second-candy rounded underline (the counter-accent) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 3px;
-    text-decoration-color: var(--cap-accent-2, #f2d160);
-    text-underline-offset: 0.12em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.92 }, { scale: 1, duration: 0.18, ease: "back.out(2)" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/cartesian/FRAME.md

@@ -1,278 +0,0 @@
----
-version: alpha
-name: Cartesian — Frame (video / frame layer)
-description: >
-  Video-first companion to Cartesian's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — the five-tone warm-stone palette, Playfair Display 400 + Inter, the
-  universal 1px taupe hairline as the only structural device, compass-drafted geometric rings,
-  and zero shadow / zero fill. Composition, frame scale, and aspect-ratio behavior are rewritten
-  for the frame. Restraint is the rule; motion is out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  bg-primary: "#EDE8E0"
-  bg-secondary: "#E2DBD1"
-  text-primary: "#1A1A1A"
-  text-secondary: "#5A5A5A"
-  accent: "#8A8178"
-  line: "#B8B0A4"
-  white-overlay: "rgba(255,255,255,0.3)"
-
-typography:
-  # — reading ramp (Inter) —
-  body:        { fontFamily: "Inter", cqw: 1.0,  weight: 400, lineHeight: 1.6, color: "text-secondary" }
-  body-sm:     { fontFamily: "Inter", cqw: 0.85, weight: 400, lineHeight: 1.6 }
-  subtitle:    { fontFamily: "Inter", cqw: 1.3,  weight: 400, lineHeight: 1.5 }
-  label:       { fontFamily: "Inter", px: 14, weight: 500, tracking: "3px", upper: true, color: "accent" }
-  attribution: { fontFamily: "Inter", px: 15, weight: 400, tracking: "2px", upper: true, color: "accent" }
-  micro:       { fontFamily: "Inter", px: 12, weight: 400, tracking: "2px", upper: true, color: "accent" }
-  # — display / hero ramp (Playfair Display 400, sentence case) —
-  h3:          { fontFamily: "Playfair Display", cqw: 1.8, weight: 400, lineHeight: 1.1 }
-  timeline-headline:{ fontFamily: "Playfair Display", cqw: 1.9, weight: 400, lineHeight: 1.1 }
-  card-headline:{ fontFamily: "Playfair Display", cqw: 2.0, weight: 400, lineHeight: 1.15 }
-  stat-figure: { fontFamily: "Playfair Display", cqw: 3.0, weight: 400, lineHeight: 1.0 }
-  quote-mark:  { fontFamily: "Playfair Display", cqw: 9.0, weight: 400, lineHeight: 0.5, color: "line" }
-  h2:          { fontFamily: "Playfair Display", cqw: 4.0, weight: 400, lineHeight: 1.1 }
-  h1:          { fontFamily: "Playfair Display", cqw: 6.2, weight: 400, lineHeight: 1.06 }
-  display:     { fontFamily: "Playfair Display", cqw: 8.0, weight: 400, lineHeight: 1.04 }
-
-spacing:
-  pad-x: "7cqw"
-  pad-y: "5cqw"
-  gap-xl: "6cqw"
-  gap-lg: "5cqw"
-
-components:
-  hairline:
-    rule: "0.07cqw solid {colors.line}"
-    description: "The universal structural device — every separator (agenda rule, timeline connector, card border, stats top) is this 1px taupe line. No thick borders exist."
-  card:
-    backgroundColor: "{colors.white-overlay}"
-    border: "0.07cqw solid {colors.line}"
-    rounded: "0"
-    shadow: "none"
-    description: "Faint white-overlay fill (canvas bleeds through) is what makes a card distinct from a bare region."
-  card-icon:
-    border: "0.07cqw solid {colors.line}"
-    rounded: "50%"
-    size: "40px circle"
-    textColor: "{colors.accent}"
-    typography: "Playfair numeral/letter"
-    description: "Ringed circle mark."
-  agenda-row:
-    borderBottom: "0.07cqw solid {colors.line}"
-    typography: "{typography.h3} (numeral {colors.accent}, label {colors.text-primary})"
-    description: "Numeral left, label right over a taupe rule."
-  timeline:
-    borderTop: "0.07cqw solid {colors.line}"
-    typography: "{typography.timeline-headline} + {typography.body-sm}"
-    description: "A single taupe top rule across items — no nodes, no dots."
-  stats-cluster:
-    borderTop: "0.07cqw solid {colors.line}"
-    typography: "{typography.stat-figure} + uppercase {colors.accent} labels"
-    description: "Inline modest stat figures (no hero numeral)."
-  geo-ring:
-    border: "1px solid {colors.line} (inner dashed ::before ~70–80%)"
-    rounded: "50%"
-    size: "10–50cqw"
-    opacity: "0.2–0.5"
-    description: "Compass-construction rings behind content. 1–2 per frame, never more."
-  horizontal-accent:
-    backgroundColor: "{colors.text-primary}"
-    size: "~18cqw × 1px"
-    description: "The system's only INK-BLACK rule — a strong terminal accent on cover/closing, sparingly."
-  vertical-line:
-    backgroundColor: "{colors.line}"
-    size: "1px × full height, ~5cqw from edge"
-    opacity: "0.3–0.4"
-    description: "Drafting-paper alignment guide. Optional."
-  image-placeholder:
-    backgroundColor: "{colors.bg-secondary}"
-    mark: "crossed +30°/−30° 1px taupe diagonals (an X)"
-    typography: "small uppercase {typography.micro}"
-    description: "The signature image-not-wired mark."
-  team-photo:
-    backgroundColor: "{colors.bg-secondary}"
-    border: "0.07cqw solid {colors.line}"
-    rounded: "50%"
-    typography: "Playfair initial in {colors.accent}"
-    description: "Circular portrait frame."
----
-
-# Cartesian — Frame (video / frame layer)
-
-## Overview
-
-Cartesian at frame scale is a **quiet museum-catalog editorial system** — restraint through 1px
-lines. Every structural separator is a single 1px taupe hairline; there are no thick borders, no
-fills (save the faint white-overlay card), no shadows, no rounded rectangles. Hierarchy comes from
-**type contrast and negative space**, and atmosphere from **compass-drafted geometric rings**
-drifting behind content.
-
-The voice is a literary pairing: **Playfair Display** at weight 400 (the thin-stroke didone, never
-bold, always sentence case) carries every headline, numeral, and quote mark in ink; **Inter**
-carries body in warm gray and labels in uppercase taupe with 2–3px tracking. The palette is five
-warm stones plus ink — no populist accent color exists. The correct density is **sparse and
-breathing**: one clear idea, well-framed, on stone paper.
-
-**Key characteristics at frame scale:**
-
-- **1px taupe hairline** as the universal structural device — every separator is this one line.
-- **Playfair Display 400** (ink, sentence case) for display; **Inter** body (gray) + labels (taupe, tracked).
-- **Five warm stones + ink** — no red/blue/green; the only "color" is type contrast.
-- **Compass-drafted geometric rings** (solid + dashed, 20–50% opacity) behind content for mood.
-- **Flat** — zero shadow, zero rounded rectangle (circles only); the lone ink line is the `horizontal-accent`.
-- **Sparse and breathing** — generous negative space; crowding reads as broken.
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one Playfair element dominates at **3–6× its nearest neighbor**; the serif/sans + size contrast carries hierarchy, not weight.
-- **Silence** — declarative frames read **55–60% empty**; Cartesian has **no dense frame** — even the agenda/index breathes (the system breaks when crowded).
-- **Restraint** — **at most two geo rings** per frame; the single INK-BLACK `horizontal-accent` rule used sparingly; no populist accent color ever.
-- **Reference** — aim at a **Vignelli editorial / Cooper Hewitt catalogue / pencil-and-tracing-paper plan**; failure looks like a **shadowed, rounded-card SaaS deck**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `pad-x` (7cqw) generous gutters; geometry may bleed off an edge.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. The 1px hairlines and geo rings hold
-their proportion against the frame at any render size.
-
-## Colors
-
-Tokens identical to the source. `{colors.bg-primary}` is the ground; `{colors.text-primary}` ink is
-headlines and the one black accent rule; `{colors.text-secondary}` gray is body; `{colors.accent}`
-taupe is labels, numerals, small text; `{colors.line}` taupe is every 1px structural border.
-`{colors.bg-secondary}` is the only secondary fill (placeholders, photo frames). **No populist
-accent** — when emphasis is needed, grow the type, switch sans→serif, or add a single
-`horizontal-accent` ink line. Headlines are never taupe; small text is never ink.
-
-## Typography
-
-Two ramps. The **reading ramp** (Inter body 1.0cqw gray, labels in px taupe) carries copy + chrome;
-the **display ramp** (Playfair `h3` 1.8cqw → `display` 8.0cqw, all weight 400) carries every headline.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; px labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `display`/`h1`; 4–6 → `h2`; 7+ → `h3`. Cartesian has no hero-stat numeral — stats stay modest (`stat-figure` 3cqw).
-- **Playfair at 400, ink, sentence case** — never bold, never uppercase, never taupe. **Inter labels uppercase, 2–3px tracked, taupe.** Italic via Playfair italic for emphasis only.
-
-## Depth & Surface
-
-The flat plane is the only technique. Hierarchy from:
-
-- **Type contrast** — Playfair serif vs Inter sans; the 8cqw→0.7cqw scale.
-- **1px taupe hairlines** — every divider, card outline, timeline rule, photo ring.
-- **Tone** — ink vs gray vs taupe.
-- **Negative space** — generous padding.
-- **Geometric atmosphere** — compass rings that suggest depth without creating it.
-
-**Ceiling:** no box-shadow, no elevated card, no gradient, no rounded rectangle. The single ink line
-(`horizontal-accent`) is the only non-taupe rule.
-
-## Shapes
-
-- **50% (circle)** — card-icon, team-photo, nav-dot, every geo ring.
-- **0** — everything else; soft-rounded corners do not exist.
-
-## Components
-
-- **hairline** — the universal 1px taupe separator (the identity).
-- **card** (1px taupe + white-overlay) / **card-icon** (ringed circle) / **agenda-row** / **timeline** (line, no nodes) / **stats-cluster** — all built on the hairline.
-- **geo-ring** — compass decoration (solid + dashed), 1–2 per frame. **horizontal-accent** — the one ink line, sparingly. **vertical-line** — drafting guide.
-- **image-placeholder** (crossed-X) / **team-photo** (ringed initial) — the stone-fill placeholders.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> Every frame is sparse and breathing; 1–2 geo decorations max.
-
-### 1 · Cover (identity · move: serif + compass ring · left)
-
-**Ground** `{colors.bg-primary}`, `pad-x`. **Composes** geo-ring (right, ~34cqw, solid+dashed), vertical-line (left), label, display/h1. **Focal** a 2–3 line Playfair `display`/`h1` headline in ink (italic on the key word), left-anchored, with a taupe `label` above and an Inter subtitle below. **Chrome** optional bottom meta row (Playfair value + taupe label). **Accent** the geo ring; optionally one `horizontal-accent` ink line (if it clears the meta). **Silence** ~55% empty. **Fixed** Playfair 400 ink sentence-case, ≤2 geo elements, 1px lines. **Free** title, ring placement, meta. **Density** sparse.
-
-### 2 · Agenda / Index (index · move: hairline list · left)
-
-**Ground** `{colors.bg-primary}`, `pad-x`. **Composes** label, h2, agenda-rows. **Focal** a Playfair `h2` over 4–6 agenda rows (Playfair numeral in taupe + Playfair label in ink), each on a 1px taupe rule. **Chrome** taupe `label` eyebrow. **Accent** none — taupe numerals carry it. **Silence** moderate; rows generously spaced. **Fixed** 1px taupe rules, Playfair 400. **Free** items, count. **Density** standard (sparse rows).
-
-### 3 · Pull Quote (quote · move: centered statement · compass ring)
-
-**Ground** `{colors.bg-primary}`, centered. **Composes** geo-ring (centered dashed, ~26cqw), quote-mark, h2/display-quote, attribution. **Focal** a 2-line Playfair quote in ink, centered, under a 50%-taupe Playfair quote-mark; a taupe uppercase attribution beneath. **Accent** the faint centered ring. **Silence** ~60% — deliberately open. **Fixed** Playfair 400, one ring, centered. **Free** quote, attribution. **Density** sparse.
-
-### 4 · Closing Plate (closer · move: centered ring · centered)
-
-**Ground** `{colors.bg-primary}`, centered. **Composes** geo-ring (centered, ~40cqw, solid+dashed), label, h1/display, horizontal-accent. **Focal** a 1–2 line Playfair sign-off in ink (italic key word), centered inside the largest compass ring; a short ink `horizontal-accent` beneath. **Accent** the ring + the one ink line. **Silence** ~60%. **Fixed** Playfair 400, centered, ≤2 geo. **Free** sign-off, ring scale. **Density** sparse.
-
-### 5 · Two-Column Editorial (content · move: asymmetric split · left)
-
-**Ground** `{colors.bg-primary}`, `pad-x`, two columns with `gap-xl`. **Composes** label, h2, body, image-placeholder (crossed-X) or card. **Focal** a Playfair `h2` + Inter body in the text column; an image-placeholder or card in the other. **Accent** none. **Silence** generous gutter. **Fixed** 1px taupe card/placeholder borders, white-overlay fill. **Free** which side is text, body copy. **Density** standard.
-
-### 6 · Stats / Timeline (data · move: hairline rail · left)
-
-**Ground** `{colors.bg-primary}`, `pad-x`. **Composes** label, h3, stats-cluster or timeline. **Focal** a modest Playfair stat row (or a 1px-rule timeline with year + headline + body, no nodes), framed by a 1px taupe top rule. **Accent** none. **Silence** moderate. **Fixed** modest stat scale, hairline rule, no nodes. **Free** figures, phases. **Density** standard.
-
-## Composition Rules
-
-### Do
-
-- Use a **single 1px taupe line** for every separator — the hairline is the identity.
-- Set every **Playfair headline at 400, ink, sentence case**; render labels taupe, uppercase, 2–3px tracked.
-- Layer **one or two compass rings** (solid + dashed, 20–50% opacity) behind content for atmosphere.
-- Let frames **breathe** — sparse, generous negative space; 55–60% empty on declarative frames.
-- Lean centered on quote/closer; asymmetric/left on cover/agenda/editorial. Use `bg-secondary` for placeholder fills.
-
-### Don't
-
-- Don't introduce a populist accent color — stone and ink only.
-- Don't bold Playfair, render headlines in taupe, or use thick (2px+) borders.
-- Don't add shadows, elevated cards, or rounded rectangles (circles only).
-- Don't crowd the frame — packed layouts read as broken.
-- Never more than two geo decorations per frame; don't blow a headline edge-to-edge.
-
-## Aspect-Ratio Behavior
-
-| Treatment            | 16:9                       | 9:16                                | 1:1                         |
-| -------------------- | -------------------------- | ----------------------------------- | --------------------------- |
-| Cover                | headline left, ring right  | headline top, ring below            | headline upper, ring behind |
-| Agenda / Index       | h2 + rows                  | h2 + rows (tighter)                 | h2 + rows                   |
-| Pull Quote           | centered, ring behind      | centered, taller                    | centered                    |
-| Closing Plate        | centered in ring           | centered, ring scaled               | centered                    |
-| Two-Column Editorial | text + visual side-by-side | stacked (collapse)                  | stacked                     |
-| Stats / Timeline     | horizontal rail            | vertical stack (drop timeline rule) | compact                     |
-
-Generous `pad-x` holds on the short edge; re-step display per ratio above the 1.4cqw floor. On
-9:16, the timeline rule loses meaning when stacked — switch to a vertical list (per source).
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder (the crossed-X image-placeholder, or a ringed initial for portraits).
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, dates, or counts at frame scale. Render slots as `— figure —`, `{metric}`.
-Stats and timeline years carry placeholders until the script supplies them. Agenda ordinals
-(01, 02…) are decorative and may be sequential.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one Playfair element dominates; the serif/sans contrast carries hierarchy.
-- **Silence** — declarative frames 55–60% empty; nothing is crowded.
-- **Palette** — five stones + ink only; no populist accent; headlines ink, labels taupe.
-- **Lines** — every separator is a 1px taupe hairline; the only ink line is `horizontal-accent`.
-- **Type** — Playfair 400 sentence-case, fit-to-measure; labels uppercase 2–3px; ≥1.4cqw floor.
-- **Depth** — 0 shadow, 0 rounded rectangle; ≤2 geo rings per frame.
-- **Anchor** — centered on quote/closer, left/asymmetric on cover/agenda/editorial; no 3 in a row alike.
-- **Fabrication** — every numeral traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the 0.6s fade in the source is a deck mechanic.
-- **Playfair Display + Inter via Google Fonts.** CJK pairing (Noto Serif SC 700/400) carries over; Playfair has no Hanzi italic — substitute weight/taupe for emphasis.
-- **9:16 / 1:1 are guidance**; verify the legibility floor and that the timeline collapses to a vertical list.
-- Geo rings, the crossed-X placeholder, and the dashed inner ring are CSS-only; no external imagery is required.

.claude/skills/hyperframes/assets/frame-presets/cartesian/caption-skin.html

@@ -1,221 +0,0 @@
-<!--
-  Cartesian — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a cartesian literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a museum-catalog lower-third — a warm-stone card on a single 1px taupe
-  hairline border (cartesian's universal structural device), SHARP corners, ZERO
-  shadow, ZERO fill beyond the stone canvas. Playfair Display 400, sentence case, ink
-  glyphs. Upcoming words sit in faint ink; the current word is marked QUIETLY — a faint
-  stone wash with a 1px taupe hairline underline (restraint, not a loud block); spoken
-  words settle to solid ink, the wash and underline cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE stone card — single 1px taupe hairline border (cartesian's universal
-     structural device), SHARP corners, ZERO shadow, ZERO fill beyond the stone canvas */
-  .caption-pill {
-    max-width: 78%;
-    padding: 20px 44px 24px;
-    background: var(--cap-canvas, #ede8e0);
-    border: 1px solid var(--cap-accent-2, #b8b0a4);
-    border-radius: 0;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.1em 0.34em;
-    font-family: var(--font-display, "Playfair Display"), Georgia, serif;
-    font-weight: 400;
-    font-size: clamp(40px, 4.4vw, 58px);
-    line-height: 1.16;
-    letter-spacing: -0.01em;
-  }
-
-  /* upcoming — faint ink, no mark */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.06em;
-    border-bottom: 1px solid transparent;
-    color: color-mix(in srgb, var(--cap-ink, #1a1a1a) 42%, var(--cap-canvas, #ede8e0));
-  }
-  /* current word — a QUIET marker: a faint warm-stone wash behind solid ink, plus a
-     1px taupe hairline underline (restraint, not a loud block; SHARP, NO shadow) */
-  .caption-word.is-active {
-    color: var(--cap-ink, #1a1a1a);
-    background: color-mix(in srgb, var(--cap-accent, #8a8178) 18%, var(--cap-canvas, #ede8e0));
-    border-bottom: 1px solid var(--cap-accent, #8a8178);
-  }
-  /* already spoken — solid ink, wash + underline cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #1a1a1a);
-    background: transparent;
-    border-bottom: 1px solid transparent;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — Playfair Display italic, cartesian's only display inflection */
-  .caption-word.cap-brand {
-    font-style: italic;
-  }
-  /* numerals / data — the body sans voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "Inter"), ui-sans-serif, sans-serif;
-    color: color-mix(in srgb, var(--cap-ink, #1a1a1a) 72%, var(--cap-canvas, #ede8e0));
-  }
-  /* emphasis — a 1px taupe hairline underline (no second color; stone-and-ink only) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 1px;
-    text-decoration-color: var(--cap-accent, #8a8178);
-    text-underline-offset: 0.12em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.985 }, { scale: 1, duration: 0.2, ease: "power1.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/cobalt-grid/FRAME.md

@@ -1,265 +0,0 @@
----
-version: alpha
-name: Cobalt Grid — Frame (video / frame layer)
-description: >
-  Video-first companion to Cobalt Grid's design.md. The unit is the frame (1920×1080). Atoms
-  are identical and sacred — warm cream paper, electric cobalt ink (the only ink), the permanent
-  graph-paper grid, Newsreader serif 400 + Hanken Grotesk + DM Mono, the top/bottom cobalt
-  hairlines, and the pixel-glitch + QR-block signatures. Composition, frame scale, and
-  aspect-ratio behavior are rewritten for the frame. Motion is out of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  paper: "#F0EBDE"
-  paper-2: "#E6E0CE"
-  ink: "#1F2BE0"
-  ink-soft: "#5560E5"
-  grid: "rgba(31,43,224,0.10)"
-  ink-faint: "rgba(31,43,224,0.18)"
-
-typography:
-  # — reading ramp —
-  body:        { fontFamily: "Hanken Grotesk", cqw: 0.83, weight: 400, lineHeight: 1.5 }
-  body-lede:   { fontFamily: "Hanken Grotesk", cqw: 0.95, weight: 400, lineHeight: 1.5 }
-  micro:       { fontFamily: "Hanken Grotesk", px: 13, weight: 600, tracking: "0.16em", upper: true }
-  micro-strong:{ fontFamily: "Hanken Grotesk", px: 16, weight: 600, tracking: "0.18em", upper: true }
-  mono-tag:    { fontFamily: "DM Mono", cqw: 0.78, weight: 400, tracking: "0.05em" }
-  mono-chrome: { fontFamily: "DM Mono", px: 13, weight: 400, tracking: "0.06em" }
-  # — display / hero ramp (Newsreader 400, negative tracking) —
-  table-name:  { fontFamily: "Newsreader", cqw: 1.5, weight: 400, lineHeight: 1.15 }
-  row-headline:{ fontFamily: "Newsreader", cqw: 2.1, weight: 400, lineHeight: 1.05 }
-  ed-callout:  { fontFamily: "Newsreader", cqw: 2.6, weight: 400, lineHeight: 1.1, italic: true }
-  headline:    { fontFamily: "Newsreader", cqw: 4.6, weight: 400, lineHeight: 0.95 }
-  headline-index:{ fontFamily: "Newsreader", cqw: 5.0, weight: 400, lineHeight: 0.95 }
-  display-quote:{ fontFamily: "Newsreader", cqw: 5.7, weight: 400, lineHeight: 1.05, tracking: "-0.005em" }
-  display-chapter:{ fontFamily: "Newsreader", cqw: 6.8, weight: 400, lineHeight: 1.0, tracking: "-0.005em" }
-  display-closing:{ fontFamily: "Newsreader", cqw: 9.4, weight: 400, lineHeight: 0.96, tracking: "-0.005em" }
-  display-hero:{ fontFamily: "Newsreader", cqw: 10.4, weight: 400, lineHeight: 0.9, tracking: "-0.008em" }
-  vbig-numeral:{ fontFamily: "Newsreader", cqw: 12.5, weight: 400, lineHeight: 0.9, tracking: "-0.015em" }
-
-spacing:
-  edge: "4cqw"          # standard frame edge inset (~80px@1920)
-  pad-top: "7cqw"
-  pad-bottom: "6cqw"
-  gap-md: "2cqw"
-
-components:
-  graph-grid:
-    backgroundImage: "linear-gradient grid, ~2cqw cells, 10% {colors.ink} ({colors.grid})"
-    placement: "behind EVERY frame on the ground"
-    description: "Permanent graph-paper grid — never disabled; the canvas tone."
-  hairlines:
-    rule: "0.12cqw solid {colors.ink}"
-    placement: "≈3cqw from top + bottom, inset {spacing.edge}"
-    description: "Two persistent cobalt rules framing every composition."
-  page-chrome:
-    typography: "{typography.pagenum}"
-    color: "{colors.ink}"
-    placement: "page number bottom-right, nav/meta hint bottom-left, above the bottom hairline"
-    description: "The only persistent chrome."
-  pixel-glitch:
-    backgroundColor: "{colors.paper}"
-    fill: "repeating-linear-gradient(90deg, {colors.ink} 0 2px, transparent 2px 8px)"
-    size: "14–30cqw wide, full height, stair-stepped"
-    placement: "right on cover/data, left on chapter/colophon; z above grid, below headline"
-    description: "Stair-stepped scanline column. Decorative."
-  qr-block:
-    backgroundColor: "{colors.paper}"
-    cells: "8×8, {colors.ink} on / {colors.grid} off"
-    size: "3–9cqw square"
-    shadow: "0 0 0 0.12cqw {colors.paper} (anti-shadow for readability, not elevation)"
-    description: "QR mosaic patch — corner punctuation."
-  topbar-rule:
-    typography: "{typography.headline-index} + {typography.mono-tag}"
-    borderBottom: "0.12cqw solid {colors.ink}"
-    description: "Section header on index/data/table frames."
-  ledger-row:
-    layout: "grid: mono num · Newsreader name · Hanken desc · mono delta"
-    borderBottom: "0.06cqw solid {colors.ink-faint} (header 0.12cqw solid {colors.ink})"
-    typography: "{typography.mono-tag} + {typography.table-name} + {typography.body}"
-    description: "Dense matrix row with ↑/↓/— delta."
-  pixel-stack-bar:
-    cells: "column-reverse, {colors.grid} off / {colors.ink} on"
-    baseline: "0.12cqw solid {colors.ink} + {typography.mono-tick} ticks"
-    description: "Data as grid-unit cells; echoes the glitch."
-  vstack-label:
-    typography: "{typography.mono-tick}"
-    transform: "writing-mode: vertical-rl"
-    description: "Catalogue chrome along a frame edge."
----
-
-# Cobalt Grid — Frame (video / frame layer)
-
-## Overview
-
-Cobalt Grid at frame scale is a **two-color risograph trend-report** — warm cream paper, electric
-cobalt ink, and a **permanent graph-paper grid** behind every frame. Cobalt is the _only_ ink:
-headlines, body, rules, the grid, the pixel-glitch decoration, the QR patches. There is no accent
-color and no second surface.
-
-The voice is a three-face conversation: **Newsreader** serif at weight 400 (size, not weight,
-makes hierarchy) carries every display and headline; **Hanken Grotesk** carries body and
-uppercase tracked labels; **DM Mono** carries all chrome — page numbers, tags, ticks, vertical
-stacks. Every frame is framed by top + bottom cobalt hairlines; declarative frames carry the
-**pixel-glitch column** and a **QR-block** patch.
-
-**Key characteristics at frame scale:**
-
-- **Strictly two-color** — cream paper + cobalt ink; no accent, no second surface.
-- **Permanent ~2cqw graph-paper grid** (10% cobalt) behind every frame; cannot be disabled.
-- **Top + bottom 1.5px cobalt hairlines** frame every composition, inset by `edge`.
-- **Newsreader 400** for all display (negative tracking); **Hanken 600** uppercase 0.16em labels; **DM Mono** chrome.
-- **Pixel-glitch column + QR-block** as the signature decorative patches on declarative frames.
-- **Pixel-stack bars** render data as grid-unit cells (cobalt on / 10% off).
-
-## The Frame
-
-### Frame Craft Bar
-
-Three eyeball tests gate every frame before any structural check:
-
-- **Squint** — one Newsreader element dominates at **3–6× its nearest neighbor** (`display-hero`/`vbig-numeral`); hierarchy is size, never weight.
-- **Silence** — declarative frames (cover, chapter, quote, colophon) read **45–60% empty** with the grid showing; the **index ledger and data frame are the one dense exception** (density via quiet repetition, not richness).
-- **Restraint** — **two-color only** (cream + cobalt, never a second hue); one pixel-glitch column and at most one QR-block per declarative frame.
-- **Reference** — aim at a **WIRED Japan / Shift two-color risograph monograph**; failure looks like a **colorful dashboard with a second accent hue**.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `edge` (4cqw) inset; hairlines + page chrome live on the safe line.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size` AND carries
-the graph-paper `background-image`; ALL frame-relative units are `cqw`/`cqh` against it — never
-`vw`. The grid `background-size` is `~2cqw 2cqw` so cell density holds at any render size.
-
-## Colors
-
-Tokens identical to the source. `{colors.paper}` is the ground; `{colors.ink}` cobalt is the only
-ink (type, rules, grid lines, glitch, QR). `{colors.ink-soft}` is a secondary cobalt for editorial
-subtitles only; `{colors.grid}` (10%) is the permanent grid + chart "off" cells; `{colors.ink-faint}`
-(18%) is faint row dividers. **Never a second hue** — emphasis comes from size, from switching
-Hanken→Newsreader, from a mono delta arrow, or from opacity, never from color.
-
-## Typography
-
-Two ramps. The **reading ramp** (Hanken body 0.83cqw, mono chrome in px) carries copy + labels;
-the **display/hero ramp** (Newsreader `headline` 4.6cqw → `vbig-numeral` 12.5cqw) carries every
-statement and figure.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; mono chrome (px) is colophon only.
-- **Fit-to-measure:** size the headline to its line length. Cap the block at **≤ 78cqw**; ≤3 words → `display-hero`/`vbig-numeral`; 4–6 → `display-chapter`; 7+ → `headline`.
-- **Newsreader at 400 only**, in cobalt, with negative tracking (hero −0.008em, numeral −0.015em). **Hanken labels uppercase, 0.16–0.18em.** **DM Mono 0.04–0.08em.** No bold serif.
-
-## Depth & Surface
-
-Flat. Depth is structural only:
-
-- **1.5px cobalt rules** — slide hairlines, topbar rule, chart baseline.
-- **1px ink-faint dividers** — dense list / ledger rows.
-- **The graph-paper grid** — measured-plane tone behind everything.
-- **Pixel-glitch + QR** — texture and graphic punctuation, no z-axis.
-
-**Ceiling:** no drop shadow (the QR's 1.5px paper outset is an anti-shadow for readability, not elevation), no gradient, no rounded corner, no second color.
-
-## Shapes
-
-- **0 radius everywhere** — frames, ledger rows, QR cells, glitch blocks, charts. Zero circular elements; this squareness is part of the identity.
-
-## Components
-
-- **graph-grid / hairlines / page-chrome** — the permanent frame furniture, inherited by every composition.
-- **pixel-glitch** (edge column) + **qr-block** (corner patch) — the signature decoration on declarative frames.
-- **topbar-rule** — the index/data/table section header. **ledger-row** — dense matrix row with delta arrows.
-- **pixel-stack-bar** — data as grid-unit cells. **vstack-label** — vertical mono catalogue chrome.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · silence · Fixed/Free · density.
-> The grid + hairlines are present on every frame. Choose density by type: declarative = sparse, index/data = dense.
-
-### 1 · Hero Cover (identity · move: serif + glitch · left)
-
-**Ground** paper + grid, hairlines. **Composes** pixel-glitch (right, ~26cqw), qr-block (top-right), display-hero, ed-callout. **Focal** a 1–2 line `display-hero` Newsreader headline in cobalt, left-anchored, with an italic `ed-callout` subtitle in `{colors.ink-soft}`. **Chrome** Hanken kicker; mono meta top + page number. **Accent** none (cobalt is the only ink). **Silence** ~45% paper. **Fixed** Newsreader 400, glitch + QR present, grid + hairlines. **Free** title, glitch step pattern, QR placement. **Density** sparse.
-
-### 2 · Index Ledger (catalog · move: dense matrix · left — the dense frame)
-
-**Ground** paper + grid, hairlines, `pad-top`/`pad-bottom`. **Composes** topbar-rule, ledger-rows. **Focal** a topbar (`headline-index` + mono lab-tag, 1.5px rule) over 4–6 ledger rows (mono num · Newsreader name · Hanken desc), ink-faint dividers. **Chrome** page number. **Accent** mono delta arrows. **Silence** tight — the density exception (the grid wants filling). **Fixed** 1.5px topbar rule, 1px ink-faint dividers, Newsreader names. **Free** rows, lab-tag, deltas. **Density** dense-exception.
-
-### 3 · Chapter Opener (section · move: scale · sparse · left)
-
-**Ground** paper + grid, hairlines. **Composes** pixel-glitch (left, ~14cqw, low opacity), mono index, display-chapter, body-lede. **Focal** a `display-chapter` Newsreader title, with a small mono `CHAPTER NN` index above and an optional Hanken lede ≤42cqw. **Accent** none. **Silence** ~60% — let the grid breathe. **Fixed** Newsreader 400, glitch low-opacity, grid showing. **Free** title, lede, glitch side. **Density** sparse.
-
-### 4 · Data Frame (chart · move: pixel-stack · left)
-
-**Ground** paper + grid, hairlines, `pad-top`. **Composes** topbar-rule, pixel-stack-bar row. **Focal** a row of 6–8 pixel-stack bars (cobalt on / 10% off) over a 1.5px cobalt baseline with mono ticks. **Chrome** topbar headline + mono fig-tag; page number. **Accent** none — data is cobalt cells. **Silence** moderate. **Fixed** grid-unit cells, cobalt baseline, mono ticks. **Free** bar values (from script), tick labels. **Density** standard/dense.
-
-### 5 · Manifesto / Quote (quote · move: centered statement · sparse)
-
-**Ground** paper + grid, hairlines. **Composes** display-quote (or display-manifesto), attribution rule, optional compact glitch. **Focal** a 2–3 line Newsreader pull in cobalt, with a Hanken kicker above and a 1px cobalt attribution rule + mono byline beneath. **Accent** none. **Silence** ~55% — deliberately open. **Fixed** Newsreader 400, attribution rule, grid showing. **Free** quote, byline. **Density** sparse.
-
-### 6 · Colophon (closer · move: right-aligned close · sparse)
-
-**Ground** paper + grid, hairlines. **Composes** pixel-glitch (left edge, mirroring the cover), display-closing, mono credit columns. **Focal** a right-aligned `display-closing` Newsreader title with a Hanken kicker above. **Chrome** 3–4 column mono credit grid at the foot; page number. **Accent** none. **Silence** ~50%. **Fixed** glitch on left, Newsreader 400. **Free** closing line, credits. **Density** sparse.
-
-## Composition Rules
-
-### Do
-
-- Keep the **graph-paper grid + top/bottom hairlines** on every frame — they are the system.
-- Set **Newsreader at 400 in cobalt**; make hierarchy with size, not weight; negative-track display.
-- Track **Hanken labels uppercase 0.16em**; **DM Mono chrome 0.04–0.08em**.
-- Render data as **pixel-stack cells** (cobalt on / 10% off); echo the glitch language.
-- Use the **pixel-glitch column + QR patch** on declarative frames (cover, chapter, quote, colophon).
-- Lean: declarative frames sparse and breathing; index/data dense. Vary anchor (left for index/chapter, centered for quote/closer).
-
-### Don't
-
-- Don't introduce a second ink color — cream + cobalt only.
-- Don't bold Newsreader, round any corner, or add a drop shadow (QR outset is an anti-shadow only).
-- Don't disable the grid or suppress the hairlines.
-- Don't crowd chapter / quote / colophon — those let the grid show.
-- Don't blow a serif headline edge-to-edge — fit to measure.
-
-## Aspect-Ratio Behavior
-
-| Treatment         | 16:9                        | 9:16                                 | 1:1                          |
-| ----------------- | --------------------------- | ------------------------------------ | ---------------------------- |
-| Hero Cover        | headline left, glitch right | headline top, glitch full-width band | headline upper, glitch lower |
-| Index Ledger      | topbar + rows               | topbar + fewer rows                  | 2-col compresses to 1        |
-| Chapter Opener    | title left, glitch left     | title top, glitch side               | centered title               |
-| Data Frame        | 6–8 bars                    | 4–5 bars taller                      | square chart                 |
-| Manifesto / Quote | centered pull               | centered, taller                     | centered                     |
-| Colophon          | right-aligned, glitch left  | stacked, glitch top                  | centered close               |
-
-Grid + hairlines hold on the short edge for every ratio; re-step display so no load-bearing line
-drops below 1.4cqw. Mono chrome stays Latin/digit-only.
-
-## Approved Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Trend names, signals, and figures are content; the system supplies the grid and chrome.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, deltas, dates, or signal counts at frame scale. Render slots as `— figure —`,
-`{metric}`, `↑ —`. Pixel-stack bar heights and ledger deltas especially carry placeholders until the
-script supplies values. Mono catalogue ordinals (001, 002…) are decorative and may be sequential.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one Newsreader element dominates at 3–5× its neighbor.
-- **Silence** — declarative frames 45–60% empty; only index/data run dense.
-- **Two-color** — cream + cobalt only; no second hue anywhere.
-- **Furniture** — grid present, top/bottom hairlines present, page chrome above the hairline.
-- **Type** — Newsreader 400 negative-tracked, fit-to-measure; Hanken labels 0.16em; ≥1.4cqw floor.
-- **Depth** — 0 shadow (QR outset excepted), 0 rounded corner.
-- **Anchor** — left on index/chapter/cover, centered on quote/closer; no 3 consecutive frames share an anchor.
-- **Fabrication** — every numeral/delta traces to the script, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only; the 280ms cross-fade in the source is a deck mechanic.
-- **Pixel-glitch is rendered in CSS here** (stacked scanline blocks) rather than the source's inline SVG, to keep the showcase SVG-free; fidelity is preserved.
-- **Three Google Fonts** (Newsreader, Hanken Grotesk, DM Mono); CJK pairing (Noto Serif SC 700/400) carries over from the source.
-- **9:16 / 1:1 are guidance**; verify the legibility floor and grid density per ratio.
-- The QR mosaic and glitch step patterns are hand-authored; there is no generative layer.

.claude/skills/hyperframes/assets/frame-presets/cobalt-grid/caption-skin.html

@@ -1,237 +0,0 @@
-<!--
-  Cobalt Grid — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a cobalt literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a cream-paper card carrying the permanent graph-paper grid behind the line,
-  framed by top + bottom 1.5px cobalt hairlines (cobalt's signature frame furniture) —
-  square corners, NO drop shadow (cobalt's depth is structural and flat, never cast).
-  Newsreader serif 400, sentence case, cobalt glyphs. Upcoming words sit in faint
-  cobalt; the current word is a hard COBALT FLAT BLOCK — a risograph knockout: a solid
-  cobalt fill (box-shadow spread = a square block, no blur, no layout shift) with the
-  cream paper reading on top. Spoken words settle to solid cobalt ink, the block cleared.
-  Strictly two-color throughout — cream + cobalt, never a second hue.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE cream card — graph-paper grid behind the line + top/bottom 1.5px cobalt
-     hairlines (cobalt's frame furniture), square corners, NO drop shadow */
-  .caption-pill {
-    position: relative;
-    max-width: 78%;
-    padding: 20px 44px 24px;
-    background: var(--cap-canvas, #f0ebde);
-    background-image:
-      linear-gradient(
-        to right,
-        color-mix(in srgb, var(--cap-ink, #1f2be0) 10%, transparent) 1px,
-        transparent 1px
-      ),
-      linear-gradient(
-        to bottom,
-        color-mix(in srgb, var(--cap-ink, #1f2be0) 10%, transparent) 1px,
-        transparent 1px
-      );
-    background-size: 16px 16px;
-    border-top: 1.5px solid var(--cap-ink, #1f2be0);
-    border-bottom: 1.5px solid var(--cap-ink, #1f2be0);
-    border-radius: 0;
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.1em 0.34em;
-    font-family: var(--font-display, "Newsreader"), Georgia, serif;
-    font-weight: 400;
-    font-size: clamp(40px, 4.4vw, 58px);
-    line-height: 1.16;
-    letter-spacing: -0.01em;
-  }
-
-  /* upcoming — faint cobalt, no block */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.06em;
-    color: color-mix(in srgb, var(--cap-ink, #1f2be0) 42%, var(--cap-canvas, #f0ebde));
-  }
-  /* current word — THE cobalt flat block (risograph knockout): a solid cobalt fill
-     via box-shadow spread = a hard square block w/o layout shift, no blur; the cream
-     paper reads on top */
-  .caption-word.is-active {
-    color: var(--cap-canvas, #f0ebde);
-    background: var(--cap-ink, #1f2be0);
-    box-shadow: 0 0 0 0.06em var(--cap-ink, #1f2be0);
-  }
-  /* already spoken — solid cobalt ink, block cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #1f2be0);
-    background: transparent;
-    box-shadow: none;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — Newsreader italic, cobalt's only display inflection */
-  .caption-word.cap-brand {
-    font-style: italic;
-  }
-  /* numerals / data — the body sans voice, slightly recessed */
-  .caption-word.cap-num {
-    font-family: var(--font-body, "Hanken Grotesk"), ui-monospace, monospace;
-    color: color-mix(in srgb, var(--cap-ink, #1f2be0) 72%, var(--cap-canvas, #f0ebde));
-  }
-  /* emphasis — a cobalt hairline underline (no second hue; emphasis is the ink) */
-  .caption-word.cap-cta {
-    text-decoration: underline;
-    text-decoration-thickness: 2px;
-    text-decoration-color: var(--cap-accent, #5560e5);
-    text-underline-offset: 0.1em;
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 48px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.985 }, { scale: 1, duration: 0.1, ease: "power3.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>

.claude/skills/hyperframes/assets/frame-presets/code-editorial/FRAME.md

@@ -1,277 +0,0 @@
----
-version: alpha
-name: Code editorial — Frame (video / frame layer)
-description: >
-  Video-first companion to Code editorial's design.md. The unit is the frame (1920×1080). Atoms are
-  identical and sacred — warm cream paper (never pure white, never cool), a single terracotta coral
-  as scarce "voltage", hairline ink elevation (no heavy shadow), EB Garamond for all
-  display + Inter body + JetBrains Mono for the index/code voice on a warm-navy code surface,
-  sentence-case display, and the ✱ coral spike mark. Composition + frame scale rewritten. Motion out
-  of scope.
-unit: the frame — 1920×1080 primary; 9:16 and 1:1 documented
-principle: atoms are sacred · composition is free · numbers come from the script
-
-colors:
-  ink: "#141413"
-  cream: "#FAF9F5"
-  tile: "#EFE9DE"
-  tile-strong: "#ECE3D4"
-  coral: "#CC785C"
-  navy: "#181715"
-  navy-soft: "#1F1E1B"
-  navy-elev: "#252320"
-
-borders: { hairline: "1px solid ink@12%", hairline-strong: "1px solid ink@20%", dark: "1px solid cream@14% (on navy)" }
-shadows: { card: "0 1px 3px ink@8%, 0 4px 16px ink@4%", none: "none" }
-
-typography:
-  # — reading + chrome ramp —
-  body:    { fontFamily: "Inter", cqw: 1.5, weight: 400, lineHeight: 1.5 }
-  lead:    { fontFamily: "Inter", cqw: 2.08, weight: 400, lineHeight: 1.5 }
-  card-title:{ fontFamily: "Inter", cqw: 2.3, weight: 500, lineHeight: 1.25, tracking: "-0.005em" }
-  button:  { fontFamily: "Inter", cqw: 1.46, weight: 500, lineHeight: 1.0 }
-  tag-upper:{ fontFamily: "Inter", cqw: 1.35, weight: 500, tracking: "0.18em", upper: true }
-  kicker:  { fontFamily: "JetBrains Mono", px: 28, cqw: 1.46, weight: 500, tracking: "0.16em", upper: true }
-  mono-label:{ fontFamily: "JetBrains Mono", px: 26, cqw: 1.35, weight: 500, tracking: "0.02em" }
-  code:    { fontFamily: "JetBrains Mono", cqw: 1.67, weight: 400, lineHeight: 1.6 }
-  # — display ramp (EB Garamond 400, sentence case, negative tracking. Renderer embeds only 400/700 — author at 400; italic is the synthesized slant) —
-  headline:{ fontFamily: "EB Garamond", cqw: 4.6, weight: 400, lineHeight: 1.06, tracking: "-0.018em" }
-  quote-pull:{ fontFamily: "EB Garamond", cqw: 5.0, weight: 400, lineHeight: 1.12, tracking: "-0.012em", italic: true }
-  display-italic:{ fontFamily: "EB Garamond", cqw: 6.7, weight: 400, lineHeight: 1.05, tracking: "-0.012em", italic: true }
-  display:{ fontFamily: "EB Garamond", cqw: 7.3, weight: 400, lineHeight: 1.02, tracking: "-0.022em" }
-  number-hero:{ fontFamily: "EB Garamond", cqw: 9.4, weight: 400, lineHeight: 0.95, tracking: "-0.025em" }
-  display-cover:{ fontFamily: "EB Garamond", cqw: 9.9, weight: 400, lineHeight: 0.98, tracking: "-0.028em" }
-  number-unit:{ fontFamily: "JetBrains Mono", cqw: 2.08, weight: 500, lineHeight: 1.0 }
-
-spacing:
-  slide-pad: "4.2cqw"   # ~80px @1920
-  gap-md: "1.7cqw"
-  hairline: "1px"
-  radius-sm: "6px"
-  radius-md: "8px"
-  radius-lg: "12px"
-  radius-pill: "9999px"
-
-components:
-  card-hairline:
-    backgroundColor: "{colors.cream} or {colors.tile}"
-    border: "1px solid {colors.ink}@12%"
-    rounded: "{spacing.radius-lg}"
-    shadow: "{shadows.card}"
-    typography: "{typography.card-title} + {typography.body}"
-    description: "The editorial content card. Elevation is the hairline + ONE soft warm shadow — never a heavy drop, glow, or gradient."
-  kicker-spike:
-    typography: "{typography.kicker}"
-    mark: "✱ coral spike prefix"
-    description: "The eyebrow — JetBrains Mono uppercase, indexical (2–5 words), prefixed with the coral ✱. Never plain text, never a sentence."
-  coral-callout:
-    backgroundColor: "{colors.coral} (full-bleed) or {colors.cream} with a coral edge"
-    textColor: "{colors.cream} on coral"
-    rounded: "{spacing.radius-md}"
-    typography: "{typography.button} / {typography.h2}"
-    description: "The ONE voltage moment per frame — the CTA, the single inline link, OR the full-bleed band. Never two corals in one frame."
-  number-lockup:
-    typography: "{typography.number-hero} figure + {typography.number-unit} unit"
-    description: "Hero stat — a EB Garamond figure paired with a JetBrains Mono unit (200K, +1,204, −318, 17 files). Figure is serif; the unit is ALWAYS mono, never the serif."
-  pull-quote:
-    typography: "{typography.quote-pull} (EB Garamond italic) + {typography.tag-upper} cite"
-    description: "A commit message, a reviewer line, or the thesis. EB Garamond italic, small Inter uppercase cite beneath."
-  section-rule:
-    rule: "1px solid {colors.ink}@12% (or {colors.cream}@14% on navy)"
-    description: "The only separator. A coral 1px rule may draw on to introduce a section. Never 2px+, never a heavy divider."
-  code-surface:
-    backgroundColor: "{colors.navy} body / {colors.navy-elev} title bar + status strip"
-    textColor: "{colors.cream} (JetBrains Mono); syntax in coral (keywords) / teal #5DB8A6 (strings) / amber #E8A55A (numbers)"
-    border: "1px solid {colors.cream}@14%"
-    rounded: "{spacing.radius-md}"
-    description: "The warm-navy code / terminal surface. The CODE ITSELF is rendered by the code-* registry blocks (code-diff / code-typing / code-snippet-*); this preset owns the surrounding surface, title bar, status strip, and mono chrome — not the code rendering."
-  spike-mark:
-    glyph: "✱ (U+2731), always {colors.coral}"
-    description: "The brand mark. Fades + scales 0.92→1 on a single emphasis beat; never spins."
----
-
-# Code editorial — Frame (video / frame layer)
-
-## Overview
-
-Code editorial at frame scale is a **warm-editorial brand book come to life** — the register of a literary
-imprint or a research note. The thesis is three colors: **cream is the ground, ink is the voice,
-coral is the voltage** — and a fourth (warm navy) only where code shows itself. Every surface is
-**warm cream** (never pure white, never cool gray); content gathers on a **tile** surface half a
-step darker — the demarcation is a half-step, never a hard contrast. Elevation is a **1px hairline**
-ink border at low alpha plus, rarely, one soft warm shadow. There are no heavy drops, no glows, no
-gradients on content.
-
-Three editorial voices, each in its own face: **EB Garamond** carries every display moment — covers,
-headlines, pull-quotes, big stat numerals — at large display sizes with gentle negative tracking;
-its **italic** is the expressive register. **Inter** carries body, leads, card titles, buttons, and
-UI chrome. **JetBrains Mono** carries the indexical layer — kickers, technical labels, the code
-window, status strips. Switching a voice's face collapses the register: a sans headline or a serif
-label reads as a different brand.
-
-**Key characteristics at frame scale:**
-
-- **Cream / ink / coral trinity** + a warm-navy code surface; cream is the default ground, ink the voice, coral the scarce voltage.
-- **EB Garamond** (sentence case, negative-tracked) for all display; **Inter** body/chrome; **JetBrains Mono** index + code.
-- **Hairline elevation** — a 1px low-alpha ink border + at most one soft warm shadow. No heavy drop, glow, or gradient.
-- **Coral is rationed** — at most ONE coral moment per frame (CTA, inline link, OR full-bleed band); coral never sets a headline or a body run.
-- **Density is free** — fill the frame as the content wants; a frame may stand on a single focal or carry a dense, layered composition.
-- **The ✱ coral spike** opens kickers; warm navy is reserved for the code/terminal surface.
-
-## The Frame
-
-### Frame Craft Bar
-
-Eyeball tests gate every frame before any structural check:
-
-- **Squint** — one EB Garamond display moment dominates at 3–6× its neighbor.
-- **Trinity** — cream/tile ground, ink text, coral exactly **once**; warm navy only on the code surface; no cool gray / pure white / fourth hue.
-- **Type** — EB Garamond sentence-case display (negative-tracked); Inter 400 body; JetBrains Mono kickers (uppercase 0.16em, coral ✱) + code.
-
-- **Primary:** 1920×1080 (16:9). Display authored in **`cqw`** (`px ÷ 1920 × 100 = cqw`).
-- **Vertical:** 1080×1920 (9:16). **Square:** 1080×1080 (1:1).
-- **Safe area:** `slide-pad` ~4.2cqw; the kicker/mono chrome sit inside it.
-
-**The container law (load-bearing).** Every frame ground sets `container-type: size`; ALL
-frame-relative units are `cqw`/`cqh` against it — never `vw`. Hairlines stay 1px; card radii stay
-6/8/12px; the warm-paper reading must survive every ratio.
-
-## Colors
-
-Tokens identical to the source. Default ground `{colors.cream}`; content gathers on
-`{colors.tile}` / `{colors.tile-strong}` (half-step warm steps, never a hard contrast).
-**Headlines & body:** `{colors.ink}` on cream/tile; `{colors.cream}` on navy. **Coral**
-(`{colors.coral}`) is the scarce voltage — one moment per frame (CTA, inline link, or full-bleed
-band), never body text, never a card fill. **Warm navy** (`{colors.navy}` / `navy-soft` /
-`navy-elev`) is the code / terminal / dark-card surface — a structural anchor, not a fourth brand
-hue. **No cool grays, no pure white, no pure black.**
-
-**Fixed syntax colors (decoration, NOT remixable brand hues).** When a code line is hand-set rather
-than rendered by a `code-*` block, keywords are coral, strings are **teal `#5DB8A6`**, numbers are
-**amber `#E8A55A`**; status reads success `#5DB872` / warn `#C64545`. These track the code surface,
-not the brand trinity — keep them out of the brand palette.
-
-## Typography
-
-Two ramps. The **reading/chrome ramp** (Inter `body` 1.5cqw / `lead` 2.08cqw weight 400; JetBrains
-Mono `kicker`/`mono-label` in px) carries copy + chrome; the **display ramp** (EB Garamond `headline` 4.6cqw
-→ `display-cover` 9.9cqw, weight 400, negative-tracked) carries every headline + stat.
-
-- **Legibility floor:** any load-bearing line ≥ **1.4cqw**; mono px labels are chrome only.
-- **Fit-to-measure:** size the headline to its length. Cap the block at **≤ 78cqw**; ≤3 words → `display-cover`; 4–6 → `display`; 7+ → `headline`. Reserve the 7.3–9.9cqw tier for cover / statement / stat.
-- **EB Garamond display is sentence case** (NOT title case, NOT uppercase), weight 400, negative-tracked (−0.012..−0.028em); reach for **italic** when the line is a stance or a definition. **Inter body** sentence case weight 400. **JetBrains Mono** kickers UPPERCASE 0.16em with the coral ✱. No uppercase serif, no sans headline, no serif label.
-
-## Depth & Surface
-
-Hairline elevation:
-
-- **1px hairline** ink border at ~12% alpha is the primary lift (cream@14% on navy).
-- **One soft warm shadow** (`0 1px 3px ink@8%, 0 4px 16px ink@4%`) — used rarely, never heavy.
-- **Half-step surface** — a `{colors.tile}` block on cream reads elevated by the warm step, not by a cast shadow.
-
-**Ceiling:** no heavy drop shadow, no glow, no gradient on content, no tilt. The system has no light
-to emit; it reads by warmth and hairline.
-
-## Shapes
-
-- **6px** small chrome, **8px** cards / code surface, **12px** large cards / quote frames, **9999px** true pills only. No square corners, no heavy rounding; the editorial register is gently rounded, never hard.
-
-## Components
-
-- **card-hairline** — the editorial content card (hairline + one soft shadow). **section-rule** — the only separator (1px, coral may draw on).
-- **kicker-spike** — the ✱ coral eyebrow. **coral-callout** — the one voltage moment (CTA / inline link / full-bleed band).
-- **number-lockup** — EB Garamond figure + mono unit (the PR `+N / −M`, `200K`, file counts). **pull-quote** — EB Garamond italic + cite (a commit message / reviewer line).
-- **code-surface** — the warm-navy code / terminal surface; the code itself comes from the **`code-*` registry blocks**, this owns the surface + mono chrome.
-- **spike-mark** — the ✱ brand glyph, always coral.
-
-## Frame Treatments
-
-> Recipe: ground · container · composes · focal · chrome · accent · Fixed/Free · density.
-> One coral moment per frame; open with a kicker-spike.
-
-### 1 · Cover (identity · move: oversized EB Garamond · cream)
-
-**Ground** `{colors.cream}`, `slide-pad`. **Composes** kicker-spike, display-cover, lead, mono-label index. **Focal** a 2–3 line EB Garamond `display-cover` (sentence case, ink) under a coral ✱ kicker. **Chrome** mono index strip (repo · branch). **Accent** the single coral ✱. **Fixed** EB Garamond 400 sentence case, hairline, cream ground. **Free** title, the mono index, layout + how full the frame runs. **Density** free.
-
-### 2 · Statement (statement · move: single EB Garamond line · cream or navy)
-
-**Ground** `{colors.cream}` (or `{colors.navy}` for gravity). **Composes** kicker-spike, display, optional lead. **Focal** one 2-line EB Garamond `display` carrying the change in a sentence — reach for **italic** if it's a stance. **Chrome** mono kicker. **Accent** none — the serif carries it (or one coral word). **Fixed** sentence-case serif. **Free** the line, ground, layout + density. **Density** free.
-
-### 3 · Code Surface (code · move: warm-navy code window · the PR-critical frame)
-
-**Ground** `{colors.cream}` framing a `{colors.navy}` **code-surface** (8px, cream@14% hairline, `navy-elev` title bar + filename in mono). **Composes** mono-label filename, the **`code-*` block** (code-diff / code-typing / code-snippet-_), optional `section-rule`. **Focal** the code panel — the diff / before→after / typed-on snippet. **Chrome** mono filename + status strip. **Accent** syntax coral/teal/amber inside the panel; one coral marker outside (e.g. a `+`/`−` gutter cue). **Fixed** warm-navy surface, mono code, hairline. **Free** which code-_ block, the code (from the diff), how large the panel runs. **Density** dense.
-
-### 4 · Number / Impact (data · move: oversized figure · cream)
-
-**Ground** `{colors.cream}`, `slide-pad`. **Composes** kicker-spike, number-lockup, lead/caption, optional `section-rule`. **Focal** a EB Garamond `number-hero` figure with a mono unit over a 1px rule — the PR impact (`+1,204 / −318`, `17 files`, `2.1× faster`). **Chrome** mono tag. **Accent** the figure in ink; at most one coral unit. **Fixed** serif figure + mono unit, hairline rule. **Free** the figures (from the script), tag, layout + density. **Density** free.
-
-### 5 · Pull-quote (quote · move: EB Garamond italic · cream)
-
-**Ground** `{colors.cream}`. **Composes** kicker-spike, pull-quote, tag-upper cite. **Focal** a EB Garamond **italic** `quote-pull` — a commit message, a reviewer line, or the thesis — with a small Inter uppercase cite (author · role) beneath. **Chrome** mono kicker. **Accent** none, or one coral mark. **Fixed** EB Garamond italic quote + uppercase cite. **Free** quote, attribution, layout + density. **Density** free.
-
-### 6 · Closing / CTA (closer · move: coral voltage · cream or navy)
-
-**Ground** `{colors.cream}` (or `{colors.navy}`). **Composes** display sign-off, coral-callout, optional contributor row (`assets/<login>.png` avatars + mono names). **Focal** a short EB Garamond sign-off with the one **coral-callout** (the CTA or full-bleed band) and, for a "shipped-by" close, a row of hairline-ringed avatar chips. **Chrome** mono index. **Accent** the single coral voltage. **Fixed** one coral moment, hairline avatar rings, sentence-case serif. **Free** sign-off, who ships, layout + density. **Density** free.
-
-## Composition Rules
-
-### Do
-
-- Stand every frame on the **warm cream floor**; gather content on a **half-step tile** surface.
-- Set all display in **EB Garamond, sentence case**, negative-tracked; **Inter 400** body; **JetBrains Mono** kickers (uppercase, 0.16em, coral ✱) + code.
-- Ration **coral to one moment per frame** — CTA, inline link, OR full-bleed band.
-- Elevate with a **1px hairline** + at most one soft warm shadow; reserve **warm navy** for the code/terminal surface.
-- Lead with **one clear focal**; open regions with a **kicker-spike**. Fill the frame as the content wants.
-- Pair a EB Garamond figure with a **mono unit** for every stat; render code via the **`code-*` blocks** on the navy surface.
-
-### Don't
-
-- No pure white, no cool gray, no pure black; no fourth brand hue (navy is structural, syntax colors are decoration).
-- No heavy drop shadow, glow, gradient on content, or tilt — hairline elevation only.
-- No uppercase or title-case EB Garamond display; no sans headline; no serif label; no serif-set numeric unit.
-- No two coral moments in one frame; coral never sets a headline or body run.
-- Don't blow a headline past the measure — step the ramp down.
-
-## Aspect-Ratio Behavior
-
-| Treatment     | 16:9                    | 9:16                        | 1:1                    |
-| ------------- | ----------------------- | --------------------------- | ---------------------- |
-| Cover         | display left, index top | display top, index below    | display, index corner  |
-| Statement     | line left/centered      | line stacked                | centered               |
-| Code Surface  | panel framed in cream   | panel taller, fewer lines   | panel centered, square |
-| Number/Impact | figure left             | figure centered, taller     | centered               |
-| Pull-quote    | quote left              | quote stacked               | centered               |
-| Closing/CTA   | sign-off + avatar row   | sign-off top, avatars below | centered, avatars wrap |
-
-`slide-pad` holds on the short edge; re-step display above the 1.4cqw floor. The code surface keeps
-its hairline + mono chrome on every ratio; the avatar row wraps rather than shrinks below legibility.
-
-## Approved Real Entities
-
-No real customers, logos, or vendors are defined in the source — render any such mark as a
-placeholder. Contributor avatars come from the project's `assets/<login>.png` (staged from the PR's
-people graph); the ✱ spike, hairlines, and the code surface are CSS-only and need no external imagery.
-
-## Numerals & Claims (hard rule)
-
-Never invent figures, stats, diffs, or counts at frame scale. Render slots as `— figure —`,
-`{metric}`, `+N / −M`. Number-lockups, code panels, and impact stats carry placeholders until the
-script (from the PR ingest) supplies real values. Branch names, file counts, and `+/−` totals trace
-to the diff; commit/issue numbers are chrome.
-
-## Pre-Render Self-Audit
-
-- **Squint** — one EB Garamond display moment dominates.
-- **Trinity** — cream floor + tile step + ink voice; coral appears exactly once; warm navy only on the code surface; no cool gray / pure white / fourth hue.
-- **Type** — EB Garamond sentence-case display (negative-tracked); Inter 400 body; JetBrains Mono kickers (uppercase 0.16em, coral ✱) + code; ≥1.4cqw floor.
-- **Depth** — 1px hairline + at most one soft warm shadow; no heavy drop / glow / gradient / tilt; 6/8/12px radii.
-- **Code** — code rendered by a `code-*` block on the warm-navy surface; syntax coral/teal/amber; figures paired with a mono unit.
-- **Fabrication** — every numeral / diff traces to the PR, else placeholder.
-
-## Known Gaps
-
-- **Motion intentionally out of scope.** frame.md specifies composition only. Code editorial's motion register — short cross-dissolves, no overshoot/bounce/elastic, coral the only "draw-on", numbers count up, code types on line by line — lives in the skill's `references/motion.md`, not here.
-- **EB Garamond + Inter + JetBrains Mono ship as licensed local WOFF2 assets with this preset.** Copy the six files in this preset's `fonts/` folder (weights 400 + 700) into the project's `assets/fonts/` and add one `@font-face` per file, so Studio, snapshots, and renders resolve them offline without a first-run Google Fonts fetch. Nothing stages them for you. Author display at **weight 400** (700 reads as a heavy bold, off-register), and treat italic as the browser-synthesized slant (acceptable for the pull-quote register; add a real italic face only if a project leans hard on it). EB Garamond is a warm old-style serif (low contrast, humanist); if it ever fails, fall to Georgia or another old-style serif — never to a sans. CJK: Noto Serif SC (display) / Noto Sans SC (body) / Noto Sans Mono CJK (code); the sentence-case warmth carries when the serif drops.
-- **Syntax colors (teal `#5DB8A6` / amber `#E8A55A` / status) are fixed decoration**, declared in §Colors — they are NOT in the remixable `colors:` block, so a brand remix never repaints them.
-- **The code itself is the `code-*` registry blocks**, not this preset — this preset owns only the surrounding warm-navy surface + mono chrome.
-- **9:16 / 1:1 are guidance**; verify the legibility floor and that the cream/tile warmth + one-coral discipline hold per ratio.

.claude/skills/hyperframes/assets/frame-presets/code-editorial/caption-skin.html

@@ -1,223 +0,0 @@
-<!--
-  Code editorial — caption skin (preset-local source).
-
-  This is the preset's own lower-third karaoke caption look: a caption skin to read or
-  copy, not to mount as is. A copy used as compositions/captions.html fills its three
-  reserved holes and wraps the fragment in a <template>:
-    · the empty GROUPS array            → the engine's scene-aware word groups
-    · the 0 duration + 0 width/height   → real total + canvas size
-    · the empty data-brand-tokens style → :root tokens derived from the project's frame.md
-
-  Token contract — reference ONLY this fixed vocab (set it from the
-  project's frame.md; each var has a code-editorial literal
-  fallback for standalone preview):
-    --cap-ink · --cap-canvas · --cap-accent · --cap-accent-2 · --font-display ·
-    --font-body · --cap-band-top · --cap-band-height
-  Hooks (do not rename): .caption-group / .caption-word + states .is-active / .is-spoken,
-  root data-composition-id="captions", timeline at window.__timelines["captions"].
-  State changes use gsap.set({className}) (applied on the engine's frame-by-frame seek);
-  never tl.call() callbacks (seek does not fire them → wrong state on render).
-
-  Visual: a warm cream card lifted off the page on a 1px hairline ink border + one soft
-  warm shadow — code-editorial's only elevation language, no tilt, editorial and precise.
-  EB Garamond sentence case, warm-ink glyphs. Upcoming words sit in faint ink; the current
-  word reads in full ink under a 3px coral "voltage" underline (the brand's inline-link
-  gesture, border-bottom = underline without layout shift); spoken words settle to solid
-  ink, underline cleared.
--->
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-
-<!-- the project's :root tokens go here -->
-<style data-brand-tokens></style>
-
-<style>
-  #captions-root {
-    position: absolute;
-    inset: 0;
-    pointer-events: none;
-  }
-  .caption-layer {
-    position: absolute;
-    inset: 0;
-    z-index: 20;
-    pointer-events: none;
-  }
-  /* the keep-out band, from captionBand(H) — frame content stays above it */
-  .caption-stage {
-    position: absolute;
-    left: 0;
-    right: 0;
-    top: var(--cap-band-top, 900px);
-    height: var(--cap-band-height, 180px);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  .caption-group {
-    /* every group is absolutely stacked over the SAME band — exactly one shown at a
-       time via opacity. Must be absolute: in-flow groups would lay out side-by-side. */
-    position: absolute;
-    inset: 0;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    opacity: 0;
-  }
-
-  /* THE lifted cream card — warm cream fill, 1px hairline ink border, one soft warm
-     shadow (code-editorial's only elevation language), 12px radius, no tilt */
-  .caption-pill {
-    max-width: 78%;
-    padding: 22px 44px 26px;
-    background: var(--cap-canvas, #faf9f5);
-    border: 1px solid color-mix(in srgb, var(--cap-ink, #141413) 12%, transparent);
-    border-radius: 12px;
-    box-shadow:
-      0 1px 3px color-mix(in srgb, var(--cap-ink, #141413) 8%, transparent),
-      0 4px 16px color-mix(in srgb, var(--cap-ink, #141413) 4%, transparent);
-  }
-  .caption-line {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: 0.12em 0.3em;
-    font-family: var(--font-display, "EB Garamond"), Georgia, serif;
-    font-weight: 500;
-    font-size: clamp(40px, 4.4vw, 56px);
-    line-height: 1.24;
-    letter-spacing: -0.02em;
-  }
-
-  /* upcoming — faint warm ink, no underline */
-  .caption-word {
-    display: inline-block;
-    padding: 0 0.02em 0.06em;
-    color: color-mix(in srgb, var(--cap-ink, #141413) 40%, var(--cap-canvas, #faf9f5));
-    border-bottom: 3px solid transparent;
-  }
-  /* current word — full ink under the coral voltage underline (the brand's signature
-     inline-link gesture; border-bottom = underline without layout shift) */
-  .caption-word.is-active {
-    color: var(--cap-ink, #141413);
-    border-bottom: 3px solid var(--cap-accent, #cc785c);
-  }
-  /* already spoken — solid warm ink, underline cleared */
-  .caption-word.is-spoken {
-    color: var(--cap-ink, #141413);
-    border-bottom: 3px solid transparent;
-  }
-
-  /* optional per-word accents (dormant until a word-classer tags them) */
-  /* brand / key term — the expressive EB Garamond italic */
-  .caption-word.cap-brand {
-    font-style: italic;
-    color: var(--cap-ink, #141413);
-  }
-  .caption-word.cap-brand.is-active {
-    border-bottom: 3px solid var(--cap-accent, #cc785c);
-  }
-  /* numerals / data — slightly recessed warm ink */
-  .caption-word.cap-num {
-    color: color-mix(in srgb, var(--cap-ink, #141413) 72%, var(--cap-canvas, #faf9f5));
-  }
-  /* emphasis — a persistent coral voltage underline */
-  .caption-word.cap-cta {
-    border-bottom: 3px solid var(--cap-accent-2, #b5654a);
-    color: var(--cap-ink, #141413);
-  }
-
-  @media (max-aspect-ratio: 9/16) {
-    .caption-pill {
-      max-width: 92%;
-    }
-    .caption-line {
-      font-size: clamp(34px, 5.4vw, 46px);
-    }
-  }
-</style>
-
-<div
-  id="captions-root"
-  data-composition-id="captions"
-  data-timeline-locked
-  data-start="0"
-  data-duration="0"
-  data-fps="30"
-  data-width="0"
-  data-height="0"
->
-  <div class="caption-layer" aria-hidden="true">
-    <div id="caption-stage" class="caption-stage"></div>
-  </div>
-</div>
-
-<script>
-  // the scene-aware word groups + real duration go here.
-  var GROUPS = [];
-  var DURATION = 0;
-
-  (function () {
-    var stage = document.getElementById("caption-stage");
-
-    // build DOM: one .caption-group per group, .caption-word per word
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.createElement("div");
-      groupEl.className = "caption-group";
-      groupEl.id = "caption-group-" + g;
-      var pill = document.createElement("div");
-      pill.className = "caption-pill";
-      var line = document.createElement("div");
-      line.className = "caption-line";
-      (group.words || []).forEach(function (w, i) {
-        var span = document.createElement("span");
-        span.className = "caption-word";
-        span.id = "caption-word-" + g + "-" + i;
-        span.textContent = String(w.text);
-        line.appendChild(span);
-      });
-      pill.appendChild(line);
-      groupEl.appendChild(pill);
-      stage.appendChild(groupEl);
-    });
-
-    window.__timelines = window.__timelines || {};
-    var tl = gsap.timeline({ paused: true });
-
-    GROUPS.forEach(function (group, g) {
-      var groupEl = document.getElementById("caption-group-" + g);
-      var words = group.words || [];
-      var next = GROUPS[g + 1];
-      var isLast = g === GROUPS.length - 1;
-      var start = Math.max(0, Number(group.start));
-      var end = isLast ? DURATION : Math.min(Number(next.start), Number(group.end) + 0.3);
-      if (end <= start) end = start + 0.01;
-
-      // group on/off — exactly one group visible at a time
-      tl.set(groupEl, { opacity: 1 }, start);
-      tl.set(groupEl, { opacity: 0 }, end);
-
-      // 3-state karaoke via className SETS — seek-safe (gsap.set applies on the
-      // engine's frame-by-frame seek; .call callbacks would NOT fire).
-      words.forEach(function (w, i) {
-        var el = document.getElementById("caption-word-" + g + "-" + i);
-        var at = Math.max(start, Number(w.start));
-        tl.set(el, { className: "caption-word" }, start); // upcoming (also resets on reverse-seek)
-        tl.set(el, { className: "caption-word is-active" }, at); // current
-        tl.fromTo(el, { scale: 0.98 }, { scale: 1, duration: 0.16, ease: "power1.out" }, at);
-        if (i + 1 < words.length) {
-          var nextAt = Math.max(start, Number(words[i + 1].start));
-          tl.set(el, { className: "caption-word is-spoken" }, nextAt); // demote when next activates
-        }
-      });
-      if (words.length) {
-        var lastEl = document.getElementById("caption-word-" + g + "-" + (words.length - 1));
-        var lastSpoken = Math.min(end, Number(words[words.length - 1].end) + 0.1);
-        tl.set(lastEl, { className: "caption-word is-spoken" }, lastSpoken);
-      }
-    });
-
-    // full-span anchor so the sub-comp timeline spans the whole video
-    tl.to({}, { duration: DURATION }, 0);
-    window.__timelines["captions"] = tl;
-  })();
-</script>