npm - tuneframes - Versions diffs - 0.1.1 → 0.2.0 - Mend

tuneframes 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

package/LICENSE +166 -166
package/README.md +158 -55
package/examples/example-ai-dj-chill.html +167 -0
package/examples/example-ai-dj-dark.html +167 -0
package/examples/example-ai-dj-energetic.html +167 -0
package/examples/example-ai-dj-happy.html +167 -0
package/examples/example-ai-dj.html +167 -0
package/examples/example-ambient.html +63 -63
package/examples/example-ambient.mp3 +0 -0
package/examples/example-bass.html +47 -47
package/examples/example-lofi.html +45 -45
package/examples/example-lofi.mp3 +0 -0
package/examples/example-minimal.html +20 -20
package/examples/example-orchestral.html +67 -67
package/examples/example-orchestral.mp3 +0 -0
package/examples/example-piano.html +52 -52
package/examples/example-piano.mp3 +0 -0
package/examples/example-techno.html +69 -69
package/examples/example-techno.mp3 +0 -0
package/package.json +42 -37
package/registry/presets/bass-electric.html +67 -0
package/registry/presets/bass-saw.html +22 -0
package/registry/presets/chord-progression.html +22 -0
package/registry/presets/drums-808.html +85 -0
package/registry/presets/drums-lofi.html +35 -0
package/registry/presets/lead-piano.html +26 -0
package/registry/presets/piano-salamander.html +69 -0
package/registry/presets/reverb-warm.html +11 -0
package/registry/samples.json +226 -0
package/skills/audio-ambient/SKILL.md +141 -0
package/skills/audio-ambient/example.html +113 -0
package/skills/audio-boss-battle/SKILL.md +157 -0
package/skills/audio-boss-battle/example.html +185 -0
package/skills/audio-boss-battle/example.mp3 +0 -0
package/skills/audio-chillwave/SKILL.md +142 -0
package/skills/audio-chillwave/example.html +144 -0
package/skills/audio-cinematic/SKILL.md +147 -0
package/skills/audio-cinematic/example.html +123 -0
package/skills/audio-classical/SKILL.md +138 -0
package/skills/audio-classical/example.html +145 -0
package/skills/audio-dnb/SKILL.md +142 -0
package/skills/audio-dnb/example.html +124 -0
package/skills/audio-downtempo/SKILL.md +152 -0
package/skills/audio-downtempo/example.html +164 -0
package/skills/audio-folk/SKILL.md +139 -0
package/skills/audio-folk/example.html +132 -0
package/skills/audio-funk/SKILL.md +149 -0
package/skills/audio-funk/example.html +144 -0
package/skills/audio-future-bass/SKILL.md +163 -0
package/skills/audio-future-bass/example.html +164 -0
package/skills/audio-hip-hop/SKILL.md +133 -0
package/skills/audio-hip-hop/example.html +129 -0
package/skills/audio-house/SKILL.md +147 -0
package/skills/audio-house/example.html +128 -0
package/skills/audio-indie-pop/SKILL.md +150 -0
package/skills/audio-indie-pop/example.html +121 -0
package/skills/audio-jazz/SKILL.md +141 -0
package/skills/audio-jazz/example.html +146 -0
package/skills/audio-lofi/SKILL.md +140 -0
package/skills/audio-lofi/example.html +135 -0
package/skills/audio-minimal/SKILL.md +155 -0
package/skills/audio-minimal/example.html +118 -0
package/skills/audio-orchestral/SKILL.md +156 -0
package/skills/audio-orchestral/example.html +140 -0
package/skills/audio-r-and-b/SKILL.md +134 -0
package/skills/audio-r-and-b/example.html +154 -0
package/skills/audio-r-and-b/example.mp3 +0 -0
package/skills/audio-techno/SKILL.md +140 -0
package/skills/audio-techno/example.html +125 -0
package/skills/audio-trap/SKILL.md +123 -0
package/skills/audio-trap/example.html +119 -0
package/skills/render-retest/example.html +115 -0
package/skills/tuneframes/SKILL.md +221 -0
package/skills/tuneframes-cli/SKILL.md +46 -0
package/skills/verify/example.html +104 -0
package/src/cli.js +260 -151
package/src/render.js +134 -7
package/examples/example-bass.mp3 +0 -0
package/examples/example-demo-beat.wav +0 -0
package/examples/example-orchestral.wav +0 -0

