diff --git a/skills/hyperframes/SKILL.md b/skills/hyperframes/SKILL.md
index f68c52dac..19dd09a4f 100644
--- a/skills/hyperframes/SKILL.md
+++ b/skills/hyperframes/SKILL.md
@@ -9,18 +9,24 @@ HTML is the source of truth for video. A composition is an HTML file with `data-
 
 ## Approach
 
-### Discovery (exploratory requests only)
+### Brief (exploratory requests only)
 
-For open-ended requests ("make me a product launch video", "create something for our brand") where the user hasn't committed to a direction, understand intent before picking colors:
+For open-ended requests ("make me a product launch video", "create something for our brand"), gather what's missing from the prompt before building a design system. For specific requests ("add a title card", "fix the timing on scene 3"), skip this.
 
-- **Audience** — who watches this? Developers? Executives? General consumers?
-- **Platform** — where does it play? Social (15s), website hero, product demo, internal?
-- **Priority** — what matters most? Motion quality? Content accuracy? Brand fidelity? Speed?
-- **Variations** — does the user want options, or a single best shot?
+Extract what you can from the prompt itself — only ask about what's genuinely missing. Ask **one question at a time** and let each answer inform the next. Combine two questions in one message when they're naturally related, but never dump a list.
 
-For specific requests ("add a title card", "fix the timing on scene 3"), skip discovery.
+**Format each question as a lettered multiple choice** (A, B, C, D) so the user can respond with just a letter. Include 2-4 contextual options plus the option to give a custom answer. Tailor the options to the specific prompt — don't use generic choices.
 
-For exploratory requests, consider offering 2-3 variations that differ meaningfully — not just color swaps, but different pacing, energy levels, or structural approaches. One safe/expected, one ambitious. Don't mandate this — it's a tool available when appropriate.
+The questions (in rough priority order):
+
+- **Audience** — who watches this? (Developers, executives, consumers — changes type scale, density, easing)
+- **Emotion** — what should the viewer feel? (Maps directly to mood board clustering in the picker. Sharpen this based on the audience answer — "technical precision or breakthrough excitement?" is better than "what mood?")
+- **Brand assets** — do they have a logo, existing colors, fonts, website? (If yes, palettes and type pairings derive from them. If no, skip — full creative freedom.)
+- **Light or dark?** (Eliminates half the palette options. Can often combine with another question.)
+- **Surface** — where does this play? (Social → portrait/punchy, website hero → landscape/looping, presentation → widescreen/breathable, internal → information-dense)
+- **Key takeaway** — what's the one thing the viewer should remember? (Drives focal hierarchy in architecture previews)
+
+Most prompts already answer 2-3 of these — a typical brief is 2-3 questions, not 6. These answers seed the design picker in Step 1 — pass them when generating mood boards, palettes, and architectures.
 
 ### Step 1: Design system
 
@@ -476,6 +482,7 @@ Skip on small edits (fixing a color, adjusting one duration). Run on new composi
 - **[references/techniques.md](references/techniques.md)** — 11 visual techniques with code patterns: SVG drawing, Canvas 2D, CSS 3D, kinetic type, Lottie, video compositing, typing effect, variable fonts, MotionPath, velocity transitions, audio-reactive. Read when planning techniques per beat.
 - **[references/narration.md](references/narration.md)** — Pacing, tone, script structure, number pronunciation, opening line patterns. Read when the composition includes voiceover or TTS.
 - **[references/design-picker.md](references/design-picker.md)** — Create a design.md via visual picker. Read when no design.md exists and the user wants to create one.
+- **[references/shader-backgrounds.md](references/shader-backgrounds.md)** — GLSL shader patterns for contextual scene backgrounds. Noise library, domain warping, pattern recipes by context (travel, medical, tech, industrial). Read when building shader backgrounds for compositions or the design picker.
 - **[visual-styles.md](visual-styles.md)** — 8 named visual styles with hex palettes, GSAP easing signatures, and shader pairings. Read when user names a style or when generating design.md.
 - **[house-style.md](house-style.md)** — Default motion, sizing, and color palettes when no design.md is specified.
 - **[patterns.md](patterns.md)** — PiP, title cards, slide show patterns.
diff --git a/skills/hyperframes/house-style.md b/skills/hyperframes/house-style.md
index 892c2ebed..3994c02d2 100644
--- a/skills/hyperframes/house-style.md
+++ b/skills/hyperframes/house-style.md
@@ -32,9 +32,9 @@ If the content genuinely calls for one of these — centered layout for a solemn
 
 ## Background Layer
 
-Every scene needs visual depth — persistent decorative elements that stay visible while content animates in. Without these, scenes feel empty during entrance staggering.
+Decoratives add depth when a scene needs it — during entrance staggering, during holds, or when the content is sparse and the frame feels flat. They're a tool, not a requirement.
 
-Ideas (mix and match, 2-5 per scene):
+Ideas:
 
 - Radial glows (accent-tinted, low opacity, breathing scale)
 - Ghost text (theme words at 3-8% opacity, very large, slow drift)
@@ -42,9 +42,7 @@ Ideas (mix and match, 2-5 per scene):
 - Grain/noise overlay, geometric shapes, grid patterns
 - Thematic decoratives (orbit rings for space, vinyl grooves for music, grid lines for data)
 
-All decoratives should have slow ambient GSAP animation — breathing, drift, pulse. Static decoratives feel dead.
-
-**Decorative count vs motion count.** The "2-5 per scene" count refers to decorative _elements_. If a project's `design.md` says "single ambient motion per scene", it means one looping motion applied to these decoratives (a shared breath/drift/pulse) — not one element total. A scene with 4 decoratives sharing one breathing motion is correct; a scene with 1 decorative is under-dressed.
+Use as many or as few as the scene earns. A data-dense scene with 4 decoratives and shared breathing motion is rich. A single word on a black frame with no decoration is powerful. Both are valid — the question is whether the density matches the emotional beat.
 
 ## Motion
 
diff --git a/skills/hyperframes/references/design-picker.md b/skills/hyperframes/references/design-picker.md
index 261566623..66a888b77 100644
--- a/skills/hyperframes/references/design-picker.md
+++ b/skills/hyperframes/references/design-picker.md
@@ -12,17 +12,190 @@ Read these before generating options — they define the rules your options must
 - [../visual-styles.md](../visual-styles.md)
 - [beat-direction.md](beat-direction.md)
 
-## Building the picker
+## Creative process (do this BEFORE writing any data)
 
-1. Generate options **deeply contextual to the user's prompt**. Every category — not just architectures — must reflect the specific product, brand, audience, and mood. Generic options that could appear on any picker are a failure.
+<HARD-GATE>
+Do NOT skip to the data format section. Do NOT start generating architecture HTML. Complete the creative thinking below FIRST. If you jump straight to code, every project will look the same.
+</HARD-GATE>
 
-   **Mood boards** — as many as the creative space warrants (4-8). Every board must tell a different STORY about the brand, not just reshuffle the same elements. Ask: "what are the genuinely different ways to position this product?" A cat food brand might be: playful chaos, premium positioning, comfort/cozy, social-native, flavor showcase, humor-led, sensory/appetizing. Each is a different narrative, not a different font on the same layout.
+### Step 1: What is unique about THIS prompt?
 
-   **Architectures** — one per mood board minimum, each visually distinct. Use `{{prompt_headline}}` and `{{prompt_sub}}` tokens. If the user provided media assets, use them as background images (use `url(path)` without quotes — single quotes inside `style='...'` break the attribute).
+Before generating anything, answer these questions about the specific brief:
 
-   **Palettes** (5-6) — named after the brand's world, not generic moods. The palette names and colors should feel like they belong to THIS specific product. Always mix dark + light + tinted. **Every palette must be visually distinct at swatch size.** If two palettes share the same background lightness AND a similar accent hue, cut one. Test: would a user see the difference in a 14px swatch chip? If not, they're duplicates.
+- **What does this subject LOOK like?** Not generically — specifically. A Santorini travel video has white walls, blue domes, caldera cliffs. A hantavirus PSA has clinical sterility, warning signage, laboratory imagery. A rocket promo has exhaust plumes, mission control grids, countdown typography. The visual vocabulary of the subject should drive the layouts.
+- **What does the target emotion FEEL like as a frame?** Wanderlust is longing — empty space the viewer wants to fill. Urgency is compression — information crowding the viewer. Awe is scale — one element so large it overwhelms.
+- **What does the surface context demand?** A lobby screen is ambient and glanced-at. A YouTube pre-roll is competing for attention. A social story is vertical and fast. The same content looks different in each context.
+- **What does every other video for this subject look like?** That's what you must NOT produce for at least 3 of your 9 boards. If every travel video is a hero image with text overlay, your rare boards shouldn't be hero images with text overlay.
 
-   **Type pairings** (5-6) — **RUN the font discovery script from typography.md BEFORE generating pairings.** This is not optional. Download Google Fonts metadata, run the script, and pick from its output. You will otherwise reach for the same 8 fonts every time (Bricolage Grotesque, Instrument Serif, Fraunces, Archivo Black, DM Serif Display, Space Grotesk, Fredoka) — that's your training data default, not a contextual choice. Match the brand's energy and audience. Cross-category per typography.md (never two sans-serifs).
+### Step 2: Verbalized sampling
+
+Generate 9 video concepts for the brief using chain-of-thought reasoning.
+
+First, produce a single `reasoning` field — a string containing your step-by-step thought process through five genuinely different paths:
+
+1. **From the subject** — what is the visual world of this specific thing?
+2. **From the emotion** — what does the target feeling look like as a layout?
+3. **From the audience** — what does this viewer expect? What would surprise them?
+4. **From the anti-pattern** — what does every competitor do? Do the opposite.
+5. **From an unusual format** — a letter, a recipe, a countdown, a newspaper, a Q&A, a map, a poem. What non-video format could this content take?
+
+Then return the concepts as JSON:
+
+```json
+{
+  "reasoning": "Step-by-step thought process through all 5 paths, generating 9 concepts from them...",
+  "responses": [
+    {
+      "text": "Video concept with layout wireframe description and silhouette of major elements",
+      "probability": 0.35
+    },
+    {
+      "text": "...",
+      "probability": 0.07
+    }
+  ]
+}
+```
+
+9 entries in `responses`. Each `text` describes the video concept including layout wireframe and silhouette of major elements. No extra explanation.
+
+Each `probability` is the estimated probability (0.0–1.0) of this response given the input prompt, relative to the full distribution.
+
+**Sample from the tails:** at least 3 of the 9 concepts MUST have probability < 0.10. These are the rare, unexpected directions that prevent mode collapse. If all 9 score above 0.10, you're reproducing the median — start over.
+
+**Anti-mode-collapse check:** verify no two concepts share the same layout silhouette. Draw the bounding boxes of major elements mentally — if two produce the same shape, replace one.
+
+### Step 3: Generate the data
+
+Now — and only now — expand the 5 concepts into architectures, palettes, type pairings, and mood boards.
+
+**Mood boards** (9) — one per concept. Each tells a different STORY, not a different color scheme on the same layout.
+
+**Architectures** (9) — one per mood board, each a different structural shape. See the structural diversity section below for layout shapes.
+
+**Palettes** (6-9) — named after the subject's world. A Santorini picker has "Aegean Blue", "Caldera Pink", "Oia Cream" — not "Dark Premium" or "Warm Editorial." Mix light + dark + tinted.
+
+**Type pairings** (6-9) — **RUN the font discovery script from typography.md FIRST.** Match the subject's energy.
+
+**Backgrounds** (one per architecture) — each mood board can have an animated 3D gradient background rendered with Three.js. The picker includes built-in presets PLUS 3 prompt-contextual options you generate.
+
+#### Built-in presets
+
+These are baked into the picker template. The user selects one and tweaks its controls:
+
+| Preset       | Geometry   | Shader   | Feel                                      |
+| ------------ | ---------- | -------- | ----------------------------------------- |
+| None         | —          | —        | Flat color, no animation                  |
+| Halo         | plane      | defaults | Warm flowing gradient, organic undulation |
+| Mint         | waterPlane | defaults | Cool water surface, gentle waves          |
+| Cosmic       | sphere     | cosmic   | Holographic nebula, iridescent shimmer    |
+| Nighty Night | waterPlane | defaults | Dark moody waves, deep atmosphere         |
+| Sunset       | sphere     | defaults | Warm sphere glow, gentle color blend      |
+| Cotton Candy | waterPlane | defaults | Pastel soft waves, light and airy         |
+| Glass        | waterPlane | glass    | Refractive surface, specular highlights   |
+| Blob         | sphere     | defaults | Wiggly organic shape, high displacement   |
+
+Each preset has contextual controls (speed, wave height, wobble, etc.) that the user adjusts live.
+
+#### Prompt-contextual backgrounds (generate 3)
+
+In addition to the built-in presets, generate **3 entirely new background styles** — new fragment shaders, new configurations, new control sets. The built-in presets (`defaults`, `cosmic`, `glass`) are templates showing how the Three.js pipeline works. Your 3 backgrounds should be original visual effects that match the prompt's world.
+
+##### How the pipeline works
+
+Each background is a Three.js scene with:
+
+1. **Geometry** — `sphere` (SphereGeometry), `water` or `plane` (PlaneGeometry with subdivisions)
+2. **Vertex shader** — shared across all backgrounds. Applies 3D Perlin noise displacement to vertices. Controlled by `uDensity` (noise scale), `uSpeed` (animation rate), `uStrength` (displacement magnitude).
+3. **Fragment shader** — this is where you create the visual effect. Receives `vPos` (displaced vertex position), `vNormal`, `vViewPos`, `uColor1/2/3` (3 palette colors), `uTime`, `uSpeed`. Must output `gl_FragColor`.
+4. **Camera** — positioned via spherical coordinates (`camAz`, `camPol`, `camDist`). Spheres always use distance 14 with `zoom` controlling magnification. Planes/water use `camDist` directly.
+5. **Controls** — 2-3 sliders the user adjusts live. Each maps to a uniform or mesh property.
+
+##### Writing a custom fragment shader
+
+The fragment shader receives these varyings/uniforms:
+
+```glsl
+varying vec3 vPos;      // displaced vertex position in model space
+varying vec3 vNormal;   // surface normal (for lighting)
+varying vec3 vViewPos;  // view-space position (for fresnel/specular)
+uniform vec3 uColor1, uColor2, uColor3;  // 3 palette colors
+uniform float uTime, uSpeed;             // animation time + speed
+```
+
+Use `vPos` for spatial color mapping — the gradient pattern comes from mapping colors to vertex positions. Use `vNormal` and `vViewPos` for lighting (diffuse, specular, fresnel). Add custom visual effects: interference patterns, noise-based distortion, view-dependent color shifts, rim glow, etc.
+
+Example — a "coral reef" fragment shader for a tropical video:
+
+```glsl
+void main() {
+  vec3 base = mix(mix(uColor1, uColor2, smoothstep(-3.0, 3.0, vPos.x)),
+                  uColor3, smoothstep(-2.0, 2.0, vPos.z));
+  vec3 n = normalize(vNormal);
+  vec3 v = normalize(-vViewPos);
+  // Subsurface scattering — warm glow through the surface
+  float sss = pow(max(0.0, dot(-n, v)), 2.0) * 0.3;
+  vec3 sssColor = mix(uColor2, uColor1, 0.5);
+  // Caustic ripples on the surface
+  float t = uTime * uSpeed;
+  float caustic = abs(sin(vPos.x * 15.0 + t * 2.0) * cos(vPos.y * 12.0 + t * 1.5)) * 0.15;
+  // Lighting
+  vec3 l = normalize(vec3(1, 1, 0.5));
+  float diff = max(dot(n, l), 0.0) * 0.25;
+  float spec = pow(max(dot(n, normalize(l + v)), 0.0), 64.0) * 0.2;
+  float fresnel = pow(1.0 - max(dot(n, v), 0.0), 4.0);
+  vec3 col = base * (0.65 + diff) + vec3(spec) + sssColor * sss + vec3(caustic);
+  col += mix(base, vec3(1), 0.3) * fresnel * 0.15;
+  gl_FragColor = vec4(col, 1.0);
+}
+```
+
+##### Custom preset format
+
+```json
+{
+  "name": "Coral Reef",
+  "desc": "Warm underwater glow with caustic ripples",
+  "type": "water",
+  "shader": "coral_reef",
+  "fragmentShader": "void main() { ... }",
+  "density": 1.4,
+  "speed": 0.15,
+  "strength": 2.8,
+  "rotX": 40,
+  "rotY": 0,
+  "rotZ": 10,
+  "camDist": 4.0,
+  "camAz": 175,
+  "camPol": 75,
+  "zoom": 1,
+  "posX": 0,
+  "posY": 0.5,
+  "posZ": 0,
+  "controls": [
+    { "label": "Speed", "key": "speed", "min": 0.05, "max": 0.5, "step": 0.05 },
+    { "label": "Wave height", "key": "strength", "min": 0.5, "max": 5.0, "step": 0.2 },
+    { "label": "Caustic intensity", "key": "density", "min": 0.5, "max": 3.0, "step": 0.1 }
+  ]
+}
+```
+
+When `fragmentShader` is present, the picker uses it directly instead of looking up `shader` in the built-in library. The `shader` field is still set for the design.md export (agents use it as a label).
+
+##### Guidelines
+
+- **Write new GLSL, don't just reconfigure existing presets.** The visual effect should be unique to the prompt. A PSA video gets a "biohazard pulse" shader with expanding rings and scan lines. A food video gets an "oil shimmer" shader with heat-distorted refraction. A music video gets a "frequency" shader with audio-reactive bands.
+- **Match the subject's physical world.** The shader should feel like looking at the subject's environment at a microscopic or atmospheric level.
+- **Pick geometry by metaphor.** `sphere` = contained, focused. `water` = expansive, environmental. `plane` = flat, graphic.
+- **Name after the prompt's world**, not the technique.
+- **2-3 controls per preset** that expose the parameters most relevant to the visual effect.
+
+Camera rules:
+
+- **sphere**: `camDist` ignored (always 14). `zoom` controls magnification (1 = full sphere, 15+ = surface detail). Higher zoom needs lower `strength`.
+- **water/plane**: `camDist` controls distance. `zoom` always 1. `posY` shifts the mesh vertically.
+
+Append the 3 custom backgrounds to the `BG_PRESETS` array via `BG_PRESETS.push(...)` after the built-in presets. If the preset has a `fragmentShader` field, register it in the `FRAGS` object so the Three.js module can use it.
 
 2. `mkdir -p .hyperframes` then copy [../templates/design-picker.html](../templates/design-picker.html) to `.hyperframes/pick-design.html`.
 3. Replace these placeholders using Python (don't hand-escape quotes in sed):
@@ -34,15 +207,27 @@ Read these before generating options — they define the rules your options must
 
 ### Architecture data format
 
-Each architecture object must include a `preview_html` field — the HTML that renders in the preview panel. Use token placeholders that the template replaces at runtime: `{{bg}}`, `{{fg}}`, `{{ac}}`, `{{mt}}`, `{{hf}}`, `{{hw}}`, `{{bf}}`, `{{bw}}`, `{{cr}}` (corner radius), `{{pad}}`, `{{gap}}`, `{{shadow}}`, `{{g}}` (grid line color), `{{fg3}}`/`{{fg6}}`/`{{fg8}}`/`{{fg15}}` (fg at opacity), `{{ac3}}`/`{{ac5}}`/`{{ac25}}` (accent at opacity).
+Each architecture object must include a `preview_frames` field — an array of 4 HTML strings, one per beat (hook, proof, action, close). Each frame renders in the mood board card carousel and in the fine-tune scene grid. The template falls back to `[preview_html]` if `preview_frames` is missing, but this produces a single-frame card with no carousel — always provide 4 frames.
+
+Use token placeholders that the template replaces at runtime: `{{bg}}`, `{{fg}}`, `{{ac}}`, `{{mt}}`, `{{hf}}`, `{{hw}}`, `{{bf}}`, `{{bw}}`, `{{cr}}` (corner radius), `{{pad}}`, `{{gap}}`, `{{shadow}}`, `{{g}}` (grid line color), `{{fg3}}`/`{{fg6}}`/`{{fg8}}`/`{{fg15}}` (fg at opacity), `{{ac3}}`/`{{ac5}}`/`{{ac25}}` (accent at opacity).
 
-**Every token must be used.** Apply `{{cr}}` to all cards, buttons, and containers. Apply `{{shadow}}` to elevated elements (cards, buttons, code blocks). Apply `{{pad}}` and `{{gap}}` to control spacing. If a token isn't used in the preview_html, that option will have no visible effect.
+**Use tokens everywhere — never hardcode colors, fonts, spacing, or radii.** The preview updates live as the user changes options in Phase 2. If you write `padding: 80px` instead of `padding: {{pad}}`, changing the density option does nothing. If you write `color: #CC2200` instead of `color: {{ac}}`, changing the palette does nothing. Every color, font-family, font-weight, padding, gap, border-radius, and shadow MUST use tokens. The only exception is structural values like `width: 1920px` or `flex: 1`.
 
