tuneframes 0.1.0 → 0.2.0

package/skills/audio-ambient/example.html

@@ -0,0 +1,113 @@
+<div id="tuneframes" style="display:none">{"bpm":60,"duration":"14s"}</div>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+<script>
+// TuneFrames — Ambient (Brian Eno style)
+// D minor drone pads, massive reverb, slow evolving pitch movement
+// No percussion. Everything breathes.
+
+async function main() {
+  await Tone.start();
+
+  Tone.Transport.bpm.value = 60;
+
+  // ── Effects chain ──────────────────────────────────────────────────────────
+  const reverb = new Tone.Reverb({ decay: 10, preDelay: 0.05, wet: 0.88 });
+  await reverb.generate();
+  reverb.toDestination();
+
+  const delay = new Tone.FeedbackDelay({ delayTime: 0.5, feedback: 0.42, wet: 0.32 });
+  delay.connect(reverb);
+
+  // ── Primary drone — sine wave, very slow attack ────────────────────────────
+  const drone = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'sine' },
+    envelope: { attack: 4.5, decay: 2.0, sustain: 0.9, release: 7.0 },
+    volume: -8,
+  });
+  drone.connect(delay);
+
+  // ── Shimmer layer — triangle, even slower, upper register ─────────────────
+  const shimmer = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 5.0, decay: 1.5, sustain: 0.75, release: 6.0 },
+    volume: -17,
+  });
+  shimmer.connect(reverb);
+
+  // ── Sub drone — anchors the bass register ─────────────────────────────────
+  const sub = new Tone.Synth({
+    oscillator: { type: 'sine' },
+    envelope: { attack: 6.0, decay: 3.0, sustain: 0.9, release: 8.0 },
+    volume: -13,
+  });
+  sub.connect(reverb);
+
+  // ── Schedule drone tones — D minor: D F A C ───────────────────────────────
+  // Staggered so they don't all attack at once — the overlapping sustains
+  // create the "chord cloud" that defines ambient music.
+  // Note durations use seconds (6, 5, etc.) so the 4.5–6s attacks can fully
+  // develop before release. '8n' (0.5s at 60 BPM) is far too short.
+
+  // Root drone: enters immediately, fades in over 4.5 seconds
+  Tone.Transport.scheduleOnce((t) => {
+    drone.triggerAttackRelease(['D3', 'A3'], 6, t);
+  }, 0);
+
+  // Fifth enters at 1.5s — builds on the drone
+  Tone.Transport.scheduleOnce((t) => {
+    drone.triggerAttackRelease(['F3', 'C4'], 6, t);
+  }, 1.5);
+
+  // Color tone — minor 7th adds bittersweet quality
+  Tone.Transport.scheduleOnce((t) => {
+    drone.triggerAttackRelease(['E3', 'G3'], 5, t);
+  }, 3.5);
+
+  // Second wave — new chord cloud begins overlapping the first
+  Tone.Transport.scheduleOnce((t) => {
+    drone.triggerAttackRelease(['D3', 'F3'], 5, t);
+  }, 6.0);
+
+  Tone.Transport.scheduleOnce((t) => {
+    drone.triggerAttackRelease(['A3', 'C4'], 4, t);
+  }, 8.0);
+
+  // ── Shimmer tones — upper harmonics ───────────────────────────────────────
+  Tone.Transport.scheduleOnce((t) => {
+    shimmer.triggerAttackRelease(['F5', 'A5'], 5, t);
+  }, 2.0);
+
+  Tone.Transport.scheduleOnce((t) => {
+    shimmer.triggerAttackRelease(['D5', 'C5'], 5, t);
+  }, 5.5);
+
+  Tone.Transport.scheduleOnce((t) => {
+    shimmer.triggerAttackRelease(['E5', 'G5'], 4, t);
+  }, 9.0);
+
+  // ── Sub bass — single low D, fades in and holds ───────────────────────────
+  Tone.Transport.scheduleOnce((t) => {
+    sub.triggerAttackRelease('D2', 7, t);
+  }, 0.5);
+
+  // NOTE: do NOT call Tone.Transport.start() here — Tone.Offline manages
+  // transport internally. Calling it manually breaks offline rendering.
+}
+
+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.0;
+
+  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-boss-battle/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: audio-boss-battle
+description: Video Game Boss Battle — driving 16th-note bass ostinato, power chord stabs on offbeats, heroic AMSynth brass melody, tuned timpani hits, fast counter-arpeggio. Final Fantasy / Nobuo Uematsu epic orchestral-hybrid energy.
+---
+
+# TuneFrames — Video Game Boss Battle
+
+## Genre Profile
+- BPM range: 150–185 (intense, relentless forward drive)
+- Key characteristics: Bass ostinato hammering the root in 16th notes (MonoSynth sawtooth), power chord stabs on offbeats (PolySynth square/sawtooth, short decay), heroic lead melody (AMSynth with sawtooth + sine modulation for brass-like tone), tuned timpani accents (MembraneSynth pitched to D1/A1), fast ascending counter-arpeggio for tension, driving kick pattern
+- Typical instruments: MonoSynth (bass ostinato), PolySynth (power chords), AMSynth (brass melody), MembraneSynth × 2 (kick + timpani), PolySynth (counter arpeggio)
+- Mood: Intense, epic, driving, heroic, desperate, high-stakes
+
+## Core Pattern
+
+```js
+// Boss Battle — 165 BPM, D minor
+// Bars 1–2: bass ostinato alone (ominous)
+// Bars 3–4: power chord stabs on offbeats
+// Bars 5–8: full: melody + counter arpeggio + drums
+
+Tone.Transport.bpm.value = 165;
+
+// Bass ostinato — driving 16th note figure around D root
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 3, type: "lowpass", rolloff: -24 },
+  filterEnvelope: { attack: 0.001, decay: 0.1, sustain: 0.5, release: 0.2,
+                    baseFrequency: 80, octaves: 2 },
+  envelope: { attack: 0.001, decay: 0.1, sustain: 0.7, release: 0.1 },
+  volume: -4
+}).toDestination();
+
+// 16th-note ostinato: D root hammered with neighbor-note movement
+const bassLine = [
+  "D2","D2","F2","D2",  "G2","D2","F2","E2",
+  "D2","D2","F2","D2",  "G2","F2","Eb2","D2"
+];
+let bassStep = 0;
+new Tone.Sequence((time) => {
+  bass.triggerAttackRelease(bassLine[bassStep++ % bassLine.length], "16n", time);
+}, new Array(16).fill(1), "16n").start(0);
+
+// Power chord stabs — PolySynth on the "and" of beats 1 and 3
+const stabChords = [["D3","A3"],["F3","C4"],["G3","D4"],["Bb3","F4"]];
+let stabStep = 0;
+new Tone.Sequence((time, val) => {
+  if (val) stabs.triggerAttackRelease(stabChords[stabStep++ % stabChords.length], "16n", time);
+}, [null,null,1,null,null,null,null,null,null,null,1,null,null,null,null,null], "16n").start("2m");
+
+// Heroic AMSynth melody — D minor ascending/descending
+const melody = [
+  { time: "4m", note: "D4", dur: "4n" }, { time: "4m:1", note: "F4", dur: "4n" },
+  { time: "4m:2", note: "A4", dur: "4n" }, { time: "4m:3", note: "C5", dur: "4n" },
+  { time: "5m", note: "Bb4", dur: "4n" }, { time: "5m:1", note: "A4", dur: "4n" },
+  { time: "5m:2", note: "G4", dur: "2n" },
+];
+melody.forEach(({ time, note, dur }) => brass.triggerAttackRelease(note, dur, time));
+
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Bass ostinato — sawtooth through lowpass filter for growl
+const bassVerb = new Tone.Reverb({ decay: 0.4, wet: 0.1 }).toDestination();
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 3, type: "lowpass", rolloff: -24 },
+  filterEnvelope: { attack: 0.001, decay: 0.1, sustain: 0.5, release: 0.2,
+                    baseFrequency: 80, octaves: 2 },
+  envelope: { attack: 0.001, decay: 0.1, sustain: 0.7, release: 0.1 },
+  volume: -4
+}).connect(bassVerb);
+
+// Power chord stabs — square wave, very short decay, punchy
+const stabReverb = new Tone.Reverb({ decay: 0.6, wet: 0.2 }).toDestination();
+const stabs = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "square" },
+  envelope: { attack: 0.001, decay: 0.12, sustain: 0.0, release: 0.08 },
+  volume: -8
+}).connect(stabReverb);
+
+// AMSynth brass melody — sawtooth carrier + sine AM creates "blat" of brass
+const brassVerb = new Tone.Reverb({ decay: 1.5, wet: 0.3 }).toDestination();
+const brass = new Tone.AMSynth({
+  oscillator: { type: "sawtooth" },
+  envelope: { attack: 0.04, decay: 0.1, sustain: 0.85, release: 0.4 },
+  modulation: { type: "sine" },
+  modulationEnvelope: { attack: 0.5, decay: 0, sustain: 1, release: 0.5 },
+  harmonicity: 1,
+  volume: -8
+}).connect(brassVerb);
+
+// Timpani — MembraneSynth pitched low, longer decay than kick
+const timpsVerb = new Tone.Reverb({ decay: 1.2, wet: 0.35 }).toDestination();
+const timps = new Tone.MembraneSynth({
+  pitchDecay: 0.2,
+  octaves: 4,
+  envelope: { attack: 0.001, decay: 0.6, sustain: 0, release: 0.3 },
+  volume: -4
+}).connect(timpsVerb);
+
+// Kick — driving, 8th or 16th note pattern
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.06, octaves: 8,
+  envelope: { attack: 0.001, decay: 0.28, sustain: 0, release: 0.08 },
+  volume: 0
+}).toDestination();
+
+// Counter arpeggio — fast 16th note ascent, adds tension
+const arpVerb = new Tone.Reverb({ decay: 0.8, wet: 0.25 }).toDestination();
+const arpSynth = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "sawtooth4" },
+  envelope: { attack: 0.001, decay: 0.08, sustain: 0, release: 0.1 },
+  volume: -14
+}).connect(arpVerb);
+```
+
+## Composition Structure
+
+- **Bars 1–2:** Bass ostinato only — ominous, low, relentless (the enemy approaches)
+- **Bars 3–4:** Timpani accents on bar downbeats, power chord stabs on offbeats (tension escalates)
+- **Bars 5–6:** Kick + snare enter, driving rhythm locked in, counter arpeggio begins
+- **Bars 7–10:** Full arrangement — AMSynth brass melody soars over the groove
+- **Bar 11–12:** Climax: all elements together, melody at highest pitch, bass most active
+- **Buildup trick:** Use `Tone.Transport.bpm.linearRampTo(180, "+4m")` to gradually accelerate into the final bars
+
+Harmonic vocabulary: D natural minor (D E F G A Bb C). Tritone sub on beat 3 (Ab) adds danger. Perfect 5th power chords [root, 5th] — no thirds — are the "8-bit" signature.
+
+## Example Variations
+
+### 1 — Faster bass (triplet feel, more chaotic)
+```js
+// 8th note triplets instead of 16ths — more chaotic, less locked-in
+const tripletBass = ["D2","F2","A2","G2","F2","D2"];
+let step = 0;
+new Tone.Sequence((time) => {
+  bass.triggerAttackRelease(tripletBass[step++ % tripletBass.length], "8t", time);
+}, new Array(6).fill(1), "8t").start(0);
+```
+
+### 2 — Tempo acceleration (building to a climax)
+```js
+// Slowly push the BPM from 160 to 185 over 8 bars
+const startTime = Tone.Time("4m").toSeconds();
+Tone.Transport.bpm.setValueAtTime(160, startTime);
+Tone.Transport.bpm.linearRampToValueAtTime(185, startTime + Tone.Time("4m").toSeconds());
+```
+
+### 3 — Minor key shift mid-battle (F minor for boss phase 2)
+```js
+// After 8 bars, shift to F minor: F G Ab Bb C Db Eb
+// Retrigger stab chords and melody with new root
+const phase2Chords = [["F3","C4"],["Ab3","Eb4"],["Bb3","F4"],["Db4","Ab4"]];
+```

