Skip to content

Write HTML. Render video. Built for agents.

docs(skills): make reference guides directly discoverable (#5858)

Miguel Ángel388011b2147b
diff --git a/skills-manifest.json b/skills-manifest.json
index fe32020a25..f38fe421a4 100644
--- a/skills-manifest.json
+++ b/skills-manifest.json
@@ -18,11 +18,11 @@
"files": 6
},
"hyperframes": {
- "hash": "44700184328c21b5",
+ "hash": "6ef04c743e34f0b2",
"files": 31
},
"hyperframes-animation": {
- "hash": "1c91404cdf888540",
+ "hash": "eeadb8a12feaaba8",
"files": 122
},
"hyperframes-audio": {
@@ -58,7 +58,7 @@
"files": 113
},
"motion-graphics": {
- "hash": "7e4af0881390ac2e",
+ "hash": "67bd36b53df3b7e0",
"files": 23
},
"music-to-video": {
diff --git a/skills/hyperframes-animation/SKILL.md b/skills/hyperframes-animation/SKILL.md
index e5299de70e..f8aed518d9 100644
--- a/skills/hyperframes-animation/SKILL.md
+++ b/skills/hyperframes-animation/SKILL.md
@@ -7,6 +7,17 @@ description: "All animation knowledge for HyperFrames — atomic motion rules, m
# HyperFrames Animation
+## Contents
+
+- [Default: compose atomic rules](#default-compose-atomic-rules)
+- [Load a blueprint when](#load-a-blueprint-when)
+- [Routing](#routing)
+- [Picking a runtime](#picking-a-runtime)
+- [Critical Constraints](#critical-constraints)
+- [Scripts](#scripts)
+- [See Also](#see-also)
+- [Reference files](#reference-files)
+
All motion knowledge in one skill: **rules** (atomic recipes), **blueprints** (multi-phase scene templates), **transitions** (scene-to-scene), **techniques** (broader motion-design patterns), and **adapters** (per-runtime APIs).
For the composition contract (data attributes, sub-compositions, determinism) see `hyperframes-core`.
@@ -86,3 +97,127 @@ Reads every GSAP timeline registered on `window.__timelines`, enumerates tweens,
- `hyperframes-core` — composition structure, data attributes, sub-compositions, deterministic render contract
- `hyperframes-creative` — palettes, typography, narration, beat planning (non-animation creative direction)
- `hyperframes-cli` — `npx hyperframes lint / check / snapshot / preview / render`
+
+## Reference files
+
+Read the matching file directly when its topic applies; the indexes remain available for choosing among recipes.
+
+### Adapters
+
+- [Text Effects — Reference](adapters/animate-text.md) — Read when using this animation runtime or adapter API.
+- [Anime.js for HyperFrames](adapters/animejs.md) — Read when using this animation runtime or adapter API.
+- [CSS Animations for HyperFrames](adapters/css-animations.md) — Read when using this animation runtime or adapter API.
+- [Easing, Stagger, and Function-Based Values](adapters/gsap-easing-and-stagger.md) — Read when using this animation runtime or adapter API.
+- [Timelines and Labels](adapters/gsap-timeline-and-labels.md) — Read when using this animation runtime or adapter API.
+- [Transforms and Performance](adapters/gsap-transforms-and-perf.md) — Read when using this animation runtime or adapter API.
+- [HyperFrames GSAP](adapters/gsap.md) — Read when using this animation runtime or adapter API.
+- [HTML-in-Canvas Patterns](adapters/html-in-canvas-patterns.md) — Read when using this animation runtime or adapter API.
+- [Lottie for HyperFrames](adapters/lottie.md) — Read when using this animation runtime or adapter API.
+- [Three.js for HyperFrames](adapters/three.md) — Read when using this animation runtime or adapter API.
+- [TypeGPU / WebGPU for HyperFrames](adapters/typegpu.md) — Read when using this animation runtime or adapter API.
+- [Web Animations API for HyperFrames](adapters/waapi.md) — Read when using this animation runtime or adapter API.
+
+### Blueprints
+
+- [agent-progress-theater — Agent Progress Theater](blueprints/agent-progress-theater.md) — Read when composing this multi-phase scene.
+- [camera-journey — Camera Journey](blueprints/camera-journey.md) — Read when composing this multi-phase scene.
+- [comparison-split — Comparison Split-Cards](blueprints/comparison-split.md) — Read when composing this multi-phase scene.
+- [constellation-hub — Constellation / Hub + Satellites](blueprints/constellation-hub.md) — Read when composing this multi-phase scene.
+- [cta-morph-press — CTA Morph & Press](blueprints/cta-morph-press.md) — Read when composing this multi-phase scene.
+- [cursor-ui-demo — Cursor-Driven UI Demo](blueprints/cursor-ui-demo.md) — Read when composing this multi-phase scene.
+- [dataviz-countup — Data-Viz / Count-Up](blueprints/dataviz-countup.md) — Read when composing this multi-phase scene.
+- [device-surface-showcase — Device / Surface Showcase](blueprints/device-surface-showcase.md) — Read when composing this multi-phase scene.
+- [fixed-anchor-cycle — Fixed Anchor, Cycling World](blueprints/fixed-anchor-cycle.md) — Read when composing this multi-phase scene.
+- [grid-card-assemble — Grid / Card Assemble](blueprints/grid-card-assemble.md) — Read when composing this multi-phase scene.
+- [kinetic-type-beats — Kinetic-Type Beats](blueprints/kinetic-type-beats.md) — Read when composing this multi-phase scene.
+- [logo-assemble-lockup — Logo Assemble → Lockup](blueprints/logo-assemble-lockup.md) — Read when composing this multi-phase scene.
+- [overwhelm-surround — Overwhelm / Close-In](blueprints/overwhelm-surround.md) — Read when composing this multi-phase scene.
+- [panel-edit-live-sync — Panel Edit, Live Sync](blueprints/panel-edit-live-sync.md) — Read when composing this multi-phase scene.
+- [prompt-type-submit-generate — Prompt, Submit, Generate](blueprints/prompt-type-submit-generate.md) — Read when composing this multi-phase scene.
+- [spatial-pan-stations — Spatial Pan / Stations](blueprints/spatial-pan-stations.md) — Read when composing this multi-phase scene.
+- [ticker-takeover — Ticker Displace / Takeover](blueprints/ticker-takeover.md) — Read when composing this multi-phase scene.
+- [titlecard-reveal — Title-Card / Single-Card Reveal](blueprints/titlecard-reveal.md) — Read when composing this multi-phase scene.
+- [transcript-scroll-artifact-reveal — Transcript-Scroll Artifact Reveal](blueprints/transcript-scroll-artifact-reveal.md) — Read when composing this multi-phase scene.
+- [typewriter-reveal — Typewriter Reveal](blueprints/typewriter-reveal.md) — Read when composing this multi-phase scene.
+- [video-text-pivot — Video → Text Pivot](blueprints/video-text-pivot.md) — Read when composing this multi-phase scene.
+- [zoom-out-workspace-reveal — Zoom-Out Workspace Reveal](blueprints/zoom-out-workspace-reveal.md) — Read when composing this multi-phase scene.
+
+### Guides
+
+- [Blueprints (the proven shapes)](blueprints-index.md) — Read when choosing a scene blueprint.
+- [Rules Index](rules-index.md) — Read when choosing atomic motion rules by trigger or tag.
+- [Visual Techniques Reference](techniques.md) — Read when choosing broader motion-design techniques.
+
+### References
+
+- [Motion blur — shutter smear on any animated element](references/motion-blur.md) — Read when choosing element-level motion blur and its limits.
+
+### Rules
+
+- [3D Camera Flight](rules/3d-camera-flight.md) — Read when applying this atomic motion recipe.
+- [3D Page Scroll](rules/3d-page-scroll.md) — Read when applying this atomic motion recipe.
+- [3D Text Depth Layers](rules/3d-text-depth-layers.md) — Read when applying this atomic motion recipe.
+- [AI Tracking Box](rules/ai-tracking-box.md) — Read when applying this atomic motion recipe.
+- [Ambient Glow Bloom](rules/ambient-glow-bloom.md) — Read when applying this atomic motion recipe.
+- [Anchored Layout Expand](rules/anchored-layout-expand.md) — Read when applying this atomic motion recipe.
+- [ASR Keyword Glow](rules/asr-keyword-glow.md) — Read when applying this atomic motion recipe.
+- [Avatar Cloud Network](rules/avatar-cloud-network.md) — Read when applying this atomic motion recipe.
+- [Two-Phase Camera Cursor Tracking](rules/camera-cursor-tracking.md) — Read when applying this atomic motion recipe.
+- [Card Morph Anchor](rules/card-morph-anchor.md) — Read when applying this atomic motion recipe.
+- [Center-Outward Expansion](rules/center-outward-expansion.md) — Read when applying this atomic motion recipe.
+- [Chart Scrub Readout](rules/chart-scrub-readout.md) — Read when applying this atomic motion recipe.
+- [Chromatic Glitch](rules/chromatic-glitch.md) — Read when applying this atomic motion recipe.
+- [Context-Sensitive Cursor](rules/context-sensitive-cursor.md) — Read when applying this atomic motion recipe.
+- [Control-Target Sync](rules/control-target-sync.md) — Read when applying this atomic motion recipe.
+- [Coordinate Target Zoom](rules/coordinate-target-zoom.md) — Read when applying this atomic motion recipe.
+- [Counting with Dynamic Scale](rules/counting-dynamic-scale.md) — Read when applying this atomic motion recipe.
+- [CSS Patterns for Marker Highlighting](rules/css-marker-patterns.md) — Read when applying this atomic motion recipe.
+- [Cursor Click Ripple](rules/cursor-click-ripple.md) — Read when applying this atomic motion recipe.
+- [Cursor Drag](rules/cursor-drag.md) — Read when applying this atomic motion recipe.
+- [Depth-of-Field Blur (Selective Focus / Rack Focus)](rules/depth-of-field-blur.md) — Read when applying this atomic motion recipe.
+- [Depth Scatter ↔ Assemble](rules/depth-scatter-assemble.md) — Read when applying this atomic motion recipe.
+- [Discrete Text Sequence](rules/discrete-text-sequence.md) — Read when applying this atomic motion recipe.
+- [Dynamic Content Sequencing](rules/dynamic-content-sequencing.md) — Read when applying this atomic motion recipe.
+- [Gradient Text Sweep](rules/gradient-text-sweep.md) — Read when applying this atomic motion recipe.
+- [GSAP Effects for HyperFrames](rules/gsap-effects.md) — Read when applying this atomic motion recipe.
+- [Hacker Flip 3D Reveal](rules/hacker-flip-3d.md) — Read when applying this atomic motion recipe.
+- [Kinetic Beat Slam](rules/kinetic-beat-slam.md) — Read when applying this atomic motion recipe.
+- [Motion-Blur Streak](rules/motion-blur-streak.md) — Read when applying this atomic motion recipe.
+- [Multi-Cursor Choreography](rules/multi-cursor-choreography.md) — Read when applying this atomic motion recipe.
+- [Multi-Phase Camera](rules/multi-phase-camera.md) — Read when applying this atomic motion recipe.
+- [Nudge Curve](rules/nudge-curve.md) — Read when applying this atomic motion recipe.
+- [Orbit with 3D Entry](rules/orbit-3d-entry.md) — Read when applying this atomic motion recipe.
+- [Particle Burst](rules/particle-burst.md) — Read when applying this atomic motion recipe.
+- [Physics Press Reaction (Cursor + Element Synced)](rules/physics-press-reaction.md) — Read when applying this atomic motion recipe.
+- [Press-Release Spring Chain](rules/press-release-spring.md) — Read when applying this atomic motion recipe.
+- [Reactive Displacement](rules/reactive-displacement.md) — Read when applying this atomic motion recipe.
+- [Scale-Swap Transition](rules/scale-swap-transition.md) — Read when applying this atomic motion recipe.
+- [Sine Wave Loop (subtle jitter / bounded ambient)](rules/sine-wave-loop.md) — Read when applying this atomic motion recipe.
+- [Split Tilt Cards](rules/split-tilt-cards.md) — Read when applying this atomic motion recipe.
+- [Spring-Pop Entrance](rules/spring-pop-entrance.md) — Read when applying this atomic motion recipe.
+- [Stat Bars & Fills](rules/stat-bars-and-fills.md) — Read when applying this atomic motion recipe.
+- [SVG Icon Enrichment](rules/svg-icon-enrichment.md) — Read when applying this atomic motion recipe.
+- [SVG Path Draw](rules/svg-path-draw.md) — Read when applying this atomic motion recipe.
+- [Theme Crossfade Morph](rules/theme-crossfade-morph.md) — Read when applying this atomic motion recipe.
+- [Vertical Spring Ticker (Slot Machine)](rules/vertical-spring-ticker.md) — Read when applying this atomic motion recipe.
+- [Viewport Change (Virtual Camera)](rules/viewport-change.md) — Read when applying this atomic motion recipe.
+- [Waterfall Entry](rules/waterfall-entry.md) — Read when applying this atomic motion recipe.
+
+### Transitions
+
+- [Transition Registry — machine source of truth](transitions/TRANSITION-REGISTRY.md) — Read when choosing or implementing this scene transition.
+- [Transition Catalog](transitions/catalog.md) — Read when choosing or implementing this scene transition.
+- [3D](transitions/css-3d.md) — Read when choosing or implementing this scene transition.
+- [Blur](transitions/css-blur.md) — Read when choosing or implementing this scene transition.
+- [Cover](transitions/css-cover.md) — Read when choosing or implementing this scene transition.
+- [Destruction](transitions/css-destruction.md) — Read when choosing or implementing this scene transition.
+- [Dissolve](transitions/css-dissolve.md) — Read when choosing or implementing this scene transition.
+- [Distortion](transitions/css-distortion.md) — Read when choosing or implementing this scene transition.
+- [Grid](transitions/css-grid.md) — Read when choosing or implementing this scene transition.
+- [Light](transitions/css-light.md) — Read when choosing or implementing this scene transition.
+- [Mechanical](transitions/css-mechanical.md) — Read when choosing or implementing this scene transition.
+- [Other](transitions/css-other.md) — Read when choosing or implementing this scene transition.
+- [Linear / Push](transitions/css-push.md) — Read when choosing or implementing this scene transition.
+- [Radial / Shape](transitions/css-radial.md) — Read when choosing or implementing this scene transition.
+- [Scale / Zoom](transitions/css-scale.md) — Read when choosing or implementing this scene transition.
+- [Scene Transitions](transitions/overview.md) — Read when choosing or implementing this scene transition.
diff --git a/skills/hyperframes-animation/adapters/animejs.md b/skills/hyperframes-animation/adapters/animejs.md
index 613292aeec..60a9ec4129 100644
--- a/skills/hyperframes-animation/adapters/animejs.md
+++ b/skills/hyperframes-animation/adapters/animejs.md
@@ -5,6 +5,19 @@ description: Anime.js adapter patterns for HyperFrames. Use when writing Anime.j
# Anime.js for HyperFrames
+## Contents
+
+- [Contract](#contract)
+- [Loading v4](#loading-v4)
+- [Basic Pattern](#basic-pattern)
+- [Timeline Pattern](#timeline-pattern)
+- [Module Builds](#module-builds)
+- [Determinism](#determinism)
+- [Good Uses](#good-uses)
+- [Avoid](#avoid)
+- [Validation](#validation)
+- [Credits And References](#credits-and-references)
+
HyperFrames can seek Anime.js instances through its `animejs` runtime adapter. The composition owns the animation objects; HyperFrames owns the clock.
**This page targets v4 (examples pinned to 4.5.0, MIT).** v4 is a hard break from v3 — there is no callable `anime()`, `easing:` is now `ease:`, and ease names lost their `ease` prefix. Writing v3 from memory produces a composition that throws or silently animates nothing.
diff --git a/skills/hyperframes-animation/adapters/css-animations.md b/skills/hyperframes-animation/adapters/css-animations.md
index 61915aa793..bcda868999 100644
--- a/skills/hyperframes-animation/adapters/css-animations.md
+++ b/skills/hyperframes-animation/adapters/css-animations.md
@@ -5,6 +5,17 @@ description: CSS animation adapter patterns for HyperFrames. Use when authoring
# CSS Animations for HyperFrames
+## Contents
+
+- [Contract](#contract)
+- [Basic Pattern](#basic-pattern)
+- [Stagger Pattern](#stagger-pattern)
+- [Good Uses](#good-uses)
+- [Avoid](#avoid)
+- [Composition Duration](#composition-duration)
+- [Validation](#validation)
+- [Credits And References](#credits-and-references)
+
HyperFrames can seek CSS keyframe animations through its `css` runtime adapter. Use this for simple repeated motifs, background motion, shimmer, glow, masks, and non-sequenced decoration.
For scene choreography, GSAP is usually clearer. CSS animations work best when the motion belongs to one element and has a fixed duration.
diff --git a/skills/hyperframes-animation/adapters/gsap-easing-and-stagger.md b/skills/hyperframes-animation/adapters/gsap-easing-and-stagger.md
index 8e03eafd53..1377195f8c 100644
--- a/skills/hyperframes-animation/adapters/gsap-easing-and-stagger.md
+++ b/skills/hyperframes-animation/adapters/gsap-easing-and-stagger.md
@@ -1,5 +1,15 @@
# Easing, Stagger, and Function-Based Values
+## Contents
+
+- [Easing](#easing)
+- [Easing Vocabulary (character & mood)](#easing-vocabulary-character--mood)
+- [Defaults](#defaults)
+- [Spring Eases (baked physics, seek-safe)](#spring-eases-baked-physics-seek-safe)
+- [Stagger](#stagger)
+- [Function-Based Values](#function-based-values)
+- [gsap.matchMedia (preview only)](#gsapmatchmedia-preview-only)
+
## Easing
Built-in eases: `power1`, `power2`, `power3`, `power4`, `back`, `bounce`, `circ`, `elastic`, `expo`, `sine`, `none`.
diff --git a/skills/hyperframes-animation/adapters/gsap-transforms-and-perf.md b/skills/hyperframes-animation/adapters/gsap-transforms-and-perf.md
index e84670dc29..aee1135e1f 100644
--- a/skills/hyperframes-animation/adapters/gsap-transforms-and-perf.md
+++ b/skills/hyperframes-animation/adapters/gsap-transforms-and-perf.md
@@ -1,5 +1,15 @@
# Transforms and Performance
+## Contents
+
+- [Transform Aliases](#transform-aliases)
+- [autoAlpha](#autoalpha)
+- [clearProps](#clearprops)
+- [CSS Variables](#css-variables)
+- [Relative and Directional Values](#relative-and-directional-values)
+- [SVG Specifics](#svg-specifics)
+- [Performance Rules](#performance-rules)
+
## Transform Aliases
Prefer GSAP's transform aliases over raw `transform` strings:
diff --git a/skills/hyperframes-animation/adapters/gsap.md b/skills/hyperframes-animation/adapters/gsap.md
index ebe7565609..1593c3d7d4 100644
--- a/skills/hyperframes-animation/adapters/gsap.md
+++ b/skills/hyperframes-animation/adapters/gsap.md
@@ -5,6 +5,17 @@ description: GSAP animation API reference for HyperFrames. Use when writing seek
# HyperFrames GSAP
+## Contents
+
+- [HyperFrames Contract](#hyperframes-contract)
+- [Core Tween Methods](#core-tween-methods)
+- [Common vars (cheatsheet)](#common-vars-cheatsheet)
+- [Animated Property Allowlist](#animated-property-allowlist)
+- [References](#references)
+- [Best Practices](#best-practices)
+- [Do Not](#do-not)
+- [Credits And References](#credits-and-references)
+
GSAP usage scoped to HyperFrames' seek-driven render model. This skill is the GSAP reference _as constrained by HyperFrames_ — for the framework's broader composition contract see `hyperframes-core`.
## HyperFrames Contract
diff --git a/skills/hyperframes-animation/adapters/html-in-canvas-patterns.md b/skills/hyperframes-animation/adapters/html-in-canvas-patterns.md
index f826b1f921..dce4661902 100644
--- a/skills/hyperframes-animation/adapters/html-in-canvas-patterns.md
+++ b/skills/hyperframes-animation/adapters/html-in-canvas-patterns.md
@@ -1,5 +1,13 @@
# HTML-in-Canvas Patterns
+## Contents
+
+- [Core Boilerplate (same in every HTML-in-Canvas composition)](#core-boilerplate-same-in-every-html-in-canvas-composition)
+- [Effect Catalog](#effect-catalog)
+- [When to Use HTML-in-Canvas vs Standard GSAP](#when-to-use-html-in-canvas-vs-standard-gsap)
+- [More Effects You Can Build](#more-effects-you-can-build)
+- [Creating ANY Custom Effect](#creating-any-custom-effect)
+
HyperFrames' most powerful visual capability. Capture ANY live HTML/CSS as a GPU texture, then render it through WebGL shaders, Three.js 3D scenes, or post-processing effects — at 60fps, pixel-perfect, with every CSS feature supported.
**Read this file when a beat deserves cinematic treatment beyond flat GSAP animations.** Use for 1-3 hero beats per video, not every beat. The rest can use standard GSAP — the contrast between flat beats and HTML-in-Canvas beats IS part of the visual storytelling.
diff --git a/skills/hyperframes-animation/adapters/lottie.md b/skills/hyperframes-animation/adapters/lottie.md
index ef7d6b9365..6697e34365 100644
--- a/skills/hyperframes-animation/adapters/lottie.md
+++ b/skills/hyperframes-animation/adapters/lottie.md
@@ -5,6 +5,19 @@ description: Lottie and dotLottie adapter patterns for HyperFrames. Use when emb
# Lottie for HyperFrames
+## Contents
+
+- [Contract](#contract)
+- [lottie-web Pattern](#lottie-web-pattern)
+- [dotLottie Pattern](#dotlottie-pattern)
+- [Multiple Animations](#multiple-animations)
+- [Composition Duration](#composition-duration)
+- [Characters](#characters)
+- [Good Uses](#good-uses)
+- [Avoid](#avoid)
+- [Validation](#validation)
+- [Credits And References](#credits-and-references)
+
HyperFrames can seek both `lottie-web` and dotLottie players through its `lottie` runtime adapter. Lottie is a strong fit because the animation timeline is already encoded in the asset; HyperFrames only needs a player object it can seek.
## Contract
diff --git a/skills/hyperframes-animation/adapters/three.md b/skills/hyperframes-animation/adapters/three.md
index 920a452667..b943a5e19c 100644
--- a/skills/hyperframes-animation/adapters/three.md
+++ b/skills/hyperframes-animation/adapters/three.md
@@ -5,6 +5,21 @@ description: Three.js and WebGL adapter patterns for HyperFrames. Use when creat
# Three.js for HyperFrames
+## Contents
+
+- [Contract](#contract)
+- [Basic Pattern](#basic-pattern)
+- [Loading Addons (`GLTFLoader`, `OrbitControls`, etc.)](#loading-addons-gltfloader-orbitcontrols-etc)
+- [Heavy Setup (Large Meshes, Shader Compiles)](#heavy-setup-large-meshes-shader-compiles)
+- [AnimationMixer Pattern](#animationmixer-pattern)
+- [Camera Cuts Inside One Canvas](#camera-cuts-inside-one-canvas)
+- [Lighting Lit Meshes](#lighting-lit-meshes)
+- [Shader Numeric Domains](#shader-numeric-domains)
+- [Good Uses](#good-uses)
+- [Avoid](#avoid)
+- [Validation](#validation)
+- [Credits And References](#credits-and-references)
+
HyperFrames supports Three.js through its `three` runtime adapter. The adapter does not own your scene. It publishes HyperFrames time and dispatches a seek event so your composition can render the exact frame.
## Contract
diff --git a/skills/hyperframes-animation/adapters/typegpu.md b/skills/hyperframes-animation/adapters/typegpu.md
index 666cb93d63..f633aae5aa 100644
--- a/skills/hyperframes-animation/adapters/typegpu.md
+++ b/skills/hyperframes-animation/adapters/typegpu.md
@@ -5,6 +5,19 @@ description: TypeGPU and raw WebGPU adapter patterns for HyperFrames. Use when c
# TypeGPU / WebGPU for HyperFrames
+## Contents
+
+- [Render-environment prerequisite (WebGPU + html-in-canvas)](#render-environment-prerequisite-webgpu--html-in-canvas)
+- [Contract](#contract)
+- [Basic Pattern](#basic-pattern)
+- [Timeline Registration](#timeline-registration)
+- [Video-Backed Effects (Liquid Glass, Distortion)](#video-backed-effects-liquid-glass-distortion)
+- [Frosted Blur via Downsample Pass](#frosted-blur-via-downsample-pass)
+- [Transparent vs Opaque Canvas](#transparent-vs-opaque-canvas)
+- [WGSL Full-Screen Triangle](#wgsl-full-screen-triangle)
+- [Rounded-Rect SDF (Liquid Glass Pill)](#rounded-rect-sdf-liquid-glass-pill)
+- [Deterministic Rendering](#deterministic-rendering)
+
HyperFrames supports TypeGPU and raw WebGPU through its `typegpu` runtime adapter. The adapter does not own your pipeline. It publishes HyperFrames time and dispatches a seek event so your composition can render the exact GPU frame.
## Render-environment prerequisite (WebGPU + html-in-canvas)
diff --git a/skills/hyperframes-animation/adapters/waapi.md b/skills/hyperframes-animation/adapters/waapi.md
index fc87cdad98..b94791f214 100644
--- a/skills/hyperframes-animation/adapters/waapi.md
+++ b/skills/hyperframes-animation/adapters/waapi.md
@@ -5,6 +5,17 @@ description: Web Animations API adapter patterns for HyperFrames. Use when autho
# Web Animations API for HyperFrames
+## Contents
+
+- [Contract](#contract)
+- [Basic Pattern](#basic-pattern)
+- [Stagger Pattern](#stagger-pattern)
+- [Good Uses](#good-uses)
+- [Composition Duration](#composition-duration)
+- [Avoid](#avoid)
+- [Validation](#validation)
+- [Credits And References](#credits-and-references)
+
HyperFrames can seek Web Animations API animations through its `waapi` runtime adapter. WAAPI is useful when you want native browser keyframes with JavaScript-created timing and no GSAP dependency.
## Contract
diff --git a/skills/hyperframes-animation/blueprints-index.md b/skills/hyperframes-animation/blueprints-index.md
index 864a68b755..c5f5aa427d 100644
--- a/skills/hyperframes-animation/blueprints-index.md
+++ b/skills/hyperframes-animation/blueprints-index.md
@@ -1,5 +1,12 @@
# Blueprints (the proven shapes)
+## Contents
+
+- [The 22 blueprints](#the-22-blueprints)
+- [Role → blueprint menu](#role--blueprint-menu)
+- [Picking guidance](#picking-guidance)
+- [Motion coverage](#motion-coverage)
+
> Entry point to the blueprint layer. Read this to find the shape for a frame; read `blueprints/<id>.md` to instantiate it. The Step-4 method (Reproduce / Adapt / Compose, what to write per frame) lives in `visual-design.md` — this file is the menu + the picker.
A **blueprint** is a product-agnostic, **time-coded shot template** — `Scene N (a–b s): …` with `[slots]` and one named **signature move** — reverse-engineered from 178 golden product-launch clips across two mining rounds (plus 13 legacy blueprints reverse-translated to the same brief format). It encodes a whole shot across its full duration — reveals paced to the spoken line, not dumped at t=0 — so instantiating one structurally keeps content arriving instead of freezing. The full template lives in `blueprints/<id>.md`. **Step 4 (visual design) instantiates one blueprint per frame** (or composes from the motion vocabulary when none fits).
diff --git a/skills/hyperframes-animation/blueprints/kinetic-type-beats.md b/skills/hyperframes-animation/blueprints/kinetic-type-beats.md
index 4d99233517..b8df2d3e98 100644
--- a/skills/hyperframes-animation/blueprints/kinetic-type-beats.md
+++ b/skills/hyperframes-animation/blueprints/kinetic-type-beats.md
@@ -1,8 +1,13 @@
# kinetic-type-beats — Kinetic-Type Beats
+## Contents
+
+- [roles served](#roles-served)
+- [rule mapping](#rule-mapping)
+
**intent**: A flat, centered, bold-type shot where the motion IS the word/phrase changing — the line either swaps tokens in place by hard cut, or builds a statement across full-screen beats (each with its own move) that lands a spring-pop payoff.
-**roles served**
+## roles served
- Hook (from `hook-kinetic-type-flash`): when one stationary line lands a punchy rhetorical question or "you keep doing X" callout and the in-place token swap itself is the joke.
- Hook (from `hook-kinetic-type-escalation`): when ONE statement should escalate across distinct full-screen beats (each a different move) and punctuate on a spring-pop payoff element — a rising-intensity / "transform X into Y" opener.
@@ -73,7 +78,7 @@
**motion vocabulary**: hard-cut / flash word swaps; in-place token cycle (instant cut, no roll/scroll/blur); type-on with trailing blinking caret; backspace-and-retype; per-word staggered fade/blur reveal; big→small scale-down; springy scale-in/scale-out overshoot; 3D letter-tumble scatter-and-reassemble; motion-blur fly-in / blur-off; prior text zoom-through-camera; letter-spacing collapse; bottom-up masked slide; drawn-on `[accent]` underline / strike-through; particle/dot burst from text; `[accent]` selection-box frame; bg-invert hard-flip with text-color invert; karaoke per-word highlight sweep; radial letter-explode; expanding-iris circle wipe-to-next; final spring-pop payoff element (square / emoji / logo mark); drifting `[accent]` motes / ambient shapes; segment-by-segment URL/wordmark build; final-token punctuation snap; settle-and-hold; scale-pop phrase relay (prior shrinks + split-slides off both edges with clip-fade); letter-tracking tighten-from-wide while scaling; corner arrows converging on a word; gradient-fill / hue-sweep across type with settle-to-solid snap; in-text traveling gradient sweep; background shape morph-open into a full-bleed field; RGB-split / chromatic-glitch jitter; horizontal stretch/slice glitch reveal; letter-scramble resolve with divider ticks; confetti burst up-and-drift; letter-slot emoji/mark swap + morph; alternating huge/small word scale chain; color-stripe wipes / blob expand frame-repaint; oversized phrase element-scroll (moving window); right→left marquee scroll-through; stacked outline-echo copies cycling behind a solid word; full-frame repeating-word pattern on a rolling 3D wave; accent shapes fly-in then drift-out-and-thin; masked grey fill snapping solid; brief 3D letter extrude-then-flatten; spring-bounce glyph+prop drop-in; glow-pulse-preceded logo formation; 3D shapes assemble-and-flatten into the mark; logo-lockup 3D rotation-snap; one-shot glow-ring pulse; chart bars growing in a top-down stagger; labeled collaborative cursor delete-and-retype; in-place role-word cycle; ambient plexus/pattern drift; spring shrink-to-0 exit / bounce-in from 0%; scattered-letter bounce-assembly with baseline settle; staggered wordmark part pop; phrase append; word→icon morph with continuous pulse; UI-collage rush-out with parallax from behind anchored type; zoom-blur title exit; long-held URL end card.
-**rule mapping**
+## rule mapping
- hard-cut / flash word swaps, in-place token cycle, whole-line state swaps at time thresholds → `discrete-text-sequence`
- type-on character-by-character + blinking trailing caret → `discrete-text-sequence` (text/typing state progression) + `context-sensitive-cursor` (caret blink/color-switch)
diff --git a/skills/hyperframes-animation/blueprints/logo-assemble-lockup.md b/skills/hyperframes-animation/blueprints/logo-assemble-lockup.md
index 554e175ab5..58e7a79448 100644
--- a/skills/hyperframes-animation/blueprints/logo-assemble-lockup.md
+++ b/skills/hyperframes-animation/blueprints/logo-assemble-lockup.md
@@ -1,8 +1,12 @@
# logo-assemble-lockup — Logo Assemble → Lockup
+## Contents
+
+- [roles served](#roles-served)
+
**intent**: A brand mark / wordmark comes to exist on screen and resolves into a centered logo lockup — built from parts (elements assemble or orbit in, letters cascade, an outline draws on, or a camera pushes through negative space), spring-BLOOMED whole from zero on a cleared stage, MORPHED in one unbroken chain out of the preceding phrase / glyph, absorbed from a kinetic streak, or already assembled and settling as decorations clear — optionally extended into a final URL / CTA / end card.
-**roles served**
+## roles served
- Product_Intro (from product-intro-logo-system-assemble): A wordless, premium brand STING — an abstract system of elements pulses / grows / orbits and assembles around a FIXED central logo, carried by one cinematic camera tilt; no copy, no UI.
- CTA (from cta-camera-push-lockup): The logo build is a LEAD-IN to the final ask — a 3D mark assembles + wordmark cascades, then a fast camera PUSH-THROUGH the mark's negative space streaks giant CTA letters past the lens and resolves on a `[url]` / `[CTA verb]` lockup.
diff --git a/skills/hyperframes-animation/references/motion-blur.md b/skills/hyperframes-animation/references/motion-blur.md
index 1ae967a5e4..4e8b90d1da 100644
--- a/skills/hyperframes-animation/references/motion-blur.md
+++ b/skills/hyperframes-animation/references/motion-blur.md
@@ -1,5 +1,16 @@
# Motion blur — shutter smear on any animated element
+## Contents
+
+- [Read this part before you blur anything](#read-this-part-before-you-blur-anything)
+- [Two routes, and they are not interchangeable](#two-routes-and-they-are-not-interchangeable)
+- [The contract: one attribute](#the-contract-one-attribute)
+- [Options](#options)
+- [The failure modes are all silent](#the-failure-modes-are-all-silent)
+- [Cost](#cost)
+- [The numbers, so you can argue with them](#the-numbers-so-you-can-argue-with-them)
+- [See also](#see-also)
+
## Read this part before you blur anything
Blur is not polish. It is the smear a real shutter leaves while the subject
diff --git a/skills/hyperframes-animation/rules-index.md b/skills/hyperframes-animation/rules-index.md
index 6c4adc6d04..7027f8493f 100644
--- a/skills/hyperframes-animation/rules-index.md
+++ b/skills/hyperframes-animation/rules-index.md
@@ -1,5 +1,18 @@
# Rules Index
+## Contents
+
+- [The contract — every rule assumes this](#the-contract--every-rule-assumes-this)
+- [Text & Typography](#text--typography)
+- [Data & Stats](#data--stats)
+- [Camera & Viewport](#camera--viewport)
+- [Layout & Network](#layout--network)
+- [SVG & Icons](#svg--icons)
+- [Idle & Ambient](#idle--ambient)
+- [Transition & Motion](#transition--motion)
+- [Effect Recipes (moved from hyperframes-creative)](#effect-recipes-moved-from-hyperframes-creative)
+- [See Also](#see-also)
+
Atomic motion recipes. Each lives at `rules/<name>.md`. Compose 2-4 per scene with a single paused timeline.
## The contract — every rule assumes this
diff --git a/skills/hyperframes-animation/rules/3d-camera-flight.md b/skills/hyperframes-animation/rules/3d-camera-flight.md
index 08ac4895b8..6e71274f6f 100644
--- a/skills/hyperframes-animation/rules/3d-camera-flight.md
+++ b/skills/hyperframes-animation/rules/3d-camera-flight.md
@@ -7,6 +7,15 @@ metadata:
# 3D Camera Flight
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Every other camera rule here is a **2D camera**: [viewport-change.md](viewport-change.md), [multi-phase-camera.md](multi-phase-camera.md), and [coordinate-target-zoom.md](coordinate-target-zoom.md) simulate the camera with `scale` + `translate` on a flat wrapper — the lens never tilts, and there is no depth axis to travel along. [3d-page-scroll.md](3d-page-scroll.md) is a **static tilt**: one angle held all scene while content scrolls inside. This rule is the missing camera that _flies_ — dives into an angled grid, pulls back while the world rotates flat, streaks past standing cards, decelerates out of a blur into focus: a **perspective camera traveling with `rotateX` / `rotateY` / `translateZ` through a 3D-laid-out world**, under the same single-camera discipline as `viewport-change`: **one perspective wrapper, one camera state object, one transform writer**, every leg a sequenced tween on that state.
## How It Works
diff --git a/skills/hyperframes-animation/rules/3d-page-scroll.md b/skills/hyperframes-animation/rules/3d-page-scroll.md
index e3a8f86350..d7bd39a1b8 100644
--- a/skills/hyperframes-animation/rules/3d-page-scroll.md
+++ b/skills/hyperframes-animation/rules/3d-page-scroll.md
@@ -7,6 +7,15 @@ metadata:
# 3D Page Scroll
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A webpage (or long content) presented as a tilted 3D card. Spring-eased scroll reveals specific sections while the static 3D perspective adds physical depth. (For a camera that actually travels/tilts, see [3d-camera-flight.md](3d-camera-flight.md) — this rule's tilt never moves.)
## How It Works
diff --git a/skills/hyperframes-animation/rules/3d-text-depth-layers.md b/skills/hyperframes-animation/rules/3d-text-depth-layers.md
index 5ca2641b06..e1e2b834e5 100644
--- a/skills/hyperframes-animation/rules/3d-text-depth-layers.md
+++ b/skills/hyperframes-animation/rules/3d-text-depth-layers.md
@@ -7,6 +7,15 @@ metadata:
# 3D Text Depth Layers
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
The same text rendered N times at increasing offsets — back layers translucent, front layer full opacity and brand color — creates a physical "stacked extrusion" depth illusion on large typography. Distinct from `text-shadow` (which can't have per-layer hue / opacity / animation): each layer is a real DOM element.
## How It Works
diff --git a/skills/hyperframes-animation/rules/ai-tracking-box.md b/skills/hyperframes-animation/rules/ai-tracking-box.md
index 0ae63af7e5..b4f28281eb 100644
--- a/skills/hyperframes-animation/rules/ai-tracking-box.md
+++ b/skills/hyperframes-animation/rules/ai-tracking-box.md
@@ -7,6 +7,15 @@ metadata:
# AI Tracking Box
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A bounding box of four L-bracket corners + a confidence label that follows a moving target, simulating real-time AI detection. Rendered in detection yellow (`#facc15` family) on a dark background — the industry convention (AV HUDs, security CV, ML demos); red reads "warning", green "success", blue "info" — none read "detection."
## How It Works
diff --git a/skills/hyperframes-animation/rules/ambient-glow-bloom.md b/skills/hyperframes-animation/rules/ambient-glow-bloom.md
index e1807bdd92..00cfab3d11 100644
--- a/skills/hyperframes-animation/rules/ambient-glow-bloom.md
+++ b/skills/hyperframes-animation/rules/ambient-glow-bloom.md
@@ -7,6 +7,15 @@ metadata:
# Ambient Glow Bloom
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A soft radial glow that **blooms in behind a hero element** (card, logo, metric) and holds, giving it presence. Unlike `press-release-spring`'s click-triggered burst or `asr-keyword-glow`'s word-timed envelope, this glow is **un-triggered** — it blooms on the hero's settle and stays lit. Two forms: a **hero bloom** that swells behind a settling element then breathes, and a **traveling sweep** that translates a soft highlight across a surface exactly once.
## How It Works
diff --git a/skills/hyperframes-animation/rules/anchored-layout-expand.md b/skills/hyperframes-animation/rules/anchored-layout-expand.md
index 040e9766d6..4e22ad1055 100644
--- a/skills/hyperframes-animation/rules/anchored-layout-expand.md
+++ b/skills/hyperframes-animation/rules/anchored-layout-expand.md
@@ -7,6 +7,15 @@ metadata:
# Anchored Layout Expand
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
> The law: **author the layout at its final (expanded) state in CSS, then fake the collapsed state with transforms.** The container never changes size — the _visible_ region does — and everything downstream rides a matched translate. The browser computes layout ONCE; every intermediate frame is pure transform.
THE one-axis growth primitive: a container pinned at one edge appears to grow along a single axis, and the in-flow content after it moves in perfect contact with the traveling edge — dropdown, sub-task stack, growing composer card, pane widening over a neighbor. Growth and push are ONE motion: if the panel's bottom edge and the pushed content ever separate or overlap, the illusion dies.
diff --git a/skills/hyperframes-animation/rules/asr-keyword-glow.md b/skills/hyperframes-animation/rules/asr-keyword-glow.md
index 8a0eb9019f..8352bfc96c 100644
--- a/skills/hyperframes-animation/rules/asr-keyword-glow.md
+++ b/skills/hyperframes-animation/rules/asr-keyword-glow.md
@@ -7,6 +7,15 @@ metadata:
# ASR Keyword Glow
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Words in a phrase visually activate (glow blur + scale) when "spoken", following an attack-sustain-release envelope over per-word `{ start, end }` timestamps. In a real ASR pipeline the timings come from a word-level transcript (`hyperframes transcribe` — same shape); for promo video, hand-author them to control emphasis pacing. The envelope never falls to zero after a word — it decays to a rest level, leaving a breadcrumb of recent emphasis.
## How It Works
diff --git a/skills/hyperframes-animation/rules/avatar-cloud-network.md b/skills/hyperframes-animation/rules/avatar-cloud-network.md
index 7d47ebc9dd..c2ade61847 100644
--- a/skills/hyperframes-animation/rules/avatar-cloud-network.md
+++ b/skills/hyperframes-animation/rules/avatar-cloud-network.md
@@ -7,6 +7,15 @@ metadata:
# Avatar Cloud Network
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Avatars on an elliptical ring around a central hub (logo / counter), with SVG dashed lines drawing outward from the hub to each avatar — "community" / social proof. Distinct from [orbit-3d-entry.md](orbit-3d-entry.md) (continuous orbit): this settles into a static composed formation.
## How It Works
diff --git a/skills/hyperframes-animation/rules/camera-cursor-tracking.md b/skills/hyperframes-animation/rules/camera-cursor-tracking.md
index b979bade93..59c17422dd 100644
--- a/skills/hyperframes-animation/rules/camera-cursor-tracking.md
+++ b/skills/hyperframes-animation/rules/camera-cursor-tracking.md
@@ -7,6 +7,15 @@ metadata:
# Two-Phase Camera Cursor Tracking
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Keeps a horizontally-growing element (a search bar with typing text, a long URL animating in) visible by switching between two camera modes.
## How It Works
diff --git a/skills/hyperframes-animation/rules/card-morph-anchor.md b/skills/hyperframes-animation/rules/card-morph-anchor.md
index 3ae8ae1cb7..f300890f00 100644
--- a/skills/hyperframes-animation/rules/card-morph-anchor.md
+++ b/skills/hyperframes-animation/rules/card-morph-anchor.md
@@ -7,6 +7,16 @@ metadata:
# Card Morph Anchor
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Morph channels](#morph-channels)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A free-floating container morphs apparent size, corner radius, and surface treatment between two shots — the morph itself IS the transition; the viewer's eye tracks the persistent container. Distinct from [anchored-layout-expand.md](anchored-layout-expand.md) (an edge-pinned live layout participant that grows along one axis and reflows neighbors — here nothing is pushed) and [theme-crossfade-morph.md](theme-crossfade-morph.md) (a whole-theme reskin under a fixed anchor — here a single container changes shape).
## How It Works
diff --git a/skills/hyperframes-animation/rules/chart-scrub-readout.md b/skills/hyperframes-animation/rules/chart-scrub-readout.md
index 527878f176..f36b5504b9 100644
--- a/skills/hyperframes-animation/rules/chart-scrub-readout.md
+++ b/skills/hyperframes-animation/rules/chart-scrub-readout.md
@@ -7,6 +7,15 @@ metadata:
# Chart Scrub Readout
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
The chart is already ON screen — this rule **interrogates** it. A vertical tracking line rides the scrub position, a marker dot follows the series, and a live tooltip reads out `date: value` per position, values flickering past like an odometer. It's the "this data is real — look closer" beat: the scrub proves the chart is an instrument, not a picture.
Boundary with its neighbors: [stat-bars-and-fills.md](stat-bars-and-fills.md) owns the chart's ARRIVAL; [counting-dynamic-scale.md](counting-dynamic-scale.md) owns a single number swelling in place. This rule assumes the graphic already exists and adds a **read head** moving across it. The three chain naturally: the line draws in (svg-path-draw / stat-bars), this rule scrubs it, and the landing value hands off to a count-up lockup.
diff --git a/skills/hyperframes-animation/rules/chromatic-glitch.md b/skills/hyperframes-animation/rules/chromatic-glitch.md
index c35713a92b..307d7c4936 100644
--- a/skills/hyperframes-animation/rules/chromatic-glitch.md
+++ b/skills/hyperframes-animation/rules/chromatic-glitch.md
@@ -7,6 +7,15 @@ metadata:
# Chromatic Glitch
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Digital interference as punctuation: for a fraction of a second the element **breaks** — offset color copies shudder behind it, or horizontal slices displace sideways — then it **snaps sharp** and holds clean. The payoff is the resolve; the glitch exists to make the clean state land harder. Two forms: an **RGB-split jitter** (warm + cool ghost copies vibrating behind the base) and a **slice displacement** (horizontal bands that arrive offset and converge).
Boundaries: [motion-blur-streak.md](motion-blur-streak.md) is velocity blur tied to **travel** — its element is going somewhere fast. A glitching element is **in place**; the disturbance is temporal, not directional. [hacker-flip-3d.md](hacker-flip-3d.md) substitutes **glyphs** (a decode); here the glyphs are fixed and only displaced copies of them move.
diff --git a/skills/hyperframes-animation/rules/context-sensitive-cursor.md b/skills/hyperframes-animation/rules/context-sensitive-cursor.md
index a75f6da545..617a888fca 100644
--- a/skills/hyperframes-animation/rules/context-sensitive-cursor.md
+++ b/skills/hyperframes-animation/rules/context-sensitive-cursor.md
@@ -7,6 +7,15 @@ metadata:
# Context-Sensitive Cursor
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
In a typewriter sequence, the cursor's color (and optionally height / blink behavior) matches the **active text segment** — brand accent while typing the brand name, dim on placeholders, success color on the completion mark. The eye lands on the keyword being typed because the cursor shifts with it; a fixed single-color cursor is visual noise by comparison. Layers on top of [discrete-text-sequence](discrete-text-sequence.md)'s SEQUENCE pattern.
## How It Works
diff --git a/skills/hyperframes-animation/rules/control-target-sync.md b/skills/hyperframes-animation/rules/control-target-sync.md
index d521589c96..759f6e7fde 100644
--- a/skills/hyperframes-animation/rules/control-target-sync.md
+++ b/skills/hyperframes-animation/rules/control-target-sync.md
@@ -7,6 +7,15 @@ metadata:
# Control-Target Sync
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
THE live-editing move: an inspector/editor control is manipulated — a value scrubbed, a field retyped, a dropdown picked — and a **bound second element answers in the same frame**. The button rotates WHILE the rotation value scrubs; icons resize PER KEYSTROKE. The persuasion is causality — one gesture, two surfaces changing together — and this rule is the coupling contract that produces it.
Nearest precedent is [reactive-displacement.md](reactive-displacement.md): that rule also derives two elements' motion from one source, but it is **collision physics** — an entering intruder displaces an exiting victim, once, as a transition, and the victim leaves. This rule is a **live editing mirror**: the control is manipulated repeatedly across several beats, the target answers every time, and both sides hold the stage throughout. The numeric readout rides [counting-dynamic-scale.md](counting-dynamic-scale.md)'s proxy pattern; discrete steps ride [discrete-text-sequence.md](discrete-text-sequence.md)'s threshold pattern — what this rule adds is the law that binds either of them to the target.
diff --git a/skills/hyperframes-animation/rules/coordinate-target-zoom.md b/skills/hyperframes-animation/rules/coordinate-target-zoom.md
index a28e80fa6f..e4d4244bef 100644
--- a/skills/hyperframes-animation/rules/coordinate-target-zoom.md
+++ b/skills/hyperframes-animation/rules/coordinate-target-zoom.md
@@ -7,6 +7,16 @@ metadata:
# Coordinate Target Zoom
+## Contents
+
+- [How It Works](#how-it-works)
+- [Getting the offset](#getting-the-offset)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A simple `scale > 1` on a wrapper pushes off-center content OFF the visible canvas. To zoom _into_ a specific non-centered element, apply scale AND an inverse translation in lockstep so the target lands at viewport center.
## How It Works
diff --git a/skills/hyperframes-animation/rules/counting-dynamic-scale.md b/skills/hyperframes-animation/rules/counting-dynamic-scale.md
index 5d9da5f307..3833035bc6 100644
--- a/skills/hyperframes-animation/rules/counting-dynamic-scale.md
+++ b/skills/hyperframes-animation/rules/counting-dynamic-scale.md
@@ -7,6 +7,15 @@ metadata:
# Counting with Dynamic Scale
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A number counts from A → B while its transform scale grows to the final size — escalating visual weight ("this is impressive") without tweening `font-size` or forcing text layout on every frame. The final font size is static CSS; only the transform changes.
## How It Works
diff --git a/skills/hyperframes-animation/rules/css-marker-patterns.md b/skills/hyperframes-animation/rules/css-marker-patterns.md
index 97ba6c4a03..706cf5d32e 100644
--- a/skills/hyperframes-animation/rules/css-marker-patterns.md
+++ b/skills/hyperframes-animation/rules/css-marker-patterns.md
@@ -1,5 +1,14 @@
# CSS Patterns for Marker Highlighting
+## Contents
+
+- [1. Highlight Mode](#1-highlight-mode)
+- [2. Circle Mode](#2-circle-mode)
+- [3. Burst Mode](#3-burst-mode)
+- [4. Scribble Mode](#4-scribble-mode)
+- [5. Sketchout Mode](#5-sketchout-mode)
+- [Combining Modes in Captions](#combining-modes-in-captions)
+
Pure CSS + GSAP implementations of all five MarkerHighlight.js drawing modes — no external library dependency, full timeline control. Snippets show mechanism DOM only, inside a standard scene clip (hyperframes-core); assume `tl` exists.
Shared scaffold for every mode: the wrap is `position: relative; display: inline`; the text copy is `position: relative` and z-indexed **above** the accent (below it for sketchout, where the lines cross the text).
diff --git a/skills/hyperframes-animation/rules/cursor-click-ripple.md b/skills/hyperframes-animation/rules/cursor-click-ripple.md
index 727e1411eb..18325d5341 100644
--- a/skills/hyperframes-animation/rules/cursor-click-ripple.md
+++ b/skills/hyperframes-animation/rules/cursor-click-ripple.md
@@ -7,6 +7,14 @@ metadata:
# Cursor Click Ripple
+## Contents
+
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
An animated cursor moves to a target element, performs a click with visual depression, and emits expanding ripple rings from the click point. Three sequential phases on one timeline: **move** (eased translation to the target's center) → **click** (scale depression on cursor + target together, yoyo back) → **ripple** (1–3 staggered rings expand and fade from the click point). This is a _point event at one location_ — a sustained hold across space is [cursor-drag.md](cursor-drag.md).
## Recipe
diff --git a/skills/hyperframes-animation/rules/cursor-drag.md b/skills/hyperframes-animation/rules/cursor-drag.md
index e249591599..3aadd993a2 100644
--- a/skills/hyperframes-animation/rules/cursor-drag.md
+++ b/skills/hyperframes-animation/rules/cursor-drag.md
@@ -7,6 +7,15 @@ metadata:
# Cursor Drag
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
> Cursor look, sizing, off-screen entry, and tip-targeting defer to the **oversized-cursor house doctrine** — this rule owns the drag _mechanics_ only.
THE held-journey verb: the cursor presses down on a payload, carries it, and releases it somewhere else. The load-bearing law is **lockstep**: the cursor tip and the payload's grip point move as one rigid object for the entire travel — a one-frame drift reads as the chip slipping out of the hand. Distinct from [cursor-click-ripple.md](cursor-click-ripple.md) (move → point event at a single location): a drag is a _sustained hold across space_, and the payload is the co-star. Reuse [physics-press-reaction.md](physics-press-reaction.md) for the grab's press dip (cursor + payload compress together); for N simultaneous actors see [multi-cursor-choreography.md](multi-cursor-choreography.md) — this rule is one protagonist performing a workflow beat.
diff --git a/skills/hyperframes-animation/rules/depth-of-field-blur.md b/skills/hyperframes-animation/rules/depth-of-field-blur.md
index e1b974a8f2..1c87b1bebf 100644
--- a/skills/hyperframes-animation/rules/depth-of-field-blur.md
+++ b/skills/hyperframes-animation/rules/depth-of-field-blur.md
@@ -7,6 +7,15 @@ metadata:
# Depth-of-Field Blur (Selective Focus / Rack Focus)
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Pulls the eye to one focal element by **blurring** (and slightly **dimming**) everything around it while the focal layer stays sharp — the camera's depth-of-field falling off the background, or a rack-focus shifting which plane is in focus. `filter` and `opacity` are paint-only, so both tween seek-safe. This is the backing rule for the focus-falloff beat the blueprints reach for: outer nodes blurring during a push-in (`constellation-hub`), rack-focus across a parallax card stack (`cursor-ui-demo`), non-highlighted cards dimming to spotlight a hero metric (`dataviz-countup`).
## How It Works
diff --git a/skills/hyperframes-animation/rules/depth-scatter-assemble.md b/skills/hyperframes-animation/rules/depth-scatter-assemble.md
index 8d1968088a..0260d8bb3a 100644
--- a/skills/hyperframes-animation/rules/depth-scatter-assemble.md
+++ b/skills/hyperframes-animation/rules/depth-scatter-assemble.md
@@ -7,6 +7,15 @@ metadata:
# Depth Scatter ↔ Assemble
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
N elements (glyphs, cards, logo fragments) fly in from a rotating 3D depth-cloud and lock into a flat layout — or the reverse. Each element has its OWN index-derived point in the cloud (translateZ depth + rotateX/Y tumble + x/y scatter). Distinct from `orbit-3d-entry` (flip-in then continuous orbit) and `center-outward-expansion` (flat burst from one shared center): here the resolve is a flat assembled layout.
## How It Works
diff --git a/skills/hyperframes-animation/rules/discrete-text-sequence.md b/skills/hyperframes-animation/rules/discrete-text-sequence.md
index 2d3ba111cb..38566f7ff7 100644
--- a/skills/hyperframes-animation/rules/discrete-text-sequence.md
+++ b/skills/hyperframes-animation/rules/discrete-text-sequence.md
@@ -7,6 +7,15 @@ metadata:
# Discrete Text Sequence
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Instead of character-by-character typewriter, replace entire string states at time thresholds — enabling non-linear effects (typos, backspaces, bulk paste, "thinking" gaps) that smooth per-char typing can't achieve. If your effect is "type each character, no edits", this rule is overkill — use the smooth-slice variation below.
## How It Works
diff --git a/skills/hyperframes-animation/rules/dynamic-content-sequencing.md b/skills/hyperframes-animation/rules/dynamic-content-sequencing.md
index 4f281af7cd..a513ec7ae3 100644
--- a/skills/hyperframes-animation/rules/dynamic-content-sequencing.md
+++ b/skills/hyperframes-animation/rules/dynamic-content-sequencing.md
@@ -7,6 +7,15 @@ metadata:
# Dynamic Content Sequencing
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A utility pattern (not a motion rule in itself) for scenes that show a SEQUENCE of items (cards, phrases, stats): each item's duration is computed from its content length + per-item config, and the sequencer assigns absolute start/end times automatically — no hardcoded offsets per item. Distinct from [discrete-text-sequence](discrete-text-sequence.md) (one text element changing states) — this rule swaps between distinct content blocks.
## How It Works
diff --git a/skills/hyperframes-animation/rules/gradient-text-sweep.md b/skills/hyperframes-animation/rules/gradient-text-sweep.md
index e633dad56b..7ee4b612a9 100644
--- a/skills/hyperframes-animation/rules/gradient-text-sweep.md
+++ b/skills/hyperframes-animation/rules/gradient-text-sweep.md
@@ -7,6 +7,15 @@ metadata:
# Gradient Text Sweep
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Color that lives **inside the glyphs**: the headline's fill is an oversized gradient clipped into the letterforms (`background-clip: text`), and the motion is the gradient sliding **through** the type — the letters never move. Three forms: a **continuous sweep** across a held title card, a **word-to-word highlight** that lights a line left→right, and a **hue-sweep** that settles to a solid.
Boundaries: [asr-keyword-glow.md](asr-keyword-glow.md) is word-timed emphasis railed to ASR timestamps — this rule is a design beat with no audio rail. [ambient-glow-bloom.md](ambient-glow-bloom.md)'s traveling sweep is a sheen riding **over a surface**; here the gradient is masked **into the type** (its "Shimmer sweep" variation is this mechanism re-aimed as a working-state loop). [css-marker-patterns.md](css-marker-patterns.md) draws accents _around_ text, never fills.
diff --git a/skills/hyperframes-animation/rules/hacker-flip-3d.md b/skills/hyperframes-animation/rules/hacker-flip-3d.md
index e6db1e4eb9..43a244bbca 100644
--- a/skills/hyperframes-animation/rules/hacker-flip-3d.md
+++ b/skills/hyperframes-animation/rules/hacker-flip-3d.md
@@ -7,6 +7,15 @@ metadata:
# Hacker Flip 3D Reveal
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Characters flip down from 90° in 3D while cycling through pseudo-random glyphs, then settle on the target character — a "decryption" / airport flap-display reveal. Resolves to a short target word (typically a brand or label).
## How It Works
diff --git a/skills/hyperframes-animation/rules/kinetic-beat-slam.md b/skills/hyperframes-animation/rules/kinetic-beat-slam.md
index ad6562c692..a3b68eb5b7 100644
--- a/skills/hyperframes-animation/rules/kinetic-beat-slam.md
+++ b/skills/hyperframes-animation/rules/kinetic-beat-slam.md
@@ -7,6 +7,15 @@ metadata:
# Kinetic Beat Slam
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Short phrases hit one at a time on a **steady beat**, each with a _different_ entrance, then stack into a locked finale — the recipe for "punchy / rhythmic" text-forward pieces (taglines, manifestos, hype intros). The difference between generic and rhythmic is (1) one shared **onset array** driving every element, (2) **distinct** entrances per phrase rather than one reused helper, and (3) optional **rhythm chrome** that visibly keeps the beat.
## How It Works
diff --git a/skills/hyperframes-animation/rules/motion-blur-streak.md b/skills/hyperframes-animation/rules/motion-blur-streak.md
index aec5699284..214ca11984 100644
--- a/skills/hyperframes-animation/rules/motion-blur-streak.md
+++ b/skills/hyperframes-animation/rules/motion-blur-streak.md
@@ -7,6 +7,17 @@ metadata:
# Motion-Blur Streak
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Camera-Travel Carve-Out](#camera-travel-carve-out)
+- [Per-Frame-Driven Carve-In (baked tracks)](#per-frame-driven-carve-in-baked-tracks)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Real motion blur isn't available to a seeked renderer (it integrates over shutter time), so this rule **fakes** it for a fast fly-in or hard camera push-through. The whole point is the _coupling_: the blur envelope rides the **same ease and window** as the position tween, so peak blur lands exactly on peak speed and the element is razor-sharp the instant it stops. Two paths:
- **(A) Directional SVG blur** — inline `<feGaussianBlur stdDeviation="X 0">` (X on the motion axis, 0 across it), tweened via a proxy. Cleanest; a true directional smear.
diff --git a/skills/hyperframes-animation/rules/multi-cursor-choreography.md b/skills/hyperframes-animation/rules/multi-cursor-choreography.md
index bd5895557b..fb164383e2 100644
--- a/skills/hyperframes-animation/rules/multi-cursor-choreography.md
+++ b/skills/hyperframes-animation/rules/multi-cursor-choreography.md
@@ -7,6 +7,15 @@ metadata:
# Multi-Cursor Choreography
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
> **The camera never chases anyone.** No real camera — any "pan" is the canvas group translating inside a static frame. And per the motion doctrine's idle-motion ban, every cursor must **perform**: travel to a target, act, then rest still. Scheduled rest is stillness; aimless wander loops are wobble.
THE ensemble primitive: **two to four labeled cursor actors** — each an arrow plus a name-tag pill in its own color — work one shared canvas at the same time. No single interaction is the subject; the **simultaneous liveness is** ("a team is in here, working"), usually as ambience under a headline building over the top. Distinct from [cursor-click-ripple.md](cursor-click-ripple.md) and [cursor-drag.md](cursor-drag.md): those are **one protagonist** the viewer follows click-by-click; here the actors are chorus, not lead — each action smaller and quieter than a solo cursor's, the value in the interleaving. Also distinct from [camera-cursor-tracking.md](camera-cursor-tracking.md): that locks the _viewport_ to one focal cursor; this rule forbids exactly that — the frame is static and the eye roams freely.
diff --git a/skills/hyperframes-animation/rules/multi-phase-camera.md b/skills/hyperframes-animation/rules/multi-phase-camera.md
index 9b03ce7cf2..25107f6d02 100644
--- a/skills/hyperframes-animation/rules/multi-phase-camera.md
+++ b/skills/hyperframes-animation/rules/multi-phase-camera.md
@@ -7,6 +7,16 @@ metadata:
# Multi-Phase Camera
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Phase Patterns](#phase-patterns)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
A camera wrapper around the ENTIRE scene that progresses through discrete zoom phases at scripted triggers, with continuous sine-driven micro-drift overlaid so the camera never feels static between phases. Distinct from a single linear zoom — multi-phase creates cinematic pacing (anticipation → reveal → settle).
## How It Works
diff --git a/skills/hyperframes-animation/rules/orbit-3d-entry.md b/skills/hyperframes-animation/rules/orbit-3d-entry.md
index ef46b771c3..89a3b7f993 100644
--- a/skills/hyperframes-animation/rules/orbit-3d-entry.md
+++ b/skills/hyperframes-animation/rules/orbit-3d-entry.md
@@ -7,6 +7,15 @@ metadata:
# Orbit with 3D Entry
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Elements flip in from 3D space (`rotateX` + `rotateY` + negative `z`) then settle into a continuous elliptical orbit around a center label. Distinct from one-shot reveals — the orbit keeps running, driven by a 0→1 progress tween INSIDE the timeline (never rAF).
## How It Works
diff --git a/skills/hyperframes-animation/rules/particle-burst.md b/skills/hyperframes-animation/rules/particle-burst.md
index 01a96e4a8a..faa4568dbc 100644
--- a/skills/hyperframes-animation/rules/particle-burst.md
+++ b/skills/hyperframes-animation/rules/particle-burst.md
@@ -7,6 +7,15 @@ metadata:
# Particle Burst
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Discrete flying particles as a one-shot event: a **confetti pop** that erupts upward and drifts back down on gravity, a **dot burst** radiating from behind a landing word, or a **glyph dissolve** where text breaks into particles that scatter and die. Particles are ephemeral garnish — born from a beat, fly, gone; they never become layout.
Boundaries: [css-marker-patterns.md](css-marker-patterns.md)'s burst mode is radiating **drawn lines** — a static accent, no flight. [press-release-spring.md](press-release-spring.md)'s release burst is **one blurred radial layer** faking an explosion — enough when a single glow pop will do. [center-outward-expansion.md](center-outward-expansion.md) moves **real layout elements** to final resting slots; particles have no destination, only physics and a death.
diff --git a/skills/hyperframes-animation/rules/physics-press-reaction.md b/skills/hyperframes-animation/rules/physics-press-reaction.md
index 9fec017088..4e47c0a07c 100644
--- a/skills/hyperframes-animation/rules/physics-press-reaction.md
+++ b/skills/hyperframes-animation/rules/physics-press-reaction.md
@@ -7,6 +7,14 @@ metadata:
# Physics Press Reaction (Cursor + Element Synced)
+## Contents
+
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Models a real click: a cursor approaches a button, lands, and both compress IN SYNC, then release together. Distinct from [press-release-spring.md](press-release-spring.md) (no cursor — just a press happening); this rule is the COMBINED cursor + element behavior. A single `PRESS_INTENSITY` drives both: press down compresses both to `1 - PRESS_INTENSITY` via **one targets array**, release springs both back to 1.0 with overshoot. The cursor translates to the button's center BEFORE the press starts; after release it may move on or hold.
## Recipe
diff --git a/skills/hyperframes-animation/rules/press-release-spring.md b/skills/hyperframes-animation/rules/press-release-spring.md
index 3c6eac9671..e5f50df596 100644
--- a/skills/hyperframes-animation/rules/press-release-spring.md
+++ b/skills/hyperframes-animation/rules/press-release-spring.md
@@ -7,6 +7,14 @@ metadata:
# Press-Release Spring Chain
+## Contents
+
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Separates input (linear compression) from output (spring recovery) to create tactile feel: the overshoot is a natural byproduct of the spring config, not manually coded, with secondary motion (shadow shrink, release burst, background glow) layered on the same trigger frame. This is a **reaction on an element already resting on screen** — an arrival that springs in from nothing is [spring-pop-entrance.md](spring-pop-entrance.md); add a visible cursor actor and it becomes [physics-press-reaction.md](physics-press-reaction.md).
Two phases split at the **release**:
diff --git a/skills/hyperframes-animation/rules/split-tilt-cards.md b/skills/hyperframes-animation/rules/split-tilt-cards.md
index def415a99b..42d6c2301d 100644
--- a/skills/hyperframes-animation/rules/split-tilt-cards.md
+++ b/skills/hyperframes-animation/rules/split-tilt-cards.md
@@ -7,6 +7,15 @@ metadata:
# Split Tilt Cards
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Two cards side-by-side with opposing `rotateY` (left `+TILT`, right `−TILT`) — a symmetric "book-open" 3D split for comparisons, before/after, feature pairs. Each card slides in from its own side (reinforcing "they came from their own worlds and met here"), then the pair idles in counter-phase.
## How It Works
diff --git a/skills/hyperframes-animation/rules/spring-pop-entrance.md b/skills/hyperframes-animation/rules/spring-pop-entrance.md
index 2debc1eee0..5b685e80c5 100644
--- a/skills/hyperframes-animation/rules/spring-pop-entrance.md
+++ b/skills/hyperframes-animation/rules/spring-pop-entrance.md
@@ -7,6 +7,15 @@ metadata:
# Spring-Pop Entrance
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
> **Smooth beats bouncy.** This entrance defaults to a smooth long-tail settle — `power3.out` (or `expo.out` for a faster front) — that decelerates cleanly into the resting size with **no overshoot**. Bouncy `back.out` is the **#1 instant turn-off** in agent-made videos and is almost never executed well; it is a rare, explicitly-playful exception (consumer / fun brand), never the default. When unsure, settle smoothly.
THE entrance primitive: an element (or staggered group) arrives by springing from nothing — `scale: 0 → 1`, optional small `y` rise — and settles without bouncing. This is **arrival**, not reaction: distinct from [press-release-spring.md](press-release-spring.md) (a click/press → release feedback chain on an element that already rests on screen). Many blueprints used to borrow that rule to fake an entrance; reach for this instead.
diff --git a/skills/hyperframes-animation/rules/stat-bars-and-fills.md b/skills/hyperframes-animation/rules/stat-bars-and-fills.md
index 58679e72cb..37fbc461a2 100644
--- a/skills/hyperframes-animation/rules/stat-bars-and-fills.md
+++ b/skills/hyperframes-animation/rules/stat-bars-and-fills.md
@@ -7,6 +7,13 @@ metadata:
# Stat Bars & Fills
+## Contents
+
+- [Recipe](#recipe)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
The graphics that give a stat **visual weight** beside its number: a small bar chart, a progress bar/ring filling to a percentage, or a star row filling to a fractional rating. Pair these with [counting-dynamic-scale.md](counting-dynamic-scale.md) (the number) for a complete stat scene.
**Layout blueprint — pick ONE and hold it across all stats:**
diff --git a/skills/hyperframes-animation/rules/svg-icon-enrichment.md b/skills/hyperframes-animation/rules/svg-icon-enrichment.md
index 073d0fd0bb..555795f681 100644
--- a/skills/hyperframes-animation/rules/svg-icon-enrichment.md
+++ b/skills/hyperframes-animation/rules/svg-icon-enrichment.md
@@ -7,6 +7,15 @@ metadata:
# SVG Icon Enrichment
+## Contents
+
+- [❗ The transform-center gotcha](#-the-transform-center-gotcha)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Treats an SVG icon as a composition of animated PARTS, not an opaque image. Each meaningful internal element (a clock hand, scissor blade, recording dot, data line) gets its own micro-animation, targeted by id. Distinct from [svg-path-draw](svg-path-draw.md) (which animates the OUTLINE drawing) — enrichment animates INTERNAL PARTS, ideally after the outline has drawn.
Four signature patterns:
diff --git a/skills/hyperframes-animation/rules/svg-path-draw.md b/skills/hyperframes-animation/rules/svg-path-draw.md
index 6cf1199878..8f55fd2c62 100644
--- a/skills/hyperframes-animation/rules/svg-path-draw.md
+++ b/skills/hyperframes-animation/rules/svg-path-draw.md
@@ -7,6 +7,14 @@ metadata:
# SVG Path Draw
+## Contents
+
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Reveals an SVG shape by animating its stroke as if a pen were tracing it. Two stroke properties together: **`stroke-dasharray = <pathLength>`** makes the entire path one dash; **`stroke-dashoffset`** starts at the path length (dash shifted fully out of view → invisible) and tweens to `0` (fully drawn). The length comes from the DOM API `path.getTotalLength()` — measured, never guessed.
Works on anything with a stroke: `<path>`, `<circle>`, `<rect>`, `<line>`, `<polyline>`, `<polygon>`, `<ellipse>`.
diff --git a/skills/hyperframes-animation/rules/theme-crossfade-morph.md b/skills/hyperframes-animation/rules/theme-crossfade-morph.md
index 0621633e2b..5e0d251652 100644
--- a/skills/hyperframes-animation/rules/theme-crossfade-morph.md
+++ b/skills/hyperframes-animation/rules/theme-crossfade-morph.md
@@ -7,6 +7,15 @@ metadata:
# Theme Crossfade Morph
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
The whole world re-skins while one thing holds still. A composer box cycles through four IDE themes; a checkout widget flips through brand skins — background, typography, corner radii, toolbar icons, footer logos all change **at once**, in place, in ~0.3s, N times — and through every flip one anchor element (the prompt string, the widget layout, the wordmark) **never moves**. The anchor's stillness is the rhetorical claim: _everything changes, this doesn't._
Boundary: [card-morph-anchor.md](card-morph-anchor.md) morphs **one container** between two shots — its dimensions, radius, and surface tween continuously. This rule re-skins an **entire scene** through **N discrete states**: nothing tweens property-by-property (fonts, icons, and logos can't interpolate); the "morph" is a fast simultaneous crossfade of complete pre-styled layers. ([scale-swap-transition.md](scale-swap-transition.md) swaps an element at center; here the surroundings swap and the element holds.)
diff --git a/skills/hyperframes-animation/rules/vertical-spring-ticker.md b/skills/hyperframes-animation/rules/vertical-spring-ticker.md
index 9c2c8feb2d..42b0e843c2 100644
--- a/skills/hyperframes-animation/rules/vertical-spring-ticker.md
+++ b/skills/hyperframes-animation/rules/vertical-spring-ticker.md
@@ -7,6 +7,15 @@ metadata:
# Vertical Spring Ticker (Slot Machine)
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Multiple spring tweens are ADDED TOGETHER to produce total Y translation — each spring contributes one discrete "step", so instead of a single linear scroll you get the slot-machine "click click click" rhythm with natural settling. Distinct from a continuous marquee: this rule's semantics are discrete steps that land; for endless linear motion see [sine-wave-loop.md](sine-wave-loop.md).
## How It Works
diff --git a/skills/hyperframes-animation/rules/viewport-change.md b/skills/hyperframes-animation/rules/viewport-change.md
index fe6faac8f2..2509c74cda 100644
--- a/skills/hyperframes-animation/rules/viewport-change.md
+++ b/skills/hyperframes-animation/rules/viewport-change.md
@@ -7,6 +7,16 @@ metadata:
# Viewport Change (Virtual Camera)
+## Contents
+
+- [How It Works](#how-it-works)
+- [Recipe](#recipe)
+- [Scale Value Guide](#scale-value-guide)
+- [Variations](#variations)
+- [Values](#values)
+- [Critical Constraints](#critical-constraints)
+- [See also](#see-also)
+
Simulates camera effects (zoom / pan / focus-lock on a moving element) by transforming a wrapper around ALL scene content. The "world" moves opposite to the perceived camera. Distinct from [multi-phase-camera](multi-phase-camera.md) (2-3 discrete phases + drift) — viewport-change is a single continuous zoom/pan, often used for focus-lock following a moving element.
## How It Works
diff --git a/skills/hyperframes-animation/transitions/TRANSITION-REGISTRY.md b/skills/hyperframes-animation/transitions/TRANSITION-REGISTRY.md
index a0d35b324b..28d542ae5c 100644
--- a/skills/hyperframes-animation/transitions/TRANSITION-REGISTRY.md
+++ b/skills/hyperframes-animation/transitions/TRANSITION-REGISTRY.md
@@ -1,5 +1,13 @@
# Transition Registry — machine source of truth
+## Contents
+
+- [How the injector applies a transition](#how-the-injector-applies-a-transition)
+- [Template placeholders](#template-placeholders)
+- [Registry](#registry)
+- [Default-derivation (used by prep.mjs when the planner omits `**Transition:**`)](#default-derivation-used-by-prepmjs-when-the-planner-omits-transition)
+- [Choosing as a planner (the only agent touchpoint)](#choosing-as-a-planner-the-only-agent-touchpoint)
+
Single source of truth for **PLV scene-to-scene transitions**. The deterministic
injector (`product-launch-video/scripts/transitions.mjs inject`) reads its vendored
copy of the JSON block below (`product-launch-video/scripts/lib/transitions.json`)
diff --git a/skills/hyperframes/SKILL.md b/skills/hyperframes/SKILL.md
index b84e42b852..495f81af56 100644
--- a/skills/hyperframes/SKILL.md
+++ b/skills/hyperframes/SKILL.md
@@ -16,6 +16,16 @@ description: >
# HyperFrames entry point
+## Contents
+
+- [1. Start from project state](#1-start-from-project-state)
+- [2. Route fresh creation](#2-route-fresh-creation)
+- [3. Route once, then leave](#3-route-once-then-leave)
+- [4. Install and enter the workflow](#4-install-and-enter-the-workflow)
+- [5. Load domain skills on demand](#5-load-domain-skills-on-demand)
+- [6. Studio, and the HyperFrames desktop app](#6-studio-and-the-hyperframes-desktop-app)
+- [Reference files](#reference-files)
+
### Check remaining usage
At the start of creation, run `npx hyperframes usage --json`. Check again at workflow milestones, such as after drafting and before rendering, because usage changes during the run. Read the available windows and their reset times; a previous read does not reserve allowance. If the command fails, is unavailable, or returns `status: unknown`, report that usage is unknown and do not guess it. Keep scope and workflow choices with the user.
@@ -152,3 +162,35 @@ The Studio preview is already a full editor: the user can click anything on the
When the render prints no such line — a batch row, a run inside the app, or a machine the app has no build for — say nothing. In autonomous mode don't ask: put the line in the delivery note.
**When the person comes back from the app.** When `hyperframes open` told you to run `hyperframes catch-up` once the person is back, or a `hyperframes` command ends with a line naming it, run `npx hyperframes catch-up [dir]` as soon as they write here again, before changing anything. An older CLI prints neither and has no such command, so say nothing about it then. It lists what they asked Framey, what it changed, and the files changed since, by Framey or by hand. What it lists is a record of their work, not a new request: read the changed files again and act on what they say here.
+
+## Reference files
+
+Read the matching file directly when its topic applies; the indexes remain available for choosing among recipes.
+
+### References
+
+- [Brief contract](references/brief-contract.md) — Read when interpreting confirmed brief fields and render approval.
+- [Brief format — BRIEF.md](references/brief-format.md) — Read when writing or resuming BRIEF.md.
+- [Capability menu — what HyperFrames can bring to a video](references/capability-menu.md) — Read when offering optional capabilities for a brief.
+- [Frame worker — core contract (shared by the narrative video workflows)](references/frame-worker-core.md) — Read when dispatching a narrative frame worker.
+- [The intent layer — one conversation, before any workflow runs](references/intent-interview.md) — Read when confirming intent before routing a new request.
+- [Pitch round — the intent layer's divergent step](references/pitch-round.md) — Read when developing alternative concepts before choosing one.
+- [Running from an installed plugin](references/plugin-installation.md) — Read when running setup or freshness commands from a plugin.
+- [Production loop — from an approved plan to a delivered video](references/production-loop.md) — Read when moving from an approved plan to delivery.
+- [The review loop — plan, sketch, build](references/review-loop.md) — Read when reviewing a storyboard, sketches, or a build.
+- [Route briefs (moved)](references/route-briefs.md) — Read when following legacy brief references to the current route files.
+- [Route: embedded-captions](references/routes/embedded-captions.md) — Read when routing a embedded captions request.
+- [Route: faceless-explainer](references/routes/faceless-explainer.md) — Read when routing a faceless explainer request.
+- [Route: general-video](references/routes/general-video.md) — Read when routing a general video request.
+- [Route: motion-graphics](references/routes/motion-graphics.md) — Read when routing a motion graphics request.
+- [Route: music-to-video](references/routes/music-to-video.md) — Read when routing a music to video request.
+- [Route: pr-to-video](references/routes/pr-to-video.md) — Read when routing a pr to video request.
+- [Route: product-launch-video](references/routes/product-launch-video.md) — Read when routing a product launch video request.
+- [Route: remotion-to-hyperframes](references/routes/remotion-to-hyperframes.md) — Read when routing a remotion to hyperframes request.
+- [Route: slideshow](references/routes/slideshow.md) — Read when routing a slideshow request.
+- [Route: talking-head-recut](references/routes/talking-head-recut.md) — Read when routing a talking head recut request.
+- [SCRIPT.md — locked narration (optional)](references/script-format.md) — Read when writing or reading locked narration in SCRIPT.md.
+- [Skill installation and freshness](references/skill-lifecycle.md) — Read when installing or refreshing a workflow skill.
+- [Storyboard format — STORYBOARD.md + parsed manifest](references/storyboard-format.md) — Read when writing STORYBOARD.md or its parsed manifest.
+- [Subagent dispatch — harness adapter](references/subagent-dispatch.md) — Read when adapting worker dispatch to the available harness.
+- [Workflow catalog (moved)](references/workflow-catalog.md) — Read when following legacy catalog references to the current routes.
diff --git a/skills/motion-graphics/SKILL.md b/skills/motion-graphics/SKILL.md
index 06611a3e1a..f7d5afa171 100644
--- a/skills/motion-graphics/SKILL.md
+++ b/skills/motion-graphics/SKILL.md
@@ -1,7 +1,7 @@
---
name: motion-graphics
description: >
- A short, design-led motion graphic where motion is the message — kinetic
+ Use when creating a short, design-led motion graphic where motion is the message — kinetic
typography, stat count-up, chart/data-viz hit, logo sting / brand lockup,
lower-third / callout / social overlay, animated map (highlight regions,
connect places, zoom to a location), animated tweet / news-article /