Skip to content

Art and animation, written as code. Illustrations, loops, interactive web art, launch-videos and scored films in dozens of styles, identical on every render.

docs: launch-video.md (split feature beats, product UI asks, the motif rule, sound from the picture, shapes with phone-safe type, captions, sync/peak on the shipped file, 60 fps, two registers, ship QA) and launch-video-kit.md (ask kinds, shapes, presets, fps, launch.mjs, the new parts); formats.md --blur auto/--shutter/--shapes and verify-export sync/peak; SKILL.md tools

Alex Greenshpunb22496505ff5
diff --git a/skills/anidoodle/SKILL.md b/skills/anidoodle/SKILL.md
index 5e5c665..6fb3864 100644
--- a/skills/anidoodle/SKILL.md
+++ b/skills/anidoodle/SKILL.md
@@ -44,7 +44,7 @@ say why in one line. Write the answers into a short brief before drawing.
- Music: pick a style vocabulary and mood, compose your own harmony, motif and form (references/music/compose.md), then node tools/music.mjs check <score.ts#export> must PASS before a human listens. Styles give sound, never notes.
- Sound effects: references/music/sound-design.md. 14 layered, seeded effects cued by film frame (filmSfx); the score ducks, and every cue must be within 6 dB of it. Effects only on real direction changes, one riser + one impact per film.
-- Launch films: `launchTemplate.ts` renders a product's launch from data: prompts, plates drawn for it, a score composed for it, words, install lines; habits that save tokens are in `references/working-method.md`.
+- Launch films: `launchTemplate.ts` renders a product's launch from data (prompts, plates or its own UI, a score composed for it, words, install lines) in every shape from one timeline; `launch.mjs new|ship`. Habits that save tokens: `references/working-method.md`.
## The seven laws
@@ -102,8 +102,8 @@ draws itself declares `kind: "drawing"` and is judged on a finer floor; a freeze
`engine/` is the portable art core plus the tooling. `engine/src/canvas-core` knows nothing
about the DOM or any backend. `W`, `H`, `fps` and `durationFrames` come from the film's `meta`.
Camera moves (pans, zooms, parallax, shake) come from `engine/src/canvas-core/camera.ts`:
-`references/camera.md`. `render.mjs --blur N` renders with motion blur (N subframes averaged in
-linear light per frame); the default path is untouched.
+`references/camera.md`. `render.mjs --blur auto` renders with motion blur (subframes per frame
+from its measured on-screen speed, averaged in linear light, `--shutter 180`); the default path is untouched.
```bash
node <skill>/engine/tools/scaffold.mjs ~/art --film intro --format 9x16 --duration 12 # seconds
@@ -121,7 +121,8 @@ node tools/emit.mjs intro --out out/intro.html # one self-co
| `gate.mjs` | determinism, contract, dead air, artifact; `--self-test` proves it can fail |
| `registry.mjs` / `gallery.mjs` | the style list from the plates themselves / the gallery sheet |
| `docs-check.mjs` | fails when any doc's style count, length or path disagrees with the code |
-| `verify-export.mjs` | QA on the rendered file: frames, duration, score; opt-in first frame, loop seam, `--delivery` |
+| `verify-export.mjs` | QA on the rendered file: frames, duration, score, A/V sync, true peak after the encode; opt-in first frame, loop seam, `--delivery` |
+| `launch.mjs` | a launch film: `new <name>` scaffolds the spec; `ship <name> --shapes 16x9,9x16` renders, posters, captions, verifies each |
| `test.mjs` (`npm test`) | unit suites in `engine/test/`, no browser |
| `music.mjs` | `vocab` prints a style's vocabulary; `check` gates your composed score; `render`, `meter` |
| `sfx.mjs` | the sound-effects kit: `list`, `one`, `kit <dir>`, `test` |
diff --git a/skills/anidoodle/references/formats.md b/skills/anidoodle/references/formats.md
index 79b13a9..0ffdd51 100644
--- a/skills/anidoodle/references/formats.md
+++ b/skills/anidoodle/references/formats.md
@@ -68,9 +68,17 @@ Render options that hold for every moving format:
on frame N (the wall of styles, the logo, the prompt written big) and dissolves into the real
opening by frame 6. The frame count and the score are unchanged. A delivery whose frame 0 is
near-blank gets a warning after the encode.
-- `--blur N`: motion blur, each output frame the average of N subframes over a one-frame shutter,
- in linear light and weighted by alpha (so a transparent WebM or APNG gets no dark fringe). Held
- frames come out unchanged; stepped art (`meta.step` > 1, `onTwos`) is never blurred.
+- `--blur auto` (or `--blur N`): motion blur, each output frame the average of subframes over the
+ shutter, in linear light and weighted by alpha (so a transparent WebM or APNG gets no dark
+ fringe). `auto` measures each frame's on-screen motion (two sharp renders at the shutter's ends,
+ block-matched; drawing strokes, typed letters and halftone patterns are not mistaken for motion)
+ and takes subframes at most `--blur-px` apart (default 3 px): 1 on a still frame, which comes out
+ untouched, up to `--blur-max` (32) on a whip. Deterministic. `--shutter DEG` is the shutter
+ angle, 180 by default (360 is the old whole-frame shutter). Stepped art (`meta.step` > 1,
+ `onTwos`) is never blurred.
+- `--shapes 16x9,1x1,4x5,9x16`: a launch template film rendered in each shape from one timeline
+ (each re-composed by its layout, never cropped) to `out/<name>-<shape>.mp4`. Any tool takes
+ `<name>-<shape>` as the film's name for one shape.
- `--from F --to T`: frames `[F, T)` only, silent, written to `out/<name>.<F>-<T>.<ext>`, never
over the finished film. For checking a passage, not for shipping.
- `--hashes out/x.md5`: the md5 of every frame handed to the encoder, for frame-exact
@@ -78,7 +86,10 @@ Render options that hold for every moving format:
After any encode, `node tools/verify-export.mjs <name> [--first-frame #hex] [--fidelity-psnr 40]`
proves the file on disk is the film: size, exact frame count, duration, the score (an audio
-stream exactly when the film has one, as long as the picture, not silent), and optionally the
+stream exactly when the film has one, as long as the picture, not silent), its SYNC (the decoded
+sound cross-correlated with the master mix at each of `meta.sync`'s markers, within 1 ms, and each
+cue's attack where the master put it), its true peak after the encode (-1 dBTP under
+`--delivery`), and optionally the
first frame's average colour and its fidelity to the source frame (`--frame N` picks which
frame `--fidelity-psnr` compares; default 0). All of it is opt-in beyond the container facts,
so transparent and non-uniform pieces pass cleanly. For a file that ships, add `--delivery`: a
diff --git a/skills/anidoodle/references/workflows/launch-video-kit.md b/skills/anidoodle/references/workflows/launch-video-kit.md
index 76552b0..fff4a32 100644
--- a/skills/anidoodle/references/workflows/launch-video-kit.md
+++ b/skills/anidoodle/references/workflows/launch-video-kit.md
@@ -5,22 +5,35 @@ product. The rules they serve are in `launch-video.md`.
## Start from the template (16 s, one file)
-`launchTemplate.ts` turns data into a film: two or three prompts answered by plates drawing
-themselves in a chat thread, a type frame between them, and an end card with your install lines.
-`launchExample.ts` is a complete one for a made-up product. Copy its shape, not its contents:
-the plates and the score are the product's own, made for its brief.
+`launchTemplate.ts` turns data into a film: one to three asks, a type frame between them, and an
+end card with your install lines. `launchExample.ts` is a complete one for a made-up product (the
+drawn look, chat asks); `launchExampleClean.ts` is the second look on a UI-first product (the
+product's own UI, a split beat, a film in a card, 60 fps). Copy their shape, not their contents:
+the plates, the UI data and the score are the product's own, made for its brief.
+
+```bash
+node tools/launch.mjs new myLaunch # the spec, every product line marked TODO (--preset clean for UI-first)
+node tools/still.mjs myLaunch-9x16 --frames 0,120,330 --sheet out/look-9x16.jpg # one look per shape, one browser
+node tools/launch.mjs ship myLaunch --shapes 16x9,1x1,9x16 --blur auto --gate
+```
+
+`ship` renders every shape to `out/myLaunch-<shape>.mp4`, writes its poster (`.poster.png`, the
+film's own legible frame) and its captions (`.srt`, `.vtt`), runs `verify-export --delivery` on each
+file (size, frames, score, A/V sync at every marker, the true peak after the encode, a legible frame
+0) and, with `--gate`, the gate; one table at the end, exit 1 if any shape fails.
```ts
import { C } from "./launchKit";
import { makeLaunchFilm } from "./launchTemplate";
import { dashboardSketch, onboardingSketch } from "./myProductPlates"; // drawn for YOUR subject
import { myProductScore } from "./myProductScore"; // composed for YOUR brief
+import { myInbox } from "./myProductUI"; // YOUR product's UI, as data (productUI.ts)
export const myLaunch = makeLaunchFilm({
title: "Your Product", subtitle: "the one line it lives by",
asks: [
{ prompt: "sketch my dashboard, as a print", plate: dashboardSketch, label: "print · drawn in code" },
- { prompt: "now the onboarding screen", plate: onboardingSketch, label: "a second answer, same thread" },
+ { kind: "ui", ui: myInbox, prompt: "match every receipt" }, // the product's own UI, before -> after
],
words: [[{ text: "IDEA IN.", style: "ink", color: C.ink }, { text: "ART OUT.", style: "ink", color: C.accent }]],
tagline: "One sentence that says what it is",
@@ -31,48 +44,87 @@ export const myLaunch = makeLaunchFilm({
});
```
-Add `src/hosts/page-myLaunch.ts` (three lines, copy `page-launchExample.ts`), then:
-
-```bash
-node tools/still.mjs myLaunch --frame 0 --out out/poster.png # the first frame is the thumbnail
-node tools/still.mjs myLaunch --frames 0-420:30 --sheet out/sheet.jpg # the cut on one sheet, one browser
-node tools/render.mjs myLaunch # --poster-frame N if frame 0 is quiet
-node tools/gate.mjs myLaunch
-node tools/verify-export.mjs myLaunch --file out/myLaunch.mp4 --delivery
-```
-
-What you get: the first prompt already being typed at frame 0 in a close-up (a hook that reads
-muted), the camera easing out for the press, an ink drop arcing from Generate into the thread
-and blooming open into a card where the plate draws itself live, the thread keeping earlier
-answers and scrolling, a gentle lean onto each new card, full-frame word pages between asks,
-and the end card blooming open and holding. The corner mark (your name, hand-lettered) steps
-aside before any lean. Real holds are declared, so the gate passes. Sync wins over length: the
-score plays at the film's bpm exactly, so every cut sits on its downbeats, and the film is made
-whole bars of the score (`gridScore`: the stretch section repeated or dropped, then the end-card
-hold, which is a hold, grows or shrinks to the bar; the tail rings out in whole bars). A score in
-4/4 with no pickup, starting on frame 0. If no form fits, the build throws: compose a 1-bar
-stretch section or change askBeats/endBeats. Render refuses a beat-grid film whose score is more
-than 0.5 % off its bpm. The bed is set to -14 LUFS with the true peak at or under -1 dBTP
-(`musicBed`); a dynamic piece stops at the peak ceiling first and render says how far short;
-`limit: true` lets a look-ahead limiter take those peaks instead.
-
-**The plates and the score are made for this product, every time.** A style is a recipe applied
-to the user's subject (`references/styles.md`): draw their dashboard, their mascot, their
-product's world in the chosen hand, as a still plus its `*Draw` film. anidoodle's own plates
-(the lighthouse and fox in `launchExample.ts`) are placeholders, never a user's film. The score
-is composed for the brief's style, mood and length (`references/music/compose.md`); `score` is
-required (`null` means silent), `bpm` has no default, and the template refuses anidoodle's own
-pieces, by identity, by title and by content (the same novelty gate `music.mjs check` runs).
+What you get, from data:
+
+- **Chat asks** (`kind` omitted): the first prompt already being typed at frame 0 in a close-up (a
+ hook that reads muted), the camera easing out for the press, an ink drop arcing from Generate
+ into the thread and blooming open into a card where the plate draws itself live (the card opens
+ on a spring), the thread keeping earlier answers and scrolling, a gentle lean onto each new card.
+- **UI asks** (`kind: "ui"`): the product's interface drawn from data (`productUI.ts`) in its
+ `before` state; the ask typed into its command bar if it has a `prompt`; the pointer presses its
+ `action`; every item springs to its place in the `after` state (matched by `id`: rows move,
+ numbers count, bars fill, new items arrive, old ones leave).
+- **Film asks** (`kind: "film"`): any film of this engine (a `webTour`, a loop, a plate) in a card.
+- **Split feature beats**: a UI or film ask with `split: [lines]` puts its words in their own
+ column beside the live UI (above it on a phone), never over it: faster than a full word page.
+- **Seams**: chat to chat is one thread; a seam between kinds with no word page opens as a bloom.
+- **The motif**: an ink drop lifts off Generate (or the product's action, or the film's card) and
+ lands as the dot of the end card's mark ("NAME."); the end card blooms open FROM it and stays.
+- **Sound from the picture** (`launchSound.ts`): a key per character typed (the space bar its
+ own), the press on the frame Generate goes down, the drop and its bloom, each card landing on its
+ spring's first arrival, each UI item's landing; every cue panned to where it happens on screen;
+ one riser and one impact at the reveal and nothing on any other cut. A cue measured under the
+ score is raised until heard (at most +8 dB), then the mix is checked and a buried cue throws.
+ `film.cues` lists them; `meta.sync` names the presses and the impact for verify-export.
+- **Captions**: `meta.captions` from the prompts, the word pages, the split words and the end card;
+ `launch.mjs ship` or `captions.mjs` writes `.srt`/`.vtt`; `captions: "burn"` also draws them
+ in their own band under the picture on the phone shapes (the picture is composed above it).
+- The corner mark (your name) steps aside before any lean. Real holds are declared, so the gate
+ passes.
+
+Sync wins over length: the score plays at the film's bpm exactly, so every cut sits on its
+downbeats, and the film is made whole bars of the score (`gridScore`: the stretch section
+repeated or dropped, then the end-card hold, which is a hold, grows or shrinks to the bar; the
+tail rings out in whole bars). A score in 4/4 with no pickup, starting on frame 0. If no form
+fits, the build throws: compose a 1-bar stretch section or change askBeats/endBeats. Render
+refuses a beat-grid film whose score is more than 0.5 % off its bpm. The bed is set to -14 LUFS
+with the true peak at or under -1 dBTP (`musicBed`); a dynamic piece stops at the peak ceiling
+first and render says how far short; `limit: true` lets a look-ahead limiter take those peaks.
+
+**The plates, the UI and the score are made for this product, every time.** A style is a recipe
+applied to the user's subject (`references/styles.md`): draw their dashboard, their mascot, their
+product's world in the chosen hand, as a still plus its `*Draw` film; a UI ask's data comes from
+the product's real screens and states. anidoodle's own plates (the lighthouse and fox in
+`launchExample.ts`) and the web tour are placeholders, never a user's film. The score is composed
+for the brief's style, mood and length (`references/music/compose.md`); `score` is required
+(`null` means silent), `bpm` has no default, and the template refuses anidoodle's own pieces, by
+identity, by title and by content (the same novelty gate `music.mjs check` runs).
+
+### One timeline, four shapes
+
+`shape: "16x9" | "1x1" | "4x5" | "9x16"` (or `film.reshape(shape)`, or the film name
+`myLaunch-9x16` in any tool) composes the same cut for another frame through `launchLayout.ts`:
+the chat window, composer and card are laid out for the frame (a phone composer wraps the prompt
+and the camera glides after the caret, a line at a time), word pages re-set their lines, the split
+beat stacks, the end card stacks and centres. The timing, the cut and the sound do not change.
+Every line a viewer must read is phone-safe on 1x1, 4x5 and 9x16: at least 32 px at 1080 across
+(about 11 pt on a phone) for prompts, bubbles, card labels, tagline and install lines, 64 px for a
+word page; the layout throws with the fix when one cannot be (an install line too long for 9x16).
+
+### Two looks
+
+`preset: "drawn"` (default): ink blooms, hand-lettered words (`writeOn`), a warm paper palette.
+`preset: "clean"`: a quiet canvas, ONE accent colour (the button, the drop, the dot, the caret;
+`accent` sets it), type as the design: word pages SET in a heavy sans (`setType`: each word rises
+into place behind its own baseline), round iris seams instead of ink, the answer card opening as
+an iris. Both are ours: the clean look is a register, not a copy of anyone's film.
+
+### Frame rate and motion blur
+
+`fps: 60` doubles the frames on the same timing (a UI-heavy film's scrolls and springs read
+smoother); the cues, holds, captions and sync markers follow. `render.mjs --blur auto` takes as
+many subframes as each frame's measured on-screen speed needs (1 on a still frame), `--shutter 180`.
| Spec field | Meaning |
|---|---|
-| `title`, `subtitle`, `placeholder`, `genLabel`, `accent` | the chat's name, subline, empty text, button word, button colour |
-| `asks[]` | 1-3 of `{ prompt, plate, label, from?, to?, crop? }` |
+| `title`, `subtitle`, `placeholder`, `genLabel`, `accent` | the chat's name, subline, empty text, button word, button (and the clean look's one accent) colour |
+| `asks[]` | 1-3 of `{ prompt, plate, label, from?, to?, crop? }` (chat), `{ kind: "ui", ui, prompt?, split? }`, `{ kind: "film", film, from?, to?, split? }` |
| `words[i]` | the type frame after `asks[i]` (not after the last ask; it flows into the end card) |
| `tagline`, `install[]`, `footer` | the end card; install lines are shown exactly as given |
-| `bpm` (required), `fps`, `askBeats`, `typeBeats`, `endBeats` | the beat grid (a beat is 60 x fps / bpm frames) and each part's length in beats |
+| `bpm` (required), `fps` (30 or 60), `askBeats`, `typeBeats`, `endBeats` | the beat grid (a beat is 60 x 30 / bpm frames at 30 fps) and each part's length in beats |
| `claimBar` | land the end card on this bar's downbeat, counting from bar 0 (`claimBar: 4` = frame 4 x bar); throws if it cannot. A longer last ask is really longer, never slowed |
-| `score` (required) or `audio` | the score composed for this product (the `Material` function compose.md writes, or a `Piece`), as a bed; `null` for silence; or your own finished mix (not checked) |
+| `score` (required) or `audio` | the score composed for this product (the `Material` function compose.md writes, or a `Piece`), as a bed; `null` for silence; or your own finished mix (not checked; it replaces the cues too) |
+| `shape`, `preset`, `sfx`, `motif`, `captions` | the frame (16x9 default); the look (drawn, clean); sound cues (default on); the relay into the end card (default on); `"sidecar"` (default) or `"burn"` |
The template refuses a feature list (more than 3 asks) and an end card too short to read.
@@ -94,17 +146,38 @@ The template refuses a feature list (more than 3 asks) and an end card too short
**`kinetic.ts`**: lettering that is written, never set.
- `writeOn(ctx, env, text, x, y, size, p, style, opts)`: a line written stroke by stroke by a
visible tool, in `ink`, `crayon`, `thread`, `chalk`, `brick` or `marker`. `measure` sizes it.
+- `setType(ctx, env, text, x, y, size, p, opts)`: a line SET in a heavy sans, each word rising
+ into place behind its baseline: the clean look's type. `setWidth` measures it.
- `sentence` (one medium per word, one word per beat), `caption` (a small callout with an
underline or arrow), `logo`/`logoCentred` and `logoBug` (anidoodle's own wordmark and corner
mark; for your product, write your name with `writeOn` as the template does).
+**`launchLayout.ts`**: `launchLayout(shape, content)` gives a shape's whole composition (the
+chat geometry, the thread, the camera's rests, the word pages, the split columns, the end card,
+the caption band) and the size of every text role, checked against the phone-safe minimums
+(`MIN_PX`). `drawChatFrame`, `caretAt`, `inkDrop` and `inkCard` take its `chat` geometry;
+`chatGeom(rect, k, px, promptPx, lines)` is the same chat component at any size.
+
+**`productUI.ts`**: `drawProductUI(ctx, rect, ui, { f, t0 }, theme, { minPx })` draws a
+product's interface from data in its before state and springs every item to its after state
+from `t0`; the window fits its content. `uiSettles` gives each item's landing frame and
+`springLand(t0, omega, zeta)` the frame any spring first reaches its target (where its sound goes).
+
+**`motif.ts`**: `relay(keys)` is one object's continuous path across a seam (cut frames),
+`seamGap` and `checkRelay` measure it on both sides of a match cut and throw past 2 px.
+
+**`launchSound.ts`**: `mixLaunch`/`launchAudio` place cues from the sfx kit (`music/sfx`),
+pan each by its screen x (`panOf`), duck the score, raise a buried cue until it is heard, and
+hold the mix under -1 dBTP.
+
**`launchCut.ts`**: the cut as data.
- `pic(from, to, len)` plays a span of your content timeline over `len` frames; `type(lines,
len, before, after)` is a word page. `makeCut(segs)` gives `N`, `at(F)`, `contentOf`, `cutOf`
(map content-frame sound events onto the cut).
- `beatGrid(bpm, fps)`: `beat`, `bar`, `frameOf(bar, beat)`, and `solve(bar, fixed)`, the frames
left for one flexible segment so the claim lands on a bar (launch3 lands on bar 26).
-- `bloomFrame` (a page inside an ink bloom; `close: false` keeps it open for an end card),
+- `bloomFrame` (a page inside an ink bloom; `close: false` keeps it open for an end card;
+ `center` opens it from a point, the motif; `shape: "circle"` is the clean look's iris),
`typeFrame` (one to three lines written on it; `lead`, `stagger`), `bloomRadius` (for holds).
**`launchGallery.ts`**: `drawWall` and `wallCam`, a rolling wall of style cards where the
diff --git a/skills/anidoodle/references/workflows/launch-video.md b/skills/anidoodle/references/workflows/launch-video.md
index 42bb1e1..5345d05 100644
--- a/skills/anidoodle/references/workflows/launch-video.md
+++ b/skills/anidoodle/references/workflows/launch-video.md
@@ -51,8 +51,11 @@ pieces are examples of the craft, never material for someone else's film.
## Type
- **Words NEVER sit over the art or the UI.** A word gets its own full frame: an ink bloom
- opens, a brush writes the word, the bloom closes on the next scene (`typeFrame`). Corner marks
- step aside when the camera brings UI under them.
+ opens, a brush writes the word, the bloom closes on the next scene (`typeFrame`). Or, for a
+ feature beat, its own COLUMN: words on the left, the live UI on the right (words above, UI
+ below on a phone), each in its own area of the layout (`split`), faster than a full word page.
+ Corner marks step aside when the camera brings UI under them, and sit in their own strip on a
+ phone frame.
- **3-7 words a frame, few frames.** Collapse word cards into one claim then proof ("JUST CODE."
then "31 STYLES"); fewer cards leave more time for the proof.
- **Hold each settled word 0.5 s or more**, longer for the claim.
@@ -70,9 +73,29 @@ pieces are examples of the craft, never material for someone else's film.
thread scrolls, a follow-up animates in the existing card instead of popping a new one.
- **Web**: show the whole site first, then zoom to each click; the site's copy describes what
the viewer is seeing.
+- **A product that is not a chat shows its own UI**, drawn from its real data in two states: the
+ before (the problem), one press of its action, every item springing to the after. Never a
+ screenshot slideshow (`productUI.ts`, a `kind: "ui"` ask).
+
+## The motif
+
+**Pick ONE object the story already owns and carry it across the seams**: anidoodle's template
+carries the ink drop that every press of Generate sends into the thread; at the end it lifts off
+Generate one last time and lands as the dot of the end card's mark ("NAME."), and the end card
+blooms open FROM it. The rule for any seam you design as a match cut: on the last frame of the
+outgoing shot and the first of the incoming one the object has the same screen position and size
+(within 2 px), and the incoming scene opens from it. `motif.ts` (`relay`, `checkRelay`) checks it;
+a seam that jumps throws. Use it for the seams that matter (the reveal), never on every cut.
- Banned defaults: a centred title on a gradient, everything fading in, bouncy easing, particle
bursts, glow on UI chrome, dead time, text scaled into blur.
+## Two registers
+
+The **drawn** register (default): ink blooms, hand-lettered words, a warm paper palette, the
+product drawn in the chosen style. The **clean** register (`preset: "clean"`) for a UI-first
+product: a quiet canvas, ONE accent colour, type as the design (set, not written; each word rises
+into place), round iris seams, the product's own UI. Pick one per film; never mix them.
+
## Brand and the end card
- **The logo recurs**: a small corner mark on every frame (`logoBug`), not once at the start.
@@ -91,8 +114,12 @@ pieces are examples of the craft, never material for someone else's film.
- **Balance by stem RMS, not only LUFS**: an integrated -14 LUFS hid a sub 7-10 dB too hot.
- **Cut on downbeats, not every beat.** Land the claim on a chord (launch3's lands on bar 26,
the home chord); `beatGrid().solve()` fits a flexible segment so it does.
-- **Sound effects only on real direction changes**: one riser into the big reveal, one impact,
- never a whoosh on every cut (`references/music/sound-design.md`).
+- **Sound effects come from the picture's own math**, never laid on by hand: a key per typed
+ character, the press on the frame the button goes down, the drop and its bloom, a card landing
+ on its spring's first arrival, each panned to where it happens on screen (`launchSound.ts`).
+ Every cue must be heard over the score (the template raises a buried one, then checks).
+- **Transition sounds only on real direction changes**: one riser into the big reveal, one
+ impact on it, never a whoosh on every cut, nothing on a word page (`references/music/sound-design.md`).
- **Master to -14 LUFS integrated, true peak -1 dBTP or lower**, then listen on a phone speaker.
## Delivery
@@ -101,7 +128,17 @@ pieces are examples of the craft, never material for someone else's film.
a platform version rather than pushing one master everywhere. Cut whole beats; never speed
the whole film up (it breaks the beat grid and reads rushed).
- **Shapes**: `16x9` for YouTube and the site, `1x1` or `4x5` for feeds, `9x16` for Reels and
- Shorts. Reframe per shape from one timeline; never crop a wide render.
+ Shorts. Re-compose per shape from one timeline; never crop a wide render. The template does it
+ through `launchLayout.ts` (`launch.mjs ship <film> --shapes 16x9,1x1,9x16`), with phone-safe type:
+ every line a viewer reads at least 32 px at 1080 across on the phone shapes.
+- **Captions**: feeds autoplay muted. Ship `.srt`/`.vtt` for players that take a sidecar (YouTube,
+ LinkedIn, the site); burn them into their OWN band under the picture for feeds that do not
+ (`captions: "burn"`), never over the art.
+- **Sync and peak are checked on the file you ship**, not the master: the sound at every sync
+ marker within 1 ms of the mix, the true peak at or under -1 dBTP after the AAC encode
+ (`verify-export --delivery`).
+- **A UI-heavy film may run at 60 fps** (`fps: 60`); render with `--blur auto` so fast moves blur
+ by their real speed and still frames stay sharp.
- **The first frame is the thumbnail.** Platforms and players show frame 1 before play. Make
it legible and on brand (anidoodle's is the wall of styles; the template's is the prompt, big,
mid-sentence); never a blank, a fade from black, or a whole chat window too small to read.
@@ -124,7 +161,9 @@ pieces are examples of the craft, never material for someone else's film.
first (type over art, spacing, hierarchy), then timing. Render only the changed range
(`render.mjs --from F --to T` writes `out/<film>.<F>-<T>.mp4`, silent). Give notes in camera words ("slow this zoom to 0.7x",
"hold the word 10 frames longer"), never "make it better".
-8. **QA**: `gate.mjs <film>` (determinism, contract, dead air; declare real holds in
- `meta.holds`, each with its reason) and `verify-export.mjs <film> --file <mp4> --delivery
- --first-frame #rrggbb` for EVERY shape shipped; meter the mix. Keep the review page updated as work lands.
+8. **QA**: `launch.mjs ship <film> --shapes ... --gate` runs, for EVERY shape shipped, the gate
+ (determinism, contract, dead air; declare real holds in `meta.holds`, each with its reason)
+ and `verify-export --delivery` (size, frames, score, sync, true peak, a legible frame 0), and
+ writes the poster and captions; add `verify-export <film>-<shape> --first-frame #rrggbb` for a
+ brand colour. Meter the mix. Keep the review page updated as work lands.
9. ✋ **Final approval** on the finished file.