tuneframes 0.1.1 → 0.2.0

package/skills/audio-downtempo/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: audio-downtempo
+description: Downtempo / Trip-Hop — dark cinematic groove, Portishead/Massive Attack vibes, breakbeat swing, vinyl texture, sub bass
+---
+
+# TuneFrames — Downtempo / Trip-Hop
+
+## Genre Profile
+- BPM range: 70-90 (always swung — 16th notes have a lazy late feel)
+- Key characteristics: heavy breakbeat (kick NOT on every beat — syncopated), vinyl noise texture, sub bass movement on root notes, eerie/minor melodic line, gritty filter on everything
+- Typical instruments: MembraneSynth kick, NoiseSynth snare + crackle, MonoSynth sub bass with lowpass filter, AMSynth for eerie melody, BitCrusher for lo-fi grit
+- Mood: gritty, hypnotic, paranoid, late-night cinematic
+
+## Core Pattern
+
+```js
+// Trip-hop breakbeat — NOT four-on-the-floor
+// Kick: 0, 3, 5 (in 8ths) — heavy, off-balance feel
+// Snare: 2, 6 (on 2 and 4 but swung)
+// BPM = 82, swung feel via manual timing offsets
+Tone.Transport.bpm.value = 82;
+
+// Lo-fi grit filter
+const bitCrusher = new Tone.BitCrusher(6).toDestination();
+const reverb = new Tone.Reverb({ decay: 4.0, wet: 0.6 });
+reverb.toDestination();
+const filter = new Tone.Filter({ frequency: 2000, type: 'lowpass', rolloff: -24 });
+filter.connect(reverb);
+
+// Sub bass — the backbone
+const bass = new Tone.MonoSynth({
+  oscillator: { type: 'sine' },
+  filter: { Q: 2, frequency: 120, type: 'lowpass' },
+  envelope: { attack: 0.02, decay: 0.3, sustain: 0.6, release: 0.4 },
+  volume: -4,
+}).toDestination();
+
+// Eerie melody — AMSynth gives that trembling quality
+const melody = new Tone.AMSynth({
+  harmonicity: 2.5,
+  envelope: { attack: 0.15, decay: 0.5, sustain: 0.3, release: 1.0 },
+  volume: -12,
+});
+melody.connect(filter);
+
+// Breakbeat kick — syncopated
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.08, octaves: 10,
+  envelope: { attack: 0.001, decay: 0.5, sustain: 0, release: 0.1 },
+  volume: -2,
+}).toDestination();
+
+// Schedule kick on syncopated positions (seconds at 82 BPM, 1 beat = ~0.73s)
+// Pattern over 2 bars (~5.85s): kick on beat 1, the "and" of 2, beat 3.5
+const beatLen = 60 / 82;
+[0, beatLen * 1.5, beatLen * 3, beatLen * 4, beatLen * 5.5, beatLen * 7].forEach(t => {
+  Tone.Transport.scheduleOnce(time => kick.triggerAttackRelease('C1', '8n', time), t);
+});
+```
+
+## Instrument Configuration
+
+```js
+// BitCrusher — vinyl artifact simulation
+const bitCrusher = new Tone.BitCrusher(7); // lower = grittier
+bitCrusher.toDestination();
+
+// Dark reverb
+const reverb = new Tone.Reverb({ decay: 5.0, preDelay: 0.03, wet: 0.65 });
+await reverb.generate();
+reverb.toDestination();
+
+// Vinyl crackle — pink noise at very low volume, always running
+const crackle = new Tone.NoiseSynth({
+  noise: { type: 'pink' },
+  envelope: { attack: 0.1, decay: 0.1, sustain: 1.0, release: 0.1 },
+  volume: -32,
+}).toDestination();
+crackle.triggerAttack(); // sustain forever
+
+// Sub bass — pure sine, filtered hard
+const bass = new Tone.MonoSynth({
+  oscillator: { type: 'sine' },
+  filter: { Q: 3, frequency: 100, type: 'lowpass', rolloff: -24 },
+  filterEnvelope: { attack: 0.05, decay: 0.5, sustain: 0.3, release: 0.8, baseFrequency: 60, octaves: 1.5 },
+  envelope: { attack: 0.02, decay: 0.2, sustain: 0.6, release: 0.5 },
+  volume: -3,
+}).toDestination();
+
+// Eerie lead — AMSynth with tremolo-like modulation
+const lead = new Tone.AMSynth({
+  harmonicity: 3,
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.2, decay: 0.8, sustain: 0.4, release: 2.0 },
+  modulation: { type: 'sine' },
+  modulationEnvelope: { attack: 0.5, decay: 0.0, sustain: 1.0, release: 0.5 },
+  volume: -14,
+}).connect(reverb);
+
+// Heavy kick
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.1, octaves: 12,
+  envelope: { attack: 0.001, decay: 0.6, sustain: 0, release: 0.15 },
+  volume: -1,
+}).toDestination();
+
+// Snare — layered noise (pink for body, white for crack)
+const snare = new Tone.NoiseSynth({
+  noise: { type: 'pink' },
+  envelope: { attack: 0.001, decay: 0.18, sustain: 0, release: 0.12 },
+  volume: -8,
+}).toDestination();
+```
+
+## Composition Structure
+
+1. **Crackle intro (0-2s):** Vinyl crackle only — establishes grit and atmosphere.
+2. **Bass enters (2-4s):** Sub bass plays the root. No other elements yet. Heavy.
+3. **Beat drop (4-6s):** Kick + snare syncopated breakbeat joins. Still just bass + beat.
+4. **Melody (6-12s):** AMSynth eerie melody over the groove. Should feel like it doesn't quite fit — that's correct.
+5. **Full loop (12s+):** All elements. Melody repeats with slight variation.
+
+**Bass movement (minor feel):**
+- Root: D2 → A2 → F2 → G2 (4 beats each)
+- Melody follows but at half speed — slower, more ominous
+
+## Example Variations
+
+### Variation 1: Pure Portishead (drum + bass only)
+```js
+// No melody — just kick, snare, bass, crackle
+// Bass line has more movement: D2 → C2 → Bb1 → A1 (descending chromatic minor)
+// Snare gets a slight BitCrusher: bitCrusher.connect(snare output)
+// This is the most "hip-hop foundation" version
+```
+
+### Variation 2: Cinematic (add string texture)
+```js
+// PolySynth triangle wave simulating strings
+// Very long attack: 3.0s, release: 4.0s
+// Notes: Dm chord sustaining throughout (D3, F3, A3)
+// Volume: -20 — barely audible shimmer behind the groove
+```
+
+### Variation 3: Faster / more aggressive
+```js
+Tone.Transport.bpm.value = 92;
+// BitCrusher lower: 5 (crunchier)
+// Kick volume: 0 (0dB — very present)
+// Add 16th hi-hats at -24dB just for texture
+// Lead melody shorter notes: 0.1s decay instead of 0.8s
+```

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>