// 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 (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)

// ── LA MELODÍA (el hook del sinte-coro, interpretación en Dm) ──
const hook = note("d5 ~ d5 ~ f5 ~ e5 ~ d5 ~ c5 d5 ~ a4 ~ ~")
  .s("sawtooth").lpf(1800).lpq(6).attack(.01).release(.12)
  .room(.4).rsize(4).delay(.35).delaytime(.375).delayfeedback(.45)
  .gain(.8).pan(sine.slow(8).range(.3,.7)).orbit(2)

const hookOctava = hook.add(note(12)).gain(.35).lpf(3200).orbit(2)

// ── 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(.34).coarse(1).gain(.88).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)

// ── 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] [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(.72).rarely(x=>x.add(note(12)))
  .delay(.25).delaytime(.1875).delayfeedback(.35).orbit(3)

// ── 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)).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(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, 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(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropAcid],
  [16, dropAcidFull],
  [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 (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)

// ── LA MELODÍA (riff exacto de 16avos, dos compases alternados) ──
const melodia = 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]>")

const riff = melodia.s("supersaw").unison(7).detune(.3).spread(.85)
  .lpf(sine.slow(16).range(1400, 3800)).lpq(4)
  .attack(.004).release(.14)
  .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.85).orbit(2)

const riffCuerpo = melodia.add(note(-12)).s("sawtooth")
  .lpf(1600).attack(.004).release(.1)
  .gain(.4).pan(sine.slow(6).range(.3,.7)).orbit(2)

// el riff a medio tiempo en piano, para el breakdown
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(8)
  .attack(.001).decay(.11).sustain(.2).release(.03)
  .shape(.35).coarse(1).gain(.92).orbit(1)

const bajoProg = bajo.add(note("<0 -4 3 -2>"))

// 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)

// 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").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))
  .speed(saw.slow(8).range(1, 1.5)).orbit(0)
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,e4] [d3,fs3,a3,e4] [a3,cs4,e4,b4] [e3,gs3,b3,ds4]>")
  .s("sawtooth").lpf(800).attack(.7).release(1.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, sub, pad, riser,
  riff.lpf(saw.slow(16).range(400, 2600)).gain(.55))
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, 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), leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.35),
  riffPiano.gain(.5).room(.9).delayfeedback(.7), pad.gain(.3))

// ── ARREGLO (140 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakPiano],
  [8,  breakBuild],
  [16, dropB],
  [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 (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(7)
  .attack(.002).decay(.18).sustain(.35).release(.05)
  .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")
  .attack(.002).decay(.26).sustain(.15).release(.04).gain(.62).orbit(1)

// 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)
  .gain(.8).orbit(2)

const vozEco = voz.off(.125, x=>x.add(note(12)).gain(.35).lpf(2400))

// ── 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 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).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(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,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)

const cuerdas = note("<c4 c4 ab3 g3>").s("supersaw").unison(5).spread(.7)
  .lpf(sine.slow(32).range(350, 1800)).attack(.6).release(.9)
  .room(.6).gain(.32).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats.gain(.3), sub.gain(.4))
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, 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), 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, 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),
  pad.gain(.3))

// ── ARREGLO (140 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, bajoSolo],
  [8,  build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBvar],
  [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 (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)

// ── EL BAJO EXACTO (la línea inmortal, redonda: capa sine + capa saw) ──
const linea = "fs1 cs2 e2 fs2 e2 cs2 b1 cs2"
const bajoSine = note(linea).swingBy(1/6, 8).s("sine")
  .decay(.25).sustain(.4).release(.06).gain(.75).orbit(1)
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")
  .s("supersaw").unison(5).spread(.7).detune(.2)
  .lpf(sine.slow(16).range(900, 2200)).attack(.15).release(.35)
  .room(.55).rsize(6).delay(.3).delaytime(.375).delayfeedback(.35)
  .gain(.7).pan(sine.slow(7).range(.35,.65)).orbit(2)

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,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).hpf(160).room(.35)
  .gain(.68).orbit(3)

// ── 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)
const hats16 = s("hh*16").bank("LinnDrum").swingBy(1/6, 16)
  .gain(rand.range(.15, .5)).pan(rand.range(.35,.65)).orbit(0)
const open = s("~ [~ oh] ~ [~ oh]").bank("LinnDrum").gain(.4).orbit(0)
const rimGhost = s("[~ rim]*4").bank("LinnDrum").swingBy(1/6, 8)
  .degradeBy(.4).gain(.32).pan(.4).orbit(0)
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,e4] [fs3,a3,cs4,e4] [b2,d3,fs3,a3] [cs3,e3,gs3,b3]>")
  .s("sawtooth").lpf(750).attack(.8).release(1.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, 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), 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))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, grooveA],
  [8,  build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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("<[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)
  .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2)

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) ──
// 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)
  .shape(.45).gain(.8).rarely(x=>x.add(note(12)))
  .delay(.2).delaytime(.1875).delayfeedback(.3).orbit(3)

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 (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)

// 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 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").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,a3] [g2,b2,d3,a3] [c3,e3,g3,d4] [d3,fs3,a3,c4]>")
  .s("sawtooth").lpf(700).attack(.8).release(1.5)
  .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, 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), 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, 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), leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.3), hook.gain(.3).room(.85).delayfeedback(.65),
  pad.gain(.3))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, acidSolo],
  [8,  build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBvar],
  [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 (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)

// ── EL STAB ICÓNICO ("ding ding", square corto con eco) ──
const ding = note("[d5 d5] ~ ~ ~").s("square")
  .attack(.001).decay(.09).sustain(0).release(.04)
  .lpf(3200).delay(.4).delaytime(.375).delayfeedback(.5)
  .room(.4).rsize(4).gain(.85).orbit(3)

const dingRespuesta = note("~ ~ [f5 f5] ~").s("square")
  .attack(.001).decay(.09).sustain(0).release(.04)
  .lpf(3200).delay(.4).delaytime(.375).delayfeedback(.5)
  .room(.4).gain(.6).pan(.3).orbit(3)

// ── VOCAL INTERPRETADO (frase sintética con formantes) ──
const voz = note("d4 f4 d4 c4 a3 c4 d4 ~")
  .s("sawtooth").vowel("<a e i o>").lpf(1900)
  .attack(.01).release(.15).room(.45).rsize(5)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.8).orbit(2)

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)
  .shape(.5).distort(1.05).gain(.8).orbit(1)

const bajoProg = note("<[d2 d2 d3 d2]!2 [bb1 bb1 bb2 bb1] [a1 a1 a2 a1]>*4")
  .s("sawtooth").lpf(750).lpq(7)
  .attack(.001).decay(.1).sustain(.25).release(.03)
  .shape(.5).distort(1.05).gain(.8).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)

// 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 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").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")
  .gain(.55).orbit(0)
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,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, 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), 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, 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), leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.3), ding.gain(.4).delayfeedback(.7),
  coros.gain(.3))

// ── ARREGLO (140 compases) ──
arrange(
  [8,  intro],
  [8,  introDing],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakCoros],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBvar],
  [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 (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)

// ── LA MELODÍA (tres frases exactas de 16 pasos, alternadas por ciclo) ──
const melodia = note("<[f4 ~ ~ ab4 ~ ~ f4 ~ f4 bb4 ~ f4 ~ eb4 ~ ~] [f4 ~ ~ c5 ~ ~ f4 ~ f4 db5 ~ c5 ~ ab4 ~ ~] [f4 c5 ~ f5 ~ f4 eb4 ~ eb4 c4 ~ g4 f4 ~ ~ ~]>")

const lead = melodia.s("sawtooth").lpf(2000).lpq(5)
  .attack(.004).decay(.18).sustain(.25).release(.12)
  .room(.45).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.85).pan(sine.slow(8).range(.35,.65)).orbit(2)

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).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).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(6)
  .attack(.002).decay(.16).sustain(.3).release(.05)
  .shape(.3).coarse(1).gain(.9).orbit(1)

