// File: src/common/dsp/oscillators/ClassicOscillator.cpp
void ClassicOscillator::process_block(float pitch, float drift, bool stereo)
{
    // Implementation details...
}

// From: src/common/SurgeStorage.h
const int n_scenes = 2;

enum scene_mode
{
    sm_single = 0,     // Only Scene A is active
    sm_split,          // Keyboard split between A and B
    sm_dual,           // Both scenes layer
    sm_chsplit,        // MIDI channel split

    n_scene_modes,
};

// From: src/common/globals.h
#if !defined(SURGE_COMPILE_BLOCK_SIZE)
#error You must compile with -DSURGE_COMPILE_BLOCK_SIZE=32 (or whatnot)
#endif

const int BLOCK_SIZE = SURGE_COMPILE_BLOCK_SIZE;  // Default: 32 samples
const int OSC_OVERSAMPLING = 2;                   // 2x oversampling
const int BLOCK_SIZE_OS = OSC_OVERSAMPLING * BLOCK_SIZE;  // 64 samples
const int BLOCK_SIZE_QUAD = BLOCK_SIZE >> 2;      // 8 quads (for SSE)
const int BLOCK_SIZE_OS_QUAD = BLOCK_SIZE_OS >> 2; // 16 quads

// From: src/common/globals.h
#include "sst/basic-blocks/simd/setup.h"

// SSE2 processes 4 floats at once (128-bit registers)
// This is why many structures are "quad" variants
const int BLOCK_SIZE_QUAD = BLOCK_SIZE >> 2;  // 32 / 4 = 8 iterations

// Voice processing: Process 4 voices simultaneously
// Filter processing: Process filter coefficients for 4 voices at once

// All DSP buffers must be 16-byte aligned for SSE2
float __attribute__((aligned(16))) buffer[BLOCK_SIZE];

// Or using the provided macro:
alignas(16) float output[BLOCK_SIZE_OS];

// From: src/common/globals.h
const int MAX_VOICES = 64;
const int MAX_UNISON = 16;  // Up to 16 unison voices per note
const int DEFAULT_POLYLIMIT = 16;  // Default polyphony limit

// From: src/common/SurgeStorage.h
class SurgeStorage
{
public:
    // Central parameter array - the heart of the synth
    Parameter param_ptr[n_total_params];

    // Wavetable storage
    std::vector<Wavetable> wt;

    // Patch database for browsing
    std::unique_ptr<PatchDB> patchDB;

    // Tuning system
    Tunings::Tuning currentTuning;

    // Resource paths
    fs::path datapath;      // Factory data
    fs::path userDataPath;  // User patches/wavetables

    // Sample rate (entire engine runs at this rate)
    float samplerate{44100.0};
    float samplerate_inv{1.0 / 44100.0};
};

// From: src/common/SurgeSynthesizer.h
class SurgeSynthesizer
{
public:
    // Main audio processing - called by plugin host
    void process();

    // Process a single block (32 samples default)
    void processControl();  // Update modulation, envelopes
    void processAudio();    // Generate audio

    // Voice management
    std::array<SurgeVoice, MAX_VOICES> voices;
    int64_t voiceCounter{0};  // For voice stealing priority

    // Scene state
    std::array<int, n_scenes> polyphonyLimit{DEFAULT_POLYLIMIT, DEFAULT_POLYLIMIT};

    // MIDI event queue
    std::vector<MIDIEvent> midiEvents;

    // Reference to storage
    SurgeStorage *storage{nullptr};
};

// From: src/common/SurgePatch.h
class SurgePatch
{
public:
    // Patch metadata
    char name[NAMECHARS];
    char author[NAMECHARS];
    char category[NAMECHARS];

    // Parameter storage (copies of Parameter objects)
    // This is the "saved state" of the synth

    // Patch I/O
    void loadPatch(const fs::path &filename);
    void savePatch(const fs::path &filename);

    // XML parsing and generation
    TiXmlElement *streamToXML();
    void streamFromXML(TiXmlElement *root);
};

// From: src/common/globals.h

// Window size (before scaling)
const int BASE_WINDOW_SIZE_X = 913;
const int BASE_WINDOW_SIZE_Y = 569;

// Audio processing blocks
const int BLOCK_SIZE = SURGE_COMPILE_BLOCK_SIZE;     // 32 samples
const int OSC_OVERSAMPLING = 2;                      // 2x for oscillators
const int BLOCK_SIZE_OS = OSC_OVERSAMPLING * BLOCK_SIZE;  // 64 samples

// SIMD processing (4 samples per SSE2 register)
const int BLOCK_SIZE_QUAD = BLOCK_SIZE >> 2;         // 8 quads
const int BLOCK_SIZE_OS_QUAD = BLOCK_SIZE_OS >> 2;   // 16 quads

// Inverse values (multiply instead of divide)
const float BLOCK_SIZE_INV = (1.f / BLOCK_SIZE);
const float BLOCK_SIZE_OS_INV = (1.f / BLOCK_SIZE_OS);

// Maximum values
const int MAX_FB_COMB = 2048;                        // Comb filter delay
const int MAX_FB_COMB_EXTENDED = 2048 * 64;          // Combulator extended
const int MAX_VOICES = 64;                           // Total polyphony
const int MAX_UNISON = 16;                           // Unison voices per note

// I/O configuration
const int N_OUTPUTS = 2;                             // Stereo out
const int N_INPUTS = 2;                              // Stereo in

// Defaults
const int DEFAULT_POLYLIMIT = 16;

// OSC (Open Sound Control) network ports
const int DEFAULT_OSC_PORT_IN = 53280;
const int DEFAULT_OSC_PORT_OUT = 53281;

// From: src/common/SurgeStorage.h

const int n_oscs = 3;                    // Oscillators per scene
const int n_lfos_voice = 6;              // Voice LFOs
const int n_lfos_scene = 6;              // Scene LFOs
const int n_lfos = n_lfos_voice + n_lfos_scene;  // Total: 12

const int n_egs = 2;                     // Envelope generators (Filter, Amp)
const int n_osc_params = 7;              // Parameters per oscillator

// Effects system
const int n_fx_slots = 16;               // Total effect slots
const int n_fx_chains = 4;               // Chains: A, B, Send1, Send2
const int n_fx_per_chain = 4;            // 4 effects per chain
const int n_fx_params = 12;              // Parameters per effect

