tuneframes 0.1.0 → 0.2.0

package/skills/audio-r-and-b/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: audio-r-and-b
+description: R&B / Neo-Soul — lush extended chords, smooth Rhodes, laid-back syncopated groove
+---
+
+# TuneFrames — R&B / Neo-Soul
+
+## Genre Profile
+- BPM range: 70–95 (the groove breathes; never rushed)
+- Key characteristics: Extended chord voicings (min9, maj9, add9, 11ths), Rhodes/electric piano feel, laid-back beat placement (drums sit just behind the grid), syncopated bass that locks with the kick, gentle compression on everything
+- Typical instruments: Rhodes (PolySynth triangle), warm bass (Synth sine), soft kick (MembraneSynth), brush snare (NoiseSynth), 8th hi-hats with occasional 16th fills, optional synth pad underneath
+- Mood: Warm, sensual, introspective, polished — D'Angelo, H.E.R., Frank Ocean, Erykah Badu, Sade
+
+## Core Pattern
+
+```js
+// Neo-Soul core: 85 BPM, Fm9–Dbmaj9–Ab–Eb progression
+async function main() {
+  await Tone.start();
+  Tone.Transport.bpm.value = 85;
+
+  const bar = Tone.Time('1n').toSeconds();
+  const q   = Tone.Time('4n').toSeconds();
+  const s8  = Tone.Time('8n').toSeconds();
+
+  // ── Warm compression + reverb ─────────────────────────────────────────
+  const comp  = new Tone.Compressor({ threshold: -20, ratio: 3, attack: 0.01, release: 0.2 }).toDestination();
+  const reverb = new Tone.Reverb({ decay: 2.5, preDelay: 0.01, wet: 0.35 }).connect(comp);
+
+  // ── Rhodes — extended voicings ────────────────────────────────────────
+  const rhodes = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.03, decay: 0.5, sustain: 0.6, release: 2.0 }
+  }).connect(reverb);
+  rhodes.volume.value = -10;
+
+  // Fm9 – Dbmaj9 – Ab – Eb (rich neo-soul changes)
+  const chords = [
+    ['F3','Ab3','C4','Eb4','G4'],    // Fm9
+    ['Db3','F3','Ab3','C4','Eb4'],   // Dbmaj9
+    ['Ab2','C3','Eb3','G3'],         // Ab maj7
+    ['Eb3','G3','Bb3','D4'],         // Ebmaj7
+  ];
+  chords.forEach((ch, i) => rhodes.triggerAttackRelease(ch, '1n', i * bar));
+
+  // ── Syncopated bass ───────────────────────────────────────────────────
+  const bass = new Tone.Synth({
+    oscillator: { type: 'sine' },
+    envelope: { attack: 0.015, decay: 0.15, sustain: 0.5, release: 0.3 }
+  }).connect(comp);
+  bass.volume.value = -7;
+
+  // Root on 1, then syncopated hits — lands a 16th early on beat 3
+  const bassLine = [
+    { note: 'F2',  time: 0 },
+    { note: 'F2',  time: q * 1.75 },  // 16th before beat 3
+    { note: 'Eb2', time: q * 3 },
+  ];
+  bassLine.forEach(({ note, time }) => bass.triggerAttackRelease(note, '8n', time));
+}
+```
+
+## Instrument Configuration
+
+```js
+// Rhodes feel — triangle wave, moderate attack, long release
+const rhodes = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.03, decay: 0.5, sustain: 0.6, release: 2.0 }
+});
+
+// Warm bass — sine, slightly longer attack than funk (more laid-back)
+const bass = new Tone.Synth({
+  oscillator: { type: 'sine' },
+  envelope: { attack: 0.015, decay: 0.15, sustain: 0.5, release: 0.3 }
+});
+
+// Pad underneath — very slow attack, barely audible, adds warmth
+const pad = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'sine' },
+  envelope: { attack: 2.0, decay: 0.5, sustain: 0.8, release: 4.0 }
+});
+pad.volume.value = -22; // subtle, under everything
+
+// Chorus on the Rhodes for that electric piano shimmer
+const chorus = new Tone.Chorus({ frequency: 1.5, delayTime: 3.5, depth: 0.4, wet: 0.5 });
+chorus.start();
+
+// Gentle compression — glues without pumping
+const comp = new Tone.Compressor({ threshold: -20, ratio: 3, attack: 0.01, release: 0.2 });
+
+// Chain: rhodes → chorus → reverb → comp → destination
+const reverb = new Tone.Reverb({ decay: 2.5, wet: 0.35 });
+rhodes.connect(chorus);
+chorus.connect(reverb);
+reverb.connect(comp);
+comp.toDestination();
+```
+
+## Composition Structure
+
+1. **Intro (0–3s):** Rhodes alone with pad underneath — establish the lush harmonic world
+2. **Bass enters (3–6s):** Syncopated bass locks with the root, still no drums
+3. **Drums drop (6–9s):** Soft kick on 1 and 3, snare on 2 and 4, 8th hats — laid-back, never aggressive
+4. **Melody/hook (9–12s):** High Rhodes or separate synth carries a smooth melodic phrase
+5. **Outro:** Strip back to Rhodes + pad, let the chord voicings breathe and decay
+
+## Example Variations
+
+### 1 — D'Angelo "Voodoo" feel (heavy laid-back drums)
+```js
+// Drums sit 20ms behind the grid — schedule everything slightly late
+const LAG = 0.02; // seconds
+kick.triggerAttackRelease('C1', '8n', 0 + LAG);
+snare.triggerAttackRelease('8n', q + LAG);
+```
+
+### 2 — Sade-style sparse ballad (60 BPM, less is more)
+```js
+Tone.Transport.bpm.value = 60;
+// Just Rhodes + bass, no drums, add a gentle delay on the melody
+const delay = new Tone.FeedbackDelay({ delayTime: '4n', feedback: 0.2, wet: 0.25 }).connect(reverb);
+```
+
+### 3 — Neo-soul key change (drop a half-step on bar 3)
+```js
+// Modulate from Fm to Em for bar 3 — creates emotional lift/tension
+const chordsWithMod = [
+  ['F3','Ab3','C4','Eb4','G4'],   // Fm9
+  ['Db3','F3','Ab3','C4','Eb4'],  // Dbmaj9
+  ['E3','G3','B3','D4','F#4'],    // Em9 (half-step down = brighter surprise)
+  ['C3','E3','G3','B3'],          // Cmaj7
+];
+```