// el walking transpuesto a la fundamental de cada compas (Fm·Fm·Db·Eb)
const bajoProg = bajo.add(note("<0 0 -4 -2>"))

// 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 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").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,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)
  .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)
  .room(.6).gain(.32).orbit(4)

// ── 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, 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, 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), 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, 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)), leadLimpio, stabArm)
const coda = stack(kick, hats16.gain(.35), bajo.lpf(550).gain(.7),
  lead.gain(.4).room(.7), pad, leadLimpio.gain(.4))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introStabs],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL RIFF (cuatro frases exactas de 8 pasos, alternadas por ciclo) ──
const melodia = note("<[cs5 b4 cs5 ~ fs4 ~ ~ ~] [d5 cs5 d5 cs5 b4 ~ ~ ~] [d5 cs5 d5 ~ fs4 ~ ~ ~] [b4 a4 b4 a4 gs4 fs4 gs4 ~]>")

const riff = melodia.s("supersaw").unison(8).detune(.4).spread(.9)
  .lpf(sine.slow(16).range(1800, 4200)).lpq(4)
  .attack(.005).release(.2)
  .room(.5).rsize(6).delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.9).orbit(2)

const riffCuerpo = melodia.add(note(-12)).s("sawtooth")
  .lpf(1400).shape(.3).attack(.004).release(.12).gain(.4).orbit(2)

const riffBreak = melodia.slow(2).s("sawtooth")
  .lpf(1200).attack(.05).release(.4)
  .room(.85).rsize(9).delay(.5).delaytime(.375).delayfeedback(.55)
  .gain(.7).orbit(2)

// ── 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(.34).coarse(1).gain(.7).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)

// ── 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 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").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)
const rimLoop = s("rim*16").bank("RolandTR909").crush(5).hpf(1200)
  .gain("[.4 .18 .28 .18]*4").pan(.35).orbit(0)
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 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)
  .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, 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, 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), leadLimpio.gain(.4))
const codaFin = stack(hats16.gain(.2), riffBreak.gain(.4).delayfeedback(.7),
  pad.gain(.3))

// ── ARREGLO (148 compases) ──
arrange(
  [8,  intro],
  [8,  maquina],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBFull],
  [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 (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)

// ── EL HOOK (interpretación del estribillo, 16 pasos) ──
const hook = note("cs5 b4 a4 b4 cs5 ~ b4 a4 fs4 ~ a4 b4 a4 ~ ~ ~")
  .s("sawtooth").lpf(1700).lpq(4)
  .attack(.01).decay(.2).sustain(.3).release(.18)
  .room(.6).rsize(6).delay(.35).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2)

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)
  .lpf(3200).delay(.4).delaytime(.333).delayfeedback(.45)
  .room(.5).rsize(5).gain(.6)
  .pan(sine.slow(3).range(.3,.7)).orbit(3)

const kalimbaVar = note("<[a3 cs4 e4 a4 e4 cs4] [fs3 a3 cs4 fs4 cs4 a3]>")
  .s("triangle").attack(.002).decay(.2).sustain(0).release(.1)
  .delay(.4).delaytime(.333).delayfeedback(.45)
  .room(.5).gain(.55).pan(.6).orbit(3)

// ── BAJO CÁLIDO (redondo, sigue A→F#m→D→E) ──
const bajo = note("<[a1 ~ a1 [~ a1]] [fs1 ~ fs1 [~ fs1]] [d2 ~ d2 [~ d2]] [e2 ~ e2 [~ e2]]>")
  .s("sine").decay(.3).sustain(.5).release(.08)
  .gain(.85).orbit(1)

const bajoArm = bajo.add(note(12)).s("triangle").gain(.3).lpf(900).orbit(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").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").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 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)
  .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)

// ── 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, ghost, bajo, bajoArm, bajoSub, kalimba, pad.gain(.3), riser,
  hook.lpf(saw.slow(16).range(300, 1700)).gain(.5))
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), 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, 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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.25), kalimba.gain(.35).delayfeedback(.6),
  viento, pad.gain(.3))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introKalimba],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakAmplio],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── LOS STABS DEL RIFF (interpretación: C-F-G sobre pedal de C) ──
const stabs = note("[g4,c5,e5] ~ [g4,c5,e5] [a4,c5,f5] ~ [g4,c5,e5] ~ [g4,b4,d5]")
  .s("supersaw").unison(7).detune(.35).spread(.8)
  .lpf(sine.slow(16).range(1800, 3200)).lpq(4)
  .attack(.005).decay(.3).sustain(.2).release(.15)
  .room(.6).rsize(7).delay(.25).delaytime(.375).delayfeedback(.3)
  .gain(.9).orbit(2)

const stabsCuerpo = note("[g3,c4,e4] ~ [g3,c4,e4] [a3,c4,f4] ~ [g3,c4,e4] ~ [g3,b3,d4]")
  .s("sawtooth").lpf(1300).attack(.005).decay(.25).sustain(.15).release(.1)
  .gain(.45).orbit(2)

const stabsBreak = stabs.slow(2).lpf(1000).room(.85).rsize(9)
  .delayfeedback(.55).gain(.65)

// ── 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)

// ── 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: 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 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").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").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")
  .gain(saw.slow(8).range(.2, .95)).speed(saw.slow(8).range(1, 1.5))
  .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 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)
  .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, 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, 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), leadLimpio.gain(.4))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introStabs],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  build2],
  [16, dropB],
  [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 (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)

// ── EL RIFF (interpretación con shuffle, dos frases alternadas) ──
const riff = note("<[d4 e4 fs4 a4 fs4 e4 d4 ~] [d4 e4 fs4 b4 a4 fs4 e4 ~]>")
  .swingBy(1/6, 8)
  .s("sawtooth").lpf(1400).lpq(4)
  .attack(.01).decay(.2).sustain(.25).release(.15)
  .room(.7).rsize(8).delay(.5).delaytime(.375).delayfeedback(.55)
  .gain(.75).pan(sine.slow(9).range(.35,.65)).orbit(2)

const riffLejos = riff.add(note(12)).gain(.28).lpf(2200).room(.85)

// ── 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)
  .delay(.6).delaytime(.375).delayfeedback(.68)
  .room(.8).rsize(9).gain(.7).orbit(3)

const chordsEco = chords.late(.5).gain(.35).lpf(800)

// ── 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)

// ── 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 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)
  .gain(rand.range(.08, .32)).hpf(5000).pan(rand.range(.4,.6)).orbit(0)
const rimDub = s("~ rim ~ [~ rim]").bank("RolandCR78")
  .delay(.45).delaytime(.375).delayfeedback(.5)
  .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").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 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, 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), 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, ghost, chords,
  bajo, bajoArm, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
  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), leadLimpio.gain(.4))
const codaFin = stack(chords.gain(.3).delayfeedback(.78), espacio,
  pad.gain(.3))

// ── ARREGLO (140 compases) ──
arrange(
  [8,  intro],
  [8,  introChords],
  [16, grooveRiff],
  [8,  build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBFull],
  [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 (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)

// ── LA MELODÍA (el tema del sinte, maquinal y sin adornos) ──
const hook = note("c5 ~ b4 c5 g4 ~ eb4 g4 f4 ~ d4 f4 c4 ~ ~ ~")
  .s("square").lpf(2600).lpq(3)
  .attack(.002).decay(.13).sustain(.12).release(.04)
  .crush(9).delay(.12).delaytime(.1875).delayfeedback(.2)
  .gain(.8).pan(.5).orbit(2)

const hookEco = hook.add(note(-12)).late(.5).gain(.3).lpf(1400).orbit(3)

// ── 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] [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)

// ── 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)

// ── 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 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").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").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")
  .decay(.05).sustain(0).crush(7)
  .degradeBy(.4).gain(.35).pan(rand.range(.3,.7))
  .delay(.2).delaytime(.25).delayfeedback(.3).orbit(3)

// ── 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)
  .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, ghost, bajo, riser,
  hook.lpf(saw.slow(8).range(400,2600)).gain(.55))
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))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, groove],
  [8,  build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakRobot],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK (estribillo interpretado en G mayor) ──