// Total parameter counts
const int n_scene_params = 273;          // Parameters per scene
const int n_global_params = 11 + n_fx_slots * (n_fx_params + 1);
const int n_global_postparams = 1;
const int n_total_params = n_global_params + 2 * n_scene_params + n_global_postparams;
// Result: 11 + 16 * 13 + 1 + 2 * 273 = 11 + 208 + 1 + 546 = 766 parameters total

# From CMakeLists.txt

# Main synthesizer plugins
surge-xt_VST3          # VST3 plugin
surge-xt_AU            # Audio Unit (macOS)
surge-xt_CLAP          # CLAP plugin
surge-xt_LV2           # LV2 plugin (optional)
surge-xt_Standalone    # Standalone application

# Effects-only plugins
surge-fx_VST3
surge-fx_AU
surge-fx_CLAP
surge-fx_Standalone

# Development targets
surge-testrunner       # Headless test suite
surgepy                # Python bindings

# Meta-targets
surge-staged-assets    # Build all with staging
surge-xt-distribution  # Create installer

# Critical defines
-DSURGE_COMPILE_BLOCK_SIZE=32      # Can be tuned for different systems
-DCMAKE_BUILD_TYPE=Release         # Release, Debug, RelWithDebInfo
-DSURGE_BUILD_PYTHON_BINDINGS=ON   # Optional Python support
-DSURGE_BUILD_LV2=TRUE             # Optional LV2 format

// SurgeSynthProcessor.cpp (JUCE plugin wrapper)
void processBlock(AudioBuffer<float>& buffer, MidiBuffer& midiMessages)
{
    for (const auto metadata : midiMessages)
    {
        auto message = metadata.getMessage();

        if (message.isNoteOn())
        {
            surge->playNote(channel, note, velocity, 0);
        }
    }
}

// SurgeSynthesizer.cpp
void SurgeSynthesizer::playNote(char channel, char key, char velocity, char detune)
{
    // Find free voice or steal one
    int voice_id = findFreeVoice();

    if (voice_id < 0)
        voice_id = stealVoice();  // No free voices - steal quietest

    // Initialize voice
    voices[voice_id].init(key, velocity, scene_id);
    voices[voice_id].state.gate = true;
}

// SurgeSynthesizer.cpp
void SurgeSynthesizer::process()
{
    // Process in BLOCK_SIZE chunks (32 samples)
    processControl();  // Update modulation, envelopes (slow rate)

    // Process all active voices
    for (int i = 0; i < MAX_VOICES; i++)
    {
        if (voices[i].state.active)
        {
            voices[i].process_block();  // Generate audio
        }
    }

    // Mix voices and process effects
    processFXChains();
}

// SurgeVoice.cpp
void SurgeVoice::process_block()
{
    // 1. Generate oscillator output (3 oscillators)
    for (int osc = 0; osc < n_oscs; osc++)
        oscillators[osc]->process_block();

    // 2. Mix oscillators with ring modulation
    mixOscillators();

    // 3. Filter processing (quad-processing for SIMD)
    filterChain.process_block(input);

    // 4. Apply amp envelope
    applyAmpEnvelope();

    // 5. Output to voice accumulator
}

// Process 4 parallel effect chains
for (int chain = 0; chain < n_fx_chains; chain++)
{
    for (int slot = 0; slot < n_fx_per_chain; slot++)
    {
        if (fx[chain][slot])
            fx[chain][slot]->process(dataL, dataR);
    }
}

// Copy to plugin host's buffer
for (int i = 0; i < BLOCK_SIZE; i++)
{
    buffer.setSample(0, i, outputL[i]);
    buffer.setSample(1, i, outputR[i]);
}

std::atomic<bool> parameterChanged[n_total_params];
// Audio thread checks these atomics each block

// From: src/common/Parameter.h (lines 35-40)
union pdata
{
    int i;
    bool b;
    float f;
};

// From: src/common/Parameter.h (lines 42-47)
enum valtypes
{
    vt_int = 0,
    vt_bool,
    vt_float,
};

// From: src/common/Parameter.h (line 509)
pdata val{}, val_default{}, val_min{}, val_max{};

// From: src/common/Parameter.cpp (lines 598-604)
case ct_pitch:
case ct_pitch_extendable_very_low_minval:
    valtype = vt_float;
    val_min.f = -60;    // 60 semitones down (5 octaves)
    val_max.f = 60;     // 60 semitones up (5 octaves)
    val_default.f = 0;  // Default: no transposition
    break;

// From: src/common/Parameter.h (lines 49-221)
enum ctrltypes
{
    ct_none,
    ct_percent,                      // 0% to 100%
    ct_percent_deactivatable,        // Can be turned off
    ct_percent_bipolar,              // -100% to +100%
    ct_decibel,                      // Decibel display
    ct_decibel_narrow,               // Narrower dB range
    ct_decibel_attenuation,          // Attenuation only (0 to -∞)
    ct_freq_audible,                 // Frequency in Hz
    ct_freq_audible_deactivatable,   // Frequency that can be disabled
    ct_pitch,                        // Pitch in semitones
    ct_pitch_semi7bp,                // ±7 semitone range
    ct_envtime,                      // Envelope time
    ct_envtime_deactivatable,        // Envelope time that can be disabled
    ct_lforate,                      // LFO rate
    ct_lforate_deactivatable,        // LFO rate that can be disabled
    ct_portatime,                    // Portamento time
    ct_osctype,                      // Oscillator type selector
    ct_fxtype,                       // Effect type selector
    ct_filtertype,                   // Filter type selector
    ct_bool,                         // Boolean on/off
    ct_midikey,                      // MIDI key number
    // ... and 200+ more types

    num_ctrltypes,
};

// From: src/common/Parameter.cpp
case ct_percent:
    valtype = vt_float;
    val_min.f = 0.f;
    val_max.f = 1.f;        // Internally 0.0 to 1.0
    val_default.f = 0.f;
    break;

// Simplified from Parameter::get_display()
if (ctrltype == ct_percent)
{
    snprintf(txt, TXT_SIZE, "%.2f %%", val.f * 100.f);
}

case ct_freq_audible:
    valtype = vt_float;
    val_min.f = -60.f;      // MIDI note 0 = 8.176 Hz
    val_max.f = 70.f;       // MIDI note 130 = 11,839 Hz
    val_default.f = 60.f;   // Middle C = 261.6 Hz
    break;

// Simplified display logic
float pitch = storage->note_to_pitch(val.f);  // Uses tuning tables
float freq = 440.0f * pitch;                  // Concert A reference
snprintf(txt, TXT_SIZE, "%.2f Hz", freq);

