tuneframes 0.1.1 → 0.2.0

package/skills/audio-hip-hop/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: audio-hip-hop
+description: Boom Bap Hip Hop — punchy kick, snare on 2 and 4 with reverb tail, shuffled 16th hi-hats with swing, smooth bass line, warm soul-pad. Pete Rock / J Dilla / Madlib head-nod groove.
+---
+
+# TuneFrames — Boom Bap Hip Hop
+
+## Genre Profile
+- BPM range: 80–95 (slow enough to feel heavy)
+- Key characteristics: Heavy kick with short distortion (MembraneSynth), snare strictly on beats 2 and 4 with long reverb tail, 16th-note hi-hats with Tone.Transport swing (0.4–0.6) for the shuffle, smooth chromatic bass line, warm pad chord with slow attack for "sampled soul" texture
+- Typical instruments: MembraneSynth (kick), NoiseSynth (snare), MetalSynth or NoiseSynth (hat), MonoSynth or Synth (bass), PolySynth (pad)
+- Mood: Head-nodding, soulful, heavy, hypnotic, dusty
+
+## Core Pattern
+
+```js
+// Boom Bap — 88 BPM, F minor, 2-bar loop
+// Swing makes this: 16th hat offbeats push back into shuffle territory
+// Kick: beat 1 + syncopated ghost hit | Snare: beats 2 and 4 | Hat: 16ths shuffled
+
+Tone.Transport.bpm.value = 88;
+Tone.Transport.swing = 0.5;           // full swing — offbeat 16ths pushed back
+Tone.Transport.swingSubdivision = "16n";
+
+// Kick: beat 1, "and" of beat 2, beat 3 (classic boom bap syncopation)
+new Tone.Sequence((time, val) => {
+  if (val) kick.triggerAttackRelease("C1", "8n", time);
+}, ["C1",null,null,null,null,null,"C1",null,"C1",null,null,null,null,null,null,null], "16n").start(0);
+//   beat1              and-of-2             beat3
+
+// Snare: strictly 2 and 4
+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").start(0);
+
+// Hi-hat: all 16ths with alternating velocity — swing does the shuffle work
+const hatVels = [0.9,0.45,0.85,0.4,0.9,0.45,0.85,0.4,0.9,0.45,0.9,0.4,0.85,0.45,0.9,0.45];
+let hatStep = 0;
+new Tone.Sequence((time) => {
+  hat.triggerAttackRelease("16n", time, hatVels[hatStep++ % 16]);
+}, new Array(16).fill(1), "16n").start(0);
+
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Kick — MembraneSynth with slight saturation (the "punchy" sound)
+const kickDist = new Tone.Distortion({ distortion: 0.2, wet: 0.4 }).toDestination();
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.07,
+  octaves: 6,
+  envelope: { attack: 0.001, decay: 0.32, sustain: 0, release: 0.1 },
+  volume: 0
+}).connect(kickDist);
+
+// Snare — white noise with a long reverb tail (the "room" sound)
+const snareVerb = new Tone.Reverb({ decay: 1.8, wet: 0.5 }).toDestination();
+const snare = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.2, sustain: 0, release: 0.06 },
+  volume: -4
+}).connect(snareVerb);
+
+// Hi-hat — crisp, short, metallic
+const hat = new Tone.MetalSynth({
+  frequency: 500,
+  envelope: { attack: 0.001, decay: 0.04, release: 0.01 },
+  harmonicity: 5.1,
+  modulationIndex: 24,
+  resonance: 4000,
+  octaves: 1.2,
+  volume: -12
+}).toDestination();
+
+// Bass — MonoSynth, smooth but defined
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 2, type: "lowpass", rolloff: -12 },
+  filterEnvelope: { attack: 0.01, decay: 0.2, sustain: 0.4, release: 0.3,
+                    baseFrequency: 120, octaves: 1.5 },
+  envelope: { attack: 0.01, decay: 0.15, sustain: 0.7, release: 0.3 },
+  volume: -4
+}).toDestination();
+
+// Soul pad — warm PolySynth, slow attack = "reverse sample" texture
+const padVerb = new Tone.Reverb({ decay: 3.5, wet: 0.5 }).toDestination();
+const pad = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.6, decay: 0.5, sustain: 0.7, release: 2.0 },
+  volume: -14
+}).connect(padVerb);
+```
+
+## Composition Structure
+
+- **Bar 1:** Kick + snare + hat only — establish the swung groove, feel the shuffle
+- **Bars 2–4:** Add bass — smooth line following Fm → Cm → Bb → Eb
+- **Bars 5–8:** Add soul pad — Fm7 chord with slow attack, warm
+- **Bars 9–16:** Full groove — all elements, occasionally double the kick for variation
+- **Half-time bar:** Every 4–8 bars, simplify to kick on beat 1 only — creates space then snaps back
+
+Dilla technique: vary the kick pattern slightly each 2 bars instead of looping the exact same hit positions. Use a step counter to swap between two kick pattern arrays.
+
+## Example Variations
+
+### 1 — "Dilla" floating kick (pattern alternates every 2 bars)
+```js
+const kickPatterns = [
+  ["C1",null,null,null,null,null,"C1",null,"C1",null,null,null,null,null,null,null],
+  ["C1",null,null,null,null,null,null,null,"C1",null,"C1",null,null,null,null,null],
+];
+let bar = 0;
+new Tone.Sequence((time, val) => {
+  if (val) kick.triggerAttackRelease("C1", "8n", time);
+}, kickPatterns[Math.floor(bar++ / 16) % 2], "16n").start(0);
+```
+
+### 2 — Swing amount variation (lighter shuffle)
+```js
+// 0.3 = light shuffle (more "straight"), 0.5 = full triplet swing, 0.15 = barely swung
+Tone.Transport.swing = 0.35; // Pete Rock feel — noticeable but not extreme
+```
+
+### 3 — Open hi-hat accent on beat 4
+```js
+// Add an open hi-hat (longer decay) on step 12 for groove
+const openHat = new Tone.MetalSynth({ ...hat options..., envelope: { decay: 0.18 } }).toDestination();
+const openHatSeq = new Tone.Sequence((time, val) => {
+  if (val) openHat.triggerAttackRelease("8n", time, 0.7);
+}, [null,null,null,null,null,null,null,null,null,null,null,null,1,null,null,null], "16n").start(0);
+```

