elektron-lfo 1.0.4 → 1.0.7

package/dist/cli/args.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Command-line argument parsing for Elektron LFO CLI
+ */
+import type { LFOConfig } from '../engine/types';
+export interface CLIArgs extends LFOConfig {
+    bpm: number;
+    help: boolean;
+}
+export declare function printHelp(): void;
+export declare function parseArgs(args: string[]): CLIArgs;

package/dist/cli/display.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Terminal display for Elektron LFO CLI
+ *
+ * Renders the LFO state with ASCII waveform visualization
+ */
+import type { LFOConfig, LFOState, TimingInfo } from '../engine/types';
+/**
+ * Render the full display
+ */
+export declare function render(config: LFOConfig, state: LFOState, timing: TimingInfo, bpm: number): string;

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+/**
+ * Elektron LFO CLI - Main Entry Point
+ *
+ * Real-time terminal visualization of the Digitakt II LFO engine
+ */
+export {};

package/dist/cli/keyboard.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Keyboard input handling for Elektron LFO CLI
+ */
+import type { Waveform, TriggerMode, Multiplier } from '../engine/types';
+export type KeyAction = {
+    type: 'trigger';
+} | {
+    type: 'quit';
+} | {
+    type: 'bpm';
+    delta: number;
+} | {
+    type: 'speed';
+    delta: number;
+} | {
+    type: 'waveform';
+    waveform: Waveform;
+} | {
+    type: 'mode';
+    mode: TriggerMode;
+} | {
+    type: 'multiplier';
+    multiplier: Multiplier;
+} | {
+    type: 'depth';
+    delta: number;
+} | {
+    type: 'fade';
+    delta: number;
+} | {
+    type: 'unknown';
+};
+/**
+ * Parse a key input into an action
+ */
+export declare function parseKey(key: Buffer, currentWaveform: Waveform, currentMode: TriggerMode, currentMultiplier: Multiplier): KeyAction;
+/**
+ * Set up raw mode input handling
+ */
+export declare function setupKeyboardInput(onKey: (key: Buffer) => void, onExit: () => void): void;
+/**
+ * Clean up keyboard input handling
+ */
+export declare function cleanupKeyboardInput(): void;

package/dist/engine/lfo.d.ts

@@ -73,4 +73,11 @@ export declare class LFO {
      * Stop the LFO
      */
     stop(): void;
+    /**
+     * Reset timing so the next update() call has deltaMs = 0
+     *
+     * Call this after trigger() when restarting from a paused state
+     * to prevent the LFO from jumping ahead by the paused duration.
+     */
+    resetTiming(): void;
 }

package/dist/engine/waveforms.d.ts

