Lazy chop stretch, path-based state, missing sample relink, button order fix

- Lazy chop preview now respects sample-level stretch settings (Repitch/
  Signalsmith/Bungee) via PreviewStretchParams passed at start
- State serialization v9: store file path instead of PCM data for much
  smaller preset sizes; backward-compatible with v8 PCM restore
- Missing sample detection with orange "MISSING" indicator and click-to-
  relink via file browser in HeaderBar
- ActionPanel button order changed to ADD, LAZY, AUTO, COPY, DEL
- VoicePool::initStretcher/initBungee promoted to public static methods
  so LazyChopEngine can reuse them without duplication
- CLAUDE.md removed from tracking and added to .gitignore

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tucktuckg00se

.gitignore

@@ -20,6 +20,7 @@ desktop.ini
 
 # Claude Code
 .claude/
+CLAUDE.md
 
 # Compiled objects
 *.o

CLAUDE.md

@@ -49,6 +49,9 @@ void IntersectProcessor::drainCommands()
         handleCommand (commandBuffer[(size_t) (scope.startIndex1 + i)]);
     for (int i = 0; i < scope.blockSize2; ++i)
         handleCommand (commandBuffer[(size_t) (scope.startIndex2 + i)]);
+
+    if (scope.blockSize1 + scope.blockSize2 > 0)
+        updateHostDisplay (ChangeDetails().withNonParameterStateChanged (true));
 }
 
 void IntersectProcessor::handleCommand (const Command& cmd)
@@ -58,8 +61,9 @@ void IntersectProcessor::handleCommand (const Command& cmd)
         case CmdLoadFile:
             if (sampleData.loadFromFile (cmd.fileParam, currentSampleRate))
             {
-                // Clear existing slices but don't create a default one
                 sliceManager.clearAll();
+                sampleMissing.store (false);
+                missingFilePath.clear();
             }
             break;
 
@@ -73,7 +77,21 @@ void IntersectProcessor::handleCommand (const Command& cmd)
 
         case CmdLazyChopStart:
             if (sampleData.isLoaded())
-                lazyChop.start (sampleData.getNumFrames(), sliceManager);
+            {
+                PreviewStretchParams psp;
+                psp.stretchEnabled = stretchParam->load() > 0.5f;
+                psp.algorithm      = (int) algoParam->load();
+                psp.bpm            = bpmParam->load();
+                psp.pitch          = pitchParam->load();
+                psp.dawBpm         = dawBpm.load();
+                psp.tonality       = tonalityParam->load();
+                psp.formant        = formantParam->load();
+                psp.formantComp    = formantCompParam->load() > 0.5f;
+                psp.grainMode      = (int) grainModeParam->load();
+                psp.sampleRate     = currentSampleRate;
+                psp.sample         = &sampleData;
+                lazyChop.start (sampleData.getNumFrames(), sliceManager, psp);
+            }
             break;
 
         case CmdLazyChopStop:
@@ -321,7 +339,7 @@ void IntersectProcessor::getStateInformation (juce::MemoryBlock& destData)
     juce::MemoryOutputStream stream (destData, false);
 
     // Version
-    stream.writeInt (8);
+    stream.writeInt (9);
 
     // APVTS state
     auto state = apvts.copyState();
@@ -368,20 +386,8 @@ void IntersectProcessor::getStateInformation (juce::MemoryBlock& destData)
         stream.writeFloat (s.volume);
     }
 
-    // Audio PCM data (stereo interleaved floats)
-    int numFrames = sampleData.getNumFrames();
-    stream.writeInt (numFrames);
-    if (numFrames > 0)
-    {
-        const auto& buf = sampleData.getBuffer();
-        for (int f = 0; f < numFrames; ++f)
-        {
-            stream.writeFloat (buf.getSample (0, f));
-            stream.writeFloat (buf.getSample (1, f));
-        }
-    }
-
-    // v8: sample filename
+    // v9: store file path only (no PCM)
+    stream.writeString (sampleData.getFilePath());
     stream.writeString (sampleData.getFileName());
 }
 
@@ -460,21 +466,47 @@ void IntersectProcessor::setStateInformation (const void* data, int sizeInBytes)
         }
     }
 