package/skills/audio-hip-hop/example.html

@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Boom Bap Hip Hop</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+</head>
+<body>
+  <!-- TuneFrames Metadata — must be JSON textContent, not data attributes -->
+  <div id="tuneframes" style="display:none">{"bpm":88,"duration":"12s"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+
+      // Set BPM so Tone.Time string values resolve correctly
+      Tone.Transport.bpm.value = 88;
+
+      const beat = Tone.Time("4n").toSeconds(); // ~0.682s at 88 BPM
+      const s16  = beat / 4;                    // 16th note ~0.170s
+      const bar  = beat * 4;                    // 1 bar ~2.727s
+      const numBars = 4;                        // 4 bars ~10.9s (fits in 12s)
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain    = new Tone.Gain(0.82).connect(masterLimiter);
+
+      // --- KICK — punchy MembraneSynth ---
+      const kickDist = new Tone.Distortion({ distortion: 0.2, wet: 0.4 }).connect(masterGain);
+      const kickGain = new Tone.Gain(0.88).connect(kickDist);
+      const kick     = new Tone.MembraneSynth({
+        pitchDecay: 0.07,
+        octaves: 6,
+        envelope: { attack: 0.001, decay: 0.32, sustain: 0, release: 0.1 }
+      }).connect(kickGain);
+
+      // --- SNARE — white noise with reverb tail ---
+      const snareVerb = new Tone.Reverb({ decay: 1.8, wet: 0.5 }).connect(masterGain);
+      const snareGain = new Tone.Gain(0.52).connect(snareVerb);
+      const snare     = new Tone.NoiseSynth({
+        noise: { type: "white" },
+        envelope: { attack: 0.001, decay: 0.2, sustain: 0, release: 0.06 }
+      }).connect(snareGain);
+
+      // --- HI-HAT — MetalSynth, short and crisp ---
+      const hatGain = new Tone.Gain(0.28).connect(masterGain);
+      const hat     = new Tone.MetalSynth({
+        frequency: 500,
+        envelope: { attack: 0.001, decay: 0.04, release: 0.01 },
+        harmonicity: 5.1,
+        modulationIndex: 24,
+        resonance: 4000,
+        octaves: 1.2
+      }).connect(hatGain);
+
+      // --- BASS — MonoSynth with filter envelope ---
+      const bassGain = new Tone.Gain(0.7).connect(masterGain);
+      const bass     = new Tone.MonoSynth({
+        oscillator: { type: "sawtooth" },
+        filter: { Q: 2, type: "lowpass", rolloff: -12 },
+        filterEnvelope: {
+          attack: 0.01, decay: 0.2, sustain: 0.4, release: 0.3,
+          baseFrequency: 120, octaves: 1.5
+        },
+        envelope: { attack: 0.01, decay: 0.15, sustain: 0.7, release: 0.3 }
+      }).connect(bassGain);
+
+      // --- SOUL PAD — warm PolySynth, slow attack ---
+      const padVerb = new Tone.Reverb({ decay: 3.5, wet: 0.5 }).connect(masterGain);
+      const padGain = new Tone.Gain(0.35).connect(padVerb);
+      const pad     = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "triangle" },
+        envelope: { attack: 0.6, decay: 0.5, sustain: 0.7, release: 2.0 }
+      }).connect(padGain);
+
+      // --- KICK PATTERN — beat 1, "and" of 2, beat 3 (classic boom bap) ---
+      // 16-step grid: positions 0, 6, 8
+      for (let b = 0; b < numBars; b++) {
+        [0, 6, 8].forEach(step => {
+          kick.triggerAttackRelease("C1", beat * 0.5, b * bar + step * s16);
+        });
+      }
+
+      // --- SNARE — strictly beats 2 and 4 (steps 4 and 12) ---
+      for (let b = 0; b < numBars; b++) {
+        [4, 12].forEach(step => {
+          snare.triggerAttackRelease(beat * 0.5, b * bar + step * s16);
+        });
+      }
+
+      // --- HI-HAT — all 16 steps per bar, velocity variation adds humanity ---
+      const hatVels = [0.9,0.45,0.85,0.4,0.9,0.45,0.85,0.4,0.9,0.45,0.9,0.4,0.85,0.45,0.9,0.45];
+      for (let b = 0; b < numBars; b++) {
+        for (let s = 0; s < 16; s++) {
+          hat.triggerAttackRelease(s16 * 0.8, b * bar + s * s16, hatVels[s]);
+        }
+      }
+
+      // --- BASS LINE — Fm vamp: 2-bar phrase played twice ---
+      // phrase repeats at bars 0-1 and bars 2-3
+      const bassPhrase = [
+        { step: 0,  note: "F1",  dur: beat },
+        { step: 4,  note: "F1",  dur: beat * 0.5 },
+        { step: 6,  note: "C2",  dur: beat * 0.5 },
+        { step: 8,  note: "Eb2", dur: beat * 0.5 },
+        { step: 10, note: "D2",  dur: beat * 0.5 },
+        { step: 12, note: "C2",  dur: beat },
+        { step: 16, note: "Bb1", dur: beat },
+        { step: 20, note: "Bb1", dur: beat * 0.5 },
+        { step: 22, note: "F1",  dur: beat * 0.5 },
+        { step: 24, note: "Ab1", dur: beat * 0.5 },
+        { step: 26, note: "G1",  dur: beat * 0.5 },
+        { step: 28, note: "F1",  dur: beat },
+      ];
+      for (let phrase = 0; phrase < 2; phrase++) {
+        bassPhrase.forEach(({ step, note, dur }) => {
+          bass.triggerAttackRelease(note, dur, phrase * 2 * bar + step * s16);
+        });
+      }
+
+      // --- SOUL PAD — Fm7 bars 0-1, Bbm7 bars 2-3 ---
+      pad.triggerAttackRelease(["F3","Ab3","C4","Eb4"],  bar * 2, 0);
+      pad.triggerAttackRelease(["Bb2","Db3","F3","Ab3"], bar * 2, bar * 2);
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-house/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: audio-house
+description: Chicago/deep house — 4-on-the-floor kick, clap on 2 and 4, off-beat hi-hat, warm piano chord stabs, bass following the kick. Groovy and soulful.
+---
+
+# TuneFrames — House
+
+## Genre Profile
+- BPM range: 120–128
+- Key characteristics: 4-on-the-floor kick, clap strictly on beats 2 and 4, off-beat open hi-hat on the "and" of every beat, warm chord stabs (7ths and 9ths), bass line locked to kick
+- Typical instruments: MembraneSynth (kick), NoiseSynth (clap), MetalSynth (hi-hat), PolySynth (piano stabs), MonoSynth (bass)
+- Mood: Warm, groovy, hypnotic, soulful, uplifting
+
+## Core Pattern
+
+```js
+// Chicago House — 4/4 at 124 BPM
+// Kick: every beat (1, 2, 3, 4)
+// Clap: beats 2 and 4
+// Hi-hat: off-beat 8th notes ("and" of each beat)
+// Piano stab: 2-bar chord loop with 7th chords
+// Bass: short punchy notes on kick hits + off-beat fills
+
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.05,
+  octaves: 6,
+  envelope: { attack: 0.001, decay: 0.3, sustain: 0, release: 0.1 }
+}).toDestination();
+
+const clap = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.12, sustain: 0, release: 0.05 }
+}).toDestination();
+
+// Reverb on clap — classic house sound
+const clapReverb = new Tone.Reverb({ decay: 2.5, wet: 0.55 }).toDestination();
+clap.connect(clapReverb);
+
+// 16-step kick: 4 on the floor
+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").start(0);
+
+// Clap on 2 and 4 (steps 4 and 12 in 16-step)
+new Tone.Sequence((time, val) => {
+  if (val) clap.triggerAttackRelease("16n", time);
+}, [null, null, null, null, 1, null, null, null,
+    null, null, null, null, 1, null, null, null], "16n").start(0);
+
+// Off-beat hi-hat (every other 8th note)
+new Tone.Sequence((time, val) => {
+  if (val) hat.triggerAttackRelease("16n", time, 0.6);
+}, [null, null, 1, null, null, null, 1, null,
+    null, null, 1, null, null, null, 1, null], "16n").start(0);
+
+Tone.Transport.bpm.value = 124;
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Kick — warm, slightly softer than techno
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.05,
+  octaves: 6,
+  volume: 0,
+  envelope: { attack: 0.001, decay: 0.28, sustain: 0, release: 0.1 }
+}).toDestination();
+
+// Clap — snappy noise with heavy reverb tail
+const clapVerb = new Tone.Reverb({ decay: 2.2, wet: 0.5 }).toDestination();
+const clap = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.1, sustain: 0, release: 0.04 },
+  volume: -4
+}).connect(clapVerb);
+
+// Hi-hat — open, airy metallic
+const hat = new Tone.MetalSynth({
+  frequency: 300, harmonicity: 3.1, modulationIndex: 16,
+  resonance: 3500, octaves: 1.2,
+  envelope: { attack: 0.001, decay: 0.08, release: 0.02 },
+  volume: -10
+}).toDestination();
+
+// Piano stab — warm PolySynth, major 7ths
+const stabChorus = new Tone.Chorus({ frequency: 3, depth: 0.4, wet: 0.3 }).toDestination();
+const stabVerb = new Tone.Reverb({ decay: 1.8, wet: 0.25 }).connect(stabChorus);
+const piano = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.01, decay: 0.4, sustain: 0.1, release: 0.6 },
+  volume: -8
+}).connect(stabVerb);
+
+// Bass — punchy MonoSynth, follows kick
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 2, type: "lowpass", frequency: 600 },
+  filterEnvelope: { attack: 0.001, decay: 0.15, sustain: 0.1, release: 0.2,
+                    baseFrequency: 100, octaves: 2 },
+  envelope: { attack: 0.001, decay: 0.2, sustain: 0.1, release: 0.15 },
+  volume: -4
+}).toDestination();
+```
+
+## Composition Structure
+
+- **Bar 1-2:** Kick + hi-hat only — establish 4-on-floor groove
+- **Bar 3-4:** Add clap on 2 and 4 — full drum feel
+- **Bar 5-8:** Add bass — follows kick with short punchy notes
+- **Bar 9-16:** Add piano stabs — 2-bar chord loop, minor 7ths or major 9ths
+- **Bar 17-24:** Full groove — all elements, maybe add a secondary hi-hat accent
+- **Breakdown (bar 25-32):** Drop kick and bass, keep hats + piano — build tension
+- **Drop:** Kick returns hard — full energy re-entry
+- **Outro:** Hi-hat fades, bass drops out, kick last
+
+Chord vocabulary (deep house): Fm7 (F-Ab-C-Eb), Bbm9, Ebmaj7, Dbmaj7. Use minor 7ths for darkness, major 7ths for warmth.
+
+## Example Variations
+
+### 1 — Swung 16ths (shuffle feel)
+```js
+// Apply shuffle to the Transport for a more "human" groove
+Tone.Transport.swing = 0.15;
+Tone.Transport.swingSubdivision = "16n";
+```
+
+### 2 — Rolling Bass (octave fills between kicks)
+```js
+// Bass hits on kick + fills in the gaps with octave jumps
+const bassPattern = [
+  { note: "A1", dur: "8n" }, { note: null },
+  { note: "A2", dur: "16n" }, { note: null }, // octave fill
+  { note: "A1", dur: "8n" }, { note: null },
+  { note: "A1", dur: "16n" }, { note: "G1", dur: "16n" } // chromatic approach
+];
+```
+
+### 3 — Piano Chord Stab Rhythm Variation
+```js
+// Syncopated stab — off the beat for groove
+// Hit on the "and" of beat 2 and beat 4
+const stabSteps = [null, null, null, null, null, 1, null, null,
+                   null, null, null, null, null, 1, null, null];
+```

