vibeaudio 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeaudio",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Procedural focus music while your AI coding tools (Claude Code, Codex, Cursor, Grok, Gemini, Copilot) think \u2014 a different arrangement per project.",
   "bin": {
     "vibeaudio": "bin/vibeaudio.js",

package/src/synth/chiptune.js

@@ -64,16 +64,26 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
     const startIdx = Math.floor(m.start * secPerBeat * SAMPLE_RATE);
     const numSamples = Math.floor(m.dur * secPerBeat * SAMPLE_RATE);
 
+    // Accumulated, for the same reason as the arpeggio below, plus one of its
+    // own: `softPulse((f + vib) * t)` is not vibrato but a phase that jumps
+    // when the vibrato switches on at t > 0.15 - by (vib * 0.15) cycles, once
+    // per note. Accumulating makes `vib` an actual frequency deviation of
+    // +/-3.5Hz, which is what it was meant to be, and the switch-on changes
+    // only the rate.
+    let leadPhase = 0.0;
+
     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;
+      const sample = softPulse(leadPhase) * env * 0.22;
 
       left[idx] += sample;
       right[idx] += sample;
+
+      leadPhase += (f + vib) / SAMPLE_RATE;
     }
   }
 
@@ -81,6 +91,22 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
   const chords = variant.chords;
   const arpSpeed = 0.075;
 
+  // The phase is accumulated, not computed as `f * t`.
+  //
+  // This arpeggio steps to a new note every 75ms and has no envelope at all -
+  // it is meant to run continuously. With `softPulse(f * t)`, changing f while
+  // t keeps running jumps the phase by (f2 - f1) * t: hundreds of cycles a few
+  // seconds in, which lands the waveform on an arbitrary value. That is a
+  // click, 13 times a second, with no envelope to hide it - reported as static
+  // on 8bit, and at tier 1 every single step over 0.05 full-scale landed
+  // exactly on one of these boundaries.
+  //
+  // Accumulating instead means a new note changes the *rate* the phase
+  // advances, never its value, so the waveform stays continuous across the
+  // step. It is also how a real oscillator behaves.
+  let arpPhase = 0.0;
+  let shimmerPhase = 0.0;
+
   for (let i = 0; i < totalSamples; i++) {
     const t = i / SAMPLE_RATE;
     const beat = Math.floor(t / secPerBeat);
@@ -88,17 +114,20 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
     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);
+    const sample = softPulse(arpPhase) * (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;
+      const shimmer = softPulse(shimmerPhase) * 0.03;
       left[i] += shimmer * 1.1;
       right[i] += shimmer * 0.9;
     }
+
+    arpPhase += f / SAMPLE_RATE;
+    shimmerPhase += (f * 2.0) / SAMPLE_RATE;
   }
 
   // 3. NES Triangle Bass