vibeaudio 0.4.0

package/src/synth/chime.js

@@ -0,0 +1,137 @@
+/**
+ * Delicate Glassy Resolution Completion Chime
+ * Harmonic Bell Decay (C5, G5, C6, E6)
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  sine,
+  createWavBuffer
+} = require("./generator");
+
+function generateSuccessChime(durationSec = 1.6) {
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  const chimeNotes = [
+    { note: "C5", delay: 0.00, pan: 0.4 },
+    { note: "G5", delay: 0.09, pan: 0.6 },
+    { note: "C6", delay: 0.18, pan: 0.45 },
+    { note: "E6", delay: 0.27, pan: 0.55 }
+  ];
+
+  for (const c of chimeNotes) {
+    const f = noteToFreq(c.note);
+    const startIdx = Math.floor(c.delay * SAMPLE_RATE);
+    const ringSamples = Math.floor(1.2 * SAMPLE_RATE);
+
+    for (let i = 0; i < ringSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+      const env = Math.exp(-t * 4.2);
+
+      // Sine fundamental + soft sparkling 2nd & 3rd harmonics
+      const sample = (
+        sine(f * t) * 0.72 +
+        sine(f * 2.0 * t) * 0.22 * Math.exp(-t * 8.0) +
+        sine(f * 3.0 * t) * 0.06 * Math.exp(-t * 14.0)
+      ) * env * 0.24;
+
+      left[idx] += sample * (1.0 - c.pan);
+      right[idx] += sample * c.pan;
+    }
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+function generateFailureChime(durationSec = 1.8) {
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  // Soft, contemplative descending minor chord (A4 -> F4 -> D4)
+  const minorNotes = [
+    { note: "A4", delay: 0.00, pan: 0.4 },
+    { note: "F4", delay: 0.12, pan: 0.6 },
+    { note: "D4", delay: 0.24, pan: 0.5 }
+  ];
+
+  for (const c of minorNotes) {
+    const f = noteToFreq(c.note);
+    const startIdx = Math.floor(c.delay * SAMPLE_RATE);
+    const ringSamples = Math.floor(1.4 * SAMPLE_RATE);
+
+    for (let i = 0; i < ringSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+      const env = Math.exp(-t * 3.2);
+
+      // Warmer, darker harmonic structure
+      const sample = (
+        sine(f * t) * 0.75 +
+        sine(f * 2.0 * t) * 0.18 * Math.exp(-t * 6.0) +
+        sine(f * 0.5 * t) * 0.12 * Math.exp(-t * 2.0)
+      ) * env * 0.23;
+
+      left[idx] += sample * (1.0 - c.pan);
+      right[idx] += sample * c.pan;
+    }
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+/**
+ * "Your turn": the agent is blocked on the user. It must not be mistaken for
+ * either outcome - success resolves downward onto the tonic and failure
+ * descends in minor, so this one rises by an open fifth and stops there,
+ * unresolved, twice. A question rather than an answer.
+ */
+function generateAttentionChime(durationSec = 1.3) {
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  const askNotes = [
+    { note: "E5", delay: 0.00, pan: 0.45 },
+    { note: "B5", delay: 0.13, pan: 0.55 },
+    { note: "E5", delay: 0.42, pan: 0.45 },
+    { note: "B5", delay: 0.55, pan: 0.55 }
+  ];
+
+  for (const c of askNotes) {
+    const f = noteToFreq(c.note);
+    const startIdx = Math.floor(c.delay * SAMPLE_RATE);
+    const ringSamples = Math.floor(0.7 * SAMPLE_RATE);
+
+    for (let i = 0; i < ringSamples; i++) {
+      const idx = startIdx + i;
+      if (idx >= totalSamples) break;
+      const t = i / SAMPLE_RATE;
+      // Shorter ring than the outcome chimes: a tap on the shoulder, not a bell.
+      const env = Math.exp(-t * 7.0);
+
+      const sample = (
+        sine(f * t) * 0.78 +
+        sine(f * 2.0 * t) * 0.16 * Math.exp(-t * 12.0)
+      ) * env * 0.28;
+
+      left[idx] += sample * (1.0 - c.pan);
+      right[idx] += sample * c.pan;
+    }
+  }
+
+  return createWavBuffer({ left, right, sampleRate: SAMPLE_RATE });
+}
+
+module.exports = {
+  generateChime: generateSuccessChime,
+  generateSuccessChime,
+  generateFailureChime,
+  generateAttentionChime
+};