-**Density matters.** Each architecture preview must include 15+ distinct elements to give the user a real sense of the layout. Include: headline, subhead, body paragraph, label/overline, stat with number, secondary stat, quote/testimonial, attribution, card with title+body, second card (different treatment), code/command block, primary button, secondary button, list or tags, accent divider/rule, and a data element (table row, progress bar, or chart).
+**Density matches the concept.** The preview should look like a real frame from the actual video — not a UI component showcase. A single-stat direction has 2-3 elements. A data-grid direction has 12+. Match the architecture's intent.
 
-Optionally include `components` (component styling rules) and `dos` (do's and don'ts) as strings — these appear in the generated design.md.
+**Build preview frames like real compositions.** Read [video-composition.md](video-composition.md), [../house-style.md](../house-style.md), and [motion-principles.md](motion-principles.md) when generating preview frame HTML. The frames are static but should look like they were paused mid-animation:
 
-**Layout constraint:** All preview HTML must use percentage widths or `max-width: 100%`. Use `flex-wrap: wrap` on all flex rows. Absolute-positioned decoratives must stay within a parent with `overflow: hidden`.
+- Apply accent color to exactly the focal element per frame
+- Use video-scale typography (80-140px heroes, 24-36px body, 14-20px labels)
+- Respect the density philosophy — high-energy frames earn more elements, contemplative frames earn fewer
+- Each of the 4 frames should represent a distinct beat: hook (grab attention), proof (deliver the message), action (what to do), close (final frame)
+- Use real content from the prompt, not "Headline Goes Here" placeholders
+
+The user judges the entire video based on these 4 frames. If they look generic, the user assumes the video will too.
+
+Optionally include `components` and `dos` as strings — these appear in the generated design.md.
+
+**Layout constraint:** Each frame is 1920×1080px. Content can use flex, grid, absolute positioning — any CSS that works in inline styles. Avoid `max-width: 100%` on frame content (the frame IS 1920px).
 
 **Security:** Architecture `preview_html` must not contain `<script>` tags, event handlers (`onclick`, `onerror`, etc.), or `javascript:` URLs. It is injected via `innerHTML`.
 
