tuneframes 0.1.0 → 0.2.0

package/skills/audio-classical/example.html

@@ -0,0 +1,145 @@
+<div id="tuneframes" style="display:none">{"bpm":104,"duration":"12s"}</div>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
+<script>
+// TuneFrames — Classical Piano
+// C major, Allegro moderato (104 BPM)
+// Right hand: melodic line with ornamental turn
+// Left hand: Alberti bass (bass-upper-inner-upper pattern)
+// Harmony: I → V → vi → IV → V → I (complete progression)
+
+async function main() {
+  await Tone.start();
+
+  Tone.Transport.bpm.value = 104;
+
+  const beat      = 60 / 104;      // 0.577s per quarter note
+  const eighth    = beat / 2;      // 0.288s per eighth note
+  const sixteenth = beat / 4;      // 0.144s per sixteenth note
+
+  // ── Small room reverb — a piano in a parlour, not a concert hall ──────────
+  const reverb = new Tone.Reverb({ decay: 1.1, preDelay: 0.008, wet: 0.22 });
+  await reverb.generate();
+  reverb.toDestination();
+
+  // ── Right hand — melody voice, triangle wave ──────────────────────────────
+  const rh = new Tone.Synth({
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.006, decay: 0.22, sustain: 0.18, release: 1.4 },
+    volume: -4,
+  });
+  rh.connect(reverb);
+
+  // ── Left hand single notes (bass) — slightly softer, same timbre ─────────
+  const lhBass = new Tone.Synth({
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.008, decay: 0.35, sustain: 0.12, release: 1.0 },
+    volume: -10,
+  });
+  lhBass.connect(reverb);
+
+  // ── Left hand chord notes (inner voices of Alberti) ───────────────────────
+  const lhChord = new Tone.PolySynth(Tone.Synth, {
+    oscillator: { type: 'triangle' },
+    envelope: { attack: 0.008, decay: 0.3, sustain: 0.1, release: 0.9 },
+    volume: -13,
+  });
+  lhChord.connect(reverb);
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Helper: schedule an Alberti bass pattern for one bar using direct time
+  // root = bass note (e.g. 'C3'), inner = e.g. 'E3', upper = e.g. 'G3'
+  // Pattern of 8 eighth notes: root upper inner upper root upper inner upper
+  // ─────────────────────────────────────────────────────────────────────────
+  function alberti(root, inner, upper, startTime) {
+    const pattern = [root, upper, inner, upper, root, upper, inner, upper];
+    pattern.forEach((note, i) => {
+      const t = startTime + i * eighth;
+      if (i % 2 === 0) {
+        lhBass.triggerAttackRelease(note, '8n', t);
+      } else {
+        lhChord.triggerAttackRelease(note, '8n', t);
+      }
+    });
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Harmony plan (one bar each, 4 beats = beat*4 per bar):
+  // Bar 1: I   — C major  (C3 E3 G3)
+  // Bar 2: V   — G major  (G2 B2 D3)
+  // Bar 3: vi  — A minor  (A2 C3 E3)
+  // Bar 4: IV  — F major  (F2 A2 C3)
+  // Bar 5: V   — G major  (G2 B2 D3)
+  // Bar 6: I   — C major  (C3 E3 G3)  — final resolution
+  // ─────────────────────────────────────────────────────────────────────────
+  const barLen = beat * 4;
+
+  alberti('C3', 'E3', 'G3', 0);              // I
+  alberti('G2', 'B2', 'D3', barLen);         // V
+  alberti('A2', 'C3', 'E3', barLen * 2);     // vi
+  alberti('F2', 'A2', 'C3', barLen * 3);     // IV
+  alberti('G2', 'B2', 'D3', barLen * 4);     // V
+  alberti('C3', 'E3', 'G3', barLen * 5);     // I (final)
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Right hand melody — stepwise, fits the chord above
+  // Phrase 1 (bars 1-2): C major scale ascending, quarter + eighth mix
+  // Phrase 2 (bars 3-4): descent with ornamental turn on E5
+  // Phrase 3 (bars 5-6): cadential figure, landing on C5
+  // ─────────────────────────────────────────────────────────────────────────
+
+  // Phrase 1: ascending C major scale with rhythmic variety
+  const phrase1 = [
+    { note: 'C5',  dur: '4n',  t: 0 },
+    { note: 'D5',  dur: '8n',  t: beat },
+    { note: 'E5',  dur: '8n',  t: beat + eighth },
+    { note: 'F5',  dur: '4n',  t: beat * 2 },
+    { note: 'G5',  dur: '4n',  t: beat * 3 },
+    // Bar 2: hold G5, then step up to A5
+    { note: 'G5',  dur: '8n',  t: barLen },
+    { note: 'A5',  dur: '8n',  t: barLen + eighth },
+    { note: 'G5',  dur: '4n',  t: barLen + beat },
+    { note: 'F5',  dur: '4n',  t: barLen + beat * 2 },
+    { note: 'E5',  dur: '4n',  t: barLen + beat * 3 },
+  ];
+
+  // Phrase 2: ornamental turn on E5 (F E D E), then descent
+  const turnStart = barLen * 2;
+  const turn = [
+    { note: 'F5',  dur: '16n', t: turnStart },
+    { note: 'E5',  dur: '16n', t: turnStart + sixteenth },
+    { note: 'D5',  dur: '16n', t: turnStart + sixteenth * 2 },
+    { note: 'E5',  dur: '8n',  t: turnStart + sixteenth * 3 },
+  ];
+  const phrase2 = [
+    ...turn,
+    { note: 'D5',  dur: '4n',  t: turnStart + beat },
+    { note: 'C5',  dur: '4n',  t: turnStart + beat * 2 },
+    { note: 'B4',  dur: '4n',  t: turnStart + beat * 3 },
+    // Bar 4:
+    { note: 'A4',  dur: '4n',  t: barLen * 3 },
+    { note: 'G4',  dur: '8n',  t: barLen * 3 + beat },
+    { note: 'A4',  dur: '8n',  t: barLen * 3 + beat + eighth },
+    { note: 'C5',  dur: '2n',  t: barLen * 3 + beat * 2 },
+  ];
+
+  // Phrase 3: cadential figure V → I landing
+  const p3start = barLen * 4;
+  const phrase3 = [
+    { note: 'B4',  dur: '4n',  t: p3start },
+    { note: 'D5',  dur: '4n',  t: p3start + beat },
+    { note: 'G5',  dur: '4n',  t: p3start + beat * 2 },
+    { note: 'F5',  dur: '4n',  t: p3start + beat * 3 },
+    // Bar 6: resolution to I — long final note
+    { note: 'E5',  dur: '8n',  t: barLen * 5 },
+    { note: 'D5',  dur: '8n',  t: barLen * 5 + eighth },
+    { note: 'C5',  dur: '2n',  t: barLen * 5 + beat },
+  ];
+
+  // Schedule all right hand notes using direct time offsets (seconds)
+  [...phrase1, ...phrase2, ...phrase3].forEach(({ note, dur, t }) => {
+    if (t < 12) {
+      rh.triggerAttackRelease(note, dur, t);
+    }
+  });
+}
+</script>