package/src/synth/chiptune.js

@@ -0,0 +1,132 @@
+/**
+ * Cozy 8-Bit Chiptune Procedural Synth Engine
+ * Filtered/Softened Pulse Lead + Shimmering Arpeggios + NES Triangle Bass
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  softPulse,
+  triangle,
+  makeRng,
+  pick,
+  createWavBuffer
+} = require("./generator");
+
+// Each variant pairs a melodic contour with the chord/bass cycle it sits over,
+// so the lead always agrees with the arpeggio underneath it.
+const VARIANTS = [
+  {
+    motif: ["E5", "G5", "A5", "C6", "B5", "G5", "E5", "F5", "A5", "C6", "D6", "B5"],
+    chords: [["C4", "E4", "G4", "C5"], ["G3", "B3", "D4", "G4"], ["A3", "C4", "E4", "A4"], ["F3", "A3", "C4", "F4"]],
+    bass: ["C3", "G2", "A2", "F2"]
+  },
+  {
+    motif: ["A5", "C6", "B5", "A5", "G5", "E5", "G5", "A5", "F5", "A5", "G5", "E5"],
+    chords: [["A3", "C4", "E4", "A4"], ["F3", "A3", "C4", "F4"], ["C4", "E4", "G4", "C5"], ["G3", "B3", "D4", "G4"]],
+    bass: ["A2", "F2", "C3", "G2"]
+  },
+  {
+    motif: ["G5", "A5", "B5", "D6", "C6", "A5", "G5", "E5", "G5", "B5", "C6", "A5"],
+    chords: [["G3", "B3", "D4", "G4"], ["C4", "E4", "G4", "C5"], ["F3", "A3", "C4", "F4"], ["A3", "C4", "E4", "A4"]],
+    bass: ["G2", "C3", "F2", "A2"]
+  }
+];
+
+function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
+  const variant = pick(makeRng(seed), VARIANTS);
+  const bpm = 128;
+  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. Melody Events - the rhythm stays fixed, the seed picks the contour.
+  const RHYTHM = [
+    [0.0, 0.45], [0.5, 0.45], [1.0, 0.45], [1.5, 0.70], [2.5, 0.45],
+    [3.0, 0.45], [3.5, 0.45], [4.0, 0.45], [4.5, 0.45], [5.0, 0.45],
+    [5.5, 0.70], [6.5, 0.45], [7.0, 0.80], [8.0, 0.45], [8.5, 0.45],
+    [9.0, 0.45], [9.5, 0.70], [10.5, 0.45], [11.0, 0.45], [11.5, 0.70],
+    [12.5, 0.45], [13.0, 0.45], [13.5, 0.45], [14.0, 0.45], [14.5, 0.85]
+  ];
+  const melodyEvents = RHYTHM.map(([start, dur], i) => ({
+    note: variant.motif[i % variant.motif.length],
+    start,
+    dur
+  }));
+
+  // Melody lead joins at Tier 2 (Tier 1 stays on arpeggio + bass only)
+  for (const m of tier >= 2 ? melodyEvents : []) {
+    const f = noteToFreq(m.note);
+    const startIdx = Math.floor(m.start * secPerBeat * SAMPLE_RATE);
+    const numSamples = Math.floor(m.dur * 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 * 75.0) * Math.max(0.0, 1.0 - (t / (m.dur * secPerBeat)));
+      const vib = t > 0.15 ? Math.sin(2 * Math.PI * 5.5 * t) * 3.5 : 0.0;
+      const sample = softPulse((f + vib) * t) * env * 0.22;
+
+      left[idx] += sample;
+      right[idx] += sample;
+    }
+  }
+
+  // 2. Chords for Retro Arpeggiation
+  const chords = variant.chords;
+  const arpSpeed = 0.075;
+
+  for (let i = 0; i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const beat = Math.floor(t / secPerBeat);
+    const chordIdx = Math.floor(beat / 4) % chords.length;
+    const chord = chords[chordIdx];
+    const noteIdx = Math.floor(t / arpSpeed) % chord.length;
+    const f = noteToFreq(chord[noteIdx]);
+    const sample = softPulse(f * t) * (tier === 1 ? 0.09 : 0.075);
+
+    left[i] += sample * 0.85;
+    right[i] += sample * 0.85;
+
+    // Tier 3: octave-up shimmer arpeggio doubling
+    if (tier >= 3) {
+      const shimmer = softPulse(f * 2.0 * t) * 0.03;
+      left[i] += shimmer * 1.1;
+      right[i] += shimmer * 0.9;
+    }
+  }
+
+  // 3. NES Triangle Bass
+  const bassNotes = variant.bass;
+  for (let i = 0; i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const beat = Math.floor(t / secPerBeat);
+    const chordIdx = Math.floor(beat / 4) % bassNotes.length;
+    const f = noteToFreq(bassNotes[chordIdx]);
+    const tNote = (t % secPerBeat);
+    const env = Math.min(1.0, tNote * 40.0) * Math.max(0.0, 1.0 - Math.pow(tNote / secPerBeat, 0.6));
+    const sample = triangle(f * t) * env * 0.24;
+
+    left[i] += sample;
+    right[i] += sample;
+  }
+
+  // Fade boundaries
+  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 = { generateChiptuneLoop };

package/src/synth/drone.js

@@ -0,0 +1,133 @@
+/**
+ * Deep Drone / Filtered Noise Procedural Synth Engine
+ * A held fundamental + slow-swept noise bed. No notes, no rhythm, no melody.
+ *
+ * Every other genre plays something. This one deliberately doesn't: it exists
+ * for people who find any melodic line distracting, where the goal is a floor
+ * of sound to mask a room rather than music to listen past.
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  sine,
+  makeRng,
+  pick,
+  ornamentRng,
+  createWavBuffer
+} = require("./generator");
+
+// A drone has no progression to clash with, so the seed picks its colour
+// rather than its harmony: a root, the interval stacked above it, and how
+// bright the noise bed sits.
+const DRONE_VARIANTS = [
+  { root: "D1", partial: 1.5, cutoff: 0.055, label: "deep fifth" },   // D + A
+  { root: "A1", partial: 1.5, cutoff: 0.040, label: "dark fifth" },   // A + E
+  { root: "E1", partial: 1.335, cutoff: 0.070, label: "open fourth" } // E + A
+];
+
+function generateDroneLoop(durationSec = 7.0, tier = 2, seed = 0) {
+  // Drawn before any tier gating, so gating a layer can't shift these.
+  const orn = ornamentRng(seed);
+  const variant = pick(orn, DRONE_VARIANTS);
+  const sweepDepth = 0.55 + orn() * 0.35;
+  const breathOffset = orn() * Math.PI * 2;
+
+  const totalSamples = Math.floor(SAMPLE_RATE * durationSec);
+  const left = new Float64Array(totalSamples);
+  const right = new Float64Array(totalSamples);
+
+  const rootHz = noteToFreq(variant.root);
+
+  // 1. Noise bed, one-pole lowpassed into brown noise and slowly swept.
+  //    The sweep runs exactly twice per loop so it lines up at the boundary.
+  //    Generated identically at every tier: the rng stream must not depend on
+  //    tier, or the same seed would render a different bed as time passes.
+  const noiseRng = makeRng(seed ^ 0x9e3779b9);
+  let lpL = 0;
+  let lpR = 0;
+  const sweepHz = 2 / durationSec;
+
+  for (let i = 0; i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    // Two uncorrelated streams, so the bed is wide rather than centred.
+    const nL = noiseRng() * 2 - 1;
+    const nR = noiseRng() * 2 - 1;
+
+    // Cutoff breathes between roughly half and full openness.
+    const sweep = 0.5 + 0.5 * sine(sweepHz * t + breathOffset / (2 * Math.PI));
+    const k = variant.cutoff * (1 - sweepDepth + sweepDepth * sweep);
+
+    lpL += k * (nL - lpL);
+    lpR += k * (nR - lpR);
+
+    // Brown noise is far quieter than white after filtering, so it needs
+    // making up - but only to the level the melodic genres sit at. Measured
+    // against jazz (peak 0.64, RMS 0.108); these land at 0.43-0.61 / 0.084-0.128.
+    const bedGain = tier === 1 ? 1.02 : tier === 3 ? 1.38 : 1.2;
+    left[i] += lpL * bedGain;
+    right[i] += lpR * bedGain;
+  }
+
+  // 2. The fundamental, held for the whole loop. Two voices a few cents apart
+  //    beat slowly against each other, which is what keeps a held note from
+  //    sounding like a test tone.
+  const rootGain = tier === 1 ? 0.072 : tier === 3 ? 0.108 : 0.09;
+  for (let i = 0; i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const a = sine(rootHz * 0.9985 * t);
+    const b = sine(rootHz * 1.0015 * t);
+    const body = (a + b) * 0.5 + sine(rootHz * 2 * t) * 0.12;
+    left[i] += body * rootGain;
+    right[i] += body * rootGain;
+  }
+
+  // 3. Tier 2+: the stacked interval, panned wide. No new notes - the same
+  //    drone gains a partial, so escalation is felt as weight, not movement.
+  if (tier >= 2) {
+    const partialHz = rootHz * variant.partial;
+    const gain = tier === 3 ? 0.0675 : 0.0495;
+    for (let i = 0; i < totalSamples; i++) {
+      const t = i / SAMPLE_RATE;
+      left[i] += sine(partialHz * 0.999 * t) * gain;
+      right[i] += sine(partialHz * 1.001 * t) * gain;
+    }
+  }
+
+  // 4. Tier 3 only: a high shimmer that swells once across the loop, the one
+  //    thing in this genre that changes over time.
+  if (tier === 3) {
+    const shimmerHz = rootHz * 6;
+    for (let i = 0; i < totalSamples; i++) {
+      const t = i / SAMPLE_RATE;
+      const swell = 0.5 - 0.5 * Math.cos((2 * Math.PI * t) / durationSec);
+      const s = sine(shimmerHz * t) * 0.035 * swell;
+      left[i] += s;
+      right[i] -= s;
+    }
+  }
+
+  // 5. Wide, slow reverberation - the tail is most of what makes a drone feel
+  //    like a space rather than an oscillator.
+  const delayL = Math.floor(0.38 * SAMPLE_RATE);
+  const delayR = Math.floor(0.51 * SAMPLE_RATE);
+  const feedback = 0.34;
+  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 = { generateDroneLoop };

package/src/synth/electronic.js

@@ -0,0 +1,133 @@
+/**
+ * Melodic Electronic / Downtempo Procedural Synth Engine
+ * Resonant Pluck Arpeggio + Warm Electronic Sub-Bass + Subtle Tech Pulse
+ */
+
+const {
+  SAMPLE_RATE,
+  noteToFreq,
+  analogSaw,
+  softPulse,
+  triangle,
+  sine,
+  makeRng,
+  pick,
+  ornamentRng,
+  createWavBuffer
+} = require("./generator");
+
+// D dorian throughout; each pluck figure ships with the bass cycle that
+// harmonises it.
+const VARIANTS = [
+  {
+    pluck: ["D4", "A4", "F4", "C5", "D4", "G4", "A4", "F4", "A#3", "F4", "D4", "A4"],
+    bass: ["D2", "D2", "A#1", "C2"]
+  },
+  {
+    pluck: ["A4", "D5", "C5", "A4", "F4", "A4", "G4", "D4", "F4", "C5", "A4", "G4"],
+    bass: ["A1", "F2", "C2", "G2"]
+  },
+  {
+    pluck: ["F4", "A4", "C5", "A4", "G4", "D5", "C5", "A4", "D4", "F4", "A4", "G4"],
+    bass: ["F2", "C2", "D2", "A#1"]
+  }
+];
+
+function generateElectronicLoop(durationSec = 6.4, tier = 2, seed = 0) {
+  const variant = pick(makeRng(seed), VARIANTS);
+  const orn = ornamentRng(seed);
+  const bpm = 116;
+  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. Resonant Electronic Pluck Synth (Dorian / Melodic Minor)
+  // Notes: D4, F4, G4, A4, C5, D5
+  const pluckSeq = variant.pluck.map((note, step) => ({ note, step }));
+
+  const stepSec = secPerBeat / 2.0; // 8th notes
+
+  for (let i = 0; i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const currentStep = Math.floor(t / stepSec) % 16;
+    const activePluck = pluckSeq.find((p) => p.step === currentStep % pluckSeq.length);
+
+    if (activePluck) {
+      const f = noteToFreq(activePluck.note);
+      const tNote = t % stepSec;
+      // Fast exponential decay filter simulation
+      const filterCutoff = Math.exp(-tNote * 14.0);
+      const env = Math.exp(-tNote * 7.0);
+
+      // Resonant pluck wave: mixture of soft pulse and harmonics modulated by filter cutoff
+      const osc = softPulse(f * t) * 0.7 + analogSaw(f * t) * 0.3 * filterCutoff;
+      const sample = osc * env * (tier === 1 ? 0.19 : 0.16);
+
+      const pan = 0.5 + 0.3 * Math.sin(2 * Math.PI * 0.8 * t);
+      left[i] += sample * (1.0 - pan);
+      right[i] += sample * pan;
+
+      // Tier 3: octave-up counter-pluck for peak energy
+      if (tier >= 3) {
+        const counter = softPulse(f * 2.0 * t) * env * 0.05;
+        left[i] += counter * pan;
+        right[i] += counter * (1.0 - pan);
+      }
+    }
+  }
+
+  // 2. Electronic Sub-Bass (Deep and punchy) - joins at Tier 2
+  const bassSeq = variant.bass;
+  for (let i = 0; tier >= 2 && i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const bar = Math.floor(t / (secPerBeat * 2.0)) % bassSeq.length;
+    const f = noteToFreq(bassSeq[bar]);
+    const tBeat = t % secPerBeat;
+    const env = Math.exp(-tBeat * 4.5);
+
+    // Deep sine sub + triangle warmth
+    const sub = (sine(f * t) * 0.75 + triangle(f * t) * 0.25) * env * 0.28;
+    left[i] += sub;
+    right[i] += sub;
+  }
+
+  // 3. Subtle Tech Glitch/Percussion Pulse (Rhythmic noise blips) - joins at Tier 2
+  for (let i = 0; tier >= 2 && i < totalSamples; i++) {
+    const t = i / SAMPLE_RATE;
+    const t16 = t % (secPerBeat / 4.0);
+    if (t16 < 0.015) {
+      const n = (orn() * 2.0 - 1.0) * (1.0 - t16 / 0.015);
+      const sample = n * 0.045;
+      left[i] += sample;
+      right[i] += sample;
+    }
+  }
+
+  // 4. Stereo Ping-Pong Echo
+  const delayL = Math.floor(0.26 * SAMPLE_RATE);
+  const delayR = Math.floor(0.39 * 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;
+  }
+
+  // Smooth loop 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 = { generateElectronicLoop };