package/skills/audio-house/example.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — House</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":124,"duration":"12s"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 124;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain = new Tone.Gain(0.88).connect(masterLimiter);
+
+      // --- KICK — warm 4-on-the-floor ---
+      const kickGain = new Tone.Gain(0.85).connect(masterGain);
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.055,
+        octaves: 6,
+        envelope: { attack: 0.001, decay: 0.28, sustain: 0, release: 0.1 }
+      }).connect(kickGain);
+
+      // --- CLAP — white noise with long reverb tail ---
+      const clapVerb = new Tone.Reverb({ decay: 2.4, wet: 0.52 }).connect(masterGain);
+      const clapGain = new Tone.Gain(0.55).connect(clapVerb);
+      const clap = new Tone.NoiseSynth({
+        noise: { type: "white" },
+        envelope: { attack: 0.001, decay: 0.11, sustain: 0, release: 0.04 }
+      }).connect(clapGain);
+
+      // --- HI-HAT — open off-beat, airy ---
+      const hatGain = new Tone.Gain(0.38).connect(masterGain);
+      const hat = new Tone.MetalSynth({
+        frequency: 300,
+        envelope: { attack: 0.001, decay: 0.09, release: 0.025 },
+        harmonicity: 3.1,
+        modulationIndex: 16,
+        resonance: 3600,
+        octaves: 1.2
+      }).connect(hatGain);
+
+      // --- PIANO STAB — PolySynth triangle, warm chord stabs ---
+      const stabVerb = new Tone.Reverb({ decay: 1.6, wet: 0.28 }).connect(masterGain);
+      const stabChorus = new Tone.Chorus({ frequency: 2.5, depth: 0.35, wet: 0.25 }).connect(stabVerb);
+      stabChorus.start();
+      const stabGain = new Tone.Gain(0.55).connect(stabChorus);
+      const piano = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "triangle" },
+        envelope: { attack: 0.008, decay: 0.35, sustain: 0.08, release: 0.7 },
+        volume: 0
+      }).connect(stabGain);
+
+      // --- BASS — punchy, follows kick ---
+      const bassGain = new Tone.Gain(0.75).connect(masterGain);
+      const bass = new Tone.MonoSynth({
+        oscillator: { type: "sawtooth" },
+        filter: { Q: 3, type: "lowpass", rolloff: -24 },
+        filterEnvelope: {
+          attack: 0.001, decay: 0.18, sustain: 0.1, release: 0.2,
+          baseFrequency: 90, octaves: 2.2
+        },
+        envelope: { attack: 0.001, decay: 0.22, sustain: 0.1, release: 0.15 },
+        volume: -2
+      }).connect(bassGain);
+
+      // --- SEQUENCES ---
+
+      // Kick: strict 4-on-the-floor
+      const kickSeq = new Tone.Sequence((time) => {
+        kick.triggerAttackRelease("C1", "8n", time);
+      }, [1, null, null, null, 1, null, null, null,
+          1, null, null, null, 1, null, null, null], "16n");
+      kickSeq.start(0);
+
+      // Clap: beats 2 and 4 only
+      const clapSeq = new Tone.Sequence((time, val) => {
+        if (val) clap.triggerAttackRelease("16n", time);
+      }, [null, null, null, null, 1, null, null, null,
+          null, null, null, null, 1, null, null, null], "16n");
+      clapSeq.start(0);
+
+      // Hi-hat: off-beat 8th notes
+      const hatSeq = new Tone.Sequence((time, val) => {
+        if (val) hat.triggerAttackRelease("16n", time, 0.6);
+      }, [null, null, 1, null, null, null, 1, null,
+          null, null, 1, null, null, null, 1, null], "16n");
+      hatSeq.start(0);
+
+      // Bass: follows kick + syncopated fills
+      // F1 root following the groove
+      const bassPattern = [
+        "F1", null, null, null, "F1", null, null, "F1",
+        "F1", null, "Ab1", null, "F1", null, "Eb1", null
+      ];
+      const bassSeq = new Tone.Sequence((time, note) => {
+        if (note) bass.triggerAttackRelease(note, "16n", time);
+      }, bassPattern, "16n");
+      bassSeq.start("2m"); // bass enters bar 3
+
+      // Piano stabs: Fm7 → Bbm7 → Ebmaj7 → Dbmaj7 (2-bar cycle)
+      // Deep house chord vocabulary
+      const chords = [
+        { notes: ["F3", "Ab3", "C4", "Eb4"], time: "4m" },      // Fm7
+        { notes: ["Bb2", "Db3", "F3", "Ab3"], time: "4m:2" },   // Bbm7
+        { notes: ["Eb3", "G3", "Bb3", "D4"], time: "5m" },      // Ebmaj7
+        { notes: ["Db3", "F3", "Ab3", "C4"], time: "5m:2" },    // Dbmaj7
+        // repeat
+        { notes: ["F3", "Ab3", "C4", "Eb4"], time: "6m" },
+        { notes: ["Bb2", "Db3", "F3", "Ab3"], time: "6m:2" },
+        { notes: ["Eb3", "G3", "Bb3", "D4"], time: "7m" },
+        { notes: ["Db3", "F3", "Ab3", "C4"], time: "7m:2" },
+      ];
+      chords.forEach(({ notes, time }) => {
+        piano.triggerAttackRelease(notes, "4n", time);
+      });
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-indie-pop/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: audio-indie-pop
+description: Indie Pop — jangly pluck arpeggios through chorus/reverb, warm bass, steady kick-snare-hat groove. Vampire Weekend / Tame Impala feel. Major key or Dorian, bright and infectious.
+---
+
+# TuneFrames — Indie Pop
+
+## Genre Profile
+- BPM range: 115–140
+- Key characteristics: Guitar-like arpeggio lines with short pluck envelope (triangle osc, fast decay, low sustain), warm bass on root and 5th, kick on beats 1+3, snare on 2+4, steady 8th-note hi-hat, lush chorus + reverb on guitar synth
+- Typical instruments: PolySynth/Synth (guitar pluck), Synth/MonoSynth (bass), MembraneSynth (kick), NoiseSynth (snare, hat)
+- Mood: Bright, infectious, slightly nostalgic, melodic, danceable
+
+## Core Pattern
+
+```js
+// Indie Pop — 128 BPM, G major
+// Chord progression: G - C - Em - D (4-bar loop)
+// Guitar: 8th note arpeggios with pluck envelope
+// Kick: beats 1 and 3 | Snare: beats 2 and 4 | Hat: 8th notes
+
+Tone.Transport.bpm.value = 128;
+
+// Effects
+const reverb = new Tone.Reverb({ decay: 2.5, wet: 0.3 }).toDestination();
+const chorus = new Tone.Chorus(3.5, 2.0, 0.6).connect(reverb);
+chorus.start(); // REQUIRED — Chorus LFO must be started manually
+
+// Guitar pluck: triangle oscillator, fast attack, short decay, minimal sustain
+const guitar = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.005, decay: 0.28, sustain: 0.06, release: 0.7 },
+}).connect(chorus);
+
+// 32-note arpeggio grid (8 notes × 4 bars = G, C, Em, D)
+const arpGrid = [
+  "G3","B3","D4","G4","D4","B3","G3","B3",  // G major
+  "C4","E4","G4","C5","G4","E4","C4","E4",  // C major
+  "E3","G3","B3","E4","B3","G3","E3","G3",  // E minor
+  "D3","F#3","A3","D4","A3","F#3","D3","F#3", // D major
+];
+let arpStep = 0;
+const arpSeq = new Tone.Sequence((time) => {
+  guitar.triggerAttackRelease(arpGrid[arpStep++ % arpGrid.length], "8n", time);
+}, new Array(8).fill(1), "8n").start(0);
+
+// Kick: beats 1 and 3
+new Tone.Sequence((time, val) => {
+  if (val) kick.triggerAttackRelease("C1", "8n", time);
+}, ["C1",null,null,null,null,null,null,null,"C1",null,null,null,null,null,null,null], "16n").start(0);
+
+// Snare: beats 2 and 4
+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").start(0);
+
+// Hat: 8th notes, quiet
+new Tone.Sequence((time, val) => {
+  if (val) hat.triggerAttackRelease("16n", time, 0.5);
+}, [1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null], "16n").start(0);
+
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Guitar pluck — triangle oscillator is key (warmer than sawtooth, brighter than sine)
+const guitarVerb = new Tone.Reverb({ decay: 2.5, wet: 0.3 }).toDestination();
+const guitarChorus = new Tone.Chorus({ frequency: 3.5, delayTime: 2, depth: 0.6, wet: 0.5 }).connect(guitarVerb);
+guitarChorus.start();
+const guitar = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "triangle" },
+  envelope: { attack: 0.005, decay: 0.28, sustain: 0.06, release: 0.7 },
+  volume: -8
+}).connect(guitarChorus);
+
+// Bass — sine oscillator for warmth, gentle attack
+const bassVerb = new Tone.Reverb({ decay: 0.6, wet: 0.1 }).toDestination();
+const bass = new Tone.Synth({
+  oscillator: { type: "sine" },
+  envelope: { attack: 0.05, decay: 0.2, sustain: 0.7, release: 0.4 },
+  volume: -4
+}).connect(bassVerb);
+
+// Kick — less aggressive than techno, shorter pitch decay
+const kickDist = new Tone.Distortion({ distortion: 0.1, wet: 0.3 }).toDestination();
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.06, octaves: 5,
+  envelope: { attack: 0.001, decay: 0.3, sustain: 0, release: 0.1 },
+  volume: -2
+}).connect(kickDist);
+
+// Snare — white noise, moderate reverb tail (less than house, more presence)
+const snareVerb = new Tone.Reverb({ decay: 0.8, wet: 0.35 }).toDestination();
+const snare = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.15, sustain: 0, release: 0.05 },
+  volume: -8
+}).connect(snareVerb);
+
+// Hi-hat — highpass filtered noise, quiet
+const hatFilter = new Tone.Filter(7000, "highpass").toDestination();
+const hat = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.05, sustain: 0, release: 0.01 },
+  volume: -16
+}).connect(hatFilter);
+```
+
+## Composition Structure
+
+- **Bars 1–2:** Guitar arpeggio + hi-hat only — establish the melodic hook
+- **Bars 3–4:** Add kick and snare — drums lock in the groove
+- **Bars 5–8:** Add bass — root + 5th pattern follows chord changes
+- **Bars 9–16:** Full band, all elements — the main verse/chorus loop
+- **Variation:** Add feedback delay on guitar (8th note, 25% wet) for extra spaciousness
+- **Outro:** Drop drums, let guitar arpeggio ring out with reverb tail
+
+Chord vocabulary: I–V–vi–IV in any major key (G–D–Em–C is the "axis of awesome"). Dorian mode (e.g., Am–G) adds darkness while keeping the bright groove.
+
+## Example Variations
+
+### 1 — Dorian Mode (darker, Am sound)
+```js
+// A Dorian: A B C D E F# G — common in Vampire Weekend
+const arpGrid = [
+  "A3","C4","E4","A4","E4","C4","A3","C4",  // Am
+  "G3","B3","D4","G4","D4","B3","G3","B3",  // G major
+  "D3","F#3","A3","D4","A3","F#3","D3","F#3", // D major
+  "E3","G3","B3","E4","B3","G3","E3","G3",  // Em
+];
+```
+
+### 2 — 16th-note arpeggio (Math rock / faster feel)
+```js
+// Double the arpeggio speed — 16 notes per bar instead of 8
+const arpGrid = ["G3","B3","D4","G4","D4","B3","G3","B3","D4","G4","B3","D4","G4","B3","D4","G4"]; // G bar
+let arpStep = 0;
+new Tone.Sequence((time) => {
+  guitar.triggerAttackRelease(arpGrid[arpStep++ % arpGrid.length], "16n", time);
+}, new Array(16).fill(1), "16n").start(0);
+```
+
+### 3 — Add feedback delay for shimmer
+```js
+// Guitar → delay → chorus → reverb
+const delay = new Tone.FeedbackDelay({ delayTime: "8n", feedback: 0.28, wet: 0.22 });
+// Insert: guitar.connect(delay); delay.connect(guitarChorus);
+```