const hook = note("g4 g4 fs4 g4 e4 e4 d4 e4 g4 g4 a4 g4 e4 ~ d4 ~")
  .s("sawtooth").lpf(2200).lpq(5)
  .attack(.005).decay(.12).sustain(.25).release(.08)
  .room(.35).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2)

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)
  .shape(.3).room(.4).gain(.7)
  .every(4, x=>x.hurry(2).gain(.55)).orbit(3)

// ── SIRENA RAVE (vibrato ancho, panea de lado a lado) ──
const sirena = note("g5").s("sawtooth")
  .attack(.6).release(2.5).vib(3).vibmod(7)
  .lpf(2800).room(.6).rsize(6).gain(.3)
  .pan(sine.slow(4)).slow(4).orbit(3)

// ── HOOVER (supersaw desafinado y sucio, riff grave) ──
const hoover = note("g2 ~ g2 g2 ~ e2 ~ [f2 fs2]")
  .s("supersaw").unison(5).detune(.8).spread(.8)
  .lpf(1400).distort(.8)
  .attack(.01).decay(.2).sustain(.4).release(.1)
  .gain(.7).orbit(3)

// ── 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 ~] [e1 ~ ~ e1 ~ ~ e1 ~] [c1 ~ ~ c1 ~ ~ c1 ~] [d1 ~ ~ d1 ~ ~ d1 ~]>").s("sine")
  .decay(.3).sustain(.3).gain(.65).orbit(1)

// ── 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 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").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").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 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)
  .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, riser,
  hook.lpf(saw.slow(16).range(400,2200)).gain(.5), stabs.gain(.4))
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), 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, 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))

// ── ARREGLO (152 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropHoover],
  [16, dropFull],
  [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 (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 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(.34).coarse(1).gain(.95).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)

// ── 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)

// ── RIFF FANTASMA (la guitarra interpretada, corta y lo-fi) ──
const riff = note("e4 ~ ~ g4 ~ e4 d4 ~ ~ e4 ~ ~ a4 g4 ~ ~")
  .s("square").lpf(1900).crush(8)
  .attack(.002).decay(.1).sustain(.05).release(.04)
  .delay(.2).delaytime(.1875).delayfeedback(.3)
  .gain(.6).pan(.4).orbit(2)

// ── 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/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) ──
const tomAlto = s("ht(3,8)").bank("RolandTR808")
  .gain(.6).pan(.3).speed("<1 1.1 .95 1.05>").orbit(0)
const tomMedio = s("mt(5,16,2)").bank("RolandTR808")
  .gain(.55).pan(.7).speed("<1 .9 1.15 1>").orbit(0)
const tomBajo = s("lt(3,16,5)").bank("RolandTR808")
  .gain(.6).pan(.5).orbit(0)

// ── CONGAS (toms agudos con speed variado, sabor latino) ──
const congas = s("[~ mt]*4").bank("RolandTR808")
  .speed(choose(1.6, 1.8, 2, 1.4)).gain(.45)
  .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 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)
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, 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, 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, ghost, bajo, sub,
  stab, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
  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, 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))

// ── ARREGLO (140 compases) ──
arrange(
  [8,  intro],
  [8,  percusion],
  [8,  grooveBajo],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAtoms],
  [8,  breakTribal],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK (estribillo interpretado, supersaw nostálgico) ──
const hook = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~")
  .s("supersaw").unison(5).spread(.7).detune(.35)
  .lpf(2400).attack(.01).decay(.2).sustain(.5).release(.15)
  .room(.6).rsize(7).delay(.35).delaytime(.375).delayfeedback(.4)
  .gain(.75).pan(sine.slow(8).range(.35,.65)).orbit(2)

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,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) ──
const arpegio = note("[c3 e3 g3 c4]*2")
  .s("sawtooth").lpf(sine.slow(16).range(800,2600)).lpq(4)
  .attack(.002).decay(.12).sustain(.1).release(.05)
  .delay(.3).delaytime(.1875).delayfeedback(.35)
  .gain(.6).pan(.6).every(4, rev).orbit(3)

const arpegio16 = note("[c3 e3 g3 c4]*4")
  .s("sawtooth").lpf(sine.slow(8).range(1000,3200)).lpq(5)
  .attack(.001).decay(.09).sustain(.05).release(.04)
  .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 — sigue las fundamentales) ──
const bajo = note("<c2 a1 f1 g1>").struct("x*16")
  .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(.34).coarse(1).orbit(1)

// ── SUB-BAJO afinado que SIGUE la fundamental ──
const sub = note("<c1 a1 f1 g1>").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("<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 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").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 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, 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, 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), 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), leadLimpio.gain(.4))
const codaFin = stack(piano.gain(.6), cuerdas.gain(.3),
  arpegio.gain(.3).delayfeedback(.6))

// ── ARREGLO (160 compases) ──
arrange(
  [8,  intro],
  [8,  introArp],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakPiano],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBvar],
  [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 (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, 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(.3).coarse(1).gain(.95).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)

// ── 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)

// ── EL LEAD (interpretación del rap-melodía, flotante a doble compás) ──
const lead = note("a4 ~ g4 f4 g4 ~ f4 ~ e4 d4 ~ ~")
  .slow(2).s("sawtooth").lpf(1600).lpq(3)
  .attack(.02).decay(.25).sustain(.3).release(.2)
  .room(.5).rsize(5).delay(.35).delaytime(.375).delayfeedback(.45)
  .gain(.7).pan(sine.slow(10).range(.35,.65)).orbit(2)

const leadEco = lead.add(note(12)).late(.25).gain(.25).lpf(2600).orbit(2)

// ── 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).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 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").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)
// 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; peak-time = poco aire) ──
const niebla = s("space").slow(8).lpf(1200).room(.8).rsize(8)
  .gain(.18).pan(sine.slow(16).range(.3,.7)).orbit(4)

// ── 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)
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, 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), 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, 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, leadLimpio, stab, contra)
const coda = stack(kick, hats, bajo.gain(.7), chords.gain(.4),
  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)

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introSub],
  [16, grooveChords],
  [8,  build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakUrbano],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL LEAD (estribillo interpretado, el lamento del sinte) ──
const hook = note("a4 c5 d5 c5 a4 g4 a4 ~ f4 g4 a4 g4 f4 ~ e4 ~")
  .s("sawtooth").lpf(2000).lpq(5)
  .attack(.008).decay(.15).sustain(.35).release(.1)
  .room(.4).rsize(4).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2)

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)
  .attack(.001).decay(.14).sustain(0)
  .vowel("a e").shape(.25)
  .room(.3).gain(.75).pan(.55).orbit(3)

// ── 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).coarse(1).gain(.9).orbit(1)

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).coarse(1).gain(.9).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)

// ── 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 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").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 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, 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), contra, leadLimpio.gain(.42).room(.7))
const breakBuild = stack(pad, stabs.gain(.5), hook.gain(.65),
  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), 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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.4), stabs.gain(.25).room(.8),
  hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3))

