vibeaudio 0.4.0

package/src/synth/generator.js

@@ -0,0 +1,179 @@
+/**
+ * Core Audio Synthesis & WAV Encoder Utilities
+ * Zero dependencies - Pure Node.js Buffers and Math
+ */
+
+const SAMPLE_RATE = 44100;
+
+const NOTE_INDICES = {
+  C: 0, "C#": 1, DB: 1,
+  D: 2, "D#": 3, EB: 3,
+  E: 4,
+  F: 5, "F#": 6, GB: 6,
+  G: 7, "G#": 8, AB: 8,
+  A: 9, "A#": 10, BB: 10,
+  B: 11
+};
+
+/**
+ * Converts note string (e.g. "C4", "A#3", "Eb5") to frequency in Hz.
+ */
+function noteToFreq(noteStr) {
+  const clean = noteStr.trim().toUpperCase();
+  const name = clean.slice(0, -1);
+  const octave = parseInt(clean.slice(-1), 10);
+  const semitone = NOTE_INDICES[name];
+  if (semitone === undefined || isNaN(octave)) {
+    throw new Error(`Invalid note name: ${noteStr}`);
+  }
+  const midi = semitone + (octave + 1) * 12;
+  return 440.0 * Math.pow(2.0, (midi - 69) / 12.0);
+}
+
+/**
+ * Deterministic PRNG (mulberry32). Same seed always yields the same music,
+ * which is what makes a project's sound stable across sessions and keeps the
+ * audio cache valid.
+ */
+function makeRng(seed) {
+  let a = seed >>> 0;
+  return function next() {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** FNV-1a: turns a project path into a stable 32-bit seed. */
+function hashString(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+function pick(rng, options) {
+  return options[Math.floor(rng() * options.length) % options.length];
+}
+
+/**
+ * Ornament placement draws from its own stream so that gating a layer by tier
+ * can't shift the choices made by other layers - tier 1 and tier 3 stay the
+ * same piece, one just has more of it.
+ */
+function ornamentRng(seed) {
+  return makeRng((seed ^ 0x9e3779b9) >>> 0);
+}
+
+/**
+ * Waveform Oscillators
+ */
+function sine(phase) {
+  return Math.sin(2.0 * Math.PI * phase);
+}
+
+function triangle(phase) {
+  const p = ((phase % 1.0) + 1.0) % 1.0;
+  return 4.0 * Math.abs(p - 0.5) - 1.0;
+}
+
+/**
+ * A saturated two-harmonic pulse: fundamental plus its octave, driven into
+ * tanh so the tops square off.
+ *
+ * It took a `duty` argument for a long time and never read it. Five call sites
+ * passed 0.3, 0.32, 0.35, 0.4 and 0.5, so chiptune's bass and its lead were
+ * asking for different widths and getting one waveform - pulse-width
+ * variation, the thing that makes a chiptune sound like a chiptune, was never
+ * wired up. The parameter is gone rather than implemented because implementing
+ * it changes how 8bit and electronic sound, and a level and voicing tuned by
+ * ear has to be re-checked by ear. If you want real PWM, add it here
+ * deliberately (compare `p` against the duty instead of summing harmonics),
+ * then re-level both genres against the house RMS and listen to every tier.
+ */
+function softPulse(phase) {
+  const p = ((phase % 1.0) + 1.0) % 1.0;
+  const s = Math.sin(2.0 * Math.PI * p) + 0.35 * Math.sin(4.0 * Math.PI * p);
+  return Math.tanh(s * 2.8);
+}
+
+function analogSaw(phase) {
+  const p = 2.0 * Math.PI * (((phase % 1.0) + 1.0) % 1.0);
+  return (
+    Math.sin(p) * 0.70 +
+    Math.sin(2.0 * p) * 0.35 +
+    Math.sin(3.0 * p) * 0.18 +
+    Math.sin(4.0 * p) * 0.08
+  );
+}
+
+/**
+ * Encodes audio buffers (Float Arrays in [-1.0, 1.0]) into a valid 16-bit PCM WAV Buffer.
+ * Supports mono (single array) or stereo (array of [left, right] or { left: [], right: [] }).
+ */
+function createWavBuffer({ left, right = null, sampleRate = SAMPLE_RATE }) {
+  const isStereo = right != null && right.length > 0;
+  const numChannels = isStereo ? 2 : 1;
+  const numSamples = left.length;
+  const bytesPerSample = 2; // 16-bit
+  const blockAlign = numChannels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+  const dataSize = numSamples * blockAlign;
+  const bufferSize = 44 + dataSize;
+
+  const buf = Buffer.alloc(bufferSize);
+
+  // RIFF Header
+  buf.write("RIFF", 0);
+  buf.writeUInt32LE(bufferSize - 8, 4);
+  buf.write("WAVE", 8);
+
+  // fmt subchunk
+  buf.write("fmt ", 12);
+  buf.writeUInt32LE(16, 16);           // Subchunk1Size for PCM
+  buf.writeUInt16LE(1, 20);            // AudioFormat 1 = PCM
+  buf.writeUInt16LE(numChannels, 22);  // NumChannels
+  buf.writeUInt32LE(sampleRate, 24);   // SampleRate
+  buf.writeUInt32LE(byteRate, 28);     // ByteRate
+  buf.writeUInt16LE(blockAlign, 32);   // BlockAlign
+  buf.writeUInt16LE(16, 34);           // BitsPerSample (16-bit)
+
+  // data subchunk
+  buf.write("data", 36);
+  buf.writeUInt32LE(dataSize, 40);
+
+  let offset = 44;
+  for (let i = 0; i < numSamples; i++) {
+    // Clamp sample between -1.0 and 1.0
+    const valL = Math.max(-1.0, Math.min(1.0, left[i]));
+    const intL = valL < 0 ? Math.floor(valL * 32768) : Math.floor(valL * 32767);
+    buf.writeInt16LE(intL, offset);
+    offset += 2;
+
+    if (isStereo) {
+      const valR = Math.max(-1.0, Math.min(1.0, right[i]));
+      const intR = valR < 0 ? Math.floor(valR * 32768) : Math.floor(valR * 32767);
+      buf.writeInt16LE(intR, offset);
+      offset += 2;
+    }
+  }
+
+  return buf;
+}
+
+module.exports = {
+  SAMPLE_RATE,
+  makeRng,
+  hashString,
+  pick,
+  ornamentRng,
+  noteToFreq,
+  sine,
+  triangle,
+  softPulse,
+  analogSaw,
+  createWavBuffer
+};

package/src/synth/jazz.js

@@ -0,0 +1,178 @@
+/**
+ * Midnight Jazz / Coffee Shop Bossa Procedural Synth Engine
+ * Classic ii-V-I Jazz Chords + Walking Upright Bass + Brushed Swing Cymbal
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  sine,
+  triangle,
+  makeRng,
+  pick,
+  ornamentRng,
+  createWavBuffer
+} = require("./generator");
+
+// Three standard turnarounds in C, each with its own walking bass line so the
+// bass always spells the changes it is under.
+const CHANGES = [
+  {
+    // ii - V - I - VI7  (Dm9 - G13 - Cmaj9 - A7b9)
+    chords: [["F3", "A3", "C4", "E4"], ["F3", "B3", "E4", "A4"], ["E3", "G3", "B3", "D4"], ["G3", "A#3", "C#4", "F4"]],
+    bass: ["D2", "F2", "F#2", "G2", "B2", "C3", "B2", "A2"]
+  },
+  {
+    // I - VI - ii - V  (Cmaj9 - Am9 - Dm9 - G13)
+    chords: [["E3", "G3", "B3", "D4"], ["E3", "G3", "C4", "B3"], ["F3", "A3", "C4", "E4"], ["F3", "B3", "E4", "A4"]],
+    bass: ["C2", "E2", "A2", "G2", "D2", "F2", "G2", "B2"]
+  },
+  {
+    // iii - VI - ii - V  (Em9 - Am9 - Dm9 - G13)
+    chords: [["G3", "B3", "D4", "F#4"], ["E3", "G3", "C4", "B3"], ["F3", "A3", "C4", "E4"], ["F3", "B3", "E4", "A4"]],
+    bass: ["E2", "G2", "A2", "C3", "D2", "F2", "G2", "B2"]
+  }
+];
+
+const STAB_NOTES = ["D5", "E5", "G5", "A5", "B5"];
+
+function generateJazzLoop(durationSec = 6.26, tier = 2, seed = 0) {
+  const rng = makeRng(seed);
+  const changes = pick(rng, CHANGES);
+  const bpm = 92;
+  const secPerBeat = 60.0 / bpm;
+  const totalBeats = Math.floor(durationSec / secPerBeat);
+  const actualDuration = totalBeats * secPerBeat;
+  const totalSamples = Math.floor(SAMPLE_RATE * actualDuration);
+
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  // 1. Jazz Piano Comping (ii-V-I-VI Progression: Dmin9 -> G13 -> Cmaj9 -> A7b9)
+  const comping = [
+    { startBeat: 0.5, durBeats: 1.2 },
+    { startBeat: 2.0, durBeats: 1.5 },
+    { startBeat: 4.5, durBeats: 1.2 },
+    { startBeat: 6.0, durBeats: 1.5 }
+  ];
+  const jazzChords = comping.map((slot, i) => ({ ...slot, notes: changes.chords[i] }));
+
+  for (const chord of jazzChords) {
+    const startIdx = Math.floor(chord.startBeat * secPerBeat * SAMPLE_RATE);
+    const numSamples = Math.floor(chord.durBeats * secPerBeat * SAMPLE_RATE);
+
+    for (const note of chord.notes) {
+      const f = noteToFreq(note);
+      for (let i = 0; i < numSamples; i++) {
+        const idx = startIdx + i;
+        if (idx >= totalSamples) break;
+        const t = i / SAMPLE_RATE;
+        const attack = Math.min(1.0, t * 45.0);
+        const body = Math.exp(-t * 1.2);
+        // Soft warm jazz piano tone
+        const sample = (
+          sine(f * t) * 0.75 +
+          sine(f * 2.0 * t) * 0.20 * body +
+          sine(f * 3.0 * t) * 0.05 * Math.exp(-t * 6.0)
+        ) * attack * body * (tier === 1 ? 0.13 : tier === 3 ? 0.18 : 0.16);
+
+        left[idx] += sample * 0.85;
+        right[idx] += sample * 1.15;
+      }
+    }
+  }
+
+  // 2. Walking Upright Acoustic Bass (Quarter notes with wood tone) - joins at Tier 2
+  const walkingBass = changes.bass;
+  for (let b = 0; tier >= 2 && b < walkingBass.length && b < totalBeats; b++) {
+    const f = noteToFreq(walkingBass[b]);
+    const startIdx = Math.floor(b * secPerBeat * SAMPLE_RATE);
+    const numSamples = Math.floor(secPerBeat * 0.95 * SAMPLE_RATE);
+
+    for (let i = 0; i < numSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+      const attack = Math.min(1.0, t * 50.0);
+      const env = Math.exp(-t * 3.2);
+
+      // Acoustic upright bass: fundamental sine + warm triangle pluck
+      const sample = (sine(f * t) * 0.70 + triangle(f * t) * 0.30) * attack * env * 0.28;
+      left[idx] += sample;
+      right[idx] += sample;
+    }
+  }
+
+  // 3. Brushed Jazz Swing Cymbal Pattern (Spang-a-lang ride cymbal swing) - joins at Tier 2
+  //
+  // The brush noise has a stream of its own rather than sharing the file's.
+  // It is the only layer here that draws at all, and it draws from inside a
+  // tier gate - so a shared stream would sit one tier-dependent number of
+  // draws ahead of anything added after it, and tier 1 would quietly stop
+  // being the same piece as tier 3. Scoping it makes that impossible rather
+  // than merely untrue today. Same seed and same draw order as before, so the
+  // audio is unchanged.
+  const brushRng = ornamentRng(seed);
+  for (let i = 0; tier >= 2 && i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const beatPos = (t / secPerBeat) % 1.0;
+    // Classic jazz triplet swing tap (on the beat and on beatPos ~ 0.66)
+    const isBeat = beatPos < 0.04;
+    const isSwingTap = beatPos > 0.64 && beatPos < 0.68;
+
+    if (isBeat || isSwingTap) {
+      const relT = isBeat ? beatPos : beatPos - 0.64;
+      const env = Math.max(0.0, 1.0 - relT / 0.04);
+      const n = (brushRng() * 2.0 - 1.0) * env * (isBeat ? 0.04 : 0.025);
+      left[i] += n * 0.7;
+      right[i] += n * 1.2;
+    }
+  }
+
+  // Tier 3: sparse upper-register piano stabs for long prompts
+  if (tier >= 3) {
+    const stabRng = ornamentRng(seed ^ 0x5f356495);
+    const stabs = [1.7, 3.4, 5.6, 7.1].map((beat) => ({ note: pick(stabRng, STAB_NOTES), beat }));
+
+    for (const stab of stabs) {
+      const f = noteToFreq(stab.note);
+      const startIdx = Math.floor(stab.beat * secPerBeat * SAMPLE_RATE);
+      const numSamples = Math.floor(0.9 * secPerBeat * SAMPLE_RATE);
+
+      for (let i = 0; i < numSamples; i++) {
+        const idx = startIdx + i;
+        if (idx >= totalSamples) break;
+        const t = i / SAMPLE_RATE;
+        const env = Math.min(1.0, t * 60.0) * Math.exp(-t * 2.6);
+        const sample = (sine(f * t) * 0.8 + sine(f * 2.0 * t) * 0.2) * env * 0.075;
+
+        left[idx] += sample * 1.1;
+        right[idx] += sample * 0.9;
+      }
+    }
+  }
+
+  // 4. Warm Room Stereo Reverb
+  const delayL = Math.floor(0.22 * SAMPLE_RATE);
+  const delayR = Math.floor(0.31 * SAMPLE_RATE);
+  const feedback = 0.24;
+
+  for (let i = 0; i < totalSamples; i++) {
+    if (i >= delayL) left[i] += right[i - delayL] * feedback;
+    if (i >= delayR) right[i] += left[i - delayR] * feedback;
+  }
+
+  // Boundary fade
+  const fadeLen = Math.floor(0.08 * SAMPLE_RATE);
+  for (let i = 0; i < fadeLen; i++) {
+    const s = i / fadeLen;
+    left[i] *= s;
+    right[i] *= s;
+    left[totalSamples - 1 - i] *= s;
+    right[totalSamples - 1 - i] *= s;
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+module.exports = { generateJazzLoop };

package/src/synth/lofi.js

@@ -0,0 +1,148 @@
+/**
+ * Lo-Fi Focus Procedural Synth Engine
+ * Warm Rhodes Electric Piano (Major 9th chords) + Soothing Kalimba & Stereo Delay
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  makeRng,
+  pick,
+  ornamentRng,
+  createWavBuffer
+} = require("./generator");
+
+// Hand-written variants, all diatonic to C major so any pairing stays
+// consonant. The seed chooses one; it never invents harmony.
+const PROGRESSIONS = [
+  [["F2", "A3", "C4", "E4", "G4"], ["C2", "G3", "B3", "D4", "E4"]], // Fmaj9 -> Cmaj9
+  [["D2", "F3", "A3", "C4", "E4"], ["G2", "B3", "D4", "F4", "A4"]], // Dm9  -> G11
+  [["A2", "C3", "E3", "G3", "B3"], ["F2", "A3", "C4", "E4", "G4"]]  // Am9  -> Fmaj9
+];
+
+// Upper-register C-major tones for the kalimba to land on.
+const DROP_NOTES = ["C5", "D5", "E5", "G5", "A5", "B5", "C6"];
+const SHIMMER_NOTES = ["E6", "G6", "A6", "B6"];
+
+function generateLofiLoop(durationSec = 6.4, tier = 2, seed = 0) {
+  const rng = makeRng(seed);
+  const progression = pick(rng, PROGRESSIONS);
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  // Rhodes chord renderer with soft tremolo & harmonic overtones
+  function addRhodesChord(chordNotes, startSec, durSec, vel = 0.18) {
+    const startIdx = Math.floor(startSec * SAMPLE_RATE);
+    const numSamples = Math.floor(durSec * SAMPLE_RATE);
+
+    for (const note of chordNotes) {
+      const f = noteToFreq(note);
+      for (let i = 0; i < numSamples; i++) {
+        const idx = startIdx + i;
+        if (idx >= totalSamples) break;
+        const t = i / SAMPLE_RATE;
+
+        const attack = Math.min(1.0, t * 35.0);
+        const body = Math.exp(-t * 0.95);
+        const tine = Math.exp(-t * 8.5);
+
+        // Gentle stereo tremolo (3.5 Hz)
+        const tremL = 1.0 + 0.15 * Math.sin(2 * Math.PI * 3.5 * t);
+        const tremR = 1.0 + 0.15 * Math.cos(2 * Math.PI * 3.5 * t);
+
+        const sample = (
+          Math.sin(2 * Math.PI * f * t) * 0.74 +
+          Math.sin(2 * Math.PI * 2.0 * f * t) * 0.22 * body +
+          Math.sin(2 * Math.PI * 3.0 * f * t) * 0.08 * tine
+        ) * attack * body * vel;
+
+        left[idx] += sample * tremL;
+        right[idx] += sample * tremR;
+      }
+    }
+  }
+
+  // Wooden Kalimba bell note renderer
+  function addKalimba(note, startSec, pan = 0.5, vel = 0.14) {
+    const f = noteToFreq(note);
+    const startIdx = Math.floor(startSec * SAMPLE_RATE);
+    const numSamples = Math.floor(1.6 * SAMPLE_RATE);
+
+    for (let i = 0; i < numSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+      const env = Math.exp(-t * 3.6);
+      const strike = Math.exp(-t * 18.0);
+
+      const sample = (
+        Math.sin(2 * Math.PI * f * t) * 0.85 +
+        Math.sin(2 * Math.PI * 2.76 * f * t) * 0.15 * strike
+      ) * env * vel;
+
+      left[idx] += sample * (1.0 - pan);
+      right[idx] += sample * pan;
+    }
+  }
+
+  const chordVel = tier === 1 ? 0.16 : tier === 3 ? 0.22 : 0.19;
+  const half = durationSec / 2;
+  addRhodesChord(progression[0], 0.0, half, chordVel);
+  addRhodesChord(progression[1], half, half, chordVel);
+
+  // Drawn regardless of tier so every tier ornaments the same piece.
+  const orn = ornamentRng(seed);
+  const drops = [0.5, 1.2, 1.8, 2.5, 3.7, 4.4, 5.1, 5.8].map((time) => ({
+    note: pick(orn, DROP_NOTES),
+    time,
+    pan: 0.3 + orn() * 0.4
+  }));
+  const shimmer = [0.8, 2.1, 3.9, 4.9].map((time) => ({
+    note: pick(orn, SHIMMER_NOTES),
+    time,
+    pan: 0.3 + orn() * 0.4
+  }));
+
+  // Kalimba drops activate on Tier 2 and Tier 3
+  if (tier >= 2) {
+    for (const d of drops) {
+      addKalimba(d.note, d.time, d.pan, 0.14);
+    }
+  }
+
+  // Tier 3: Higher octave shimmer drops (richer energy for long prompts)
+  if (tier >= 3) {
+    for (const s of shimmer) {
+      addKalimba(s.note, s.time, s.pan, 0.09);
+    }
+  }
+
+  // Warm stereo delay feedback
+  const delayL = Math.floor(0.24 * SAMPLE_RATE);
+  const delayR = Math.floor(0.32 * SAMPLE_RATE);
+  const feedback = 0.28;
+
+  for (let i = 0; i < totalSamples; i++) {
+    if (i >= delayL) {
+      left[i] += left[i - delayL] * feedback;
+    }
+    if (i >= delayR) {
+      right[i] += right[i - delayR] * feedback;
+    }
+  }
+
+  // Soft master boundary fades for seamless looping
+  const fadeLen = Math.floor(0.08 * SAMPLE_RATE);
+  for (let i = 0; i < fadeLen; i++) {
+    const s = i / fadeLen;
+    left[i] *= s;
+    right[i] *= s;
+    left[totalSamples - 1 - i] *= s;
+    right[totalSamples - 1 - i] *= s;
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+module.exports = { generateLofiLoop };

package/src/synth/piano.js

@@ -0,0 +1,158 @@
+/**
+ * Sparse Piano Procedural Synth Engine
+ * Single struck notes, long silences, no pulse — the reading-room genre.
+ *
+ * Every other melodic genre keeps something moving underneath (a bass line, a
+ * pad, an arpeggio). This one is mostly rest: two or three notes decaying into
+ * a room. Tiers add notes into the existing silence rather than adding layers
+ * on top, so escalation never turns it into a piece with a groove.
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  sine,
+  makeRng,
+  pick,
+  ornamentRng,
+  createWavBuffer
+} = require("./generator");
+
+// Three curated resting points, each a slow two-chord motion with the melody
+// pool that belongs to it. As everywhere else, the seed chooses among these -
+// it never picks notes freely, which is what keeps it from wandering off key.
+const PIANO_VARIANTS = [
+  {
+    // A minor - the darkest of the three
+    bass: ["A1", "F1"],
+    notes: ["A3", "C4", "E4", "G4", "A4", "B4", "E5"]
+  },
+  {
+    // C major - open and plain
+    bass: ["C2", "G1"],
+    notes: ["C4", "E4", "G4", "A4", "C5", "D5", "E5"]
+  },
+  {
+    // D minor 7 moving to G - the one with a little pull to it
+    bass: ["D2", "G1"],
+    notes: ["D4", "F4", "A4", "C5", "D5", "E5", "A5"]
+  }
+];
+
+/**
+ * A struck string is a fundamental plus partials that die faster the higher
+ * they are, and real piano partials sit slightly sharp of whole multiples.
+ * Without that inharmonicity the same envelope reads as a bell, not a piano.
+ */
+const PARTIALS = [
+  { mult: 1.0, amp: 1.0, decay: 0.85 },
+  { mult: 2.004, amp: 0.36, decay: 1.5 },
+  { mult: 3.012, amp: 0.15, decay: 2.3 },
+  { mult: 4.028, amp: 0.075, decay: 3.3 },
+  { mult: 5.05, amp: 0.035, decay: 4.5 }
+];
+
+function generatePianoLoop(durationSec = 7.6, tier = 2, seed = 0) {
+  const rng = makeRng(seed);
+  const variant = pick(rng, PIANO_VARIANTS);
+
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  /**
+   * One struck note. `velocity` also opens the tone slightly - a harder strike
+   * on a real piano is brighter, not just louder - so the loud notes don't
+   * sound like the quiet ones turned up.
+   */
+  function strike(freq, startSec, velocity, pan) {
+    const startIdx = Math.floor(startSec * SAMPLE_RATE);
+    const ringSamples = Math.floor(5.0 * SAMPLE_RATE);
+    const attackSamples = Math.floor(0.004 * SAMPLE_RATE);
+    const brightness = 0.55 + velocity * 0.45;
+
+    for (let i = 0; i < ringSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+
+      let sample = 0;
+      for (let p = 0; p < PARTIALS.length; p++) {
+        const { mult, amp, decay } = PARTIALS[p];
+        // Upper partials are scaled by brightness, the fundamental never is.
+        const weight = p === 0 ? amp : amp * brightness;
+        sample += sine(freq * mult * t) * weight * Math.exp(-t * decay);
+      }
+
+      const attack = i < attackSamples ? i / attackSamples : 1.0;
+      const out = sample * attack * velocity * 0.59;
+
+      left[idx] += out * (1.0 - pan);
+      right[idx] += out * pan;
+    }
+  }
+
+  // Drawn before any tier gating, in a fixed order, so tier 3 is the same
+  // piece as tier 1 with more of it - not a different arrangement.
+  const orn = ornamentRng(seed);
+  const melody = [0.25, 3.10, 1.55, 5.20, 4.15, 6.40].map((time) => ({
+    note: pick(orn, variant.notes),
+    time,
+    // Hand-placed rubato: never exactly on a grid, never far enough off to
+    // sound wrong.
+    offset: (orn() - 0.5) * 0.12,
+    velocity: 0.55 + orn() * 0.35,
+    pan: 0.38 + orn() * 0.24
+  }));
+
+  // Tier 1 is two notes in eight seconds. That is the point of the genre.
+  const melodyCount = tier === 1 ? 2 : tier === 2 ? 4 : 6;
+  for (let i = 0; i < melodyCount; i++) {
+    const m = melody[i];
+    strike(noteToFreq(m.note), Math.max(0, m.time + m.offset), m.velocity, m.pan);
+  }
+
+  // The left hand: one low octave that spells the change, struck softly and
+  // left to ring. The second one only arrives once there is enough going on
+  // above it to justify a move.
+  strike(noteToFreq(variant.bass[0]), 0.05, 0.42, 0.5);
+  if (tier >= 2) strike(noteToFreq(variant.bass[1]), 3.85, 0.36, 0.5);
+
+  // Tier 3 adds sustain rather than notes: the una corda pedal held down, so
+  // the room itself gets fuller while the playing stays as sparse as before.
+  if (tier >= 3) {
+    const pedalF = noteToFreq(variant.bass[0]) * 0.5;
+    for (let i = 0; i < totalSamples; i++) {
+      const t = i / SAMPLE_RATE;
+      const swell = 0.55 + 0.45 * Math.sin(2 * Math.PI * 0.09 * t);
+      const sample = (sine(pedalF * t) * 0.75 + sine(pedalF * 2 * t) * 0.25) * swell * 0.105;
+      left[i] += sample;
+      right[i] += sample;
+    }
+  }
+
+  // Room tone. Longer and quieter than zen's - a piano in a hall, not a bowl
+  // in a cave.
+  const delayL = Math.floor(0.37 * SAMPLE_RATE);
+  const delayR = Math.floor(0.51 * SAMPLE_RATE);
+  const feedback = 0.26;
+
+  for (let i = 0; i < totalSamples; i++) {
+    if (i >= delayL) left[i] += right[i - delayL] * feedback;
+    if (i >= delayR) right[i] += left[i - delayR] * feedback;
+  }
+
+  // Seamless crossfade boundary
+  const fadeLen = Math.floor(0.12 * SAMPLE_RATE);
+  for (let i = 0; i < fadeLen; i++) {
+    const s = i / fadeLen;
+    left[i] *= s;
+    right[i] *= s;
+    left[totalSamples - 1 - i] *= s;
+    right[totalSamples - 1 - i] *= s;
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+module.exports = { generatePianoLoop };