package/skills/audio-dnb/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: audio-dnb
+description: Drum and Bass — syncopated Amen-style breakbeat, reese bass with chorus and filter, atmospheric pad, heavy sub frequencies. Hard hitting and kinetic.
+---
+
+# TuneFrames — Drum and Bass
+
+## Genre Profile
+- BPM range: 165–180
+- Key characteristics: Complex syncopated breakbeat (kick not on the beat — that's the point), heavy Reese bass (sawtooth + chorus + filter), atmospheric pad underneath, powerful sub frequencies, kinetic forward momentum
+- Typical instruments: MembraneSynth (kick), NoiseSynth (snare), MetalSynth (hi-hat), FMSynth or MonoSynth (Reese bass), PolySynth (pad)
+- Mood: Intense, kinetic, dark, cerebral, euphoric at the peak
+
+## Core Pattern
+
+```js
+// Drum and Bass — 174 BPM
+// Breakbeat: kick/snare NOT on beats 1,2,3,4 — syncopated Amen-style
+// Reese bass: sawtooth + heavy chorus = that "wobble" character
+// Pad: slow attack, atmospheric underneath
+
+// Classic DnB breakbeat (Amen-style, 16-step)
+// K=kick, S=snare, .=rest
+// K . . S . K K S . . K . S . K S  (feel, not strict)
+const breakPattern = [
+  "kick", null,   null,  "snare", null,  "kick", "kick", "snare",
+  null,   null,   "kick", null,  "snare", null,  "kick",  "snare"
+];
+
+new Tone.Sequence((time, hit) => {
+  if (hit === "kick")  kick.triggerAttackRelease("C1", "8n", time);
+  if (hit === "snare") snare.triggerAttackRelease("16n", time);
+}, breakPattern, "16n").start(0);
+
+// Reese bass — sawtooth through chorus
+const chorus = new Tone.Chorus({ frequency: 1.8, delayTime: 3.5, depth: 0.7, wet: 0.7 });
+const filter = new Tone.Filter({ frequency: 800, type: "lowpass", Q: 2 });
+const reese = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  envelope: { attack: 0.01, decay: 0.5, sustain: 0.8, release: 0.3 },
+  volume: -4
+}).chain(chorus, filter, Tone.Destination);
+chorus.start();
+
+Tone.Transport.bpm.value = 174;
+Tone.Transport.start();
+```
+
+## Instrument Configuration
+
+```js
+// Kick — short, punchy, low
+const kick = new Tone.MembraneSynth({
+  pitchDecay: 0.04,
+  octaves: 5,
+  envelope: { attack: 0.001, decay: 0.2, sustain: 0, release: 0.08 },
+  volume: 2
+}).toDestination();
+
+// Snare — crisp, with slight room
+const snareVerb = new Tone.Reverb({ decay: 0.5, wet: 0.15 }).toDestination();
+const snare = new Tone.NoiseSynth({
+  noise: { type: "white" },
+  envelope: { attack: 0.001, decay: 0.12, sustain: 0, release: 0.04 },
+  volume: -2
+}).connect(snareVerb);
+
+// Hi-hat — very fast, adds texture between beats
+const hat = new Tone.MetalSynth({
+  frequency: 500, harmonicity: 5.1, modulationIndex: 32,
+  resonance: 4500, octaves: 1.5,
+  envelope: { attack: 0.001, decay: 0.035, release: 0.01 },
+  volume: -12
+}).toDestination();
+
+// Reese bass — the DnB defining sound
+// Two detuned sawtooths + heavy chorus + filter
+const reeseLimiter = new Tone.Limiter(-4).toDestination();
+const reeseFilter = new Tone.Filter({ frequency: 700, type: "lowpass", Q: 3 }).connect(reeseLimiter);
+const reeseChorus = new Tone.Chorus({
+  frequency: 1.8,    // slow chorus = the "reese" movement
+  delayTime: 3.5,
+  depth: 0.75,
+  wet: 0.75
+}).connect(reeseFilter);
+reeseChorus.start();
+const reese = new Tone.MonoSynth({
+  oscillator: { type: "sawtooth" },
+  filter: { Q: 1, type: "lowpass", frequency: 2000 },
+  filterEnvelope: { attack: 0.02, decay: 0.5, sustain: 0.5, release: 0.5,
+                    baseFrequency: 200, octaves: 2 },
+  envelope: { attack: 0.01, decay: 0.3, sustain: 0.8, release: 0.3 },
+  volume: -2
+}).connect(reeseChorus);
+
+// Atmospheric pad — slow attack, long release
+const padVerb = new Tone.Reverb({ decay: 5.0, wet: 0.7 }).toDestination();
+const pad = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: "sawtooth4" },
+  envelope: { attack: 0.6, decay: 1.0, sustain: 0.6, release: 2.5 },
+  volume: -14
+}).connect(padVerb);
+```
+
+## Composition Structure
+
+- **Bar 1-2:** Breakbeat only — establish the syncopated groove immediately
+- **Bar 3-4:** Add hi-hat fills between kick/snare — density builds
+- **Bar 5-8:** Add Reese bass — low sustained notes, filter opens slowly
+- **Bar 9-16:** Full arrangement — breakbeat + Reese + atmospheric pad
+- **Variation bar:** Every 4 bars, drop a kick or add a snare roll for surprise
+- **Reese movement:** Filter automation — close at bar 5, sweep open over bar 6-8, close and re-open
+- **Outro:** Break strip — just pad remains, then breakbeat returns for exit
+
+The breakbeat is the identity. The kick landing OFF the downbeat is what separates DnB from techno — resist putting the kick on beat 1. The snare DOES land around beats 2 and 4 but offset slightly.
+
+## Example Variations
+
+### 1 — Half-time feel bridge
+```js
+// Every 8 bars, drop to a 2-step pattern (kick-snare only) for 1 bar
+// Builds tension before the full break returns
+const halfTimeBar = ["kick", null, null, null, null, null, null, null,
+                     null,   null, null, null, "snare", null, null, null];
+```
+
+### 2 — Reese filter wobble (1/4 note LFO)
+```js
+// LFO modulating the Reese filter — creates rhythmic wobble
+const lfo = new Tone.LFO({ frequency: "4n", min: 200, max: 2000, type: "sine" });
+lfo.connect(reeseFilter.frequency);
+lfo.start();
+```
+
+### 3 — Snare roll into drop
+```js
+// 16th-note snare roll over the last bar before a new section
+// Schedule 8 snare hits in last bar
+for (let i = 0; i < 8; i++) {
+  snare.triggerAttackRelease("32n", `${barStart} + ${i * 0.107}`, 0.3 + i * 0.087);
+}
+```

package/skills/audio-dnb/example.html

@@ -0,0 +1,124 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>TuneFrames — Drum and Bass</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":174,"duration":"12s"}</div>
+
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 174;
+
+      // --- MASTER BUS ---
+      const masterLimiter = new Tone.Limiter(-1).toDestination();
+      const masterGain = new Tone.Gain(0.87).connect(masterLimiter);
+
+      // --- KICK — short, punchy, sub-heavy ---
+      const kickGain = new Tone.Gain(0.9).connect(masterGain);
+      const kick = new Tone.MembraneSynth({
+        pitchDecay: 0.038,
+        octaves: 5,
+        envelope: { attack: 0.001, decay: 0.18, sustain: 0, release: 0.07 }
+      }).connect(kickGain);
+
+      // --- SNARE — crisp white noise ---
+      const snareVerb = new Tone.Reverb({ decay: 0.45, wet: 0.14 }).connect(masterGain);
+      const snareGain = new Tone.Gain(0.65).connect(snareVerb);
+      const snare = new Tone.NoiseSynth({
+        noise: { type: "white" },
+        envelope: { attack: 0.001, decay: 0.11, sustain: 0, release: 0.035 }
+      }).connect(snareGain);
+
+      // --- HI-HAT — fast texture between beats ---
+      const hatGain = new Tone.Gain(0.28).connect(masterGain);
+      const hat = new Tone.MetalSynth({
+        frequency: 520,
+        envelope: { attack: 0.001, decay: 0.032, release: 0.01 },
+        harmonicity: 5.1,
+        modulationIndex: 32,
+        resonance: 4600,
+        octaves: 1.5
+      }).connect(hatGain);
+
+      // --- REESE BASS — MonoSynth sawtooth + Chorus + Filter ---
+      // The Reese is the defining DnB sound: two slightly detuned saws = chorus
+      const reeseLimiter = new Tone.Limiter(-4).connect(masterGain);
+      const reeseFilter = new Tone.Filter({ frequency: 500, type: "lowpass", Q: 2.5 }).connect(reeseLimiter);
+      const reeseChorus = new Tone.Chorus({
+        frequency: 1.7,
+        delayTime: 3.5,
+        depth: 0.78,
+        wet: 0.72
+      }).connect(reeseFilter);
+      reeseChorus.start();
+      const reese = new Tone.MonoSynth({
+        oscillator: { type: "sawtooth" },
+        filter: { Q: 1.5, type: "lowpass", frequency: 3000 },
+        filterEnvelope: {
+          attack: 0.02, decay: 0.6, sustain: 0.5, release: 0.4,
+          baseFrequency: 180, octaves: 2.5
+        },
+        envelope: { attack: 0.008, decay: 0.4, sustain: 0.8, release: 0.35 },
+        volume: 0
+      }).connect(reeseChorus);
+
+      // --- ATMOSPHERIC PAD — slow attack, very wet reverb ---
+      const padVerb = new Tone.Reverb({ decay: 5.5, wet: 0.72 }).connect(masterGain);
+      const padGain = new Tone.Gain(0.45).connect(padVerb);
+      const pad = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: "sawtooth4" },
+        envelope: { attack: 0.7, decay: 1.2, sustain: 0.6, release: 3.0 },
+        volume: -2
+      }).connect(padGain);
+
+      // --- BREAKBEAT PATTERN — syncopated Amen-style ---
+      // K=kick, S=snare, h=hat, .=rest
+      // Pattern: .  .  S  .  K  K  S  .  .  K  .  S  K  .  S  h
+      const breakSeq = new Tone.Sequence((time, hit) => {
+        if (hit === "K") kick.triggerAttackRelease("C1", "8n", time);
+        if (hit === "S") snare.triggerAttackRelease("16n", time, 0.85);
+        if (hit === "s") snare.triggerAttackRelease("16n", time, 0.45); // ghost snare
+        if (hit === "h") hat.triggerAttackRelease("32n", time, 0.5);
+      }, [
+        null, "h", "S",  null, "K",  "K",  "S",  null,
+        "h",  "K", null, "S",  "K",  "h",  "S",  "h"
+      ], "16n");
+      breakSeq.start(0);
+
+      // --- REESE BASS LINE — D minor, sustained long notes ---
+      // Reese bass plays whole-bar notes — the filter movement IS the melody
+      const reeseLine = [
+        { note: "D1", dur: "1m", time: "2m" },
+        { note: "C1", dur: "1m", time: "3m" },
+        { note: "Bb0", dur: "1m", time: "4m" },
+        { note: "A0",  dur: "1m", time: "5m" },
+        { note: "D1",  dur: "1m", time: "6m" },
+        { note: "F1",  dur: "1m", time: "7m" },
+      ];
+      reeseLine.forEach(({ note, dur, time }) => {
+        reese.triggerAttackRelease(note, dur, time);
+      });
+
+      // Filter sweep on Reese — opens over bars 3-5, closes back bar 6-7
+      const sweepStart = Tone.Time("2m").toSeconds();
+      reeseFilter.frequency.setValueAtTime(300, sweepStart);
+      reeseFilter.frequency.exponentialRampToValueAtTime(2200, sweepStart + 4);
+      reeseFilter.frequency.exponentialRampToValueAtTime(250, sweepStart + 5.5);
+      reeseFilter.frequency.exponentialRampToValueAtTime(1800, sweepStart + 9);
+
+      // --- PAD — atmospheric Dm chord, enters at bar 4 ---
+      const padNotes = ["D3", "F3", "A3", "C4"]; // Dm7
+      pad.triggerAttackRelease(padNotes, "4m", "3m");
+      pad.triggerAttackRelease(["C3", "Eb3", "G3", "Bb3"], "4m", "7m"); // Cm7
+
+    }
+
+    main();
+  </script>
+</body>
+</html>

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
+```