// ── ARREGLO (148 compases) ──
arrange(
  [8,  intro],
  [8,  introStabs],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakVocal],
  [8,  breakBuild],
  [16, dropOctava],
  [16, dropOctavaVar],
  [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 (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)

// ── EL HOOK (la melodía del sinte, interpretada en Gm) ──
const hook = note("g4 ~ bb4 g4 c5 ~ bb4 g4 d5 ~ c5 bb4 g4 ~ f4 g4")
  .s("sawtooth").lpf(2300).lpq(5)
  .attack(.005).decay(.14).sustain(.3).release(.1)
  .room(.4).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2)

const hookAlta = hook.add(note(12)).gain(.3).lpf(3600).orbit(2)

// ── 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, 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, 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(.34).coarse(1).gain(.9).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)

// ── 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 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(.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").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 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))
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, 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), contra, leadLimpio.gain(.42).room(.7))
const breakBuild = stack(pad, pianoRave.gain(.6), hook.gain(.65),
  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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.4), pianoRave.gain(.3).room(.8),
  hook.gain(.3).room(.85).delayfeedback(.65), pad.gain(.3))

// ── ARREGLO (152 compases) ──
arrange(
  [8,  intro],
  [8,  introPiano],
  [16, build],
  [8,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakOh],
  [8,  breakBuild],
  [16, dropHoover],
  [16, dropHooverFull],
  [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 (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 — 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)
  .distort(.7).coarse(2)
  .gain(.8).pan(.5).orbit(2)

const riffAlta = riff.add(note(12)).gain(.35).lpf(3400).coarse(0).orbit(2)

// ── 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)
  .gain(.7).orbit(3)

// ── VOZ PERCUSIVA ("no no no", samples de numbers troceados) ──
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, 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).coarse(1).gain(.9).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)

// ── 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 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 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").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").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 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))
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, 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), 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, 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), leadLimpio, stab)
const coda = stack(kick, hats, clap, bajo.gain(.7), riff.gain(.45),
  pad.gain(.3), leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.4), voz.gain(.3),
  riff.gain(.25).room(.7), pad.gain(.3))

// ── ARREGLO (160 compases) ──
arrange(
  [8,  intro],
  [8,  introRiff],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakVoces],
  [8,  breakBuild],
  [16, dropGabber],
  [16, dropGabberFull],
  [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 (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)

// ── EL HOOK (estribillo interpretado, piano italo protagonista) ──
const hookPiano = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~")
  .s("piano").room(.5).rsize(5)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.95).pan(.5).orbit(2)

// ── EL MISMO HOOK EN SUPERSAW (para el segundo drop) ──
const hookSaw = note("e5 d5 c5 d5 e5 d5 c5 a4 ~ c5 d5 c5 a4 g4 a4 ~")
  .s("supersaw").unison(5).spread(.7).detune(.4)
  .lpf(2800).attack(.008).decay(.15).sustain(.4).release(.12)
  .room(.5).rsize(6).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.7).pan(sine.slow(8).range(.35,.65)).orbit(2)

// ── 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").hpf(150).room(.4).rsize(4)
  .gain(.7).pan(.55).orbit(3)

// ── 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(perlin.slow(4).range(600,1300)).lpq(8)
  .attack(.001).decay(.12).sustain(.3).release(.04)
  .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)

// ── 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)
// 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 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, ghost, bajo, acordes, pad.gain(.25),
  hookPiano.gain(.55))
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), leadLimpio.gain(.42).room(.7))
const breakBuild = stack(pad, hookPiano.gain(.8), acordes.gain(.55),
  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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.4), hookPiano.gain(.4).room(.85).delayfeedback(.6),
  acordes.gain(.25).room(.8), pad.gain(.3))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introPiano],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakPiano],
  [8,  breakBuild],
  [16, dropSaw],
  [16, dropSawFull],
  [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 (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)

// ── LA MELODÍA (exacta, dos frases alternadas de 16 pasos) ──
const melodia = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>")
  .s("piano").room(.85).rsize(9)
  .delay(.4).delaytime(.375).delayfeedback(.45)
  .gain(.95).pan(.5).orbit(2)

// ── LA MISMA MELODÍA EN SINTE (doblada para los drops) ──
const melodiaSinte = note("<[e5 ~ ~ a4 ~ ~ b4 ~ c5 ~ ~ b4 ~ a4 ~ ~] [e5 ~ ~ a4 ~ ~ b4 ~ d5 ~ c5 b4 ~ a4 ~ ~]>")
  .s("supersaw").unison(5).spread(.7).detune(.3)
  .lpf(2600).attack(.01).decay(.2).sustain(.45).release(.15)
  .room(.6).rsize(7).delay(.35).delaytime(.375).delayfeedback(.4)
  .gain(.55).pan(sine.slow(8).range(.35,.65)).orbit(2)

// ── 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 (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(.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)

// ── 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").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 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, ghost, bajo, melodia.gain(.75),
  cuerdas.gain(.3), sub.gain(.5))
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,
  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), 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), leadLimpio.gain(.4))
const codaFin = stack(melodia.gain(.7).room(.95).delayfeedback(.6),
  pianoAcordes.gain(.4), viento)

// ── ARREGLO (168 compases) ──
arrange(
  [16, pianoSolo],
  [8,  pianoPads],
  [8,  entraKick],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakCentral],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBvar],
  [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 (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)

// ── EL ARPEGIO PERPETUO (16avos; el lpf sube durante los 152 compases) ──
const arpegio = note("[fs2 fs3 a3 cs4 fs2 fs3 a3 e4]*2")
  .s("sawtooth").lpf(saw.slow(152).range(260, 4400)).lpq(7)
  .attack(.002).decay(.12).sustain(.25).release(.06)
  .shape(.25).gain(.78).pan(sine.slow(6).range(.35,.65)).orbit(3)

const arpegioAlto = arpegio.add(note(12)).gain(.3).orbit(3)

// ── LA MELODÍA (interpretación del canto en F#m) ──
const hook = note("fs4 a4 gs4 fs4 cs4 ~ fs4 ~ a4 b4 a4 fs4 e4 ~ cs4 ~")
  .s("supersaw").unison(5).spread(.6).detune(.15)
  .lpf(2400).attack(.02).release(.3)
  .room(.6).rsize(7).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.72).orbit(2)

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(.32).coarse(1).gain(.85).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)

// ── 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 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").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 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)).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, 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) ──
arrange(
  [8,  intro],
  [8,  introArp],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [12, breakdown],
  [8,  breakBuild],
  [16, dropEpic],
  [16, dropEpicFull],
  [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 (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)

// ── EL RIFF (16 pasos, la metralleta de Sandstorm) ──
const riff = note("b3 b3 b3 [b3 b3] e4 e4 e4 [e4 e4] d4 d4 d4 [d4 d4] a3 ~ b3 b3")
  .s("sawtooth").lpf(2600).lpq(8)
  .attack(.001).decay(.11).sustain(0).release(.05)
  .shape(.3).delay(.3).delaytime(.1875).delayfeedback(.4)
  .gain(.85).orbit(2)

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)

// ── 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).coarse(1).gain(.9).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)

// ── 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 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").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 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, 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, 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))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [12, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBfull],
  [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 (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)

// ── EL HOOK (interpretación del estribillo, con vocal sintética) ──
const hook = note("bb4 ~ g4 ~ f4 g4 bb4 g4 ~ f4 ~ d4 f4 g4 ~ ~")
  .s("sawtooth").vowel("<o a o e>").lpf(3000)
  .attack(.01).decay(.15).sustain(.4).release(.15)
  .delay(.28).delaytime(.375).delayfeedback(.35)
  .gain(.82).pan(sine.slow(7).range(.35,.65)).orbit(2)

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, raíces g·g·eb·f) ──
const bajo = note("[g1 g2 g1 g2]*2").add(note("<0 0 -4 -2>"))
  .s("sawtooth").lpf(perlin.slow(4).range(600,1200)).lpq(5)
  .attack(.001).decay(.14).sustain(.3).release(.04)
  .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)