package/skills/audio-r-and-b/example.html

@@ -0,0 +1,154 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>TuneFrames — R&amp;B / Neo-Soul</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+</head>
+<body>
+  <div id="tuneframes" style="display:none">{"bpm":86,"duration":"12s"}</div>
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 86;
+
+      const bar = Tone.Time('1n').toSeconds(); // ~2.79s
+      const q   = Tone.Time('4n').toSeconds(); // ~0.698s
+      const s8  = Tone.Time('8n').toSeconds(); // ~0.349s
+      const s16 = Tone.Time('16n').toSeconds();
+
+      // ── Signal chain: everything → comp → destination ────────────────────
+      const comp   = new Tone.Compressor({ threshold: -20, ratio: 3, attack: 0.008, release: 0.18 }).toDestination();
+      const reverb = new Tone.Freeverb({ roomSize: 0.72, dampening: 3500, wet: 0.38 }).connect(comp);
+
+      // ── Pad underneath (barely audible warmth) ───────────────────────────
+      const pad = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: 'sine' },
+        envelope: { attack: 2.2, decay: 0.5, sustain: 0.85, release: 5.0 }
+      }).connect(reverb);
+      pad.volume.value = -24;
+
+      // Hold the tonic throughout
+      pad.triggerAttackRelease(['F2','C3','Eb3'], '2n', 0);
+      pad.triggerAttackRelease(['Db2','Ab2','C3'], '2n', bar);
+      pad.triggerAttackRelease(['Ab2','Eb3','G3'], '2n', bar * 2);
+      pad.triggerAttackRelease(['Eb2','Bb2','D3'], '2n', bar * 3);
+
+      // ── Rhodes — chorus shimmer + reverb ────────────────────────────────
+      const chorus = new Tone.Chorus({ frequency: 1.5, delayTime: 3.5, depth: 0.4, wet: 0.45 }).connect(reverb);
+      chorus.start();
+      const rhodes = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: 'triangle' },
+        envelope: { attack: 0.025, decay: 0.5, sustain: 0.62, release: 2.2 }
+      }).connect(chorus);
+      rhodes.volume.value = -9;
+
+      // Fm9 – Dbmaj9 – Abmaj7 – Ebmaj7 (4-bar loop × 2 passes + variation)
+      const changes = [
+        { chord: ['F3','Ab3','C4','Eb4','G4'],   time: 0          }, // Fm9
+        { chord: ['Db3','F3','Ab3','C4','Eb4'],  time: bar        }, // Dbmaj9
+        { chord: ['Ab2','Eb3','G3','C4'],        time: bar * 2    }, // Abmaj7
+        { chord: ['Eb3','G3','Bb3','D4'],        time: bar * 3    }, // Ebmaj7
+        // Second pass with richer upper voicing
+        { chord: ['F3','Ab3','C4','G4'],         time: bar * 4    }, // Fm add9
+        { chord: ['Db3','Ab3','C4','F4'],        time: bar * 4 + bar }, // Dbmaj9/Ab
+      ];
+      changes.forEach(({ chord, time }) => rhodes.triggerAttackRelease(chord, '1n', time));
+
+      // ── Warm syncopated bass ─────────────────────────────────────────────
+      const bass = new Tone.Synth({
+        oscillator: { type: 'sine' },
+        envelope: { attack: 0.014, decay: 0.18, sustain: 0.48, release: 0.28 }
+      }).connect(comp);
+      bass.volume.value = -5;
+
+      // Neo-soul bass: root on 1, anticipation (16th early) into beat 3, fill at end
+      const bassPattern = (root, fifth, t) => [
+        { note: root,  time: t                    }, // beat 1
+        { note: root,  time: t + q + s16          }, // "and-a" of beat 2 (anticipates 3)
+        { note: fifth, time: t + q * 2            }, // beat 3
+        { note: root,  time: t + q * 3 + s16 * 2 }, // syncopated fill before bar end
+      ];
+
+      [
+        ['F2',  'C3',  0        ],
+        ['Db2', 'Ab2', bar      ],
+        ['Ab1', 'Eb2', bar * 2  ],
+        ['Eb2', 'Bb2', bar * 3  ],
+        ['F2',  'C3',  bar * 4  ],
+        ['Db2', 'Ab2', bar * 4 + bar],
+      ].forEach(([root, fifth, t]) => {
+        bassPattern(root, fifth, t).forEach(({ note, time }) =>
+          bass.triggerAttackRelease(note, '8n', time));
+      });
+
+      // ── Kick (soft, beat 1 and 3) ────────────────────────────────────────
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.055, octaves: 5,
+        envelope: { attack: 0.001, decay: 0.35, sustain: 0, release: 0.3 }
+      }).connect(comp);
+      kick.volume.value = -14;
+
+      // Kicks enter on bar 2 (let Rhodes establish first)
+      for (let rep = 1; rep < 5; rep++) {
+        kick.triggerAttackRelease('C1', '8n', rep * bar);           // beat 1
+        kick.triggerAttackRelease('C1', '8n', rep * bar + q * 2);   // beat 3
+        // Syncopated ghost kick on the "and" of 4 every other bar
+        if (rep % 2 === 0) kick.triggerAttackRelease('C1', '8n', rep * bar + q * 3.5);
+      }
+
+      // ── Brush snare on 2 and 4 ──────────────────────────────────────────
+      const snareBp = new Tone.Filter(2600, 'bandpass').connect(reverb);
+      const snare   = new Tone.NoiseSynth({
+        noise: { type: 'white' },
+        envelope: { attack: 0.003, decay: 0.13, sustain: 0, release: 0.06 }
+      }).connect(snareBp);
+      snare.volume.value = -20;
+
+      for (let rep = 1; rep < 5; rep++) {
+        snare.triggerAttackRelease('8n', rep * bar + q);       // beat 2
+        snare.triggerAttackRelease('8n', rep * bar + q * 3);   // beat 4
+      }
+
+      // ── Hi-hats: 8ths with 16th fill before beat 3 ──────────────────────
+      const hat = new Tone.MetalSynth({
+        frequency: 500, harmonicity: 5.1, modulationIndex: 24,
+        resonance: 4000, octaves: 1.5,
+        envelope: { attack: 0.001, decay: 0.05, release: 0.01 }
+      }).connect(reverb);
+      hat.volume.value = -24;
+
+      for (let rep = 1; rep < 5; rep++) {
+        // Regular 8th notes
+        for (let i = 0; i < 8; i++) hat.triggerAttackRelease('16n', rep * bar + i * s8);
+        // 16th-note fill going into beat 3 (soul fill)
+        hat.triggerAttackRelease('16n', rep * bar + q * 2 - s16 * 2);
+        hat.triggerAttackRelease('16n', rep * bar + q * 2 - s16);
+      }
+
+      // ── Melody (enters bar 3) — smooth Rhodes phrase ─────────────────────
+      const melDelay = new Tone.FeedbackDelay({ delayTime: '8n', feedback: 0.18, wet: 0.22 }).connect(reverb);
+      const melody   = new Tone.Synth({
+        oscillator: { type: 'triangle' },
+        envelope: { attack: 0.04, decay: 0.35, sustain: 0.5, release: 1.5 }
+      }).connect(melDelay);
+      melody.volume.value = -13;
+
+      // Silky descending/ascending phrase — Fm pentatonic flavour
+      const phrase = [
+        { note: 'C5',  time: bar * 2,           dur: '8n'  },
+        { note: 'Ab4', time: bar * 2 + s8,      dur: '8n'  },
+        { note: 'G4',  time: bar * 2 + s8*2,    dur: '4n'  },
+        { note: 'Eb4', time: bar * 2 + s8*4,    dur: '8n'  },
+        { note: 'F4',  time: bar * 2 + s8*5,    dur: '4n.' },
+        { note: 'G4',  time: bar * 3 + q,       dur: '8n'  },
+        { note: 'Ab4', time: bar * 3 + q + s8,  dur: '8n'  },
+        { note: 'C5',  time: bar * 3 + q*2,     dur: '2n'  },
+        { note: 'Bb4', time: bar * 4 + s8,      dur: '4n'  },
+        { note: 'Ab4', time: bar * 4 + s8*3,    dur: '4n'  },
+        { note: 'G4',  time: bar * 4 + s8*5,    dur: '2n'  },
+      ];
+      phrase.forEach(({ note, time, dur }) => melody.triggerAttackRelease(note, dur, time));
+    }
+  </script>
+</body>
+</html>