-    // Audio PCM
-    int numFrames = stream.readInt();
-    if (numFrames > 0)
+    if (version >= 9)
     {
-        juce::AudioBuffer<float> restoredBuf (2, numFrames);
-        for (int f = 0; f < numFrames; ++f)
+        // v9: path-only restore
+        auto filePath = stream.readString();
+        auto fileName = stream.readString();
+
+        if (filePath.isNotEmpty())
         {
-            restoredBuf.setSample (0, f, stream.readFloat());
-            restoredBuf.setSample (1, f, stream.readFloat());
+            juce::File f (filePath);
+            double sr = currentSampleRate > 0 ? currentSampleRate : 44100.0;
+            if (f.existsAsFile() && sampleData.loadFromFile (f, sr))
+            {
+                sampleMissing.store (false);
+            }
+            else
+            {
+                sampleMissing.store (true);
+                missingFilePath = filePath;
+                sampleData.setFileName (fileName);
+                sampleData.setFilePath (filePath);
+            }
         }
-        sampleData.loadFromBuffer (std::move (restoredBuf));
     }
+    else
+    {
+        // v8 and earlier: PCM restore (backward compat)
+        int numFrames = stream.readInt();
+        if (numFrames > 0)
+        {
+            juce::AudioBuffer<float> restoredBuf (2, numFrames);
+            for (int f = 0; f < numFrames; ++f)
+            {
+                restoredBuf.setSample (0, f, stream.readFloat());
+                restoredBuf.setSample (1, f, stream.readFloat());
+            }
+            sampleData.loadFromBuffer (std::move (restoredBuf));
+        }
 
-    if (version >= 8)
-        sampleData.setFileName (stream.readString());
+        if (version >= 8)
+            sampleData.setFileName (stream.readString());
+    }
 
     sliceManager.rebuildMidiMap();
 }

project/src/PluginProcessor.cpp

@@ -100,6 +100,10 @@ class IntersectProcessor : public juce::AudioProcessor
     // MIDI-selects-slice toggle
     std::atomic<bool> midiSelectsSlice { false };
 
+    // Missing sample state (for relink UI)
+    std::atomic<bool> sampleMissing { false };
+    juce::String missingFilePath;
+
 private:
     void drainCommands();
     void handleCommand (const Command& cmd);

project/src/PluginProcessor.h

@@ -1,13 +1,15 @@
 #include "LazyChopEngine.h"
 #include <cmath>
 