@@ -50,6 +235,98 @@ Optionally include `components` (component styling rules) and `dos` (do's and do
 
 **Palette variety:** Always include a mix of light, dark, and tinted backgrounds across the 6 palettes — even for calm/wellness prompts.
 
+### Strict data schemas
+
+The template will crash if these shapes are wrong. Do not deviate.
+
+**Palette object — EXACT field names required:**
+
+```json
+{
+  "name": "Palette Name",
+  "background": "#hex",
+  "foreground": "#hex",
+  "accent": "#hex",
+  "muted": "#hex",
+  "desc": "One-line description"
+}
+```
+
+Fields are `background`, `foreground`, `accent`, `muted`. NOT `bg`/`fg`/`ac`/`mt`. The template reads `p.background`, `p.accent`, etc. — short names will render as `undefined`.
+
+**Type pair object — EXACT field names required:**
+
+```json
+{
+  "name": "Pair Name",
+  "headline": { "family": "Font Name", "weight": 700 },
+  "body": { "family": "Font Name", "weight": 400 },
+  "preview": "The Island Awaits",
+  "body_preview": "Wake with the sun, sleep with the stars.",
+  "desc": "One-line description"
+}
+```
+
+Fields are nested: `headline.family`, `headline.weight`, `body.family`, `body.weight`. NOT `headFont`/`bodyFont`/`headWeight`/`bodyWeight`. The template reads `tp.headline.family` — flat keys will crash.
+
+`preview` is the headline specimen text shown in the type card. `body_preview` is the body specimen text. Both are REQUIRED — without them the cards show "undefined". Use real content from the prompt, not generic lorem ipsum.
+
+**Architecture object — MUST have 4 frames:**
+
+```json
+{
+  "name": "...",
+  "description": "...",
+  "tag": "...",
+  "mood": "...",
+  "bg_preset": "Halo",
+  "preview_frames": [
+    "<div style='...'>Hook frame — grab attention</div>",
+    "<div style='...'>Proof frame — deliver the message</div>",
+    "<div style='...'>Action frame — what to do</div>",
+    "<div style='...'>Close frame — final frame</div>"
+  ]
+}
+```
+
+Field is `preview_frames` (array of 4 HTML strings), NOT `preview_html` (single string). The template renders these as a carousel in Phase 1 and a scene grid in Phase 2. Using `preview_html` produces a single-frame card with no carousel — the user cannot evaluate the video's arc from one frame.
+
+`bg_preset` (optional) is the name of a background preset to pre-select when this mood board is chosen. Must match a name in `BG_PRESETS` (either built-in or custom). Omit for no background.
+
+**Mood board object:**
+
+```json
+{
+  "name": "...",
+  "description": "...",
+  "theme": "dark|light",
+  "arch_index": 0,
+  "palette_index": 0,
+  "type_index": 0,
+  "corners_index": 0,
+  "density_index": 0,
+  "depth_index": 0,
+  "easing_index": 0,
+  "corners": "4px",
+  "padding": "24px",
+  "gap": "16px",
+  "shadow": "0 2px 12px rgba(0,0,0,0.08)"
+}
+```
+
+All `*_index` fields are zero-based indices into their respective arrays (ARCHITECTURES, PALETTES, TYPEPAIRS, CORNERS, DENSITIES, DEPTHS, EASINGS).
+
+**Prompt context object:**
+
+```json
+{
+  "title": "...",
+  "headline": "...",
+  "subline": "...",
+  "section_desc": "..."
+}
+```
+
 ### Example architecture object
 
 ```json
@@ -114,4 +391,13 @@ This makes previews contextual — the user sees their own content styled, not g
 4. Serve the file: `cd <project-dir> && python3 -m http.server 8723 &` (use port 8723 or any unused port above 8000; if the curl check fails, try the next port). Verify: `curl -s -o /dev/null -w "%{http_code}" http://localhost:8723/.hyperframes/pick-design.html` — only share the link if it returns 200. Do NOT use `npx hyperframes preview` for the picker — it blocks. Only start the HTTP server from the main conversation thread. If you are running as a dispatched task or subagent, return the file path and let the caller serve it.
 5. Once the user picks, tell them: "Copy the design.md from the picker and paste it here." The user pastes the markdown back into the conversation. Save it verbatim to `design.md` in the project root — it's already in spec format (YAML frontmatter + prose sections). After the user pastes, kill the background server: `kill %1` or `kill $(lsof -ti:8723)`. Then proceed with construction.
 
-The picker outputs a [google-labs-code/design.md](https://github.com/google-labs-code/design.md) spec-compliant file: YAML frontmatter with `colors`, `typography`, `rounded`, and `spacing` tokens, followed by `## Overview`, `## Colors`, `## Typography`, `## Layout`, `## Elevation`, `## Components`, and `## Do's and Don'ts` prose sections.
+The picker outputs a video-specific design.md — a director's lookbook, not a web component library. YAML frontmatter carries tokens (colors, typography, rounded, spacing, motion). Prose sections cover:
+
+- **Overview** — one paragraph establishing the visual identity
+- **Palette** — every color with its exact role in video (canvas, text, accent, muted) + accent discipline rules
+- **Typography** — role-based table (hero/slam, section, body, label, data) with video-scale sizes (80-140px heroes, 24-36px body)
+- **Surface & Depth** — elevation philosophy, corner radius, background layer treatment, container style
+- **Motion** — entry easing signature, energy level, stagger philosophy, ambient motion rules, number presentation style
+- **Transitions** — primary transition type (60-70% of cuts), accent transition for peak moments, rhythm guidance
+- **Composition** — structure, density philosophy, text-per-second pacing rule, accent placement
+- **Do's and Don'ts** — explicit accent discipline, font rules, size floors, forbidden patterns
diff --git a/skills/hyperframes/references/prompt-expansion.md b/skills/hyperframes/references/prompt-expansion.md
index ab504eee1..e177a3fc5 100644
--- a/skills/hyperframes/references/prompt-expansion.md
+++ b/skills/hyperframes/references/prompt-expansion.md
@@ -21,9 +21,9 @@ If `design.md` doesn't exist yet, run Step 1 (Design system) first. Expansion wi
 
 Even a detailed 7-scene brief lacks things only the expansion adds:
 
-- **Atmosphere layers per scene** (required 2–5 from house-style: radial glows, ghost type, hairline rules, grain, thematic decoratives) — the user's prompt almost never lists these; expansion adds them.
-- **Secondary motion for every decorative** — breath, drift, pulse, orbit. A decorative without ambient motion feels dead.
-- **Micro-details that make a scene feel real** — registration marks, tick indicators, monospace coord labels, typographic accents, code snippets in the background, grid patterns. Things the user didn't think to request.
+- **Atmosphere where the scene earns it** — a radial glow, ghost text, or grain texture can add depth. But a scene built around one powerful element doesn't need decoration. Add atmosphere to serve the mood, not to fill emptiness.
+- **Motion that serves pacing** — ambient motion keeps scenes alive during the breathe phase. But stillness is also a tool. Not every element needs to move.
+- **Micro-details sparingly** — registration marks, monospace labels, structural rules. These earn their place in data-dense or technical scenes. In a contemplative scene, they're clutter.
 - **Transition choreography at the object level** — not "crossfade" but "X expands outward and becomes Y". Specific duration, ease, and morph source/target.
 - **Pacing beats within each scene** — where tension builds, where a hold lets the viewer breathe, where the accent word lands.
 - **Exact hex values, typography parameters, ease choices** from design.md — no vagueness left for the scene subagent to guess.
@@ -47,7 +47,7 @@ Expand into a full production prompt with these sections:
 4. **Per-scene beats** — for each scene, use the beat-direction format:
    - **Concept** — the big idea in 2-3 sentences. What visual WORLD? What metaphor? What should the viewer FEEL?
    - **Mood direction** — cultural/design references, not hex codes. ("Bauhaus color studies", "cinematic title sequence", "editorial calm")
-   - **Depth layers** — BG (2-5 decoratives with ambient motion), MG (content), FG (accents, structural elements, micro-details). 8-10 total elements per scene per video-composition.md.
+   - **Depth layers** — BG (atmosphere), MG (content), FG (accents). Density matches the beat — a SLAM might have one element; a proof scene might have a data grid. Don't pad sparse scenes with decoratives just to hit a count.
    - **Animation choreography** — specific verbs per element. High: SLAMS, CRASHES. Medium: CASCADE, SLIDES. Low: floats, types on, counts up. Every element gets a verb. If you can't name the verb, the element is not yet designed.
    - **Transition out** — shader or CSS, with specific type and parameters. Not "crossfade" but "blur crossfade, 0.4s, power2.inOut."
 
diff --git a/skills/hyperframes/references/shader-backgrounds.md b/skills/hyperframes/references/shader-backgrounds.md
new file mode 100644
index 000000000..bb861b450
--- /dev/null
+++ b/skills/hyperframes/references/shader-backgrounds.md
@@ -0,0 +1,173 @@
+# Shader Backgrounds
+
+WebGL fragment shaders as living, breathing scene backgrounds. Each composition can have a contextual shader that renders behind the content.
+
+## Noise Library
+
+Include this in every shader. It provides gradient noise (no grid artifacts), FBM, and domain warping.
+
+```glsl
+precision highp float;
+uniform float u_time;
+uniform vec2 u_res;
+
+vec2 h2(vec2 p) {
+  p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+  return -1.0 + 2.0 * fract(sin(p) * 43758.5453);
+}
+
+float gn(vec2 p) {
+  vec2 i = floor(p), f = fract(p);
+  vec2 u = f*f*f*(f*(f*6.0-15.0)+10.0); // quintic smoothstep
+  return mix(
+    mix(dot(h2(i), f), dot(h2(i+vec2(1,0)), f-vec2(1,0)), u.x),
+    mix(dot(h2(i+vec2(0,1)), f-vec2(0,1)), dot(h2(i+vec2(1,1)), f-vec2(1,1)), u.x),
+    u.y
+  );
+}
+
+// FBM with rotated octaves — prevents directional banding
+float fbm(vec2 p) {
+  float v = 0.0, a = 0.5;
+  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);
+  for (int i = 0; i < 6; i++) { v += a * gn(p); p = r * p * 2.0 + vec2(1.7, 9.2); a *= 0.5; }
+  return v;
+}
+
+// Lighter FBM for secondary detail
+float fbm4(vec2 p) {
+  float v = 0.0, a = 0.5;
+  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);
+  for (int i = 0; i < 4; i++) { v += a * gn(p); p = r * p * 2.0 + vec2(1.7, 9.2); a *= 0.5; }
+  return v;
+}
+```
+
+## Domain Warping
+
+The single most important technique for natural-looking shaders. Feed noise into noise:
+
+```glsl
+// Single warp — organic but recognizable as noise
+vec2 q = vec2(fbm(uv * 2.0 + vec2(t * 0.3, t * 0.1)),
+              fbm(uv * 2.0 + vec2(t * 0.1, t * 0.4) + 5.0));
+float f = fbm(uv * 1.5 + q * 1.5);
+
+// Double warp — painterly, flowing, no visible noise pattern
+vec2 q = vec2(fbm(uv * 2.0 + vec2(t * 0.3, t * 0.1)),
+              fbm(uv * 2.0 + vec2(t * 0.1, t * 0.4) + 5.0));
+vec2 r = vec2(fbm(uv * 3.0 + q * 3.0 + vec2(1.7, t * 0.15)),
+              fbm(uv * 3.0 + q * 3.0 + vec2(8.3, t * 0.2)));
+float f = fbm(uv * 2.0 + r * 1.5);
+
+// Triple warp — truly organic, like real fluid dynamics
+vec2 q = ...; // as above
+vec2 r = ...; // as above
+vec2 s = vec2(fbm(uv * 1.0 + r * 2.0 + vec2(3.1, t * 0.05)),
+              fbm(uv * 1.0 + r * 2.0 + vec2(6.7, t * 0.03)));
+float f = fbm(uv * 1.5 + s * 1.5);
+```
+
+## Shader Patterns by Context
+
+### Warm / Travel / Lifestyle
+
+**Gradient Mesh** — flowing color blobs:
+
+```glsl
+// 5 blobs with gaussian falloff, noise-warped edges
+vec2 c1 = vec2(0.3 + sin(t*0.7)*0.15, 0.7 + cos(t*0.5)*0.12);
+float w1 = exp(-pow(length(uv - c1 + warp) * 2.5, 2.0));
+// ... repeat for each blob, weighted blend of colors
+col = (color1*w1 + color2*w2 + ...) / (w1+w2+...+0.001);
+```
+
+**Warm Caustics** — golden light on cream:
+
+```glsl
+// Double domain warp, then map to warm palette
+float c = smoothstep(0.2, 0.8, f * 0.5 + 0.5);
+vec3 col = mix(cream, gold, pow(c, 2.0) * 0.3);
+```
+
+**Sunset Horizon** — sky gradient + clouds + water reflection. Use 5+ color stops for the sky, FBM clouds with bottom-lit coloring, water below with noise-broken sun reflection.
+
+### Medical / Emergency / PSA
+
+**Biohazard Pulse** — expanding rings from center:
+
+```glsl
+for (int i = 0; i < 3; i++) {
+  float phase = fract(t * 0.3 + float(i) * 0.33);
+  float ring = abs(dist - phase * 0.7) * 30.0;
+  col += dangerColor * exp(-ring*ring) * (1.0 - phase) * 0.4;
+}
+```
+
+**Clinical Sterile** — bright white + scan line + faint grid:
+
+```glsl
+float scanY = fract(t * 0.04);
+float scan = exp(-abs(uv.y - scanY) * 100.0) * 0.08;
+float grid = max(
+  smoothstep(0.49, 0.5, fract(uv.x * 60.0)),
+  smoothstep(0.49, 0.5, fract(uv.y * 35.0))
+);
+```
+
+**Microscopic** — floating particles with membrane rings:
+
+```glsl
+float cell = exp(-pd*pd/(size*size)) * 0.2;
+float membrane = exp(-pow(abs(pd-size)*40.0, 2.0)) * 0.15;
+```
+
+**Respiratory** — breathing cycle with UV warp:
+
+```glsl
+float breath = sin(t * 0.8) * 0.5 + 0.5;
+vec2 dir = uv - center;
+vec2 warped = center + dir * (1.0 + breath * 0.04 * exp(-length(dir) * 2.0));
+```
+
+### Tech / Data / Product
+
+**Data Grid** — subtle flowing grid with accent-colored intersections. Use `fract()` for grid lines, noise for line brightness variation.
+
+**Terminal Glow** — dark base with green/blue accent scan. Monospace character rain (use noise thresholds to place bright dots in grid positions).
+
+### Industrial / Manufacturing
+
+**Heat Distortion** — UV warp increasing toward bottom:
+
+```glsl
+float heat = pow(1.0 - uv.y, 1.5);
+warped.x += sin(uv.y * 30.0 + t * 8.0) * 0.003 * heat;
+```
+
+**Warning Stripe** — diagonal hazard bands at edges:
+
+```glsl
+float stripe = sin((uv.x + uv.y) * 40.0) > 0.3 ? 1.0 : 0.0;
+float bandMask = max(smoothstep(0.88, 0.92, uv.y), smoothstep(0.12, 0.08, uv.y));
+```
+
+## Integration
+
+### In the picker
+
+Each architecture's `preview_frames` can include a `<canvas>` element with inline GLSL. The canvas renders behind the frame content. Use the picker's accent color as a uniform.
+
+### In the composition
+
+The design.md `## Background` section describes the shader for the composition agent to implement. Include:
+
+- Effect name and visual description
+- Key GLSL techniques used (domain warp level, pattern type)
+- Color palette mapping (which design.md colors map to which shader roles)
+- Movement speed and character
+- How the shader integrates with content (behind, overlay, mask)
+
+### In rendering
+
+Shaders use `u_time` as their only time input — compatible with GSAP timeline seeking. The capture engine advances `u_time` per frame for deterministic output. No `Math.random()`, no `Date.now()`.
diff --git a/skills/hyperframes/references/video-composition.md b/skills/hyperframes/references/video-composition.md
index e0758eba0..87197add2 100644
--- a/skills/hyperframes/references/video-composition.md
+++ b/skills/hyperframes/references/video-composition.md
@@ -12,15 +12,15 @@ design.md defines what the brand looks like: colors, fonts, personality, constra
 
 ## Density
 
-A beat with 3 elements looks empty. A beat with 8-10 feels alive.
+Density is a creative choice, not a minimum. A single number filling the frame can be more powerful than 10 elements competing for attention. An empty frame with one element appearing creates tension a busy frame can't.
 
-Every scene needs:
+Think in layers, not counts:
 
-- **Background texture** — radial glow, oversized ghost type, color panel, grain, grid. Never solid flat color.
-- **Midground content** — the actual message. Cards, stats, code blocks, images.
-- **Foreground accents** — dividers, labels, data bars, registration marks, monospace metadata. The details that make it feel produced, not generated.
+- **Background** — texture, color, atmosphere. Can be a solid color if that serves the scene.
+- **Content** — the actual message. Could be one word or a data table.
+- **Accents** — structural elements that guide the eye. Optional — not every scene needs them.
 
-Aim for 8-10 visual elements per scene. Two of those should be decorative elements the user didn't ask for — you add them because empty frames look broken.
+The default failure mode is too sparse (flat background, centered text, no depth). But the overcorrection — cramming decoratives into every frame — is equally bad. Match density to the scene's emotional beat: high-energy scenes earn more elements; contemplative moments earn fewer.
 
 ## Color Presence
 
@@ -49,14 +49,14 @@ If you're writing a font-size under 24px in a video composition, justify it. If
 
 Subtle reads as static at 30fps. Err toward more movement than feels safe.
 
-- Every decorative element should have ambient motion: breathe, drift, pulse, orbit. Static decoratives feel dead.
+- Decorative elements usually need ambient motion: breathe, drift, pulse, orbit. But deliberate stillness after motion is powerful — don't animate something just because it exists.
 - Vary motion per scene — don't repeat the same ambient pattern.
 - Scene entrances should use 3+ different eases and directions. If every element enters from `y: 30, opacity: 0`, the scene has no choreography.
 
 ## Frame Composition
 
-- **Two focal points minimum.** The eye needs somewhere to travel.
-- **Fill the frame.** Hero text: 60-80% of frame width.
+- **Focal hierarchy.** The eye needs to know where to land first. Sometimes that's two competing elements; sometimes it's one dominating element with nothing else. Both work — what doesn't work is everything at equal weight.
+- **Use the frame.** Content can fill 80% of the width or occupy one corner — both are valid compositions. What looks broken is content floating in the center with equal margins on all sides, the default web layout.
 - **Anchor to edges.** Pin content to left/top or right/bottom. Centered-and-floating is a web layout pattern.
 - **Split frames.** Data panel left, content right. Top bar with metadata, full-width below. Zone-based layouts over centered stacks.
 - **Structural elements.** Rules, dividers, border panels. They create visual paths and animate well (`scaleX: 0` → `1`).
diff --git a/skills/hyperframes/templates/design-picker.html b/skills/hyperframes/templates/design-picker.html
index 6cb6f0878..ab744448e 100644
--- a/skills/hyperframes/templates/design-picker.html
+++ b/skills/hyperframes/templates/design-picker.html
@@ -5,6 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Design your visual direction</title>
     <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/CustomEase.min.js"></script>
+    <script type="importmap">{"imports":{"three":"https://cdn.jsdelivr.net/npm/three@0.167.0/build/three.module.js"}}</script>
     <style>
       * {
         margin: 0;
@@ -67,12 +69,13 @@
       /* ── Phase 1: Mood boards ── */
       .mood-grid {
         display: grid;
-        grid-template-columns: repeat(auto-fill, minmax(380px, 1fr));
+        grid-template-columns: repeat(3, minmax(0, 420px));
         gap: 16px;
         padding: 20px;
         overflow-y: auto;
         flex: 1;
-        align-content: start;
+        align-content: center;
+        justify-content: center;
       }
       .mood-card {
         border: 1px solid #1e1e1e;
@@ -84,8 +87,6 @@
           transform 0.15s,
           box-shadow 0.15s;
         background: #141414;
-        display: flex;
-        flex-direction: column;
       }
       .mood-card:hover {
         border-color: #333;
@@ -96,16 +97,69 @@
         border-color: #fff;
       }
       .mood-preview {
-        height: 500px;
+        aspect-ratio: 16/9;
         overflow: hidden;
         position: relative;
         background: #0a0a0a;
       }
-      .mood-preview > div {
+      .mood-frame {
         transform-origin: top left;
+        width: 1920px;
+        height: 1080px;
+        position: absolute;
+        top: 0;
+        left: 0;
+        opacity: 0;
+        transition: opacity 0.25s;
+        z-index: 1;
       }
+      .mood-frame.active { opacity: 1; }
+      .mood-arrow {
+        position: absolute;
+        top: 50%;
+        transform: translateY(-50%);
+        width: 28px;
+        height: 28px;
+        background: rgba(0,0,0,0.6);
+        border: 1px solid rgba(255,255,255,0.15);
+        border-radius: 50%;
+        color: #fff;
+        font-size: 13px;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        opacity: 0;
+        transition: opacity 0.15s;
+        z-index: 10;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .mood-preview:hover .mood-arrow { opacity: 1; }
+      .mood-arrow:hover { background: rgba(0,0,0,0.8); border-color: rgba(255,255,255,0.3); }
+      .mood-arrow.left { left: 8px; }
+      .mood-arrow.right { right: 8px; }
+      .mood-dots {
+        position: absolute;
+        bottom: 8px;
+        left: 50%;
+        transform: translateX(-50%);
+        display: flex;
+        gap: 5px;
+        z-index: 10;
+        opacity: 0;
+        transition: opacity 0.15s;
+      }
+      .mood-preview:hover .mood-dots { opacity: 1; }
+      .mood-dot {
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        background: rgba(255,255,255,0.25);
+      }
+      .mood-dot.active { background: #fff; }
       .mood-info {
-        padding: 14px 16px;
+        display: none;
       }
       .mood-name {
         font-size: 14px;
@@ -193,10 +247,195 @@
         overflow-x: hidden;
         background: #0e0e0e;
       }
-      .panel-right * {
+      .panel-right > *:not(.showcase) {
         max-width: 100%;
         box-sizing: border-box;
       }
+      .showcase *, .showcase *::before, .showcase *::after {
+        box-sizing: border-box;
+      }
+      .scene-frame, .scene-frame * {
+        max-width: none !important;
+      }
+
+      /* ── Showcase ── */
+      .showcase {
+        padding: 0;
+        --sc-bg: #0e0e0e;
+        --sc-fg: #eee;
+        --sc-ac: #888;
+        --sc-mt: #555;
+      }
+      .showcase-section {
+        padding: 48px 40px;
+        border-bottom: 1px solid var(--sc-mt, #1a1a1a);
+        background: var(--sc-bg);
+        color: var(--sc-fg);
+      }
+      .showcase-eyebrow {
+        font-size: 11px;
+        font-weight: 500;
+        letter-spacing: 0.5px;
+        text-transform: uppercase;
+        color: var(--sc-ac);
+        margin: 0 0 12px;
+        font-family: ui-monospace, "SF Mono", monospace;
+      }
+      .showcase-heading {
+        font-size: 22px;
+        font-weight: 600;
+        color: var(--sc-fg);
+        margin: 0 0 8px;
+        letter-spacing: -0.02em;
+      }
+      .showcase-lead {
+        font-size: 13px;
+        line-height: 1.6;
+        color: var(--sc-mt);
+        margin: 0 0 24px;
+        max-width: 600px;
+      }
+
+      /* Palette swatches */
+      .swatch-grid { display: flex; gap: 12px; flex-wrap: wrap; }
+      .swatch-card {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        padding: 10px 14px;
+        background: rgba(128,128,128,0.06);
+        border: 1px solid rgba(128,128,128,0.12);
+        border-radius: 8px;
+        min-width: 180px;
+      }
+      .swatch-chip {
+        width: 36px;
+        height: 36px;
+        border-radius: 6px;
+        flex-shrink: 0;
+        border: 1px solid rgba(128,128,128,0.1);
+      }
+      .swatch-name { font-size: 13px; font-weight: 600; color: var(--sc-fg); }
+      .swatch-hex { font-size: 11px; color: var(--sc-mt); font-family: ui-monospace, monospace; }
+      .swatch-role { font-size: 11px; color: var(--sc-mt); margin-top: 2px; opacity: 0.7; }
+
+      /* Type specimens */
+      .type-specimen-row {
+        display: flex;
+        gap: 20px;
+        padding: 16px 0;
+        border-bottom: 1px solid rgba(128,128,128,0.1);
+        align-items: baseline;
+      }
+      .type-meta {
+        width: 120px;
+        flex-shrink: 0;
+        font-size: 11px;
+        color: var(--sc-mt);
+        font-family: ui-monospace, monospace;
+        line-height: 1.4;
+      }
+      .type-meta strong { color: var(--sc-ac); display: block; margin-bottom: 2px; }
+      .type-sample { flex: 1; color: var(--sc-fg); }
+
+      /* Scene grid */
+      .scene-grid {
+        display: grid;
+        grid-template-columns: repeat(2, 1fr);
+        gap: 6px;
+      }
+      .scene-cell {
+        position: relative;
+        overflow: hidden;
+        border-radius: 6px;
+        aspect-ratio: 16/9;
+        border: 1px solid rgba(128,128,128,0.12);
+      }
+      .scene-cell-label {
+        position: absolute;
+        top: 6px;
+        left: 8px;
+        font-size: 9px;
+        color: var(--sc-mt);
+        font-family: ui-monospace, monospace;
+        letter-spacing: 0.5px;
+        text-transform: uppercase;
+        z-index: 2;
+      }
+      .scene-frame {
+        width: 1920px;
+        height: 1080px;
+        transform-origin: top left;
+        position: absolute;
+        top: 0;
+        left: 0;
+      }
+
+      /* Motion preview */
+      .ease-preview-track {
+        width: 100%;
+        height: 48px;
+        position: relative;
+      }
+      .ease-preview-dot {
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        position: absolute;
+        top: 8px;
+        left: 10px;
+      }
+
+      /* Elevation */
+      .elevation-grid { display: flex; gap: 12px; flex-wrap: wrap; }
+      .elevation-card {
+        width: 140px;
+        height: 80px;
+        border-radius: 6px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        gap: 4px;
+        font-size: 11px;
+      }
+      .elevation-label { font-size: 10px; color: var(--sc-mt); }
+
+      /* Radius */
+      .radius-grid { display: flex; gap: 16px; flex-wrap: wrap; align-items: flex-end; }
+      .radius-chip-preview {
+        width: 48px;
+        height: 48px;
+        border: 1px solid var(--sc-mt);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+      .radius-label { font-size: 10px; color: var(--sc-mt); text-align: center; margin-top: 4px; font-family: ui-monospace, monospace; }
+
+      .tune-grid {
+        display: grid;
+        grid-template-columns: repeat(2, 1fr);
+        gap: 4px;
+        padding: 8px;
+        width: 100%;
+        max-height: calc(100vh - 45px);
+        align-content: center;
+      }
+      .tune-cell {
+        position: relative;
+        overflow: hidden;
+        border-radius: 6px;
+        aspect-ratio: 16/9;
+      }
+      .tune-frame {
+        width: 1920px;
+        height: 1080px;
+        transform-origin: top left;
+        position: absolute;
+        top: 0;
+        left: 0;
+      }
 
       /* ── Section cards (Neuform-inspired) ── */
       .section-card {
@@ -466,6 +705,102 @@
         font-family: "SF Mono", Consolas, monospace;
         letter-spacing: 0.02em;
       }
+      #shader-editor input[type="color"] {
+        padding: 0;
+        border-radius: 4px;
+        cursor: pointer;
+      }
+      .bezier-editor {
+        border: 1px solid #1e1e1e;
+        border-radius: 10px;
+        margin-bottom: 6px;
+        cursor: pointer;
+        background: #141414;
+        padding: 14px;
+        transition: border-color 0.12s;
+      }
+      .bezier-editor:hover { border-color: #333; }
+      .bezier-editor.selected { border-color: #fff; }
+      .bezier-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 10px;
+      }
+      .bezier-header .ease-name { font-size: 11px; font-weight: 600; }
+      .bezier-header .ease-value {
+        font-size: 9px;
+        color: #444;
+        font-family: "SF Mono", Consolas, monospace;
+      }
+      .bezier-canvas-wrap {
+        position: relative;
+        width: 100%;
+        aspect-ratio: 1;
+        overflow: visible;
+        cursor: crosshair;
+      }
+      .bezier-canvas-wrap canvas {
+        width: 100%;
+        height: 100%;
+        display: block;
+      }
+      .bezier-handle {
+        position: absolute;
+        width: 12px;
+        height: 12px;
+        border-radius: 50%;
+        border: 2px solid #4e7fff;
+        background: #0e0e0e;
+        cursor: grab;
+        transform: translate(-50%, -50%);
+        z-index: 2;
+      }
+      .bezier-handle:hover, .bezier-handle.dragging {
+        background: #4e7fff;
+        cursor: grabbing;
+      }
+      .bezier-anchor {
+        position: absolute;
+        width: 12px;
+        height: 12px;
+        border: 2px solid #4e7fff;
+        background: #fff;
+        cursor: grab;
+        transform: translate(-50%, -50%) rotate(45deg);
+        z-index: 3;
+      }
+      .bezier-anchor:hover, .bezier-anchor.dragging {
+        background: #4e7fff;
+        cursor: grabbing;
+      }
+      .bezier-anchor.selected {
+        background: #4e7fff;
+      }
+      .bezier-hint {
+        font-size: 9px;
+        color: #555;
+        margin-top: 6px;
+        line-height: 1.3;
+      }
+      .bezier-track {
+        position: relative;
+        height: 8px;
+        background: #1a1a1a;
+        border-radius: 4px;
+        margin-top: 10px;
+        overflow: visible;
+      }
+      .bezier-dot {
+        position: absolute;
+        top: 50%;
+        transform: translateY(-50%);
+        left: 0;
+        width: 12px;
+        height: 12px;
+        border-radius: 50%;
+        background: #fff;
+      }
 
       .preview-empty {
         display: flex;
@@ -671,6 +1006,36 @@ <h2 id="mood-title">Pick a direction</h2>
           </div>
           <div class="section-body"><div class="chips" id="theme-options"></div></div>
         </div>
+        <!-- Background / Shader Editor -->
+        <div class="section-card" id="bg-section">
+          <div class="section-header">
+            <div class="section-icon">◈</div>
+            <div class="section-title">Background</div>
+          </div>
+          <div class="section-body">
+            <div class="chips" id="bg-options"></div>
+            <div id="shader-editor" style="display:none;margin-top:10px;">
+              <div style="display:flex;gap:8px;margin-bottom:8px;">
+                <label style="flex:1;font-size:10px;color:#666;">
+                  Color 1
+                  <input type="color" id="se-c1" value="#f7f4ef" style="width:100%;height:24px;border:none;background:none;cursor:pointer;">
+                </label>
+                <label style="flex:1;font-size:10px;color:#666;">
+                  Color 2
+                  <input type="color" id="se-c2" value="#2a9d8f" style="width:100%;height:24px;border:none;background:none;cursor:pointer;">
+                </label>
+                <label style="flex:1;font-size:10px;color:#666;">
+                  Color 3
+                  <input type="color" id="se-c3" value="#7a8b8d" style="width:100%;height:24px;border:none;background:none;cursor:pointer;">
+                </label>
+              </div>
+              <label style="display:flex;align-items:center;gap:8px;cursor:pointer;font-size:10px;color:#666;margin-bottom:8px;">
+                <input type="checkbox" id="se-use-palette" checked style="accent-color:#fff;"> Use palette colors
+              </label>
+              <div id="se-controls"></div>
+            </div>
+          </div>
+        </div>
         <!-- Structure -->
         <div class="section-card">
           <div class="section-header">
@@ -707,7 +1072,7 @@ <h2 id="mood-title">Pick a direction</h2>
         <!-- Density -->
         <div class="section-card">
           <div class="section-header">
-            <div class="section-icon">≡</div>
+            <div class="section-icon">▦</div>
             <div class="section-title">Density</div>
           </div>
           <div class="section-body"><div class="chips" id="density-options"></div></div>
@@ -732,17 +1097,67 @@ <h2 id="mood-title">Pick a direction</h2>
       </div>
       <div class="panel-right" id="preview">
         <div class="preview-empty">Pick a structure to preview</div>
+        <div class="showcase" id="showcase" style="display:none;">
+
+          <div class="showcase-section" id="sc-overview">
+            <div class="showcase-eyebrow">/ 01 / Overview</div>
+            <h2 class="showcase-heading" id="sc-overview-title"></h2>
+            <p class="showcase-lead" id="sc-overview-lead"></p>
+          </div>
+
+          <div class="showcase-section" id="sc-scenes">
+            <div class="showcase-eyebrow">/ 02 / Composition</div>
+            <h2 class="showcase-heading">Scene Frames</h2>
+            <p class="showcase-lead">Four key moments — hook, proof, action, close.</p>
+            <div class="scene-grid" id="sc-scene-grid"></div>
+          </div>
+
+          <div class="showcase-section" id="sc-palette">
+            <div class="showcase-eyebrow">/ 03 / Palette</div>
+            <h2 class="showcase-heading">Color Palette</h2>
+            <p class="showcase-lead" id="sc-palette-lead"></p>
+            <div class="swatch-grid" id="sc-swatches"></div>
+          </div>
+
+          <div class="showcase-section" id="sc-type">
+            <div class="showcase-eyebrow">/ 04 / Typography</div>
+            <h2 class="showcase-heading">Typography Scale</h2>
+            <p class="showcase-lead" id="sc-type-lead"></p>
+            <div id="sc-type-specimens"></div>
+          </div>
+
+          <div class="showcase-section" id="sc-radius">
+            <div class="showcase-eyebrow">/ 05 / Corners</div>
+            <h2 class="showcase-heading">Border Radius</h2>
+            <div class="radius-grid" id="sc-radius-grid"></div>
+          </div>
+
+          <div class="showcase-section" id="sc-elevation">
+            <div class="showcase-eyebrow">/ 06 / Depth</div>
+            <h2 class="showcase-heading">Elevation</h2>
+            <p class="showcase-lead" id="sc-elevation-lead"></p>
+            <div class="elevation-grid" id="sc-elevation-grid"></div>
+          </div>
+
+          <div class="showcase-section" id="sc-motion">
+            <div class="showcase-eyebrow">/ 07 / Motion</div>
+            <h2 class="showcase-heading">Motion Personality</h2>
+            <p class="showcase-lead" id="sc-motion-lead"></p>
+            <div id="sc-ease-preview"></div>
+          </div>
+
+        </div>
       </div>
     </div>
 
-    <button class="fab" id="fab" onclick="showOutput()">Create design.md</button>
+    <button class="fab" id="fab" onclick="showOutput()">Create design.html</button>
 
     <div class="md-overlay" id="md-overlay">
       <div class="md-card">
         <div class="md-header">
           <div class="md-title">
-            design.md
-            <span style="font-size: 11px; font-weight: 400; color: #555">— edit, then copy</span>
+            design.html
+            <span style="font-size: 11px; font-weight: 400; color: #555">— copy and paste back</span>
           </div>
           <div class="md-actions">
             <button class="copy-btn" id="copy-btn">Copy</button>
@@ -775,6 +1190,7 @@ <h2 id="mood-title">Pick a direction</h2>
         density: null,
         depth: null,
         easing: null,
+        bg_mode: null,
       };
 
       var EASINGS = [
@@ -844,7 +1260,7 @@ <h2 id="mood-title">Pick a direction</h2>
       var palBar = document.getElementById("pal-bar");
       PALETTES.forEach(function (p, i) {
         var chip = document.createElement("div");
-        chip.className = "pal-bar-chip" + (i === 0 ? "" : "");
+        chip.className = "pal-bar-chip";
         chip.innerHTML =
           '<div class="pal-bar-chip-swatches"><div class="pal-bar-chip-swatch" style="background:' +
           p.background +
@@ -912,25 +1328,33 @@ <h2 id="mood-title">Pick a direction</h2>
             "{{prompt_headline}}": (PROMPT && PROMPT.headline) || "Your Headline",
             "{{prompt_sub}}": (PROMPT && PROMPT.subline) || "A subline for your product.",
           };
-          var preview = arch.preview_html || "";
-          Object.keys(tokens).forEach(function (k) {
-            preview = preview.split(k).join(tokens[k]);
-          });
-          var tagHtml = [tp.headline.family, pal.name, CORNERS[mb.corners_index || 1].name]
-            .map(function (t) {
-              return '<span class="mood-token">' + t + "</span>";
-            })
-            .join("");
-          card.innerHTML =
-            '<div class="mood-preview"><div style="transform:scale(0.38);transform-origin:top left;width:263.16%;min-height:263.16%;">' +
-            preview +
-            '</div></div><div class="mood-info"><div class="mood-name">' +
-            mb.name +
-            '</div><div class="mood-desc">' +
-            mb.description +
-            '</div><div class="mood-tokens">' +
-            tagHtml +
-            "</div></div>";
+          var frames = arch.preview_frames || [arch.preview_html || ""];
+          var framesHtml = frames.map(function (f, fi) {
+            var resolved = f || "";
+            Object.keys(tokens).forEach(function (k) {
+              resolved = resolved.split(k).join(tokens[k]);
+            });
+            return '<div class="mood-frame' + (fi === 0 ? ' active' : '') + '">' + resolved + '</div>';
+          }).join("");
+          var dotsHtml = frames.length > 1 ? '<div class="mood-dots">' + frames.map(function (_, di) {
+            return '<div class="mood-dot' + (di === 0 ? ' active' : '') + '"></div>';
+          }).join("") + '</div>' : '';
+          var arrowsHtml = frames.length > 1 ? '<div class="mood-arrow left">‹</div><div class="mood-arrow right">›</div>' : '';
+          card.innerHTML = '<div class="mood-preview" style="background:' + bg + ';">' + framesHtml + arrowsHtml + dotsHtml + '</div>';
+
+          if (frames.length > 1) {
+            (function(cardEl, count) {
+              var idx = 0;
+              var prev = cardEl.querySelector('.mood-preview');
+              function show(n) {
+                idx = (n + count) % count;
+                prev.querySelectorAll('.mood-frame').forEach(function(f,fi) { f.classList.toggle('active', fi === idx); });
+                prev.querySelectorAll('.mood-dot').forEach(function(d,di) { d.classList.toggle('active', di === idx); });
+              }
+              prev.querySelector('.mood-arrow.left').onclick = function(e) { e.stopPropagation(); show(idx - 1); };
+              prev.querySelector('.mood-arrow.right').onclick = function(e) { e.stopPropagation(); show(idx + 1); };
+            })(card, frames.length);
+          }
           card.onclick = function () {
             moodGrid.querySelectorAll(".mood-card").forEach(function (c) {
               c.classList.remove("selected");
@@ -941,8 +1365,20 @@ <h2 id="mood-title">Pick a direction</h2>
           };
           moodGrid.appendChild(card);
         });
+        scaleMoodPreviews();
       }
       renderMoodBoards();
+      function scaleMoodPreviews() {
+        document.querySelectorAll(".mood-preview").forEach(function (p) {
+          var s = p.offsetWidth / 1920;
+          p.querySelectorAll(".mood-frame").forEach(function (f) {
+            f.style.transform = "scale(" + s + ")";
+          });
+        });
+      }
+      window.addEventListener("resize", scaleMoodPreviews);
+
+      // ── Removed: procedural canvas backgrounds ──
 
       var currentPhase = "mood";
       function showPhase(name) {
@@ -978,6 +1414,18 @@ <h2 id="mood-title">Pick a direction</h2>
           chipSel("density", mb.density_index, document.getElementById("density-options"));
         if (mb.depth_index != null)
           chipSel("depth", mb.depth_index, document.getElementById("depth-options"));
+        // Pre-fill background from architecture
+        var arch = ARCHITECTURES[mb.arch_index || 0];
+        var bgIdx = 0;
+        if (arch.bg_preset) {
+          for (var si = 0; si < BG_PRESETS.length; si++) {
+            if (BG_PRESETS[si].name === arch.bg_preset) { bgIdx = si; break; }
+          }
+        }
+        chipSel("bg_mode", bgIdx, document.getElementById("bg-options"));
+        shaderEditor.style.display = bgIdx > 0 ? "block" : "none";
+        renderBgControls(bgIdx > 0 ? BG_PRESETS[bgIdx] : null);
+
         var eIdx = mb.easing_index != null ? mb.easing_index : 0;
         var eOpts = document.getElementById("ease-options");
         eOpts.querySelectorAll(".ease-opt").forEach(function (c) {
@@ -987,6 +1435,7 @@ <h2 id="mood-title">Pick a direction</h2>
         picks.easing = eIdx;
         document.getElementById("tab-tune").classList.remove("disabled");
         showPhase("tune");
+        renderPreview();
       }
 
       // ── Phase 2: Build options ──
@@ -1157,6 +1606,7 @@ <h2 id="mood-title">Pick a direction</h2>
         depthOpts.appendChild(el);
       });
 
+
       // Easing options with GSAP animation
       var easeOpts = document.getElementById("ease-options");
       EASINGS.forEach(function (e, i) {
@@ -1179,6 +1629,7 @@ <h2 id="mood-title">Pick a direction</h2>
           el.classList.add("selected");
           picks.easing = i;
           checkReady();
+          renderPreview();
         };
         easeOpts.appendChild(el);
         // Animate the dot with GSAP
@@ -1192,17 +1643,420 @@ <h2 id="mood-title">Pick a direction</h2>
         });
       });
 
-      function chipSel(key, idx, container) {
-        container.querySelectorAll(".chip").forEach(function (c) {
-          c.classList.remove("selected");
+      // ── Custom Ease Editor (GSAP CustomEase, multi-waypoint) ──
+      (function() {
+        var customIdx = EASINGS.length;
+        var initPath = "M0,0 C0.126,0.382 0.282,0.674 0.44,0.822 0.632,1.002 0.818,1.001 1,1";
+        EASINGS.push({ name: "Custom", value: initPath, desc: "Click curve to add points, drag to shape" });
+        if (typeof CustomEase !== "undefined") { gsap.registerPlugin(CustomEase); CustomEase.create("_pickerCustom", initPath); }
+
+        // Anchors: [{x,y,ox,oy,ix,iy}] — ox/oy = outgoing handle, ix/iy = incoming handle (absolute coords, 0-1 normalized, y=0 is bottom)
+        var anchors = [
+          { x: 0, y: 0, ox: 0.126, oy: 0.382, ix: 0, iy: 0 },
+          { x: 0.44, y: 0.822, ox: 0.632, oy: 1.002, ix: 0.282, iy: 0.674 },
+          { x: 1, y: 1, ox: 1, oy: 1, ix: 0.818, iy: 1.001 }
+        ];
+        var selectedAnchor = -1;
+
+        var wrap = document.createElement("div");
+        wrap.className = "bezier-editor";
+        wrap.innerHTML =
+          '<div class="bezier-header"><div class="ease-name">Custom</div><div class="ease-value" id="bezier-value" style="font-size:8px;word-break:break-all;max-height:28px;overflow:hidden;">' + initPath + '</div></div>' +
+          '<div class="bezier-canvas-wrap" id="bezier-wrap"><canvas id="bezier-canvas"></canvas></div>' +
+          '<div class="bezier-hint">Click curve to add point · Select + Delete to remove · Drag handles to shape</div>' +
+          '<div class="bezier-track"><div class="bezier-dot" id="bezier-dot"></div></div>';
+
+        wrap.addEventListener("click", function(e) {
+          if (e.target.closest(".bezier-canvas-wrap") || e.target.closest(".bezier-anchor") || e.target.closest(".bezier-handle")) return;
+          selectCustom();
         });
-        container.children[idx].classList.add("selected");
-        picks[key] = idx;
-        checkReady();
-        renderPreview();
+        easeOpts.appendChild(wrap);
+
+        var canvas = document.getElementById("bezier-canvas");
+        var bwrap = document.getElementById("bezier-wrap");
+        var valEl = document.getElementById("bezier-value");
+        var dotEl = document.getElementById("bezier-dot");
+        var handles = []; // DOM elements for handles/anchors
+
+        function selectCustom() {
+          easeOpts.querySelectorAll(".ease-opt").forEach(function(c) { c.classList.remove("selected"); });
+          wrap.classList.add("selected");
+          picks.easing = customIdx;
+          checkReady();
+          renderPreview();
+        }
+
+        // Convert anchors to SVG path (CustomEase: y=0 is start, y=1 is end — same as our internal coords)
+        function toPath() {
+          var d = "M0,0";
+          for (var i = 0; i < anchors.length - 1; i++) {
+            var a = anchors[i], b = anchors[i + 1];
+            d += " C" + n(a.ox) + "," + n(a.oy) + " " + n(b.ix) + "," + n(b.iy) + " " + n(b.x) + "," + n(b.y);
+          }
+          return d;
+        }
+        function n(v) { return parseFloat(v.toFixed(3)); }
+
+        // De Casteljau split
+        function splitBezier(p0, cp1, cp2, p1, t) {
+          var u = 1 - t;
+          var q0 = lerp(p0, cp1, t), q1 = lerp(cp1, cp2, t), q2 = lerp(cp2, p1, t);
+          var r0 = lerp(q0, q1, t), r1 = lerp(q1, q2, t);
+          var s = lerp(r0, r1, t);
+          return { left: { cp1: q0, cp2: r0, end: s }, right: { cp1: r1, cp2: q2, end: p1 } };
+        }
+        function lerp(a, b, t) { return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t }; }
+
+        // Find closest point on curve to click
+        function closestOnCurve(mx, my) {
+          var best = { dist: Infinity, seg: 0, t: 0.5 };
+          for (var i = 0; i < anchors.length - 1; i++) {
+            var a = anchors[i], b = anchors[i + 1];
+            var p0 = { x: a.x, y: a.y }, cp1 = { x: a.ox, y: a.oy }, cp2 = { x: b.ix, y: b.iy }, p1 = { x: b.x, y: b.y };
+            for (var t = 0; t <= 1; t += 0.01) {
+              var u = 1 - t;
+              var px = u*u*u*p0.x + 3*u*u*t*cp1.x + 3*u*t*t*cp2.x + t*t*t*p1.x;
+              var py = u*u*u*p0.y + 3*u*u*t*cp1.y + 3*u*t*t*cp2.y + t*t*t*p1.y;
+              var dx = px - mx, dy = py - my;
+              var d = dx * dx + dy * dy;
+              if (d < best.dist) { best.dist = d; best.seg = i; best.t = t; }
+            }
+          }
+          return best;
+        }
+
+        // Add waypoint
+        function addWaypoint(seg, t) {
+          var a = anchors[seg], b = anchors[seg + 1];
+          var p0 = { x: a.x, y: a.y }, cp1 = { x: a.ox, y: a.oy }, cp2 = { x: b.ix, y: b.iy }, p1 = { x: b.x, y: b.y };
+          var sp = splitBezier(p0, cp1, cp2, p1, t);
+          a.ox = sp.left.cp1.x; a.oy = sp.left.cp1.y;
+          var newAnchor = {
+            x: sp.left.end.x, y: sp.left.end.y,
+            ix: sp.left.cp2.x, iy: sp.left.cp2.y,
+            ox: sp.right.cp1.x, oy: sp.right.cp1.y
+          };
+          b.ix = sp.right.cp2.x; b.iy = sp.right.cp2.y;
+          anchors.splice(seg + 1, 0, newAnchor);
+          selectedAnchor = seg + 1;
+          rebuild();
+          updateValue();
+        }
+
+        // Remove waypoint
+        function removeWaypoint(idx) {
+          if (idx <= 0 || idx >= anchors.length - 1) return;
+          anchors.splice(idx, 1);
+          selectedAnchor = -1;
+          rebuild();
+          updateValue();
+        }
+
+        // Rebuild handle DOM elements
+        function rebuild() {
+          handles.forEach(function(h) { if (h.el.parentNode) h.el.parentNode.removeChild(h.el); });
+          handles = [];
+          for (var i = 0; i < anchors.length; i++) {
+            var a = anchors[i];
+            // Anchor point (not for first/last x position, but y is draggable)
+            if (i > 0 && i < anchors.length - 1) {
+              makeHandle(i, "anchor", "x", "y", true, true);
+            }
+            // Outgoing handle (not for last anchor)
+            if (i < anchors.length - 1) {
+              makeHandle(i, "out", "ox", "oy", true, true);
+            }
+            // Incoming handle (not for first anchor)
+            if (i > 0) {
+              makeHandle(i, "in", "ix", "iy", true, true);
+            }
+          }
+          draw();
+        }
+
+        function makeHandle(idx, type, xk, yk, dragX, dragY) {
+          var el = document.createElement("div");
+          el.className = type === "anchor" ? "bezier-anchor" : "bezier-handle";
+          el.dataset.idx = idx;
+          el.dataset.type = type;
+          bwrap.appendChild(el);
+          var info = { el: el, idx: idx, type: type, xk: xk, yk: yk };
+          handles.push(info);
+
+          var dragging = false;
+          el.addEventListener("mousedown", function(e) {
+            e.preventDefault(); e.stopPropagation();
+            dragging = true;
+            el.classList.add("dragging");
+            selectCustom();
+            if (type === "anchor") {
+              selectedAnchor = idx;
+              handles.forEach(function(h) { if (h.type === "anchor") h.el.classList.toggle("selected", h.idx === idx); });
+            }
+          });
+          window.addEventListener("mousemove", function(e) {
+            if (!dragging) return;
+            var r = bwrap.getBoundingClientRect();
+            var nx = (e.clientX - r.left) / r.width;
+            var ny = 1 - (e.clientY - r.top) / r.height;
+            if (type === "anchor") {
+              var prev = anchors[idx - 1], next = anchors[idx + 1];
+              nx = Math.max(prev.x + 0.01, Math.min(next.x - 0.01, nx));
+              var dx = nx - anchors[idx].x, dy = ny - anchors[idx].y;
+              anchors[idx].x = nx; anchors[idx].y = ny;
+              anchors[idx].ox += dx; anchors[idx].oy += dy;
+              anchors[idx].ix += dx; anchors[idx].iy += dy;
+            } else {
+              anchors[idx][xk] = nx;
+              anchors[idx][yk] = ny;
+            }
+            draw();
+            updateValue();
+          });
+          window.addEventListener("mouseup", function() {
+            if (dragging) { dragging = false; el.classList.remove("dragging"); }
+          });
+        }
+
+        // Canvas click to add waypoint
+        bwrap.addEventListener("click", function(e) {
+          if (e.target.classList.contains("bezier-handle") || e.target.classList.contains("bezier-anchor")) return;
+          var r = bwrap.getBoundingClientRect();
+          var mx = (e.clientX - r.left) / r.width;
+          var my = 1 - (e.clientY - r.top) / r.height;
+          var hit = closestOnCurve(mx, my);
+          if (hit.dist < 0.005) {
+            addWaypoint(hit.seg, hit.t);
+          } else {
+            selectedAnchor = -1;
+            handles.forEach(function(h) { if (h.type === "anchor") h.el.classList.remove("selected"); });
+          }
+        });
+
+        // Delete key removes selected waypoint
+        document.addEventListener("keydown", function(e) {
+          if ((e.key === "Delete" || e.key === "Backspace") && selectedAnchor > 0 && selectedAnchor < anchors.length - 1) {
+            if (document.activeElement && (document.activeElement.tagName === "INPUT" || document.activeElement.tagName === "TEXTAREA")) return;
+            e.preventDefault();
+            removeWaypoint(selectedAnchor);
+          }
+        });
+
+        function draw() {
+          var r = bwrap.getBoundingClientRect();
+          canvas.width = r.width * 2; canvas.height = r.height * 2;
+          var ctx = canvas.getContext("2d");
+          var w = canvas.width, ht = canvas.height;
+          ctx.clearRect(0, 0, w, ht);
+
+          // Grid
+          ctx.strokeStyle = "rgba(255,255,255,0.04)"; ctx.lineWidth = 1;
+          for (var g = 0.25; g < 1; g += 0.25) {
+            ctx.beginPath(); ctx.moveTo(g*w, 0); ctx.lineTo(g*w, ht); ctx.stroke();
+            ctx.beginPath(); ctx.moveTo(0, g*ht); ctx.lineTo(w, g*ht); ctx.stroke();
+          }
+          // Diagonal
+          ctx.strokeStyle = "rgba(255,255,255,0.06)"; ctx.setLineDash([6, 6]);
+          ctx.beginPath(); ctx.moveTo(0, ht); ctx.lineTo(w, 0); ctx.stroke(); ctx.setLineDash([]);
+
+          // Handle lines
+          ctx.strokeStyle = "rgba(78,127,255,0.3)"; ctx.lineWidth = 1.5;
+          for (var i = 0; i < anchors.length; i++) {
+            var a = anchors[i];
+            if (i < anchors.length - 1) {
+              ctx.beginPath(); ctx.moveTo(a.x*w, (1-a.y)*ht); ctx.lineTo(a.ox*w, (1-a.oy)*ht); ctx.stroke();
+            }
+            if (i > 0) {
+              ctx.beginPath(); ctx.moveTo(a.x*w, (1-a.y)*ht); ctx.lineTo(a.ix*w, (1-a.iy)*ht); ctx.stroke();
+            }
+          }
+
+          // Curve
+          ctx.strokeStyle = "#0ae448"; ctx.lineWidth = 3;
+          ctx.beginPath(); ctx.moveTo(0, ht);
+          for (var i = 0; i < anchors.length - 1; i++) {
+            var a = anchors[i], b = anchors[i + 1];
+            ctx.bezierCurveTo(a.ox*w, (1-a.oy)*ht, b.ix*w, (1-b.iy)*ht, b.x*w, (1-b.y)*ht);
+          }
+          ctx.stroke();
+
+          // Position handle DOM elements
+          handles.forEach(function(h) {
+            var a = anchors[h.idx];
+            var px = a[h.xk] * r.width, py = (1 - a[h.yk]) * r.height;
+            h.el.style.left = px + "px"; h.el.style.top = py + "px";
+          });
+        }
+
+        function updateValue() {
+          var path = toPath();
+          EASINGS[customIdx].value = path;
+          valEl.textContent = path;
+          if (typeof CustomEase !== "undefined") { CustomEase.create("_pickerCustom", path); }
+          if (picks.easing === customIdx) { animateBezierDot(); renderPreview(); }
+        }
+
+        var bzTween = null;
+        function animateBezierDot() {
+          if (bzTween) { bzTween.kill(); bzTween = null; }
+          if (typeof CustomEase === "undefined") return;
+          bzTween = gsap.fromTo(dotEl, { left: 0 }, {
+            left: "calc(100% - 12px)", duration: 1.2,
+            ease: "_pickerCustom", repeat: -1, repeatDelay: 0.5, yoyo: true
+          });
+        }
+
+        rebuild();
+        setTimeout(function() { draw(); animateBezierDot(); }, 100);
+        window.addEventListener("resize", function() { draw(); });
+      })();
+
+      // ── Background / Three.js Gradient Presets ──
+      var bgOpts = document.getElementById("bg-options");
+      var shaderEditor = document.getElementById("shader-editor");
+      var seC1 = document.getElementById("se-c1");
+      var seC2 = document.getElementById("se-c2");
+      var seC3 = document.getElementById("se-c3");
+      var seUsePal = document.getElementById("se-use-palette");
+
+      var BG_PRESETS = [
+        { name: "None", desc: "Flat color" },
+        { name: "Halo", desc: "Warm flowing gradient", type: "plane", shader: "defaults", density: 1.3, speed: 0.4, strength: 4, rotX: 0, rotY: 10, rotZ: 50, camDist: 3.6, camAz: 180, camPol: 90, zoom: 1, posX: -1.4,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 1.0, step: 0.05 },
+            { label: "Density", key: "density", min: 0.5, max: 3.0, step: 0.1 },
+            { label: "Rotation", key: "rotZ", min: -180, max: 180, step: 5 }
+          ]},
+        { name: "Mint", desc: "Cool water surface", type: "water", shader: "defaults", density: 1.2, speed: 0.2, strength: 3.4, rotX: 45, rotY: 0, rotZ: 0, camDist: 4.4, camAz: 170, camPol: 70, zoom: 1, posY: 0.9, posZ: -0.3,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 0.8, step: 0.05 },
+            { label: "Wave height", key: "strength", min: 0.5, max: 6.0, step: 0.2 },
+            { label: "Wave density", key: "density", min: 0.5, max: 3.0, step: 0.1 }
+          ]},
+        { name: "Cosmic", desc: "Holographic nebula", type: "sphere", shader: "cosmic", density: 0.8, speed: 0.3, strength: 0.3, rotX: 0, rotY: 130, rotZ: 70, camDist: 0.5, camAz: 270, camPol: 180, zoom: 15.1, posX: -0.1,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 0.8, step: 0.05 },
+            { label: "Shimmer", key: "strength", min: 0.05, max: 0.8, step: 0.05 },
+            { label: "Pattern scale", key: "density", min: 0.3, max: 2.0, step: 0.1 }
+          ]},
+        { name: "Nighty Night", desc: "Dark moody waves", type: "water", shader: "defaults", density: 1.5, speed: 0.3, strength: 0.4, rotX: 50, rotY: 0, rotZ: -60, camDist: 2.8, camAz: 180, camPol: 80, zoom: 9.1,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 0.8, step: 0.05 },
+            { label: "Wave height", key: "strength", min: 0.1, max: 2.0, step: 0.1 },
+            { label: "Darkness", key: "density", min: 0.5, max: 3.0, step: 0.1 }
+          ]},
+        { name: "Sunset", desc: "Warm sphere glow", type: "sphere", shader: "defaults", density: 1.1, speed: 0.1, strength: 0.4, rotX: 0, rotY: 0, rotZ: 0, camDist: 7.1, camAz: 60, camPol: 90, zoom: 15.3, posY: -0.15,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.02, max: 0.4, step: 0.02 },
+            { label: "Glow", key: "strength", min: 0.1, max: 1.0, step: 0.05 }
+          ]},
+        { name: "Cotton Candy", desc: "Pastel soft waves", type: "water", shader: "defaults", density: 1, speed: 0.3, strength: 3, rotX: 0, rotY: 0, rotZ: -90, camDist: 2.9, camAz: 180, camPol: 120, zoom: 1, posY: 1.8,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 0.8, step: 0.05 },
+            { label: "Wave height", key: "strength", min: 0.5, max: 5.0, step: 0.2 },
+            { label: "Softness", key: "density", min: 0.5, max: 2.5, step: 0.1 }
+          ]},
+        { name: "Glass", desc: "Refractive water", type: "water", shader: "glass", density: 1.2, speed: 0.2, strength: 3.4, rotX: 45, rotY: 0, rotZ: 0, camDist: 4.4, camAz: 170, camPol: 70, zoom: 1, posY: 0.9, posZ: -0.3,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.05, max: 0.6, step: 0.05 },
+            { label: "Refraction", key: "strength", min: 0.5, max: 6.0, step: 0.2 },
+            { label: "Clarity", key: "density", min: 0.5, max: 3.0, step: 0.1 }
+          ]},
+        { name: "Blob", desc: "Wiggly organic shape", type: "sphere", shader: "defaults", density: 1.3, speed: 0.4, strength: 1.5, rotX: 0, rotY: 10, rotZ: 0, camDist: 3.6, camAz: 180, camPol: 90, zoom: 1,
+          controls: [
+            { label: "Speed", key: "speed", min: 0.1, max: 1.0, step: 0.05 },
+            { label: "Wobble", key: "strength", min: 0.3, max: 4.0, step: 0.1 },
+            { label: "Wobble density", key: "density", min: 0.5, max: 3.0, step: 0.1 }
+          ]}
+      ];
+
+      var seControls = document.getElementById("se-controls");
+
+      function makeSlider(parent, label, key, min, max, step, preset) {
+        var wrap = document.createElement("label");
+        wrap.style.cssText = "font-size:10px;color:#666;display:block;margin-bottom:6px;";
+        var input = document.createElement("input");
+        input.type = "range";
+        input.min = min; input.max = max; input.step = step;
+        input.value = preset[key];
+        input.style.cssText = "width:100%;accent-color:#0ae448;height:4px;-webkit-appearance:none;background:#222;border-radius:2px;outline:none;margin-top:4px;";
+        input.dataset.key = key;
+        var valSpan = document.createElement("span");
+        valSpan.style.cssText = "float:right;color:#888;font-family:monospace;";
+        valSpan.textContent = preset[key];
+        input.addEventListener("input", function() {
+          var val = parseFloat(this.value);
+          preset[this.dataset.key] = val;
+          valSpan.textContent = val;
+          if (typeof window._sgUpdateBg === "function") window._sgUpdateBg();
+        });
+        wrap.textContent = label + " ";
+        wrap.appendChild(valSpan);
+        wrap.appendChild(input);
+        parent.appendChild(wrap);
+      }
+
+      function renderBgControls(preset) {
+        seControls.innerHTML = "";
+        if (!preset) return;
+        // Preset-specific controls
+        if (preset.controls) {
+          preset.controls.forEach(function(c) {
+            makeSlider(seControls, c.label, c.key, c.min, c.max, c.step, preset);
+          });
+        }
+        // Camera controls (always shown)
+        var camLabel = document.createElement("div");
+        camLabel.style.cssText = "font-size:9px;color:#444;text-transform:uppercase;letter-spacing:0.1em;margin:10px 0 6px;border-top:1px solid #222;padding-top:8px;";
+        camLabel.textContent = "Camera";
+        seControls.appendChild(camLabel);
+        var isSphere = preset.type === "sphere";
+        if (isSphere) {
+          makeSlider(seControls, "Zoom", "zoom", 1, 20, 0.5, preset);
+        } else {
+          makeSlider(seControls, "Distance", "camDist", 1, 10, 0.2, preset);
+        }
+        makeSlider(seControls, "Angle", "camAz", 0, 360, 5, preset);
+        makeSlider(seControls, "Tilt", "camPol", 30, 170, 5, preset);
       }
