@olegkoval/agent-skills 1.59.3 → 1.61.0

package/adapters/claude/olko-creative/skills/carousel-maker/scripts/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "lib": ["es2023"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "erasableSyntaxOnly": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": ["*.ts", "domain", "edge", "test"]
+}

package/adapters/claude/olko-creative/skills/shorts-animator/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: shorts-animator
+description: Use when someone wants a narrated, painted or hand-drawn animated short (TikTok, Reels, YouTube Shorts) from a script or topic and a look described in words. Every frame is drawn in code and GPU-painted, voiced locally, captioned and scored into an MP4; no image models or stock.
+license: MIT
+allowed-tools: Bash, Read, Write, Edit
+compatibility: Codex, Claude Code, Hermes Agent, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Needs Node 22.18+, ffmpeg and Chrome; the narrator installs Python and its voice model on first use.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - video
+    - animation
+    - shorts
+    - narration
+    - canvas
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# Shorts Animator
+
+A script and a look in, an animated short out. You write the lines and draw every shot as canvas code; the
+tool paints it on the GPU on twos, narrates it with a local Kokoro voice, captions it, scores it and
+encodes the MP4. Nothing is filmed, generated by an image model, or licensed.
+
+`SA` = `node <this skill's folder>/scripts/sa.ts`. Write the full command each time. One folder per short:
+`WORK=./<slug>-short`. First run on a machine: `SA doctor` (checks Node, ffmpeg, Chrome, sets up the voice,
+renders a 3-second test).
+
+## 1. Decide, do not interrogate
+
+Decide the lines, shots, look, voice and music yourself. Ask one question only if the subject is unclear.
+A pasted script is used word for word. A topic: write it per `references/writing.md`.
+
+| they say | look |
+|---|---|
+| oil, painterly, Van Gogh, swirly, "like the faith shorts" | `oil` |
+| watercolour, soft, dreamy, children's book | `watercolor` |
+| crayon, pastel, chalk, for kids | `pastel` |
+| ink, comic, graphic novel, line art | `ink` |
+| flat, storybook, gouache, poster, calm | `gouache` |
+
+Custom look: `"look": { "base": "oil", "brush": 16, "palette": {...} }`. Read `references/looks.md` only
+when overriding numbers. Voice `bm_george` (default, scripture and quotes), `am_michael`, `bf_emma`
+(stories), `af_heart` (kids); `speed` 0.85 to 0.95 reads calm. Their recording: `"voice": { "file":
+"assets/voice.m4a" }` with `say` lines matching it in order. `"voice": "none"` for music only. Music
+`mood`: `tender`, `hopeful`, `night`, `wonder`, `playful`, `none`, or a track path. `SA looks` lists all.
+
+## 2. Write the plan and the drawings
+
+```bash
+SA new "$WORK" --look oil      # short.json + scenes.js + assets/
+```
+
+`short.json` lines: `{ "say": "...", "scene": "meadow" | ["a", "b"], "move": "push", "hold": 0.8 }`.
+- A list of scenes cuts on the caption chunks. Cut often: a new picture every 1.5 to 3 s.
+- `move`: push, pull, pan-left, pan-right, rise, fall, drift, still. `transition`: cut, fade, dip (rarely).
+- `caption` shows different words; `/` forces a break. `captions.style`: box, plain, none.
+- `format`: 9:16 (default), 16:9, 1:1, 4:5. `twos`: 2 (hand-drawn), 1 (smooth).
+
+`scenes.js`: `window.SCENES = { "meadow": (k) => { k.sky({...}); k.person({...}); } }`. Read
+`references/kit.md` before writing scenes. Draw like a painter:
+- Big simple shapes, strong value contrast, one subject. The paint pass adds texture; draw nothing fussy.
+- Keep faces out of the caption band (about 77% down).
+- Every shot different: place, scale, day and night, warm and cool. Match the words.
+- Small motion: `pose: "walk"`, `dx`, rain, glints. `k.t` seconds, `k.p` progress 0 to 1.
+- No helper for it (a boat, an animal)? Write a small function with `k.g`, flat shapes in the palette.
+
+## 3. Check, then look (budgeted)
+
+```bash
+SA check "$WORK"     # no browser, about a second: missing scenes, throwing scenes, unknown kit calls,
+                     # figures under the captions, line and total length
+SA frames "$WORK"    # narrates (cached), one painted frame per shot -> frames/sheet.jpg
+SA still "$WORK" 7   # one shot full size, only when the sheet shows a problem you cannot place
+```
+
+Fix every `ERROR` from `check` before spending a browser run. Then read `frames/sheet.jpg` once. Fix muddy
+or empty shots, a figure lost in its background (contrast, `rim`), look-alike shots, a red "no scene"
+frame, and every `⚠ the page said` line. **Budget: at most two frames rounds before the first render.**
+Images are the expensive part of this loop; do not reopen a sheet you have already judged.
+
+## 4. Render and deliver
+
+```bash
+SA render "$WORK"    # about a minute for 40 s -> <title>.mp4, renders/vN.mp4 (+ its short.json), qa/sheet.jpg
+```
+
+Read `qa/sheet.jpg` only if the render printed a warning or they report a problem. Tell them in two
+lines what it is (look, length, shots) and: "Tell me what to change, one sentence is enough."
+
+## 5. One-sentence changes
+
+Smallest change, `SA check`, render, show. `SA set "$WORK" voice.speed=0.85 music.mood=night` edits
+short.json (JSON values; plain text otherwise) and refuses an invalid result.
+
+| they say | change |
+|---|---|
+| more painterly, softer | `look` or its numbers (brush, swirl, wash) |
+| slower, faster | `voice.speed`, `pause` |
+| a woman's voice, American | `voice.id` |
+| no music, more emotional | `music.mood` |
+| bigger captions, no box | `captions.size` 52, `captions.style` plain |
+| for YouTube | `format` 16:9, redraw shots whose layout breaks |
+| change shot 4 | that scene function only |
+
+## When something goes wrong
+
+| symptom | fix |
+|---|---|
+| no Chrome | install Chrome, or `SA doctor` fetches a headless one |
+| "painting on the CPU" | works, about 10x slower |
+| narrator setup fails | needs Python 3.10+ or `uv`; or use `"voice": "none"` or their recording |
+| voice timing off with their recording | `say` lines must match its words, in order |

