tuneframes 0.1.0 → 0.2.0

package/skills/audio-minimal/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: audio-minimal
+description: Minimal techno — Robert Hood / Villalobos style. A click, a sub, a single hi-hat, one repeating note. Every sound has massive space. Groove lives in subtle velocity variation and silence.
+---
+
+# TuneFrames — Minimal Techno
+
+## Genre Profile
+- BPM range: 128–135
+- Key characteristics: Extreme sparsity — 3 to 5 sounds maximum, massive amounts of silence, subtle velocity and timing micro-variations create the groove, no melodic content or filtered sweeps, hypnotic through repetition and restraint
+- Typical instruments: MembraneSynth (kick/click), one MetalSynth or NoiseSynth (hi-hat), one MonoSynth (single repeating note or sub), maybe one sparse PolySynth texture
+- Mood: Hypnotic, austere, cerebral, meditative, relentless
+
+## Core Pattern
+
+```js
+// Minimal Techno — 132 BPM
+// Rule: if you're adding a sound, ask whether removing it makes it better.
+// The answer is usually yes.
+
+// Click kick — not a deep sub, more of a transient "click"
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.02,   // very short pitch decay = more click, less boom
+  octaves: 4,
+  envelope: { attack: 0.001, decay: 0.18, sustain: 0, release: 0.05 }
+}).toDestination();
+
+// Sub — single note, all session, barely moving
+const sub = new Tone.MonoSynth({
+  oscillator: { type: "sine" },
+  envelope: { attack: 0.01, decay: 0.3, sustain: 0.6, release: 0.2 },
+  filter: { type: "lowpass", frequency: 120 },
+  volume: -6
+}).toDestination();
+
+// Hi-hat — one hit, lots of space, slight velocity drift
+const hat = new Tone.MetalSynth({
+  frequency: 400,
+  envelope: { attack: 0.001, decay: 0.06, release: 0.015 },
+  harmonicity: 3.1, modulationIndex: 16, resonance: 3000, octaves: 1.2,
+  volume: -12
+}).toDestination();
+
+// The groove is here: velocity micro-variation on the kick
+let step = 0;
+const vels = [0.9, 0.75, 0.85, 0.7, 0.9, 0.8, 0.78, 0.85]; // never quite the same
+new Tone.Sequence((time) => {
+  kick.triggerAttackRelease("C1", "8n", time, vels[step % vels.length]);
+  step++;
+}, [1, null, null, null, 1, null, null, null,
+    1, null, null, null, 1, null, null, null], "16n").start(0);
+
+// Hat: only on the "and" of beat 4 — one hit per bar
+new Tone.Sequence((time, val) => {
+  if (val) hat.triggerAttackRelease("16n", time, 0.55 + Math.random() * 0.12);
+}, [null, null, null, null, null, null, null, null,
+    null, null, null, null, null, null, 1, null], "16n").start(0);
+```
+
+## Instrument Configuration
+
+```js
+// Kick — transient-heavy click, minimal sub content
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.018,  // ultra-short = it's mostly a click/transient
+  octaves: 4,
+  volume: -2,
+  envelope: { attack: 0.001, decay: 0.16, sustain: 0, release: 0.04 }
+}).toDestination();
+
+// Sub tone — sine wave, barely audible, felt not heard
+// This is the floor the kick sits on
+const sub = new Tone.MonoSynth({
+  oscillator: { type: "sine" },
+  filter: { type: "lowpass", frequency: 100 },
+  envelope: { attack: 0.008, decay: 0.25, sustain: 0.7, release: 0.3 },
+  volume: -10
+}).toDestination();
+
+// Hi-hat — single sparse hit, slightly random velocity = humanization
+const hat = new Tone.MetalSynth({
+  frequency: 380, harmonicity: 3.1, modulationIndex: 16,
+  resonance: 3200, octaves: 1.2,
+  envelope: { attack: 0.001, decay: 0.065, release: 0.018 },
+  volume: -14
+}).toDestination();
+
+// Optional: one sparse texture note
+// A single note (Tone.Synth) with long release and deep reverb
+// Triggered once every 4-8 bars — the only "melodic" element
+const textureVerb = new Tone.Reverb({ decay: 8.0, wet: 0.85 }).toDestination();
+const texture = new Tone.Synth({
+  oscillator: { type: "sine" },
+  envelope: { attack: 0.2, decay: 2.0, sustain: 0, release: 3.0 },
+  volume: -18
+}).connect(textureVerb);
+```
+
+## Composition Structure
+
+Minimal techno is NOT about adding — it's about what you don't play.
+
+- **Bar 1-4:** Kick only. Establish the pulse. Let silence speak.
+- **Bar 5-8:** Add sub note on beat 1 only. Four bars of kick + one sub note per bar.
+- **Bar 9-16:** Add hat — ONE hit per bar, on beat 4.5 (last 16th). That's it.
+- **Bar 17-32:** No changes. Let the loop breathe. Micro-velocity variation IS the movement.
+- **Bar 33:** Remove the hat. Just kick + sub. Feel the absence.
+- **Bar 37:** Bring hat back at different position in the bar.
+- **Bar 41:** Single texture note — sine wave through 8s reverb. Play it once. Don't repeat it for 8 bars.
+- **Outro:** Remove sub. Just kick. Then silence mid-beat.
+
+The key insight: in minimal, a sound you've heard 32 times and then REMOVED is louder in its absence than it ever was playing. Use this. Remove things. Let the memory of the sound carry the groove.
+
+Micro-variation toolkit:
+- Velocity: never the same value twice in a row — vary ±10% randomly
+- Timing: slight humanization (`time + (Math.random() - 0.5) * 0.005`) on the hat only
+- Filter: one slow, almost-imperceptible filter movement over 32 bars on the sub
+- Volume: a 2dB swell over 8 bars, back down — the listener should feel it not notice it
+
+## Example Variations
+
+### 1 — Hat timing humanization (the Villalobos move)
+```js
+// Subtle timing displacement on hat = the groove isn't in the kick, it's here
+hat.triggerAttackRelease(
+  "16n",
+  time + (Math.random() - 0.5) * 0.006, // ±6ms drift
+  0.5 + Math.random() * 0.15
+);
+```
+
+### 2 — Sub filter drift (imperceptible movement)
+```js
+// Extremely slow filter sweep — listener feels unease without knowing why
+const now = Tone.now();
+subFilter.frequency.setValueAtTime(90, now);
+subFilter.frequency.linearRampToValueAtTime(140, now + 30); // over 30 seconds
+subFilter.frequency.linearRampToValueAtTime(90, now + 60);
+```
+
+### 3 — Silence as event (drop the kick for 1 bar)
+```js
+// Most powerful move in minimal: remove kick for exactly one bar
+// Use a Tone.Part to exclude one specific bar from the sequence
+// The groove snaps back harder when the kick returns
+let kickEnabled = true;
+const kickSeq = new Tone.Sequence((time) => {
+  if (kickEnabled) kick.triggerAttackRelease("C1", "8n", time);
+}, [1, null, null, null, 1, null, null, null,
+    1, null, null, null, 1, null, null, null], "16n");
+
+// Disable for bar 9 only
+Tone.Transport.scheduleOnce(() => { kickEnabled = false; }, "8m");
+Tone.Transport.scheduleOnce(() => { kickEnabled = true; },  "9m");
+```

