elektron-lfo 1.0.1 → 1.0.3

package/dist/index.js

@@ -283,7 +283,15 @@ function checkModeStop(config, state, previousPhase, currentPhase) {
   const isForward = config.speed >= 0;
   if (config.mode === "ONE") {
     if (state.cycleCount >= 1) {
-      return { shouldStop: true, cycleCompleted: true };
+      if (isForward) {
+        if (startPhase === 0 || currentPhase >= startPhase) {
+          return { shouldStop: true, cycleCompleted: true };
+        }
+      } else {
+        if (startPhase === 0 || currentPhase <= startPhase) {
+          return { shouldStop: true, cycleCompleted: true };
+        }
+      }
     }
   } else if (config.mode === "HLF") {
     const halfPhase = (startPhase + 0.5) % 1;

package/package.json

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

package/src/engine/triggers.ts

@@ -112,11 +112,23 @@ export function checkModeStop(
   const isForward = config.speed >= 0;
 
   if (config.mode === 'ONE') {
-    // ONE mode: Stop after completing one full cycle
-    // We detect this by checking if cycleCount has incremented (phase wrapped)
-    // and we've returned to or passed the start phase
+    // ONE mode: Stop after completing one full cycle back to startPhase
+    // For non-zero startPhase, we need to:
+    // 1. Wait for phase to wrap (cycleCount >= 1)
+    // 2. Then continue until we reach/pass the startPhase again
     if (state.cycleCount >= 1) {
-      return { shouldStop: true, cycleCompleted: true };
+      if (isForward) {
+        // Forward: stop when current phase reaches or passes startPhase after wrapping
+        // Handle the case where startPhase is 0 (stop immediately on wrap)
+        if (startPhase === 0 || currentPhase >= startPhase) {
+          return { shouldStop: true, cycleCompleted: true };
+        }
+      } else {
+        // Backward: stop when current phase reaches or goes below startPhase after wrapping
+        if (startPhase === 0 || currentPhase <= startPhase) {
+          return { shouldStop: true, cycleCompleted: true };
+        }
+      }
     }
   } else if (config.mode === 'HLF') {
     // HLF mode: Stop after half cycle (0.5 phase distance from start)

package/tests/triggers.test.ts

@@ -240,6 +240,64 @@ describe('checkModeStop - ONE mode', () => {
     const result = checkModeStop(config, state, 0.05, 0.95);
     expect(result.shouldStop).toBe(true);
   });
+
+  test('with non-zero startPhase, does NOT stop immediately after wrap - must reach startPhase', () => {
+    // Bug fix: With startPhase 53 (~0.414), the LFO should:
+    // 1. Start at 0.414
+    // 2. Run to 1.0, wrap to 0.0 (cycleCount = 1)
+    // 3. Continue from 0.0 to 0.414 (startPhase)
+    // 4. THEN stop
+    const config = createConfig({ mode: 'ONE', speed: 16, startPhase: 53 });
+    const startPhaseNormalized = 53 / 128; // ~0.414
+
+    // After wrap, phase is 0.1, which is BEFORE startPhase (0.414)
+    // Should NOT stop yet
+    const stateAfterWrap = createState({
+      hasTriggered: true,
+      startPhaseNormalized,
+      cycleCount: 1,
+    });
+    const resultBeforeStart = checkModeStop(config, stateAfterWrap, 0.05, 0.1);
+    expect(resultBeforeStart.shouldStop).toBe(false);
+
+    // Phase reaches 0.3, still before startPhase - should NOT stop
+    const resultStillBefore = checkModeStop(config, stateAfterWrap, 0.2, 0.3);
+    expect(resultStillBefore.shouldStop).toBe(false);
+
+    // Phase crosses startPhase (0.414) - NOW should stop
+    const resultAtStart = checkModeStop(config, stateAfterWrap, 0.4, 0.45);
+    expect(resultAtStart.shouldStop).toBe(true);
+    expect(resultAtStart.cycleCompleted).toBe(true);
+  });
+
+  test('with non-zero startPhase (backward), continues after wrap until reaching startPhase', () => {
+    // Backward direction with startPhase 53 (~0.414):
+    // 1. Start at 0.414
+    // 2. Run backward to 0.0, wrap to 1.0 (cycleCount = 1)
+    // 3. Continue from 1.0 down to 0.414
+    // 4. THEN stop
+    const config = createConfig({ mode: 'ONE', speed: -16, startPhase: 53 });
+    const startPhaseNormalized = 53 / 128; // ~0.414
+
+    // After wrap going backward, phase is 0.9, which is ABOVE startPhase (0.414)
+    // Should NOT stop yet
+    const stateAfterWrap = createState({
+      hasTriggered: true,
+      startPhaseNormalized,
+      cycleCount: 1,
+    });
+    const resultAfterWrap = checkModeStop(config, stateAfterWrap, 0.95, 0.9);
+    expect(resultAfterWrap.shouldStop).toBe(false);
+
+    // Phase reaches 0.5, still above startPhase - should NOT stop
+    const resultStillAbove = checkModeStop(config, stateAfterWrap, 0.6, 0.5);
+    expect(resultStillAbove.shouldStop).toBe(false);
+
+    // Phase crosses startPhase (0.414) going down - NOW should stop
+    const resultAtStart = checkModeStop(config, stateAfterWrap, 0.45, 0.4);
+    expect(resultAtStart.shouldStop).toBe(true);
+    expect(resultAtStart.cycleCompleted).toBe(true);
+  });
 });
 
 describe('checkModeStop - HLF mode', () => {