package/adapters/claude/olko-creative/skills/shorts-animator/references/kit.md

@@ -0,0 +1,59 @@
+# The drawing kit
+
+Every scene is `(k) => { ... }`. Positions are fractions of the frame (x 0→1 left→right, y 0→1 top→bottom);
+sizes in px are for a 1920-tall frame and scale with it (`k.u`). Draw back to front: sky, far, middle, near.
+
+| in `k` | what |
+|---|---|
+| `k.g` | the 2D canvas context (camera already applied): draw anything the helpers don't cover |
+| `k.W`, `k.H`, `k.u` | frame size, and the scale (H/1920) |
+| `k.X(x)`, `k.Y(y)` | fraction → pixels |
+| `k.t`, `k.p` | seconds into the shot (on twos), progress 0→1 |
+| `k.r()` | random, the same on every drawing of the shot |
+| `k.rng(seed)`, `k.noise1(x)` | a seeded random source; smooth 1D noise |
+| `k.pal`, `k.beat` | the short's palette; this shot's beat (scene, line, move) |
+| `k.mix(a, b, t)`, `k.alpha(c, a)` | colour helpers |
+| `IMAGES.name` | an image from `assets/` (a logo, a reference), for `k.g.drawImage` |
+
+## Sky and light
+- `k.sky({ stops: [top, …, bottom], y0, y1 })`: a gradient
+- `k.clouds({ y, band, n, size, color, shade, drift, seed })`: small cumulus in a band, drifting
+- `k.sun({ x, y, r, color, glow, glowSize, glowAlpha })`: sun, moon, a bright bulb
+- `k.glow({ x, y, r, color, a })`: any soft light (windows, lanterns, a halo)
+- `k.stars({ n, y1 })`, `k.motes({ n, y0, y1, color })` (fireflies, embers), `k.rain({ n, a, slant })`
+- `k.rays({ x, y, angle, spread, n, a, width })`: god rays through trees or clouds
+- `k.haze({ y, h, color, a })`: air between planes
+
+## Land and water
+- `k.ridge({ y, amp, freq, color, top, shape, seed })`: filled ridge: `soft` hills, `peaks` mountains,
+  `pines` a conifer line, `bush` a broadleaf line, `rocky`
+- `k.ground({ y, color, far, stripes, stripe, flowers })`: the ground plane, mown stripes, flowers
+- `k.path({ x, y, near, far, color, bend })`: a road to the horizon
+- `k.water({ y0, y1, color, deep, glint, glints })`: lake or sea with moving glints
+- `k.waterfall({ x, w, y0, y1 })`
+- `k.shape({ pts: [[x,y],…], color, smooth })`: any shape: a cliff, a giant tree trunk, an island
+
+## Plants
+- `k.tree({ x, y, h, kind, crown, trunk, fruit })`: kind `round` `pine` `autumn` `bare` `palm` `column`
+- `k.trees({ n, y, h, x0, x1, kind, crown })`: a row
+- `k.foliage({ side, x, depth, y0, y1, color, light })`: leaves hanging into frame from a side
+- `k.trunks({ n, color, light, width, x0, x1 })`: inside a forest
+
+## Built things
+- `k.house({ x, y, w, h, wall, roof, window, lit, floors, aFrame })`
+- `k.city({ y, h, color, lit, litColor, density, n })`: skyline, windows lit at night
+- `k.pagoda({ x, y, h, color })`, `k.pole({ x, y, h })`, `k.lamp({ x, y, h, light })`
+- `k.block({ x0, y0, x1, y1, color, edge })`: walls, doorways, a lit edge
+- `k.heart({ x, y, s, color })`
+
+## People
+`k.person({ x, y, h, pose, facing, hair, skin, hairColor, top, bottom, shoes, robe, rim, silhouette, walk, dx, flip, build })`
+- feet at (x, y), `h` = height as a fraction of the frame (0.25 is a full figure in a landscape)
+- `pose`: `stand` `walk` `cheer` `open` `wave` `point` `reach` `pray` `hug` `sit` `kneel` `hold`
+- `facing`: `front` | `back` (faces are left blank on purpose: it's the style, and it reads at any size)
+- `hair`: `short` `long` `curly` `afro` `bun` `hood` `hat` `cap` `bald`
+- `robe: true`: a long garment (biblical, monks, a dress)
+- `silhouette: "#111"`: one colour (backlit, sunset); `rim: "#9db6f0"`: a lit outline (night)
+- `dx`: moves over the shot (0.05 = 5% of the width); `walk`: steps per second
+- `k.people([{...}, {...}])`: several `person` calls in one
+- Two people walking together read as a relationship; a tiny figure in a huge landscape reads as awe or loneliness.

package/adapters/claude/olko-creative/skills/shorts-animator/references/looks.md

@@ -0,0 +1,32 @@
+# Looks: from words to numbers
+
+A look is a JSON object. Start from a shipped one (`"base": "oil"`) and override.
+
+| key | what it does | range |
+|---|---|---|
+| `mode` | `strokes` (paint/pastel), `wash` (watercolour/ink), `flat` | |
+| `brush` | stroke size in px at 1920 tall | 5 fine … 11 oil … 18 bold |
+| `length` | stroke length ÷ width | 2 dabs … 4.6 hatching |
+| `swirl` | strokes follow a swirl (1) or the shapes (0) | 0 … 1 |
+| `curve` | strokes bend | 0 … 1 |
+| `bristle` | streaks inside a stroke, broken dry ends | 0 … 1 |
+| `impasto` | thick paint catching light | 0 … 1 |
+| `hueJitter` `valueJitter` `satJitter` | colour variation stroke to stroke | 0 … 0.4 |
+| `respect` | big strokes stop at edges (crisper subjects) | 0 … 1 |
+| `boil` | share of strokes redrawn every drawing (the shimmer) | 0 still … 1 lively |
+| `wash` `bleed` | watercolour pooling, blooms, granulation; how far colour runs | 0 … 1 |
+| `outline` `ink` | hand-inked lines, their colour | 0 … 1 |
+| `paper` `paperColor` `grain` | canvas/paper texture, grain | 0 … 1.6 |
+| `posterize` | flat colour bands (screen print, retro) | 0 off, 4 … 8 |
+| `saturation` `contrast` `warmth` | grade | ~0.8 … 1.3 |
+| `vignette` `bloom` | dark corners, glow from lights | 0 … 0.6 |
+| `captions` | `{ style, size, y, box, color, font, case }` | |
+
+Words → moves:
+- "thicker / bolder paint" → brush +4, impasto +0.2 · "finer" → brush −3
+- "swirly / Van Gogh" → swirl 0.9, curve 1, hueJitter 0.25 · "calmer" → swirl 0.3, boil 0.2
+- "dreamy / soft" → watercolor, bleed 1 · "crisp" → respect 1, boil 0.2
+- "vintage / old film" → saturation 0.8, warmth 0.5, grain 1, vignette 0.5
+- "comic / graphic novel" → ink, posterize 6 · "screen print / retro poster" → gouache, posterize 5
+- "night is too dark" → contrast 0.95 and lighten the palette, not the look
+- "for kids" → pastel or gouache, saturation 1.1, warm palette, playful music

package/adapters/claude/olko-creative/skills/shorts-animator/references/writing.md

@@ -0,0 +1,9 @@
+# Writing the lines
+
+- One idea per line, 4 to 12 words. Read aloud it should take 1.5 to 4 seconds.
+- Open on a hook that makes the second line necessary ("You have heard that it was said,").
+- A turn two-thirds in ("But…", "And yet…", "Nobody ever…").
+- Land the last line; give it `hold: 0.8` and a final wide or calm shot.
+- Scripture, quotes and poems: use a public-domain translation (KJV, WEB) or their own words; keep it exact.
+- Never invent a quote and attribute it to a real person.
+- 20 to 45 seconds is the sweet spot for Shorts, Reels and TikTok; 60 s at most.

package/adapters/claude/olko-creative/skills/shorts-animator/scripts/audio/compose.ts

@@ -0,0 +1,290 @@
+// The music: presets, chord voicing and the arrangement. Pure given the two rngs; the only effect is
+// writing into the buses it allocates itself.
+import { SR, biquad, busAdd, busMixFrom, delay, human, makeBus, reverb } from "./dsp.ts";
+import type { Bus, Rng, Voice } from "./dsp.ts";
+import {
+  bass, brush, ep, epChord, hat, kick, outroImpact, outroRiser, pad, pluck, shaker, snare, softSynth, strum, vinyl,
+} from "./instruments.ts";
+
+// key = MIDI root; prog = chords as scale degrees in the key, one per bar; ext = chord size (4 = sevenths,
+// 5 = ninths). Chords are voiced in the middle register with the root left to the bass.
+export type Preset = {
+  readonly bpm: number; readonly root: number; readonly scale: readonly number[]; readonly prog: readonly number[];
+  readonly ext: number; readonly parts: readonly string[]; readonly swing: number; readonly verb: number;
+  readonly duck: number; readonly low?: number; readonly drums?: number;
+};
+const MAJ: readonly number[] = [0, 2, 4, 5, 7, 9, 11], MIN: readonly number[] = [0, 2, 3, 5, 7, 8, 10];
+
+export const PRESETS: Readonly<Record<string, Preset>> = {
+  kinetic: { bpm: 118, root: 57, scale: MIN, prog: [0, 5, 2, 6], ext: 5, parts: ["kick4", "snare", "hatOff", "bassHouse", "epStab", "pad"], swing: 0, verb: 0.2, duck: 0.6 },
+  keynote: { bpm: 100, root: 60, scale: MAJ, prog: [0, 5, 3, 4], ext: 4, parts: ["kickHalf", "shaker16", "epPulse", "epHold", "pad", "bassLong"], swing: 0, verb: 0.3, duck: 0.85 },
+  aura: { bpm: 78, root: 63, scale: MAJ, prog: [0, 3, 5, 4], ext: 5, parts: ["pad", "epArp", "bassSwell"], swing: 0, verb: 0.45, duck: 1 },
+  paper: { bpm: 104, root: 65, scale: MAJ, prog: [0, 4, 5, 3], ext: 4, parts: ["kickSoft", "brush", "hat8", "pluck8", "bassBounce"], swing: 0.14, verb: 0.22, duck: 0.85 },
+  terminal: { bpm: 112, root: 62, scale: MIN, prog: [0, 5, 6, 0], ext: 4, parts: ["kick4", "hat16", "bass8", "synthArp", "pad"], swing: 0, verb: 0.2, duck: 0.65, low: 0.7, drums: 0.85 },
+  data: { bpm: 86, root: 67, scale: MAJ, prog: [1, 4, 0, 5], ext: 5, parts: ["kickBoom", "snareBoom", "hat8", "epHold", "bassBoom", "vinyl"], swing: 0.18, verb: 0.25, duck: 0.85 },
+  story: { bpm: 96, root: 62, scale: MAJ, prog: [0, 4, 5, 3], ext: 4, parts: ["kickSoft", "brush", "shaker8", "guitar8", "epHold", "bassLong"], swing: 0.08, verb: 0.3, duck: 0.9 },
+  // Shorts Animator's moods: beds for a voice to sit on, no drums in the quiet ones
+  tender: { bpm: 70, root: 60, scale: MAJ, prog: [0, 5, 3, 4], ext: 5, parts: ["pad", "epArp", "bassSwell"], swing: 0, verb: 0.5, duck: 1 },
+  hopeful: { bpm: 84, root: 62, scale: MAJ, prog: [0, 4, 5, 3], ext: 4, parts: ["pad", "guitar8", "bassLong"], swing: 0.06, verb: 0.38, duck: 1 },
+  night: { bpm: 64, root: 57, scale: MIN, prog: [0, 5, 3, 6], ext: 5, parts: ["pad", "epHold", "bassSwell"], swing: 0, verb: 0.55, duck: 1 },
+  wonder: { bpm: 76, root: 65, scale: MAJ, prog: [3, 4, 0, 5], ext: 5, parts: ["pad", "epArp", "bassSwell"], swing: 0, verb: 0.5, duck: 1 },
+  playful: { bpm: 100, root: 65, scale: MAJ, prog: [0, 4, 5, 3], ext: 4, parts: ["kickSoft", "brush", "pluck8", "bassBounce"], swing: 0.14, verb: 0.22, duck: 0.9 },
+};
+
+// ---------- harmony ----------
+const chord = (root: number, scale: readonly number[], deg: number, size = 4): number[] =>
+  Array.from({ length: size }, (_, k) => { const s = deg + k * 2; return root + scale[s % 7] + 12 * Math.floor(s / 7); });
+const bassNote = (root: number, scale: readonly number[], deg: number): number => {
+  let m = root + scale[deg % 7];
+  while (m > 45) m -= 12;
+  while (m < 33) m += 12;
+  return m;
+};
+function nextWithPc(from: number, pc: number): number {
+  let m = from + 1;
+  while (m % 12 !== pc) m++;
+  return m;
+}
+// rootless close voicing that tops out by B4, as near as it can to the last chord's lowest note
+function voicing(root: number, scale: readonly number[], deg: number, size: number, prev: readonly number[] | null): number[] {
+  const tones = chord(root, scale, deg, size).map((m) => ((m % 12) + 12) % 12);
+  const pcs = size >= 4 ? tones.slice(1) : tones;
+  const want = prev ? (prev[0] + 56) / 2 : 56; // led by the last chord, pulled back toward the middle
+  const cands = Array.from({ length: 14 }, (_, i) => 51 + i).filter((lo) => lo % 12 === pcs[0]).map((lo) => {
+    const v = pcs.slice(1).reduce((acc, pc) => [...acc, nextWithPc(acc[acc.length - 1], pc)], [lo]);
+    return { v, score: Math.abs(lo - want) + (v[v.length - 1] > 71 ? 100 : 0) };
+  });
+  return cands.reduce((best, c) => (c.score < best.score ? c : best)).v;
+}
+
+// ---------- the arrangement ----------
+export type Timing = { readonly duration: number; readonly outroAt?: number };
+type Ctx = {
+  readonly P: Preset; readonly r: Rng; readonly ham: Rng;
+  readonly spb: number; readonly bar: number; readonly s16: number; readonly end: number;
+  readonly drums: Bus; readonly inst: Bus; readonly low: Bus; readonly send: Bus;
+  readonly voices: readonly (readonly number[])[]; readonly roots: readonly number[];
+};
+type Bar = { readonly b: number; readonly t0: number; readonly ch: readonly number[]; readonly rt: number; readonly len: number };
+
+const hasPart = (c: Ctx, p: string): boolean => c.P.parts.includes(p);
+const intro = (c: Ctx, bar: Bar): boolean => bar.b === 0 && c.P.bpm < 90; // slow beds open on the harmony alone
+const before = (c: Ctx, t: number): boolean => t < c.end - 0.02;
+// every call draws one rng value for the humanising jitter, so the call order is part of the sound
+function at(c: Ctx, bar: Bar, q: number): number {
+  const swing = q % 2 ? c.P.swing * c.s16 * 2 : 0;
+  return bar.t0 + q * c.s16 + swing + (c.r() - 0.5) * 0.01;
+}
+const steps = (step: number, count = 16 / step): number[] => Array.from({ length: count }, (_, i) => i * step);
+
+// stops at the first step that falls past the end
+function walk(c: Ctx, bar: Bar, qs: readonly number[], fn: (q: number, t: number) => void): void {
+  for (const q of qs) {
+    const t = Math.max(0, at(c, bar, q));
+    if (!before(c, t)) break;
+    fn(q, t);
+  }
+}
+// skips the steps that fall past the end, keeps going
+function visit(c: Ctx, bar: Bar, qs: readonly number[], clampT: boolean, fn: (q: number, t: number) => void): void {
+  for (const q of qs) {
+    const raw = at(c, bar, q), t = clampT ? Math.max(0, raw) : raw;
+    if (before(c, t)) fn(q, t);
+  }
+}
+const instSend = (c: Ctx, v: Voice, t: number, ig: number, pan: number, sg: number): void => {
+  busAdd(c.inst, v, t, ig, pan);
+  busAdd(c.send, v, t, sg);
+};
+
+// ---------- drums: each step returns the kick times it played (the sidechain listens to them) ----------
+type DrumStep = (c: Ctx, bar: Bar, q: number, t: number) => number[];
+const kickAt = (c: Ctx, t: number, v: Float32Array, gain: number): number[] => { busAdd(c.drums, v, t, gain); return [t]; };
+const snareAt = (c: Ctx, t: number, s: Float32Array, dg: number, sg: number): number[] => { busAdd(c.drums, s, t, dg); busAdd(c.send, s, t, sg); return []; };
+const tick = (c: Ctx, v: Float32Array, t: number, gain: number, pan: number): number[] => { busAdd(c.drums, v, t, gain, pan); return []; };
+
+// the order is the order the rng is drawn in
+const DRUM_STEPS: readonly (readonly [string, DrumStep])[] = [
+  ["kick4", (c, _b, q, t) => (q % 4 === 0 ? kickAt(c, t, kick(c.r), 0.75 * human(c.r, 0.08)) : [])],
+  ["kickHalf", (c, _b, q, t) => (q === 0 || q === 8 ? kickAt(c, t, kick(c.r, { punch: 0.6, dec: 0.32 }), 0.45) : [])],
+  ["kickSoft", (c, bar, q, t) => (q === 0 || q === 8 || (q === 6 && bar.b % 2 === 1) ? kickAt(c, t, kick(c.r, { punch: 0.7, dec: 0.3 }), 0.55) : [])],
+  ["kickBoom", (c, _b, q, t) => (q === 0 || q === 7 || q === 10 ? kickAt(c, t, kick(c.r, { pitch: 48, dec: 0.4 }), q === 7 ? 0.4 : 0.65) : [])],
+  ["snare", (c, _b, q, t) => (q === 4 || q === 12 ? snareAt(c, t, snare(c.r, { tone: 200, top: 8000 }), 0.42, 0.18) : [])],
+  ["snareBoom", (c, _b, q, t) => (q === 4 || q === 12 ? snareAt(c, t, snare(c.r, { dec: 0.16, top: 6000 }), 0.5, 0.12) : [])],
+  ["brush", (c, _b, q, t) => {
+    if (q !== 4 && q !== 12) return [];
+    const s = brush(c.r);
+    busAdd(c.drums, s, t, 0.5, 0.1); busAdd(c.send, s, t, 0.2);
+    return [];
+  }],
+  ["hatOff", (c, _b, q, t) => (q % 4 === 2 ? tick(c, hat(c.r), t, 0.3 * human(c.r, 0.3), 0.25) : [])],
+  ["hat8", (c, _b, q, t) => (q % 2 === 0 ? tick(c, hat(c.r), t, (q % 4 === 2 ? 0.2 : 0.11) * human(c.r, 0.4), 0.3) : [])],
+  ["shaker16", (c, _b, q, t) => tick(c, shaker(c.r), t, (q % 4 === 2 ? 0.2 : q % 2 ? 0.07 : 0.12) * human(c.r, 0.4), 0.35)],
+  ["shaker8", (c, _b, q, t) => (q % 2 === 0 ? tick(c, shaker(c.r), t, (q % 4 === 2 ? 0.2 : 0.1) * human(c.r, 0.4), 0.35) : [])],
+  ["hat16", (c, _b, q, t) => tick(c, hat(c.r), t, (q % 4 === 2 ? 0.16 : 0.08) * human(c.r, 0.4), -0.2)],
+];
+
+// recursion (not a loop) so the kick times come back as a value; stops at the first step past the end
+function drumWalk(c: Ctx, bar: Bar, q: number): number[] {
+  if (q >= 16) return [];
+  const t = Math.max(0, at(c, bar, q));
+  if (!before(c, t)) return [];
+  const here = DRUM_STEPS.flatMap(([name, fn]) => (hasPart(c, name) ? fn(c, bar, q, t) : []));
+  return [...here, ...drumWalk(c, bar, q + 1)];
+}
+
+// ---------- harmony and bass parts ----------
+type Part = (c: Ctx, bar: Bar) => void;
+
+const padPart: Part = (c, bar) => {
+  const p = pad(bar.ch, bar.len + 1.2, c.r, { cutoff: c.P.bpm < 90 ? 2800 : 2400, attack: intro(c, bar) ? 1.4 : 0.5 });
+  instSend(c, p, bar.t0, hasPart(c, "epArp") ? 0.5 : 0.28, 0, 0.4);
+};
+const epHoldPart: Part = (c, bar) => visit(c, bar, bar.b % 2 ? [0, 10] : [0], false, (q, t) => {
+  const v = epChord(bar.ch, q ? c.spb * 1.5 : bar.len + 0.3, 0.42, c.r, c.ham);
+  instSend(c, v, Math.max(0, t), q ? 0.3 : 0.45, 0, 0.3);
+});
+const epStabPart: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  visit(c, bar, [3, 6, 10, 14], false, (q, t) => instSend(c, epChord(bar.ch, c.spb * 0.55, 0.5, c.r, c.ham, { roll: 0.004 }), t, 0.5, q % 2 ? 0.15 : -0.15, 0.25));
+};
+const epPulsePart: Part = (c, bar) => walk(c, bar, steps(2), (q, t) => {
+  const m = q % 8 === 0 ? bar.ch[0] : q % 4 === 0 ? bar.ch[2] ?? bar.ch[1] : bar.ch[1];
+  const v = ep(m - 12 >= 48 ? m - 12 : m, c.spb * 0.9, 0.38 * human(c.r, 0.15), c.ham);
+  instSend(c, v, t, 0.38, q % 4 ? 0.2 : -0.2, 0.25);
+});
+const epArpPart: Part = (c, bar) => walk(c, bar, steps(4), (q, t) => {
+  const v = ep(bar.ch[(q / 4) % bar.ch.length], c.spb * 3, 0.3 * human(c.r, 0.2), c.ham);
+  instSend(c, v, t, 0.42, (q / 4 - 1.5) * 0.3, 0.5);
+});
+const PLUCK8_PAT = [0, 2, 1, 3, 2, 1, 0, 2];
+const pluck8Part: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  // steps 3 and 7 are rests: they draw no jitter and cannot end the walk
+  walk(c, bar, [0, 1, 2, 4, 5, 6].map((k) => k * 2), (q, t) => {
+    const k = q / 2, s = pluck(bar.ch[PLUCK8_PAT[k] % bar.ch.length], 0.8, c.r, { bright: 0.28, decay: 0.993 });
+    instSend(c, s, t, human(c.r, 0.2), (k % 3 - 1) * 0.3, 0.3);
+  });
+};
+const GUITAR8_PAT = [0, 1, 2, 3, 2, 1, 2, 3];
+const guitar8Part: Part = (c, bar) => walk(c, bar, steps(2), (q, t) => {
+  const k = q / 2, ch = bar.ch;
+  const m = k === 0 ? (ch[0] - 12 >= 45 ? ch[0] - 12 : ch[0]) : ch[GUITAR8_PAT[k] % ch.length];
+  const s = pluck(m, 1.2, c.r, { bright: 0.22, decay: 0.996 });
+  instSend(c, s, t, 0.9 * human(c.r, 0.2), k % 2 ? 0.25 : -0.25, 0.3);
+});
+const SYNTH_ARP_PAT = [0, 1, 2, 1, 3, 2];
+const synthArpPart: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  walk(c, bar, steps(1), (q, t) => {
+    const m = bar.ch[SYNTH_ARP_PAT[q % 6] % bar.ch.length] - 12;
+    const s = softSynth(m < 45 ? m + 12 : m, c.s16 * 1.6, 1900 + 700 * Math.sin((bar.b * 16 + q) / 10));
+    instSend(c, s, t, 0.22, q % 2 ? 0.25 : -0.25, 0.22);
+  });
+};
+
+const lowAt = (c: Ctx, v: Float32Array, t: number, gain: number): void => busAdd(c.low, v, t, gain);
+const bassHousePart: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  visit(c, bar, [2, 6, 10, 14], false, (q, t) => lowAt(c, bass(q === 14 ? bar.rt + 7 : bar.rt, c.spb * 0.45), t, 0.55));
+};
+const bassLongPart: Part = (c, bar) => visit(c, bar, [0, 8], true, (_q, t) => lowAt(c, bass(bar.rt, c.spb * 1.9, { a: 0.02, r: 0.2 }), t, 0.45));
+const bassSwellPart: Part = (c, bar) => lowAt(c, bass(bar.rt, bar.len + 0.4, { a: 0.6, r: 0.6, drive: 1 }), bar.t0, 0.4);
+const BOUNCE: readonly (readonly [number, number])[] = [[0, 0], [6, 7], [8, 0], [14, 7]];
+const bassBouncePart: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  BOUNCE.forEach(([q, d]) => visit(c, bar, [q], true, (_q, t) => lowAt(c, bass(bar.rt + d, c.spb * 0.45, { tone: 0.3 }), t, 0.5)));
+};
+const bass8Part: Part = (c, bar) => {
+  if (intro(c, bar)) return;
+  visit(c, bar, steps(2), true, (_q, t) => lowAt(c, bass(bar.rt, c.spb * 0.4), t, 0.34));
+};
+const bassBoomPart: Part = (c, bar) => visit(c, bar, [0, 10], true, (q, t) => lowAt(c, bass(bar.rt, c.spb * (q ? 1.2 : 1.5), { a: 0.01, r: 0.15 }), t, 0.55));
+
+// the order is the order the rng is drawn in: harmony first, then bass
+const PARTS: readonly (readonly [string, Part])[] = [
+  ["pad", padPart], ["epHold", epHoldPart], ["epStab", epStabPart], ["epPulse", epPulsePart], ["epArp", epArpPart],
+  ["pluck8", pluck8Part], ["guitar8", guitar8Part], ["synthArp", synthArpPart],
+  ["bassHouse", bassHousePart], ["bassLong", bassLongPart], ["bassSwell", bassSwellPart],
+  ["bassBounce", bassBouncePart], ["bass8", bass8Part], ["bassBoom", bassBoomPart],
+];
+
+function renderBar(c: Ctx, bar: Bar): number[] {
+  const kicks = intro(c, bar) ? [] : drumWalk(c, bar, 0);
+  PARTS.forEach(([name, part]) => { if (hasPart(c, name)) part(c, bar); });
+  return kicks;
+}
+
+// the end: a low swell, one deep hit, the home chord left ringing
+function ending(c: Ctx, duration: number): void {
+  const { P, r, ham, spb, end } = c;
+  const home = voicing(P.root, P.scale, 0, P.ext || 4, c.voices[c.voices.length - 1]);
+  const riserSec = Math.min(1.6, spb * 3);
+  busAdd(c.inst, outroRiser(r, riserSec), end - riserSec, 0.14);
+  const hit = outroImpact(r, P.root);
+  busAdd(c.inst, hit, end, 0.3); busAdd(c.send, hit, end, 0.2);
+  const tail = Math.max(2.4, duration - end + 1.8);
+  if (hasPart(c, "guitar8") || hasPart(c, "pluck8")) {
+    const s = strum([bassNote(P.root, P.scale, 0) + 12, ...home], tail, r, { bright: 0.24, decay: 0.998 });
+    busAdd(c.inst, s, end, 1.1); busAdd(c.send, s, end, 0.4);
+  } else {
+    const ch = epChord(home, tail, 0.45, r, ham, { roll: 0.03 });
+    busAdd(c.inst, ch, end, 0.55); busAdd(c.send, ch, end, 0.5);
+  }
+  const p = pad(home, tail, r, { cutoff: 2200, attack: 0.05, release: 1.8 });
+  busAdd(c.inst, p, end, 0.22); busAdd(c.send, p, end, 0.4);
+  busAdd(c.low, bass(bassNote(P.root, P.scale, 0), Math.max(1.5, duration - end + 0.6), { a: 0.005, r: 1.2 }), end, 0.45);
+  if (P.parts.some((x) => x.startsWith("kick"))) busAdd(c.drums, kick(r, { dec: 0.5 }), end, 0.7);
+}
+
+// ---------- mix ----------
+function duckAround(duck: Float32Array, t: number, depth: number): void {
+  const i0 = Math.round(t * SR);
+  for (let i = 0; i < 0.22 * SR && i0 + i < duck.length; i++) duck[i0 + i] = Math.min(duck[i0 + i], 1 - depth + depth * Math.pow(i / (0.22 * SR), 0.6));
+}
+// sidechain: the harmony breathes under each kick (deep for the dance beds, barely for the gentle ones)
+function sidechain(c: Ctx, kicks: readonly number[]): void {
+  const depth = 1 - c.P.duck;
+  if (depth <= 0.01) return;
+  const { inst, low } = c, duck = new Float32Array(inst.n).fill(1);
+  kicks.forEach((t) => duckAround(duck, t, depth));
+  for (let i = 0; i < inst.n; i++) { inst.L[i] *= duck[i]; inst.R[i] *= duck[i]; low.L[i] *= duck[i] * 0.7 + 0.3; low.R[i] *= duck[i] * 0.7 + 0.3; }
+}
+// a dark room: the reverb only hears the middle of the spectrum
+function darken(send: Bus): void {
+  const sl = [biquad("lp", 6500), biquad("lp", 6500)], sh = [biquad("hp", 220), biquad("hp", 220)];
+  for (let i = 0; i < send.n; i++) { send.L[i] = sl[0](sh[0](send.L[i])); send.R[i] = sl[1](sh[1](send.R[i])); }
+}
+function mixDown(c: Ctx, total: number, duration: number): Bus {
+  const { P, send, spb } = c;
+  darken(send);
+  const wet = reverb(send, { room: P.verb > 0.4 ? 0.88 : 0.82, damp: 0.45 });
+  const echo = P.bpm >= 100 ? delay(send, spb * 0.75, 0.28, 2400) : null;
+  const music = makeBus(total);
+  busMixFrom(music, c.drums, P.drums ?? 1); busMixFrom(music, c.inst, 1); busMixFrom(music, c.low, P.low ?? 1); busMixFrom(music, wet, P.verb * 2.2);
+  if (echo) busMixFrom(music, echo, 0.1);
+  // fade in over half a beat, out after the ring
+  const fin = Math.round(spb * SR * 0.5), fout0 = Math.round((duration + 0.2) * SR), fout1 = Math.round((duration + 2.6) * SR);
+  for (let i = 0; i < music.n; i++) {
+    const g = (i < fin ? i / fin : 1) * (i > fout0 ? Math.max(0, 1 - (i - fout0) / (fout1 - fout0)) : 1);
+    music.L[i] *= g; music.R[i] *= g;
+  }
+  return music;
+}
+
+export function composeMusic(P: Preset, timing: Timing, r: Rng, ham: Rng): Bus {
+  const { duration } = timing;
+  const spb = 60 / P.bpm, bar = spb * 4, total = duration + 3; // ring-out
+  const end = timing.outroAt ?? Math.max(0, duration - 3);
+  const nBars = Math.ceil(duration / bar) + 1;
+  const deg = (b: number): number => P.prog[b % P.prog.length];
+  const voices = Array.from({ length: nBars }).reduce<number[][]>((acc, _, b) => [...acc, voicing(P.root, P.scale, deg(b), P.ext || 4, acc[b - 1] ?? null)], []);
+  const roots = Array.from({ length: nBars }, (_, b) => bassNote(P.root, P.scale, deg(b)));
+  const c: Ctx = { P, r, ham, spb, bar, s16: spb / 4, end, drums: makeBus(total), inst: makeBus(total), low: makeBus(total), send: makeBus(total), voices, roots };
+  const bars = Array.from({ length: nBars }, (_, b) => b).filter((b) => b * bar < end - 0.01);
+  const kicks = bars.flatMap((b) => renderBar(c, { b, t0: b * bar, ch: voices[b], rt: roots[b], len: Math.min(bar, end - b * bar) }));
+  if (hasPart(c, "vinyl")) busAdd(c.inst, vinyl(duration + 1, r), 0, 0.5);
+  ending(c, duration);
+  sidechain(c, kicks);
+  return mixDown(c, total, duration);
+}