elektron-lfo 1.0.10 → 1.0.12

package/dist/index.js

@@ -345,7 +345,12 @@ function calculateFadeMultiplier(fadeValue, fadeProgress) {
 function calculateFadeCycles(fadeValue) {
   if (fadeValue === 0)
     return 0;
-  return 128 / Math.abs(fadeValue);
+  const absFade = Math.abs(fadeValue);
+  if (absFade <= 16) {
+    return Math.max(0.5, 0.1 * absFade + 0.6);
+  }
+  const baseAt16 = 2.2;
+  return baseAt16 * Math.pow(2, (absFade - 16) / 4.5);
 }
 function updateFade(config, state, cycleTimeMs, deltaMs) {
   if (config.fade === 0 || config.mode === "FRE") {
@@ -356,7 +361,7 @@ function updateFade(config, state, cycleTimeMs, deltaMs) {
   }
   const fadeCycles = calculateFadeCycles(config.fade);
   const fadeDurationMs = fadeCycles * cycleTimeMs;
-  if (fadeDurationMs === 0 || fadeDurationMs === Infinity) {
+  if (fadeDurationMs === 0) {
     return {
       fadeProgress: 1,
       fadeMultiplier: config.fade < 0 ? 0 : 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elektron-lfo",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "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,41 @@ 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 (January 2025):
  *
- * 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.
+ * Key observations:
+ * - |FADE| <= 16: Linear region, ~1 cycle at FADE=4, ~2.2 cycles at FADE=16
+ * - |FADE| > 16: Exponential slowdown, doubling every ~4.7 units
+ * - NO "disabled" threshold - even |FADE|=63 continues fading, just very slowly
+ *
+ * Measured values:
+ *   |FADE| = 4:  ~1 cycle
+ *   |FADE| = 8:  ~1.6 cycles
+ *   |FADE| = 16: ~2.2 cycles
+ *   |FADE| = 24: ~7 cycles
+ *   |FADE| = 32: ~26 cycles
+ *   |FADE| = 40: ~90 cycles
+ *   |FADE| = 48: ~320 cycles
+ *   |FADE| = 56: ~1100 cycles
+ *   |FADE| = 63: ~3300 cycles
+ *
+ * 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);
+
+  // Linear region (|FADE| <= 16): ~1 cycle at FADE=4, ~2.2 cycles at FADE=16
+  // Formula: 0.1 * |FADE| + 0.6, with minimum of 0.5
+  if (absFade <= 16) {
+    return Math.max(0.5, 0.1 * absFade + 0.6);
+  }
+
+  // Exponential region (|FADE| > 16): starts at 2.2 cycles at FADE=16
+  // Doubles every ~4.5 units of |FADE|
+  const baseAt16 = 2.2;
+  return baseAt16 * Math.pow(2, (absFade - 16) / 4.5);
 }
 
 /**
@@ -90,9 +109,13 @@ export function updateFade(
 
   // Calculate how many cycles the fade takes
   const fadeCycles = calculateFadeCycles(config.fade);
+
+  // Note: There is no "disabled" threshold - even extreme fade values
+  // just result in very slow fades (thousands of cycles for |FADE|=63)
+
   const fadeDurationMs = fadeCycles * cycleTimeMs;
 
-  if (fadeDurationMs === 0 || fadeDurationMs === Infinity) {
+  if (fadeDurationMs === 0) {
     return {
       fadeProgress: 1,
       fadeMultiplier: config.fade < 0 ? 0 : 1,
@@ -111,6 +134,9 @@ export function updateFade(
 
 /**
  * Reset fade state (called on trigger for modes that reset fade)
+ *
+ * Note: There is no "disabled" threshold - even extreme fade values
+ * will eventually complete, just over thousands of cycles.
  */
 export function resetFade(config: LFOConfig): { fadeProgress: number; fadeMultiplier: number } {
   if (config.fade === 0) {

package/tests/depth-fade.test.ts

@@ -133,16 +133,53 @@ 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 from Digitakt II)', () => {
+    // Based on Digitakt II hardware testing (January 2025):
+    // - Higher |FADE| = SLOWER fade (more cycles)
+    // - NO disabled threshold - even extreme values fade, just slowly
+
+    // Linear region (|FADE| <= 16): 0.1 * |FADE| + 0.6
+    expect(calculateFadeCycles(4)).toBeCloseTo(1.0, 1);    // ~1 cycle
+    expect(calculateFadeCycles(-4)).toBeCloseTo(1.0, 1);
+    expect(calculateFadeCycles(8)).toBeCloseTo(1.4, 1);    // ~1.4 cycles
+    expect(calculateFadeCycles(-8)).toBeCloseTo(1.4, 1);
+    expect(calculateFadeCycles(16)).toBeCloseTo(2.2, 1);   // ~2.2 cycles
+    expect(calculateFadeCycles(-16)).toBeCloseTo(2.2, 1);
+
+    // Exponential region (|FADE| > 16): 2.2 * 2^((|FADE| - 16) / 4.5)
+    expect(calculateFadeCycles(24)).toBeCloseTo(7.5, 0);   // ~7-8 cycles
+    expect(calculateFadeCycles(-24)).toBeCloseTo(7.5, 0);
+    expect(calculateFadeCycles(32)).toBeCloseTo(26, 0);    // ~26 cycles
+    expect(calculateFadeCycles(-32)).toBeCloseTo(26, 0);
+
+    // Extreme values - NOT disabled, just very slow
+    // Using loose precision since exact values are less critical at extremes
+    const fade40 = calculateFadeCycles(40);
+    const fade48 = calculateFadeCycles(48);
+    const fade56 = calculateFadeCycles(56);
+    const fade63 = calculateFadeCycles(63);
+
+    expect(fade40).toBeGreaterThan(70);
+    expect(fade40).toBeLessThan(120);      // ~90 cycles
+    expect(fade48).toBeGreaterThan(250);
+    expect(fade48).toBeLessThan(400);      // ~300 cycles
+    expect(fade56).toBeGreaterThan(800);
+    expect(fade56).toBeLessThan(1400);     // ~1000 cycles
+    expect(fade63).toBeGreaterThan(2500);
+    expect(fade63).toBeLessThan(4000);     // ~3000 cycles
+  });
+
+  test('is symmetric for positive and negative fade values', () => {
+    expect(calculateFadeCycles(-16)).toBe(calculateFadeCycles(16));
+    expect(calculateFadeCycles(-32)).toBe(calculateFadeCycles(32));
+    expect(calculateFadeCycles(-48)).toBe(calculateFadeCycles(48));
+  });
+
+  test('extreme fade values return finite (large) cycle counts', () => {
+    // Verify no Infinity values - Digitakt continues fading even at extremes
+    expect(isFinite(calculateFadeCycles(48))).toBe(true);
+    expect(isFinite(calculateFadeCycles(63))).toBe(true);
+    expect(isFinite(calculateFadeCycles(-64))).toBe(true);
   });
 });
 
@@ -166,16 +203,29 @@ describe('updateFade', () => {
   });
 
   test('progresses fade over time', () => {
-    // fade=-64 takes 128/64 = 2 cycles
+    // fade=-16 takes ~2.2 cycles (based on new empirical formula)
+    const config = createConfig({ fade: -16, mode: 'TRG' });
+    const state = createState({ fadeProgress: 0 });
+    const cycleTimeMs = 1000;
+
+    // Fade duration = ~2.2 cycles * 1000ms = ~2200ms
+    // After 1000ms (~45% of fade), progress should be ~0.45
+    const result = updateFade(config, state, cycleTimeMs, 1000);
+    expect(result.fadeProgress).toBeCloseTo(0.45, 1);
+    expect(result.fadeMultiplier).toBeCloseTo(0.45, 1);
+  });
+
+  test('extreme fade values still progress, just very slowly', () => {
+    // fade=-64 takes ~3500+ cycles - NOT disabled, just very slow
     const config = createConfig({ fade: -64, mode: 'TRG' });
     const state = createState({ fadeProgress: 0 });
-    const cycleTimeMs = 2000;
+    const cycleTimeMs = 1000;
 
-    // Fade duration = 2 cycles * 2000ms = 4000ms
-    // After 1000ms (1/4 of fade), progress should be ~0.25
+    // After 1000ms (1 cycle), progress should be 1/3500 = ~0.0003
     const result = updateFade(config, state, cycleTimeMs, 1000);
-    expect(result.fadeProgress).toBeCloseTo(0.25, 1);
-    expect(result.fadeMultiplier).toBeCloseTo(0.25, 1);
+    expect(result.fadeProgress).toBeGreaterThan(0);
+    expect(result.fadeProgress).toBeLessThan(0.01);
+    expect(result.fadeMultiplier).toBeGreaterThan(0);
   });
 });
 