// From: src/common/Parameter.cpp (lines 252-269)
bool Parameter::can_temposync() const
{
    switch (ctrltype)
    {
    case ct_portatime:
    case ct_lforate:
    case ct_lforate_deactivatable:
    case ct_envtime:
    case ct_envtime_deformable:
    case ct_reverbpredelaytime:
        return true;
    }
    return false;
}

// From: src/common/Parameter.h (line 536)
bool temposync{}, absolute{}, deactivated{}, extend_range{};

// From: src/common/Parameter.cpp (lines 271-314)
bool Parameter::can_extend_range() const
{
    switch (ctrltype)
    {
    case ct_percent_with_extend_to_bipolar:       // Extends unipolar to bipolar
    case ct_pitch_semi7bp:                         // Extends ±7 to full range
    case ct_freq_shift:                            // Extends frequency shift range
    case ct_decibel_extendable:                    // More extreme dB values
    case ct_osc_feedback:                          // Higher feedback amounts
    case ct_lfoamplitude:                          // Extends LFO amplitude
        return true;
    }
    return false;
}

// From: src/common/Parameter.cpp (lines 329-355)
bool Parameter::can_deactivate() const
{
    switch (ctrltype)
    {
    case ct_percent_deactivatable:
    case ct_freq_audible_deactivatable:
    case ct_freq_audible_deactivatable_hp:    // High-pass filter
    case ct_freq_audible_deactivatable_lp:    // Low-pass filter
    case ct_lforate_deactivatable:
    case ct_envtime_deactivatable:
        return true;
    }
    return false;
}

// From: src/common/SurgePatch.cpp (lines 69-72)
param_ptr.push_back(volume.assign(
    p_id.next(),                              // Unique ID promise
    0,                                        // Scene-local ID (0 = global)
    "volume",                                 // Internal name
    "Global Volume",                          // Display name
    "global/volume",                          // OSC name
    ct_decibel_attenuation_clipper,           // Control type
    Surge::Skin::Global::master_volume,       // UI position
    0,                                        // Scene (0 = global)
    cg_GLOBAL,                                // Control group
    0,                                        // Group entry
    true,                                     // Modulateable?
    int(kHorizontal) | int(kEasy)             // UI flags
));

// From: src/common/Parameter.h (lines 316-363)
struct ParameterIDCounter
{
    struct ParameterIDPromise
    {
        std::shared_ptr<ParameterIDPromise> next;
        long value = -1;
    };

    promise_t head, tail;

    // Get next promise (doesn't assign value yet)
    promise_t next()
    {
        promise_t n(new ParameterIDPromise());
        tail->next = n;
        auto ret = tail;
        tail = n;
        return ret;
    }

    // Resolve all promises to actual IDs
    void resolve() const
    {
        auto h = head;
        int val = 0;
        while (h.get())
        {
            h->value = val++;
            h = h->next;
        }
    }
};

// From: src/common/Parameter.h (lines 517-539)
class Parameter
{
public:
    int id{};                                  // Globally unique ID
    char name[NAMECHARS]{};                    // Internal name
    char dispname[NAMECHARS]{};                // Display name
    char name_storage[NAMECHARS]{};            // Storage name (for patches)
    char fullname[NAMECHARS]{};                // Full qualified name
    char ui_identifier[NAMECHARS]{};           // UI widget ID

    bool modulateable{};                       // Can be modulated?
    int valtype = 0;                           // vt_int/bool/float
    int scene{};                               // 0=patch, 1=scene A, 2=scene B
    int ctrltype{};                            // ct_percent, ct_freq_audible, etc.

    int posx, posy, posy_offset;               // UI position
    ControlGroup ctrlgroup = cg_GLOBAL;        // Which section (OSC, FILTER, etc.)
    int ctrlgroup_entry = 0;                   // Which instance (Osc 1, Osc 2, etc.)

    bool temposync{}, absolute{}, deactivated{}, extend_range{};
    float moverate{};                          // UI response speed
    bool per_voice_processing{};               // Voice vs. scene processing
};

// From: src/common/Parameter.h (lines 228-238)
enum ControlGroup
{
    cg_GLOBAL = 0,     // Global parameters
    cg_OSC = 2,        // Oscillator parameters
    cg_MIX = 3,        // Mixer parameters
    cg_FILTER = 4,     // Filter parameters
    cg_ENV = 5,        // Envelope parameters
    cg_LFO = 6,        // LFO/modulator parameters
    cg_FX = 7,         // Effect parameters
    endCG
};

const char ControlGroupDisplay[endCG][32] = {
    "Global", "", "Oscillators", "Mixer",
    "Filters", "Envelopes", "Modulators", "FX"
};

// From: src/common/Parameter.h (lines 488-493)
float get_modulation_f01(float mod) const;   // Convert mod depth to 0-1
float set_modulation_f01(float v) const;     // Convert 0-1 to mod depth

// Simplified from SurgeVoice.cpp
float pitch_base = scene->pitch.val.f;
float pitch_modulated = pitch_base +
    (lfo1.output * lfo1_to_pitch_depth) +
    (lfo2.output * lfo2_to_pitch_depth) +
    // ... other modulators

// From: src/common/Parameter.h (line 533)
float moverate{};  // Smoothing speed multiplier

// Simplified smoothing logic
float target = param.val.f;
float current = param_smoothed[param.id];
float rate = param.moverate * BLOCK_SIZE_INV;

current += (target - current) * rate;
param_smoothed[param.id] = current;

// From: src/common/SurgePatch.h (lines 1215-1216)
std::vector<Parameter *> param_ptr;

// Get parameter by global ID
Parameter *p = storage->getPatch().param_ptr[param_id];

// Set value
p->val.f = 0.5f;

// Get display string
char display[256];
p->get_display(display);  // "50.0 %"

// From: src/common/SurgeStorage.h (lines 150-154)
const int n_scene_params = 273;     // Parameters per scene
const int n_global_params = 11 +    // Global controls
    n_fx_slots * (n_fx_params + 1); // FX (16 slots × 13 params each)
const int n_global_postparams = 1;  // Character parameter
const int n_total_params = n_global_params +
                           2 * n_scene_params +
                           n_global_postparams;

// n_global_params = 11 + (16 × 13) = 11 + 208 = 219
// n_total_params = 219 + (2 × 273) + 1 = 219 + 546 + 1 = 766

// From: src/common/SurgeStorage.h (lines 1560-1565)
std::vector<Patch> wt_list;                  // All available wavetables
std::vector<PatchCategory> wt_category;      // Wavetable categories
int firstThirdPartyWTCategory;               // Category boundary
int firstUserWTCategory;                     // Category boundary
std::vector<int> wtOrdering;                 // Sorted order
std::vector<int> wtCategoryOrdering;         // Category sort order

