Skip to content

Text to motion graphics for Claude Code and Codex: write a brief, get a checked MP4. 30 art forms from claymation and paper cut-out to anime and pixel art, 2D explainers, Shorts, 3D products. Installs brief2motion for websites. MIT.

feat: art forms, 30 looks with references, a brief router, generated pages and tests

Varun Pratap Bhardwaj6e447271c0b3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3fa3d7b..250b43c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,19 @@
All notable changes to brief2mp4. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses [Semantic Versioning](https://semver.org/).
+## [Unreleased]
+
+### Added
+- **Art forms.** Thirty looks for animated video, each with its own reference page: what makes it read as that form, its timing, how to build it in HyperFrames, canvas, SVG or Three.js, the assets it needs, the sound that fits, what makes it look wrong, and sources. Craft and handmade (claymation, stop-motion, paper cut-out, felt, origami, shadow puppetry, collage, risograph), drawn and painted (anime and cel shading, flat explainer, whiteboard and chalkboard, watercolour, ink wash, line art, rotoscope, motion comic, UPA mid-century, rubber-hose, linocut), geometry and 3D (isometric, low-poly, voxel, pixel art, product render), type, data and retro (kinetic typography, infographic, lyric video, VHS and glitch, blueprint, neon sign).
+- `art-forms/looks.js`: 31 small demos, one per look, each a pure function of time, with `art-forms/gallery.html` to view them.
+- `scripts/art_route.py`: proposes an art form from a brief and says why, or says that none fits.
+- `scripts/build_art_forms.py`: generates the index and the 30 pages from `references/art-forms.json` and the demo code, so they cannot drift apart.
+- Tests: `tests/test_art_forms.py` (data, generated pages, router, and a ban on clocks and unseeded randomness in the demos) and `tests/art_forms/check_looks.mjs`, which draws every look in headless Chrome and checks that it paints, changes over time and gives identical pixels when the same time is drawn twice.
+
+### Notes
+- Tested on macOS with Chrome 157. The demos are checked as browser pictures; no art-form video was rendered through HyperFrames for this change.
+- The version number and the marketplace entry are unchanged and need a release decision.
+
## [0.3.0] - 2026-11-15
### Added
diff --git a/README.md b/README.md
index c8c97cc..9a34c0a 100644
--- a/README.md
+++ b/README.md
@@ -129,6 +129,23 @@ Examples 05 (a 20 s explainer) and 06 (a 15 s vertical Short), each made by runn
Every format has a beat sheet, a route and its own checks in [references/formats.md](plugin/skills/brief2mp4/references/formats.md), which the agent reads when your brief names the kind of video.
+### Art forms: ask for a look by name
+
+<p align="center">
+ <img src="assets/art-forms.jpg" alt="A contact sheet of 31 small animation looks: stop-motion blocks, a paper cut-out landscape, felt shapes, origami, shadow puppets on a lamp-lit screen, collage, risograph print, a flat explainer, whiteboard, chalkboard, watercolour, ink wash, line art, rotoscope, a motion comic panel, mid-century cartoon, rubber-hose cartoon, linocut, isometric blocks, pixel art, a blueprint, a neon sign, kinetic type, a bar chart, a lyric video, VHS damage, a clay figure, a cel-shaded shape, a low-poly hill, a voxel tree and a product render." width="100%">
+</p>
+
+Say "claymation", "paper cut-out", "anime", "like a blueprint" or "shadow puppets" and the skill has a recipe for it. [references/art-forms.md](plugin/skills/brief2mp4/references/art-forms.md) indexes 30 art forms; each has a page with what makes it read as that form, its timing, how to build it in HyperFrames, canvas, SVG or Three.js, the assets and sound it needs, what makes it look wrong, and its sources. The picture above is one frame from each of the 31 demos in [`art-forms/looks.js`](plugin/skills/brief2mp4/art-forms/looks.js), drawn by the test that checks them.
+
+| Family | Art forms |
+|---|---|
+| Craft and handmade | claymation, stop-motion, paper cut-out, felt, origami, shadow puppetry, collage, risograph |
+| Drawn and painted | anime and cel shading, flat vector explainer, whiteboard and chalkboard, watercolour, ink wash, line art, rotoscope, motion comic, UPA mid-century, rubber-hose, linocut |
+| Geometry, pixels and 3D | isometric, low-poly, voxel, pixel art, 3D product render |
+| Type, data and retro | kinetic typography, infographic, lyric video, VHS and glitch, blueprint, neon sign |
+
+Three rules carry all of them: the picture is a function of time, handmade looks hold their drawings at 8 to 12 changes a second while the video stays at 24 or 30, and every wobble, flicker and misregistration is seeded by the drawing number, so two renders of the same frame match. `python3 plugin/skills/brief2mp4/scripts/art_route.py BRIEF.md` proposes a form from a brief and says why. The demos are browser pictures checked for determinism; they are starting points for a scene, not finished films.
+
**Proof the skill works:** example brief 01, pasted as written, came back as a 12.000 s, 1920x1080, 30 fps file that passed the delivery check. Its [report](examples/01-kinetic-type/SAMPLE-REPORT.md) lists every requirement with its evidence: which still shows which line, the measured headline height (126 px against a 120 px minimum), the text bounds and the loudness at each sound accent.
## How it works
diff --git a/plugin/skills/brief2mp4/SKILL.md b/plugin/skills/brief2mp4/SKILL.md
index 7d310b2..c1132cc 100644
--- a/plugin/skills/brief2mp4/SKILL.md
+++ b/plugin/skills/brief2mp4/SKILL.md
@@ -1,6 +1,6 @@
---
name: brief2mp4
-description: Turn a written brief into a finished, checked MP4 motion graphic. Use when asked to make an animation, motion graphic, 2D explainer, maths or algorithm animation, tutorial intro, animated story or skit, YouTube Short or Reel, data story, kinetic typography, lyric video, title sequence, logo sting, 3D scene, 3D product shot, physics drop, exploded view, product turntable or short explainer clip as a video file. Builds with HyperFrames (HTML + GSAP), Three.js, an optional 3D pack (CAD, materials, physics), Blender or an optional edit pack (timeline cuts, multitrack mixing, compositing), finishes with ffmpeg, then checks the video against the brief and fixes what fails before handing it over.
+description: Turn a written brief into a finished, checked MP4 motion graphic. Use when asked to make an animation, motion graphic, a video in a named art form or look (claymation, paper cut-out, stop-motion, anime or cel-shaded, watercolour, ink wash, shadow puppet, risograph, pixel art, voxel, low-poly, isometric, whiteboard, VHS or glitch, neon, blueprint), 2D explainer, maths or algorithm animation, tutorial intro, animated story or skit, YouTube Short or Reel, data story, kinetic typography, lyric video, title sequence, logo sting, 3D scene, 3D product shot, physics drop, exploded view, product turntable or short explainer clip as a video file. Builds with HyperFrames (HTML + GSAP), Three.js, an optional 3D pack (CAD, materials, physics), Blender or an optional edit pack (timeline cuts, multitrack mixing, compositing), finishes with ffmpeg, then checks the video against the brief and fixes what fails before handing it over.
---
# brief2mp4
@@ -41,7 +41,7 @@ SPEC.md is the contract you will check against. It has six parts:
| Audio | AAC, 48 kHz, stereo, -14 LUFS integrated, true peak at or below -1 dBTP. Silent only if the brief says silent (still include a silent track) |
2. **Exact text.** Every word that appears on screen, copied character for character from the brief. Spelling, capitals and punctuation are part of the spec.
-3. **Look.** Palette as hex codes, one or two typefaces, background, the mood in five words or fewer.
+3. **Look.** Palette as hex codes, one or two typefaces, background, the mood in five words or fewer. If the brief names an art form or describes a look ("claymation", "like a paper cut-out", "anime", "hand-drawn"), name it here with its cadence: see **Art forms** below.
4. **Beat sheet.** Time ranges (`0.0-2.0 s`), what is on screen, what moves, and where the one hero moment lands. Something must be visible by 0.3 s. The final message holds for the last 1.5-2.5 s.
5. **Tool choice** (section 2) and one sentence on why.
6. **Done when.** One checklist line per requirement in the brief, each one checkable by a command or by looking at a named frame: "`final.mp4` is 12.0 s", "at 9.5 s the words FINISH SOMETHING TODAY are fully on screen, nothing cut off".
@@ -65,6 +65,20 @@ If the brief names a kind of video (explainer, maths, tutorial intro, skit, Shor
Mixing is normal: render a Blender shot to frames, then use it as a video layer under HyperFrames type, or join HyperFrames and Blender clips with ffmpeg. Every path ends with `scripts/finish.sh` and `scripts/check_delivery.sh`.
+### Art forms: when the brief asks for a look
+
+Thirty art forms have a recipe each: claymation, stop-motion, paper cut-out, felt, origami, shadow puppetry, collage, risograph, anime and cel shading, flat vector explainer, whiteboard and chalkboard, watercolour, ink wash, line art, rotoscope, motion comic, UPA mid-century, rubber-hose, linocut, isometric, low-poly, voxel, pixel art, 3D product render, kinetic typography, infographic, lyric video, VHS and glitch, blueprint, neon sign.
+
+```bash
+python3 <this skill's folder>/scripts/art_route.py BRIEF.md # proposes one, with the reason, or says none fits
+```
+
+Read `references/art-forms.md` (the index and the three rules), then only the page for the form you chose in `references/art-forms/`. Each page gives the visual rules, the timing, how to build it in HyperFrames, canvas, SVG or Three.js, what assets it needs, the sound that fits, what makes it look wrong, and a tested demo from `art-forms/looks.js`. The router is a keyword scorer: a look the brief names always wins, and when it suggests none, do not force one.
+
+Three rules carry every look. The picture is a function of time (no clock, no `Math.random()`). Handmade looks hold their drawings: quantise time to 8 to 12 changes a second (`Math.floor(t * 12) / 12`, or GSAP `ease: "steps(12)"`) while the video stays at 24 or 30. Imperfection (line boil, paper jitter, flicker, misregistered ink) is seeded by the drawing number, so two renders match. Write the cadence into the beat sheet, and add a **Done when** line for the look: "at 4.0 s the frame shows flat paper layers with a shadow under each; the bird's wings change at most 12 times a second".
+
+An art form sets the look and the timing. The format (`references/formats.md`) still sets the beats and the tool table above still sets the route.
+
### The 3D pack (optional)
Run `bash <this skill's folder>/scripts/detect_3d.sh`. If it prints `3d: ready`, build 3D product beats with it: `model` (CAD or mesh spec to GLB), `material` (presets), `physics` (a baked, deterministic Jolt track), `hf` (shot JSON to a HyperFrames project) and `blender` (photoreal hero). Read `3d/README-3D.md` first: it maps brief language to shot JSON ("parts fall and settle" is physics plus `camera.auto`, "show what's inside" is `explode`, "hero product" is `blender --look dramatic`) and lists the look rules (Neutral tone mapping, a dim environment around 0.35, a shadow-catcher floor, linear colours, bloom only for emissive parts).
@@ -143,9 +157,11 @@ That message means: re-read the **original brief** (not your spec), go through i
- `references/blender.md`: headless Blender, engines, light, camera, text, frames
- `references/ffmpeg.md`: finishing, joining, overlays, sound, loudness, inspection
- `references/formats.md`: beat sheets, routes and checks per format (explainer, maths, tutorial, story, Short, data, launch, logo, lyric, captions)
+- `references/art-forms.md` and `references/art-forms/<id>.md`: 30 art forms, each with visual rules, timing, a build recipe, assets, sound, pitfalls, sources and a tested demo (generated from `references/art-forms.json`)
+- `art-forms/looks.js`, `art-forms/gallery.html`: one deterministic demo per look, and a viewer
- `references/pipelines.md`: architecture diagram, route per beat, recipes for mixed pipelines, methods
- `references/ecosystem.md`: 45+ open-source motion, 3D and agent-skill repos, when to use each, how to connect them
- `3d/README-3D.md`: the optional 3D pack (components, commands, shot JSON, brief-to-shot mapping, look rules)
- `edit/README-EDIT.md`: the optional edit pack (ArtCraft editors: install, verification, recipes, command discovery, MCP)
-- `scripts/finish.sh`, `scripts/check_delivery.sh`, `scripts/contact_sheet.sh`, `scripts/sound_bed.sh`, `scripts/doctor.sh`, `scripts/detect_3d.sh`, `scripts/bounds.py`, `scripts/vendor_libs.sh`, `scripts/detect_edit.sh`
+- `scripts/finish.sh`, `scripts/check_delivery.sh`, `scripts/contact_sheet.sh`, `scripts/sound_bed.sh`, `scripts/doctor.sh`, `scripts/detect_3d.sh`, `scripts/bounds.py`, `scripts/vendor_libs.sh`, `scripts/detect_edit.sh`, `scripts/art_route.py` (brief to art form), `scripts/build_art_forms.py` (regenerates the art-form pages)
- `templates/SPEC.md`, `templates/threejs/index.html`, `templates/blender/scene.py`
diff --git a/plugin/skills/brief2mp4/references/art-forms.json b/plugin/skills/brief2mp4/references/art-forms.json
new file mode 100644
index 0000000..defaf35
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms.json
@@ -0,0 +1,1527 @@
+{
+ "version": 1,
+ "checked": "2026-11-17",
+ "families": {
+ "craft": "Craft and handmade",
+ "drawn": "Drawn and painted",
+ "geometry": "Geometry, pixels and 3D",
+ "type": "Type, data and retro"
+ },
+ "forms": [
+ {
+ "id": "claymation",
+ "name": "Claymation",
+ "aliases": [
+ "clay animation",
+ "plasticine animation"
+ ],
+ "family": "craft",
+ "what": "Figures of clay or plasticine, posed and photographed one frame at a time. Soft, lumpy, a little uneven, and never perfectly smooth in motion.",
+ "origin": "Plasticine dates from 1897. Art Clokey (Gumby) and Aardman, founded in 1972, made the look famous.",
+ "rules": [
+ "Rounded volumes with small lumps and dents, never a perfect sphere",
+ "Matte, high-roughness surfaces under soft light",
+ "Saturated colour, few of them",
+ "Small asymmetries; a silhouette that changes slightly between poses",
+ "A miniature set: a floor, a backdrop, shallow depth"
+ ],
+ "timing": "Shot on doubles: about 12 pose changes a second inside a 24 frames-a-second film. Each held pose sits a hair differently from the last.",
+ "fps": 12,
+ "build": [
+ "Three.js: `MeshStandardMaterial` with roughness about 0.9, metalness 0, and a noise canvas as `bumpMap`",
+ "Push each vertex in or out by a few percent with a seeded hash, then `computeVertexNormals()`",
+ "Pose from stepped time: `held(t, 12)`",
+ "Add a seeded nudge per drawing to position and rotation (about 2% of the size)",
+ "A hemisphere light plus one soft key; no hard specular highlights"
+ ],
+ "assets": "Geometry in code (spheres, capsules, lathes) for simple characters. Fingerprint or noise detail as a generated bump texture. A real character needs modelling.",
+ "sound": "Close foley on pose changes (soft thuds, squelches), light percussion. Practice note.",
+ "pitfalls": [
+ "Smooth 24 or 30 frames-a-second motion: it reads as CG, not clay",
+ "Glossy plastic highlights",
+ "Perfect symmetry and clean edges"
+ ],
+ "route": "Three.js inside HyperFrames",
+ "blender": "Use Blender when the clay needs real subsurface scattering, soft area-light shadows or sculpted detail.",
+ "keywords": [
+ "clay",
+ "claymation",
+ "plasticine",
+ "aardman",
+ "wallace",
+ "gumby",
+ "stop motion clay",
+ "play-doh",
+ "clay 3d"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Clay_animation",
+ "https://en.wikipedia.org/wiki/Stop_motion"
+ ],
+ "looks": [
+ "claymation"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "stop-motion",
+ "name": "Stop-motion look",
+ "aliases": [],
+ "family": "craft",
+ "what": "Any real object moved and photographed a pose at a time. On screen it shows as stepped motion, tiny position errors and light that flickers a little.",
+ "origin": "As old as film: stop tricks appear in the 1890s. Pixilation, cut-out and puppet animation are all forms of it.",
+ "rules": [
+ "Real materials: wood, card, cloth, plastic",
+ "Position jitter of a pixel or two between drawings",
+ "Lighting that varies slightly frame to frame",
+ "Hard cuts between poses, no in-between blur"
+ ],
+ "timing": "On twos (12 changes a second) is the usual cadence; action sometimes on ones, held moments on threes or more.",
+ "fps": 12,
+ "build": [
+ "Quantise time before anything else: `const ts = held(t, 12)`",
+ "GSAP: `ease: \"steps(12)\"` on a one-second tween does the same for a tween",
+ "Jitter and flicker keyed to the frame number: `jit(frameOf(t, 12), i, 1.2)`",
+ "Keep the camera and background steady: step the subject, not the world"
+ ],
+ "assets": "None needed. Everything is procedural.",
+ "sound": "Foley that lands on pose changes. A bed that is not too smooth. Practice note.",
+ "pitfalls": [
+ "Stepping the camera and background together, so everything strobes",
+ "Easing between held poses, which defeats the look",
+ "Jitter so large the object vibrates"
+ ],
+ "route": "HyperFrames (canvas or DOM) or Three.js",
+ "blender": "",
+ "keywords": [
+ "stop motion",
+ "stop-motion",
+ "frame by frame",
+ "stepped",
+ "on twos",
+ "handmade",
+ "lego",
+ "brickfilm"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Stop_motion",
+ "https://en.wikipedia.org/wiki/Clay_animation",
+ "https://gsap.com/docs/v3/Eases/SteppedEase/"
+ ],
+ "looks": [
+ "stop-motion"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "paper-cutout",
+ "name": "Paper cut-out",
+ "aliases": [
+ "papercraft",
+ "cutout animation"
+ ],
+ "family": "craft",
+ "what": "Flat shapes cut from paper or card, layered, and moved a pose at a time. Parts hinge at joints; nothing bends.",
+ "origin": "Lotte Reiniger's The Adventures of Prince Achmed (1926) is the oldest surviving animated feature. Terry Gilliam's Monty Python animations and the South Park pilot used cut paper.",
+ "rules": [
+ "Flat fills with hard, slightly uneven cut edges",
+ "Layers stacked with a small, tight shadow under each",
+ "Rigid parts that rotate about a pivot",
+ "Paper grain over everything",
+ "A limited, slightly muted palette"
+ ],
+ "timing": "Stop-motion cadence, usually on twos. Motion is rotation about joints and sliding, with pops and holds.",
+ "fps": 12,
+ "build": [
+ "Each part is its own shape; nudge the corners with a seeded hash so edges look cut by hand",
+ "Canvas: `shadowOffsetY` 3 to 4 px with `shadowBlur` 4 to 5 px per layer. DOM: `filter: drop-shadow()`",
+ "Joints: rotate about a pivot (`transformOrigin` in GSAP, `translate` then `rotate` on a canvas)",
+ "Paper grain: a noise texture drawn once and laid over with `multiply`",
+ "SVG route: `feTurbulence` into `feDisplacementMap` (scale 2 to 4) roughens an edge"
+ ],
+ "assets": "Shapes drawn in code or as SVG. Photo cut-outs need images you own, or generated ones.",
+ "sound": "Paper rustle, snips, soft ticks on pose changes. Practice note.",
+ "pitfalls": [
+ "Smooth vector motion with no stepping",
+ "Perfect edges",
+ "Large soft shadows, which look like interface cards, not paper"
+ ],
+ "route": "HyperFrames (canvas, SVG or DOM)",
+ "blender": "Use Blender for real folded paper with thickness and light passing through it.",
+ "keywords": [
+ "paper",
+ "cut-out",
+ "cutout",
+ "papercraft",
+ "paper craft",
+ "south park",
+ "collage paper",
+ "layered paper",
+ "craft"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Cutout_animation",
+ "https://en.wikipedia.org/wiki/Lotte_Reiniger",
+ "https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/feDisplacementMap"
+ ],
+ "looks": [
+ "paper-cutout"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "felt",
+ "name": "Felt and fabric craft",
+ "aliases": [
+ "needle felt",
+ "fabric craft"
+ ],
+ "family": "craft",
+ "what": "Shapes that look needle-felted or sewn: a fuzzy edge of loose fibres, a matte mottled surface, visible stitches.",
+ "origin": "Needle felting tangles wool fibres with barbed needles to make flat pictures and soft figures.",
+ "rules": [
+ "A halo of short fibres along every edge",
+ "Matte, slightly mottled colour",
+ "Stitches: a dashed line just inside the edge",
+ "Chunky, simple forms in wool colours"
+ ],
+ "timing": "Stop-motion cadence, on twos. Gentle bobbing and nudging.",
+ "fps": 12,
+ "build": [
+ "Draw the shape, then several hundred short strokes outward from its edge, each angled by a seeded hash",
+ "Stitches: `setLineDash([9, 7])` on a path just inside the edge (SVG: `stroke-dasharray`)",
+ "Mottle: a grain texture clipped to the shape with `multiply`",
+ "SVG route: high-frequency `feTurbulence` (0.8 to 1.2) with displacement scale 3 to 6 on the edge"
+ ],
+ "assets": "Procedural. A felt texture from an image model helps for close-ups.",
+ "sound": "Soft, warm, acoustic. Practice note.",
+ "pitfalls": [
+ "Crisp vector edges",
+ "Flat plastic colour",
+ "No fibre fuzz"
+ ],
+ "route": "HyperFrames (canvas or SVG)",
+ "blender": "Use Blender hair or fur for real fibre fuzz on 3D figures.",
+ "keywords": [
+ "felt",
+ "fabric",
+ "wool",
+ "needle felt",
+ "knitted",
+ "sewn",
+ "stitched",
+ "textile",
+ "plush"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Needle_felting"
+ ],
+ "looks": [
+ "felt"
+ ],
+ "thin": "The craft is well documented; its use in animation is a practice note, not sourced."
+ },
+ {
+ "id": "origami",
+ "name": "Origami",
+ "aliases": [],
+ "family": "craft",
+ "what": "Paper folded from a flat sheet: sharp creases, flat facets, each fold a clean move followed by a pause.",
+ "origin": "Japanese paper folding. Modern computational origami works from crease patterns.",
+ "rules": [
+ "Sharp mountain and valley creases",
+ "Flat facets, each shaded as one plane",
+ "Paper coloured on one side, white on the other",
+ "Soft, even light so the creases read"
+ ],
+ "timing": "Folds are eased moves of about 0.8 seconds with a short hold after each. Smooth, not stepped.",
+ "fps": null,
+ "build": [
+ "2D: a fold is a point travelling across the crease; draw the moving flap from the crease to that point",
+ "Shade the flap by its angle, and swap to the paper's other colour past 90 degrees",
+ "3D: flat-shaded polygons, child groups rotating about the crease axis",
+ "An orthographic camera gives a diagram-clean view"
+ ],
+ "assets": "Geometry in code. A faint paper grain.",
+ "sound": "Light paper crinkle on each fold, soft piano or music box. Practice note.",
+ "pitfalls": [
+ "Faces passing through each other",
+ "Folding with no hold, so the eye cannot follow",
+ "Light that hides the creases"
+ ],
+ "route": "HyperFrames (canvas or SVG), or Three.js",
+ "blender": "Use Blender when the paper has to bend or show thickness.",
+ "keywords": [
+ "origami",
+ "fold",
+ "folding",
+ "paper crane",
+ "folded paper",
+ "crease"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Origami",
+ "https://github.com/amandaghassaei/OrigamiSimulator"
+ ],
+ "looks": [
+ "origami"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "shadow-puppet",
+ "name": "Shadow puppetry",
+ "aliases": [
+ "shadow play",
+ "Ravana Chhaya",
+ "wayang kulit",
+ "silhouette animation"
+ ],
+ "family": "craft",
+ "what": "Flat figures held between a lamp and a cloth screen: dark silhouettes with punched patterns on a warm, glowing field.",
+ "origin": "An old tradition across Asia. Ravana Chhaya of Odisha uses uncoloured deerskin puppets with no joints; wayang kulit of Java and Bali was recognised by UNESCO in 2003. Lotte Reiniger brought silhouettes to film.",
+ "rules": [
+ "Black silhouettes on a warm lit screen, never on white",
+ "Interior detail made of perforations: rows of holes and cut patterns",
+ "A lamp that flickers",
+ "The shadow softens and grows as the puppet moves away from the screen",
+ "Rods visible below the figures"
+ ],
+ "timing": "Live puppets move continuously on rods; film versions are stop-motion, so use twos. Stiff, deliberate moves; no squash and stretch.",
+ "fps": 12,
+ "build": [
+ "One path per puppet filled with the even-odd rule, so holes are part of the figure",
+ "Screen: a radial gradient from warm yellow to deep brown",
+ "Flicker: scale the lamp brightness by a seeded value per drawing",
+ "Distance from the screen: `filter: blur()` growing with distance, and lower opacity",
+ "Ravana Chhaya style: no joints, move and tilt the whole puppet. Wayang style: hinge the arms"
+ ],
+ "assets": "Simple figures in code. Ornate traditional figures need drawing or tracing with care.",
+ "sound": "Narrator, singers and percussion in the tradition: cymbals and drums for Ravana Chhaya, gamelan for wayang.",
+ "pitfalls": [
+ "Black on white, which loses the lamp",
+ "Smooth modern vector motion",
+ "Careless drawings of sacred figures: check the iconography with a source"
+ ],
+ "route": "HyperFrames (canvas or SVG)",
+ "blender": "Use Blender for real light through translucent coloured leather.",
+ "keywords": [
+ "shadow puppet",
+ "shadow play",
+ "silhouette",
+ "ravana chhaya",
+ "wayang",
+ "puppet",
+ "lotte reiniger",
+ "lamp",
+ "leather puppet"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Shadow_play",
+ "https://en.wikipedia.org/wiki/Ravana_Chhaya",
+ "https://en.wikipedia.org/wiki/Lotte_Reiniger"
+ ],
+ "looks": [
+ "shadow-puppet"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "collage",
+ "name": "Collage and mixed media",
+ "aliases": [
+ "photomontage",
+ "mixed media"
+ ],
+ "family": "craft",
+ "what": "Pieces of different papers, photographs and print stuck together: mismatched scale and texture, torn edges, hard shadows.",
+ "origin": "From the French coller, to glue. Braque and Picasso brought it into modern art around 1912; Dada followed with photomontage.",
+ "rules": [
+ "Torn or cut edges",
+ "Mixed materials: flat colour, halftone photograph, tape",
+ "Overlap with a hard, offset shadow",
+ "Mismatched scale on purpose",
+ "One palette holding it together"
+ ],
+ "timing": "On twos or threes. Pieces pop into place on the beat with a small rotation, then hold.",
+ "fps": 8,
+ "build": [
+ "Torn edge: walk the outline of a rectangle and nudge every point with a seeded hash",
+ "Hard shadow: `shadowBlur: 0` with an offset of 5 to 6 px",
+ "Halftone a photo: dots on a staggered grid sized by brightness",
+ "Entrance: scale from 1.25 to 1 with a quarter-turn of rotation over a quarter of a second"
+ ],
+ "assets": "Paper textures in code. Photo fragments need images you own, or generated ones.",
+ "sound": "Bright percussive music, staccato effects on each pop. Practice note.",
+ "pitfalls": [
+ "Everything neatly aligned",
+ "No shadows",
+ "Too many unrelated colours and typefaces"
+ ],
+ "route": "HyperFrames (canvas or DOM)",
+ "blender": "",
+ "keywords": [
+ "collage",
+ "mixed media",
+ "photomontage",
+ "scrapbook",
+ "zine",
+ "torn paper",
+ "cut and paste",
+ "gilliam"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Collage",
+ "https://en.wikipedia.org/wiki/Cutout_animation"
+ ],
+ "looks": [
+ "collage"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "risograph",
+ "name": "Risograph and halftone print",
+ "aliases": [
+ "riso",
+ "halftone print"
+ ],
+ "family": "craft",
+ "what": "The look of a cheap stencil print: two to four bright inks laid over each other, visible grain, dot screens, and layers that never quite line up.",
+ "origin": "The Risograph duplicator dates from 1980: one ink per drum, so each colour is a separate pass. Halftone dots go back to the 1860s.",
+ "rules": [
+ "Two to four spot colours, often pink, blue and yellow",
+ "Inks overprint to make new colours (multiply)",
+ "Each layer sits a pixel or two off register",
+ "Grain and dot screens; no smooth gradients",
+ "Off-white paper"
+ ],
+ "timing": "Print is still. Animate by re-rolling the misregistration and swapping the grain 8 to 12 times a second.",
+ "fps": 8,
+ "build": [
+ "Each ink is its own layer drawn with `mix-blend-mode: multiply` (canvas: `globalCompositeOperation`)",
+ "Offset each layer by a seeded amount per drawing: `jit(frameOf(t, 8), layer, 3)`",
+ "Tone as dots: a staggered grid of circles whose radius follows the tone",
+ "Grain: several pre-made noise tiles, cycled by frame number",
+ "Three.js `HalftonePass` exists for 3D scenes; SVG `feColorMatrix` separates a photo into one ink"
+ ],
+ "assets": "All procedural. A chunky sans or slab typeface.",
+ "sound": "Lo-fi, tape hiss. Practice note.",
+ "pitfalls": [
+ "Gradients",
+ "Perfect registration",
+ "More than four colours"
+ ],
+ "route": "HyperFrames (canvas or DOM)",
+ "blender": "",
+ "keywords": [
+ "riso",
+ "risograph",
+ "halftone",
+ "print",
+ "screen print",
+ "overprint",
+ "zine print",
+ "duotone print",
+ "ben-day"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Risograph",
+ "https://en.wikipedia.org/wiki/Halftone",
+ "https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode"
+ ],
+ "looks": [
+ "risograph"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "cel-shaded",
+ "name": "Anime and cel shading",
+ "aliases": [
+ "anime",
+ "toon shading"
+ ],
+ "family": "drawn",
+ "what": "Light broken into two or three flat tones with a hard edge between them, and an ink outline around every form.",
+ "origin": "Named after the celluloid sheets of hand-drawn animation. In 3D it became toon shading, as in Jet Set Radio and The Wind Waker.",
+ "rules": [
+ "Two or three tone bands with hard edges",
+ "Shadows tinted with colour, not black",
+ "A clean outline",
+ "Flat, detailed backgrounds behind simpler characters",
+ "Limited animation: holds, then sudden moves"
+ ],
+ "timing": "On twos as the baseline, ones for key action, threes and holds for dialogue.",
+ "fps": 12,
+ "build": [
+ "Three.js `MeshToonMaterial` with a `gradientMap`: a three-texel `DataTexture` with `NearestFilter`, so light snaps to bands",
+ "Outline by inverted hull: a second copy of each mesh, slightly larger, drawn back faces only in black",
+ "`OutlineEffect` and `SobelOperatorShader` in the three.js examples are the two other routes",
+ "Step the pose time: `held(t, 12)`",
+ "2D: flat SVG shapes, a thick outline, `steps()` timing"
+ ],
+ "assets": "The gradient map is three bytes. Characters need modelling or generated models.",
+ "sound": "Whoosh and impact effects on key poses. Practice note.",
+ "pitfalls": [
+ "Smooth interpolation at 24 frames a second",
+ "More than three bands",
+ "Shadows that are only a darker grey"
+ ],
+ "route": "Three.js inside HyperFrames",
+ "blender": "Use Blender for Freestyle line art and shader-to-RGB ramps on real characters.",
+ "keywords": [
+ "anime",
+ "cel",
+ "cel-shaded",
+ "toon",
+ "manga",
+ "cartoon shader",
+ "ghibli",
+ "spider-verse",
+ "japanese animation"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Cel_shading",
+ "https://en.wikipedia.org/wiki/Limited_animation",
+ "https://github.com/mrdoob/three.js"
+ ],
+ "looks": [
+ "cel-shaded"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "flat-explainer",
+ "name": "2D flat vector explainer",
+ "aliases": [
+ "motion graphics explainer"
+ ],
+ "family": "drawn",
+ "what": "The plain explainer look: flat fills, a few colours, simple shapes and icons, smooth eased motion.",
+ "origin": "Flat design comes from Swiss style and modernism; in animation its ancestor is the stylised, limited look of the UPA studio.",
+ "rules": [
+ "Flat fills, three to five colours, one accent",
+ "Geometric shapes with one stroke width",
+ "Plenty of space; one idea per frame",
+ "Clean sans type"
+ ],
+ "timing": "Smooth ease-out moves of 0.4 to 0.8 seconds, staggered, with holds long enough to read.",
+ "fps": null,
+ "build": [
+ "HTML or SVG with GSAP: this is what HyperFrames is best at",
+ "Stagger related items 0.15 to 0.25 seconds apart",
+ "Draw check marks and connectors on with `stroke-dashoffset`",
+ "Move a highlight instead of cutting"
+ ],
+ "assets": "All in code.",
+ "sound": "Soft interface blips, a light bed, voice-led pacing. Practice note.",
+ "pitfalls": [
+ "A grid of identical cards",
+ "Gradients and shadows creeping in",
+ "Too much on screen at once"
+ ],
+ "route": "HyperFrames (DOM, SVG)",
+ "blender": "",
+ "keywords": [
+ "explainer",
+ "flat",
+ "vector",
+ "motion graphics",
+ "corporate",
+ "saas",
+ "icon animation",
+ "infographic style"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Flat_design",
+ "https://en.wikipedia.org/wiki/United_Productions_of_America"
+ ],
+ "looks": [
+ "flat-explainer"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "whiteboard",
+ "name": "Whiteboard and doodle",
+ "aliases": [
+ "video scribing",
+ "chalkboard"
+ ],
+ "family": "drawn",
+ "what": "Marker lines that draw themselves on a white board, in the order someone would draw them. The chalkboard is the same recipe, inverted.",
+ "origin": "Also called video scribing. A 2016 study found little evidence that it teaches better than other formats, so use it for its tone, not as a learning trick.",
+ "rules": [
+ "Black marker lines with a slight wobble",
+ "Strokes appear in drawing order",
+ "One or two accent colours",
+ "Chalk variant: a dark board, dusty broken strokes, a little smudge"
+ ],
+ "timing": "Each element draws on over 0.3 to 1.5 seconds, paced to the narration. The line boils at about 10 changes a second.",
+ "fps": 10,
+ "build": [
+ "Draw-on: a polyline drawn up to a fraction of its length (SVG: `stroke-dashoffset`)",
+ "Boil: nudge every point by a seeded amount keyed to `frameOf(t, 10)`",
+ "Chalk: three thin passes of the same stroke with different dash patterns at half opacity, over a speckled board",
+ "rough.js (MIT) generates sketchy shapes and hatching to animate afterwards"
+ ],
+ "assets": "All in code. A marker or chalk typeface if the system has one.",
+ "sound": "Marker squeak, voice-led. Practice note.",
+ "pitfalls": [
+ "Perfect vector lines",
+ "A hand that covers the drawing",
+ "Paragraphs of text"
+ ],
+ "route": "HyperFrames (canvas or SVG)",
+ "blender": "",
+ "keywords": [
+ "whiteboard",
+ "doodle",
+ "scribe",
+ "sketch",
+ "hand-drawn",
+ "marker",
+ "chalkboard",
+ "chalk",
+ "blackboard"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Whiteboard_animation",
+ "https://github.com/rough-stuff/rough"
+ ],
+ "looks": [
+ "whiteboard",
+ "chalkboard"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "watercolour",
+ "name": "Watercolour",
+ "aliases": [
+ "watercolor"
+ ],
+ "family": "drawn",
+ "what": "Transparent washes on textured paper: colour that spreads, pools darker at its edge, and lets the paper show through.",
+ "origin": "Pigment in water on paper. Wet-on-wet blends softly; wet-on-dry gives crisp edges.",
+ "rules": [
+ "Transparent colour; overlaps make new colours",
+ "Darker pigment at the edge of each wash",
+ "Irregular, soft outlines",
+ "Paper grain visible everywhere",
+ "Unpainted paper as the highlight"
+ ],
+ "timing": "Slow. A wash grows over 1 to 3 seconds with an ease-out. Hold drawings at 12 a second for a hand-painted feel.",
+ "fps": 12,
+ "build": [
+ "Each wash: an irregular closed outline, clipped, filled with a radial gradient that is darkest near the rim",
+ "Layer washes with `multiply`",
+ "Paper grain over everything with `multiply`",
+ "SVG route: low-frequency `feTurbulence` (0.01 to 0.03) into `feDisplacementMap` (scale 10 to 25) for bleeding edges",
+ "3D: a Kuwahara filter as a custom pass gives a painterly result; three.js ships none"
+ ],
+ "assets": "Procedural. A scanned paper texture improves close-ups.",
+ "sound": "Slow, gentle, acoustic. Practice note.",
+ "pitfalls": [
+ "Opaque flat colour",
+ "A uniform blur, which looks out of focus, not painted",
+ "No paper texture"
+ ],
+ "route": "HyperFrames (canvas or SVG)",
+ "blender": "",
+ "keywords": [
+ "watercolour",
+ "watercolor",
+ "painted",
+ "wash",
+ "painterly",
+ "aquarelle",
+ "soft paint"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Watercolor_painting",
+ "https://blog.maximeheckel.com/posts/on-crafting-painterly-shaders",
+ "https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/feTurbulence"
+ ],
+ "looks": [
+ "watercolour"
+ ],
+ "thin": "The edge-darkening rule is a practice note; the technique sources cover the filter, not the look."
+ },
+ {
+ "id": "ink-wash",
+ "name": "Ink wash (sumi-e)",
+ "aliases": [
+ "sumi-e",
+ "ink painting"
+ ],
+ "family": "drawn",
+ "what": "Black ink in every shade from deep black to pale grey, laid down in tapered brush strokes on rice paper, with a great deal left empty.",
+ "origin": "Chinese ink wash painting from the Tang dynasty, carried to Japan by Zen monks. Shanghai Animation Film Studio made ink-wash films from 1960.",
+ "rules": [
+ "One ink, many dilutions",
+ "Strokes that taper from thick to a point",
+ "Empty paper as part of the picture",
+ "One small red seal",
+ "Soft grey washes behind sharp strokes"
+ ],
+ "timing": "Slow and fluid. A stroke accelerates and lifts. On twos.",
+ "fps": 12,
+ "build": [
+ "A stroke is a row of overlapping dots whose radius tapers along its length, drawn up to a fraction",
+ "Vary each dot's opacity with a seeded hash for a dry-brush break",
+ "Washes: soft radial gradients with `multiply`",
+ "SVG route: variable-width filled paths revealed by a mask"
+ ],
+ "assets": "Procedural. Rice-paper grain.",
+ "sound": "Sparse: flute, single plucked notes, silence. Practice note.",
+ "pitfalls": [
+ "Pure black on pure white",
+ "Uniform stroke width",
+ "Filling the frame"
+ ],
+ "route": "HyperFrames (canvas or SVG)",
+ "blender": "",
+ "keywords": [
+ "ink",
+ "sumi-e",
+ "sumi",
+ "ink wash",
+ "brush",
+ "calligraphy",
+ "zen",
+ "chinese painting",
+ "japanese ink"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Ink_wash_painting",
+ "https://en.wikipedia.org/wiki/Shanghai_Animation_Film_Studio"
+ ],
+ "looks": [
+ "ink-wash"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "line-art",
+ "name": "Line art",
+ "aliases": [
+ "minimal line"
+ ],
+ "family": "drawn",
+ "what": "One weight of line on a plain ground, no shading: the drawing draws itself, then quivers slightly as if redrawn each frame.",
+ "origin": "Drawing with line alone, where tone comes only from hatching or stippling.",
+ "rules": [
+ "A constant or tapered stroke with round ends",
+ "No fills, or one flat tone",
+ "Plenty of empty space",
+ "One accent colour at most"
+ ],
+ "timing": "Draw-on over 1 to 2 seconds, then a boil at 8 to 12 changes a second.",
+ "fps": 10,
+ "build": [
+ "Draw-on with `stroke-dashoffset` (canvas: a polyline to a fraction of its length)",
+ "Boil: a seeded nudge of 1 to 2 px per point, keyed to the frame number",
+ "SVG route: `feTurbulence` with `seed` set from the frame number, into `feDisplacementMap` (scale 1.5 to 3)",
+ "`vector-effect: non-scaling-stroke` keeps the weight when scaled"
+ ],
+ "assets": "All in code.",
+ "sound": "A pencil or pen sound under the draw-on. Practice note.",
+ "pitfalls": [
+ "Jitter so strong the line turns to noise",
+ "Filters that re-run on a large area every frame and slow the render"
+ ],
+ "route": "HyperFrames (SVG or canvas)",
+ "blender": "",
+ "keywords": [
+ "line art",
+ "line drawing",
+ "one line",
+ "minimal line",
+ "outline",
+ "continuous line",
+ "pen drawing"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Line_art",
+ "https://camillovisini.com/coding/simulating-hand-drawn-motion-with-svg-filters"
+ ],
+ "looks": [
+ "line-art"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "rotoscope",
+ "name": "Rotoscope look",
+ "aliases": [],
+ "family": "drawn",
+ "what": "Real movement traced by hand: lifelike motion, flat colour fields that drift, and an outline that shimmers.",
+ "origin": "Max Fleischer built the rotoscope. A Scanner Darkly, Waking Life and the a-ha video for Take On Me are the well-known examples.",
+ "rules": [
+ "Motion with the timing of live action",
+ "Flat or posterised colour fields",
+ "Outlines that change slightly every drawing",
+ "Colour that sits a little off the line"
+ ],
+ "timing": "Every frame or on twos. The boil is keyed to the drawing.",
+ "fps": 12,
+ "build": [
+ "From footage: draw each video frame to a canvas, posterise it, find edges (three.js has `SobelOperatorShader`), then nudge the edges per drawing",
+ "From code: a figure built from joints, drawn twice: thick flat colour offset by a seeded amount, then a thin outline with its own nudge",
+ "Re-encode source video with a keyframe on every frame so seeking is exact"
+ ],
+ "assets": "Footage you own, or a figure built in code.",
+ "sound": "The original scene audio, or music-led. Practice note.",
+ "pitfalls": [
+ "Edge noise that flickers out of control",
+ "Losing the subject in the treatment",
+ "Tracing footage you have no right to use"
+ ],
+ "route": "HyperFrames (canvas over video)",
+ "blender": "Dedicated tools do true painterly rotoscoping better than a browser.",
+ "keywords": [
+ "rotoscope",
+ "rotoscoping",
+ "traced",
+ "scanner darkly",
+ "take on me",
+ "waking life"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Rotoscoping"
+ ],
+ "looks": [
+ "rotoscope"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "motion-comic",
+ "name": "Motion comic",
+ "aliases": [],
+ "family": "drawn",
+ "what": "Comic panels brought to life: layers inside a panel slide at different speeds under a slow camera move, then a hard cut to the next panel.",
+ "origin": "Watchmen: Motion Comic (2008) is the usual first example.",
+ "rules": [
+ "Ink outlines, flat colour, halftone shading",
+ "A panel border",
+ "Foreground, figure and background on separate layers",
+ "Bursts and lettering as graphic elements"
+ ],
+ "timing": "Slow pushes and pans of 2 to 4 seconds, hard cuts between panels, a pop for a burst.",
+ "fps": null,
+ "build": [
+ "Layers in a clipped panel; move far layers less than near ones",
+ "A slow scale from 1 to about 1.07 on the whole panel",
+ "Halftone shading: dots that shrink across the tone",
+ "Cut to the next panel by switching the scene at a time, not by cross-fading"
+ ],
+ "assets": "Drawn panels in layers. Artwork needs an illustrator or generated images cut into layers.",
+ "sound": "Voice, music and effects carry it. Practice note.",
+ "pitfalls": [
+ "A slow zoom on one flat image, which reads as a slideshow",
+ "No separation between figure and background"
+ ],
+ "route": "HyperFrames (DOM or canvas)",
+ "blender": "",
+ "keywords": [
+ "motion comic",
+ "comic",
+ "graphic novel",
+ "panels",
+ "manga panels",
+ "comic book"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Motion_comic",
+ "https://en.wikipedia.org/wiki/Limited_animation"
+ ],
+ "looks": [
+ "motion-comic"
+ ],
+ "thin": "Pan-and-zoom staging is a practice note; the source describes the format, not the technique."
+ },
+ {
+ "id": "upa-midcentury",
+ "name": "UPA and mid-century modern",
+ "aliases": [
+ "mid-century modern",
+ "limited animation"
+ ],
+ "family": "drawn",
+ "what": "Flat, stylised design from 1950s cartoons: geometric characters, abstract backgrounds, colour printed slightly off its outline, and very few drawings.",
+ "origin": "United Productions of America turned away from Disney realism and made limited animation a style. Gerald McBoing-Boing won an Academy Award in 1950.",
+ "rules": [
+ "Characters built from triangles, circles and lines",
+ "Flat colour blocks that do not meet their outlines",
+ "Abstract backgrounds: a few shapes, no perspective",
+ "A warm, muted palette"
+ ],
+ "timing": "Limited animation: a pose is held, then pops to the next. Eight or fewer changes a second.",
+ "fps": 8,
+ "build": [
+ "Flat shapes; draw the outline 6 to 9 px away from the fill",
+ "Two or three poses, switched on a frame count with no in-betweens",
+ "Paper grain with `multiply`"
+ ],
+ "assets": "All in code.",
+ "sound": "Jazz combo, sound effects as music. Practice note.",
+ "pitfalls": [
+ "Smooth, fluid motion",
+ "Gradients and realistic light"
+ ],
+ "route": "HyperFrames (canvas, SVG)",
+ "blender": "",
+ "keywords": [
+ "upa",
+ "mid-century",
+ "midcentury",
+ "1950s",
+ "retro cartoon",
+ "limited animation",
+ "saul bass",
+ "mid century modern"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/United_Productions_of_America",
+ "https://en.wikipedia.org/wiki/Limited_animation"
+ ],
+ "looks": [
+ "upa-midcentury"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "rubber-hose",
+ "name": "Rubber-hose cartoon",
+ "aliases": [],
+ "family": "drawn",
+ "what": "The 1920s cartoon: limbs like hoses with no elbows or knees, round bodies that bounce to the music, black and white film.",
+ "origin": "Credited to Bill Nolan on Felix the Cat. The Fleischer studio kept it longest; Cuphead revived it.",
+ "rules": [
+ "Curved tubular limbs",
+ "Round forms",
+ "Black and white or sepia, high contrast",
+ "Film grain, scratches and a frame that weaves slightly",
+ "Everything moves to the beat"
+ ],
+ "timing": "Bouncy loops locked to the music, on twos, with squash and stretch.",
+ "fps": 12,
+ "build": [
+ "A limb is a quadratic curve between two points; move the control point to bend it",
+ "Squash and stretch: scale the body on one axis by the inverse of the other",
+ "Grain: cycle a few noise tiles by frame; gate weave: shift the whole picture by a seeded pixel or two",
+ "Sepia with `feColorMatrix` if wanted"
+ ],
+ "assets": "All in code. Original characters only.",
+ "sound": "Hot jazz, slide whistles, effects on every bounce. Practice note.",
+ "pitfalls": [
+ "Stiff jointed limbs",
+ "Clean modern gradients",
+ "Copying characters that are still under copyright"
+ ],
+ "route": "HyperFrames (canvas, SVG)",
+ "blender": "",
+ "keywords": [
+ "rubber hose",
+ "rubberhose",
+ "1920s cartoon",
+ "1930s cartoon",
+ "cuphead",
+ "fleischer",
+ "vintage cartoon",
+ "steamboat"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Rubber_hose_animation"
+ ],
+ "looks": [
+ "rubber-hose"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "linocut",
+ "name": "Linocut and woodcut print",
+ "aliases": [],
+ "family": "drawn",
+ "what": "A relief print: bold flat shapes in one to three inks, with white gouge marks where the block was carved.",
+ "origin": "Carved in linoleum or wood; the uncut surface prints. Each colour is a separate block.",
+ "rules": [
+ "Bold shapes, no fine detail",
+ "Short white cut marks inside the ink, all leaning one way",
+ "One to three inks, laid slightly off register",
+ "Paper showing at the edges"
+ ],
+ "timing": "Each colour arrives as a pull, top to bottom, then holds. On twos or slower.",
+ "fps": 8,
+ "build": [
+ "Draw each block to its own canvas, then cut marks out of it: short strokes with `destination-out`",
+ "Print blocks over each other with `multiply`, the second one offset a few pixels",
+ "Reveal a block by widening a clip from the top",
+ "SVG route: `feTurbulence` through a hard threshold makes rough voids"
+ ],
+ "assets": "All in code.",
+ "sound": "A roller, a press, paper lifting. Practice note.",
+ "pitfalls": [
+ "Gradients",
+ "Thin delicate lines",
+ "Too many colours"
+ ],
+ "route": "HyperFrames (canvas, SVG)",
+ "blender": "",
+ "keywords": [
+ "linocut",
+ "woodcut",
+ "block print",
+ "relief print",
+ "printmaking",
+ "carved"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Linocut"
+ ],
+ "looks": [
+ "linocut"
+ ],
+ "thin": "The source covers the technique; the visual rules are practice notes."
+ },
+ {
+ "id": "isometric",
+ "name": "Isometric",
+ "aliases": [],
+ "family": "geometry",
+ "what": "A parallel projection seen from above at an angle: no perspective, three visible faces per block, a tidy model world.",
+ "origin": "A technical drawing projection. Games use a 2:1 pixel slope, about 26.6 degrees, which is strictly dimetric.",
+ "rules": [
+ "No perspective: parallel lines stay parallel",
+ "Three tones per object: top lightest, one side mid, one side darkest",
+ "One light direction for everything",
+ "A grid floor"
+ ],
+ "timing": "The camera does not orbit. Objects drop, stack and slide along the three axes, staggered by grid position.",
+ "fps": null,
+ "build": [
+ "2D: `x = (gx - gy) * s`, `y = (gx + gy) * s / 2 - gz * s`; draw the two side faces, then the top",
+ "Sort by `gx + gy`, then by height, so nearer cubes cover farther ones",
+ "Three.js: an `OrthographicCamera` placed at equal x, y and z looking at the origin",
+ "CSS: `rotateX(60deg) rotateZ(-45deg)` on a flat layer"
+ ],
+ "assets": "All in code.",
+ "sound": "Soft clicks as pieces land. Practice note.",
+ "pitfalls": [
+ "A perspective camera by accident",
+ "Shadows that disagree with the light",
+ "Uneven block heights"
+ ],
+ "route": "HyperFrames (canvas, SVG) or Three.js",
+ "blender": "Use Blender for bevelled, ambient-occluded isometric scenes.",
+ "keywords": [
+ "isometric",
+ "iso",
+ "isometric city",
+ "diorama",
+ "blocks",
+ "tiles",
+ "monument valley"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Isometric_video_game_graphics"
+ ],
+ "looks": [
+ "isometric"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "low-poly",
+ "name": "Low-poly 3D",
+ "aliases": [],
+ "family": "geometry",
+ "what": "Meshes with few polygons, each face lit as one flat facet. A hardware limit that became a style.",
+ "origin": "From the era of early 3D consoles; chosen on purpose since about 2013.",
+ "rules": [
+ "Visible facets, flat shaded",
+ "A limited, saturated palette",
+ "Simple lighting and a gradient or flat sky",
+ "Chunky silhouettes"
+ ],
+ "timing": "Clean, so smooth: slow eased orbits and dollies at the full frame rate.",
+ "fps": null,
+ "build": [
+ "Low segment counts and `flatShading: true` on `MeshStandardMaterial`",
+ "Displace a plane's vertices with a seeded hash for terrain, then `computeVertexNormals()`",
+ "A hemisphere light plus one directional key; fog in the sky colour for depth",
+ "Camera position from `t` directly"
+ ],
+ "assets": "Geometry in code for landscapes and props. Characters need modelling.",
+ "sound": "Calm, spacious. Practice note.",
+ "pitfalls": [
+ "Smooth normals, which erase the facets",
+ "Detailed textures that fight the flat colour"
+ ],
+ "route": "Three.js inside HyperFrames",
+ "blender": "Use Blender for modelling and baked light.",
+ "keywords": [
+ "low poly",
+ "low-poly",
+ "lowpoly",
+ "faceted",
+ "polygon",
+ "polygonal"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Low_poly"
+ ],
+ "looks": [
+ "low-poly"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "voxel",
+ "name": "Voxel",
+ "aliases": [],
+ "family": "geometry",
+ "what": "Everything built from cubes of one size on a grid, like a three-dimensional pixel picture.",
+ "origin": "A voxel is a value on a 3D grid. Minecraft made the look familiar.",
+ "rules": [
+ "One cube size, integer positions",
+ "Each face one flat tone",
+ "A small palette",
+ "Small floating scenes"
+ ],
+ "timing": "On twos. Things appear cube by cube or layer by layer; moves snap to the grid.",
+ "fps": 12,
+ "build": [
+ "One `InstancedMesh` of a box for all the cubes: one draw call",
+ "Set each cube's matrix from stepped time; hide a cube by scaling it to nothing",
+ "Cubes slightly under size (0.96) so the seams read",
+ "`MeshLambertMaterial` and a hemisphere light"
+ ],
+ "assets": "Models as arrays in code, or made with a voxel editor.",
+ "sound": "Blocky, percussive, chiptune. Practice note.",
+ "pitfalls": [
+ "Cubes at non-integer positions",
+ "Faces flickering where cubes touch at full size"
+ ],
+ "route": "Three.js inside HyperFrames",
+ "blender": "",
+ "keywords": [
+ "voxel",
+ "voxels",
+ "minecraft",
+ "cubes",
+ "blocky",
+ "magicavoxel"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Voxel",
+ "https://github.com/danielesteban/cubitos"
+ ],
+ "looks": [
+ "voxel"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "pixel-art",
+ "name": "Pixel art",
+ "aliases": [
+ "8-bit"
+ ],
+ "family": "geometry",
+ "what": "A tiny picture placed pixel by pixel and scaled up with hard edges: a few colours, no blur, sprites that step.",
+ "origin": "From early video games; the term dates from 1982.",
+ "rules": [
+ "A small canvas scaled by a whole number",
+ "A limited palette, often 8 to 32 colours",
+ "No anti-aliasing, no soft gradients",
+ "Sprites animate in a few frames"
+ ],
+ "timing": "Walk cycles of 4 to 8 frames at about 8 a second. Scrolling moves in whole pixels.",
+ "fps": 8,
+ "build": [
+ "Draw on a small canvas (160 by 90), then `drawImage` it up with `imageSmoothingEnabled = false`",
+ "CSS: `image-rendering: pixelated` on an upscaled canvas",
+ "Sprites as arrays of palette indexes",
+ "Three.js: `RenderPixelatedPass` renders a 3D scene to low resolution with nearest filtering"
+ ],
+ "assets": "Sprites as data in code, or drawn in a pixel editor.",
+ "sound": "Chiptune. Practice note.",
+ "pitfalls": [
+ "Scaling by a fraction",
+ "Mixed pixel sizes on one screen",
+ "Smooth vector edges or too many colours"
+ ],
+ "route": "HyperFrames (canvas)",
+ "blender": "",
+ "keywords": [
+ "pixel art",
+ "pixel",
+ "8-bit",
+ "16-bit",
+ "retro game",
+ "sprite",
+ "arcade",
+ "chiptune"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Pixel_art",
+ "https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering"
+ ],
+ "looks": [
+ "pixel-art"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "product-render",
+ "name": "3D product render",
+ "aliases": [],
+ "family": "geometry",
+ "what": "A studio shot of an object: a seamless backdrop, soft key, fill and rim lights, controlled reflections, a slow turn.",
+ "origin": "Product photography lighting, done in 3D.",
+ "rules": [
+ "A seamless backdrop",
+ "Key light to one side and above, a softer fill opposite, a rim light behind",
+ "A contact shadow under the object",
+ "True materials: gloss, metal, glass",
+ "One slow move"
+ ],
+ "timing": "Smooth and slow at the full frame rate. The opposite of the handmade looks.",
+ "fps": null,
+ "build": [
+ "`MeshPhysicalMaterial` with `clearcoat` for lacquer, `metalness: 1` for metal",
+ "Three directional lights in the key, fill and rim positions, plus a hemisphere light",
+ "Contact shadow: a plane with a radial-gradient texture, `depthWrite: false`",
+ "Rotation from `t` directly; ease the camera, not the turntable"
+ ],
+ "assets": "A model of the product: built in code, made with the 3D pack, or supplied.",
+ "sound": "Minimal: a low bed and one accent on the reveal. Practice note.",
+ "pitfalls": [
+ "No reflections, so it looks like plastic",
+ "One harsh light",
+ "An object floating with no shadow"
+ ],
+ "route": "Three.js, the 3D pack, or Blender",
+ "blender": "Use Blender when the brief asks for photoreal glass, caustics or depth of field.",
+ "keywords": [
+ "product render",
+ "product shot",
+ "studio",
+ "turntable",
+ "packshot",
+ "photoreal",
+ "hero product"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Three-point_lighting"
+ ],
+ "looks": [
+ "product-render"
+ ],
+ "thin": "The lighting source is about photography; applying it to rendering is a practice note."
+ },
+ {
+ "id": "kinetic-type",
+ "name": "Kinetic typography",
+ "aliases": [
+ "motion typography"
+ ],
+ "family": "type",
+ "what": "Moving words as the whole picture: scale, weight and timing carry the meaning.",
+ "origin": "Saul Bass's title sequences for North by Northwest (1959) and Psycho (1960) made it a form.",
+ "rules": [
+ "Type is the image; nothing competes with it",
+ "Strong contrast of size and weight",
+ "Words arrive in reading order, on the beat",
+ "One idea per frame"
+ ],
+ "timing": "Each word lands in 0.3 to 0.5 seconds with a small overshoot, then the line holds long enough to read.",
+ "fps": null,
+ "build": [
+ "HyperFrames: split text into inline-block spans and stagger with GSAP",
+ "Canvas: `fillText` with a transform per word",
+ "Timing from the narration: one start time per word",
+ "Hold for (words / 3) + 0.5 seconds before the next line"
+ ],
+ "assets": "A typeface with enough weights. No pictures.",
+ "sound": "Cut to the voice or the beat. Practice note.",
+ "pitfalls": [
+ "Words faster than they can be read",
+ "Effects that add no meaning",
+ "Everything moving at once"
+ ],
+ "route": "HyperFrames (DOM)",
+ "blender": "",
+ "keywords": [
+ "kinetic",
+ "typography",
+ "type animation",
+ "text animation",
+ "title sequence",
+ "words",
+ "quote video"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Kinetic_typography"
+ ],
+ "looks": [
+ "kinetic-type"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "infographic",
+ "name": "Infographic and data animation",
+ "aliases": [
+ "data-viz animation"
+ ],
+ "family": "type",
+ "what": "A chart that builds in a sensible order: axes, then the data from an honest baseline, then the exact values.",
+ "origin": "From Playfair's first charts in 1786 to animated infographics in music videos in 2002.",
+ "rules": [
+ "One chart type that fits the data",
+ "Direct labels, not a legend",
+ "An honest axis: bars start at zero",
+ "One colour for the point being made"
+ ],
+ "timing": "Axes in about half a second, each series over 0.8 to 1.5 seconds with an ease-out, then a hold to read.",
+ "fps": null,
+ "build": [
+ "Drive the chart from one time value; never use a chart library's own transitions",
+ "Bars grow from the baseline; counters show the rounded value as it grows and end on the exact figure",
+ "SVG or canvas with scale maths; D3 scales are enough",
+ "Every number needs a source in the brief"
+ ],
+ "assets": "The data, with its source.",
+ "sound": "A tick or tone per value, a bed that stays out of the way. Practice note.",
+ "pitfalls": [
+ "Numbers that were not checked",
+ "3D bars",
+ "An axis cut off to exaggerate a difference"
+ ],
+ "route": "HyperFrames (SVG, canvas)",
+ "blender": "",
+ "keywords": [
+ "infographic",
+ "data",
+ "chart",
+ "graph",
+ "statistics",
+ "data viz",
+ "bar chart",
+ "numbers",
+ "report"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Infographic"
+ ],
+ "looks": [
+ "infographic"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "lyric-video",
+ "name": "Lyric video",
+ "aliases": [],
+ "family": "type",
+ "what": "The words of a song as the main image, each line timed to the vocal and the active word lit.",
+ "origin": "Lyric text appears in music videos from the 1980s; the format took off on video sites in the 2010s.",
+ "rules": [
+ "Three to eight words on screen",
+ "The word being sung is brighter or larger",
+ "A background that never fights the text",
+ "One typographic system for the whole song"
+ ],
+ "timing": "Locked to the music. A word changes exactly on its beat; a few frames late is visible.",
+ "fps": null,
+ "build": [
+ "Word start times from forced alignment or a beat grid",
+ "Compute the active line and word from `t`",
+ "A pulse from the beat phase: `1 - (beat % 1)` drives scale and background",
+ "Measure words first so the line is centred"
+ ],
+ "assets": "The audio, with the right to use it, and its word timings.",
+ "sound": "The song.",
+ "pitfalls": [
+ "Timing that drifts",
+ "Text over a busy background",
+ "Music you have no licence for"
+ ],
+ "route": "HyperFrames (DOM, canvas)",
+ "blender": "",
+ "keywords": [
+ "lyric",
+ "lyrics",
+ "song",
+ "karaoke",
+ "music video",
+ "sing-along"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Lyric_video",
+ "https://en.wikipedia.org/wiki/Kinetic_typography"
+ ],
+ "looks": [
+ "lyric-video"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "vhs-glitch",
+ "name": "VHS and glitch",
+ "aliases": [
+ "glitch",
+ "retro VHS"
+ ],
+ "family": "type",
+ "what": "The damage of old tape and broken data: colour that bleeds sideways, scan lines, a band of noise at the bottom, sudden torn slices.",
+ "origin": "VHS records colour at far lower resolution than brightness, which is why colour smears. Glitch art uses such errors on purpose.",
+ "rules": [
+ "Colour offset from brightness by a few pixels and softer",
+ "Scan lines",
+ "A tracking band of noise near the bottom",
+ "A date stamp in a blocky face",
+ "Glitch: slices displaced sideways, in short bursts"
+ ],
+ "timing": "Full frame rate, with bursts of a fifth of a second. Seeds come from the frame number so every render matches.",
+ "fps": 30,
+ "build": [
+ "Draw the clean frame to its own canvas first, then the damage on top",
+ "Redraw it in thin horizontal strips with a per-strip offset; large offsets only during a burst",
+ "Chroma bleed: a blurred copy drawn again a few pixels to the side with `screen`",
+ "Scan lines: a dark row every third pixel",
+ "Three.js: `FilmPass`, `RGBShiftShader` and `GlitchPass` exist; `GlitchPass` picks its own random timing, so check it repeats before relying on it"
+ ],
+ "assets": "All in code.",
+ "sound": "Tape hiss, hum, a click on each burst. Practice note.",
+ "pitfalls": [
+ "Constant glitching, which tires the eye",
+ "Glitching text the viewer has to read",
+ "Unseeded randomness, so two renders differ"
+ ],
+ "route": "HyperFrames (canvas) or Three.js post-processing",
+ "blender": "",
+ "keywords": [
+ "vhs",
+ "glitch",
+ "retro",
+ "tape",
+ "analog",
+ "crt",
+ "static",
+ "distortion",
+ "80s video",
+ "90s video"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/VHS",
+ "https://en.wikipedia.org/wiki/Glitch_art"
+ ],
+ "looks": [
+ "vhs-glitch"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "blueprint",
+ "name": "Blueprint and technical drawing",
+ "aliases": [],
+ "family": "type",
+ "what": "White lines on blue: a grid, an object drawn in outline, centre lines, dimensions and a title block.",
+ "origin": "The blueprint is a cyanotype copy of an engineering drawing, introduced in 1842: white lines on blue.",
+ "rules": [
+ "White or pale lines on a deep blue",
+ "A faint grid",
+ "Dashed centre lines, dimension lines with end ticks",
+ "A title block in a monospace face"
+ ],
+ "timing": "Steady: lines draw on, then dimensions and labels fade in. No bounce.",
+ "fps": null,
+ "build": [
+ "Grid: thin lines every 30 px at low opacity (CSS: `repeating-linear-gradient`)",
+ "Draw-on with `stroke-dashoffset` or a partial polyline",
+ "Dashed centre lines with `setLineDash`",
+ "Dimension lines: a line, two end ticks and a centred label"
+ ],
+ "assets": "All in code.",
+ "sound": "A pen plotter, a pencil. Practice note.",
+ "pitfalls": [
+ "A neon blue",
+ "Labels that say nothing",
+ "Perspective in the drawing"
+ ],
+ "route": "HyperFrames (SVG, canvas)",
+ "blender": "",
+ "keywords": [
+ "blueprint",
+ "technical drawing",
+ "schematic",
+ "cad",
+ "engineering",
+ "plan",
+ "wireframe drawing"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Blueprint"
+ ],
+ "looks": [
+ "blueprint"
+ ],
+ "thin": ""
+ },
+ {
+ "id": "neon-sign",
+ "name": "Neon sign",
+ "aliases": [],
+ "family": "type",
+ "what": "Glass tubes bent into letters and lit: a bright core, a coloured glow, a dark wall, tubes that light one by one and sometimes flicker.",
+ "origin": "Glass tubing filled with gas and lit by electrodes; sections can be switched in sequence.",
+ "rules": [
+ "One continuous line per letter, one width",
+ "A white-hot core inside a coloured halo",
+ "A dark wall behind",
+ "Letters light in sequence"
+ ],
+ "timing": "Tubes come on in order with a short stutter each; now and then one dims for a frame.",
+ "fps": 24,
+ "build": [
+ "Each tube is drawn three times: a wide faint stroke, a medium one, a thin white core, all with `shadowBlur`",
+ "Add them with the `lighter` blend (CSS: `mix-blend-mode: plus-lighter` or `screen`)",
+ "Flicker from `hash(frame, tube)`, never from a random call",
+ "Three.js: `UnrealBloomPass` for bloom on emissive geometry"
+ ],
+ "assets": "Letter paths in code. A brick or plaster texture can be drawn.",
+ "sound": "A low electrical hum, a tick as each tube lights. Practice note.",
+ "pitfalls": [
+ "A glow so wide the word cannot be read",
+ "Filled letters instead of a single tube",
+ "Flicker that differs between renders"
+ ],
+ "route": "HyperFrames (canvas, SVG)",
+ "blender": "",
+ "keywords": [
+ "neon",
+ "neon sign",
+ "glow",
+ "bar sign",
+ "tube",
+ "night",
+ "cyberpunk sign"
+ ],
+ "sources": [
+ "https://en.wikipedia.org/wiki/Neon_sign",
+ "https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode"
+ ],
+ "looks": [
+ "neon-sign"
+ ],
+ "thin": ""
+ }
+ ]
+}
\ No newline at end of file
diff --git a/plugin/skills/brief2mp4/references/art-forms.md b/plugin/skills/brief2mp4/references/art-forms.md
new file mode 100644
index 0000000..5a447e7
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms.md
@@ -0,0 +1,92 @@
+# Art forms: 30 looks for animated video, and how to build each
+
+Read this when a brief names a look ("claymation", "paper cut-out", "anime", "like a blueprint") or describes a feeling that a look would carry. It is the index. Each art form has its own page in `references/art-forms/` with its visual rules, timing, build recipe, assets, sound, pitfalls, sources and a tested demo. `scripts/art_route.py BRIEF.md` proposes one from a brief and says why.
+
+An art form sets the look and the timing. The format (`references/formats.md`) still sets the beats, and the tool table in SKILL.md still sets the route.
+
+## Three rules behind every look
+
+1. **The picture is a function of time.** No clock, no timers, no `Math.random()`. HyperFrames renders by seeking, so anything that depends on the frame before it will be wrong. Randomness comes from a hash of the frame number or of a position.
+2. **Handmade looks hold their drawings.** Clay, paper, felt, cel and ink change 8 to 12 times a second while the video stays at 24 or 30. Quantise time before posing anything: `const ts = Math.floor(t * 12) / 12`. In GSAP the same thing is `ease: "steps(12)"` on a one-second tween. Clean looks (flat explainer, low-poly, product render, type) stay smooth.
+3. **Imperfection is seeded.** Line boil, paper jitter, lamp flicker, misregistered ink and tape damage are all keyed to the drawing number, so two renders of the same frame match exactly.
+
+A `setInterval` that re-rolls a filter, the usual web recipe for line boil, breaks rule 1 and will not render correctly. Key the change to `Math.floor(t * 10)` instead.
+
+## Craft and handmade
+
+| Art form | What it is | Cadence | Usual tool |
+|---|---|---|---|
+| [Claymation](art-forms/claymation.md) | Figures of clay or plasticine, posed and photographed one frame at a time. | steps 12 times a second | Three.js inside HyperFrames |
+| [Stop-motion look](art-forms/stop-motion.md) | Any real object moved and photographed a pose at a time. | steps 12 times a second | HyperFrames (canvas or DOM) or Three.js |
+| [Paper cut-out](art-forms/paper-cutout.md) | Flat shapes cut from paper or card, layered, and moved a pose at a time. | steps 12 times a second | HyperFrames (canvas, SVG or DOM) |
+| [Felt and fabric craft](art-forms/felt.md) | Shapes that look needle-felted or sewn: a fuzzy edge of loose fibres, a matte mottled surface, visible stitches. | steps 12 times a second | HyperFrames (canvas or SVG) |
+| [Origami](art-forms/origami.md) | Paper folded from a flat sheet: sharp creases, flat facets, each fold a clean move followed by a pause. | smooth, full frame rate | HyperFrames (canvas or SVG), or Three.js |
+| [Shadow puppetry](art-forms/shadow-puppet.md) | Flat figures held between a lamp and a cloth screen: dark silhouettes with punched patterns on a warm, glowing field. | steps 12 times a second | HyperFrames (canvas or SVG) |
+| [Collage and mixed media](art-forms/collage.md) | Pieces of different papers, photographs and print stuck together: mismatched scale and texture, torn edges, hard shadows. | steps 8 times a second | HyperFrames (canvas or DOM) |
+| [Risograph and halftone print](art-forms/risograph.md) | The look of a cheap stencil print: two to four bright inks laid over each other, visible grain, dot screens, and layers that never quite line up. | steps 8 times a second | HyperFrames (canvas or DOM) |
+
+## Drawn and painted
+
+| Art form | What it is | Cadence | Usual tool |
+|---|---|---|---|
+| [Anime and cel shading](art-forms/cel-shaded.md) | Light broken into two or three flat tones with a hard edge between them, and an ink outline around every form. | steps 12 times a second | Three.js inside HyperFrames |
+| [2D flat vector explainer](art-forms/flat-explainer.md) | The plain explainer look: flat fills, a few colours, simple shapes and icons, smooth eased motion. | smooth, full frame rate | HyperFrames (DOM, SVG) |
+| [Whiteboard and doodle](art-forms/whiteboard.md) | Marker lines that draw themselves on a white board, in the order someone would draw them. | steps 10 times a second | HyperFrames (canvas or SVG) |
+| [Watercolour](art-forms/watercolour.md) | Transparent washes on textured paper: colour that spreads, pools darker at its edge, and lets the paper show through. | steps 12 times a second | HyperFrames (canvas or SVG) |
+| [Ink wash (sumi-e)](art-forms/ink-wash.md) | Black ink in every shade from deep black to pale grey, laid down in tapered brush strokes on rice paper, with a great deal left empty. | steps 12 times a second | HyperFrames (canvas or SVG) |
+| [Line art](art-forms/line-art.md) | One weight of line on a plain ground, no shading: the drawing draws itself, then quivers slightly as if redrawn each frame. | steps 10 times a second | HyperFrames (SVG or canvas) |
+| [Rotoscope look](art-forms/rotoscope.md) | Real movement traced by hand: lifelike motion, flat colour fields that drift, and an outline that shimmers. | steps 12 times a second | HyperFrames (canvas over video) |
+| [Motion comic](art-forms/motion-comic.md) | Comic panels brought to life: layers inside a panel slide at different speeds under a slow camera move, then a hard cut to the next panel. | smooth, full frame rate | HyperFrames (DOM or canvas) |
+| [UPA and mid-century modern](art-forms/upa-midcentury.md) | Flat, stylised design from 1950s cartoons: geometric characters, abstract backgrounds, colour printed slightly off its outline, and very few drawings. | steps 8 times a second | HyperFrames (canvas, SVG) |
+| [Rubber-hose cartoon](art-forms/rubber-hose.md) | The 1920s cartoon: limbs like hoses with no elbows or knees, round bodies that bounce to the music, black and white film. | steps 12 times a second | HyperFrames (canvas, SVG) |
+| [Linocut and woodcut print](art-forms/linocut.md) | A relief print: bold flat shapes in one to three inks, with white gouge marks where the block was carved. | steps 8 times a second | HyperFrames (canvas, SVG) |
+
+## Geometry, pixels and 3D
+
+| Art form | What it is | Cadence | Usual tool |
+|---|---|---|---|
+| [Isometric](art-forms/isometric.md) | A parallel projection seen from above at an angle: no perspective, three visible faces per block, a tidy model world. | smooth, full frame rate | HyperFrames (canvas, SVG) or Three.js |
+| [Low-poly 3D](art-forms/low-poly.md) | Meshes with few polygons, each face lit as one flat facet. | smooth, full frame rate | Three.js inside HyperFrames |
+| [Voxel](art-forms/voxel.md) | Everything built from cubes of one size on a grid, like a three-dimensional pixel picture. | steps 12 times a second | Three.js inside HyperFrames |
+| [Pixel art](art-forms/pixel-art.md) | A tiny picture placed pixel by pixel and scaled up with hard edges: a few colours, no blur, sprites that step. | steps 8 times a second | HyperFrames (canvas) |
+| [3D product render](art-forms/product-render.md) | A studio shot of an object: a seamless backdrop, soft key, fill and rim lights, controlled reflections, a slow turn. | smooth, full frame rate | Three.js, the 3D pack, or Blender |
+
+## Type, data and retro
+
+| Art form | What it is | Cadence | Usual tool |
+|---|---|---|---|
+| [Kinetic typography](art-forms/kinetic-type.md) | Moving words as the whole picture: scale, weight and timing carry the meaning. | smooth, full frame rate | HyperFrames (DOM) |
+| [Infographic and data animation](art-forms/infographic.md) | A chart that builds in a sensible order: axes, then the data from an honest baseline, then the exact values. | smooth, full frame rate | HyperFrames (SVG, canvas) |
+| [Lyric video](art-forms/lyric-video.md) | The words of a song as the main image, each line timed to the vocal and the active word lit. | smooth, full frame rate | HyperFrames (DOM, canvas) |
+| [VHS and glitch](art-forms/vhs-glitch.md) | The damage of old tape and broken data: colour that bleeds sideways, scan lines, a band of noise at the bottom, sudden torn slices. | steps 30 times a second | HyperFrames (canvas) or Three.js post-processing |
+| [Blueprint and technical drawing](art-forms/blueprint.md) | White lines on blue: a grid, an object drawn in outline, centre lines, dimensions and a title block. | smooth, full frame rate | HyperFrames (SVG, canvas) |
+| [Neon sign](art-forms/neon-sign.md) | Glass tubes bent into letters and lit: a bright core, a coloured glow, a dark wall, tubes that light one by one and sometimes flicker. | steps 24 times a second | HyperFrames (canvas, SVG) |
+
+## Choosing one from a brief
+
+| The brief is about | Try | Why |
+|---|---|---|
+| children, family, a gentle story | paper cut-out, claymation, felt | handmade textures feel warm and safe |
+| a folk tale, a myth, heritage | shadow puppetry, linocut, ink wash | the form carries the tradition; check the iconography with a source |
+| explaining a product or a process | flat vector explainer, isometric, whiteboard | clean shapes keep attention on the idea |
+| numbers | infographic | the chart is the picture; every number needs a source |
+| a song or a quote | lyric video, kinetic typography | the words are the content |
+| a physical product | 3D product render, claymation for a playful take | the object is the hero |
+| nostalgia | VHS and glitch, pixel art, rubber-hose, UPA mid-century | each one is a decade |
+| calm, reflective | watercolour, ink wash, line art | slow, sparse, quiet |
+| loud, independent | risograph, collage, motion comic | print energy and hard cuts |
+
+If the brief names a look, use it. If it names none and nothing above fits, do not force one: the plain formats in `references/formats.md` are a look too.
+
+## Tools that exist, by name
+
+- SVG filters: `feTurbulence` (noise), `feDisplacementMap` (bend by noise: rough edges, line boil, ink bleed), `feMorphology` (thicken or thin: outlines), `feColorMatrix` and `feComponentTransfer` (recolour, threshold, duotone), `feGaussianBlur`.
+- CSS: `steps()` timing, `mix-blend-mode: multiply` for overprinted ink and `screen` or `plus-lighter` for glow, `image-rendering: pixelated`, `filter: drop-shadow()`.
+- GSAP: `ease: "steps(n)"`; `fromTo` inside scenes; one paused root timeline.
+- three.js materials and passes that ship in its examples: `MeshToonMaterial` with a `gradientMap`, `OutlineEffect`, `SobelOperatorShader`, `HalftonePass`, `RenderPixelatedPass`, `FilmPass`, `RGBShiftShader`, `GlitchPass`, `UnrealBloomPass`, `OutputPass`. It ships no watercolour (Kuwahara) pass and no VHS pass.
+- Blender does these better than a browser: real subsurface clay, fur and felt fibre, folded paper with thickness, photoreal product shots, Freestyle line art.
+
+## The demos
+
+`art-forms/looks.js` holds one small demo per look (31 in all), and `art-forms/gallery.html` plays them. `tests/art_forms/check_looks.mjs` checks every one in a real browser.
+These pages are generated from `references/art-forms.json` and `art-forms/looks.js` by `scripts/build_art_forms.py`.
diff --git a/plugin/skills/brief2mp4/references/art-forms/blueprint.md b/plugin/skills/brief2mp4/references/art-forms/blueprint.md
new file mode 100644
index 0000000..093d13b
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/blueprint.md
@@ -0,0 +1,68 @@
+# Blueprint and technical drawing
+
+Family: Type, data and retro. Cadence: smooth, full frame rate. Usual tool: HyperFrames (SVG, canvas).
+
+White lines on blue: a grid, an object drawn in outline, centre lines, dimensions and a title block.
+
+The blueprint is a cyanotype copy of an engineering drawing, introduced in 1842: white lines on blue.
+
+## What makes it read as this
+
+- White or pale lines on a deep blue
+- A faint grid
+- Dashed centre lines, dimension lines with end ticks
+- A title block in a monospace face
+
+## Timing
+
+Steady: lines draw on, then dimensions and labels fade in. No bounce.
+
+## How to build it
+
+- Grid: thin lines every 30 px at low opacity (CSS: `repeating-linear-gradient`)
+- Draw-on with `stroke-dashoffset` or a partial polyline
+- Dashed centre lines with `setLineDash`
+- Dimension lines: a line, two end ticks and a centred label
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+A pen plotter, a pencil. Practice note.
+
+## What makes it look wrong
+
+- A neon blue
+- Labels that say nothing
+- Perspective in the drawing
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=blueprint` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ blueprint: { kind: '2d', fps: null, draw(g, t, W, H) {
+ // white lines on blue, a grid, then the drawing itself, then its dimensions. Steady, with no bounce.
+ bg(g, W, H, '#1d4f91');
+ g.strokeStyle = 'rgba(255,255,255,.12)'; g.lineWidth = 1; g.beginPath(); for (let x = 0; x <= W; x += 30) { g.moveTo(x, 0); g.lineTo(x, H); } for (let y = 0; y <= H; y += 30) { g.moveTo(0, y); g.lineTo(W, y); } g.stroke();
+ g.strokeStyle = '#eaf2ff'; g.lineWidth = 2.5; g.lineCap = 'round'; g.lineJoin = 'round';
+ const cx = W * 0.42, cy = H * 0.52, gear = Array.from({ length: 97 }, (_, i) => { const a = (i / 96) * TAU, r = 120 + (Math.floor(i / 4) % 2 ? 22 : 0); return [cx + Math.cos(a) * r, cy + Math.sin(a) * r]; });
+ strokePart(g, gear, prog(t, 0.1, 1.2)); strokePart(g, circlePts(cx, cy, 44, 40), prog(t, 1.1, 0.4));
+ g.setLineDash([10, 6]); g.lineWidth = 1.4; strokePart(g, [[cx - 170, cy], [cx + 170, cy]], prog(t, 1.4, 0.3)); strokePart(g, [[cx, cy - 170], [cx, cy + 170]], prog(t, 1.5, 0.3)); g.setLineDash([]);
+ const k = prog(t, 1.9, 0.4); if (k > 0) {
+ g.globalAlpha = k; g.lineWidth = 1.6; const y = cy + 176; g.beginPath(); g.moveTo(cx - 142, y); g.lineTo(cx + 142, y); g.moveTo(cx - 142, y - 8); g.lineTo(cx - 142, y + 8); g.moveTo(cx + 142, y - 8); g.lineTo(cx + 142, y + 8); g.stroke();
+ g.fillStyle = '#eaf2ff'; g.font = `500 20px ui-monospace, Menlo, monospace`; g.textAlign = 'center'; g.fillText('Ø 284', cx, y + 28); g.textAlign = 'left';
+ g.strokeRect(W * 0.68, H * 0.66, W * 0.26, H * 0.22); g.fillText('GEAR 12 T', W * 0.68 + 14, H * 0.66 + 32); g.fillText('SCALE 1:1', W * 0.68 + 14, H * 0.66 + 62); g.fillText('DRG B2M-01', W * 0.68 + 14, H * 0.66 + 92); g.globalAlpha = 1;
+ }
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Blueprint>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/cel-shaded.md b/plugin/skills/brief2mp4/references/art-forms/cel-shaded.md
new file mode 100644
index 0000000..fbeaafb
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/cel-shaded.md
@@ -0,0 +1,96 @@
+# Anime and cel shading
+
+Also called: anime, toon shading.
+
+Family: Drawn and painted. Cadence: steps 12 times a second. Usual tool: Three.js inside HyperFrames.
+
+Light broken into two or three flat tones with a hard edge between them, and an ink outline around every form.
+
+Named after the celluloid sheets of hand-drawn animation. In 3D it became toon shading, as in Jet Set Radio and The Wind Waker.
+
+## What makes it read as this
+
+- Two or three tone bands with hard edges
+- Shadows tinted with colour, not black
+- A clean outline
+- Flat, detailed backgrounds behind simpler characters
+- Limited animation: holds, then sudden moves
+
+## Timing
+
+On twos as the baseline, ones for key action, threes and holds for dialogue.
+
+## How to build it
+
+- Three.js `MeshToonMaterial` with a `gradientMap`: a three-texel `DataTexture` with `NearestFilter`, so light snaps to bands
+- Outline by inverted hull: a second copy of each mesh, slightly larger, drawn back faces only in black
+- `OutlineEffect` and `SobelOperatorShader` in the three.js examples are the two other routes
+- Step the pose time: `held(t, 12)`
+- 2D: flat SVG shapes, a thick outline, `steps()` timing
+
+Use Blender for Freestyle line art and shader-to-RGB ramps on real characters.
+
+## Assets
+
+The gradient map is three bytes. Characters need modelling or generated models. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Whoosh and impact effects on key poses. Practice note.
+
+## What makes it look wrong
+
+- Smooth interpolation at 24 frames a second
+- More than three bands
+- Shadows that are only a darker grey
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=cel-shaded` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'cel-shaded': { kind: '3d', fps: 12, setup(THREE, scene, camera) {
+ // light in three hard bands (a tiny gradient texture with no smoothing) and an outline made from a second, inside-out copy
+ scene.background = new THREE.Color('#ffd9a8');
+ const ramp = new THREE.DataTexture(new Uint8Array([70, 150, 255]), 3, 1, THREE.RedFormat); ramp.minFilter = ramp.magFilter = THREE.NearestFilter; ramp.needsUpdate = true;
+ const group = new THREE.Group(), ink = new THREE.MeshBasicMaterial({ color: '#17131c', side: THREE.BackSide });
+ const add = (geo, col, x, y, z) => { const m = new THREE.Mesh(geo, new THREE.MeshToonMaterial({ color: col, gradientMap: ramp })); m.position.set(x, y, z); const o = new THREE.Mesh(geo, ink); o.scale.setScalar(1.06); m.add(o); group.add(m); return m; };
+ add(new THREE.SphereGeometry(1, 48, 32), '#3f7fd6', 0, 0, 0); add(new THREE.ConeGeometry(0.7, 1.5, 40), '#ff5a5f', 0, 1.5, 0); add(new THREE.TorusGeometry(1.5, 0.16, 20, 80), '#ffd23f', 0, 0, 0).rotation.x = 1.2;
+ scene.add(group); const sun = new THREE.DirectionalLight('#ffffff', 3); sun.position.set(4, 5, 5); scene.add(sun, new THREE.AmbientLight('#8a7fb5', 0.9));
+ camera.position.set(0, 1, 7.5); camera.lookAt(0, 0.4, 0);
+ return { group };
+ }, draw(s, t) { const ts = held(t, 12); s.group.rotation.y = ts * 1.4; s.group.rotation.z = Math.sin(ts * 2) * 0.12; s.group.position.y = Math.sin(ts * 2.5) * 0.25; } },
+ 'low-poly': { kind: '3d', fps: null, setup(THREE, scene, camera) {
+ // few polygons, each lit as one flat facet. Clean, so the camera move is smooth, not stepped.
+ scene.background = new THREE.Color('#bfe3f2'); scene.fog = new THREE.Fog('#bfe3f2', 9, 22);
+ const geo = new THREE.PlaneGeometry(26, 26, 22, 22); geo.rotateX(-Math.PI / 2); const p = geo.attributes.position;
+ for (let i = 0; i < p.count; i++) { const x = p.getX(i), z = p.getZ(i), d = Math.hypot(x, z); p.setY(i, Math.max(0, 3.2 - d * 0.42) * (0.6 + hash(i, 9) * 0.9) + hash(i, 4) * 0.25); }
+ geo.computeVertexNormals(); const land = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: '#5fa36a', flatShading: true, roughness: 0.9 }));
+ const sunBall = new THREE.Mesh(new THREE.IcosahedronGeometry(0.9, 1), new THREE.MeshBasicMaterial({ color: '#ffd166' })); sunBall.position.set(-5, 5.5, -8);
+ const trees = new THREE.Group(); for (let i = 0; i < 22; i++) { const a = hash(i, 1) * TAU, r = 3.6 + hash(i, 2) * 5, tr = new THREE.Mesh(new THREE.ConeGeometry(0.34, 1.1, 5), new THREE.MeshStandardMaterial({ color: '#2f6b4f', flatShading: true })); tr.position.set(Math.cos(a) * r, 0.75, Math.sin(a) * r); trees.add(tr); }
+ scene.add(land, sunBall, trees, new THREE.HemisphereLight('#ffffff', '#4a6a4a', 1.4)); const key = new THREE.DirectionalLight('#fff0d0', 2.4); key.position.set(-5, 6, 2); scene.add(key);
+ return { camera };
+ }, draw(s, t) { const a = 0.5 + t * 0.22; s.camera.position.set(Math.sin(a) * 11, 4.6, Math.cos(a) * 11); s.camera.lookAt(0, 1.4, 0); } },
+ voxel: { kind: '3d', fps: 12, setup(THREE, scene, camera) {
+ // every cube the same size, on a grid, in one instanced mesh. The model builds layer by layer, on twos.
+ scene.background = new THREE.Color('#1c2333');
+ const cells = []; for (let y = 0; y < 9; y++) for (let x = -4; x <= 4; x++) for (let z = -4; z <= 4; z++) { const d = Math.hypot(x, z); const trunk = y < 4 && d < 1.2, leaves = y >= 3 && Math.hypot(x, (y - 6) * 1.25, z) < 3.6 && hash(x + 9, y, z + 9) > 0.12; if (trunk || leaves) cells.push([x, y, z, trunk && y < 4 && !leaves ? '#7a4f2a' : hash(x, y, z) > 0.5 ? '#3f9b57' : '#2f7d47']); }
+ const mesh = new THREE.InstancedMesh(new THREE.BoxGeometry(0.96, 0.96, 0.96), new THREE.MeshLambertMaterial(), cells.length), col = new THREE.Color();
+ cells.forEach((c, i) => mesh.setColorAt(i, col.set(c[3]))); scene.add(mesh, new THREE.HemisphereLight('#ffffff', '#33405a', 1.6)); const key = new THREE.DirectionalLight('#ffffff', 2); key.position.set(6, 9, 4); scene.add(key);
+ return { mesh, cells, m: new THREE.Matrix4(), camera };
+ }, draw(s, t) {
+ const ts = held(t, 12), shown = Math.floor(clamp(ts / 2.2) * 9.99);
+ s.cells.forEach(([x, y, z], i) => { const on = y <= shown; s.m.makeScale(on ? 1 : 0.0001, on ? 1 : 0.0001, on ? 1 : 0.0001); s.m.setPosition(x, y - 4, z); s.mesh.setMatrixAt(i, s.m); });
+ s.mesh.instanceMatrix.needsUpdate = true; const a = 0.7 + ts * 0.35; s.camera.position.set(Math.sin(a) * 15, 6, Math.cos(a) * 15); s.camera.lookAt(0, 0, 0);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Cel_shading>
+- <https://en.wikipedia.org/wiki/Limited_animation>
+- <https://github.com/mrdoob/three.js>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/claymation.md b/plugin/skills/brief2mp4/references/art-forms/claymation.md
new file mode 100644
index 0000000..63c7c86
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/claymation.md
@@ -0,0 +1,78 @@
+# Claymation
+
+Also called: clay animation, plasticine animation.
+
+Family: Craft and handmade. Cadence: steps 12 times a second. Usual tool: Three.js inside HyperFrames.
+
+Figures of clay or plasticine, posed and photographed one frame at a time. Soft, lumpy, a little uneven, and never perfectly smooth in motion.
+
+Plasticine dates from 1897. Art Clokey (Gumby) and Aardman, founded in 1972, made the look famous.
+
+## What makes it read as this
+
+- Rounded volumes with small lumps and dents, never a perfect sphere
+- Matte, high-roughness surfaces under soft light
+- Saturated colour, few of them
+- Small asymmetries; a silhouette that changes slightly between poses
+- A miniature set: a floor, a backdrop, shallow depth
+
+## Timing
+
+Shot on doubles: about 12 pose changes a second inside a 24 frames-a-second film. Each held pose sits a hair differently from the last.
+
+## How to build it
+
+- Three.js: `MeshStandardMaterial` with roughness about 0.9, metalness 0, and a noise canvas as `bumpMap`
+- Push each vertex in or out by a few percent with a seeded hash, then `computeVertexNormals()`
+- Pose from stepped time: `held(t, 12)`
+- Add a seeded nudge per drawing to position and rotation (about 2% of the size)
+- A hemisphere light plus one soft key; no hard specular highlights
+
+Use Blender when the clay needs real subsurface scattering, soft area-light shadows or sculpted detail.
+
+## Assets
+
+Geometry in code (spheres, capsules, lathes) for simple characters. Fingerprint or noise detail as a generated bump texture. A real character needs modelling. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Close foley on pose changes (soft thuds, squelches), light percussion. Practice note.
+
+## What makes it look wrong
+
+- Smooth 24 or 30 frames-a-second motion: it reads as CG, not clay
+- Glossy plastic highlights
+- Perfect symmetry and clean edges
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=claymation` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ claymation: { kind: '3d', fps: 12, setup(THREE, scene, camera) {
+ // rough, lumpy, matte spheres under soft light. Poses change 12 times a second and wobble a little between holds.
+ scene.background = new THREE.Color('#e9d9c4');
+ const tex = new THREE.CanvasTexture(grain(256, 256, 31, 255, [128, 128, 128])); tex.wrapS = tex.wrapT = THREE.RepeatWrapping; tex.repeat.set(3, 3);
+ const clay = (col) => new THREE.MeshStandardMaterial({ color: col, roughness: 0.92, metalness: 0, bumpMap: tex, bumpScale: 2.2 });
+ const lump = (r, seed, mat) => { const geo = new THREE.SphereGeometry(r, 40, 28), p = geo.attributes.position; for (let i = 0; i < p.count; i++) { const k = 1 + (hash(i, seed) - 0.5) * 0.045; p.setXYZ(i, p.getX(i) * k, p.getY(i) * k, p.getZ(i) * k); } geo.computeVertexNormals(); return new THREE.Mesh(geo, mat); };
+ const body = lump(1, 1, clay('#d2603f')), head = lump(0.62, 2, clay('#e9b88f')), eyes = [-1, 1].map((s) => { const e = lump(0.1, 3, clay('#1c1c1c')); e.position.set(s * 0.22, 0.12, 0.56); head.add(e); return e; });
+ const floor = new THREE.Mesh(new THREE.CircleGeometry(6, 48), clay('#b99b78')); floor.rotation.x = -Math.PI / 2; floor.position.y = -1;
+ scene.add(body, head, floor, new THREE.HemisphereLight('#fff6ea', '#7a6048', 1.5)); const key = new THREE.DirectionalLight('#fff2dd', 2.2); key.position.set(3, 5, 4); scene.add(key);
+ camera.position.set(0, 1.2, 7.2); camera.lookAt(0, 0.5, 0);
+ return { body, head, eyes };
+ }, draw(s, t) {
+ const f = frameOf(t, 12), ts = held(t, 12), hop = Math.abs(Math.sin(ts * Math.PI * 1.2)), sq = 1 - 0.18 * (1 - hop);
+ s.body.position.set(jit(f, 1, 0.02), hop * 0.9 + jit(f, 2, 0.015), 0); s.body.scale.set(1 / Math.sqrt(sq), sq, 1 / Math.sqrt(sq)); s.body.rotation.z = jit(f, 3, 0.03);
+ s.head.position.set(jit(f, 4, 0.02), 1.42 * sq + hop * 0.9, 0.1); s.head.rotation.set(jit(f, 5, 0.04), Math.sin(ts * 2) * 0.4, jit(f, 6, 0.04));
+ s.eyes.forEach((e) => e.scale.setScalar(f % 30 === 14 ? 0.15 : 1)); // a blink that lasts one drawing
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Clay_animation>
+- <https://en.wikipedia.org/wiki/Stop_motion>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/collage.md b/plugin/skills/brief2mp4/references/art-forms/collage.md
new file mode 100644
index 0000000..de3c839
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/collage.md
@@ -0,0 +1,81 @@
+# Collage and mixed media
+
+Also called: photomontage, mixed media.
+
+Family: Craft and handmade. Cadence: steps 8 times a second. Usual tool: HyperFrames (canvas or DOM).
+
+Pieces of different papers, photographs and print stuck together: mismatched scale and texture, torn edges, hard shadows.
+
+From the French coller, to glue. Braque and Picasso brought it into modern art around 1912; Dada followed with photomontage.
+
+## What makes it read as this
+
+- Torn or cut edges
+- Mixed materials: flat colour, halftone photograph, tape
+- Overlap with a hard, offset shadow
+- Mismatched scale on purpose
+- One palette holding it together
+
+## Timing
+
+On twos or threes. Pieces pop into place on the beat with a small rotation, then hold.
+
+## How to build it
+
+- Torn edge: walk the outline of a rectangle and nudge every point with a seeded hash
+- Hard shadow: `shadowBlur: 0` with an offset of 5 to 6 px
+- Halftone a photo: dots on a staggered grid sized by brightness
+- Entrance: scale from 1.25 to 1 with a quarter-turn of rotation over a quarter of a second
+
+## Assets
+
+Paper textures in code. Photo fragments need images you own, or generated ones. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Bright percussive music, staccato effects on each pop. Practice note.
+
+## What makes it look wrong
+
+- Everything neatly aligned
+- No shadows
+- Too many unrelated colours and typefaces
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=collage` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ collage: { kind: '2d', fps: 8, draw(g, t, W, H) {
+ // torn paper, a halftone "photo", tape. Pieces pop in on threes with a hard shadow, slightly rotated.
+ const f = frameOf(t, 8), ts = held(t, 8);
+ bg(g, W, H, '#e9e2d0');
+ const torn = (x, y, w, h, col, seed, start, rot) => {
+ const k = prog(ts, start, 0.25); if (k <= 0) return;
+ g.save(); g.translate(x, y); g.rotate(rot + (1 - k) * 0.25); g.scale(lerp(1.25, 1, k), lerp(1.25, 1, k));
+ g.shadowColor = 'rgba(20,10,0,.45)'; g.shadowOffsetX = 5; g.shadowOffsetY = 6; g.shadowBlur = 0;
+ g.beginPath(); const n = 26; for (let i = 0; i < n; i++) { const e = i / n, px = e < 0.25 ? lerp(-w, w, e * 4) : e < 0.5 ? w : e < 0.75 ? lerp(w, -w, (e - 0.5) * 4) : -w, py = e < 0.25 ? -h : e < 0.5 ? lerp(-h, h, (e - 0.25) * 4) : e < 0.75 ? h : lerp(h, -h, (e - 0.75) * 4); const jx = jit(seed, i, 7), jy = jit(seed, i + 50, 7); i ? g.lineTo(px + jx, py + jy) : g.moveTo(px + jx, py + jy); } g.closePath(); fill(g, col);
+ g.restore();
+ };
+ torn(W * 0.3, H * 0.42, 190, 130, '#2e4a7d', 41, 0.2, -0.08);
+ torn(W * 0.62, H * 0.56, 210, 110, '#d94f30', 42, 0.6, 0.06);
+ torn(W * 0.5, H * 0.3, 120, 70, '#f1c84b', 43, 1.0, -0.14);
+ const k = prog(ts, 1.4, 0.25);
+ if (k > 0) { // the halftone disc: dots sized by a gradient
+ g.save(); g.translate(W * 0.47, H * 0.52); g.scale(lerp(1.3, 1, k), lerp(1.3, 1, k)); g.fillStyle = '#111';
+ for (let y = -110; y <= 110; y += 11) for (let x = -110; x <= 110; x += 11) { const d = Math.hypot(x, y); if (d > 110) continue; g.beginPath(); g.arc(x + ((y / 11) % 2) * 5.5, y, 1 + 4.2 * (1 - (x + 110) / 220), 0, TAU); g.fill(); }
+ g.restore();
+ }
+ const tk = prog(ts, 1.9, 0.2); if (tk > 0) { g.save(); g.translate(W * 0.47, H * 0.3); g.rotate(-0.2); g.fillStyle = 'rgba(240,225,170,.8)'; g.fillRect(-60 * tk, -14, 120 * tk, 28); g.restore(); }
+ paper(g, W, H, 9, 32 + jit(f, 1, 3));
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Collage>
+- <https://en.wikipedia.org/wiki/Cutout_animation>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/felt.md b/plugin/skills/brief2mp4/references/art-forms/felt.md
new file mode 100644
index 0000000..e641440
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/felt.md
@@ -0,0 +1,75 @@
+# Felt and fabric craft
+
+Also called: needle felt, fabric craft.
+
+Family: Craft and handmade. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas or SVG).
+
+Shapes that look needle-felted or sewn: a fuzzy edge of loose fibres, a matte mottled surface, visible stitches.
+
+Needle felting tangles wool fibres with barbed needles to make flat pictures and soft figures.
+
+Sourcing note: The craft is well documented; its use in animation is a practice note, not sourced.
+
+## What makes it read as this
+
+- A halo of short fibres along every edge
+- Matte, slightly mottled colour
+- Stitches: a dashed line just inside the edge
+- Chunky, simple forms in wool colours
+
+## Timing
+
+Stop-motion cadence, on twos. Gentle bobbing and nudging.
+
+## How to build it
+
+- Draw the shape, then several hundred short strokes outward from its edge, each angled by a seeded hash
+- Stitches: `setLineDash([9, 7])` on a path just inside the edge (SVG: `stroke-dasharray`)
+- Mottle: a grain texture clipped to the shape with `multiply`
+- SVG route: high-frequency `feTurbulence` (0.8 to 1.2) with displacement scale 3 to 6 on the edge
+
+Use Blender hair or fur for real fibre fuzz on 3D figures.
+
+## Assets
+
+Procedural. A felt texture from an image model helps for close-ups. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Soft, warm, acoustic. Practice note.
+
+## What makes it look wrong
+
+- Crisp vector edges
+- Flat plastic colour
+- No fibre fuzz
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=felt` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ felt: { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // soft shapes with a halo of fibres along the edge and a row of stitches; everything bobs on twos
+ const ts = onTwos(t);
+ bg(g, W, H, '#d8cdb8');
+ const fuzzy = (x, y, r, col, seed) => {
+ blob(g, x, y, r, seed, 0.06); fill(g, col);
+ g.strokeStyle = col; g.lineWidth = 1.1; g.globalAlpha = 0.75;
+ for (let i = 0; i < 520; i++) { const a = hash(i, seed) * TAU, rr = r * (0.97 + hash(i, seed, 1) * 0.07), l = 3 + hash(i, seed, 2) * 7, tw = a + (hash(i, seed, 3) - 0.5) * 1.6; g.beginPath(); g.moveTo(x + Math.cos(a) * rr, y + Math.sin(a) * rr); g.lineTo(x + Math.cos(a) * rr + Math.cos(tw) * l, y + Math.sin(a) * rr + Math.sin(tw) * l); g.stroke(); }
+ g.globalAlpha = 1; g.setLineDash([9, 7]); g.strokeStyle = 'rgba(255,250,235,.85)'; g.lineWidth = 2.4; g.beginPath(); g.arc(x, y, r * 0.8, 0, TAU); g.stroke(); g.setLineDash([]);
+ g.save(); g.globalCompositeOperation = 'multiply'; g.beginPath(); g.arc(x, y, r, 0, TAU); g.clip(); g.drawImage(grain(W, H, seed, 60, [40, 30, 30]), 0, 0); g.restore();
+ };
+ fuzzy(W * 0.3, H * 0.52 + Math.sin(ts * 2.4) * 10, 108, '#c85a54', 21);
+ fuzzy(W * 0.56, H * 0.46 + Math.sin(ts * 2.4 + 1.3) * 12, 84, '#e2b23f', 22);
+ fuzzy(W * 0.76, H * 0.56 + Math.sin(ts * 2.4 + 2.6) * 9, 66, '#5d8a72', 23);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Needle_felting>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/flat-explainer.md b/plugin/skills/brief2mp4/references/art-forms/flat-explainer.md
new file mode 100644
index 0000000..e7eea2e
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/flat-explainer.md
@@ -0,0 +1,71 @@
+# 2D flat vector explainer
+
+Also called: motion graphics explainer.
+
+Family: Drawn and painted. Cadence: smooth, full frame rate. Usual tool: HyperFrames (DOM, SVG).
+
+The plain explainer look: flat fills, a few colours, simple shapes and icons, smooth eased motion.
+
+Flat design comes from Swiss style and modernism; in animation its ancestor is the stylised, limited look of the UPA studio.
+
+## What makes it read as this
+
+- Flat fills, three to five colours, one accent
+- Geometric shapes with one stroke width
+- Plenty of space; one idea per frame
+- Clean sans type
+
+## Timing
+
+Smooth ease-out moves of 0.4 to 0.8 seconds, staggered, with holds long enough to read.
+
+## How to build it
+
+- HTML or SVG with GSAP: this is what HyperFrames is best at
+- Stagger related items 0.15 to 0.25 seconds apart
+- Draw check marks and connectors on with `stroke-dashoffset`
+- Move a highlight instead of cutting
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Soft interface blips, a light bed, voice-led pacing. Practice note.
+
+## What makes it look wrong
+
+- A grid of identical cards
+- Gradients and shadows creeping in
+- Too much on screen at once
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=flat-explainer` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'flat-explainer': { kind: '2d', fps: null, draw(g, t, W, H) {
+ // the explainer look: flat fills, one accent, smooth ease-out moves, a stagger, and a hold at the end
+ bg(g, W, H, '#f5f7fb');
+ const labels = ['Brief', 'Build', 'Check'];
+ for (let i = 0; i < 3; i++) {
+ const k = easeOut(prog(t, 0.2 + i * 0.22, 0.6)), x = W * (0.22 + i * 0.28), y = lerp(H * 0.62, H * 0.46, k);
+ g.globalAlpha = k; g.fillStyle = i === 2 ? '#ff5a1f' : '#1f2a44'; g.beginPath(); g.roundRect(x - 92, y - 62, 184, 124, 22); g.fill();
+ g.fillStyle = '#fff'; g.font = `700 30px ${FONT}`; g.textAlign = 'center'; g.fillText(labels[i], x, y + 10);
+ if (i < 2) { const a = easeOut(prog(t, 0.9 + i * 0.25, 0.4)); g.globalAlpha = a; g.strokeStyle = '#1f2a44'; g.lineWidth = 5; g.lineCap = 'round'; g.beginPath(); g.moveTo(x + 104, H * 0.46); g.lineTo(x + 104 + 60 * a, H * 0.46); g.stroke(); }
+ }
+ g.globalAlpha = 1; g.textAlign = 'left';
+ const c = prog(t, 1.7, 0.45); g.strokeStyle = '#fff'; g.lineWidth = 9; g.lineCap = 'round'; g.lineJoin = 'round';
+ strokePart(g, [[W * 0.78 - 22, H * 0.46 - 44], [W * 0.78 - 8, H * 0.46 - 30], [W * 0.78 + 22, H * 0.46 - 60]], easeOut(c));
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Flat_design>
+- <https://en.wikipedia.org/wiki/United_Productions_of_America>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/infographic.md b/plugin/skills/brief2mp4/references/art-forms/infographic.md
new file mode 100644
index 0000000..ef8ba78
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/infographic.md
@@ -0,0 +1,70 @@
+# Infographic and data animation
+
+Also called: data-viz animation.
+
+Family: Type, data and retro. Cadence: smooth, full frame rate. Usual tool: HyperFrames (SVG, canvas).
+
+A chart that builds in a sensible order: axes, then the data from an honest baseline, then the exact values.
+
+From Playfair's first charts in 1786 to animated infographics in music videos in 2002.
+
+## What makes it read as this
+
+- One chart type that fits the data
+- Direct labels, not a legend
+- An honest axis: bars start at zero
+- One colour for the point being made
+
+## Timing
+
+Axes in about half a second, each series over 0.8 to 1.5 seconds with an ease-out, then a hold to read.
+
+## How to build it
+
+- Drive the chart from one time value; never use a chart library's own transitions
+- Bars grow from the baseline; counters show the rounded value as it grows and end on the exact figure
+- SVG or canvas with scale maths; D3 scales are enough
+- Every number needs a source in the brief
+
+## Assets
+
+The data, with its source. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+A tick or tone per value, a bed that stays out of the way. Practice note.
+
+## What makes it look wrong
+
+- Numbers that were not checked
+- 3D bars
+- An axis cut off to exaggerate a difference
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=infographic` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ infographic: { kind: '2d', fps: null, draw(g, t, W, H) {
+ // axes first, then the bars from a zero baseline, then the exact values. The numbers here are sample data.
+ bg(g, W, H, '#fbfaf6');
+ const data = [['2021', 12], ['2022', 19], ['2023', 31], ['2024', 44], ['2025', 62]], x0 = 130, y0 = H - 100, cw = (W - 220) / data.length, max = 70;
+ g.strokeStyle = '#1b1e22'; g.lineWidth = 3; g.lineCap = 'round'; strokePart(g, [[x0, 70], [x0, y0], [W - 70, y0]], easeOut(prog(t, 0.1, 0.6)));
+ g.font = `600 22px ${FONT}`; g.textAlign = 'center';
+ data.forEach(([label, v], i) => {
+ const k = easeOut(prog(t, 0.6 + i * 0.16, 0.8)), h = (v / max) * (y0 - 90) * k, x = x0 + 26 + i * cw;
+ g.fillStyle = i === data.length - 1 ? '#c4271d' : '#9aa3ad'; g.fillRect(x, y0 - h, cw - 52, h);
+ g.fillStyle = '#555b63'; g.globalAlpha = clamp(prog(t, 0.4, 0.4)); g.fillText(label, x + (cw - 52) / 2, y0 + 34);
+ g.globalAlpha = clamp(k * 2); g.fillStyle = '#1b1e22'; g.fillText(String(Math.round(v * k)), x + (cw - 52) / 2, y0 - h - 14); g.globalAlpha = 1;
+ });
+ g.textAlign = 'left'; g.fillStyle = '#1b1e22'; g.font = `800 30px ${FONT}`; g.globalAlpha = clamp(prog(t, 0.1, 0.4)); g.fillText('Sample data: units per year', x0, 50); g.globalAlpha = 1;
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Infographic>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/ink-wash.md b/plugin/skills/brief2mp4/references/art-forms/ink-wash.md
new file mode 100644
index 0000000..739ff16
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/ink-wash.md
@@ -0,0 +1,70 @@
+# Ink wash (sumi-e)
+
+Also called: sumi-e, ink painting.
+
+Family: Drawn and painted. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas or SVG).
+
+Black ink in every shade from deep black to pale grey, laid down in tapered brush strokes on rice paper, with a great deal left empty.
+
+Chinese ink wash painting from the Tang dynasty, carried to Japan by Zen monks. Shanghai Animation Film Studio made ink-wash films from 1960.
+
+## What makes it read as this
+
+- One ink, many dilutions
+- Strokes that taper from thick to a point
+- Empty paper as part of the picture
+- One small red seal
+- Soft grey washes behind sharp strokes
+
+## Timing
+
+Slow and fluid. A stroke accelerates and lifts. On twos.
+
+## How to build it
+
+- A stroke is a row of overlapping dots whose radius tapers along its length, drawn up to a fraction
+- Vary each dot's opacity with a seeded hash for a dry-brush break
+- Washes: soft radial gradients with `multiply`
+- SVG route: variable-width filled paths revealed by a mask
+
+## Assets
+
+Procedural. Rice-paper grain. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Sparse: flute, single plucked notes, silence. Practice note.
+
+## What makes it look wrong
+
+- Pure black on pure white
+- Uniform stroke width
+- Filling the frame
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=ink-wash` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'ink-wash': { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // bamboo in ink: tapered strokes laid down segment by segment, grey washes, a red seal, a lot of empty paper
+ const ts = onTwos(t);
+ bg(g, W, H, '#f2ecdd');
+ const stroke = (x0, y0, x1, y1, w0, w1, k, alpha = 0.92) => { const n = 60; for (let i = 0; i <= n * clamp(k); i++) { const e = i / n, r = lerp(w0, w1, e) * (0.85 + 0.3 * hash(i, x0 | 0)); g.fillStyle = `rgba(22,22,24,${alpha * (0.55 + 0.45 * hash(i, y0 | 0))})`; g.beginPath(); g.arc(lerp(x0, x1, e), lerp(y0, y1, e) + Math.sin(e * 3) * 3, r, 0, TAU); g.fill(); } };
+ for (let s = 0; s < 4; s++) stroke(W * 0.3 + s * 3, H * 0.96 - s * 118, W * 0.3 + (s + 1) * 3, H * 0.96 - (s + 1) * 118 + 8, 13 - s, 12 - s, prog(ts, 0.1 + s * 0.3, 0.3));
+ const leaf = (x, y, a, l, start) => stroke(x, y, x + Math.cos(a) * l, y + Math.sin(a) * l, 9, 0.6, easeOut(prog(ts, start, 0.3)), 0.85);
+ leaf(W * 0.31, H * 0.5, -0.3, 150, 1.4); leaf(W * 0.31, H * 0.5, 0.25, 130, 1.6); leaf(W * 0.31, H * 0.3, -0.7, 120, 1.8); leaf(W * 0.31, H * 0.3, -0.05, 160, 2.0);
+ g.globalCompositeOperation = 'multiply'; const m = g.createRadialGradient(W * 0.7, H * 0.72, 10, W * 0.7, H * 0.72, 220); m.addColorStop(0, `rgba(60,62,66,${0.35 * prog(ts, 0.4, 1.5)})`); m.addColorStop(1, 'rgba(60,62,66,0)'); g.fillStyle = m; g.fillRect(0, 0, W, H); g.globalCompositeOperation = 'source-over';
+ const k = prog(ts, 2.3, 0.2); if (k > 0) { g.fillStyle = '#b3261e'; g.fillRect(W * 0.82, H * 0.74, 38 * k, 38); }
+ paper(g, W, H, 15, 22);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Ink_wash_painting>
+- <https://en.wikipedia.org/wiki/Shanghai_Animation_Film_Studio>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/isometric.md b/plugin/skills/brief2mp4/references/art-forms/isometric.md
new file mode 100644
index 0000000..0936c75
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/isometric.md
@@ -0,0 +1,71 @@
+# Isometric
+
+Family: Geometry, pixels and 3D. Cadence: smooth, full frame rate. Usual tool: HyperFrames (canvas, SVG) or Three.js.
+
+A parallel projection seen from above at an angle: no perspective, three visible faces per block, a tidy model world.
+
+A technical drawing projection. Games use a 2:1 pixel slope, about 26.6 degrees, which is strictly dimetric.
+
+## What makes it read as this
+
+- No perspective: parallel lines stay parallel
+- Three tones per object: top lightest, one side mid, one side darkest
+- One light direction for everything
+- A grid floor
+
+## Timing
+
+The camera does not orbit. Objects drop, stack and slide along the three axes, staggered by grid position.
+
+## How to build it
+
+- 2D: `x = (gx - gy) * s`, `y = (gx + gy) * s / 2 - gz * s`; draw the two side faces, then the top
+- Sort by `gx + gy`, then by height, so nearer cubes cover farther ones
+- Three.js: an `OrthographicCamera` placed at equal x, y and z looking at the origin
+- CSS: `rotateX(60deg) rotateZ(-45deg)` on a flat layer
+
+Use Blender for bevelled, ambient-occluded isometric scenes.
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Soft clicks as pieces land. Practice note.
+
+## What makes it look wrong
+
+- A perspective camera by accident
+- Shadows that disagree with the light
+- Uneven block heights
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=isometric` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ isometric: { kind: '2d', fps: null, draw(g, t, W, H) {
+ // a parallel projection: no perspective, three tones per cube, one light. Cubes drop in, staggered by grid position.
+ bg(g, W, H, '#eaf0f6');
+ const s = 44, ox = W / 2, oy = H * 0.34, iso = (x, y, z) => [ox + (x - y) * s, oy + (x + y) * s * 0.5 - z * s];
+ const quad = (pts, col) => { g.beginPath(); pts.forEach(([x, y], i) => (i ? g.lineTo(x, y) : g.moveTo(x, y))); g.closePath(); fill(g, col); };
+ for (let y = 0; y < 5; y++) for (let x = 0; x < 5; x++) quad([iso(x, y, 0), iso(x + 1, y, 0), iso(x + 1, y + 1, 0), iso(x, y + 1, 0)], (x + y) % 2 ? '#d5dfea' : '#dfe7f0');
+ const towers = [[0, 0, 2], [1, 3, 1], [2, 1, 3], [3, 3, 2], [4, 0, 1], [3, 1, 1], [1, 1, 1], [4, 4, 3]];
+ towers.sort((a, b) => a[0] + a[1] - (b[0] + b[1]));
+ for (const [x, y, h] of towers) for (let z = 0; z < h; z++) {
+ const k = prog(t, 0.2 + (x + y) * 0.12 + z * 0.14, 0.5); if (k <= 0) continue; const zz = z + (1 - bounce(k)) * 7, hue = 216 + (x * 7 + y * 13) % 40;
+ quad([iso(x, y + 1, zz + 1), iso(x + 1, y + 1, zz + 1), iso(x + 1, y + 1, zz), iso(x, y + 1, zz)], `hsl(${hue} 52% 42%)`);
+ quad([iso(x + 1, y, zz + 1), iso(x + 1, y + 1, zz + 1), iso(x + 1, y + 1, zz), iso(x + 1, y, zz)], `hsl(${hue} 52% 54%)`);
+ quad([iso(x, y, zz + 1), iso(x + 1, y, zz + 1), iso(x + 1, y + 1, zz + 1), iso(x, y + 1, zz + 1)], `hsl(${hue} 60% 70%)`);
+ }
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Isometric_video_game_graphics>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/kinetic-type.md b/plugin/skills/brief2mp4/references/art-forms/kinetic-type.md
new file mode 100644
index 0000000..3b7abd6
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/kinetic-type.md
@@ -0,0 +1,67 @@
+# Kinetic typography
+
+Also called: motion typography.
+
+Family: Type, data and retro. Cadence: smooth, full frame rate. Usual tool: HyperFrames (DOM).
+
+Moving words as the whole picture: scale, weight and timing carry the meaning.
+
+Saul Bass's title sequences for North by Northwest (1959) and Psycho (1960) made it a form.
+
+## What makes it read as this
+
+- Type is the image; nothing competes with it
+- Strong contrast of size and weight
+- Words arrive in reading order, on the beat
+- One idea per frame
+
+## Timing
+
+Each word lands in 0.3 to 0.5 seconds with a small overshoot, then the line holds long enough to read.
+
+## How to build it
+
+- HyperFrames: split text into inline-block spans and stagger with GSAP
+- Canvas: `fillText` with a transform per word
+- Timing from the narration: one start time per word
+- Hold for (words / 3) + 0.5 seconds before the next line
+
+## Assets
+
+A typeface with enough weights. No pictures. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Cut to the voice or the beat. Practice note.
+
+## What makes it look wrong
+
+- Words faster than they can be read
+- Effects that add no meaning
+- Everything moving at once
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=kinetic-type` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'kinetic-type': { kind: '2d', fps: null, draw(g, t, W, H) {
+ // the words are the picture: each one lands with an overshoot, in reading order, then the line holds still
+ bg(g, W, H, '#101319'); g.textAlign = 'center'; g.textBaseline = 'middle';
+ const words = [['MAKE', '#f4f1ea', 0.15, H * 0.3, 118], ['IT', '#ff5a1f', 0.6, H * 0.52, 150], ['MOVE.', '#f4f1ea', 1.05, H * 0.76, 118]];
+ for (const [w, col, start, y, size] of words) {
+ const k = prog(t, start, 0.5); if (k <= 0) continue; const s = overshoot(k);
+ g.save(); g.translate(W / 2, y + (1 - easeOut(k)) * 40); g.scale(s, s); g.globalAlpha = clamp(k * 3); g.fillStyle = col; g.font = `900 ${size}px ${FONT}`; g.fillText(w, 0, 0); g.restore();
+ }
+ const u = easeOut(prog(t, 1.7, 0.5)); g.fillStyle = '#ff5a1f'; g.fillRect(W / 2 - 190 * u, H * 0.9, 380 * u, 8);
+ g.textAlign = 'left'; g.textBaseline = 'alphabetic';
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Kinetic_typography>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/line-art.md b/plugin/skills/brief2mp4/references/art-forms/line-art.md
new file mode 100644
index 0000000..3d18f3a
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/line-art.md
@@ -0,0 +1,65 @@
+# Line art
+
+Also called: minimal line.
+
+Family: Drawn and painted. Cadence: steps 10 times a second. Usual tool: HyperFrames (SVG or canvas).
+
+One weight of line on a plain ground, no shading: the drawing draws itself, then quivers slightly as if redrawn each frame.
+
+Drawing with line alone, where tone comes only from hatching or stippling.
+
+## What makes it read as this
+
+- A constant or tapered stroke with round ends
+- No fills, or one flat tone
+- Plenty of empty space
+- One accent colour at most
+
+## Timing
+
+Draw-on over 1 to 2 seconds, then a boil at 8 to 12 changes a second.
+
+## How to build it
+
+- Draw-on with `stroke-dashoffset` (canvas: a polyline to a fraction of its length)
+- Boil: a seeded nudge of 1 to 2 px per point, keyed to the frame number
+- SVG route: `feTurbulence` with `seed` set from the frame number, into `feDisplacementMap` (scale 1.5 to 3)
+- `vector-effect: non-scaling-stroke` keeps the weight when scaled
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+A pencil or pen sound under the draw-on. Practice note.
+
+## What makes it look wrong
+
+- Jitter so strong the line turns to noise
+- Filters that re-run on a large area every frame and slow the render
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=line-art` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'line-art': { kind: '2d', fps: 10, draw(g, t, W, H) {
+ // one continuous line that draws a cup and its steam, then keeps quivering
+ const f = frameOf(t, 10);
+ bg(g, W, H, '#fffdf8'); g.strokeStyle = '#151515'; g.lineWidth = 3.2; g.lineCap = 'round'; g.lineJoin = 'round';
+ const cup = [[W * 0.62, H * 0.5], [W * 0.36, H * 0.5], [W * 0.38, H * 0.7], [W * 0.42, H * 0.76], [W * 0.56, H * 0.76], [W * 0.6, H * 0.7], [W * 0.62, H * 0.5], ...circlePts(W * 0.625, H * 0.6, 44, 16, -Math.PI * 0.5, Math.PI * 0.5)];
+ strokePart(g, cup, easeInOut(prog(t, 0.1, 1.5)), f, 1.3);
+ for (let i = 0; i < 3; i++) strokePart(g, Array.from({ length: 24 }, (_, j) => [W * (0.43 + i * 0.06) + Math.sin(j * 0.6 + i) * 9, H * 0.45 - j * 6]), easeOut(prog(t, 1.5 + i * 0.2, 0.7)), f, 1.3);
+ g.fillStyle = '#e0532f'; const k = easeOut(prog(t, 2.3, 0.3)); g.beginPath(); g.arc(W * 0.3, H * 0.8, 9 * k, 0, TAU); g.fill();
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Line_art>
+- <https://camillovisini.com/coding/simulating-hand-drawn-motion-with-svg-filters>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/linocut.md b/plugin/skills/brief2mp4/references/art-forms/linocut.md
new file mode 100644
index 0000000..5856775
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/linocut.md
@@ -0,0 +1,70 @@
+# Linocut and woodcut print
+
+Family: Drawn and painted. Cadence: steps 8 times a second. Usual tool: HyperFrames (canvas, SVG).
+
+A relief print: bold flat shapes in one to three inks, with white gouge marks where the block was carved.
+
+Carved in linoleum or wood; the uncut surface prints. Each colour is a separate block.
+
+Sourcing note: The source covers the technique; the visual rules are practice notes.
+
+## What makes it read as this
+
+- Bold shapes, no fine detail
+- Short white cut marks inside the ink, all leaning one way
+- One to three inks, laid slightly off register
+- Paper showing at the edges
+
+## Timing
+
+Each colour arrives as a pull, top to bottom, then holds. On twos or slower.
+
+## How to build it
+
+- Draw each block to its own canvas, then cut marks out of it: short strokes with `destination-out`
+- Print blocks over each other with `multiply`, the second one offset a few pixels
+- Reveal a block by widening a clip from the top
+- SVG route: `feTurbulence` through a hard threshold makes rough voids
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+A roller, a press, paper lifting. Practice note.
+
+## What makes it look wrong
+
+- Gradients
+- Thin delicate lines
+- Too many colours
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=linocut` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ linocut: { kind: '2d', fps: 8, draw(g, t, W, H) {
+ // two blocks, two inks. Bold shapes with white gouge marks cut out of them; the second colour lands a little off.
+ const ts = held(t, 8);
+ bg(g, W, H, '#efe7d3');
+ const block = (col, k, dx, dy, shape, seed) => {
+ if (k <= 0) return; const c = new OffscreenCanvas(W, H), b = c.getContext('2d');
+ b.fillStyle = col; shape(b); b.globalCompositeOperation = 'destination-out'; b.strokeStyle = '#000'; b.lineCap = 'round';
+ for (let i = 0; i < 230; i++) { const x = hash(i, seed) * W, y = hash(i, seed, 1) * H, a = -0.6 + hash(i, seed, 2) * 0.5, l = 14 + hash(i, seed, 3) * 38; b.lineWidth = 1.5 + hash(i, seed, 4) * 4; b.beginPath(); b.moveTo(x, y); b.lineTo(x + Math.cos(a) * l, y + Math.sin(a) * l); b.stroke(); }
+ g.save(); g.globalCompositeOperation = 'multiply'; g.globalAlpha = 0.94; g.beginPath(); g.rect(0, 0, W, H * k); g.clip(); g.drawImage(c, dx, dy); g.restore(); // the print is "pulled" from the top
+ };
+ block('#1f3b57', prog(ts, 0.2, 0.9), 0, 0, (b) => { b.beginPath(); b.moveTo(0, H * 0.78); b.lineTo(W * 0.24, H * 0.4); b.lineTo(W * 0.42, H * 0.62); b.lineTo(W * 0.62, H * 0.26); b.lineTo(W, H * 0.7); b.lineTo(W, H); b.lineTo(0, H); b.closePath(); b.fill(); }, 61);
+ block('#d6452b', prog(ts, 1.3, 0.9), 7, -5, (b) => { b.beginPath(); b.arc(W * 0.74, H * 0.26, 76, 0, TAU); b.fill(); b.fillRect(W * 0.1, H * 0.84, W * 0.8, 26); }, 62);
+ paper(g, W, H, 19, 24);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Linocut>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/low-poly.md b/plugin/skills/brief2mp4/references/art-forms/low-poly.md
new file mode 100644
index 0000000..2870a8a
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/low-poly.md
@@ -0,0 +1,78 @@
+# Low-poly 3D
+
+Family: Geometry, pixels and 3D. Cadence: smooth, full frame rate. Usual tool: Three.js inside HyperFrames.
+
+Meshes with few polygons, each face lit as one flat facet. A hardware limit that became a style.
+
+From the era of early 3D consoles; chosen on purpose since about 2013.
+
+## What makes it read as this
+
+- Visible facets, flat shaded
+- A limited, saturated palette
+- Simple lighting and a gradient or flat sky
+- Chunky silhouettes
+
+## Timing
+
+Clean, so smooth: slow eased orbits and dollies at the full frame rate.
+
+## How to build it
+
+- Low segment counts and `flatShading: true` on `MeshStandardMaterial`
+- Displace a plane's vertices with a seeded hash for terrain, then `computeVertexNormals()`
+- A hemisphere light plus one directional key; fog in the sky colour for depth
+- Camera position from `t` directly
+
+Use Blender for modelling and baked light.
+
+## Assets
+
+Geometry in code for landscapes and props. Characters need modelling. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Calm, spacious. Practice note.
+
+## What makes it look wrong
+
+- Smooth normals, which erase the facets
+- Detailed textures that fight the flat colour
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=low-poly` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'low-poly': { kind: '3d', fps: null, setup(THREE, scene, camera) {
+ // few polygons, each lit as one flat facet. Clean, so the camera move is smooth, not stepped.
+ scene.background = new THREE.Color('#bfe3f2'); scene.fog = new THREE.Fog('#bfe3f2', 9, 22);
+ const geo = new THREE.PlaneGeometry(26, 26, 22, 22); geo.rotateX(-Math.PI / 2); const p = geo.attributes.position;
+ for (let i = 0; i < p.count; i++) { const x = p.getX(i), z = p.getZ(i), d = Math.hypot(x, z); p.setY(i, Math.max(0, 3.2 - d * 0.42) * (0.6 + hash(i, 9) * 0.9) + hash(i, 4) * 0.25); }
+ geo.computeVertexNormals(); const land = new THREE.Mesh(geo, new THREE.MeshStandardMaterial({ color: '#5fa36a', flatShading: true, roughness: 0.9 }));
+ const sunBall = new THREE.Mesh(new THREE.IcosahedronGeometry(0.9, 1), new THREE.MeshBasicMaterial({ color: '#ffd166' })); sunBall.position.set(-5, 5.5, -8);
+ const trees = new THREE.Group(); for (let i = 0; i < 22; i++) { const a = hash(i, 1) * TAU, r = 3.6 + hash(i, 2) * 5, tr = new THREE.Mesh(new THREE.ConeGeometry(0.34, 1.1, 5), new THREE.MeshStandardMaterial({ color: '#2f6b4f', flatShading: true })); tr.position.set(Math.cos(a) * r, 0.75, Math.sin(a) * r); trees.add(tr); }
+ scene.add(land, sunBall, trees, new THREE.HemisphereLight('#ffffff', '#4a6a4a', 1.4)); const key = new THREE.DirectionalLight('#fff0d0', 2.4); key.position.set(-5, 6, 2); scene.add(key);
+ return { camera };
+ }, draw(s, t) { const a = 0.5 + t * 0.22; s.camera.position.set(Math.sin(a) * 11, 4.6, Math.cos(a) * 11); s.camera.lookAt(0, 1.4, 0); } },
+ voxel: { kind: '3d', fps: 12, setup(THREE, scene, camera) {
+ // every cube the same size, on a grid, in one instanced mesh. The model builds layer by layer, on twos.
+ scene.background = new THREE.Color('#1c2333');
+ const cells = []; for (let y = 0; y < 9; y++) for (let x = -4; x <= 4; x++) for (let z = -4; z <= 4; z++) { const d = Math.hypot(x, z); const trunk = y < 4 && d < 1.2, leaves = y >= 3 && Math.hypot(x, (y - 6) * 1.25, z) < 3.6 && hash(x + 9, y, z + 9) > 0.12; if (trunk || leaves) cells.push([x, y, z, trunk && y < 4 && !leaves ? '#7a4f2a' : hash(x, y, z) > 0.5 ? '#3f9b57' : '#2f7d47']); }
+ const mesh = new THREE.InstancedMesh(new THREE.BoxGeometry(0.96, 0.96, 0.96), new THREE.MeshLambertMaterial(), cells.length), col = new THREE.Color();
+ cells.forEach((c, i) => mesh.setColorAt(i, col.set(c[3]))); scene.add(mesh, new THREE.HemisphereLight('#ffffff', '#33405a', 1.6)); const key = new THREE.DirectionalLight('#ffffff', 2); key.position.set(6, 9, 4); scene.add(key);
+ return { mesh, cells, m: new THREE.Matrix4(), camera };
+ }, draw(s, t) {
+ const ts = held(t, 12), shown = Math.floor(clamp(ts / 2.2) * 9.99);
+ s.cells.forEach(([x, y, z], i) => { const on = y <= shown; s.m.makeScale(on ? 1 : 0.0001, on ? 1 : 0.0001, on ? 1 : 0.0001); s.m.setPosition(x, y - 4, z); s.mesh.setMatrixAt(i, s.m); });
+ s.mesh.instanceMatrix.needsUpdate = true; const a = 0.7 + ts * 0.35; s.camera.position.set(Math.sin(a) * 15, 6, Math.cos(a) * 15); s.camera.lookAt(0, 0, 0);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Low_poly>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/lyric-video.md b/plugin/skills/brief2mp4/references/art-forms/lyric-video.md
new file mode 100644
index 0000000..f73ef07
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/lyric-video.md
@@ -0,0 +1,72 @@
+# Lyric video
+
+Family: Type, data and retro. Cadence: smooth, full frame rate. Usual tool: HyperFrames (DOM, canvas).
+
+The words of a song as the main image, each line timed to the vocal and the active word lit.
+
+Lyric text appears in music videos from the 1980s; the format took off on video sites in the 2010s.
+
+## What makes it read as this
+
+- Three to eight words on screen
+- The word being sung is brighter or larger
+- A background that never fights the text
+- One typographic system for the whole song
+
+## Timing
+
+Locked to the music. A word changes exactly on its beat; a few frames late is visible.
+
+## How to build it
+
+- Word start times from forced alignment or a beat grid
+- Compute the active line and word from `t`
+- A pulse from the beat phase: `1 - (beat % 1)` drives scale and background
+- Measure words first so the line is centred
+
+## Assets
+
+The audio, with the right to use it, and its word timings. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+The song.
+
+## What makes it look wrong
+
+- Timing that drifts
+- Text over a busy background
+- Music you have no licence for
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=lyric-video` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'lyric-video': { kind: '2d', fps: null, draw(g, t, W, H) {
+ // one line at a time, and the word being sung is lit. Timing comes from a beat grid (here 120 beats a minute).
+ const beat = t / 0.5, pulse = 1 - (beat % 1);
+ const grad = g.createLinearGradient(0, 0, W, H); grad.addColorStop(0, `hsl(${258 + pulse * 8} 60% ${16 + pulse * 5}%)`); grad.addColorStop(1, 'hsl(320 60% 22%)');
+ g.globalCompositeOperation = 'source-over'; g.fillStyle = grad; g.fillRect(0, 0, W, H);
+ const lines = [['say', 'it', 'once'], ['and', 'let', 'it', 'move']], li = Math.min(1, Math.floor(beat / 3)), line = lines[li], wi = Math.min(line.length - 1, Math.floor(beat - li * 3));
+ g.font = `800 84px ${FONT}`; g.textBaseline = 'middle';
+ const widths = line.map((w) => g.measureText(w + ' ').width), total = widths.reduce((a, b) => a + b, 0); let x = (W - total) / 2;
+ const enter = easeOut(prog(beat - li * 3, 0, 0.5));
+ line.forEach((w, i) => {
+ const active = i === wi, done = i < wi, s = active ? 1 + 0.08 * pulse : 1;
+ g.save(); g.translate(x + widths[i] / 2, H / 2 + (1 - enter) * 30); g.scale(s, s); g.globalAlpha = enter * (active ? 1 : done ? 0.85 : 0.35);
+ g.fillStyle = active ? '#ffd166' : '#ffffff'; g.textAlign = 'center'; g.fillText(w, 0, 0); g.restore(); x += widths[i];
+ });
+ g.textAlign = 'left'; g.textBaseline = 'alphabetic';
+ for (let i = 0; i < 6; i++) { g.fillStyle = i <= beat % 6 ? '#ffd166' : 'rgba(255,255,255,.25)'; g.fillRect(W / 2 - 96 + i * 34, H - 70, 22, 6); }
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Lyric_video>
+- <https://en.wikipedia.org/wiki/Kinetic_typography>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/motion-comic.md b/plugin/skills/brief2mp4/references/art-forms/motion-comic.md
new file mode 100644
index 0000000..f845ad0
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/motion-comic.md
@@ -0,0 +1,72 @@
+# Motion comic
+
+Family: Drawn and painted. Cadence: smooth, full frame rate. Usual tool: HyperFrames (DOM or canvas).
+
+Comic panels brought to life: layers inside a panel slide at different speeds under a slow camera move, then a hard cut to the next panel.
+
+Watchmen: Motion Comic (2008) is the usual first example.
+
+Sourcing note: Pan-and-zoom staging is a practice note; the source describes the format, not the technique.
+
+## What makes it read as this
+
+- Ink outlines, flat colour, halftone shading
+- A panel border
+- Foreground, figure and background on separate layers
+- Bursts and lettering as graphic elements
+
+## Timing
+
+Slow pushes and pans of 2 to 4 seconds, hard cuts between panels, a pop for a burst.
+
+## How to build it
+
+- Layers in a clipped panel; move far layers less than near ones
+- A slow scale from 1 to about 1.07 on the whole panel
+- Halftone shading: dots that shrink across the tone
+- Cut to the next panel by switching the scene at a time, not by cross-fading
+
+## Assets
+
+Drawn panels in layers. Artwork needs an illustrator or generated images cut into layers. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Voice, music and effects carry it. Practice note.
+
+## What makes it look wrong
+
+- A slow zoom on one flat image, which reads as a slideshow
+- No separation between figure and background
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=motion-comic` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'motion-comic': { kind: '2d', fps: null, draw(g, t, W, H) {
+ // two panels and a hard cut. Inside each: layers that move at different speeds under a slow push-in, with halftone shading.
+ bg(g, W, H, '#f0ead8');
+ const second = t >= 1.6, k = second ? prog(t, 1.6, 1.4) : prog(t, 0, 1.6), z = 1 + 0.07 * k;
+ g.save(); g.beginPath(); g.rect(40, 40, W - 80, H - 80); g.clip();
+ g.translate(W / 2, H / 2); g.scale(z, z); g.translate(-W / 2, -H / 2);
+ g.fillStyle = second ? '#ffcf4a' : '#27335c'; g.fillRect(0, 0, W, H);
+ g.fillStyle = second ? '#e9772b' : '#141b36'; // far layer: slow
+ for (let i = 0; i < 9; i++) { const h = 120 + hash(i, second ? 5 : 3) * 190; g.fillRect(i * 120 - 40 - k * 18, H - 120 - h, 96, h + 200); }
+ g.fillStyle = 'rgba(0,0,0,.28)'; // halftone shade, dots shrink to the right
+ for (let y = 60; y < H; y += 14) for (let x = 60; x < W * 0.5; x += 14) { g.beginPath(); g.arc(x + ((y / 14) % 2 | 0) * 7, y, 4.5 * (1 - x / (W * 0.5)), 0, TAU); g.fill(); }
+ g.save(); g.translate(W * (second ? 0.62 : 0.4) + k * 46, H * 0.66); // near layer: fast
+ g.fillStyle = '#101010'; g.beginPath(); g.moveTo(-70, 220); g.lineTo(-52, -40); g.lineTo(-20, -70); g.arc(0, -108, 44, Math.PI * 0.7, Math.PI * 2.3); g.lineTo(52, -40); g.lineTo(70, 220); g.closePath(); g.fill(); g.restore();
+ if (second) { const b = overshoot(prog(t, 1.75, 0.35)); g.save(); g.translate(W * 0.3, H * 0.34); g.scale(b, b); g.fillStyle = '#fff'; g.strokeStyle = '#101010'; g.lineWidth = 5; g.beginPath(); for (let i = 0; i < 20; i++) { const a = (i / 20) * TAU, r = i % 2 ? 62 : 104; i ? g.lineTo(Math.cos(a) * r, Math.sin(a) * r) : g.moveTo(Math.cos(a) * r, Math.sin(a) * r); } g.closePath(); g.fill(); g.stroke(); g.fillStyle = '#101010'; g.font = `900 46px ${FONT}`; g.textAlign = 'center'; g.fillText('NOW!', 0, 16); g.textAlign = 'left'; g.restore(); }
+ g.restore(); g.strokeStyle = '#101010'; g.lineWidth = 8; g.strokeRect(40, 40, W - 80, H - 80);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Motion_comic>
+- <https://en.wikipedia.org/wiki/Limited_animation>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/neon-sign.md b/plugin/skills/brief2mp4/references/art-forms/neon-sign.md
new file mode 100644
index 0000000..3d06837
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/neon-sign.md
@@ -0,0 +1,68 @@
+# Neon sign
+
+Family: Type, data and retro. Cadence: steps 24 times a second. Usual tool: HyperFrames (canvas, SVG).
+
+Glass tubes bent into letters and lit: a bright core, a coloured glow, a dark wall, tubes that light one by one and sometimes flicker.
+
+Glass tubing filled with gas and lit by electrodes; sections can be switched in sequence.
+
+## What makes it read as this
+
+- One continuous line per letter, one width
+- A white-hot core inside a coloured halo
+- A dark wall behind
+- Letters light in sequence
+
+## Timing
+
+Tubes come on in order with a short stutter each; now and then one dims for a frame.
+
+## How to build it
+
+- Each tube is drawn three times: a wide faint stroke, a medium one, a thin white core, all with `shadowBlur`
+- Add them with the `lighter` blend (CSS: `mix-blend-mode: plus-lighter` or `screen`)
+- Flicker from `hash(frame, tube)`, never from a random call
+- Three.js: `UnrealBloomPass` for bloom on emissive geometry
+
+## Assets
+
+Letter paths in code. A brick or plaster texture can be drawn. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+A low electrical hum, a tick as each tube lights. Practice note.
+
+## What makes it look wrong
+
+- A glow so wide the word cannot be read
+- Filled letters instead of a single tube
+- Flicker that differs between renders
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=neon-sign` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'neon-sign': { kind: '2d', fps: 24, draw(g, t, W, H) {
+ // one continuous tube per letter, a bright core with a coloured halo, lit letter by letter, with a seeded flicker
+ const f = frameOf(t, 24);
+ bg(g, W, H, '#120a16'); g.fillStyle = 'rgba(255,255,255,.035)'; for (let y = 0; y < H; y += 34) for (let x = (y / 34) % 2 ? 0 : 45; x < W; x += 90) g.fillRect(x, y, 86, 30);
+ const L = { O: circlePts(0, 0, 54, 30), P: [[-40, 60], [-40, -56], [10, -56], ...circlePts(10, -22, 34, 12, -Math.PI / 2, Math.PI / 2), [-40, 12]], E: [[40, -56], [-40, -56], [-40, 0], [20, 0], [-40, 0], [-40, 60], [40, 60]], N: [[-40, 60], [-40, -56], [40, 60], [40, -56]] };
+ g.lineCap = 'round'; g.lineJoin = 'round'; g.globalCompositeOperation = 'lighter';
+ [...'OPEN'].forEach((ch, i) => {
+ const on = t > 0.3 + i * 0.35, stutter = on && t < 0.3 + i * 0.35 + 0.25 && hash(f, i) < 0.45, dim = i === 2 && hash(f, 44) < 0.06; // a start-up stutter, and one tired tube
+ const a = !on || stutter ? 0.08 : dim ? 0.35 : 1, pts = L[ch].map(([x, y]) => [W * (0.2 + i * 0.2) + x, H * 0.5 + y]), col = i % 2 ? '80,220,255' : '255,60,170';
+ for (const [w, alpha, blur] of [[26, 0.16, 26], [12, 0.4, 12], [5, 1, 0]]) { g.strokeStyle = blur ? `rgba(${col},${alpha * a})` : `rgba(255,255,255,${a})`; g.shadowColor = `rgba(${col},${a})`; g.shadowBlur = blur; g.lineWidth = w; strokePart(g, pts, 1); }
+ });
+ g.shadowBlur = 0; g.globalCompositeOperation = 'source-over';
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Neon_sign>
+- <https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/origami.md b/plugin/skills/brief2mp4/references/art-forms/origami.md
new file mode 100644
index 0000000..d496dba
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/origami.md
@@ -0,0 +1,77 @@
+# Origami
+
+Family: Craft and handmade. Cadence: smooth, full frame rate. Usual tool: HyperFrames (canvas or SVG), or Three.js.
+
+Paper folded from a flat sheet: sharp creases, flat facets, each fold a clean move followed by a pause.
+
+Japanese paper folding. Modern computational origami works from crease patterns.
+
+## What makes it read as this
+
+- Sharp mountain and valley creases
+- Flat facets, each shaded as one plane
+- Paper coloured on one side, white on the other
+- Soft, even light so the creases read
+
+## Timing
+
+Folds are eased moves of about 0.8 seconds with a short hold after each. Smooth, not stepped.
+
+## How to build it
+
+- 2D: a fold is a point travelling across the crease; draw the moving flap from the crease to that point
+- Shade the flap by its angle, and swap to the paper's other colour past 90 degrees
+- 3D: flat-shaded polygons, child groups rotating about the crease axis
+- An orthographic camera gives a diagram-clean view
+
+Use Blender when the paper has to bend or show thickness.
+
+## Assets
+
+Geometry in code. A faint paper grain. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Light paper crinkle on each fold, soft piano or music box. Practice note.
+
+## What makes it look wrong
+
+- Faces passing through each other
+- Folding with no hold, so the eye cannot follow
+- Light that hides the creases
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=origami` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ origami: { kind: '2d', fps: null, draw(g, t, W, H) {
+ // a square folds corner to corner, holds, then folds again. Each fold is an eased move with a hold after it.
+ bg(g, W, H, '#eef0ee');
+ const cx = W / 2, cy = H / 2 + 20, s = 150;
+ const f1 = easeInOut(prog(t, 0.3, 0.8)), f2 = easeInOut(prog(t, 1.5, 0.8));
+ const face = (pts, col) => { g.beginPath(); pts.forEach(([x, y], i) => (i ? g.lineTo(x, y) : g.moveTo(x, y))); g.closePath(); fill(g, col); g.strokeStyle = 'rgba(40,50,60,.45)'; g.lineWidth = 1.2; g.stroke(); };
+ g.save(); g.translate(cx, cy);
+ g.fillStyle = 'rgba(30,40,50,.12)'; g.beginPath(); g.ellipse(0, s * 0.95, s * 1.05, 16, 0, 0, TAU); g.fill();
+ // the fixed lower-left triangle, then the upper-right triangle swinging over the diagonal crease
+ const a1 = f1 * Math.PI, k1 = Math.cos(a1); // 1 flat, -1 folded over
+ face([[-s, -s], [s, s], [-s, s]], '#f7f7f4');
+ const tip = [lerp(s, -s, (1 - k1) / 2), lerp(-s, s, (1 - k1) / 2)];
+ face([[-s, -s], [s, s], tip], k1 > 0 ? `hsl(8 70% ${58 - (1 - k1) * 16}%)` : `hsl(0 0% ${90 - (1 + k1) * 6}%)`);
+ if (f1 >= 1) { // second fold: the bottom-right corner comes up
+ const k2 = Math.cos(f2 * Math.PI), tip2 = [lerp(s, 0, (1 - k2) / 2), lerp(s, 0, (1 - k2) / 2)];
+ face([[0, 0], [0, s], [s, s], [0, 0]].slice(0, 3).map((p, i) => (i === 2 ? tip2 : p)), k2 > 0 ? '#e8e8e4' : '#d8553f');
+ }
+ g.setLineDash([6, 6]); g.strokeStyle = 'rgba(40,50,60,.5)'; g.beginPath(); g.moveTo(-s, -s); g.lineTo(s, s); g.stroke(); g.setLineDash([]);
+ g.restore(); paper(g, W, H, 8, 12);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Origami>
+- <https://github.com/amandaghassaei/OrigamiSimulator>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/paper-cutout.md b/plugin/skills/brief2mp4/references/art-forms/paper-cutout.md
new file mode 100644
index 0000000..b693471
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/paper-cutout.md
@@ -0,0 +1,77 @@
+# Paper cut-out
+
+Also called: papercraft, cutout animation.
+
+Family: Craft and handmade. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas, SVG or DOM).
+
+Flat shapes cut from paper or card, layered, and moved a pose at a time. Parts hinge at joints; nothing bends.
+
+Lotte Reiniger's The Adventures of Prince Achmed (1926) is the oldest surviving animated feature. Terry Gilliam's Monty Python animations and the South Park pilot used cut paper.
+
+## What makes it read as this
+
+- Flat fills with hard, slightly uneven cut edges
+- Layers stacked with a small, tight shadow under each
+- Rigid parts that rotate about a pivot
+- Paper grain over everything
+- A limited, slightly muted palette
+
+## Timing
+
+Stop-motion cadence, usually on twos. Motion is rotation about joints and sliding, with pops and holds.
+
+## How to build it
+
+- Each part is its own shape; nudge the corners with a seeded hash so edges look cut by hand
+- Canvas: `shadowOffsetY` 3 to 4 px with `shadowBlur` 4 to 5 px per layer. DOM: `filter: drop-shadow()`
+- Joints: rotate about a pivot (`transformOrigin` in GSAP, `translate` then `rotate` on a canvas)
+- Paper grain: a noise texture drawn once and laid over with `multiply`
+- SVG route: `feTurbulence` into `feDisplacementMap` (scale 2 to 4) roughens an edge
+
+Use Blender for real folded paper with thickness and light passing through it.
+
+## Assets
+
+Shapes drawn in code or as SVG. Photo cut-outs need images you own, or generated ones. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Paper rustle, snips, soft ticks on pose changes. Practice note.
+
+## What makes it look wrong
+
+- Smooth vector motion with no stepping
+- Perfect edges
+- Large soft shadows, which look like interface cards, not paper
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=paper-cutout` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'paper-cutout': { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // flat layers with scissor-cut edges and small shadows; the bird's wings hinge at the shoulder, on twos
+ const ts = onTwos(t), f = frameOf(t, 12);
+ bg(g, W, H, '#f3e6c8');
+ const layer = (pts, col, seed, dy) => { g.save(); g.shadowColor = 'rgba(70,40,10,.38)'; g.shadowBlur = 5; g.shadowOffsetX = 3; g.shadowOffsetY = 4; cut(g, pts.map(([x, y]) => [x, y + dy]), seed, 3); fill(g, col); g.restore(); };
+ g.save(); g.shadowColor = 'rgba(70,40,10,.3)'; g.shadowBlur = 4; g.shadowOffsetY = 3; blob(g, W * 0.76, H * 0.26, 62, 4, 0.03); fill(g, '#e9763b'); g.restore();
+ layer([[0, 330], [170, 250], [330, 300], [520, 230], [720, 290], [960, 240], [960, 540], [0, 540]], '#7fa27a', 11, Math.sin(ts * 1.2) * 3);
+ layer([[0, 400], [210, 340], [400, 390], [610, 330], [800, 380], [960, 350], [960, 540], [0, 540]], '#4f7d67', 12, Math.sin(ts * 1.2 + 1) * 4);
+ layer([[0, 470], [250, 430], [500, 470], [760, 430], [960, 460], [960, 540], [0, 540]], '#2f5a52', 13, 0);
+ const bx = lerp(-80, W + 80, (ts / 3) % 1), by = 150 + Math.sin(ts * 3) * 22, flap = Math.sin(ts * 14) * 0.7;
+ g.save(); g.translate(bx, by); g.shadowColor = 'rgba(70,40,10,.4)'; g.shadowBlur = 4; g.shadowOffsetY = 4;
+ for (const s of [-1, 1]) { g.save(); g.rotate(s * flap); cut(g, [[0, 0], [s * 58, -20], [s * 46, 12]], 30 + s, 1.5); fill(g, '#f7f1e3'); g.restore(); }
+ cut(g, [[-26, -9], [30, -5], [44, 4], [26, 12], [-30, 9]], 33, 1.5); fill(g, '#fffaf0'); g.restore();
+ paper(g, W, H, 2, 30 + jit(f, 3, 2));
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Cutout_animation>
+- <https://en.wikipedia.org/wiki/Lotte_Reiniger>
+- <https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/feDisplacementMap>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/pixel-art.md b/plugin/skills/brief2mp4/references/art-forms/pixel-art.md
new file mode 100644
index 0000000..96e6685
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/pixel-art.md
@@ -0,0 +1,69 @@
+# Pixel art
+
+Also called: 8-bit.
+
+Family: Geometry, pixels and 3D. Cadence: steps 8 times a second. Usual tool: HyperFrames (canvas).
+
+A tiny picture placed pixel by pixel and scaled up with hard edges: a few colours, no blur, sprites that step.
+
+From early video games; the term dates from 1982.
+
+## What makes it read as this
+
+- A small canvas scaled by a whole number
+- A limited palette, often 8 to 32 colours
+- No anti-aliasing, no soft gradients
+- Sprites animate in a few frames
+
+## Timing
+
+Walk cycles of 4 to 8 frames at about 8 a second. Scrolling moves in whole pixels.
+
+## How to build it
+
+- Draw on a small canvas (160 by 90), then `drawImage` it up with `imageSmoothingEnabled = false`
+- CSS: `image-rendering: pixelated` on an upscaled canvas
+- Sprites as arrays of palette indexes
+- Three.js: `RenderPixelatedPass` renders a 3D scene to low resolution with nearest filtering
+
+## Assets
+
+Sprites as data in code, or drawn in a pixel editor. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Chiptune. Practice note.
+
+## What makes it look wrong
+
+- Scaling by a fraction
+- Mixed pixel sizes on one screen
+- Smooth vector edges or too many colours
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=pixel-art` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'pixel-art': { kind: '2d', fps: 8, draw(g, t, W, H) {
+ // drawn on a 160 x 90 canvas with a six-colour palette, then scaled up six times with no smoothing. The walk cycle has four frames.
+ const lw = 160, lh = 90, c = new OffscreenCanvas(lw, lh), p = c.getContext('2d'), f = frameOf(t, 8), PAL = ['#1b1f3b', '#3b4a8c', '#f4d35e', '#ee6c4d', '#f7f3e8', '#2e7d5b'];
+ p.fillStyle = PAL[1]; p.fillRect(0, 0, lw, lh); p.fillStyle = PAL[0]; p.fillRect(0, 62, lw, 28);
+ for (let i = 0; i < 26; i++) { p.fillStyle = PAL[4]; if (hash(i, 3) > 0.5 || f % 4 !== i % 4) p.fillRect((hash(i) * lw) | 0, (hash(i, 1) * 44) | 0, 1, 1); }
+ p.fillStyle = PAL[2]; p.fillRect(124, 10, 12, 12);
+ for (let x = 0; x < lw; x += 8) { p.fillStyle = PAL[5]; p.fillRect(((x - f * 2) % lw + lw) % lw, 62, 4, 2); } // the ground scrolls two pixels a frame
+ const SPR = ['..3333..', '.333333.', '.34343..', '.344443.', '..2222..', '.222222.', '.2.22.2.', '..1..1..'], legs = [['..1..1..', '.11..11.'], ['..11.1..', '..1..11.'], ['..1..1..', '.11..11.'], ['..1.11..', '.11..1..']][f % 4];
+ const rows = [...SPR.slice(0, 7), ...legs], bx = 72, by = 62 - rows.length * 2 - (f % 2);
+ rows.forEach((row, y) => [...row].forEach((ch, x) => { if (ch !== '.') { p.fillStyle = PAL[+ch]; p.fillRect(bx + x * 2, by + y * 2, 2, 2); } }));
+ g.imageSmoothingEnabled = false; g.globalCompositeOperation = 'source-over'; g.drawImage(c, 0, 0, W, H); g.imageSmoothingEnabled = true;
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Pixel_art>
+- <https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/product-render.md b/plugin/skills/brief2mp4/references/art-forms/product-render.md
new file mode 100644
index 0000000..b573ea5
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/product-render.md
@@ -0,0 +1,75 @@
+# 3D product render
+
+Family: Geometry, pixels and 3D. Cadence: smooth, full frame rate. Usual tool: Three.js, the 3D pack, or Blender.
+
+A studio shot of an object: a seamless backdrop, soft key, fill and rim lights, controlled reflections, a slow turn.
+
+Product photography lighting, done in 3D.
+
+Sourcing note: The lighting source is about photography; applying it to rendering is a practice note.
+
+## What makes it read as this
+
+- A seamless backdrop
+- Key light to one side and above, a softer fill opposite, a rim light behind
+- A contact shadow under the object
+- True materials: gloss, metal, glass
+- One slow move
+
+## Timing
+
+Smooth and slow at the full frame rate. The opposite of the handmade looks.
+
+## How to build it
+
+- `MeshPhysicalMaterial` with `clearcoat` for lacquer, `metalness: 1` for metal
+- Three directional lights in the key, fill and rim positions, plus a hemisphere light
+- Contact shadow: a plane with a radial-gradient texture, `depthWrite: false`
+- Rotation from `t` directly; ease the camera, not the turntable
+
+Use Blender when the brief asks for photoreal glass, caustics or depth of field.
+
+## Assets
+
+A model of the product: built in code, made with the 3D pack, or supplied. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Minimal: a low bed and one accent on the reveal. Practice note.
+
+## What makes it look wrong
+
+- No reflections, so it looks like plastic
+- One harsh light
+- An object floating with no shadow
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=product-render` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'product-render': { kind: '3d', fps: null, setup(THREE, scene, camera) {
+ // a studio shot: a seamless backdrop, a key, a fill and a rim light, a contact shadow, a slow smooth turntable
+ scene.background = new THREE.Color('#dfe3e8');
+ const bottle = new THREE.Group(), glass = new THREE.MeshPhysicalMaterial({ color: '#b5462c', roughness: 0.18, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.06 }), metal = new THREE.MeshStandardMaterial({ color: '#c9a25a', roughness: 0.28, metalness: 1 });
+ const body = new THREE.Mesh(new THREE.CapsuleGeometry(0.8, 1.5, 12, 40), glass), cap = new THREE.Mesh(new THREE.CylinderGeometry(0.34, 0.34, 0.5, 40), metal), band = new THREE.Mesh(new THREE.TorusGeometry(0.81, 0.04, 12, 60), metal);
+ cap.position.y = 1.78; band.rotation.x = Math.PI / 2; band.position.y = 0.3; bottle.add(body, cap, band);
+ const sh = new OffscreenCanvas(256, 256), sg = sh.getContext('2d'), rg = sg.createRadialGradient(128, 128, 0, 128, 128, 128); rg.addColorStop(0, 'rgba(20,24,34,.6)'); rg.addColorStop(1, 'rgba(20,24,34,0)'); sg.fillStyle = rg; sg.fillRect(0, 0, 256, 256);
+ const shadow = new THREE.Mesh(new THREE.PlaneGeometry(4.4, 4.4), new THREE.MeshBasicMaterial({ map: new THREE.CanvasTexture(sh), transparent: true, depthWrite: false })); shadow.rotation.x = -Math.PI / 2; shadow.position.y = -1.55;
+ const floor = new THREE.Mesh(new THREE.PlaneGeometry(40, 40), new THREE.MeshStandardMaterial({ color: '#dfe3e8', roughness: 1 })); floor.rotation.x = -Math.PI / 2; floor.position.y = -1.56;
+ const key = new THREE.DirectionalLight('#ffffff', 3.2); key.position.set(4, 5, 4); const fillL = new THREE.DirectionalLight('#cfe0ff', 1.1); fillL.position.set(-5, 2, 3); const rim = new THREE.DirectionalLight('#ffe2c0', 2.6); rim.position.set(-2, 4, -6);
+ scene.add(floor, shadow, bottle, key, fillL, rim, new THREE.HemisphereLight('#ffffff', '#b0b6c0', 1.1)); camera.position.set(0, 0.9, 7.4); camera.lookAt(0, 0.2, 0);
+ return { bottle };
+ }, draw(s, t) { s.bottle.rotation.y = t * 0.7; } },
+};
+export const IDS = Object.keys(LOOKS);
+
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Three-point_lighting>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/risograph.md b/plugin/skills/brief2mp4/references/art-forms/risograph.md
new file mode 100644
index 0000000..da176e4
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/risograph.md
@@ -0,0 +1,72 @@
+# Risograph and halftone print
+
+Also called: riso, halftone print.
+
+Family: Craft and handmade. Cadence: steps 8 times a second. Usual tool: HyperFrames (canvas or DOM).
+
+The look of a cheap stencil print: two to four bright inks laid over each other, visible grain, dot screens, and layers that never quite line up.
+
+The Risograph duplicator dates from 1980: one ink per drum, so each colour is a separate pass. Halftone dots go back to the 1860s.
+
+## What makes it read as this
+
+- Two to four spot colours, often pink, blue and yellow
+- Inks overprint to make new colours (multiply)
+- Each layer sits a pixel or two off register
+- Grain and dot screens; no smooth gradients
+- Off-white paper
+
+## Timing
+
+Print is still. Animate by re-rolling the misregistration and swapping the grain 8 to 12 times a second.
+
+## How to build it
+
+- Each ink is its own layer drawn with `mix-blend-mode: multiply` (canvas: `globalCompositeOperation`)
+- Offset each layer by a seeded amount per drawing: `jit(frameOf(t, 8), layer, 3)`
+- Tone as dots: a staggered grid of circles whose radius follows the tone
+- Grain: several pre-made noise tiles, cycled by frame number
+- Three.js `HalftonePass` exists for 3D scenes; SVG `feColorMatrix` separates a photo into one ink
+
+## Assets
+
+All procedural. A chunky sans or slab typeface. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Lo-fi, tape hiss. Practice note.
+
+## What makes it look wrong
+
+- Gradients
+- Perfect registration
+- More than four colours
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=risograph` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ risograph: { kind: '2d', fps: 8, draw(g, t, W, H) {
+ // three ink layers printed with multiply. Each layer slips a pixel or two per frame (misregistration), with grain on top.
+ const f = frameOf(t, 8);
+ bg(g, W, H, '#f4efe2'); g.globalCompositeOperation = 'multiply';
+ const off = (i) => [jit(f, i, 3), jit(f, i + 10, 3)];
+ let [x, y] = off(1); g.fillStyle = '#ff48a0'; g.beginPath(); g.arc(W * 0.42 + x, H * 0.48 + y, 150, 0, TAU); g.fill();
+ [x, y] = off(2); g.fillStyle = '#2a5cff'; g.beginPath(); g.moveTo(W * 0.5 + x, H * 0.2 + y); g.lineTo(W * 0.78 + x, H * 0.76 + y); g.lineTo(W * 0.3 + x, H * 0.76 + y); g.closePath(); g.fill();
+ [x, y] = off(3); g.fillStyle = '#ffd400'; // the yellow layer is a halftone: dots that grow left to right
+ for (let py = H * 0.2; py < H * 0.82; py += 12) for (let px = W * 0.5; px < W * 0.86; px += 12) { g.beginPath(); g.arc(px + x + ((py / 12) % 2 | 0) * 6, py + y, 0.8 + 5 * ((px - W * 0.5) / (W * 0.36)), 0, TAU); g.fill(); }
+ g.drawImage(grain(W, H, 10 + (f % 4), 46, [30, 30, 40]), 0, 0); g.globalCompositeOperation = 'source-over';
+ g.fillStyle = '#2a5cff'; g.font = `800 34px ${FONT}`; g.fillText('3 INKS', 40, H - 40);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Risograph>
+- <https://en.wikipedia.org/wiki/Halftone>
+- <https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/rotoscope.md b/plugin/skills/brief2mp4/references/art-forms/rotoscope.md
new file mode 100644
index 0000000..75a856c
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/rotoscope.md
@@ -0,0 +1,74 @@
+# Rotoscope look
+
+Family: Drawn and painted. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas over video).
+
+Real movement traced by hand: lifelike motion, flat colour fields that drift, and an outline that shimmers.
+
+Max Fleischer built the rotoscope. A Scanner Darkly, Waking Life and the a-ha video for Take On Me are the well-known examples.
+
+## What makes it read as this
+
+- Motion with the timing of live action
+- Flat or posterised colour fields
+- Outlines that change slightly every drawing
+- Colour that sits a little off the line
+
+## Timing
+
+Every frame or on twos. The boil is keyed to the drawing.
+
+## How to build it
+
+- From footage: draw each video frame to a canvas, posterise it, find edges (three.js has `SobelOperatorShader`), then nudge the edges per drawing
+- From code: a figure built from joints, drawn twice: thick flat colour offset by a seeded amount, then a thin outline with its own nudge
+- Re-encode source video with a keyframe on every frame so seeking is exact
+
+Dedicated tools do true painterly rotoscoping better than a browser.
+
+## Assets
+
+Footage you own, or a figure built in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+The original scene audio, or music-led. Practice note.
+
+## What makes it look wrong
+
+- Edge noise that flickers out of control
+- Losing the subject in the treatment
+- Tracing footage you have no right to use
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=rotoscope` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ rotoscope: { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // a walking figure traced on twos: flat colour fields that drift a little and an outline that never sits still
+ const f = frameOf(t, 12), ts = onTwos(t), ph = ts * 5.5, x = W * 0.5, y = H * 0.58;
+ bg(g, W, H, '#20263a'); g.fillStyle = '#2c3552'; g.fillRect(0, H * 0.8, W, H * 0.2);
+ const limb = (x0, y0, a, l1, b, l2) => { const x1 = x0 + Math.sin(a) * l1, y1 = y0 + Math.cos(a) * l1; return [[x0, y0], [x1, y1], [x1 + Math.sin(a + b) * l2, y1 + Math.cos(a + b) * l2]]; };
+ const parts = [limb(x, y, Math.sin(ph) * 0.6, 62, Math.max(0, -Math.sin(ph)) * 0.9, 62), limb(x, y, -Math.sin(ph) * 0.6, 62, Math.max(0, Math.sin(ph)) * 0.9, 62),
+ limb(x, y - 112, -Math.sin(ph) * 0.7, 52, -0.5, 48), limb(x, y - 112, Math.sin(ph) * 0.7, 52, -0.5, 48)];
+ const body = () => { g.beginPath(); g.moveTo(x - 26, y - 118); g.lineTo(x + 26, y - 118); g.lineTo(x + 18, y + 6); g.lineTo(x - 18, y + 6); g.closePath(); };
+ for (let pass = 0; pass < 2; pass++) {
+ g.lineCap = 'round'; g.lineJoin = 'round';
+ const dx = pass ? 0 : jit(f, 1, 4), dy = pass ? 0 : jit(f, 2, 4); // the colour field drifts off the line
+ g.save(); g.translate(dx, dy);
+ g.strokeStyle = pass ? '#f4f0e8' : '#e8643c'; g.lineWidth = pass ? 2.2 : 22;
+ for (const [i, p] of parts.entries()) { g.beginPath(); p.forEach(([px, py], j) => { const qx = px + (pass ? jit(f, i * 9 + j, 2.2) : 0), qy = py + (pass ? jit(f, i * 9 + j + 40, 2.2) : 0); j ? g.lineTo(qx, qy) : g.moveTo(qx, qy); }); g.stroke(); }
+ body(); pass ? g.stroke() : fill(g, '#f0b23c');
+ g.beginPath(); g.arc(x + jit(f, 77, pass ? 1.5 : 0), y - 146 + Math.abs(Math.sin(ph)) * 5, 24, 0, TAU); pass ? g.stroke() : fill(g, '#f4d7b5');
+ g.restore();
+ }
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Rotoscoping>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/rubber-hose.md b/plugin/skills/brief2mp4/references/art-forms/rubber-hose.md
new file mode 100644
index 0000000..0851c60
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/rubber-hose.md
@@ -0,0 +1,74 @@
+# Rubber-hose cartoon
+
+Family: Drawn and painted. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas, SVG).
+
+The 1920s cartoon: limbs like hoses with no elbows or knees, round bodies that bounce to the music, black and white film.
+
+Credited to Bill Nolan on Felix the Cat. The Fleischer studio kept it longest; Cuphead revived it.
+
+## What makes it read as this
+
+- Curved tubular limbs
+- Round forms
+- Black and white or sepia, high contrast
+- Film grain, scratches and a frame that weaves slightly
+- Everything moves to the beat
+
+## Timing
+
+Bouncy loops locked to the music, on twos, with squash and stretch.
+
+## How to build it
+
+- A limb is a quadratic curve between two points; move the control point to bend it
+- Squash and stretch: scale the body on one axis by the inverse of the other
+- Grain: cycle a few noise tiles by frame; gate weave: shift the whole picture by a seeded pixel or two
+- Sepia with `feColorMatrix` if wanted
+
+## Assets
+
+All in code. Original characters only. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Hot jazz, slide whistles, effects on every bounce. Practice note.
+
+## What makes it look wrong
+
+- Stiff jointed limbs
+- Clean modern gradients
+- Copying characters that are still under copyright
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=rubber-hose` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'rubber-hose': { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // limbs are curves with no elbows or knees; the body squashes and stretches on the beat; film grain and a weaving gate
+ const f = frameOf(t, 12), ts = onTwos(t), beat = Math.abs(Math.sin(ts * Math.PI * 2)), sq = 1 + 0.16 * (beat - 0.5);
+ bg(g, W, H, '#d9d2c0');
+ g.save(); g.translate(jit(f, 1, 1.5), jit(f, 2, 1.5)); // gate weave
+ const x = W / 2, y = H * 0.56 - beat * 26;
+ g.fillStyle = 'rgba(0,0,0,.25)'; g.beginPath(); g.ellipse(x, H * 0.84, 90 - beat * 20, 12, 0, 0, TAU); g.fill();
+ g.strokeStyle = '#111'; g.lineWidth = 15; g.lineCap = 'round';
+ const hose = (x0, y0, x1, y1, bend) => { g.beginPath(); g.moveTo(x0, y0); g.quadraticCurveTo((x0 + x1) / 2 + bend, (y0 + y1) / 2 + Math.abs(bend) * 0.4, x1, y1); g.stroke(); };
+ hose(x - 30, y + 60, x - 62, H * 0.83, -40 * beat); hose(x + 30, y + 60, x + 62, H * 0.83, 40 * beat);
+ hose(x - 62, y - 10, x - 150, y - 60 - beat * 50, -50 + beat * 70); hose(x + 62, y - 10, x + 150, y - 60 - (1 - beat) * 50, 50 - beat * 70);
+ g.fillStyle = '#111'; g.beginPath(); g.ellipse(x, y, 78 / sq, 84 * sq, 0, 0, TAU); g.fill();
+ g.fillStyle = '#f4efe2'; g.beginPath(); g.ellipse(x, y - 8, 54 / sq, 56 * sq, 0, 0, TAU); g.fill();
+ for (const s of [-1, 1]) { g.fillStyle = '#111'; g.beginPath(); g.ellipse(x + s * 20, y - 22, 9, 15 * sq, 0, 0, TAU); g.fill(); g.fillStyle = '#f4efe2'; g.beginPath(); g.moveTo(x + s * 20, y - 22); g.arc(x + s * 20, y - 22, 9, -0.9, -0.3); g.fill(); }
+ g.strokeStyle = '#111'; g.lineWidth = 5; g.beginPath(); g.arc(x, y + 6, 26, 0.15 * Math.PI, 0.85 * Math.PI); g.stroke();
+ for (const s of [-1, 1]) { g.fillStyle = '#f4efe2'; g.strokeStyle = '#111'; g.lineWidth = 5; g.beginPath(); g.arc(x + s * 150, y - 60 - (s < 0 ? beat : 1 - beat) * 50, 22, 0, TAU); g.fill(); g.stroke(); g.fillStyle = '#111'; g.beginPath(); g.ellipse(x + s * 62, H * 0.84, 34, 15, 0, 0, TAU); g.fill(); }
+ g.restore(); g.drawImage(grain(W, H, 20 + (f % 5), 50, [20, 20, 20]), 0, 0);
+ g.fillStyle = `rgba(0,0,0,${0.5 * hash(f, 9)})`; g.fillRect(hash(f, 3) * W, 0, 1.5, H); // a scratch
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Rubber_hose_animation>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/shadow-puppet.md b/plugin/skills/brief2mp4/references/art-forms/shadow-puppet.md
new file mode 100644
index 0000000..0213267
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/shadow-puppet.md
@@ -0,0 +1,81 @@
+# Shadow puppetry
+
+Also called: shadow play, Ravana Chhaya, wayang kulit, silhouette animation.
+
+Family: Craft and handmade. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas or SVG).
+
+Flat figures held between a lamp and a cloth screen: dark silhouettes with punched patterns on a warm, glowing field.
+
+An old tradition across Asia. Ravana Chhaya of Odisha uses uncoloured deerskin puppets with no joints; wayang kulit of Java and Bali was recognised by UNESCO in 2003. Lotte Reiniger brought silhouettes to film.
+
+## What makes it read as this
+
+- Black silhouettes on a warm lit screen, never on white
+- Interior detail made of perforations: rows of holes and cut patterns
+- A lamp that flickers
+- The shadow softens and grows as the puppet moves away from the screen
+- Rods visible below the figures
+
+## Timing
+
+Live puppets move continuously on rods; film versions are stop-motion, so use twos. Stiff, deliberate moves; no squash and stretch.
+
+## How to build it
+
+- One path per puppet filled with the even-odd rule, so holes are part of the figure
+- Screen: a radial gradient from warm yellow to deep brown
+- Flicker: scale the lamp brightness by a seeded value per drawing
+- Distance from the screen: `filter: blur()` growing with distance, and lower opacity
+- Ravana Chhaya style: no joints, move and tilt the whole puppet. Wayang style: hinge the arms
+
+Use Blender for real light through translucent coloured leather.
+
+## Assets
+
+Simple figures in code. Ornate traditional figures need drawing or tracing with care. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Narrator, singers and percussion in the tradition: cymbals and drums for Ravana Chhaya, gamelan for wayang.
+
+## What makes it look wrong
+
+- Black on white, which loses the lamp
+- Smooth modern vector motion
+- Careless drawings of sacred figures: check the iconography with a source
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=shadow-puppet` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'shadow-puppet': { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // a lamp-lit screen and jointless leather figures with punched patterns, moved whole on their rods (the Ravana Chhaya way)
+ const f = frameOf(t, 12), ts = onTwos(t), flick = 1 + jit(f, 0, 0.05);
+ bg(g, W, H, '#1a0d05');
+ const lamp = g.createRadialGradient(W / 2, H * 0.55, 30, W / 2, H * 0.55, W * 0.62);
+ lamp.addColorStop(0, `rgba(255,${196 * flick},110,1)`); lamp.addColorStop(0.55, `rgba(214,${120 * flick},48,1)`); lamp.addColorStop(1, 'rgba(60,24,8,1)');
+ g.fillStyle = lamp; g.fillRect(24, 24, W - 48, H - 48);
+ const puppet = (x, y, s, lean, far) => {
+ g.save(); g.translate(x, y); g.rotate(lean); g.scale(s, s); g.filter = `blur(${far * 5}px)`; g.fillStyle = `rgba(18,8,2,${1 - far * 0.35})`;
+ g.beginPath(); // one path, even-odd: the holes are part of the figure
+ g.moveTo(-34, 150); g.lineTo(-44, 20); g.lineTo(-70, -30); g.lineTo(-40, -44); g.lineTo(-26, -96); g.lineTo(-44, -150); g.lineTo(0, -196); g.lineTo(44, -150); g.lineTo(26, -96); g.lineTo(40, -44); g.lineTo(84, -70); g.lineTo(92, -44); g.lineTo(44, 20); g.lineTo(34, 150); g.closePath();
+ for (let i = 0; i < 5; i++) { g.moveTo(8, -20 + i * 30); g.arc(0, -20 + i * 30, 8, 0, TAU); }
+ for (let i = 0; i < 7; i++) { const a = (i / 7) * TAU; g.moveTo(Math.cos(a) * 22 + 4, -140 + Math.sin(a) * 22); g.arc(Math.cos(a) * 22, -140 + Math.sin(a) * 22, 4, 0, TAU); }
+ g.fill('evenodd'); g.filter = 'none'; g.fillRect(-3, 150, 6, 260); g.restore();
+ };
+ puppet(W * 0.34 + Math.sin(ts * 1.6) * 26, H * 0.62, 0.95, Math.sin(ts * 1.6) * 0.06, 0);
+ puppet(W * 0.68 - Math.sin(ts * 1.3) * 34, H * 0.66, 0.8, -Math.sin(ts * 1.3) * 0.08, (Math.sin(ts * 0.9) + 1) / 2);
+ g.globalCompositeOperation = 'multiply'; g.drawImage(grain(W, H, 6, 40, [80, 40, 10]), 0, 0); g.globalCompositeOperation = 'source-over';
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Shadow_play>
+- <https://en.wikipedia.org/wiki/Ravana_Chhaya>
+- <https://en.wikipedia.org/wiki/Lotte_Reiniger>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/stop-motion.md b/plugin/skills/brief2mp4/references/art-forms/stop-motion.md
new file mode 100644
index 0000000..6ad4048
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/stop-motion.md
@@ -0,0 +1,71 @@
+# Stop-motion look
+
+Family: Craft and handmade. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas or DOM) or Three.js.
+
+Any real object moved and photographed a pose at a time. On screen it shows as stepped motion, tiny position errors and light that flickers a little.
+
+As old as film: stop tricks appear in the 1890s. Pixilation, cut-out and puppet animation are all forms of it.
+
+## What makes it read as this
+
+- Real materials: wood, card, cloth, plastic
+- Position jitter of a pixel or two between drawings
+- Lighting that varies slightly frame to frame
+- Hard cuts between poses, no in-between blur
+
+## Timing
+
+On twos (12 changes a second) is the usual cadence; action sometimes on ones, held moments on threes or more.
+
+## How to build it
+
+- Quantise time before anything else: `const ts = held(t, 12)`
+- GSAP: `ease: "steps(12)"` on a one-second tween does the same for a tween
+- Jitter and flicker keyed to the frame number: `jit(frameOf(t, 12), i, 1.2)`
+- Keep the camera and background steady: step the subject, not the world
+
+## Assets
+
+None needed. Everything is procedural. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Foley that lands on pose changes. A bed that is not too smooth. Practice note.
+
+## What makes it look wrong
+
+- Stepping the camera and background together, so everything strobes
+- Easing between held poses, which defeats the look
+- Jitter so large the object vibrates
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=stop-motion` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'stop-motion': { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // blocks stack one by one. Time is held on twos, every pose is nudged a pixel, and the light flickers per frame.
+ const f = frameOf(t, 12), ts = held(t, 12);
+ bg(g, W, H, `hsl(34 30% ${86 + jit(f, 1, 1.2)}%)`);
+ g.fillStyle = '#c9b48f'; g.fillRect(0, H * 0.74, W, H * 0.26);
+ const cols = ['#c0392b', '#e0a526', '#2f6f8f', '#3d8b5a', '#7a4fa0'];
+ for (let i = 0; i < 5; i++) {
+ const k = bounce(prog(ts, 0.25 + i * 0.42, 0.5)); if (prog(ts, 0.25 + i * 0.42, 0.5) <= 0) continue;
+ const x = W / 2 - 70 + (i % 2) * 34 + jit(f, i, 1.2), y = lerp(-90, H * 0.74 - 62 - i * 62, k) + jit(f, i + 9, 1.2);
+ g.save(); g.translate(x + 60, y + 31); g.rotate(jit(f, i + 20, 0.012) + (i % 2 ? 0.03 : -0.02));
+ g.shadowColor = 'rgba(60,40,10,.35)'; g.shadowBlur = 10; g.shadowOffsetY = 6; g.fillStyle = cols[i]; g.fillRect(-60, -31, 120, 62);
+ g.shadowColor = 'transparent'; g.fillStyle = 'rgba(255,255,255,.14)'; g.fillRect(-60, -31, 120, 12); g.restore();
+ }
+ paper(g, W, H, 5, 18);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Stop_motion>
+- <https://en.wikipedia.org/wiki/Clay_animation>
+- <https://gsap.com/docs/v3/Eases/SteppedEase/>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/upa-midcentury.md b/plugin/skills/brief2mp4/references/art-forms/upa-midcentury.md
new file mode 100644
index 0000000..0b1775e
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/upa-midcentury.md
@@ -0,0 +1,70 @@
+# UPA and mid-century modern
+
+Also called: mid-century modern, limited animation.
+
+Family: Drawn and painted. Cadence: steps 8 times a second. Usual tool: HyperFrames (canvas, SVG).
+
+Flat, stylised design from 1950s cartoons: geometric characters, abstract backgrounds, colour printed slightly off its outline, and very few drawings.
+
+United Productions of America turned away from Disney realism and made limited animation a style. Gerald McBoing-Boing won an Academy Award in 1950.
+
+## What makes it read as this
+
+- Characters built from triangles, circles and lines
+- Flat colour blocks that do not meet their outlines
+- Abstract backgrounds: a few shapes, no perspective
+- A warm, muted palette
+
+## Timing
+
+Limited animation: a pose is held, then pops to the next. Eight or fewer changes a second.
+
+## How to build it
+
+- Flat shapes; draw the outline 6 to 9 px away from the fill
+- Two or three poses, switched on a frame count with no in-betweens
+- Paper grain with `multiply`
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Jazz combo, sound effects as music. Practice note.
+
+## What makes it look wrong
+
+- Smooth, fluid motion
+- Gradients and realistic light
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=upa-midcentury` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'upa-midcentury': { kind: '2d', fps: 8, draw(g, t, W, H) {
+ // limited animation: flat geometric shapes, colour printed slightly off its outline, held poses that pop on threes
+ const pose = frameOf(t, 8) % 12 < 6 ? 0 : 1, f = frameOf(t, 8);
+ bg(g, W, H, '#e8dcc0');
+ g.fillStyle = '#d98c3a'; g.fillRect(W * 0.08, H * 0.16, W * 0.3, H * 0.62); g.fillStyle = '#5a6fa5'; g.beginPath(); g.arc(W * 0.78, H * 0.28, 70, 0, TAU); g.fill();
+ g.strokeStyle = '#1c1c1c'; g.lineWidth = 3; g.strokeRect(W * 0.08 + 9, H * 0.16 - 8, W * 0.3, H * 0.62); g.beginPath(); g.arc(W * 0.78 - 8, H * 0.28 + 6, 70, 0, TAU); g.stroke();
+ const x = W * 0.55, y = H * 0.74, lean = pose ? 0.14 : -0.1;
+ g.save(); g.translate(x, y); g.rotate(lean);
+ g.fillStyle = '#c8452f'; g.beginPath(); g.moveTo(-70, 0); g.lineTo(70, 0); g.lineTo(0, -210); g.closePath(); g.fill();
+ g.strokeStyle = '#1c1c1c'; g.beginPath(); g.moveTo(-64, -8); g.lineTo(76, -8); g.lineTo(6, -218); g.closePath(); g.stroke();
+ g.fillStyle = '#f3e9d2'; g.beginPath(); g.arc(0, -236, 34, 0, TAU); g.fill(); g.stroke();
+ g.lineWidth = 5; g.lineCap = 'round'; g.beginPath(); g.moveTo(-30, -130); g.lineTo(-96, pose ? -206 : -100); g.moveTo(30, -130); g.lineTo(100, pose ? -110 : -196); g.stroke();
+ g.fillStyle = '#1c1c1c'; g.beginPath(); g.arc(pose ? 10 : -8, -240, 4, 0, TAU); g.fill(); g.restore();
+ paper(g, W, H, 17, 26 + jit(f, 1, 2));
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/United_Productions_of_America>
+- <https://en.wikipedia.org/wiki/Limited_animation>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/vhs-glitch.md b/plugin/skills/brief2mp4/references/art-forms/vhs-glitch.md
new file mode 100644
index 0000000..d529523
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/vhs-glitch.md
@@ -0,0 +1,73 @@
+# VHS and glitch
+
+Also called: glitch, retro VHS.
+
+Family: Type, data and retro. Cadence: steps 30 times a second. Usual tool: HyperFrames (canvas) or Three.js post-processing.
+
+The damage of old tape and broken data: colour that bleeds sideways, scan lines, a band of noise at the bottom, sudden torn slices.
+
+VHS records colour at far lower resolution than brightness, which is why colour smears. Glitch art uses such errors on purpose.
+
+## What makes it read as this
+
+- Colour offset from brightness by a few pixels and softer
+- Scan lines
+- A tracking band of noise near the bottom
+- A date stamp in a blocky face
+- Glitch: slices displaced sideways, in short bursts
+
+## Timing
+
+Full frame rate, with bursts of a fifth of a second. Seeds come from the frame number so every render matches.
+
+## How to build it
+
+- Draw the clean frame to its own canvas first, then the damage on top
+- Redraw it in thin horizontal strips with a per-strip offset; large offsets only during a burst
+- Chroma bleed: a blurred copy drawn again a few pixels to the side with `screen`
+- Scan lines: a dark row every third pixel
+- Three.js: `FilmPass`, `RGBShiftShader` and `GlitchPass` exist; `GlitchPass` picks its own random timing, so check it repeats before relying on it
+
+## Assets
+
+All in code. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Tape hiss, hum, a click on each burst. Practice note.
+
+## What makes it look wrong
+
+- Constant glitching, which tires the eye
+- Glitching text the viewer has to read
+- Unseeded randomness, so two renders differ
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=vhs-glitch` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ 'vhs-glitch': { kind: '2d', fps: 30, draw(g, t, W, H) {
+ // a clean frame first, then the damage on top: colour that bleeds sideways, scan lines, a tracking band, a seeded burst
+ const f = frameOf(t, 30), c = new OffscreenCanvas(W, H), s = c.getContext('2d');
+ s.fillStyle = '#0b1020'; s.fillRect(0, 0, W, H);
+ ['#c0c0c0', '#c0c000', '#00c0c0', '#00c000', '#c000c0', '#c00000', '#0000c0'].forEach((col, i) => { s.fillStyle = col; s.fillRect(i * W / 7, H * 0.52, W / 7 + 1, H * 0.3); });
+ s.fillStyle = '#fff'; s.font = `800 96px ${FONT}`; s.fillText('PLAY ▶', 60, 170); s.font = `600 34px ui-monospace, Menlo, monospace`; s.fillText('SP 0:00:' + String(Math.floor(t)).padStart(2, '0'), 60, H - 44); s.fillText('NOV 18 1994', W - 300, H - 44);
+ bg(g, W, H, '#000');
+ const burst = hash(Math.floor(f / 6), 5) < 0.22; // roughly one burst in five, 0.2 s long, the same every render
+ for (let y = 0; y < H; y += 6) { const shift = (burst && hash(f, y) < 0.3 ? jit(f, y, 46) : 0) + Math.sin(y * 0.05 + f * 0.4) * 1.5; g.drawImage(c, 0, y, W, 6, shift, y, W, 6); }
+ g.globalCompositeOperation = 'screen'; g.globalAlpha = 0.5; g.filter = 'blur(2px)'; g.drawImage(c, 7, 0); g.filter = 'none'; g.globalAlpha = 1; // chroma is softer than brightness and sits a few pixels off
+ g.globalCompositeOperation = 'source-over'; g.fillStyle = 'rgba(0,0,0,.22)'; for (let y = 0; y < H; y += 3) g.fillRect(0, y, W, 1);
+ const band = H - 46 + Math.sin(f * 0.3) * 6; for (let i = 0; i < 260; i++) { g.fillStyle = `rgba(255,255,255,${hash(f, i) * 0.8})`; g.fillRect(hash(f, i, 1) * W, band + hash(f, i, 2) * 34, 4 + hash(f, i, 3) * 60, 2); }
+ g.globalAlpha = 0.5; g.drawImage(grain(W, H, 30 + (f % 6), 40, [255, 255, 255]), 0, 0); g.globalAlpha = 1;
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/VHS>
+- <https://en.wikipedia.org/wiki/Glitch_art>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/voxel.md b/plugin/skills/brief2mp4/references/art-forms/voxel.md
new file mode 100644
index 0000000..4ad8c52
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/voxel.md
@@ -0,0 +1,66 @@
+# Voxel
+
+Family: Geometry, pixels and 3D. Cadence: steps 12 times a second. Usual tool: Three.js inside HyperFrames.
+
+Everything built from cubes of one size on a grid, like a three-dimensional pixel picture.
+
+A voxel is a value on a 3D grid. Minecraft made the look familiar.
+
+## What makes it read as this
+
+- One cube size, integer positions
+- Each face one flat tone
+- A small palette
+- Small floating scenes
+
+## Timing
+
+On twos. Things appear cube by cube or layer by layer; moves snap to the grid.
+
+## How to build it
+
+- One `InstancedMesh` of a box for all the cubes: one draw call
+- Set each cube's matrix from stepped time; hide a cube by scaling it to nothing
+- Cubes slightly under size (0.96) so the seams read
+- `MeshLambertMaterial` and a hemisphere light
+
+## Assets
+
+Models as arrays in code, or made with a voxel editor. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Blocky, percussive, chiptune. Practice note.
+
+## What makes it look wrong
+
+- Cubes at non-integer positions
+- Faces flickering where cubes touch at full size
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=voxel` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ voxel: { kind: '3d', fps: 12, setup(THREE, scene, camera) {
+ // every cube the same size, on a grid, in one instanced mesh. The model builds layer by layer, on twos.
+ scene.background = new THREE.Color('#1c2333');
+ const cells = []; for (let y = 0; y < 9; y++) for (let x = -4; x <= 4; x++) for (let z = -4; z <= 4; z++) { const d = Math.hypot(x, z); const trunk = y < 4 && d < 1.2, leaves = y >= 3 && Math.hypot(x, (y - 6) * 1.25, z) < 3.6 && hash(x + 9, y, z + 9) > 0.12; if (trunk || leaves) cells.push([x, y, z, trunk && y < 4 && !leaves ? '#7a4f2a' : hash(x, y, z) > 0.5 ? '#3f9b57' : '#2f7d47']); }
+ const mesh = new THREE.InstancedMesh(new THREE.BoxGeometry(0.96, 0.96, 0.96), new THREE.MeshLambertMaterial(), cells.length), col = new THREE.Color();
+ cells.forEach((c, i) => mesh.setColorAt(i, col.set(c[3]))); scene.add(mesh, new THREE.HemisphereLight('#ffffff', '#33405a', 1.6)); const key = new THREE.DirectionalLight('#ffffff', 2); key.position.set(6, 9, 4); scene.add(key);
+ return { mesh, cells, m: new THREE.Matrix4(), camera };
+ }, draw(s, t) {
+ const ts = held(t, 12), shown = Math.floor(clamp(ts / 2.2) * 9.99);
+ s.cells.forEach(([x, y, z], i) => { const on = y <= shown; s.m.makeScale(on ? 1 : 0.0001, on ? 1 : 0.0001, on ? 1 : 0.0001); s.m.setPosition(x, y - 4, z); s.mesh.setMatrixAt(i, s.m); });
+ s.mesh.instanceMatrix.needsUpdate = true; const a = 0.7 + ts * 0.35; s.camera.position.set(Math.sin(a) * 15, 6, Math.cos(a) * 15); s.camera.lookAt(0, 0, 0);
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Voxel>
+- <https://github.com/danielesteban/cubitos>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/watercolour.md b/plugin/skills/brief2mp4/references/art-forms/watercolour.md
new file mode 100644
index 0000000..be1f0bb
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/watercolour.md
@@ -0,0 +1,78 @@
+# Watercolour
+
+Also called: watercolor.
+
+Family: Drawn and painted. Cadence: steps 12 times a second. Usual tool: HyperFrames (canvas or SVG).
+
+Transparent washes on textured paper: colour that spreads, pools darker at its edge, and lets the paper show through.
+
+Pigment in water on paper. Wet-on-wet blends softly; wet-on-dry gives crisp edges.
+
+Sourcing note: The edge-darkening rule is a practice note; the technique sources cover the filter, not the look.
+
+## What makes it read as this
+
+- Transparent colour; overlaps make new colours
+- Darker pigment at the edge of each wash
+- Irregular, soft outlines
+- Paper grain visible everywhere
+- Unpainted paper as the highlight
+
+## Timing
+
+Slow. A wash grows over 1 to 3 seconds with an ease-out. Hold drawings at 12 a second for a hand-painted feel.
+
+## How to build it
+
+- Each wash: an irregular closed outline, clipped, filled with a radial gradient that is darkest near the rim
+- Layer washes with `multiply`
+- Paper grain over everything with `multiply`
+- SVG route: low-frequency `feTurbulence` (0.01 to 0.03) into `feDisplacementMap` (scale 10 to 25) for bleeding edges
+- 3D: a Kuwahara filter as a custom pass gives a painterly result; three.js ships none
+
+## Assets
+
+Procedural. A scanned paper texture improves close-ups. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Slow, gentle, acoustic. Practice note.
+
+## What makes it look wrong
+
+- Opaque flat colour
+- A uniform blur, which looks out of focus, not painted
+- No paper texture
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=watercolour` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ watercolour: { kind: '2d', fps: 12, draw(g, t, W, H) {
+ // transparent washes that spread, with pigment pooling at the edge and paper showing through
+ const ts = onTwos(t);
+ bg(g, W, H, '#f6f1e6'); g.globalCompositeOperation = 'multiply';
+ const wash = (x, y, r, rgb, seed, start) => {
+ const k = easeOut(prog(ts, start, 1.6)); if (k <= 0) return; const rr = r * (0.35 + 0.65 * k);
+ g.save(); blob(g, x, y, rr, seed, 0.16); g.clip();
+ const grad = g.createRadialGradient(x, y, rr * 0.1, x, y, rr * 1.12);
+ grad.addColorStop(0, `rgba(${rgb},${0.28 * k})`); grad.addColorStop(0.72, `rgba(${rgb},${0.42 * k})`); grad.addColorStop(0.93, `rgba(${rgb},${0.8 * k})`); grad.addColorStop(1, `rgba(${rgb},${0.3 * k})`);
+ g.fillStyle = grad; g.fillRect(x - rr * 1.3, y - rr * 1.3, rr * 2.6, rr * 2.6); g.restore();
+ };
+ wash(W * 0.36, H * 0.5, 170, '52,110,170', 51, 0.1);
+ wash(W * 0.58, H * 0.44, 150, '214,84,96', 52, 0.6);
+ wash(W * 0.5, H * 0.66, 120, '232,178,60', 53, 1.1);
+ g.drawImage(grain(W, H, 14, 44, [70, 55, 40]), 0, 0); g.globalCompositeOperation = 'source-over';
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Watercolor_painting>
+- <https://blog.maximeheckel.com/posts/on-crafting-painterly-shaders>
+- <https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Element/feTurbulence>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/references/art-forms/whiteboard.md b/plugin/skills/brief2mp4/references/art-forms/whiteboard.md
new file mode 100644
index 0000000..5f47c81
--- /dev/null
+++ b/plugin/skills/brief2mp4/references/art-forms/whiteboard.md
@@ -0,0 +1,83 @@
+# Whiteboard and doodle
+
+Also called: video scribing, chalkboard.
+
+Family: Drawn and painted. Cadence: steps 10 times a second. Usual tool: HyperFrames (canvas or SVG).
+
+Marker lines that draw themselves on a white board, in the order someone would draw them. The chalkboard is the same recipe, inverted.
+
+Also called video scribing. A 2016 study found little evidence that it teaches better than other formats, so use it for its tone, not as a learning trick.
+
+## What makes it read as this
+
+- Black marker lines with a slight wobble
+- Strokes appear in drawing order
+- One or two accent colours
+- Chalk variant: a dark board, dusty broken strokes, a little smudge
+
+## Timing
+
+Each element draws on over 0.3 to 1.5 seconds, paced to the narration. The line boils at about 10 changes a second.
+
+## How to build it
+
+- Draw-on: a polyline drawn up to a fraction of its length (SVG: `stroke-dashoffset`)
+- Boil: nudge every point by a seeded amount keyed to `frameOf(t, 10)`
+- Chalk: three thin passes of the same stroke with different dash patterns at half opacity, over a speckled board
+- rough.js (MIT) generates sketchy shapes and hatching to animate afterwards
+
+## Assets
+
+All in code. A marker or chalk typeface if the system has one. Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.
+
+## Sound and pacing
+
+Marker squeak, voice-led. Practice note.
+
+## What makes it look wrong
+
+- Perfect vector lines
+- A hand that covers the drawing
+- Paragraphs of text
+
+## Tested demo
+
+This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. View it: open `art-forms/gallery.html?look=whiteboard` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. Take the technique, not the picture.
+
+```js
+ whiteboard: { kind: '2d', fps: 10, draw(g, t, W, H) {
+ // marker strokes that draw on in order, with a slight boil: the points are re-nudged ten times a second
+ const f = frameOf(t, 10);
+ bg(g, W, H, '#fbfbf8'); g.lineCap = 'round'; g.lineJoin = 'round'; g.strokeStyle = '#17202b'; g.lineWidth = 5;
+ const bulb = circlePts(W * 0.3, H * 0.42, 78, 36, Math.PI * 0.72, Math.PI * 2.28);
+ strokePart(g, bulb, prog(t, 0.1, 0.8), f, 1.6);
+ strokePart(g, [[W * 0.3 - 34, H * 0.42 + 72], [W * 0.3 - 34, H * 0.42 + 112], [W * 0.3 + 34, H * 0.42 + 112], [W * 0.3 + 34, H * 0.42 + 72]], prog(t, 0.9, 0.35), f, 1.6);
+ g.strokeStyle = '#e0532f'; for (let i = 0; i < 5; i++) { const a = -Math.PI * (0.15 + i * 0.175); strokePart(g, [[W * 0.3 + Math.cos(a) * 100, H * 0.42 + Math.sin(a) * 100], [W * 0.3 + Math.cos(a) * 132, H * 0.42 + Math.sin(a) * 132]], prog(t, 1.25 + i * 0.07, 0.15), f, 1.2); }
+ g.strokeStyle = '#17202b'; strokePart(g, [[W * 0.45, H * 0.44], [W * 0.6, H * 0.44], [W * 0.57, H * 0.4], [W * 0.6, H * 0.44], [W * 0.57, H * 0.48]], prog(t, 1.6, 0.4), f, 1.6);
+ strokePart(g, [[W * 0.65, H * 0.3], [W * 0.88, H * 0.3], [W * 0.88, H * 0.58], [W * 0.65, H * 0.58], [W * 0.65, H * 0.3]], prog(t, 2.0, 0.5), f, 1.6);
+ const k = prog(t, 2.5, 0.3); if (k > 0) { g.globalAlpha = k; g.fillStyle = '#17202b'; g.font = `italic 600 34px "Marker Felt", "Comic Sans MS", ${FONT}`; g.fillText('idea → plan', W * 0.665, H * 0.46); g.globalAlpha = 1; }
+ } }
+```
+
+```js
+ chalkboard: { kind: '2d', fps: 10, draw(g, t, W, H) {
+ // the whiteboard recipe on a dark board: dusty, broken strokes (three thin passes) and a smudge of chalk dust
+ const f = frameOf(t, 10);
+ bg(g, W, H, '#24382f'); g.drawImage(grain(W, H, 12, 34, [230, 240, 235]), 0, 0);
+ g.lineCap = 'round'; g.lineJoin = 'round';
+ const chalk = (pts, k, col = '#f2f0e6') => { for (let p = 0; p < 3; p++) { g.strokeStyle = col; g.globalAlpha = 0.5; g.lineWidth = 3; g.setLineDash([14 + p * 5, 3 + p]); g.lineDashOffset = p * 7; strokePart(g, pts.map(([x, y]) => [x + p - 1, y + (p - 1) * 1.4]), k, f + p * 31, 1.3); } g.setLineDash([]); g.globalAlpha = 1; };
+ chalk([[W * 0.16, H * 0.72], [W * 0.84, H * 0.72]], prog(t, 0.1, 0.5));
+ chalk([[W * 0.16, H * 0.72], [W * 0.16, H * 0.2]], prog(t, 0.4, 0.5));
+ chalk(Array.from({ length: 40 }, (_, i) => [W * (0.16 + 0.66 * i / 39), H * (0.72 - 0.46 * (i / 39) ** 2)]), prog(t, 0.9, 1.0), '#ffd966');
+ const k = prog(t, 2.0, 0.4); if (k > 0) { g.globalAlpha = k * 0.9; g.fillStyle = '#f2f0e6'; g.font = `600 36px "Chalkduster", "Marker Felt", ${FONT}`; g.fillText('y = x²', W * 0.56, H * 0.34); g.globalAlpha = 1; }
+ } }
+```
+
+To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object's `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.
+
+## Sources
+
+- <https://en.wikipedia.org/wiki/Whiteboard_animation>
+- <https://github.com/rough-stuff/rough>
+
+Facts checked on 2026-11-17. Lines marked "practice note" are working advice, not sourced facts.
diff --git a/plugin/skills/brief2mp4/scripts/art_route.py b/plugin/skills/brief2mp4/scripts/art_route.py
new file mode 100644
index 0000000..6a9b7ab
--- /dev/null
+++ b/plugin/skills/brief2mp4/scripts/art_route.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""art_route.py: read a brief and propose an art form for the video, with the reason.
+
+ python3 scripts/art_route.py BRIEF.md a short report
+ python3 scripts/art_route.py BRIEF.md --json the same as JSON
+ echo "a claymation ad for our tea" | python3 scripts/art_route.py -
+
+A keyword scorer over references/art-forms.json, not a judge. A look named in the brief wins. Otherwise it looks at
+what the video is about and the mood. One stray word is never enough, and when nothing fits it says so: the plain
+formats in references/formats.md are a look too. Standard library only.
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+REF = Path(__file__).resolve().parent.parent / 'references'
+
+# what the video is about, or its mood -> art forms in order, and the reason given
+SUBJECTS = [
+ (r'\b(kids?|children|toddlers?|family|bedtime|nursery|preschool)\b', ['paper-cutout', 'claymation', 'felt'], 'a young or family audience: handmade textures feel warm'),
+ (r'\b(folk ?tale|myth\w*|legend|epic|heritage|tradition\w*|ramayana|mahabharata|fable|ancestral)\b', ['shadow-puppet', 'linocut', 'ink-wash'], 'a traditional story: the form carries the tradition'),
+ (r'\b(explain\w*|how it works|onboarding|tutorial|walkthrough|process|workflow|saas|software)\b', ['flat-explainer', 'isometric', 'whiteboard'], 'explaining something: clean shapes keep attention on the idea'),
+ (r'\b(lesson|lecture|classroom|teach\w*|maths?|physics|equation)\b', ['whiteboard', 'flat-explainer', 'line-art'], 'teaching: a drawing that builds as it is explained'),
+ (r'\b(data|statistics?|stats|numbers|percent\w*|growth|survey|report|chart|graph)\b', ['infographic', 'flat-explainer', 'isometric'], 'numbers: the chart is the picture'),
+ (r'\b(song|lyrics?|music video|single|track|album|chorus)\b', ['lyric-video', 'kinetic-type', 'vhs-glitch'], 'a song: the words are timed to the vocal'),
+ (r'\b(quote|manifesto|slogan|tagline|poem|spoken word)\b', ['kinetic-type', 'line-art', 'ink-wash'], 'a line of words: let the type carry it'),
+ (r'\b(product shot|packshot|launch|unboxing|hardware|device|bottle|perfume|watch|headphones|gadget)\b', ['product-render', 'claymation', 'isometric'], 'a physical product: the object is the hero'),
+ (r'\b(architecture|infrastructure|logistics|city|factory|network|system diagram|supply chain)\b', ['isometric', 'blueprint', 'low-poly'], 'a system: a small model seen from above explains it'),
+ (r'\b(engineering|mechanical|machine|invention|patent|specification|how it is made)\b', ['blueprint', 'line-art', 'isometric'], 'something engineered: a technical drawing suits it'),
+ (r'\b(game|gaming|arcade|console|8-?bit|16-?bit)\b', ['pixel-art', 'voxel', 'low-poly'], 'games: the look of the medium'),
+ (r'\b(80s|1980s|90s|1990s|nostalgi\w+|throwback|retro|vintage|old-?school)\b', ['vhs-glitch', 'pixel-art', 'upa-midcentury'], 'a past decade: its own recording medium is the look'),
+ (r'\b(1920s|1930s|jazz age|old cartoon|silent film)\b', ['rubber-hose', 'upa-midcentury', 'linocut'], 'early animation: the cartoon style of that time'),
+ (r'\b(calm|meditat\w+|mindful\w*|quiet|gentle|reflective|serene|slow)\b', ['watercolour', 'ink-wash', 'line-art'], 'a calm tone: slow, sparse, quiet looks'),
+ (r'\b(bold|loud|punk|zine|indie|diy|street|poster|protest)\b', ['risograph', 'collage', 'motion-comic'], 'a loud, independent tone: print energy and hard cuts'),
+ (r'\b(craft\w*|handmade|artisan\w*|cosy|cozy|homemade|bakery|knit\w*|wool)\b', ['paper-cutout', 'felt', 'stop-motion'], 'something handmade: show the hand'),
+ (r'\b(night|bar|club|nightlife|after dark|city lights|open late)\b', ['neon-sign', 'vhs-glitch', 'kinetic-type'], 'night: light that glows on dark'),
+ (r'\b(action|fight|hero\w*|superhero|battle|chase)\b', ['cel-shaded', 'motion-comic', 'kinetic-type'], 'action: hard poses and hard cuts'),
+ (r'\b(nature|landscape|mountain|forest|travel|outdoors?)\b', ['low-poly', 'watercolour', 'paper-cutout'], 'landscape: simple forms and soft colour'),
+]
+
+
+def load():
+ return json.loads((REF / 'art-forms.json').read_text())
+
+
+def route(brief, data=None):
+ data = data or load()
+ text = str(brief or '').replace('’', "'")
+ score, why, strong = {}, {}, set()
+
+ def bump(fid, n, reason, is_strong=False):
+ score[fid] = score.get(fid, 0) + n
+ why.setdefault(fid, [])
+ if reason not in why[fid]:
+ why[fid].append(reason)
+ if is_strong:
+ strong.add(fid)
+
+ named = False
+ for f in data['forms']:
+ for nm in [f['name']] + f['aliases'] + [f['id'].replace('-', ' ')]:
+ short = re.sub(r'\s*\(.*\)', '', nm).split(' and ')[0].strip()
+ if len(short) > 3 and re.search(r'\b%s\b' % re.escape(short), text, re.I):
+ bump(f['id'], 20, 'the brief names "%s"' % short.lower(), True)
+ named = True
+ break
+ for kw in f['keywords']:
+ if re.search(r'\b%s\w*\b' % re.escape(kw), text, re.I):
+ bump(f['id'], 3, 'it says "%s"' % kw)
+ for pattern, forms, reason in SUBJECTS:
+ m = re.search(pattern, text, re.I)
+ if m:
+ for i, fid in enumerate(forms):
+ bump(fid, 4.5 - i, '%s ("%s")' % (reason, m.group(0).lower()), True)
+ ranked = sorted(((s, fid) for fid, s in score.items() if fid in strong or s >= 6), key=lambda x: (-x[0], [f['id'] for f in data['forms']].index(x[1])))
+ by_id = {f['id']: f for f in data['forms']}
+ if not ranked:
+ return {'form': None, 'confidence': 'none', 'why': ['the brief names no look, subject or mood the table knows'], 'alternatives': [], 'read': ['references/formats.md', 'references/art-forms.md']}
+ top = by_id[ranked[0][1]]
+ return {
+ 'form': top['id'], 'name': top['name'], 'confidence': 'named' if named and ranked[0][0] >= 20 else 'inferred', 'why': why[top['id']][:3],
+ 'cadence': 'steps %d times a second' % top['fps'] if top['fps'] else 'smooth, full frame rate', 'route': top['route'], 'blender': top['blender'],
+ 'pitfalls': top['pitfalls'], 'alternatives': [{'form': by_id[fid]['id'], 'name': by_id[fid]['name']} for _, fid in ranked[1:3]],
+ 'read': ['references/art-forms/%s.md' % top['id'], 'references/art-forms.md'], 'demo': 'art-forms/gallery.html?look=%s' % top['looks'][0],
+ }
+
+
+def report(r):
+ if not r['form']:
+ return 'Art form: none suggested. %s. Use a format from references/formats.md, or choose a look from references/art-forms.md and say why in SPEC.md.' % r['why'][0].capitalize()
+ lines = ['Art form: %s (%s)' % (r['name'], 'named in the brief' if r['confidence'] == 'named' else 'inferred')]
+ lines += [' why: ' + w for w in r['why']]
+ lines += [' cadence: ' + r['cadence'], ' usual tool: ' + r['route']]
+ if r['blender']:
+ lines.append(' note: ' + r['blender'])
+ if r['alternatives']:
+ lines.append(' or: ' + ', '.join(a['name'] for a in r['alternatives']))
+ lines += [' watch for: ' + '; '.join(r['pitfalls']), ' read: ' + r['read'][0], ' demo: ' + r['demo']]
+ if r['confidence'] == 'inferred':
+ lines.append('Note: this is a guess from the subject and mood words. If the brief or the brand has its own look, that wins.')
+ return '\n'.join(lines)
+
+
+def main(argv):
+ args = [a for a in argv if not a.startswith('--')]
+ if '--help' in argv or '-h' in argv or not args:
+ print('usage: python3 art_route.py <BRIEF.md | -> [--json]\n Proposes an art form for a video brief, with reasons. "-" reads the brief from standard input.')
+ return 0 if ('--help' in argv or '-h' in argv) else 2
+ try:
+ brief = sys.stdin.read() if args[0] == '-' else Path(args[0]).read_text()
+ except OSError as e:
+ print('art_route.py: cannot read %s: %s' % (args[0], e), file=sys.stderr)
+ return 2
+ if not brief.strip():
+ print('art_route.py: the brief is empty', file=sys.stderr)
+ return 2
+ r = route(brief)
+ print(json.dumps(r, indent=2) if '--json' in argv else report(r))
+ return 0
+
+
+if __name__ == '__main__':
+ sys.exit(main(sys.argv[1:]))
diff --git a/plugin/skills/brief2mp4/scripts/build_art_forms.py b/plugin/skills/brief2mp4/scripts/build_art_forms.py
new file mode 100644
index 0000000..582f50f
--- /dev/null
+++ b/plugin/skills/brief2mp4/scripts/build_art_forms.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""build_art_forms.py: make the art-form reference pages from one data file.
+
+ references/art-forms.json + art-forms/looks.js
+ -> references/art-forms.md the index the agent reads first
+ -> references/art-forms/<id>.md one page per art form, with the tested demo code
+
+ python3 scripts/build_art_forms.py write the files
+ python3 scripts/build_art_forms.py --check exit 1 if any generated file is out of date
+
+Standard library only. Edit the JSON (facts) or looks.js (code), run this, then run tests/art_forms/check_looks.mjs.
+"""
+import json
+import re
+import sys
+from pathlib import Path
+
+SKILL = Path(__file__).resolve().parent.parent
+REF = SKILL / 'references'
+DATA = json.loads((REF / 'art-forms.json').read_text())
+LOOKS_JS = (SKILL / 'art-forms' / 'looks.js').read_text()
+
+
+def look_source(look_id):
+ """The source of one look, cut out of looks.js: from its key to the line that closes it."""
+ m = re.search(r"^ (?:'%s'|%s): \{ kind:" % (re.escape(look_id), re.escape(look_id)), LOOKS_JS, re.M)
+ if not m:
+ raise SystemExit('build_art_forms: no look called %r in art-forms/looks.js' % look_id)
+ rest = LOOKS_JS[m.start():]
+ end = re.search(r"^ \} \},\n", rest, re.M)
+ return rest[:end.end()].rstrip().rstrip(',') if end else rest
+
+
+def cadence(f):
+ return 'steps %d times a second' % f['fps'] if f['fps'] else 'smooth, full frame rate'
+
+
+def bullets(items):
+ return '\n'.join('- ' + x for x in items)
+
+
+def page(f):
+ out = ['# ' + f['name'], '']
+ if f['aliases']:
+ out += ['Also called: ' + ', '.join(f['aliases']) + '.', '']
+ out += ['Family: %s. Cadence: %s. Usual tool: %s.' % (DATA['families'][f['family']], cadence(f), f['route']), '', f['what'], '', f['origin'], '']
+ if f['thin']:
+ out += ['Sourcing note: ' + f['thin'], '']
+ out += ['## What makes it read as this', '', bullets(f['rules']), '', '## Timing', '', f['timing'], '', '## How to build it', '', bullets(f['build']), '']
+ if f['blender']:
+ out += [f['blender'], '']
+ out += ['## Assets', '', f['assets'] + ' Use only pictures, footage and music the user owns or may reuse; if the user has an image model available, generate textures and cut-out parts with it and say so in REPORT.md.', '',
+ '## Sound and pacing', '', f['sound'], '', '## What makes it look wrong', '', bullets(f['pitfalls']), '', '## Tested demo', '',
+ 'This is the look from `art-forms/looks.js`, which `tests/art_forms/check_looks.mjs` draws in a real browser: it must paint, change over time, and give the same pixels when the same time is drawn twice. '
+ 'View it: open `art-forms/gallery.html?look=%s` through a local server. The helpers it calls (`held`, `frameOf`, `jit`, `hash`, `grain`, `prog`, the easings) are at the top of that file. '
+ 'Take the technique, not the picture.' % f['looks'][0], '']
+ for look in f['looks']:
+ out += ['```js', look_source(look), '```', '']
+ out += ['To use a look in a HyperFrames composition, drive it from the timeline the way `references/threejs.md` shows: a paused GSAP timeline tweens a plain object\'s `t` from 0 to the duration with `ease: "none"`, and `onUpdate` calls `draw` with that `t`. Vendor GSAP and three.js into the project first.', '',
+ '## Sources', '', bullets('<%s>' % u for u in f['sources']), '', 'Facts checked on %s. Lines marked "practice note" are working advice, not sourced facts.' % DATA['checked'], '']
+ return '\n'.join(out)
+
+
+def index():
+ n = len(DATA['forms'])
+ out = ['# Art forms: %d looks for animated video, and how to build each' % n, '',
+ 'Read this when a brief names a look ("claymation", "paper cut-out", "anime", "like a blueprint") or describes a feeling that a look would carry. '
+ 'It is the index. Each art form has its own page in `references/art-forms/` with its visual rules, timing, build recipe, assets, sound, pitfalls, sources and a tested demo. '
+ '`scripts/art_route.py BRIEF.md` proposes one from a brief and says why.', '',
+ 'An art form sets the look and the timing. The format (`references/formats.md`) still sets the beats, and the tool table in SKILL.md still sets the route.', '',
+ '## Three rules behind every look', '',
+ '1. **The picture is a function of time.** No clock, no timers, no `Math.random()`. HyperFrames renders by seeking, so anything that depends on the frame before it will be wrong. Randomness comes from a hash of the frame number or of a position.',
+ '2. **Handmade looks hold their drawings.** Clay, paper, felt, cel and ink change 8 to 12 times a second while the video stays at 24 or 30. Quantise time before posing anything: `const ts = Math.floor(t * 12) / 12`. In GSAP the same thing is `ease: "steps(12)"` on a one-second tween. Clean looks (flat explainer, low-poly, product render, type) stay smooth.',
+ '3. **Imperfection is seeded.** Line boil, paper jitter, lamp flicker, misregistered ink and tape damage are all keyed to the drawing number, so two renders of the same frame match exactly.', '',
+ 'A `setInterval` that re-rolls a filter, the usual web recipe for line boil, breaks rule 1 and will not render correctly. Key the change to `Math.floor(t * 10)` instead.', '']
+ for fam, title in DATA['families'].items():
+ out += ['## ' + title, '', '| Art form | What it is | Cadence | Usual tool |', '|---|---|---|---|']
+ for f in DATA['forms']:
+ if f['family'] == fam:
+ out.append('| [%s](art-forms/%s.md) | %s | %s | %s |' % (f['name'], f['id'], f['what'].split('. ')[0].rstrip('.') + '.', cadence(f), f['route']))
+ out.append('')
+ out += ['## Choosing one from a brief', '',
+ '| The brief is about | Try | Why |', '|---|---|---|',
+ '| children, family, a gentle story | paper cut-out, claymation, felt | handmade textures feel warm and safe |',
+ '| a folk tale, a myth, heritage | shadow puppetry, linocut, ink wash | the form carries the tradition; check the iconography with a source |',
+ '| explaining a product or a process | flat vector explainer, isometric, whiteboard | clean shapes keep attention on the idea |',
+ '| numbers | infographic | the chart is the picture; every number needs a source |',
+ '| a song or a quote | lyric video, kinetic typography | the words are the content |',
+ '| a physical product | 3D product render, claymation for a playful take | the object is the hero |',
+ '| nostalgia | VHS and glitch, pixel art, rubber-hose, UPA mid-century | each one is a decade |',
+ '| calm, reflective | watercolour, ink wash, line art | slow, sparse, quiet |',
+ '| loud, independent | risograph, collage, motion comic | print energy and hard cuts |', '',
+ 'If the brief names a look, use it. If it names none and nothing above fits, do not force one: the plain formats in `references/formats.md` are a look too.', '',
+ '## Tools that exist, by name', '',
+ '- SVG filters: `feTurbulence` (noise), `feDisplacementMap` (bend by noise: rough edges, line boil, ink bleed), `feMorphology` (thicken or thin: outlines), `feColorMatrix` and `feComponentTransfer` (recolour, threshold, duotone), `feGaussianBlur`.',
+ '- CSS: `steps()` timing, `mix-blend-mode: multiply` for overprinted ink and `screen` or `plus-lighter` for glow, `image-rendering: pixelated`, `filter: drop-shadow()`.',
+ '- GSAP: `ease: "steps(n)"`; `fromTo` inside scenes; one paused root timeline.',
+ '- three.js materials and passes that ship in its examples: `MeshToonMaterial` with a `gradientMap`, `OutlineEffect`, `SobelOperatorShader`, `HalftonePass`, `RenderPixelatedPass`, `FilmPass`, `RGBShiftShader`, `GlitchPass`, `UnrealBloomPass`, `OutputPass`. It ships no watercolour (Kuwahara) pass and no VHS pass.',
+ '- Blender does these better than a browser: real subsurface clay, fur and felt fibre, folded paper with thickness, photoreal product shots, Freestyle line art.', '',
+ '## The demos', '',
+ '`art-forms/looks.js` holds one small demo per look (%d in all), and `art-forms/gallery.html` plays them. `tests/art_forms/check_looks.mjs` checks every one in a real browser.' % sum(len(f['looks']) for f in DATA['forms']),
+ 'These pages are generated from `references/art-forms.json` and `art-forms/looks.js` by `scripts/build_art_forms.py`.', '']
+ return '\n'.join(out)
+
+
+def main():
+ files = {REF / 'art-forms.md': index()}
+ for f in DATA['forms']:
+ files[REF / 'art-forms' / (f['id'] + '.md')] = page(f)
+ check = '--check' in sys.argv
+ stale = 0
+ for path, text in files.items():
+ if path.exists() and path.read_text() == text:
+ continue
+ if check:
+ print('out of date: %s' % path.relative_to(SKILL))
+ stale += 1
+ else:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ path.write_text(text)
+ if check:
+ print('art forms: %d generated files are current' % len(files) if not stale else '%d generated file(s) out of date: run python3 scripts/build_art_forms.py' % stale)
+ sys.exit(1 if stale else 0)
+ print('art forms: %d forms, %d files written' % (len(DATA['forms']), len(files)))
+
+
+if __name__ == '__main__':
+ main()
diff --git a/plugin/skills/brief2mp4/templates/SPEC.md b/plugin/skills/brief2mp4/templates/SPEC.md
index 7566218..66ead4c 100644
--- a/plugin/skills/brief2mp4/templates/SPEC.md
+++ b/plugin/skills/brief2mp4/templates/SPEC.md
@@ -18,6 +18,7 @@
- Palette: background #......, ink #......, accent #......
- Type: <face>, <weights>
- Mood: <five words or fewer>
+- Art form, if the brief asks for a look: <name from references/art-forms.md>, <cadence: smooth, or N changes a second>
## Beat sheet
| Time (s) | On screen | Motion |
diff --git a/tests/test_art_forms.py b/tests/test_art_forms.py
new file mode 100644
index 0000000..bac168d
--- /dev/null
+++ b/tests/test_art_forms.py
@@ -0,0 +1,126 @@
+"""Art forms: the data, the generated pages, the router and (slow) every demo look in a real browser."""
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO = Path(__file__).resolve().parents[1]
+SKILL = REPO / "plugin" / "skills" / "brief2mp4"
+REF = SKILL / "references"
+DATA = json.loads((REF / "art-forms.json").read_text())
+LOOKS_JS = (SKILL / "art-forms" / "looks.js").read_text()
+sys.path.insert(0, str(SKILL / "scripts"))
+import art_route # noqa: E402
+
+
+def look_ids() -> list[str]:
+ return re.findall(r"^ '?([a-z0-9-]+)'?: \{ kind:", LOOKS_JS, re.M)
+
+
+def test_there_are_enough_forms_and_ids_are_unique():
+ ids = [f["id"] for f in DATA["forms"]]
+ assert len(ids) >= 28
+ assert len(ids) == len(set(ids))
+
+
[email protected]("form", DATA["forms"], ids=lambda f: f["id"])
+def test_every_form_is_complete(form):
+ assert len(form["what"]) > 60 and len(form["origin"]) > 20
+ assert len(form["rules"]) >= 4 and len(form["build"]) >= 3 and len(form["pitfalls"]) >= 2
+ assert form["timing"] and form["assets"] and form["sound"] and form["route"]
+ assert form["family"] in DATA["families"]
+ assert form["fps"] is None or 6 <= form["fps"] <= 30
+ assert len(form["keywords"]) >= 3
+ assert form["sources"] and all(u.startswith("https://") for u in form["sources"])
+ assert form["looks"], "each form has at least one demo"
+
+
+def test_every_form_has_a_demo_and_every_demo_belongs_to_a_form():
+ in_data = {look for f in DATA["forms"] for look in f["looks"]}
+ assert in_data == set(look_ids())
+
+
+def test_looks_never_read_a_clock_or_unseeded_randomness():
+ code = re.sub(r"//.*", "", LOOKS_JS) # comments may name the things that are banned
+ for banned in ("Math.random", "Date.now", "performance.now", "setInterval", "setTimeout", "requestAnimationFrame", "new Date"):
+ assert banned not in code, f"looks.js must be a pure function of time: found {banned}"
+ assert "http://" not in code and "https://" not in code, "looks load nothing from the network"
+
+
+def test_stepped_looks_quantise_time():
+ for form in DATA["forms"]:
+ if not form["fps"]:
+ continue
+ for look in form["looks"]:
+ m = re.search(r"^ '?%s'?: \{ kind:.*?^ \} \},\n" % re.escape(look), LOOKS_JS, re.M | re.S)
+ assert m, look
+ assert re.search(r"\b(held|onTwos|frameOf)\(", m.group(0)), f"{look} is a stepped look but never quantises time"
+
+
+def test_generated_pages_are_current():
+ out = subprocess.run([sys.executable, str(SKILL / "scripts" / "build_art_forms.py"), "--check"], capture_output=True, text=True)
+ assert out.returncode == 0, out.stdout
+ for form in DATA["forms"]:
+ page = (REF / "art-forms" / f"{form['id']}.md").read_text()
+ assert "## Tested demo" in page and "```js" in page and "## Sources" in page
+ index = (REF / "art-forms.md").read_text()
+ assert all(f"art-forms/{f['id']}.md" in index for f in DATA["forms"])
+
+
[email protected]("brief,expected,confidence", [
+ ("A claymation ad for our tea brand, 15 seconds", "claymation", "named"),
+ ("An anime style intro for my channel", "cel-shaded", "named"),
+ ("Make it look like a paper cut-out", "paper-cutout", "named"),
+ ("Tell the story of Ravana from the Ramayana for a festival screen", "shadow-puppet", "inferred"),
+ ("Explain how our SaaS onboarding works in 40 seconds", "flat-explainer", "inferred"),
+ ("A lyric video for our new single", "lyric-video", "named"),
+ ("Show our survey statistics: 62 percent growth", "infographic", "inferred"),
+ ("A bedtime story for children about a fox", "paper-cutout", "inferred"),
+ ("A retro 90s promo that feels like an old tape", "vhs-glitch", "inferred"),
+ ("A calm meditation intro", "watercolour", "inferred"),
+ ("chalkboard style maths lesson", "whiteboard", "named"),
+])
+def test_router_picks_the_form(brief, expected, confidence):
+ r = art_route.route(brief)
+ assert r["form"] == expected
+ assert r["confidence"] == confidence
+ assert (SKILL / r["read"][0]).exists()
+
+
+def test_router_says_so_when_nothing_fits():
+ for brief in ("make a cool video", "A paper plane flies over the title"): # one stray word is not a look
+ r = art_route.route(brief)
+ assert r["form"] is None and r["confidence"] == "none"
+ assert "none suggested" in art_route.report(art_route.route("make a cool video"))
+
+
+def test_router_command_line(tmp_path):
+ script = str(SKILL / "scripts" / "art_route.py")
+ brief = tmp_path / "BRIEF.md"
+ brief.write_text("A voxel style trailer for our game")
+ out = subprocess.run([sys.executable, script, str(brief), "--json"], capture_output=True, text=True)
+ assert out.returncode == 0 and json.loads(out.stdout)["form"] == "voxel"
+ piped = subprocess.run([sys.executable, script, "-"], input="neon sign that says OPEN", capture_output=True, text=True)
+ assert piped.returncode == 0 and piped.stdout.startswith("Art form: Neon sign")
+ empty = subprocess.run([sys.executable, script, "-"], input=" ", capture_output=True, text=True)
+ assert empty.returncode == 2
+ assert subprocess.run([sys.executable, script, "--help"], capture_output=True, text=True).returncode == 0
+
+
+def test_every_look_draws_moves_and_repeats_in_a_real_browser():
+ """Needs Node, Chrome and the network (three.js for the five 3D looks). Skips when Node is missing."""
+ node = shutil.which("node")
+ if not node:
+ pytest.skip("node is not installed")
+ out = subprocess.run([node, str(REPO / "tests" / "art_forms" / "check_looks.mjs")], capture_output=True, text=True, timeout=900)
+ if "Could not start Chrome" in out.stderr:
+ pytest.skip("no Chrome or Chromium to start")
+ assert out.returncode == 0, out.stdout[-2000:]
+ assert f"{len(look_ids())} of {len(look_ids())} looks pass" in out.stdout