// ── 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 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").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 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)).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, ghost, bajo, riff,
  hook.lpf(saw.slow(16).range(400, 2600)).gain(.55))
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))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBfull],
  [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 (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)

// ── EL PLUCK INCONFUNDIBLE (16 pasos exactos, square+saw en ping-pong) ──
const melodia = "cs5 ~ cs5 ~ fs5 ~ e5 ~ ~ cs5 ~ b4 ~ cs5 ~ ~"
const pluckSq = note(melodia).s("square")
  .lpf(2400).attack(.001).decay(.12).sustain(0).release(.06)
  .delay(.4).delaytime(.1875).delayfeedback(.45)
  .pan(square.fast(2).range(.25,.75))
  .gain(.6).orbit(2)
const pluckSaw = note(melodia).s("sawtooth")
  .lpf(3200).attack(.001).decay(.1).sustain(0).release(.05)
  .delay(.3).delaytime(.375).delayfeedback(.35)
  .pan(square.fast(2).range(.75,.25))
  .gain(.5).orbit(2)
const pluck = stack(pluckSq, pluckSaw)
const pluckOctava = note(melodia).add(note(12)).s("square").lpf(4200)
  .attack(.001).decay(.1).sustain(0).release(.05).gain(.25).orbit(2)

// ── SUPERSAW DEL CLÍMAX (dobla la melodía) ──
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)

// ── 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).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).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)

// ── 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 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").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 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, ghost, bajoOff, pluck, pad.gain(.3))
const pausa = stack(pluck.gain(.95).room(.7).delayfeedback(.6), silence)
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))

// ── ARREGLO (134 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [8,  pluckSolo],
  [16, build],
  [2,  pausa],
  [16, dropA],
  [14, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [2,  pausa],
  [16, dropB],
  [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 (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)

// ── EL LEAD (16 pasos exactos, eléctrico y enorme) ──
const lead = note("e5 ~ gs5 e5 ~ fs5 e5 ~ b4 ~ cs5 ~ e5 ~ ~ ~")
  .s("supersaw").unison(5).spread(.7).detune(.12)
  .lpf(2700).attack(.015).decay(.3).sustain(.3).release(.5)
  .room(.85).rsize(9).delay(.4).delaytime(.375).delayfeedback(.5)
  .gain(.75).orbit(2)

const leadOctava = lead.add(note(12)).gain(.28).lpf(4500).orbit(2)
const leadGrave = lead.add(note(-12)).gain(.45).lpf(1400).orbit(2)

// ── 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)).hpf(150).attack(1).release(2)
  .room(.9).rsize(9).gain(.4).orbit(4)

// ── 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 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 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)
// 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")
  .shape(.3).gain(.6).pan(sine.fast(2).range(.25,.75)).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 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), 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) ──
arrange(
  [8,  leadSolo],
  [8,  leadCoro],
  [8,  kickEntra],
  [16, kickLead],
  [4,  tomsBuild],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL RIFF (8vos exactos, stab metálico con FM alto) ──
const riff = note("c5 bb4 g4 bb4 c5 bb4 g4 f4")
  .s("sawtooth").fm(9).fmh(2.01)
  .lpf(2500).attack(.001).decay(.15).sustain(.1).release(.06)
  .shape(.25).delay(.22).delaytime(.1875).delayfeedback(.3)
  .gain(.78).pan(sine.slow(9).range(.35,.65)).orbit(2)

const riffHpf = riff.hpf(900).gain(.65).room(.5).orbit(2)
const riffApoyo = riff.add(note(-12)).fm(5).gain(.4).orbit(2)

// ── 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)

// ── 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")
  .s("sawtooth").ftype("ladder")
  .lpf(sine.slow(16).range(180, 2400)).lpq(sine.slow(9).range(7, 17))
  .lpenv(3).lpattack(.005).lpdecay(.12)
  .shape(.3).gain(.68).rarely(x=>x.add(note(12)))
  .delay(.22).delaytime(.1875).delayfeedback(.3).orbit(3)

// ── 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 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)
// 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, 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), 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, 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, 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))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakHpf],
  [8,  breakBuild],
  [16, dropAcid],
  [16, dropAcidFull],
  [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 (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)

// ── LOS POWER CHORDS (guitarra sintética distorsionada, F5→Bb5→Ab5→Db5) ──
const chords = note("[f2,c3] [f2,c3] [bb2,f3] ~ [ab2,eb3] [ab2,eb3] [db3,ab3] ~")
  .s("sawtooth").distort(1.5)
  .lpf(perlin.slow(4).range(700, 2400)).lpq(4)
  .attack(.002).decay(.25).sustain(.45).release(.08)
  .gain(.78).orbit(3)

const chordsAlto = chords.add(note(12)).gain(.3).lpf(3000).orbit(3)

// ── LA VOZ (interpretación susurrada de la melodía vocal) ──
const voz = note("f4 ab4 f4 eb4 f4 ~ c4 ~")
  .s("sine").vib(4).vibmod(.25)
  .attack(.03).release(.3)
  .room(.8).rsize(8).delay(.35).delaytime(.375).delayfeedback(.45)
  .gain(.6).orbit(2)

const vozOctava = voz.add(note(12)).gain(.25).orbit(2)

// ── 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(.28).gain(.75).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)

// ── 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 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).swingBy(1/24,8)
  .gain("[.5 .28]*4").pan(rand.range(.3,.7)).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 (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), 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, 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, 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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [12, breakSusurro],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBfull],
  [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 (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)

// ── LA TROMPETA (16 pasos exactos, sonido teléfono) ──
const trompeta = note("d5 ~ d5 d5 cs5 d5 a4 f4 e4 d4 ~ ~ ~ ~ ~ ~")
  .s("square").crush(5).lpf(2100).hpf(420)
  .attack(.002).decay(.16).sustain(.3).release(.08)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.72).orbit(2)

const trompetaBaja = trompeta.add(note(-12)).gain(.3).orbit(2)

// ── 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)

// ── 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)

// ── 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)
  .gain(.5).pan(sine.slow(5).range(.3,.7)).orbit(3)

// ── PIANO LO-FI (contrapunto del break) ──
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: 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").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 (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, 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), 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, 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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.3), trompeta.gain(.3).room(.8).delayfeedback(.6),
  pad.gain(.25))

// ── ARREGLO (132 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakRobot],
  [8,  breakBuild],
  [16, dropB],
  [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 (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 (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(.32).coarse(1).gain(.95).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 ~ ~")
  .s("sawtooth").vowel("<o a e o>")
  .lpf(sine.slow(32).range(700, 2600))
  .attack(.01).decay(.18).sustain(.4).release(.12)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.72).pan(sine.slow(11).range(.35,.65)).orbit(2)

const vocoderAlto = vocoder.add(note(12)).gain(.28).orbit(2)

// ── 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).hpf(160)
  .attack(.002).decay(.14).sustain(.05).release(.05)
  .phaser(2).phaserdepth(.5)
  .gain(.55).pan(.4).orbit(3)

// ── 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 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").swingBy(1/24,8)
  .phaser(4).phaserdepth(.7).gain(.55).pan(.6).orbit(0)
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").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, 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), bajoSub.gain(.5),
  bajo.lpf(sine.slow(32).range(250, 700)).gain(.7))
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, 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), 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), 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))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakFiltro],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBfull],
  [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 (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)

// ── EL PLUCK-GUITARRA DE ATB (16 pasos exactos, bend característico con penv) ──
const hook = note("cs5 ~ d5 cs5 ~ b4 cs5 ~ e5 ~ cs5 ~ b4 ~ a4 b4")
  .s("triangle").penv(12).pattack(.001).pdecay(.09)
  .lpf(3200).attack(.002).decay(.2).sustain(.15).release(.12)
  .delay(.35).delaytime(.375).delayfeedback(.45)
  .room(.5).rsize(5).gain(.8).pan(sine.slow(8).range(.35,.65)).orbit(2)

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(perlin.slow(4).range(600, 1100)).lpq(5)
  .attack(.001).decay(.09).sustain(.15).release(.03)
  .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")
  .attack(.002).decay(.26).sustain(.18).release(.04).gain(.6).orbit(1)

// ── 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 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").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 (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)).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)
  .room(.9).rsize(9).gain(.3).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
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), 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), 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), 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))