package/skills/audio-minimal/example.html

@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Minimal Techno</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+</head>
+<body>
+  <!-- TuneFrames Metadata -->
+  <div id="tuneframes"
+    data-bpm="132"
+    data-duration="12s"
+    data-genre="minimal"
+    data-key="none"
+    style="display:none">
+  </div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 132;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-2).toDestination();
+      const masterGain = new Tone.Gain(0.9).connect(masterLimiter);
+
+      // --- KICK CLICK — transient-forward, minimal sub ---
+      const kickGain = new Tone.Gain(0.8).connect(masterGain);
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.019,
+        octaves: 4,
+        envelope: { attack: 0.001, decay: 0.16, sustain: 0, release: 0.04 }
+      }).connect(kickGain);
+
+      // --- SUB TONE — sine, low-passed, felt not heard ---
+      const subGain = new Tone.Gain(0.55).connect(masterGain);
+      const subFilter = new Tone.Filter({ frequency: 110, type: "lowpass", Q: 1 }).connect(subGain);
+      const sub = new Tone.MonoSynth({
+        oscillator: { type: "sine" },
+        filter: { type: "lowpass", frequency: 200 },
+        filterEnvelope: { attack: 0.01, decay: 0.3, sustain: 0.6, release: 0.3,
+                          baseFrequency: 80, octaves: 1 },
+        envelope: { attack: 0.008, decay: 0.22, sustain: 0.65, release: 0.25 },
+        volume: -4
+      }).connect(subFilter);
+
+      // --- HI-HAT — sparse, single hit per bar, humanized ---
+      const hatGain = new Tone.Gain(0.35).connect(masterGain);
+      const hat = new Tone.MetalSynth({
+        frequency: 385,
+        envelope: { attack: 0.001, decay: 0.062, release: 0.018 },
+        harmonicity: 3.1,
+        modulationIndex: 16,
+        resonance: 3100,
+        octaves: 1.2
+      }).connect(hatGain);
+
+      // --- TEXTURE — single sine note, massive reverb, triggered once ---
+      const textureVerb = new Tone.Reverb({ decay: 7.5, wet: 0.88 }).connect(masterGain);
+      const textureGain = new Tone.Gain(0.3).connect(textureVerb);
+      const texture = new Tone.Synth({
+        oscillator: { type: "sine" },
+        envelope: { attack: 0.25, decay: 2.5, sustain: 0, release: 4.0 },
+        volume: -2
+      }).connect(textureGain);
+
+      // --- KICK SEQUENCE — 4-on-the-floor with subtle velocity drift ---
+      // The groove IS the velocity variation — never fully uniform
+      const kickVels = [0.88, 0.74, 0.84, 0.71, 0.90, 0.76, 0.82, 0.70,
+                        0.91, 0.73, 0.85, 0.72, 0.88, 0.75, 0.83, 0.74];
+      let kickStep = 0;
+      const kickSeq = new Tone.Sequence((time) => {
+        kick.triggerAttackRelease("C1", "8n", time, kickVels[kickStep % kickVels.length]);
+        kickStep++;
+      }, [1, null, null, null, 1, null, null, null,
+          1, null, null, null, 1, null, null, null], "16n");
+      kickSeq.start(0);
+
+      // --- SUB SEQUENCE — one hit per bar, beat 1 only ---
+      // Enters at bar 3 — two bars of kick-only silence first
+      const subSeq = new Tone.Sequence((time) => {
+        sub.triggerAttackRelease("C1", "4n", time);
+      }, [1, null, null, null, null, null, null, null,
+          null, null, null, null, null, null, null, null], "16n");
+      subSeq.start("2m");
+
+      // Very slow filter drift on sub — imperceptible but felt
+      const subDriftStart = Tone.Time("2m").toSeconds();
+      subFilter.frequency.setValueAtTime(100, subDriftStart);
+      subFilter.frequency.linearRampToValueAtTime(145, subDriftStart + 8);
+      subFilter.frequency.linearRampToValueAtTime(95, subDriftStart + 12);
+
+      // --- HI-HAT SEQUENCE — ONE hit per bar, on last 16th (step 15) ---
+      // Slight timing humanization = the Villalobos groove
+      // Enters at bar 5
+      const hatSeq = new Tone.Sequence((time) => {
+        const jitter = (Math.random() - 0.5) * 0.005; // ±5ms humanization
+        const vel = 0.48 + Math.random() * 0.16;      // velocity drift
+        hat.triggerAttackRelease("16n", time + jitter, vel);
+      }, [null, null, null, null, null, null, null, null,
+          null, null, null, null, null, null, 1, null], "16n");
+      hatSeq.start("4m");
+
+      // --- TEXTURE NOTE — single event, bar 7, D above middle ---
+      // Plays once. Never repeats. The reverb tail carries it.
+      texture.triggerAttackRelease("D4", "8n", "6m");
+
+      // --- STRUCTURAL EVENT: remove hat for exactly one bar (bar 9), then return ---
+      // Absence as rhythm — the most minimal move there is
+      Tone.Transport.scheduleOnce(() => { hatSeq.mute = true; }, "8m");
+      Tone.Transport.scheduleOnce(() => { hatSeq.mute = false; }, "9m");
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-orchestral/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: audio-orchestral
+description: Full orchestral writing — strings carry melody, brass punctuate, timpani on downbeats, woodwind color
+---
+
+# TuneFrames — Orchestral
+
+## Genre Profile
+- BPM range: 60-120 (varies by mood — slow for drama, faster for action)
+- Key characteristics: proper voice leading between parts, strings as primary melodic voice, brass on structural downbeats, timpani emphasizes phrase endings, woodwinds add color between string phrases
+- Typical instruments: PolySynth triangle (strings), PolySynth sawtooth (brass), MembraneSynth (timpani), AMSynth (woodwinds)
+- Mood: cinematic, epic, emotional, noble
+
+## Core Pattern
+
+```js
+// Orchestral texture: strings carry the tune, brass confirm the harmony
+// Key = D minor, BPM = 80
+Tone.Transport.bpm.value = 80;
+
+// Hall reverb — essential for orchestral realism
+const reverb = new Tone.Reverb({ decay: 3.5, preDelay: 0.04, wet: 0.7 });
+await reverb.generate();
+reverb.toDestination();
+
+// STRINGS — PolySynth, triangle wave, slow attack (bowing)
+const strings = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.8, decay: 0.3, sustain: 0.9, release: 1.5 },
+  volume: -6,
+});
+strings.connect(reverb);
+
+// BRASS — PolySynth, sawtooth, medium attack (breath to tone)
+const brass = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.3, decay: 0.4, sustain: 0.7, release: 0.8 },
+  volume: -10,
+});
+brass.connect(reverb);
+
+// TIMPANI — MembraneSynth with long resonance
+const timpani = new Tone.MembraneSynth({
+  pitchDecay: 0.4, octaves: 4,
+  envelope: { attack: 0.001, decay: 1.2, sustain: 0, release: 0.8 },
+  volume: -8,
+}).connect(reverb);
+
+// Strings: melody phrase (quarter notes + half notes)
+// D minor: D E F G A Bb A G
+const stringMelody = ['D4','E4','F4','G4','A4','Bb4','A4','G4'];
+const stringTimes  = [0, 0.75, 1.5, 2.25, 3, 3.75, 4.5, 5.25];
+stringMelody.forEach((note, i) => {
+  Tone.Transport.scheduleOnce(time => {
+    strings.triggerAttackRelease(note, '4n', time);
+  }, stringTimes[i]);
+});
+
+// Brass: hold root + fifth on downbeats, confirm the harmony
+Tone.Transport.scheduleOnce(t => brass.triggerAttackRelease(['D3','A3'], '2n', t), 0);
+Tone.Transport.scheduleOnce(t => brass.triggerAttackRelease(['F3','C4'], '2n', t), 3);
+Tone.Transport.scheduleOnce(t => brass.triggerAttackRelease(['G3','D4'], '2n', t), 6);
+
+// Timpani: roll on downbeats — D2 as the root
+[0, 3, 6].forEach(t => {
+  Tone.Transport.scheduleOnce(time => timpani.triggerAttackRelease('D2', '8n', time), t);
+});
+```
+
+## Instrument Configuration
+
+```js
+// Hall reverb — orchestras play in halls
+const reverb = new Tone.Reverb({ decay: 3.5, preDelay: 0.05, wet: 0.7 });
+await reverb.generate();
+reverb.toDestination();
+
+// STRINGS (Violin section)
+// Triangle wave approximates the bowed string harmonic spectrum (rough, not sine)
+// Slow attack simulates bow catching the string
+const strings = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.8, decay: 0.2, sustain: 0.95, release: 1.5 },
+  volume: -5,
+}).connect(reverb);
+
+// BRASS (French horns / Trumpets)
+// Sawtooth gives the harmonic richness of a brass instrument
+// Medium attack = breath control into tone
+const brass = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.35, decay: 0.3, sustain: 0.75, release: 1.0 },
+  volume: -9,
+}).connect(reverb);
+
+// WOODWINDS (Oboe / Flute color)
+// AMSynth provides the reedy, breathy quality
+const woodwinds = new Tone.AMSynth({
+  harmonicity: 1,
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.15, decay: 0.1, sustain: 0.85, release: 0.6 },
+  modulation: { type: 'square' },
+  modulationEnvelope: { attack: 0.5, decay: 0.0, sustain: 0.3, release: 0.5 },
+  volume: -16,
+}).connect(reverb);
+
+// TIMPANI
+// MembraneSynth: pitchDecay simulates the drum head ringing
+const timpani = new Tone.MembraneSynth({
+  pitchDecay: 0.35, octaves: 5,
+  envelope: { attack: 0.001, decay: 1.5, sustain: 0, release: 1.0 },
+  volume: -7,
+}).connect(reverb);
+```
+
+## Composition Structure
+
+**Phrase-based (not loop-based):**
+
+1. **Statement (0-3s):** Strings introduce the melody. Brass hold the tonic chord quietly. Timpani on beat 1.
+2. **Response (3-6s):** Strings move to a contrasting phrase. Brass shift to IV or V chord. Woodwinds enter between string notes.
+3. **Development (6-9s):** Melody moves to upper strings (higher octave). Brass build in volume. Timpani on phrase downbeats.
+4. **Cadence (9-12s):** All voices converge on a half-cadence (ends on V) or full cadence (ends on I). Timpani rolls.
+
+**Voice leading rules:**
+- Strings: move by step or small intervals. Avoid leaps larger than a 5th in the melody.
+- Brass: hold common tones between chords when possible. Move the voice that needs to move.
+- Woodwinds: fill in the 3rd or 7th of the chord — the color tones strings and brass don't cover.
+
+## Example Variations
+
+### Variation 1: Heroic major (C major, faster)
+```js
+Tone.Transport.bpm.value = 108;
+// Key: C major — C D E F G A B C
+// Brass on I, IV, V, I (C, F, G, C)
+// Timpani on C2, G2 alternating
+// Strings lead in 8th notes — more energetic
+```
+
+### Variation 2: Tragic minor (A minor, slow)
+```js
+Tone.Transport.bpm.value = 66;
+// Key: A minor — A B C D E F G A
+// Very slow strings: half notes and whole notes only
+// Brass only enter at climax (bar 3), very quiet before that
+// Timpani: soft rolls (8 rapid 32nd notes) instead of single hits
+```
+
+### Variation 3: Mysterious woodwind feature
+```js
+// Woodwinds take the melody for 4 bars — strings accompany
+// Strings: slow tremolo (fast repeating 32nd notes on a held chord)
+// Woodwinds: stepwise descending line D4→C4→B3→A3→G3
+// No brass, no timpani — intimate chamber feel
+```