// From: src/common/SurgeStorage.h
void refresh_wtlist();                       // Scan wavetable directories
void load_wt(int id, Wavetable *wt,         // Load wavetable by ID
             OscillatorStorage *);
void load_wt(std::string filename,          // Load by filename
             Wavetable *wt, OscillatorStorage *);

// From: src/common/SurgeStorage.h (lines 1648-1652)
Tunings::Tuning currentTuning;               // Active tuning
Tunings::Scale currentScale;                 // Current scale (.scl)
Tunings::KeyboardMapping currentMapping;     // Current mapping (.kbm)
bool isStandardTuning = true;                // Using 12-TET?
bool isStandardScale = true;
bool isStandardMapping = true;

// From: src/common/SurgeStorage.h (lines 1615-1626)
float note_to_pitch(float x);                      // MIDI note → pitch multiplier
float note_to_pitch_inv(float x);                  // Inverse
float note_to_pitch_ignoring_tuning(float x);      // 12-TET only
void note_to_omega(float note, float &omega_out,   // Note → angular frequency
                   float &omega_out2);

// From: src/common/SurgeStorage.h (lines 1366-1368)
float samplerate{0}, samplerate_inv{1};           // Float SR
double dsamplerate{0}, dsamplerate_inv{1};        // Double precision
double dsamplerate_os{0}, dsamplerate_os_inv{1};  // Oversampled rate

void setSamplerate(float sr);                      // Update sample rate

// From: src/common/SurgeStorage.h (lines 1363-1365, 1447-1455)
float *sinctable, *sinctable1X;                    // Sinc interpolation
float table_dB[512];                               // dB conversion
float table_envrate_lpf[512];                      // Envelope rates
float table_envrate_linear[512];                   // Linear envelope rates
float table_glide_exp[512];                        // Exponential glide
float table_glide_log[512];                        // Logarithmic glide

static constexpr int tuning_table_size = 512;
float table_pitch[tuning_table_size];              // MIDI note → pitch
float table_pitch_inv[tuning_table_size];          // Inverse
float table_note_omega[2][tuning_table_size];      // Note → omega

// Instead of: pow(10.0, db / 20.0)
float linear = storage->table_dB[(int)(db_value * scale_factor)];

// From: src/common/SurgeStorage.h (lines 1571-1586)
fs::path datapath;                     // Factory data (read-only)
fs::path userDefaultFilePath;          // User preferences
fs::path userDataPath;                 // User data root
fs::path userPatchesPath;              // User patches
fs::path userWavetablesPath;           // User wavetables
fs::path userModulatorSettingsPath;    // LFO presets
fs::path userFXPath;                   // FX presets
fs::path userSkinsPath;                // Custom skins
fs::path userMidiMappingsPath;         // MIDI learn maps

// From: src/common/SurgeStorage.h (lines 1459-1462, 1551-1557)
std::unique_ptr<Surge::PatchStorage::PatchDB> patchDB;
bool patchDBInitialized{false};

std::vector<Patch> patch_list;                     // All patches
std::vector<PatchCategory> patch_category;         // Categories
int firstThirdPartyCategory;                       // Category boundary
int firstUserCategory;                             // Category boundary
std::vector<int> patchOrdering;                    // Sort order
std::vector<int> patchCategoryOrdering;            // Category sort

// From: src/common/SurgeStorage.h (lines 1354-1357)
float audio_in alignas(16)[2][BLOCK_SIZE_OS];      // Oversampled input
float audio_in_nonOS alignas(16)[2][BLOCK_SIZE];   // Non-oversampled
float audio_otherscene alignas(16)[2][BLOCK_SIZE_OS]; // Other scene output

// From: src/common/SurgeStorage.h (lines 1880-1931)
struct RNGGen
{
    std::minstd_rand g;                            // Generator
    std::uniform_int_distribution<int> d;          // Integer distribution
    std::uniform_real_distribution<float> pm1;     // -1 to +1
    std::uniform_real_distribution<float> z1;      // 0 to 1
    std::uniform_int_distribution<uint32_t> u32;   // 32-bit unsigned
} rngGen;

inline int rand() { return rngGen.d(rngGen.g); }
inline float rand_pm1() { return rngGen.pm1(rngGen.g); }  // ±1
inline float rand_01() { return rngGen.z1(rngGen.g); }    // 0-1
inline uint32_t rand_u32() { return rngGen.u32(rngGen.g); }

// From: src/common/SurgePatch.h (lines 1157-1227)
class SurgePatch
{
public:
    // Scene data (2 scenes)
    SurgeSceneStorage scene[n_scenes], morphscene;

    // Effects (16 slots)
    FxStorage fx[n_fx_slots];

    // Global parameters
    Parameter scene_active, scenemode, splitpoint;
    Parameter volume, polylimit, fx_bypass, fx_disable;
    Parameter character;

    // Modulation data
    StepSequencerStorage stepsequences[n_scenes][n_lfos];
    MSEGStorage msegs[n_scenes][n_lfos];
    FormulaModulatorStorage formulamods[n_scenes][n_lfos];

    // Metadata
    std::string name, category, author, license, comment;
    std::vector<Tag> tags;

    // Modulation routing
    std::vector<ModulationRouting> modulation_global;

    // Reference to storage
    SurgeStorage *storage;
};

<?xml version="1.0" encoding="UTF-8"?>
<patch revision="28">
    <meta>
        <name>My Awesome Sound</name>
        <category>Bass</category>
        <author>John Doe</author>
    </meta>

    <parameters>
        <p id="0" value="0.75"/>  <!-- Send FX 1 Return -->
        <p id="1" value="0.50"/>  <!-- Send FX 2 Return -->
        <!-- ... 764 more parameters ... -->
    </parameters>

    <modulation>
        <routing source="lfo1" depth="0.5" destination="filter1_cutoff"/>
        <routing source="modwheel" depth="1.0" destination="lfo1_rate"/>
        <!-- ... more routing ... -->
    </modulation>

    <scene id="0">
        <osc id="0" type="wavetable" wavetable="Sawtooth"/>
        <!-- ... oscillator data ... -->
    </scene>
</patch>

// From: src/common/SurgeStorage.h (lines 88-147)
const int ff_revision = 28;  // Current revision