// ── ARREGLO (152 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [8,  hookIntro],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [12, breakFlotante],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK (el grito "encore une fois", interpretación en Am) ──
const hook = note("a4 ~ a4 g4 a4 c5 a4 g4 a4 e4 ~ ~ g4 a4 g4 ~")
  .s("supersaw").unison(5).spread(.6).detune(.18)
  .lpf(2600).attack(.01).release(.15)
  .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(6).range(.35,.65)).orbit(2)

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)
  .lpf(3500).room(.4).gain(.8).orbit(3)

// ── BAJO OFFBEAT (rebota contra el kick, misma progresión) ──
const bajo = note("~ a1 ~ a1 ~ a1 ~ a1").add(note("<0 -4 3 -2>"))
  .s("sawtooth").lpf(900).lpq(4)
  .attack(.001).decay(.18).sustain(.15).release(.05)
  .shape(.35).gain(.9).orbit(1)

const bajoSub = note("<a0 f1 c1 g1>").s("sine")
  .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)

// ── 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").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,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, ghost, bajo, piano,
  hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
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), 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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [1,  silence],
  [16, dropA],
  [16, dropAvar],
  [8,  breakPiano],
  [8,  breakBuild],
  [1,  silence],
  [16, dropB],
  [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 (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)

// ── EL BAJO WAH (la línea EXACTA de Flat Beat: square + filtro que mastica) ──
const bajo = note("f1 f1 ~ f1 ~ f1 eb1 f1")
  .s("square").lpf(sine.slow(2).range(100,900)).lpq(16)
  .attack(.001).decay(.22).sustain(.4).release(.04)
  .shape(.3).gain(.95).orbit(1)

const bajoOctava = bajo.add(note(12)).gain(.28)
  .lpf(sine.slow(2).range(300,1600)).orbit(3)

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) ──
// 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")
  .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")
  .gain(.5).speed(.9).mask("<0 0 0 1>").orbit(0)

// ── STABS RAROS (campanitas FM que aparecen y desaparecen) ──
const stabs = note("~ ~ ~ [~ ab3] ~ ~ [c4 ~] ~")
  .s("sine").fm(6).fmh(2.02).attack(.001).decay(.15).sustain(0)
  .delay(.4).delaytime(.1875).delayfeedback(.5)
  .gain(.6).degradeBy(.35).pan(rand.range(.2,.8)).orbit(3)

// ── CONTRAMELODÍA (segunda parte, triangle suave) ──
const contra = note("c4 ~ ab3 bb3").s("triangle")
  .attack(.02).release(.2).clip(.8).lpf(2200)
  .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, 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, padCalido.gain(.22))
const grooveBFull = stack(kick, hats, open, snare, ghost, rim, toms,
  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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, bajoIn],
  [16, grooveA],
  [8,  grooveStabs],
  [8,  soloBajo],
  [16, grooveB],
  [16, grooveBFull],
  [8,  breakFm],
  [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 (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)

// ── LA MELODÍA (EXACTA: dos frases de corcheas que alternan por ciclo) ──
const melodia = note("<[e4 g4 e4 d4 e4 c4 d4 b3] [e4 g4 e4 a4 g4 e4 d4 c4]>")

const leadSq = melodia.s("square").crush(8).lpf(2800).lpq(5)
  .attack(.005).release(.1).shape(.3)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.7).orbit(2)
const leadSaw = melodia.s("sawtooth").lpf(2200)
  .attack(.005).release(.12)
  .gain(.5).pan(sine.slow(5).range(.3,.7)).orbit(2)
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 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 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")
  .attack(.01).decay(.2).sustain(0).lpf(2500).hpf(300)
  .room(.6).gain(.5).orbit(4)
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 kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.92)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
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").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 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, ghost, bajo,
  leadSq.lpf(saw.slow(16).range(350,2800)).gain(.55))
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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakPiano],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBFull],
  [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 (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)

// ── EL ARPEGIO CRISTALINO (con delay ping-pong) ──
const arpegio = note("[a3 c4 e4 a4 e4 c4]*2")
  .s("triangle").lpf(3200)
  .attack(.002).decay(.12).sustain(.1).release(.08)
  .delay(.45).delaytime(.375).delayfeedback(.5)
  .pan(square.fast(3).range(.2,.8))
  .gain(.65).orbit(3)

// ── LA MELODÍA (interpretación del lead celestial) ──
const melodia = note("e5 d5 c5 d5 e5 c5 a4 b4 c5 b4 a4 g4 a4 ~ ~ ~")
  .s("sawtooth").lpf(2000).attack(.02).release(.3)
  .room(.6).rsize(6).delay(.4).delaytime(.375).delayfeedback(.45)
  .gain(.75).orbit(2)
const melodiaFlotante = melodia.slow(2).s("supersaw").unison(5).spread(.7)
  .attack(.15).release(.8).room(.85).rsize(9).gain(.6)
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)
  .attack(.001).decay(.1).sustain(.2).release(.03)
  .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 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").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, 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, ghost, bajo, arpegio,
  melodia.lpf(saw.slow(8).range(300,2000)).gain(.5))
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), 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, leadLimpio.gain(.4))
const fin = stack(hats.gain(.3), arpegio.gain(.35).delayfeedback(.7), pad.gain(.35))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, arpIn],
  [8,  build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK ITALO (la melodía inconfundible, sierra fina + delay corto) ──
const hook = note("a4 ~ bb4 a4 g4 f4 g4 ~ a4 ~ g4 f4 e4 f4 g4 ~")
  .s("sawtooth").lpf(2600).lpq(3)
  .attack(.004).release(.12).clip(.9)
  .delay(.28).delaytime(.1875).delayfeedback(.35)
  .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] [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 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]>")
  .struct("x x x x").s("piano").clip(.5)
  .lpf(3200).room(.45).gain(.8).orbit(3)

// ── BATERÍA 909 ──
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").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, 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, ghost, bajo, piano.gain(.55),
  hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
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), 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, leadLimpio.gain(.4))
const fin = stack(hats.gain(.32), hook.gain(.3).room(.85).delayfeedback(.6), pad.gain(.35))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakPiano],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBFull],
  [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 (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)

// ── EL FILTRO QUE RESPIRA (se aplica al bus melódico entero del drop) ──
const respira = p => p.lpf(sine.slow(16).range(500,4500)).hpf(sine.slow(16).range(40,650))

// ── EL BRASS HOOK (la fanfarria de celebración, interpretación en D) ──
const brass = note("d5 d5 c5 d5 ~ f5 ~ d5 c5 a4 c5 d5 ~ ~ ~ ~")
  .s("sawtooth").attack(.008).decay(.18).sustain(.45).release(.12).clip(.85)
  .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)
  .attack(.001).decay(.18).sustain(.25).release(.05)
  .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 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(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 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, 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, leadLimpio.gain(.4))
const fin = stack(hatsSwing.gain(.3), brass.gain(.3).room(.85), pad.gain(.35))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAfiltro],
  [16, breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK VOCODER (vocales secuenciadas = robot que canta) ──
const hook = note("e4 e4 ~ e4 d4 e4 g4 ~ e4 d4 e4 ~ b3 ~ d4 ~")
  .s("sawtooth").vowel("[e a o i]*2")
  .lpf(2800).attack(.005).release(.1).shape(.25)
  .gain(.85).orbit(2)
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 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).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)

