Production-ready animations, transitions, backgrounds, and scenes for Remotion
TypeScript ai-agentsclaude-codedemo-videomcpmcp-servermodel-context-protocolmotion-designproduct-demoreactremotionshadcnvideo
feat: restruct skill.md, added all new components. create design spec
dev_wandry1cd3317d95eb
diff --git a/public/r/masked-slide-reveal.json b/public/r/masked-slide-reveal.jsondeleted file mode 100644index 4c7225da..00000000--- a/public/r/masked-slide-reveal.json+++ /dev/null@@ -1,18 +0,0 @@-{- "$schema": "https://ui.shadcn.com/schema/registry-item.json",- "name": "masked-slide-reveal",- "title": "Masked Slide Reveal",- "description": "Words slide up out of an invisible horizontal mask, one after another.",- "dependencies": [- "remotion"- ],- "files": [- {- "path": "registry/remocn/masked-slide-reveal/index.tsx",- "content": "\"use client\";\n\nimport { spring, useCurrentFrame, useVideoConfig } from \"remotion\";\n\nexport interface MaskedSlideRevealProps {\n text: string;\n staggerDelay?: number;\n fontSize?: number;\n color?: string;\n fontWeight?: number;\n speed?: number;\n className?: string;\n}\n\nexport function MaskedSlideReveal({\n text,\n staggerDelay = 3,\n fontSize = 72,\n color = \"#171717\",\n fontWeight = 700,\n speed = 1,\n className,\n}: MaskedSlideRevealProps) {\n const frame = useCurrentFrame() * speed;\n const { fps } = useVideoConfig();\n\n const words = text.split(\" \");\n\n return (\n <div\n style={{\n position: \"absolute\",\n inset: 0,\n display: \"flex\",\n alignItems: \"center\",\n justifyContent: \"center\",\n background: \"white\",\n }}\n >\n <span\n className={className}\n style={{\n fontSize,\n fontWeight,\n color,\n letterSpacing: \"-0.03em\",\n fontFamily:\n \"var(--font-geist-sans), -apple-system, BlinkMacSystemFont, sans-serif\",\n }}\n >\n {words.map((word, i) => {\n const t = spring({\n frame: frame - i * staggerDelay,\n fps,\n config: { damping: 14 },\n });\n return (\n <span\n key={i}\n style={{\n display: \"inline-block\",\n overflow: \"hidden\",\n verticalAlign: \"bottom\",\n lineHeight: 1,\n marginRight: \"0.25em\",\n }}\n >\n <span\n style={{\n display: \"inline-block\",\n transform: `translateY(${(1 - t) * 100}%)`,\n }}\n >\n {word}\n </span>\n </span>\n );\n })}\n </span>\n </div>\n );\n}\n",- "type": "registry:component",- "target": "components/remocn/masked-slide-reveal.tsx"- }- ],- "type": "registry:component"-}\ No newline at end of filediff --git a/skills/remocn/SKILL.md b/skills/remocn/SKILL.mdnew file mode 100644index 00000000..959901d2--- /dev/null+++ b/skills/remocn/SKILL.md@@ -0,0 +1,173 @@+---+name: remocn+description: >+ Build Remotion videos with remocn — a shadcn registry of copy-paste animation components and+ timeline-driven UI primitives. Use when composing video scenes, adding text animations,+ transitions, backgrounds, UI blocks, brand/social cards, or full compositions in a Remotion+ project. Triggers include "remocn", "video component", "add animation", "text reveal",+ "scene transition", "product demo video", "remotion component", "typewriter", "terminal+ simulator", "glass code block", and the UI-primitive tier: "video dialog", "video button",+ "command menu", "video select", "video tooltip". Even if the user doesn't mention remocn,+ activate when they need polished video primitives for Remotion.+---++# remocn++Copy-paste components for Remotion videos. Components install via `shadcn` and land in+`components/remocn/` — you own the code.++## Installation++Prerequisites: a Remotion project (`npx create-video@latest`).++```bash+# Add any component (namespaced shadcn registry)+shadcn add @remocn/blur-out-up++# Component lands at components/remocn/blur-out-up.tsx+```++`@remocn/<name>` is the canonical namespaced form (configured under `registries` in+`components.json`). The plain registry URL `https://remocn.dev/r/<name>.json` also works.++### Dependencies install automatically++Many components pull others via `registryDependencies` — `shadcn` installs them transitively.+For example, `shadcn add @remocn/typewriter` also pulls `@remocn/remocn-ui` and `@remocn/caret`.++- **`@remocn/remocn-ui`** is the shared core lib (timeline-fold hook, theme context, color math).+ Most UI Primitives depend on it. You rarely install it directly.++## Two tiers++remocn has two kinds of components — they have **different APIs**:++- **Animation tier** (`remocn`) — text animations, transitions, backgrounds, UI-block sims,+ brand/social cards, full compositions. Frame-driven. Shared props: `speed` (time multiplier),+ and for text: `fontSize`, `color`, `fontWeight`.+- **UI Primitives** (`remocn-ui`) — timeline-driven shadcn-style primitives (button, dialog,+ select, command-menu, tooltip…). State-based props (`state`, `style`, `variant`, `theme`).+ **No `speed` prop.** Built on `@remocn/remocn-ui`.++## Component categories++Pick by what you're building. The **full catalog with props, defaults, and dependencies** is+`references/components.md` — read it before installing.++| Category | Tier | Use for |+|---|---|---|+| **Text Animations** | `remocn` | Reveal/replace/emphasize text (`typewriter`, `blur-out-up`, `tracking-in`, `rolling-number`, `shimmer-sweep`…) |+| **Backgrounds & Effects** | `remocn` | Animated foundations, cursors, one-shot effects (`mesh-gradient-bg`, `dynamic-grid`, `spotlight-card`, `confetti`, `backdrop`) |+| **Transitions & Wipes** | `remocn` | Swap between two scenes (`directional-wipe`, `frosted-glass-wipe`, `spatial-push`, `zoom-through-transition`…) |+| **UI Blocks** | `remocn` | Interface sims for product demos (`terminal-simulator`, `glass-code-block`, `animated-bar-chart`, `progress-steps`…) |+| **AI & Social Cards** | `remocn` | Brand/product card scenes (`chat-gpt`, `claude-code`, `v0`, `github-stars`, `x-follow-card`…) |+| **Compositions** | `remocn` | Ready multi-scene sequences (`dashboard-populate`, `terminal-to-browser-deploy`, `hero-device-assemble`…) |+| **UI Primitives** | `remocn-ui` | shadcn-style primitives for video (`button`, `dialog`, `select`, `command-menu`, `tooltip`…) |++## Component patterns++Conventions differ by tier — don't assume animation-tier props on a primitive.++### Animation tier (`remocn`)++- Named `Props` interface per component (e.g. `BlurOutUpProps`).+- `speed?: number` — global time multiplier (default `1`), applied as `frame * speed`.+- Text components: `fontSize`, `color`, `fontWeight`.+- Transitions: take `from` / `to` as `ReactNode` (the two scenes), plus `transitionDuration`.+- `className?: string` on the root.++### UI Primitives (`remocn-ui`)++- State-based, **not** `speed`-based: `state` (e.g. `"open"` / `"closed"`), `style`, `variant`,+ `size`, `theme?: Partial<RemocnTheme>`.+- The opened/closed/active state is a pure function of the timeline (keyframed presets).+- Compose modal-layer primitives (dialog, alert-dialog, drawer) with a trigger element — see+ each component's example.++### Animation API++```tsx+import { interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";++const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: "clamp" });+const scale = spring({ fps, frame, config: { damping: 12, mass: 1, stiffness: 100 } });++// Deterministic randomness (NEVER Math.random())+import { random } from "@remotion/random";+const jitter = random(`seed-${frame}`);+```++### Composition structure++```tsx+import { Sequence, Series } from "remotion";++<Sequence from={30} durationInFrames={60}>+ <Typewriter text="npm install remocn" />+</Sequence>++<Series>+ <Series.Sequence durationInFrames={60}><SceneA /></Series.Sequence>+ <Series.Sequence durationInFrames={60}><SceneB /></Series.Sequence>+</Series>+```++### Canvas & timing++- **Canvas standard:** `1280×720 @ 30fps`. Components are laid out for it.+- **Budget each Sequence around the component's natural length** — `components.md` lists it as+ `*Nf @ 30fps*` per component. Under-budgeting clips the animation; over-budgeting leaves dead air.+- **Tone matching:** each catalog entry carries a `vibe` tag (`tech`/`premium`/`data`/`clean`/+ `playful`/`social`) — pick components whose vibe fits the brand.+- **Palette & fonts:** stay within the library's tokens (`references/design.md` → tokens) so your+ own elements don't clash.++## Design defaults — avoid AI-slop++When you write your **own** text, scene chrome, or cards (not the prebuilt components), keep it+restrained:++- **No decorative `letter-spacing`** on body/heading text you add.+- **No `text-transform: uppercase` / ALL-CAPS** defaults — prefer sentence case (`Launch`, not `LAUNCH`).+- **No gradient text-fills or decorative gradient washes** — gradients only as intentional backgrounds.+- **No glow / colored drop-shadows or large blur radii** (`blur > ~24px`, spread, multi-layer) —+ subtle 1px elevation only.++**Exception:** never strip these from components whose essence is the effect — `tracking-in`+(letter-spacing), `mesh-gradient-bg` and social cards (gradients), and intentional elevation are+all legitimate. The rules govern *your* additions, not the library.++Full do/avoid examples: `references/design.md`. For motion quality (timing, anticipation,+staging, easing), see `references/motion-principles.md`.++## Gotchas (remocn-specific)++- **Transitions wrap two scenes** — pass `from` / `to` as `ReactNode`, not as a static instance.+- **Terminal scroll is instant** — step-function `translateY`, never spring/ease the scroll.+- **`overflow: hidden` on split layouts** — prevents content breakage during width animations.+- **Cursor blink is deterministic** — `Math.floor(frame / 15) % 2 === 0`, not intervals.+- **Static files go in `public/`** — load via `staticFile('cursor.svg')`, not imports.+- **Social cards render offline** — `avatarUrl=""` / `coverUrl=""` fall back to gradients; no fetch.++General Remotion rules (no `Math.random()`, no `setInterval`, animate `transform` not `top`/`left`,+load fonts before render) live in the `remotion-best-practices` skill.++## Composing a video++Typical product demo:++1. **Background**: `mesh-gradient-bg` or `dynamic-grid`.+2. **Title reveal**: `blur-out-up`, `staggered-fade-up`, or `tracking-in`.+3. **Show the product**: `browser-flow`, `terminal-simulator`, or `glass-code-block`.+4. **Transition between scenes**: `frosted-glass-wipe`, `spatial-push`, or `directional-wipe`.+5. **End with impact**: `confetti`, `pricing-tier-focus`, or a full composition.++Or drop in a full composition (`dashboard-populate`, `terminal-to-browser-deploy`,+`hero-device-assemble`) and customize its props.++## Reference++- `references/components.md` — full catalog: props, defaults, dependencies, duration & vibe per component.+- `references/design.md` — anti-slop design defaults (do/avoid) + design tokens (palette, fonts, canvas).+- `references/motion-principles.md` — motion-design principles adapted to remocn + Remotion.+- `references/anti-patterns.md` — common generation mistakes and their fixes.diff --git a/skills/remocn/references/anti-patterns.md b/skills/remocn/references/anti-patterns.mdnew file mode 100644index 00000000..af7b80f2--- /dev/null+++ b/skills/remocn/references/anti-patterns.md@@ -0,0 +1,88 @@+# remocn Anti-Patterns++Common mistakes when generating remocn videos. Each is something the model tends to do wrong.++## 1. Clipping a component by under-budgeting its Sequence++Every component has a natural length (the `*Nf @ 30fps*` line in `components.md`). Budget the+`Sequence` around it.++```tsx+// ❌ blur-out-up needs ~90f, gets cut at 30+<Sequence durationInFrames={30}><BlurOutUp text="Launch" /></Sequence>+// ✅+<Sequence durationInFrames={90}><BlurOutUp text="Launch" /></Sequence>+```++## 2. Treating a transition like a static element++Transitions wrap **two** scenes via `from` / `to` — they are not a single overlay.++```tsx+// ❌+<DirectionalWipe />+<SceneB />+// ✅+<DirectionalWipe from={<SceneA />} to={<SceneB />} />+```++## 3. Animation-tier props on a UI Primitive++Primitives (`remocn-ui`) are state-based and have **no `speed`**. Drive them with `state`.++```tsx+// ❌+<Dialog speed={2} />+// ✅+<Dialog state="open" />+```++## 4. Wrong canvas size++The standard composition is `1280×720 @ 30fps`. Components are laid out for it. Don't invent+`1920×1080` and wonder why things are off-center.++## 5. Animating layout properties++Animate `transform` (and individual `translate`/`scale`), never `top`/`left`/`width`/`height` —+layout animation reflows every frame and breaks split layouts.++```tsx+// ❌ left: interpolate(frame, [0,30], [0,200])+// ✅ transform: `translateX(${interpolate(frame,[0,30],[0,200])}px)`+```++## 6. Non-deterministic code++Renders are multi-pass — `Math.random()`, `setInterval`/`setTimeout`, `Date.now()` all produce+flicker or diverging frames.++```tsx+// ❌ const x = Math.random();+// ✅ import { random } from "@remotion/random"; const x = random(`seed-${frame}`);+```++## 7. Mishandling registryDependencies++Dependencies install **automatically** — don't tell the user to add them manually, and don't+inline-copy a dependency's code. Also: don't import deeper than one path segment+(`@/components/remocn/<name>`); the tsconfig glob doesn't resolve `<name>/helpers`.++## 8. Loading fonts mid-render++Load fonts once before render via `@remotion/google-fonts` (`loadFont()`), not inside a component+body per frame. Unloaded fonts flash fallback in the export.++## 9. Hardcoding a background on a component++remocn components render **transparent** — they don't own a background. Set the scene background+with `backdrop` (or your own container), not by hardcoding a fill into the component.++## 10. Slop styling on your own additions++ALL-CAPS + wide tracking + gradient text + glow shadows on text *you* add. See `design.md`.++## 11. Everything enters on one frame++Stagger sibling entrances (3–6f). Landing a whole group simultaneously reads robotic. See+`motion-principles.md` → Follow-Through & Overlapping Action.diff --git a/skills/remocn/references/design.md b/skills/remocn/references/design.mdnew file mode 100644index 00000000..daf8c47d--- /dev/null+++ b/skills/remocn/references/design.md@@ -0,0 +1,121 @@+# remocn Design Defaults++These are defaults for content **you author** — your own text, scene chrome, cards, and overlays.+They keep output from reading as generic AI-slop. They are **not** retroactive rules for the+prebuilt remocn components.++> **Scope & exception.** Never strip these traits from a component whose essence *is* the effect:+> `tracking-in` is letter-spacing; `mesh-gradient-bg`, `spotlight-card`, and the social cards are+> gradients; some primitives use subtle elevation. The rules govern your additions, not the library.++---++## No decorative letter-spacing++Don't widen tracking on text you add. It reads as "designed by AI".++```tsx+// ✅ default tracking+<div style={{ fontSize: 64, fontWeight: 600 }}>Ship faster</div>++// ❌ decorative wide tracking+<div style={{ letterSpacing: "0.3em", textTransform: "uppercase" }}>SHIP FASTER</div>+```++**Exception:** `tracking-in` animates letter-spacing as its whole effect — that's intentional.++## No uppercase / ALL-CAPS defaults++Prefer sentence case. Don't `text-transform: uppercase` and don't write ALL-CAPS string literals+as defaults.++```tsx+// ✅+<BlurOutUp text="Launch week" />++// ❌+<BlurOutUp text="LAUNCH WEEK" />+```++Use ALL-CAPS only when the design genuinely calls for it (e.g. a glitch/tech label), not as a+reflex for emphasis.++## No gradient text-fills or decorative washes++Gradients belong on **backgrounds** that are meant to be gradients — not as text fills or+decorative overlays sprinkled on cards.++```tsx+// ✅ gradient as an intentional background+<MeshGradientBg colors={["#0ea5e9", "#9333ea"]} />+<div style={{ color: "#fafafa" }}>Clear, solid text on top</div>++// ❌ gradient-clipped text + decorative wash+<h1 style={{+ background: "linear-gradient(90deg,#0ea5e9,#9333ea)",+ WebkitBackgroundClip: "text",+ color: "transparent",+}}>Slop headline</h1>+```++**Exception:** `shimmer-sweep` uses `background-clip: text` deliberately; social-card cover/avatar+fallbacks render gradients by design.++## No glow / heavy shadows++No colored glows, no large blur radii, no multi-layer drop-shadows. Use a 1px border or a small,+neutral elevation if you need separation.++```tsx+// ✅ subtle elevation+boxShadow: "0 1px 2px rgba(0,0,0,0.08)"+border: "1px solid #e5e5e5"++// ❌ glow / oversized shadow+boxShadow: "0 0 80px 20px rgba(14,165,233,0.6)"+filter: "blur(60px)" // decorative glow blob+```++Threshold to avoid: shadow/`filter` blur `> ~24px`, any `spread`, any colored/glow shadow,+stacked shadow layers. See also: decorative radial-gradient/blur "glow blobs" are never acceptable.++**Exception:** components that intentionally model real UI elevation (cards, modals) keep their+designed shadow — don't flatten them.++---++## Design tokens++When you author your own text, surfaces, or chrome, pull from the palette the library already+uses so your additions don't clash with the components.++### Canvas++`1280×720 @ 30fps`. Font weights in use: `400 · 500 · 600 · 700`.++### Palette++| Role | Hex |+|---|---|+| Primary text (on light) | `#171717` |+| Text on dark | `#fafafa` / `#ffffff` |+| Background — near-black | `#0a0a0a` / `#050505` |+| Surface — zinc | `#27272a` |+| Accent — green / success | `#22c55e` |+| Accent — sky | `#0ea5e9` |+| Accent — violet | `#a855f7` / `#7c3aed` |+| Brand — warm (Claude) | `#D97757` |++Stay within this set for your own elements. Brand cards (`claude-*`, `v0`, `chat-gpt`) carry their+own brand hex — don't override it.++### Fonts (`@remotion/google-fonts`)++| Use | Font |+|---|---|+| UI / body | `Inter` |+| Display | `Manrope` |+| Serif display | `Fraunces` |+| Code / mono | `JetBrainsMono` / `GeistMono` |++Load fonts before render (`@remotion/google-fonts/Inter` → `loadFont()`), never mid-frame.diff --git a/skills/remocn/references/motion-principles.md b/skills/remocn/references/motion-principles.mdnew file mode 100644index 00000000..6f6292b5--- /dev/null+++ b/skills/remocn/references/motion-principles.md@@ -0,0 +1,132 @@+# Motion Principles for remocn++The 12 classic animation principles, adapted to **composing Remotion videos from remocn blocks**.+Each entry: the principle → the Remotion mechanic that expresses it → a remocn component that+demonstrates it → do/avoid tuned to remocn's restraint.++- This file is about **which** principle and **when** (intent). For **how** the APIs work+ (easing curves, sequencing, spring config), see the `remotion-best-practices` skill.+- Motion must stay restrained — see `design.md`. Where a principle pushes toward boldness+ (squash, exaggeration), the cap below always wins.+- Idiom note: remocn components drive motion with `spring()` and `interpolate()` + `Easing`.+ Examples here use that same idiom.++Tags: **`core`** — routinely useful when assembling scenes · **`rarely-needed`** — character-+animation territory; only relevant if you hand-draw motion, not when composing blocks.++---++## 1. Squash & Stretch — `rarely-needed`++Compress on impact, elongate on speed; preserve volume. For UI this means a tiny scale-x/scale-y+trade on landing — nothing cartoon.++- **Mechanic:** `spring()` driving `scaleX`/`scaleY` inversely on impact frames.+- **remocn:** `spring-scale-in` (settle), `confetti` (particle pop).+- **Do/Avoid:** at most a 2–4% volume trade on a hard landing. ❌ No rubber-band squash on text or+ cards — it fights `design.md`.++## 2. Anticipation — `core`++A short wind-up before the action makes it feel intentional: a drawer dips before it expands.++- **Mechanic:** `spring()` with light overshoot, or a brief reverse `interpolate` (e.g. `−4px`)+ for 1–3 frames before the main move.+- **remocn:** `spring-scale-in`, `tool-menu-slide-in` (palette crouches before it flies up),+ `code-accordion`.+- **Do/Avoid:** keep the wind-up to 1–3 frames, ≤110% scale. ❌ No bouncy cartoon recoil.++## 3. Staging — `core`++Direct the eye: one clear idea per scene. Clear the stage before introducing the next element.++- **Mechanic:** `<Sequence>` / `<Series>` to isolate beats; stagger entrances so only one focal+ element moves at a time; dim/scale-down what's leaving.+- **remocn:** `pricing-tier-focus` (focused tier rises, siblings dim), most Compositions.+- **Do/Avoid:** one focal action per beat. ❌ Don't enter five elements on the same frame.++## 4. Straight-Ahead vs Pose-to-Pose — `rarely-needed`++Pose-to-pose = define key frames, interpolate between. That's exactly how remocn works.++- **Mechanic:** `interpolate(frame, [k0, k1, k2], [v0, v1, v2])` — your keyframes are the poses.+- **remocn:** every component (key ranges in `index.tsx`).+- **Do/Avoid:** think in keyframes and let `interpolate` fill between. Straight-ahead (frame-by-+ frame) is for hand-drawn organic effects — not block composition.++## 5. Follow-Through & Overlapping Action — `core`++Nothing stops at once; elements arrive staggered. Lighter things lead, heavier lag.++- **Mechanic:** per-element delay offsets (`frame - index * stagger`) on the same animation.+- **remocn:** `staggered-fade-up`, `tool-menu-slide-in` (icons pop after the panel),+ `short-slide-right`.+- **Do/Avoid:** stagger 3–6 frames between siblings. ❌ Don't land a whole group on one frame+ (reads robotic) and don't over-stagger (feels sluggish).++## 6. Slow In & Slow Out — `core`++Ease into and out of poses — almost nothing should move linearly.++- **Mechanic:** `interpolate(..., { easing: Easing.out(Easing.cubic) })`; sharp curve = snappy,+ gentle = graceful.+- **remocn:** transitions (`directional-wipe`, `frosted-glass-wipe`), most text reveals.+- **Do/Avoid:** default to ease-out for entrances. ❌ Linear `interpolate` for visible motion+ unless it's a constant drift (e.g. marquee, grid pan).++## 7. Arc — `core`++Living motion follows curves, not straight lines — especially cursors and gestures.++- **Mechanic:** drive `x` and `y` from separate eased interpolations, or a bezier path.+- **remocn:** `cursor` + `useCursorPath`, social cards' cursor travel to the Follow button.+- **Do/Avoid:** curve cursor/hand paths. ❌ No straight diagonal cursor jumps.++## 8. Secondary Action — `core`++Supporting motion that reinforces the primary action without stealing focus.++- **Mechanic:** a small parallel channel — a cursor ripple on click, a shadow that breathes as a+ card opens, a caret blink under typing.+- **remocn:** `x-follow-card` (ripple at click), `typewriter` (`caret` blink).+- **Do/Avoid:** secondary motion stays subtle and on-theme. ❌ Don't add competing animation that+ splits attention.++## 9. Timing — `core`++Frame counts set weight: fast = light, slow = heavy. Vary timing for contrast.++- **Mechanic:** budget in frames @ fps (remocn defaults to 30fps; component durations run+ ~90–300 frames). The `speed` prop scales the animation tier.+- **remocn:** every animation-tier component (`speed`); composition `durationInFrames`.+- **Do/Avoid:** match duration to weight — a heavy hero assemble is slower than a toast. ❌ Don't+ reuse one duration for everything (kills rhythm).++## 10. Exaggeration — `core` (capped)++Push slightly past literal reality for clarity — but remocn's house style is restraint.++- **Mechanic:** a touch of overshoot on `spring()`, a brief ≤110% scale peak.+- **remocn:** `spring-scale-in`, `micro-scale-fade`.+- **Do/Avoid:** subtle UI exaggeration only (≤110%, gentle overshoot). ❌ No stretched/cartoon+ exaggeration — this is the principle most likely to collide with `design.md`; the cap wins.++## 11. Solid Drawing — `rarely-needed`++Form, weight, and consistent perspective. For block composition this is mostly fixed by the+components; it matters only if you build 3D-ish scenes.++- **Mechanic:** consistent `perspective` / `transform-origin` across layered elements.+- **remocn:** `spatial-push`, `perspective-marquee`, `device-mockup-zoom`.+- **Do/Avoid:** keep one perspective per scene when stacking 3D layers. ❌ Don't mix inconsistent+ vanishing points.++## 12. Appeal — `rarely-needed`++The charisma of the result: clear shapes, balanced proportion, motion that invites watching.+Emergent, not a knob.++- **Mechanic:** outcome of staging + timing + restraint working together.+- **remocn:** the full Compositions as reference for a coherent, watchable result.+- **Do/Avoid:** aim for clear and captivating, not busy. ❌ More motion ≠ more appeal — cut what+ doesn't serve the focal idea.