@@ -23,7 +23,7 @@ export declare function generateSine(phase: number): number;
 export declare function generateSquare(phase: number): number;
 /**
  * Sawtooth waveform - Bipolar
- * Linear rise from -1 to +1
+ * Linear fall from +1 to -1 (with positive depth)
  */
 export declare function generateSawtooth(phase: number): number;
 /**
@@ -33,7 +33,7 @@ export declare function generateSawtooth(phase: number): number;
 export declare function generateExponential(phase: number): number;
 /**
  * Ramp waveform - Unipolar (0 to +1)
- * Linear fall from +1 to 0
+ * Linear rise from 0 to +1
  */
 export declare function generateRamp(phase: number): number;
 /**

package/dist/index.js

@@ -69,8 +69,9 @@ function generateSawtooth(phase) {
   return 1 - phase * 2;
 }
 function generateExponential(phase) {
-  const k = 4;
-  return (Math.exp(phase * k) - 1) / (Math.exp(k) - 1);
+  const k = 3;
+  const expK = Math.exp(-k);
+  return (Math.exp(-phase * k) - expK) / (1 - expK);
 }
 function generateRamp(phase) {
   return phase;
@@ -154,8 +155,7 @@ function calculatePhaseIncrement(config, bpm) {
   if (cycleTimeMs === Infinity || cycleTimeMs === 0) {
     return 0;
   }
-  const direction = config.speed >= 0 ? 1 : -1;
-  return direction / cycleTimeMs;
+  return 1 / cycleTimeMs;
 }
 function calculateCyclesPerBar(config) {
   const product = calculateProduct(config);
@@ -345,7 +345,7 @@ function calculateFadeMultiplier(fadeValue, fadeProgress) {
 function calculateFadeCycles(fadeValue) {
   if (fadeValue === 0)
     return 0;
-  return Math.abs(fadeValue) / 64;
+  return 128 / Math.abs(fadeValue);
 }
 function updateFade(config, state, cycleTimeMs, deltaMs) {
   if (config.fade === 0 || config.mode === "FRE") {
@@ -452,6 +452,9 @@ class LFO {
     if (this.config.mode === "HLD" && this.state.triggerCount > 0) {
       effectiveRawOutput = this.state.heldOutput;
     }
+    if (this.config.speed < 0) {
+      effectiveRawOutput = -effectiveRawOutput;
+    }
     const depthScale = this.config.depth / 63;
     let scaledOutput = effectiveRawOutput * depthScale;
     scaledOutput *= this.state.fadeMultiplier;
@@ -460,7 +463,18 @@ class LFO {
     return { ...this.state };
   }
   trigger() {
-    this.state = handleTrigger(this.config, this.state, this.state.rawOutput);
+    let rawOutputForTrigger = this.state.rawOutput;
+    if (this.config.mode === "HLD") {
+      const waveformResult = generateWaveform(this.config.waveform, this.state.phase, this.state);
+      rawOutputForTrigger = waveformResult.value;
+      if (waveformResult.newRandomValue !== undefined) {
+        this.state.randomValue = waveformResult.newRandomValue;
+      }
+      if (waveformResult.newRandomStep !== undefined) {
+        this.state.randomStep = waveformResult.newRandomStep;
+      }
+    }
+    this.state = handleTrigger(this.config, this.state, rawOutputForTrigger);
   }
   getState() {
     return { ...this.state };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "elektron-lfo",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "Elektron LFO engine simulator implementation with CLI visualization",
   "main": "dist/index.js",
   "module": "src/index.ts",
   "types": "dist/index.d.ts",
   "bin": {
-    "elektron-lfo": "./src/cli/index.ts"
+    "elektron-lfo": "src/cli/index.ts"
   },
   "scripts": {
     "dev": "bun run src/cli/index.ts",

package/src/engine/fade.ts

@@ -48,16 +48,21 @@ 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:
- * - |FADE| / 64 gives the number of cycles (approximately)
- * - At |FADE| = 64, fade takes 1 cycle
- * - At |FADE| = 32, fade takes 0.5 cycles
- * - At |FADE| = 1, fade takes ~1/64 of a cycle
+ * - 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
+ *
+ * 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.
  */
 export function calculateFadeCycles(fadeValue: number): number {
   if (fadeValue === 0) return 0;
-  // Map |FADE| to cycles: |FADE| / 64 cycles
-  // Maximum fade (64) = 1 cycle, minimum (1) = 1/64 cycle
-  return Math.abs(fadeValue) / 64;
+  // Map |FADE| to cycles: 128 / |FADE| cycles
+  // Maximum fade (64) = 2 cycles, minimum (1) = 128 cycles
+  return 128 / Math.abs(fadeValue);
 }
 
 /**

package/src/engine/lfo.ts

@@ -134,6 +134,11 @@ export class LFO {
       effectiveRawOutput = this.state.heldOutput;
     }
 
+    // Invert output for negative speed (phase still runs forward)
+    if (this.config.speed < 0) {
+      effectiveRawOutput = -effectiveRawOutput;
+    }
+
     // Apply depth
     // Depth scales the output: depth of 63 = 100%, depth of 0 = 0%
     // Negative depth inverts the waveform
@@ -157,9 +162,32 @@ export class LFO {
 
   /**
    * Trigger the LFO
+   *
+   * For HLD mode, this computes the current waveform value at the current phase
+   * to ensure the held value is accurate, even if trigger() is called before
+   * any update() calls.
    */
   trigger(): void {
-    this.state = handleTrigger(this.config, this.state, this.state.rawOutput);
+    // For HLD mode, compute fresh waveform output at current phase.
+    // This is necessary because rawOutput may be stale if trigger() is called
+    // before update() has been called (e.g., when initializing an HLD mode LFO).
+    let rawOutputForTrigger = this.state.rawOutput;
+    if (this.config.mode === 'HLD') {
+      const waveformResult = generateWaveform(
+        this.config.waveform,
+        this.state.phase,
+        this.state
+      );
+      rawOutputForTrigger = waveformResult.value;
+      // Update random state if needed (for RND waveform)
+      if (waveformResult.newRandomValue !== undefined) {
+        this.state.randomValue = waveformResult.newRandomValue;
+      }
+      if (waveformResult.newRandomStep !== undefined) {
+        this.state.randomStep = waveformResult.newRandomStep;
+      }
+    }
+    this.state = handleTrigger(this.config, this.state, rawOutputForTrigger);
   }
 
   /**

package/src/engine/timing.ts

@@ -62,9 +62,8 @@ export function calculatePhaseIncrement(config: LFOConfig, bpm: number): number
     return 0;
   }
 
-  // Negative speed runs phase backwards
-  const direction = config.speed >= 0 ? 1 : -1;
-  return direction / cycleTimeMs;
+  // Phase always moves forward; negative speed is handled by inverting waveform output
+  return 1 / cycleTimeMs;
 }
 
 /**

package/src/engine/waveforms.ts

@@ -48,11 +48,16 @@ export function generateSawtooth(phase: number): number {
 
 /**
  * Exponential waveform - Unipolar (0 to +1)
- * Accelerating curve from 0 to 1
+ * Decaying curve from 1 to 0 (matches Digitakt II behavior)
+ * Fast initial decay, slowing toward the end (true exponential decay shape)
  */
 export function generateExponential(phase: number): number {
-  const k = 4; // Steepness factor
-  return (Math.exp(phase * k) - 1) / (Math.exp(k) - 1);
+  const k = 3; // Decay rate - controls steepness of decay
+  // True exponential decay: starts at 1, decays rapidly then slows
+  // Formula: (exp(-phase * k) - exp(-k)) / (1 - exp(-k))
+  // This normalizes to exactly [1, 0] range
+  const expK = Math.exp(-k);
+  return (Math.exp(-phase * k) - expK) / (1 - expK);
 }
 
 /**

package/tests/depth-fade.test.ts

@@ -133,11 +133,16 @@ describe('calculateFadeCycles', () => {
     expect(calculateFadeCycles(0)).toBe(0);
   });
 
-  test('calculates cycles based on fade value', () => {
-    expect(calculateFadeCycles(64)).toBe(1); // Full fade = 1 cycle
-    expect(calculateFadeCycles(-64)).toBe(1);
-    expect(calculateFadeCycles(32)).toBe(0.5); // Half fade = 0.5 cycle
-    expect(calculateFadeCycles(-32)).toBe(0.5);
+  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);
   });
 });
 
@@ -161,13 +166,16 @@ describe('updateFade', () => {
   });
 
   test('progresses fade over time', () => {
-    const config = createConfig({ fade: -64, mode: 'TRG' }); // 1 cycle fade
+    // fade=-64 takes 128/64 = 2 cycles
+    const config = createConfig({ fade: -64, mode: 'TRG' });
     const state = createState({ fadeProgress: 0 });
+    const cycleTimeMs = 2000;
 
-    // After half the cycle time, progress should be ~0.5
-    const result = updateFade(config, state, 2000, 1000);
-    expect(result.fadeProgress).toBeCloseTo(0.5, 1);
-    expect(result.fadeMultiplier).toBeCloseTo(0.5, 1);
+    // 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);
   });
 });
 
@@ -221,7 +229,7 @@ describe('Fade with LFO integration', () => {
     const lfo = new LFO({
       waveform: 'SIN',
       depth: 63,
-      fade: -64, // Fade in over 1 cycle
+      fade: -64, // Fade in over 2 cycles (128/64)
       mode: 'TRG',
     }, 120);
 
@@ -231,9 +239,10 @@ describe('Fade with LFO integration', () => {
     const state1 = lfo.update(100);
     expect(Math.abs(state1.output)).toBeLessThan(0.1); // Start near 0
 
-    // After more time, output should increase
+    // Fade takes 2 cycles = 4000ms at 2000ms/cycle
+    // After more time, output should increase significantly
     let maxOutput = 0;
-    for (let t = 100; t < 2500; t += 100) {
+    for (let t = 100; t < 5000; t += 100) {
       const state = lfo.update(t);
       maxOutput = Math.max(maxOutput, Math.abs(state.output));
     }
@@ -244,7 +253,7 @@ describe('Fade with LFO integration', () => {
     const lfo = new LFO({
       waveform: 'SIN',
       depth: 63,
-      fade: 64, // Fade out over 1 cycle
+      fade: 64, // Fade out over 2 cycles (128/64)
       mode: 'TRG',
       startPhase: 32, // Start at peak
     }, 120);
@@ -256,9 +265,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
     // After fade completes, output should be near 0
     let lastOutput = 0;
-    for (let t = 10; t < 3000; t += 100) {
+    for (let t = 10; t < 5000; t += 100) {
       const state = lfo.update(t);
       lastOutput = Math.abs(state.output);
     }

package/tests/phase.test.ts

@@ -23,11 +23,11 @@ describe('Phase wrapping', () => {
     expect(wrappedFromOne).toBe(true);
   });
 
-  test('phase wraps from 0 to 1 (backward/negative speed)', () => {
-    const lfo = new LFO({ speed: -32, multiplier: 64 }, 120); // Fast backward cycle
+  test('phase wraps from 1 to 0 (negative speed - phase still runs forward)', () => {
+    const lfo = new LFO({ speed: -32, multiplier: 64 }, 120); // Fast cycle, negative speed
 
     let lastTime = 0;
-    let wrappedToOne = false;
+    let wrappedFromOne = false;
     let previousPhase = 0;
 
     // First update to initialize
@@ -36,15 +36,16 @@ describe('Phase wrapping', () => {
 
     for (let i = 0; i < 200; i++) {
       const state = lfo.update(lastTime);
-      if (previousPhase < 0.1 && state.phase > 0.9) {
-        wrappedToOne = true;
+      // Phase still runs forward even with negative speed
+      if (previousPhase > 0.9 && state.phase < 0.1) {
+        wrappedFromOne = true;
         break;
       }
       previousPhase = state.phase;
       lastTime += 10;
     }
 
-    expect(wrappedToOne).toBe(true);
+    expect(wrappedFromOne).toBe(true);
   });
 
   test('phase stays within 0-1 range', () => {
@@ -61,16 +62,23 @@ describe('Phase wrapping', () => {
 });
 
 describe('Negative speed', () => {
-  test('negative speed runs phase backwards', () => {
-    const lfo = new LFO({ speed: -16, multiplier: 8, startPhase: 64 }, 120);
-
-    // Initialize
-    lfo.update(0);
-    const state1 = lfo.update(100);
-    const state2 = lfo.update(200);
-
-    // Phase should decrease
-    expect(state2.phase).toBeLessThan(state1.phase);
+  test('negative speed inverts output (phase still runs forward)', () => {
+    // Positive speed LFO
+    const lfoPos = new LFO({ speed: 16, multiplier: 8, waveform: 'TRI' }, 120);
+    // Negative speed LFO (same magnitude)
+    const lfoNeg = new LFO({ speed: -16, multiplier: 8, waveform: 'TRI' }, 120);
+
+    // Initialize both
+    lfoPos.update(0);
+    lfoNeg.update(0);
+
+    const statePos = lfoPos.update(500);
+    const stateNeg = lfoNeg.update(500);
+
+    // Phase should be the same (both run forward)
+    expect(stateNeg.phase).toBeCloseTo(statePos.phase, 4);
+    // Output should be inverted
+    expect(stateNeg.output).toBeCloseTo(-statePos.output, 4);
   });
 
   test('positive speed runs phase forwards', () => {

package/tests/presets.test.ts

@@ -62,17 +62,17 @@ describe('Preset 1: Fade-In One-Shot', () => {
     lfo.update(0);
 
     const state1 = lfo.update(100);
-    expect(state1.fadeMultiplier).toBeLessThan(0.5);
+    expect(state1.fadeMultiplier).toBeLessThan(0.2);
 
-    // Fade -32 = 0.5 cycles = 1000ms at 2000ms cycle
-    // After ~500ms, should be about halfway
-    let midFadeMultiplier = 0;
-    for (let t = 100; t < 600; t += 50) {
+    // Fade -32 = 128/32 = 4 cycles = 8000ms at 2000ms cycle
+    // After ~2000ms (1 cycle), should be at 25% (2000/8000)
+    let laterFadeMultiplier = 0;
+    for (let t = 100; t < 2100; t += 50) {
       const state = lfo.update(t);
-      midFadeMultiplier = state.fadeMultiplier;
+      laterFadeMultiplier = state.fadeMultiplier;
     }
-    expect(midFadeMultiplier).toBeGreaterThan(0.3);
-    expect(midFadeMultiplier).toBeLessThan(0.8);
+    expect(laterFadeMultiplier).toBeGreaterThan(0.15);
+    expect(laterFadeMultiplier).toBeLessThan(0.4);
   });
 });
 

package/tests/timing.test.ts

@@ -103,11 +103,12 @@ describe('calculatePhaseIncrement', () => {
     expect(increment).toBeCloseTo(1 / 2000, 8);
   });
 
-  test('calculates negative increment for negative speed', () => {
-    const config = createConfig({ speed: -16, multiplier: 8 }); // 2000ms cycle, backward
+  test('calculates positive increment for negative speed (phase always forward)', () => {
+    const config = createConfig({ speed: -16, multiplier: 8 }); // 2000ms cycle
     const increment = calculatePhaseIncrement(config, 120);
-    expect(increment).toBeLessThan(0);
-    expect(increment).toBeCloseTo(-1 / 2000, 8);
+    // Phase always moves forward; output inversion is handled in LFO class
+    expect(increment).toBeGreaterThan(0);
+    expect(increment).toBeCloseTo(1 / 2000, 8);
   });
 
   test('returns 0 for speed 0', () => {

package/tests/unipolar-digitakt.test.ts

@@ -0,0 +1,387 @@
+/**
+ * Expectation-based tests for EXP and RMP waveforms.
+ *
+ * Based on Digitakt II hardware verification, these waveforms should behave as:
+ *
+ * EXP (Exponential):
+ * - DECAY curve: starts at 1 (peak), decays toward 0 (center)
+ * - Unipolar output range: 0 to 1
+ * - With positive depth: CC goes from (64+depth) down to 64
+ * - Shape: Fast initial decay, slowing toward the end
+ *
+ * RMP (Ramp):
+ * - RISE curve: starts at 0 (center), rises toward 1 (peak)
+ * - Unipolar output range: 0 to 1
+ * - With positive depth: CC goes from 64 up to (64+depth)
+ * - Shape: Linear rise
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { generateExponential, generateRamp } from '../src/engine/waveforms';
+import { LFO } from '../src/engine/lfo';
+
+// Helper to convert LFO output to CC value
+const outputToCC = (output: number): number => {
+  return Math.max(0, Math.min(127, Math.round(64 + output * 63)));
+};
+
+describe('EXP Waveform - Expected Behavior', () => {
+  describe('raw waveform generator', () => {
+    test('should return 1.0 at phase 0 (starts at peak)', () => {
+      expect(generateExponential(0)).toBeCloseTo(1.0, 2);
+    });
+
+    test('should return value < 0.5 at phase 0.5 (decaying)', () => {
+      const value = generateExponential(0.5);
+      expect(value).toBeLessThan(0.5);
+      expect(value).toBeGreaterThan(0);
+    });
+
+    test('should return value near 0 at phase 1 (decayed to center)', () => {
+      expect(generateExponential(1)).toBeLessThan(0.1);
+    });
+
+    test('should monotonically decrease from phase 0 to 1', () => {
+      const phases = [0, 0.2, 0.4, 0.6, 0.8, 1.0];
+      const values = phases.map(p => generateExponential(p));
+
+      for (let i = 1; i < values.length; i++) {
+        expect(values[i]).toBeLessThan(values[i - 1]);
+      }
+    });
+
+    test('should be unipolar (output range 0 to 1)', () => {
+      for (let i = 0; i <= 100; i++) {
+        const value = generateExponential(i / 100);
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(1);
+      }
+    });
+  });
+
+  describe('full LFO with depth=40', () => {
+    const BPM = 120;
+    const DEPTH = 40;
+
+    test('should produce CC near 104 at phase 0 (start at peak)', () => {
+      const lfo = new LFO({
+        waveform: 'EXP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      const state = lfo.update(1);
+      const cc = outputToCC(state.output);
+
+      // At phase 0, EXP should be at peak: CC = 64 + 40 = 104
+      expect(cc).toBeGreaterThan(100);
+      expect(cc).toBeLessThanOrEqual(104);
+    });
+
+    test('should produce CC near 64 at phase 1 (end at center)', () => {
+      const lfo = new LFO({
+        waveform: 'EXP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      // First update to set initial time (deltaMs=0 on first call)
+      lfo.update(1);
+      // Update to near end of cycle
+      const cycleMs = 4000;
+      const state = lfo.update(1 + cycleMs * 0.99);
+      const cc = outputToCC(state.output);
+
+      // At phase ~1, EXP should be near center: CC ≈ 64
+      expect(cc).toBeGreaterThanOrEqual(64);
+      expect(cc).toBeLessThan(75);
+    });
+
+    test('CC should decrease over time (decay behavior)', () => {
+      const lfo = new LFO({
+        waveform: 'EXP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      const cycleMs = 4000;
+
+      const ccStart = outputToCC(lfo.update(1).output);
+      const ccMid = outputToCC(lfo.update(1 + cycleMs * 0.5).output);
+      const ccEnd = outputToCC(lfo.update(1 + cycleMs * 0.99).output);
+
+      expect(ccStart).toBeGreaterThan(ccMid);
+      expect(ccMid).toBeGreaterThan(ccEnd);
+    });
+  });
+});
+
+describe('RMP Waveform - Expected Behavior', () => {
+  describe('raw waveform generator', () => {
+    test('should return 0 at phase 0 (starts at center)', () => {
+      expect(generateRamp(0)).toBe(0);
+    });
+
+    test('should return 0.5 at phase 0.5 (linear rise)', () => {
+      expect(generateRamp(0.5)).toBe(0.5);
+    });
+
+    test('should return 1.0 at phase 1 (ends at peak)', () => {
+      expect(generateRamp(1)).toBe(1);
+    });
+
+    test('should rise linearly from phase 0 to 1', () => {
+      for (let i = 0; i <= 100; i++) {
+        const phase = i / 100;
+        expect(generateRamp(phase)).toBeCloseTo(phase, 5);
+      }
+    });
+
+    test('should be unipolar (output range 0 to 1)', () => {
+      for (let i = 0; i <= 100; i++) {
+        const value = generateRamp(i / 100);
+        expect(value).toBeGreaterThanOrEqual(0);
+        expect(value).toBeLessThanOrEqual(1);
+      }
+    });
+  });
+
+  describe('full LFO with depth=40', () => {
+    const BPM = 120;
+    const DEPTH = 40;
+
+    test('should produce CC near 64 at phase 0 (start at center)', () => {
+      const lfo = new LFO({
+        waveform: 'RMP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      const state = lfo.update(1);
+      const cc = outputToCC(state.output);
+
+      // At phase 0, RMP should be at center: CC = 64
+      expect(cc).toBe(64);
+    });
+
+    test('should produce CC near 104 at phase 1 (end at peak)', () => {
+      const lfo = new LFO({
+        waveform: 'RMP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      // First update to set initial time (deltaMs=0 on first call)
+      lfo.update(1);
+      const cycleMs = 4000;
+      const state = lfo.update(1 + cycleMs * 0.99);
+      const cc = outputToCC(state.output);
+
+      // At phase ~1, RMP should be at peak: CC = 64 + 40 = 104
+      expect(cc).toBeGreaterThan(100);
+      expect(cc).toBeLessThanOrEqual(104);
+    });
+
+    test('CC should increase over time (rise behavior)', () => {
+      const lfo = new LFO({
+        waveform: 'RMP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      const cycleMs = 4000;
+
+      const ccStart = outputToCC(lfo.update(1).output);
+      const ccMid = outputToCC(lfo.update(1 + cycleMs * 0.5).output);
+      const ccEnd = outputToCC(lfo.update(1 + cycleMs * 0.99).output);
+
+      expect(ccStart).toBeLessThan(ccMid);
+      expect(ccMid).toBeLessThan(ccEnd);
+    });
+
+    test('should produce CC range [64-104] over full cycle', () => {
+      const lfo = new LFO({
+        waveform: 'RMP',
+        speed: 16,
+        multiplier: 4,
+        depth: DEPTH,
+        startPhase: 0,
+        mode: 'TRG',
+      }, BPM);
+
+      lfo.trigger();
+      const cycleMs = 4000;
+      let minCC = 127, maxCC = 0;
+
+      for (let i = 0; i <= 100; i++) {
+        const state = lfo.update(1 + (i / 100) * cycleMs);
+        const cc = outputToCC(state.output);
+        minCC = Math.min(minCC, cc);
+        maxCC = Math.max(maxCC, cc);
+      }
+
+      expect(minCC).toBe(64);
+      expect(maxCC).toBeGreaterThanOrEqual(103);
+      expect(maxCC).toBeLessThanOrEqual(104);
+    });
+  });
+});
+
+describe('Depth Scaling Comparison', () => {
+  const BPM = 120;
+  const DEPTH = 40;
+
+  test('TRI (bipolar) should swing ±40 from center [24-104]', () => {
+    const lfo = new LFO({
+      waveform: 'TRI',
+      speed: 16,
+      multiplier: 4,
+      depth: DEPTH,
+      startPhase: 0,
+      mode: 'TRG',
+    }, BPM);
+
+    lfo.trigger();
+    const cycleMs = 4000;
+    let minCC = 127, maxCC = 0;
+
+    for (let i = 0; i <= 100; i++) {
+      const state = lfo.update(1 + (i / 100) * cycleMs);
+      const cc = outputToCC(state.output);
+      minCC = Math.min(minCC, cc);
+      maxCC = Math.max(maxCC, cc);
+    }
+
+    // Bipolar: 64 - 40 = 24, 64 + 40 = 104
+    expect(minCC).toBe(24);
+    expect(maxCC).toBe(104);
+  });
+
+  test('RMP (unipolar) should swing +40 from center [64-104]', () => {
+    const lfo = new LFO({
+      waveform: 'RMP',
+      speed: 16,
+      multiplier: 4,
+      depth: DEPTH,
+      startPhase: 0,
+      mode: 'TRG',
+    }, BPM);
+
+    lfo.trigger();
+    const cycleMs = 4000;
+    let minCC = 127, maxCC = 0;
+
+    for (let i = 0; i <= 100; i++) {
+      const state = lfo.update(1 + (i / 100) * cycleMs);
+      const cc = outputToCC(state.output);
+      minCC = Math.min(minCC, cc);
+      maxCC = Math.max(maxCC, cc);
+    }
+
+    // Unipolar rising: 64 to 64 + 40 = 104
+    expect(minCC).toBe(64);
+    expect(maxCC).toBeGreaterThanOrEqual(103);
+  });
+
+  test('EXP (unipolar) should swing +40 from center [64-104]', () => {
+    const lfo = new LFO({
+      waveform: 'EXP',
+      speed: 16,
+      multiplier: 4,
+      depth: DEPTH,
+      startPhase: 0,
+      mode: 'TRG',
+    }, BPM);
+
+    lfo.trigger();
+    const cycleMs = 4000;
+    let minCC = 127, maxCC = 0;
+
+    for (let i = 0; i <= 100; i++) {
+      const state = lfo.update(1 + (i / 100) * cycleMs);
+      const cc = outputToCC(state.output);
+      minCC = Math.min(minCC, cc);
+      maxCC = Math.max(maxCC, cc);
+    }
+
+    // Unipolar decay: starts at 64 + 40 = 104, decays to 64
+    expect(minCC).toBeGreaterThanOrEqual(64);
+    expect(minCC).toBeLessThan(70);
+    expect(maxCC).toBeGreaterThanOrEqual(103);
+  });
+});
+
+describe('Negative Depth', () => {
+  const BPM = 120;
+  const DEPTH = -40;
+
+  test('EXP with negative depth should produce CC below center', () => {
+    const lfo = new LFO({
+      waveform: 'EXP',
+      speed: 16,
+      multiplier: 4,
+      depth: DEPTH,
+      startPhase: 0,
+      mode: 'TRG',
+    }, BPM);
+
+    lfo.trigger();
+    const state = lfo.update(1);
+    const cc = outputToCC(state.output);
+
+    // With negative depth, peak should be BELOW center: 64 - 40 = 24
+    expect(cc).toBeLessThan(30);
+    expect(cc).toBeGreaterThanOrEqual(24);
+  });
+
+  test('RMP with negative depth should rise toward center', () => {
+    const lfo = new LFO({
+      waveform: 'RMP',
+      speed: 16,
+      multiplier: 4,
+      depth: DEPTH,
+      startPhase: 0,
+      mode: 'TRG',
+    }, BPM);
+
+    lfo.trigger();
+    const state = lfo.update(1);
+    const cc = outputToCC(state.output);
+
+    // At phase 0, RMP should be at center
+    expect(cc).toBe(64);
+
+    // At end of cycle, should be at negative peak
+    const cycleMs = 4000;
+    const stateEnd = lfo.update(1 + cycleMs * 0.99);
+    const ccEnd = outputToCC(stateEnd.output);
+
+    // 64 - 40 = 24
+    expect(ccEnd).toBeLessThan(30);
+    expect(ccEnd).toBeGreaterThanOrEqual(24);
+  });
+});

package/tests/waveforms.test.ts

@@ -143,12 +143,13 @@ describe('Sawtooth Waveform', () => {
 });
 
 describe('Exponential Waveform', () => {
-  test('starts at 0 at phase 0', () => {
-    expect(generateExponential(0)).toBeCloseTo(0, 5);
+  test('starts at 1 at phase 0 (peak, matching Digitakt II)', () => {
+    expect(generateExponential(0)).toBeCloseTo(1, 5);
   });
 
-  test('ends at 1 at phase 1', () => {
-    expect(generateExponential(1)).toBeCloseTo(1, 5);
+  test('decays toward 0 at phase 1', () => {
+    // Normalized exponential decay reaches exactly 0 at phase 1
+    expect(generateExponential(1)).toBeCloseTo(0, 5);
   });
 
   test('is unipolar (0 to +1)', () => {
@@ -157,9 +158,10 @@ describe('Exponential Waveform', () => {
     expect(Math.max(...samples)).toBeLessThanOrEqual(1);
   });
 
-  test('has accelerating (exponential) curve shape', () => {
-    // At phase 0.5, should be less than 0.5 (curve bends up)
+  test('has decaying (exponential decay) curve shape', () => {
+    // At phase 0.5, should be greater than 0.5 (decay curve starts high)
     const midValue = generateExponential(0.5);
+    expect(midValue).toBeGreaterThan(0.1);
     expect(midValue).toBeLessThan(0.5);
   });
 });
@@ -237,7 +239,7 @@ describe('generateWaveform', () => {
     expect(generateWaveform('SIN', 0.25, state).value).toBeCloseTo(1, 5);
     expect(generateWaveform('SQR', 0.25, state).value).toBe(1);
     expect(generateWaveform('SAW', 0.5, state).value).toBe(0);
-    expect(generateWaveform('EXP', 1, state).value).toBeCloseTo(1, 5);
+    expect(generateWaveform('EXP', 0, state).value).toBeCloseTo(1, 5); // EXP starts at peak
     expect(generateWaveform('RMP', 0, state).value).toBe(0);
   });
 });