// ── 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)
// 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 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)
  .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, riser,
  hook.lpf(saw.slow(16).range(400,2800)).gain(.55))
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), 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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropStut],
  [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 (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)

// ── EL LA-LA-LA (interpretación nocturna, triangle + delay) ──
const lalala = note("d5 ~ d5 c5 a4 ~ c5 d5 c5 a4 g4 f4 g4 ~ ~ ~")
  .s("triangle").lpf(2600)
  .attack(.01).release(.15)
  .delay(.4).delaytime(.375).delayfeedback(.5)
  .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)

// ── 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).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 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,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)

// ── 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 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)
// 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").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, 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), 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, 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), leadLimpio, contra)
const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.75),
  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))

// ── ARREGLO (132 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, groove],
  [8,  build],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL RIFF BENASSI (EXACTO: sierra mordida con envolvente de filtro agresiva) ──
const riff = note("c3 ~ c3 eb3 ~ c3 f3 eb3")
  .s("sawtooth").ftype("ladder")
  .lpf(sine.slow(8).range(300,2200)).lpq(12)
  .lpenv(4).lpattack(.001).lpdecay(.1)
  .crush(6).shape(.5)
  .gain(.9).orbit(2)
const riffAlto = riff.add(note(12)).gain(.38).crush(8).orbit(3)

// ── 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)

// ── 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 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)
// 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").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 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, riser)
const buildFin = stack(kickDemoledor, rodillo, riser,
  riff.hpf(saw.slow(4).range(200,3000)).gain(.8))
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, 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) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, riffIn],
  [8,  build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── EL HOOK (los stabs saturados de saw, interpretación en Bm) ──
const hook = note("fs4 ~ fs4 e4 d4 e4 fs4 ~ b4 ~ a4 fs4 e4 d4 e4 ~")
  .s("sawtooth").shape(.5).lpf(2400).lpq(4)
  .attack(.004).release(.1)
  .room(.35).gain(.85).orbit(2)
const hookStab = hook.superimpose(x=>x.add(note(-12)).lpf(1300).gain(.6))
const hookOctava = hook.add(note(12)).gain(.28).orbit(2)

// ── 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).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)

// ── 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 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)
// 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 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, riser,
  hookStab.lpf(saw.slow(16).range(400,2400)).gain(.6))
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), leadLimpio.gain(.4))
const fin = stack(hatsMin.gain(.25), hook.gain(.3).room(.85), pad.gain(.28))

// ── ARREGLO (128 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [8,  breakdown],
  [8,  breakBuild],
  [16, dropB],
  [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 (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)

// ── TAIKOS TRIBALES (el verdadero protagonista del track) ──
const taikoA = s("east:6(5,16)").speed(.9).shape(.3).gain(.95)
  .pan(.42).orbit(3)
const taikoB = s("east:7(7,16,2)").speed(1.1).shape(.25).gain(.8)
  .pan(.58).orbit(3)
const taikoC = s("east:8(3,16,1)").speed(.72).shape(.35).gain(.9)
  .room(.3).rsize(3).orbit(3)
const taikoSolo = s("east:6 ~ east:7 east:6 ~ east:8 east:7 ~ east:6 east:6 ~ east:7 ~ east:8 east:7 east:8")
  .speed("<.9 .95 1 1.05>").shape(.3).gain(1)
  .pan(rand.range(.3,.7)).orbit(3)

// ── TOMS 909 (respuesta grave a los taikos) ──
const toms = s("~ ~ [ht mt] ~ ~ lt ~ [mt ht]").bank("RolandTR909")
  .gain(.8).pan(sine.slow(4).range(.35,.65)).orbit(0)
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)

// ── 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 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)
// 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 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).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 ~")
  .s("square").lpf(1600).lpq(5).attack(.01).decay(.2).sustain(.3).release(.1)
  .delay(.3).delaytime(.375).delayfeedback(.4)
  .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)

// ── 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, 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, 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, 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, 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) ──
arrange(
  [8,  introPerc],
  [8,  percDobla],
  [16, tribalFull],
  [4,  rodilloTom],
  [16, dropPerc],
  [16, dropMelodia],
  [8,  breakTribal],
  [8,  buildTribal],
  [16, dropTotal],
  [16, dropTotalVar],
  [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 (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)

// ── EL RIFF ESPACIAL RUSO (16 pasos, interpretación) ──
const riff = note("a4 b4 c5 d5 e5 ~ c5 e5 a5 ~ g5 e5 d5 c5 b4 ~")
  .s("supersaw").unison(5).spread(.65).detune(.18)
  .penv(3).pattack(.01).pdecay(.14)
  .lpf(2200).lpq(4).attack(.01).decay(.18).sustain(.25).release(.12)
  .room(.5).rsize(5).delay(.3).delaytime(.375).delayfeedback(.4)
  .gain(.8).pan(sine.slow(8).range(.3,.7)).orbit(2)
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)

// ── 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).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)

// ── 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 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)
// 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").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,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, riser,
  riff.lpf(saw.slow(16).range(350,2200)).gain(.55))
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), contra, leadLimpio.gain(.42).room(.7))
const breakBuild = stack(espacio.gain(.3), pad, riffCosmico.gain(.7),
  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), leadLimpio, stab, contra)
const coda = stack(kick, hats, bajo.lpf(550).gain(.7),
  riff.gain(.45).room(.7), pad, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.3), espacio,
  riffCosmico.gain(.35).delayfeedback(.75), pad.gain(.3))

// ── ARREGLO (148 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [12, breakCosmos],
  [8,  breakBuild],
  [16, dropDelay],
  [16, dropTotal],
  [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 (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)

// ── EL RIFF FUNKY (pluck disco filtrado, el loop eterno de Modjo) ──
const riff = note("fs3 a3 b3 cs4 e4 cs4 b3 a3")
  .s("sawtooth").lpf(1200).lpq(5).attack(.005).decay(.13).sustain(.08).release(.07)
  .phaser(.5).phaserdepth(.4)
  .gain(.85).pan(sine.slow(12).range(.35,.65)).orbit(2)
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 (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(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)

// ── 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(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, 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)).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(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, 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), 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(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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.3), riff.gain(.28).room(.8).lpf(800),
  pad.gain(.25), bajoSub.gain(.3))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, groove],
  [4,  grooveFin],
  [16, dropFiltrado],
  [16, dropFunk],
  [8,  breakSedoso],
  [8,  breakBuild],
  [16, dropAbierto],
  [16, dropAbiertoVar],
  [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 (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, 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)
  .gain(.95).orbit(1)
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)

// ── 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 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").swingBy(1/24,8)
  .gain("[.5 .3]*4").sometimesBy(.15, x=>x.ply(2)).pan(.6).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)
  .vowel("a e i o a i e o").hpf(700).lpf(3200)
  .speed(rand.range(.7,1.5)).pan(rand.range(.2,.8))
  .stut(3, .5, .06).degradeBy(.35).gain(.5).orbit(3)

// ── HOOK LO-FI (interpretación del canto, con crush) ──
const hook = note("e4 ~ e4 d4 e4 g4 ~ e4 d4 c4 ~ b3 ~ d4 e4 ~")
  .s("square").crush(6).lpf(1800)
  .attack(.01).decay(.15).sustain(.2).release(.08)
  .delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.6).pan(sine.slow(8).range(.4,.6)).orbit(2)
const hookOctava = hook.add(note(12)).gain(.25).crush(8).orbit(2)

// ── 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), riser,
  bajo, risa.gain(.35))
const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim, ghost,
  bajo, bajoSub)
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), 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, 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, leadLimpio.gain(.4))
const codaFin = stack(viento, hook.gain(.25).room(.85).delayfeedback(.6),
  pad.gain(.25), bajoSub.gain(.3))