// XML file format revision history:
// 0 → 1   New filter/amp EG attack shapes
// 1 → 2   New LFO EG stages
// 2 → 3   Filter subtypes added
// 3 → 4   Comb+ and Comb- combined
// 4 → 5   Stereo filter separate pan controls
// 5 → 6   Filter resonance response changed (1.2.0 release)
// 6 → 7   Custom controller state in DAW recall
// 7 → 8   Larger resonance range, Pan 2 → Width
// 8 → 9   Macros extended to 8, macro naming
// 9 → 10  Character parameter added
// 10 → 11 DAW extra state (1.6.2)
// 11 → 12 New Distortion parameters (1.6.3)
// 12 → 13 Slider deactivation, Sine filters, feedback extension (1.7.0)
// 13 → 14 Phaser parameters, Vocoder input config (1.8.0 nightlies)
// 14 → 15 Filter type remapping (1.8.0 release)
// 15 → 16 Oscillator retrigger consistency (1.9.0)
// 16 → 17 Window oscillator, new waveshapers, 2 extra FX slots (XT 1.0)
// 17 → 18 Delay feedback clipping, Phaser tone (XT 1.1 nightlies)
// 18 → 19 String deform, negative delay (XT 1.1 nightlies)
// 19 → 20 Voice envelope mode (XT 1.1)
// 20 → 21 Combulator absolute mode, MTS (XT 1.2)
// 21 → 22 Ring mod modes, Bonsai FX, MIDI mapping (XT 1.3)
// 22 → 23 Tempo parameter, Ensemble output filter (XT 1.3.2)
// 23 → 24 FM2 extend mode fix (XT 1.3.3)
// 24 → 25 Wavetable script state (XT 1.3.4)
// 25 → 26 WT Deform, LFO amplitude extend, Lua editor state (XT 1.4.*)
// 26 → 27 OBXD and BP12 legacy fix, extendable waveshaper (XT 1.4.*)
// 27 → 28 Corrected TX shapes (XT 1.4.*)

// Simplified migration example
if (patch_revision < 8)
{
    // Old patches had "Pan 2", rename to "Width"
    scene[s].width.set_name("Width");
}

if (patch_revision < 15)
{
    // Remap old filter type IDs to new organization
    int old_type = filter.type.val.i;
    filter.type.val.i = legacyFilterTypeRemap[old_type];
}

// From: src/common/SurgePatch.h (lines 1226-1234)
std::string name;        // "Aggressive Bass"
std::string category;    // "Bass / Mono"
std::string author;      // "Claes Johanson"
std::string license;     // "CC-BY-SA"
std::string comment;     // "Great for techno!"

struct Tag
{
    std::string tag;     // "dark", "aggressive", etc.
};
std::vector<Tag> tags;

// From: src/common/SurgePatch.cpp
void SurgePatch::load_xml(const void *data, int size, bool preset)
{
    // 1. Parse XML
    TiXmlDocument doc;
    doc.Parse((const char *)data);

    // 2. Read revision number
    int rev = 0;
    root->Attribute("revision", &rev);
    streamingRevision = rev;

    // 3. Read metadata
    TiXmlElement *meta = root->FirstChildElement("meta");
    if (meta)
    {
        name = meta->Attribute("name");
        category = meta->Attribute("category");
        author = meta->Attribute("author");
    }

    // 4. Load parameters
    TiXmlElement *params = root->FirstChildElement("parameters");
    for (TiXmlElement *p = params->FirstChildElement("p");
         p; p = p->NextSiblingElement("p"))
    {
        int id = 0;
        p->Attribute("id", &id);

        Parameter *param = param_ptr[id];

        if (param->valtype == vt_float)
        {
            double v = 0;
            p->Attribute("value", &v);
            param->val.f = v;
        }
        // ... int and bool cases ...
    }

    // 5. Load modulation routing
    TiXmlElement *modulation = root->FirstChildElement("modulation");
    // ... parse routing ...

    // 6. Load scene-specific data (oscillators, LFOs, MSEGs)
    // ...

    // 7. Run migration if needed
    if (streamingRevision < ff_revision)
    {
        // Apply version-specific migrations
    }

    // 8. Rebuild derived state
    update_controls(true);  // Recalculate dependent values
}

unsigned int SurgePatch::save_xml(void **data)
{
    TiXmlDocument doc;

    // Root element with current revision
    TiXmlElement root("patch");
    root.SetAttribute("revision", ff_revision);

    // Metadata
    TiXmlElement meta("meta");
    meta.SetAttribute("name", name);
    meta.SetAttribute("category", category);
    meta.SetAttribute("author", author);
    root.InsertEndChild(meta);

    // Parameters
    TiXmlElement params("parameters");
    for (int i = 0; i < param_ptr.size(); i++)
    {
        TiXmlElement p("p");
        p.SetAttribute("id", i);

        if (param_ptr[i]->valtype == vt_float)
            p.SetDoubleAttribute("value", param_ptr[i]->val.f);
        // ... other types ...

        params.InsertEndChild(p);
    }
    root.InsertEndChild(params);

    // Modulation
    // Scene data
    // ...

    doc.InsertEndChild(root);

    // Convert to string
    TiXmlPrinter printer;
    doc.Accept(&printer);

    *data = strdup(printer.CStr());
    return printer.Size();
}

// From: src/common/SurgeStorage.h (lines 897-1145)
struct DAWExtraStateStorage
{
    bool isPopulated = false;

    struct EditorState
    {
        int instanceZoomFactor = -1;          // UI zoom level
        int current_scene = 0;                // Which scene tab is open
        int current_fx = 0;                   // Which FX is selected
        int current_osc[n_scenes] = {0};      // Which osc is selected
        bool isMSEGOpen = false;              // Is MSEG editor open?

        // Formula editor state
        struct FormulaEditState { /* ... */ } formulaEditState[n_scenes][n_lfos];

        // Wavetable script editor state
        struct WavetableScriptEditState { /* ... */ } wavetableScriptEditState[n_scenes][n_oscs];
    } editor;

    // MPE settings (session-specific, not patch-specific)
    bool mpeEnabled = false;
    int mpePitchBendRange = -1;

    // MIDI controller mappings (learned in the session)
    std::map<int, int> midictrl_map;

    // Tuning (can be session or patch)
    bool hasScale = false;
    std::string scaleContents = "";
    bool hasMapping = false;
    std::string mappingContents = "";
};