-      function sel(key, idx, container) {
-        container.querySelectorAll(".opt").forEach(function (c) {
+
+      BG_PRESETS.forEach(function(p, i) {
+        var el = document.createElement("div");
+        el.className = "chip";
+        var dot = i > 0 ? '<span style="display:inline-block;width:8px;height:8px;border-radius:50%;background:#0ae448;margin-right:6px;"></span>' : '';
+        el.innerHTML = '<div><div class="chip-label">' + dot + p.name + '</div><div class="chip-sub">' + p.desc + '</div></div>';
+        el.onclick = function() {
+          chipSel("bg_mode", i, bgOpts);
+          shaderEditor.style.display = i > 0 ? "block" : "none";
+          renderBgControls(i > 0 ? p : null);
+          if (typeof window._sgUpdateBg === "function") window._sgUpdateBg();
+        };
+        bgOpts.appendChild(el);
+      });
+
+      function getBgColors() {
+        if (seUsePal.checked && picks.palette !== null) {
+          var p = PALETTES[picks.palette];
+          return [p.background, p.accent, p.muted];
+        }
+        return [seC1.value, seC2.value, seC3.value];
+      }
+
+      seUsePal.addEventListener("change", function() {
+        if (this.checked && picks.palette !== null) {
+          var p = PALETTES[picks.palette];
+          seC1.value = p.background; seC2.value = p.accent; seC3.value = p.muted;
+        }
+        if (typeof window._sgUpdateBg === "function") window._sgUpdateBg();
+      });
+      [seC1, seC2, seC3].forEach(function(el) {
+        el.addEventListener("input", function() {
+          if (typeof window._sgUpdateBg === "function") window._sgUpdateBg();
+        });
+      });
+
+      function sel(key, idx, container, cls) {
+        container.querySelectorAll(cls || ".opt").forEach(function (c) {
           c.classList.remove("selected");
         });
         container.children[idx].classList.add("selected");
@@ -1210,6 +2064,7 @@ <h2 id="mood-title">Pick a direction</h2>
         checkReady();
         renderPreview();
       }
+      function chipSel(key, idx, container) { sel(key, idx, container, ".chip"); }
 
       function checkReady() {
         var ready =
@@ -1220,7 +2075,8 @@ <h2 id="mood-title">Pick a direction</h2>
           picks.corners !== null &&
           picks.density !== null &&
           picks.depth !== null &&
-          picks.easing !== null;
+          picks.easing !== null &&
+          picks.bg_mode !== null;
         document
           .getElementById("fab")
           .classList.toggle("visible", ready && currentPhase === "tune");
@@ -1229,193 +2085,299 @@ <h2 id="mood-title">Pick a direction</h2>
 
       function renderPreview() {
         var pv = document.getElementById("preview");
+        var sc = document.getElementById("showcase");
+        var empty = pv.querySelector(".preview-empty");
         if (picks.arch === null) {
-          pv.innerHTML = '<div class="preview-empty">Pick a structure to preview</div>';
+          if (empty) empty.style.display = "";
+          sc.style.display = "none";
           return;
         }
+        if (empty) empty.style.display = "none";
+        sc.style.display = "";
+
         var a = ARCHITECTURES[picks.arch];
         var th = picks.theme !== null ? THEMES[picks.theme] : THEMES[0];
-        var p =
-          picks.palette !== null ? PALETTES[picks.palette] : { accent: "#888", muted: "#555" };
-        var t =
-          picks.type !== null
-            ? TYPEPAIRS[picks.type]
-            : {
-                headline: { family: "system-ui", weight: 600 },
-                body: { family: "system-ui", weight: 400 },
-              };
-        var cr = picks.corners !== null ? CORNERS[picks.corners].value : "0px";
+        var p = picks.palette !== null ? PALETTES[picks.palette] : { accent: "#888", muted: "#555", name: "Default" };
+        var t = picks.type !== null ? TYPEPAIRS[picks.type] : { headline: { family: "system-ui", weight: "600" }, body: { family: "system-ui", weight: "400" }, name: "Default" };
+        var cr = picks.corners !== null ? CORNERS[picks.corners] : { name: "Slight", value: "4px" };
         var dn = picks.density !== null ? picks.density : 1;
-        var dp = picks.depth !== null ? picks.depth : 0;
+        var dp = picks.depth !== null ? DEPTHS[picks.depth] : DEPTHS[0];
+        var easeObj = picks.easing !== null ? EASINGS[picks.easing] : null;
         var bg, fg;
-        if (th.id === "palette" && p.background) {
-          bg = p.background;
-          fg = p.foreground;
-        } else {
-          bg = th.bg;
-          fg = th.fg;
-        }
-        var ac = p.accent,
-          mt = p.muted || al(fg, 0.4);
-        var pad = [12, 20, 36][dn] + "px",
-          gap = [8, 16, 28][dn] + "px";
+        if (th.id === "palette" && p.background) { bg = p.background; fg = p.foreground; }
+        else { bg = th.bg; fg = th.fg; }
+        var ac = p.accent, mt = p.muted || al(fg, 0.4);
         var isDark = bg && bg[0] === "#" ? parseInt(bg.slice(1, 3), 16) < 80 : true;
+        var pad = [12, 20, 36][dn] + "px", gap = [8, 16, 28][dn] + "px";
         var shCol = isDark ? ac : fg;
-        var shadow = [
-          "none",
-          "0 2px 16px " + al(shCol, isDark ? 0.15 : 0.1),
-          "0 4px 32px " + al(shCol, isDark ? 0.3 : 0.18),
-        ][dp];
+        var shadow = ["none", "0 2px 16px " + al(shCol, isDark ? 0.15 : 0.1), "0 4px 32px " + al(shCol, isDark ? 0.3 : 0.18)][picks.depth || 0];
+
+        // Token map for frame rendering
         var tokens = {
-          "{{bg}}": bg,
-          "{{fg}}": fg,
-          "{{ac}}": ac,
-          "{{mt}}": mt,
-          "{{sf}}": al(fg, 0.06),
-          "{{hf}}": t.headline.family,
-          "{{hw}}": t.headline.weight,
-          "{{bf}}": t.body.family,
-          "{{bw}}": t.body.weight,
-          "{{cr}}": cr,
-          "{{pad}}": pad,
-          "{{gap}}": gap,
-          "{{shadow}}": shadow,
-          "{{g}}": al(fg, 0.06),
-          "{{fg3}}": al(fg, 0.03),
-          "{{fg6}}": al(fg, 0.06),
-          "{{fg8}}": al(fg, 0.08),
-          "{{fg15}}": al(fg, 0.15),
-          "{{ac3}}": al(ac, 0.03),
-          "{{ac5}}": al(ac, 0.05),
-          "{{ac25}}": al(ac, 0.25),
+          "{{bg}}": bg, "{{fg}}": fg, "{{ac}}": ac, "{{mt}}": mt,
+          "{{hf}}": t.headline.family, "{{hw}}": t.headline.weight,
+          "{{bf}}": t.body.family, "{{bw}}": t.body.weight,
+          "{{cr}}": cr.value, "{{pad}}": pad, "{{gap}}": gap, "{{shadow}}": shadow,
+          "{{sf}}": al(fg, 0.06), "{{g}}": al(fg, 0.06),
+          "{{fg3}}": al(fg, 0.03), "{{fg6}}": al(fg, 0.06), "{{fg8}}": al(fg, 0.08), "{{fg15}}": al(fg, 0.15),
+          "{{ac3}}": al(ac, 0.03), "{{ac5}}": al(ac, 0.05), "{{ac25}}": al(ac, 0.25),
           "{{prompt_headline}}": (PROMPT && PROMPT.headline) || "Your Headline",
           "{{prompt_sub}}": (PROMPT && PROMPT.subline) || "Subline.",
         };
-        var h =
-          a.preview_html ||
-          '<div style="background:' +
-            bg +
-            ";padding:40px;min-height:100%;display:flex;align-items:center;justify-content:center;color:" +
-            mt +
-            ';font-size:14px;">No preview</div>';
-        Object.keys(tokens).forEach(function (k) {
-          h = h.split(k).join(tokens[k]);
-        });
-        pv.innerHTML = h;
+
+        // Set CSS variables for the showcase
+        sc.style.setProperty("--sc-bg", bg);
+        sc.style.setProperty("--sc-fg", fg);
+        sc.style.setProperty("--sc-ac", ac);
+        sc.style.setProperty("--sc-mt", mt);
+
+        // ── Overview ──
+        document.getElementById("sc-overview-title").textContent = (PROMPT && PROMPT.title) || "Untitled";
+        document.getElementById("sc-overview-lead").textContent = (a.mood || "") + " " + (a.description || "") + ". " + (isDark ? "Dark" : "Light") + " canvas, " + t.headline.family + " headlines, " + t.body.family + " body.";
+        // Overview inherits from CSS variables set on .showcase
+
+        // ── Palette ──
+        var swatchData = [
+          { name: "Canvas", hex: bg, role: "Frame background" },
+          { name: "Text", hex: fg, role: "Primary readable text" },
+          { name: "Accent", hex: ac, role: "Hero stats, focal elements" },
+          { name: "Muted", hex: mt, role: "Captions, labels, secondary" },
+        ];
+        document.getElementById("sc-palette-lead").textContent = p.name + " palette. Accent (" + ac + ") carries every focal element. Use it scarcely.";
+        var swatchHtml = swatchData.map(function(s) {
+          return '<div class="swatch-card"><span class="swatch-chip" style="background:' + s.hex + ';"></span><div><div class="swatch-name">' + s.name + '</div><div class="swatch-hex">' + s.hex + '</div><div class="swatch-role">' + s.role + '</div></div></div>';
+        }).join("");
+        document.getElementById("sc-swatches").innerHTML = swatchHtml;
+
+        // ── Typography ──
+        document.getElementById("sc-type-lead").textContent = t.headline.family + " (weight " + t.headline.weight + ") for headlines. " + t.body.family + " (weight " + t.body.weight + ") for body. Cross-category pairing.";
+        var typeRows = [
+          { token: "hero-slam", size: "96px", weight: t.headline.weight, family: t.headline.family, sample: (PROMPT && PROMPT.headline) || "Hero Headline", lh: "0.95", ls: "-0.03em" },
+          { token: "section", size: "48px", weight: t.headline.weight, family: t.headline.family, sample: "Section Headline", lh: "1.1", ls: "-0.02em" },
+          { token: "body", size: "28px", weight: t.body.weight, family: t.body.family, sample: "Body text at video scale — readable at 3 seconds on screen.", lh: "1.5", ls: "0" },
+          { token: "label", size: "14px", weight: t.body.weight, family: t.body.family, sample: "OVERLINE LABEL · UPPERCASE · WIDE TRACKING", lh: "1.4", ls: "0.1em" },
+          { token: "data", size: "64px", weight: t.headline.weight, family: t.body.family, sample: "2,481,000", lh: "1.0", ls: "-0.02em" },
+        ];
+        var typeHtml = typeRows.map(function(r) {
+          return '<div class="type-specimen-row"><div class="type-meta"><strong>' + r.token + '</strong></div><div class="type-sample" style="font-family:\'' + r.family + '\',sans-serif;font-weight:' + r.weight + ';font-size:' + r.size + ';line-height:' + r.lh + ';letter-spacing:' + r.ls + ';color:' + fg + ';">' + r.sample + '</div></div>';
+        }).join("");
+        document.getElementById("sc-type-specimens").innerHTML = typeHtml;
+
+        // ── Scenes ──
+        var frames = a.preview_frames || [a.preview_html || ""];
+        var sceneLabels = ["/ Scene 1 · Hook", "/ Scene 2 · Proof", "/ Scene 3 · Action", "/ Scene 4 · Close"];
+        var sceneHtml = frames.map(function(f, fi) {
+          var r = f || "";
+          Object.keys(tokens).forEach(function(k) { r = r.split(k).join(tokens[k]); });
+          return '<div class="scene-cell" style="background:' + bg + ';"><div class="scene-cell-label">' + (sceneLabels[fi] || "/ Scene " + (fi+1)) + '</div><div class="scene-frame">' + r + '</div></div>';
+        }).join("");
+        document.getElementById("sc-scene-grid").innerHTML = sceneHtml;
+
+        // Three.js shader background — rendered by module script, triggered via global hook
+        var _hasBgPreset = picks.bg_mode !== null && picks.bg_mode > 0;
+
+        // Scale scene frames — retry until cells have width
+        if (window._scaleRetry) clearTimeout(window._scaleRetry);
+        if (window._scaleScenes) window.removeEventListener("resize", window._scaleScenes);
+        function scaleScenes() {
+          var allDone = true;
+          document.querySelectorAll(".scene-cell").forEach(function(cell) {
+            var f = cell.querySelector(".scene-frame");
+            if (!f) return;
+            var cw = cell.offsetWidth;
+            if (cw <= 0) { allDone = false; return; }
+            var s = cw / 1920;
+            f.style.transform = "scale(" + s + ")";
+            f.style.background = _hasBgPreset ? "transparent" : bg;
+          });
+          if (!allDone) window._scaleRetry = setTimeout(scaleScenes, 50);
+          else if (typeof window._sgUpdateBg === "function") window._sgUpdateBg();
+        }
+        window._scaleScenes = scaleScenes;
+        window._scaleRetry = setTimeout(scaleScenes, 100);
+        window.addEventListener("resize", scaleScenes);
+
+        // ── Motion ──
+        var motionLead = easeObj ? easeObj.name + " energy. Entry easing: " + easeObj.value + " — " + easeObj.desc + "." : "Select an easing to preview.";
+        document.getElementById("sc-motion-lead").textContent = motionLead;
+        var easePreview = document.getElementById("sc-ease-preview");
+        // Kill any existing ease animation
+        if (window._easeDotTween) { window._easeDotTween.kill(); window._easeDotTween = null; }
+        if (window._easeDotReturn) { window._easeDotReturn.kill(); window._easeDotReturn = null; }
+        easePreview.innerHTML = '<div class="ease-preview-track"><div class="ease-preview-dot" id="sc-ease-dot" style="background:' + ac + ';"></div></div>';
+        if (easeObj && typeof gsap !== "undefined") {
+          var dot = document.getElementById("sc-ease-dot");
+          var isCustom = easeObj.value.indexOf("M") === 0;
+          var currentEase = isCustom ? "_pickerCustom" : easeObj.value;
+          function animateDot() {
+            window._easeDotTween = gsap.fromTo(dot, { left: 10 }, { left: "calc(100% - 34px)", duration: 1.2, ease: currentEase, delay: 0.5, onComplete: function() {
+              window._easeDotReturn = gsap.to(dot, { left: 10, duration: 1.2, ease: currentEase, delay: 0.5, onComplete: animateDot });
+            }});
+          }
+          animateDot();
+        }
+
+        // ── Elevation ──
+        document.getElementById("sc-elevation-lead").textContent = dp.name + " — " + dp.desc + ".";
+        var surfBg = isDark ? al(fg, 0.06) : al(fg, 0.03);
+        var elvGrid = document.getElementById("sc-elevation-grid");
+        elvGrid.innerHTML = [64, 48, 36].map(function(size) {
+          return '<div style="width:' + size + 'px;height:' + size + 'px;background:' + surfBg + ';border-radius:' + cr.value + ';box-shadow:' + shadow + ';"></div>';
+        }).join("") + '<div style="width:80px;height:48px;background:' + surfBg + ';border-radius:' + cr.value + ';box-shadow:' + shadow + ';"></div>' +
+        '<div style="width:48px;height:64px;background:' + surfBg + ';border-radius:' + cr.value + ';box-shadow:' + shadow + ';"></div>';
+
+        // ── Radius ──
+        var radGrid = document.getElementById("sc-radius-grid");
+        var cards = [
+          { title: "$1,299", sub: "7 nights · all inclusive" },
+          { title: "28°C", sub: "Average summer" },
+          { title: "Oia", sub: "Famous sunset point" },
+        ];
+        radGrid.innerHTML = cards.map(function(c) {
+          return '<div style="background:' + surfBg + ';border-radius:' + cr.value + ';padding:20px 24px;min-width:160px;box-shadow:' + shadow + ';">' +
+            '<div style="font-family:\'' + t.headline.family + '\',sans-serif;font-weight:' + t.headline.weight + ';font-size:28px;color:' + ac + ';">' + c.title + '</div>' +
+            '<div style="font-size:13px;color:' + mt + ';margin-top:6px;font-family:\'' + t.body.family + '\',serif;">' + c.sub + '</div></div>';
+        }).join("") +
+        '<div style="background:' + ac + ';color:' + bg + ';border-radius:' + cr.value + ';padding:14px 32px;display:flex;align-items:center;font-family:\'' + t.headline.family + '\',sans-serif;font-weight:' + t.headline.weight + ';font-size:16px;">Book Now</div>' +
+        '<div style="background:transparent;border:1px solid ' + al(fg, 0.12) + ';border-radius:' + cr.value + ';padding:14px 32px;display:flex;align-items:center;font-size:16px;color:' + fg + ';font-family:\'' + t.headline.family + '\',sans-serif;font-weight:' + t.headline.weight + ';">Learn More</div>';
       }
 
       // ── Output ──
+      // GLSL accessed via window._sgShaders (set by the module script)
+
       function showOutput() {
-        if (
-          picks.theme === null ||
-          picks.arch === null ||
-          picks.palette === null ||
-          picks.type === null ||
-          picks.corners === null ||
-          picks.density === null ||
-          picks.depth === null
-        )
-          return;
-        var a = ARCHITECTURES[picks.arch],
-          p = PALETTES[picks.palette],
-          t = TYPEPAIRS[picks.type];
-        var th = THEMES[picks.theme],
-          cr = CORNERS[picks.corners],
-          dn = DENSITIES[picks.density],
-          dp = DEPTHS[picks.depth];
+        if (picks.theme === null || picks.arch === null || picks.palette === null || picks.type === null || picks.corners === null || picks.density === null || picks.depth === null) return;
+        var a = ARCHITECTURES[picks.arch], p = PALETTES[picks.palette], t = TYPEPAIRS[picks.type];
+        var th = THEMES[picks.theme], cr = CORNERS[picks.corners], dn = DENSITIES[picks.density], dp = DEPTHS[picks.depth];
         var bg = th.id === "palette" && p.background ? p.background : th.bg;
         var fg = th.id === "palette" && p.foreground ? p.foreground : th.fg;
-        var ac = p.accent,
-          mt = p.muted || p.mid || "#888";
+        var ac = p.accent, mt = p.muted || p.mid || "#888";
         var padVal = { Tight: "8px", Normal: "16px", Generous: "32px" }[dn.name] || "16px";
         var gapVal = { Tight: "8px", Normal: "16px", Generous: "28px" }[dn.name] || "16px";
-
-        var md = "---\n";
-        md += "name: " + ((PROMPT && PROMPT.title) || "Untitled") + "\n";
-        md +=
-          'colors:\n  primary: "' +
-          bg +
-          '"\n  on-primary: "' +
-          fg +
-          '"\n  accent: "' +
-          ac +
-          '"\n  muted: "' +
-          mt +
-          '"\n';
-        md +=
-          "typography:\n  headline:\n    fontFamily: " +
-          t.headline.family +
-          "\n    fontSize: 3.5rem\n    fontWeight: " +
-          t.headline.weight +
-          "\n    letterSpacing: -0.03em\n";
-        md +=
-          "  body:\n    fontFamily: " +
-          t.body.family +
-          "\n    fontSize: 1rem\n    fontWeight: " +
-          t.body.weight +
-          "\n    lineHeight: 1.5\n";
-        md += "rounded:\n  md: " + cr.value + "\n";
-        md += "spacing:\n  md: " + padVal + "\n  lg: " + gapVal + "\n";
-        md += "---\n\n";
-        md += "## Overview\n\n" + a.mood + ". " + a.description + ". " + p.description + ".\n\n";
-        md +=
-          "## Colors\n\n- **Primary** (`" +
-          bg +
-          "`) — Canvas background\n- **On-Primary** (`" +
-          fg +
-          "`) — Text and content\n- **Accent** (`" +
-          ac +
-          "`) — CTAs, highlights\n- **Muted** (`" +
-          mt +
-          "`) — Secondary text\n\n";
-        md +=
-          "## Typography\n\n- **Headline** — " +
-          t.headline.family +
-          " at weight " +
-          t.headline.weight +
-          "\n- **Body** — " +
-          t.body.family +
-          " at weight " +
-          t.body.weight +
-          "\n\n";
-        md +=
-          "## Layout\n\n- Structure: " +
-          a.name +
-          " — " +
-          a.tag +
-          "\n- Density: " +
-          dn.name +
-          " (" +
-          dn.desc +
-          ")\n- Corners: " +
-          cr.name +
-          " (" +
-          cr.value +
-          ")\n\n";
-        md += "## Elevation\n\n" + dp.name + " — " + dp.desc + ".\n\n";
         var easeObj = picks.easing !== null ? EASINGS[picks.easing] : null;
-        if (easeObj) {
-          md +=
-            "## Motion\n\n- **Entry easing:** `" +
-            easeObj.value +
-            "` — " +
-            easeObj.desc +
-            "\n- **Energy:** " +
-            easeObj.name +
-            "\n\n";
+        var isDark = bg && bg[0] === "#" ? parseInt(bg.slice(1, 3), 16) < 80 : true;
+
+        // ── Build design.html ──
+        var wDiff = parseInt(t.headline.weight) - parseInt(t.body.weight);
+        var bgpObj = (picks.bg_mode > 0 && BG_PRESETS[picks.bg_mode]) ? BG_PRESETS[picks.bg_mode] : null;
+        var bgColors = bgpObj ? getBgColors() : [];
+
+        var spec = {
+          name: (PROMPT && PROMPT.title) || "Untitled",
+          palette: { canvas: bg, text: fg, accent: ac, muted: mt },
+          typography: {
+            headline: { family: t.headline.family, weight: t.headline.weight },
+            body: { family: t.body.family, weight: t.body.weight }
+          },
+          surface: { corners: cr.value, elevation: dp.name, padding: padVal, gap: gapVal, shadow: dp.name === "Flat" ? "none" : "0 2px 12px rgba(0,0,0,0.08)" },
+          motion: easeObj ? { easing: easeObj.value, energy: easeObj.name.toLowerCase(), desc: easeObj.desc } : null,
+          background: bgpObj ? {
+            preset: bgpObj.name, type: bgpObj.type, shader: bgpObj.shader,
+            fragmentShader: bgpObj.fragmentShader || null,
+            colors: bgColors, density: bgpObj.density, speed: bgpObj.speed, strength: bgpObj.strength,
+            rotation: [bgpObj.rotX, bgpObj.rotY, bgpObj.rotZ],
+            camera: { distance: bgpObj.camDist, azimuth: bgpObj.camAz, polar: bgpObj.camPol, zoom: bgpObj.zoom || 1 },
+            position: [bgpObj.posX || 0, bgpObj.posY || 0, bgpObj.posZ || 0]
+          } : null,
+          structure: { name: a.name, tag: a.tag || "", mood: a.mood || "", description: a.description || "" },
+          density: { level: dn.name, desc: dn.desc },
+          dos: [
+            "Use accent (" + ac + ") for exactly the element the viewer should remember",
+            "Maintain " + cr.name.toLowerCase() + " corners (" + cr.value + ") on every container",
+            "Keep headline weight at " + t.headline.weight,
+            "Use " + t.body.family + " for all readable body text",
+            "Tint neutrals toward the accent hue"
+          ],
+          donts: [
+            "Don't introduce a second accent color",
+            "Don't use accent for background fills or large surfaces",
+            "Don't use body text under 24px in video compositions",
+            "Don't use the same entrance animation on every element",
+            isDark ? "Don't use pure #000 for canvas or pure #fff for text" : "Don't leave light backgrounds untextured"
+          ]
+        };
+
+        var h = '<!doctype html>\n<html lang="en">\n<head>\n';
+        h += '<meta charset="UTF-8">\n';
+        h += '<title>Design System — ' + spec.name + '</title>\n';
+        h += '<link rel="preconnect" href="https://fonts.googleapis.com">\n';
+        h += '<link href="https://fonts.googleapis.com/css2?family=' + t.headline.family.replace(/ /g,'+') + ':wght@' + t.headline.weight + '&family=' + t.body.family.replace(/ /g,'+') + ':wght@' + t.body.weight + '&display=swap" rel="stylesheet">\n';
+        h += '<style>\n:root {\n';
+        h += '  --bg: ' + bg + ';\n  --fg: ' + fg + ';\n  --accent: ' + ac + ';\n  --muted: ' + mt + ';\n';
+        h += '  --font-headline: "' + t.headline.family + '", serif;\n  --font-headline-weight: ' + t.headline.weight + ';\n';
+        h += '  --font-body: "' + t.body.family + '", sans-serif;\n  --font-body-weight: ' + t.body.weight + ';\n';
+        h += '  --corner-radius: ' + cr.value + ';\n  --padding: ' + padVal + ';\n  --gap: ' + gapVal + ';\n';
+        h += '  --shadow: ' + spec.surface.shadow + ';\n';
+        if (easeObj) h += '  --easing: ' + easeObj.value + ';\n';
+        h += '}\n';
+        h += 'body{margin:0;background:var(--bg);color:var(--fg);font-family:var(--font-body);font-weight:var(--font-body-weight);}\n';
+        h += '</style>\n';
+        if (bgpObj) {
+          h += '<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"><\/script>\n';
+          h += '<script type="importmap">{"imports":{"three":"https://cdn.jsdelivr.net/npm/three@0.167.0/build/three.module.js"}}<\/script>\n';
         }
-        if (a.components) md += "## Components\n\n" + a.components + "\n\n";
-        md += "## Do's and Don'ts\n\n";
-        if (a.dos) {
-          md += a.dos + "\n";
-        } else {
-          md +=
-            "### Do's\n- Use accent color sparingly for maximum impact\n- Maintain consistent " +
-            cr.name.toLowerCase() +
-            " corners\n\n### Don'ts\n- Do not mix multiple accent colors\n- Do not use weights outside the headline/body pair\n";
+        h += '</head>\n<body>\n\n';
+
+        // Machine-readable spec
+        h += '<script type="application/json" id="design-spec">\n';
+        h += JSON.stringify(spec, null, 2) + '\n';
+        h += '<\/script>\n\n';
+
+        // Shader background module (if selected)
+        if (bgpObj) {
+          h += '<!-- Working Three.js shader background — copy this script into compositions -->\n';
+          h += '<canvas id="design-bg" style="position:fixed;inset:0;width:100%;height:100%;z-index:-1;"><\/canvas>\n';
+          h += '<script type="module" id="design-background">\n';
+          h += 'import * as THREE from "three";\n';
+          h += 'const spec = JSON.parse(document.getElementById("design-spec").textContent);\n';
+          h += 'const bg = spec.background;\n';
+          h += 'if (bg) {\n';
+          h += '  const canvas = document.getElementById("design-bg");\n';
+          h += '  const renderer = new THREE.WebGLRenderer({canvas, antialias:true, alpha:true});\n';
+          h += '  renderer.setPixelRatio(Math.min(devicePixelRatio, 2));\n';
+          h += '  const scene = new THREE.Scene();\n';
+          h += '  const camera = new THREE.PerspectiveCamera(45, innerWidth/innerHeight, 0.1, 100);\n';
+          h += '  const isSphere = bg.type === "sphere";\n';
+          h += '  const dist = isSphere ? 14 : bg.camera.distance;\n';
+          h += '  const az = bg.camera.azimuth * Math.PI / 180;\n';
+          h += '  const pol = bg.camera.polar * Math.PI / 180;\n';
+          h += '  camera.position.set(dist*Math.sin(pol)*Math.sin(az), dist*Math.cos(pol), dist*Math.sin(pol)*Math.cos(az));\n';
+          h += '  camera.lookAt(0,0,0);\n';
+          h += '  camera.zoom = isSphere ? bg.camera.zoom : 1;\n';
+          h += '  camera.updateProjectionMatrix();\n';
+          h += '  scene.add(new THREE.AmbientLight(0xffffff, 0.6));\n';
+          h += '  const dl = new THREE.DirectionalLight(0xffffff, 0.8); dl.position.set(5,5,5); scene.add(dl);\n\n';
+
+          // Vertex shader
+          var _sg = window._sgShaders || {};
+          var vtxSrc = (_sg.vertex || '').replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+          h += '  const vertexShader = `' + vtxSrc + '`;\n\n';
+
+          var fragSrc = bgpObj.fragmentShader || (_sg[bgpObj.shader]) || (_sg.defaults) || '';
+          h += '  const fragmentShader = `' + fragSrc.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$') + '`;\n';
+
+          h += '\n  const uniforms = {\n';
+          h += '    uTime:{value:0}, uSpeed:{value:' + bgpObj.speed + '}, uDensity:{value:' + bgpObj.density + '}, uStrength:{value:' + bgpObj.strength + '},\n';
+          h += '    uColor1:{value:new THREE.Color("' + bgColors[0] + '")},\n';
+          h += '    uColor2:{value:new THREE.Color("' + bgColors[1] + '")},\n';
+          h += '    uColor3:{value:new THREE.Color("' + bgColors[2] + '")}\n';
+          h += '  };\n';
+          h += '  const material = new THREE.ShaderMaterial({vertexShader, fragmentShader, uniforms, side:THREE.DoubleSide});\n';
+          h += '  const geometry = isSphere ? new THREE.SphereGeometry(1,256,256) : new THREE.PlaneGeometry(10,10,128,128);\n';
+          h += '  const mesh = new THREE.Mesh(geometry, material);\n';
+          h += '  mesh.rotation.set(' + (bgpObj.rotX*Math.PI/180).toFixed(3) + ',' + (bgpObj.rotY*Math.PI/180).toFixed(3) + ',' + (bgpObj.rotZ*Math.PI/180).toFixed(3) + ');\n';
+          h += '  mesh.position.set(' + (bgpObj.posX||0) + ',' + (bgpObj.posY||0) + ',' + (bgpObj.posZ||0) + ');\n';
+          h += '  scene.add(mesh);\n\n';
+          h += '  function renderAt(time){renderer.setSize(innerWidth,innerHeight,false);camera.aspect=innerWidth/innerHeight;camera.updateProjectionMatrix();uniforms.uTime.value=time;renderer.render(scene,camera);}\n';
+          h += '  window.addEventListener("hf-seek",e=>renderAt(e.detail.time));\n';
+          h += '  renderAt(window.__hfThreeTime||0);\n';
+          h += '}\n';
+          h += '<\/script>\n\n';
         }
 
-        document.getElementById("md-output").value = md;
+        h += '</body>\n</html>';
+
+        document.getElementById("md-output").value = h;
         document.getElementById("md-overlay").classList.add("visible");
       }
 
@@ -1428,5 +2390,187 @@ <h2 id="mood-title">Pick a direction</h2>
         });
       });
     </script>
+
+    <!-- Three.js shader gradient backgrounds (ES module) -->
+    <script type="module">
+    import * as THREE from 'three';
+
+    const vertexShader = `
+vec3 mod289(vec3 x){return x-floor(x*(1.0/289.0))*289.0;}
+vec4 mod289(vec4 x){return x-floor(x*(1.0/289.0))*289.0;}
+vec4 permute(vec4 x){return mod289(((x*34.0)+1.0)*x);}
+vec4 taylorInvSqrt(vec4 r){return 1.79284291400159-0.85373472095314*r;}
+vec3 fade(vec3 t){return t*t*t*(t*(t*6.0-15.0)+10.0);}
+float cnoise(vec3 P){vec3 Pi0=floor(P);vec3 Pi1=Pi0+vec3(1.0);Pi0=mod289(Pi0);Pi1=mod289(Pi1);vec3 Pf0=fract(P);vec3 Pf1=Pf0-vec3(1.0);vec4 ix=vec4(Pi0.x,Pi1.x,Pi0.x,Pi1.x);vec4 iy=vec4(Pi0.yy,Pi1.yy);vec4 iz0=Pi0.zzzz;vec4 iz1=Pi1.zzzz;vec4 ixy=permute(permute(ix)+iy);vec4 ixy0=permute(ixy+iz0);vec4 ixy1=permute(ixy+iz1);vec4 gx0=ixy0*(1.0/7.0);vec4 gy0=fract(floor(gx0)*(1.0/7.0))-0.5;gx0=fract(gx0);vec4 gz0=vec4(0.5)-abs(gx0)-abs(gy0);vec4 sz0=step(gz0,vec4(0.0));gx0-=sz0*(step(0.0,gx0)-0.5);gy0-=sz0*(step(0.0,gy0)-0.5);vec4 gx1=ixy1*(1.0/7.0);vec4 gy1=fract(floor(gx1)*(1.0/7.0))-0.5;gx1=fract(gx1);vec4 gz1=vec4(0.5)-abs(gx1)-abs(gy1);vec4 sz1=step(gz1,vec4(0.0));gx1-=sz1*(step(0.0,gx1)-0.5);gy1-=sz1*(step(0.0,gy1)-0.5);vec3 g000=vec3(gx0.x,gy0.x,gz0.x);vec3 g100=vec3(gx0.y,gy0.y,gz0.y);vec3 g010=vec3(gx0.z,gy0.z,gz0.z);vec3 g110=vec3(gx0.w,gy0.w,gz0.w);vec3 g001=vec3(gx1.x,gy1.x,gz1.x);vec3 g101=vec3(gx1.y,gy1.y,gz1.y);vec3 g011=vec3(gx1.z,gy1.z,gz1.z);vec3 g111=vec3(gx1.w,gy1.w,gz1.w);vec4 norm0=taylorInvSqrt(vec4(dot(g000,g000),dot(g010,g010),dot(g100,g100),dot(g110,g110)));g000*=norm0.x;g010*=norm0.y;g100*=norm0.z;g110*=norm0.w;vec4 norm1=taylorInvSqrt(vec4(dot(g001,g001),dot(g011,g011),dot(g101,g101),dot(g111,g111)));g001*=norm1.x;g011*=norm1.y;g101*=norm1.z;g111*=norm1.w;float n000=dot(g000,Pf0);float n100=dot(g100,vec3(Pf1.x,Pf0.yz));float n010=dot(g010,vec3(Pf0.x,Pf1.y,Pf0.z));float n110=dot(g110,vec3(Pf1.xy,Pf0.z));float n001=dot(g001,vec3(Pf0.xy,Pf1.z));float n101=dot(g101,vec3(Pf1.x,Pf0.y,Pf1.z));float n011=dot(g011,vec3(Pf0.x,Pf1.yz));float n111=dot(g111,Pf1);vec3 fade_xyz=fade(Pf0);vec4 n_z=mix(vec4(n000,n100,n010,n110),vec4(n001,n101,n011,n111),fade_xyz.z);vec2 n_yz=mix(n_z.xy,n_z.zw,fade_xyz.y);return 2.2*mix(n_yz.x,n_yz.y,fade_xyz.x);}
+varying vec3 vPos;varying vec3 vNormal;varying vec3 vViewPos;
+uniform float uTime;uniform float uSpeed;uniform float uDensity;uniform float uStrength;
+void main(){
+  vNormal=normalize(normalMatrix*normal);
+  float t=uTime*uSpeed;
+  vec3 noisePos=0.43*position*uDensity;
+  float distortion=0.75*cnoise(noisePos+t);
+  vec3 pos=position+normal*distortion*uStrength;
+  vPos=pos;
+  vec4 mvPos=modelViewMatrix*vec4(pos,1.0);
+  vViewPos=mvPos.xyz;
+  gl_Position=projectionMatrix*mvPos;
+}`;
+
+    const FRAG_DEFAULTS = `varying vec3 vPos;varying vec3 vNormal;varying vec3 vViewPos;uniform vec3 uColor1;uniform vec3 uColor2;uniform vec3 uColor3;
+void main(){
+  vec3 base=mix(mix(uColor1,uColor2,smoothstep(-3.0,3.0,vPos.x)),uColor3,smoothstep(-2.0,2.0,vPos.z));
+  vec3 n=normalize(vNormal);vec3 v=normalize(-vViewPos);
+  vec3 l1=normalize(vec3(1,1,0.5));vec3 l2=normalize(vec3(-0.5,0.3,1));vec3 l3=normalize(vec3(0,-1,0.3));
+  float diff=max(dot(n,l1),0.0)*0.25+max(dot(n,l2),0.0)*0.15+max(dot(n,l3),0.0)*0.1;
+  float spec=pow(max(dot(n,normalize(l1+v)),0.0),64.0)*0.25+pow(max(dot(n,normalize(l2+v)),0.0),48.0)*0.15;
+  float fresnel=pow(1.0-max(dot(n,v),0.0),4.0);
+  vec3 col=base*(0.65+diff)+vec3(spec)+mix(base,vec3(1),0.3)*fresnel*0.2;
+  gl_FragColor=vec4(col,1.0);
+}`;
+
+    const FRAG_COSMIC = `varying vec3 vPos;varying vec3 vNormal;varying vec3 vViewPos;uniform vec3 uColor1;uniform vec3 uColor2;uniform vec3 uColor3;uniform float uTime;uniform float uSpeed;
+float hash(vec2 p){return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453123);}
+float noise2D(vec2 p){vec2 i=floor(p);vec2 f=fract(p);vec2 u=f*f*(3.0-2.0*f);return mix(mix(hash(i),hash(i+vec2(1,0)),u.x),mix(hash(i+vec2(0,1)),hash(i+vec2(1,1)),u.x),u.y);}
+void main(){
+  float t=uTime*uSpeed;vec3 n=normalize(vNormal);vec3 v=normalize(-vViewPos);
+  float i1=sin(vPos.x*20.0+t*3.0)*cos(vPos.y*15.0+t*2.0);
+  float i2=sin(vPos.x*35.0+t*4.0)*sin(vPos.y*30.0+t*3.5);
+  float i3=cos(vPos.x*50.0+t*5.0)*cos(vPos.y*45.0+t*4.5);
+  float holo=(i1+i2*0.5+i3*0.25)/1.75;
+  float shimmer=noise2D(vPos.xy*40.0+t*2.0)*0.3;float glow=noise2D(vPos.xy*8.0+t*0.5)*0.5;
+  vec3 shift=vec3(sin(vPos.x*10.0+t*2.0)*0.1,sin(vPos.x*10.0+t*2.0+2.094)*0.1,sin(vPos.x*10.0+t*2.0+4.188)*0.1);
+  float gx=smoothstep(-4.0,4.0,vPos.x+holo*2.0);
+  vec3 col=mix(mix(uColor1,uColor2,gx),uColor3,smoothstep(-2.0,2.0,vPos.z)*0.7);
+  col+=shift+vec3(glow*0.15,shimmer*0.1,(glow+shimmer)*0.08);
+  float irid=sin(vPos.x*25.0+t*3.0)*cos(vPos.y*20.0+t*2.5)*0.08;
+  col+=vec3(irid*0.2,irid*0.3,irid*0.4);
+  vec3 l1=normalize(vec3(1,1,0.5));vec3 l2=normalize(vec3(-0.5,0.3,1));
+  float diff=max(dot(n,l1),0.0)*0.2+max(dot(n,l2),0.0)*0.12;
+  float spec=pow(max(dot(n,normalize(l1+v)),0.0),64.0)*0.3+pow(max(dot(n,normalize(l2+v)),0.0),48.0)*0.15;
+  float fresnel=pow(1.0-max(dot(n,v),0.0),4.0);
+  col=col*(0.7+diff)+vec3(spec)+mix(col,vec3(1),0.3)*fresnel*0.25;
+  gl_FragColor=vec4(col,1.0);
+}`;
+
+    const FRAG_GLASS = `varying vec3 vPos;varying vec3 vNormal;varying vec3 vViewPos;uniform vec3 uColor1;uniform vec3 uColor2;uniform vec3 uColor3;
+void main(){
+  vec3 base=mix(mix(uColor1,uColor2,smoothstep(-3.0,3.0,vPos.x)),uColor3,smoothstep(-2.0,2.0,vPos.z));
+  vec3 n=normalize(vNormal);vec3 v=normalize(-vViewPos);
+  float fresnel=pow(1.0-max(dot(n,v),0.0),3.0);
+  vec3 l1=normalize(vec3(1,1,0.5));vec3 l2=normalize(vec3(-0.5,0.3,1));
+  float diff=max(dot(n,l1),0.0)*0.15+max(dot(n,l2),0.0)*0.1;
+  float spec=pow(max(dot(n,normalize(l1+v)),0.0),128.0)*0.5+pow(max(dot(n,normalize(l2+v)),0.0),96.0)*0.25;
+  vec3 col=mix(base,base*0.85+vec3(0.08),fresnel*0.6);
+  col=col*(0.75+diff)+vec3(spec)+mix(base,vec3(1),0.4)*fresnel*0.25;
+  gl_FragColor=vec4(col,1.0);
+}`;
+
+    const FRAGS = { defaults: FRAG_DEFAULTS, cosmic: FRAG_COSMIC, glass: FRAG_GLASS };
+    window._sgShaders = { vertex: vertexShader, defaults: FRAG_DEFAULTS, cosmic: FRAG_COSMIC, glass: FRAG_GLASS };
+
+    function degToRad(d) { return d * Math.PI / 180; }
+
+    let activeRenderers = [];
+
+    function destroyRenderers() {
+      activeRenderers.forEach(r => { r.renderer.dispose(); r.renderer.forceContextLoss(); });
+      activeRenderers = [];
+    }
+
+    let _sgDebounce = null;
+    window._sgUpdateBg = function() {
+      clearTimeout(_sgDebounce);
+      _sgDebounce = setTimeout(_sgUpdateBgNow, 80);
+    };
+    function _sgUpdateBgNow() {
+      destroyRenderers();
+      const bgMode = window.picks ? window.picks.bg_mode : 0;
+      if (!bgMode || bgMode <= 0) return;
+      const preset = window.BG_PRESETS ? window.BG_PRESETS[bgMode] : null;
+      if (!preset || !preset.type) return;
+
+      const colors = window.getBgColors ? window.getBgColors() : ["#ffffff","#888888","#444444"];
+      const cells = document.querySelectorAll('.scene-cell');
+      if (cells.length === 0) return;
+
+      cells.forEach(cell => {
+        cell.querySelectorAll('canvas.sg-bg').forEach(c => c.remove());
+
+        const canvas = document.createElement('canvas');
+        canvas.className = 'sg-bg';
+        canvas.style.cssText = 'position:absolute;inset:0;width:100%;height:100%;z-index:0;pointer-events:none;';
+        cell.insertBefore(canvas, cell.firstChild);
+
+        const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: true });
+        renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
+
+        const scene = new THREE.Scene();
+        const camera = new THREE.PerspectiveCamera(45, 16/9, 0.1, 100);
+
+        const isSphere = preset.type === 'sphere';
+        const dist = isSphere ? 14 : preset.camDist;
+        const az = degToRad(preset.camAz);
+        const pol = degToRad(preset.camPol);
+        camera.position.set(dist*Math.sin(pol)*Math.sin(az), dist*Math.cos(pol), dist*Math.sin(pol)*Math.cos(az));
+        camera.lookAt(0, 0, 0);
+        camera.zoom = isSphere ? (preset.zoom || 1) : 1;
+        camera.updateProjectionMatrix();
+
+        scene.add(new THREE.AmbientLight(0xffffff, 0.6));
+        const dir = new THREE.DirectionalLight(0xffffff, 0.8);
+        dir.position.set(5, 5, 5);
+        scene.add(dir);
+
+        const frag = preset.fragmentShader || FRAGS[preset.shader] || FRAG_DEFAULTS;
+        const uniforms = {
+          uTime: { value: 0 },
+          uSpeed: { value: preset.speed },
+          uDensity: { value: preset.density },
+          uStrength: { value: preset.strength },
+          uColor1: { value: new THREE.Color(colors[0]) },
+          uColor2: { value: new THREE.Color(colors[1]) },
+          uColor3: { value: new THREE.Color(colors[2]) }
+        };
+
+        const material = new THREE.ShaderMaterial({ vertexShader, fragmentShader: frag, uniforms, side: THREE.DoubleSide });
+
+        let geometry;
+        if (isSphere) geometry = new THREE.SphereGeometry(1, 256, 256);
+        else geometry = new THREE.PlaneGeometry(10, 10, 128, 128);
+
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.rotation.set(degToRad(preset.rotX), degToRad(preset.rotY), degToRad(preset.rotZ));
+        mesh.position.set(preset.posX || 0, preset.posY || 0, preset.posZ || 0);
+        scene.add(mesh);
+
+        const frame = cell.querySelector('.scene-frame');
+        if (frame) {
+          frame.style.background = 'transparent';
+          const root = frame.querySelector(':scope > div');
+          if (root) root.style.background = 'transparent';
+        }
+
+        activeRenderers.push({ renderer, scene, camera, uniforms, canvas });
+      });
+
+      if (!window._sgAnimating) {
+        window._sgAnimating = true;
+        function animate() {
+          const t = performance.now() * 0.001;
+          activeRenderers.forEach(s => {
+            const w = s.canvas.offsetWidth, h = s.canvas.offsetHeight;
+            if (w <= 0) return;
+            s.renderer.setSize(w, h, false);
+            s.camera.aspect = w / h;
+            s.camera.updateProjectionMatrix();
+            s.uniforms.uTime.value = t;
+            s.renderer.render(s.scene, s.camera);
+          });
+          requestAnimationFrame(animate);
+        }
+        animate();
+      }
+    };
+    </script>
   </body>
 </html>