diff --git a/website/src/repl/components/panel/VisorTab.jsx b/website/src/repl/components/panel/VisorTab.jsx
index 6ebb0218..3d3621c1 100644
--- a/website/src/repl/components/panel/VisorTab.jsx
+++ b/website/src/repl/components/panel/VisorTab.jsx
@@ -3,23 +3,122 @@ import cx from '@src/cx.mjs';
 import { useSettings } from '@src/settings.mjs';
 import { __pianoroll } from '@strudel/draw';
 import {
-  drawTimeScope,
-  drawFrequencyScope,
   getAudioContext,
   getAnalyserById,
+  getAnalyzerData,
   getSuperdoughAudioController,
-  analysers,
 } from '@strudel/webaudio';
 
-// Visor: dibuja EN VIVO lo que suena, sin tener que escribir nada en el codigo.
-//  - PENTAGRAMA (piano-roll): rejilla de notas de lo que se esta tocando ahora.
-//  - ONDA (osciloscopio): forma de onda del sonido en tiempo real.
-//  - ESPECTRO: reparto de frecuencias (graves -> agudos).
-// El truco para que funcione con CUALQUIER codigo (sin .scope()) es pinchar un
+// Visor: dibuja EN VIVO lo que suena, sin escribir nada en el código.
+//  - PENTAGRAMA (piano-roll): notas de lo que se está tocando ahora.
+//  - ONDA: osciloscopio estable (disparo por cruce por cero + auto-ganancia).
+//  - ESPECTRO: bandas logarítmicas (graves→agudos) con peak-hold.
+// Para que funcione con CUALQUIER código (sin .scope()) pinchamos dos
 // AnalyserNode al bus maestro de superdough (destinationGain).
 
 const CKEY = 'strudel-visor-cycles'; // zoom del pentagrama (compases visibles)
-const SCOPE_ID = 'visor';
+const ID_T = 'visorTime'; // analizador de forma de onda
+const ID_F = 'visorFreq'; // analizador de espectro
+const FFT = 2048;
+
+const CYAN = '#00e5ff';
+const ORANGE = '#ff7a18';
+
+// ── osciloscopio estable ────────────────────────────────────────────
+function drawOnda(ctx, data, gainRef) {
+  const w = ctx.canvas.width;
+  const h = ctx.canvas.height;
+  const n = data.length;
+  const mid = h / 2;
+
+  // línea central tenue
+  ctx.strokeStyle = 'rgba(255,255,255,0.12)';
+  ctx.lineWidth = 1;
+  ctx.beginPath();
+  ctx.moveTo(0, mid);
+  ctx.lineTo(w, mid);
+  ctx.stroke();
+
+  // disparo: primer cruce por cero ascendente (estabiliza la imagen)
+  let start = 0;
+  const search = Math.floor(n / 2);
+  for (let i = 1; i < search; i++) {
+    if (data[i - 1] <= 0 && data[i] > 0) {
+      start = i;
+      break;
+    }
+  }
+
+  // auto-ganancia suave: normaliza al pico reciente para que se vea igual de
+  // bien con el tema flojo o fuerte (con límite para no ampliar el silencio).
+  let peak = 0;
+  for (let i = 0; i < n; i++) {
+    const a = Math.abs(data[i]);
+    if (a > peak) peak = a;
+  }
+  const amp = mid * 0.92; // altura útil (deja margen arriba/abajo)
+  const norm = 1 / Math.max(peak, 0.02); // multiplicador para que el pico llene amp
+  gainRef.g += (norm - gainRef.g) * 0.15; // suavizado entre frames
+  const k = amp * Math.min(gainRef.g, 6); // tope de amplificación x6
+
+  const len = n - start;
+  ctx.lineWidth = 2;
+  ctx.strokeStyle = CYAN;
+  ctx.shadowBlur = 8;
+  ctx.shadowColor = CYAN;
+  ctx.beginPath();
+  for (let i = 0; i < len; i++) {
+    const x = (i / (len - 1)) * w;
+    let s = data[start + i] * k;
+    if (s > amp) s = amp;
+    else if (s < -amp) s = -amp;
+    const y = mid - s;
+    if (i === 0) ctx.moveTo(x, y);
+    else ctx.lineTo(x, y);
+  }
+  ctx.stroke();
+  ctx.shadowBlur = 0;
+}
+
+// ── espectro con bandas logarítmicas + peak-hold ────────────────────
+function drawEspectro(ctx, data, sampleRate, peaks) {
+  const w = ctx.canvas.width;
+  const h = ctx.canvas.height;
+  const bins = data.length; // dB, lineal de 0..nyquist
+  const nyquist = sampleRate / 2;
+  const BANDS = peaks.length;
+  const fmin = 30;
+  const fmax = Math.min(16000, nyquist);
+  const minDb = -90;
+  const maxDb = -10;
+  const bw = w / BANDS;
+
+  for (let b = 0; b < BANDS; b++) {
+    const f0 = fmin * Math.pow(fmax / fmin, b / BANDS);
+    const f1 = fmin * Math.pow(fmax / fmin, (b + 1) / BANDS);
+    let i0 = Math.floor((f0 / nyquist) * bins);
+    let i1 = Math.floor((f1 / nyquist) * bins);
+    if (i1 <= i0) i1 = i0 + 1;
+    let m = -Infinity;
+    for (let i = i0; i < i1 && i < bins; i++) if (data[i] > m) m = data[i];
+    if (m === -Infinity) m = minDb;
+    let v = (m - minDb) / (maxDb - minDb);
+    v = v < 0 ? 0 : v > 1 ? 1 : v;
+
+    const x = b * bw;
+    const bh = v * h;
+    // color por frecuencia: graves naranjas → agudos cian (tema neón)
+    const hue = 25 + (b / BANDS) * 165;
+    ctx.fillStyle = `hsl(${hue}, 90%, 55%)`;
+    ctx.fillRect(x, h - bh, Math.max(1, bw * 0.8), bh);
+
+    // peak-hold: cae despacio
+    peaks[b] = Math.max(v, peaks[b] - 0.015);
+    const py = h - peaks[b] * h;
+    ctx.fillStyle = 'rgba(255,255,255,0.85)';
+    ctx.fillRect(x, py - 1.5, Math.max(1, bw * 0.8), 1.5);
+  }
+}
 
 export function VisorTab({ context }) {
   const { fontFamily } = useSettings();
@@ -37,7 +136,6 @@ export function VisorTab({ context }) {
   const [show, setShow] = useState({ roll: true, scope: true, spec: true });
   const [playing, setPlaying] = useState(false);
 
-  // refs para que el bucle lea los valores actuales sin reiniciarse
   const cyclesRef = useRef(cycles);
   const showRef = useRef(show);
   cyclesRef.current = cycles;
@@ -59,32 +157,39 @@ export function VisorTab({ context }) {
     const sctx = scope?.getContext('2d');
     const fctx = spec?.getContext('2d');
     let raf;
-    let lastNode = null;
+    let lastT = null;
+    let lastF = null;
+    const gainRef = { g: 1 };
+    const peaks = new Float32Array(64); // bandas del espectro
 
-    // ajusta el tamaño interno del canvas al que ocupa en pantalla
-    const fit = (cv) => {
+    // el piano-roll usa tamaños de texto en píxeles → dpr 1; onda/espectro
+    // los dibujo yo, así que ahí sí uso dpr para que se vean nítidos.
+    const dpr = Math.min(2, window.devicePixelRatio || 1);
+    const fit = (cv, scale) => {
       if (!cv) return;
-      const w = cv.clientWidth;
-      const h = cv.clientHeight;
+      const w = Math.round(cv.clientWidth * scale);
+      const h = Math.round(cv.clientHeight * scale);
       if (w && h && (cv.width !== w || cv.height !== h)) {
         cv.width = w;
         cv.height = h;
       }
     };
 
-    // pincha un analizador al bus maestro para poder leer onda/espectro de
-    // TODO lo que suena (sin que el usuario escriba .scope()). Se reengancha
-    // solo si el nodo cambia (p.ej. tras reiniciar el motor de audio).
-    const ensureAnalyser = () => {
+    const ensureAnalysers = () => {
       try {
-        getAudioContext(); // fuerza el contexto si aún no existe
-        const node = getAnalyserById(SCOPE_ID, 1024);
-        if (node !== lastNode) {
-          getSuperdoughAudioController().output.destinationGain.connect(node);
-          lastNode = node;
+        getAudioContext();
+        const nt = getAnalyserById(ID_T, FFT, 0);
+        if (nt !== lastT) {
+          getSuperdoughAudioController().output.destinationGain.connect(nt);
+          lastT = nt;
+        }
+        const nf = getAnalyserById(ID_F, FFT, 0.7);
+        if (nf !== lastF) {
+          getSuperdoughAudioController().output.destinationGain.connect(nf);
+          lastF = nf;
         }
       } catch {
-        /* el audio aún no está listo: se reintenta el siguiente frame */
+        /* audio aún no listo */
       }
     };
 
@@ -94,25 +199,23 @@ export function VisorTab({ context }) {
       setPlaying((p) => (p !== started ? started : p));
 
       const S = showRef.current;
-      fit(roll);
-      fit(scope);
-      fit(spec);
+      fit(roll, 1);
+      fit(scope, dpr);
+      fit(spec, dpr);
       rctx && rctx.clearRect(0, 0, roll.width, roll.height);
       sctx && sctx.clearRect(0, 0, scope.width, scope.height);
       fctx && fctx.clearRect(0, 0, spec.width, spec.height);
 
       if (started && scheduler.pattern) {
-        const time = scheduler.now();
-        const cyc = cyclesRef.current;
-
-        // PENTAGRAMA (piano-roll) de lo que suena en esta ventana de tiempo
+        // PENTAGRAMA
         if (S.roll && rctx) {
+          const cyc = cyclesRef.current;
           const playhead = 0.5;
           const from = -cyc * playhead;
           const to = cyc * (1 - playhead);
           let haps = [];
           try {
-            haps = scheduler.pattern.queryArc(time + from, time + to).filter((h) => h.hasOnset());
+            haps = scheduler.pattern.queryArc(scheduler.now() + from, scheduler.now() + to).filter((h) => h.hasOnset());
           } catch {
             haps = [];
           }
@@ -120,32 +223,33 @@ export function VisorTab({ context }) {
             __pianoroll({
               ctx: rctx,
               haps,
-              time,
+              time: scheduler.now(),
               cycles: cyc,
               playhead,
               fold: 1,
               labels: 1,
               background: 'transparent',
-              playheadColor: '#ff7a18',
+              playheadColor: ORANGE,
             });
           } catch {
             /* noop */
           }
         }
 
-        // ONDA + ESPECTRO del bus maestro
-        if ((S.scope || S.spec) && (sctx || fctx)) {
-          ensureAnalyser();
-          if (S.scope && sctx && analysers[SCOPE_ID]) {
+        // ONDA + ESPECTRO
+        if (S.scope || S.spec) {
+          ensureAnalysers();
+          if (S.scope && sctx) {
             try {
-              drawTimeScope(analysers[SCOPE_ID], { ctx: sctx, id: SCOPE_ID, color: '#00e5ff', thickness: 2 });
+              drawOnda(sctx, getAnalyzerData('time', ID_T), gainRef);
             } catch {
               /* noop */
             }
           }
-          if (S.spec && fctx && analysers[SCOPE_ID]) {
+          if (S.spec && fctx) {
             try {
-              drawFrequencyScope(analysers[SCOPE_ID], { ctx: fctx, id: SCOPE_ID, color: '#ff7a18' });
+              const sr = getAudioContext().sampleRate || 44100;
+              drawEspectro(fctx, getAnalyzerData('frequency', ID_F), sr, peaks);
             } catch {
               /* noop */
             }
@@ -167,7 +271,6 @@ export function VisorTab({ context }) {
 
   return (
     <div className="w-full h-full text-foreground flex flex-col overflow-hidden" style={{ fontFamily }}>
-      {/* controles */}
       <div className="flex items-center gap-3 px-2 py-2 border-b border-muted shrink-0 flex-wrap">
         <span className="text-xs opacity-70">zoom</span>
         <input
@@ -194,7 +297,6 @@ export function VisorTab({ context }) {
         </span>
       </div>
 
-      {/* lienzos */}
       <div className="relative grow min-h-0 flex flex-col">
         {!playing && (
           <div className="absolute inset-0 flex items-center justify-center pointer-events-none z-10">
@@ -216,7 +318,7 @@ export function VisorTab({ context }) {
           </div>
         )}
         {show.spec && (
-          <div className="relative shrink-0" style={{ height: 110 }}>
+          <div className="relative shrink-0" style={{ height: 120 }}>
             <span className="absolute top-1 left-2 text-[10px] uppercase tracking-widest opacity-40 z-10">
               espectro
             </span>
diff --git a/website/src/repl/components/panel/remix-projects.mjs b/website/src/repl/components/panel/remix-projects.mjs
index 13057a82..033648c8 100644
--- a/website/src/repl/components/panel/remix-projects.mjs
+++ b/website/src/repl/components/panel/remix-projects.mjs
@@ -1,12 +1,16 @@
 // Remixes retro (80s/90s/2000s) para la pestaña Projects.
 // GENERADO desde my-patterns/RETRO-TECHNO-REMIXES/*.strudel — edita alli y regenera.
+// Regenera con: node my-patterns/RETRO-TECHNO-REMIXES/_generate.mjs
 export const RETRO_REMIXES = [
   {
     name: "01 · blue monday 909 — new order (1983)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 01 · BLUE MONDAY 909 — New Order (1983) → Peak-Time Techno Remix
-// 132 BPM · Dm · TR-909 · sidechain + acid en el 2º drop
+// 132 BPM · Dm (i·i·VII·v = Dm·Dm·C·Am) · TR-909 + sub-boom afinado
+// PRODUCCIÓN PRO: kick en 2 capas (click 909 + boom con envolvente de
+// tono), bajo que SIGUE las fundamentales del acorde, groove con swing +
+// ghost notes, armonía con 7as/9as, capa de aire, separacion de frecuencias.
 // Estructura: intro→build→drop A→break→acid drop→coda (144 compases ≈ 4:22)
 // ════════════════════════════════════════════════════════════════
 setcps(132/60/4)
@@ -19,63 +23,113 @@ const hook = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~")
 
 const hookOctava = hook.add(note(12)).gain(.35).lpf(3200).orbit(2)
 
-// ── EL BAJO SECUENCIADO (16avos icónicos de Blue Monday) ──
-const bajo = note("d2!7 d3 d2!4 f2 f2 e2 e2")
-  .s("sawtooth").lpf(perlin.slow(4).range(500, 1200)).lpq(8)
+// ── LEAD LIMPIO (la melodía, nítida y al frente) ──
+const leadLimpio = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.58).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Dm9·Dm9·Cadd9·Am7) ──
+// voicings extendidos + voice-leading (notas comunes) = color "deep", no triada seca
+const stab = note("<[d3,f3,a3,e4] [d3,f3,a3,e4] [c3,e3,g3,d4] [a2,c3,e3,g3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(180).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.3).pan(.62).orbit(3)
+
+// ── EL BAJO SECUENCIADO (16avos de Blue Monday, AHORA sigue el acorde) ──
+// el riff icónico transpuesto a la fundamental de cada compás: D·D·C·A
+// (teoría techno nº1: el bajo sale de las fundamentales de los acordes)
+const bajo = note("<[d2!7 d3 d2!4 f2 f2 e2 e2] [d2!7 d3 d2!4 f2 f2 e2 e2] [c2!7 c3 c2!4 e2 e2 d2 d2] [a1!7 a2 a1!4 c2 c2 b1 b1]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(600, 1300)).lpq(8)
   .attack(.001).decay(.15).sustain(.3).release(.05)
-  .shape(.3).gain(.9).orbit(1)
+  .shape(.34).coarse(1).gain(.88).orbit(1)
 
-const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.2)
-  .gain(.7).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica total) ──
+const bajoSub = note("<d1 d1 c1 a0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04)
+  .gain(.72).orbit(1)
 
-// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
-  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
-  .duck("1:2").duckattack(.12).duckdepth(.7).orbit(0)
-const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y" entre kicks) ──
+const bajoOff = note("<d2 d2 c2 a1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (cuerpo) ──
+// el boom es una sine con envolvente de TONO que cae 28 semitonos en 55ms
+// = el "thump" analógico. Esto es lo que mata el sonido de sonajero.
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.32).gain(.9)
+  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kickBoom = note("<d1 d1 c1 a0>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.1).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
+const clap = s("~ cp ~ cp").bank("RolandTR909").room(.28).rsize(4).hpf(300).gain(.72).orbit(0)
+// hats con SWING + velocity humanizada (groove, no rejilla plana)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).pan(.45).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.35).orbit(0)
+// ghost snare (redoble con dinamica de velocity que sube)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
 // ── CAPA ACID (para el segundo drop) ──
-const acid = note("d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2")
+const acid = note("<[d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2] [c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [d2 eb2] c2] [a1 [~ a1] e2 [a1 a2] g2 [~ a1] [bb1 b1] a1]>")
   .s("sawtooth").ftype("ladder")
   .lpf(sine.slow(16).range(150, 2800)).lpq(sine.slow(7).range(8, 22))
   .lpenv(3).lpattack(.005).lpdecay(.12)
-  .shape(.4).gain(.75).rarely(x=>x.add(note(12)))
+  .shape(.4).gain(.72).rarely(x=>x.add(note(12)))
   .delay(.25).delaytime(.1875).delayfeedback(.35).orbit(3)
 
-// ── ATMÓSFERA / PADS ──
-const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [a2,c3,e3]>")
-  .s("sawtooth").lpf(700).attack(.8).release(1.5)
-  .room(.7).rsize(8).gain(.4).orbit(4)
-
+// ── ATMÓSFERA / PADS (2 capas + separacion de frecuencias) ──
+// pad cálido grave (hi-pass a 150 para dejar el sub-bajo libre)
+const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3] [a2,c3,e3,g3]>")
+  .s("sawtooth").lpf(sine.slow(24).range(500,1100)).lpq(3)
+  .hpf(150).attack(.8).release(1.5)
+  .room(.7).rsize(8).gain(.36).orbit(4)
+// capa de AIRE: supersaw ancho, muy reverberado, arriba (profundidad estéreo)
+const aire = note("<d5 d5 c5 a4>").s("supersaw").unison(5).spread(.8)
+  .lpf(sine.slow(32).range(600,2600)).hpf(400).attack(1.2).release(2)
+  .room(.85).rsize(9).gain(.2).pan(sine.slow(12).range(.2,.8)).orbit(4)
 const cuerdas = note("<d4 d4 c4 a3>").s("supersaw").unison(5).spread(.7)
-  .lpf(sine.slow(32).range(400,2200)).attack(.5).release(.8)
-  .room(.6).gain(.35).orbit(4)
+  .lpf(sine.slow(32).range(400,2200)).hpf(200).attack(.5).release(.8)
+  .room(.6).gain(.32).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.5).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
-const intro = stack(kick, hats, bajoSub.gain(.4))
-const introB = stack(kick, hats, hatsOpen, clap.gain(.4), bajo.lpf(400).gain(.6))
-const build = stack(kick, hats16, clap, bajo, pad,
+const intro = stack(kickBoom.gain(.9), hats, bajoSub.gain(.4), pad.gain(.25))
+const introB = stack(kick, hats, hatsOpen, clap.gain(.4), bajo.lpf(500).gain(.6), pad.gain(.3))
+const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, pad,
   hook.lpf(saw.slow(16).range(300,1800)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, hook.gain(.65))
-const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, hook, hookOctava)
-const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride,
-  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, cuerdas)
-const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.8),
-  hats.gain(.3), bajoSub.gain(.3))
-const breakBuild = stack(pad, cuerdas, hook, rodillo, hats16.gain(.4))
-const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub, hook.gain(.6))
-const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, ride, acid,
-  bajoSub, hook, hookOctava, cuerdas.gain(.25))
-const coda = stack(kick, hats, bajo.lpf(600).gain(.7), hook.gain(.45).room(.7), pad)
-const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.9).delayfeedback(.7), pad.gain(.3))
+const buildFin = stack(kickHard, rodillo, riser, bajo, bajoSub, hook.gain(.65), leadLimpio.gain(.5), stab)
+const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajo, bajoSub, hook, hookOctava, leadLimpio, stab, pad.gain(.28))
+const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ghost, ride,
+  bajo, bajoSub, bajoOff, hook, hookOctava, cuerdas, leadLimpio, stab, contra, aire)
+const breakdown = stack(pad, aire, cuerdas, hook.gain(.6).room(.8),
+  hats.gain(.3), bajoSub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, cuerdas, riser, hook, rodillo, hats16.gain(.4), leadLimpio.gain(.5))
+const dropAcid = stack(kickHard, hats16, hatsOpen, clap, ghost, acid, bajoSub, hook.gain(.6), leadLimpio, stab)
+const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, ghost, ride, acid,
+  bajoSub, bajoOff, hook, hookOctava, cuerdas.gain(.25), leadLimpio, stab, contra, aire)
+const coda = stack(kick, hats, bajo.lpf(600).gain(.7), bajoSub.gain(.5), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4))
+const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.9).delayfeedback(.7), pad.gain(.3), aire.gain(.25))
 
 // ── ARREGLO (144 compases) ──
 arrange(
@@ -92,14 +146,17 @@ arrange(
   [16, dropAvar],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "02 · take on me hard trance — a-ha (1985)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 02 · TAKE ON ME HARD TRANCE — a-ha (1985) → Hard Trance Techno Remix
-// 140 BPM · F#m/A · TR-909 · supersaw masivo + rodillos largos + break de piano
+// 140 BPM · F#m (F#m·D·A·E) · TR-909 · supersaw masivo + rodillos largos + break de piano
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→build→drop A→break piano→drop B→coda (140 compases ≈ 4:00)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -122,27 +179,61 @@ const riffPiano = melodia.slow(2).add(note(-12)).s("piano")
   .room(.85).rsize(8).delay(.45).delaytime(.375).delayfeedback(.5)
   .gain(.8).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[fs5 fs5 d5 b4 ~ b4 ~ e5 ~ e5 ~ e5 gs5 gs5 a5 b5] [a5 a5 a5 e5 ~ d5 ~ fs5 ~ fs5 ~ fs5 e5 e5 fs5 e5]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (F#m·D·A·E) + contramelodía ──
+const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,e4] [a3,cs4,e4,b4] [e3,gs3,b3,ds4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO ROLLING (16avos en fs; en el drop B sigue F#m→D→A→E) ──
 const bajo = note("fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs2")
-  .s("sawtooth").lpf(perlin.slow(5).range(420, 1100)).lpq(7)
+  .s("sawtooth").lpf(perlin.slow(5).range(420, 1100)).lpq(8)
   .attack(.001).decay(.11).sustain(.2).release(.03)
-  .shape(.35).gain(.92).orbit(1)
+  .shape(.35).coarse(1).gain(.92).orbit(1)
 
 const bajoProg = bajo.add(note("<0 -4 3 -2>"))
 
-const sub = note("fs1*4").s("sine").decay(.28).sustain(.25).gain(.65).orbit(1)
+// SUB afinado que SIGUE la fundamental de cada compas (F#m·D·A·E)
+const sub = note("<fs1 d1 a0 e1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.68).orbit(1)
 
-// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
-  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
-  .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0)
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<fs2 d2 a1 e2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909: KICK EN 2 CAPAS (click 909 + boom afinado que sigue las raices) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.45).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
+const kickBoom = note("<fs1 d1 a0 e1>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(1.0)
+  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.55).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 // rodillo LARGO de 8 compases, marca de la casa hard trance
 const rodilloLargo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(8).range(.15, .9)).hpf(saw.slow(8).range(300, 2400))
@@ -151,27 +242,30 @@ const rodilloCorto = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.25, .95)).ply("<1 1 1 2>").orbit(0)
 
 // ── PADS ÉPICOS (F#m → D → A → E) ──
-const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
+const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,e4] [a3,cs4,e4,b4] [e3,gs3,b3,ds4]>")
   .s("sawtooth").lpf(800).attack(.7).release(1.4)
-  .room(.7).rsize(8).gain(.4).orbit(4)
+  .hpf(150).room(.7).rsize(8).gain(.4).orbit(4)
+// riser de ruido filtrado para transiciones/subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introB = stack(kick, hats, open, clap.gain(.45), bajo.lpf(420).gain(.65))
-const build = stack(kick, hats16, clap, bajo, pad,
+const build = stack(kick, hats16, clap, bajo, sub, pad, riser,
   riff.lpf(saw.slow(16).range(400, 2600)).gain(.55))
-const buildFin = stack(kickHard, rodilloLargo, bajo, riff.gain(.7))
-const dropA = stack(kickHard, hats16, open, clap, bajo, sub, riff, riffCuerpo)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, pad.gain(.3))
-const breakPiano = stack(riffPiano, pad, hats.gain(.25), sub.gain(.3))
+const buildFin = stack(kickHard, rodilloLargo, riser, ghost, bajo, sub, riff.gain(.7))
+const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, riff, riffCuerpo, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, pad.gain(.3), leadLimpio, stab, contra)
+const breakPiano = stack(riffPiano, pad, hats.gain(.25), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(riffPiano.gain(.6), pad, rodilloLargo,
   hats16.gain(.35), kick.degradeBy(.5))
-const dropB = stack(kickHard, hats16, open, clap, bajoProg, sub, riff, riffCuerpo)
-const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ride,
-  bajoProg, sub, riff, riffCuerpo, pad.gain(.35))
+const dropB = stack(kickHard, hats16, open, clap, ghost, bajoProg, sub, riff, riffCuerpo, leadLimpio, stab)
+const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ride, ghost,
+  bajoProg, sub, bajoOff, riff, riffCuerpo, pad.gain(.35), leadLimpio, stab, contra)
 const coda = stack(kick, hats, clap.gain(.4), bajo.lpf(600).gain(.7),
-  riff.gain(.4).room(.7))
+  riff.gain(.4).room(.7), leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35),
   riffPiano.gain(.5).room(.9).delayfeedback(.7), pad.gain(.3))
 
@@ -189,29 +283,38 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "03 · sweet dreams warehouse — eurythmics (1983)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 03 · SWEET DREAMS WAREHOUSE — Eurythmics (1983) → Dark Warehouse Techno Remix
-// 128 BPM · Cm · TR-808 · bajo icónico con shape + hats industriales + hpf
+// 128 BPM · Cm (Cm·Cm·Ab·G) · TR-808 · bajo icónico con shape + hats industriales + hpf
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→bajo solo→build→drop A→break→drop B→coda (140 compases ≈ 4:22)
 // ════════════════════════════════════════════════════════════════
 setcps(128/60/4)
 
 // ── EL BAJO ICÓNICO (octavas Cm; progresión Cm→Cm→Ab→G por secciones) ──
 const bajo = note("<[c2 c3 g2 ab2 c2 c3 g2 ab2]!2 [ab1 ab2 eb2 c2 ab1 ab2 eb2 c2] [g1 g2 d2 b1 g1 g2 d2 b1]>")
-  .s("sawtooth").lpf(perlin.slow(6).range(500, 950)).lpq(6)
+  .s("sawtooth").lpf(perlin.slow(6).range(500, 950)).lpq(7)
   .attack(.002).decay(.18).sustain(.35).release(.05)
-  .shape(.45).gain(.95).orbit(1)
+  .shape(.45).coarse(1).gain(.95).orbit(1)
 
+// SUB afinado que SIGUE la fundamental (Cm·Cm·Ab·G)
 const sub = note("<c1 c1 ab1 g1>").struct("x*4").s("sine")
-  .decay(.3).sustain(.2).gain(.6).orbit(1)
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1)
 
-// ── HOOK VOCAL (interpretación sintética del estribillo) ──
-const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4")
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<c2 c2 ab2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── HOOK VOCAL (melodía real: "sweet dreams are made of this / who am I to disagree") ──
+const voz = note("<[g4 g4 g4 eb4 c4 ~ ~ ~] [c4 c4 d4 eb4 c4 bb3 c4 ~]>")
   .s("sawtooth").lpf(1500).lpq(5).attack(.01).release(.2)
   .vowel("<a o e o>").room(.5).rsize(6)
   .delay(.35).delaytime(.375).delayfeedback(.45)
@@ -219,26 +322,51 @@ const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4")
 
 const vozEco = voz.off(.125, x=>x.add(note(12)).gain(.35).lpf(2400))
 
-// ── BATERÍA 808 (percusión pasada por hpf, carácter industrial) ──
-const kick = s("bd bd bd <bd [bd bd]>").bank("RolandTR808").shape(.5).gain(1.05)
+// ── LEAD LIMPIO (la misma melodía real, nítida y al frente) ──
+const leadLimpio = note("<[g4 g4 g4 eb4 c4 ~ ~ ~] [c4 c4 d4 eb4 c4 bb3 c4 ~]>")
+  .s("triangle").lpf(5200).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (Cm·Ab·G) + contramelodía de respuesta ──
+const stab = note("<[c3,eb3,g3,bb3]!2 [ab2,c3,eb3,g3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BATERÍA 808: KICK EN 2 CAPAS (click 808 + boom afinado que sigue las raices) ──
+const kickClick = s("bd bd bd <bd [bd bd]>").bank("RolandTR808").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd bd bd <bd [bd bd]>").bank("RolandTR808")
-  .shape(.6).distort(1.1).gain(1.1)
+const kickBoom = note("<c1 c1 ab1 g1>").struct("x x x <x [x x]>").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickHardClick = s("bd bd bd <bd [bd bd]>").bank("RolandTR808").hpf(38).shape(.6).distort(1.1).gain(1.0)
   .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR808").hpf(500).room(.3).gain(.7).orbit(0)
-const hats = s("hh*8").bank("RolandTR808").hpf(6000).gain("[.5 .28]*4")
+const hats = s("hh*8").bank("RolandTR808").hpf(6000).swingBy(1/24,8).gain("[.5 .28]*4")
   .pan(sine.slow(5).range(.35,.65)).orbit(0)
 const industria = s("metal*8").n(irand(8)).hpf(2800).crush(8)
   .gain("[.3 .12 .2 .12]*2").pan(rand.range(.25,.75)).orbit(0)
 const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.55)
-  .hpf(400).gain(.28).orbit(0)
+  .hpf(400).gain(rand.range(.1,.28)).orbit(0)
 const tomsBuild = s("lt lt mt lt ht mt lt mt").bank("RolandTR808")
   .gain(saw.slow(4).range(.3, .75)).speed(saw.slow(4).range(1, 1.3)).orbit(0)
 const riser = s("white").clip(1).hpf(saw.slow(8).range(300, 5000))
   .gain(saw.slow(8).range(.05, .3)).room(.5).orbit(3)
 
 // ── PADS MENORES TENSOS ──
-const pad = note("<[c3,eb3,g3]!2 [ab2,c3,eb3] [g2,b2,d3]>")
+const pad = note("<[c3,eb3,g3,bb3]!2 [ab2,c3,eb3,g3] [g2,b2,d3,f3]>")
   .s("sawtooth").lpf(sine.slow(24).range(400, 900)).attack(.9).release(1.6)
   .hpf(150).room(.7).rsize(8).gain(.4).orbit(4)
 
@@ -252,18 +380,18 @@ const introB = stack(kick, hats, ghost, clap.gain(.4), sub)
 const bajoSolo = stack(kick, hats, clap, bajo, ghost)
 const build = stack(kick, hats, industria.gain(.2), clap, bajo, pad, riser,
   voz.lpf(saw.slow(8).range(300, 1600)).gain(.5))
-const dropA = stack(kickHard, hats, industria, clap, bajo, sub, voz)
-const dropAvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub,
-  vozEco, cuerdas)
+const dropA = stack(kickHard, hats, industria, clap, ghost, bajo, sub, voz, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, bajoOff,
+  vozEco, cuerdas, leadLimpio, stab, contra)
 const breakdown = stack(pad, cuerdas, voz.gain(.55).room(.8),
-  hats.gain(.25), sub.gain(.3))
+  hats.gain(.25), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, cuerdas, voz.gain(.65), tomsBuild, riser,
   hats.gain(.35))
 const dropB = stack(kickHard, hats, industria, clap, ghost,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.55)), sub, vozEco)
-const dropBvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub,
-  vozEco, cuerdas, pad.gain(.28))
-const punchFinal = stack(kickHard, hats, clap, bajo, sub, voz.gain(.6))
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.55)), sub, vozEco, leadLimpio, stab)
+const dropBvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub, bajoOff,
+  vozEco, cuerdas, pad.gain(.28), leadLimpio, stab, contra)
+const punchFinal = stack(kickHard, hats, clap, bajo, sub, voz.gain(.6), leadLimpio, stab)
 const coda = stack(kick, hats.gain(.35), bajo.lpf(550).gain(.7),
   voz.gain(.4).room(.7), pad)
 const codaFin = stack(hats.gain(.25), voz.gain(.3).room(.9).delayfeedback(.7),
@@ -284,14 +412,17 @@ arrange(
   [8,  punchFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "04 · billie jean tech house — michael jackson (1983)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 04 · BILLIE JEAN TECH HOUSE — Michael Jackson (1983) → Tech House Remix
-// 126 BPM · F#m · LinnDrum · groove shuffleado + stabs F#m-B + bajo sine+saw
+// 126 BPM · F#m (F#m·F#m·Bm·C#m) · LinnDrum · groove shuffleado + stabs F#m-B + bajo sine+saw
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→groove→build→drop A→break→drop B→coda (136 compases ≈ 4:19)
 // ════════════════════════════════════════════════════════════════
 setcps(126/60/4)
@@ -304,6 +435,17 @@ const bajoSaw = note(linea).swingBy(1/6, 8).s("sawtooth")
   .lpf(650).lpq(4).attack(.002).decay(.15).sustain(.3).release(.05)
   .shape(.2).gain(.55).orbit(1)
 const bajo = stack(bajoSine, bajoSaw)
+// variante por compas transpuesta a la raiz de cada acorde (F#m·F#m·Bm·C#m)
+const bajoProg = bajo.add(note("<0 0 5 -5>"))
+
+// SUB afinado que SIGUE la fundamental (coherencia armonica total)
+const bajoSub = note("<fs1 fs1 b0 cs1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.68).orbit(1)
+
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<fs2 fs2 b1 cs2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── CONTRAMELODÍA DE STRINGS (interpretación) ──
 const cuerdas = note("cs5 ~ b4 ~ a4 ~ gs4 fs4")
@@ -314,17 +456,33 @@ const cuerdas = note("cs5 ~ b4 ~ a4 ~ gs4 fs4")
 
 const cuerdasAlto = cuerdas.add(note(12)).gain(.3).lpf(3000).orbit(2)
 
+// ── VOZ PRINCIPAL (el estribillo real: "Billie Jean is not my lover…") ──
+const voz = note("<[cs5 cs5 cs5 cs5 d5 cs5 b4 ~] [a4 ~ fs4 a4 b4 a4 fs4 ~]>")
+  .s("triangle").lpf(4800).lpq(1)
+  .attack(.005).decay(.18).sustain(.5).release(.15)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.66).pan(.5).orbit(2)
+
 // ── STABS DE ACORDE (F#m alternando con B, muy tech house) ──
-const stabs = note("~ [fs3,a3,cs4] ~ <[fs3,a3,cs4] [b3,ds4,fs4]>")
+const stabs = note("~ [fs3,a3,cs4,e4] ~ <[fs3,a3,cs4,e4] [b3,ds4,fs4,cs5]>")
   .s("sawtooth").lpf(1900).lpq(6)
   .attack(.004).decay(.13).sustain(0).release(.08)
-  .phaser(.6).phaserdepth(.5).room(.35)
-  .gain(.7).orbit(3)
+  .phaser(.6).phaserdepth(.5).hpf(160).room(.35)
+  .gain(.68).orbit(3)
 
-// ── BATERÍA LINNDRUM (crujiente, todo shuffleado) ──
-const kick = s("bd*4").bank("LinnDrum").shape(.3).gain(1.05)
-  .duck("1:3").duckattack(.1).duckdepth(.5).orbit(0)
+// ── BATERÍA LINNDRUM: KICK EN 2 CAPAS (click + boom afinado que sigue las raices) ──
+const kickClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.4).gain(.95)
+  .duck("1:3").duckattack(.11).duckdepth(.5).orbit(0)
+const kickBoom = note("<fs1 fs1 b0 cs1>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.0).orbit(0)
+const kickHardClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.55).distort(1.05).gain(1.0)
+  .duck("1:3").duckattack(.11).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.03))
 const clap = s("~ cp ~ cp").bank("LinnDrum").room(.25).gain(.8).orbit(0)
+const ghost = s("~ ~ [~ rim] ~ ~ ~ [rim ~] ~").bank("LinnDrum").gain(rand.range(.1,.24)).hpf(400).orbit(0)
 const snare = s("~ ~ ~ [~ sd]").bank("LinnDrum").gain(.4).orbit(0)
 const hats = s("hh*8").bank("LinnDrum").swingBy(1/6, 8)
   .gain("[.55 .3]*4").pan(.6).orbit(0)
@@ -337,27 +495,30 @@ const rodillo = s("sd*16").bank("LinnDrum")
   .gain(saw.slow(4).range(.2, .8)).speed(saw.slow(4).range(1, 1.35)).orbit(0)
 
 // ── PAD SUAVE DE FONDO ──
-const pad = note("<[fs3,a3,cs4] [fs3,a3,cs4] [b2,d3,fs3] [cs3,e3,gs3]>")
+const pad = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [b2,d3,fs3,a3] [cs3,e3,gs3,b3]>")
   .s("sawtooth").lpf(750).attack(.8).release(1.4)
-  .room(.6).rsize(7).gain(.35).orbit(4)
+  .hpf(150).room(.6).rsize(7).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones/subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, rimGhost)
 const introB = stack(kick, hats, open, clap.gain(.5), bajoSine.gain(.5))
 const grooveA = stack(kick, hats, open, clap, rimGhost, bajo)
-const build = stack(kick, hats16, clap, rimGhost, bajo, stabs, pad,
-  cuerdas.lpf(saw.slow(8).range(400, 2000)).gain(.45))
-const dropA = stack(kick, hats, open, clap, snare, rimGhost, bajo, stabs, cuerdas)
-const dropAvar = stack(kick, hats16, open, clap, snare, bajo, stabs,
-  cuerdas, cuerdasAlto)
+const build = stack(kick, hats16, clap, rimGhost, bajo, bajoSub, stabs, pad, riser,
+  cuerdas.lpf(saw.slow(8).range(400, 2000)).gain(.45), voz.gain(.5))
+const dropA = stack(kickHard, hats, open, clap, snare, rimGhost, ghost, bajo, bajoSub, stabs, cuerdas, voz)
+const dropAvar = stack(kickHard, hats16, open, clap, snare, ghost, bajo, bajoSub, bajoOff, stabs,
+  cuerdas, cuerdasAlto, voz)
 const breakdown = stack(pad, cuerdas.gain(.55).room(.75),
-  bajoSine.gain(.45), hats.gain(.3), rimGhost.gain(.2))
-const breakBuild = stack(pad, cuerdas.gain(.65), bajo, rodillo, hats16.gain(.3))
-const dropB = stack(kick, hats, open, clap, snare, rimGhost,
-  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), stabs, cuerdas)
-const dropBvar = stack(kick, hats16, open, clap, snare, bajo,
-  stabs.every(4, x=>x.iter(4)), cuerdas, cuerdasAlto, pad.gain(.25))
-const coda = stack(kick, hats, clap.gain(.5), bajo, cuerdas.gain(.4).room(.7))
+  bajoSine.gain(.45), hats.gain(.3), rimGhost.gain(.2), voz.gain(.5).room(.6))
+const breakBuild = stack(pad, cuerdas.gain(.65), bajo, rodillo, riser, hats16.gain(.3))
+const dropB = stack(kickHard, hats, open, clap, snare, rimGhost, ghost,
+  bajoProg.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff, stabs, cuerdas, voz)
+const dropBvar = stack(kickHard, hats16, open, clap, snare, ghost, bajoProg, bajoSub, bajoOff,
+  stabs.every(4, x=>x.iter(4)), cuerdas, cuerdasAlto, pad.gain(.25), voz)
+const coda = stack(kick, hats, clap.gain(.5), bajo, cuerdas.gain(.4).room(.7), voz.gain(.45))
 const codaFin = stack(hats.gain(.3), bajoSine.gain(.4),
   cuerdas.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3))
 
@@ -375,20 +536,23 @@ arrange(
   [16, dropBvar],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "05 · just can't get enough acid — depeche mode (1981)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 05 · JUST CAN'T GET ENOUGH ACID — Depeche Mode (1981) → Acid Techno Remix
-// 135 BPM · G · TR-606 + 303 · línea acid protagonista + hook cuadrado naïf
+// 135 BPM · G (G·G·C·D) · TR-606 + 303 · línea acid protagonista + hook cuadrado naïf
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · acid/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→acid solo→build→drop A→break→drop B→acid final→coda (144 compases ≈ 4:16)
 // ════════════════════════════════════════════════════════════════
 setcps(135/60/4)
 
 // ── EL HOOK (interpretación: frase y respuesta alternadas, sinte naïf) ──
-const hook = note("<[g4 b4 d5 b4 e5 d5 b4 g4] [c5 e5 g5 e5 d5 b4 a4 g4]>")
+const hook = note("<[d5 ~ d5 d5 e5 d5 b4 ~ g4 ~ b4 d5 e5 d5 b4 ~] [d5 ~ d5 d5 e5 d5 b4 ~ a4 ~ b4 d5 e5 d5 ~ ~]>")
   .s("square").lpf(2300).lpq(3)
   .attack(.004).decay(.14).sustain(.15).release(.08)
   .room(.35).rsize(4).delay(.3).delaytime(.375).delayfeedback(.35)
@@ -396,8 +560,29 @@ const hook = note("<[g4 b4 d5 b4 e5 d5 b4 g4] [c5 e5 g5 e5 d5 b4 a4 g4]>")
 
 const hookOctava = hook.add(note(12)).gain(.3).lpf(3600).orbit(2)
 
+// ── LEAD LIMPIO (la misma frase vocal, nítida y al frente) ──
+const leadLimpio = note("<[d5 ~ d5 d5 e5 d5 b4 ~ g4 ~ b4 d5 e5 d5 b4 ~] [d5 ~ d5 d5 e5 d5 b4 ~ a4 ~ b4 d5 e5 d5 ~ ~]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (G·C·D) + contramelodía ──
+const stab = note("<[g2,b2,d3,a3] [g2,b2,d3,a3] [c3,e3,g3,d4] [d3,fs3,a3,c4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("2:3").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ d4 ~ b3 ~ g3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ c4 ~ g3 ~] [~ ~ fs4 ~ d4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── LA 303 (protagonista absoluta: lpf modulado lento + lpq alto) ──
-const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1")
+// el riff acid transpuesto a la fundamental de cada compas (G·G·C·D)
+const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1").add(note("<0 0 5 7>"))
   .s("sawtooth").ftype("ladder")
   .lpf(sine.slow(24).range(140, 3200)).lpq(sine.slow(9).range(10, 24))
   .lpenv(4).lpattack(.003).lpdecay(.14)
@@ -407,46 +592,62 @@ const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1")
 const acidFuria = acid.lpf(sine.slow(6).range(300, 3600))
   .lpq(sine.slow(3).range(14, 26)).sometimesBy(.3, x=>x.ply(2))
 
-// ── SUB DE APOYO ──
-const sub = note("g1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)
+// ── SUB DE APOYO (afinado, SIGUE la fundamental G·G·C·D) ──
+const sub = note("<g1 g1 c1 d1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1)
 
-// ── BATERÍA 606 (seca, sin room, puro garaje) ──
-const kick = s("bd*4").bank("RolandTR606").shape(.45).gain(1.1)
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<g2 g2 c2 d2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 606: KICK EN 2 CAPAS (click 606 + boom afinado que sigue las raices) ──
+const kickClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.45).gain(1.0)
   .duck("2:3").duckattack(.09).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR606").shape(.6).distort(1.1).gain(1.1)
+const kickBoom = note("<g1 g1 c1 d1>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.6).distort(1.1).gain(1.05)
   .duck("2:3").duckattack(.09).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const snare = s("~ sd ~ sd").bank("RolandTR606").gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR606").gain(.55).pan(.58).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR606")
-  .gain("[.5 .2 .3 .2]*4").pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR606").gain(.45).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR606").swingBy(1/24,8).gain(.55).pan(.58).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR606").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR606").nudge(.004).gain(.45).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR606").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR606")
   .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.5)).orbit(0)
 
 // ── PAD MÍNIMO (solo para el break) ──
-const pad = note("<[g2,b2,d3] [g2,b2,d3] [c3,e3,g3] [d3,fs3,a3]>")
+const pad = note("<[g2,b2,d3,a3] [g2,b2,d3,a3] [c3,e3,g3,d4] [d3,fs3,a3,c4]>")
   .s("sawtooth").lpf(700).attack(.8).release(1.5)
-  .room(.65).rsize(7).gain(.35).orbit(4)
+  .hpf(150).room(.65).rsize(7).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones/subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introB = stack(kick, hats, open, snare.gain(.4), sub)
 const acidSolo = stack(kick, hats, snare, acid.gain(.65), sub.gain(.4))
-const build = stack(kick, hats16, snare, acid, sub, pad.gain(.25),
-  hook.lpf(saw.slow(8).range(400, 2400)).gain(.5))
-const dropA = stack(kickHard, hats16, open, snare, acid, sub, hook)
-const dropAvar = stack(kickHard, hats16, open, snare, acid, sub,
-  hook, hookOctava)
+const build = stack(kick, hats16, snare, ghost, acid, sub, pad.gain(.25), riser,
+  hook.lpf(saw.slow(8).range(400, 2400)).gain(.5), leadLimpio.gain(.5), stab)
+const dropA = stack(kickHard, hats16, open, snare, ghost, acid, sub, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, snare, ghost, acid, sub, bajoOff,
+  hook, hookOctava, leadLimpio, stab, contra)
 const breakdown = stack(pad, hook.gain(.55).room(.7).delayfeedback(.55),
-  hats.gain(.3), acid.gain(.4).lpf(500))
-const breakBuild = stack(pad, hook.gain(.65), rodillo, hats16.gain(.35),
+  hats.gain(.3), acid.gain(.4).lpf(500), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, hook.gain(.65), rodillo, riser, hats16.gain(.35),
   acid.gain(.6))
-const dropB = stack(kickHard, hats16, open, snare, acidFuria, sub, hook)
-const dropBvar = stack(kickHard, hats16, open, snare, acidFuria, sub,
-  hook.every(4, x=>x.rev()), hookOctava)
+const dropB = stack(kickHard, hats16, open, snare, ghost, acidFuria, sub, hook, leadLimpio, stab)
+const dropBvar = stack(kickHard, hats16, open, snare, ghost, acidFuria, sub, bajoOff,
+  hook.every(4, x=>x.rev()), hookOctava, leadLimpio, stab, contra)
 const acidFinal = stack(kickHard, hats, snare, acidFuria, sub)
 const coda = stack(kick, hats, snare.gain(.4), acid.gain(.55).lpf(800),
-  hook.gain(.45).room(.6), sub.gain(.4))
+  hook.gain(.45).room(.6), sub.gain(.4), leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), hook.gain(.3).room(.85).delayfeedback(.65),
   pad.gain(.3))
 
@@ -465,14 +666,17 @@ arrange(
   [8,  acidFinal],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "06 · tainted love ebm — soft cell (1981)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 06 · TAINTED LOVE EBM — Soft Cell (1981) → EBM / Electro Techno Remix
-// 130 BPM · Dm · TR-808 · bajo EBM distorsionado + "ding ding" + coros vowel
+// 130 BPM · Dm (Dm·Dm·Bb·A) · TR-808 · bajo EBM distorsionado + "ding ding" + coros vowel
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→ding→build→drop A→break coros→drop B→coda (140 compases ≈ 4:18)
 // ════════════════════════════════════════════════════════════════
 setcps(130/60/4)
@@ -497,6 +701,20 @@ const voz = note("d4 f4 d4 c4 a3 c4 d4 ~")
 
 const vozOctava = voz.add(note(12)).gain(.3).orbit(2)
 
+// ── LEAD LIMPIO (la voz una octava arriba, nítida y al frente) ──
+const leadLimpio = note("d5 f5 d5 c5 a4 c5 d5 ~")
+  .s("triangle").lpf(4800).lpq(1)
+  .attack(.005).decay(.18).sustain(.5).release(.15)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.22)
+  .gain(.58).pan(.5).orbit(2)
+
+// ── PAD CÁLIDO (colchón Dm·Bb·A que llena la zona media) ──
+const padCalido = note("<[d3,f3,a3,c4]!2 [bb2,d3,f3,a3] [a2,cs3,e3,g3]>")
+  .s("sawtooth").lpf(sine.slow(24).range(500, 1100)).lpq(3)
+  .attack(.7).release(1.4).shape(.15).hpf(150)
+  .room(.55).rsize(7).gain(.34).pan(.45)
+  .duck("1:2").duckdepth(.35).orbit(4)
+
 // ── BAJO EBM (16avos machacones con distorsión) ──
 const bajo = note("[d2 d2 d3 d2]*4").s("sawtooth")
   .lpf(750).lpq(7).attack(.001).decay(.1).sustain(.25).release(.03)
@@ -507,18 +725,32 @@ const bajoProg = note("<[d2 d2 d3 d2]!2 [bb1 bb1 bb2 bb1] [a1 a1 a2 a1]>*4")
   .attack(.001).decay(.1).sustain(.25).release(.03)
   .shape(.5).distort(1.05).gain(.8).orbit(1)
 
-const sub = note("d1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)
+// SUB afinado que SIGUE la fundamental (Dm·Dm·Bb·A)
+const sub = note("<d1 d1 bb0 a0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1)
 
-// ── BATERÍA 808 (snare seca, marcial) ──
-const kick = s("bd*4").bank("RolandTR808").shape(.5).gain(1.05)
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<d2 d2 bb1 a1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 808: KICK EN 2 CAPAS (click 808 + boom afinado que sigue las raices) ──
+const kickClick = s("bd*4").bank("RolandTR808").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kickVar = s("bd bd bd [bd bd]").bank("RolandTR808")
-  .shape(.6).distort(1.05).gain(1.1)
+const kickBoom = note("<d1 d1 bb0 a0>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickVarClick = s("bd bd bd [bd bd]").bank("RolandTR808").hpf(38)
+  .shape(.6).distort(1.05).gain(1.0)
   .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickVar = stack(kickVarClick, kickBoom.gain(1.05))
 const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.85).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR808")
-  .gain("[.45 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR808").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR808").swingBy(1/24,16)
+  .gain(perlin.range(.2,.48)).pan(rand.range(.4,.6)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rimInd = s("rim*8").bank("RolandTR808").crush(6)
   .gain("[.35 .18]*4").hpf(900).pan(.35).orbit(0)
 const tomsFill = s("~ ~ ~ [lt mt ht mt]").bank("RolandTR808")
@@ -527,31 +759,34 @@ const rodillo = s("sd*16").bank("RolandTR808")
   .gain(saw.slow(4).range(.2, .9)).speed(saw.slow(4).range(1, 1.4)).orbit(0)
 
 // ── COROS SINTÉTICOS (Dm → Bb → A con formantes) ──
-const coros = note("<[d3,f3,a3]!2 [bb2,d3,f3] [a2,cs3,e3]>")
-  .s("sawtooth").vowel("o").lpf(1200)
+const coros = note("<[d3,f3,a3,c4]!2 [bb2,d3,f3,a3] [a2,cs3,e3,g3]>")
+  .s("sawtooth").vowel("o").lpf(1200).hpf(150)
   .attack(.6).release(1.2).room(.65).rsize(7)
   .gain(.45).orbit(4)
+// riser de ruido filtrado para transiciones/subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introDing = stack(kick, hats, snare.gain(.4), ding, sub)
-const build = stack(kick, hats16, snare, bajo, ding, coros.gain(.3),
-  voz.lpf(saw.slow(8).range(400, 1900)).gain(.5))
-const buildFin = stack(kickVar, rodillo, bajo, ding, voz.gain(.65))
-const dropA = stack(kickVar, hats16, snare, rimInd, bajo, sub, ding, voz)
-const dropAvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajo, sub,
-  ding, dingRespuesta, voz, vozOctava)
+const build = stack(kick, hats16, snare, ghost, bajo, sub, ding, coros.gain(.3), riser,
+  voz.lpf(saw.slow(8).range(400, 1900)).gain(.5), leadLimpio.gain(.5), padCalido.gain(.25))
+const buildFin = stack(kickVar, rodillo, riser, ghost, bajo, sub, ding, voz.gain(.65), leadLimpio.gain(.55))
+const dropA = stack(kickVar, hats16, snare, rimInd, ghost, bajo, sub, ding, voz, leadLimpio, padCalido)
+const dropAvar = stack(kickVar, hats16, snare, rimInd, tomsFill, ghost, bajo, sub, bajoOff,
+  ding, dingRespuesta, voz, vozOctava, leadLimpio, padCalido)
 const breakCoros = stack(coros, voz.gain(.55).room(.75), ding.gain(.5),
-  hats.gain(.25), sub.gain(.3))
+  hats.gain(.25), sub.gain(.3), leadLimpio.gain(.45).room(.7))
 const breakBuild = stack(coros, voz.gain(.65), rodillo, hats16.gain(.3),
   ding.gain(.6))
-const dropB = stack(kickVar, hats16, snare, rimInd, bajoProg, sub, ding,
-  voz, coros.gain(.3))
-const dropBvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajoProg, sub,
-  ding, dingRespuesta, voz, vozOctava, coros.gain(.35))
-const marcha = stack(kick, hats, snare, bajo, sub, ding.gain(.6), voz.gain(.6))
+const dropB = stack(kickVar, hats16, snare, rimInd, ghost, bajoProg, sub, ding,
+  voz, coros.gain(.3), leadLimpio, padCalido.gain(.28))
+const dropBvar = stack(kickVar, hats16, snare, rimInd, tomsFill, ghost, bajoProg, sub, bajoOff,
+  ding, dingRespuesta, voz, vozOctava, coros.gain(.35), leadLimpio, padCalido.gain(.3))
+const marcha = stack(kick, hats, snare, bajo, sub, ding.gain(.6), voz.gain(.6), leadLimpio.gain(.5))
 const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.6),
-  voz.gain(.45).room(.7), coros.gain(.35))
+  voz.gain(.45).room(.7), coros.gain(.35), leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), ding.gain(.4).delayfeedback(.7),
   coros.gain(.3))
 
@@ -570,14 +805,17 @@ arrange(
   [8,  marcha],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "07 · axel f detroit — harold faltermeyer (1984)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 07 · AXEL F DETROIT — Harold Faltermeyer (1984) → Detroit Techno Remix
-// 128 BPM · Fm · TR-909 · chords stab Fm7 en offbeat + hats rápidos + bajo walking
+// 128 BPM · Fm (Fm·Fm·Db·Eb) · TR-909 · chords stab Fm7 en offbeat + hats rápidos + bajo walking
+// PRO: kick 2 capas (click+boom afinado que sigue las raices) · bajo/sub siguen acordes
+// bajo offbeat · groove swing+ghost+velocity · 7as/9as+hpf · caracter duro peak-time · riser
 // Estructura: intro→stabs→build→drop A→break→drop B→drop C→coda (144 compases ≈ 4:30)
 // ════════════════════════════════════════════════════════════════
 setcps(128/60/4)
@@ -593,45 +831,86 @@ const lead = melodia.s("sawtooth").lpf(2000).lpq(5)
 const leadOctava = melodia.add(note(12)).s("square")
   .lpf(3400).attack(.004).release(.1).gain(.3).pan(.65).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[f4 ~ ~ ab4 ~ ~ f4 ~ f4 bb4 ~ f4 ~ eb4 ~ ~] [f4 ~ ~ c5 ~ ~ f4 ~ f4 db5 ~ c5 ~ ab4 ~ ~] [f4 c5 ~ f5 ~ f4 eb4 ~ eb4 c4 ~ g4 f4 ~ ~ ~]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (Fm·Db·Eb) + contramelodía ──
+// (se llama stabArm porque ya existe un const stab de chords Detroit)
+const stabArm = note("<[f3,ab3,c4,eb4] [f3,ab3,c4,eb4] [db3,f3,ab3,c4] [eb3,g3,bb3,db4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ ab4 ~ f4 ~ db4 ~] [~ ~ bb4 ~ g4 ~ eb4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── CHORDS STAB DETROIT (Fm7 en offbeat, con phaser) ──
 const stab = note("~ [f3,ab3,c4,eb4] ~ [f3,ab3,c4,eb4]")
   .s("sawtooth").lpf(2100).lpq(5)
   .attack(.003).decay(.15).sustain(0).release(.1)
-  .phaser(2).phaserdepth(.6).room(.4).rsize(5)
+  .phaser(2).phaserdepth(.6).hpf(160).room(.4).rsize(5)
   .gain(.7).orbit(3)
 
 const stabVar = note("~ [f3,ab3,c4,eb4] ~ <[f3,ab3,c4,eb4] [ab3,c4,eb4,g4]>")
   .s("sawtooth").lpf(2400).lpq(5)
   .attack(.003).decay(.15).sustain(0).release(.1)
-  .phaser(2).phaserdepth(.6).room(.4).rsize(5)
+  .phaser(2).phaserdepth(.6).hpf(160).room(.4).rsize(5)
   .gain(.7).every(4, x=>x.iter(4)).orbit(3)
 
 // ── BAJO WALKING (corcheas que caminan por Fm) ──
 const bajo = note("f1 f2 eb2 c2 f1 ab1 bb1 c2")
-  .s("sawtooth").lpf(perlin.slow(5).range(450, 900)).lpq(5)
+  .s("sawtooth").lpf(perlin.slow(5).range(450, 900)).lpq(6)
   .attack(.002).decay(.16).sustain(.3).release(.05)
-  .shape(.3).gain(.9).orbit(1)
+  .shape(.3).coarse(1).gain(.9).orbit(1)
 
-const sub = note("f1*4").s("sine").decay(.28).sustain(.2).gain(.6).orbit(1)
+// el walking transpuesto a la fundamental de cada compas (Fm·Fm·Db·Eb)
+const bajoProg = bajo.add(note("<0 0 -4 -2>"))
 
-// ── BATERÍA 909 (hats rápidos, ride Detroit) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// SUB afinado que SIGUE la fundamental (Fm·Fm·Db·Eb)
+const sub = note("<f1 f1 db1 eb1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
+
+// BAJO OFFBEAT (rompe el 4x4, pulsa en las "y")
+const bajoOff = note("<f2 f2 db2 eb2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909: KICK EN 2 CAPAS (click 909 + boom afinado que sigue las raices) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.4).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.05).gain(1.1)
+const kickBoom = note("<f1 f1 db1 eb1>").struct("x*4").s("sine")
+  .penv(28).pattack(.001).pdecay(.055).pcurve(0)
+  .attack(.001).decay(.32).sustain(0).release(.04)
+  .shape(.26).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.05).gain(1.0)
   .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.4).room(.5).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.4)).orbit(0)
 
 // ── PADS / STRINGS DETROIT ──
-const pad = note("<[f3,ab3,c4] [f3,ab3,c4] [db3,f3,ab3] [eb3,g3,bb3]>")
+const pad = note("<[f3,ab3,c4,eb4] [f3,ab3,c4,eb4] [db3,f3,ab3,c4] [eb3,g3,bb3,db4]>")
   .s("sawtooth").lpf(sine.slow(24).range(450, 1000)).attack(.8).release(1.5)
-  .room(.7).rsize(8).gain(.4).orbit(4)
+  .hpf(150).room(.7).rsize(8).gain(.4).orbit(4)
+// riser de ruido filtrado para transiciones/subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 const cuerdas = note("<f4 ab4 db4 eb4>").s("supersaw").unison(5).spread(.7)
   .lpf(sine.slow(32).range(400, 2000)).attack(.5).release(.9)
@@ -640,24 +919,24 @@ const cuerdas = note("<f4 ab4 db4 eb4>").s("supersaw").unison(5).spread(.7)
 // ── SECCIONES ──
 const intro = stack(kick, hats16.gain(.25), sub.gain(.4))
 const introStabs = stack(kick, hats16.gain(.35), open, stab.gain(.5), sub)
-const build = stack(kick, hats16, clap, bajo, stab, pad.gain(.3),
+const build = stack(kick, hats16, clap, ghost, bajo, sub, stab, pad.gain(.3), riser,
   melodia.s("sawtooth").lpf(saw.slow(16).range(300, 2000)).gain(.5).orbit(2))
-const buildFin = stack(kickHard, rodillo, bajo, stab, lead.gain(.7))
-const dropA = stack(kickHard, hats16, open, clap, bajo, sub, stab, lead)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  stabVar, lead, leadOctava)
+const buildFin = stack(kickHard, rodillo, riser, ghost, bajo, sub, stab, lead.gain(.7))
+const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, stab, lead, leadLimpio, stabArm)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  stabVar, lead, leadOctava, leadLimpio, stabArm, contra)
 const breakdown = stack(pad, cuerdas, lead.gain(.55).room(.75),
-  hats16.gain(.2), sub.gain(.3))
-const breakBuild = stack(pad, cuerdas, lead.gain(.65), rodillo,
+  hats16.gain(.2), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, cuerdas, lead.gain(.65), rodillo, riser,
   hats16.gain(.3), stab.gain(.4))
-const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  stabVar, lead, leadOctava)
-const dropBFull = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
-  stabVar, lead, leadOctava, cuerdas.gain(.25))
+const dropB = stack(kickHard, hats16, open, clap, crash, ghost, bajoProg, sub,
+  stabVar, lead, leadOctava, leadLimpio, stabArm)
+const dropBFull = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajoProg, sub, bajoOff,
+  stabVar, lead, leadOctava, cuerdas.gain(.25), leadLimpio, stabArm, contra)
 const grooveOut = stack(kick, hats16, open, clap, bajo, sub, stab,
-  lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5)))
+  lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), leadLimpio, stabArm)
 const coda = stack(kick, hats16.gain(.35), bajo.lpf(550).gain(.7),
-  lead.gain(.4).room(.7), pad)
+  lead.gain(.4).room(.7), pad, leadLimpio.gain(.4))
 
 // ── ARREGLO (144 compases) ──
 arrange(
@@ -673,14 +952,16 @@ arrange(
   [16, dropBFull],
   [16, grooveOut],
   [8,  coda]
-)`,
+)
+`,
   },
   {
     name: "08 · the final countdown schranz — europe (1986)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 08 · THE FINAL COUNTDOWN SCHRANZ — Europe (1986) → Schranz / Hard Techno Remix
-// 145 BPM · F#m · TR-909 distorsionado · kick implacable + metal loops + supersaw solo en drops
+// 145 BPM · F#m (F#m·F#m·D·E) · TR-909 distorsionado · PRO: kick 2 capas +
+// boom afinado que sigue las fundamentales + reese/sub siguen acordes + groove
 // Estructura: intro→máquina→build→drop A→break→drop B→schranz total→coda (148 compases ≈ 4:05)
 // ════════════════════════════════════════════════════════════════
 setcps(145/60/4)
@@ -702,22 +983,54 @@ const riffBreak = melodia.slow(2).s("sawtooth")
   .room(.85).rsize(9).delay(.5).delaytime(.375).delayfeedback(.55)
   .gain(.7).orbit(2)
 
-// ── BAJO REESE (muro grave con detune, sostenido) ──
-const reese = note("fs1").s("supersaw").unison(3).detune(.7)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[cs5 b4 cs5 ~ fs4 ~ ~ ~] [d5 cs5 d5 cs5 b4 ~ ~ ~] [d5 cs5 d5 ~ fs4 ~ ~ ~] [b4 a4 b4 a4 gs4 fs4 gs4 ~]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (F#m7·F#m7·Dadd9·E7) + hi-pass ──
+const stab = note("<[fs2,a2,cs3,e3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(180).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJO REESE que SIGUE las fundamentales (F#·F#·D·E) ──
+const reese = note("<fs1 fs1 d1 e1>").s("supersaw").unison(3).detune(.7)
   .lpf(sine.slow(8).range(200, 600)).lpq(4)
   .attack(.01).sustain(.8).release(.2).clip(1)
-  .shape(.3).gain(.7).orbit(1)
+  .shape(.34).coarse(1).gain(.7).orbit(1)
 
-const sub = note("fs1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ──
+const sub = note("<fs1 fs1 d1 e1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA 909 DESTROZADA (kick distorsionado implacable) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<fs2 fs2 d2 e2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909 DESTROZADA: kick en 2 capas (click 909 + BOOM afinado) ──
+// el boom es una sine con envolvente de tono que sigue las fundamentales
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(1)
   .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0)
-const kickSchranz = s("bd*4").bank("RolandTR909").ply("<1 1 1 2>")
-  .shape(.7).distort(1.15).gain(1.1)
+const kickBoom = note("<fs1 fs1 d1 e1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0)
+const kickClickHard = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.15).gain(1)
   .duck("1:2").duckattack(.08).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickSchranz = stack(kickClickHard.ply("<1 1 1 2>"), kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").hpf(400).room(.25).gain(.7).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
   .gain("[.45 .2 .3 .2]*4").hpf(4000).pan(rand.range(.35,.65)).orbit(0)
 const metalLoop = s("metal*8").n(irand(8)).crush(6).hpf(2200)
   .gain("[.35 .15 .25 .15]*2").pan(rand.range(.25,.75)).orbit(0)
@@ -726,35 +1039,37 @@ const rimLoop = s("rim*16").bank("RolandTR909").crush(5).hpf(1200)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.25, .95)).speed(saw.slow(4).range(1, 1.6))
   .hpf(saw.slow(4).range(200, 1800)).orbit(0)
+// ghost snare sincopado (dinámica de velocity, entra en los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const riser = s("white").clip(1).hpf(saw.slow(8).range(400, 6000))
   .gain(saw.slow(8).range(.05, .32)).room(.4).orbit(3)
 
-// ── PAD OSCURO (solo respira en el break) ──
-const pad = note("<[fs2,a2,cs3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>")
+// ── PAD OSCURO con 7as/9as (solo respira en el break) + hi-pass ──
+const pad = note("<[fs2,a2,cs3,e3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>")
   .s("sawtooth").lpf(600).attack(1).release(1.8)
-  .room(.75).rsize(9).gain(.38).orbit(4)
+  .hpf(150).room(.75).rsize(9).gain(.38).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats16.gain(.25), sub.gain(.4))
 const maquina = stack(kick, hats16, clap.gain(.5), rimLoop.gain(.25), reese.gain(.5))
 const build = stack(kick, hats16, clap, metalLoop.gain(.2), reese, sub, riser,
   riffCuerpo.lpf(saw.slow(8).range(300, 1400)).gain(.5))
-const buildFin = stack(kickSchranz, rodillo, reese, riffCuerpo.gain(.55))
-const dropA = stack(kick, hats16, clap, metalLoop, reese, sub, riff, riffCuerpo)
-const dropAvar = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese, sub,
-  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo)
-const breakdown = stack(pad, riffBreak, hats16.gain(.15), sub.gain(.3))
+const buildFin = stack(kickSchranz, rodillo, reese, sub, riser, riffCuerpo.gain(.55))
+const dropA = stack(kick, hats16, clap, metalLoop, ghost, reese, sub, riff, riffCuerpo, leadLimpio, stab)
+const dropAvar = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, ghost, reese, sub, bajoOff,
+  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, leadLimpio, stab, contra)
+const breakdown = stack(pad, riffBreak, hats16.gain(.15), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, riffBreak.gain(.6), rodillo, riser,
   hats16.gain(.3), kick.degradeBy(.5))
-const dropB = stack(kickSchranz, hats16, clap, metalLoop, reese, sub,
-  riff, riffCuerpo)
-const dropBFull = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese,
-  sub, riff, riffCuerpo, pad.gain(.25))
-const schranzTotal = stack(kickSchranz, rimLoop, metalLoop, clap,
-  reese.lpf(sine.slow(4).range(250, 800)), sub,
-  riff.every(4, x=>x.rev()))
+const dropB = stack(kickSchranz, hats16, clap, metalLoop, ghost, reese, sub,
+  riff, riffCuerpo, leadLimpio, stab)
+const dropBFull = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, ghost, reese,
+  sub, bajoOff, riff, riffCuerpo, pad.gain(.25), leadLimpio, stab, contra)
+const schranzTotal = stack(kickSchranz, rimLoop, metalLoop, clap, ghost,
+  reese.lpf(sine.slow(4).range(250, 800)), sub, bajoOff,
+  riff.every(4, x=>x.rev()), leadLimpio, stab)
 const coda = stack(kick, hats16.gain(.3), clap.gain(.4), reese.gain(.5),
-  riffBreak.gain(.5))
+  riffBreak.gain(.5), leadLimpio.gain(.4))
 const codaFin = stack(hats16.gain(.2), riffBreak.gain(.4).delayfeedback(.7),
   pad.gain(.3))
 
@@ -773,14 +1088,16 @@ arrange(
   [16, schranzTotal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "09 · africa melodic — toto (1982)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 09 · AFRICA MELODIC — Toto (1982) → Melodic Techno Remix
-// 122 BPM · A/F#m · TR-707 · kalimba casio + toms tribales + breakdown con viento
+// 122 BPM · A/F#m (A·F#m·D·E) · TR-707 · PRO: kick 2 capas + boom afinado
+// que sigue las fundamentales + bajoSub sigue acordes + groove con swing
 // Estructura: intro→kalimba→build→drop A→break amplio→drop B→coda (136 compases ≈ 4:27)
 // ════════════════════════════════════════════════════════════════
 setcps(122/60/4)
@@ -794,6 +1111,26 @@ const hook = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~")
 
 const hookSuave = hook.lpf(1100).gain(.55).room(.8)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Aadd9·F#m7·Dadd9·E7) + hi-pass ──
+const stab = note("<[a2,cs3,e3,b3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── ARPEGIO KALIMBA (seisillos con casio, la marimba del remix) ──
 const kalimba = note("a3 cs4 e4 a4 e4 cs4").s("casio")
   .attack(.001).decay(.18).sustain(0).release(.08)
@@ -813,23 +1150,44 @@ const bajo = note("<[a1 ~ a1 [~ a1]] [fs1 ~ fs1 [~ fs1]] [d2 ~ d2 [~ d2]] [e2 ~
 
 const bajoArm = bajo.add(note(12)).s("triangle").gain(.3).lpf(900).orbit(1)
 
-// ── BATERÍA 707 (suave, con toms tribales) ──
-const kick = s("bd*4").bank("RolandTR707").shape(.3).gain(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (A·F#m·D·E) ──
+const bajoSub = note("<a1 fs1 d1 e1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.55).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<a2 fs2 d2 e2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── BATERÍA 707: kick en 2 capas (click 707 + BOOM afinado que sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR707").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0)
+const kickBoom = note("<a1 fs1 d1 e1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickClickHard = s("bd*4").bank("RolandTR707").hpf(38).shape(.6).distort(1.15).gain(.95)
+  .duck("1:2").duckattack(.13).duckdepth(.55).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickClickHard, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR707").room(.35).gain(.6).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR707").gain(.45).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR707")
+const hats = s("[~ hh]*4").bank("RolandTR707").swingBy(1/24,8).gain(.45).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR707").swingBy(1/24,16)
   .gain(rand.range(.12, .42)).pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR707").gain(.35).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR707").nudge(.004).gain(.35).orbit(0)
 const toms = s("~ mt ~ [~ lt] ~ ht ~ lt").bank("RolandTR707")
   .gain(.5).pan("<.35 .65 .5 .4>").room(.3).orbit(0)
 const tomsTribal = s("mt lt [mt mt] lt ht [~ mt] lt [ht lt]").bank("RolandTR707")
   .gain(saw.slow(4).range(.3, .7)).room(.3).orbit(0)
+// ghost snare sincopado (entra en los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR707").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PADS LARGOS Y VIENTO ──
-const pad = note("<[a2,cs3,e3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>")
+// ── PADS LARGOS con 7as/9as (hi-pass) Y VIENTO ──
+const pad = note("<[a2,cs3,e3,b3] [fs2,a2,cs3,e3] [d3,fs3,a3,e4] [e3,gs3,b3,d4]>")
   .s("sawtooth").lpf(sine.slow(32).range(500, 1300)).attack(1.2).release(2)
-  .room(.75).rsize(9).gain(.42).orbit(4)
+  .hpf(150).room(.75).rsize(9).gain(.42).orbit(4)
 
 const viento = s("wind").n(irand(4)).slow(4).clip(1)
   .gain(.3).room(.9).rsize(9).hpf(300).orbit(4)
@@ -837,22 +1195,22 @@ const viento = s("wind").n(irand(4)).slow(4).clip(1)
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajo.gain(.5))
 const introKalimba = stack(kick, hats, open, kalimba.gain(.45), bajo)
-const build = stack(kick, hats16, clap, bajo, bajoArm, kalimba, pad.gain(.3),
+const build = stack(kick, hats16, clap, ghost, bajo, bajoArm, bajoSub, kalimba, pad.gain(.3), riser,
   hook.lpf(saw.slow(16).range(300, 1700)).gain(.5))
-const buildFin = stack(kick, tomsTribal, bajo, kalimba, hook.gain(.65))
-const dropA = stack(kick, hats16, open, clap, toms, bajo, bajoArm, kalimba, hook)
-const dropAvar = stack(kick, hats16, open, clap, toms, bajo, bajoArm,
-  kalimbaVar, hook, pad.gain(.3))
+const buildFin = stack(kickHard, tomsTribal, riser, bajo, bajoSub, kalimba, hook.gain(.65))
+const dropA = stack(kick, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub, kalimba, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub, bajoOff,
+  kalimbaVar, hook, pad.gain(.3), leadLimpio, stab, contra)
 const breakAmplio = stack(pad, viento, hookSuave, kalimba.gain(.4),
-  bajo.gain(.4))
-const breakBuild = stack(pad, viento.gain(.2), hook.gain(.65), kalimba,
+  bajo.gain(.4), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, viento.gain(.2), riser, hook.gain(.65), kalimba,
   tomsTribal, hats16.gain(.3))
-const dropB = stack(kick, hats16, open, clap, toms, bajo, bajoArm,
-  kalimba, hook.sometimesBy(.25, x=>x.add(note(12)).gain(.5)))
-const dropBFull = stack(kick, hats16, open, clap, toms, tomsTribal.gain(.3),
-  bajo, bajoArm, kalimbaVar, hook, pad.gain(.35))
+const dropB = stack(kick, hats16, open, clap, toms, ghost, bajo, bajoArm, bajoSub,
+  kalimba, hook.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), leadLimpio, stab)
+const dropBFull = stack(kickHard, hats16, open, clap, toms, tomsTribal.gain(.3), ghost,
+  bajo, bajoArm, bajoSub, bajoOff, kalimbaVar, hook, pad.gain(.35), leadLimpio, stab, contra)
 const coda = stack(kick, hats, clap.gain(.4), bajo.gain(.6),
-  kalimba.gain(.45), hookSuave.gain(.4), pad)
+  kalimba.gain(.45), hookSuave.gain(.4), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.25), kalimba.gain(.35).delayfeedback(.6),
   viento, pad.gain(.3))
 
@@ -870,14 +1228,16 @@ arrange(
   [16, dropBFull],
   [4,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "10 · jump big room — van halen (1984)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 10 · JUMP BIG ROOM — Van Halen (1984) → Big Room Techno Remix
-// 132 BPM · C · TR-909 · sidechain profundo (duckdepth .8) + sub en c1 + builds con rodillo
+// 132 BPM · C (C·C·F·G) · TR-909 · PRO: kick 2 capas + sub/boom siguen los
+// acordes + bajo offbeat + groove con swing · sidechain profundo (duckdepth .8)
 // Estructura: intro→stabs→build→drop A→break→build 2→drop B→coda (144 compases ≈ 4:22)
 // ════════════════════════════════════════════════════════════════
 setcps(132/60/4)
@@ -897,24 +1257,43 @@ const stabsCuerpo = note("[g3,c4,e4] ~ [g3,c4,e4] [a3,c4,f4] ~ [g3,c4,e4] ~ [g3,
 const stabsBreak = stabs.slow(2).lpf(1000).room(.85).rsize(9)
   .delayfeedback(.55).gain(.65)
 
-// ── EL SUB POTENTE (pedal en c1) + bajo offbeat ──
-const sub = note("c1*4").s("sine").decay(.35).sustain(.35).release(.05)
-  .gain(.8).orbit(1)
+// ── LEAD LIMPIO (la melodía superior del riff, nítida y al frente) ──
+const leadLimpio = note("e5 ~ e5 f5 ~ e5 ~ d5")
+  .s("triangle").lpf(5200).lpq(1)
+  .attack(.005).decay(.2).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.6).pan(.5).orbit(2)
 
-const bajoOff = note("[~ c2]*4").s("sawtooth")
+// ── CONTRAMELODÍA (zona media, notas de C·F·G) ──
+const contra = note("<[~ ~ g4 ~ e4 ~ c4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ a4 ~ f4 ~ c4 ~] [~ ~ b4 ~ g4 ~ d4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── EL SUB que SIGUE los acordes (C·C·F·G) + bajo offbeat ──
+const sub = note("<c1 c1 f1 g1>").struct("x*4").s("sine")
+  .attack(.002).decay(.35).sustain(.35).release(.05).gain(.8).orbit(1)
+
+const bajoOff = note("<c2 c2 f2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
   .lpf(700).lpq(5).attack(.001).decay(.14).sustain(.2).release(.04)
   .shape(.3).gain(.7).orbit(1)
 
-// ── BATERÍA 909 ENORME (el kick hunde TODO con duckdepth .8) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
+// ── BATERÍA 909 ENORME: kick en 2 capas (hunde TODO con duckdepth .8) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(1)
   .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
+const kickBoom = note("<c1 c1 f1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.05).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.15).gain(1)
   .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.1))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.55).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.55).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
   .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
 const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.45).room(.5).orbit(0)
 // rodillo + hpf que sube: la rampa big room
 const rodillo = s("sd*16").bank("RolandTR909")
@@ -922,36 +1301,41 @@ const rodillo = s("sd*16").bank("RolandTR909")
   .hpf(saw.slow(8).range(150, 2500)).orbit(0)
 const rodilloCorto = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.3, .95)).ply("<1 1 2 2>").orbit(0)
+// ghost snare sincopado (entra en los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD ESTADIO ──
-const pad = note("<[c3,e3,g3] [c3,e3,g3] [f3,a3,c4] [g3,b3,d4]>")
+// ── PAD ESTADIO con 7as/9as (hi-pass) ──
+const pad = note("<[c3,e3,g3,d4] [c3,e3,g3,d4] [f3,a3,c4,e4] [g3,b3,d4,f4]>")
   .s("supersaw").unison(5).spread(.7)
   .lpf(sine.slow(32).range(450, 1400)).attack(.9).release(1.8)
-  .room(.75).rsize(9).gain(.4).orbit(4)
+  .hpf(150).room(.75).rsize(9).gain(.4).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introStabs = stack(kick, hats, open, clap.gain(.5),
   stabs.lpf(900).gain(.5), sub.gain(.5))
-const build = stack(kick, hats16, clap, bajoOff, pad.gain(.3),
-  stabs.hpf(saw.slow(16).range(50, 2500)).gain(.6), sub.gain(.5))
-const buildFin = stack(kickHard, rodillo, bajoOff,
-  stabs.hpf(saw.slow(8).range(100, 4000)).gain(.7))
-const dropA = stack(kickHard, hats16, open, clap, crash, sub, bajoOff,
-  stabs, stabsCuerpo)
-const dropAvar = stack(kickHard, hats16, open, clap, sub, bajoOff,
-  stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.6)), stabsCuerpo, pad.gain(.3))
-const breakdown = stack(pad, stabsBreak, hats.gain(.25), sub.gain(.35))
-const build2 = stack(pad, stabsBreak.gain(.5), rodillo, hats16.gain(.35),
+const build = stack(kick, hats16, clap, ghost, bajoOff, pad.gain(.3), riser,
+  stabs.hpf(saw.slow(16).range(50, 2500)).gain(.6), sub.gain(.5), leadLimpio.gain(.5))
+const buildFin = stack(kickHard, rodillo, riser, bajoOff,
+  stabs.hpf(saw.slow(8).range(100, 4000)).gain(.7), leadLimpio.gain(.55))
+const dropA = stack(kickHard, hats16, open, clap, crash, ghost, sub, bajoOff,
+  stabs, stabsCuerpo, leadLimpio, contra)
+const dropAvar = stack(kickHard, hats16, open, clap, ghost, sub, bajoOff,
+  stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.6)), stabsCuerpo, pad.gain(.3), leadLimpio, contra)
+const breakdown = stack(pad, stabsBreak, hats.gain(.25), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const build2 = stack(pad, stabsBreak.gain(.5), rodillo, riser, hats16.gain(.35),
   kick.degradeBy(.5), sub.gain(.4))
-const dropB = stack(kickHard, hats16, open, clap, crash, sub, bajoOff,
-  stabs, stabsCuerpo, pad.gain(.3))
-const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, sub,
-  bajoOff, stabs, stabsCuerpo, pad.gain(.35))
-const grooveOut = stack(kick, hats16, open, clap, sub, bajoOff,
-  stabs.gain(.7))
+const dropB = stack(kickHard, hats16, open, clap, crash, ghost, sub, bajoOff,
+  stabs, stabsCuerpo, pad.gain(.3), leadLimpio, contra)
+const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ghost, sub,
+  bajoOff, stabs, stabsCuerpo, pad.gain(.35), leadLimpio, contra)
+const grooveOut = stack(kick, hats16, open, clap, ghost, sub, bajoOff,
+  stabs.gain(.7), leadLimpio)
 const coda = stack(kick, hats, clap.gain(.5), sub.gain(.5),
-  stabsBreak.gain(.5), pad.gain(.3))
+  stabsBreak.gain(.5), pad.gain(.3), leadLimpio.gain(.4))
 
 // ── ARREGLO (144 compases) ──
 arrange(
@@ -967,14 +1351,16 @@ arrange(
   [16, dropBFull],
   [16, grooveOut],
   [8,  coda]
-)`,
+)
+`,
   },
   {
     name: "11 · rule the world dub — tears for fears (1985)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 11 · RULE THE WORLD DUB — Tears for Fears (1985) → Dub Techno Remix
-// 118 BPM · D · Roland CR-78 · chords dub con delay infinito + bajo sine + shuffle hipnótico
+// 118 BPM · D (D·D·G·A) · Roland CR-78 · PRO: kick 2 capas + boom afinado y
+// bajo/sub que siguen los acordes + chords con 7as/9as + groove shuffle
 // Estructura: intro→chords→riff→drop A→break→drop B→dub final→coda (140 compases ≈ 4:45)
 // ════════════════════════════════════════════════════════════════
 setcps(118/60/4)
@@ -989,8 +1375,28 @@ const riff = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>")
 
 const riffLejos = riff.add(note(12)).gain(.28).lpf(2200).room(.85)
 
-// ── CHORDS DUB (el corazón del track: delay largo + feedback alto) ──
-const chords = note("~ <[d3,fs3,a3] [d3,fs3,a3] [g3,b3,d4] [a3,cs4,e4]> ~ ~")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Dadd9·Dadd9·Gmaj7·A7) + hi-pass ──
+const stab = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g2,b2,d3,fs3] [a2,cs3,e3,g3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ cs4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── CHORDS DUB con 7as/9as (delay largo + feedback alto) ──
+const chords = note("~ <[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g3,b3,d4,fs4] [a3,cs4,e4,g4]> ~ ~")
   .s("sawtooth").lpf(1100).lpq(3).hpf(250)
   .attack(.01).decay(.4).sustain(0).release(.3)
   .phaser(.7).phaserdepth(.5)
@@ -999,18 +1405,31 @@ const chords = note("~ <[d3,fs3,a3] [d3,fs3,a3] [g3,b3,d4] [a3,cs4,e4]> ~ ~")
 
 const chordsEco = chords.late(.5).gain(.35).lpf(800)
 
-// ── BAJO REDONDO (sine profundo, respirado) ──
-const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] [~ a1]]>")
+// ── BAJO REDONDO (sine profundo, ahora sigue D·D·G·A) ──
+const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] ~] [g1 ~ [~ g1] ~] [a1 ~ [~ a1] [~ e1]]>")
   .s("sine").decay(.4).sustain(.55).release(.1)
   .gain(.9).orbit(1)
 
 const bajoArm = bajo.add(note(12)).s("triangle").lpf(700).gain(.25).orbit(1)
 
-// ── BATERÍA CR-78 (suave, vintage, hipnótica) ──
-const kick = s("bd*4").bank("RolandCR78").shape(.35).gain(1.05)
+// ── SUB-BAJO afinado que SIGUE la fundamental (D·D·G·A) ──
+const bajoSub = note("<d1 d1 g1 a1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.5).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<d2 d2 g2 a2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.35).duck("1").orbit(1)
+
+// ── BATERÍA CR-78: kick en 2 capas (click vintage + BOOM afinado) ──
+const kickClick = s("bd*4").bank("RolandCR78").hpf(38).shape(.45).gain(.98)
   .duck("2:3").duckattack(.15).duckdepth(.45).orbit(0)
-const kickIntro = s("bd*4").bank("RolandCR78").degradeBy(.15).shape(.3).gain(1)
-  .duck("2:3").duckattack(.15).duckdepth(.4).orbit(0)
+const kickBoom = note("<d1 d1 g1 a1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickIntro = stack(s("bd*4").bank("RolandCR78").degradeBy(.15).hpf(38).shape(.3).gain(.9)
+  .duck("2:3").duckattack(.15).duckdepth(.4).orbit(0), kickBoom.gain(.85))
 const hats = s("[~ hh]*4").bank("RolandCR78").swingBy(1/6, 8)
   .gain(.4).pan(.6).orbit(0)
 const shaker = s("hh*16").bank("RolandCR78").swingBy(1/6, 16)
@@ -1020,40 +1439,45 @@ const rimDub = s("~ rim ~ [~ rim]").bank("RolandCR78")
   .room(.6).gain(.45).pan(.4).orbit(0)
 const snareDub = s("~ sd ~ ~").bank("RolandCR78")
   .room(.6).rsize(7).gain(.5).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandCR78").gain(.3).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandCR78").nudge(.004).gain(.3).orbit(0)
+// ghost sincopado (entra en los drops)
+const ghost = s("~ ~ [~ rim] ~ ~ ~ [rim ~] ~").bank("RolandCR78").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── ATMÓSFERA (pads inmensos + textura) ──
-const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [g2,b2,d3] [a2,cs3,e3]>")
+// ── ATMÓSFERA (pads inmensos con 7as/9as + textura) ──
+const pad = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [g2,b2,d3,fs3] [a2,cs3,e3,g3]>")
   .s("sawtooth").lpf(sine.slow(48).range(400, 900)).attack(1.5).release(2.5)
   .hpf(120).room(.85).rsize(9).gain(.4).orbit(4)
 
 const espacio = s("space").n(irand(4)).slow(8).clip(1)
   .gain(.25).room(.9).rsize(9).hpf(250).orbit(4)
+// riser de ruido para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kickIntro, hats, bajo.gain(.5))
 const introChords = stack(kickIntro, hats, chords.gain(.5), bajo)
 const grooveRiff = stack(kick, hats, shaker.gain(.15), rimDub.gain(.3),
   chords, bajo, riff.gain(.5).lpf(900))
-const build = stack(kick, hats, shaker, rimDub, chords, bajo, bajoArm,
-  pad.gain(.3), riff.lpf(saw.slow(16).range(500, 1600)).gain(.6))
-const dropA = stack(kick, hats, shaker, open, rimDub, snareDub,
-  chords, bajo, bajoArm, riff)
-const dropAvar = stack(kick, hats, shaker, open, rimDub, snareDub,
-  chords, chordsEco, bajo, bajoArm, riff, riffLejos)
+const build = stack(kick, hats, shaker, rimDub, chords, bajo, bajoArm, bajoSub,
+  pad.gain(.3), riser, riff.lpf(saw.slow(16).range(500, 1600)).gain(.6))
+const dropA = stack(kick, hats, shaker, open, rimDub, snareDub, ghost,
+  chords, bajo, bajoArm, riff, leadLimpio, stab)
+const dropAvar = stack(kick, hats, shaker, open, rimDub, snareDub, ghost,
+  chords, chordsEco, bajo, bajoArm, bajoSub, bajoOff, riff, riffLejos, leadLimpio, stab, contra)
 const breakdown = stack(pad, espacio, chords.gain(.55).delayfeedback(.72),
-  riff.gain(.45).room(.85), bajo.gain(.45))
-const breakBuild = stack(pad, espacio.gain(.15), chords, riff.gain(.6),
+  riff.gain(.45).room(.85), bajo.gain(.45), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, espacio.gain(.15), riser, chords, riff.gain(.6),
   shaker.gain(.25), rimDub, bajo)
-const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, chords,
+const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, ghost, chords,
   bajo, bajoArm, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
-  pad.gain(.25))
-const dropBFull = stack(kick, hats, shaker, open, rimDub, snareDub,
-  chords, chordsEco, bajo, bajoArm, riff, riffLejos, pad.gain(.3))
-const dubFinal = stack(kick, hats, rimDub, chords.delayfeedback(.72),
-  bajo, riff.gain(.5).room(.9))
+  pad.gain(.25), leadLimpio, stab)
+const dropBFull = stack(kick, hats, shaker, open, rimDub, snareDub, ghost,
+  chords, chordsEco, bajo, bajoArm, bajoSub, bajoOff, riff, riffLejos, pad.gain(.3), leadLimpio, stab, contra)
+const dubFinal = stack(kick, hats, rimDub, ghost, chords.delayfeedback(.72),
+  bajo, bajoSub, riff.gain(.5).room(.9), leadLimpio, stab)
 const coda = stack(kickIntro, hats.gain(.3),
-  chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3))
+  chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3), leadLimpio.gain(.4))
 const codaFin = stack(chords.gain(.3).delayfeedback(.78), espacio,
   pad.gain(.3))
 
@@ -1072,14 +1496,16 @@ arrange(
   [8,  dubFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "12 · the model minimal — kraftwerk (1978)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 12 · THE MODEL MINIMAL — Kraftwerk (1978) → Minimal Electro Remix
-// 126 BPM · Cm · TR-606 · square robótico + crush suave · ultra seco
+// 126 BPM · Cm (Cm·Cm·Ab·G) · TR-606 · PRO: kick 2 capas + boom afinado y
+// bajo/sub que siguen los acordes + groove con swing · square robótico, seco
 // Estructura: intro→groove→drop A→break robot→drop B→coda (136 compases ≈ 4:19)
 // ════════════════════════════════════════════════════════════════
 setcps(126/60/4)
@@ -1093,33 +1519,73 @@ const hook = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~")
 
 const hookEco = hook.add(note(-12)).late(.5).gain(.3).lpf(1400).orbit(3)
 
-// ── BAJO ROBÓTICO (pulso de máquina en Cm) ──
-const bajo = note("c2 c2 g1 c2").s("square")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Cm7·Cm7·Abmaj7·G7) + hi-pass ──
+const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJO ROBÓTICO (pulso de máquina, ahora sigue Cm·Cm·Ab·G) ──
+const bajo = note("<[c2 c2 g1 c2] [c2 c2 g1 c2] [ab1 ab1 eb1 ab1] [g1 g1 d1 g1]>").s("square")
   .lpf(850).lpq(5).attack(.001).decay(.11).sustain(.3).release(.03)
   .shape(.2).gain(.9).orbit(1)
 
 const bajoOcho = bajo.ply(2).gain(.85)
 
-const bajoDrop = note("c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1")
+const bajoDrop = note("<[c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1] [c2 [~ c2] g1 [c2 c2] c2 [~ c2] bb1 g1] [ab1 [~ ab1] eb1 [ab1 ab1] ab1 [~ ab1] gb1 eb1] [g1 [~ g1] d1 [g1 g1] g1 [~ g1] f1 d1]>")
   .s("square").lpf(1000).lpq(6)
   .attack(.001).decay(.1).sustain(.2).release(.03)
   .shape(.25).gain(.9).orbit(1)
 
-const sub = note("c1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (Cm·Cm·Ab·G) ──
+const sub = note("<c1 c1 ab1 g1>").struct("x*4").s("sine")
+  .attack(.002).decay(.25).sustain(.2).gain(.6).orbit(1)
 
-// ── BATERÍA 606 (seca, sin reverb, precisión maquinal) ──
-const kick = s("bd*4").bank("RolandTR606").shape(.35).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<c2 c2 ab2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── BATERÍA 606: kick en 2 capas (click seco + BOOM afinado) ──
+const kickClick = s("bd*4").bank("RolandTR606").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kickElectro = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR606")
-  .shape(.4).gain(1.05).duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
+const kickBoom = note("<c1 c1 ab1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickElectroClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR606").hpf(38).shape(.4).gain(.95)
+  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
+const kickElectroBoom = note("<c1 c1 ab1 g1>").struct("x ~ ~ x ~ ~ x ~").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0)
+const kickElectro = stack(kickElectroClick, kickElectroBoom)
 const clap = s("~ cp ~ cp").bank("RolandTR606").gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR606").gain(.5).pan(.55).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR606")
+const hats = s("[~ hh]*4").bank("RolandTR606").swingBy(1/24,8).gain(.5).pan(.55).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR606").swingBy(1/24,16)
   .gain("[.45 .2 .3 .2]*4").pan(.45).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").gain(.45).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").nudge(.004).gain(.45).orbit(0)
 const rim = s("[~ rim]*2").bank("RolandTR606").gain(.4).pan(.65).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR606")
   .gain(saw.slow(4).range(.15,.7)).speed(saw.slow(4).range(1,1.3)).orbit(0)
+// ghost snare sincopado (entra en los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR606").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── BLIPS DE ORDENADOR (textura minimal, aleatoria y fría) ──
 const blips = note("c6 ~ ~ g5 ~ ~ eb6 ~").s("square")
@@ -1127,27 +1593,27 @@ const blips = note("c6 ~ ~ g5 ~ ~ eb6 ~").s("square")
   .degradeBy(.4).gain(.35).pan(rand.range(.3,.7))
   .delay(.2).delaytime(.25).delayfeedback(.3).orbit(3)
 
-// ── PAD MÍNIMO (frío, casi inaudible, solo da contexto) ──
-const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [g2,b2,d3]>")
+// ── PAD MÍNIMO con 7as (frío, da contexto) + hi-pass ──
+const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [g2,b2,d3,f3]>")
   .s("triangle").lpf(600).attack(1).release(1.5)
-  .room(.3).gain(.35).orbit(4)
+  .hpf(150).room(.3).gain(.35).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats)
 const introB = stack(kick, hats, rim, bajo.lpf(400).gain(.7))
 const groove = stack(kick, hats, hatsOpen, clap, bajo, sub.gain(.4))
-const build = stack(kick, hats16, clap, rim, bajo,
+const build = stack(kick, hats16, clap, rim, ghost, bajo, riser,
   hook.lpf(saw.slow(8).range(400,2600)).gain(.55))
-const buildFin = stack(kick, rodillo, bajoOcho, hook.gain(.7))
-const dropA = stack(kick, hats16, hatsOpen, clap, bajoOcho, sub, hook)
-const dropAvar = stack(kick, hats16, hatsOpen, clap, rim, bajoOcho, sub,
-  hook.every(4, x=>x.iter(4)), hookEco, blips)
-const breakRobot = stack(bajo.gain(.6), blips, hook.gain(.5), pad, hats.gain(.3))
-const breakBuild = stack(bajo, blips, hook.gain(.6), pad, rodillo, hats16.gain(.35))
-const dropB = stack(kickElectro, hats16, hatsOpen, clap, bajoDrop, sub, hook, hookEco)
-const dropBvar = stack(kick, hats16, hatsOpen, clap, rim, bajoDrop, sub,
-  hook.sometimesBy(.25, x=>x.add(note(12)).gain(.6)), hookEco, blips)
-const coda = stack(kick, hats, bajo.gain(.7), hook.gain(.45), pad)
+const buildFin = stack(kick, rodillo, riser, bajoOcho, hook.gain(.7))
+const dropA = stack(kick, hats16, hatsOpen, clap, ghost, bajoOcho, sub, hook, leadLimpio, stab)
+const dropAvar = stack(kick, hats16, hatsOpen, clap, rim, ghost, bajoOcho, sub, bajoOff,
+  hook.every(4, x=>x.iter(4)), hookEco, blips, leadLimpio, stab, contra)
+const breakRobot = stack(bajo.gain(.6), blips, hook.gain(.5), pad, hats.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(bajo, blips, riser, hook.gain(.6), pad, rodillo, hats16.gain(.35))
+const dropB = stack(kickElectro, hats16, hatsOpen, clap, ghost, bajoDrop, sub, hook, hookEco, leadLimpio, stab)
+const dropBvar = stack(kick, hats16, hatsOpen, clap, rim, ghost, bajoDrop, sub, bajoOff,
+  hook.sometimesBy(.25, x=>x.add(note(12)).gain(.6)), hookEco, blips, leadLimpio, stab, contra)
+const coda = stack(kick, hats, bajo.gain(.7), hook.gain(.45), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35), hook.gain(.3).delayfeedback(.5),
   blips.gain(.25), pad.gain(.25))
 
@@ -1166,14 +1632,16 @@ arrange(
   [16, dropBvar],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "13 · girls fun breakbeat — cyndi lauper (1983)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 13 · GIRLS FUN BREAKBEAT — Cyndi Lauper (1983) → Breakbeat Rave Remix
-// 138 BPM · G · OberheimDMX · breaks + stabs rave + sirenas + hoover
+// 138 BPM · G (G·Em·C·D) · OberheimDMX · PRO: kick 2 capas + boom afinado y
+// bajo/sub que siguen los acordes + stabs con 7as/9as + groove con swing
 // Estructura: intro→build→drop A→sirenas→break→drop hoover→coda (152 compases ≈ 4:24)
 // ════════════════════════════════════════════════════════════════
 setcps(138/60/4)
@@ -1187,6 +1655,26 @@ const hook = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~")
 
 const hookAlta = hook.add(note(12)).gain(.35).lpf(3500).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Gadd9·Em7·Cmaj7·D7) + hi-pass ──
+const stab = note("<[g3,b3,d4,a4] [e3,g3,b3,d4] [c3,e3,g3,b3] [d3,fs3,a3,c4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ d4 ~ b3 ~ g3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ a4 ~ fs4 ~ d4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── STABS RAVE (acorde de G, cada 4 compases se aceleran con hurry) ──
 const stabs = note("[g4,b4,d5] ~ ~ [g4,b4,d5] ~ [g4,b4,d5] ~ ~")
   .s("sawtooth").lpf(3000).attack(.001).decay(.15).sustain(0)
@@ -1206,56 +1694,72 @@ const hoover = note("g2 ~ g2 g2 ~ e2 ~ [f2 fs2]")
   .attack(.01).decay(.2).sustain(.4).release(.1)
   .gain(.7).orbit(3)
 
-// ── BAJO RAVE (punchy, con sub de refuerzo) ──
-const bajo = note("g1 ~ [~ g1] g1 ~ g1 [~ e1] [f1 fs1]")
+// ── BAJO RAVE que SIGUE los acordes (G·Em·C·D), con sub de refuerzo ──
+const bajo = note("<[g1 ~ [~ g1] g1 ~ g1 [~ d1] [fs1 f1]] [e1 ~ [~ e1] e1 ~ e1 [~ b1] [a1 b1]] [c1 ~ [~ c1] c1 ~ c1 [~ g1] [e1 eb1]] [d1 ~ [~ d1] d1 ~ d1 [~ a1] [f1 fs1]]>")
   .s("sawtooth").lpf(700).lpq(6)
   .attack(.001).decay(.12).sustain(.35).release(.04)
   .shape(.3).gain(.9).orbit(1)
 
-const sub = note("g1 ~ ~ g1 ~ ~ g1 ~").s("sine")
+const sub = note("<[g1 ~ ~ g1 ~ ~ g1 ~] [e1 ~ ~ e1 ~ ~ e1 ~] [c1 ~ ~ c1 ~ ~ c1 ~] [d1 ~ ~ d1 ~ ~ d1 ~]>").s("sine")
   .decay(.3).sustain(.3).gain(.65).orbit(1)
 
-// ── BATERÍA DMX (breakbeat con snares desplazadas y fantasma) ──
-const kick = s("bd ~ [~ bd] bd").bank("OberheimDMX").shape(.35).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<g2 e2 c2 d2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.38).duck("1").orbit(1)
+
+// ── BATERÍA DMX: kick en 2 capas (breakbeat + BOOM afinado que sigue raíces) ──
+const kickClick = s("bd ~ [~ bd] bd").bank("OberheimDMX").hpf(38).shape(.45).gain(1)
   .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kick4 = s("bd*4").bank("OberheimDMX").shape(.4).gain(1.05)
+const kickBoom = note("<g1 e1 c1 d1>").struct("x ~ [~ x] x").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kick4Click = s("bd*4").bank("OberheimDMX").hpf(38).shape(.5).gain(1)
   .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
+const kick4Boom = note("<g1 e1 c1 d1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.03).orbit(0)
+const kick4 = stack(kick4Click, kick4Boom)
 const snare = s("~ sd ~ [~ sd]").bank("OberheimDMX").room(.25).gain(.8).orbit(0)
 const ghost = s("sd*8").bank("OberheimDMX")
   .degradeBy(.65).gain(.22).pan(.6).orbit(0)
-const hats = s("[~ hh]*4").bank("OberheimDMX").gain(.55).pan(.4).orbit(0)
-const hats16 = s("hh*16").bank("OberheimDMX")
+const hats = s("[~ hh]*4").bank("OberheimDMX").swingBy(1/24,8).gain(.55).pan(.4).orbit(0)
+const hats16 = s("hh*16").bank("OberheimDMX").swingBy(1/24,16)
   .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").gain(.5).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").nudge(.004).gain(.5).orbit(0)
 const clap = s("~ cp ~ cp").bank("OberheimDMX").room(.3).gain(.7).orbit(0)
 const rodillo = s("sd*16").bank("OberheimDMX")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.5)).orbit(0)
+// riser de ruido para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD (colchón alegre G-Em-C-D) ──
-const pad = note("<[g3,b3,d4] [e3,g3,b3] [c3,e3,g3] [d3,fs3,a3]>")
+// ── PAD con 7as/9as (colchón G-Em-C-D) + hi-pass ──
+const pad = note("<[g3,b3,d4,a4] [e3,g3,b3,d4] [c3,e3,g3,b3] [d3,fs3,a3,c4]>")
   .s("supersaw").unison(4).spread(.6).lpf(900)
-  .attack(.7).release(1.2).room(.6).rsize(7).gain(.35).orbit(4)
+  .hpf(150).attack(.7).release(1.2).room(.6).rsize(7).gain(.35).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick4, hats)
 const introB = stack(kick4, hats, clap, ghost, bajo.lpf(400).gain(.7))
-const build = stack(kick4, hats16, clap, bajo, pad,
+const build = stack(kick4, hats16, clap, bajo, pad, riser,
   hook.lpf(saw.slow(16).range(400,2200)).gain(.5), stabs.gain(.4))
-const buildFin = stack(kick4, rodillo, bajo, hook.gain(.65), sirena)
-const dropA = stack(kick, snare, ghost, hats16, open, bajo, sub, hook, stabs)
-const dropAvar = stack(kick, snare, ghost, hats16, open, bajo, sub,
-  hook, hookAlta, stabs, sirena)
+const buildFin = stack(kick4, rodillo, riser, bajo, hook.gain(.65), sirena)
+const dropA = stack(kick, snare, ghost, hats16, open, bajo, sub, hook, stabs, leadLimpio, stab)
+const dropAvar = stack(kick, snare, ghost, hats16, open, bajo, sub, bajoOff,
+  hook, hookAlta, stabs, sirena, leadLimpio, stab, contra)
 const breakdown = stack(pad, sirena, hook.gain(.55).room(.7),
-  hats.gain(.3), sub.gain(.35))
-const breakBuild = stack(pad, hook.gain(.65), stabs.gain(.5),
+  hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, riser, hook.gain(.65), stabs.gain(.5),
   rodillo, hats16.gain(.4), sirena)
 const dropHoover = stack(kick, snare, hats16, open, hoover, sub,
-  hook.gain(.6), ghost)
-const dropFull = stack(kick, snare, ghost, hats16, open, hoover, sub,
-  hook, hookAlta, stabs.gain(.5), sirena)
-const dropUltimo = stack(kick, snare, ghost, hats16, open, bajo, sub,
-  hook.sometimesBy(.2, x=>x.add(note(12))), hookAlta, stabs, pad.gain(.25))
-const coda = stack(kick4, hats, clap, bajo.gain(.7), hook.gain(.45).room(.6), pad)
+  hook.gain(.6), ghost, leadLimpio, stab)
+const dropFull = stack(kick, snare, ghost, hats16, open, hoover, sub, bajoOff,
+  hook, hookAlta, stabs.gain(.5), sirena, leadLimpio, stab, contra)
+const dropUltimo = stack(kick, snare, ghost, hats16, open, bajo, sub, bajoOff,
+  hook.sometimesBy(.2, x=>x.add(note(12))), hookAlta, stabs, pad.gain(.25), leadLimpio, stab, contra)
+const coda = stack(kick4, hats, clap, bajo.gain(.7), hook.gain(.45).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.8).delayfeedback(.6),
   sirena.gain(.2), pad.gain(.3))
 
@@ -1274,29 +1778,41 @@ arrange(
   [16, dropUltimo],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "14 · bites the dust tribal — queen (1980)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 14 · BITES THE DUST TRIBAL — Queen (1980) → Tribal Tech House Remix
-// 125 BPM · Em · TR-808 · toms euclidianos + bajo funk exacto · groove seco
+// 125 BPM · Em (Em·Em·Am·Bm = i·i·iv·v) · TR-808 · toms euclidianos + groove seco
+// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue las
+// fundamentales), sub/bajo siguen los acordes, bajo offbeat, groove con
+// swing + ghost + velocity humanizada, armonía con 7as/9as e hi-pass, riser
+// de ruido en subidas. Carácter peak-time duro (saturación, poco aire).
 // Estructura: intro→percusión→groove→drop A→break tribal→drop B→coda (140 compases ≈ 4:29)
 // ════════════════════════════════════════════════════════════════
 setcps(125/60/4)
 
-// ── EL BAJO (la línea exacta de John Deacon, 16 pasos) ──
-const bajo = note("e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~")
-  .s("sawtooth").lpf(750).lpq(7)
+// ── EL BAJO (la línea de John Deacon, AHORA sigue el acorde: Em·Em·Am·Bm) ──
+// mismo groove de 16 pasos, transpuesto a la fundamental de cada compás
+const bajo = note("<[e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~] [e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~] [a1 ~ ~ a1 a1 ~ a1 ~ [c2 a1] d2 ~ ~ ~ ~ ~ ~] [b1 ~ ~ b1 b1 ~ b1 ~ [d2 b1] e2 ~ ~ ~ ~ ~ ~]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8)
   .attack(.001).decay(.14).sustain(.35).release(.05)
-  .shape(.3).gain(.95).orbit(1)
+  .shape(.34).coarse(1).gain(.95).orbit(1)
 
-const sub = note("e1 ~ ~ e1 e1 ~ e1 ~ ~ a1 ~ ~ ~ ~ ~ ~")
-  .s("sine").decay(.25).sustain(.3).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ──
+const sub = note("<e1 e1 a1 b1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── STABS MÍNIMOS (acorde Em seco, casi percusivo) ──
-const stab = note("~ ~ [e3,g3,b3] ~ ~ [e3,g3,b3] ~ ~")
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y" entre kicks) ──
+const bajoOff = note("<e2 e2 a2 b2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── STABS MÍNIMOS (Em7 seco, casi percusivo) ──
+const stab = note("~ ~ [e3,g3,b3,d4] ~ ~ [e3,g3,b3,d4] ~ ~")
   .s("sawtooth").lpf(1600).hpf(300)
   .attack(.001).decay(.09).sustain(0)
   .gain(.55).pan(.6).orbit(3)
@@ -1308,15 +1824,45 @@ const riff = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~")
   .delay(.2).delaytime(.1875).delayfeedback(.3)
   .gain(.6).pan(.4).orbit(2)
 
-// ── BATERÍA 808 (bombo seco con swing + claps a contratiempo) ──
-const kick = s("bd*4").bank("RolandTR808").shape(.3).gain(1.05)
+// ── LEAD LIMPIO (la melodía real del riff, nítida y al frente) ──
+const leadLimpio = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Em7·Em7·Am7·Bm7) + contramelodía ──
+// voicings extendidos + voice-leading (notas comunes) + hi-pass = color, no triada seca
+const stabPad = note("<[e2,g2,b2,d3] [e2,g2,b2,d3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ b3 ~ g3 ~ e3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue raíces ──
+// el boom es una sine con envolvente de TONO que cae 26 semitonos = "thump"
+const kickClick = s("bd*4").bank("RolandTR808").hpf(38).shape(.5).distort(1.05).gain(.9)
   .duck("1:2").duckattack(.09).duckdepth(.45).orbit(0)
+const kickBoom = note("<e1 e1 a1 b1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
+
 const clap = s("[~ cp]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0)
 const clapDos = s("~ cp ~ cp").bank("RolandTR808").gain(.65).orbit(0)
+// hats con SWING (groove, no rejilla plana)
 const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.35)
-  .swingBy(1/8, 4).orbit(0)
-const shaker = s("hh*16").bank("RolandTR808")
-  .gain("[.4 .18 .28 .18]*4").speed(rand.range(1.4,1.8))
+  .swingBy(1/24, 8).orbit(0)
+// shaker con SWING + velocity humanizada (perlin)
+const shaker = s("hh*16").bank("RolandTR808").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).speed(rand.range(1.4,1.8))
   .pan(rand.range(.3,.7)).orbit(0)
 
 // ── TOMS TRIBALES (euclidianos, el corazón del remix) ──
@@ -1333,11 +1879,16 @@ const congas = s("[~ mt]*4").bank("RolandTR808")
   .pan(rand.range(.25,.75)).orbit(0)
 const rodillo = s("lt*8").bank("RolandTR808")
   .gain(saw.slow(4).range(.25,.8)).speed(saw.slow(4).range(.8,1.3)).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD OSCURO (mínimo, solo en las pausas) ──
-const pad = note("<[e2,g2,b2] [e2,g2,b2] [a2,c3,e3] [b2,d3,fs3]>")
-  .s("triangle").lpf(550).attack(1.2).release(1.8)
+// ── PAD OSCURO con 7as (mínimo, solo en las pausas; hi-pass para el sub) ──
+const pad = note("<[e2,g2,b2,d3] [e2,g2,b2,d3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>")
+  .s("triangle").lpf(550).hpf(150).attack(1.2).release(1.8)
   .room(.5).rsize(5).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats)
@@ -1345,22 +1896,22 @@ const percusion = stack(kick, hats, clap, congas)
 const grooveBajo = stack(kick, hats, clap, clapDos.gain(.4), bajo, sub.gain(.4))
 const build = stack(kick, hats, shaker, clap, bajo, sub, tomAlto,
   riff.lpf(saw.slow(16).range(400,1900)).gain(.45))
-const buildFin = stack(kick, rodillo, bajo, tomAlto, tomMedio, riff.gain(.55))
-const dropA = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub,
-  stab, riff, congas)
-const dropAtoms = stack(kick, clap, shaker, bajo, sub, stab, riff,
-  tomAlto, tomMedio, tomBajo, congas)
+const buildFin = stack(kick, rodillo, riser, bajo, tomAlto, tomMedio, riff.gain(.55))
+const dropA = stack(kick, clap, clapDos.gain(.4), shaker, ghost, bajo, sub,
+  stab, riff, congas, leadLimpio, stabPad)
+const dropAtoms = stack(kick, clap, shaker, ghost, bajo, sub, bajoOff, stab, riff,
+  tomAlto, tomMedio, tomBajo, congas, leadLimpio, stabPad, contra)
 const breakTribal = stack(tomAlto, tomMedio, tomBajo, congas, shaker,
-  bajo.gain(.6), sub.gain(.4), pad)
-const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo,
+  bajo.gain(.6), sub.gain(.4), pad, contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo, riser,
   bajo, riff.gain(.5), pad)
-const dropB = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub,
+const dropB = stack(kick, clap, clapDos.gain(.4), shaker, ghost, bajo, sub,
   stab, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
-  tomAlto, congas)
-const dropBvar = stack(kick, clap, shaker, bajo, sub, stab,
-  riff, tomAlto, tomMedio, tomBajo, congas.gain(.55))
+  tomAlto, congas, leadLimpio, stabPad)
+const dropBvar = stack(kick, clap, shaker, ghost, bajo, sub, bajoOff, stab,
+  riff, tomAlto, tomMedio, tomBajo, congas.gain(.55), leadLimpio, stabPad, contra)
 const coda = stack(kick, hats, clap, bajo.gain(.7), congas.gain(.35),
-  riff.gain(.4), pad)
+  riff.gain(.4), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35), congas.gain(.3), sub.gain(.35),
   riff.gain(.25).room(.7).delayfeedback(.55), pad.gain(.3))
 
@@ -1379,14 +1930,19 @@ arrange(
   [16, dropBvar],
   [12, coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "15 · forever young trance — alphaville (1984)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 15 · FOREVER YOUNG TRANCE — Alphaville (1984) → Trance Techno Remix
-// 138 BPM · C/Am · TR-909 · supersaw nostálgico + piano + arpegio perpetuo
+// 138 BPM · C/Am (C·Am·F·G) · TR-909 · supersaw + piano + arpegio perpetuo
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las
+// fundamentales C·Am·F·G), sub/bajo siguen los acordes, bajo offbeat, groove
+// con swing + ghost + velocity humanizada, armonía con 7as/9as e hi-pass,
+// riser de ruido en subidas. Carácter peak-time duro (saturación, poco aire).
 // Estructura: intro→arpegio→build→drop A→breakdown piano→drop B→coda (160 compases ≈ 4:38)
 // ════════════════════════════════════════════════════════════════
 setcps(138/60/4)
@@ -1400,13 +1956,33 @@ const hook = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~")
 
 const hookAlta = hook.add(note(12)).gain(.3).lpf(4000).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Cadd9·Am7·Fmaj7·G7) + contramelodía ──
+const stab = note("<[c3,e3,g3,d4] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── PIANO EMOTIVO (protagonista del breakdown) ──
 const piano = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~")
   .s("piano").slow(2).room(.8).rsize(8)
   .delay(.4).delaytime(.375).delayfeedback(.45)
   .gain(.9).orbit(2)
 
-const pianoAcordes = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
+const pianoAcordes = note("<[c3,e3,g3,b3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
   .s("piano").room(.8).rsize(8).gain(.7).orbit(4)
 
 // ── ARPEGIO PERPETUO (el motor del track) ──
@@ -1422,57 +1998,75 @@ const arpegio16 = note("[c3 e3 g3 c4]*4")
   .delay(.25).delaytime(.1875).delayfeedback(.3)
   .gain(.55).pan(sine.slow(3).range(.3,.7)).orbit(3)
 
-// ── BAJO ROLLING (16avos, progresión C·Am·F·G) ──
+// ── BAJO ROLLING (16avos, progresión C·Am·F·G — sigue las fundamentales) ──
 const bajo = note("<c2 a1 f1 g1>").struct("x*16")
-  .s("sawtooth").lpf(650).lpq(6)
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8)
   .attack(.001).decay(.1).sustain(.25).release(.03)
-  .gain("[.9 .55 .7 .55]*4").shape(.25).orbit(1)
+  .gain("[.9 .55 .7 .55]*4").shape(.34).coarse(1).orbit(1)
 
+// ── SUB-BAJO afinado que SIGUE la fundamental ──
 const sub = note("<c1 a1 f1 g1>").struct("x*4")
-  .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1)
+  .s("sine").attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA 909 ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<c2 a2 f2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909 EN 2 CAPAS (click + boom afinado) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1)
+const kickBoom = note("<c1 a1 f1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.15).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── CUERDAS / PADS (el gran room trance) ──
-const cuerdas = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
-  .s("supersaw").unison(4).spread(.8).lpf(1000)
+// ── CUERDAS / PADS con 7as (el gran room trance; hi-pass para el sub) ──
+const cuerdas = note("<[c3,e3,g3,d4] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .s("supersaw").unison(4).spread(.8).lpf(1000).hpf(160)
   .attack(.9).release(1.8).room(.75).rsize(8).gain(.4).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introArp = stack(kick, hats, open, arpegio, sub.gain(.5))
 const build = stack(kick, hats16, clap, bajo, arpegio, cuerdas.gain(.3),
   hook.lpf(saw.slow(16).range(400,2400)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, arpegio16, hook.gain(.65))
-const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  arpegio16, hook)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  arpegio16, hook, hookAlta, cuerdas.gain(.3))
-const breakPiano = stack(piano, pianoAcordes, cuerdas, sub.gain(.3))
+const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio16, hook.gain(.65))
+const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub,
+  arpegio16, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  arpegio16, hook, hookAlta, cuerdas.gain(.3), leadLimpio, stab, contra)
+const breakPiano = stack(piano, pianoAcordes, cuerdas, sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(piano.gain(.7), pianoAcordes.gain(.5), cuerdas,
-  arpegio, rodillo, hats16.gain(.4))
-const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  arpegio16, hook, hookAlta)
-const dropBvar = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
+  arpegio, rodillo, riser, hats16.gain(.4))
+const dropB = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub,
+  arpegio16, hook, hookAlta, leadLimpio, stab)
+const dropBvar = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajo, sub, bajoOff,
   arpegio16, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)),
-  hookAlta, cuerdas.gain(.3))
-const dropFinal = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  arpegio16, hook, hookAlta, cuerdas.gain(.35), pianoAcordes.gain(.35))
+  hookAlta, cuerdas.gain(.3), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  arpegio16, hook, hookAlta, cuerdas.gain(.35), pianoAcordes.gain(.35), leadLimpio, stab)
 const coda = stack(kick, hats, bajo.gain(.6), arpegio, hook.gain(.4).room(.7),
-  cuerdas.gain(.3))
+  cuerdas.gain(.3), leadLimpio.gain(.4))
 const codaFin = stack(piano.gain(.6), cuerdas.gain(.3),
   arpegio.gain(.3).delayfeedback(.6))
 
@@ -1491,29 +2085,40 @@ arrange(
   [16, dropFinal],
   [12, coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "16 · west end girls deep — pet shop boys (1985)",
     folder: "remixes 80s",
     code: `// ════════════════════════════════════════════════════════════════
 // 16 · WEST END GIRLS DEEP — Pet Shop Boys (1985) → Deep Techno Remix
-// 124 BPM · Dm · LinnDrum · chords deep con phaser + sub redondo + eco dub
+// 124 BPM · Dm (Dm·Dm·C·Bb) · LinnDrum · chords deep con phaser + eco dub
+// PRODUCCIÓN PRO: kick 2 capas (click Linn + boom afinado que sigue las
+// fundamentales Dm·Dm·C·Bb), sub/bajo siguen los acordes, bajo offbeat,
+// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass,
+// riser de ruido en subidas. Carácter peak-time (saturación, menos aire).
 // Estructura: intro→sub→chords→drop A→break urbano→drop B→coda (136 compases ≈ 4:23)
 // ════════════════════════════════════════════════════════════════
 setcps(124/60/4)
 
-// ── EL BAJO (la línea del original, redonda y profunda) ──
-const bajo = note("d2 d2 c2 d2 f2 d2 g2 f2")
-  .s("triangle").lpf(500)
+// ── EL BAJO (la línea del original, AHORA sigue el acorde: Dm·Dm·C·Bb) ──
+const bajo = note("<[d2 d2 c2 d2 f2 d2 g2 f2] [d2 d2 c2 d2 f2 d2 g2 f2] [c2 c2 bb1 c2 e2 c2 g2 e2] [bb1 bb1 ab1 bb1 d2 bb1 f2 d2]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(500,1000)).lpq(6)
   .attack(.002).decay(.18).sustain(.5).release(.08)
-  .shape(.15).gain(.95).orbit(1)
+  .shape(.3).coarse(1).gain(.95).orbit(1)
 
-const sub = note("d1 ~ ~ d1 ~ ~ d1 ~").s("sine")
-  .decay(.35).sustain(.35).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental ──
+const sub = note("<d1 d1 c1 bb0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── ECO DUB DEL BAJO (delay largo, flotando por detrás) ──
-const bajoDub = note("d2 ~ ~ ~ f2 ~ ~ ~")
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<d2 d2 c2 bb1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── ECO DUB DEL BAJO (delay largo, sigue el acorde, flotando por detrás) ──
+const bajoDub = note("<[d2 ~ ~ ~ f2 ~ ~ ~] [d2 ~ ~ ~ f2 ~ ~ ~] [c2 ~ ~ ~ e2 ~ ~ ~] [bb1 ~ ~ ~ d2 ~ ~ ~]>")
   .s("triangle").hpf(200).lpf(900)
   .delay(.5).delaytime(.5625).delayfeedback(.55)
   .gain(.4).pan(.65).orbit(3)
@@ -1527,35 +2132,65 @@ const lead = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~")
 
 const leadEco = lead.add(note(12)).late(.25).gain(.25).lpf(2600).orbit(2)
 
-// ── CHORDS DEEP (Dm7 con phaser, sofisticación urbana) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente, a doble compás) ──
+const leadLimpio = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~")
+  .slow(2).s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·C7·Bbmaj7) + contramelodía ──
+const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── CHORDS DEEP (Dm7·Dm7·C7·Bbmaj7 con phaser; hi-pass para el sub) ──
 const chords = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>")
   .struct("~ x ~ [~ x]")
-  .s("sawtooth").lpf(1100).lpq(2)
+  .s("sawtooth").lpf(1100).hpf(160).lpq(2)
   .attack(.01).decay(.3).sustain(.2).release(.15)
   .phaser(.5).phaserdepth(.7)
   .room(.45).rsize(4).gain(.6).pan(.45).orbit(4)
 
-// ── BATERÍA LINNDRUM (suave, elegante, ochentera) ──
-const kick = s("bd*4").bank("LinnDrum").shape(.2).gain(1)
+// ── BATERÍA LINNDRUM EN 2 CAPAS (click + boom afinado) ──
+const kickClick = s("bd*4").bank("LinnDrum").hpf(38).shape(.4).gain(.9)
   .duck("1:2").duckattack(.1).duckdepth(.4).orbit(0)
+const kickBoom = note("<d1 d1 c1 bb0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
+
 const clap = s("~ cp ~ cp").bank("LinnDrum").room(.3).gain(.6).orbit(0)
-const hats = s("[~ hh]*4").bank("LinnDrum").gain(.45).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("LinnDrum")
-  .gain("[.4 .18 .28 .18]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("LinnDrum").gain(.4).orbit(0)
+const hats = s("[~ hh]*4").bank("LinnDrum").swingBy(1/24,8).gain(.45).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("LinnDrum").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("LinnDrum").nudge(.004).gain(.4).orbit(0)
 const rim = s("~ [~ rim] ~ rim").bank("LinnDrum").gain(.4).pan(.35).orbit(0)
-const ghost = s("sd*8").bank("LinnDrum").degradeBy(.7).gain(.18).pan(.55).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("sd*8").bank("LinnDrum").degradeBy(.7).gain(.18).pan(.55).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("LinnDrum")
   .gain(saw.slow(4).range(.15,.65)).speed(saw.slow(4).range(1,1.3)).orbit(0)
 
-// ── ATMÓSFERA URBANA (textura espacial, muy al fondo) ──
+// ── ATMÓSFERA URBANA (textura espacial, muy al fondo; peak-time = poco aire) ──
 const niebla = s("space").slow(8).lpf(1200).room(.8).rsize(8)
-  .gain(.25).pan(sine.slow(16).range(.3,.7)).orbit(4)
+  .gain(.18).pan(sine.slow(16).range(.3,.7)).orbit(4)
 
-// ── PAD NOCTURNO ──
-const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [bb2,d3,f3]>")
-  .s("triangle").lpf(700).attack(1).release(2)
+// ── PAD NOCTURNO con 7as (hi-pass para dejar libre el sub) ──
+const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>")
+  .s("triangle").lpf(700).hpf(150).attack(1).release(2)
   .room(.6).rsize(6).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, niebla)
@@ -1563,21 +2198,21 @@ const introSub = stack(kick, hats, rim, sub, bajo.lpf(300).gain(.7))
 const grooveChords = stack(kick, hats, open, clap, bajo, sub, chords.gain(.45))
 const build = stack(kick, hats16, clap, rim, bajo, sub, chords,
   lead.lpf(saw.slow(16).range(300,1600)).gain(.45))
-const buildFin = stack(kick, rodillo, bajo, chords, lead.gain(.6))
-const dropA = stack(kick, hats16, open, clap, ghost, bajo, sub, chords, lead)
-const dropAvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub,
-  bajoDub, chords, lead, leadEco)
+const buildFin = stack(kick, rodillo, riser, bajo, chords, lead.gain(.6))
+const dropA = stack(kick, hats16, open, clap, ghost, bajo, sub, chords, lead, leadLimpio, stab)
+const dropAvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, bajoOff,
+  bajoDub, chords, lead, leadEco, leadLimpio, stab, contra)
 const breakUrbano = stack(pad, niebla, chords.gain(.4), lead.gain(.5).room(.7),
-  bajoDub, hats.gain(.25))
-const breakBuild = stack(pad, chords.gain(.5), lead.gain(.6), rodillo,
+  bajoDub, hats.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, chords.gain(.5), lead.gain(.6), rodillo, riser,
   hats16.gain(.35), sub.gain(.4))
 const dropB = stack(kick, hats16, open, clap, ghost, bajo, sub, bajoDub,
-  chords.every(4, x=>x.iter(4)), lead, leadEco)
-const dropBvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub,
+  chords.every(4, x=>x.iter(4)), lead, leadEco, leadLimpio, stab)
+const dropBvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub, bajoOff,
   bajoDub, chords, lead.sometimesBy(.2, x=>x.add(note(12)).gain(.5)),
-  leadEco, niebla)
+  leadEco, niebla, leadLimpio, stab, contra)
 const coda = stack(kick, hats, bajo.gain(.7), chords.gain(.4),
-  lead.gain(.4).room(.7), pad)
+  lead.gain(.4).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), bajoDub.gain(.3),
   lead.gain(.25).room(.85).delayfeedback(.65), pad.gain(.3), niebla)
 
@@ -1596,14 +2231,19 @@ arrange(
   [16, dropBvar],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "17 · what is love hard house — haddaway (1993)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 17 · WHAT IS LOVE HARD HOUSE — Haddaway (1993) → Hard House Remix
-// 134 BPM · Dm · TR-909 · stabs offbeat con vowel + bajo offbeat · segundo drop en octava
+// 134 BPM · Dm (Dm·Dm·Bb·C) · TR-909 · stabs offbeat con vowel + bajo offbeat
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las
+// fundamentales Dm·Dm·Bb·C), sub/bajo siguen los acordes, bajo offbeat,
+// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass,
+// riser de ruido en subidas. Carácter peak-time duro (saturación).
 // Estructura: intro→stabs→build→drop A→break vocal→drop octava→coda (148 compases ≈ 4:25)
 // ════════════════════════════════════════════════════════════════
 setcps(134/60/4)
@@ -1617,6 +2257,26 @@ const hook = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~")
 
 const hookOctava = hook.add(note(12)).gain(.85).lpf(3200).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·Bbmaj7·C7) + contramelodía ──
+const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [c3,e3,g3,bb3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ f4 ~ d4 ~ bb3 ~] [~ ~ g4 ~ e4 ~ c4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── STABS OFFBEAT (los acordes exactos del género, con vocal sintética) ──
 const stabs = note("~ [d4,f4,a4] ~ [c4,f4,a4]").fast(2)
   .s("sawtooth").lpf(2400).lpq(3)
@@ -1624,63 +2284,82 @@ const stabs = note("~ [d4,f4,a4] ~ [c4,f4,a4]").fast(2)
   .vowel("a e").shape(.25)
   .room(.3).gain(.75).pan(.55).orbit(3)
 
-// ── BAJO OFFBEAT (bombeo clásico hard house) ──
-const bajo = note("[~ d2]*4")
-  .s("sawtooth").lpf(800).lpq(7)
+// ── BAJO OFFBEAT (bombeo clásico hard house, AHORA sigue el acorde) ──
+const bajo = note("<[~ d2]*4 [~ d2]*4 [~ bb1]*4 [~ c2]*4>")
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(7)
   .attack(.001).decay(.13).sustain(.3).release(.04)
-  .shape(.35).gain(.9).orbit(1)
+  .shape(.35).coarse(1).gain(.9).orbit(1)
 
-const bajoVar = note("[~ d2]!3 [~ [c2 e2]]")
-  .s("sawtooth").lpf(850).lpq(7)
+const bajoVar = note("<[[~ d2]!3 [~ [c2 e2]]] [[~ d2]!3 [~ [c2 e2]]] [[~ bb1]!3 [~ [ab1 c2]]] [[~ c2]!3 [~ [bb1 d2]]]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(7)
   .attack(.001).decay(.13).sustain(.3).release(.04)
-  .shape(.35).gain(.9).orbit(1)
+  .shape(.35).coarse(1).gain(.9).orbit(1)
 
-const sub = note("d1*4").s("sine").decay(.28).sustain(.2).gain(.65).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental ──
+const sub = note("<d1 d1 bb0 c1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.65).orbit(1)
 
-// ── BATERÍA 909 (dura y directa) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
+// ── BAJO OFFBEAT EXTRA (sub-octava para el clímax) ──
+const bajoOff = note("<d2 d2 bb1 c2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── BATERÍA 909 EN 2 CAPAS (dura y directa) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
+const kickBoom = note("<d1 d1 bb0 c1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
 const rodilloCorto = s("sd*8").bank("RolandTR909")
   .gain(saw.slow(2).range(.3,.8)).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD (colchón menor dramático) ──
-const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [c3,e3,g3]>")
-  .s("supersaw").unison(4).spread(.7).lpf(900)
+// ── PAD con 7as (colchón menor dramático; hi-pass para el sub) ──
+const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [c3,e3,g3,bb3]>")
+  .s("supersaw").unison(4).spread(.7).lpf(900).hpf(150)
   .attack(.8).release(1.5).room(.65).rsize(7).gain(.38).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introStabs = stack(kick, hats, open, stabs.gain(.45), sub.gain(.5))
 const build = stack(kick, hats16, clap, bajo, stabs, pad.gain(.3),
   hook.lpf(saw.slow(16).range(400,2000)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, stabs, hook.gain(.65))
-const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub, stabs, hook)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub,
-  stabs, hook, pad.gain(.25))
+const buildFin = stack(kickHard, rodillo, riser, bajo, stabs, hook.gain(.65))
+const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub, stabs, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajoVar, sub,
+  stabs, hook, pad.gain(.25), leadLimpio, stab, contra)
 const breakVocal = stack(pad, stabs.gain(.4).room(.6),
-  hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35))
+  hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, stabs.gain(.5), hook.gain(.65),
-  rodilloCorto, hats16.gain(.4))
-const dropOctava = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  stabs, hookOctava)
-const dropOctavaVar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub,
+  rodilloCorto, riser, hats16.gain(.4))
+const dropOctava = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub,
+  stabs, hookOctava, leadLimpio, stab)
+const dropOctavaVar = stack(kickHard, hats16, open, clap, ride, ghost, bajoVar, sub,
   stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.5)),
-  hookOctava, hook.gain(.4), pad.gain(.25))
-const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajoVar,
-  sub, stabs, hook, hookOctava.gain(.5))
+  hookOctava, hook.gain(.4), pad.gain(.25), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajoVar,
+  sub, bajoOff, stabs, hook, hookOctava.gain(.5), leadLimpio, stab)
 const coda = stack(kick, hats, clap, bajo.gain(.7), stabs.gain(.4),
-  hook.gain(.45).room(.6), pad)
+  hook.gain(.45).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), stabs.gain(.25).room(.8),
   hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3))
 
@@ -1699,14 +2378,19 @@ arrange(
   [16, dropFinal],
   [12, coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "18 · rhythm is a dancer rave — snap! (1992)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 18 · RHYTHM IS A DANCER RAVE — Snap! (1992) → Rave Techno Remix
-// 140 BPM · Gm · TR-909 · piano rave offbeat + hoover + euforia noventera
+// 140 BPM · Gm (Gm·Gm·Eb·F) · TR-909 · piano rave offbeat + hoover
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las
+// fundamentales Gm·Gm·Eb·F), sub/bajo/hoover siguen los acordes, bajo offbeat,
+// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass,
+// riser de ruido en subidas. Carácter peak-time duro (saturación).
 // Estructura: intro→piano→build→drop A→break oh→drop hoover→coda (152 compases ≈ 4:21)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -1720,48 +2404,86 @@ const hook = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4")
 
 const hookAlta = hook.add(note(12)).gain(.3).lpf(3600).orbit(2)
 
-// ── PIANO RAVE (el acorde en offbeat, pura euforia) ──
-const pianoRave = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Gm7·Gm7·Ebmaj7·F7) + contramelodía ──
+const stab = note("<[g2,bb2,d3,f3] [g2,bb2,d3,f3] [eb2,g2,bb2,d3] [f2,a2,c3,eb3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ bb3 ~ g3 ~ eb3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── PIANO RAVE con 7as (el acorde en offbeat, pura euforia) ──
+const pianoRave = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>")
   .struct("[~ x]*4")
   .s("piano").room(.45).rsize(4)
   .gain(.8).pan(.55).orbit(3)
 
-// ── HOOVER (supersaw rugiente, el terror de 1992) ──
-const hoover = note("g2 g2 ~ g2 ~ bb2 ~ c3")
+// ── HOOVER (supersaw rugiente, AHORA sigue el acorde: Gm·Gm·Eb·F) ──
+const hoover = note("<[g2 g2 ~ g2 ~ bb2 ~ c3] [g2 g2 ~ g2 ~ bb2 ~ c3] [eb2 eb2 ~ eb2 ~ g2 ~ ab2] [f2 f2 ~ f2 ~ a2 ~ bb2]>")
   .s("supersaw").unison(6).detune(.9).spread(.85)
   .lpf(1500).distort(.9)
   .attack(.01).decay(.2).sustain(.45).release(.12)
   .gain(.7).orbit(3)
 
-// ── BAJO (el motor: negras que empujan + sub) ──
-const bajo = note("g1 g1 bb1 c2").ply(2)
-  .s("sawtooth").lpf(700).lpq(6)
+// ── BAJO (el motor: negras que empujan, AHORA sigue el acorde) ──
+const bajo = note("<[g1 g1 bb1 c2] [g1 g1 bb1 c2] [eb1 eb1 g1 ab1] [f1 f1 a1 bb1]>").ply(2)
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8)
   .attack(.001).decay(.12).sustain(.35).release(.04)
-  .shape(.3).gain(.9).orbit(1)
+  .shape(.34).coarse(1).gain(.9).orbit(1)
 
-const sub = note("g1 ~ g1 ~ bb1 ~ c2 ~").s("sine")
-  .decay(.3).sustain(.25).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental ──
+const sub = note("<g1 g1 eb1 f1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA 909 (con fills doblados cada 8 compases) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<g2 g2 eb2 f2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909 EN 2 CAPAS (con fills doblados cada 8 compases) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1)
+const kickBoom = note("<g1 g1 eb1 f1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.1).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.65)
-  .every(8, x=>x.ply(2).gain(.95)).orbit(0)
+  .every(8, x=>x.ply(2).gain(.85)).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const openRave = s("[~ oh]*4").bank("RolandTR909").gain(.5).pan(.4).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const openRave = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.5).pan(.4).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD (colchón Gm, grande) ──
-const pad = note("<[g2,bb2,d3] [g2,bb2,d3] [eb2,g2,bb2] [f2,a2,c3]>")
-  .s("supersaw").unison(4).spread(.75).lpf(950)
+// ── PAD con 7as (colchón Gm, grande; hi-pass para el sub) ──
+const pad = note("<[g2,bb2,d3,f3] [g2,bb2,d3,f3] [eb2,g2,bb2,d3] [f2,a2,c3,eb3]>")
+  .s("supersaw").unison(4).spread(.75).lpf(950).hpf(150)
   .attack(.8).release(1.6).room(.7).rsize(8).gain(.38).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
@@ -1769,24 +2491,24 @@ const introPiano = stack(kick, hats, clap.gain(.4), pianoRave.gain(.5),
   bajo.lpf(400).gain(.65))
 const build = stack(kick, hats16, clap, bajo, pianoRave, pad.gain(.3),
   hook.lpf(saw.slow(16).range(400,2300)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, pianoRave, hook.gain(.65))
-const dropA = stack(kickHard, hats16, openRave, clap, crash, bajo, sub,
-  pianoRave, hook)
-const dropAvar = stack(kickHard, hats16, openRave, clap, ride, bajo, sub,
-  pianoRave, hook, hookAlta, pad.gain(.25))
+const buildFin = stack(kickHard, rodillo, riser, bajo, pianoRave, hook.gain(.65))
+const dropA = stack(kickHard, hats16, openRave, clap, crash, ghost, bajo, sub,
+  pianoRave, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, openRave, clap, ride, ghost, bajo, sub, bajoOff,
+  pianoRave, hook, hookAlta, pad.gain(.25), leadLimpio, stab, contra)
 const breakOh = stack(pad, pianoRave.gain(.5).room(.7),
-  hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35))
+  hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, pianoRave.gain(.6), hook.gain(.65),
-  rodillo, hats16.gain(.4), openRave.gain(.4))
-const dropHoover = stack(kickHard, hats16, openRave, clap, crash, hoover,
-  sub, hook.gain(.6), pianoRave.gain(.5))
-const dropHooverFull = stack(kickHard, hats16, openRave, clap, ride, hoover,
-  sub, hook, hookAlta, pianoRave.gain(.6))
-const dropFinal = stack(kickHard, hats16, openRave, clap, ride, crash, bajo,
-  sub, pianoRave, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)),
-  hookAlta, pad.gain(.25))
+  rodillo, riser, hats16.gain(.4), openRave.gain(.4))
+const dropHoover = stack(kickHard, hats16, openRave, clap, crash, ghost, hoover,
+  sub, hook.gain(.6), pianoRave.gain(.5), leadLimpio, stab)
+const dropHooverFull = stack(kickHard, hats16, openRave, clap, ride, ghost, hoover,
+  sub, bajoOff, hook, hookAlta, pianoRave.gain(.6), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, openRave, clap, ride, crash, ghost, bajo,
+  sub, bajoOff, pianoRave, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)),
+  hookAlta, pad.gain(.25), leadLimpio, stab)
 const coda = stack(kick, hats, clap, bajo.gain(.7), pianoRave.gain(.45),
-  hook.gain(.45).room(.6), pad)
+  hook.gain(.45).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), pianoRave.gain(.3).room(.8),
   hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3))
 
@@ -1805,19 +2527,24 @@ arrange(
   [16, dropFinal],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "19 · no limit hardcore — 2 unlimited (1993)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 19 · NO LIMIT HARDCORE — 2 Unlimited (1993) → Hardcore / Gabber suave Remix
-// 150 BPM · Cm · TR-909 · kick distorsionado + riff square + rodillos dobles
+// 150 BPM · Cm (Cm·Cm·Ab·Bb) · TR-909 · kick distorsionado + riff square
+// PRODUCCIÓN PRO: kick 2 capas (click gabber + boom afinado que sigue las
+// fundamentales Cm·Cm·Ab·Bb), sub/bajo/hoover siguen los acordes, bajo offbeat,
+// groove con swing + ghost + velocity humanizada, armonía con 7as e hi-pass,
+// riser de ruido en subidas. Carácter peak-time gabber (saturación seria).
 // Estructura: intro→riff→build→drop A→break voces→drop gabber→coda (160 compases ≈ 4:16)
 // ════════════════════════════════════════════════════════════════
 setcps(150/60/4)
 
-// ── EL RIFF (square agresivo, martillo de Cm) ──
+// ── EL RIFF (square agresivo, martillo de Cm — la melodía, notas intactas) ──
 const riff = note("c4 ~ c4 c4 eb4 c4 f4 eb4")
   .s("square").lpf(2200).lpq(6)
   .attack(.001).decay(.12).sustain(.25).release(.05)
@@ -1826,8 +2553,28 @@ const riff = note("c4 ~ c4 c4 eb4 c4 f4 eb4")
 
 const riffAlta = riff.add(note(12)).gain(.35).lpf(3400).coarse(0).orbit(2)
 
-// ── HOOVER (stabs supersaw, el rugido rave) ──
-const hoover = note("c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("c4 ~ c4 c4 eb4 c4 f4 eb4")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Cm7·Cm7·Abmaj7·Bb7) + contramelodía ──
+const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── HOOVER (stabs supersaw, AHORA sigue el acorde: Cm·Cm·Ab·Bb) ──
+const hoover = note("<[c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]] [c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]] [ab2 ~ ~ ab2 ~ c3 ~ [eb3 c3]] [bb2 ~ ~ bb2 ~ d3 ~ [f3 d3]]>")
   .s("supersaw").unison(6).detune(.9).spread(.85)
   .lpf(1600).distort(.9)
   .attack(.01).decay(.18).sustain(.4).release(.1)
@@ -1838,37 +2585,61 @@ const voz = s("numbers:0 numbers:0 numbers:0 ~")
   .speed(1.3).crush(6).hpf(300)
   .gain(.5).pan(.6).orbit(3)
 
-// ── BAJO (sub duro pegado al kick) ──
-const bajo = note("c2 c2 c2 [c2 eb2]")
-  .s("sawtooth").lpf(600).lpq(6)
+// ── BAJO (sub duro pegado al kick, AHORA sigue el acorde) ──
+const bajo = note("<[c2 c2 c2 [c2 eb2]] [c2 c2 c2 [c2 eb2]] [ab1 ab1 ab1 [ab1 c2]] [bb1 bb1 bb1 [bb1 d2]]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(500,1100)).lpq(6)
   .attack(.001).decay(.11).sustain(.35).release(.03)
-  .shape(.4).gain(.9).orbit(1)
+  .shape(.4).coarse(1).gain(.9).orbit(1)
 
-const sub = note("c1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental ──
+const sub = note("<c1 c1 ab0 bb0>").struct("x*4").s("sine")
+  .attack(.002).decay(.22).sustain(.2).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA 909 GABBER (bombo con distorsión seria) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).distort(1.2).gain(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<c2 c2 ab1 bb1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── BATERÍA 909 GABBER EN 2 CAPAS (click distorsionado + boom afinado) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.2).gain(.9)
   .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
-const kickGabber = s("bd*4").bank("RolandTR909").shape(.6).distort(1.5).gain(1)
+const kickBoom = note("<c1 c1 ab0 bb0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04)
+  .shape(.3).gain(1).orbit(0)
+const kickGabberClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.5).gain(.9)
   .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0)
-const kickDoble = s("bd*8").bank("RolandTR909").shape(.55).distort(1.3).gain(.9)
+const kickDobleClick = s("bd*8").bank("RolandTR909").hpf(38).shape(.55).distort(1.3).gain(.85)
   .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0)
+const kickBoomDoble = note("<c1 c1 ab0 bb0>").struct("x*8").s("sine")
+  .penv(26).pattack(.001).pdecay(.04).pcurve(0)
+  .attack(.001).decay(.16).sustain(0).release(.03)
+  .shape(.3).gain(.9).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickGabber = stack(kickGabberClick, kickBoom.gain(1.05))
+const kickDoble = stack(kickDobleClick, kickBoomDoble)
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.6).pan(.6).orbit(0)
-const hatsMachaca = s("hh*8").bank("RolandTR909")
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.6).pan(.6).orbit(0)
+const hatsMachaca = s("hh*8").bank("RolandTR909").swingBy(1/24,8)
   .gain("[.55 .35]*4").pan(.45).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.35).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
 const rodilloDoble = s("sd*32").bank("RolandTR909")
   .gain(saw.slow(2).range(.3,.95)).speed(saw.slow(2).range(1.1,1.7))
   .pan(sine.fast(2).range(.3,.7)).orbit(0)
+// ghost snare (percusión sincopada muy baja, groove anti-4x4)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD OSCURO (tensión entre drops) ──
-const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>")
-  .s("supersaw").unison(4).spread(.7).lpf(850)
+// ── PAD OSCURO con 7as (tensión entre drops; hi-pass para el sub) ──
+const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>")
+  .s("supersaw").unison(4).spread(.7).lpf(850).hpf(150)
   .attack(.7).release(1.4).room(.6).rsize(7).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
@@ -1876,24 +2647,24 @@ const introRiff = stack(kick, hats, clap.gain(.4),
   riff.lpf(800).gain(.55), sub.gain(.5))
 const build = stack(kick, hatsMachaca, clap, bajo, pad.gain(.25),
   riff.lpf(saw.slow(16).range(500,2200)).gain(.6))
-const buildFin = stack(kickGabber, rodillo, bajo, riff.gain(.7), voz.gain(.4))
-const dropA = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub,
-  riff, hoover.gain(.5))
-const dropAvar = stack(kickGabber, hatsMachaca, open, clap, bajo, sub,
-  riff, riffAlta, voz, hoover.gain(.55))
+const buildFin = stack(kickGabber, rodillo, riser, bajo, riff.gain(.7), voz.gain(.4))
+const dropA = stack(kickGabber, hatsMachaca, open, clap, crash, ghost, bajo, sub,
+  riff, hoover.gain(.5), leadLimpio, stab)
+const dropAvar = stack(kickGabber, hatsMachaca, open, clap, ghost, bajo, sub, bajoOff,
+  riff, riffAlta, voz, hoover.gain(.55), leadLimpio, stab, contra)
 const breakVoces = stack(pad, voz, riff.gain(.5).room(.5),
-  hats.gain(.3), sub.gain(.35))
-const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble,
+  hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble, riser,
   hatsMachaca.gain(.4))
-const dropGabber = stack(kickGabber, hatsMachaca, open, clap, crash, sub,
-  hoover, riff, voz.gain(.4))
-const dropGabberFull = stack(kickDoble, hatsMachaca, clap, sub,
-  hoover, riff, riffAlta, voz)
-const dropFinal = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub,
+const dropGabber = stack(kickGabber, hatsMachaca, open, clap, crash, ghost, sub,
+  hoover, riff, voz.gain(.4), leadLimpio, stab)
+const dropGabberFull = stack(kickDoble, hatsMachaca, clap, sub, bajoOff,
+  hoover, riff, riffAlta, voz, leadLimpio, stab, contra)
+const dropFinal = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub, bajoOff,
   riff.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), riffAlta,
-  hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3))
+  hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3), leadLimpio, stab)
 const coda = stack(kick, hats, clap, bajo.gain(.7), riff.gain(.45),
-  pad.gain(.3))
+  pad.gain(.3), leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), voz.gain(.3),
   riff.gain(.25).room(.7), pad.gain(.3))
 
@@ -1912,14 +2683,18 @@ arrange(
   [16, dropFinal],
   [16, coda],
   [12, codaFin]
-)`,
+)
+`,
   },
   {
     name: "20 · rhythm of the night italo — corona (1993)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 20 · RHYTHM OF THE NIGHT ITALO — Corona (1993) → Italo Dance Techno Remix
-// 130 BPM · Am · TR-909 · piano italo protagonista + bajo octavador · claps brillantes
+// 130 BPM · Am (Am·F·C·G → raíces a·f·c·g) · TR-909 · piano italo + bajo octavador
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity,
+// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido.
 // Estructura: intro→piano→build→drop A→break piano→drop supersaw→coda (144 compases ≈ 4:26)
 // ════════════════════════════════════════════════════════════════
 setcps(130/60/4)
@@ -1937,66 +2712,99 @@ const hookSaw = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~")
   .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.4)
   .gain(.7).pan(sine.slow(8).range(.35,.65)).orbit(2)
 
-// ── ACORDES ITALO (piano en offbeat, Am·F·C·G) ──
-const acordes = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>")
+// ── LEAD LIMPIO (el hook de piano, nítido y al frente) ──
+const leadLimpio = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~")
+  .s("triangle").lpf(5200).lpq(1)
+  .attack(.005).decay(.2).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.55).pan(.5).orbit(2)
+
+// ── CONTRAMELODÍA (zona media, Am·F·C·G) ──
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ f4 ~ c4 ~ a3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.3).pan(.62).orbit(3)
+
+// ── ACORDES ITALO con 7as (Am7·Fmaj7·Cmaj7·G7, piano en offbeat + hi-pass) ──
+const acordes = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>")
   .struct("[~ x]*4")
-  .s("piano").room(.4).rsize(4)
+  .s("piano").hpf(150).room(.4).rsize(4)
   .gain(.7).pan(.55).orbit(3)
 
-// ── BAJO OCTAVADOR (corcheas saltando la octava) ──
+// ── BAJO OCTAVADOR (corcheas saltando la octava, sigue las raíces a·f·c·g) ──
 const bajo = note("<[a1 a2 a1 a2 a1 a2 a1 a2] [f1 f2 f1 f2 f1 f2 f1 f2] [c2 c3 c2 c3 c2 c3 c2 c3] [g1 g2 g1 g2 g1 g2 g1 g2]>")
-  .s("sawtooth").lpf(750).lpq(6)
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1300)).lpq(8)
   .attack(.001).decay(.12).sustain(.3).release(.04)
-  .shape(.3).gain(.9).orbit(1)
+  .shape(.34).coarse(1).gain(.9).orbit(1)
 
+// ── SUB que SIGUE la fundamental (coherencia armónica total) ──
 const sub = note("<a1 f1 c2 g1>").struct("x*4")
   .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1)
 
-// ── BATERÍA 909 (brillante y bailonga) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
-  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1)
-  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", sigue las raíces) ──
+const bajoOff = note("<a2 f2 c3 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
+  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kickBoom = note("<a1 f1 c2 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909")
   .hpf(300).room(.35).gain(.8).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
+// hats con SWING + velocity humanizada
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.5).room(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare sincopado (dinámica de velocity aleatoria)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD MEDITERRÁNEO (colchón cálido) ──
-const pad = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>")
-  .s("supersaw").unison(4).spread(.7).lpf(950)
+// ── PAD MEDITERRÁNEO con 7as (colchón cálido + hi-pass) ──
+const pad = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>")
+  .s("supersaw").unison(4).spread(.7).lpf(950).hpf(150)
   .attack(.8).release(1.6).room(.65).rsize(7).gain(.38).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introPiano = stack(kick, hats, clap.gain(.4), acordes.gain(.45),
   bajo.lpf(400).gain(.65))
-const build = stack(kick, hats16, clap, bajo, acordes, pad.gain(.25),
+const build = stack(kick, hats16, clap, ghost, bajo, acordes, pad.gain(.25),
   hookPiano.gain(.55))
-const buildFin = stack(kickHard, rodillo, bajo, acordes, hookPiano.gain(.75))
-const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  acordes, hookPiano)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  acordes, hookPiano, pad.gain(.25))
+const buildFin = stack(kickHard, rodillo, riser, bajo, acordes, hookPiano.gain(.75))
+const dropA = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub,
+  acordes, hookPiano, leadLimpio, contra)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  acordes, hookPiano, pad.gain(.25), leadLimpio, contra)
 const breakPiano = stack(pad, hookPiano.gain(.7).room(.75),
-  acordes.gain(.5).room(.6), sub.gain(.35))
+  acordes.gain(.5).room(.6), sub.gain(.35), leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, hookPiano.gain(.8), acordes.gain(.55),
-  rodillo, hats16.gain(.4))
-const dropSaw = stack(kickHard, hats16, open, clap, crash, bajo, sub,
-  acordes.gain(.5), hookSaw)
-const dropSawFull = stack(kickHard, hats16, open, clap, ride, bajo, sub,
-  acordes, hookSaw, hookPiano.gain(.5), pad.gain(.25))
-const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
+  riser, rodillo, hats16.gain(.4))
+const dropSaw = stack(kickHard, hats16, open, clap, crash, ghost, bajo, sub,
+  acordes.gain(.5), hookSaw, leadLimpio.gain(.45), contra)
+const dropSawFull = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  acordes, hookSaw, hookPiano.gain(.5), pad.gain(.25), leadLimpio.gain(.45), contra)
+const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, ghost, bajo, sub, bajoOff,
   acordes, hookPiano,
   hookSaw.sometimesBy(.2, x=>x.add(note(12)).gain(.4)).gain(.5))
 const coda = stack(kick, hats, clap, bajo.gain(.7), acordes.gain(.45),
-  hookPiano.gain(.5).room(.6), pad)
+  hookPiano.gain(.5).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), hookPiano.gain(.4).room(.85).delayfeedback(.6),
   acordes.gain(.25).room(.8), pad.gain(.3))
 
@@ -2015,14 +2823,18 @@ arrange(
   [16, dropFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "21 · children dream — robert miles (1995)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 21 · CHILDREN DREAM — Robert Miles (1995) → Dream Trance Remix
-// 137 BPM · Am · TR-909 + piano · LA joya dream: piano solo→drops elegantes→coda
+// 137 BPM · Am (Am·F·C·G → raíces a·f·c·g) · TR-909 + piano
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity,
+// armonía con 7as/9as e hi-pass, carácter más duro, riser de ruido.
 // Estructura: piano solo→pads→build→drop A→break central→drop B→coda piano (168 compases ≈ 4:54)
 // ════════════════════════════════════════════════════════════════
 setcps(137/60/4)
@@ -2040,65 +2852,104 @@ const melodiaSinte = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~
   .room(.6).rsize(7).delay(.35).delaytime(.375).delayfeedback(.4)
   .gain(.55).pan(sine.slow(8).range(.35,.65)).orbit(2)
 
-// ── ACORDES DE PIANO (Am·F·C·G, la mano izquierda del sueño) ──
-const pianoAcordes = note("<[a2,e3,a3] [f2,c3,f3] [c3,g3,c4] [g2,d3,g3]>")
-  .s("piano").room(.8).rsize(8)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Am7·Fmaj7·Cmaj7·G7) + contramelodía + hi-pass ──
+const stab = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── ACORDES DE PIANO con 7as (Am·F·C·G, la mano izquierda del sueño) ──
+const pianoAcordes = note("<[a2,e3,g3,a3] [f2,c3,e3,f3] [c3,g3,b3,c4] [g2,d3,f3,g3]>")
+  .s("piano").hpf(120).room(.8).rsize(8)
   .gain(.7).pan(.45).orbit(4)
 
-// ── BAJO ROLLING SUAVE (16avos redondos, progresión Am·F·C·G) ──
+// ── BAJO ROLLING (16avos redondos, sigue las raíces a·f·c·g) ──
 const bajo = note("<a1 f1 c2 g1>").struct("x*16")
   .s("sawtooth").lpf(500).lpq(4)
   .attack(.001).decay(.11).sustain(.25).release(.03)
-  .gain("[.8 .5 .6 .5]*4").shape(.2).orbit(1)
+  .gain("[.8 .5 .6 .5]*4").shape(.24).coarse(1).orbit(1)
 
+// ── SUB que SIGUE la fundamental ──
 const sub = note("<a1 f1 c2 g1>").struct("x*4")
   .s("sine").decay(.3).sustain(.3).gain(.6).orbit(1)
 
-// ── BATERÍA 909 (elegante, nunca agresiva) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ──
+const bajoOff = note("<a2 f2 c3 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.48).gain(.92)
   .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
+const kickBoom = note("<a1 f1 c2 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.58).distort(1.2).gain(.95)
+  .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.65).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.45 .22 .32 .22]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.2,.45)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0)
 const crash = s("cr ~ ~ ~").slow(4).bank("RolandTR909").gain(.45).room(.5).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.15,.75)).speed(saw.slow(4).range(1,1.35)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.26)).hpf(400).orbit(0)
 
-// ── CUERDAS (el colchón que llora detrás del piano) ──
-const cuerdas = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>")
-  .s("supersaw").unison(5).spread(.8).lpf(sine.slow(32).range(500,1400))
+// ── CUERDAS con 7as (el colchón que llora detrás del piano) + hi-pass ──
+const cuerdas = note("<[a2,c3,e3,g3] [f2,a2,c3,e3] [c3,e3,g3,b3] [g2,b2,d3,f3]>")
+  .s("supersaw").unison(5).spread(.8).lpf(sine.slow(32).range(500,1400)).hpf(150)
   .attack(1).release(2).room(.8).rsize(9).gain(.4).orbit(4)
 
 // ── VIENTO (textura del sueño, solo en el breakdown) ──
 const viento = s("wind").slow(8).lpf(1000).room(.9).rsize(9)
   .gain(.22).pan(sine.slow(16).range(.3,.7)).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const pianoSolo = stack(melodia, pianoAcordes)
 const pianoPads = stack(melodia, pianoAcordes, cuerdas.gain(.3), viento)
 const entraKick = stack(kick, hats, melodia.gain(.7), pianoAcordes.gain(.5),
   sub.gain(.4))
-const build = stack(kick, hats16, clap, bajo, melodia.gain(.75),
+const build = stack(kick, hats16, clap, ghost, bajo, melodia.gain(.75),
   cuerdas.gain(.3), sub.gain(.5))
-const buildFin = stack(kick, rodillo, bajo, melodia.gain(.85), cuerdas.gain(.35))
-const dropA = stack(kick, hats16, open, clap, crash, bajo, sub,
-  melodia, melodiaSinte.gain(.4))
-const dropAvar = stack(kick, hats16, open, clap, ride, bajo, sub,
-  melodia, melodiaSinte, cuerdas.gain(.3))
-const breakCentral = stack(melodia, pianoAcordes, cuerdas, viento, sub.gain(.3))
+const buildFin = stack(kick, rodillo, riser, bajo, melodia.gain(.85), cuerdas.gain(.35))
+const dropA = stack(kick, hats16, open, clap, crash, ghost, bajo, sub,
+  melodia, melodiaSinte.gain(.4), leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
+  melodia, melodiaSinte, cuerdas.gain(.3), leadLimpio, stab, contra)
+const breakCentral = stack(melodia, pianoAcordes, cuerdas, viento, sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(melodia, pianoAcordes.gain(.5), cuerdas,
-  rodillo, hats16.gain(.35))
-const dropB = stack(kick, hats16, open, clap, crash, bajo, sub,
-  melodia, melodiaSinte, cuerdas.gain(.35))
-const dropBvar = stack(kick, hats16, open, clap, ride, bajo, sub,
+  riser, rodillo, hats16.gain(.35))
+const dropB = stack(kick, hats16, open, clap, crash, ghost, bajo, sub,
+  melodia, melodiaSinte, cuerdas.gain(.35), leadLimpio, stab)
+const dropBvar = stack(kickHard, hats16, open, clap, ride, ghost, bajo, sub, bajoOff,
   melodia, melodiaSinte.sometimesBy(.2, x=>x.add(note(12)).gain(.35)),
-  cuerdas.gain(.4), pianoAcordes.gain(.4))
+  cuerdas.gain(.4), pianoAcordes.gain(.4), leadLimpio, stab, contra)
 const bajada = stack(kick, hats, bajo.gain(.6), melodia.gain(.8),
   pianoAcordes.gain(.5), cuerdas.gain(.35))
-const codaPiano = stack(melodia, pianoAcordes, cuerdas.gain(.25))
+const codaPiano = stack(melodia, pianoAcordes, cuerdas.gain(.25), leadLimpio.gain(.4))
 const codaFin = stack(melodia.gain(.7).room(.95).delayfeedback(.6),
   pianoAcordes.gain(.4), viento)
 
@@ -2118,14 +2969,18 @@ arrange(
   [12, bajada],
   [8,  codaPiano],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "22 · insomnia — faithless (1995)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 22 · INSOMNIA — Faithless (1995) → Epic Techno Remix
-// 130 BPM · F#m · TR-909 · el arpegio abre su filtro durante TODO el track
+// 130 BPM · F#m (F#m·F#m·D·E → raíces fs·fs·d·e) · TR-909
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo/sub que siguen los acordes (el sub deja de ser nota fija), bajo offbeat,
+// groove swing/ghost/velocity, armonía con 7as/9as e hi-pass, riser de ruido.
 // Estructura: intro→arpegio→build→drop A→breakdown→drop épico→coda (152 compases ≈ 4:41)
 // ════════════════════════════════════════════════════════════════
 setcps(130/60/4)
@@ -2147,55 +3002,93 @@ const hook = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~")
 
 const hookEco = hook.add(note(12)).gain(.26).lpf(4200).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (F#m7·F#m7·Dmaj7·E7) + contramelodía + hi-pass ──
+const stab = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [e3,gs3,b3,d4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a3 ~ fs3 ~ d3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO (corcheas de raíz que siguen la armonía F#m→D→E) ──
 const bajo = note("fs1!8").add(note("<0 0 -4 -2>"))
   .s("sawtooth").lpf(perlin.slow(8).range(400, 900)).lpq(6)
   .attack(.001).decay(.18).sustain(.25).release(.05)
-  .shape(.3).gain(.85).orbit(1)
+  .shape(.32).coarse(1).gain(.85).orbit(1)
 
-const bajoSub = note("fs1*4").s("sine").decay(.35).sustain(.2).gain(.7).orbit(1)
+// ── SUB que ahora SIGUE la fundamental (fs·fs·d·e), ya no nota fija ──
+const bajoSub = note("<fs1 fs1 d1 e1>").struct("x*4")
+  .s("sine").decay(.35).sustain(.2).gain(.7).orbit(1)
 
-// ── BATERÍA 909 (sidechain sobre bajo y lead) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ──
+const bajoOff = note("<fs2 fs2 d2 e2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
+const kickBoom = note("<fs1 fs1 d1 e1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.28).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PADS ÉPICOS ──
-const pad = note("<[fs3,a3,cs4] [fs3,a3,cs4] [d3,fs3,a3] [e3,gs3,b3]>")
-  .s("sawtooth").lpf(750).attack(.9).release(1.6)
+// ── PADS ÉPICOS con 7as + hi-pass ──
+const pad = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [e3,gs3,b3,d4]>")
+  .s("sawtooth").lpf(750).hpf(150).attack(.9).release(1.6)
   .room(.8).rsize(8).gain(.4).orbit(4)
 
 const cuerdas = note("<fs4 fs4 d4 e4>").s("supersaw").unison(6).spread(.8)
-  .lpf(sine.slow(32).range(500, 2400)).attack(.6).release(1)
+  .lpf(sine.slow(32).range(500, 2400)).hpf(200).attack(.6).release(1)
   .room(.7).gain(.32).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introArp = stack(kick, hats, bajoSub.gain(.5), arpegio.gain(.6))
-const build = stack(kick, hats16, clap, bajoSub, arpegio, pad)
-const buildFin = stack(kickHard, rodillo, arpegio, hook.gain(.5).lpf(1500))
-const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio, hook)
-const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio,
-  hook, hookEco, cuerdas.gain(.24))
-const breakdown = stack(arpegio.gain(.65).room(.6), pad, cuerdas)
-const breakBuild = stack(arpegio, arpegioAlto, pad, cuerdas, rodillo, hats16.gain(.4))
-const dropEpic = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub,
-  arpegio, arpegioAlto, hook)
-const dropEpicFull = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub,
-  arpegio, arpegioAlto, hook, hookEco, cuerdas.gain(.26))
-const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
-  arpegio, hook, cuerdas.gain(.24))
-const coda = stack(kick, hats, arpegio.gain(.55), pad, hook.gain(.4).room(.8))
+const build = stack(kick, hats16, clap, ghost, bajoSub, arpegio, pad)
+const buildFin = stack(kickHard, rodillo, riser, arpegio, hook.gain(.5).lpf(1500))
+const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajo, bajoSub, arpegio, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub, bajoOff, arpegio,
+  hook, hookEco, cuerdas.gain(.24), leadLimpio, stab, contra)
+const breakdown = stack(arpegio.gain(.65).room(.6), pad, cuerdas, contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(arpegio, arpegioAlto, pad, cuerdas, riser, rodillo, hats16.gain(.4))
+const dropEpic = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub,
+  arpegio, arpegioAlto, hook, leadLimpio, stab)
+const dropEpicFull = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajo, bajoSub, bajoOff,
+  arpegio, arpegioAlto, hook, hookEco, cuerdas.gain(.26), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, ghost,
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  arpegio, hook, cuerdas.gain(.24), leadLimpio, stab)
+const coda = stack(kick, hats, arpegio.gain(.55), pad, hook.gain(.4).room(.8), leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35), arpegio.gain(.35).room(.85), pad.gain(.3))
 
 // ── ARREGLO (152 compases) ──
@@ -2213,14 +3106,18 @@ arrange(
   [16, dropFinal],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "23 · sandstorm — darude (1999)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 23 · SANDSTORM — Darude (1999) → Hard Trance Remix
-// 138 BPM · Bm · TR-909 · pluck metralleta + bajo offbeat + doble drop con ride
+// 138 BPM · Bm (Bm·G·A·Bm → raíces b·g·a·b) · TR-909
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo offbeat y sub que siguen los acordes (dejan de ser nota fija),
+// groove swing/ghost/velocity, armonía con 7as/9as e hi-pass, carácter duro, riser.
 // Estructura: intro→build→drop A→break→drop B con ride→coda (136 compases ≈ 3:57)
 // ════════════════════════════════════════════════════════════════
 setcps(138/60/4)
@@ -2235,53 +3132,86 @@ const riff = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3
 const riffAlto = riff.add(note(12)).gain(.35).lpf(4200).orbit(2)
 const riffGrave = riff.add(note(-12)).lpf(saw.slow(16).range(400, 2200)).gain(.7).orbit(2)
 
-// ── BAJO OFFBEAT (hard trance clásico) ──
-const bajoOff = note("[~ b1]*4").s("sawtooth").lpf(760).lpq(5)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Bm7·Gmaj7·A7·Bm7) + contramelodía + hi-pass ──
+const stab = note("<[b2,d3,fs3,a3] [g2,b2,d3,fs3] [a2,cs3,e3,g3] [b2,d3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJO OFFBEAT (hard trance clásico, ahora sigue las raíces b·g·a·b) ──
+const bajoOff = note("<b1 g1 a1 b1>").struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(760).lpq(5)
   .attack(.001).decay(.16).sustain(.2).release(.04)
-  .shape(.35).gain(.9).orbit(1)
+  .shape(.35).coarse(1).gain(.9).orbit(1)
 
-const bajoSub = note("b1*4").s("sine").decay(.3).sustain(.15).gain(.6).orbit(1)
+// ── SUB que ahora SIGUE la fundamental (b·g·a·b), ya no nota fija ──
+const bajoSub = note("<b1 g1 a1 b1>").struct("x*4").s("sine")
+  .decay(.3).sustain(.15).gain(.6).orbit(1)
 
-// ── BATERÍA 909 DURA ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
+// ── KICK 909 DURO EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).gain(.94)
   .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.35).gain(1.1)
+const kickBoom = note("<b1 g1 a1 b1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.32).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.62).distort(1.4).gain(.96)
   .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.3,.7)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.32).pan(.35).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.25,.55)).pan(rand.range(.3,.7)).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.32).pan(.35).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
 const rodilloLargo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(8).range(.15,.9)).speed(saw.slow(8).range(1,1.6)).orbit(0)
 const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.5).room(.4).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.3)).hpf(400).orbit(0)
 
-// ── PAD DE FONDO (Bm→G→A) ──
-const pad = note("<[b2,d3,fs3] [g2,b2,d3] [a2,cs3,e3] [b2,d3,fs3]>")
-  .s("sawtooth").lpf(700).attack(.8).release(1.4)
+// ── PAD DE FONDO con 7as (Bm·G·A·Bm) + hi-pass ──
+const pad = note("<[b2,d3,fs3,a3] [g2,b2,d3,fs3] [a2,cs3,e3,g3] [b2,d3,fs3,a3]>")
+  .s("sawtooth").lpf(700).hpf(150).attack(.8).release(1.4)
   .room(.6).rsize(6).gain(.38).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(450).gain(.7))
-const build = stack(kick, hats16, clap, bajoOff, riffGrave, pad.gain(.3))
-const buildFin = stack(kickHard, rodillo, bajoOff, riff.gain(.7))
-const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff)
-const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff,
-  riffAlto, crash)
-const breakdown = stack(pad, riff.gain(.55).room(.7).delayfeedback(.55), hats.gain(.3))
-const breakBuild = stack(pad, riff.gain(.75), rodilloLargo, hats16.gain(.4),
+const build = stack(kick, hats16, clap, ghost, bajoOff, riffGrave, pad.gain(.3))
+const buildFin = stack(kickHard, rodillo, riser, bajoOff, riff.gain(.7))
+const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoOff, bajoSub, riff, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub, riff,
+  riffAlto, crash, leadLimpio, stab, contra)
+const breakdown = stack(pad, riff.gain(.55).room(.7).delayfeedback(.55), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, riff.gain(.75), riser, rodilloLargo, hats16.gain(.4),
   bajoSub.gain(.4))
-const dropB = stack(kickHard, hats16, hatsOpen, clap, ride, bajoOff, bajoSub,
-  riff, riffAlto)
-const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, crash, bajoOff,
-  bajoSub, riff, riffAlto, pad.gain(.25))
-const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride,
-  bajoOff.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), bajoSub, riff, riffAlto)
-const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), riff.gain(.5).room(.6), pad)
+const dropB = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub,
+  riff, riffAlto, leadLimpio, stab)
+const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, crash, ghost, bajoOff,
+  bajoSub, riff, riffAlto, pad.gain(.25), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride, ghost,
+  bajoOff.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), bajoSub, riff, riffAlto, leadLimpio, stab)
+const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), riff.gain(.5).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.65),
   pad.gain(.3))
 
@@ -2300,14 +3230,18 @@ arrange(
   [12, dropFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "24 · blue (da ba dee) — eiffel 65 (1998)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 24 · BLUE (DA BA DEE) — Eiffel 65 (1998) → Eurodance Techno Remix
-// 133 BPM · Gm · TR-909 · lead vocoder con vowel + bajo octavado eurodance
+// 133 BPM · Gm (Gm·Gm·Eb·F → raíces g·g·eb·f) · TR-909
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo/sub que siguen los acordes, bajo offbeat, groove swing/ghost/velocity,
+// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido.
 // Estructura: intro→build→drop A→break→drop B→coda (136 compases ≈ 4:05)
 // ════════════════════════════════════════════════════════════════
 setcps(133/60/4)
@@ -2321,60 +3255,97 @@ const hook = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~")
 
 const hookOctava = hook.add(note(12)).gain(.3).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Gm7·Gm7·Ebmaj7·F7) + contramelodía + hi-pass ──
+const stab = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ d4 ~ bb3 ~ g3 ~] [~ ~ bb3 ~ g3 ~ eb3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── RIFF SINTÉTICO (pluck de apoyo en corcheas) ──
 const riff = note("[g3 bb3 c4 d4]*2").s("square")
   .lpf(1900).attack(.001).decay(.1).sustain(.05).release(.05)
   .delay(.2).delaytime(.1875).delayfeedback(.3)
   .gain(.6).pan(.35).orbit(3)
 
-// ── BAJO OCTAVADO EURODANCE (sigue Gm→Eb→F) ──
+// ── BAJO OCTAVADO EURODANCE (sigue Gm→Eb→F, raíces g·g·eb·f) ──
 const bajo = note("[g1 g2 g1 g2]*2").add(note("<0 0 -4 -2>"))
-  .s("sawtooth").lpf(820).lpq(5)
+  .s("sawtooth").lpf(perlin.slow(4).range(600,1200)).lpq(5)
   .attack(.001).decay(.14).sustain(.3).release(.04)
-  .shape(.3).gain(.9).orbit(1)
+  .shape(.34).coarse(1).gain(.9).orbit(1)
 
+// ── SUB que SIGUE la fundamental (g·g·eb·f) ──
 const bajoSub = note("g1*4").add(note("<0 0 -4 -2>")).s("sine")
   .decay(.3).sustain(.2).gain(.65).orbit(1)
 
-// ── BATERÍA 909 (claps dobles, energía pop) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue las raíces) ──
+const bajoOff = note("<g2 g2 eb2 f2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickDoble = s("<[bd*4] [bd*4] [bd*4] [bd bd bd [bd bd]]>").bank("RolandTR909")
-  .shape(.5).distort(1.1).gain(1.1)
-  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kickBoom = note("<g1 g1 eb1 f1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickDobleClick = s("<[bd*4] [bd*4] [bd*4] [bd bd bd [bd bd]]>").bank("RolandTR909")
+  .hpf(38).shape(.6).distort(1.2).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickDoble = stack(kickDobleClick, kickBoom.gain(1.05))
+
 const clapDoble = s("~ cp ~ [cp cp]").bank("RolandTR909").room(.3).gain(.72).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PADS BRILLANTES ──
-const pad = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>")
+// ── PADS BRILLANTES con 7as + hi-pass ──
+const pad = note("<[g3,bb3,d4,f4] [g3,bb3,d4,f4] [eb3,g3,bb3,d4] [f3,a3,c4,eb4]>")
   .s("supersaw").unison(5).spread(.7)
-  .lpf(sine.slow(16).range(600, 2200)).attack(.5).release(1)
+  .lpf(sine.slow(16).range(600, 2200)).hpf(150).attack(.5).release(1)
   .room(.6).rsize(6).gain(.35).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, hatsOpen, riff.gain(.4), bajo.lpf(400).gain(.6))
-const build = stack(kick, hats16, clapDoble, bajo, riff,
+const build = stack(kick, hats16, clapDoble, ghost, bajo, riff,
   hook.lpf(saw.slow(16).range(400, 2600)).gain(.55))
-const buildFin = stack(kickDoble, rodillo, bajo, hook.gain(.65))
-const dropA = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, hook, riff)
-const dropAvar = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
-  hook, hookOctava, riff, pad.gain(.25))
-const breakdown = stack(pad, hook.gain(.6).room(.75), bajoSub.gain(.35), hats.gain(.3))
-const breakBuild = stack(pad, hook.gain(.75), riff.gain(.5), rodillo, hats16.gain(.4))
-const dropB = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
-  hook, hookOctava, riff)
-const dropBfull = stack(kickDoble, hats16, hatsOpen, clapDoble,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
-  hook, hookOctava, riff, pad.gain(.28))
-const dropFinal = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
-  hook, hookOctava, pad.gain(.25))
-const coda = stack(kick, hats, bajo.lpf(550).gain(.7), hook.gain(.45).room(.7), pad)
+const buildFin = stack(kickDoble, rodillo, riser, bajo, hook.gain(.65))
+const dropA = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, hook, riff, leadLimpio, stab)
+const dropAvar = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, bajoOff,
+  hook, hookOctava, riff, pad.gain(.25), leadLimpio, stab, contra)
+const breakdown = stack(pad, hook.gain(.6).room(.75), bajoSub.gain(.35), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, hook.gain(.75), riff.gain(.5), riser, rodillo, hats16.gain(.4))
+const dropB = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub,
+  hook, hookOctava, riff, leadLimpio, stab)
+const dropBfull = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost,
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  hook, hookOctava, riff, pad.gain(.28), leadLimpio, stab, contra)
+const dropFinal = stack(kickDoble, hats16, hatsOpen, clapDoble, ghost, bajo, bajoSub, bajoOff,
+  hook, hookOctava, pad.gain(.25), leadLimpio, stab)
+const coda = stack(kick, hats, bajo.lpf(550).gain(.7), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.85).delayfeedback(.6),
   pad.gain(.3))
 
@@ -2393,14 +3364,18 @@ arrange(
   [8,  dropFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "25 · better off alone — alice deejay (1998)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 25 · BETTER OFF ALONE — Alice Deejay (1998) → Hands-Up Techno Remix
-// 137 BPM · F#m · TR-909 · pluck ping-pong + pausas dramáticas + supersaw
+// 137 BPM · F#m (F#m·D·A·E → raíces fs·d·a·e) · TR-909
+// PRODUCCIÓN PRO: kick 2 capas + boom afinado que sigue las fundamentales,
+// bajo offbeat/rolling y sub que siguen los acordes, groove swing/ghost/velocity,
+// armonía con 7as/9as e hi-pass, carácter duro peak-time, riser de ruido.
 // Estructura: intro→pluck solo→build→PAUSA→drop A→break→PAUSA→drop B→coda (134 compases ≈ 3:55)
 // ════════════════════════════════════════════════════════════════
 setcps(137/60/4)
@@ -2426,53 +3401,85 @@ const superLead = note(melodia).s("supersaw").unison(6).spread(.8).detune(.18)
   .lpf(3400).attack(.005).decay(.2).sustain(.15).release(.15)
   .room(.5).rsize(5).gain(.55).orbit(3)
 
-// ── BAJOS (offbeat en el drop A, rolling en el drop B; F#m→D→A→E) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("cs5 ~ cs5 ~ fs5 ~ e5 ~ ~ cs5 ~ b4 ~ cs5 ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (F#m7·Dmaj7·Amaj7·E7) + contramelodía + hi-pass ──
+const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,d4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(170).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a3 ~ fs3 ~ d3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b3 ~ gs3 ~ e3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJOS (offbeat en el drop A, rolling en el drop B; siguen fs·d·a·e) ──
 const bajoOff = note("[~ fs1]*4").add(note("<0 -4 3 -2>"))
   .s("sawtooth").lpf(720).lpq(5)
   .attack(.001).decay(.15).sustain(.2).release(.04)
-  .shape(.35).gain(.88).orbit(1)
+  .shape(.35).coarse(1).gain(.88).orbit(1)
 const bajoRoll = note("fs1*16").add(note("<0 -4 3 -2>"))
   .s("sawtooth").lpf(850).lpq(6)
   .attack(.001).decay(.1).sustain(.15).release(.03)
-  .shape(.3).gain("[.85 .45 .6 .45]*4").orbit(1)
+  .shape(.3).coarse(1).gain("[.85 .45 .6 .45]*4").orbit(1)
 const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine")
   .decay(.3).sustain(.15).gain(.6).orbit(1)
 
-// ── BATERÍA 909 ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08)
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las fundamentales ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.52).gain(.94)
   .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
+const kickBoom = note("<fs1 d1 a1 e1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.96)
   .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.52 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.52)).pan(rand.range(.35,.65)).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.45)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PADS ──
-const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
-  .s("sawtooth").lpf(720).attack(.8).release(1.5)
+// ── PADS con 7as + hi-pass ──
+const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,d4]>")
+  .s("sawtooth").lpf(720).hpf(150).attack(.8).release(1.5)
   .room(.7).rsize(7).gain(.38).orbit(4)
 
+// ── RISER de ruido filtrado para las subidas ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES (la PAUSA deja el pluck solo, flotando antes del drop) ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(420).gain(.65))
 const pluckSolo = stack(pluck, kick.gain(.9), hats.gain(.4))
-const build = stack(kick, hats16, clap, bajoOff, pluck, pad.gain(.3))
+const build = stack(kick, hats16, clap, ghost, bajoOff, pluck, pad.gain(.3))
 const pausa = stack(pluck.gain(.95).room(.7).delayfeedback(.6), silence)
-const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub,
-  pluck, pluckOctava)
-const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub,
-  pluck, pluckOctava, pad.gain(.25))
-const breakdown = stack(pad, pluck.gain(.6).room(.7), bajoSub.gain(.3), hats.gain(.3))
-const breakBuild = stack(pad, pluck, rodillo, hats16.gain(.4))
-const dropB = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub,
-  pluck, superLead)
-const dropBfull = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub,
-  pluck, pluckOctava, superLead, pad.gain(.25))
-const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), pluck.gain(.5).room(.6), pad)
+const dropA = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoOff, bajoSub,
+  pluck, pluckOctava, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoOff, bajoSub,
+  pluck, pluckOctava, pad.gain(.25), leadLimpio, stab, contra)
+const breakdown = stack(pad, pluck.gain(.6).room(.7), bajoSub.gain(.3), hats.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, pluck, riser, rodillo, hats16.gain(.4))
+const dropB = stack(kickHard, hats16, hatsOpen, clap, ghost, bajoRoll, bajoSub,
+  pluck, superLead, leadLimpio, stab)
+const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, ghost, bajoRoll, bajoSub,
+  pluck, pluckOctava, superLead, pad.gain(.25), leadLimpio, stab, contra)
+const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), pluck.gain(.5).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), pluck.gain(.3).room(.85).delayfeedback(.65),
   pad.gain(.3))
 
@@ -2492,14 +3499,18 @@ arrange(
   [16, dropBfull],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "26 · born slippy .nuxx — underworld (1995)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 26 · BORN SLIPPY .NUXX — Underworld (1995) → Progressive Techno Remix
-// 140 BPM · E · TR-909 · lead celestial 16 compases → kick brutal SIN bajo + toms
+// 140 BPM · E (i·i·IV·V = Em? -> E·E·A·B) · TR-909 · lead celestial
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue E-A-B),
+// sub que sigue los acordes + bajo offbeat, groove swing/ghost/velocity,
+// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido.
 // Estructura: lead solo→kick entra→toms→drop A→break→drop B→coda (140 compases ≈ 4:00)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -2514,23 +3525,60 @@ const lead = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~")
 const leadOctava = lead.add(note(12)).gain(.28).lpf(4500).orbit(2)
 const leadGrave = lead.add(note(-12)).gain(.45).lpf(1400).orbit(2)
 
-// ── PADS ELÉCTRICOS ENORMES (E→A→B) ──
-const pad = note("<[e3,gs3,b3] [e3,gs3,b3] [a3,cs4,e4] [b3,ds4,fs4]>")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Eadd9·Eadd9·Aadd9·B7) + hi-pass ──
+const stab = note("<[e3,gs3,b3,fs4] [e3,gs3,b3,fs4] [a3,cs4,e4,b4] [b3,ds4,fs4,a4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("2:4").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ b3 ~ gs3 ~ e3 ~] [~ ~ b3 ~ gs3 ~ e3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ ds4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── PADS ELÉCTRICOS ENORMES (E→A→B, 7as/9as + hi-pass para dejar respirar el sub) ──
+const pad = note("<[e3,gs3,b3,fs4] [e3,gs3,b3,fs4] [a3,cs4,e4,b4] [b3,ds4,fs4,a4]>")
   .s("supersaw").unison(6).spread(.85)
-  .lpf(sine.slow(32).range(500, 2000)).attack(1).release(2)
+  .lpf(sine.slow(32).range(500, 2000)).hpf(150).attack(1).release(2)
   .room(.9).rsize(9).gain(.4).orbit(4)
 
-// ── BATERÍA (distorsión creciente, toms marciales, SIN bajo: bombo+lead) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
+// ── SUB-BAJO que SIGUE la fundamental de cada acorde (E·E·A·B) ──
+const bajoSub = note("<e1 e1 a0 b0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04)
+  .gain(.68).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el 4x4, pulsa en las "y") solo en los drops grandes ──
+const bajoOff = note("<e2 e2 a1 b1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("2").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue E-A-B ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("2:4").duckattack(.1).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.3).gain(1.1)
+const kickBoom = note("<e1 e1 a0 b0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("2:4").duckattack(.1).duckdepth(.6).orbit(0)
-const kickBrutal = s("bd*4").bank("RolandTR909").shape(.65).distort(1.6).gain(1.1)
+const kickBrutalClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.65).distort(1.6).gain(.97)
   .duck("2:4").duckattack(.1).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+const kickBrutal = stack(kickBrutalClick, kickBoom.gain(1.08))
 const snare = s("~ sd ~ sd").bank("RolandTR909").shape(.3).room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0)
+// hats con SWING + velocity humanizada
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.3,.7)).orbit(0)
 const tomsMarcial = s("ht mt ~ lt ~ mt ht lt").bank("RolandTR909")
   .shape(.25).gain(.62).pan(sine.fast(2).range(.3,.7)).orbit(0)
 const tomsFuria = s("[ht ht] mt [mt lt] lt [ht mt] lt [mt mt] [lt lt]").bank("RolandTR909")
@@ -2538,22 +3586,27 @@ const tomsFuria = s("[ht ht] mt [mt lt] lt [ht mt] lt [mt mt] [lt lt]").bank("Ro
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
 const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.5).room(.4).orbit(0)
+// ghost snare sincopada (dinámica de velocity aleatoria)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const leadSolo = stack(lead.gain(.85), silence)
 const leadCoro = stack(lead.gain(.85), leadOctava, pad.gain(.3))
-const kickEntra = stack(kick, lead.gain(.7), hats.gain(.35))
-const kickLead = stack(kick, hats, snare.gain(.5), lead, leadGrave.gain(.3))
-const tomsBuild = stack(kickHard, tomsMarcial, rodillo, lead.gain(.65))
-const dropA = stack(kickHard, hats16, snare, tomsMarcial, lead, leadGrave)
-const dropAvar = stack(kickHard, hats16, snare, tomsMarcial, crash,
-  lead, leadOctava, leadGrave)
-const breakdown = stack(pad, lead.gain(.6), hats.gain(.25))
-const breakBuild = stack(pad, lead.gain(.8), leadOctava, rodillo, hats16.gain(.35))
-const dropB = stack(kickBrutal, hats16, snare, tomsFuria, lead, leadGrave)
-const dropBfull = stack(kickBrutal, hats16, snare, tomsFuria, crash,
-  lead, leadOctava, leadGrave, pad.gain(.25))
-const coda = stack(kick, hats, lead.gain(.55).room(.9), pad)
+const kickEntra = stack(kick, lead.gain(.7), hats.gain(.35), bajoSub.gain(.4))
+const kickLead = stack(kick, hats, snare.gain(.5), lead, leadGrave.gain(.3), bajoSub)
+const tomsBuild = stack(kickHard, tomsMarcial, rodillo, riser, bajoSub, lead.gain(.65))
+const dropA = stack(kickHard, hats16, snare, tomsMarcial, ghost, bajoSub, lead, leadGrave, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, snare, tomsMarcial, crash, ghost, bajoSub, bajoOff,
+  lead, leadOctava, leadGrave, leadLimpio, stab, contra)
+const breakdown = stack(pad, lead.gain(.6), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, lead.gain(.8), leadOctava, rodillo, riser, hats16.gain(.35))
+const dropB = stack(kickBrutal, hats16, snare, tomsFuria, ghost, bajoSub, lead, leadGrave, leadLimpio, stab)
+const dropBfull = stack(kickBrutal, hats16, snare, tomsFuria, crash, ghost, bajoSub, bajoOff,
+  lead, leadOctava, leadGrave, pad.gain(.25), leadLimpio, stab, contra)
+const coda = stack(kick, hats, bajoSub, lead.gain(.55).room(.9), pad, leadLimpio.gain(.4))
 const codaFin = stack(lead.gain(.4).room(.95).delayfeedback(.6), pad.gain(.3))
 
 // ── ARREGLO (140 compases) ──
@@ -2571,14 +3624,18 @@ arrange(
   [16, dropBfull],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "27 · mr. vain — culture beat (1993)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 27 · MR. VAIN — Culture Beat (1993) → Eurotechno Remix
-// 133 BPM · Cm · TR-909 · stabs FM metálicos + corte hpf + acid suave al final
+// 133 BPM · Cm (i·i·VI·VII = Cm·Cm·Ab·Bb) · TR-909 · stabs FM metálicos
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue C-Ab-Bb),
+// bajo + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity,
+// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido.
 // Estructura: intro→build→drop A→break hpf→drop acid→coda (136 compases ≈ 4:05)
 // ════════════════════════════════════════════════════════════════
 setcps(133/60/4)
@@ -2593,13 +3650,40 @@ const riff = note("c5 bb4 g4 bb4 c5 bb4 g4 f4")
 const riffHpf = riff.hpf(900).gain(.65).room(.5).orbit(2)
 const riffApoyo = riff.add(note(-12)).fm(5).gain(.4).orbit(2)
 
-// ── EL BAJO (groove noventero exacto) ──
-const bajo = note("c2 ~ c2 c2 ~ c2 eb2 f2")
-  .s("sawtooth").lpf(830).lpq(6)
-  .attack(.001).decay(.13).sustain(.2).release(.04)
-  .shape(.35).gain(.92).orbit(1)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("c5 bb4 g4 bb4 c5 bb4 g4 f4")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
 
-const bajoSub = note("c1*4").s("sine").decay(.3).sustain(.2).gain(.65).orbit(1)
+// ── ZONA MEDIA: stab armónico con 7as/9as (Cm7·Cm7·Abmaj7·Bb7) + hi-pass ──
+const stab = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ f4 ~ d4 ~ bb3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── EL BAJO (groove noventero, AHORA sigue el acorde: C·C·Ab·Bb) ──
+const bajo = note("<[c2 ~ c2 c2 ~ c2 eb2 f2] [c2 ~ c2 c2 ~ c2 eb2 f2] [ab1 ~ ab1 ab1 ~ ab1 c2 eb2] [bb1 ~ bb1 bb1 ~ bb1 d2 f2]>")
+  .s("sawtooth").lpf(perlin.slow(4).range(600, 1300)).lpq(8)
+  .attack(.001).decay(.13).sustain(.2).release(.04)
+  .shape(.34).coarse(1).gain(.9).orbit(1)
+
+// ── SUB-BAJO afinado que SIGUE la fundamental (C·C·Ab·Bb) ──
+const bajoSub = note("<c1 c1 ab0 bb0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.65).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ──
+const bajoOff = note("<c2 c2 ab1 bb1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
 
 // ── CAPA ACID SUAVE (segunda mitad) ──
 const acid = note("c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [f2 eb2] c2")
@@ -2609,45 +3693,56 @@ const acid = note("c2 [~ c2] g2 [c2 c3] bb2 [~ c2] [f2 eb2] c2")
   .shape(.3).gain(.68).rarely(x=>x.add(note(12)))
   .delay(.22).delaytime(.1875).delayfeedback(.3).orbit(3)
 
-// ── BATERÍA 909 CON GROOVE (swing sutil + rim fantasma) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue C-Ab-Bb ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.42).gain(.92)
   .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
+const kickBoom = note("<c1 c1 ab0 bb0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.2).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.28).gain(.72).orbit(0)
 const rim = s("[~ rim]*4").bank("RolandTR909").gain(rand.range(.2,.45)).pan(.3).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909").swingBy(.06, 8)
-  .gain("[.5 .25 .36 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
+// hats con SWING + velocity humanizada
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.48).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare sincopada
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD (Cm→Ab→Bb) ──
-const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>")
-  .s("sawtooth").lpf(700).attack(.8).release(1.5)
+// ── PAD (Cm→Ab→Bb, 7as/9as + hi-pass) ──
+const pad = note("<[c3,eb3,g3,bb3] [c3,eb3,g3,bb3] [ab2,c3,eb3,g3] [bb2,d3,f3,ab3]>")
+  .s("sawtooth").lpf(700).hpf(150).attack(.8).release(1.5)
   .room(.65).rsize(6).gain(.38).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
-const introB = stack(kick, hats, hatsOpen, rim.gain(.3), bajo.lpf(420).gain(.65))
-const build = stack(kick, hats16, clap, bajo, riffApoyo,
+const introB = stack(kick, hats, hatsOpen, rim.gain(.3), bajoSub.gain(.5), bajo.lpf(420).gain(.65))
+const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, riffApoyo, riser,
   riff.lpf(saw.slow(16).range(400, 2500)).gain(.55))
-const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65))
-const dropA = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub, riff)
-const dropAvar = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub,
-  riff, riffApoyo, pad.gain(.24))
-const breakHpf = stack(riffHpf, pad, hats.gain(.3), clap.gain(.4))
-const breakBuild = stack(riffHpf.gain(.75), pad, rodillo, hats16.gain(.4),
+const buildFin = stack(kickHard, rodillo, riser, bajo, bajoSub, riff.gain(.65))
+const dropA = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, bajo, bajoSub, riff, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, bajo, bajoSub, bajoOff,
+  riff, riffApoyo, pad.gain(.24), leadLimpio, stab, contra)
+const breakHpf = stack(riffHpf, pad, hats.gain(.3), clap.gain(.4), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(riffHpf.gain(.75), pad, rodillo, riser, hats16.gain(.4),
   bajoSub.gain(.4))
-const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub,
-  riff.gain(.6))
-const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, rim, acid,
-  bajo, bajoSub, riff, pad.gain(.24))
-const dropFinal = stack(kickHard, hats16, hatsOpen, clap, rim,
-  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
-  riff, riffApoyo, acid.gain(.5))
-const coda = stack(kick, hats, bajo.lpf(500).gain(.7), riff.gain(.5).room(.6), pad)
+const dropAcid = stack(kickHard, hats16, hatsOpen, clap, ghost, acid, bajoSub,
+  riff.gain(.6), leadLimpio, stab)
+const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, rim, ghost, acid,
+  bajo, bajoSub, bajoOff, riff, pad.gain(.24), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, hatsOpen, clap, rim, ghost,
+  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  riff, riffApoyo, acid.gain(.5), leadLimpio, stab)
+const coda = stack(kick, hats, bajo.lpf(500).gain(.7), bajoSub.gain(.5), riff.gain(.5).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.4), riff.gain(.3).room(.85).delayfeedback(.6),
   pad.gain(.3))
 
@@ -2666,14 +3761,18 @@ arrange(
   [8,  dropFinal],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "28 · smells like teen spirit — nirvana (1991)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 28 · SMELLS LIKE TEEN SPIRIT — Nirvana (1991) → Industrial Techno Remix
-// 135 BPM · Fm · TR-909 · muro de power chords + snare metálica + reese
+// 135 BPM · Fm (i·i·VI·bII = Fm·Fm·Ab·Db) · TR-909 · muro de power chords
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue F-Ab-Db),
+// reese + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity,
+// stabs con 7as/9as + hi-pass, carácter peak-time (distorsión) + riser de ruido.
 // Estructura: intro→build→drop A→break susurrado→drop B→coda (144 compases ≈ 4:16)
 // ════════════════════════════════════════════════════════════════
 setcps(135/60/4)
@@ -2696,55 +3795,92 @@ const voz = note("f4 ab4 f4 eb4 f4 ~ c4 ~")
 
 const vozOctava = voz.add(note(12)).gain(.25).orbit(2)
 
-// ── REESE INDUSTRIAL (supersaw desafinado grave) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("f4 ab4 f4 eb4 f4 ~ c4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Fm7·Fm7·Abmaj7·Dbmaj7) + hi-pass ──
+const stab = note("<[f2,ab2,c3,eb3] [f2,ab2,c3,eb3] [ab2,c3,eb3,g3] [db3,f3,ab3,c4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ c4 ~ ab3 ~ f3 ~] [~ ~ eb4 ~ c4 ~ ab3 ~] [~ ~ ab4 ~ f4 ~ db4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── REESE INDUSTRIAL que SIGUE las fundamentales (F·F·Ab·Db) ──
 const reese = note("<f1 f1 ab1 db1>")
   .s("supersaw").unison(3).detune(.5).spread(.9)
   .lpf(520).attack(.04).decay(.3).sustain(.75).release(.2)
-  .shape(.2).gain(.75).orbit(1)
+  .shape(.28).gain(.75).orbit(1)
 
-const bajoSub = note("f1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (F·F·Ab·Db) ──
+const bajoSub = note("<f1 f1 ab0 db1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA INDUSTRIAL (kick distorsionado + snare de chatarra) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1)
+// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ──
+const bajoOff = note("<f2 f2 ab1 db2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── BATERÍA INDUSTRIAL: kick 2 capas (click distorsionado + boom afinado) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.55).distort(1.1).gain(.95)
   .duck("1:3").duckattack(.1).duckdepth(.55).orbit(0)
-const kickBrutal = s("<[bd*4] [bd*4] [bd [bd bd] bd bd] [bd*4]>").bank("RolandTR909")
-  .shape(.65).distort(1.45).gain(1.1)
+const kickBoom = note("<f1 f1 ab0 db1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickBrutalClick = s("<[bd*4] [bd*4] [bd [bd bd] bd bd] [bd*4]>").bank("RolandTR909")
+  .hpf(38).shape(.65).distort(1.45).gain(.97)
   .duck("1:3").duckattack(.1).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickBrutal = stack(kickBrutalClick, kickBoom.gain(1.05))
 const snareMetal = s("~ metal ~ metal").speed(1.8).hpf(900)
   .shape(.3).room(.3).gain(.55).orbit(0)
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.6).orbit(0)
-const hatsInd = s("hh*8").bank("RolandTR909").crush(6)
+const hatsInd = s("hh*8").bank("RolandTR909").crush(6).swingBy(1/24,8)
   .gain("[.5 .28]*4").pan(rand.range(.3,.7)).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909").crush(8)
-  .gain("[.5 .22 .35 .22]*4").orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").crush(8).swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909").shape(.3)
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
+// ghost snare sincopada
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD OSCURO ──
-const pad = note("<[f2,ab2,c3] [f2,ab2,c3] [ab2,c3,eb3] [db3,f3,ab3]>")
-  .s("sawtooth").lpf(600).attack(1).release(1.8)
+// ── PAD OSCURO (7as/9as + hi-pass) ──
+const pad = note("<[f2,ab2,c3,eb3] [f2,ab2,c3,eb3] [ab2,c3,eb3,g3] [db3,f3,ab3,c4]>")
+  .s("sawtooth").lpf(600).hpf(150).attack(1).release(1.8)
   .room(.8).rsize(8).gain(.35).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hatsInd.gain(.35), bajoSub.gain(.4))
-const introB = stack(kick, hatsInd, clap.gain(.45), chords.lpf(500).gain(.55))
-const build = stack(kick, hats16, clap, reese,
+const introB = stack(kick, hatsInd, clap.gain(.45), bajoSub.gain(.5), chords.lpf(500).gain(.55))
+const build = stack(kick, hats16, clap, ghost, reese, bajoSub, riser,
   chords.lpf(saw.slow(16).range(500, 2400)))
-const buildFin = stack(kickBrutal, rodillo, reese, chords)
-const dropA = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, chords)
-const dropAvar = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
-  chords, chordsAlto, voz.gain(.4))
-const breakSusurro = stack(pad, voz, vozOctava, bajoSub.gain(.3), hatsInd.gain(.25))
-const breakBuild = stack(pad, voz, chords.gain(.55).lpf(1200), rodillo,
+const buildFin = stack(kickBrutal, rodillo, riser, reese, bajoSub, chords)
+const dropA = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, chords, leadLimpio, stab)
+const dropAvar = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, bajoOff,
+  chords, chordsAlto, voz.gain(.4), leadLimpio, stab, contra)
+const breakSusurro = stack(pad, voz, vozOctava, bajoSub.gain(.3), hatsInd.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, voz, chords.gain(.55).lpf(1200), rodillo, riser,
   hats16.gain(.35))
-const dropB = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
-  chords, voz.gain(.5))
-const dropBfull = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
-  chords, chordsAlto, voz, pad.gain(.25))
-const dropFinal = stack(kickBrutal, hats16, snareMetal, clap,
-  reese.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
-  chords, chordsAlto)
-const coda = stack(kick, hatsInd, chords.gain(.5).lpf(900), voz.gain(.5), pad)
+const dropB = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub,
+  chords, voz.gain(.5), leadLimpio, stab)
+const dropBfull = stack(kickBrutal, hats16, snareMetal, clap, ghost, reese, bajoSub, bajoOff,
+  chords, chordsAlto, voz, pad.gain(.25), leadLimpio, stab, contra)
+const dropFinal = stack(kickBrutal, hats16, snareMetal, clap, ghost,
+  reese.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  chords, chordsAlto, leadLimpio, stab)
+const coda = stack(kick, hatsInd, chords.gain(.5).lpf(900), voz.gain(.5), pad, leadLimpio.gain(.4))
 const codaFin = stack(voz.gain(.4).room(.9), pad.gain(.3), hatsInd.gain(.3))
 
 // ── ARREGLO (144 compases) ──
@@ -2762,14 +3898,18 @@ arrange(
   [8,  dropFinal],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "29 · your woman — white town (1997)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 29 · YOUR WOMAN — White Town (1997) → Minimal Electro Remix
-// 125 BPM · Dm · TR-808 · trompeta telefónica (square+crush) + electro roto
+// 125 BPM · Dm (i·i·VI·V = Dm·Dm·Bb·A) · TR-808 · trompeta telefónica
+// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue D-Bb-A,
+// respetando el patrón roto), bajo + sub que siguen las fundamentales + bajo
+// offbeat, groove swing/ghost/velocity, pad con 7as/9as + hi-pass, riser de ruido.
 // Estructura: intro→build→drop A→break robótico→drop B→coda (132 compases ≈ 4:13)
 // ════════════════════════════════════════════════════════════════
 setcps(125/60/4)
@@ -2783,18 +3923,39 @@ const trompeta = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~")
 
 const trompetaBaja = trompeta.add(note(-12)).gain(.3).orbit(2)
 
-// ── BAJO ELECTRO SINCOPADO ──
-const bajo = note("d2 ~ [~ d2] a1")
-  .s("sawtooth").coarse(2).lpf(700).lpq(5)
-  .attack(.001).decay(.14).sustain(.2).release(.04)
-  .shape(.3).gain(.9).orbit(1)
+// ── LEAD LIMPIO (la trompeta "your woman", nítida y al frente) ──
+const leadLimpio = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.005).decay(.2).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.55).pan(.5).orbit(2)
 
-const bajoVar = note("d2 ~ [~ d2] [a1 c2]")
-  .s("sawtooth").coarse(2).lpf(750).lpq(5)
-  .attack(.001).decay(.14).sustain(.2).release(.04)
-  .shape(.3).gain(.9).orbit(1)
+// ── CONTRAMELODÍA (zona media, Dm·Dm·Bb·A) ──
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ bb4 ~ f4 ~ d4 ~] [~ ~ a4 ~ e4 ~ cs4 ~]>")
+  .s("triangle").lpf(2700).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.3).pan(.62).orbit(3)
 
-const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.18).gain(.55).orbit(1)
+// ── BAJO ELECTRO SINCOPADO (AHORA sigue el acorde: D·D·Bb·A) ──
+const bajo = note("<[d2 ~ [~ d2] a1] [d2 ~ [~ d2] a1] [bb1 ~ [~ bb1] f1] [a1 ~ [~ a1] e1]>")
+  .s("sawtooth").coarse(2).lpf(perlin.slow(4).range(600, 1100)).lpq(6)
+  .attack(.001).decay(.14).sustain(.2).release(.04)
+  .shape(.32).gain(.9).orbit(1)
+
+const bajoVar = note("<[d2 ~ [~ d2] [a1 c2]] [d2 ~ [~ d2] [a1 c2]] [bb1 ~ [~ bb1] [f1 a1]] [a1 ~ [~ a1] [e1 g1]]>")
+  .s("sawtooth").coarse(2).lpf(perlin.slow(4).range(650, 1150)).lpq(6)
+  .attack(.001).decay(.14).sustain(.2).release(.04)
+  .shape(.32).gain(.9).orbit(1)
+
+// ── SUB-BAJO afinado que SIGUE la fundamental (D·D·Bb·A) ──
+const bajoSub = note("<d1 d1 bb0 a0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.18).release(.04).gain(.55).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el patrón) solo en los drops grandes ──
+const bajoOff = note("<d2 d2 bb1 a1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.36).duck("1").orbit(1)
 
 // ── VOZ ROBÓTICA (números hablados triturados) ──
 const robot = s("numbers").n("<0 1 2 3>").crush(6).lpf(2000)
@@ -2804,41 +3965,50 @@ const robot = s("numbers").n("<0 1 2 3>").crush(6).lpf(2000)
 const piano = note("[d3,f3,a3] ~ [c3,e3,g3] ~").slow(2).s("piano")
   .crush(8).room(.5).gain(.5).orbit(3)
 
-// ── BATERÍA ELECTRO 808 (patrón roto, nada de 4x4) ──
-const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.35).gain(1.05)
+// ── BATERÍA ELECTRO 808: kick 2 capas (click 808 + boom afinado), patrón roto ──
+const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.35).gain(.92)
   .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0)
+const kickBoom = note("<d1 d1 bb0 a0>").struct("x ~ ~ x ~ ~ x ~").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kick = stack(kickClick, kickBoom)
 const snare = s("~ ~ sd ~ ~ ~ sd ~").bank("RolandTR808").gain(.8).orbit(0)
 const rimGhost = s("[~ rim]*4").bank("RolandTR808")
   .gain(rand.range(.15,.4)).pan(rand.range(.3,.7)).orbit(0)
-const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").crush(8).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR808")
-  .gain("[.45 .2 .3 .2]*4").crush(8).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0)
+const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8).gain("[.5 .25]*4").crush(8).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR808").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).crush(8).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR808").nudge(.004).gain(.4).orbit(0)
 const toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808").gain(.55).pan(.35).orbit(0)
+// ghost snare sincopada
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD MINIMAL ──
-const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [a2,c3,e3]>")
-  .s("sawtooth").lpf(550).attack(1).release(1.6)
+// ── PAD MINIMAL (7as/9as + hi-pass) ──
+const pad = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [bb2,d3,f3,a3] [a2,c3,e3,g3]>")
+  .s("sawtooth").lpf(550).hpf(150).attack(1).release(1.6)
   .room(.6).rsize(6).gain(.32).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
-const introB = stack(kick, snare.gain(.5), hats, bajo.lpf(400).gain(.6))
-const build = stack(kick, snare, hats16, rimGhost, bajo,
-  trompeta.lpf(saw.slow(16).range(500, 2100)).gain(.55))
-const dropA = stack(kick, snare, hats, hatsOpen, rimGhost, bajo, bajoSub, trompeta)
-const dropAvar = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
-  bajoVar, bajoSub, trompeta, trompetaBaja)
+const introB = stack(kick, snare.gain(.5), hats, bajoSub.gain(.5), bajo.lpf(400).gain(.6))
+const build = stack(kick, snare, hats16, rimGhost, ghost, bajo, bajoSub, riser,
+  trompeta.lpf(saw.slow(16).range(500, 2100)).gain(.55), leadLimpio.gain(.45))
+const dropA = stack(kick, snare, hats, hatsOpen, rimGhost, ghost, bajo, bajoSub, trompeta, leadLimpio, contra)
+const dropAvar = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms,
+  bajoVar, bajoSub, bajoOff, trompeta, trompetaBaja, leadLimpio, contra)
 const breakRobot = stack(pad, robot, piano, trompeta.gain(.5).room(.6),
-  hats.gain(.25))
-const breakBuild = stack(pad, trompeta.gain(.7), robot, hats16.gain(.35),
+  hats.gain(.25), leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, trompeta.gain(.7), robot, riser, hats16.gain(.35),
   bajo.gain(.6))
-const dropB = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
-  bajo, bajoSub, trompeta, robot.gain(.35))
-const dropBfull = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
-  bajoVar, bajoSub, trompeta, trompetaBaja, piano.gain(.3))
+const dropB = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms,
+  bajo, bajoSub, trompeta, robot.gain(.35), leadLimpio, contra)
+const dropBfull = stack(kick, snare, hats16, hatsOpen, rimGhost, ghost, toms,
+  bajoVar, bajoSub, bajoOff, trompeta, trompetaBaja, piano.gain(.3), leadLimpio, contra)
 const coda = stack(kick, hats, bajo.lpf(450).gain(.65),
-  trompeta.gain(.45).room(.6), pad)
+  trompeta.gain(.45).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), trompeta.gain(.3).room(.8).delayfeedback(.6),
   pad.gain(.25))
 
@@ -2855,25 +4025,36 @@ arrange(
   [16, dropBfull],
   [12, coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "30 · around the world — daft punk (1997)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 30 · AROUND THE WORLD — Daft Punk (1997) → French Techno Remix
-// 121 BPM · Am · TR-909 · el bajo es el rey · todo respira con el filtro lento
+// 121 BPM · Am (i·VII·VI·VII = Am·G·F·G) · TR-909 · el bajo es el rey
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue A-G-F),
+// bajo rey + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity,
+// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido.
 // Estructura: intro→build→drop A→break filtrado→drop B→coda (144 compases ≈ 4:46)
 // ════════════════════════════════════════════════════════════════
 setcps(121/60/4)
 
-// ── EL BAJO REY (línea exacta, filter house francés) ──
-const bajo = note("a1 a2 g2 a2 e2 g2 a1 ~")
+// ── EL BAJO REY (groove filter-house, AHORA sigue el acorde: Am·G·F·G) ──
+const bajo = note("<[a1 a2 g2 a2 e2 g2 a1 ~] [g1 g2 f2 g2 d2 f2 g1 ~] [f1 f2 e2 f2 c2 e2 f1 ~] [g1 g2 f2 g2 d2 f2 g1 ~]>")
   .s("sawtooth").lpf(sine.slow(32).range(320, 1700)).lpq(6)
   .attack(.001).decay(.2).sustain(.35).release(.05)
-  .shape(.3).gain(.95).orbit(1)
+  .shape(.32).coarse(1).gain(.95).orbit(1)
 
-const bajoSub = note("a1*4").s("sine").decay(.3).sustain(.2).gain(.55).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (A·G·F·G) ──
+const bajoSub = note("<a1 g1 f1 g1>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.2).release(.04).gain(.55).orbit(1)
+
+// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ──
+const bajoOff = note("<a2 g2 f2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
 
 // ── EL VOCODER (interpretación, vocales sintéticas que respiran) ──
 const vocoder = note("e4 e4 d4 c4 d4 e4 ~ ~")
@@ -2885,54 +4066,84 @@ const vocoder = note("e4 e4 d4 c4 d4 e4 ~ ~")
 
 const vocoderAlto = vocoder.add(note(12)).gain(.28).orbit(2)
 
-// ── STAB FUNKY (acorde filtrado, discoteca francesa) ──
+// ── LEAD LIMPIO (la melodía real -vocoder-, nítida y al frente) ──
+const leadLimpio = note("e4 e4 d4 c4 d4 e4 ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (Am7·G7·Fmaj7·G7) + hi-pass ──
+const stabArm = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── STAB FUNKY (acorde filtrado, discoteca francesa) + hi-pass ──
 const stab = note("~ [a3,c4,e4] ~ [a3,c4,e4] ~ ~ [g3,b3,d4] ~")
-  .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7)
+  .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7).hpf(160)
   .attack(.002).decay(.14).sustain(.05).release(.05)
   .phaser(2).phaserdepth(.5)
   .gain(.55).pan(.4).orbit(3)
 
-// ── BATERÍA FRANCESA (hats con phaser, groove disco) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── BATERÍA FRANCESA: kick 2 capas (click 909 + boom afinado que sigue A-G-F) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.4).gain(.92)
   .duck("1:2").duckattack(.13).duckdepth(.6).orbit(0)
-const kickFuerte = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.08)
+const kickBoom = note("<a1 g1 f1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickFuerteClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).distort(1.1).gain(.95)
   .duck("1:2").duckattack(.13).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickFuerte = stack(kickFuerteClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.7).orbit(0)
-const hatsPhaser = s("[~ hh]*4").bank("RolandTR909")
+const hatsPhaser = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8)
   .phaser(4).phaserdepth(.7).gain(.55).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .38 .25]*4").phaser(2).phaserdepth(.5)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).phaser(2).phaserdepth(.5)
   .pan(rand.range(.35,.65)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.5).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.8)).speed(saw.slow(4).range(1,1.35)).orbit(0)
+// ghost snare sincopada
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PAD QUE RESPIRA (Am→G→F→G) ──
-const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>")
-  .s("sawtooth").lpf(sine.slow(32).range(400, 1200)).attack(.9).release(1.6)
+// ── PAD QUE RESPIRA (Am→G→F→G, 7as/9as + hi-pass) ──
+const pad = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .s("sawtooth").lpf(sine.slow(32).range(400, 1200)).hpf(150).attack(.9).release(1.6)
   .room(.6).rsize(6).gain(.36).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hatsPhaser, bajoSub.gain(.4))
-const introB = stack(kick, hatsPhaser, hatsOpen, clap.gain(.5),
+const introB = stack(kick, hatsPhaser, hatsOpen, clap.gain(.5), bajoSub.gain(.5),
   bajo.lpf(sine.slow(32).range(250, 700)).gain(.7))
-const build = stack(kick, hats16, clap, bajo, stab.gain(.4),
+const build = stack(kick, hats16, clap, ghost, bajo, bajoSub, stab.gain(.4), riser,
   vocoder.lpf(saw.slow(16).range(400, 2200)).gain(.5))
-const buildFin = stack(kickFuerte, rodillo, bajo, vocoder.gain(.6))
-const dropA = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, vocoder, stab)
-const dropAvar = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
-  vocoder, vocoderAlto, stab, pad.gain(.24))
+const buildFin = stack(kickFuerte, rodillo, riser, bajo, bajoSub, vocoder.gain(.6))
+const dropA = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, vocoder, stab, leadLimpio, stabArm)
+const dropAvar = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, bajoOff,
+  vocoder, vocoderAlto, stab, pad.gain(.24), leadLimpio, stabArm, contra)
 const breakFiltro = stack(bajo.lpf(sine.slow(8).range(200, 900)).gain(.85),
-  vocoder.gain(.55).room(.6), pad, hatsPhaser.gain(.3))
-const breakBuild = stack(bajo, vocoder.gain(.7), pad, rodillo, hats16.gain(.4))
-const dropB = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
-  vocoder, vocoderAlto, stab)
-const dropBfull = stack(kickFuerte, hats16, hatsOpen, clap,
+  vocoder.gain(.55).room(.6), pad, hatsPhaser.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(bajo, vocoder.gain(.7), pad, rodillo, riser, hats16.gain(.4))
+const dropB = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub,
+  vocoder, vocoderAlto, stab, leadLimpio, stabArm)
+const dropBfull = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajoOff,
   bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
-  vocoder, vocoderAlto, stab, pad.gain(.26))
-const dropFinal = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
-  vocoder, stab, pad.gain(.24))
-const coda = stack(kick, hatsPhaser, bajo.gain(.8), vocoder.gain(.45).room(.7), pad)
+  vocoder, vocoderAlto, stab, pad.gain(.26), leadLimpio, stabArm, contra)
+const dropFinal = stack(kickFuerte, hats16, hatsOpen, clap, ghost, bajo, bajoSub, bajoOff,
+  vocoder, stab, pad.gain(.24), leadLimpio, stabArm)
+const coda = stack(kick, hatsPhaser, bajo.gain(.8), bajoSub.gain(.5), vocoder.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hatsPhaser.gain(.35), bajo.lpf(400).gain(.6),
   vocoder.gain(.3).room(.85).delayfeedback(.6), pad.gain(.3))
 
@@ -2951,14 +4162,18 @@ arrange(
   [12, dropFinal],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "31 · 9pm (till i come) — atb (1998)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 31 · 9PM (TILL I COME) — ATB (1998) → Progressive Trance Remix
-// 132 BPM · F#m · TR-909 · pluck-guitarra con pitch bend (penv) + bajo rolling
+// 132 BPM · F#m (i·VI·III·VII = F#m·D·A·E) · TR-909 · pluck-guitarra con pitch bend
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue F#-D-A-E),
+// bajo rolling + sub que siguen las fundamentales + bajo offbeat, groove swing/ghost/velocity,
+// stabs con 7as/9as + hi-pass, carácter peak-time (saturación) + riser de ruido.
 // Estructura: intro→hook→build→drop A→break flotante→drop B→coda (152 compases ≈ 4:36)
 // ════════════════════════════════════════════════════════════════
 setcps(132/60/4)
@@ -2973,34 +4188,70 @@ const hook = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4")
 const hookGrave = hook.add(note(-12)).gain(.3).lpf(1800).orbit(2)
 const hookFlotante = hook.slow(2).gain(.6).room(.85).rsize(8).delayfeedback(.6).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as/9as (F#m7·Dmaj7·Amaj7·Eadd9) + hi-pass ──
+const stab = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,fs4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ b4 ~ gs4 ~ e4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO ROLLING SUAVE (16avos, sigue F#m→D→A→E) ──
 const bajo = note("fs1*16").add(note("<0 -4 3 -2>"))
-  .s("sawtooth").lpf(820).lpq(5)
+  .s("sawtooth").lpf(perlin.slow(4).range(600, 1100)).lpq(5)
   .attack(.001).decay(.09).sustain(.15).release(.03)
-  .shape(.25).gain("[.8 .42 .58 .42]*4").orbit(1)
+  .shape(.34).coarse(1).gain("[.8 .42 .58 .42]*4").orbit(1)
 
+// ── SUB-BAJO afinado que SIGUE la fundamental (F#·D·A·E) ──
 const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine")
-  .decay(.3).sustain(.18).gain(.6).orbit(1)
+  .attack(.002).decay(.26).sustain(.18).release(.04).gain(.6).orbit(1)
 
-// ── BATERÍA 909 ELEGANTE (shaker agudo con pan aleatorio) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02)
+// ── BAJO OFFBEAT (rompe el 4x4) solo en los drops grandes ──
+const bajoOff = note("<fs2 d2 a1 e2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── BATERÍA 909 ELEGANTE: kick 2 capas (click 909 + boom afinado que sigue F#-D-A-E) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.35).gain(.9)
   .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
-const kickDrop = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
+const kickBoom = note("<fs1 d1 a1 e1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickDropClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickDrop = stack(kickDropClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.68).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.48 .22 .34 .22]*4").pan(rand.range(.35,.65)).orbit(0)
-const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
 const shaker = s("hh*16").bank("RolandTR909").speed(1.8).hpf(7000)
   .gain(rand.range(.15,.38)).pan(rand.range(.25,.75)).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.18,.8)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare sincopada
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
-// ── PADS FLOTANTES ──
-const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
+// ── PADS FLOTANTES (7as/9as + hi-pass) ──
+const pad = note("<[fs3,a3,cs4,e4] [d3,fs3,a3,cs4] [a3,cs4,e4,gs4] [e3,gs3,b3,fs4]>")
   .s("supersaw").unison(5).spread(.8)
-  .lpf(sine.slow(32).range(500, 1900)).attack(.8).release(1.8)
+  .lpf(sine.slow(32).range(500, 1900)).hpf(150).attack(.8).release(1.8)
   .room(.8).rsize(8).gain(.36).orbit(4)
 
 const colchon = note("<fs4 d4 a4 e4>").s("sine").attack(1).release(2)
@@ -3008,23 +4259,23 @@ const colchon = note("<fs4 d4 a4 e4>").s("sine").attack(1).release(2)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
-const introB = stack(kick, hats, hatsOpen, clap.gain(.45), bajo.lpf(400).gain(.6))
+const introB = stack(kick, hats, hatsOpen, clap.gain(.45), bajoSub.gain(.5), bajo.lpf(400).gain(.6))
 const hookIntro = stack(kick, hats, bajoSub.gain(.5),
   hook.lpf(saw.slow(8).range(600, 3200)).gain(.6))
-const build = stack(kick, hats16, clap, shaker.gain(.2), bajo, hook, pad.gain(.28))
-const buildFin = stack(kickDrop, rodillo, bajo, hook.gain(.65))
-const dropA = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub, hook)
-const dropAvar = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub,
-  hook, hookGrave, pad.gain(.26))
+const build = stack(kick, hats16, clap, shaker.gain(.2), ghost, bajo, bajoSub, riser, hook, pad.gain(.28))
+const buildFin = stack(kickDrop, rodillo, riser, bajo, bajoSub, hook.gain(.65))
+const dropA = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub, hook, leadLimpio, stab)
+const dropAvar = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub, bajoOff,
+  hook, hookGrave, pad.gain(.26), leadLimpio, stab, contra)
 const breakFlotante = stack(pad, colchon, hookFlotante, bajoSub.gain(.3),
-  hats.gain(.25))
-const breakBuild = stack(pad, colchon, hook.gain(.75), rodillo, hats16.gain(.38))
-const dropB = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub,
-  hook, hookGrave)
-const dropBfull = stack(kickDrop, hats16, hatsOpen, clap, shaker,
+  hats.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, colchon, hook.gain(.75), rodillo, riser, hats16.gain(.38))
+const dropB = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajo, bajoSub,
+  hook, hookGrave, leadLimpio, stab)
+const dropBfull = stack(kickDrop, hats16, hatsOpen, clap, shaker, ghost, bajoOff,
   bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.45)), bajoSub,
-  hook, hookGrave, pad.gain(.28), colchon.gain(.22))
-const coda = stack(kick, hats, bajo.lpf(500).gain(.65), hook.gain(.5).room(.7), pad)
+  hook, hookGrave, pad.gain(.28), colchon.gain(.22), leadLimpio, stab, contra)
+const coda = stack(kick, hats, bajo.lpf(500).gain(.65), bajoSub.gain(.5), hook.gain(.5).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35), hookFlotante.gain(.4), pad.gain(.3),
   colchon.gain(.25))
 
@@ -3043,14 +4294,16 @@ arrange(
   [16, dropBfull],
   [16, coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "32 · encore une fois — sash! (1996)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 32 · ENCORE UNE FOIS — Sash! (1996) → Happy Hard Techno Remix
-// 140 BPM · Am · TR-909 · piano offbeat + supersaw eufórica + doble clap
+// 140 BPM · Am (Am·F·C·G = raices a f c g) · TR-909 · piano offbeat euforico
+// PRO: kick 2 capas + boom afinado (a f c g) · bajo sigue acordes · groove swing/ghost · 7as/9as · riser
 // Estructura: intro→build→PAUSA→drop A→break piano→PAUSA→drop B→coda (134 compases ≈ 3:50)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -3064,6 +4317,26 @@ const hook = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~")
 
 const hookOctava = hook.add(note(12)).gain(.3).lpf(4200).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (Am·F·C·G) + contramelodía ──
+const stab = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── PIANO OFFBEAT (el rebote eufórico del happy hard, Am F C G) ──
 const piano = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>")
   .struct("~ x ~ x ~ x ~ x").s("piano").clip(.6)
@@ -3075,47 +4348,62 @@ const bajo = note("~ a1 ~ a1 ~ a1 ~ a1").add(note("<0 -4 3 -2>"))
   .attack(.001).decay(.18).sustain(.15).release(.05)
   .shape(.35).gain(.9).orbit(1)
 
-const bajoSub = note("<a1 f1 c2 g1>").s("sine")
+const bajoSub = note("<a0 f1 c1 g1>").s("sine")
   .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)
 
-// ── BATERÍA 909 (kick duro, DOBLE clap, rodillos constantes) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
-  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
-  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", sigue el acorde) ──
+const bajoOff = note("<a1 f2 c2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
+
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue el acorde ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
+  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kickBoom = note("<a0 f1 c1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+// ── DOBLE clap + rodillos ──
 const dobleClap = s("~ [cp cp] ~ [cp cp]").bank("RolandTR909")
   .room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.55).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.5)).orbit(0)
 const rodilloCorto = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(2).range(.3,.95)).hpf(250).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
 // ── PAD (colchón mayor eufórico) ──
-const pad = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>")
-  .s("sawtooth").lpf(800).attack(.6).release(1.2)
+const pad = note("<[a3,c4,e4,g4] [f3,a3,c4,e4] [c4,e4,g4,b4] [g3,b3,d4,f4]>")
+  .s("sawtooth").lpf(800).hpf(150).attack(.6).release(1.2)
   .room(.7).rsize(7).gain(.4).orbit(4)
+// riser de ruido filtrado para las subidas
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.35))
 const introB = stack(kick, hats, open, dobleClap.gain(.4), bajo.lpf(500).gain(.7))
-const build = stack(kick, hats16, dobleClap, bajo, piano,
+const build = stack(kick, hats16, dobleClap, ghost, bajo, piano,
   hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
-const buildFin = stack(kickHard, rodillo, bajo, piano, hook.gain(.7))
-const dropA = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava)
-const dropAvar = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub, piano,
-  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3))
+const buildFin = stack(kickHard, rodillo, riser, bajo, piano, hook.gain(.7))
+const dropA = stack(kickHard, hats16, open, dobleClap, ghost, bajo, bajoSub, piano, hook, hookOctava, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, dobleClap, ghost, ride, bajo, bajoSub, bajoOff, piano,
+  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), leadLimpio, stab, contra)
 const breakPiano = stack(piano.gain(.85).room(.6), pad, hook.gain(.5).room(.75),
-  hats.gain(.3), bajoSub.gain(.35))
-const breakBuild = stack(piano, pad, hook.gain(.7), rodilloCorto, kick.gain(.95), bajo)
-const dropB = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava, ride)
-const dropBFull = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub,
-  piano, hook, hookOctava, pad.gain(.35), rodillo.gain(.35))
-const coda = stack(kick, hats, dobleClap.gain(.5), piano.gain(.6), hook.gain(.45).room(.7), pad)
+  hats.gain(.3), bajoSub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(piano, pad, hook.gain(.7), rodilloCorto, riser, kick.gain(.95), bajo)
+const dropB = stack(kickHard, hats16, open, dobleClap, ghost, bajo, bajoSub, piano, hook, hookOctava, ride, leadLimpio, stab)
+const dropBFull = stack(kickHard, hats16, open, dobleClap, ghost, ride, bajo, bajoSub, bajoOff,
+  piano, hook, hookOctava, pad.gain(.35), rodillo.gain(.35), leadLimpio, stab, contra)
+const coda = stack(kick, hats, dobleClap.gain(.5), piano.gain(.6), hook.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.35), hook.gain(.3).room(.9).delayfeedback(.65), pad.gain(.35))
 
 // ── ARREGLO (134 compases, con las dos PAUSAS de silencio total) ──
@@ -3134,14 +4422,16 @@ arrange(
   [16, dropBFull],
   [12, coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "33 · flat beat — mr. oizo (1999)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 33 · FLAT BEAT — Mr. Oizo (1999) → Electro Bass Remix
-// 128 BPM · Fm · TR-808 · el bajo wah ES el track · groove roto y funky
+// 128 BPM · Fm (Fm·Fm·Fm·Eb = raices f f f eb) · TR-808 · el bajo wah ES el track
+// PRO: kick 2 capas + boom afinado que sigue el kick roto (f/eb) · sub sigue acordes · Fm9 · riser
 // Estructura: intro→bajo wah→groove→stabs FM→solo bajo→contramelodía→groove final (132 compases ≈ 4:07)
 // ════════════════════════════════════════════════════════════════
 setcps(128/60/4)
@@ -3155,16 +4445,26 @@ const bajo = note("f1 f1 ~ f1 ~ f1 eb1 f1")
 const bajoOctava = bajo.add(note(12)).gain(.28)
   .lpf(sine.slow(2).range(300,1600)).orbit(3)
 
-const sub = note("f1").s("sine").attack(.02).decay(.6).sustain(.35)
+const sub = note("<f1 f1 f1 eb1>").s("sine").attack(.02).decay(.6).sustain(.35)
   .gain(.4).orbit(1)
 
+// ── BAJO OFFBEAT (textura sintetica en las "y", sigue el acorde) ──
+const bajoOff = note("<f2 f2 f2 eb2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.32).duck("1").orbit(1)
+
 // ── PERCUSIÓN 808 (mínima pero groovy: kick roto con huecos) ──
-const kick = s("bd ~ [~ bd] ~ bd ~ ~ ~").bank("RolandTR808")
-  .shape(.4).gain(1.05).duck("2:3").duckattack(.08).duckdepth(.4).orbit(0)
+// KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue el kick roto
+const kickClick = s("bd ~ [~ bd] ~ bd ~ ~ ~").bank("RolandTR808")
+  .hpf(38).shape(.5).gain(.95).duck("2:3").duckattack(.08).duckdepth(.4).orbit(0)
+const kickBoom = note("<f1 f1 f1 eb1>").struct("x ~ [~ x] ~ x ~ ~ ~").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(.92).orbit(0)
+const kick = stack(kickClick, kickBoom)
 const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.7).orbit(0)
 const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.7).gain(.25).hpf(300).orbit(0)
 const hats = s("[~ hh] [hh ~] [~ hh] [hh hh]").bank("RolandTR808")
-  .gain(.5).pan(.6).orbit(0)
+  .swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
 const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0)
 const rim = s("~ ~ rim ~ ~ rim ~ ~").bank("RolandTR808").gain(.4).pan(.35).orbit(0)
 const toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808")
@@ -3182,21 +4482,31 @@ const contra = note("c4 ~ ab3 bb3").s("triangle")
   .delay(.3).delaytime(.375).delayfeedback(.4)
   .room(.4).gain(.7).orbit(2)
 
+// ── PAD CÁLIDO (colchón Fm·Eb sutil que llena la zona media sin romper el funk) ──
+const padCalido = note("<[f2,ab2,c3,g3]!3 [eb2,g2,bb2,f3]>")
+  .s("sawtooth").lpf(sine.slow(24).range(400, 950)).lpq(3)
+  .attack(.9).release(1.6).shape(.12).hpf(160)
+  .room(.6).rsize(7).gain(.28).pan(.5)
+  .duck("2:3").duckdepth(.35).orbit(4)
+// riser de ruido filtrado para las transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
+
 // ── SECCIONES ──
 const intro = stack(kick, hats)
 const introB = stack(kick, hats, snare, rim)
 const bajoIn = stack(kick, hats, snare, bajo.lpf(sine.slow(4).range(80,500)).gain(.85))
-const grooveA = stack(kick, hats, open, snare, ghost, bajo, sub)
-const grooveStabs = stack(kick, hats, open, snare, ghost, rim, bajo, sub, stabs)
+const grooveA = stack(kick, hats, open, snare, ghost, bajo, sub, padCalido.gain(.2))
+const grooveStabs = stack(kick, hats, open, snare, ghost, rim, bajo, sub, stabs, padCalido.gain(.22))
 const soloBajo = stack(bajo.lpf(sine.slow(1).range(100,1400)).gain(1),
   hats.gain(.25), toms, sub)
-const grooveB = stack(kick, hats, open, snare, ghost, bajo, sub, contra)
+const grooveB = stack(kick, hats, open, snare, ghost, bajo, sub, contra, padCalido.gain(.22))
 const grooveBFull = stack(kick, hats, open, snare, ghost, rim, toms,
-  bajo, bajoOctava, sub, contra, stabs)
-const breakFm = stack(stabs.gain(.7), contra.gain(.5).room(.7), hats.gain(.3), sub)
-const grooveFinal = stack(kick, hats, open, snare, ghost, rim, bajo, bajoOctava, sub,
-  contra.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), stabs)
-const coda = stack(kick, hats, bajo.gain(.8), sub)
+  bajo, bajoOctava, bajoOff, sub, contra, stabs, padCalido.gain(.25))
+const breakFm = stack(stabs.gain(.7), contra.gain(.5).room(.7), hats.gain(.3), riser, sub, padCalido.gain(.3))
+const grooveFinal = stack(kick, hats, open, snare, ghost, rim, bajo, bajoOctava, bajoOff, sub,
+  contra.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), stabs, padCalido.gain(.25))
+const coda = stack(kick, hats, bajo.gain(.8), sub, padCalido.gain(.22))
 const fin = stack(bajo.lpf(300).gain(.7), hats.gain(.25))
 
 // ── ARREGLO (132 compases) ──
@@ -3213,14 +4523,16 @@ arrange(
   [16, grooveFinal],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "34 · kernkraft 400 — zombie nation (1999)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 34 · KERNKRAFT 400 — Zombie Nation (1999) → Rave Techno Remix
-// 140 BPM · Em · TR-909 · el himno de estadio · multitud de ruido blanco
+// 140 BPM · Em (Em·C·Am·Bm = raices e c a b) · TR-909 · himno de estadio
+// PRO: kick 2 capas + boom afinado (e c a b) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser
 // Estructura: intro→build→drop A→break piano→drop B→drop final→coda (152 compases ≈ 4:21)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -3238,16 +4550,40 @@ const leadSaw = melodia.s("sawtooth").lpf(2200)
 const leadOctava = melodia.add(note(12)).s("square").crush(7).lpf(4200)
   .gain(.3).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("<[e4 g4 e4 d4 e4 c4 d4 b3] [e4 g4 e4 a4 g4 e4 d4 c4]>")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (Em·C·Am·Bm) + contramelodía ──
+const stab = note("<[e3,g3,b3,d4] [c3,e3,g3,b3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ b4 ~ g4 ~ e4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── PIANO (para el breakdown de estadio) ──
 const piano = melodia.s("piano").clip(.9).lpf(3000)
   .room(.6).rsize(6).gain(.85).orbit(3)
 
 // ── BAJO (corcheas motrices en Em) ──
-const bajo = note("e1!8").s("sawtooth")
+const bajo = note("<e1!8 c1!8 a0!8 b0!8>").s("sawtooth")
   .lpf(perlin.slow(4).range(400,1000)).lpq(6)
   .attack(.001).decay(.12).sustain(.25).release(.04)
   .shape(.35).gain("[.95 .7]*4").orbit(1)
-const sub = note("e1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1)
+const sub = note("<e1 c1 a0 b0>").struct("x*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ──
+const bajoOff = note("<e2 c2 a1 b1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── LA MULTITUD (ruido blanco con vocales = coros de estadio) ──
 const multitud = s("white").struct("~ x ~ x").vowel("a")
@@ -3257,43 +4593,51 @@ const estadio = s("white").vowel("<o a e o>").attack(.8).release(1)
   .lpf(1800).hpf(200).gain(.25).room(.8).rsize(8).orbit(4)
 
 // ── BATERÍA 909 (kick ENORME) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
-const kickEnorme = s("bd*4").bank("RolandTR909").shape(.65).distort(1.3).gain(1.12)
+const kickBoom = note("<e1 c1 a0 b0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickEnormeClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.65).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickEnorme = stack(kickEnormeClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.35,.65)).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
 const tomsRave = s("~ ~ ~ [ht mt lt lt]").bank("RolandTR909")
   .gain(.6).mask("<0 0 0 1>").orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD (Em C Am B) ──
-const pad = note("<[e3,g3,b3] [c3,e3,g3] [a2,c3,e3] [b2,d3,fs3]>")
-  .s("sawtooth").lpf(700).attack(.7).release(1.4)
+// ── PAD (Em C Am B con 7as) ──
+const pad = note("<[e3,g3,b3,d4] [c3,e3,g3,b3] [a2,c3,e3,g3] [b2,d3,fs3,a3]>")
+  .s("sawtooth").lpf(700).hpf(150).attack(.7).release(1.4)
   .room(.7).rsize(8).gain(.4).orbit(4)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.4))
 const introB = stack(kick, hats, clap, bajo.lpf(450).gain(.7))
-const build = stack(kick, hats16, clap, bajo,
+const build = stack(kick, hats16, clap, ghost, bajo,
   leadSq.lpf(saw.slow(16).range(350,2800)).gain(.55))
-const buildFin = stack(kickEnorme, rodillo, bajo, leadSq.gain(.75))
-const dropA = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, multitud)
-const dropAvar = stack(kickEnorme, hats16, open, clap, ride, tomsRave,
-  bajo, sub, leadSq, leadSaw, leadOctava, multitud)
-const breakPiano = stack(piano, pad, estadio, hats.gain(.3), sub.gain(.35))
-const breakBuild = stack(piano, pad, rodillo, kick.gain(.95), bajo, estadio)
-const dropB = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, leadOctava)
-const dropBFull = stack(kickEnorme, hats16, open, clap, ride, bajo, sub,
-  leadSq, leadSaw, leadOctava, multitud, estadio)
-const dropFinal = stack(kickEnorme, hats16, open, clap, ride, tomsRave, bajo, sub,
-  leadSq.sometimesBy(.25, x=>x.add(note(12))), leadSaw, multitud, pad.gain(.3))
-const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(600).gain(.7), piano.gain(.5), pad)
+const buildFin = stack(kickEnorme, rodillo, riser, bajo, leadSq.gain(.75))
+const dropA = stack(kickEnorme, hats16, open, clap, ghost, bajo, sub, leadSq, leadSaw, multitud, leadLimpio, stab)
+const dropAvar = stack(kickEnorme, hats16, open, clap, ghost, ride, tomsRave,
+  bajo, sub, bajoOff, leadSq, leadSaw, leadOctava, multitud, leadLimpio, stab, contra)
+const breakPiano = stack(piano, pad, estadio, hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(piano, pad, rodillo, riser, kick.gain(.95), bajo, estadio)
+const dropB = stack(kickEnorme, hats16, open, clap, ghost, bajo, sub, leadSq, leadSaw, leadOctava, leadLimpio, stab)
+const dropBFull = stack(kickEnorme, hats16, open, clap, ghost, ride, bajo, sub, bajoOff,
+  leadSq, leadSaw, leadOctava, multitud, estadio, leadLimpio, stab, contra)
+const dropFinal = stack(kickEnorme, hats16, open, clap, ghost, ride, tomsRave, bajo, sub, bajoOff,
+  leadSq.sometimesBy(.25, x=>x.add(note(12))), leadSaw, multitud, pad.gain(.3), leadLimpio, stab)
+const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(600).gain(.7), piano.gain(.5), pad, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.35), piano.gain(.4).room(.85), estadio.gain(.2))
 
 // ── ARREGLO (152 compases) ──
@@ -3311,14 +4655,16 @@ arrange(
   [16, dropFinal],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "35 · café del mar — energy 52 (1993)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 35 · CAFÉ DEL MAR — Energy 52 (1993) → Classic Trance Remix
-// 136 BPM · Am · TR-909 · la catedral trance · breakdown de 16 compases
+// 136 BPM · Am (Am·Am·F·G = raices a a f g) · TR-909 · la catedral trance
+// PRO: kick 2 capas + boom afinado (a a f g) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser
 // Estructura: intro→arpegio→build→drop A→breakdown épico→drop B→coda (144 compases ≈ 4:14)
 // ════════════════════════════════════════════════════════════════
 setcps(136/60/4)
@@ -3342,6 +4688,26 @@ const melodiaEpica = melodia.s("supersaw").unison(7).spread(.8).detune(.2)
   .lpf(3500).gain(.8)
 const melodiaOctava = melodiaEpica.add(note(12)).gain(.3)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("e5 d5 c5 d5 e5 c5 a4 b4 c5 b4 a4 g4 a4 ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (Am·F·G) + contramelodía ──
+const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO ROLLING (16avos con acentos, progresión Am Am F G) ──
 const bajo = note("a1!16").add(note("<0 0 -4 -2>"))
   .s("sawtooth").lpf(750).lpq(5)
@@ -3349,46 +4715,58 @@ const bajo = note("a1!16").add(note("<0 0 -4 -2>"))
   .shape(.25).gain("[.9 .5 .65 .5]*4").orbit(1)
 const sub = note("<a1 a1 f1 g1>").s("sine")
   .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ──
+const bajoOff = note("<a1 a1 f2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── BATERÍA 909 ──
-const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
-  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
-  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
+  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kickBoom = note("<a0 a0 f1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .22 .38 .22]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.42).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.35).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── ATMÓSFERA (la catedral: reverbs enormes) ──
-const pad = note("<[a2,c3,e3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
-  .s("sawtooth").lpf(650).attack(.9).release(1.8)
+// ── ATMÓSFERA (la catedral: reverbs enormes, con 7as) ──
+const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .s("sawtooth").lpf(650).hpf(150).attack(.9).release(1.8)
   .room(.8).rsize(9).gain(.4).orbit(4)
 const cuerdas = note("<a3 a3 f3 g3>").s("supersaw").unison(5).spread(.6)
   .lpf(sine.slow(32).range(400,2000)).attack(.6).release(1)
   .room(.7).gain(.35).orbit(4)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.35))
 const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(400).gain(.65))
 const arpIn = stack(kick, hats, clap, bajo, arpegio.lpf(saw.slow(16).range(500,3200)))
-const build = stack(kick, hats16, clap, bajo, arpegio,
+const build = stack(kick, hats16, clap, ghost, bajo, arpegio,
   melodia.lpf(saw.slow(8).range(300,2000)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, arpegio, melodia.gain(.65))
-const dropA = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodia)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio, melodia, cuerdas)
+const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio, melodia.gain(.65))
+const dropA = stack(kickHard, hats16, open, clap, ghost, bajo, sub, arpegio, melodia, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ghost, ride, bajo, sub, bajoOff, arpegio, melodia, cuerdas, leadLimpio, stab, contra)
 const breakdown = stack(melodiaFlotante, pad, arpegio.gain(.5).room(.7),
-  cuerdas.gain(.3), sub.gain(.3))
-const breakBuild = stack(melodiaFlotante, pad, arpegio, rodillo, hats16.gain(.4))
-const dropB = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodiaEpica, melodiaOctava)
-const dropBFull = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio,
-  melodiaEpica, melodiaOctava, cuerdas)
+  cuerdas.gain(.3), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(melodiaFlotante, pad, arpegio, rodillo, riser, hats16.gain(.4))
+const dropB = stack(kickHard, hats16, open, clap, ghost, bajo, sub, arpegio, melodiaEpica, melodiaOctava, leadLimpio, stab)
+const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, bajo, sub, bajoOff, arpegio,
+  melodiaEpica, melodiaOctava, cuerdas, leadLimpio, stab, contra)
 const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(550).gain(.7),
-  arpegio.gain(.5), melodia.gain(.45).room(.75), pad)
+  arpegio.gain(.5), melodia.gain(.45).room(.75), pad, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.3), arpegio.gain(.35).delayfeedback(.7), pad.gain(.35))
 
 // ── ARREGLO (144 compases) ──
@@ -3406,14 +4784,16 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "36 · l'amour toujours — gigi d'agostino (1999)",
     folder: "remixes 90s",
     code: `// ════════════════════════════════════════════════════════════════
 // 36 · L'AMOUR TOUJOURS — Gigi D'Agostino (1999) → Italo Techno Remix
-// 139 BPM · F · TR-909 · lead italo de sierra fina + piano marcato + optimismo total
+// 139 BPM · F (F·Bb·F·C = raices f bb f c) · TR-909 · lead italo + piano marcato
+// PRO: kick 2 capas + boom afinado (f bb f c) · bajo/sub siguen acordes · groove swing/ghost · 7as · riser
 // Estructura: intro→build→drop A→break piano→drop B→drop final→coda (144 compases ≈ 4:09)
 // ════════════════════════════════════════════════════════════════
 setcps(139/60/4)
@@ -3426,12 +4806,36 @@ const hook = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~")
   .room(.35).gain(.82).orbit(2)
 const hookOctava = hook.add(note(12)).gain(.28).lpf(4200).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico (F·Bb·C) + contramelodía ──
+const stab = note("<[f3,a3,c4,e4] [bb2,d3,f3,a3] [f3,a3,c4,e4] [c3,e3,g3,bb3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.3).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ c4 ~ a3 ~ f3 ~] [~ ~ f4 ~ d4 ~ bb3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ g4 ~ e4 ~ c4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO QUE BAILA (el salto de octava italo) ──
-const bajo = note("f1 f2 c2 f1").s("sawtooth")
+const bajo = note("<[f1 f2 c2 f1] [bb0 bb1 f1 bb0] [f1 f2 c2 f1] [c1 c2 g1 c1]>").s("sawtooth")
   .lpf(850).lpq(4).attack(.001).decay(.2).sustain(.2).release(.04)
   .shape(.3).gain(.95).orbit(1)
 const bajoBaile = bajo.ply(2).gain(.85)
-const sub = note("f1*4").s("sine").decay(.3).sustain(.15).gain(.5).orbit(1)
+const sub = note("<f1 bb0 f1 c1>").struct("x*4").s("sine").decay(.3).sustain(.15).gain(.5).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ──
+const bajoOff = note("<f2 bb1 f2 c2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── PIANO MARCATO (para los breaks, F Bb F C) ──
 const piano = note("<[f3,a3,c4] [f3,bb3,d4] [f3,a3,c4] [e3,g3,c4]>")
@@ -3439,43 +4843,51 @@ const piano = note("<[f3,a3,c4] [f3,bb3,d4] [f3,a3,c4] [e3,g3,c4]>")
   .lpf(3200).room(.45).gain(.8).orbit(3)
 
 // ── BATERÍA 909 ──
-const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
-  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.58).distort(1.1).gain(1.1)
-  .duck("1:2").duckattack(.1).duckdepth(.62).orbit(0)
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
+  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
+const kickBoom = note("<f1 bb0 f1 c1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.58).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.42).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.58).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.42).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.35)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD (colchón mayor optimista) ──
-const pad = note("<[f3,a3,c4] [bb2,d3,f3] [f3,a3,c4] [c3,e3,g3]>")
-  .s("sawtooth").lpf(750).attack(.7).release(1.3)
+// ── PAD (colchón mayor optimista, con 7as) ──
+const pad = note("<[f3,a3,c4,e4] [bb2,d3,f3,a3] [f3,a3,c4,e4] [c3,e3,g3,bb3]>")
+  .s("sawtooth").lpf(750).hpf(150).attack(.7).release(1.3)
   .room(.65).rsize(7).gain(.38).orbit(4)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, sub.gain(.35))
 const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.7))
-const build = stack(kick, hats16, clap, bajo, piano.gain(.55),
+const build = stack(kick, hats16, clap, ghost, bajo, piano.gain(.55),
   hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
-const buildFin = stack(kickHard, rodillo, bajoBaile, hook.gain(.72))
-const dropA = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava)
-const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
-  hook, hookOctava, pad.gain(.3))
+const buildFin = stack(kickHard, rodillo, riser, bajoBaile, hook.gain(.72))
+const dropA = stack(kickHard, hats16, open, clap, ghost, bajoBaile, sub, hook, hookOctava, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff,
+  hook, hookOctava, pad.gain(.3), leadLimpio, stab, contra)
 const breakPiano = stack(piano, pad, hook.gain(.5).room(.7),
-  hats.gain(.3), sub.gain(.35))
-const breakBuild = stack(piano, pad, hook.gain(.7), rodillo, kick.gain(.95), bajo)
-const dropB = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava, piano.gain(.5))
-const dropBFull = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
-  hook, hookOctava, piano.gain(.55), pad.gain(.32))
-const dropFinal = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
-  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), rodillo.gain(.3))
+  hats.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(piano, pad, hook.gain(.7), rodillo, riser, kick.gain(.95), bajo)
+const dropB = stack(kickHard, hats16, open, clap, ghost, bajoBaile, sub, hook, hookOctava, piano.gain(.5), leadLimpio, stab)
+const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff,
+  hook, hookOctava, piano.gain(.55), pad.gain(.32), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, open, clap, ghost, ride, bajoBaile, sub, bajoOff,
+  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), rodillo.gain(.3), leadLimpio, stab)
 const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.8), piano.gain(.6),
-  hook.gain(.45).room(.7), pad)
+  hook.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.32), hook.gain(.3).room(.85).delayfeedback(.6), pad.gain(.35))
 
 // ── ARREGLO (144 compases) ──
@@ -3493,14 +4905,16 @@ arrange(
   [16, dropFinal],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "37 · one more time — daft punk (2000)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 37 · ONE MORE TIME — Daft Punk (2000) → Filter House Techno Remix
-// 123 BPM · D · TR-909 · todo el drop respira por lpf+hpf · hats con swing
+// 123 BPM · D (D·D·Bm·A = raices d d b a) · TR-909 · el drop respira por lpf+hpf
+// PRO: kick 2 capas + boom afinado (d d b a) · bajo/sub siguen acordes · ghost · pad 9as · riser
 // Estructura: intro→build→drop filtrado A→breakdown→drop B→coda (136 compases ≈ 4:25)
 // ════════════════════════════════════════════════════════════════
 setcps(123/60/4)
@@ -3514,6 +4928,20 @@ const brass = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~")
   .lpf(2400).lpq(2).room(.5).rsize(4).gain(.82).orbit(2)
 const brassOctava = brass.add(note(12)).gain(.25).orbit(2)
 
+// ── LEAD LIMPIO (la fanfarria, nítida y al frente, FUERA del filtro que respira) ──
+const leadLimpio = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~")
+  .s("triangle").lpf(5200).lpq(1)
+  .attack(.005).decay(.2).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.58).pan(.5).orbit(2)
+
+// ── CONTRAMELODÍA (zona media, D·Bm·A) ──
+const contra = note("<[~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ a4 ~ fs4 ~ d4 ~] [~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ e4 ~ cs4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── BAJO DISCO (con la subida de octava, progresión D D B A) ──
 const bajo = note("d2 ~ d2 d3").add(note("<0 0 -3 -5>"))
   .s("sawtooth").lpf(900).lpq(3)
@@ -3521,45 +4949,57 @@ const bajo = note("d2 ~ d2 d3").add(note("<0 0 -3 -5>"))
   .shape(.3).gain(.9).orbit(1)
 const sub = note("<d1 d1 b1 a1>").s("sine")
   .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue el acorde) ──
+const bajoOff = note("<d2 d2 b1 a1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── BATERÍA 909 (hats con swing francés) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
-  .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.52).distort(1.08).gain(1.08)
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
+const kickBoom = note("<d1 d1 b0 a0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.12).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
 const hatsSwing = s("hh*8").bank("RolandTR909").swingBy(1/6, 8)
   .gain("[.5 .3]*4").pan(.6).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/8, 8)
-  .gain("[.5 .22 .36 .22]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0)
+  .gain(perlin.range(.22,.5)).pan(rand.range(.4,.6)).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.42).orbit(0)
 const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.3)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD CON PHASER (movimiento constante, D D Bm A) ──
-const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [b2,d3,fs3] [a2,cs3,e3]>")
-  .s("sawtooth").lpf(900).attack(.5).release(1.2)
+// ── PAD CON PHASER (movimiento constante, D D Bm A con 9as) ──
+const pad = note("<[d3,fs3,a3,e4] [d3,fs3,a3,e4] [b2,d3,fs3,a3] [a2,cs3,e3,b3]>")
+  .s("sawtooth").lpf(900).hpf(150).attack(.5).release(1.2)
   .phaser(.5).phaserdepth(.75).room(.6).rsize(6).gain(.4).orbit(4)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hatsSwing, sub.gain(.35))
 const introB = stack(kick, hatsSwing, clap, bajo.lpf(500).gain(.7))
-const build = stack(kick, hats16, clap, bajo, pad,
-  brass.lpf(saw.slow(16).range(400,2400)).gain(.55))
-const buildFin = stack(kickHard, rodillo, bajo, brass.gain(.7))
-const dropA = stack(kickHard, hats16, open, clap, sub,
-  respira(stack(bajo, brass, brassOctava)))
-const dropAfiltro = stack(kickHard, hats16, open, clap, ride, sub,
-  respira(stack(bajo, brass, brassOctava, pad.gain(.3))))
-const breakdown = stack(pad, brass.gain(.55).room(.75), hatsSwing.gain(.3), sub.gain(.35))
-const breakBuild = stack(pad, brass.gain(.7), rodillo, hats16.gain(.4), bajo)
-const dropB = stack(kickHard, hats16, open, clap, sub,
-  respira(stack(bajo, brass.sometimesBy(.2, x=>x.add(note(12))), brassOctava)))
-const dropBFull = stack(kickHard, hats16, open, clap, ride, sub,
-  respira(stack(bajo, brass, brassOctava, pad.gain(.32))), rodillo.gain(.25))
+const build = stack(kick, hats16, clap, ghost, bajo, pad,
+  brass.lpf(saw.slow(16).range(400,2400)).gain(.55), leadLimpio.gain(.5))
+const buildFin = stack(kickHard, rodillo, riser, bajo, brass.gain(.7), leadLimpio.gain(.55))
+const dropA = stack(kickHard, hats16, open, clap, ghost, sub,
+  respira(stack(bajo, brass, brassOctava)), leadLimpio, contra)
+const dropAfiltro = stack(kickHard, hats16, open, clap, ghost, ride, sub, bajoOff,
+  respira(stack(bajo, brass, brassOctava, pad.gain(.3))), leadLimpio, contra)
+const breakdown = stack(pad, brass.gain(.55).room(.75), hatsSwing.gain(.3), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, brass.gain(.7), rodillo, riser, hats16.gain(.4), bajo)
+const dropB = stack(kickHard, hats16, open, clap, ghost, sub,
+  respira(stack(bajo, brass.sometimesBy(.2, x=>x.add(note(12))), brassOctava)), leadLimpio, contra)
+const dropBFull = stack(kickHard, hats16, open, clap, ghost, ride, sub, bajoOff,
+  respira(stack(bajo, brass, brassOctava, pad.gain(.32))), rodillo.gain(.25), leadLimpio, contra)
 const coda = stack(kick, hatsSwing, clap.gain(.5), bajo.lpf(600).gain(.7),
-  brass.gain(.45).room(.7), pad)
+  brass.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const fin = stack(hatsSwing.gain(.3), brass.gain(.3).room(.85), pad.gain(.35))
 
 // ── ARREGLO (136 compases) ──
@@ -3576,14 +5016,18 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "38 · harder better faster stronger — daft punk (2001)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 38 · HARDER BETTER FASTER STRONGER — Daft Punk (2001) → Electro Techno Remix
-// 123 BPM · Em · TR-808 · vocoder con vowel secuenciado + kick 3-3-2 + cortes stut
+// 123 BPM · Em (i·III·i·VII = Em·G·Em·D) · TR-808 · vocoder con vowel secuenciado
+// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado que sigue las raíces
+// e·g·e·d) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing +
+// ghost + armonía con 7as/9as e hi-pass + carácter DURO peak-time + riser de ruido.
 // Estructura: intro→build→drop A→breakdown→drop stut→coda (128 compases ≈ 4:10)
 // ════════════════════════════════════════════════════════════════
 setcps(123/60/4)
@@ -3596,52 +5040,92 @@ const hook = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~")
 const hookRobot = hook.add(note(12)).vowel("[i o a e]*2").gain(.32).orbit(2)
 const hookStut = hook.every(4, x=>x.stut(4,.55,.0625))
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as/9as (Em7·Gmaj7·Em7·D7) + hi-pass ──
+const stab = note("<[e3,g3,b3,d4] [g3,b3,d4,fs4] [e3,g3,b3,d4] [d3,fs3,a3,c4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ b3 ~ g3 ~] [~ ~ g4 ~ d4 ~ b3 ~] [~ ~ e4 ~ b3 ~ g3 ~] [~ ~ fs4 ~ d4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── TALKBOX (FM + vibrato = la voz de goma) ──
 const talkbox = note("<e3 ~ g3 ~>").s("sine").fm(5).fmh(1.98)
   .vib(5.5).vibmod(.5).attack(.05).release(.3)
   .lpf(1800).gain(.5).room(.4).orbit(3)
 
-// ── BAJO ELECTRO PUNCHY (síncopa 3-3-2 pegada al kick) ──
-const bajo = note("e1 ~ ~ e1 ~ ~ <e1 g1> ~")
+// ── BAJO ELECTRO PUNCHY (síncopa 3-3-2 AHORA sigue el acorde: E·G·E·D) ──
+const bajo = note("<[e1 ~ ~ e1 ~ ~ g1 ~] [g1 ~ ~ g1 ~ ~ b1 ~] [e1 ~ ~ e1 ~ ~ g1 ~] [d1 ~ ~ d1 ~ ~ fs1 ~]>")
   .s("square").lpf(700).lpq(8)
   .attack(.001).decay(.15).sustain(.1).release(.03)
-  .shape(.4).gain(.95).orbit(1)
-const sub = note("e1").s("sine").attack(.02).decay(.6).sustain(.3)
+  .shape(.4).coarse(1).gain(.95).orbit(1)
+// ── SUB afinado que SIGUE la fundamental de cada compás ──
+const sub = note("<e1 g1 e1 d1>").s("sine").attack(.02).decay(.6).sustain(.3)
   .gain(.4).orbit(1)
+// ── BAJO OFFBEAT (rompe el 3-3-2: pulsa en las "y") ──
+const bajoOff = note("<e2 g2 e2 d2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BATERÍA 808 ELECTRO (kick 3-3-2, clave de rim, toms de máquina) ──
-const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808")
-  .shape(.45).gain(1.06).duck("1:2").duckattack(.09).duckdepth(.5).orbit(0)
-const kick4 = s("bd*4").bank("RolandTR808").shape(.5).gain(1.08)
+// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado que sigue las raíces ──
+const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.5).gain(.92)
+  .duck("1:2").duckattack(.09).duckdepth(.5).orbit(0)
+const kickBoom = note("<e1 g1 e1 d1>").struct("x ~ ~ x ~ ~ x ~").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickBoom4 = note("<e1 g1 e1 d1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kick4Click = s("bd*4").bank("RolandTR808").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.09).duckdepth(.55).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kick4 = stack(kick4Click, kickBoom4.gain(1.05))
+
 const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.72).orbit(0)
 const clave = s("[~ rim]*4").bank("RolandTR808").degradeBy(.4).gain(.4).pan(.3).orbit(0)
-const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").pan(.6).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0)
+// hats con SWING + velocity patrón (groove, no rejilla plana)
+const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8).gain("[.5 .25]*4").pan(.6).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").nudge(.004).gain(.4).orbit(0)
 const toms = s("~ ~ ~ ~ ~ ~ [ht mt] lt").bank("RolandTR808")
   .gain(.55).mask("<0 0 0 1>").orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD LO-FI (coarse = circuito viejo) ──
-const pad = note("<[e3,g3,b3] [g3,b3,d4] [e3,g3,b3] [d3,fs3,a3]>")
+// ── PAD LO-FI con 7as + hi-pass (deja el sub libre) ──
+const pad = note("<[e3,g3,b3,d4] [g3,b3,d4,fs4] [e3,g3,b3,d4] [d3,fs3,a3,c4]>")
   .s("sawtooth").lpf(800).coarse(3).attack(.5).release(1.1)
-  .room(.55).rsize(6).gain(.38).orbit(4)
+  .hpf(150).room(.55).rsize(6).gain(.38).orbit(4)
+// riser de ruido filtrado para transiciones (barrido que sube)
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats)
 const introB = stack(kick, hats, snare, clave)
-const build = stack(kick, hats, snare, bajo,
+const build = stack(kick, hats, snare, bajo, riser,
   hook.lpf(saw.slow(16).range(400,2800)).gain(.55))
-const buildFin = stack(kick4, hats, snare, bajo, hook.gain(.7), toms)
-const dropA = stack(kick, hats, open, snare, clave, bajo, sub, hook, talkbox)
-const dropAvar = stack(kick, hats, open, snare, clave, toms, bajo, sub,
-  hook, hookRobot, talkbox)
+const buildFin = stack(kick4, hats, snare, bajo, riser, hook.gain(.7), toms)
+const dropA = stack(kick, hats, open, snare, clave, ghost, bajo, sub, hook, talkbox, leadLimpio, stab)
+const dropAvar = stack(kick, hats, open, snare, clave, toms, ghost, bajo, sub, bajoOff,
+  hook, hookRobot, talkbox, leadLimpio, stab, contra)
 const breakdown = stack(pad, talkbox.gain(.6), hook.slow(2).gain(.5).room(.65),
-  hats.gain(.28), sub.gain(.35))
-const breakBuild = stack(pad, hook.gain(.7), hats, snare.gain(.5), bajo)
-const dropStut = stack(kick4, hats, open, snare, bajo, sub, hookStut, talkbox)
-const dropStutFull = stack(kick4, hats, open, snare, clave, toms, bajo, sub,
-  hookStut, hookRobot, talkbox, pad.gain(.3))
-const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.8), hook.gain(.5), sub)
+  hats.gain(.28), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, riser, hook.gain(.7), hats, snare.gain(.5), bajo)
+const dropStut = stack(kick4, hats, open, snare, ghost, bajo, sub, hookStut, talkbox, leadLimpio, stab)
+const dropStutFull = stack(kick4, hats, open, snare, clave, toms, ghost, bajo, sub, bajoOff,
+  hookStut, hookRobot, talkbox, pad.gain(.3), leadLimpio, stab, contra)
+const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.8), hook.gain(.5), sub, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.3), hook.slow(2).gain(.35).room(.8), pad.gain(.3))
 
 // ── ARREGLO (128 compases) ──
@@ -3658,14 +5142,18 @@ arrange(
   [16, dropStutFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "39 · can't get you out of my head — kylie minogue (2001)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 39 · CAN'T GET YOU OUT OF MY HEAD — Kylie Minogue (2001) → Dark Disco Techno Remix
-// 126 BPM · Dm · TR-909 · la-la-la nocturno + bajo disco en octavas + cuerdas staccato
+// 126 BPM · Dm (i·i·VI·VII = Dm·Dm·Bb·C) · TR-909 · la-la-la nocturno
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces
+// d·d·bb·c) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing +
+// ghost + cuerdas con 7as/9as e hi-pass + carácter DURO peak-time + riser de ruido.
 // Estructura: intro→groove→drop A→breakdown→drop B (tensión máxima)→coda (132 compases ≈ 4:11)
 // ════════════════════════════════════════════════════════════════
 setcps(126/60/4)
@@ -3678,57 +5166,88 @@ const lalala = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~")
   .room(.5).rsize(5).gain(.8).pan(sine.slow(7).range(.35,.65)).orbit(2)
 const lalalaEco = lalala.add(note(12)).gain(.25).late(.0625).orbit(2)
 
-// ── BAJO DISCO EN OCTAVAS (Dm Dm Bb C) ──
+// ── LEAD LIMPIO (el "la la la", nítido y al frente) ──
+const leadLimpio = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.005).decay(.2).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.55).pan(.5).orbit(2)
+
+// ── CONTRAMELODÍA (zona media, Dm·Bb·C) ──
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ bb4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~]>")
+  .s("triangle").lpf(2700).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.3).pan(.62).orbit(3)
+
+// ── BAJO DISCO EN OCTAVAS (SIGUE el acorde: Dm·Dm·Bb·C) ──
 const bajo = note("d2 d3 d2 d3 d2 d3 d2 d3").add(note("<0 0 -4 -2>"))
   .s("sawtooth").lpf(950).lpq(4)
   .attack(.001).decay(.14).sustain(.12).release(.03)
-  .shape(.3).gain(.9).orbit(1)
-const sub = note("d1!2").add(note("<0 0 8 10>")).s("sine")
+  .shape(.3).coarse(1).gain(.9).orbit(1)
+// ── SUB afinado que SIGUE la fundamental de cada compás ──
+const sub = note("<d1 d1 bb0 c1>").s("sine")
   .attack(.02).decay(.5).sustain(.35).gain(.5).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<d2 d2 bb1 c2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── CUERDAS STACCATO (la elegancia oscura) ──
-const cuerdas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>")
+// ── CUERDAS STACCATO con 7as/9as (Dm7·Dm7·Bbmaj7·C7) + hi-pass ──
+const cuerdas = note("<[d4,f4,a4,c5] [d4,f4,a4,c5] [bb3,d4,f4,a4] [c4,e4,g4,bb4]>")
   .struct("~ x ~ x ~ ~ x ~").s("sawtooth").clip(.25)
   .attack(.005).release(.08).lpf(3200).hpf(280)
   .room(.35).gain(.6).orbit(3)
-const cuerdasLargas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>")
-  .s("sawtooth").lpf(1400).attack(.6).release(1.2)
+const cuerdasLargas = note("<[d4,f4,a4,c5] [d4,f4,a4,c5] [bb3,d4,f4,a4] [c4,e4,g4,bb4]>")
+  .s("sawtooth").lpf(1400).hpf(160).attack(.6).release(1.2)
   .room(.7).rsize(7).gain(.35).orbit(4)
 
-// ── BATERÍA 909 (hats franceses: hpf alto + iter) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado que sigue las raíces ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.08)
+const kickBoom = note("<d1 d1 bb0 c1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0)
-const hatsFr = s("hh*16").bank("RolandTR909").hpf(6000).iter(4)
+// hats con SWING (groove francés, no rejilla plana)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.48).pan(.58).orbit(0)
+const hatsFr = s("hh*16").bank("RolandTR909").hpf(6000).iter(4).swingBy(1/24,16)
   .gain("[.5 .2 .35 .2]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.38).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.4).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.26).pan(.38).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.35)).orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+// riser de ruido filtrado para transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES (la tensión crece sección a sección) ──
 const intro = stack(kick, hats, sub.gain(.35))
 const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.65))
 const groove = stack(kick, hatsFr, clap, bajo, cuerdas.gain(.4))
-const build = stack(kick, hatsFr, clap, bajo, cuerdas,
-  lalala.lpf(saw.slow(8).range(400,2600)).gain(.55))
-const dropA = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, cuerdas)
-const dropAvar = stack(kickHard, hatsFr, open, clap, ride, bajo, sub,
-  lalala, lalalaEco, cuerdas)
+const build = stack(kick, hatsFr, clap, bajo, cuerdas, riser,
+  lalala.lpf(saw.slow(8).range(400,2600)).gain(.55), leadLimpio.gain(.5))
+const dropA = stack(kickHard, hatsFr, open, clap, ghost, bajo, sub, lalala, cuerdas, leadLimpio, contra)
+const dropAvar = stack(kickHard, hatsFr, open, clap, ride, ghost, bajo, sub, bajoOff,
+  lalala, lalalaEco, cuerdas, leadLimpio, contra)
 const breakdown = stack(cuerdasLargas, lalala.slow(2).gain(.55).room(.75),
-  hats.gain(.28), sub.gain(.35))
-const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo,
+  hats.gain(.28), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo, riser,
   hatsFr.gain(.35), bajo)
-const dropB = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, lalalaEco,
-  cuerdas.hpf(saw.slow(32).range(280,1200)))
-const dropBFull = stack(kickHard, hatsFr, open, clap, ride, bajo, sub,
+const dropB = stack(kickHard, hatsFr, open, clap, ghost, bajo, sub, lalala, lalalaEco,
+  cuerdas.hpf(saw.slow(32).range(280,1200)), leadLimpio, contra)
+const dropBFull = stack(kickHard, hatsFr, open, clap, ride, ghost, bajo, sub, bajoOff,
   lalala.sometimesBy(.2, x=>x.add(note(12))), lalalaEco, cuerdas,
-  cuerdasLargas.gain(.28), rodillo.gain(.25))
+  cuerdasLargas.gain(.28), rodillo.gain(.25), leadLimpio, contra)
 const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.75),
-  lalala.gain(.45).room(.7), cuerdasLargas)
+  lalala.gain(.45).room(.7), cuerdasLargas, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.3), lalala.gain(.3).room(.9).delayfeedback(.65),
   cuerdasLargas.gain(.3))
 
@@ -3746,14 +5265,18 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "40 · satisfaction — benny benassi (2002)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 40 · SATISFACTION — Benny Benassi (2002) → Electro House Remix
-// 130 BPM · Cm · TR-909 · el zumbido serrado (crush+shape) + sidechain exagerado
+// 130 BPM · Cm (vamp de un acorde, raíz C) · TR-909 · el zumbido serrado
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado en la raíz C) + sub que
+// sigue la raíz + bajo offbeat + groove con swing + ghost + stab con 7as/9as e
+// hi-pass + carácter DURO peak-time (crush+shape) + riser de ruido en subidas.
 // Estructura: intro→riff→build hpf→drop A→breakdown→drop B demoledor→coda (136 compases ≈ 4:11)
 // ════════════════════════════════════════════════════════════════
 setcps(130/60/4)
@@ -3767,44 +5290,80 @@ const riff = note("c3 ~ c3 eb3 ~ c3 f3 eb3")
   .gain(.9).orbit(2)
 const riffAlto = riff.add(note(12)).gain(.38).crush(8).orbit(3)
 
-// ── SUB (la misma línea, una octava abajo en seno) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("c3 ~ c3 eb3 ~ c3 f3 eb3")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as/9as (Cm9) + hi-pass ──
+const stab = note("[c3,eb3,g3,bb3,d4]")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ g4 ~ eb4 ~ c4 ~] [~ ~ eb4 ~ c4 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── SUB (la misma línea Benassi, una octava abajo en seno, centrada en C) ──
 const sub = note("c1 ~ c1 eb1 ~ c1 f1 eb1").s("sine")
   .decay(.25).sustain(.2).gain(.65).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y", raíz C) ──
+const bajoOff = note("c2").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BATERÍA 909 (sidechain exagerado: duckdepth .85) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado en la raíz (sidechain exagerado) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).gain(.92)
   .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0)
-const kickDemoledor = s("bd*4").bank("RolandTR909").shape(.65).distort(1.25).gain(1.12)
+const kickBoom = note("c1").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickDemoledorClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.35).gain(.95)
   .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickDemoledor = stack(kickDemoledorClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
+// hats con SWING + velocity patrón (groove, no rejilla plana)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.48).pan(.58).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
   .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0)
-const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.42).orbit(0)
+const open = s("~ ~ [~ oh] ~").bank("RolandTR909").nudge(.004).gain(.42).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.45)).orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD (respiro entre zumbidos) ──
-const pad = note("[c3,eb3,g3]").s("supersaw").unison(5).spread(.6)
-  .lpf(sine.slow(32).range(350,1600)).attack(.6).release(1.2)
+// ── PAD con 7as + hi-pass (respiro entre zumbidos) ──
+const pad = note("[c3,eb3,g3,bb3]").s("supersaw").unison(5).spread(.6)
+  .lpf(sine.slow(32).range(350,1600)).hpf(150).attack(.6).release(1.2)
   .room(.6).rsize(6).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES (los builds suben con hpf, el drop lo suelta todo) ──
 const intro = stack(kick, hats, sub.gain(.35))
 const introB = stack(kick, hats, clap.gain(.5), sub.gain(.5))
 const riffIn = stack(kick, hats, clap, riff.lpf(sine.slow(8).range(200,900)).gain(.7))
-const build = stack(kick, hats16, clap, riff.hpf(saw.slow(8).range(60,2400)), sub)
-const buildFin = stack(kickDemoledor, rodillo,
+const build = stack(kick, hats16, clap, riff.hpf(saw.slow(8).range(60,2400)), sub, riser)
+const buildFin = stack(kickDemoledor, rodillo, riser,
   riff.hpf(saw.slow(4).range(200,3000)).gain(.8))
-const dropA = stack(kickDemoledor, hats16, open, clap, riff, sub)
-const dropAvar = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub)
-const breakdown = stack(pad, riff.lpf(500).gain(.55).room(.6), hats.gain(.3), sub.gain(.3))
+const dropA = stack(kickDemoledor, hats16, open, clap, ghost, riff, sub, leadLimpio, stab)
+const dropAvar = stack(kickDemoledor, hats16, open, clap, ghost, riff, riffAlto, sub, bajoOff, leadLimpio, stab, contra)
+const breakdown = stack(pad, riff.lpf(500).gain(.55).room(.6), hats.gain(.3), sub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(pad, riff.hpf(saw.slow(8).range(60,2800)).gain(.75),
-  rodillo, hats16.gain(.4))
-const dropB = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub)
-const dropBFull = stack(kickDemoledor, hats16, open, clap,
-  riff.sometimesBy(.2, x=>x.add(note(12))), riffAlto, sub, pad.gain(.3))
-const coda = stack(kick, hats, clap.gain(.5), riff.lpf(700).gain(.7), sub)
+  rodillo, riser, hats16.gain(.4))
+const dropB = stack(kickDemoledor, hats16, open, clap, ghost, riff, riffAlto, sub, leadLimpio, stab)
+const dropBFull = stack(kickDemoledor, hats16, open, clap, ghost, bajoOff,
+  riff.sometimesBy(.2, x=>x.add(note(12))), riffAlto, sub, pad.gain(.3), leadLimpio, stab, contra)
+const coda = stack(kick, hats, clap.gain(.5), riff.lpf(700).gain(.7), sub, leadLimpio.gain(.4))
 const fin = stack(hats.gain(.3), riff.lpf(400).gain(.4).room(.7), pad.gain(.3))
 
 // ── ARREGLO (136 compases) ──
@@ -3822,14 +5381,18 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "41 · call on me — eric prydz (2004)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 41 · CALL ON ME — Eric Prydz (2004) → Pump House Remix
-// 128 BPM · Bm · TR-909 · sidechain EXTREMO (duckdepth .9): todo el track respira
+// 128 BPM · Bm (i·i·VII·VI = Bm·Bm·A·G) · TR-909 · sidechain EXTREMO (duckdepth .9)
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces
+// b·b·a·g) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing +
+// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido.
 // Estructura: intro→build→drop A→breakdown→drop B→coda (128 compases ≈ 4:00)
 // ════════════════════════════════════════════════════════════════
 setcps(128/60/4)
@@ -3842,48 +5405,85 @@ const hook = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~")
 const hookStab = hook.superimpose(x=>x.add(note(-12)).lpf(1300).gain(.6))
 const hookOctava = hook.add(note(12)).gain(.28).orbit(2)
 
-// ── BAJO PEGADO AL KICK (corcheas que el duck convierte en bomba) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Bm7·Bm7·A7·Gmaj7) + hi-pass ──
+const stab = note("<[b2,d3,fs3,a3] [b2,d3,fs3,a3] [a2,cs3,e3,g3] [g2,b2,d3,fs3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ fs4 ~ d4 ~ b3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJO PEGADO AL KICK (corcheas que SIGUEN el acorde: B·B·A·G) ──
 const bajo = note("b1!8").add(note("<0 0 -2 -4>"))
   .s("sawtooth").lpf(800).lpq(5)
   .attack(.001).decay(.2).sustain(.35).release(.04)
-  .shape(.4).gain(.95).orbit(1)
+  .shape(.4).coarse(1).gain(.95).orbit(1)
+// ── SUB afinado que SIGUE la fundamental de cada compás ──
 const sub = note("<b1 b1 a1 g1>").s("sine")
   .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<b2 b2 a2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BATERÍA 909 (el kick manda: duckdepth .9, duckattack .2) ──
-const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado (el kick manda: duckdepth .9) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).gain(.92)
   .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0)
-const kickPump = s("bd*4").bank("RolandTR909").shape(.6).distort(1.15).gain(1.1)
+const kickBoom = note("<b1 b1 a1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickPumpClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.7).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickPump = stack(kickPumpClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
-const hatsMin = s("[~ hh]*4").bank("RolandTR909").gain(.32).pan(.55).orbit(0)
-const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.3).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.22).pan(.4).orbit(0)
+// hats con SWING (groove, no rejilla plana)
+const hatsMin = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.32).pan(.55).orbit(0)
+const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.3).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.22).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── PAD CON PUMP FALSO (saw.fast(4) simula el sidechain en la órbita 4) ──
-const pad = note("<[b2,d3,fs3] [b2,d3,fs3] [a2,cs3,e3] [g2,b2,d3]>")
-  .s("supersaw").unison(5).spread(.6).lpf(1000)
+// ── PAD CON PUMP FALSO con 7as + hi-pass (saw.fast(4) simula el sidechain) ──
+const pad = note("<[b2,d3,fs3,a3] [b2,d3,fs3,a3] [a2,cs3,e3,g3] [g2,b2,d3,fs3]>")
+  .s("supersaw").unison(5).spread(.6).lpf(1000).hpf(150)
   .attack(.05).release(.6)
   .gain(saw.fast(4).range(.12,.45)).room(.5).rsize(5).orbit(4)
+// riser de ruido filtrado para transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hatsMin, sub.gain(.4))
 const introB = stack(kick, hatsMin, clap.gain(.5), bajo.lpf(400).gain(.7))
-const build = stack(kick, hatsMin, clap, bajo,
+const build = stack(kick, hatsMin, clap, bajo, riser,
   hookStab.lpf(saw.slow(16).range(400,2400)).gain(.6))
-const buildFin = stack(kickPump, rodillo, bajo, hookStab.gain(.75))
-const dropA = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab)
-const dropAvar = stack(kickPump, hatsMin, open, clap, bajo, sub,
-  hookStab, hookOctava, pad)
-const breakdown = stack(pad, hook.gain(.55).room(.7), hatsMin.gain(.25), sub.gain(.35))
-const breakBuild = stack(pad, hookStab.gain(.7), rodillo, kick.gain(.95), bajo)
-const dropB = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab, hookOctava)
-const dropBFull = stack(kickPump, hatsMin, open, clap, ride, bajo, sub,
-  hookStab.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad, rodillo.gain(.22))
+const buildFin = stack(kickPump, rodillo, riser, bajo, hookStab.gain(.75))
+const dropA = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, hookStab, leadLimpio, stab)
+const dropAvar = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, bajoOff,
+  hookStab, hookOctava, pad, leadLimpio, stab, contra)
+const breakdown = stack(pad, hook.gain(.55).room(.7), hatsMin.gain(.25), sub.gain(.35), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, hookStab.gain(.7), rodillo, riser, kick.gain(.95), bajo)
+const dropB = stack(kickPump, hatsMin, open, clap, ghost, bajo, sub, hookStab, hookOctava, leadLimpio, stab)
+const dropBFull = stack(kickPump, hatsMin, open, clap, ride, ghost, bajo, sub, bajoOff,
+  hookStab.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad, rodillo.gain(.22), leadLimpio, stab, contra)
 const coda = stack(kick, hatsMin, clap.gain(.5), bajo.gain(.8),
-  hook.gain(.45).room(.6), pad.gain(.3))
+  hook.gain(.45).room(.6), pad.gain(.3), leadLimpio.gain(.4))
 const fin = stack(hatsMin.gain(.25), hook.gain(.3).room(.85), pad.gain(.28))
 
 // ── ARREGLO (128 compases) ──
@@ -3900,14 +5500,18 @@ arrange(
   [16, dropBFull],
   [8,  coda],
   [4,  fin]
-)`,
+)
+`,
   },
   {
     name: "42 · played-a-live tribal — safri duo (2000)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 42 · PLAYED-A-LIVE TRIBAL — Safri Duo (2000) → Tribal Techno Remix
-// 138 BPM · Dm · TR-909 + east · los tambores SON el hook
+// 138 BPM · Dm (i·i·VII·v = Dm·Dm·C·Am) · TR-909 + east · los tambores SON el hook
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces
+// d·d·c·a) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing +
+// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido.
 // Estructura: percusión sola→toms→drop tribal→melodía tardía→drop total→coda (144 compases ≈ 4:10)
 // ════════════════════════════════════════════════════════════════
 setcps(138/60/4)
@@ -3929,24 +5533,38 @@ const toms = s("~ ~ [ht mt] ~ ~ lt ~ [mt ht]").bank("RolandTR909")
 const tomsRodillo = s("lt lt mt mt ht ht mt lt mt ht ht mt lt mt ht ht").bank("RolandTR909")
   .gain(saw.slow(4).range(.4,.95)).speed(saw.slow(4).range(1,1.55)).orbit(0)
 
-// ── BATERÍA 909 ──
-const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las raíces ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1)
+const kickBoom = note("<d1 d1 c1 a0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.7).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
+// hats con SWING (groove, no rejilla plana)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
   .gain("[.5 .22 .32 .22]*4").pan(rand.range(.35,.65)).orbit(0)
 const shaker = s("hh*16").bank("RolandCR78")
   .gain(rand.range(.15,.4)).hpf(6000).pan(rand.range(.2,.8)).orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
-// ── BAJO PUNCHY (stabs sincopados, deja hueco a los tambores) ──
-const bajo = note("d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~")
+// ── BAJO PUNCHY (stabs sincopados que SIGUEN el acorde: D·D·C·A) ──
+const bajo = note("<[d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~] [d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~] [c2 ~ ~ c2 ~ ~ c2 ~ c2 ~ ~ c2 ~ e2 d2 ~] [a1 ~ ~ a1 ~ ~ a1 ~ a1 ~ ~ a1 ~ c2 b1 ~]>")
   .s("sawtooth").lpf(900).lpq(7).attack(.002).decay(.14).sustain(.15).release(.04)
-  .shape(.35).gain(.9).orbit(1)
-const bajoSub = note("d1 ~ d1 d1 ~ d1 ~ ~").s("sine")
+  .shape(.35).coarse(1).gain(.9).orbit(1)
+// ── SUB afinado que SIGUE la fundamental de cada compás ──
+const bajoSub = note("<[d1 ~ d1 d1 ~ d1 ~ ~] [d1 ~ d1 d1 ~ d1 ~ ~] [c1 ~ c1 c1 ~ c1 ~ ~] [a0 ~ a0 a0 ~ a0 ~ ~]>").s("sine")
   .decay(.25).sustain(.25).gain(.7).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<d2 d2 c2 a1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
 // ── LA MELODÍA (entra tarde, interpretación del hook de Safri Duo) ──
 const hook = note("d4 f4 g4 a4 g4 f4 d4 ~")
@@ -3955,29 +5573,52 @@ const hook = note("d4 f4 g4 a4 g4 f4 d4 ~")
   .room(.35).rsize(4).gain(.75).pan(sine.slow(8).range(.35,.65)).orbit(2)
 const hookOctava = hook.add(note(12)).gain(.3).lpf(2800).orbit(2)
 
-// ── TEXTURA / DRONE OSCURO ──
-const drone = note("[d2,a2,d3]").s("sawtooth").lpf(500)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("d4 f4 g4 a4 g4 f4 d4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Dm7·Dm7·Cmaj7·Am7) + hi-pass ──
+const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3] [a2,c3,e3,g3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ e4 ~ c4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── TEXTURA / DRONE OSCURO (hi-pass para dejar el sub libre) ──
+const drone = note("[d2,a2,d3]").s("sawtooth").lpf(500).hpf(120)
   .attack(1.2).release(2).room(.7).rsize(7).gain(.35).orbit(4)
+// riser de ruido filtrado para transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const introPerc = stack(kick, taikoA, hats)
 const percDobla = stack(kick, taikoA, taikoB, hats, clap.gain(.45))
 const tribalFull = stack(kick, taikoA, taikoB, taikoC, toms, hats16, clap)
-const rodilloTom = stack(kickHard, tomsRodillo, taikoSolo.gain(.8))
-const dropPerc = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, bajo, bajoSub)
-const dropMelodia = stack(kickHard, taikoA, taikoB, toms, hats16, clap, bajo, bajoSub,
-  hook.lpf(saw.slow(16).range(400,1800)).gain(.6))
-const breakTribal = stack(taikoSolo, toms.gain(.6), drone, bajoSub.gain(.35), shaker.gain(.5))
-const buildTribal = stack(taikoSolo, tomsRodillo, hats16.gain(.4), drone,
+const rodilloTom = stack(kickHard, tomsRodillo, riser, taikoSolo.gain(.8))
+const dropPerc = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, ghost, bajo, bajoSub)
+const dropMelodia = stack(kickHard, taikoA, taikoB, toms, hats16, clap, ghost, bajo, bajoSub,
+  hook.lpf(saw.slow(16).range(400,1800)).gain(.6), leadLimpio, stab)
+const breakTribal = stack(taikoSolo, toms.gain(.6), drone, bajoSub.gain(.35), shaker.gain(.5), contra, leadLimpio.gain(.42).room(.7))
+const buildTribal = stack(taikoSolo, tomsRodillo, hats16.gain(.4), drone, riser,
   hook.gain(.5).room(.6))
-const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap,
-  bajo, bajoSub, hook, hookOctava)
+const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, ghost,
+  bajo, bajoSub, hook, hookOctava, leadLimpio, stab)
 const dropTotalVar = stack(kickHard, taikoA.sometimesBy(.25, x=>x.speed(1.3)), taikoB, taikoC,
-  toms.every(4, x=>x.fast(2)), hats16, clap,
-  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, drone)
+  toms.every(4, x=>x.fast(2)), hats16, clap, ghost, bajoOff,
+  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, drone, leadLimpio, stab, contra)
 const dropPercFin = stack(kickHard, taikoA, taikoB, taikoC, toms,
-  tomsRodillo.degradeBy(.5).gain(.5), hats16, shaker, clap, bajo, bajoSub)
-const coda = stack(kick, taikoA, hats, hook.gain(.4).room(.6), bajoSub.gain(.4))
+  tomsRodillo.degradeBy(.5).gain(.5), hats16, shaker, clap, ghost, bajo, bajoSub)
+const coda = stack(kick, taikoA, hats, hook.gain(.4).room(.6), bajoSub.gain(.4), leadLimpio.gain(.4))
 const codaFin = stack(taikoSolo.gain(.6).room(.7), drone.gain(.25), shaker.gain(.3))
 
 // ── ARREGLO (144 compases) ──
@@ -3995,14 +5636,18 @@ arrange(
   [16, dropPercFin],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "43 · resurection trance — ppk (2001)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 43 · RESURECTION TRANCE — PPK (2001) → Trance Techno Remix
-// 138 BPM · Am · TR-909 · supersaw con portamento (penv) + FX espaciales
+// 138 BPM · Am (i·i·VII·VI = Am·Am·G·F) · TR-909 · supersaw con portamento (penv)
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado que sigue las raíces
+// a·a·g·f) + bajo/sub que siguen los acordes + bajo offbeat + groove con swing +
+// ghost + stab con 7as e hi-pass + carácter DURO peak-time + riser de ruido.
 // Estructura: intro→build→drop A→break cósmico→drop delay largo→coda (148 compases ≈ 4:17)
 // ════════════════════════════════════════════════════════════════
 setcps(138/60/4)
@@ -4018,58 +5663,95 @@ const riffOctava = riff.add(note(12)).gain(.28).lpf(3600).orbit(2)
 const riffCosmico = riff.delay(.55).delaytime(.5).delayfeedback(.65)
   .room(.8).rsize(9)
 
-// ── BAJO ROLLING (16avos con acentos, progresión Am→G→F) ──
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 b4 c5 d5 e5 ~ c5 e5 a5 ~ g5 e5 d5 c5 b4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab con 7as (Am7·Am7·G7·Fmaj7) + hi-pass ──
+const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.22).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── BAJO ROLLING (16avos con acentos, SIGUE el acorde: Am→Am→G→F) ──
 const bajo = note("a1*16").add(note("<0 0 -2 -4>"))
   .s("sawtooth").lpf(perlin.slow(8).range(450,1100)).lpq(9)
   .attack(.001).decay(.09).sustain(.2).release(.03)
-  .shape(.3).gain("[1 .55 .75 .55]*4").orbit(1)
+  .shape(.3).coarse(1).gain("[1 .55 .75 .55]*4").orbit(1)
+// ── SUB afinado que SIGUE la fundamental de cada compás ──
 const bajoSub = note("<a1 a1 g1 f1>").s("sine")
   .attack(.02).decay(.4).sustain(.5).gain(.6).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<a2 a2 g2 f2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BATERÍA 909 TRANCE ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click + BOOM afinado que sigue las raíces ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
+const kickBoom = note("<a1 a1 g1 f1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
-const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0)
-const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0)
-const hats16 = s("hh*16").bank("RolandTR909")
+// hats con SWING (groove, no rejilla plana)
+const hats = s("hh*8").bank("RolandTR909").swingBy(1/24,8).gain(.4).pan(.6).orbit(0)
+const hatsOff = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.55).orbit(0)
+const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/24,16)
   .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.4).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
+// ghost snare sincopada muy baja (para los drops)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
 // ── ATMÓSFERA CÓSMICA ──
 const espacio = s("<space:1 space:3 space:0 space:4>").slow(2)
   .gain(.4).room(.8).rsize(8).lpf(3000)
   .pan(sine.slow(16).range(.2,.8)).orbit(4)
-const pad = note("<[a2,c3,e3] [a2,c3,e3] [g2,b2,d3] [f2,a2,c3]>")
-  .s("sawtooth").lpf(700).attack(.9).release(1.6)
+const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>")
+  .s("sawtooth").lpf(700).hpf(150).attack(.9).release(1.6)
   .room(.7).rsize(7).gain(.4).orbit(4)
+// riser de ruido filtrado para transiciones
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, hatsOff, clap.gain(.45), bajo.lpf(400).gain(.6))
-const build = stack(kick, hats16, clap, bajo, pad,
+const build = stack(kick, hats16, clap, bajo, pad, riser,
   riff.lpf(saw.slow(16).range(350,2200)).gain(.55))
-const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65))
-const dropA = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub, riff)
-const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub,
-  riff, riffOctava)
+const buildFin = stack(kickHard, rodillo, riser, bajo, riff.gain(.65))
+const dropA = stack(kickHard, hats16, hatsOff, clap, ghost, bajo, bajoSub, riff, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajo, bajoSub,
+  riff, riffOctava, leadLimpio, stab, contra)
 const breakCosmos = stack(espacio, pad, riffCosmico.gain(.6),
-  bajoSub.gain(.35), hats.gain(.25))
+  bajoSub.gain(.35), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7))
 const breakBuild = stack(espacio.gain(.3), pad, riffCosmico.gain(.7),
-  rodillo, hats16.gain(.4))
-const dropDelay = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub,
-  riffCosmico.gain(.75))
-const dropTotal = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub,
-  riff, riffOctava, pad.gain(.3))
-const dropTotalVar = stack(kickHard, hats16, hatsOff, clap, ride,
+  rodillo, riser, hats16.gain(.4))
+const dropDelay = stack(kickHard, hats16, hatsOff, clap, ghost, bajo, bajoSub,
+  riffCosmico.gain(.75), leadLimpio, stab)
+const dropTotal = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajo, bajoSub,
+  riff, riffOctava, pad.gain(.3), leadLimpio, stab)
+const dropTotalVar = stack(kickHard, hats16, hatsOff, clap, ride, ghost, bajoOff,
   bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub,
-  riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25))
+  riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25), leadLimpio, stab, contra)
 const coda = stack(kick, hats, bajo.lpf(550).gain(.7),
-  riff.gain(.45).room(.7), pad)
+  riff.gain(.45).room(.7), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), espacio,
   riffCosmico.gain(.35).delayfeedback(.75), pad.gain(.3))
 
@@ -4088,14 +5770,18 @@ arrange(
   [16, dropTotalVar],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "44 · lady french touch — modjo (2000)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 44 · LADY FRENCH TOUCH — Modjo (2000) → French Touch Remix
-// 122 BPM · F#m · TR-909 · filtros que respiran + swing suave y elegante
+// 122 BPM · F#m (i·i·III·iv = F#m·F#m·A·Bm) · TR-909 · filtros que respiran
+// PRODUCCIÓN PRO: kick 2 capas (click + boom afinado F#·F#·A·B) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass
+// + carácter peak-time (saturación) + riser de ruido. Estructura conservada.
 // Estructura: intro→groove→drop filtrado→break sedoso→drop abierto→coda (136 compases ≈ 4:28)
 // ════════════════════════════════════════════════════════════════
 setcps(122/60/4)
@@ -4109,60 +5795,100 @@ const riffRespira = riff.lpf(sine.slow(16).range(500,2400))
   .hpf(sine.slow(23).range(40,500))
 const riffOctava = riff.add(note(12)).gain(.3).lpf(2600).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("fs3 a3 b3 cs4 e4 cs4 b3 a3")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (F#m7·F#m7·Amaj7·Bm7) + hi-pass ──
+const stab = note("<[fs3,a3,cs4,e4] [fs3,a3,cs4,e4] [a2,cs3,e3,gs3] [b2,d3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.32).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ cs4 ~ a3 ~ fs3 ~] [~ ~ e4 ~ cs4 ~ a3 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── STABS DE ACORDE (a contratiempo, como el sample original) ──
 const stabs = note("~ [fs3,a3,cs4,e4] ~ [fs3,a3,cs4,e4]")
   .s("sawtooth").lpf(1500).attack(.005).decay(.15).sustain(0).release(.08)
   .hpf(300).room(.3).rsize(3).gain(.55)
   .phaser(.3).phaserdepth(.3).orbit(3)
 
-// ── BAJO DISCO CON OCTAVAS (progresión F#m→F#m→A→B) ──
+// ── BAJO DISCO CON OCTAVAS (sigue las fundamentales F#·F#·A·B) ──
 const bajo = note("fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2]")
   .add(note("<0 0 3 5>"))
-  .s("sawtooth").lpf(750).lpq(4).attack(.003).decay(.16).sustain(.3).release(.05)
-  .shape(.2).gain(.9).swingBy(.06, 8).orbit(1)
+  .s("sawtooth").lpf(perlin.slow(4).range(500,1200)).lpq(6).attack(.003).decay(.16).sustain(.3).release(.05)
+  .shape(.3).coarse(1).gain(.9).swingBy(.06, 8).orbit(1)
+// ── SUB-BAJO afinado que SIGUE la fundamental (coherencia armónica) ──
 const bajoSub = note("<fs1 fs1 a1 b1>").s("sine")
   .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4: pulsa en las "y") ──
+const bajoOff = note("<fs2 fs2 a2 b2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BATERÍA 909 CÁLIDA CON SWING ──
-const kick = s("bd*4").bank("RolandTR909").shape(.25).gain(1)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0)
+const kickBoom = note("<fs1 fs1 a1 b1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(.95)
+  .duck("1:2").duckattack(.13).duckdepth(.55).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
+
+// ── PERCUSIÓN CÁLIDA CON SWING + velocity humanizada + ghost ──
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(3).gain(.7).orbit(0)
 const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).swingBy(.08, 8).pan(.6).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.4 .18 .28 .18]*4").swingBy(.08, 8).pan(rand.range(.4,.6)).orbit(0)
-const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0)
+  .gain(perlin.range(.22,.5)).swingBy(.08, 8).pan(rand.range(.4,.6)).orbit(0)
+const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.4).orbit(0)
 const rimGroove = s("~ ~ rim ~ ~ rim ~ ~").bank("LinnDrum")
   .gain(.4).swingBy(.08, 8).pan(.35).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
+const rodillo = s("sd*16").bank("RolandTR909")
+  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)
 
-// ── PAD SUAVE (strings de terciopelo) ──
-const pad = note("[fs3,a3,cs4]").add(note("<0 0 3 5>"))
+// ── PAD SUAVE (strings de terciopelo, 7as, hi-pass para dejar el sub libre) ──
+const pad = note("[fs3,a3,cs4,e4]").add(note("<0 0 3 5>"))
   .s("supersaw").unison(4).spread(.5)
-  .lpf(sine.slow(24).range(400,1400)).attack(.7).release(1.2)
-  .room(.6).rsize(6).gain(.32).orbit(4)
+  .lpf(sine.slow(24).range(400,1400)).hpf(150).attack(.7).release(1.2)
+  .room(.6).rsize(6).gain(.3).orbit(4)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, hatOpen, clap.gain(.4), bajo.lpf(450).gain(.65))
 const groove = stack(kick, hats, hats16, clap, rimGroove, bajo,
   riffRespira.gain(.6))
-const grooveFin = stack(kick, hats16, clap, bajo,
+const grooveFin = stack(kickHard, hats16, clap, rodillo, riser, bajo,
   riff.hpf(saw.slow(4).range(40,900)).gain(.7))
-const dropFiltrado = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
-  bajo, bajoSub, riffRespira, stabs.gain(.4))
-const dropFunk = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
-  bajo, bajoSub, riff, stabs, riffOctava)
+const dropFiltrado = stack(kick, hats, hats16, hatOpen, clap, rimGroove, ghost,
+  bajo, bajoSub, riffRespira, stabs.gain(.4), leadLimpio, stab)
+const dropFunk = stack(kickHard, hats, hats16, hatOpen, clap, rimGroove, ghost,
+  bajo, bajoSub, bajoOff, riff, stabs, riffOctava, leadLimpio, stab)
 const breakSedoso = stack(pad, riff.gain(.5).room(.6).lpf(900),
-  hats.gain(.3), bajoSub.gain(.35), rimGroove.gain(.25))
-const breakBuild = stack(pad, riffRespira.gain(.7), stabs.gain(.4),
+  hats.gain(.3), bajoSub.gain(.35), rimGroove.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, riffRespira.gain(.7), stabs.gain(.4), riser,
   hats16.gain(.35), bajo.lpf(500).gain(.6))
-const dropAbierto = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
-  bajo, bajoSub, riff.lpf(2600), stabs, riffOctava, pad.gain(.22))
-const dropAbiertoVar = stack(kick, hats16, hatOpen, clap, rimGroove,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
-  riff.every(4, x=>x.rev()), stabs, riffOctava, pad.gain(.22))
+const dropAbierto = stack(kickHard, hats, hats16, hatOpen, clap, rimGroove, ghost,
+  bajo, bajoSub, riff.lpf(2600), stabs, riffOctava, pad.gain(.22), leadLimpio, stab)
+const dropAbiertoVar = stack(kickHard, hats16, hatOpen, clap, rimGroove, ghost,
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  riff.every(4, x=>x.rev()), stabs, riffOctava, pad.gain(.22), leadLimpio, stab, contra)
 const salida = stack(kick, hats, clap, bajo, riffRespira.gain(.55), stabs.gain(.35))
 const coda = stack(kick, hats, bajo.lpf(550).gain(.7),
-  riff.gain(.4).room(.6), pad)
+  riff.gain(.4).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.3), riff.gain(.28).room(.8).lpf(800),
   pad.gain(.25), bajoSub.gain(.3))
 
@@ -4181,19 +5907,23 @@ arrange(
   [8,  salida],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "45 · feel good inc bass — gorillaz (2005)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 45 · FEEL GOOD INC BASS — Gorillaz (2005) → Bass Techno Remix
-// 127 BPM · Em · TR-808 · bajazo + risa maníaca (white+vowel+stut) · oscuro y chulesco
+// 127 BPM · Em (i·VII·VI·v = Em·D·C·Bm) · TR-808 · oscuro y chulesco
+// PRODUCCIÓN PRO: kick 2 capas (click 808 + boom afinado E·D·C·B siguiendo
+// el tresillo) + sub/pad que siguen los acordes + groove (swing+ghost) +
+// 7as/9as e hi-pass + carácter peak-time (distort) + riser. Estructura conservada.
 // Estructura: intro sombría→groove 808→drop bajo→break risa→drop total→coda (136 compases ≈ 4:17)
 // ════════════════════════════════════════════════════════════════
 setcps(127/60/4)
 
-// ── EL BAJAZO (línea EXACTA de Feel Good Inc) ──
+// ── EL BAJAZO (línea EXACTA de Feel Good Inc, outlinea la armonía) ──
 const bajo = note("e2 ~ g2 e2 d2 ~ c2 b1")
   .s("sawtooth").shape(.45).lpf(800).lpq(7)
   .attack(.002).decay(.2).sustain(.4).release(.06)
@@ -4201,20 +5931,32 @@ const bajo = note("e2 ~ g2 e2 d2 ~ c2 b1")
 const bajoSub = note("e1 ~ g1 e1 d1 ~ c1 b0").s("sine")
   .attack(.003).decay(.3).sustain(.4).gain(.65).orbit(1)
 const bajoSucio = bajo.distort(1.1).lpf(1100).gain(.85)
+// ── BAJO OFFBEAT (rompe el tresillo: pulsa en las "y", sigue raíces) ──
+const bajoOff = note("<e2 d2 c2 b1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.42).duck("1").orbit(1)
 
-// ── BEAT 808 HIP-HOP-TECHNO (bombo con huecos, tresillo 3-3-2) ──
-const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.4).gain(1.05)
+// ── KICK 808 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+// el boom sigue el tresillo 3-3-2 con fundamental por compás E·D·C·B
+const kickClick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0)
-const kickDuro = s("bd ~ [~ bd] bd ~ ~ bd ~").bank("RolandTR808")
-  .shape(.5).distort(1.05).gain(1.1)
+const kickBoom = note("<e1 d1 c1 b0>").struct("x ~ ~ x ~ ~ x ~").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0)
+const kickDuroClick = s("bd ~ [~ bd] bd ~ ~ bd ~").bank("RolandTR808")
+  .hpf(38).shape(.6).distort(1.3).gain(1.05)
   .duck("1:2").duckattack(.08).duckdepth(.55).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickDuro = stack(kickDuroClick, kickBoom.gain(1.05))
+
 const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.8).room(.15).orbit(0)
 const snareGhost = s("sd(3,16,6)").bank("RolandTR808").gain(.25)
   .pan(rand.range(.3,.7)).orbit(0)
-const hats = s("hh*8").bank("RolandTR808")
+const hats = s("hh*8").bank("RolandTR808").swingBy(1/24,8)
   .gain("[.5 .3]*4").sometimesBy(.15, x=>x.ply(2)).pan(.6).orbit(0)
-const hatOpen = s("~ ~ [~ oh] ~").bank("RolandTR808").gain(.4).orbit(0)
+const hatOpen = s("~ ~ [~ oh] ~").bank("RolandTR808").nudge(.004).gain(.4).orbit(0)
 const cowRim = s("~ ~ ~ rim").bank("RolandTR808").gain(.35).pan(.3).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR808").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 
 // ── LA RISA MANÍACA (ruido blanco + vocales + stut) ──
 const risa = s("white*8").attack(.001).decay(.07).sustain(0)
@@ -4230,35 +5972,59 @@ const hook = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~")
   .gain(.6).pan(sine.slow(8).range(.4,.6)).orbit(2)
 const hookOctava = hook.add(note(12)).gain(.25).crush(8).orbit(2)
 
-// ── ATMÓSFERA OSCURA ──
-const pad = note("[e2,g2,b2]").s("sawtooth").lpf(450)
-  .attack(1.1).release(2).room(.65).rsize(7).gain(.35).orbit(4)
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Em7·Dadd9·Cmaj7·Bm7) + hi-pass ──
+const stab = note("<[e3,g3,b3,d4] [d3,fs3,a3,e4] [c3,e3,g3,b3] [b2,d3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ e4 ~ b3 ~ g3 ~] [~ ~ d4 ~ a3 ~ fs3 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ fs4 ~ d4 ~ b3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── ATMÓSFERA OSCURA (pad que SIGUE los acordes, con 7as e hi-pass) ──
+const pad = note("<[e2,g2,b2,d3] [d2,fs2,a2,c3] [c2,e2,g2,b2] [b1,d2,fs2,a2]>")
+  .s("sawtooth").lpf(450).attack(1.1).release(2).hpf(120)
+  .room(.65).rsize(7).gain(.35).orbit(4)
 const viento = s("wind:2").slow(2).gain(.3).lpf(2000)
   .room(.7).rsize(8).pan(sine.slow(12).range(.3,.7)).orbit(4)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, pad.gain(.25))
 const introB = stack(kick, hats, cowRim, snare.gain(.5), bajoSub.gain(.45))
 const groove = stack(kick, hats, hatOpen, snare, snareGhost, cowRim,
   bajo.lpf(saw.slow(16).range(300,800)).gain(.8))
-const grooveFin = stack(kickDuro, snare, hats.fast(2).gain(.4),
+const grooveFin = stack(kickDuro, snare, hats.fast(2).gain(.4), riser,
   bajo, risa.gain(.35))
-const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim,
+const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, ghost,
   bajo, bajoSub)
-const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost,
-  bajo, bajoSub, hook)
+const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost, ghost,
+  bajo, bajoSub, hook, leadLimpio, stab)
 const breakRisa = stack(risa, viento, pad, bajoSub.gain(.35),
-  hats.gain(.25), hook.gain(.4).room(.6))
-const breakBuild = stack(risa.degradeBy(.15).gain(.6), pad,
+  hats.gain(.25), hook.gain(.4).room(.6), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(risa.degradeBy(.15).gain(.6), pad, riser,
   snareGhost.fast(2).gain(.35), bajo.lpf(500).gain(.7), hook.gain(.5))
-const dropTotal = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim,
-  bajoSucio, bajoSub, hook, hookOctava)
-const dropTotalVar = stack(kickDuro, hats, hatOpen, snare,
-  bajoSucio.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
-  hook.every(4, x=>x.iter(4)), hookOctava, risa.degradeBy(.6).gain(.35))
+const dropTotal = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, ghost,
+  bajoSucio, bajoSub, bajoOff, hook, hookOctava, leadLimpio, stab)
+const dropTotalVar = stack(kickDuro, hats, hatOpen, snare, ghost,
+  bajoSucio.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  hook.every(4, x=>x.iter(4)), hookOctava, risa.degradeBy(.6).gain(.35), leadLimpio, stab, contra)
 const salida = stack(kick, hats, snare, cowRim, bajo, bajoSub, hook.gain(.45))
 const coda = stack(kick, hats, bajo.lpf(500).gain(.7),
-  hook.gain(.35).room(.6), pad)
+  hook.gain(.35).room(.6), pad, leadLimpio.gain(.4))
 const codaFin = stack(viento, hook.gain(.25).room(.85).delayfeedback(.6),
   pad.gain(.25), bajoSub.gain(.3))
 
@@ -4277,14 +6043,18 @@ arrange(
   [8,  salida],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "46 · seven nation army anthem — the white stripes (2003)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 46 · SEVEN NATION ARMY ANTHEM — The White Stripes (2003) → Peak-Time Anthem Remix
-// 130 BPM · Em · TR-909 · riff masivo + multitud de estadio + rodillos militares
+// 130 BPM · Em (i·i·VI·V = Em·Em·C·B) · TR-909 · riff masivo de estadio
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado E·E·C·B) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass
+// + carácter peak-time (distort) + riser. Estructura conservada.
 // Estructura: stomp→build→drop riff→break estadio→drop octavas→drop final→coda (152 compases ≈ 4:41)
 // ════════════════════════════════════════════════════════════════
 setcps(130/60/4)
@@ -4303,58 +6073,94 @@ const riffLead = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~")
   .attack(.01).decay(.2).sustain(.35).release(.15)
   .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.35)
   .gain(.6).orbit(2)
+// ── SUB-BAJO afinado que SIGUE la fundamental por compás E·E·C·B ──
+const bajoSub = note("<e1 e1 c1 b0>").struct("x*4").s("sine")
+  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ──
+const bajoOff = note("<e2 e2 c2 b1>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
+
+// ── LEAD LIMPIO (el riff una octava arriba, nítido y al frente) ──
+const leadLimpio = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~")
+  .s("triangle").lpf(5200).lpq(1)
+  .attack(.005).decay(.22).sustain(.45).release(.16)
+  .room(.3).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Em7·Em7·Cmaj7·B7) + hi-pass ──
+const stab = note("<[e3,g3,b3,d4] [e3,g3,b3,d4] [c3,e3,g3,b3] [b2,ds3,fs3,a3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ b3 ~ g3 ~ e3 ~] [~ ~ b3 ~ g3 ~ e3 ~] [~ ~ c4 ~ g3 ~ e3 ~] [~ ~ b3 ~ fs3 ~ ds3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
 
 // ── LA MULTITUD (oleadas de ruido blanco, estadio) ──
 const multitud = s("white*2").attack(.35).decay(.6).sustain(.3).release(.5)
   .lpf(1500).hpf(300).gain(sine.slow(8).range(.12,.3))
   .pan(sine.slow(5).range(.3,.7)).room(.6).rsize(8).orbit(4)
 
-// ── BATERÍA 909 MILITAR ──
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
 const stomp = s("bd ~ bd ~").bank("RolandTR909").shape(.5).gain(1.1).orbit(0)
 const stompClap = s("~ ~ cp ~").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0)
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
+const kickBoom = note("<e1 e1 c1 b0>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1)
   .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
+  .gain(perlin.range(.25,.5)).swingBy(1/24,16).pan(rand.range(.35,.65)).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.35).orbit(0)
 const sdGhost = s("sd(5,16,2)").bank("RolandTR909").gain(.28)
   .pan(rand.range(.3,.7)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rodilloMil = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.25,.9)).speed(saw.slow(4).range(1,1.3)).orbit(0)
 
-// ── CUERDAS ÉPICAS (Em→Em→C→B) ──
-const cuerdas = note("<[e3,g3,b3] [e3,g3,b3] [c3,g3,c4] [b2,ds3,fs3]>")
+// ── CUERDAS ÉPICAS (Em7→Em7→Cmaj7→B7, hi-pass) ──
+const cuerdas = note("<[e3,g3,b3,d4] [e3,g3,b3,d4] [c3,e3,g3,b3] [b2,ds3,fs3,a3]>")
   .s("supersaw").unison(6).spread(.8)
-  .lpf(sine.slow(32).range(400,2200)).attack(.5).release(1)
-  .room(.6).rsize(7).gain(.38).orbit(4)
+  .lpf(sine.slow(32).range(400,2200)).hpf(200).attack(.5).release(1)
+  .room(.6).rsize(7).gain(.36).orbit(4)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const introStomp = stack(stomp, stompClap, multitud)
 const introRiff = stack(kick, hats, riff.lpf(500).gain(.6), multitud.gain(.15))
 const build = stack(kick, hats16, clap, sdGhost, riff, riffSub.gain(.4),
   cuerdas.gain(.25))
-const buildFin = stack(kickHard, rodilloMil, riff, riffLead.gain(.4))
-const dropRiff = stack(kickHard, hats16, hats, clap, sdGhost,
-  riff, riffSub)
-const dropRiffVar = stack(kickHard, hats16, hats, clap, ride, sdGhost,
-  riff, riffSub, riffLead.gain(.45), multitud.gain(.12))
+const buildFin = stack(kickHard, rodilloMil, riser, riff, riffLead.gain(.4))
+const dropRiff = stack(kickHard, hats16, hats, clap, sdGhost, ghost,
+  riff, riffSub, leadLimpio, stab)
+const dropRiffVar = stack(kickHard, hats16, hats, clap, ride, sdGhost, ghost,
+  riff, riffSub, bajoOff, riffLead.gain(.45), multitud.gain(.12), leadLimpio, stab, contra)
 const breakEstadio = stack(multitud.gain(.3), cuerdas,
-  riffLead.gain(.55).room(.8), stomp.gain(.5), stompClap.gain(.5))
-const breakBuild = stack(multitud.gain(.2), cuerdas, riff.lpf(800).gain(.7),
+  riffLead.gain(.55).room(.8), stomp.gain(.5), stompClap.gain(.5), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(multitud.gain(.2), cuerdas, riser, riff.lpf(800).gain(.7),
   rodilloMil, hats16.gain(.4))
-const dropOctavas = stack(kickHard, hats16, hats, clap, sdGhost,
-  riffOctavas, riffSub, riffLead.gain(.5))
-const dropOctavasFull = stack(kickHard, hats16, hats, clap, ride, sdGhost,
-  riffOctavas, riffSub, riffLead, cuerdas.gain(.28), multitud.gain(.12))
-const dropFinal = stack(kickHard, hats16, hats, clap, ride,
-  riffOctavas.sometimesBy(.2, x=>x.ply(2)), riffSub,
-  riffLead.every(4, x=>x.add(note(12)).gain(.4)), cuerdas.gain(.3))
+const dropOctavas = stack(kickHard, hats16, hats, clap, sdGhost, ghost,
+  riffOctavas, riffSub, riffLead.gain(.5), leadLimpio, stab)
+const dropOctavasFull = stack(kickHard, hats16, hats, clap, ride, sdGhost, ghost,
+  riffOctavas, riffSub, bajoOff, riffLead, cuerdas.gain(.28), multitud.gain(.12), leadLimpio, stab, contra)
+const dropFinal = stack(kickHard, hats16, hats, clap, ride, ghost,
+  riffOctavas.sometimesBy(.2, x=>x.ply(2)), riffSub, bajoOff,
+  riffLead.every(4, x=>x.add(note(12)).gain(.4)), cuerdas.gain(.3), leadLimpio, stab, contra)
 const coda = stack(kick, hats, clap, riff.lpf(700).gain(.7),
-  riffSub.gain(.5), cuerdas, multitud.gain(.15))
+  riffSub.gain(.5), cuerdas, multitud.gain(.15), leadLimpio.gain(.4))
 const codaFin = stack(multitud, cuerdas.gain(.3),
   riffLead.gain(.3).room(.9).delayfeedback(.6), stomp.gain(.4))
 
@@ -4373,14 +6179,18 @@ arrange(
   [16, dropFinal],
   [12, coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "47 · kids melodic — mgmt (2008)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 47 · KIDS MELODIC — MGMT (2008) → Melodic Techno Remix
-// 128 BPM · Am · TR-909 · tipo Afterlife: supersaw suave + arpegio contrapunto
+// 128 BPM · Am (i·i·VII·VI = Am·Am·G·F) · TR-909 · tipo Afterlife
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·A·G·F) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass
+// + carácter peak-time + riser. Estructura conservada.
 // Estructura: intro→build→drop A→breakdown emotivo largo→drop B→coda (152 compases ≈ 4:45)
 // ════════════════════════════════════════════════════════════════
 setcps(128/60/4)
@@ -4393,6 +6203,26 @@ const hook = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~")
   .room(.5).rsize(6).gain(.75).pan(sine.slow(10).range(.35,.65)).orbit(2)
 const hookEco = hook.add(note(12)).gain(.25).late(.125).lpf(3000).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Am7·Am7·G7·Fmaj7) + hi-pass ──
+const stab = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ e4 ~ c4 ~] [~ ~ a4 ~ e4 ~ c4 ~] [~ ~ g4 ~ d4 ~ b3 ~] [~ ~ f4 ~ c4 ~ a3 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── ARPEGIO CONTRAPUNTO (a2 e3 a3 c4 en 16avos) ──
 const arpegio = note("[a2 e3 a3 c4]*4").add(note("<0 0 -2 -4>"))
   .s("triangle").lpf(sine.slow(16).range(700,2200))
@@ -4400,33 +6230,46 @@ const arpegio = note("[a2 e3 a3 c4]*4").add(note("<0 0 -2 -4>"))
   .delay(.2).delaytime(.1875).delayfeedback(.3)
   .gain(.6).pan(.4).orbit(3)
 
-// ── BAJO PULSANTE (corcheas, progresión Am→Am→G→F) ──
+// ── BAJO PULSANTE (corcheas, sigue las fundamentales A·A·G·F) ──
 const bajo = note("a1*8").add(note("<0 0 -2 -4>"))
-  .s("sawtooth").lpf(600).lpq(6).attack(.002).decay(.14).sustain(.25).release(.04)
-  .shape(.25).gain("[.9 .55]*4").orbit(1)
+  .s("sawtooth").lpf(perlin.slow(4).range(500,1100)).lpq(6).attack(.002).decay(.14).sustain(.25).release(.04)
+  .shape(.3).coarse(1).gain("[.9 .55]*4").orbit(1)
 const bajoSub = note("<a1 a1 g1 f1>").s("sine")
   .attack(.05).decay(.5).sustain(.5).gain(.55).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ──
+const bajoOff = note("<a2 a2 g2 f2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
 
-// ── BATERÍA 909 ELEGANTE ──
-const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
   .duck("1:2").duckattack(.14).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08)
+const kickBoom = note("<a1 a1 g1 f1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.2).gain(.98)
   .duck("1:2").duckattack(.14).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.04))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.65).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).pan(.6).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.45).pan(.6).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.42 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.25).pan(.35).orbit(0)
+  .gain(perlin.range(.22,.45)).swingBy(1/24,16).pan(rand.range(.4,.6)).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.25).pan(.35).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.15,.7)).speed(saw.slow(4).range(1,1.3)).orbit(0)
 
-// ── PADS OSCUROS Y CUERDAS ──
+// ── PADS OSCUROS Y CUERDAS (7as, hi-pass para dejar el sub libre) ──
 const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>")
-  .s("sawtooth").lpf(550).attack(1).release(1.8)
+  .s("sawtooth").lpf(550).hpf(150).attack(1).release(1.8)
   .room(.75).rsize(8).gain(.4).orbit(4)
 const cuerdas = note("<a3 a3 g3 f3>").s("supersaw").unison(5).spread(.7)
-  .lpf(sine.slow(32).range(350,1800)).attack(.6).release(1)
+  .lpf(sine.slow(32).range(350,1800)).hpf(200).attack(.6).release(1)
   .vib(4).vibmod(.15).room(.6).rsize(6).gain(.3).orbit(4)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4), pad.gain(.25))
@@ -4434,25 +6277,25 @@ const introB = stack(kick, hats, clap.gain(.4), bajo.lpf(400).gain(.6),
   arpegio.lpf(900).gain(.4))
 const build = stack(kick, hats16, clap, bajo, arpegio, pad,
   hook.lpf(saw.slow(16).range(400,2000)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, arpegio, hook.gain(.6))
-const dropA = stack(kickHard, hats16, hats, clap, bajo, bajoSub,
-  arpegio, hook)
-const dropAvar = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub,
-  arpegio, hook, hookEco, cuerdas)
+const buildFin = stack(kickHard, rodillo, riser, bajo, arpegio, hook.gain(.6))
+const dropA = stack(kickHard, hats16, hats, clap, ghost, bajo, bajoSub,
+  arpegio, hook, leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hats, clap, ride, ghost, bajo, bajoSub, bajoOff,
+  arpegio, hook, hookEco, cuerdas, leadLimpio, stab, contra)
 const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.85).rsize(9),
-  arpegio.lpf(800).gain(.4), bajoSub.gain(.3))
-const breakBuild = stack(pad, cuerdas, hook.gain(.7), arpegio,
+  arpegio.lpf(800).gain(.4), bajoSub.gain(.3), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pad, cuerdas, riser, hook.gain(.7), arpegio,
   rodillo, hats16.gain(.35))
-const dropB = stack(kickHard, hats16, hats, clap, bajo, bajoSub,
-  arpegio, hook, hookEco)
-const dropBFull = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub,
+const dropB = stack(kickHard, hats16, hats, clap, ghost, bajo, bajoSub,
+  arpegio, hook, hookEco, leadLimpio, stab)
+const dropBFull = stack(kickHard, hats16, hats, clap, ride, ghost, bajo, bajoSub, bajoOff,
   arpegio.sometimesBy(.2, x=>x.add(note(12)).gain(.4)), hook, hookEco,
-  cuerdas, pad.gain(.2))
-const dropBvar = stack(kickHard, hats16, clap, ride,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
-  arpegio, hook.every(4, x=>x.iter(4)), hookEco, cuerdas)
+  cuerdas, pad.gain(.2), leadLimpio, stab, contra)
+const dropBvar = stack(kickHard, hats16, clap, ride, ghost,
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  arpegio, hook.every(4, x=>x.iter(4)), hookEco, cuerdas, leadLimpio, stab, contra)
 const coda = stack(kick, hats, bajo.lpf(500).gain(.65),
-  hook.gain(.45).room(.7), arpegio.gain(.4), pad)
+  hook.gain(.45).room(.7), arpegio.gain(.4), pad, leadLimpio.gain(.4))
 const codaFin = stack(hats.gain(.25), hook.gain(.3).room(.9).delayfeedback(.65),
   pad.gain(.3), cuerdas.gain(.2))
 
@@ -4471,14 +6314,18 @@ arrange(
   [16, dropBvar],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "48 · hung up disco — madonna sobre abba (2005)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 48 · HUNG UP DISCO — Madonna sobre ABBA (2005) → Disco Techno Remix
-// 126 BPM · Dm · TR-909 · arpegio ABBA con phaser + tick-tock de reloj
+// 126 BPM · Dm (i·i·i·VII = Dm·Dm·Dm·C) · TR-909 · arpegio ABBA con phaser
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado D·D·D·C) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass
+// + carácter peak-time (distort) + riser. Estructura conservada.
 // Estructura: intro→motor arpegio→drop disco→break reloj→drop brillante→coda (144 compases ≈ 4:34)
 // ════════════════════════════════════════════════════════════════
 setcps(126/60/4)
@@ -4497,38 +6344,71 @@ const hook = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~")
   .delay(.3).delaytime(.25).delayfeedback(.35)
   .room(.4).rsize(5).gain(.8).pan(sine.slow(9).range(.35,.65)).orbit(2)
 
+// ── LEAD LIMPIO (la melodía real, nítida y al frente) ──
+const leadLimpio = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~")
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Dm7·Dm7·Dm7·Cadd9) + hi-pass ──
+const stab = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
 // ── TICK-TOCK DE RELOJ (rim panorámico, como el original) ──
 const reloj = s("rim*4").bank("RolandTR909")
   .speed("1 .82 1 .82").pan("0.15 0.85 0.15 0.85")
   .gain(.6).room(.4).rsize(4)
   .delay(.3).delaytime(.375).delayfeedback(.4).orbit(3)
 
-// ── BAJO DISCO CON OCTAVAS (Dm→Dm→Dm→C) ──
+// ── BAJO DISCO CON OCTAVAS (sigue las fundamentales D·D·D·C) ──
 const bajo = note("d1 [~ d2] d1 [~ d2] d1 [~ d2] d1 [~ d2]")
   .add(note("<0 0 0 -2>"))
   .s("sawtooth").lpf(800).lpq(4).attack(.003).decay(.15).sustain(.3).release(.05)
-  .shape(.2).gain(.9).orbit(1)
+  .shape(.3).coarse(1).gain(.9).orbit(1)
 const bajoSub = note("<d1 d1 d1 c1>").s("sine")
   .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ──
+const bajoOff = note("<d2 d2 d2 c2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.4).duck("1").orbit(1)
 
-// ── STRINGS DISCO (supersaw brillante) ──
-const cuerdas = note("<[d3,f3,a3] [d3,f3,a3] [d3,f3,a3] [c3,e3,g3]>")
+// ── STRINGS DISCO (supersaw brillante, 7as, hi-pass) ──
+const cuerdas = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,b3]>")
   .s("supersaw").unison(6).spread(.8)
-  .lpf(sine.slow(16).range(500,2000)).attack(.4).release(.9)
+  .lpf(sine.slow(16).range(500,2000)).hpf(200).attack(.4).release(.9)
   .room(.55).rsize(6).gain(.4).orbit(4)
 
-// ── BATERÍA 909 DISCO ──
-const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1)
+const kickBoom = note("<d1 d1 d1 c1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1)
   .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
-const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.55).pan(.6).orbit(0)
+const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").nudge(.004).gain(.45).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.48 .22 .34 .22]*4").pan(rand.range(.4,.6)).orbit(0)
+  .gain(perlin.range(.22,.48)).swingBy(1/24,16).pan(rand.range(.4,.6)).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.8)).speed(saw.slow(4).range(1,1.35)).orbit(0)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4), reloj.gain(.3))
@@ -4536,27 +6416,27 @@ const introB = stack(kick, hats, hatOpen, clap.gain(.45),
   arpegio.lpf(700).gain(.5))
 const motor = stack(kick, hats16, hats, clap, bajo, arpegio,
   cuerdas.gain(.25))
-const motorFin = stack(kickHard, rodillo, bajo, arpegio,
+const motorFin = stack(kickHard, rodillo, riser, bajo, arpegio,
   hook.lpf(900).gain(.5))
-const dropDisco = stack(kickHard, hats16, hats, hatOpen, clap,
-  bajo, bajoSub, arpegio, hook)
-const dropDiscoVar = stack(kickHard, hats16, hats, hatOpen, clap,
-  bajo, bajoSub, arpegio, arpegioAlto, hook, cuerdas.gain(.3))
+const dropDisco = stack(kickHard, hats16, hats, hatOpen, clap, ghost,
+  bajo, bajoSub, arpegio, hook, leadLimpio, stab)
+const dropDiscoVar = stack(kickHard, hats16, hats, hatOpen, clap, ghost,
+  bajo, bajoSub, bajoOff, arpegio, arpegioAlto, hook, cuerdas.gain(.3), leadLimpio, stab, contra)
 const breakReloj = stack(reloj, cuerdas, hook.gain(.55).room(.75),
-  bajoSub.gain(.3), hats.gain(.25))
-const breakBuild = stack(reloj.gain(.4), cuerdas, hook.gain(.65),
+  bajoSub.gain(.3), hats.gain(.25), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(reloj.gain(.4), cuerdas, hook.gain(.65), riser,
   arpegio.lpf(saw.slow(8).range(600,2200)).gain(.6),
   rodillo, hats16.gain(.35))
-const dropBrillante = stack(kickHard, hats16, hats, hatOpen, clap,
-  bajo, bajoSub, arpegio.lpf(2400), arpegioAlto, hook, cuerdas.gain(.32))
-const dropBrillanteVar = stack(kickHard, hats16, hatOpen, clap,
-  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
+const dropBrillante = stack(kickHard, hats16, hats, hatOpen, clap, ghost,
+  bajo, bajoSub, arpegio.lpf(2400), arpegioAlto, hook, cuerdas.gain(.32), leadLimpio, stab)
+const dropBrillanteVar = stack(kickHard, hats16, hatOpen, clap, ghost,
+  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
   arpegio.every(4, x=>x.rev()), arpegioAlto, hook, cuerdas.gain(.32),
-  reloj.gain(.25))
+  reloj.gain(.25), leadLimpio, stab, contra)
 const salida = stack(kick, hats, clap, bajo, arpegio.gain(.6),
   hook.gain(.5), cuerdas.gain(.25))
 const coda = stack(kick, hats, bajo.lpf(550).gain(.7),
-  arpegio.lpf(900).gain(.45), hook.gain(.4).room(.7), cuerdas)
+  arpegio.lpf(900).gain(.45), hook.gain(.4).room(.7), cuerdas, leadLimpio.gain(.4))
 const codaFin = stack(reloj.gain(.4), hook.gain(.3).room(.9).delayfeedback(.6),
   cuerdas.gain(.25))
 
@@ -4575,14 +6455,18 @@ arrange(
   [12, salida],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "49 · touch me deep — rui da silva (2001)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 49 · TOUCH ME DEEP — Rui da Silva (2001) → Deep Progressive Remix
-// 126 BPM · Am · TR-909 + piano · nocturno, sensual, subida lenta
+// 126 BPM · Am (i·VII·VI·VII = Am·G·F·G) · TR-909 + piano · nocturno
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·G·F·G) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + pad con 7as e hi-pass
+// + carácter peak-time + riser. Estructura conservada.
 // Estructura: intro→groove profundo→drop piano→break piano solo→drop abierto→coda (144 compases ≈ 4:34)
 // ════════════════════════════════════════════════════════════════
 setcps(126/60/4)
@@ -4595,58 +6479,85 @@ const piano = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<0 -2 -4 -2>"))
 const pianoAlto = piano.add(note(12)).gain(.3).room(.7).orbit(2)
 const pianoSolo = piano.room(.85).rsize(9).delayfeedback(.5).gain(.85)
 
-// ── BAJO PROFUNDO Y REDONDO (triangle, sigue la progresión) ──
+// ── LEAD LIMPIO (el riff de piano una octava arriba, nítido y al frente) ──
+const leadLimpio = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<12 10 8 10>"))
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.005).decay(.2).sustain(.4).release(.16)
+  .room(.32).rsize(4).delay(.25).delaytime(.375).delayfeedback(.25)
+  .gain(.5).pan(.5).orbit(2)
+
+// ── CONTRAMELODÍA (zona media, Am·G·F·G) ──
+const contra = note("<[~ ~ e4 ~ c4 ~ a3 ~] [~ ~ d4 ~ b3 ~ g3 ~] [~ ~ c4 ~ a3 ~ f3 ~] [~ ~ d4 ~ b3 ~ g3 ~]>")
+  .s("triangle").lpf(2700).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.3).pan(.62).orbit(3)
+
+// ── BAJO PROFUNDO Y REDONDO (triangle, sigue las fundamentales A·G·F·G) ──
 const bajo = note("a1 ~ [~ a1] ~ a1 ~ [~ a1] ~").add(note("<0 -2 -4 -2>"))
   .s("triangle").lpf(500).attack(.01).decay(.3).sustain(.5).release(.08)
-  .shape(.15).gain(.95).orbit(1)
+  .shape(.18).gain(.95).orbit(1)
 const bajoSub = note("<a1 g1 f1 g1>").s("sine")
   .attack(.05).decay(.5).sustain(.55).gain(.55).orbit(1)
+// ── BAJO OFFBEAT (rompe el 4x4, sigue raíces) ──
+const bajoOff = note("<a2 g2 f2 g2>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.38).duck("1").orbit(1)
 
-// ── BATERÍA 909 SEDOSA ──
-const kick = s("bd*4").bank("RolandTR909").shape(.3).gain(1)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.48).gain(.9)
   .duck("1:2").duckattack(.15).duckdepth(.45).orbit(0)
-const kickHondo = s("bd*4").bank("RolandTR909").shape(.4).gain(1.06)
+const kickBoom = note("<a1 g1 f1 g1>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.28).gain(1).orbit(0)
+const kickHondoClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.58).distort(1.15).gain(.96)
   .duck("1:2").duckattack(.15).duckdepth(.55).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHondo = stack(kickHondoClick, kickBoom.gain(1.04))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(4).gain(.6).orbit(0)
-const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).hpf(8000).pan(.6).orbit(0)
+const hats = s("[~ hh]*4").bank("RolandTR909").swingBy(1/24,8).gain(.45).hpf(8000).pan(.6).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
   .gain(rand.range(.12,.35)).hpf(9000).swingBy(.04, 8)
   .pan(rand.range(.35,.65)).orbit(0)
 const rimSuave = s("~ ~ ~ rim ~ ~ rim ~").bank("RolandTR909")
   .gain(.35).pan(.35).room(.3).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.26)).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(8).range(.1,.6)).speed(saw.slow(8).range(1,1.25)).orbit(0)
 
-// ── VOZ SINTÉTICA Y PAD NOCTURNO ──
+// ── VOZ SINTÉTICA Y PAD NOCTURNO (sigue los acordes, con 7as e hi-pass) ──
 const voz = note("<a3 g3 f3 g3>").s("sawtooth").vowel("<o a u a>")
-  .attack(.7).release(1.2).lpf(1500)
+  .attack(.7).release(1.2).lpf(1500).hpf(160)
   .room(.7).rsize(8).gain(.35).orbit(4)
-const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>")
-  .s("sawtooth").lpf(sine.slow(32).range(350,900)).attack(1.2).release(2)
+const pad = note("<[a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3] [g2,b2,d3,f3]>")
+  .s("sawtooth").lpf(sine.slow(32).range(350,900)).hpf(150).attack(1.2).release(2)
   .room(.75).rsize(8).gain(.38).orbit(4)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, bajoSub.gain(.4))
 const introB = stack(kick, hats, rimSuave, clap.gain(.4),
   bajo.lpf(350).gain(.7))
 const groove = stack(kick, hats, hats16, clap, rimSuave, bajo, bajoSub,
-  piano.lpf(saw.slow(32).range(600,3500)).gain(.6))
-const grooveFin = stack(kickHondo, rodillo, bajo, piano.gain(.7))
-const dropPiano = stack(kickHondo, hats, hats16, clap, rimSuave,
-  bajo, bajoSub, piano)
-const dropPianoVar = stack(kickHondo, hats, hats16, clap, rimSuave,
-  bajo, bajoSub, piano, pianoAlto, voz)
-const breakPiano = stack(pianoSolo, bajoSub.gain(.25), hats.gain(.2))
-const breakBuild = stack(pianoSolo.gain(.75), pad, voz,
+  piano.lpf(saw.slow(32).range(600,3500)).gain(.6), leadLimpio.gain(.42))
+const grooveFin = stack(kickHondo, rodillo, riser, bajo, piano.gain(.7), leadLimpio.gain(.5))
+const dropPiano = stack(kickHondo, hats, hats16, clap, rimSuave, ghost,
+  bajo, bajoSub, piano, leadLimpio, contra)
+const dropPianoVar = stack(kickHondo, hats, hats16, clap, rimSuave, ghost,
+  bajo, bajoSub, bajoOff, piano, pianoAlto, voz, leadLimpio, contra)
+const breakPiano = stack(pianoSolo, bajoSub.gain(.25), hats.gain(.2), contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(pianoSolo.gain(.75), pad, voz, riser,
   rodillo, hats16.gain(.3), bajo.lpf(400).gain(.6))
-const dropAbierto = stack(kickHondo, hats, hats16, clap, rimSuave,
-  bajo, bajoSub, piano, pianoAlto, pad.gain(.25))
-const dropAbiertoVar = stack(kickHondo, hats16, clap, rimSuave,
-  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
-  piano.every(4, x=>x.rev()), pianoAlto, voz, pad.gain(.25))
+const dropAbierto = stack(kickHondo, hats, hats16, clap, rimSuave, ghost,
+  bajo, bajoSub, piano, pianoAlto, pad.gain(.25), leadLimpio, contra)
+const dropAbiertoVar = stack(kickHondo, hats16, clap, rimSuave, ghost,
+  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
+  piano.every(4, x=>x.rev()), pianoAlto, voz, pad.gain(.25), leadLimpio, contra)
 const salida = stack(kick, hats, clap, bajo, piano.gain(.6), voz.gain(.25))
 const coda = stack(kick, hats, bajo.lpf(400).gain(.7),
-  piano.gain(.5).room(.75), pad)
+  piano.gain(.5).room(.75), pad, leadLimpio.gain(.4))
 const codaFin = stack(pianoSolo.gain(.4).delayfeedback(.6),
   pad.gain(.3), voz.gain(.25), hats.gain(.2))
 
@@ -4665,14 +6576,18 @@ arrange(
   [12, salida],
   [8,  coda],
   [4,  codaFin]
-)`,
+)
+`,
   },
   {
     name: "50 · adagio big room — tiësto / samuel barber (2005)",
     folder: "remixes 2000s",
     code: `// ════════════════════════════════════════════════════════════════
 // 50 · ADAGIO BIG ROOM — Tiësto / Samuel Barber (2005) → Big Room Trance Remix
-// 140 BPM · Am · TR-909 · cuerdas supersaw masivas · el cierre épico de la colección
+// 140 BPM · Am (i·iv·III·v = Am·Dm·C·Em) · TR-909 · cuerdas supersaw masivas
+// PRODUCCIÓN PRO: kick 2 capas (click 909 + boom afinado A·D·C·E) + bajo/sub
+// que siguen los acordes + groove (swing+ghost+velocity) + 7as/9as e hi-pass
+// + carácter peak-time (distort) + riser. Estructura conservada.
 // Estructura: intro→build→drop A→breakdown orquestal 20→drop final devastador→coda en cuerdas (172 compases ≈ 4:55)
 // ════════════════════════════════════════════════════════════════
 setcps(140/60/4)
@@ -4687,10 +6602,31 @@ const melodia = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~")
 const melodiaOctava = melodia.add(note(12)).gain(.3).lpf(3400).orbit(2)
 const melodiaSola = melodia.room(.95).rsize(10).lpf(2800).gain(.7)
 
-// ── CUERDAS MASIVAS (Am→Dm→C→Em, unison 7 spread .9) ──
-const cuerdas = note("<[a2,c3,e3] [d3,f3,a3] [c3,e3,g3] [e3,g3,b3]>")
+// ── LEAD LIMPIO (la melodía real, nítida y al frente · .slow(4) para alinear con melodia) ──
+const leadLimpio = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~")
+  .slow(4).clip(1.5)
+  .s("triangle").lpf(5000).lpq(1)
+  .attack(.004).decay(.18).sustain(.5).release(.14)
+  .room(.28).rsize(3).delay(.2).delaytime(.375).delayfeedback(.2)
+  .gain(.6).pan(.5).orbit(2)
+
+// ── ZONA MEDIA: stab armónico con 7as (Am7·Dm7·Cmaj7·Em7) + hi-pass ──
+const stab = note("<[a2,c3,e3,g3] [d3,f3,a3,c4] [c3,e3,g3,b3] [e3,g3,b3,d4]>")
+  .struct("~ x ~ x ~ x ~ x").s("sawtooth").lpf(1700).lpq(4)
+  .attack(.004).decay(.13).sustain(.08).release(.08)
+  .hpf(160).shape(.24).room(.3).rsize(5).gain(.33).pan(.4)
+  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(3)
+
+const contra = note("<[~ ~ a4 ~ e4 ~ c4 ~] [~ ~ a4 ~ f4 ~ d4 ~] [~ ~ g4 ~ e4 ~ c4 ~] [~ ~ b4 ~ g4 ~ e4 ~]>")
+  .s("triangle").lpf(2800).lpq(2)
+  .attack(.004).decay(.15).sustain(.2).release(.1)
+  .room(.42).rsize(6).delay(.25).delaytime(.1875).delayfeedback(.3)
+  .gain(.32).pan(.62).orbit(3)
+
+// ── CUERDAS MASIVAS (Am7→Dm7→Cmaj7→Em7, unison 7 spread .9, hi-pass) ──
+const cuerdas = note("<[a2,c3,e3,g3] [d3,f3,a3,c4] [c3,e3,g3,b3] [e3,g3,b3,d4]>")
   .s("supersaw").unison(7).spread(.9)
-  .lpf(sine.slow(32).range(400,2400)).attack(.8).release(1.6)
+  .lpf(sine.slow(32).range(400,2400)).hpf(200).attack(.8).release(1.6)
   .room(.8).rsize(9).gain(.45).orbit(4)
 const cuerdasBajas = note("<a1 d2 c2 e2>").s("sawtooth").lpf(400)
   .attack(.5).release(1).room(.5).gain(.4).orbit(4)
@@ -4698,30 +6634,43 @@ const cuerdasBajas = note("<a1 d2 c2 e2>").s("sawtooth").lpf(400)
 // ── BAJO TRANCE (offbeat, sigue la progresión A→D→C→E) ──
 const bajo = note("[~ a1]*4").add(note("<0 5 3 7>"))
   .s("sawtooth").lpf(700).lpq(5).attack(.002).decay(.18).sustain(.3).release(.05)
-  .shape(.3).gain(.95).orbit(1)
+  .shape(.3).coarse(1).gain(.95).orbit(1)
 const bajoFin = note("a1*8").add(note("<0 5 3 7>"))
   .s("sawtooth").lpf(perlin.slow(8).range(500,1200)).lpq(7)
   .attack(.001).decay(.1).sustain(.2).release(.03)
-  .shape(.35).gain("[1 .6]*4").orbit(1)
+  .shape(.35).coarse(1).gain("[1 .6]*4").orbit(1)
 const bajoSub = note("<a1 d2 c2 e2>").s("sine")
   .attack(.03).decay(.5).sustain(.5).gain(.55).orbit(1)
+// ── BAJO OFFBEAT REFUERZO (sigue raíces, en el clímax) ──
+const bajoOff = note("<a2 d3 c3 e3>").struct("~ x ~ x ~ x ~ x").s("sawtooth")
+  .lpf(900).lpq(6).attack(.002).decay(.1).sustain(.05).release(.04)
+  .shape(.2).gain(.38).duck("1").orbit(1)
 
-// ── BATERÍA 909 BIG ROOM ──
-const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
+// ── KICK 909 EN 2 CAPAS: click (transient) + BOOM afinado (sigue raíces) ──
+const kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95)
   .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
-const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
+const kickBoom = note("<a1 d2 c2 e2>").struct("x*4").s("sine")
+  .penv(26).pattack(.001).pdecay(.05).pcurve(0)
+  .attack(.001).decay(.3).sustain(0).release(.04).shape(.3).gain(1.02).orbit(0)
+const kickHardClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.6).distort(1.3).gain(1)
   .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
+const kick = stack(kickClick, kickBoom)
+const kickHard = stack(kickHardClick, kickBoom.gain(1.05))
 const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
-const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0)
-const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0)
+const hats = s("hh*8").bank("RolandTR909").swingBy(1/24,8).gain(.4).pan(.6).orbit(0)
+const hatsOff = s("[~ oh]*4").bank("RolandTR909").nudge(.004).gain(.55).orbit(0)
 const hats16 = s("hh*16").bank("RolandTR909")
-  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
-const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
+  .gain(perlin.range(.25,.5)).swingBy(1/24,16).pan(rand.range(.35,.65)).orbit(0)
+const ride = s("rd*8").bank("RolandTR909").swingBy(1/24,8).gain(.3).pan(.35).orbit(0)
 const crash = s("cr/4").bank("RolandTR909").gain(.5).room(.5).rsize(5).orbit(0)
+const ghost = s("~ ~ [~ sd] ~ ~ ~ [sd ~] ~").bank("RolandTR909").gain(rand.range(.1,.28)).hpf(400).orbit(0)
 const rodillo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(4).range(.2,.9)).speed(saw.slow(4).range(1,1.4)).orbit(0)
 const rodilloLargo = s("sd*16").bank("RolandTR909")
   .gain(saw.slow(8).range(.1,.8)).speed(saw.slow(8).range(1,1.35)).orbit(0)
+// ── RISER de ruido filtrado para transiciones ──
+const riser = s("white").hpf(400).lpf(saw.slow(8).range(500,8000))
+  .room(.4).gain(saw.slow(8).range(.05,.4)).orbit(4)
 
 // ── SECCIONES ──
 const intro = stack(kick, hats, cuerdasBajas.gain(.25))
@@ -4729,28 +6678,28 @@ const introB = stack(kick, hats, hatsOff, clap.gain(.45),
   bajo.lpf(400).gain(.6), cuerdasBajas.gain(.3))
 const build = stack(kick, hats16, clap, bajo, cuerdas.gain(.35),
   melodia.lpf(saw.slow(16).range(400,2200)).gain(.5))
-const buildFin = stack(kickHard, rodillo, bajo, melodia.gain(.65))
-const dropA = stack(kickHard, hats16, hatsOff, clap, crash,
-  bajo, bajoSub, melodia, cuerdas.gain(.3))
-const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, crash,
-  bajo, bajoSub, melodia, melodiaOctava, cuerdas.gain(.35))
-const breakdown = stack(melodiaSola, cuerdas, cuerdasBajas)
-const breakBuild = stack(melodiaSola.gain(.75), cuerdas, cuerdasBajas,
+const buildFin = stack(kickHard, rodillo, riser, bajo, melodia.gain(.65))
+const dropA = stack(kickHard, hats16, hatsOff, clap, crash, ghost,
+  bajo, bajoSub, melodia, cuerdas.gain(.3), leadLimpio, stab)
+const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, crash, ghost,
+  bajo, bajoSub, melodia, melodiaOctava, cuerdas.gain(.35), leadLimpio, stab, contra)
+const breakdown = stack(melodiaSola, cuerdas, cuerdasBajas, contra, leadLimpio.gain(.42).room(.7))
+const breakBuild = stack(melodiaSola.gain(.75), cuerdas, cuerdasBajas, riser,
   rodilloLargo, hats16.gain(.3), bajo.lpf(450).gain(.5))
-const buildFin2 = stack(kickHard, rodillo, melodia, cuerdas.gain(.4))
-const dropFinal = stack(kickHard, hats16, hatsOff, clap, crash,
-  bajoFin, bajoSub, melodia, melodiaOctava)
-const dropFinalFull = stack(kickHard, hats16, hatsOff, clap, ride, crash,
+const buildFin2 = stack(kickHard, rodillo, riser, melodia, cuerdas.gain(.4))
+const dropFinal = stack(kickHard, hats16, hatsOff, clap, crash, ghost,
+  bajoFin, bajoSub, melodia, melodiaOctava, leadLimpio, stab)
+const dropFinalFull = stack(kickHard, hats16, hatsOff, clap, ride, crash, ghost,
   bajoFin, bajoSub, melodia, melodiaOctava, cuerdas.gain(.4),
-  cuerdasBajas.gain(.3))
-const dropFinalVar = stack(kickHard, hats16, hatsOff, clap, ride,
-  bajoFin.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
+  cuerdasBajas.gain(.3), leadLimpio, stab, contra)
+const dropFinalVar = stack(kickHard, hats16, hatsOff, clap, ride, ghost,
+  bajoFin.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub, bajoOff,
   melodia, melodiaOctava.every(4, x=>x.add(note(12)).gain(.2)),
-  cuerdas.gain(.4))
+  cuerdas.gain(.4), leadLimpio, stab, contra)
 const salida = stack(kick, hats, clap, bajo, melodia.gain(.55),
   cuerdas.gain(.35))
 const coda = stack(melodiaSola.gain(.6), cuerdas, cuerdasBajas,
-  hats.gain(.25), bajoSub.gain(.3))
+  hats.gain(.25), bajoSub.gain(.3), leadLimpio.gain(.4))
 const codaFin = stack(melodiaSola.gain(.35).delayfeedback(.6),
   cuerdas.gain(.25), cuerdasBajas.gain(.2))
 
@@ -4771,6 +6720,7 @@ arrange(
   [8,  salida],
   [8,  coda],
   [8,  codaFin]
-)`,
+)
+`,
   },
 ];