package/skills/audio-techno/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: audio-techno
+description: Berlin-style techno — hard MembraneSynth kick, acid MonoSynth bass, industrial hi-hats, sparse stabs. Dark and mechanical.
+---
+
+# TuneFrames — Techno
+
+## Genre Profile
+- BPM range: 130–145
+- Key characteristics: Hard kick on every beat, relentless forward momentum, hypnotic repetition, industrial textures, minimal melody
+- Typical instruments: MembraneSynth (kick), MonoSynth (acid bass), MetalSynth or NoiseSynth (hi-hats), PolySynth (sparse stabs)
+- Mood: Dark, mechanical, hypnotic, relentless
+
+## Core Pattern
+
+```js
+// Berlin Techno — 4/4 at 136 BPM
+// Kick on every beat (4-on-the-floor)
+// Acid bass follows kick with filter sweep
+// Hi-hats: closed on 8ths, open on off-beats
+// Stabs: sparse, dissonant, 2-bar cycle
+
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.08,
+  octaves: 10,
+  envelope: { attack: 0.001, decay: 0.4, sustain: 0, release: 0.1 }
+}).toDestination();
+
+// Acid bass through distortion
+const dist = new Tone.Distortion(0.6).toDestination();
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 6, type: "lowpass", rolloff: -24 },
+  filterEnvelope: {
+    attack: 0.001, decay: 0.2, sustain: 0.3, release: 0.5,
+    baseFrequency: 80, octaves: 4
+  },
+  envelope: { attack: 0.001, decay: 0.3, sustain: 0.4, release: 0.2 }
+}).connect(dist);
+
+// Industrial closed hi-hat
+const hat = new Tone.MetalSynth({
+  frequency: 400, envelope: { attack: 0.001, decay: 0.04, release: 0.01 },
+  harmonicity: 5.1, modulationIndex: 32, resonance: 4000, octaves: 1.5
+}).toDestination();
+
+// Scheduling — 1-bar loop
+new Tone.Sequence((time, note) => {
+  kick.triggerAttackRelease("C1", "8n", time);
+}, ["C1", null, null, null, "C1", null, null, null,
+    "C1", null, null, null, "C1", null, null, null], "16n").start(0);
+
+new Tone.Sequence((time, note) => {
+  if (note) hat.triggerAttackRelease("16n", time, note);
+}, [0.7, 0.4, 0.7, 0.4, 0.7, 0.4, 0.9, 0.4,
+    0.7, 0.4, 0.7, 0.4, 0.7, 0.5, 0.9, 0.6], "16n").start(0);
+
+Tone.Transport.bpm.value = 136;
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Kick — punchy, sub-heavy membrane
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.06,
+  octaves: 10,
+  volume: 2,
+  envelope: { attack: 0.001, decay: 0.35, sustain: 0, release: 0.1 }
+}).toDestination();
+
+// Acid bass — sawtooth through distortion + filter
+const limiter = new Tone.Limiter(-3).toDestination();
+const dist = new Tone.Distortion({ distortion: 0.5, wet: 0.8 }).connect(limiter);
+const bass = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 8, type: "lowpass", rolloff: -24 },
+  filterEnvelope: {
+    attack: 0.002, decay: 0.3, sustain: 0.2, release: 0.6,
+    baseFrequency: 60, octaves: 3.5
+  },
+  envelope: { attack: 0.001, decay: 0.2, sustain: 0.5, release: 0.3 },
+  volume: -4
+}).connect(dist);
+
+// Hi-hat — metallic, tight
+const hat = new Tone.MetalSynth({
+  frequency: 380, harmonicity: 5.1, modulationIndex: 32,
+  resonance: 4000, octaves: 1.5,
+  envelope: { attack: 0.001, decay: 0.05, release: 0.01 },
+  volume: -8
+}).toDestination();
+
+// Stab — cold PolySynth, short decay
+const reverb = new Tone.Reverb({ decay: 1.5, wet: 0.3 }).toDestination();
+const stab = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "square" },
+  envelope: { attack: 0.001, decay: 0.15, sustain: 0, release: 0.1 },
+  volume: -10
+}).connect(reverb);
+```
+
+## Composition Structure
+
+- **Bar 1-2:** Kick only — establish the pulse
+- **Bar 3-4:** Add hi-hats — density builds
+- **Bar 5-8:** Add acid bass — filter opens over 4 bars (automation)
+- **Bar 9-16:** Full loop — kick + hats + bass + sparse stabs every 2 bars
+- **Bar 17+:** Variation — mute elements in/out for tension/release
+- **Breakdown:** Drop kick, keep hats, let bass filter sweep down — then kick re-enters hard
+- **Outro:** Strip back to kick only, fade hats
+
+Key technique: filter automation on the bass is the main expressive tool. Sweep `bass.filter.frequency` from 80Hz up to 2kHz over 8 bars, then drop back.
+
+## Example Variations
+
+### 1 — Stutter Kick (double kick on last 16th)
+```js
+// Standard 4-on-floor with double hit before the beat
+const kickPattern = ["C1", null, null, null, "C1", null, null, null,
+                     "C1", null, null, null, "C1", null, "C1", null];
+```
+
+### 2 — Acid Filter Sweep (automation)
+```js
+// Automate bass filter opening over 2 bars
+const now = Tone.now();
+bass.filter.frequency.setValueAtTime(80, now);
+bass.filter.frequency.linearRampToValueAtTime(3000, now + 4);
+bass.filter.frequency.linearRampToValueAtTime(120, now + 4.5);
+```
+
+### 3 — Ride + Open Hat Pattern
+```js
+// More complex hat pattern: closed-closed-open on the off
+const hatVelocities = [0.8, 0.3, 0.8, 0.3, 0.8, 0.3, 1.0, 0.2,
+                        0.8, 0.3, 0.8, 0.3, 0.8, 0.4, 1.0, 0.5];
+// Longer decay on accented hits for "open hat" feel
+```