-void LazyChopEngine::start (int sampleLen, SliceManager& sliceMgr)
+void LazyChopEngine::start (int sampleLen, SliceManager& sliceMgr,
+                            const PreviewStretchParams& params)
 {
     active = true;
     playing = false;
     chopPos = 0;
     sampleLength = sampleLen;
     lastNote = -1;
+    cachedParams = params;
 
     nextMidiNote = sliceMgr.rootNote.load();
     int num = sliceMgr.getNumSlices();
@@ -26,7 +28,6 @@ void LazyChopEngine::startPreview (VoicePool& voicePool, int fromPos)
     v.active      = true;
     v.sliceIdx    = -1;
     v.position    = (double) fromPos;
-    v.speed       = 1.0;
     v.direction   = 1;
     v.velocity    = 1.0f;
     v.midiNote    = -1;
@@ -36,9 +37,75 @@ void LazyChopEngine::startPreview (VoicePool& voicePool, int fromPos)
     v.muteGroup   = 0;
     v.wsolaActive = false;
     v.stretchActive = false;
+    v.bungeeActive  = false;
     v.pitchRatio  = 1.0f;
     v.age         = 0;
     v.looping     = true;
+    v.volume      = 1.0f;
+    v.speed       = 1.0;
+
+    // Apply stretch from cached sample-level params
+    const auto& p = cachedParams;
+    int algo = p.algorithm;
+
+    if (p.stretchEnabled && p.dawBpm > 0.0f && p.bpm > 0.0f)
+    {
+        float speedRatio = p.dawBpm / p.bpm;
+
+        if (algo == 0)
+        {
+            // Repitch: speed change (pitch is consequence)
+            v.speed = speedRatio;
+        }
+        else if (algo == 2 && p.sample != nullptr)
+        {
+            // Bungee
+            v.bungeeActive = true;
+            v.speed = 1.0;
+            v.bungeeSpeed = (double) speedRatio;
+            v.bungeeSrcPos = fromPos;
+            int hopAdj = juce::jlimit (-1, 1, p.grainMode - 1);
+            VoicePool::initBungee (v, p.pitch, p.sampleRate, hopAdj);
+        }
+        else if (p.sample != nullptr)
+        {
+            // Signalsmith Stretch
+            v.stretchActive = true;
+            v.speed = 1.0;
+            v.stretchTimeRatio = speedRatio;
+            v.stretchPitchSemis = p.pitch;
+            v.stretchSrcPos = fromPos;
+            VoicePool::initStretcher (v, p.pitch, p.sampleRate,
+                                      p.tonality, p.formant, p.formantComp, *p.sample);
+        }
+    }
+    else if (algo == 1 && p.sample != nullptr)
+    {
+        // Stretch algo, no stretch enabled — pitch only via Signalsmith
+        v.stretchActive = true;
+        v.speed = 1.0;
+        v.stretchTimeRatio = 1.0f;
+        v.stretchPitchSemis = p.pitch;
+        v.stretchSrcPos = fromPos;
+        VoicePool::initStretcher (v, p.pitch, p.sampleRate,
+                                  p.tonality, p.formant, p.formantComp, *p.sample);
+    }
+    else if (algo == 2 && p.sample != nullptr)
+    {
+        // Bungee algo, no stretch — pitch only
+        v.bungeeActive = true;
+        v.speed = 1.0;
+        v.bungeeSpeed = 1.0;
+        v.bungeeSrcPos = fromPos;
+        int hopAdj = juce::jlimit (-1, 1, p.grainMode - 1);
+        VoicePool::initBungee (v, p.pitch, p.sampleRate, hopAdj);
+    }
+    else
+    {
+        // Repitch: apply pitch ratio to speed
+        v.pitchRatio = std::pow (2.0f, p.pitch / 12.0f);
+        v.speed = v.pitchRatio;
+    }
 
     // Sustain at half volume
     v.envelope.noteOn (0.0f, 0.0f, 0.5f, 0.02f);
@@ -49,6 +116,10 @@ void LazyChopEngine::stop (VoicePool& voicePool, SliceManager& /*sliceMgr*/)
     // Stop preview voice
     auto& v = voicePool.getVoice (getPreviewVoiceIndex());
     v.active = false;
+    v.stretchActive = false;
+    v.bungeeActive = false;
+    v.stretcher.reset();
+    v.bungeeStretcher.reset();
 
     active = false;
     playing = false;

project/src/audio/LazyChopEngine.cpp

@@ -2,14 +2,29 @@
 #include "VoicePool.h"
 #include "SliceManager.h"
 
+struct PreviewStretchParams
+{
+    bool  stretchEnabled = false;
+    int   algorithm      = 0;
+    float bpm            = 120.0f;
+    float pitch          = 0.0f;
+    float dawBpm         = 120.0f;
+    float tonality       = 0.0f;
+    float formant        = 0.0f;
+    bool  formantComp    = false;
+    int   grainMode      = 0;
+    double sampleRate    = 44100.0;
+    const SampleData* sample = nullptr;
+};
+
 class LazyChopEngine
 {
 public:
     bool isActive() const { return active; }
     bool isPlaying() const { return playing; }
     int  getChopPos() const { return chopPos; }
 
-    void start (int sampleLen, SliceManager& sliceMgr);
+    void start (int sampleLen, SliceManager& sliceMgr, const PreviewStretchParams& params);
     void stop (VoicePool& voicePool, SliceManager& sliceMgr);
     void onNote (int note, VoicePool& voicePool, SliceManager& sliceMgr);
 
@@ -24,4 +39,6 @@ class LazyChopEngine
     int  nextMidiNote = 36;
     int  sampleLength = 0;
     int  lastNote     = -1;
+
+    PreviewStretchParams cachedParams;
 };