package/skills/audio-boss-battle/example.html

@@ -0,0 +1,185 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Boss Battle</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":165,"duration":"12s","genre":"boss-battle","key":"D minor"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 165;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain = new Tone.Gain(0.8).connect(masterLimiter);
+
+      // --- BASS OSTINATO — driving 16th notes, sawtooth growl ---
+      const bassVerb = new Tone.Reverb({ decay: 0.4, wet: 0.1 }).connect(masterGain);
+      const bassGain = new Tone.Gain(0.75).connect(bassVerb);
+      const bass = new Tone.MonoSynth({
+        oscillator: { type: "sawtooth" },
+        filter: { Q: 3, type: "lowpass", rolloff: -24 },
+        filterEnvelope: {
+          attack: 0.001, decay: 0.1, sustain: 0.5, release: 0.2,
+          baseFrequency: 80, octaves: 2
+        },
+        envelope: { attack: 0.001, decay: 0.1, sustain: 0.7, release: 0.1 },
+        volume: -2
+      }).connect(bassGain);
+
+      // --- POWER CHORD STABS — square wave, very punchy ---
+      const stabReverb = new Tone.Reverb({ decay: 0.6, wet: 0.22 }).connect(masterGain);
+      const stabGain = new Tone.Gain(0.5).connect(stabReverb);
+      const stabs = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "square" },
+        envelope: { attack: 0.001, decay: 0.12, sustain: 0.0, release: 0.08 },
+        volume: 0
+      }).connect(stabGain);
+
+      // --- BRASS MELODY — AMSynth: sawtooth + sine AM = heroic blat ---
+      const brassVerb = new Tone.Reverb({ decay: 1.5, wet: 0.3 }).connect(masterGain);
+      const brassGain = new Tone.Gain(0.55).connect(brassVerb);
+      const brass = new Tone.AMSynth({
+        oscillator: { type: "sawtooth" },
+        envelope: { attack: 0.04, decay: 0.1, sustain: 0.85, release: 0.4 },
+        modulation: { type: "sine" },
+        modulationEnvelope: { attack: 0.5, decay: 0, sustain: 1, release: 0.5 },
+        harmonicity: 1,
+        volume: 0
+      }).connect(brassGain);
+
+      // --- TIMPANI — low-tuned MembraneSynth, long decay ---
+      const timpsVerb = new Tone.Reverb({ decay: 1.2, wet: 0.35 }).connect(masterGain);
+      const timpsGain = new Tone.Gain(0.65).connect(timpsVerb);
+      const timps = new Tone.MembraneSynth({
+        pitchDecay: 0.2,
+        octaves: 4,
+        envelope: { attack: 0.001, decay: 0.6, sustain: 0, release: 0.3 }
+      }).connect(timpsGain);
+
+      // --- KICK — hard, driving ---
+      const kickGain = new Tone.Gain(0.9).connect(masterGain);
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.06,
+        octaves: 8,
+        envelope: { attack: 0.001, decay: 0.28, sustain: 0, release: 0.08 }
+      }).connect(kickGain);
+
+      // --- SNARE — sharp crack ---
+      const snareVerb = new Tone.Reverb({ decay: 0.5, wet: 0.3 }).connect(masterGain);
+      const snareGain = new Tone.Gain(0.48).connect(snareVerb);
+      const snare = new Tone.NoiseSynth({
+        noise: { type: "white" },
+        envelope: { attack: 0.001, decay: 0.1, sustain: 0, release: 0.04 }
+      }).connect(snareGain);
+
+      // --- COUNTER ARPEGGIO — fast ascending D minor runs ---
+      const arpVerb = new Tone.Reverb({ decay: 0.8, wet: 0.25 }).connect(masterGain);
+      const arpGain = new Tone.Gain(0.3).connect(arpVerb);
+      const arpSynth = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "sawtooth4" },
+        envelope: { attack: 0.001, decay: 0.08, sustain: 0, release: 0.1 },
+        volume: 0
+      }).connect(arpGain);
+
+      // --- PATTERNS ---
+
+      // Bass ostinato: 16th-note D minor figure with neighbor movement (from bar 1)
+      const bassLine = [
+        "D2","D2","F2","D2", "G2","D2","F2","E2",
+        "D2","D2","F2","D2", "G2","F2","Eb2","D2"
+      ];
+      let bassStep = 0;
+      const bassSeq = new Tone.Sequence((time) => {
+        bass.triggerAttackRelease(bassLine[bassStep % bassLine.length], "16n", time);
+        bassStep++;
+      }, new Array(16).fill(1), "16n");
+      bassSeq.start(0);
+
+      // Timpani: D1 on bar 1, A1 on beat 3, D1 on bar 3 — enters bar 2
+      // Use bars:beats:sixteenths (0-indexed) to avoid mixed-notation parsing errors.
+      const timpsHits = [
+        { time: "1:0:0",  note: "D1" },
+        { time: "1:2:0",  note: "A1" },
+        { time: "2:0:0",  note: "D1" },
+        { time: "2:2:0",  note: "A1" },
+        { time: "3:0:0",  note: "D1" },
+        { time: "3:2:0",  note: "A1" },
+        { time: "4:0:0",  note: "D1" },
+        { time: "5:0:0",  note: "D1" },
+        { time: "6:0:0",  note: "D1" },
+        { time: "7:0:0",  note: "D1" },
+      ];
+      timpsHits.forEach(({ time, note }) => {
+        timps.triggerAttackRelease(note, "4n", time);
+      });
+
+      // Power chord stabs: cycling Dm–F–G–Bb on offbeats, enters bar 3
+      const stabChords = [["D3","A3"], ["F3","C4"], ["G3","D4"], ["Bb3","F4"]];
+      let stabStep = 0;
+      const stabSeq = new Tone.Sequence((time, val) => {
+        if (val) {
+          stabs.triggerAttackRelease(stabChords[stabStep % stabChords.length], "16n", time);
+          stabStep++;
+        }
+      }, [null,null,1,null,null,null,null,null,null,null,1,null,null,null,null,null], "16n");
+      stabSeq.start("2m");
+
+      // Kick: driving 8th notes, enters bar 3
+      const kickSeq = new Tone.Sequence((time, val) => {
+        if (val) kick.triggerAttackRelease("C1", "8n", time);
+      }, ["C1",null,null,null,"C1",null,null,null,"C1",null,null,null,"C1",null,null,null], "16n");
+      kickSeq.start("2m");
+
+      // Snare: beats 2 and 4, enters bar 3
+      const snareSeq = new Tone.Sequence((time, val) => {
+        if (val) snare.triggerAttackRelease("8n", time);
+      }, [null,null,null,null,1,null,null,null,null,null,null,null,1,null,null,null], "16n");
+      snareSeq.start("2m");
+
+      // Counter arpeggio: D minor ascending 16th runs (D F A C, repeat), enters bar 5
+      const arpNotes = ["D4","F4","A4","C5","A4","F4","D4","F4",
+                        "D4","F4","A4","C5","D5","C5","A4","F4"];
+      let arpStep = 0;
+      const arpSeq = new Tone.Sequence((time) => {
+        arpSynth.triggerAttackRelease(arpNotes[arpStep % arpNotes.length], "16n", time);
+        arpStep++;
+      }, new Array(16).fill(1), "16n");
+      arpSeq.start("4m");
+
+      // Heroic brass melody: D minor scale, ascending then descending, enters bar 5
+      const melodyNotes = [
+        // Bar 4: D ascending triad + 7th
+        { time: "4:0:0", note: "D4", dur: "4n" },
+        { time: "4:1:0", note: "F4", dur: "4n" },
+        { time: "4:2:0", note: "A4", dur: "4n" },
+        { time: "4:3:0", note: "C5", dur: "4n" },
+        // Bar 5: descend
+        { time: "5:0:0", note: "Bb4", dur: "4n" },
+        { time: "5:1:0", note: "A4",  dur: "4n" },
+        { time: "5:2:0", note: "G4",  dur: "2n" },
+        // Bar 6: climb again, higher
+        { time: "6:0:0", note: "A4",  dur: "4n" },
+        { time: "6:1:0", note: "C5",  dur: "4n" },
+        { time: "6:2:0", note: "D5",  dur: "4n" },
+        { time: "6:3:0", note: "F5",  dur: "4n" },
+        // Bar 7: final resolve
+        { time: "7:0:0", note: "Eb5", dur: "4n" },
+        { time: "7:1:0", note: "D5",  dur: "4n" },
+        { time: "7:2:0", note: "A4",  dur: "2n" },
+      ];
+      melodyNotes.forEach(({ time, note, dur }) => {
+        brass.triggerAttackRelease(note, dur, time);
+      });
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-chillwave/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: audio-chillwave
+description: Chillwave / Retrowave — hazy 80s nostalgia, dreamy arpeggio over gated drum machine, warm chorus + delay, minor chords
+---
+
+# TuneFrames — Chillwave / Retrowave
+
+## Genre Profile
+- BPM range: 90-110 (laid back, never rushed)
+- Key characteristics: minor key arpeggios, 80s drum machine pattern (four-on-the-floor kick, clap on 2/4, 16th hi-hats), chorus on synths, slight ping-pong delay, tape-saturated warmth
+- Typical instruments: PolySynth (sawtooth with chorus), NoiseSynth hi-hats, MembraneSynth kick, FMSynth for clap texture
+- Mood: nostalgic, washed-out, sun-bleached, driving at 2am
+
+## Core Pattern
+
+```js
+// Chillwave core: minor arpeggio over 80s drum machine
+// Key = A minor, BPM = 98
+Tone.Transport.bpm.value = 98;
+
+// Warm chorus on all melodic synths
+const chorus = new Tone.Chorus({ frequency: 1.5, delayTime: 3.5, depth: 0.7, wet: 0.6 });
+chorus.start(); // Chorus must be started manually
+const reverb = new Tone.Reverb({ decay: 3.5, wet: 0.55 });
+const delay = new Tone.FeedbackDelay({ delayTime: '8n.', feedback: 0.35, wet: 0.4 });
+reverb.toDestination();
+delay.connect(reverb);
+chorus.connect(delay);
+
+// Main arpeggio synth — the neon heartbeat
+const arp = new Tone.Synth({
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.02, decay: 0.15, sustain: 0.3, release: 0.5 },
+  volume: -8,
+});
+arp.connect(chorus);
+
+// A minor arpeggio pattern: Am - F - C - G
+const arpNotes = ['A4','C5','E5','A5', 'F4','A4','C5','F5', 'C4','E4','G4','C5', 'G4','B4','D5','G5'];
+let arpIdx = 0;
+new Tone.Sequence((time) => {
+  arp.triggerAttackRelease(arpNotes[arpIdx % arpNotes.length], '16n', time);
+  arpIdx++;
+}, [null], '16n').start(0);
+// ^ Simpler: use scheduleRepeat or explicit schedule below
+```
+
+## Instrument Configuration
+
+```js
+// Chorus — the defining warmth of chillwave
+const chorus = new Tone.Chorus({ frequency: 1.5, delayTime: 3.5, depth: 0.7, wet: 0.6 }).start();
+
+// Tape-style reverb
+const reverb = new Tone.Reverb({ decay: 3.0, preDelay: 0.02, wet: 0.5 });
+await reverb.generate();
+
+// Slapback-style delay (dotted 8th = that 80s bounce)
+const delay = new Tone.FeedbackDelay({ delayTime: '8n.', feedback: 0.3, wet: 0.38 });
+
+// Signal chain: arp → chorus → delay → reverb → destination
+reverb.toDestination();
+delay.connect(reverb);
+chorus.connect(delay);
+
+// Arpeggio synth — sawtooth for that retrowave shimmer
+const arp = new Tone.Synth({
+  oscillator: { type: 'sawtooth' },
+  envelope: { attack: 0.01, decay: 0.1, sustain: 0.25, release: 0.4 },
+  volume: -6,
+});
+arp.connect(chorus);
+
+// Pad behind the arp — PolySynth with longer attack
+const pad = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.6, decay: 0.5, sustain: 0.7, release: 2.0 },
+  volume: -16,
+});
+pad.connect(reverb);
+
+// Kick — punchy 4-on-the-floor
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.06, octaves: 8,
+  envelope: { attack: 0.001, decay: 0.35, sustain: 0, release: 0.1 },
+  volume: -4,
+}).toDestination();
+
+// Hi-hats — 16th-note machine pattern, slightly gated
+const hihat = new Tone.NoiseSynth({
+  noise: { type: 'white' },
+  envelope: { attack: 0.001, decay: 0.04, sustain: 0, release: 0.01 },
+  volume: -16,
+}).toDestination();
+
+// Clap — pink noise, sits on 2 and 4
+const clap = new Tone.NoiseSynth({
+  noise: { type: 'pink' },
+  envelope: { attack: 0.001, decay: 0.12, sustain: 0, release: 0.08 },
+  volume: -10,
+}).toDestination();
+```
+
+## Composition Structure
+
+1. **Intro (0-2s):** Arp enters alone — no drums yet. Establishes the hazy tone.
+2. **Drop-in (2-4s):** Kick and hi-hat join. Clap enters on 2 and 4.
+3. **Full loop (4-12s):** All elements running. Pad adds chord warmth behind the arp.
+4. **Variation (optional):** Drop the kick for 2 bars, let the arp breathe.
+
+**Chord cycle (4 chords, each 1 bar):**
+- Am → F → C → G (classic 80s nostalgia loop)
+- Em → C → G → D (brighter alternative)
+- Dm → Bb → F → C (darker, more melancholic)
+
+## Example Variations
+
+### Variation 1: Slower / dreamier
+```js
+Tone.Transport.bpm.value = 88;
+// Longer attack on arp: 0.04
+// Chorus depth: 0.85, wet: 0.7
+// Reverb decay: 5.0 — more smear
+// Drop hi-hats to 8th notes instead of 16th
+```
+
+### Variation 2: More synthwave, less chill
+```js
+Tone.Transport.bpm.value = 108;
+// Square oscillator instead of sawtooth
+// Add a bass line: MonoSynth root notes, sawtooth, lowpass filter at 400hz
+// Kick volume up: -2
+// Less reverb: 0.3 wet
+```
+
+### Variation 3: Pure pads (no drums)
+```js
+// Just the chord pad + arp, massive chorus + reverb
+// Pad attack: 2.0s, release: 4.0s
+// This is the most "chill" direction — remove percussion entirely
+// Use a second delayed arp an octave higher for shimmer
+```