// ── ARREGLO (136 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, groove],
  [4,  grooveFin],
  [16, dropBajo],
  [16, dropBajoHook],
  [8,  breakRisa],
  [8,  breakBuild],
  [16, dropTotal],
  [16, dropTotalVar],
  [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 (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)

// ── EL RIFF (16 pasos EXACTOS, como bajo masivo) ──
const riff = note("e3 ~ ~ e3 [g3 e3] d3 ~ ~ c3 ~ ~ ~ b2 ~ ~ ~")
  .s("sawtooth").distort(1.1).lpf(1100).lpq(6)
  .attack(.003).decay(.25).sustain(.45).release(.08)
  .shape(.3).gain(.9).orbit(1)
const riffSub = note("e2 ~ ~ e2 [g2 e2] d2 ~ ~ c2 ~ ~ ~ b1 ~ ~ ~")
  .s("sine").attack(.002).decay(.3).sustain(.5).release(.06)
  .gain(.7).orbit(1)
const riffOctavas = riff.superimpose(x=>x.add(note(12)).lpf(2400).gain(.55))
const riffLead = note("e4 ~ ~ e4 [g4 e4] d4 ~ ~ c4 ~ ~ ~ b3 ~ ~ ~")
  .s("supersaw").unison(5).spread(.7).lpf(2800)
  .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)

// ── 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 kickClick = s("bd*4").bank("RolandTR909").hpf(38).shape(.5).gain(.95)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
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").swingBy(1/24,8).gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .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 (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)).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, 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), 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, 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), leadLimpio.gain(.4))
const codaFin = stack(multitud, cuerdas.gain(.3),
  riffLead.gain(.3).room(.9).delayfeedback(.6), stomp.gain(.4))

// ── ARREGLO (152 compases) ──
arrange(
  [8,  introStomp],
  [8,  introRiff],
  [16, build],
  [4,  buildFin],
  [16, dropRiff],
  [16, dropRiffVar],
  [8,  breakEstadio],
  [8,  breakBuild],
  [16, dropOctavas],
  [16, dropOctavasFull],
  [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 (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)

// ── EL HOOK (16 pasos, interpretación del sinte de Kids) ──
const hook = note("a4 ~ c5 b4 a4 g4 a4 e5 d5 c5 b4 c5 b4 a4 g4 ~")
  .s("supersaw").unison(4).spread(.5).detune(.12)
  .lpf(2000).attack(.02).decay(.2).sustain(.35).release(.15)
  .delay(.35).delaytime(.375).delayfeedback(.45)
  .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))
  .attack(.005).decay(.12).sustain(.1).release(.06)
  .delay(.2).delaytime(.1875).delayfeedback(.3)
  .gain(.6).pan(.4).orbit(3)

// ── BAJO PULSANTE (corcheas, sigue las fundamentales A·A·G·F) ──
const bajo = note("a1*8").add(note("<0 0 -2 -4>"))
  .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)

// ── 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 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").swingBy(1/24,8).gain(.45).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .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 (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).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)).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))
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, 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), 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, 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), 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, leadLimpio.gain(.4))
const codaFin = stack(hats.gain(.25), hook.gain(.3).room(.9).delayfeedback(.65),
  pad.gain(.3), cuerdas.gain(.2))

// ── ARREGLO (152 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [16, breakdown],
  [8,  breakBuild],
  [16, dropB],
  [16, dropBFull],
  [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 (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)

// ── EL ARPEGIO ABBA (16avos, el motor del track) ──
const arpegio = note("[d3 f3 a3 d4 f4 d4 a3 f3]*2")
  .s("sawtooth").lpf(1800).lpq(5).attack(.004).decay(.12).sustain(.12).release(.06)
  .phaser(4).phaserdepth(.6)
  .gain(.75).pan(sine.slow(6).range(.35,.65)).orbit(3)
const arpegioAlto = arpegio.add(note(12)).gain(.28).lpf(3000).orbit(3)

// ── EL HOOK (interpretación de la voz de Hung Up) ──
const hook = note("a4 ~ a4 g4 f4 g4 a4 d5 ~ c5 a4 g4 f4 ~ e4 ~")
  .s("supersaw").unison(4).spread(.55).lpf(2400)
  .attack(.01).decay(.18).sustain(.3).release(.12)
  .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 (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(.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, 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)).hpf(200).attack(.4).release(.9)
  .room(.55).rsize(6).gain(.4).orbit(4)

// ── 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 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").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(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))
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, riser, bajo, arpegio,
  hook.lpf(900).gain(.5))
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), 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, 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), 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, leadLimpio.gain(.4))
const codaFin = stack(reloj.gain(.4), hook.gain(.3).room(.9).delayfeedback(.6),
  cuerdas.gain(.25))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, motor],
  [4,  motorFin],
  [16, dropDisco],
  [16, dropDiscoVar],
  [12, breakReloj],
  [8,  breakBuild],
  [16, dropBrillante],
  [16, dropBrillanteVar],
  [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 (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)

// ── EL PIANO (riff con progresión Am→G→F→G) ──
const piano = note("a3 c4 e4 a4 g4 e4 c4 e4").add(note("<0 -2 -4 -2>"))
  .s("piano").clip(1.1)
  .room(.6).rsize(7).delay(.25).delaytime(.375).delayfeedback(.35)
  .gain(.8).pan(sine.slow(12).range(.4,.6)).orbit(2)
const pianoAlto = piano.add(note(12)).gain(.3).room(.7).orbit(2)
const pianoSolo = piano.room(.85).rsize(9).delayfeedback(.5).gain(.85)

// ── 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(.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)

// ── 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 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").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 (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).hpf(160)
  .room(.7).rsize(8).gain(.35).orbit(4)
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), 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, 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, leadLimpio.gain(.4))
const codaFin = stack(pianoSolo.gain(.4).delayfeedback(.6),
  pad.gain(.3), voz.gain(.25), hats.gain(.2))

// ── ARREGLO (144 compases) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, groove],
  [4,  grooveFin],
  [16, dropPiano],
  [16, dropPianoVar],
  [12, breakPiano],
  [8,  breakBuild],
  [16, dropAbierto],
  [16, dropAbiertoVar],
  [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 (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)

// ── LA MELODÍA DEL ADAGIO (frases lentas sobre 4 compases, notas largas) ──
const melodia = note("e4 f4 e4 d4 e4 ~ f4 g4 f4 e4 f4 ~ g4 a4 g4 f4 g4 ~ a4 ~")
  .slow(4).clip(1.5)
  .s("supersaw").unison(7).spread(.9).detune(.2)
  .lpf(2200).attack(.3).decay(.5).sustain(.8).release(1.2)
  .room(.8).rsize(9).delay(.3).delaytime(.5).delayfeedback(.4)
  .gain(.8).pan(sine.slow(16).range(.35,.65)).orbit(2)
const melodiaOctava = melodia.add(note(12)).gain(.3).lpf(3400).orbit(2)
const melodiaSola = melodia.room(.95).rsize(10).lpf(2800).gain(.7)

// ── 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)).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)

// ── 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).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).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)

// ── 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 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").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(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))
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, 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, 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), 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), 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), leadLimpio.gain(.4))
const codaFin = stack(melodiaSola.gain(.35).delayfeedback(.6),
  cuerdas.gain(.25), cuerdasBajas.gain(.2))

// ── ARREGLO (172 compases · la más larga de la colección) ──
arrange(
  [8,  intro],
  [8,  introB],
  [16, build],
  [4,  buildFin],
  [16, dropA],
  [16, dropAvar],
  [20, breakdown],
  [8,  breakBuild],
  [4,  buildFin2],
  [16, dropFinal],
  [16, dropFinalFull],
  [16, dropFinalVar],
  [8,  salida],
  [8,  coda],
  [8,  codaFin]
)
`,
  },
];