package/skills/audio-techno/example.html

@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Techno</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":136,"duration":"12s"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 136;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain = new Tone.Gain(0.85).connect(masterLimiter);
+
+      // --- KICK — hard MembraneSynth ---
+      const kickGain = new Tone.Gain(0.9).connect(masterGain);
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.07,
+        octaves: 10,
+        envelope: { attack: 0.001, decay: 0.38, sustain: 0, release: 0.1 }
+      }).connect(kickGain);
+
+      // --- ACID BASS — MonoSynth sawtooth through distortion ---
+      const bassLimiter = new Tone.Limiter(-4).connect(masterGain);
+      const bassDist = new Tone.Distortion({ distortion: 0.55, wet: 0.7 }).connect(bassLimiter);
+      const bassFilter = new Tone.Filter({ frequency: 400, type: "lowpass", rolloff: -24, Q: 3 }).connect(bassDist);
+      const bass = new Tone.MonoSynth({
+        oscillator: { type: "sawtooth" },
+        filter: { Q: 7, type: "lowpass", rolloff: -24 },
+        filterEnvelope: {
+          attack: 0.002, decay: 0.25, sustain: 0.2, release: 0.5,
+          baseFrequency: 70, octaves: 3.5
+        },
+        envelope: { attack: 0.001, decay: 0.25, sustain: 0.5, release: 0.3 },
+        volume: -2
+      }).connect(bassFilter);
+
+      // --- HI-HAT — tight MetalSynth ---
+      const hatGain = new Tone.Gain(0.45).connect(masterGain);
+      const hat = new Tone.MetalSynth({
+        frequency: 400,
+        envelope: { attack: 0.001, decay: 0.045, release: 0.01 },
+        harmonicity: 5.1,
+        modulationIndex: 32,
+        resonance: 4200,
+        octaves: 1.5
+      }).connect(hatGain);
+
+      // --- STAB — sparse cold PolySynth ---
+      const stabReverb = new Tone.Reverb({ decay: 1.8, wet: 0.35 }).connect(masterGain);
+      const stab = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "square4" },
+        envelope: { attack: 0.001, decay: 0.12, sustain: 0, release: 0.08 },
+        volume: -14
+      }).connect(stabReverb);
+
+      // Stab chords — dissonant, industrial
+      const stabNotes = [["A2", "Eb3"], ["A2", "D3"], null, ["G2", "C#3"]];
+
+      // --- SEQUENCES ---
+
+      // Kick: 4-on-the-floor with ghost on bar 2 last 16th
+      const kickPattern = 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, "C1", null], "16n");
+      kickPattern.start(0);
+
+      // Hi-hat: 16th notes, velocity variation
+      let hatStep = 0;
+      const hatVels = [0.75, 0.35, 0.75, 0.35, 0.75, 0.35, 0.95, 0.35,
+                       0.75, 0.35, 0.75, 0.35, 0.75, 0.45, 0.95, 0.55];
+      const hatSeq = new Tone.Sequence((time) => {
+        hat.triggerAttackRelease("32n", time, hatVels[hatStep % 16]);
+        hatStep++;
+      }, new Array(16).fill(1), "16n");
+      hatSeq.start(0);
+
+      // Bass: acid pattern — A1 root with chromatic movement
+      const bassLine = [
+        { note: "A1", dur: "8n" }, { note: null },
+        { note: "A1", dur: "16n" }, { note: "A1", dur: "16n" },
+        { note: null }, { note: "C2", dur: "8n" },
+        { note: null }, { note: "A1", dur: "16n" },
+        { note: "A1", dur: "8n" }, { note: null },
+        { note: "Bb1", dur: "16n" }, { note: "A1", dur: "16n" },
+        { note: null }, { note: "G1", dur: "16n" },
+        { note: null }, { note: "A1", dur: "8n" }
+      ];
+      let bassStep = 0;
+      const bassSeq = new Tone.Sequence((time) => {
+        const step = bassLine[bassStep % bassLine.length];
+        if (step.note) bass.triggerAttackRelease(step.note, step.dur, time);
+        bassStep++;
+      }, new Array(16).fill(1), "16n");
+      bassSeq.start("2m"); // bass enters at bar 3
+
+      // Stabs: every 2 bars on beat 3
+      let stabStep = 0;
+      const stabSeq = new Tone.Sequence((time) => {
+        const chord = stabNotes[stabStep % stabNotes.length];
+        if (chord) stab.triggerAttackRelease(chord, "32n", time);
+        stabStep++;
+      }, [1, null, null, null, null, null, null, null], "2n");
+      stabSeq.start("4m"); // stabs enter at bar 5
+
+      // --- BASS FILTER SWEEP — signature acid movement ---
+      const sweepStart = Tone.Time("2m").toSeconds();
+      bassFilter.frequency.setValueAtTime(200, sweepStart);
+      bassFilter.frequency.linearRampToValueAtTime(2800, sweepStart + 4);
+      bassFilter.frequency.linearRampToValueAtTime(150, sweepStart + 4.5);
+      bassFilter.frequency.linearRampToValueAtTime(1800, sweepStart + 8);
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