package/skills/audio-orchestral/example.html

@@ -0,0 +1,140 @@
+<div id="tuneframes" style="display:none">{"bpm":80,"duration":"14s"}</div>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+<script>
+// TuneFrames — Orchestral
+// D minor: strings carry melody, brass confirm harmony,
+// woodwinds add color, timpani on downbeats
+// Proper voice leading — each section has a role
+
+async function main() {
+  await Tone.start();
+
+  const beat = 60 / 80;     // 0.75s per quarter note
+  const half = beat * 2;    // 1.5s per half note
+
+  // ── Hall reverb — all orchestral sound happens in a hall ──────────────────
+  const reverb = new Tone.Reverb({ decay: 3.5, preDelay: 0.05, wet: 0.7 });
+  await reverb.generate();
+  reverb.toDestination();
+
+  // ── STRINGS — PolySynth triangle, slow bow-attack ─────────────────────────
+  const strings = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.75, decay: 0.2, sustain: 0.95, release: 1.5 },
+    volume: -5,
+  });
+  strings.connect(reverb);
+
+  // ── BRASS — PolySynth sawtooth, medium breath-attack ─────────────────────
+  const brass = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'sawtooth' },
+    envelope: { attack: 0.32, decay: 0.35, sustain: 0.72, release: 1.0 },
+    volume: -10,
+  });
+  brass.connect(reverb);
+
+  // ── WOODWINDS — AMSynth for reedy, breathy character ─────────────────────
+  const woodwinds = new Tone.AMSynth({
+    harmonicity: 1.0,
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.14, decay: 0.1, sustain: 0.88, release: 0.6 },
+    modulation: { type: 'square' },
+    modulationEnvelope: { attack: 0.5, decay: 0.0, sustain: 0.3, release: 0.5 },
+    volume: -16,
+  });
+  woodwinds.connect(reverb);
+
+  // ── TIMPANI — MembraneSynth, long resonating pitch ───────────────────────
+  const timpani = new Tone.MembraneSynth({
+    pitchDecay: 0.38, octaves: 5,
+    envelope: { attack: 0.001, decay: 1.6, sustain: 0, release: 1.0 },
+    volume: -7,
+  });
+  timpani.connect(reverb);
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PHRASE 1 (0-6s): Statement — strings introduce D minor melody
+  // D minor scale ascending: D E F G A Bb A G
+  // ─────────────────────────────────────────────────────────────────────────
+
+  const phrase1 = [
+    { note: 'D4',  t: 0 },
+    { note: 'E4',  t: beat * 0.5 },
+    { note: 'F4',  t: beat * 1 },
+    { note: 'G4',  t: beat * 1.5 },
+    { note: 'A4',  t: beat * 2 },
+    { note: 'Bb4', t: beat * 2.5 },
+    { note: 'A4',  t: beat * 3 },
+    { note: 'G4',  t: beat * 3.5 },
+  ];
+  phrase1.forEach(({ note, t }) => strings.triggerAttackRelease(note, '4n', t));
+
+  // Brass: tonic Dm for 3 beats, then IV (Gm)
+  brass.triggerAttackRelease(['D3', 'F3', 'A3'], half, 0);
+  brass.triggerAttackRelease(['G2', 'Bb2', 'D3'], half, beat * 3);
+
+  // Timpani: downbeat on D2
+  timpani.triggerAttackRelease('D2', '8n', 0);
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PHRASE 2 (6-10s): Response — melody rises, woodwinds fill
+  // Half-cadence: ends on A major (V chord)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  const p2start = beat * 8; // 6s
+
+  const phrase2 = [
+    { note: 'F4',  t: p2start },
+    { note: 'A4',  t: p2start + beat * 0.5 },
+    { note: 'C5',  t: p2start + beat * 1 },
+    { note: 'D5',  t: p2start + beat * 1.5 },
+    { note: 'E5',  t: p2start + beat * 2 },
+    { note: 'F5',  t: p2start + beat * 2.5 },
+  ];
+  phrase2.forEach(({ note, t }) => strings.triggerAttackRelease(note, '4n', t));
+
+  // Woodwinds: fill inner voices between string notes
+  const woodwindNotes = [
+    { note: 'A4', t: p2start + beat * 0.25 },
+    { note: 'C5', t: p2start + beat * 1.25 },
+    { note: 'F4', t: p2start + beat * 2.25 },
+  ];
+  woodwindNotes.forEach(({ note, t }) => woodwinds.triggerAttackRelease(note, '4n', t));
+
+  // Brass: IV (Bb) → V (A major) — half cadence
+  brass.triggerAttackRelease(['Bb2', 'D3', 'F3'], half, p2start);
+  brass.triggerAttackRelease(['A2', 'C#3', 'E3'], half, p2start + beat * 3);
+
+  timpani.triggerAttackRelease('G2', '8n', p2start);
+  timpani.triggerAttackRelease('A2', '8n', p2start + beat * 3);
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PHRASE 3 (10-14s): Resolution — full cadence I (Dm), all voices converge
+  // ─────────────────────────────────────────────────────────────────────────
+
+  const p3start = p2start + beat * 6; // ~10.5s
+
+  const phrase3 = [
+    { note: 'F5',  t: p3start },
+    { note: 'E5',  t: p3start + beat * 0.5 },
+    { note: 'D5',  t: p3start + beat * 1 },
+    { note: 'C5',  t: p3start + beat * 1.5 },
+    { note: 'A4',  t: p3start + beat * 2 },
+    { note: 'F4',  t: p3start + beat * 2.5 },
+    { note: 'D4',  t: p3start + beat * 3 },
+  ];
+  phrase3.forEach(({ note, t }) => {
+    if (t < 14) strings.triggerAttackRelease(note, '4n', t);
+  });
+
+  // Brass: full Dm resolution chord
+  brass.triggerAttackRelease(['D3', 'F3', 'A3', 'D4'], beat * 4, p3start);
+
+  // Woodwinds: hold the 5th above brass
+  woodwinds.triggerAttackRelease('F5', beat * 3, p3start);
+
+  // Timpani: final downbeats on D2
+  timpani.triggerAttackRelease('D2', '4n', p3start);
+  timpani.triggerAttackRelease('D2', '4n', p3start + beat * 3);
+}
+</script>