package/skills/audio-cinematic/example.html ADDED Viewed

@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>TuneFrames — Cinematic Score</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":72,"duration":"15s"}</div>
+  <script>
+    async function main() {
+      await Tone.start();
+      Tone.Transport.bpm.value = 72;
+      const bar = Tone.Time('1n').toSeconds(); // ~3.33s per bar at 72 BPM
+      const q   = Tone.Time('4n').toSeconds(); // ~0.83s per beat
+      // ── Reverb halls ─────────────────────────────────────────────────────
+      const hall  = new Tone.Reverb({ decay: 7, preDelay: 0.06, wet: 0.65 });
+      const room  = new Tone.Reverb({ decay: 3, preDelay: 0.01, wet: 0.35 });
+      // Await IR generation before offline rendering begins — required in Tone.Offline
+      await Promise.all([hall.ready, room.ready]);
+      hall.toDestination();
+      room.toDestination();
+      // ── Choir pad (enters immediately, very soft) ─────────────────────────
+      const choir = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: 'sine' },
+        envelope: { attack: 2.8, decay: 0.4, sustain: 0.85, release: 6.0 }
+      }).connect(hall);
+      choir.volume.value = -22;
+      // Dm open fifth — ethereal, thin, creates space
+      choir.triggerAttackRelease(['D3','A3'], '2n', 0);
+      // ── Strings — slow attack swell ──────────────────────────────────────
+      const strings = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: 'sawtooth' },
+        envelope: { attack: 2.0, decay: 0.5, sustain: 0.85, release: 5.0 }
+      }).connect(hall);
+      strings.volume.value = -16;
+      // Dm – Bb – F – C (the cinematic minor-to-relative-major arc)
+      const prog = [
+        ['D3','F3','A3','D4'],    // Dm  (bar 1)
+        ['Bb2','D3','F3','Bb3'],  // Bb  (bar 2)
+        ['F2','C3','F3','A3'],    // F   (bar 3)
+        ['C3','G3','C4','E4'],    // C   (bar 4)
+      ];
+      prog.forEach((ch, i) => strings.triggerAttackRelease(ch, '1n', i * bar));
+      // ── Cello ostinato (enters bar 2 — adds forward motion) ──────────────
+      const cello = new Tone.Synth({
+        oscillator: { type: 'sawtooth' },
+        envelope: { attack: 0.12, decay: 0.2, sustain: 0.7, release: 0.8 }
+      }).connect(hall);
+      cello.volume.value = -18;
+      // D–A–D pattern driving through bars 2–4
+      const ostinato = ['D3','A3','D3','A3','D3','A3','D3','F3'];
+      ostinato.forEach((n, i) => cello.triggerAttackRelease(n, '8n', bar + i * (q * 0.5)));
+      const ostinato2 = ['Bb2','F3','Bb2','F3','Bb2','F3','C3','G3'];
+      ostinato2.forEach((n, i) => cello.triggerAttackRelease(n, '8n', bar * 2 + i * (q * 0.5)));
+      const ostinato3 = ['F2','C3','F3','C3','F2','C3','G2','C3'];
+      ostinato3.forEach((n, i) => cello.triggerAttackRelease(n, '8n', bar * 3 + i * (q * 0.5)));
+      // ── Low piano (enters bar 1, punctuates downbeats) ───────────────────
+      const piano = new Tone.Synth({
+        oscillator: { type: 'sine' },
+        envelope: { attack: 0.01, decay: 1.2, sustain: 0.1, release: 2.0 }
+      }).connect(room);
+      piano.volume.value = -14;
+      piano.triggerAttackRelease('D2', '2n', 0);
+      piano.triggerAttackRelease('Bb1', '2n', bar);
+      piano.triggerAttackRelease('F1',  '2n', bar * 2);
+      piano.triggerAttackRelease('C2',  '2n', bar * 3);
+      // ── Yearning solo melody (enters bar 2, high register) ───────────────
+      const solo = new Tone.Synth({
+        oscillator: { type: 'sine' },
+        envelope: { attack: 0.35, decay: 0.3, sustain: 0.85, release: 2.5 }
+      }).connect(hall);
+      solo.volume.value = -14;
+      // Morricone-style descending phrase: D5–C5–Bb4–A4–F4–A4
+      const soloPhrase = [
+        { note: 'D5',  time: bar * 1.5,       dur: '4n' },
+        { note: 'C5',  time: bar * 1.5 + q,   dur: '4n' },
+        { note: 'Bb4', time: bar * 1.5 + q*2, dur: '2n' },
+        { note: 'A4',  time: bar * 2.5,        dur: '4n' },
+        { note: 'F4',  time: bar * 2.5 + q,   dur: '4n' },
+        { note: 'A4',  time: bar * 2.5 + q*2, dur: '4n' },
+        { note: 'D5',  time: bar * 3,          dur: '2n.' },
+        { note: 'C5',  time: bar * 3.75,       dur: '4n' },
+      ];
+      soloPhrase.forEach(({ note, time, dur }) => solo.triggerAttackRelease(note, dur, time));
+      // ── Brass swell (enters bar 3 — the climax) ──────────────────────────
+      const brass = new Tone.PolySynth(Tone.Synth, {
+        oscillator: { type: 'sawtooth' },
+        envelope: { attack: 0.5, decay: 0.3, sustain: 0.85, release: 3.0 }
+      }).connect(hall);
+      brass.volume.value = -20;
+      brass.triggerAttackRelease(['F3','A3','C4','F4'], '2n', bar * 2);
+      brass.triggerAttackRelease(['C3','G3','C4','E4'], '1n', bar * 3);
+      // ── Timpani — dramatic hits on bars 3 and 4 ──────────────────────────
+      const timp = new Tone.MembraneSynth({
+        pitchDecay: 0.1, octaves: 6,
+        envelope: { attack: 0.001, decay: 1.5, sustain: 0, release: 2.5 }
+      }).connect(hall);
+      timp.volume.value = -8;
+      timp.triggerAttackRelease('F1', '4n', bar * 2);
+      timp.triggerAttackRelease('D1', '4n', bar * 3);
+      timp.triggerAttackRelease('C1', '4n', bar * 3 + q * 2);
+    }
+  </script>
+</body>
+</html>

