elektron-lfo 1.0.9 → 1.0.11

package/dist/index.js

@@ -66,7 +66,7 @@ function generateSquare(phase) {
   return phase < 0.5 ? 1 : -1;
 }
 function generateSawtooth(phase) {
-  return phase * 2 - 1;
+  return 1 - phase * 2;
 }
 function generateExponential(phase) {
   const k = 3;
@@ -345,7 +345,15 @@ function calculateFadeMultiplier(fadeValue, fadeProgress) {
 function calculateFadeCycles(fadeValue) {
   if (fadeValue === 0)
     return 0;
-  return 128 / Math.abs(fadeValue);
+  const absFade = Math.abs(fadeValue);
+  if (absFade >= 48) {
+    return Infinity;
+  }
+  if (absFade <= 16) {
+    return Math.max(0.5, absFade / 6);
+  }
+  const baseAt16 = 16 / 6;
+  return baseAt16 * Math.pow(2, (absFade - 16) / 5);
 }
 function updateFade(config, state, cycleTimeMs, deltaMs) {
   if (config.fade === 0 || config.mode === "FRE") {
@@ -355,8 +363,14 @@ function updateFade(config, state, cycleTimeMs, deltaMs) {
     };
   }
   const fadeCycles = calculateFadeCycles(config.fade);
+  if (!isFinite(fadeCycles)) {
+    return {
+      fadeProgress: 0,
+      fadeMultiplier: 0
+    };
+  }
   const fadeDurationMs = fadeCycles * cycleTimeMs;
-  if (fadeDurationMs === 0 || fadeDurationMs === Infinity) {
+  if (fadeDurationMs === 0) {
     return {
       fadeProgress: 1,
       fadeMultiplier: config.fade < 0 ? 0 : 1
@@ -373,6 +387,10 @@ function resetFade(config) {
   if (config.fade === 0) {
     return { fadeProgress: 1, fadeMultiplier: 1 };
   }
+  const fadeCycles = calculateFadeCycles(config.fade);
+  if (!isFinite(fadeCycles)) {
+    return { fadeProgress: 0, fadeMultiplier: 0 };
+  }
   if (config.fade < 0) {
     return { fadeProgress: 0, fadeMultiplier: 0 };
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elektron-lfo",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Elektron LFO engine simulator implementation with CLI visualization",
   "main": "dist/index.js",
   "module": "src/index.ts",

package/src/engine/fade.ts

@@ -47,22 +47,38 @@ export function calculateFadeMultiplier(
 /**
  * Calculate fade cycles - how many LFO cycles for complete fade
  *
- * The FADE parameter (-64 to +63) maps to fade duration in cycles:
- * - 128 / |FADE| gives the number of cycles
- * - At |FADE| = 64, fade takes 2 cycles
- * - At |FADE| = 32, fade takes 4 cycles
- * - At |FADE| = 16, fade takes 8 cycles
- * - At |FADE| = 1, fade takes 128 cycles
+ * Based on empirical testing against Digitakt II hardware:
+ * - |FADE| <= 16: Fast fade, roughly linear (~|FADE|/6 cycles)
+ *   - |FADE| = 4: ~1 cycle (nearly instant)
+ *   - |FADE| = 8: ~1.5 cycles
+ *   - |FADE| = 16: ~2.5 cycles
+ * - |FADE| > 16: Exponential slowdown
+ *   - |FADE| = 32: ~25 cycles
+ * - |FADE| >= 48: Effectively disabled (infinitely slow)
  *
- * This follows the same "128" convention used in LFO timing calculations,
- * where 128 is the crossover point for bar-length cycles.
- * Higher |FADE| values = faster fade, lower |FADE| values = slower fade.
+ * IMPORTANT: Higher |FADE| = SLOWER fade (opposite of what you might expect)
  */
 export function calculateFadeCycles(fadeValue: number): number {
   if (fadeValue === 0) return 0;
-  // Map |FADE| to cycles: 128 / |FADE| cycles
-  // Maximum fade (64) = 2 cycles, minimum (1) = 128 cycles
-  return 128 / Math.abs(fadeValue);
+
+  const absFade = Math.abs(fadeValue);
+
+  // |FADE| >= 48 is effectively disabled (infinitely slow fade)
+  if (absFade >= 48) {
+    return Infinity;
+  }
+
+  // Fast fade region: roughly linear
+  if (absFade <= 16) {
+    // |FADE|=4 → ~0.7 cycles, |FADE|=16 → ~2.7 cycles
+    return Math.max(0.5, absFade / 6);
+  }
+
+  // Slow fade region: exponential growth
+  // Base of ~2.7 cycles at |FADE|=16, doubling every 5 units
+  const baseAt16 = 16 / 6; // ~2.67 cycles
+  return baseAt16 * Math.pow(2, (absFade - 16) / 5);
+  // |FADE|=32: 2.67 * 2^3.2 ≈ 24.5 cycles (matches hardware)
 }
 
 /**
@@ -90,9 +106,19 @@ export function updateFade(
 
   // Calculate how many cycles the fade takes
   const fadeCycles = calculateFadeCycles(config.fade);
+
+  // Handle disabled fade (|FADE| >= 48)
+  // Both fade-in and fade-out with high values result in no modulation
+  if (!isFinite(fadeCycles)) {
+    return {
+      fadeProgress: 0,
+      fadeMultiplier: 0, // No modulation when fade is disabled
+    };
+  }
+
   const fadeDurationMs = fadeCycles * cycleTimeMs;
 
-  if (fadeDurationMs === 0 || fadeDurationMs === Infinity) {
+  if (fadeDurationMs === 0) {
     return {
       fadeProgress: 1,
       fadeMultiplier: config.fade < 0 ? 0 : 1,
@@ -117,6 +143,13 @@ export function resetFade(config: LFOConfig): { fadeProgress: number; fadeMultip
     return { fadeProgress: 1, fadeMultiplier: 1 };
   }
 
+  // Check if fade is disabled (|FADE| >= 48)
+  const fadeCycles = calculateFadeCycles(config.fade);
+  if (!isFinite(fadeCycles)) {
+    // Disabled fade = no modulation
+    return { fadeProgress: 0, fadeMultiplier: 0 };
+  }
+
   if (config.fade < 0) {
     // Fade IN: start at 0
     return { fadeProgress: 0, fadeMultiplier: 0 };

package/src/engine/waveforms.ts

@@ -39,10 +39,10 @@ export function generateSquare(phase: number): number {
 
 /**
  * Sawtooth waveform - Bipolar
- * Linear rise from -1 to +1 (matches Digitakt II behavior)
+ * Linear fall from +1 to -1 (matches Digitakt II behavior)
  */
 export function generateSawtooth(phase: number): number {
-  return phase * 2 - 1;
+  return 1 - phase * 2;
 }
 
 /**

package/tests/depth-fade.test.ts

@@ -133,16 +133,28 @@ describe('calculateFadeCycles', () => {
     expect(calculateFadeCycles(0)).toBe(0);
   });
 
-  test('calculates cycles based on fade value (128/|FADE|)', () => {
-    // Higher |FADE| = faster fade (fewer cycles)
-    expect(calculateFadeCycles(64)).toBe(2);   // 128/64 = 2 cycles
-    expect(calculateFadeCycles(-64)).toBe(2);
-    expect(calculateFadeCycles(32)).toBe(4);   // 128/32 = 4 cycles
-    expect(calculateFadeCycles(-32)).toBe(4);
-    expect(calculateFadeCycles(16)).toBe(8);   // 128/16 = 8 cycles
-    expect(calculateFadeCycles(-16)).toBe(8);
-    expect(calculateFadeCycles(1)).toBe(128);  // 128/1 = 128 cycles (slowest)
-    expect(calculateFadeCycles(-1)).toBe(128);
+  test('calculates cycles based on fade value (empirical formula)', () => {
+    // Based on Digitakt II hardware testing:
+    // - Higher |FADE| = SLOWER fade (more cycles)
+    // - |FADE| >= 48 is disabled (Infinity)
+
+    // Fast fade region (|FADE| <= 16): ~|FADE|/6 cycles
+    expect(calculateFadeCycles(4)).toBeCloseTo(0.67, 1);   // ~0.67 cycles
+    expect(calculateFadeCycles(-4)).toBeCloseTo(0.67, 1);
+    expect(calculateFadeCycles(8)).toBeCloseTo(1.33, 1);   // ~1.33 cycles
+    expect(calculateFadeCycles(-8)).toBeCloseTo(1.33, 1);
+    expect(calculateFadeCycles(16)).toBeCloseTo(2.67, 1);  // ~2.67 cycles
+    expect(calculateFadeCycles(-16)).toBeCloseTo(2.67, 1);
+
+    // Slow fade region (16 < |FADE| < 48): exponential
+    expect(calculateFadeCycles(32)).toBeCloseTo(24.5, 0);  // ~24.5 cycles
+    expect(calculateFadeCycles(-32)).toBeCloseTo(24.5, 0);
+
+    // Disabled region (|FADE| >= 48)
+    expect(calculateFadeCycles(48)).toBe(Infinity);
+    expect(calculateFadeCycles(-48)).toBe(Infinity);
+    expect(calculateFadeCycles(64)).toBe(Infinity);
+    expect(calculateFadeCycles(-64)).toBe(Infinity);
   });
 });
 
@@ -166,16 +178,27 @@ describe('updateFade', () => {
   });
 
   test('progresses fade over time', () => {
-    // fade=-64 takes 128/64 = 2 cycles
+    // fade=-16 takes ~2.67 cycles (based on new formula)
+    const config = createConfig({ fade: -16, mode: 'TRG' });
+    const state = createState({ fadeProgress: 0 });
+    const cycleTimeMs = 1000;
+
+    // Fade duration = ~2.67 cycles * 1000ms = ~2670ms
+    // After 1000ms (~37.5% of fade), progress should be ~0.375
+    const result = updateFade(config, state, cycleTimeMs, 1000);
+    expect(result.fadeProgress).toBeCloseTo(0.375, 1);
+    expect(result.fadeMultiplier).toBeCloseTo(0.375, 1);
+  });
+
+  test('returns 0 multiplier for disabled fade', () => {
+    // fade=-64 is disabled (|FADE| >= 48)
     const config = createConfig({ fade: -64, mode: 'TRG' });
     const state = createState({ fadeProgress: 0 });
     const cycleTimeMs = 2000;
 
-    // Fade duration = 2 cycles * 2000ms = 4000ms
-    // After 1000ms (1/4 of fade), progress should be ~0.25
     const result = updateFade(config, state, cycleTimeMs, 1000);
-    expect(result.fadeProgress).toBeCloseTo(0.25, 1);
-    expect(result.fadeMultiplier).toBeCloseTo(0.25, 1);
+    expect(result.fadeProgress).toBe(0);
+    expect(result.fadeMultiplier).toBe(0); // No modulation when disabled
   });
 });
 
@@ -229,7 +252,7 @@ describe('Fade with LFO integration', () => {
     const lfo = new LFO({
       waveform: 'SIN',
       depth: 63,
-      fade: -64, // Fade in over 2 cycles (128/64)
+      fade: -16, // Fade in over ~2.67 cycles
       mode: 'TRG',
     }, 120);
 
@@ -237,23 +260,43 @@ describe('Fade with LFO integration', () => {
     lfo.update(0);
 
     const state1 = lfo.update(100);
-    expect(Math.abs(state1.output)).toBeLessThan(0.1); // Start near 0
+    expect(Math.abs(state1.output)).toBeLessThan(0.2); // Start near 0
 
-    // Fade takes 2 cycles = 4000ms at 2000ms/cycle
+    // Fade takes ~2.67 cycles = ~5340ms at 2000ms/cycle
     // After more time, output should increase significantly
     let maxOutput = 0;
-    for (let t = 100; t < 5000; t += 100) {
+    for (let t = 100; t < 6000; t += 100) {
       const state = lfo.update(t);
       maxOutput = Math.max(maxOutput, Math.abs(state.output));
     }
     expect(maxOutput).toBeGreaterThan(0.5);
   });
 
+  test('disabled fade returns no modulation', () => {
+    const lfo = new LFO({
+      waveform: 'SIN',
+      depth: 63,
+      fade: -64, // Disabled (|FADE| >= 48)
+      mode: 'TRG',
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+
+    // With disabled fade, output should stay at 0 (no modulation)
+    let maxOutput = 0;
+    for (let t = 100; t < 10000; t += 100) {
+      const state = lfo.update(t);
+      maxOutput = Math.max(maxOutput, Math.abs(state.output));
+    }
+    expect(maxOutput).toBe(0);
+  });
+
   test('fade out starts at full output and decreases', () => {
     const lfo = new LFO({
       waveform: 'SIN',
       depth: 63,
-      fade: 64, // Fade out over 2 cycles (128/64)
+      fade: 16, // Fade out over ~2.67 cycles
       mode: 'TRG',
       startPhase: 32, // Start at peak
     }, 120);
@@ -265,10 +308,10 @@ describe('Fade with LFO integration', () => {
     // Should start near full output (at SIN peak)
     expect(Math.abs(state1.output)).toBeGreaterThan(0.8);
 
-    // Fade takes 2 cycles = 4000ms at 2000ms/cycle
+    // Fade takes ~2.67 cycles = ~5340ms at 2000ms/cycle
     // After fade completes, output should be near 0
     let lastOutput = 0;
-    for (let t = 10; t < 5000; t += 100) {
+    for (let t = 10; t < 6000; t += 100) {
       const state = lfo.update(t);
       lastOutput = Math.abs(state.output);
     }
@@ -278,7 +321,7 @@ describe('Fade with LFO integration', () => {
   test('fade resets on trigger for TRG mode', () => {
     const lfo = new LFO({
       waveform: 'SIN',
-      fade: -64,
+      fade: -16, // Use non-disabled fade value
       mode: 'TRG',
     }, 120);
 

package/tests/negative-speed.test.ts

@@ -0,0 +1,316 @@
+import { describe, test, expect } from 'bun:test';
+import { LFO } from '../src/engine/lfo';
+
+/**
+ * Negative Speed Behavior Tests
+ *
+ * Current implementation: Negative speed INVERTS the output while phase still runs forward
+ * - SAW at +speed: outputs +1 → -1 (falling)
+ * - SAW at -speed: outputs -1 → +1 (rising, because output is negated)
+ *
+ * NOTE: Digitakt II behavior may differ. These tests document our current model.
+ * If Digitakt tests show different behavior, we may need to update the implementation.
+ */
+
+describe('Negative Speed - SAW waveform', () => {
+  test('positive speed SAW starts high and falls', () => {
+    const lfo = new LFO({
+      waveform: 'SAW',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // SAW at phase 0 should be +1, mapped to output ~+1 with depth 63
+    expect(stateStart.rawOutput).toBeCloseTo(1, 1);
+    expect(stateStart.output).toBeGreaterThan(0.9);
+
+    // After some time, SAW should fall
+    const stateLater = lfo.update(2000);
+    expect(stateLater.rawOutput).toBeLessThan(stateStart.rawOutput);
+  });
+
+  test('negative speed SAW starts low and rises (inverted)', () => {
+    const lfo = new LFO({
+      waveform: 'SAW',
+      speed: -16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // With negative speed, output is inverted
+    // rawOutput is still +1 (SAW at phase 0), but output is negated to -1
+    expect(stateStart.rawOutput).toBeCloseTo(1, 1);
+    expect(stateStart.output).toBeLessThan(-0.9); // Inverted!
+  });
+
+  test('SAW positive vs negative speed have inverted outputs at same time', () => {
+    const lfoPos = new LFO({
+      waveform: 'SAW',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    const lfoNeg = new LFO({
+      waveform: 'SAW',
+      speed: -16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfoPos.trigger();
+    lfoNeg.trigger();
+    lfoPos.update(0);
+    lfoNeg.update(0);
+
+    // Check at several time points
+    for (const time of [100, 500, 1000, 2000, 3000]) {
+      const statePos = lfoPos.update(time);
+      const stateNeg = lfoNeg.update(time);
+
+      // Phase should be the same
+      expect(stateNeg.phase).toBeCloseTo(statePos.phase, 3);
+
+      // Output should be inverted (opposite sign)
+      expect(stateNeg.output).toBeCloseTo(-statePos.output, 3);
+    }
+  });
+});
+
+describe('Negative Speed - TRI waveform', () => {
+  test('positive speed TRI starts at 0, rises to peak, then falls', () => {
+    const lfo = new LFO({
+      waveform: 'TRI',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // TRI at phase 0 should be 0
+    expect(stateStart.rawOutput).toBeCloseTo(0, 1);
+  });
+
+  test('negative speed TRI has inverted output', () => {
+    const lfoPos = new LFO({
+      waveform: 'TRI',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    const lfoNeg = new LFO({
+      waveform: 'TRI',
+      speed: -16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfoPos.trigger();
+    lfoNeg.trigger();
+
+    // Initialize with time 0, then advance to 25% of cycle
+    const cycleMs = lfoPos.getTimingInfo().cycleTimeMs;
+    const timeAt25Percent = cycleMs * 0.25;
+
+    // Start from time 1 to avoid sentinel value issue
+    lfoPos.update(1);
+    lfoNeg.update(1);
+
+    const statePos = lfoPos.update(1 + timeAt25Percent);
+    const stateNeg = lfoNeg.update(1 + timeAt25Percent);
+
+    // At phase 0.25, TRI should be at +1, so output ~= +1 * depth/63
+    // Positive should be positive, negative should be negative (inverted)
+    expect(statePos.output).toBeGreaterThan(0.5);
+    expect(stateNeg.output).toBeLessThan(-0.5);
+  });
+});
+
+describe('Negative Speed - RMP waveform (unipolar)', () => {
+  test('positive speed RMP rises from 0 to 1', () => {
+    const lfo = new LFO({
+      waveform: 'RMP',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // RMP at phase 0 should be 0
+    expect(stateStart.rawOutput).toBeCloseTo(0, 1);
+
+    // After half cycle, should be at 0.5
+    const cycleMs = lfo.getTimingInfo().cycleTimeMs;
+    const stateMid = lfo.update(cycleMs * 0.5);
+    expect(stateMid.rawOutput).toBeCloseTo(0.5, 1);
+  });
+
+  test('negative speed RMP has inverted output (0 to -1)', () => {
+    const lfo = new LFO({
+      waveform: 'RMP',
+      speed: -16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // rawOutput is still 0 (RMP at phase 0), output is negated to 0
+    expect(stateStart.rawOutput).toBeCloseTo(0, 1);
+    expect(stateStart.output).toBeCloseTo(0, 1); // -0 = 0
+
+    // After half cycle, rawOutput is 0.5, output is -0.5 * depth
+    const cycleMs = lfo.getTimingInfo().cycleTimeMs;
+    const stateMid = lfo.update(cycleMs * 0.5);
+    expect(stateMid.rawOutput).toBeCloseTo(0.5, 1);
+    expect(stateMid.output).toBeLessThan(0); // Negated
+  });
+});
+
+describe('Negative Speed - EXP waveform (unipolar)', () => {
+  test('positive speed EXP decays from 1 to 0', () => {
+    const lfo = new LFO({
+      waveform: 'EXP',
+      speed: 16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // EXP at phase 0 should be 1
+    expect(stateStart.rawOutput).toBeCloseTo(1, 1);
+    expect(stateStart.output).toBeGreaterThan(0.9);
+
+    // Near end of cycle, should be close to 0
+    const cycleMs = lfo.getTimingInfo().cycleTimeMs;
+    const stateEnd = lfo.update(cycleMs * 0.95);
+    expect(stateEnd.rawOutput).toBeLessThan(0.2);
+  });
+
+  test('negative speed EXP has inverted output (-1 to 0)', () => {
+    const lfo = new LFO({
+      waveform: 'EXP',
+      speed: -16,
+      multiplier: 4,
+      depth: 63,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // rawOutput is still 1 (EXP at phase 0), output is negated to -1
+    expect(stateStart.rawOutput).toBeCloseTo(1, 1);
+    expect(stateStart.output).toBeLessThan(-0.9); // Inverted!
+  });
+});
+
+describe('Negative Speed - CC value mapping', () => {
+  test('SAW positive speed maps to CC 103 → 24 (high to low)', () => {
+    const lfo = new LFO({
+      waveform: 'SAW',
+      speed: 16,
+      multiplier: 4,
+      depth: 40, // CC range: 64-40=24 to 64+40=104
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // Convert output to CC: center (64) + output * 63
+    const ccStart = Math.round(64 + stateStart.output * 63);
+    expect(ccStart).toBeGreaterThan(95); // Should start near max (~103)
+
+    // At end of cycle
+    const cycleMs = lfo.getTimingInfo().cycleTimeMs;
+    const stateEnd = lfo.update(cycleMs * 0.95);
+    const ccEnd = Math.round(64 + stateEnd.output * 63);
+    expect(ccEnd).toBeLessThan(35); // Should end near min (~24)
+  });
+
+  test('SAW negative speed maps to CC 24 → 103 (low to high)', () => {
+    const lfo = new LFO({
+      waveform: 'SAW',
+      speed: -16,
+      multiplier: 4,
+      depth: 40,
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+    const stateStart = lfo.update(1);
+
+    // With negative speed, output is inverted
+    const ccStart = Math.round(64 + stateStart.output * 63);
+    expect(ccStart).toBeLessThan(35); // Should start near min (~24)
+
+    // At end of cycle
+    const cycleMs = lfo.getTimingInfo().cycleTimeMs;
+    const stateEnd = lfo.update(cycleMs * 0.95);
+    const ccEnd = Math.round(64 + stateEnd.output * 63);
+    expect(ccEnd).toBeGreaterThan(95); // Should end near max (~103)
+  });
+});
+
+describe('Negative Speed - Timing', () => {
+  test('cycle time is same for positive and negative speed', () => {
+    const lfoPos = new LFO({ speed: 16, multiplier: 4 }, 120);
+    const lfoNeg = new LFO({ speed: -16, multiplier: 4 }, 120);
+
+    expect(lfoPos.getTimingInfo().cycleTimeMs).toBe(lfoNeg.getTimingInfo().cycleTimeMs);
+  });
+
+  test('phase progression is forward for both positive and negative speed', () => {
+    const lfoPos = new LFO({ speed: 16, multiplier: 4 }, 120);
+    const lfoNeg = new LFO({ speed: -16, multiplier: 4 }, 120);
+
+    lfoPos.trigger();
+    lfoNeg.trigger();
+    lfoPos.update(0);
+    lfoNeg.update(0);
+
+    let prevPhasePos = 0;
+    let prevPhaseNeg = 0;
+
+    // Check that phase always increases (modulo wrap)
+    for (let time = 100; time < 2000; time += 100) {
+      const statePos = lfoPos.update(time);
+      const stateNeg = lfoNeg.update(time);
+
+      // Both should have same phase
+      expect(stateNeg.phase).toBeCloseTo(statePos.phase, 3);
+
+      // Phase should increase or wrap
+      if (statePos.phase < 0.1 && prevPhasePos > 0.9) {
+        // Wrapped
+      } else {
+        expect(statePos.phase).toBeGreaterThanOrEqual(prevPhasePos - 0.01);
+      }
+
+      prevPhasePos = statePos.phase;
+      prevPhaseNeg = stateNeg.phase;
+    }
+  });
+});

package/tests/presets.test.ts

@@ -49,12 +49,13 @@ describe('Preset 1: Fade-In One-Shot', () => {
   });
 
   test('fade multiplier increases over time (fade in)', () => {
+    // Use TRG mode instead of ONE so LFO keeps running for fade to progress
     const lfo = new LFO({
       waveform: 'RMP',
       speed: 8,
-      multiplier: 16,
-      mode: 'ONE',
-      fade: -32, // Negative = fade IN
+      multiplier: 8,  // product=64, cycle=4000ms
+      mode: 'TRG',
+      fade: -16, // Fast fade-in (~2.67 cycles)
       depth: 63,
     }, 120);
 
@@ -62,17 +63,19 @@ describe('Preset 1: Fade-In One-Shot', () => {
     lfo.update(0);
 
     const state1 = lfo.update(100);
-    expect(state1.fadeMultiplier).toBeLessThan(0.2);
+    expect(state1.fadeMultiplier).toBeLessThan(0.1);
 
-    // Fade -32 = 128/32 = 4 cycles = 8000ms at 2000ms cycle
-    // After ~2000ms (1 cycle), should be at 25% (2000/8000)
+    // Fade -16 = ~2.67 cycles (new formula)
+    // With speed=8, mult=8, product=64, cycle time = 4000ms at 120 BPM
+    // Total fade duration = ~2.67 * 4000ms = ~10680ms
+    // After ~8000ms (2 cycles), should be at ~75%
     let laterFadeMultiplier = 0;
-    for (let t = 100; t < 2100; t += 50) {
+    for (let t = 100; t < 8100; t += 100) {
       const state = lfo.update(t);
       laterFadeMultiplier = state.fadeMultiplier;
     }
-    expect(laterFadeMultiplier).toBeGreaterThan(0.15);
-    expect(laterFadeMultiplier).toBeLessThan(0.4);
+    expect(laterFadeMultiplier).toBeGreaterThan(0.6);
+    expect(laterFadeMultiplier).toBeLessThan(0.9);
   });
 });
 

package/tests/waveforms.test.ts

@@ -123,22 +123,22 @@ describe('Square Waveform', () => {
 });
 
 describe('Sawtooth Waveform', () => {
-  test('starts at -1 at phase 0', () => {
-    expect(generateSawtooth(0)).toBe(-1);
+  test('starts at +1 at phase 0', () => {
+    expect(generateSawtooth(0)).toBe(1);
   });
 
   test('is 0 at phase 0.5', () => {
     expect(generateSawtooth(0.5)).toBe(0);
   });
 
-  test('approaches +1 at phase ~1', () => {
-    expect(generateSawtooth(1)).toBe(1);
-    expect(generateSawtooth(0.999)).toBeCloseTo(1, 2);
+  test('approaches -1 at phase ~1', () => {
+    expect(generateSawtooth(1)).toBe(-1);
+    expect(generateSawtooth(0.999)).toBeCloseTo(-1, 2);
   });
 
-  test('is bipolar and linear (rising)', () => {
-    expect(generateSawtooth(0.25)).toBeCloseTo(-0.5, 5);
-    expect(generateSawtooth(0.75)).toBeCloseTo(0.5, 5);
+  test('is bipolar and linear (falling)', () => {
+    expect(generateSawtooth(0.25)).toBeCloseTo(0.5, 5);
+    expect(generateSawtooth(0.75)).toBeCloseTo(-0.5, 5);
   });
 });