package/skills/audio-trap/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: audio-trap
+description: Trap — 808 sub bass with pitch bend, snare on 2 and 4, rapid hi-hat rolls with velocity variation, sparse orchestral strings for drama.
+---
+
+# TuneFrames — Trap
+
+## Genre Profile
+- BPM range: 130–160 (half-time feel makes it sit like 65–80)
+- Key characteristics: 808 sub bass with long decay and downward pitch bend, snare on beats 2 and 4, hi-hat rolls in 16th/32nd triplets with strong velocity variation, heavy low end, atmospheric elements
+- Typical instruments: MembraneSynth (808 sub), NoiseSynth (snare), MetalSynth (hi-hats), PolySynth (strings/pads)
+- Mood: Menacing, cinematic, heavy, dramatic
+
+## Core Pattern
+
+```js
+// Trap — 140 BPM, half-time feel
+// 808: long decay sub with downward pitch glide
+// Snare: beat 2 and 4 (half-time = bars 1 and 3)
+// Hi-hats: rapid rolls, velocity builds and drops — the signature
+// Strings: sparse atmospheric chords
+
+// 808 sub — MembraneSynth with pitch envelope = signature glide
+const sub = new Tone.MembraneSynth({
+  pitchDecay: 0.5,       // long pitch glide (the "808 fall")
+  octaves: 3,            // moderate pitch drop
+  envelope: { attack: 0.001, decay: 1.2, sustain: 0, release: 0.5 }
+}).toDestination();
+
+// Trigger 808 on beat 1 — pitch starts at C2 then falls
+sub.triggerAttackRelease("C2", "2n", time);
+
+// Hi-hat roll — 32nd notes, velocity variation = the trap signature
+const hatVelocities = [
+  0.9, 0.3, 0.5, 0.2, 0.7, 0.2, 0.4, 0.2,  // 8-step build
+  0.6, 0.3, 0.8, 0.2, 0.5, 0.3, 1.0, 0.2   // accent on last
+];
+new Tone.Sequence((time, vel) => {
+  hat.triggerAttackRelease("32n", time, vel);
+}, hatVelocities, "32n").start(0);
+```
+
+## Instrument Configuration
+
+```js
+// 808 Sub — long pitchDecay is the defining characteristic
+const dist808 = new Tone.Distortion({ distortion: 0.15, wet: 0.3 }).toDestination();
+const sub = new Tone.MembraneSynth({
+  pitchDecay: 0.45,    // how long the pitch "falls" — the 808 glide
+  octaves: 3,          // semitones of pitch drop
+  volume: 2,
+  envelope: { attack: 0.001, decay: 1.0, sustain: 0, release: 0.6 }
+}).connect(dist808);   // light saturation adds warmth to the sub
+
+// Snare — tight white noise, minimal reverb
+const snareVerb = new Tone.Reverb({ decay: 0.8, wet: 0.2 }).toDestination();
+const snare = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.18, sustain: 0, release: 0.06 },
+  volume: -2
+}).connect(snareVerb);
+
+// Hi-hat — very short decay, high frequency
+const hat = new Tone.MetalSynth({
+  frequency: 800,
+  envelope: { attack: 0.001, decay: 0.03, release: 0.008 },
+  harmonicity: 5.1,
+  modulationIndex: 32,
+  resonance: 5000,
+  octaves: 2,
+  volume: -8
+}).toDestination();
+
+// Orchestral strings — sparse, atmospheric
+const stringsVerb = new Tone.Reverb({ decay: 4.0, wet: 0.6 }).toDestination();
+const strings = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "sawtooth4" },
+  envelope: { attack: 0.4, decay: 1.0, sustain: 0.7, release: 1.5 },
+  volume: -12
+}).connect(stringsVerb);
+```
+
+## Composition Structure
+
+- **Bar 1:** 808 hit on beat 1, snare on beat 3 (half-time), hi-hat roll building
+- **Bar 2:** 808 on beat 1 again (the sub is still decaying from bar 1), hi-hat variation
+- **Bars 1-4:** Drum loop establishes half-time feel with rolls escalating
+- **Bar 5-8:** Add strings — sparse pad chord, lots of reverb
+- **Bar 9-16:** Full arrangement — 808 pattern + hi-hat rolls + strings harmony
+- **Build:** Hi-hat velocity increases toward drop, 32nd note flurry
+- **Drop:** 808 hits hard, hi-hats sparse, strings cut — maximum impact
+
+Hi-hat roll anatomy: Start sparse (quarter notes), build to 8ths, then 16ths, then 32nds on the approach to the drop. This escalation is the genre's primary tension tool.
+
+## Example Variations
+
+### 1 — Classic 808 Double Hit
+```js
+// 808 hits twice in a bar — beat 1 and the "and" of beat 3
+const subPattern = ["C2", null, null, null, null, null, "C1", null];
+// Second hit is higher (C1 vs C2) — common trap technique
+```
+
+### 2 — Hi-Hat Triplet Roll
+```js
+// Triplet 16ths (12 per bar instead of 16) — more organic feel
+new Tone.Sequence((time, vel) => {
+  if (vel) hat.triggerAttackRelease("32n", time, vel);
+}, [0.9, 0.3, 0.6, 0.9, 0.3, 0.6, 0.9, 0.3, 0.6, 0.9, 0.3, 0.9], "8t").start(0);
+```
+
+### 3 — Sliding 808 Pitch (Tone.js portamento)
+```js
+// Use portamento on MonoSynth for more dramatic pitch slide
+const slideSub = new Tone.MonoSynth({
+  oscillator: { type: "sine" },
+  portamento: 0.4,    // glide time in seconds
+  envelope: { attack: 0.001, decay: 1.2, sustain: 0, release: 0.5 },
+  filter: { type: "lowpass", frequency: 200 }
+});
+slideSub.triggerAttackRelease("C3", "2n", time);
+// Then after portamento, note has already slid down
+```