// From: src/common/SurgeSynthesizer.cpp
void SurgeSynthesizer::process()
{
    // At 48kHz, this is called ~1500 times per second
    // Each call generates 32 samples (~0.67ms of audio)

    if (halt_engine)
    {
        mech::clear_block<BLOCK_SIZE>(output[0]);
        mech::clear_block<BLOCK_SIZE>(output[1]);
        return;  // Silent output during patch loading
    }

    // Process inputs (upsample to 2x for oscillators)
    if (process_input)
    {
        halfbandIN.process_block_U2(input[0], input[1],
                                     storage.audio_in[0], storage.audio_in[1],
                                     BLOCK_SIZE_OS);
    }

    // Clear scene outputs
    mech::clear_block<BLOCK_SIZE_OS>(sceneout[0][0]);
    mech::clear_block<BLOCK_SIZE_OS>(sceneout[0][1]);
    mech::clear_block<BLOCK_SIZE_OS>(sceneout[1][0]);
    mech::clear_block<BLOCK_SIZE_OS>(sceneout[1][1]);

    // Process control rate updates (once per block)
    storage.modRoutingMutex.lock();
    processControl();

    // Process all active voices
    for (int s = 0; s < n_scenes; s++)
    {
        for (auto v : voices[s])
        {
            bool resume = v->process_block(...);
            if (!resume)
                freeVoice(v);  // Voice finished
        }
    }

    // Apply effects and mix to output
    // ... (detailed later in this chapter)

    storage.modRoutingMutex.unlock();
}

// From: src/common/globals.h
const int BLOCK_SIZE = 32;              // Samples per block
const int OSC_OVERSAMPLING = 2;         // 2x oversampling for oscillators
const int BLOCK_SIZE_OS = 64;           // Oversampled block size
const int BLOCK_SIZE_QUAD = 8;          // SIMD quads (4 samples each)

// From: src/common/SurgeSynthesizer.cpp
void SurgeSynthesizer::processControl()
{
    // Load any enqueued patch
    processEnqueuedPatchIfNeeded();

    // Perform any queued wavetable loads
    storage.perform_queued_wtloads();

    // Determine which scenes are active
    int sm = storage.getPatch().scenemode.val.i;
    bool playA = (sm == sm_split) || (sm == sm_dual) ||
                 (sm == sm_chsplit) ||
                 (storage.getPatch().scene_active.val.i == 0);
    bool playB = (sm == sm_split) || (sm == sm_dual) ||
                 (sm == sm_chsplit) ||
                 (storage.getPatch().scene_active.val.i == 1);

    // Update tempo and song position
    storage.songpos = time_data.ppqPos;
    storage.temposyncratio = time_data.tempo / 120.f;
    storage.temposyncratio_inv = 1.f / storage.temposyncratio;

    // Interpolate MIDI controllers smoothly
    for (int i = 0; i < num_controlinterpolators; i++)
    {
        if (mControlInterpolatorUsed[i])
        {
            ControllerModulationSource *mc = &mControlInterpolator[i];
            bool cont = mc->process_block_until_close(0.001f);
            int id = mc->id;
            storage.getPatch().param_ptr[id]->set_value_f01(mc->get_output(0));
            if (!cont)
                mControlInterpolatorUsed[i] = false;
        }
    }

    // Prepare modulation sources
    prepareModsourceDoProcess((playA ? 1 : 0) | (playB ? 2 : 0));

    // Process all modulators for active scenes
    for (int s = 0; s < n_scenes; s++)
    {
        if ((s == 0 && playA) || (s == 1 && playB))
        {
            // Voice LFOs are per-voice, but scene LFOs run here
            for (int i = 0; i < n_lfos_scene; i++)
            {
                storage.getPatch().scene[s].modsources[ms_slfo1 + i]
                    ->process_block();
            }
        }
    }

    // Apply global modulations
    int n = storage.getPatch().modulation_global.size();
    for (int i = 0; i < n; i++)
    {
        int src_id = storage.getPatch().modulation_global[i].source_id;
        int src_index = storage.getPatch().modulation_global[i].source_index;
        int dst_id = storage.getPatch().modulation_global[i].destination_id;
        float depth = storage.getPatch().modulation_global[i].depth;
        int source_scene = storage.getPatch().modulation_global[i].source_scene;

        storage.getPatch().globaldata[dst_id].f +=
            depth * storage.getPatch().scene[source_scene]
                        .modsources[src_id]->get_output(src_index) *
            (1 - storage.getPatch().modulation_global[i].muted);
    }

    // Load effects if needed
    if (load_fx_needed)
        loadFx(false, false);
}

// When a MIDI CC is received:
ControllerModulationSource *mc = AddControlInterpolator(cc_num, alreadyExists);
mc->set_target(new_value);

// Then in processControl(), it smooths toward the target:
mc->process_block_until_close(0.001f);  // Approach within 0.1%

// From: src/common/SurgeSynthesizer.h
std::array<std::array<SurgeVoice, MAX_VOICES>, 2> voices_array;
unsigned int voices_usedby[2][MAX_VOICES];  // 0=unused, 1=scene A, 2=scene B

std::list<SurgeVoice *> voices[n_scenes];  // Active voices per scene

// From: src/common/dsp/SurgeVoiceState.h
struct SurgeVoiceState
{
    bool gate;              // True during attack/sustain, false during release
    bool keep_playing;      // Force voice to continue (used by some modes)
    bool uberrelease;       // Ultra-fast release for voice stealing

    int key, velocity, channel, scene_id;
    float pitch, fvel, detune;

    // State for polyphonic/MPE control
    MidiKeyState *keyState;
    MidiChannelState *mainChannelState;
    MidiChannelState *voiceChannelState;

    // Portamento state
    float portasrc_key, portaphase;
    bool porta_doretrigger;

    // MPE support
    ControllerModulationSource mpePitchBend;
    float mpePitchBendRange;
    bool mpeEnabled;

    int64_t voiceOrderAtCreate;  // For voice stealing algorithms
};

// From: src/common/SurgeSynthesizer.cpp
SurgeVoice *SurgeSynthesizer::getUnusedVoice(int scene)
{
    for (int i = 0; i < MAX_VOICES; i++)
    {
        if (!voices_usedby[scene][i])
        {
            voices_usedby[scene][i] = scene + 1;  // Mark as used
            return &voices_array[scene][i];
        }
    }
    return nullptr;  // All voices in use!
}

