Add yuruyurau_5 (#3) equation and merge feature

- Add 5th equation preset (#3): yuruyurau_5 with nested double-sin,
alternating m parameter, and 7 mutable trig sites
- Add merge zone UI below base equation selector: drag any of the 5
equation chips to layer a second equation onto all variant canvases
- Merged equations both rendered per frame; evolution mutates combined
parameter set (_2_ prefix for secondary equation params)
- Refactor rendering into shared drawEquationPoints() helper,
eliminating ~400 lines of duplicated if-else render chains
- Backend: merged_secondary_set field, set_merged_secondary API endpoint

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

genetic_backend.py

@@ -32,7 +32,7 @@ class EquationGene:
         """
         keys = trig_keys if trig_keys is not None else [k for k in self.params.keys() if k.startswith('trig')]
         # Get all constant keys (numeric parameters, not trig function names)
-        constant_keys = [k for k in self.params.keys() if not k.startswith('trig') and isinstance(self.params.get(k), (int, float))]
+        constant_keys = [k for k in self.params.keys() if not k.startswith('trig') and not k.startswith('_2_trig') and isinstance(self.params.get(k), (int, float))]
 
         self.mutation_log = []
         
@@ -119,6 +119,7 @@ class GeneticEquationEvolver:
         self.systematic_phase_generations = 3  # First 3 generations are systematic
         self.approved_trig_sites: set = set()  # Track which trig sites user has approved (selected)
         self.current_base_set = 'always_finding_yourself'  # Current base equation set name
+        self.merged_secondary_set = None  # Optional secondary equation for merge mode
         self.jump_size_multiplier = 1.0  # Multiplier for mutation delta (controls jump size)
         self.trig_mutation_prob_base = 1.0  # Base value for auto-decay (starts at 1.0, can be set by user)
         self.trig_mutation_prob_base_generation = 0  # Generation when base was last set (for decay calculation)
@@ -216,6 +217,37 @@ class GeneticEquationEvolver:
                 'trig_q_sin2': 'sin',     # sin(k*d/3) in q
                 'trig_px_sin': 'sin',     # sin(c) in px
                 'trig_py_cos': 'cos'      # cos(c-i%2+i%5*3+7) in py
+            },
+            'yuruyurau_5': {
+                # Equation: a=(m,d=mag(k=9*cos(i/61),e=i/692-13)**2/99+1)=>point(
+                #   (q=79-e/2*sin(k/d*4)+k/d*(8+5*sin(sin(d*d+e/9-t+m))))*cos(c=d/2+cos(t-d*2+m)/9-t/16+m)+200,
+                #   (q+40)*sin(c)+200)
+                # t=0,draw=$=>{t||createCanvas(w=400,w);background(9).stroke(w,96);for(t+=PI/45,i=2e4;i--;)a(i%2*9)}
+                # k = k_mult * cos(i / k_cos_div)
+                'k_mult': 9, 'k_cos_div': 61,
+                # e = i / e_div - e_sub
+                'e_div': 692, 'e_sub': 13,
+                # d = mag(k,e)**d_pow / d_div + d_add
+                'd_pow': 2, 'd_div': 99, 'd_add': 1,
+                # m = (i%2) * m_mult  (alternates 0 or m_mult per point)
+                'm_mult': 9,
+                # q = q_base - e/q_e_div*sin1(k/d*q_sin1_mult) + k/d*(q_k_mult + q_sin2_mult*sin2(sin3(d*d+e/q_sin_e_div-t+m)))
+                'q_base': 79, 'q_e_div': 2, 'q_sin1_mult': 4,
+                'q_k_mult': 8, 'q_sin2_mult': 5, 'q_sin_e_div': 9,
+                # c = d/c_d_div + cosc(t - d*c_d2_mult + m)/c_cos_div - t/c_t_div + m
+                'c_d_div': 2, 'c_d2_mult': 2, 'c_cos_div': 9, 'c_t_div': 16,
+                # px = q * cosp(c) + px_add
+                'px_add': 200,
+                # py = (q + py_q_add) * sinp(c) + py_add
+                'py_q_add': 40, 'py_add': 200,
+                # Trig sites:
+                'trig_k_cos': 'cos',     # cos(i/k_cos_div) in k
+                'trig_q_sin1': 'sin',    # outer sin in e term: -e/q_e_div*sin(k/d*q_sin1_mult)
+                'trig_q_sin2': 'sin',    # outer sin in nested double-sin: q_sin2_mult*sin(sin(...))
+                'trig_q_sin3': 'sin',    # inner sin in nested double-sin: sin(d*d+e/q_sin_e_div-t+m)
+                'trig_c_cos': 'cos',     # cos(t-d*c_d2_mult+m) in c
+                'trig_px_cos': 'cos',    # cos(c) in px
+                'trig_py_sin': 'sin',    # sin(c) in py
             }
         }
         
@@ -223,13 +255,20 @@ class GeneticEquationEvolver:
     
     @property
     def base_params(self):
-        """Get current base params based on selected equation set"""
-        return self.base_equation_sets.get(self.current_base_set, self.base_equation_sets['always_finding_yourself'])
-    
+        """Get current base params based on selected equation set (and merged secondary if active)"""
+        primary = self.base_equation_sets.get(self.current_base_set, self.base_equation_sets['always_finding_yourself'])
+        if self.merged_secondary_set and self.merged_secondary_set in self.base_equation_sets:
+            secondary = self.base_equation_sets[self.merged_secondary_set]
+            combined = dict(primary)
+            for k, v in secondary.items():
+                combined['_2_' + k] = v
+            return combined
+        return primary
+
     @property
     def trig_keys(self):
-        """Get trig keys for current base equation set"""
-        return [k for k in self.base_params.keys() if k.startswith('trig')]
+        """Get trig keys for current base equation set (including merged secondary)"""
+        return [k for k in self.base_params.keys() if k.startswith('trig') or k.startswith('_2_trig')]
     
     def get_trig_mutation_probability(self) -> float:
         """Calculate probability of trig mutations vs constant mutations.
@@ -744,6 +783,7 @@ class GeneticEquationEvolver:
             'trig_mutation_prob_base_generation': self.trig_mutation_prob_base_generation,
             'jump_size_multiplier': self.jump_size_multiplier,
         }
+        data['merged_secondary_set'] = self.merged_secondary_set
         if not lite:
             data['base_params'] = self.base_params
             data['parameter_preferences'] = self.parameter_preferences
@@ -753,6 +793,7 @@ class GeneticEquationEvolver:
         """Change the base equation set and reset population"""
         if set_name in self.base_equation_sets:
             self.current_base_set = set_name
+            self.merged_secondary_set = None  # Clear merge when changing base set
             # Reset all state when changing equation sets
             self.generation = 0
             self.trig_mutation_prob_base = 1.0
@@ -767,6 +808,23 @@ class GeneticEquationEvolver:
             return True
         return False
 
+    def set_merged_secondary(self, set_name: Optional[str]):
+        """Set (or clear) the secondary equation for merge mode and reinitialize population"""
+        if set_name is None or set_name in self.base_equation_sets:
+            self.merged_secondary_set = set_name
+            # Reset evolution state for the new combined genome
+            self.generation = 0
+            self.trig_mutation_prob_base = 1.0
+            self.trig_mutation_prob_base_generation = 0
+            self.approved_trig_sites = set()
+            self.parameter_preferences = {}
+            self.mutation_penalties = {}
+            self.liked_variants = []
+            self.select_none_history = []
+            self.initialize_population()
+            return True
+        return False
+
 # Global evolver instance
 evolver = GeneticEquationEvolver()
 
@@ -852,6 +910,8 @@ def reset_all():
         evolver.trig_mutation_prob_base_generation = 0  # Reset generation offset
         evolver.jump_size_multiplier = 1.0  # Reset jump size to default
 
+        evolver.merged_secondary_set = None  # Clear merge on full reset
+
         # Reinitialize population from scratch
         evolver.initialize_population()
 
@@ -880,5 +940,17 @@ def set_trig_mutation_prob():
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+@app.route('/api/set_merged_secondary', methods=['POST'])
+def set_merged_secondary():
+    """Set or clear the secondary equation for merge mode."""
+    try:
+        data = request.get_json()
+        set_name = data.get('set_name')  # None/null to clear merge
+        if evolver.set_merged_secondary(set_name):
+            return jsonify({'success': True, 'merged_secondary_set': evolver.merged_secondary_set})
+        return jsonify({'success': False, 'error': 'Invalid equation set name'}), 400
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
 if __name__ == '__main__':
     app.run(debug=True, host='0.0.0.0', port=5000)

templates/genetic_evolver.html

@@ -44,6 +44,14 @@
     .btn{background:#000;color:#fff;border:1px solid #666;padding:8px 16px;margin:0;cursor:pointer;font-family:monospace;font-size:11px;text-transform:uppercase;letter-spacing:0.5px}
     .btn:hover{background:#333;border-color:#999}
     .btn:disabled{background:#111;color:#666;border-color:#444;cursor:not-allowed}
+    .eq-chip{font-family:monospace;font-size:8px;color:#bbb;border:1px solid #444;padding:2px 6px;cursor:grab;background:#111;user-select:none;white-space:nowrap}
+    .eq-chip:hover{border-color:#aaa;color:#fff}
+    .eq-chip:active{cursor:grabbing}
+    .eq-chip-in-zone{display:inline-flex;align-items:center;gap:4px;border:1px solid #fff;padding:2px 6px;font-size:8px;font-family:monospace;color:#fff;background:#222}
+    .eq-chip-remove{cursor:pointer;color:#999;font-size:10px;line-height:1;padding:0 1px}
+    .eq-chip-remove:hover{color:#fff}
+    #merge-drop-zone{min-height:36px;border:1px dashed #444;padding:5px;background:#000;font-size:8px;color:#555;display:flex;align-items:center;gap:6px;flex-wrap:wrap;transition:border-color 0.2s,background 0.2s}
+    #merge-drop-zone.drag-over{border-color:#fff;background:#111}
   </style>
 </head>
 <body>
@@ -70,9 +78,24 @@
           <!-- <option value="yuruyurau_2">yuruyurau #2</option> -->
           <!-- <option value="yuruyurau_3">yuruyurau #3</option> -->
           <option value="yuruyurau_4">#2</option>
+          <option value="yuruyurau_5">#3</option>
         </select>
       </div>
 
+      <div style="margin-bottom:15px;">
+        <label style="font-size:9px;color:#666;text-transform:lowercase;letter-spacing:1px;display:block;margin-bottom:5px;">merge equations:</label>
+        <div id="equation-chips" style="display:flex;flex-wrap:wrap;gap:4px;margin-bottom:6px;">
+          <div class="eq-chip" draggable="true" data-eq="always_finding_yourself">always_finding</div>
+          <div class="eq-chip" draggable="true" data-eq="a_constant_state_of_bliss">a constant state</div>
+          <div class="eq-chip" draggable="true" data-eq="yuruyurau">#1</div>
+          <div class="eq-chip" draggable="true" data-eq="yuruyurau_4">#2</div>
+          <div class="eq-chip" draggable="true" data-eq="yuruyurau_5">#3</div>
+        </div>
+        <div id="merge-drop-zone">
+          <span id="merge-drop-hint" style="pointer-events:none;">drag to layer a second equation</span>
+        </div>
+      </div>
+
       <div style="margin-bottom:15px;">
         <label style="font-size:9px;color:#666;text-transform:lowercase;letter-spacing:1px;display:block;margin-bottom:5px;">trigonometric mutation probability:</label>
         <div style="display:flex;gap:4px;align-items:center;height:20px;">
@@ -191,6 +214,7 @@
 
   <script>
     let variants=[]; let selectedIds=new Set();
+    let mergedSecondarySet = null; // Secondary equation for merge mode
     let currentParams = {
       k_div: 4, k_sub: 10.5, e_div: 9, e_add: 9, o_div: 9, x_offset: 60,
       y_trig_div: 8, q_mult: 0.7, px_add: 200, py_add: 200, py_q_div: 3,
@@ -200,6 +224,7 @@
     let currentBaseSet = 'always_finding_yourself'; // Current base equation set
     let variantSketches = []; // Track p5 instances for variants to clean them up
     let sketchBaseSet = null;  // Which base set the current sketches were built for
+    let sketchMergedSet = null; // Which merged secondary set the current sketches were built for
     // Shared mutable param objects — p5 sketches hold references so we can update without recreation
     const variantParamSlots = Array.from({length: 16}, () => ({}));
     let currentMutations = []; // Track mutations for highlighting
@@ -223,7 +248,8 @@
       'yuruyurau': 6,                     // for(let i = 0; i < 12000; i += 6)
       'yuruyurau_2': 1,                   // for(let i = 30000; i > 0; i--)
       'yuruyurau_3': 1,                   // for(let i = 20000; i > 0; i--)
-      'yuruyurau_4': 1                   // for(let i = 20000; i > 0; i--)
+      'yuruyurau_4': 1,                  // for(let i = 20000; i > 0; i--)
+      'yuruyurau_5': 1                   // for(let i = 20000; i > 0; i--)
     };
     const LOOP_BOUNDS = {
       'always_finding_yourself': 6400,
@@ -231,7 +257,8 @@
       'yuruyurau': 12000,
       'yuruyurau_2': 10000,
       'yuruyurau_3': 10000,
-      'yuruyurau_4': 1000
+      'yuruyurau_4': 1000,
+      'yuruyurau_5': 20000
     };
 
     // O(1) trig dispatch — avoids per-point if-else chain
@@ -265,6 +292,10 @@
             currentBaseSet = data.current_base_set;
             document.getElementById('base-equation-selector').value = currentBaseSet;
           }
+          if('merged_secondary_set' in data) {
+            mergedSecondarySet = data.merged_secondary_set;
+            updateMergeZoneUI();
+          }
           if(data.trig_mutation_prob !== undefined) {
             trigMutationProb = data.trig_mutation_prob;
             updateMutationProbChart();
@@ -379,6 +410,8 @@
       .then(data=>{
         if(data.success) {
           currentBaseSet = newSet;
+          mergedSecondarySet = null; // Backend clears merge on base set change
+          updateMergeZoneUI();
           loadPopulation();
         } else {
           alert('Error changing base equation set: '+data.error);
@@ -451,6 +484,18 @@
         equation += `&nbsp;&nbsp;px = q*${getTrigSpan('trig_px_sin')}(c) + ${getParamSpan('px_add')}<br>`;
         equation += `&nbsp;&nbsp;py = q*${getTrigSpan('trig_py_cos')}(c-i%${getParamSpan('c_mod2')}+i%${getParamSpan('c_mod1')}*3+${getParamSpan('py_cos_add1')}) + ${getParamSpan('py_add')}<br>`;
         equation += `&nbsp;&nbsp;point(px,py)`;
+      } else if(currentBaseSet === 'yuruyurau_5') {
+        // yuruyurau #3
+        equation += 'for i in range(20000, 0, -1):<br>';
+        equation += `&nbsp;&nbsp;m = (i%2)*${getParamSpan('m_mult')}<br>`;
+        equation += `&nbsp;&nbsp;k = ${getParamSpan('k_mult')}*${getTrigSpan('trig_k_cos')}(i/${getParamSpan('k_cos_div')})<br>`;
+        equation += `&nbsp;&nbsp;e = i/${getParamSpan('e_div')} - ${getParamSpan('e_sub')}<br>`;
+        equation += `&nbsp;&nbsp;d = mag(k,e)^${getParamSpan('d_pow')}/${getParamSpan('d_div')} + ${getParamSpan('d_add')}<br>`;
+        equation += `&nbsp;&nbsp;q = ${getParamSpan('q_base')} - e/${getParamSpan('q_e_div')}·${getTrigSpan('trig_q_sin1')}(k/d·${getParamSpan('q_sin1_mult')}) + k/d·(${getParamSpan('q_k_mult')}+${getParamSpan('q_sin2_mult')}·${getTrigSpan('trig_q_sin2')}(${getTrigSpan('trig_q_sin3')}(d²+e/${getParamSpan('q_sin_e_div')}-t+m)))<br>`;
+        equation += `&nbsp;&nbsp;c = d/${getParamSpan('c_d_div')} + ${getTrigSpan('trig_c_cos')}(t-d·${getParamSpan('c_d2_mult')}+m)/${getParamSpan('c_cos_div')} - t/${getParamSpan('c_t_div')} + m<br>`;
+        equation += `&nbsp;&nbsp;px = q·${getTrigSpan('trig_px_cos')}(c) + ${getParamSpan('px_add')}<br>`;
+        equation += `&nbsp;&nbsp;py = (q+${getParamSpan('py_q_add')})·${getTrigSpan('trig_py_sin')}(c) + ${getParamSpan('py_add')}<br>`;
+        equation += `&nbsp;&nbsp;point(px,py)`;
       } else {
         // Original equations (always_finding_yourself)
         equation += 'for i in range(0, 6400, 3):<br>';
@@ -471,6 +516,167 @@
 
     let basePreviewSketch = null;
 
+    // Extract _2_ prefixed params (secondary merged equation) into a plain param object
+    function extractMergedParams(params) {
+      const result = {};
+      for(const [k, v] of Object.entries(params)) {
+        if(k.startsWith('_2_')) result[k.slice(3)] = v;
+      }
+      return result;
+    }
+
+    // Shared rendering function: draws one equation layer's points onto p
+    function drawEquationPoints(p, params, baseSet, t, centerX, centerY) {
+      const trig = (name, val) => getTrig(name)(val);
+
+      if(baseSet === 'a_constant_state_of_bliss') {
+        const zoomFactor = 0.4;
+        const kDiv = params.k_div || 8, kSub = params.k_sub || 11.5;
+        const eDiv = params.e_div || 8, eSub = params.e_sub || 12.5;
+        const oDiv = params.o_div || 139, dMult = params.d_mult || 10;
+        const pxDiv = params.px_div || 2, pxAdd1 = params.px_add1 || 150;
+        const pyYDiv = params.py_y_div || 9, pyDMult = params.py_d_mult || 15;
+        const pyCosMult = params.py_cos_mult || 2, pyAdd = params.py_add || 220;
+        const strokeBase = params.stroke_base || 99, strokeMult = params.stroke_mult || 99, strokePow = params.stroke_pow || 30;
+        const trigDCos = params.trig_d_cos || 'cos';
+        const trigPxSin1 = params.trig_px_sin1 || 'sin';
+        const trigPxSin2 = params.trig_px_sin2 || 'sin';
+        const trigPyCos = params.trig_py_cos || 'cos';
+        const trigPySin = params.trig_py_sin || 'sin';
+        const trigStrokeSin1 = params.trig_stroke_sin1 || 'sin';
+        const trigStrokeSin2 = params.trig_stroke_sin2 || 'sin';
+        const patternCenterX = pxAdd1 * zoomFactor, patternCenterY = pyAdd * zoomFactor;
+        const step = FRAME_SAMPLING_STEPS[baseSet] || DEFAULT_FRAME_SAMPLING_STEP;
+        const maxI = LOOP_BOUNDS[baseSet] || 6400;
+        for(let i = 0; i < maxI; i += step){
+          let x = i % 200, y = i / 200;
+          let k = x / kDiv - kSub, e = y / eDiv - eSub;
+          let o = Math.hypot(k, e) ** 2 / oDiv;
+          let d = dMult * trig(trigDCos, o);
+          let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
+          let stroke_r = strokeBase + strokeMult / trig(trigStrokeSin1, ksafe) * trig(trigStrokeSin2, t + e) ** strokePow;
+          p.stroke(stroke_r, 66);
+          let px = ((x + trig(trigPxSin1, d) * d * k) / pxDiv + pxAdd1 + o * k * trig(trigPxSin2, t + d * o)) * zoomFactor;
+          let py = (y / pyYDiv - d * pyDMult - trig(trigPyCos, d * pyCosMult) * d + pyAdd + d * trig(trigPySin, d - t)) * zoomFactor;
+          p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
+        }
+      } else if(baseSet === 'yuruyurau') {
+        p.stroke(255, 96);
+        const zoomFactor = 0.3;
+        const kBase = params.k_base || 4, kSinMult = params.k_sin_mult || 3, kCosDiv = params.k_cos_div || 29;
+        const eDiv = params.e_div || 8, eSub = params.e_sub || 13;
+        const qSin1Mult = params.q_sin1_mult || 3, qSin1Mult2 = params.q_sin1_mult2 || 2, qDiv = params.q_div || 0.3;
+        const qSin2Div = params.q_sin2_div || 25, qBase = params.q_base || 9;
+        const qSin3Mult = params.q_sin3_mult || 4, qSin3EMult = params.q_sin3_e_mult || 9;
+        const qSin3DMult = params.q_sin3_d_mult || 3, qSin3TMult = params.q_sin3_t_mult || 2;
+        const pxCosMult = params.px_cos_mult || 30, pxAdd = params.px_add || 200;
+        const pyDMult = params.py_d_mult || 39, pySub = params.py_sub || 220;
+        const trigKSin = params.trig_k_sin || 'sin', trigKCos = params.trig_k_cos || 'cos';
+        const trigQSin1 = params.trig_q_sin1 || 'sin', trigQSin2 = params.trig_q_sin2 || 'sin';
+        const trigQSin3 = params.trig_q_sin3 || 'sin', trigPxCos = params.trig_px_cos || 'cos';
+        const trigPySin = params.trig_py_sin || 'sin';
+        const patternCenterX = pxAdd * zoomFactor, patternCenterY = (pySub / 2) * zoomFactor;
+        const step = FRAME_SAMPLING_STEPS[baseSet] || DEFAULT_FRAME_SAMPLING_STEP;
+        const maxI = LOOP_BOUNDS[baseSet] || 10000;
+        for(let i = 0; i < maxI; i += step){
+          let x = i, y = i / 235;
+          let k = (kBase + trig(trigKSin, y * 2 - t) * kSinMult) * trig(trigKCos, x / kCosDiv);
+          let e = y / eDiv - eSub, d = Math.hypot(k, e);
+          let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
+          let q = qSin1Mult * trig(trigQSin1, k * qSin1Mult2) + qDiv / ksafe + trig(trigQSin2, y / qSin2Div) * k * (qBase + qSin3Mult * trig(trigQSin3, e * qSin3EMult - d * qSin3DMult + t * qSin3TMult));
+          let c = d - t;
+          let px = (q + pxCosMult * trig(trigPxCos, c) + pxAdd) * zoomFactor;
+          let py = (q * trig(trigPySin, c) + d * pyDMult - pySub) * zoomFactor;
+          p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
+        }
+      } else if(baseSet === 'yuruyurau_4') {
+        p.stroke(255, 96);
+        const zoomFactor = 0.3;
+        const kMult = params.k_mult || 5, kCosDiv = params.k_cos_div || 8;
+        const eMult = params.e_mult || 5, eCosDiv = params.e_cos_div || 9;
+        const dDivBase = params.d_div_base || 6, dPow = params.d_pow || 4, dAdd = params.d_add || 4;
+        const qKMult = params.q_k_mult || 3, qEDiv = params.q_e_div || 2;
+        const qSinMult = params.q_sin_mult || 3, qSinKDDiv = params.q_sin_kd_div || 3, qBitwiseMult = params.q_bitwise_mult || 70;
+        const pxSinMult = params.px_sin_mult || 1, pxAdd = params.px_add || 200;
+        const pyCosAdd1 = params.py_cos_add1 || 7, pyAdd = params.py_add || 200;
+        const cTDiv = params.c_t_div || 9, cMod1 = params.c_mod1 || 5, cMod1Mult = params.c_mod1_mult || 5, cMod2 = params.c_mod2 || 2;
+        const trigKCos = params.trig_k_cos || 'cos', trigECos = params.trig_e_cos || 'cos';
+        const trigQSin = params.trig_q_sin || 'sin', trigQSin2 = params.trig_q_sin2 || 'sin';
+        const trigPxSin = params.trig_px_sin || 'sin', trigPyCos = params.trig_py_cos || 'cos';
+        const patternCenterX = pxAdd * zoomFactor, patternCenterY = pyAdd * zoomFactor;
+        const step = FRAME_SAMPLING_STEPS[baseSet] || DEFAULT_FRAME_SAMPLING_STEP;
+        const maxI = LOOP_BOUNDS[baseSet] || 20000;
+        for(let i = maxI; i > 0; i -= step){
+          let y = i / 799;
+          let k = kMult * trig(trigKCos, i / kCosDiv);
+          let e = eMult * trig(trigECos, y / eCosDiv);
+          let d = (Math.hypot(k, e) / (dDivBase + (i % 5))) ** dPow + dAdd;
+          let q = k * (qKMult + e / qEDiv * trig(trigQSin, d * d - t)) - qSinMult * trig(trigQSin2, k * d / qSinKDDiv) - (~(i & 1)) * qBitwiseMult;
+          let c = d - t / cTDiv + (i % cMod1) * cMod1Mult + (i % cMod2);
+          let px = (q * trig(trigPxSin, c) + pxAdd) * zoomFactor;
+          let py = (q * trig(trigPyCos, c - (i % cMod2) + (i % cMod1) * 3 + pyCosAdd1) + pyAdd) * zoomFactor;
+          p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
+        }
+      } else if(baseSet === 'yuruyurau_5') {
+        // a=(m,d=mag(k=9*cos(i/61),e=i/692-13)**2/99+1)=>point(
+        //   (q=79-e/2*sin(k/d*4)+k/d*(8+5*sin(sin(d*d+e/9-t+m))))*cos(c=d/2+cos(t-d*2+m)/9-t/16+m)+200,
+        //   (q+40)*sin(c)+200)
+        p.stroke(255, 96);
+        const zoomFactor = 0.315;
+        const kMult = params.k_mult || 9, kCosDiv = params.k_cos_div || 61;
+        const eDiv = params.e_div || 692, eSub = params.e_sub || 13;
+        const dPow = params.d_pow || 2, dDiv = params.d_div || 99, dAdd = params.d_add || 1;
+        const mMult = params.m_mult || 9;
+        const qBase = params.q_base || 79, qEDiv = params.q_e_div || 2, qSin1Mult = params.q_sin1_mult || 4;
+        const qKMult = params.q_k_mult || 8, qSin2Mult = params.q_sin2_mult || 5, qSinEDiv = params.q_sin_e_div || 9;
+        const cDDiv = params.c_d_div || 2, cD2Mult = params.c_d2_mult || 2, cCosDiv = params.c_cos_div || 9, cTDiv = params.c_t_div || 16;
+        const pxAdd = params.px_add || 200, pyQAdd = params.py_q_add || 40, pyAdd = params.py_add || 200;
+        const trigKCos = params.trig_k_cos || 'cos';
+        const trigQSin1 = params.trig_q_sin1 || 'sin';
+        const trigQSin2 = params.trig_q_sin2 || 'sin';
+        const trigQSin3 = params.trig_q_sin3 || 'sin';
+        const trigCCos = params.trig_c_cos || 'cos';
+        const trigPxCos = params.trig_px_cos || 'cos';
+        const trigPySin = params.trig_py_sin || 'sin';
+        const patternCenterX = pxAdd * zoomFactor, patternCenterY = pyAdd * zoomFactor;
+        const step = FRAME_SAMPLING_STEPS[baseSet] || 1;
+        const maxI = LOOP_BOUNDS[baseSet] || 20000;
+        for(let i = maxI; i--;) {
+          let m = (i % 2) * mMult;
+          let k = kMult * trig(trigKCos, i / kCosDiv);
+          let e = i / eDiv - eSub;
+          let d = Math.hypot(k, e) ** dPow / dDiv + dAdd;
+          let q = qBase - e / qEDiv * trig(trigQSin1, k / d * qSin1Mult) + k / d * (qKMult + qSin2Mult * trig(trigQSin2, trig(trigQSin3, d * d + e / qSinEDiv - t + m)));
+          let c = d / cDDiv + trig(trigCCos, t - d * cD2Mult + m) / cCosDiv - t / cTDiv + m;
+          let px = (q * trig(trigPxCos, c) + pxAdd) * zoomFactor;
+          let py = ((q + pyQAdd) * trig(trigPySin, c) + pyAdd) * zoomFactor;
+          if(isFinite(px) && isFinite(py)) p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
+        }
+      } else {
+        // always_finding_yourself
+        p.stroke(255, 40);
+        const zoomFactor = 0.2;
+        const kDiv = params.k_div, kSub = params.k_sub, eDiv = params.e_div, eAdd = params.e_add ?? 9;
+        const oDiv = params.o_div, xOff = params.x_offset, yTrigDiv = params.y_trig_div;
+        const qMult = params.q_mult, pxAdd = params.px_add, pyAdd = params.py_add, pyQDiv = params.py_q_div;
+        const trigY = params.trig_y, trigE = params.trig_e, trigO = params.trig_o;
+        const trigCSin = params.trig_c_sin, trigC4Cos = params.trig_c4_cos, trigCCos = params.trig_c_cos;
+        const patternCenterX = pxAdd * zoomFactor, patternCenterY = pyAdd * zoomFactor;
+        const step = FRAME_SAMPLING_STEPS[baseSet] || DEFAULT_FRAME_SAMPLING_STEP;
+        const maxI = LOOP_BOUNDS[baseSet] || 6400;
+        for(let i = 0; i < maxI; i += step){
+          let x = i % 200, y = i / 200;
+          let k = x / kDiv - kSub; let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
+          let e = y / eDiv + eAdd, o = Math.hypot(k, e) / oDiv;
+          let q = x + xOff + y + 1/ksafe + o * k * (trig(trigY, y) / yTrigDiv + trig(trigE, e)) * trig(trigO, o * 4 - t);
+          let c = o + e / 99 - t / 8 + (i % 2) * 3;
+          let px = (qMult * q * trig(trigCSin, c) + pxAdd) * zoomFactor;
+          let py = (pyAdd + y / 2 * trig(trigC4Cos, c * 4 - o) - q / pyQDiv * trig(trigCCos, c - 1)) * zoomFactor;
+          p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
+        }
+      }
+    }
+
     function updateBaseEquationDisplay(){
       const container = document.getElementById('base-preview-canvas');
 
@@ -483,10 +689,8 @@
       const baseParams = {...currentParams};
 
       basePreviewSketch = new p5(p => {
-        const trig = (name, val) => getTrig(name)(val);
-
         p.setup = () => {
-          p.createCanvas(126, 126).parent(container); // Same size as grid variants
+          p.createCanvas(126, 126).parent(container);
           p.pixelDensity(1);
           p.frameRate(FRAME_RATE);
           p.noFill();
@@ -494,227 +698,13 @@
         };
 
         p.draw = () => {
-          // Animate over 300 frames, repeating (100x speed)
           const frame = p.frameCount % ANIMATION_FRAMES;
-          const t = (frame / ANIMATION_FRAMES) * Math.PI * 2 * 100; // 0 to 200π over 300 frames (100x faster)
-          
-          p.clear(); // Remove background patching
-          p.stroke(255, 40); // Subtle rendering for base pattern
-
-          // Calculate center offset based on canvas size
-          const centerX = p.width / 2;
-          const centerY = p.height / 2;
-
-          if(currentBaseSet === 'a_constant_state_of_bliss') {
-            // Render "a constant state of bliss" equations
-            const zoomFactor = 0.4; // 0.8x zoom out from 0.5
-            const kDiv = baseParams.k_div || 8, kSub = baseParams.k_sub || 11.5;
-            const eDiv = baseParams.e_div || 8, eSub = baseParams.e_sub || 12.5;
-            const oDiv = baseParams.o_div || 139, dMult = baseParams.d_mult || 10;
-            const pxDiv = baseParams.px_div || 2, pxAdd1 = baseParams.px_add1 || 150;
-            const pyYDiv = baseParams.py_y_div || 9, pyDMult = baseParams.py_d_mult || 15;
-            const pyCosMult = baseParams.py_cos_mult || 2, pyAdd = baseParams.py_add || 220;
-            const strokeBase = baseParams.stroke_base || 99, strokeMult = baseParams.stroke_mult || 99, strokePow = baseParams.stroke_pow || 30;
-            // Trig functions
-            const trigDCos = baseParams.trig_d_cos || 'cos';
-            const trigPxSin1 = baseParams.trig_px_sin1 || 'sin';
-            const trigPxSin2 = baseParams.trig_px_sin2 || 'sin';
-            const trigPyCos = baseParams.trig_py_cos || 'cos';
-            const trigPySin = baseParams.trig_py_sin || 'sin';
-            const trigStrokeSin1 = baseParams.trig_stroke_sin1 || 'sin';
-            const trigStrokeSin2 = baseParams.trig_stroke_sin2 || 'sin';
-            
-            // Pattern center in world coordinates (approximate, based on typical px/py values)
-            // For this equation, px typically ranges around pxAdd1 (150), py around pyAdd (220)
-            const patternCenterX = pxAdd1 * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-            
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 6400;
-            for(let i = 0; i < maxI; i += step){
-              let x = i % 200, y = i / 200;
-              let k = x / kDiv - kSub;
-              let e = y / eDiv - eSub;
-              let o = Math.hypot(k, e) ** 2 / oDiv;
-              let d = dMult * trig(trigDCos, o);
-              let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
-              let stroke_r = strokeBase + strokeMult / trig(trigStrokeSin1, ksafe) * trig(trigStrokeSin2, t + e) ** strokePow;
-              p.stroke(stroke_r, 66);
-              let px = ((x + trig(trigPxSin1, d) * d * k) / pxDiv + pxAdd1 + o * k * trig(trigPxSin2, t + d * o)) * zoomFactor;
-              let py = (y / pyYDiv - d * pyDMult - trig(trigPyCos, d * pyCosMult) * d + pyAdd + d * trig(trigPySin, d - t)) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          } else if(currentBaseSet === 'yuruyurau') {
-            // Render yuruyurau equation
-            p.stroke(255, 96); // Match original stroke(w,96)
-            const zoomFactor = 0.3;
-            const kBase = baseParams.k_base || 4, kSinMult = baseParams.k_sin_mult || 3, kCosDiv = baseParams.k_cos_div || 29;
-            const eDiv = baseParams.e_div || 8, eSub = baseParams.e_sub || 13;
-            const qSin1Mult = baseParams.q_sin1_mult || 3, qSin1Mult2 = baseParams.q_sin1_mult2 || 2, qDiv = baseParams.q_div || 0.3;
-            const qSin2Div = baseParams.q_sin2_div || 25, qBase = baseParams.q_base || 9;
-            const qSin3Mult = baseParams.q_sin3_mult || 4, qSin3EMult = baseParams.q_sin3_e_mult || 9;
-            const qSin3DMult = baseParams.q_sin3_d_mult || 3, qSin3TMult = baseParams.q_sin3_t_mult || 2;
-            const pxCosMult = baseParams.px_cos_mult || 30, pxAdd = baseParams.px_add || 200;
-            const pyDMult = baseParams.py_d_mult || 39, pySub = baseParams.py_sub || 220;
-            // Trig functions
-            const trigKSin = baseParams.trig_k_sin || 'sin';
-            const trigKCos = baseParams.trig_k_cos || 'cos';
-            const trigQSin1 = baseParams.trig_q_sin1 || 'sin';
-            const trigQSin2 = baseParams.trig_q_sin2 || 'sin';
-            const trigQSin3 = baseParams.trig_q_sin3 || 'sin';
-            const trigPxCos = baseParams.trig_px_cos || 'cos';
-            const trigPySin = baseParams.trig_py_sin || 'sin';
-            
-            // Pattern center estimate
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pySub / 2) * zoomFactor;
-            
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 10000;
-            for(let i = 0; i < maxI; i += step){
-              let x = i, y = i / 235;
-              let k = (kBase + trig(trigKSin, y * 2 - t) * kSinMult) * trig(trigKCos, x / kCosDiv);
-              let e = y / eDiv - eSub;
-              let d = Math.hypot(k, e);
-              let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
-              let q = qSin1Mult * trig(trigQSin1, k * qSin1Mult2) + qDiv / ksafe + trig(trigQSin2, y / qSin2Div) * k * (qBase + qSin3Mult * trig(trigQSin3, e * qSin3EMult - d * qSin3DMult + t * qSin3TMult));
-              let c = d - t;
-              let px = (q + pxCosMult * trig(trigPxCos, c) + pxAdd) * zoomFactor;
-              let py = (q * trig(trigPySin, c) + d * pyDMult - pySub) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          /* } else if(currentBaseSet === 'yuruyurau_2') {
-            // Render yuruyurau #2
-            p.stroke(255, 46);
-            const zoomFactor = 0.3;
-            const kCondThreshold = baseParams.k_cond_threshold || 20000;
-            const kSinDiv = baseParams.k_sin_div || 9, kSinMult = baseParams.k_sin_mult || 9;
-            const kCosMult = baseParams.k_cos_mult || 4, kCosDiv1 = baseParams.k_cos_div1 || 49, kCosDiv2 = baseParams.k_cos_div2 || 3690;
-            const eDiv = baseParams.e_div || 984, eSub = baseParams.e_sub || 12;
-            const dPow = baseParams.d_pow || 2, dDiv = baseParams.d_div || 99, dAdd = baseParams.d_add || 1;
-            const qKMult = baseParams.q_k_mult || 4, qSinDMult = baseParams.q_sin_d_mult || 16;
-            const qAtan2Mult = baseParams.q_atan2_mult || 5, qAtan2Mult2 = baseParams.q_atan2_mult2 || 9;
-            const pxSinMult = baseParams.px_sin_mult || 60, pxAdd = baseParams.px_add || 200;
-            const pyQAdd = baseParams.py_q_add || 40, pyDMult = baseParams.py_d_mult || 79;
-            const cDMult = baseParams.c_d_mult || 1.1, cTDiv = baseParams.c_t_div || 18;
-            const trigKSin = baseParams.trig_k_sin || 'sin';
-            const trigKCos1 = baseParams.trig_k_cos1 || 'cos';
-            const trigKCos2 = baseParams.trig_k_cos2 || 'cos';
-            const trigQSin = baseParams.trig_q_sin || 'sin';
-            const trigQAtan2 = baseParams.trig_q_atan2 || 'atan';
-            const trigPxSin = baseParams.trig_px_sin || 'sin';
-            const trigPySin = baseParams.trig_py_sin || 'sin';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pyDMult * 50) * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 30000;
-            for(let i = maxI; i > 0; i -= step){
-              let k = i < kCondThreshold ? trig(trigKSin, i / kSinDiv) * kSinMult : kCosMult * trig(trigKCos1, i / kCosDiv1) * trig(trigKCos2, i / kCosDiv2);
-              let e = i / eDiv - eSub;
-              let d = (Math.hypot(k, e) ** dPow / dDiv) + dAdd;
-              let q = k * (qKMult + trig(trigQSin, d * qSinDMult - t + k)) - qAtan2Mult * Math.atan2(k, e) * qAtan2Mult2;
-              let c = d * cDMult - t / cTDiv + (i % 2) * 3;
-              let px = (q + pxSinMult * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = ((q + pyQAdd) * trig(trigPySin, c - d) + d * pyDMult) * zoomFactor;
-              if(isFinite(px) && isFinite(py)) {
-                p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-              }
-            }
-          } else if(currentBaseSet === 'yuruyurau_3') {
-            // Render yuruyurau #3
-            const zoomFactor = 0.3;
-            const kMult = baseParams.k_mult || 5, kCosDiv1 = baseParams.k_cos_div1 || 49, kCosDiv2 = baseParams.k_cos_div2 || 3690;
-            const eDiv = baseParams.e_div || 984, eSub = baseParams.e_sub || 12;
-            const dPow = baseParams.d_pow || 2, dDiv = baseParams.d_div || 99, dAdd = baseParams.d_add || 1;
-            const qKMult = baseParams.q_k_mult || 4, qSinDMult = baseParams.q_sin_d_mult || 18, qSinTMult = baseParams.q_sin_t_mult || 2;
-            const qSinMod = baseParams.q_sin_mod || 3, qSinModMult = baseParams.q_sin_mod_mult || 2;
-            const qAtan2Mult = baseParams.q_atan2_mult || 5, qAtan2Mult2 = baseParams.q_atan2_mult2 || 9;
-            const pxSinMult = baseParams.px_sin_mult || 30, pxAdd = baseParams.px_add || 200;
-            const pySinMult = baseParams.py_sin_mult || 80, pyDMult = baseParams.py_d_mult || 79;
-            const cTDiv = baseParams.c_t_div || 18, cMod = baseParams.c_mod || 3, cModMult = baseParams.c_mod_mult || 4;
-            const trigKCos1 = baseParams.trig_k_cos1 || 'cos';
-            const trigKCos2 = baseParams.trig_k_cos2 || 'cos';
-            const trigQSin = baseParams.trig_q_sin || 'sin';
-            const trigQAtan2 = baseParams.trig_q_atan2 || 'atan';
-            const trigPxSin = baseParams.trig_px_sin || 'sin';
-            const trigPySin = baseParams.trig_py_sin || 'sin';
-            const trigStrokeCos = baseParams.trig_stroke_cos || 'cos';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pyDMult * 50) * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 20000;
-            for(let i = maxI; i > 0; i -= step){
-              let k = kMult * trig(trigKCos1, i / kCosDiv1) * trig(trigKCos2, i / kCosDiv2);
-              let e = i / eDiv - eSub;
-              let d = (Math.hypot(k, e) ** dPow / dDiv) + dAdd;
-              let cosVal = trig(trigStrokeCos, t + e);
-              let stroke_r = 36 + 3 / (Math.abs(cosVal) > 0.001 ? cosVal : 0.001);
-              p.stroke(255, Math.min(255, Math.max(0, stroke_r)));
-              let c = d - t / cTDiv + (i % cMod) * cModMult;
-              let px = (k * (qKMult + trig(trigQSin, d * qSinDMult - t * qSinTMult + (i % qSinMod) * qSinModMult)) - qAtan2Mult * Math.atan2(k, e) * qAtan2Mult2 + pxSinMult * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = (pySinMult * trig(trigPySin, c - d) + d * pyDMult) * zoomFactor;
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          */ } else if(currentBaseSet === 'yuruyurau_4') {
-            // Render yuruyurau #4
-            p.stroke(255, 96);
-            const zoomFactor = 0.3;
-            const kMult = baseParams.k_mult || 5, kCosDiv = baseParams.k_cos_div || 8;
-            const eMult = baseParams.e_mult || 5, eCosDiv = baseParams.e_cos_div || 9;
-            const dDivBase = baseParams.d_div_base || 6, dPow = baseParams.d_pow || 4, dAdd = baseParams.d_add || 4;
-            const qKMult = baseParams.q_k_mult || 3, qEDiv = baseParams.q_e_div || 2;
-            const qSinMult = baseParams.q_sin_mult || 3, qSinKDDiv = baseParams.q_sin_kd_div || 3, qBitwiseMult = baseParams.q_bitwise_mult || 70;
-            const pxSinMult = baseParams.px_sin_mult || 1, pxAdd = baseParams.px_add || 200;
-            const pyCosAdd1 = baseParams.py_cos_add1 || 7, pyAdd = baseParams.py_add || 200;
-            const cTDiv = baseParams.c_t_div || 9, cMod1 = baseParams.c_mod1 || 5, cMod1Mult = baseParams.c_mod1_mult || 5, cMod2 = baseParams.c_mod2 || 2;
-            const trigKCos = baseParams.trig_k_cos || 'cos';
-            const trigECos = baseParams.trig_e_cos || 'cos';
-            const trigQSin = baseParams.trig_q_sin || 'sin';
-            const trigQSin2 = baseParams.trig_q_sin2 || 'sin';
-            const trigPxSin = baseParams.trig_px_sin || 'sin';
-            const trigPyCos = baseParams.trig_py_cos || 'cos';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 20000;
-            for(let i = maxI; i > 0; i -= step){
-              let y = i / 799;
-              let k = kMult * trig(trigKCos, i / kCosDiv);
-              let e = eMult * trig(trigECos, y / eCosDiv);
-              let d = (Math.hypot(k, e) / (dDivBase + (i % 5))) ** dPow + dAdd;
-              let q = k * (qKMult + e / qEDiv * trig(trigQSin, d * d - t)) - qSinMult * trig(trigQSin2, k * d / qSinKDDiv) - (~(i & 1)) * qBitwiseMult;
-              let c = d - t / cTDiv + (i % cMod1) * cMod1Mult + (i % cMod2);
-              let px = (q * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = (q * trig(trigPyCos, c - (i % cMod2) + (i % cMod1) * 3 + pyCosAdd1) + pyAdd) * zoomFactor;
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          } else {
-            // Render "always_finding_yourself" equations
-          const zoomFactor = 0.2;
-          const kDiv = baseParams.k_div, kSub = baseParams.k_sub, eDiv = baseParams.e_div, eAdd = baseParams.e_add;
-          const oDiv = baseParams.o_div, xOff = baseParams.x_offset, yTrigDiv = baseParams.y_trig_div;
-          const qMult = baseParams.q_mult, pxAdd = baseParams.px_add, pyAdd = baseParams.py_add, pyQDiv = baseParams.py_q_div;
-          const trigY = baseParams.trig_y, trigE = baseParams.trig_e, trigO = baseParams.trig_o;
-          const trigCSin = baseParams.trig_c_sin, trigC4Cos = baseParams.trig_c4_cos, trigCCos = baseParams.trig_c_cos;
-            
-            // Pattern center in world coordinates (pxAdd and pyAdd are the base offsets)
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-          
-          for(let i = 0; i < 6400; i += 3){
-            let x = i % 200, y = i / 200;
-            let k = x / kDiv - kSub; let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
-            let e = y / eDiv + eAdd;
-            let o = Math.hypot(k, e) / oDiv;
-            let q = x + xOff + y + 1/ksafe + o * k * (trig(trigY, y) / yTrigDiv + trig(trigE, e)) * trig(trigO, o * 4 - t);
-            let c = o + e / 99 - t / 8 + (i % 2) * 3;
-              let px = (qMult * q * trig(trigCSin, c) + pxAdd) * zoomFactor;
-              let py = (pyAdd + y / 2 * trig(trigC4Cos, c * 4 - o) - q / pyQDiv * trig(trigCCos, c - 1)) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
+          const t = (frame / ANIMATION_FRAMES) * Math.PI * 2 * 100;
+          p.clear();
+          const centerX = p.width / 2, centerY = p.height / 2;
+          drawEquationPoints(p, baseParams, currentBaseSet, t, centerX, centerY);
+          if(mergedSecondarySet) {
+            drawEquationPoints(p, extractMergedParams(baseParams), mergedSecondarySet, t, centerX, centerY);
           }
         };
       });
@@ -764,8 +754,8 @@
       currentMutations = [];
       variants.forEach(v => { if(v.mutations) currentMutations.push(...v.mutations); });
 
-      // Fast path: same base set + same count → just update params & labels, no sketch recreation
-      if(sketchBaseSet === currentBaseSet && variantSketches.length === variants.length) {
+      // Fast path: same base set + same merge + same count → just update params & labels, no sketch recreation
+      if(sketchBaseSet === currentBaseSet && sketchMergedSet === mergedSecondarySet && variantSketches.length === variants.length) {
         variants.forEach((v, i) => {
           // Update shared param slot — the p5 draw loop reads from this reference each frame
           Object.assign(variantParamSlots[i], v.params);
@@ -782,10 +772,11 @@
         return;
       }
 
-      // Full rebuild: base set changed or first render
+      // Full rebuild: base set/merge changed or first render
       variantSketches.forEach(s => { if(s && typeof s.remove === 'function') s.remove(); });
       variantSketches = [];
       sketchBaseSet = currentBaseSet;
+      sketchMergedSet = mergedSecondarySet;
       grid.innerHTML = '';
 
       variants.forEach((v, i) => {
@@ -818,9 +809,6 @@
 
     function renderEquation(container, params){
       const sketch = new p5(p=>{
-        // Use global TRIG_FNS lookup (O(1)) — avoids per-point if-else chain
-        const trig = (name, val) => getTrig(name)(val);
-
         p.setup=()=>{
           p.createCanvas(126,126).parent(container);
           p.pixelDensity(1);
@@ -831,230 +819,13 @@
         };
 
         p.draw=()=>{
-          // Animate over 300 frames, repeating (100x speed)
           const frame = p.frameCount % ANIMATION_FRAMES;
-          const t = (frame / ANIMATION_FRAMES) * Math.PI * 2 * 100; // 0 to 200π over 300 frames (100x faster)
-          
+          const t = (frame / ANIMATION_FRAMES) * Math.PI * 2 * 100;
           p.background(0);
-
-          // Calculate center offset based on canvas size (variants are 126x126)
-          const centerX = p.width / 2;
-          const centerY = p.height / 2;
-
-          if(currentBaseSet === 'a_constant_state_of_bliss') {
-            // Render "a constant state of bliss" equations
-            const zoomFactor = 0.4; // 0.8x zoom out from 0.5
-            const kDiv = params.k_div || 8, kSub = params.k_sub || 11.5;
-            const eDiv = params.e_div || 8, eSub = params.e_sub || 12.5;
-            const oDiv = params.o_div || 139, dMult = params.d_mult || 10;
-            const pxDiv = params.px_div || 2, pxAdd1 = params.px_add1 || 150;
-            const pyYDiv = params.py_y_div || 9, pyDMult = params.py_d_mult || 15;
-            const pyCosMult = params.py_cos_mult || 2, pyAdd = params.py_add || 220;
-            const strokeBase = params.stroke_base || 99, strokeMult = params.stroke_mult || 99, strokePow = params.stroke_pow || 30;
-            // Trig functions
-            const trigDCos = params.trig_d_cos || 'cos';
-            const trigPxSin1 = params.trig_px_sin1 || 'sin';
-            const trigPxSin2 = params.trig_px_sin2 || 'sin';
-            const trigPyCos = params.trig_py_cos || 'cos';
-            const trigPySin = params.trig_py_sin || 'sin';
-            const trigStrokeSin1 = params.trig_stroke_sin1 || 'sin';
-            const trigStrokeSin2 = params.trig_stroke_sin2 || 'sin';
-            
-            // Pattern center in world coordinates (approximate, based on typical px/py values)
-            // For this equation, px typically ranges around pxAdd1 (150), py around pyAdd (220)
-            const patternCenterX = pxAdd1 * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-            
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 6400;
-            for(let i = 0; i < maxI; i += step){
-              let x = i % 200, y = i / 200;
-              let k = x / kDiv - kSub;
-              let e = y / eDiv - eSub;
-              let o = Math.hypot(k, e) ** 2 / oDiv;
-              let d = dMult * trig(trigDCos, o);
-              let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
-              let stroke_r = strokeBase + strokeMult / trig(trigStrokeSin1, ksafe) * trig(trigStrokeSin2, t + e) ** strokePow;
-              p.stroke(stroke_r, 66);
-              let px = ((x + trig(trigPxSin1, d) * d * k) / pxDiv + pxAdd1 + o * k * trig(trigPxSin2, t + d * o)) * zoomFactor;
-              let py = (y / pyYDiv - d * pyDMult - trig(trigPyCos, d * pyCosMult) * d + pyAdd + d * trig(trigPySin, d - t)) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          } else if(currentBaseSet === 'yuruyurau') {
-            // Render yuruyurau equation
-            p.stroke(255, 96); // Match original stroke(w,96)
-            const zoomFactor = 0.3;
-            const kBase = params.k_base || 4, kSinMult = params.k_sin_mult || 3, kCosDiv = params.k_cos_div || 29;
-            const eDiv = params.e_div || 8, eSub = params.e_sub || 13;
-            const qSin1Mult = params.q_sin1_mult || 3, qSin1Mult2 = params.q_sin1_mult2 || 2, qDiv = params.q_div || 0.3;
-            const qSin2Div = params.q_sin2_div || 25, qBase = params.q_base || 9;
-            const qSin3Mult = params.q_sin3_mult || 4, qSin3EMult = params.q_sin3_e_mult || 9;
-            const qSin3DMult = params.q_sin3_d_mult || 3, qSin3TMult = params.q_sin3_t_mult || 2;
-            const pxCosMult = params.px_cos_mult || 30, pxAdd = params.px_add || 200;
-            const pyDMult = params.py_d_mult || 39, pySub = params.py_sub || 220;
-            // Trig functions
-            const trigKSin = params.trig_k_sin || 'sin';
-            const trigKCos = params.trig_k_cos || 'cos';
-            const trigQSin1 = params.trig_q_sin1 || 'sin';
-            const trigQSin2 = params.trig_q_sin2 || 'sin';
-            const trigQSin3 = params.trig_q_sin3 || 'sin';
-            const trigPxCos = params.trig_px_cos || 'cos';
-            const trigPySin = params.trig_py_sin || 'sin';
-            
-            // Pattern center estimate
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pySub / 2) * zoomFactor;
-            
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 10000;
-            for(let i = 0; i < maxI; i += step){
-              let x = i, y = i / 235;
-              let k = (kBase + trig(trigKSin, y * 2 - t) * kSinMult) * trig(trigKCos, x / kCosDiv);
-              let e = y / eDiv - eSub;
-              let d = Math.hypot(k, e);
-              let ksafe = Math.abs(k) > 1e-6 ? k : 1e-6;
-              let q = qSin1Mult * trig(trigQSin1, k * qSin1Mult2) + qDiv / ksafe + trig(trigQSin2, y / qSin2Div) * k * (qBase + qSin3Mult * trig(trigQSin3, e * qSin3EMult - d * qSin3DMult + t * qSin3TMult));
-              let c = d - t;
-              let px = (q + pxCosMult * trig(trigPxCos, c) + pxAdd) * zoomFactor;
-              let py = (q * trig(trigPySin, c) + d * pyDMult - pySub) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          /* } else if(currentBaseSet === 'yuruyurau_2') {
-            // Render yuruyurau #2
-            p.stroke(255, 46);
-            const zoomFactor = 0.3;
-            const kCondThreshold = params.k_cond_threshold || 20000;
-            const kSinDiv = params.k_sin_div || 9, kSinMult = params.k_sin_mult || 9;
-            const kCosMult = params.k_cos_mult || 4, kCosDiv1 = params.k_cos_div1 || 49, kCosDiv2 = params.k_cos_div2 || 3690;
-            const eDiv = params.e_div || 984, eSub = params.e_sub || 12;
-            const dPow = params.d_pow || 2, dDiv = params.d_div || 99, dAdd = params.d_add || 1;
-            const qKMult = params.q_k_mult || 4, qSinDMult = params.q_sin_d_mult || 16;
-            const qAtan2Mult = params.q_atan2_mult || 5, qAtan2Mult2 = params.q_atan2_mult2 || 9;
-            const pxSinMult = params.px_sin_mult || 60, pxAdd = params.px_add || 200;
-            const pyQAdd = params.py_q_add || 40, pyDMult = params.py_d_mult || 79;
-            const cDMult = params.c_d_mult || 1.1, cTDiv = params.c_t_div || 18;
-            const trigKSin = params.trig_k_sin || 'sin';
-            const trigKCos1 = params.trig_k_cos1 || 'cos';
-            const trigKCos2 = params.trig_k_cos2 || 'cos';
-            const trigQSin = params.trig_q_sin || 'sin';
-            const trigQAtan2 = params.trig_q_atan2 || 'atan';
-            const trigPxSin = params.trig_px_sin || 'sin';
-            const trigPySin = params.trig_py_sin || 'sin';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pyDMult * 50) * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 30000;
-            for(let i = maxI; i > 0; i -= step){
-              let k = i < kCondThreshold ? trig(trigKSin, i / kSinDiv) * kSinMult : kCosMult * trig(trigKCos1, i / kCosDiv1) * trig(trigKCos2, i / kCosDiv2);
-              let e = i / eDiv - eSub;
-              let d = (Math.hypot(k, e) ** dPow / dDiv) + dAdd;
-              let q = k * (qKMult + trig(trigQSin, d * qSinDMult - t + k)) - qAtan2Mult * Math.atan2(k, e) * qAtan2Mult2;
-              let c = d * cDMult - t / cTDiv + (i % 2) * 3;
-              let px = (q + pxSinMult * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = ((q + pyQAdd) * trig(trigPySin, c - d) + d * pyDMult) * zoomFactor;
-              if(isFinite(px) && isFinite(py)) {
-                p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-              }
-            }
-          } else if(currentBaseSet === 'yuruyurau_3') {
-            // Render yuruyurau #3
-            const zoomFactor = 0.3;
-            const kMult = params.k_mult || 5, kCosDiv1 = params.k_cos_div1 || 49, kCosDiv2 = params.k_cos_div2 || 3690;
-            const eDiv = params.e_div || 984, eSub = params.e_sub || 12;
-            const dPow = params.d_pow || 2, dDiv = params.d_div || 99, dAdd = params.d_add || 1;
-            const qKMult = params.q_k_mult || 4, qSinDMult = params.q_sin_d_mult || 18, qSinTMult = params.q_sin_t_mult || 2;
-            const qSinMod = params.q_sin_mod || 3, qSinModMult = params.q_sin_mod_mult || 2;
-            const qAtan2Mult = params.q_atan2_mult || 5, qAtan2Mult2 = params.q_atan2_mult2 || 9;
-            const pxSinMult = params.px_sin_mult || 30, pxAdd = params.px_add || 200;
-            const pySinMult = params.py_sin_mult || 80, pyDMult = params.py_d_mult || 79;
-            const cTDiv = params.c_t_div || 18, cMod = params.c_mod || 3, cModMult = params.c_mod_mult || 4;
-            const trigKCos1 = params.trig_k_cos1 || 'cos';
-            const trigKCos2 = params.trig_k_cos2 || 'cos';
-            const trigQSin = params.trig_q_sin || 'sin';
-            const trigQAtan2 = params.trig_q_atan2 || 'atan';
-            const trigPxSin = params.trig_px_sin || 'sin';
-            const trigPySin = params.trig_py_sin || 'sin';
-            const trigStrokeCos = params.trig_stroke_cos || 'cos';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = (pyDMult * 50) * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 20000;
-            for(let i = maxI; i > 0; i -= step){
-              let k = kMult * trig(trigKCos1, i / kCosDiv1) * trig(trigKCos2, i / kCosDiv2);
-              let e = i / eDiv - eSub;
-              let d = (Math.hypot(k, e) ** dPow / dDiv) + dAdd;
-              let cosVal = trig(trigStrokeCos, t + e);
-              let stroke_r = 36 + 3 / (Math.abs(cosVal) > 0.001 ? cosVal : 0.001);
-              p.stroke(255, Math.min(255, Math.max(0, stroke_r)));
-              let c = d - t / cTDiv + (i % cMod) * cModMult;
-              let px = (k * (qKMult + trig(trigQSin, d * qSinDMult - t * qSinTMult + (i % qSinMod) * qSinModMult)) - qAtan2Mult * Math.atan2(k, e) * qAtan2Mult2 + pxSinMult * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = (pySinMult * trig(trigPySin, c - d) + d * pyDMult) * zoomFactor;
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          */ } else if(currentBaseSet === 'yuruyurau_4') {
-            // Render yuruyurau #4
-            p.stroke(255, 96);
-            const zoomFactor = 0.3;
-            const kMult = params.k_mult || 5, kCosDiv = params.k_cos_div || 8;
-            const eMult = params.e_mult || 5, eCosDiv = params.e_cos_div || 9;
-            const dDivBase = params.d_div_base || 6, dPow = params.d_pow || 4, dAdd = params.d_add || 4;
-            const qKMult = params.q_k_mult || 3, qEDiv = params.q_e_div || 2;
-            const qSinMult = params.q_sin_mult || 3, qSinKDDiv = params.q_sin_kd_div || 3, qBitwiseMult = params.q_bitwise_mult || 70;
-            const pxSinMult = params.px_sin_mult || 1, pxAdd = params.px_add || 200;
-            const pyCosAdd1 = params.py_cos_add1 || 7, pyAdd = params.py_add || 200;
-            const cTDiv = params.c_t_div || 9, cMod1 = params.c_mod1 || 5, cMod1Mult = params.c_mod1_mult || 5, cMod2 = params.c_mod2 || 2;
-            const trigKCos = params.trig_k_cos || 'cos';
-            const trigECos = params.trig_e_cos || 'cos';
-            const trigQSin = params.trig_q_sin || 'sin';
-            const trigQSin2 = params.trig_q_sin2 || 'sin';
-            const trigPxSin = params.trig_px_sin || 'sin';
-            const trigPyCos = params.trig_py_cos || 'cos';
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 20000;
-            for(let i = maxI; i > 0; i -= step){
-              let y = i / 799;
-              let k = kMult * trig(trigKCos, i / kCosDiv);
-              let e = eMult * trig(trigECos, y / eCosDiv);
-              let d = (Math.hypot(k, e) / (dDivBase + (i % 5))) ** dPow + dAdd;
-              let q = k * (qKMult + e / qEDiv * trig(trigQSin, d * d - t)) - qSinMult * trig(trigQSin2, k * d / qSinKDDiv) - (~(i & 1)) * qBitwiseMult;
-              let c = d - t / cTDiv + (i % cMod1) * cMod1Mult + (i % cMod2);
-              let px = (q * trig(trigPxSin, c) + pxAdd) * zoomFactor;
-              let py = (q * trig(trigPyCos, c - (i % cMod2) + (i % cMod1) * 3 + pyCosAdd1) + pyAdd) * zoomFactor;
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
-          } else {
-            // Render "always_finding_yourself" equations
-          p.stroke(255, 40); // Same as base preview
-          const zoomFactor = 0.2; // Same as base
-          const kDiv = params.k_div, kSub = params.k_sub, eDiv = params.e_div, eAdd = params.e_add ?? 9;
-          const oDiv = params.o_div, xOff = params.x_offset, yTrigDiv = params.y_trig_div;
-          const qMult = params.q_mult, pxAdd = params.px_add, pyAdd = params.py_add, pyQDiv = params.py_q_div;
-          const trigY = params.trig_y, trigE = params.trig_e, trigO = params.trig_o;
-          const trigCSin = params.trig_c_sin, trigC4Cos = params.trig_c4_cos, trigCCos = params.trig_c_cos;
-            
-            // Pattern center in world coordinates (pxAdd and pyAdd are the base offsets)
-            const patternCenterX = pxAdd * zoomFactor;
-            const patternCenterY = pyAdd * zoomFactor;
-          
-          // Same point count and step as base preview (6400 points, i += 3)
-            const step = FRAME_SAMPLING_STEPS[currentBaseSet] || DEFAULT_FRAME_SAMPLING_STEP;
-            const maxI = LOOP_BOUNDS[currentBaseSet] || 6400;
-            for(let i=0;i<maxI;i+=step){
-            let x=i%200, y=i/200;
-            let k=x/kDiv-kSub; let ksafe=Math.abs(k)>1e-6?k:1e-6;
-            let e=y/eDiv+eAdd;
-            let o=Math.hypot(k,e)/oDiv;
-            let q=x+xOff+y+1/ksafe + o*k*(trig(trigY,y)/yTrigDiv + trig(trigE,e)) * trig(trigO,o*4 - t);
-            let c=o + e/99 - t/8 + (i%2)*3;
-              let px=(qMult*q*trig(trigCSin,c) + pxAdd) * zoomFactor;
-              let py=(pyAdd + y/2*trig(trigC4Cos,c*4 - o) - q/pyQDiv*trig(trigCCos,c - 1)) * zoomFactor;
-              // Center the pattern in the canvas
-              p.point(px - patternCenterX + centerX, py - patternCenterY + centerY);
-            }
+          const centerX = p.width / 2, centerY = p.height / 2;
+          drawEquationPoints(p, params, currentBaseSet, t, centerX, centerY);
+          if(mergedSecondarySet) {
+            drawEquationPoints(p, extractMergedParams(params), mergedSecondarySet, t, centerX, centerY);
           }
         };
       });
@@ -1410,6 +1181,17 @@
         equation += `  px = q*${getParam('trig_px_sin')}(c) + ${getParam('px_add')}\n`;
         equation += `  py = q*${getParam('trig_py_cos')}(c-i%${getParam('c_mod2')}+i%${getParam('c_mod1')}*3+${getParam('py_cos_add1')}) + ${getParam('py_add')}\n`;
         equation += `  point(px,py)`;
+      } else if(baseSet === 'yuruyurau_5') {
+        equation += 'for i in range(20000, 0, -1):\n';
+        equation += `  m = (i%2) * ${getParam('m_mult')}\n`;
+        equation += `  k = ${getParam('k_mult')}*${getParam('trig_k_cos')}(i/${getParam('k_cos_div')})\n`;
+        equation += `  e = i/${getParam('e_div')} - ${getParam('e_sub')}\n`;
+        equation += `  d = mag(k,e)^${getParam('d_pow')}/${getParam('d_div')} + ${getParam('d_add')}\n`;
+        equation += `  q = ${getParam('q_base')} - e/${getParam('q_e_div')}*${getParam('trig_q_sin1')}(k/d*${getParam('q_sin1_mult')}) + k/d*(${getParam('q_k_mult')}+${getParam('q_sin2_mult')}*${getParam('trig_q_sin2')}(${getParam('trig_q_sin3')}(d*d+e/${getParam('q_sin_e_div')}-t+m)))\n`;
+        equation += `  c = d/${getParam('c_d_div')} + ${getParam('trig_c_cos')}(t-d*${getParam('c_d2_mult')}+m)/${getParam('c_cos_div')} - t/${getParam('c_t_div')} + m\n`;
+        equation += `  px = q*${getParam('trig_px_cos')}(c) + ${getParam('px_add')}\n`;
+        equation += `  py = (q+${getParam('py_q_add')})*${getParam('trig_py_sin')}(c) + ${getParam('py_add')}\n`;
+        equation += `  point(px,py)`;
       } else {
         // Original equations (always_finding_yourself)
         equation += 'for i in range(0, 6400, 3):\n';
@@ -1452,6 +1234,103 @@
     // Make download function global
     window.downloadEquation = downloadEquation;
 
+    // ── Merge zone logic ──────────────────────────────────────────────────────
+
+    const EQ_LABELS = {
+      'always_finding_yourself': 'always_finding',
+      'a_constant_state_of_bliss': 'a constant state',
+      'yuruyurau': '#1',
+      'yuruyurau_4': '#2',
+      'yuruyurau_5': '#3'
+    };
+
+    function updateMergeZoneUI() {
+      const zone = document.getElementById('merge-drop-zone');
+      const hint = document.getElementById('merge-drop-hint');
+      if(!zone) return;
+      // Clear dynamic chips (keep the hint span)
+      zone.querySelectorAll('.eq-chip-in-zone').forEach(el => el.remove());
+      if(mergedSecondarySet) {
+        if(hint) hint.style.display = 'none';
+        const chip = document.createElement('div');
+        chip.className = 'eq-chip-in-zone';
+        chip.innerHTML = `${EQ_LABELS[mergedSecondarySet] || mergedSecondarySet}<span class="eq-chip-remove" onclick="clearMerge()" title="remove">✕</span>`;
+        zone.appendChild(chip);
+      } else {
+        if(hint) hint.style.display = '';
+      }
+    }
+
+    function setMergedSecondary(setName) {
+      if(setName === currentBaseSet) {
+        // Can't merge an equation with itself as secondary — silently ignore
+        return;
+      }
+      fetchJSON('/api/set_merged_secondary', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({set_name: setName})
+      })
+      .then(data => {
+        if(data.success) {
+          mergedSecondarySet = data.merged_secondary_set;
+          updateMergeZoneUI();
+          loadPopulation();
+        }
+      })
+      .catch(err => console.error('Error setting merge:', err));
+    }
+
+    function clearMerge() {
+      fetchJSON('/api/set_merged_secondary', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({set_name: null})
+      })
+      .then(data => {
+        if(data.success) {
+          mergedSecondarySet = null;
+          updateMergeZoneUI();
+          loadPopulation();
+        }
+      })
+      .catch(err => console.error('Error clearing merge:', err));
+    }
+    window.clearMerge = clearMerge;
+
+    // Set up draggable equation chips
+    document.querySelectorAll('.eq-chip').forEach(chip => {
+      chip.addEventListener('dragstart', e => {
+        e.dataTransfer.setData('eq-set', chip.dataset.eq);
+        e.dataTransfer.effectAllowed = 'copy';
+      });
+    });
+
+    // Set up merge drop zone
+    const mergeDropZone = document.getElementById('merge-drop-zone');
+    if(mergeDropZone) {
+      mergeDropZone.addEventListener('dragover', e => {
+        if(e.dataTransfer.types.includes('eq-set')) {
+          e.preventDefault();
+          e.dataTransfer.dropEffect = 'copy';
+          mergeDropZone.classList.add('drag-over');
+        }
+      });
+      mergeDropZone.addEventListener('dragleave', () => mergeDropZone.classList.remove('drag-over'));
+      mergeDropZone.addEventListener('drop', e => {
+        e.preventDefault();
+        mergeDropZone.classList.remove('drag-over');
+        const setName = e.dataTransfer.getData('eq-set');
+        if(setName) setMergedSecondary(setName);
+      });
+    }
+
+    // Also reset sketchBaseSet when merge changes so renderVariants does a full rebuild
+    const _origSetMergedSecondary = setMergedSecondary;
+    // (sketchBaseSet reset happens via loadPopulation → renderVariants which checks sketchBaseSet)
+
+    // ── End merge zone logic ──────────────────────────────────────────────────
+
     // Initialize the application
     updateMutationProbChart(); // Initialize chart
     updateTrigProbIndicator(); // Initialize trig prob indicator