package/skills/audio-classical/SKILL.md ADDED Viewed

@@ -0,0 +1,138 @@
+---
+name: audio-classical
+description: Classical solo piano — left hand Alberti bass or broken chords, right hand melody with ornaments, no effects beyond room reverb
+---
+# TuneFrames — Classical Piano
+## Genre Profile
+- BPM range: 80-140 (Allegro for Mozart, Andante for slow movements)
+- Key characteristics: Alberti bass in left hand (bass-chord-chord pattern), melodic right hand in single notes or octaves, voice leading between the two hands, harmonic rhythm changes every half or full bar
+- Typical instruments: Tone.Synth with triangle oscillator (cleanest piano approximation), slight room reverb only
+- Mood: elegant, structured, emotionally direct, intellectually clear
+## Core Pattern
+```js
+// Classical piano: right hand melody over left hand Alberti bass
+// Key = C major, BPM = 104 (Allegro moderato)
+// Alberti bass = bass note → inner chord → upper chord, repeating 8th notes
+Tone.Transport.bpm.value = 104;
+// Piano synth — triangle wave with tight envelope
+const piano = new Tone.Synth({
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.008, decay: 0.3, sustain: 0.2, release: 1.2 },
+  volume: -6,
+});
+// Gentle room reverb only
+const reverb = new Tone.Reverb({ decay: 1.2, preDelay: 0.01, wet: 0.25 });
+await reverb.generate();
+reverb.toDestination();
+piano.connect(reverb);
+// A second instance for left hand (allows simultaneous notes)
+const pianoL = new Tone.Synth({
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.008, decay: 0.4, sustain: 0.15, release: 1.0 },
+  volume: -10, // left hand slightly quieter
+});
+pianoL.connect(reverb);
+// RIGHT HAND: C major scale as 8th-note melody (C D E F G F E D)
+const rhNotes = ['C5','D5','E5','F5','G5','F5','E5','D5'];
+const rhTimes = [0, 0.29, 0.57, 0.86, 1.15, 1.44, 1.73, 2.02]; // 8th notes at 104 BPM
+rhNotes.forEach((note, i) => {
+  Tone.Transport.scheduleOnce(time => {
+    piano.triggerAttackRelease(note, '8n', time);
+  }, rhTimes[i]);
+});
+// LEFT HAND: Alberti bass on C major chord (C3 → E3 → G3 repeating)
+// Pattern: C3, G3, E3, G3 (bass → upper → inner → upper)
+const lhPattern = ['C3','G3','E3','G3', 'F2','A2','F2','A2'];
+lhPattern.forEach((note, i) => {
+  Tone.Transport.scheduleOnce(time => {
+    pianoL.triggerAttackRelease(note, '8n', time);
+  }, i * 0.29); // 8th note spacing at 104 BPM
+});
+```
+## Instrument Configuration
+```js
+// Piano approximation — triangle + tight decay, slight room
+// Two instances: right hand (melody) and left hand (accompaniment)
+// Room reverb — small, 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, slightly brighter
+const rh = new Tone.Synth({
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.006, decay: 0.25, sustain: 0.15, release: 1.4 },
+  volume: -4,
+}).connect(reverb);
+// Left hand — accompaniment, slightly softer and darker
+const lh = new Tone.Synth({
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.01, decay: 0.4, sustain: 0.1, release: 1.0 },
+  volume: -9,
+}).connect(reverb);
+// For chords in the left hand, use PolySynth
+const lhChord = new Tone.PolySynth(Tone.Synth, {
+  oscillator: { type: 'triangle' },
+  envelope: { attack: 0.01, decay: 0.35, sustain: 0.15, release: 1.2 },
+  volume: -11,
+}).connect(reverb);
+```
+## Composition Structure
+**Classical follows phrase structure — typically 4-bar or 8-bar phrases:**
+1. **Antecedent phrase (0-4s):** Opening melody in right hand. Left hand Alberti bass on I chord (tonic). Ends on V (half cadence — tension).
+2. **Consequent phrase (4-8s):** Melody continues or develops. Left hand harmonic progression I→IV→V→I. Ends on I (full cadence — resolution).
+3. **Middle section / contrast (8-12s):** Move to relative minor or vi. Melody gets more chromatic or ornamental. Left hand may switch from Alberti to block chords.
+4. **Return (12s+):** Return to opening material. Final cadence: IV→V→I.
+**Alberti bass pattern at any BPM:**
+- Bass note (lowest note of chord) → Upper note → Middle note → Upper note
+- Repeat for each 8th note subdivision
+- C major: C3 → G3 → E3 → G3
+- F major: F2 → C3 → A2 → C3
+- G major: G2 → D3 → B2 → D3
+## Example Variations
+### Variation 1: Slow movement (Andante cantabile)
+```js
+Tone.Transport.bpm.value = 72;
+// Right hand: long notes (quarter and half notes) — singable melody
+// Left hand: broken octaves instead of Alberti — just bass + high octave alternating
+// Reverb slightly wetter: 0.35 — feels more intimate
+// Envelope release: 2.0 — notes ring longer
+```
+### Variation 2: Fast passage work (Allegro vivace)
+```js
+Tone.Transport.bpm.value = 132;
+// Right hand: 16th-note scalar run (C major scale, 2 octaves up and down)
+// Left hand: block chords on beats 1 and 3 only (not Alberti — too busy)
+// Use PolySynth for left hand chords: ['C3','E3','G3'], ['G2','B2','D3'], etc.
+// Shorter release: 0.6 — crisp, not muddy at fast tempo
+```
+### Variation 3: Ornamental turn
+```js
+// Right hand melody includes a trill approximation
+// Instead of one quarter note on E5, play: E5, F5, E5, D5, E5 as 32nd notes
+// Schedule these rapid notes as very short triggerAttackRelease calls
+// const trillNotes = ['E5','F5','E5','D5','E5'];
+// trillNotes.forEach((n, i) => rh.triggerAttackRelease(n, '32n', time + i * 0.045));
+```

package/skills/audio-classical/example.html ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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>