// From: src/common/SurgeSynthesizer.cpp
void SurgeSynthesizer::softkillVoice(int s)
{
    list<SurgeVoice *>::iterator iter, max_playing, max_released;
    int max_age = -1, max_age_release = -1;

    iter = voices[s].begin();

    while (iter != voices[s].end())
    {
        SurgeVoice *v = *iter;

        // Prefer stealing released voices
        if (v->state.gate)  // Still playing (attack/sustain)
        {
            if (v->age > max_age)
            {
                max_age = v->age;
                max_playing = iter;
            }
        }
        else if (!v->state.uberrelease)  // In release
        {
            if (v->age_release > max_age_release)
            {
                max_age_release = v->age_release;
                max_released = iter;
            }
        }
        iter++;
    }

    // Steal the oldest released voice, or oldest playing voice
    if (max_age_release >= 0)
        (*max_released)->uber_release();  // Force immediate fadeout
    else if (max_age >= 0)
        (*max_playing)->uber_release();
}

// From: src/common/SurgeSynthesizer.cpp
void SurgeSynthesizer::enforcePolyphonyLimit(int s, int margin)
{
    int paddedPoly = std::min(
        (storage.getPatch().polylimit.val.i + margin),
        MAX_VOICES - 1
    );

    if (voices[s].size() > paddedPoly)
    {
        int excess_voices = max(0, (int)voices[s].size() - paddedPoly);
        auto iter = voices[s].begin();

        while (iter != voices[s].end())
        {
            if (excess_voices < 1)
                break;

            SurgeVoice *v = *iter;
            if (v->state.uberrelease)  // Already being killed
            {
                excess_voices--;
                freeVoice(v);
                iter = voices[s].erase(iter);
            }
            else
                iter++;
        }
    }
}

// From: src/common/SurgeSynthesizer.cpp (simplified)
void SurgeSynthesizer::playVoice(int scene, char channel, char key,
                                  char velocity, char detune,
                                  int32_t host_noteid, ...)
{
    // Trigger scene LFOs if this is the first note
    if (getNonReleasedVoices(scene) == 0)
    {
        for (int l = 0; l < n_lfos_scene; l++)
        {
            storage.getPatch().scene[scene].modsources[ms_slfo1 + l]->attack();
        }
    }

    // Trigger random/alternate modulators
    for (int i = ms_random_bipolar; i <= ms_alternate_unipolar; ++i)
    {
        storage.getPatch().scene[scene].modsources[i]->attack();
    }

    // Voice stealing if needed
    int excessVoices = max(0, (int)getNonUltrareleaseVoices(scene) -
                           storage.getPatch().polylimit.val.i + 1);
    for (int i = 0; i < excessVoices; i++)
    {
        softkillVoice(scene);
    }
    enforcePolyphonyLimit(scene, 3);

    // Get an unused voice
    SurgeVoice *nvoice = getUnusedVoice(scene);

    if (nvoice)
    {
        // Reconstruct the voice (calls destructor then constructor)
        nvoice->~SurgeVoice();
        voices[scene].push_back(nvoice);

        new (nvoice) SurgeVoice(
            &storage,
            &storage.getPatch().scene[scene],
            storage.getPatch().scenedata[scene],
            storage.getPatch().scenedataOrig[scene],
            key, velocity, channel, scene, detune,
            &channelState[channel].keyState[key],
            &channelState[mpeMainChannel],
            &channelState[channel],
            mpeEnabled,
            voiceCounter++,  // Unique voice ID
            host_noteid,
            host_originating_key,
            host_originating_channel,
            0.f, 0.f  // AEG/FEG start levels
        );
    }
}

// From: src/common/SurgeSynthesizer.cpp
void SurgeSynthesizer::freeVoice(SurgeVoice *v)
{
    // Notify host that note has ended (for MPE, etc.)
    if (v->host_note_id >= 0)
    {
        bool used_away = false;
        // Check if another voice still uses this note ID (unison, etc.)
        for (int s = 0; s < n_scenes; ++s)
        {
            for (auto vo : voices[s])
            {
                if (vo != v && vo->host_note_id == v->host_note_id)
                    used_away = true;
            }
        }
        if (!used_away)
            notifyEndedNote(v->host_note_id, v->originating_host_key,
                           v->originating_host_channel);
    }

    // Find the voice in the array
    int foundScene{-1}, foundIndex{-1};
    for (int i = 0; i < MAX_VOICES; i++)
    {
        if (voices_usedby[0][i] && (v == &voices_array[0][i]))
        {
            foundScene = 0;
            foundIndex = i;
            voices_usedby[0][i] = 0;  // Mark as free
        }
        if (voices_usedby[1][i] && (v == &voices_array[1][i]))
        {
            foundScene = 1;
            foundIndex = i;
            voices_usedby[1][i] = 0;
        }
    }

    // Free any allocated resources
    v->freeAllocatedElements();

    // Call destructor and reconstruct
    v->~SurgeVoice();
    v = new (&voices_array[foundScene][foundIndex]) SurgeVoice();
}

// From: src/common/dsp/SurgeStorage.h
enum scene_mode
{
    sm_single = 0,   // Only Scene A is active
    sm_split,        // Key split: notes below splitpoint → A, above → B
    sm_dual,         // Both scenes play all notes (layer)
    sm_chsplit,      // MIDI channel split: channels 1-8 → A, 9-16 → B

    n_scene_modes,
};

// From: src/common/SurgeSynthesizer.cpp
for (int s = 0; s < n_scenes; s++)
{
    // Process all voices in this scene
    iter = voices[s].begin();
    while (iter != voices[s].end())
    {
        SurgeVoice *v = *iter;

        // Process one block (64 samples at 2x oversampling)
        bool resume = v->process_block(FBQ[s][FBentry[s] >> 2],
                                       FBentry[s] & 3);
        FBentry[s]++;

        if (!resume)  // Voice finished
        {
            freeVoice(v);
            iter = voices[s].erase(iter);
        }
        else
            iter++;
    }

    // Unlock modulation routing for QuadFilterChain processing
    storage.modRoutingMutex.unlock();

    // Get filter function pointers for this scene
    using sst::filters::FilterType, sst::filters::FilterSubType;
    fbq_global g;

    g.FU1ptr = sst::filters::GetQFPtrFilterUnit(
        static_cast<FilterType>(storage.getPatch().scene[s].filterunit[0].type.val.i),
        static_cast<FilterSubType>(storage.getPatch().scene[s].filterunit[0].subtype.val.i)
    );

    g.FU2ptr = sst::filters::GetQFPtrFilterUnit(
        static_cast<FilterType>(storage.getPatch().scene[s].filterunit[1].type.val.i),
        static_cast<FilterSubType>(storage.getPatch().scene[s].filterunit[1].subtype.val.i)
    );

    g.WSptr = sst::waveshapers::GetQuadWaveshaper(
        static_cast<sst::waveshapers::WaveshaperType>(
            storage.getPatch().scene[s].wsunit.type.val.i)
    );

    // Get the quad filter processing function
    FBQFPtr ProcessQuadFB = GetFBQPointer(
        storage.getPatch().scene[s].filterblock_configuration.val.i,
        g.FU1ptr != 0, g.WSptr != 0, g.FU2ptr != 0
    );

    // Process filters for all voices (4 at a time in SIMD)
    for (int e = 0; e < FBentry[s]; e += 4)
    {
        ProcessQuadFB(FBQ[s][e >> 2], g, sceneout[s][0], sceneout[s][1]);
    }

    // Save filter state back to voices
    iter = voices[s].begin();
    while (iter != voices[s].end())
    {
        SurgeVoice *v = *iter;
        v->GetQFB();  // Save filter registers
        iter++;
    }

    storage.modRoutingMutex.lock();
}

