tuneframes 0.1.0 → 0.2.0

package/skills/audio-downtempo/example.html

@@ -0,0 +1,164 @@
+<div id="tuneframes" style="display:none">{"bpm":82,"duration":"12s"}</div>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+<script>
+// TuneFrames — Downtempo / Trip-Hop
+// Portishead/Massive Attack: syncopated breakbeat, vinyl crackle,
+// sub bass movement, AMSynth eerie melody, BitCrusher grit
+
+async function main() {
+  await Tone.start();
+
+  const beat = 60 / 82;          // one quarter note in seconds ≈ 0.732s
+  const eighth = beat / 2;       // ≈ 0.366s
+  const sixteenth = beat / 4;    // ≈ 0.183s
+
+  // ── Effects chain ──────────────────────────────────────────────────────────
+  const reverb = new Tone.Reverb({ decay: 5.5, preDelay: 0.03, wet: 0.65 });
+  await reverb.generate();
+  reverb.toDestination();
+
+  const filter = new Tone.Filter({ frequency: 2200, type: 'lowpass', rolloff: -24 });
+  filter.connect(reverb);
+
+  const bitCrusher = new Tone.BitCrusher(7);
+  bitCrusher.connect(reverb);
+
+  // ── Vinyl crackle — pink noise, always running ─────────────────────────────
+  // Constant sustain with no attack creates the "record playing" texture
+  const crackle = new Tone.NoiseSynth({
+    noise: { type: 'pink' },
+    envelope: { attack: 0.1, decay: 0.1, sustain: 1.0, release: 0.5 },
+    volume: -30,
+  }).toDestination();
+  // Start immediately in offline context
+  crackle.triggerAttack(0);
+
+  // ── Sub bass — pure sine, root movement ───────────────────────────────────
+  const bass = new Tone.MonoSynth({
+    oscillator: { type: 'sine' },
+    filter: { Q: 3, frequency: 110, type: 'lowpass', rolloff: -24 },
+    filterEnvelope: {
+      attack: 0.05, decay: 0.6, sustain: 0.3, release: 0.8,
+      baseFrequency: 60, octaves: 1.2,
+    },
+    envelope: { attack: 0.02, decay: 0.25, sustain: 0.65, release: 0.5 },
+    volume: -3,
+  }).toDestination();
+
+  // ── Eerie melody — AMSynth for trembling character ────────────────────────
+  const lead = new Tone.AMSynth({
+    harmonicity: 2.8,
+    oscillator: { type: 'sawtooth' },
+    envelope: { attack: 0.18, decay: 0.7, sustain: 0.35, release: 2.0 },
+    modulation: { type: 'sine' },
+    modulationEnvelope: {
+      attack: 0.4, decay: 0.0, sustain: 1.0, release: 0.8,
+    },
+    volume: -14,
+  });
+  lead.connect(filter);
+
+  // ── Kick — heavy, syncopated (NOT four-on-the-floor) ─────────────────────
+  const kick = new Tone.MembraneSynth({
+    pitchDecay: 0.1, octaves: 12,
+    envelope: { attack: 0.001, decay: 0.62, sustain: 0, release: 0.15 },
+    volume: -1,
+  }).toDestination();
+
+  // ── Snare — pink noise, sits late on 2 and 4 (swung feel) ────────────────
+  const snare = new Tone.NoiseSynth({
+    noise: { type: 'pink' },
+    envelope: { attack: 0.001, decay: 0.2, sustain: 0, release: 0.14 },
+    volume: -8,
+  });
+  snare.connect(bitCrusher);
+
+  // ── Hi-hat — sparse, off-beat 16th accents ────────────────────────────────
+  const hihat = new Tone.NoiseSynth({
+    noise: { type: 'white' },
+    envelope: { attack: 0.001, decay: 0.05, sustain: 0, release: 0.02 },
+    volume: -22,
+  }).toDestination();
+
+  // ── Schedule: bass enters at 0, beat at 2s, melody at 5s ─────────────────
+
+  // Bass line: D2 → A2 → F2 → G2 (minor feel, moves every 2 beats)
+  // Crackle plays from 0, bass from ~0, drums from 2s, melody from 5s
+  const bassNotes = [
+    { note: 'D2', t: 0 },
+    { note: 'A1', t: beat * 2 },
+    { note: 'F1', t: beat * 4 },
+    { note: 'G1', t: beat * 6 },
+    { note: 'D2', t: beat * 8 },
+    { note: 'A1', t: beat * 10 },
+    { note: 'F1', t: beat * 12 },
+    { note: 'G1', t: beat * 14 },
+  ];
+  bassNotes.forEach(({ note, t }) => {
+    if (t < 12) bass.triggerAttackRelease(note, '4n', t);
+  });
+
+  // Breakbeat kick pattern (syncopated — not on every beat)
+  // Pattern over 2 bars: beats 1, the-and-of-2, 3, the-and-of-4
+  // In 8ths at 82 BPM: positions 0, 3, 4, 7 out of 8
+  const kickPattern = [0, 3, 4, 7]; // 8th-note positions
+  for (let bar = 0; bar < 4; bar++) {
+    kickPattern.forEach((pos) => {
+      const t = 2.0 + bar * eighth * 8 + pos * eighth;
+      if (t < 12) kick.triggerAttackRelease('C1', '8n', t);
+    });
+  }
+
+  // Snare: beats 2 and 4 but slightly swung (pushed ~30ms late)
+  const snareSwing = 0.03;
+  const snarePattern = [1, 3, 5, 7]; // 8th positions = beats 2, 4 etc
+  for (let bar = 0; bar < 4; bar++) {
+    snarePattern.filter((_, i) => i % 2 === 0).forEach((pos) => {
+      const t = 2.0 + bar * eighth * 8 + pos * eighth + snareSwing;
+      if (t < 12) snare.triggerAttackRelease('8n', t);
+    });
+  }
+
+  // Sparse hi-hat: 16th-note accents on the off-offbeats
+  const hihatPositions = [1, 5, 9, 13]; // 16th positions
+  for (let bar = 0; bar < 4; bar++) {
+    hihatPositions.forEach((pos) => {
+      const t = 2.0 + bar * sixteenth * 16 + pos * sixteenth;
+      if (t < 12) hihat.triggerAttackRelease('16n', t);
+    });
+  }
+
+  // Eerie melody: enters at 5s, D minor descending line
+  // D4 → C4 → Bb3 → A3 → G3 → A3 (minor descent, last note back up)
+  const melodyNotes = [
+    { note: 'D4',  dur: '4n',  t: 5.0 },
+    { note: 'C4',  dur: '4n',  t: 5.0 + beat },
+    { note: 'Bb3', dur: '4n',  t: 5.0 + beat * 2 },
+    { note: 'A3',  dur: '2n',  t: 5.0 + beat * 3 },
+    { note: 'G3',  dur: '4n',  t: 5.0 + beat * 5 },
+    { note: 'A3',  dur: '2n',  t: 5.0 + beat * 6 },
+    { note: 'D4',  dur: '4n',  t: 5.0 + beat * 8 },
+    { note: 'C4',  dur: '4n',  t: 5.0 + beat * 9 },
+  ];
+  melodyNotes.forEach(({ note, dur, t }) => {
+    if (t < 12) lead.triggerAttackRelease(note, dur, t);
+  });
+}
+
+window.renderComposition = async function(wavPath) {
+  let attempts = 0;
+  while (typeof Tone === 'undefined' && attempts < 50) {
+    await new Promise(r => setTimeout(r, 100));
+    attempts++;
+  }
+  if (typeof Tone === 'undefined') throw new Error('Tone not loaded');
+
+  const meta = JSON.parse(document.getElementById('tuneframes').textContent);
+  const durationSec = parseFloat(meta.duration) + 1.5;
+
+  const buffer = await Tone.Offline(async () => { await main(); }, durationSec, 1, 44100);
+  const wav = audioBufferToWav(buffer);
+  window.writeFile(wavPath, Array.from(new Uint8Array(wav)));
+  return wav.byteLength;
+};
+</script>