@@ -229,7 +279,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.2 cycles
       mode: 'TRG',
     }, 120);
 
@@ -237,23 +287,46 @@ 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.2 cycles = ~4400ms 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('extreme fade values progress very slowly but are not disabled', () => {
+    const lfo = new LFO({
+      waveform: 'SIN',
+      depth: 63,
+      fade: -64, // Very slow fade (~3500 cycles), NOT disabled
+      mode: 'TRG',
+    }, 120);
+
+    lfo.trigger();
+    lfo.update(0);
+
+    // With extreme fade, output starts near 0 and increases VERY slowly
+    // After 10 seconds (~5 cycles), fade is only 5/3500 = 0.14% complete
+    let maxOutput = 0;
+    for (let t = 100; t < 10000; t += 100) {
+      const state = lfo.update(t);
+      maxOutput = Math.max(maxOutput, Math.abs(state.output));
+    }
+    // Should have some tiny output (not zero) since fade is progressing
+    expect(maxOutput).toBeGreaterThan(0);
+    expect(maxOutput).toBeLessThan(0.05); // But still very small
+  });
+
   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.2 cycles
       mode: 'TRG',
       startPhase: 32, // Start at peak
     }, 120);
@@ -265,10 +338,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.2 cycles = ~4400ms 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 +351,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);
   });
 });