// 1. Hard clipping (if enabled)
if (play_scene[s])
{
    switch (storage.sceneHardclipMode[s])
    {
    case SurgeStorage::HARDCLIP_TO_18DBFS:
        sdsp::hardclip_block8<BLOCK_SIZE_OS>(sceneout[s][0]);
        sdsp::hardclip_block8<BLOCK_SIZE_OS>(sceneout[s][1]);
        break;
    case SurgeStorage::HARDCLIP_TO_0DBFS:
        sdsp::hardclip_block<BLOCK_SIZE_OS>(sceneout[s][0]);
        sdsp::hardclip_block<BLOCK_SIZE_OS>(sceneout[s][1]);
        break;
    }

    // 2. Downsample from 2x to 1x
    halfbandA.process_block_D2(sceneout[s][0], sceneout[s][1], BLOCK_SIZE_OS);
}

// 3. Scene lowcut filter (high-pass)
if (!storage.getPatch().scene[s].lowcut.deactivated)
{
    auto freq = storage.getPatch().scenedata[s][
        storage.getPatch().scene[s].lowcut.param_id_in_scene].f;
    auto slope = storage.getPatch().scene[s].lowcut.deform_type;

    for (int i = 0; i <= slope; i++)
    {
        hpA[i].coeff_HP(hpA[i].calc_omega(freq / 12.0), 0.4);
        hpA[i].process_block(sceneout[s][0], sceneout[s][1]);
    }
}

// From: src/common/dsp/SurgeStorage.h
enum fx_type
{
    fxslot_ains1 = 0,   // Scene A Insert 1
    fxslot_ains2,       // Scene A Insert 2
    fxslot_ains3,       // Scene A Insert 3
    fxslot_ains4,       // Scene A Insert 4

    fxslot_bins1,       // Scene B Insert 1
    fxslot_bins2,       // Scene B Insert 2
    fxslot_bins3,       // Scene B Insert 3
    fxslot_bins4,       // Scene B Insert 4

    fxslot_send1,       // Send FX 1
    fxslot_send2,       // Send FX 2
    fxslot_send3,       // Send FX 3
    fxslot_send4,       // Send FX 4

    fxslot_global1,     // Global FX 1 (Master)
    fxslot_global2,     // Global FX 2
    fxslot_global3,     // Global FX 3
    fxslot_global4,     // Global FX 4

    n_fx_slots = 16
};

// From: src/common/SurgeSynthesizer.cpp
// Apply Scene A insert effects
for (auto v : {fxslot_ains1, fxslot_ains2, fxslot_ains3, fxslot_ains4})
{
    if (fx[v] && !(storage.getPatch().fx_disable.val.i & (1 << v)))
    {
        sc_state[0] = fx[v]->process_ringout(
            sceneout[0][0],  // Left input/output
            sceneout[0][1],  // Right input/output
            sc_state[0]      // Is scene active?
        );
    }
}

// Apply Scene B insert effects
for (auto v : {fxslot_bins1, fxslot_bins2, fxslot_bins3, fxslot_bins4})
{
    if (fx[v] && !(storage.getPatch().fx_disable.val.i & (1 << v)))
    {
        sc_state[1] = fx[v]->process_ringout(
            sceneout[1][0], sceneout[1][1], sc_state[1]
        );
    }
}

// Sum both scenes to main output
mech::copy_from_to<BLOCK_SIZE>(sceneout[0][0], output[0]);
mech::copy_from_to<BLOCK_SIZE>(sceneout[0][1], output[1]);
mech::accumulate_from_to<BLOCK_SIZE>(sceneout[1][0], output[0]);
mech::accumulate_from_to<BLOCK_SIZE>(sceneout[1][1], output[1]);

// For each send effect (typically reverb, delay, chorus, etc.)
for (auto si : sendToIndex)  // Send 1-4
{
    auto slot = si[0];  // Effect slot
    auto idx = si[1];   // Send index

    if (fx[slot] && !(storage.getPatch().fx_disable.val.i & (1 << slot)))
    {
        // Mix scene A with send level into send buffer
        send[idx][0].MAC_2_blocks_to(
            sceneout[0][0], sceneout[0][1],  // Scene A L/R
            fxsendout[idx][0], fxsendout[idx][1],  // Send buffer L/R
            BLOCK_SIZE_QUAD
        );

        // Mix scene B with send level into send buffer
        send[idx][1].MAC_2_blocks_to(
            sceneout[1][0], sceneout[1][1],  // Scene B L/R
            fxsendout[idx][0], fxsendout[idx][1],  // Send buffer L/R
            BLOCK_SIZE_QUAD
        );

        // Process the send buffer through the effect
        sendused[idx] = fx[slot]->process_ringout(
            fxsendout[idx][0], fxsendout[idx][1],
            sc_state[0] || sc_state[1]
        );

        // Mix effect output back to main output with return level
        FX[idx].MAC_2_blocks_to(
            fxsendout[idx][0], fxsendout[idx][1],  // Effect output
            output[0], output[1],  // Main output
            BLOCK_SIZE_QUAD
        );
    }
}

// Apply global effects (master chain)
bool glob = sc_state[0] || sc_state[1];
for (int i = 0; i < n_send_slots; ++i)
    glob = glob || sendused[i];

for (auto v : {fxslot_global1, fxslot_global2, fxslot_global3, fxslot_global4})
{
    if (fx[v] && !(storage.getPatch().fx_disable.val.i & (1 << v)))
    {
        glob = fx[v]->process_ringout(
            output[0], output[1],  // Process main output in-place
            glob
        );
    }
}