package/skills/audio-folk/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: audio-folk
+description: Folk / Acoustic — fingerpicked guitar simulation (PolySynth pluck, alternating bass + chord tones), simple melodic line, bass root on downbeats, optional brushed snare. C/G/D major. Warm, wooden, human. Simon & Garfunkel simplicity.
+---
+
+# TuneFrames — Folk / Acoustic
+
+## Genre Profile
+- BPM range: 80–110 (comfortable walking pace)
+- Key characteristics: Fingerpicking simulation via PolySynth with very fast attack, short decay, near-zero sustain (pluck envelope); thumb alternates root/5th bass notes while fingers pluck upper chord tones in between; simple diatonic melody; warm reverb, no chorus; near-dry bass; optional soft brushed snare
+- Typical instruments: PolySynth/Synth (acoustic guitar pluck), Synth (bass), optional NoiseSynth (brushed snare)
+- Mood: Intimate, warm, storytelling, human, wooden, unadorned
+
+## Core Pattern
+
+```js
+// Folk fingerpicking — 92 BPM, G major
+// Travis picking: thumb alternates G2/D2 (root/5th), fingers pluck upper chord tones
+// Chord progression: G – C – D – Em (4-bar loop)
+
+Tone.Transport.bpm.value = 92;
+
+// Acoustic pluck: triangle oscillator, very short decay, no sustain
+const guitarVerb = new Tone.Reverb({ decay: 1.5, wet: 0.2 }).toDestination();
+const guitar = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.003, decay: 0.22, sustain: 0.0, release: 0.5 },
+  volume: -6
+}).connect(guitarVerb);
+
+// Travis picking pattern for G major (8th notes, 1 bar):
+// G2 (thumb-root), B3 (finger), D2 (thumb-5th), G3 (finger),
+// G2 (thumb-root), D3 (finger), D2 (thumb-5th), B3 (finger)
+const gBar = [
+  ["0:0:0","G2"], ["0:0:2","B3"], ["0:1:0","D2"], ["0:1:2","G3"],
+  ["0:2:0","G2"], ["0:2:2","D3"], ["0:3:0","D2"], ["0:3:2","B3"],
+];
+
+const cBar = [
+  ["1:0:0","C2"], ["1:0:2","E3"], ["1:1:0","G2"], ["1:1:2","C3"],
+  ["1:2:0","C2"], ["1:2:2","G3"], ["1:3:0","G2"], ["1:3:2","E3"],
+];
+
+const dBar = [
+  ["2:0:0","D2"], ["2:0:2","F#3"], ["2:1:0","A2"], ["2:1:2","D3"],
+  ["2:2:0","D2"], ["2:2:2","A3"], ["2:3:0","A2"], ["2:3:2","F#3"],
+];
+
+const emBar = [
+  ["3:0:0","E2"], ["3:0:2","G3"], ["3:1:0","B2"], ["3:1:2","E3"],
+  ["3:2:0","E2"], ["3:2:2","B3"], ["3:3:0","B2"], ["3:3:2","G3"],
+];
+
+const arpPart = new Tone.Part((time, note) => {
+  guitar.triggerAttackRelease(note, "8n", time);
+}, [...gBar, ...cBar, ...dBar, ...emBar]);
+arpPart.loopEnd = "4m";
+arpPart.loop = true;
+arpPart.start(0);
+
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Acoustic guitar pluck — triangle oscillator, zero sustain is critical
+const guitarVerb = new Tone.Reverb({ decay: 1.4, wet: 0.18 }).toDestination();
+const guitar = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.003, decay: 0.22, sustain: 0.0, release: 0.5 },
+  volume: -6
+}).connect(guitarVerb);
+// Note: sustain: 0.0 is what makes it "pluck" instead of "pad"
+// Increase decay (0.3–0.5) for a slower, more resonant string feel
+
+// Bass — sine oscillator, warm, simple root notes
+const bass = new Tone.Synth({
+  oscillator: { type: "sine" },
+  envelope: { attack: 0.04, decay: 0.15, sustain: 0.6, release: 0.4 },
+  volume: -4
+}).toDestination();
+
+// Optional: brushed snare (very soft white noise, quiet)
+const brushVerb = new Tone.Reverb({ decay: 0.6, wet: 0.3 }).toDestination();
+const brushSnare = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.01, decay: 0.08, sustain: 0, release: 0.04 },
+  volume: -22  // very quiet — just a whisper of rhythm
+}).connect(brushVerb);
+
+// Optional: simple melody line (same pluck synth, higher octave)
+const melody = new Tone.Synth({
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.005, decay: 0.3, sustain: 0.2, release: 0.6 },
+  volume: -8
+}).connect(guitarVerb); // shares reverb with guitar
+```
+
+## Composition Structure
+
+- **Bars 1–2:** Guitar fingerpicking alone — just the pattern, completely bare, let it breathe
+- **Bars 3–4:** Add bass root notes on beat 1 of each bar — minimal, subtle
+- **Bars 5–8:** Melody enters over the fingerpicking — simple 8th-note lines, diatonic
+- **Bars 9–16:** Optional brushed snare very quietly on beats 2 and 4
+- **Variation:** Pick one chord per 2 bars instead of 1 for a slower, more hymn-like feel
+- **Outro:** Slow down BPM (use Transport.bpm ramp), fingerpicking thins to just root notes
+
+Harmonic vocabulary: Stay strictly diatonic. G major scale only (G A B C D E F#). Common progressions: G–C–D–G (I–IV–V–I), G–Em–C–D (I–vi–IV–V), G–D–Em–C (the "axis" — works everywhere).
+
+## Example Variations
+
+### 1 — Capo feel (higher key)
+```js
+// Transpose all notes up a perfect 4th (G → C, like a capo at fret 5)
+// G major → C major: C D E F G A B
+const gBar_capo = [
+  ["0:0:0","C3"], ["0:0:2","E4"], ["0:1:0","G2"], ["0:1:2","C4"],
+  ["0:2:0","C3"], ["0:2:2","G3"], ["0:3:0","G2"], ["0:3:2","E4"],
+];
+```
+
+### 2 — Arpeggio (no alternating bass, just chord tones ascending)
+```js
+// Simpler pattern: just arpeggiate each chord upward
+const gArp = ["G2","B2","D3","G3","D3","B2","G2","B2"];
+let step = 0;
+new Tone.Sequence((time) => {
+  guitar.triggerAttackRelease(gArp[step++ % gArp.length], "8n", time);
+}, new Array(8).fill(1), "8n").start(0);
+```
+
+### 3 — Slower "hymn" tempo with whole-note chord pads
+```js
+// One chord per 2 bars at 72 BPM — more contemplative
+Tone.Transport.bpm.value = 72;
+pad.triggerAttackRelease(["G3","B3","D4"], "2m", "0m");
+pad.triggerAttackRelease(["C3","E3","G3"], "2m", "2m");
+```

package/skills/audio-folk/example.html

@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Folk / Acoustic</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+</head>
+<body>
+  <!-- TuneFrames Metadata -->
+  <div id="tuneframes" style="display:none">{"bpm":92,"duration":"12s"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 92;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain = new Tone.Gain(0.88).connect(masterLimiter);
+
+      // --- GUITAR — triangle pluck, very short decay, near-zero sustain ---
+      const guitarVerb = new Tone.Reverb({ decay: 1.4, wet: 0.18 }).connect(masterGain);
+      await guitarVerb.ready;
+      const guitarGain = new Tone.Gain(0.65).connect(guitarVerb);
+      const guitar = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "triangle" },
+        envelope: { attack: 0.003, decay: 0.22, sustain: 0.0, release: 0.5 },
+        volume: 0
+      }).connect(guitarGain);
+
+      // --- MELODY — slightly warmer pluck, higher register ---
+      const melodyGain = new Tone.Gain(0.45).connect(guitarVerb); // shares reverb
+      const melody = new Tone.Synth({
+        oscillator: { type: "triangle" },
+        envelope: { attack: 0.005, decay: 0.3, sustain: 0.15, release: 0.6 },
+        volume: 0
+      }).connect(melodyGain);
+
+      // --- BASS — warm sine, root notes only ---
+      const bassGain = new Tone.Gain(0.55).connect(masterGain);
+      const bass = new Tone.Synth({
+        oscillator: { type: "sine" },
+        envelope: { attack: 0.04, decay: 0.15, sustain: 0.6, release: 0.4 },
+        volume: 0
+      }).connect(bassGain);
+
+      // --- BRUSHED SNARE — barely there, just rhythm shape ---
+      const brushVerb = new Tone.Reverb({ decay: 0.6, wet: 0.3 }).connect(masterGain);
+      await brushVerb.ready;
+      const brushGain = new Tone.Gain(0.12).connect(brushVerb);
+      const brush = new Tone.NoiseSynth({
+        noise: { type: "white" },
+        envelope: { attack: 0.01, decay: 0.08, sustain: 0, release: 0.04 }
+      }).connect(brushGain);
+
+      // --- TRAVIS PICKING — 4-bar G–C–D–Em loop ---
+      // Each bar: thumb on root/5th (low notes), finger on upper chord tones
+      // 8th note grid: bass note, chord tone, bass note, chord tone...
+      const pickingPattern = [
+        // Bar 0: G major — G2(thumb), B3(finger), D2(thumb-5th), G3(finger)...
+        ["0:0:0","G2"], ["0:0:2","B3"], ["0:1:0","D2"], ["0:1:2","G3"],
+        ["0:2:0","G2"], ["0:2:2","D3"], ["0:3:0","D2"], ["0:3:2","B3"],
+        // Bar 1: C major — C2(thumb), E3(finger), G2(thumb-5th), C3(finger)...
+        ["1:0:0","C2"], ["1:0:2","E3"], ["1:1:0","G2"], ["1:1:2","C3"],
+        ["1:2:0","C2"], ["1:2:2","G3"], ["1:3:0","G2"], ["1:3:2","E3"],
+        // Bar 2: D major — D2(thumb), F#3(finger), A2(thumb-5th), D3(finger)...
+        ["2:0:0","D2"], ["2:0:2","F#3"], ["2:1:0","A2"], ["2:1:2","D3"],
+        ["2:2:0","D2"], ["2:2:2","A3"],  ["2:3:0","A2"], ["2:3:2","F#3"],
+        // Bar 3: E minor — E2(thumb), G3(finger), B2(thumb-5th), E3(finger)...
+        ["3:0:0","E2"], ["3:0:2","G3"], ["3:1:0","B2"], ["3:1:2","E3"],
+        ["3:2:0","E2"], ["3:2:2","B3"], ["3:3:0","B2"], ["3:3:2","G3"],
+      ];
+      const pickPart = new Tone.Part((time, note) => {
+        guitar.triggerAttackRelease(note, "8n", time);
+      }, pickingPattern);
+      pickPart.loopEnd = "4m";
+      pickPart.loop = true;
+      pickPart.start(0);
+
+      // --- BASS — root on beat 1 of each bar, enters bar 2 ---
+      const bassPart = new Tone.Part((time, note) => {
+        bass.triggerAttackRelease(note, "2n", time);
+      }, [
+        ["0:0:0","G2"],
+        ["1:0:0","C2"],
+        ["2:0:0","D2"],
+        ["3:0:0","E2"],
+      ]);
+      bassPart.loopEnd = "4m";
+      bassPart.loop = true;
+      bassPart.start("1m"); // bass enters bar 2
+
+      // --- MELODY — simple diatonic line over the chord progression, enters bar 3 ---
+      const melodyNotes = [
+        // Over G: D4 – B3 – G3 – A3
+        { time: "0:0:0", note: "D4", dur: "4n" },
+        { time: "0:1:0", note: "B3", dur: "4n" },
+        { time: "0:2:0", note: "G3", dur: "4n" },
+        { time: "0:3:0", note: "A3", dur: "4n" },
+        // Over C: G3 – E3 – C4 – D4
+        { time: "1:0:0", note: "G3", dur: "4n" },
+        { time: "1:1:0", note: "E3", dur: "4n" },
+        { time: "1:2:0", note: "C4", dur: "2n" },
+        // Over D: D4 – F#3 – A3 – G3
+        { time: "2:0:0", note: "D4", dur: "4n" },
+        { time: "2:1:0", note: "F#3", dur: "4n" },
+        { time: "2:2:0", note: "A3", dur: "4n" },
+        { time: "2:3:0", note: "G3", dur: "4n" },
+        // Over Em: E3 – G3 – B3 – G3
+        { time: "3:0:0", note: "E3", dur: "4n" },
+        { time: "3:1:0", note: "G3", dur: "4n" },
+        { time: "3:2:0", note: "B3", dur: "2n" },
+      ];
+      const melodyPart = new Tone.Part((time, val) => {
+        melody.triggerAttackRelease(val.note, val.dur, time);
+      }, melodyNotes.map(({ time, note, dur }) => [time, { note, dur }]));
+      melodyPart.loopEnd = "4m";
+      melodyPart.loop = true;
+      melodyPart.start("2m"); // melody enters bar 3
+
+      // --- BRUSHED SNARE — beats 2 and 4, very quiet, enters bar 3 ---
+      const brushSeq = new Tone.Sequence((time, val) => {
+        if (val) brush.triggerAttackRelease("8n", time);
+      }, [null,null,null,null,1,null,null,null,null,null,null,null,1,null,null,null], "16n");
+      brushSeq.start("2m");
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-funk/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: audio-funk
+description: Funk — slap bass, brass stabs, 16th-note hi-hats, syncopated groove that snaps
+---
+
+# TuneFrames — Funk
+
+## Genre Profile
+- BPM range: 95–115 (the pocket lives around 100–108)
+- Key characteristics: Syncopated 16th-note grid, everything lands on or anticipates the beat, brass stabs on upbeats, rhythm guitar "chank" on the "and" of 2 and 4, bass owns the low end
+- Typical instruments: Slap bass (Synth with fast attack + filter), brass stabs (PolySynth sawtooth, sharp envelope), rhythm guitar (PolySynth pluck), kick (MembraneSynth), tight snare (NoiseSynth), 16th hi-hats (MetalSynth)
+- Mood: Infectious, locked-in, body-moving, celebratory — James Brown, Parliament, Daft Punk, Vulfpeck
+
+## Core Pattern
+
+```js
+// Funk core: 104 BPM, E minor groove
+async function main() {
+  await Tone.start();
+  Tone.Transport.bpm.value = 104;
+
+  const s16 = Tone.Time('16n').toSeconds(); // one 16th note
+  const q   = Tone.Time('4n').toSeconds();  // one beat
+
+  const dest = new Tone.Gain(1).toDestination();
+  const comp = new Tone.Compressor(-18, 4).connect(dest);
+
+  // ── Slap bass ────────────────────────────────────────────────────────
+  const bass = new Tone.Synth({
+    oscillator: { type: 'square' },
+    envelope: { attack: 0.001, decay: 0.08, sustain: 0.0, release: 0.05 }
+  }).connect(comp);
+  bass.volume.value = -6;
+
+  // Classic one-bar funk bass: E on 1, ghost note 16th early, pop on e2-and
+  const bassLine = [
+    { note: 'E2',  time: 0 },
+    { note: 'E2',  time: s16 * 2 },
+    { note: 'G2',  time: s16 * 3 },
+    { note: 'E2',  time: s16 * 4 },
+    { note: 'A2',  time: s16 * 6 },
+    { note: 'E2',  time: s16 * 8 },
+    { note: 'D2',  time: s16 * 10 },
+    { note: 'E2',  time: s16 * 12 },
+    { note: 'G2',  time: s16 * 14 },
+  ];
+  bassLine.forEach(({ note, time }) => bass.triggerAttackRelease(note, '16n', time));
+
+  // ── Brass stabs (upbeat hits — "and" of 2 and 4) ──────────────────────
+  const brass = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'sawtooth' },
+    envelope: { attack: 0.005, decay: 0.12, sustain: 0.0, release: 0.08 }
+  }).connect(comp);
+  brass.volume.value = -12;
+
+  // Stab on the "and" of beat 2 (s16*9) and "and" of beat 4 (s16*13)
+  brass.triggerAttackRelease(['E4','G4','B4'], '16n', s16 * 9);
+  brass.triggerAttackRelease(['E4','G4','B4'], '16n', s16 * 13);
+
+  // ── Tight kick ────────────────────────────────────────────────────────
+  const kick = new Tone.MembraneSynth({
+    pitchDecay: 0.04, octaves: 6,
+    envelope: { attack: 0.001, decay: 0.25, sustain: 0, release: 0.1 }
+  }).connect(dest);
+  kick.volume.value = -10;
+  kick.triggerAttackRelease('C1', '8n', 0);       // beat 1
+  kick.triggerAttackRelease('C1', '8n', s16 * 10); // beat 2-and-a (syncopated)
+
+  // ── Snare on 3 ────────────────────────────────────────────────────────
+  const snare = new Tone.NoiseSynth({
+    noise: { type: 'white' },
+    envelope: { attack: 0.001, decay: 0.1, sustain: 0, release: 0.05 }
+  }).connect(new Tone.Filter(3500, 'bandpass').connect(dest));
+  snare.volume.value = -14;
+  snare.triggerAttackRelease('8n', s16 * 8); // beat 3
+
+  // ── 16th hi-hats ─────────────────────────────────────────────────────
+  const hat = new Tone.MetalSynth({
+    frequency: 600, harmonicity: 5.1, modulationIndex: 32,
+    resonance: 4000, octaves: 1.5,
+    envelope: { attack: 0.001, decay: 0.03, release: 0.01 }
+  }).connect(dest);
+  hat.volume.value = -20;
+  for (let i = 0; i < 16; i++) hat.triggerAttackRelease('32n', i * s16);
+}
+```
+
+## Instrument Configuration
+
+```js
+// Slap bass — square wave, nearly no sustain (percussive pluck feel)
+const bass = new Tone.Synth({
+  oscillator: { type: 'square' },
+  envelope: { attack: 0.001, decay: 0.08, sustain: 0.0, release: 0.05 }
+});
+
+// Rhythm guitar "chank" — bright pluck, bandpass filtered, chord stab
+const guitar = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.003, decay: 0.15, sustain: 0.0, release: 0.08 }
+});
+const guitarFilter = new Tone.Filter(2500, 'bandpass');
+guitar.connect(guitarFilter);
+
+// Brass stabs — sawtooth, instant attack, very short decay (punchy, no tail)
+const brass = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.005, decay: 0.12, sustain: 0.0, release: 0.08 }
+});
+
+// Bus compressor glues everything together (the "pumping" funk feel)
+const comp = new Tone.Compressor({ threshold: -18, ratio: 4, attack: 0.003, release: 0.1 });
+comp.toDestination();
+// Route everything through comp
+[bass, brass, guitar].forEach(s => s.connect(comp));
+```
+
+## Composition Structure
+
+1. **Intro (0–2s):** Bass alone on the groove, just root and fifth — establish the pocket
+2. **Drums in (2–4s):** Kick + snare + 16th hats lock with the bass
+3. **Full band (4–8s):** Brass stabs enter on upbeats, guitar chank fills the midrange
+4. **Breakdown (8–10s):** Strip to bass + kick only — tension before the re-hit
+5. **Re-hit (10–12s):** Everything back, maybe add a filter sweep on the bass up
+
+## Example Variations
+
+### 1 — Open hi-hat accent on beat 4
+```js
+const openHat = new Tone.MetalSynth({ envelope: { decay: 0.25 } }).connect(dest);
+openHat.volume.value = -18;
+openHat.triggerAttackRelease('8n', q * 3); // beat 4 open
+```
+
+### 2 — Wah filter on brass (auto-wah effect)
+```js
+const autoWah = new Tone.AutoFilter({ frequency: 4, baseFrequency: 200, octaves: 4, wet: 0.8 });
+autoWah.connect(dest);
+autoWah.start(0);
+brass.connect(autoWah);
+```
+
+### 3 — Daft Punk-style filtered house funk
+```js
+// Add LP filter sweep on the bass from 300 Hz to 2000 Hz over 4 bars
+const bassFilter = new Tone.Filter(300, 'lowpass').connect(comp);
+bass.connect(bassFilter);
+bassFilter.frequency.rampTo(2000, bar * 4);
+```