strudel/website/src/repl/components/panel/remix-projects.mjs

// Remixes retro (80s/90s/2000s) para la pestaña Projects.
// GENERADO desde my-patterns/RETRO-TECHNO-REMIXES/*.strudel — edita alli y regenera.
export const RETRO_REMIXES = [
  {
    name: "01 · blue monday 909 — new order (1983)",
    folder: "remixes 80s",
    code: `// ════════════════════════════════════════════════════════════════
// 01 · BLUE MONDAY 909 — New Order (1983) → Peak-Time Techno Remix
// 132 BPM · Dm · TR-909 · sidechain + acid en el 2º drop
// 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)

// ── EL BAJO SECUENCIADO (16avos icónicos de Blue Monday) ──
const bajo = note("d2!7 d3 d2!4 f2 f2 e2 e2")
  .s("sawtooth").lpf(perlin.slow(4).range(500, 1200)).lpq(8)
  .attack(.001).decay(.15).sustain(.3).release(.05)
  .shape(.3).gain(.9).orbit(1)

const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.2)
  .gain(.7).orbit(1)

// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
  .duck("1:2").duckattack(.12).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)

// ── CAPA ACID (para el segundo drop) ──
const acid = note("d2 [~ d2] a2 [d2 d3] c3 [~ d2] [eb2 e2] d2")
  .s("sawtooth").ftype("ladder")
  .lpf(sine.slow(16).range(150, 2800)).lpq(sine.slow(7).range(8, 22))
  .lpenv(3).lpattack(.005).lpdecay(.12)
  .shape(.4).gain(.75).rarely(x=>x.add(note(12)))
  .delay(.25).delaytime(.1875).delayfeedback(.35).orbit(3)

// ── ATMÓSFERA / PADS ──
const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [a2,c3,e3]>")
  .s("sawtooth").lpf(700).attack(.8).release(1.5)
  .room(.7).rsize(8).gain(.4).orbit(4)

const cuerdas = note("<d4 d4 c4 a3>").s("supersaw").unison(5).spread(.7)
  .lpf(sine.slow(32).range(400,2200)).attack(.5).release(.8)
  .room(.6).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatsOpen, clap.gain(.4), bajo.lpf(400).gain(.6))
const build = stack(kick, hats16, clap, bajo, pad,
  hook.lpf(saw.slow(16).range(300,1800)).gain(.5))
const buildFin = stack(kickHard, rodillo, bajo, hook.gain(.65))
const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, hook, hookOctava)
const dropAvar = stack(kickHard, hats16, hatsOpen, clap, ride,
  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, cuerdas)
const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.8),
  hats.gain(.3), bajoSub.gain(.3))
const breakBuild = stack(pad, cuerdas, hook, rodillo, hats16.gain(.4))
const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub, hook.gain(.6))
const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, ride, acid,
  bajoSub, hook, hookOctava, cuerdas.gain(.25))
const coda = stack(kick, hats, bajo.lpf(600).gain(.7), hook.gain(.45).room(.7), pad)
const codaFin = stack(hats.gain(.4), hook.gain(.3).room(.9).delayfeedback(.7), pad.gain(.3))

// ── 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/A · TR-909 · supersaw masivo + rodillos largos + break de piano
// 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)

// ── BAJO ROLLING (16avos en fs; en el drop B sigue F#m→D→A→E) ──
const bajo = note("fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs1 fs1 fs2 fs1 fs1 fs2 fs1 fs2")
  .s("sawtooth").lpf(perlin.slow(5).range(420, 1100)).lpq(7)
  .attack(.001).decay(.11).sustain(.2).release(.03)
  .shape(.35).gain(.92).orbit(1)

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

const sub = note("fs1*4").s("sine").decay(.28).sustain(.25).gain(.65).orbit(1)

// ── BATERÍA 909 (el kick lanza el sidechain sobre bajo y lead) ──
const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
// 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] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
  .s("sawtooth").lpf(800).attack(.7).release(1.4)
  .room(.7).rsize(8).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introB = stack(kick, hats, open, clap.gain(.45), bajo.lpf(420).gain(.65))
const build = stack(kick, hats16, clap, bajo, pad,
  riff.lpf(saw.slow(16).range(400, 2600)).gain(.55))
const buildFin = stack(kickHard, rodilloLargo, bajo, riff.gain(.7))
const dropA = stack(kickHard, hats16, open, clap, bajo, sub, riff, riffCuerpo)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo, pad.gain(.3))
const breakPiano = stack(riffPiano, pad, hats.gain(.25), sub.gain(.3))
const breakBuild = stack(riffPiano.gain(.6), pad, rodilloLargo,
  hats16.gain(.35), kick.degradeBy(.5))
const dropB = stack(kickHard, hats16, open, clap, bajoProg, sub, riff, riffCuerpo)
const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, ride,
  bajoProg, sub, riff, riffCuerpo, pad.gain(.35))
const coda = stack(kick, hats, clap.gain(.4), bajo.lpf(600).gain(.7),
  riff.gain(.4).room(.7))
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 · TR-808 · bajo icónico con shape + hats industriales + hpf
// Estructura: intro→bajo solo→build→drop A→break→drop B→coda (140 compases ≈ 4:22)
// ════════════════════════════════════════════════════════════════
setcps(128/60/4)

// ── EL BAJO ICÓNICO (octavas Cm; progresión Cm→Cm→Ab→G por secciones) ──
const bajo = note("<[c2 c3 g2 ab2 c2 c3 g2 ab2]!2 [ab1 ab2 eb2 c2 ab1 ab2 eb2 c2] [g1 g2 d2 b1 g1 g2 d2 b1]>")
  .s("sawtooth").lpf(perlin.slow(6).range(500, 950)).lpq(6)
  .attack(.002).decay(.18).sustain(.35).release(.05)
  .shape(.45).gain(.95).orbit(1)

const sub = note("<c1 c1 ab1 g1>").struct("x*4").s("sine")
  .decay(.3).sustain(.2).gain(.6).orbit(1)

// ── HOOK VOCAL (interpretación sintética del estribillo) ──
const voz = note("g4 g4 eb4 g4 c5 ~ bb4 g4")
  .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))

// ── BATERÍA 808 (percusión pasada por hpf, carácter industrial) ──
const kick = s("bd bd bd <bd [bd bd]>").bank("RolandTR808").shape(.5).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd bd bd <bd [bd bd]>").bank("RolandTR808")
  .shape(.6).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR808").hpf(500).room(.3).gain(.7).orbit(0)
const hats = s("hh*8").bank("RolandTR808").hpf(6000).gain("[.5 .28]*4")
  .pan(sine.slow(5).range(.35,.65)).orbit(0)
const industria = s("metal*8").n(irand(8)).hpf(2800).crush(8)
  .gain("[.3 .12 .2 .12]*2").pan(rand.range(.25,.75)).orbit(0)
const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.55)
  .hpf(400).gain(.28).orbit(0)
const tomsBuild = s("lt lt mt lt ht mt lt mt").bank("RolandTR808")
  .gain(saw.slow(4).range(.3, .75)).speed(saw.slow(4).range(1, 1.3)).orbit(0)
const riser = s("white").clip(1).hpf(saw.slow(8).range(300, 5000))
  .gain(saw.slow(8).range(.05, .3)).room(.5).orbit(3)

// ── PADS MENORES TENSOS ──
const pad = note("<[c3,eb3,g3]!2 [ab2,c3,eb3] [g2,b2,d3]>")
  .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, bajo, sub, voz)
const dropAvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub,
  vozEco, cuerdas)
const breakdown = stack(pad, cuerdas, voz.gain(.55).room(.8),
  hats.gain(.25), sub.gain(.3))
const breakBuild = stack(pad, cuerdas, voz.gain(.65), tomsBuild, riser,
  hats.gain(.35))
const dropB = stack(kickHard, hats, industria, clap, ghost,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.55)), sub, vozEco)
const dropBvar = stack(kickHard, hats, industria, clap, ghost, bajo, sub,
  vozEco, cuerdas, pad.gain(.28))
const punchFinal = stack(kickHard, hats, clap, bajo, sub, voz.gain(.6))
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 · LinnDrum · groove shuffleado + stabs F#m-B + bajo sine+saw
// 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)

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

// ── STABS DE ACORDE (F#m alternando con B, muy tech house) ──
const stabs = note("~ [fs3,a3,cs4] ~ <[fs3,a3,cs4] [b3,ds4,fs4]>")
  .s("sawtooth").lpf(1900).lpq(6)
  .attack(.004).decay(.13).sustain(0).release(.08)
  .phaser(.6).phaserdepth(.5).room(.35)
  .gain(.7).orbit(3)

// ── BATERÍA LINNDRUM (crujiente, todo shuffleado) ──
const kick = s("bd*4").bank("LinnDrum").shape(.3).gain(1.05)
  .duck("1:3").duckattack(.1).duckdepth(.5).orbit(0)
const clap = s("~ cp ~ cp").bank("LinnDrum").room(.25).gain(.8).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] [fs3,a3,cs4] [b2,d3,fs3] [cs3,e3,gs3]>")
  .s("sawtooth").lpf(750).attack(.8).release(1.4)
  .room(.6).rsize(7).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, rimGhost)
const introB = stack(kick, hats, open, clap.gain(.5), bajoSine.gain(.5))
const grooveA = stack(kick, hats, open, clap, rimGhost, bajo)
const build = stack(kick, hats16, clap, rimGhost, bajo, stabs, pad,
  cuerdas.lpf(saw.slow(8).range(400, 2000)).gain(.45))
const dropA = stack(kick, hats, open, clap, snare, rimGhost, bajo, stabs, cuerdas)
const dropAvar = stack(kick, hats16, open, clap, snare, bajo, stabs,
  cuerdas, cuerdasAlto)
const breakdown = stack(pad, cuerdas.gain(.55).room(.75),
  bajoSine.gain(.45), hats.gain(.3), rimGhost.gain(.2))
const breakBuild = stack(pad, cuerdas.gain(.65), bajo, rodillo, hats16.gain(.3))
const dropB = stack(kick, hats, open, clap, snare, rimGhost,
  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), stabs, cuerdas)
const dropBvar = stack(kick, hats16, open, clap, snare, bajo,
  stabs.every(4, x=>x.iter(4)), cuerdas, cuerdasAlto, pad.gain(.25))
const coda = stack(kick, hats, clap.gain(.5), bajo, cuerdas.gain(.4).room(.7))
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 · TR-606 + 303 · línea acid protagonista + hook cuadrado naïf
// Estructura: intro→acid solo→build→drop A→break→drop B→acid final→coda (144 compases ≈ 4:16)
// ════════════════════════════════════════════════════════════════
setcps(135/60/4)

// ── EL HOOK (interpretación: frase y respuesta alternadas, sinte naïf) ──
const hook = note("<[g4 b4 d5 b4 e5 d5 b4 g4] [c5 e5 g5 e5 d5 b4 a4 g4]>")
  .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)

// ── LA 303 (protagonista absoluta: lpf modulado lento + lpq alto) ──
const acid = note("g1 [~ g1] g2 g1 [g1 g2] bb1 [~ a1] g1")
  .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 ──
const sub = note("g1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 606 (seca, sin room, puro garaje) ──
const kick = s("bd*4").bank("RolandTR606").shape(.45).gain(1.1)
  .duck("2:3").duckattack(.09).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR606").shape(.6).distort(1.1).gain(1.1)
  .duck("2:3").duckattack(.09).duckdepth(.6).orbit(0)
const snare = s("~ sd ~ sd").bank("RolandTR606").gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR606").gain(.55).pan(.58).orbit(0)
const hats16 = s("hh*16").bank("RolandTR606")
  .gain("[.5 .2 .3 .2]*4").pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR606").gain(.45).orbit(0)
const rodillo = s("sd*16").bank("RolandTR606")
  .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.5)).orbit(0)

// ── PAD MÍNIMO (solo para el break) ──
const pad = note("<[g2,b2,d3] [g2,b2,d3] [c3,e3,g3] [d3,fs3,a3]>")
  .s("sawtooth").lpf(700).attack(.8).release(1.5)
  .room(.65).rsize(7).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introB = stack(kick, hats, open, snare.gain(.4), sub)
const acidSolo = stack(kick, hats, snare, acid.gain(.65), sub.gain(.4))
const build = stack(kick, hats16, snare, acid, sub, pad.gain(.25),
  hook.lpf(saw.slow(8).range(400, 2400)).gain(.5))
const dropA = stack(kickHard, hats16, open, snare, acid, sub, hook)
const dropAvar = stack(kickHard, hats16, open, snare, acid, sub,
  hook, hookOctava)
const breakdown = stack(pad, hook.gain(.55).room(.7).delayfeedback(.55),
  hats.gain(.3), acid.gain(.4).lpf(500))
const breakBuild = stack(pad, hook.gain(.65), rodillo, hats16.gain(.35),
  acid.gain(.6))
const dropB = stack(kickHard, hats16, open, snare, acidFuria, sub, hook)
const dropBvar = stack(kickHard, hats16, open, snare, acidFuria, sub,
  hook.every(4, x=>x.rev()), hookOctava)
const 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))
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 · TR-808 · bajo EBM distorsionado + "ding ding" + coros vowel
// 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)

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

const sub = note("d1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 808 (snare seca, marcial) ──
const kick = s("bd*4").bank("RolandTR808").shape(.5).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kickVar = s("bd bd bd [bd bd]").bank("RolandTR808")
  .shape(.6).distort(1.05).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.85).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR808")
  .gain("[.45 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0)
const 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]!2 [bb2,d3,f3] [a2,cs3,e3]>")
  .s("sawtooth").vowel("o").lpf(1200)
  .attack(.6).release(1.2).room(.65).rsize(7)
  .gain(.45).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introDing = stack(kick, hats, snare.gain(.4), ding, sub)
const build = stack(kick, hats16, snare, bajo, ding, coros.gain(.3),
  voz.lpf(saw.slow(8).range(400, 1900)).gain(.5))
const buildFin = stack(kickVar, rodillo, bajo, ding, voz.gain(.65))
const dropA = stack(kickVar, hats16, snare, rimInd, bajo, sub, ding, voz)
const dropAvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajo, sub,
  ding, dingRespuesta, voz, vozOctava)
const breakCoros = stack(coros, voz.gain(.55).room(.75), ding.gain(.5),
  hats.gain(.25), sub.gain(.3))
const breakBuild = stack(coros, voz.gain(.65), rodillo, hats16.gain(.3),
  ding.gain(.6))
const dropB = stack(kickVar, hats16, snare, rimInd, bajoProg, sub, ding,
  voz, coros.gain(.3))
const dropBvar = stack(kickVar, hats16, snare, rimInd, tomsFill, bajoProg, sub,
  ding, dingRespuesta, voz, vozOctava, coros.gain(.35))
const marcha = stack(kick, hats, snare, bajo, sub, ding.gain(.6), voz.gain(.6))
const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.6),
  voz.gain(.45).room(.7), coros.gain(.35))
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 · TR-909 · chords stab Fm7 en offbeat + hats rápidos + bajo walking
// 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)

// ── CHORDS STAB DETROIT (Fm7 en offbeat, con phaser) ──
const stab = note("~ [f3,ab3,c4,eb4] ~ [f3,ab3,c4,eb4]")
  .s("sawtooth").lpf(2100).lpq(5)
  .attack(.003).decay(.15).sustain(0).release(.1)
  .phaser(2).phaserdepth(.6).room(.4).rsize(5)
  .gain(.7).orbit(3)

const stabVar = note("~ [f3,ab3,c4,eb4] ~ <[f3,ab3,c4,eb4] [ab3,c4,eb4,g4]>")
  .s("sawtooth").lpf(2400).lpq(5)
  .attack(.003).decay(.15).sustain(0).release(.1)
  .phaser(2).phaserdepth(.6).room(.4).rsize(5)
  .gain(.7).every(4, x=>x.iter(4)).orbit(3)

// ── BAJO WALKING (corcheas que caminan por Fm) ──
const bajo = note("f1 f2 eb2 c2 f1 ab1 bb1 c2")
  .s("sawtooth").lpf(perlin.slow(5).range(450, 900)).lpq(5)
  .attack(.002).decay(.16).sustain(.3).release(.05)
  .shape(.3).gain(.9).orbit(1)

const sub = note("f1*4").s("sine").decay(.28).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 909 (hats rápidos, ride Detroit) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.05).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
const crash = s("cr ~ ~ ~").bank("RolandTR909").slow(4).gain(.4).room(.5).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2, .85)).speed(saw.slow(4).range(1, 1.4)).orbit(0)

// ── PADS / STRINGS DETROIT ──
const pad = note("<[f3,ab3,c4] [f3,ab3,c4] [db3,f3,ab3] [eb3,g3,bb3]>")
  .s("sawtooth").lpf(sine.slow(24).range(450, 1000)).attack(.8).release(1.5)
  .room(.7).rsize(8).gain(.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, bajo, stab, pad.gain(.3),
  melodia.s("sawtooth").lpf(saw.slow(16).range(300, 2000)).gain(.5).orbit(2))
const buildFin = stack(kickHard, rodillo, bajo, stab, lead.gain(.7))
const dropA = stack(kickHard, hats16, open, clap, bajo, sub, stab, lead)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  stabVar, lead, leadOctava)
const breakdown = stack(pad, cuerdas, lead.gain(.55).room(.75),
  hats16.gain(.2), sub.gain(.3))
const breakBuild = stack(pad, cuerdas, lead.gain(.65), rodillo,
  hats16.gain(.3), stab.gain(.4))
const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  stabVar, lead, leadOctava)
const dropBFull = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
  stabVar, lead, leadOctava, cuerdas.gain(.25))
const grooveOut = stack(kick, hats16, open, clap, bajo, sub, stab,
  lead.sometimesBy(.3, x=>x.add(note(12)).gain(.5)))
const coda = stack(kick, hats16.gain(.35), bajo.lpf(550).gain(.7),
  lead.gain(.4).room(.7), pad)

// ── 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 · TR-909 distorsionado · kick implacable + metal loops + supersaw solo en drops
// 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)

// ── BAJO REESE (muro grave con detune, sostenido) ──
const reese = note("fs1").s("supersaw").unison(3).detune(.7)
  .lpf(sine.slow(8).range(200, 600)).lpq(4)
  .attack(.01).sustain(.8).release(.2).clip(1)
  .shape(.3).gain(.7).orbit(1)

const sub = note("fs1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 909 DESTROZADA (kick distorsionado implacable) ──
const kick = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0)
const kickSchranz = s("bd*4").bank("RolandTR909").ply("<1 1 1 2>")
  .shape(.7).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.08).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").hpf(400).room(.25).gain(.7).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .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)
const riser = s("white").clip(1).hpf(saw.slow(8).range(400, 6000))
  .gain(saw.slow(8).range(.05, .32)).room(.4).orbit(3)

// ── PAD OSCURO (solo respira en el break) ──
const pad = note("<[fs2,a2,cs3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>")
  .s("sawtooth").lpf(600).attack(1).release(1.8)
  .room(.75).rsize(9).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats16.gain(.25), sub.gain(.4))
const maquina = stack(kick, hats16, clap.gain(.5), rimLoop.gain(.25), reese.gain(.5))
const build = stack(kick, hats16, clap, metalLoop.gain(.2), reese, sub, riser,
  riffCuerpo.lpf(saw.slow(8).range(300, 1400)).gain(.5))
const buildFin = stack(kickSchranz, rodillo, reese, riffCuerpo.gain(.55))
const dropA = stack(kick, hats16, clap, metalLoop, reese, sub, riff, riffCuerpo)
const dropAvar = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese, sub,
  riff.sometimesBy(.2, x=>x.add(note(12))), riffCuerpo)
const breakdown = stack(pad, riffBreak, hats16.gain(.15), sub.gain(.3))
const breakBuild = stack(pad, riffBreak.gain(.6), rodillo, riser,
  hats16.gain(.3), kick.degradeBy(.5))
const dropB = stack(kickSchranz, hats16, clap, metalLoop, reese, sub,
  riff, riffCuerpo)
const dropBFull = stack(kickSchranz, hats16, clap, metalLoop, rimLoop, reese,
  sub, riff, riffCuerpo, pad.gain(.25))
const schranzTotal = stack(kickSchranz, rimLoop, metalLoop, clap,
  reese.lpf(sine.slow(4).range(250, 800)), sub,
  riff.every(4, x=>x.rev()))
const coda = stack(kick, hats16.gain(.3), clap.gain(.4), reese.gain(.5),
  riffBreak.gain(.5))
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 · TR-707 · kalimba casio + toms tribales + breakdown con viento
// 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)

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

// ── BATERÍA 707 (suave, con toms tribales) ──
const kick = s("bd*4").bank("RolandTR707").shape(.3).gain(1)
  .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR707").room(.35).gain(.6).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR707").gain(.45).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR707")
  .gain(rand.range(.12, .42)).pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR707").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)

// ── PADS LARGOS Y VIENTO ──
const pad = note("<[a2,cs3,e3] [fs2,a2,cs3] [d3,fs3,a3] [e3,gs3,b3]>")
  .s("sawtooth").lpf(sine.slow(32).range(500, 1300)).attack(1.2).release(2)
  .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, bajo, bajoArm, kalimba, pad.gain(.3),
  hook.lpf(saw.slow(16).range(300, 1700)).gain(.5))
const buildFin = stack(kick, tomsTribal, bajo, kalimba, hook.gain(.65))
const dropA = stack(kick, hats16, open, clap, toms, bajo, bajoArm, kalimba, hook)
const dropAvar = stack(kick, hats16, open, clap, toms, bajo, bajoArm,
  kalimbaVar, hook, pad.gain(.3))
const breakAmplio = stack(pad, viento, hookSuave, kalimba.gain(.4),
  bajo.gain(.4))
const breakBuild = stack(pad, viento.gain(.2), hook.gain(.65), kalimba,
  tomsTribal, hats16.gain(.3))
const dropB = stack(kick, hats16, open, clap, toms, bajo, bajoArm,
  kalimba, hook.sometimesBy(.25, x=>x.add(note(12)).gain(.5)))
const dropBFull = stack(kick, hats16, open, clap, toms, tomsTribal.gain(.3),
  bajo, bajoArm, kalimbaVar, hook, pad.gain(.35))
const coda = stack(kick, hats, clap.gain(.4), bajo.gain(.6),
  kalimba.gain(.45), hookSuave.gain(.4), pad)
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 · TR-909 · sidechain profundo (duckdepth .8) + sub en c1 + builds con rodillo
// 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)

// ── EL SUB POTENTE (pedal en c1) + bajo offbeat ──
const sub = note("c1*4").s("sine").decay(.35).sustain(.35).release(.05)
  .gain(.8).orbit(1)

const bajoOff = note("[~ c2]*4").s("sawtooth")
  .lpf(700).lpq(5).attack(.001).decay(.14).sustain(.2).release(.04)
  .shape(.3).gain(.7).orbit(1)

// ── BATERÍA 909 ENORME (el kick hunde TODO con duckdepth .8) ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
  .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
  .duck("1:2:4").duckattack(.14).duckdepth(.8).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").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)

// ── PAD ESTADIO ──
const pad = note("<[c3,e3,g3] [c3,e3,g3] [f3,a3,c4] [g3,b3,d4]>")
  .s("supersaw").unison(5).spread(.7)
  .lpf(sine.slow(32).range(450, 1400)).attack(.9).release(1.8)
  .room(.75).rsize(9).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introStabs = stack(kick, hats, open, clap.gain(.5),
  stabs.lpf(900).gain(.5), sub.gain(.5))
const build = stack(kick, hats16, clap, bajoOff, pad.gain(.3),
  stabs.hpf(saw.slow(16).range(50, 2500)).gain(.6), sub.gain(.5))
const buildFin = stack(kickHard, rodillo, bajoOff,
  stabs.hpf(saw.slow(8).range(100, 4000)).gain(.7))
const dropA = stack(kickHard, hats16, open, clap, crash, sub, bajoOff,
  stabs, stabsCuerpo)
const dropAvar = stack(kickHard, hats16, open, clap, sub, bajoOff,
  stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.6)), stabsCuerpo, pad.gain(.3))
const breakdown = stack(pad, stabsBreak, hats.gain(.25), sub.gain(.35))
const build2 = stack(pad, stabsBreak.gain(.5), rodillo, hats16.gain(.35),
  kick.degradeBy(.5), sub.gain(.4))
const dropB = stack(kickHard, hats16, open, clap, crash, sub, bajoOff,
  stabs, stabsCuerpo, pad.gain(.3))
const dropBFull = stack(kickHard, rodilloCorto.gain(.3), open, clap, sub,
  bajoOff, stabs, stabsCuerpo, pad.gain(.35))
const grooveOut = stack(kick, hats16, open, clap, sub, bajoOff,
  stabs.gain(.7))
const coda = stack(kick, hats, clap.gain(.5), sub.gain(.5),
  stabsBreak.gain(.5), pad.gain(.3))

// ── 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 · Roland CR-78 · chords dub con delay infinito + bajo sine + shuffle hipnótico
// 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)

// ── CHORDS DUB (el corazón del track: delay largo + feedback alto) ──
const chords = note("~ <[d3,fs3,a3] [d3,fs3,a3] [g3,b3,d4] [a3,cs4,e4]> ~ ~")
  .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, respirado) ──
const bajo = note("<[d1 ~ [~ d1] ~] [d1 ~ [~ d1] [~ a1]]>")
  .s("sine").decay(.4).sustain(.55).release(.1)
  .gain(.9).orbit(1)

const bajoArm = bajo.add(note(12)).s("triangle").lpf(700).gain(.25).orbit(1)

// ── BATERÍA CR-78 (suave, vintage, hipnótica) ──
const kick = s("bd*4").bank("RolandCR78").shape(.35).gain(1.05)
  .duck("2:3").duckattack(.15).duckdepth(.45).orbit(0)
const kickIntro = s("bd*4").bank("RolandCR78").degradeBy(.15).shape(.3).gain(1)
  .duck("2:3").duckattack(.15).duckdepth(.4).orbit(0)
const 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").gain(.3).orbit(0)

// ── ATMÓSFERA (pads inmensos + textura) ──
const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [g2,b2,d3] [a2,cs3,e3]>")
  .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)

// ── SECCIONES ──
const intro = stack(kickIntro, hats, bajo.gain(.5))
const introChords = stack(kickIntro, hats, chords.gain(.5), bajo)
const grooveRiff = stack(kick, hats, shaker.gain(.15), rimDub.gain(.3),
  chords, bajo, riff.gain(.5).lpf(900))
const build = stack(kick, hats, shaker, rimDub, chords, bajo, bajoArm,
  pad.gain(.3), riff.lpf(saw.slow(16).range(500, 1600)).gain(.6))
const dropA = stack(kick, hats, shaker, open, rimDub, snareDub,
  chords, bajo, bajoArm, riff)
const dropAvar = stack(kick, hats, shaker, open, rimDub, snareDub,
  chords, chordsEco, bajo, bajoArm, riff, riffLejos)
const breakdown = stack(pad, espacio, chords.gain(.55).delayfeedback(.72),
  riff.gain(.45).room(.85), bajo.gain(.45))
const breakBuild = stack(pad, espacio.gain(.15), chords, riff.gain(.6),
  shaker.gain(.25), rimDub, bajo)
const dropB = stack(kick, hats, shaker, open, rimDub, snareDub, chords,
  bajo, bajoArm, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
  pad.gain(.25))
const dropBFull = stack(kick, hats, shaker, open, rimDub, snareDub,
  chords, chordsEco, bajo, bajoArm, riff, riffLejos, pad.gain(.3))
const dubFinal = stack(kick, hats, rimDub, chords.delayfeedback(.72),
  bajo, riff.gain(.5).room(.9))
const coda = stack(kickIntro, hats.gain(.3),
  chords.gain(.45).delayfeedback(.75), bajo.gain(.5), pad.gain(.3))
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 · TR-606 · square robótico + crush suave · ultra 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)

// ── BAJO ROBÓTICO (pulso de máquina en Cm) ──
const bajo = note("c2 c2 g1 c2").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")
  .s("square").lpf(1000).lpq(6)
  .attack(.001).decay(.1).sustain(.2).release(.03)
  .shape(.25).gain(.9).orbit(1)

const sub = note("c1*4").s("sine").decay(.25).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 606 (seca, sin reverb, precisión maquinal) ──
const kick = s("bd*4").bank("RolandTR606").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kickElectro = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR606")
  .shape(.4).gain(1.05).duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR606").gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR606").gain(.5).pan(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR606")
  .gain("[.45 .2 .3 .2]*4").pan(.45).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR606").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)

// ── 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 (frío, casi inaudible, solo da contexto) ──
const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [g2,b2,d3]>")
  .s("triangle").lpf(600).attack(1).release(1.5)
  .room(.3).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats)
const introB = stack(kick, hats, rim, bajo.lpf(400).gain(.7))
const groove = stack(kick, hats, hatsOpen, clap, bajo, sub.gain(.4))
const build = stack(kick, hats16, clap, rim, bajo,
  hook.lpf(saw.slow(8).range(400,2600)).gain(.55))
const buildFin = stack(kick, rodillo, bajoOcho, hook.gain(.7))
const dropA = stack(kick, hats16, hatsOpen, clap, bajoOcho, sub, hook)
const dropAvar = stack(kick, hats16, hatsOpen, clap, rim, bajoOcho, sub,
  hook.every(4, x=>x.iter(4)), hookEco, blips)
const breakRobot = stack(bajo.gain(.6), blips, hook.gain(.5), pad, hats.gain(.3))
const breakBuild = stack(bajo, blips, hook.gain(.6), pad, rodillo, hats16.gain(.35))
const dropB = stack(kickElectro, hats16, hatsOpen, clap, bajoDrop, sub, hook, hookEco)
const dropBvar = stack(kick, hats16, hatsOpen, clap, rim, bajoDrop, sub,
  hook.sometimesBy(.25, x=>x.add(note(12)).gain(.6)), hookEco, blips)
const coda = stack(kick, hats, bajo.gain(.7), hook.gain(.45), pad)
const 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 · OberheimDMX · breaks + stabs rave + sirenas + hoover
// 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)

// ── 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 (punchy, con sub de refuerzo) ──
const bajo = note("g1 ~ [~ g1] g1 ~ g1 [~ e1] [f1 fs1]")
  .s("sawtooth").lpf(700).lpq(6)
  .attack(.001).decay(.12).sustain(.35).release(.04)
  .shape(.3).gain(.9).orbit(1)

const sub = note("g1 ~ ~ g1 ~ ~ g1 ~").s("sine")
  .decay(.3).sustain(.3).gain(.65).orbit(1)

// ── BATERÍA DMX (breakbeat con snares desplazadas y fantasma) ──
const kick = s("bd ~ [~ bd] bd").bank("OberheimDMX").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kick4 = s("bd*4").bank("OberheimDMX").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
const snare = s("~ sd ~ [~ sd]").bank("OberheimDMX").room(.25).gain(.8).orbit(0)
const ghost = s("sd*8").bank("OberheimDMX")
  .degradeBy(.65).gain(.22).pan(.6).orbit(0)
const hats = s("[~ hh]*4").bank("OberheimDMX").gain(.55).pan(.4).orbit(0)
const hats16 = s("hh*16").bank("OberheimDMX")
  .gain("[.5 .22 .32 .22]*4").pan(rand.range(.3,.7)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("OberheimDMX").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)

// ── PAD (colchón alegre G-Em-C-D) ──
const pad = note("<[g3,b3,d4] [e3,g3,b3] [c3,e3,g3] [d3,fs3,a3]>")
  .s("supersaw").unison(4).spread(.6).lpf(900)
  .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,
  hook.lpf(saw.slow(16).range(400,2200)).gain(.5), stabs.gain(.4))
const buildFin = stack(kick4, rodillo, bajo, hook.gain(.65), sirena)
const dropA = stack(kick, snare, ghost, hats16, open, bajo, sub, hook, stabs)
const dropAvar = stack(kick, snare, ghost, hats16, open, bajo, sub,
  hook, hookAlta, stabs, sirena)
const breakdown = stack(pad, sirena, hook.gain(.55).room(.7),
  hats.gain(.3), sub.gain(.35))
const breakBuild = stack(pad, hook.gain(.65), stabs.gain(.5),
  rodillo, hats16.gain(.4), sirena)
const dropHoover = stack(kick, snare, hats16, open, hoover, sub,
  hook.gain(.6), ghost)
const dropFull = stack(kick, snare, ghost, hats16, open, hoover, sub,
  hook, hookAlta, stabs.gain(.5), sirena)
const dropUltimo = stack(kick, snare, ghost, hats16, open, bajo, sub,
  hook.sometimesBy(.2, x=>x.add(note(12))), hookAlta, stabs, pad.gain(.25))
const coda = stack(kick4, hats, clap, bajo.gain(.7), hook.gain(.45).room(.6), pad)
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 · TR-808 · toms euclidianos + bajo funk exacto · groove seco
// Estructura: intro→percusión→groove→drop A→break tribal→drop B→coda (140 compases ≈ 4:29)
// ════════════════════════════════════════════════════════════════
setcps(125/60/4)

// ── EL BAJO (la línea exacta de John Deacon, 16 pasos) ──
const bajo = note("e1 ~ ~ e1 e1 ~ e1 ~ [g1 e1] a1 ~ ~ ~ ~ ~ ~")
  .s("sawtooth").lpf(750).lpq(7)
  .attack(.001).decay(.14).sustain(.35).release(.05)
  .shape(.3).gain(.95).orbit(1)

const sub = note("e1 ~ ~ e1 e1 ~ e1 ~ ~ a1 ~ ~ ~ ~ ~ ~")
  .s("sine").decay(.25).sustain(.3).gain(.6).orbit(1)

// ── STABS MÍNIMOS (acorde Em seco, casi percusivo) ──
const stab = note("~ ~ [e3,g3,b3] ~ ~ [e3,g3,b3] ~ ~")
  .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)

// ── BATERÍA 808 (bombo seco con swing + claps a contratiempo) ──
const kick = s("bd*4").bank("RolandTR808").shape(.3).gain(1.05)
  .duck("1:2").duckattack(.09).duckdepth(.45).orbit(0)
const clap = s("[~ cp]*4").bank("RolandTR808").gain(.5).pan(.6).orbit(0)
const clapDos = s("~ cp ~ cp").bank("RolandTR808").gain(.65).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR808").gain(.5).pan(.35)
  .swingBy(1/8, 4).orbit(0)
const shaker = s("hh*16").bank("RolandTR808")
  .gain("[.4 .18 .28 .18]*4").speed(rand.range(1.4,1.8))
  .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)

// ── PAD OSCURO (mínimo, solo en las pausas) ──
const pad = note("<[e2,g2,b2] [e2,g2,b2] [a2,c3,e3] [b2,d3,fs3]>")
  .s("triangle").lpf(550).attack(1.2).release(1.8)
  .room(.5).rsize(5).gain(.35).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, bajo, tomAlto, tomMedio, riff.gain(.55))
const dropA = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub,
  stab, riff, congas)
const dropAtoms = stack(kick, clap, shaker, bajo, sub, stab, riff,
  tomAlto, tomMedio, tomBajo, congas)
const breakTribal = stack(tomAlto, tomMedio, tomBajo, congas, shaker,
  bajo.gain(.6), sub.gain(.4), pad)
const breakBuild = stack(tomAlto, tomMedio, tomBajo, congas, rodillo,
  bajo, riff.gain(.5), pad)
const dropB = stack(kick, clap, clapDos.gain(.4), shaker, bajo, sub,
  stab, riff.sometimesBy(.25, x=>x.add(note(12)).gain(.45)),
  tomAlto, congas)
const dropBvar = stack(kick, clap, shaker, bajo, sub, stab,
  riff, tomAlto, tomMedio, tomBajo, congas.gain(.55))
const coda = stack(kick, hats, clap, bajo.gain(.7), congas.gain(.35),
  riff.gain(.4), pad)
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 · TR-909 · supersaw nostálgico + piano + arpegio perpetuo
// 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)

// ── PIANO EMOTIVO (protagonista del breakdown) ──
const piano = note("e4 g4 a4 g4 e4 ~ d4 c4 d4 e4 ~ ~ g4 e4 d4 ~")
  .s("piano").slow(2).room(.8).rsize(8)
  .delay(.4).delaytime(.375).delayfeedback(.45)
  .gain(.9).orbit(2)

const pianoAcordes = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
  .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) ──
const bajo = note("<c2 a1 f1 g1>").struct("x*16")
  .s("sawtooth").lpf(650).lpq(6)
  .attack(.001).decay(.1).sustain(.25).release(.03)
  .gain("[.9 .55 .7 .55]*4").shape(.25).orbit(1)

const sub = note("<c1 a1 f1 g1>").struct("x*4")
  .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1)

// ── BATERÍA 909 ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
const 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)

// ── CUERDAS / PADS (el gran room trance) ──
const cuerdas = note("<[c3,e3,g3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
  .s("supersaw").unison(4).spread(.8).lpf(1000)
  .attack(.9).release(1.8).room(.75).rsize(8).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introArp = stack(kick, hats, open, arpegio, sub.gain(.5))
const build = stack(kick, hats16, clap, bajo, arpegio, cuerdas.gain(.3),
  hook.lpf(saw.slow(16).range(400,2400)).gain(.5))
const buildFin = stack(kickHard, rodillo, bajo, arpegio16, hook.gain(.65))
const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  arpegio16, hook)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  arpegio16, hook, hookAlta, cuerdas.gain(.3))
const breakPiano = stack(piano, pianoAcordes, cuerdas, sub.gain(.3))
const breakBuild = stack(piano.gain(.7), pianoAcordes.gain(.5), cuerdas,
  arpegio, rodillo, hats16.gain(.4))
const dropB = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  arpegio16, hook, hookAlta)
const dropBvar = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
  arpegio16, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)),
  hookAlta, cuerdas.gain(.3))
const dropFinal = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  arpegio16, hook, hookAlta, cuerdas.gain(.35), pianoAcordes.gain(.35))
const coda = stack(kick, hats, bajo.gain(.6), arpegio, hook.gain(.4).room(.7),
  cuerdas.gain(.3))
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 · LinnDrum · chords deep con phaser + sub redondo + eco dub
// Estructura: intro→sub→chords→drop A→break urbano→drop B→coda (136 compases ≈ 4:23)
// ════════════════════════════════════════════════════════════════
setcps(124/60/4)

// ── EL BAJO (la línea del original, redonda y profunda) ──
const bajo = note("d2 d2 c2 d2 f2 d2 g2 f2")
  .s("triangle").lpf(500)
  .attack(.002).decay(.18).sustain(.5).release(.08)
  .shape(.15).gain(.95).orbit(1)

const sub = note("d1 ~ ~ d1 ~ ~ d1 ~").s("sine")
  .decay(.35).sustain(.35).gain(.6).orbit(1)

// ── ECO DUB DEL BAJO (delay largo, flotando por detrás) ──
const bajoDub = note("d2 ~ ~ ~ f2 ~ ~ ~")
  .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)

// ── CHORDS DEEP (Dm7 con phaser, sofisticación urbana) ──
const chords = note("<[d3,f3,a3,c4] [d3,f3,a3,c4] [c3,e3,g3,bb3] [bb2,d3,f3,a3]>")
  .struct("~ x ~ [~ x]")
  .s("sawtooth").lpf(1100).lpq(2)
  .attack(.01).decay(.3).sustain(.2).release(.15)
  .phaser(.5).phaserdepth(.7)
  .room(.45).rsize(4).gain(.6).pan(.45).orbit(4)

// ── BATERÍA LINNDRUM (suave, elegante, ochentera) ──
const kick = s("bd*4").bank("LinnDrum").shape(.2).gain(1)
  .duck("1:2").duckattack(.1).duckdepth(.4).orbit(0)
const clap = s("~ cp ~ cp").bank("LinnDrum").room(.3).gain(.6).orbit(0)
const hats = s("[~ hh]*4").bank("LinnDrum").gain(.45).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("LinnDrum")
  .gain("[.4 .18 .28 .18]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("LinnDrum").gain(.4).orbit(0)
const rim = s("~ [~ rim] ~ rim").bank("LinnDrum").gain(.4).pan(.35).orbit(0)
const ghost = s("sd*8").bank("LinnDrum").degradeBy(.7).gain(.18).pan(.55).orbit(0)
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) ──
const niebla = s("space").slow(8).lpf(1200).room(.8).rsize(8)
  .gain(.25).pan(sine.slow(16).range(.3,.7)).orbit(4)

// ── PAD NOCTURNO ──
const pad = note("<[d3,f3,a3] [d3,f3,a3] [c3,e3,g3] [bb2,d3,f3]>")
  .s("triangle").lpf(700).attack(1).release(2)
  .room(.6).rsize(6).gain(.35).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, bajo, chords, lead.gain(.6))
const dropA = stack(kick, hats16, open, clap, ghost, bajo, sub, chords, lead)
const dropAvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub,
  bajoDub, chords, lead, leadEco)
const breakUrbano = stack(pad, niebla, chords.gain(.4), lead.gain(.5).room(.7),
  bajoDub, hats.gain(.25))
const breakBuild = stack(pad, chords.gain(.5), lead.gain(.6), rodillo,
  hats16.gain(.35), sub.gain(.4))
const dropB = stack(kick, hats16, open, clap, ghost, bajo, sub, bajoDub,
  chords.every(4, x=>x.iter(4)), lead, leadEco)
const dropBvar = stack(kick, hats16, open, clap, rim, ghost, bajo, sub,
  bajoDub, chords, lead.sometimesBy(.2, x=>x.add(note(12)).gain(.5)),
  leadEco, niebla)
const coda = stack(kick, hats, bajo.gain(.7), chords.gain(.4),
  lead.gain(.4).room(.7), pad)
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 · TR-909 · stabs offbeat con vowel + bajo offbeat · segundo drop en octava
// 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)

// ── 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) ──
const bajo = note("[~ d2]*4")
  .s("sawtooth").lpf(800).lpq(7)
  .attack(.001).decay(.13).sustain(.3).release(.04)
  .shape(.35).gain(.9).orbit(1)

const bajoVar = note("[~ d2]!3 [~ [c2 e2]]")
  .s("sawtooth").lpf(850).lpq(7)
  .attack(.001).decay(.13).sustain(.3).release(.04)
  .shape(.35).gain(.9).orbit(1)

const sub = note("d1*4").s("sine").decay(.28).sustain(.2).gain(.65).orbit(1)

// ── BATERÍA 909 (dura y directa) ──
const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
const 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)

// ── PAD (colchón menor dramático) ──
const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [c3,e3,g3]>")
  .s("supersaw").unison(4).spread(.7).lpf(900)
  .attack(.8).release(1.5).room(.65).rsize(7).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introStabs = stack(kick, hats, open, stabs.gain(.45), sub.gain(.5))
const build = stack(kick, hats16, clap, bajo, stabs, pad.gain(.3),
  hook.lpf(saw.slow(16).range(400,2000)).gain(.5))
const buildFin = stack(kickHard, rodillo, bajo, stabs, hook.gain(.65))
const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub, stabs, hook)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub,
  stabs, hook, pad.gain(.25))
const breakVocal = stack(pad, stabs.gain(.4).room(.6),
  hook.gain(.55).room(.7), hats.gain(.3), sub.gain(.35))
const breakBuild = stack(pad, stabs.gain(.5), hook.gain(.65),
  rodilloCorto, hats16.gain(.4))
const dropOctava = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  stabs, hookOctava)
const dropOctavaVar = stack(kickHard, hats16, open, clap, ride, bajoVar, sub,
  stabs.sometimesBy(.2, x=>x.add(note(12)).gain(.5)),
  hookOctava, hook.gain(.4), pad.gain(.25))
const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajoVar,
  sub, stabs, hook, hookOctava.gain(.5))
const coda = stack(kick, hats, clap, bajo.gain(.7), stabs.gain(.4),
  hook.gain(.45).room(.6), pad)
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 · TR-909 · piano rave offbeat + hoover + euforia noventera
// 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)

// ── PIANO RAVE (el acorde en offbeat, pura euforia) ──
const pianoRave = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>")
  .struct("[~ x]*4")
  .s("piano").room(.45).rsize(4)
  .gain(.8).pan(.55).orbit(3)

// ── HOOVER (supersaw rugiente, el terror de 1992) ──
const hoover = note("g2 g2 ~ g2 ~ bb2 ~ c3")
  .s("supersaw").unison(6).detune(.9).spread(.85)
  .lpf(1500).distort(.9)
  .attack(.01).decay(.2).sustain(.45).release(.12)
  .gain(.7).orbit(3)

// ── BAJO (el motor: negras que empujan + sub) ──
const bajo = note("g1 g1 bb1 c2").ply(2)
  .s("sawtooth").lpf(700).lpq(6)
  .attack(.001).decay(.12).sustain(.35).release(.04)
  .shape(.3).gain(.9).orbit(1)

const sub = note("g1 ~ g1 ~ bb1 ~ c2 ~").s("sine")
  .decay(.3).sustain(.25).gain(.6).orbit(1)

// ── BATERÍA 909 (con fills doblados cada 8 compases) ──
const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.6).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65)
  .every(8, x=>x.ply(2).gain(.95)).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const openRave = s("[~ oh]*4").bank("RolandTR909").gain(.5).pan(.4).orbit(0)
const 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)

// ── PAD (colchón Gm, grande) ──
const pad = note("<[g2,bb2,d3] [g2,bb2,d3] [eb2,g2,bb2] [f2,a2,c3]>")
  .s("supersaw").unison(4).spread(.75).lpf(950)
  .attack(.8).release(1.6).room(.7).rsize(8).gain(.38).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, bajo, pianoRave, hook.gain(.65))
const dropA = stack(kickHard, hats16, openRave, clap, crash, bajo, sub,
  pianoRave, hook)
const dropAvar = stack(kickHard, hats16, openRave, clap, ride, bajo, sub,
  pianoRave, hook, hookAlta, pad.gain(.25))
const breakOh = stack(pad, pianoRave.gain(.5).room(.7),
  hook.gain(.55).room(.75), openRave.gain(.35), sub.gain(.35))
const breakBuild = stack(pad, pianoRave.gain(.6), hook.gain(.65),
  rodillo, hats16.gain(.4), openRave.gain(.4))
const dropHoover = stack(kickHard, hats16, openRave, clap, crash, hoover,
  sub, hook.gain(.6), pianoRave.gain(.5))
const dropHooverFull = stack(kickHard, hats16, openRave, clap, ride, hoover,
  sub, hook, hookAlta, pianoRave.gain(.6))
const dropFinal = stack(kickHard, hats16, openRave, clap, ride, crash, bajo,
  sub, pianoRave, hook.sometimesBy(.2, x=>x.add(note(12)).gain(.55)),
  hookAlta, pad.gain(.25))
const coda = stack(kick, hats, clap, bajo.gain(.7), pianoRave.gain(.45),
  hook.gain(.45).room(.6), pad)
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 · TR-909 · kick distorsionado + riff square + rodillos dobles
// 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) ──
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)

// ── HOOVER (stabs supersaw, el rugido rave) ──
const hoover = note("c3 ~ ~ c3 ~ eb3 ~ [f3 eb3]")
  .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) ──
const bajo = note("c2 c2 c2 [c2 eb2]")
  .s("sawtooth").lpf(600).lpq(6)
  .attack(.001).decay(.11).sustain(.35).release(.03)
  .shape(.4).gain(.9).orbit(1)

const sub = note("c1*4").s("sine").decay(.22).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA 909 GABBER (bombo con distorsión seria) ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).distort(1.2).gain(1)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const kickGabber = s("bd*4").bank("RolandTR909").shape(.6).distort(1.5).gain(1)
  .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0)
const kickDoble = s("bd*8").bank("RolandTR909").shape(.55).distort(1.3).gain(.9)
  .duck("1:2").duckattack(.08).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.6).pan(.6).orbit(0)
const hatsMachaca = s("hh*8").bank("RolandTR909")
  .gain("[.55 .35]*4").pan(.45).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").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)

// ── PAD OSCURO (tensión entre drops) ──
const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>")
  .s("supersaw").unison(4).spread(.7).lpf(850)
  .attack(.7).release(1.4).room(.6).rsize(7).gain(.35).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, bajo, riff.gain(.7), voz.gain(.4))
const dropA = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub,
  riff, hoover.gain(.5))
const dropAvar = stack(kickGabber, hatsMachaca, open, clap, bajo, sub,
  riff, riffAlta, voz, hoover.gain(.55))
const breakVoces = stack(pad, voz, riff.gain(.5).room(.5),
  hats.gain(.3), sub.gain(.35))
const breakBuild = stack(pad, voz, riff.gain(.65), rodilloDoble,
  hatsMachaca.gain(.4))
const dropGabber = stack(kickGabber, hatsMachaca, open, clap, crash, sub,
  hoover, riff, voz.gain(.4))
const dropGabberFull = stack(kickDoble, hatsMachaca, clap, sub,
  hoover, riff, riffAlta, voz)
const dropFinal = stack(kickGabber, hatsMachaca, open, clap, crash, bajo, sub,
  riff.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), riffAlta,
  hoover.gain(.5), rodilloDoble.degradeBy(.5).gain(.3))
const coda = stack(kick, hats, clap, bajo.gain(.7), riff.gain(.45),
  pad.gain(.3))
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 · TR-909 · piano italo protagonista + bajo octavador · claps brillantes
// 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)

// ── ACORDES ITALO (piano en offbeat, Am·F·C·G) ──
const acordes = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>")
  .struct("[~ x]*4")
  .s("piano").room(.4).rsize(4)
  .gain(.7).pan(.55).orbit(3)

// ── BAJO OCTAVADOR (corcheas saltando la octava) ──
const bajo = note("<[a1 a2 a1 a2 a1 a2 a1 a2] [f1 f2 f1 f2 f1 f2 f1 f2] [c2 c3 c2 c3 c2 c3 c2 c3] [g1 g2 g1 g2 g1 g2 g1 g2]>")
  .s("sawtooth").lpf(750).lpq(6)
  .attack(.001).decay(.12).sustain(.3).release(.04)
  .shape(.3).gain(.9).orbit(1)

const sub = note("<a1 f1 c2 g1>").struct("x*4")
  .s("sine").decay(.3).sustain(.25).gain(.6).orbit(1)

// ── BATERÍA 909 (brillante y bailonga) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909")
  .hpf(300).room(.35).gain(.8).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
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)

// ── PAD MEDITERRÁNEO (colchón cálido) ──
const pad = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>")
  .s("supersaw").unison(4).spread(.7).lpf(950)
  .attack(.8).release(1.6).room(.65).rsize(7).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introPiano = stack(kick, hats, clap.gain(.4), acordes.gain(.45),
  bajo.lpf(400).gain(.65))
const build = stack(kick, hats16, clap, bajo, acordes, pad.gain(.25),
  hookPiano.gain(.55))
const buildFin = stack(kickHard, rodillo, bajo, acordes, hookPiano.gain(.75))
const dropA = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  acordes, hookPiano)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  acordes, hookPiano, pad.gain(.25))
const breakPiano = stack(pad, hookPiano.gain(.7).room(.75),
  acordes.gain(.5).room(.6), sub.gain(.35))
const breakBuild = stack(pad, hookPiano.gain(.8), acordes.gain(.55),
  rodillo, hats16.gain(.4))
const dropSaw = stack(kickHard, hats16, open, clap, crash, bajo, sub,
  acordes.gain(.5), hookSaw)
const dropSawFull = stack(kickHard, hats16, open, clap, ride, bajo, sub,
  acordes, hookSaw, hookPiano.gain(.5), pad.gain(.25))
const dropFinal = stack(kickHard, hats16, open, clap, ride, crash, bajo, sub,
  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)
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 · TR-909 + piano · LA joya dream: piano solo→drops elegantes→coda
// 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)

// ── ACORDES DE PIANO (Am·F·C·G, la mano izquierda del sueño) ──
const pianoAcordes = note("<[a2,e3,a3] [f2,c3,f3] [c3,g3,c4] [g2,d3,g3]>")
  .s("piano").room(.8).rsize(8)
  .gain(.7).pan(.45).orbit(4)

// ── BAJO ROLLING SUAVE (16avos redondos, progresión Am·F·C·G) ──
const bajo = note("<a1 f1 c2 g1>").struct("x*16")
  .s("sawtooth").lpf(500).lpq(4)
  .attack(.001).decay(.11).sustain(.25).release(.03)
  .gain("[.8 .5 .6 .5]*4").shape(.2).orbit(1)

const sub = note("<a1 f1 c2 g1>").struct("x*4")
  .s("sine").decay(.3).sustain(.3).gain(.6).orbit(1)

// ── BATERÍA 909 (elegante, nunca agresiva) ──
const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.65).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.45 .22 .32 .22]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
const 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)

// ── CUERDAS (el colchón que llora detrás del piano) ──
const cuerdas = note("<[a2,c3,e3] [f2,a2,c3] [c3,e3,g3] [g2,b2,d3]>")
  .s("supersaw").unison(5).spread(.8).lpf(sine.slow(32).range(500,1400))
  .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)

// ── SECCIONES ──
const pianoSolo = stack(melodia, pianoAcordes)
const pianoPads = stack(melodia, pianoAcordes, cuerdas.gain(.3), viento)
const entraKick = stack(kick, hats, melodia.gain(.7), pianoAcordes.gain(.5),
  sub.gain(.4))
const build = stack(kick, hats16, clap, bajo, melodia.gain(.75),
  cuerdas.gain(.3), sub.gain(.5))
const buildFin = stack(kick, rodillo, bajo, melodia.gain(.85), cuerdas.gain(.35))
const dropA = stack(kick, hats16, open, clap, crash, bajo, sub,
  melodia, melodiaSinte.gain(.4))
const dropAvar = stack(kick, hats16, open, clap, ride, bajo, sub,
  melodia, melodiaSinte, cuerdas.gain(.3))
const breakCentral = stack(melodia, pianoAcordes, cuerdas, viento, sub.gain(.3))
const breakBuild = stack(melodia, pianoAcordes.gain(.5), cuerdas,
  rodillo, hats16.gain(.35))
const dropB = stack(kick, hats16, open, clap, crash, bajo, sub,
  melodia, melodiaSinte, cuerdas.gain(.35))
const dropBvar = stack(kick, hats16, open, clap, ride, bajo, sub,
  melodia, melodiaSinte.sometimesBy(.2, x=>x.add(note(12)).gain(.35)),
  cuerdas.gain(.4), pianoAcordes.gain(.4))
const bajada = stack(kick, hats, bajo.gain(.6), melodia.gain(.8),
  pianoAcordes.gain(.5), cuerdas.gain(.35))
const codaPiano = stack(melodia, pianoAcordes, cuerdas.gain(.25))
const 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 · TR-909 · el arpegio abre su filtro durante TODO el track
// 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)

// ── BAJO (corcheas de raíz que siguen la armonía F#m→D→E) ──
const bajo = note("fs1!8").add(note("<0 0 -4 -2>"))
  .s("sawtooth").lpf(perlin.slow(8).range(400, 900)).lpq(6)
  .attack(.001).decay(.18).sustain(.25).release(.05)
  .shape(.3).gain(.85).orbit(1)

const bajoSub = note("fs1*4").s("sine").decay(.35).sustain(.2).gain(.7).orbit(1)

// ── BATERÍA 909 (sidechain sobre bajo y lead) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.28).pan(.4).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)

// ── PADS ÉPICOS ──
const pad = note("<[fs3,a3,cs4] [fs3,a3,cs4] [d3,fs3,a3] [e3,gs3,b3]>")
  .s("sawtooth").lpf(750).attack(.9).release(1.6)
  .room(.8).rsize(8).gain(.4).orbit(4)

const cuerdas = note("<fs4 fs4 d4 e4>").s("supersaw").unison(6).spread(.8)
  .lpf(sine.slow(32).range(500, 2400)).attack(.6).release(1)
  .room(.7).gain(.32).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introArp = stack(kick, hats, bajoSub.gain(.5), arpegio.gain(.6))
const build = stack(kick, hats16, clap, bajoSub, arpegio, pad)
const buildFin = stack(kickHard, rodillo, arpegio, hook.gain(.5).lpf(1500))
const dropA = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio, hook)
const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajo, bajoSub, arpegio,
  hook, hookEco, cuerdas.gain(.24))
const breakdown = stack(arpegio.gain(.65).room(.6), pad, cuerdas)
const breakBuild = stack(arpegio, arpegioAlto, pad, cuerdas, rodillo, hats16.gain(.4))
const dropEpic = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub,
  arpegio, arpegioAlto, hook)
const dropEpicFull = stack(kickHard, hats16, hatsOpen, clap, ride, bajo, bajoSub,
  arpegio, arpegioAlto, hook, hookEco, cuerdas.gain(.26))
const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  arpegio, hook, cuerdas.gain(.24))
const coda = stack(kick, hats, arpegio.gain(.55), pad, hook.gain(.4).room(.8))
const 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 · TR-909 · pluck metralleta + bajo offbeat + doble drop con ride
// 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)

// ── BAJO OFFBEAT (hard trance clásico) ──
const bajoOff = note("[~ b1]*4").s("sawtooth").lpf(760).lpq(5)
  .attack(.001).decay(.16).sustain(.2).release(.04)
  .shape(.35).gain(.9).orbit(1)

const bajoSub = note("b1*4").s("sine").decay(.3).sustain(.15).gain(.6).orbit(1)

// ── BATERÍA 909 DURA ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.35).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.3,.7)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.5).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.32).pan(.35).orbit(0)
const 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)

// ── PAD DE FONDO (Bm→G→A) ──
const pad = note("<[b2,d3,fs3] [g2,b2,d3] [a2,cs3,e3] [b2,d3,fs3]>")
  .s("sawtooth").lpf(700).attack(.8).release(1.4)
  .room(.6).rsize(6).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(450).gain(.7))
const build = stack(kick, hats16, clap, bajoOff, riffGrave, pad.gain(.3))
const buildFin = stack(kickHard, rodillo, bajoOff, riff.gain(.7))
const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff)
const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub, riff,
  riffAlto, crash)
const breakdown = stack(pad, riff.gain(.55).room(.7).delayfeedback(.55), hats.gain(.3))
const breakBuild = stack(pad, riff.gain(.75), rodilloLargo, hats16.gain(.4),
  bajoSub.gain(.4))
const dropB = stack(kickHard, hats16, hatsOpen, clap, ride, bajoOff, bajoSub,
  riff, riffAlto)
const dropBfull = stack(kickHard, hats16, hatsOpen, clap, ride, crash, bajoOff,
  bajoSub, riff, riffAlto, pad.gain(.25))
const dropFinal = stack(kickHard, hats16, hatsOpen, clap, ride,
  bajoOff.sometimesBy(.2, x=>x.add(note(12)).gain(.55)), bajoSub, riff, riffAlto)
const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), riff.gain(.5).room(.6), pad)
const 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 · TR-909 · lead vocoder con vowel + bajo octavado eurodance
// 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)

// ── 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) ──
const bajo = note("[g1 g2 g1 g2]*2").add(note("<0 0 -4 -2>"))
  .s("sawtooth").lpf(820).lpq(5)
  .attack(.001).decay(.14).sustain(.3).release(.04)
  .shape(.3).gain(.9).orbit(1)

const bajoSub = note("g1*4").add(note("<0 0 -4 -2>")).s("sine")
  .decay(.3).sustain(.2).gain(.65).orbit(1)

// ── BATERÍA 909 (claps dobles, energía pop) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickDoble = s("<[bd*4] [bd*4] [bd*4] [bd bd bd [bd bd]]>").bank("RolandTR909")
  .shape(.5).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clapDoble = s("~ cp ~ [cp cp]").bank("RolandTR909").room(.3).gain(.72).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)

// ── PADS BRILLANTES ──
const pad = note("<[g3,bb3,d4] [g3,bb3,d4] [eb3,g3,bb3] [f3,a3,c4]>")
  .s("supersaw").unison(5).spread(.7)
  .lpf(sine.slow(16).range(600, 2200)).attack(.5).release(1)
  .room(.6).rsize(6).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatsOpen, riff.gain(.4), bajo.lpf(400).gain(.6))
const build = stack(kick, hats16, clapDoble, bajo, riff,
  hook.lpf(saw.slow(16).range(400, 2600)).gain(.55))
const buildFin = stack(kickDoble, rodillo, bajo, hook.gain(.65))
const dropA = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub, hook, riff)
const dropAvar = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
  hook, hookOctava, riff, pad.gain(.25))
const breakdown = stack(pad, hook.gain(.6).room(.75), bajoSub.gain(.35), hats.gain(.3))
const breakBuild = stack(pad, hook.gain(.75), riff.gain(.5), rodillo, hats16.gain(.4))
const dropB = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
  hook, hookOctava, riff)
const dropBfull = stack(kickDoble, hats16, hatsOpen, clapDoble,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  hook, hookOctava, riff, pad.gain(.28))
const dropFinal = stack(kickDoble, hats16, hatsOpen, clapDoble, bajo, bajoSub,
  hook, hookOctava, pad.gain(.25))
const coda = stack(kick, hats, bajo.lpf(550).gain(.7), hook.gain(.45).room(.7), pad)
const 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 · TR-909 · pluck ping-pong + pausas dramáticas + supersaw
// 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)

// ── BAJOS (offbeat en el drop A, rolling en el drop B; F#m→D→A→E) ──
const bajoOff = note("[~ fs1]*4").add(note("<0 -4 3 -2>"))
  .s("sawtooth").lpf(720).lpq(5)
  .attack(.001).decay(.15).sustain(.2).release(.04)
  .shape(.35).gain(.88).orbit(1)
const bajoRoll = note("fs1*16").add(note("<0 -4 3 -2>"))
  .s("sawtooth").lpf(850).lpq(6)
  .attack(.001).decay(.1).sustain(.15).release(.03)
  .shape(.3).gain("[.85 .45 .6 .45]*4").orbit(1)
const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine")
  .decay(.3).sustain(.15).gain(.6).orbit(1)

// ── BATERÍA 909 ──
const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08)
  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.52 .25 .38 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.88)).speed(saw.slow(4).range(1,1.45)).orbit(0)

// ── PADS ──
const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
  .s("sawtooth").lpf(720).attack(.8).release(1.5)
  .room(.7).rsize(7).gain(.38).orbit(4)

// ── SECCIONES (la PAUSA deja el pluck solo, flotando antes del drop) ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatsOpen, clap.gain(.5), bajoOff.lpf(420).gain(.65))
const pluckSolo = stack(pluck, kick.gain(.9), hats.gain(.4))
const build = stack(kick, hats16, clap, bajoOff, pluck, pad.gain(.3))
const pausa = stack(pluck.gain(.95).room(.7).delayfeedback(.6), silence)
const dropA = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub,
  pluck, pluckOctava)
const dropAvar = stack(kickHard, hats16, hatsOpen, clap, bajoOff, bajoSub,
  pluck, pluckOctava, pad.gain(.25))
const breakdown = stack(pad, pluck.gain(.6).room(.7), bajoSub.gain(.3), hats.gain(.3))
const breakBuild = stack(pad, pluck, rodillo, hats16.gain(.4))
const dropB = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub,
  pluck, superLead)
const dropBfull = stack(kickHard, hats16, hatsOpen, clap, bajoRoll, bajoSub,
  pluck, pluckOctava, superLead, pad.gain(.25))
const coda = stack(kick, hats, bajoOff.lpf(500).gain(.7), pluck.gain(.5).room(.6), pad)
const 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 · TR-909 · lead celestial 16 compases → kick brutal SIN bajo + toms
// 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)

// ── PADS ELÉCTRICOS ENORMES (E→A→B) ──
const pad = note("<[e3,gs3,b3] [e3,gs3,b3] [a3,cs4,e4] [b3,ds4,fs4]>")
  .s("supersaw").unison(6).spread(.85)
  .lpf(sine.slow(32).range(500, 2000)).attack(1).release(2)
  .room(.9).rsize(9).gain(.4).orbit(4)

// ── BATERÍA (distorsión creciente, toms marciales, SIN bajo: bombo+lead) ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.1)
  .duck("2:4").duckattack(.1).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.3).gain(1.1)
  .duck("2:4").duckattack(.1).duckdepth(.6).orbit(0)
const kickBrutal = s("bd*4").bank("RolandTR909").shape(.65).distort(1.6).gain(1.1)
  .duck("2:4").duckattack(.1).duckdepth(.65).orbit(0)
const snare = s("~ sd ~ sd").bank("RolandTR909").shape(.3).room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .22 .35 .22]*4").pan(rand.range(.3,.7)).orbit(0)
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)

// ── SECCIONES ──
const leadSolo = stack(lead.gain(.85), silence)
const leadCoro = stack(lead.gain(.85), leadOctava, pad.gain(.3))
const kickEntra = stack(kick, lead.gain(.7), hats.gain(.35))
const kickLead = stack(kick, hats, snare.gain(.5), lead, leadGrave.gain(.3))
const tomsBuild = stack(kickHard, tomsMarcial, rodillo, lead.gain(.65))
const dropA = stack(kickHard, hats16, snare, tomsMarcial, lead, leadGrave)
const dropAvar = stack(kickHard, hats16, snare, tomsMarcial, crash,
  lead, leadOctava, leadGrave)
const breakdown = stack(pad, lead.gain(.6), hats.gain(.25))
const breakBuild = stack(pad, lead.gain(.8), leadOctava, rodillo, hats16.gain(.35))
const dropB = stack(kickBrutal, hats16, snare, tomsFuria, lead, leadGrave)
const dropBfull = stack(kickBrutal, hats16, snare, tomsFuria, crash,
  lead, leadOctava, leadGrave, pad.gain(.25))
const coda = stack(kick, hats, lead.gain(.55).room(.9), pad)
const 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 · TR-909 · stabs FM metálicos + corte hpf + acid suave al final
// 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)

// ── EL BAJO (groove noventero exacto) ──
const bajo = note("c2 ~ c2 c2 ~ c2 eb2 f2")
  .s("sawtooth").lpf(830).lpq(6)
  .attack(.001).decay(.13).sustain(.2).release(.04)
  .shape(.35).gain(.92).orbit(1)

const bajoSub = note("c1*4").s("sine").decay(.3).sustain(.2).gain(.65).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)

// ── BATERÍA 909 CON GROOVE (swing sutil + rim fantasma) ──
const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.28).gain(.72).orbit(0)
const rim = s("[~ rim]*4").bank("RolandTR909").gain(rand.range(.2,.45)).pan(.3).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909").swingBy(.06, 8)
  .gain("[.5 .25 .36 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.48).orbit(0)
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 (Cm→Ab→Bb) ──
const pad = note("<[c3,eb3,g3] [c3,eb3,g3] [ab2,c3,eb3] [bb2,d3,f3]>")
  .s("sawtooth").lpf(700).attack(.8).release(1.5)
  .room(.65).rsize(6).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatsOpen, rim.gain(.3), bajo.lpf(420).gain(.65))
const build = stack(kick, hats16, clap, bajo, riffApoyo,
  riff.lpf(saw.slow(16).range(400, 2500)).gain(.55))
const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65))
const dropA = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub, riff)
const dropAvar = stack(kickHard, hats16, hatsOpen, clap, rim, bajo, bajoSub,
  riff, riffApoyo, pad.gain(.24))
const breakHpf = stack(riffHpf, pad, hats.gain(.3), clap.gain(.4))
const breakBuild = stack(riffHpf.gain(.75), pad, rodillo, hats16.gain(.4),
  bajoSub.gain(.4))
const dropAcid = stack(kickHard, hats16, hatsOpen, clap, acid, bajoSub,
  riff.gain(.6))
const dropAcidFull = stack(kickHard, hats16, hatsOpen, clap, rim, acid,
  bajo, bajoSub, riff, pad.gain(.24))
const dropFinal = stack(kickHard, hats16, hatsOpen, clap, rim,
  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
  riff, riffApoyo, acid.gain(.5))
const coda = stack(kick, hats, bajo.lpf(500).gain(.7), riff.gain(.5).room(.6), pad)
const 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 · TR-909 · muro de power chords + snare metálica + reese
// 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)

// ── REESE INDUSTRIAL (supersaw desafinado grave) ──
const reese = note("<f1 f1 ab1 db1>")
  .s("supersaw").unison(3).detune(.5).spread(.9)
  .lpf(520).attack(.04).decay(.3).sustain(.75).release(.2)
  .shape(.2).gain(.75).orbit(1)

const bajoSub = note("f1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1)

// ── BATERÍA INDUSTRIAL (kick distorsionado + snare de chatarra) ──
const kick = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.1)
  .duck("1:3").duckattack(.1).duckdepth(.55).orbit(0)
const kickBrutal = s("<[bd*4] [bd*4] [bd [bd bd] bd bd] [bd*4]>").bank("RolandTR909")
  .shape(.65).distort(1.45).gain(1.1)
  .duck("1:3").duckattack(.1).duckdepth(.65).orbit(0)
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)
  .gain("[.5 .28]*4").pan(rand.range(.3,.7)).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909").crush(8)
  .gain("[.5 .22 .35 .22]*4").orbit(0)
const 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)

// ── PAD OSCURO ──
const pad = note("<[f2,ab2,c3] [f2,ab2,c3] [ab2,c3,eb3] [db3,f3,ab3]>")
  .s("sawtooth").lpf(600).attack(1).release(1.8)
  .room(.8).rsize(8).gain(.35).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hatsInd.gain(.35), bajoSub.gain(.4))
const introB = stack(kick, hatsInd, clap.gain(.45), chords.lpf(500).gain(.55))
const build = stack(kick, hats16, clap, reese,
  chords.lpf(saw.slow(16).range(500, 2400)))
const buildFin = stack(kickBrutal, rodillo, reese, chords)
const dropA = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub, chords)
const dropAvar = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
  chords, chordsAlto, voz.gain(.4))
const breakSusurro = stack(pad, voz, vozOctava, bajoSub.gain(.3), hatsInd.gain(.25))
const breakBuild = stack(pad, voz, chords.gain(.55).lpf(1200), rodillo,
  hats16.gain(.35))
const dropB = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
  chords, voz.gain(.5))
const dropBfull = stack(kickBrutal, hats16, snareMetal, clap, reese, bajoSub,
  chords, chordsAlto, voz, pad.gain(.25))
const dropFinal = stack(kickBrutal, hats16, snareMetal, clap,
  reese.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
  chords, chordsAlto)
const coda = stack(kick, hatsInd, chords.gain(.5).lpf(900), voz.gain(.5), pad)
const 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 · TR-808 · trompeta telefónica (square+crush) + electro roto
// 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)

// ── BAJO ELECTRO SINCOPADO ──
const bajo = note("d2 ~ [~ d2] a1")
  .s("sawtooth").coarse(2).lpf(700).lpq(5)
  .attack(.001).decay(.14).sustain(.2).release(.04)
  .shape(.3).gain(.9).orbit(1)

const bajoVar = note("d2 ~ [~ d2] [a1 c2]")
  .s("sawtooth").coarse(2).lpf(750).lpq(5)
  .attack(.001).decay(.14).sustain(.2).release(.04)
  .shape(.3).gain(.9).orbit(1)

const bajoSub = note("d1*4").s("sine").decay(.3).sustain(.18).gain(.55).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 (patrón roto, nada de 4x4) ──
const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0)
const snare = s("~ ~ sd ~ ~ ~ sd ~").bank("RolandTR808").gain(.8).orbit(0)
const rimGhost = s("[~ rim]*4").bank("RolandTR808")
  .gain(rand.range(.15,.4)).pan(rand.range(.3,.7)).orbit(0)
const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").crush(8).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR808")
  .gain("[.45 .2 .3 .2]*4").crush(8).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0)
const toms = s("~ ~ ~ ~ ~ ~ [mt lt] ~").bank("RolandTR808").gain(.55).pan(.35).orbit(0)

// ── PAD MINIMAL ──
const pad = note("<[d3,f3,a3] [d3,f3,a3] [bb2,d3,f3] [a2,c3,e3]>")
  .s("sawtooth").lpf(550).attack(1).release(1.6)
  .room(.6).rsize(6).gain(.32).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, snare.gain(.5), hats, bajo.lpf(400).gain(.6))
const build = stack(kick, snare, hats16, rimGhost, bajo,
  trompeta.lpf(saw.slow(16).range(500, 2100)).gain(.55))
const dropA = stack(kick, snare, hats, hatsOpen, rimGhost, bajo, bajoSub, trompeta)
const dropAvar = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
  bajoVar, bajoSub, trompeta, trompetaBaja)
const breakRobot = stack(pad, robot, piano, trompeta.gain(.5).room(.6),
  hats.gain(.25))
const breakBuild = stack(pad, trompeta.gain(.7), robot, hats16.gain(.35),
  bajo.gain(.6))
const dropB = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
  bajo, bajoSub, trompeta, robot.gain(.35))
const dropBfull = stack(kick, snare, hats16, hatsOpen, rimGhost, toms,
  bajoVar, bajoSub, trompeta, trompetaBaja, piano.gain(.3))
const coda = stack(kick, hats, bajo.lpf(450).gain(.65),
  trompeta.gain(.45).room(.6), pad)
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 · TR-909 · el bajo es el rey · todo respira con el filtro lento
// Estructura: intro→build→drop A→break filtrado→drop B→coda (144 compases ≈ 4:46)
// ════════════════════════════════════════════════════════════════
setcps(121/60/4)

// ── EL BAJO REY (línea exacta, filter house francés) ──
const bajo = note("a1 a2 g2 a2 e2 g2 a1 ~")
  .s("sawtooth").lpf(sine.slow(32).range(320, 1700)).lpq(6)
  .attack(.001).decay(.2).sustain(.35).release(.05)
  .shape(.3).gain(.95).orbit(1)

const bajoSub = note("a1*4").s("sine").decay(.3).sustain(.2).gain(.55).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)

// ── STAB FUNKY (acorde filtrado, discoteca francesa) ──
const stab = note("~ [a3,c4,e4] ~ [a3,c4,e4] ~ ~ [g3,b3,d4] ~")
  .s("sawtooth").lpf(sine.slow(16).range(500, 2200)).lpq(7)
  .attack(.002).decay(.14).sustain(.05).release(.05)
  .phaser(2).phaserdepth(.5)
  .gain(.55).pan(.4).orbit(3)

// ── BATERÍA FRANCESA (hats con phaser, groove disco) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.13).duckdepth(.6).orbit(0)
const kickFuerte = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.08)
  .duck("1:2").duckattack(.13).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.7).orbit(0)
const hatsPhaser = s("[~ hh]*4").bank("RolandTR909")
  .phaser(4).phaserdepth(.7).gain(.55).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .38 .25]*4").phaser(2).phaserdepth(.5)
  .pan(rand.range(.35,.65)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").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)

// ── PAD QUE RESPIRA (Am→G→F→G) ──
const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>")
  .s("sawtooth").lpf(sine.slow(32).range(400, 1200)).attack(.9).release(1.6)
  .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),
  bajo.lpf(sine.slow(32).range(250, 700)).gain(.7))
const build = stack(kick, hats16, clap, bajo, stab.gain(.4),
  vocoder.lpf(saw.slow(16).range(400, 2200)).gain(.5))
const buildFin = stack(kickFuerte, rodillo, bajo, vocoder.gain(.6))
const dropA = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub, vocoder, stab)
const dropAvar = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
  vocoder, vocoderAlto, stab, pad.gain(.24))
const breakFiltro = stack(bajo.lpf(sine.slow(8).range(200, 900)).gain(.85),
  vocoder.gain(.55).room(.6), pad, hatsPhaser.gain(.3))
const breakBuild = stack(bajo, vocoder.gain(.7), pad, rodillo, hats16.gain(.4))
const dropB = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
  vocoder, vocoderAlto, stab)
const dropBfull = stack(kickFuerte, hats16, hatsOpen, clap,
  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
  vocoder, vocoderAlto, stab, pad.gain(.26))
const dropFinal = stack(kickFuerte, hats16, hatsOpen, clap, bajo, bajoSub,
  vocoder, stab, pad.gain(.24))
const coda = stack(kick, hatsPhaser, bajo.gain(.8), vocoder.gain(.45).room(.7), pad)
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 · TR-909 · pluck-guitarra con pitch bend (penv) + bajo rolling
// 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)

// ── BAJO ROLLING SUAVE (16avos, sigue F#m→D→A→E) ──
const bajo = note("fs1*16").add(note("<0 -4 3 -2>"))
  .s("sawtooth").lpf(820).lpq(5)
  .attack(.001).decay(.09).sustain(.15).release(.03)
  .shape(.25).gain("[.8 .42 .58 .42]*4").orbit(1)

const bajoSub = note("fs1*4").add(note("<0 -4 3 -2>")).s("sine")
  .decay(.3).sustain(.18).gain(.6).orbit(1)

// ── BATERÍA 909 ELEGANTE (shaker agudo con pan aleatorio) ──
const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02)
  .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
const kickDrop = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.68).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.48 .22 .34 .22]*4").pan(rand.range(.35,.65)).orbit(0)
const hatsOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const 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)

// ── PADS FLOTANTES ──
const pad = note("<[fs3,a3,cs4] [d3,fs3,a3] [a3,cs4,e4] [e3,gs3,b3]>")
  .s("supersaw").unison(5).spread(.8)
  .lpf(sine.slow(32).range(500, 1900)).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), bajo.lpf(400).gain(.6))
const hookIntro = stack(kick, hats, bajoSub.gain(.5),
  hook.lpf(saw.slow(8).range(600, 3200)).gain(.6))
const build = stack(kick, hats16, clap, shaker.gain(.2), bajo, hook, pad.gain(.28))
const buildFin = stack(kickDrop, rodillo, bajo, hook.gain(.65))
const dropA = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub, hook)
const dropAvar = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub,
  hook, hookGrave, pad.gain(.26))
const breakFlotante = stack(pad, colchon, hookFlotante, bajoSub.gain(.3),
  hats.gain(.25))
const breakBuild = stack(pad, colchon, hook.gain(.75), rodillo, hats16.gain(.38))
const dropB = stack(kickDrop, hats16, hatsOpen, clap, shaker, bajo, bajoSub,
  hook, hookGrave)
const dropBfull = stack(kickDrop, hats16, hatsOpen, clap, shaker,
  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.45)), bajoSub,
  hook, hookGrave, pad.gain(.28), colchon.gain(.22))
const coda = stack(kick, hats, bajo.lpf(500).gain(.65), hook.gain(.5).room(.7), pad)
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 · TR-909 · piano offbeat + supersaw eufórica + doble clap
// 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)

// ── 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("<a1 f1 c2 g1>").s("sine")
  .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)

// ── BATERÍA 909 (kick duro, DOBLE clap, rodillos constantes) ──
const kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.6).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const dobleClap = s("~ [cp cp] ~ [cp cp]").bank("RolandTR909")
  .room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0)
const 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)

// ── PAD (colchón mayor eufórico) ──
const pad = note("<[a3,c4,e4] [f3,a3,c4] [c4,e4,g4] [g3,b3,d4]>")
  .s("sawtooth").lpf(800).attack(.6).release(1.2)
  .room(.7).rsize(7).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.35))
const introB = stack(kick, hats, open, dobleClap.gain(.4), bajo.lpf(500).gain(.7))
const build = stack(kick, hats16, dobleClap, bajo, piano,
  hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
const buildFin = stack(kickHard, rodillo, bajo, piano, hook.gain(.7))
const dropA = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava)
const dropAvar = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub, piano,
  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3))
const breakPiano = stack(piano.gain(.85).room(.6), pad, hook.gain(.5).room(.75),
  hats.gain(.3), bajoSub.gain(.35))
const breakBuild = stack(piano, pad, hook.gain(.7), rodilloCorto, kick.gain(.95), bajo)
const dropB = stack(kickHard, hats16, open, dobleClap, bajo, bajoSub, piano, hook, hookOctava, ride)
const dropBFull = stack(kickHard, hats16, open, dobleClap, ride, bajo, bajoSub,
  piano, hook, hookOctava, pad.gain(.35), rodillo.gain(.35))
const coda = stack(kick, hats, dobleClap.gain(.5), piano.gain(.6), hook.gain(.45).room(.7), pad)
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 · TR-808 · el bajo wah ES el track · groove roto y funky
// 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").s("sine").attack(.02).decay(.6).sustain(.35)
  .gain(.4).orbit(1)

// ── PERCUSIÓN 808 (mínima pero groovy: kick roto con huecos) ──
const kick = s("bd ~ [~ bd] ~ bd ~ ~ ~").bank("RolandTR808")
  .shape(.4).gain(1.05).duck("2:3").duckattack(.08).duckdepth(.4).orbit(0)
const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.7).orbit(0)
const ghost = s("[~ sd]*4").bank("RolandTR808").degradeBy(.7).gain(.25).hpf(300).orbit(0)
const hats = s("[~ hh] [hh ~] [~ hh] [hh hh]").bank("RolandTR808")
  .gain(.5).pan(.6).orbit(0)
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)

// ── SECCIONES ──
const intro = stack(kick, hats)
const introB = stack(kick, hats, snare, rim)
const bajoIn = stack(kick, hats, snare, bajo.lpf(sine.slow(4).range(80,500)).gain(.85))
const grooveA = stack(kick, hats, open, snare, ghost, bajo, sub)
const grooveStabs = stack(kick, hats, open, snare, ghost, rim, bajo, sub, stabs)
const soloBajo = stack(bajo.lpf(sine.slow(1).range(100,1400)).gain(1),
  hats.gain(.25), toms, sub)
const grooveB = stack(kick, hats, open, snare, ghost, bajo, sub, contra)
const grooveBFull = stack(kick, hats, open, snare, ghost, rim, toms,
  bajo, bajoOctava, sub, contra, stabs)
const breakFm = stack(stabs.gain(.7), contra.gain(.5).room(.7), hats.gain(.3), sub)
const grooveFinal = stack(kick, hats, open, snare, ghost, rim, bajo, bajoOctava, sub,
  contra.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), stabs)
const coda = stack(kick, hats, bajo.gain(.8), sub)
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 · TR-909 · el himno de estadio · multitud de ruido blanco
// 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)

// ── PIANO (para el breakdown de estadio) ──
const piano = melodia.s("piano").clip(.9).lpf(3000)
  .room(.6).rsize(6).gain(.85).orbit(3)

// ── BAJO (corcheas motrices en Em) ──
const bajo = note("e1!8").s("sawtooth")
  .lpf(perlin.slow(4).range(400,1000)).lpq(6)
  .attack(.001).decay(.12).sustain(.25).release(.04)
  .shape(.35).gain("[.95 .7]*4").orbit(1)
const sub = note("e1*4").s("sine").decay(.3).sustain(.2).gain(.6).orbit(1)

// ── 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 kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
const kickEnorme = s("bd*4").bank("RolandTR909").shape(.65).distort(1.3).gain(1.12)
  .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.55 .25 .4 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.45).orbit(0)
const 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)

// ── PAD (Em C Am B) ──
const pad = note("<[e3,g3,b3] [c3,e3,g3] [a2,c3,e3] [b2,d3,fs3]>")
  .s("sawtooth").lpf(700).attack(.7).release(1.4)
  .room(.7).rsize(8).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.4))
const introB = stack(kick, hats, clap, bajo.lpf(450).gain(.7))
const build = stack(kick, hats16, clap, bajo,
  leadSq.lpf(saw.slow(16).range(350,2800)).gain(.55))
const buildFin = stack(kickEnorme, rodillo, bajo, leadSq.gain(.75))
const dropA = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, multitud)
const dropAvar = stack(kickEnorme, hats16, open, clap, ride, tomsRave,
  bajo, sub, leadSq, leadSaw, leadOctava, multitud)
const breakPiano = stack(piano, pad, estadio, hats.gain(.3), sub.gain(.35))
const breakBuild = stack(piano, pad, rodillo, kick.gain(.95), bajo, estadio)
const dropB = stack(kickEnorme, hats16, open, clap, bajo, sub, leadSq, leadSaw, leadOctava)
const dropBFull = stack(kickEnorme, hats16, open, clap, ride, bajo, sub,
  leadSq, leadSaw, leadOctava, multitud, estadio)
const dropFinal = stack(kickEnorme, hats16, open, clap, ride, tomsRave, bajo, sub,
  leadSq.sometimesBy(.25, x=>x.add(note(12))), leadSaw, multitud, pad.gain(.3))
const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(600).gain(.7), piano.gain(.5), pad)
const 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 · TR-909 · la catedral trance · breakdown de 16 compases
// 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)

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

// ── BATERÍA 909 ──
const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .22 .38 .22]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0)
const 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)

// ── ATMÓSFERA (la catedral: reverbs enormes) ──
const pad = note("<[a2,c3,e3] [a2,c3,e3] [f2,a2,c3] [g2,b2,d3]>")
  .s("sawtooth").lpf(650).attack(.9).release(1.8)
  .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)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.35))
const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(400).gain(.65))
const arpIn = stack(kick, hats, clap, bajo, arpegio.lpf(saw.slow(16).range(500,3200)))
const build = stack(kick, hats16, clap, bajo, arpegio,
  melodia.lpf(saw.slow(8).range(300,2000)).gain(.5))
const buildFin = stack(kickHard, rodillo, bajo, arpegio, melodia.gain(.65))
const dropA = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodia)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio, melodia, cuerdas)
const breakdown = stack(melodiaFlotante, pad, arpegio.gain(.5).room(.7),
  cuerdas.gain(.3), sub.gain(.3))
const breakBuild = stack(melodiaFlotante, pad, arpegio, rodillo, hats16.gain(.4))
const dropB = stack(kickHard, hats16, open, clap, bajo, sub, arpegio, melodiaEpica, melodiaOctava)
const dropBFull = stack(kickHard, hats16, open, clap, ride, bajo, sub, arpegio,
  melodiaEpica, melodiaOctava, cuerdas)
const coda = stack(kick, hats, clap.gain(.5), bajo.lpf(550).gain(.7),
  arpegio.gain(.5), melodia.gain(.45).room(.75), pad)
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 · TR-909 · lead italo de sierra fina + piano marcato + optimismo total
// 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)

// ── BAJO QUE BAILA (el salto de octava italo) ──
const bajo = note("f1 f2 c2 f1").s("sawtooth")
  .lpf(850).lpq(4).attack(.001).decay(.2).sustain(.2).release(.04)
  .shape(.3).gain(.95).orbit(1)
const bajoBaile = bajo.ply(2).gain(.85)
const sub = note("f1*4").s("sine").decay(.3).sustain(.15).gain(.5).orbit(1)

// ── 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 kick = s("bd*4").bank("RolandTR909").shape(.45).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.58).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.62).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.58).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR909").gain(.42).orbit(0)
const 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)

// ── PAD (colchón mayor optimista) ──
const pad = note("<[f3,a3,c4] [bb2,d3,f3] [f3,a3,c4] [c3,e3,g3]>")
  .s("sawtooth").lpf(750).attack(.7).release(1.3)
  .room(.65).rsize(7).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, sub.gain(.35))
const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.7))
const build = stack(kick, hats16, clap, bajo, piano.gain(.55),
  hook.lpf(saw.slow(16).range(400,2600)).gain(.55))
const buildFin = stack(kickHard, rodillo, bajoBaile, hook.gain(.72))
const dropA = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava)
const dropAvar = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
  hook, hookOctava, pad.gain(.3))
const breakPiano = stack(piano, pad, hook.gain(.5).room(.7),
  hats.gain(.3), sub.gain(.35))
const breakBuild = stack(piano, pad, hook.gain(.7), rodillo, kick.gain(.95), bajo)
const dropB = stack(kickHard, hats16, open, clap, bajoBaile, sub, hook, hookOctava, piano.gain(.5))
const dropBFull = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
  hook, hookOctava, piano.gain(.55), pad.gain(.32))
const dropFinal = stack(kickHard, hats16, open, clap, ride, bajoBaile, sub,
  hook.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad.gain(.3), rodillo.gain(.3))
const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.8), piano.gain(.6),
  hook.gain(.45).room(.7), pad)
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 · TR-909 · todo el drop respira por lpf+hpf · hats con swing
// 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)

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

// ── BATERÍA 909 (hats con swing francés) ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.52).distort(1.08).gain(1.08)
  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.72).orbit(0)
const hatsSwing = s("hh*8").bank("RolandTR909").swingBy(1/6, 8)
  .gain("[.5 .3]*4").pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909").swingBy(1/8, 8)
  .gain("[.5 .22 .36 .22]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.42).orbit(0)
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)

// ── PAD CON PHASER (movimiento constante, D D Bm A) ──
const pad = note("<[d3,fs3,a3] [d3,fs3,a3] [b2,d3,fs3] [a2,cs3,e3]>")
  .s("sawtooth").lpf(900).attack(.5).release(1.2)
  .phaser(.5).phaserdepth(.75).room(.6).rsize(6).gain(.4).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hatsSwing, sub.gain(.35))
const introB = stack(kick, hatsSwing, clap, bajo.lpf(500).gain(.7))
const build = stack(kick, hats16, clap, bajo, pad,
  brass.lpf(saw.slow(16).range(400,2400)).gain(.55))
const buildFin = stack(kickHard, rodillo, bajo, brass.gain(.7))
const dropA = stack(kickHard, hats16, open, clap, sub,
  respira(stack(bajo, brass, brassOctava)))
const dropAfiltro = stack(kickHard, hats16, open, clap, ride, sub,
  respira(stack(bajo, brass, brassOctava, pad.gain(.3))))
const breakdown = stack(pad, brass.gain(.55).room(.75), hatsSwing.gain(.3), sub.gain(.35))
const breakBuild = stack(pad, brass.gain(.7), rodillo, hats16.gain(.4), bajo)
const dropB = stack(kickHard, hats16, open, clap, sub,
  respira(stack(bajo, brass.sometimesBy(.2, x=>x.add(note(12))), brassOctava)))
const dropBFull = stack(kickHard, hats16, open, clap, ride, sub,
  respira(stack(bajo, brass, brassOctava, pad.gain(.32))), rodillo.gain(.25))
const coda = stack(kick, hatsSwing, clap.gain(.5), bajo.lpf(600).gain(.7),
  brass.gain(.45).room(.7), pad)
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 · TR-808 · vocoder con vowel secuenciado + kick 3-3-2 + cortes stut
// 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))

// ── TALKBOX (FM + vibrato = la voz de goma) ──
const talkbox = note("<e3 ~ g3 ~>").s("sine").fm(5).fmh(1.98)
  .vib(5.5).vibmod(.5).attack(.05).release(.3)
  .lpf(1800).gain(.5).room(.4).orbit(3)

// ── BAJO ELECTRO PUNCHY (síncopa 3-3-2 pegada al kick) ──
const bajo = note("e1 ~ ~ e1 ~ ~ <e1 g1> ~")
  .s("square").lpf(700).lpq(8)
  .attack(.001).decay(.15).sustain(.1).release(.03)
  .shape(.4).gain(.95).orbit(1)
const sub = note("e1").s("sine").attack(.02).decay(.6).sustain(.3)
  .gain(.4).orbit(1)

// ── BATERÍA 808 ELECTRO (kick 3-3-2, clave de rim, toms de máquina) ──
const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808")
  .shape(.45).gain(1.06).duck("1:2").duckattack(.09).duckdepth(.5).orbit(0)
const kick4 = s("bd*4").bank("RolandTR808").shape(.5).gain(1.08)
  .duck("1:2").duckattack(.09).duckdepth(.55).orbit(0)
const snare = s("~ sd ~ sd").bank("RolandTR808").gain(.72).orbit(0)
const clave = s("[~ rim]*4").bank("RolandTR808").degradeBy(.4).gain(.4).pan(.3).orbit(0)
const hats = s("hh*8").bank("RolandTR808").gain("[.5 .25]*4").pan(.6).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR808").gain(.4).orbit(0)
const toms = s("~ ~ ~ ~ ~ ~ [ht mt] lt").bank("RolandTR808")
  .gain(.55).mask("<0 0 0 1>").orbit(0)

// ── PAD LO-FI (coarse = circuito viejo) ──
const pad = note("<[e3,g3,b3] [g3,b3,d4] [e3,g3,b3] [d3,fs3,a3]>")
  .s("sawtooth").lpf(800).coarse(3).attack(.5).release(1.1)
  .room(.55).rsize(6).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats)
const introB = stack(kick, hats, snare, clave)
const build = stack(kick, hats, snare, bajo,
  hook.lpf(saw.slow(16).range(400,2800)).gain(.55))
const buildFin = stack(kick4, hats, snare, bajo, hook.gain(.7), toms)
const dropA = stack(kick, hats, open, snare, clave, bajo, sub, hook, talkbox)
const dropAvar = stack(kick, hats, open, snare, clave, toms, bajo, sub,
  hook, hookRobot, talkbox)
const breakdown = stack(pad, talkbox.gain(.6), hook.slow(2).gain(.5).room(.65),
  hats.gain(.28), sub.gain(.35))
const breakBuild = stack(pad, hook.gain(.7), hats, snare.gain(.5), bajo)
const dropStut = stack(kick4, hats, open, snare, bajo, sub, hookStut, talkbox)
const dropStutFull = stack(kick4, hats, open, snare, clave, toms, bajo, sub,
  hookStut, hookRobot, talkbox, pad.gain(.3))
const coda = stack(kick, hats, snare.gain(.5), bajo.gain(.8), hook.gain(.5), sub)
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 · TR-909 · la-la-la nocturno + bajo disco en octavas + cuerdas staccato
// 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)

// ── BAJO DISCO EN OCTAVAS (Dm Dm Bb C) ──
const bajo = note("d2 d3 d2 d3 d2 d3 d2 d3").add(note("<0 0 -4 -2>"))
  .s("sawtooth").lpf(950).lpq(4)
  .attack(.001).decay(.14).sustain(.12).release(.03)
  .shape(.3).gain(.9).orbit(1)
const sub = note("d1!2").add(note("<0 0 8 10>")).s("sine")
  .attack(.02).decay(.5).sustain(.35).gain(.5).orbit(1)

// ── CUERDAS STACCATO (la elegancia oscura) ──
const cuerdas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>")
  .struct("~ x ~ x ~ ~ x ~").s("sawtooth").clip(.25)
  .attack(.005).release(.08).lpf(3200).hpf(280)
  .room(.35).gain(.6).orbit(3)
const cuerdasLargas = note("<[d4,f4,a4] [d4,f4,a4] [bb3,d4,f4] [c4,e4,g4]>")
  .s("sawtooth").lpf(1400).attack(.6).release(1.2)
  .room(.7).rsize(7).gain(.35).orbit(4)

// ── BATERÍA 909 (hats franceses: hpf alto + iter) ──
const kick = s("bd*4").bank("RolandTR909").shape(.42).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.1).gain(1.08)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0)
const hatsFr = s("hh*16").bank("RolandTR909").hpf(6000).iter(4)
  .gain("[.5 .2 .35 .2]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.26).pan(.38).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.35)).orbit(0)

// ── SECCIONES (la tensión crece sección a sección) ──
const intro = stack(kick, hats, sub.gain(.35))
const introB = stack(kick, hats, clap.gain(.5), bajo.lpf(450).gain(.65))
const groove = stack(kick, hatsFr, clap, bajo, cuerdas.gain(.4))
const build = stack(kick, hatsFr, clap, bajo, cuerdas,
  lalala.lpf(saw.slow(8).range(400,2600)).gain(.55))
const dropA = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, cuerdas)
const dropAvar = stack(kickHard, hatsFr, open, clap, ride, bajo, sub,
  lalala, lalalaEco, cuerdas)
const breakdown = stack(cuerdasLargas, lalala.slow(2).gain(.55).room(.75),
  hats.gain(.28), sub.gain(.35))
const breakBuild = stack(cuerdasLargas, lalala.gain(.7), rodillo,
  hatsFr.gain(.35), bajo)
const dropB = stack(kickHard, hatsFr, open, clap, bajo, sub, lalala, lalalaEco,
  cuerdas.hpf(saw.slow(32).range(280,1200)))
const dropBFull = stack(kickHard, hatsFr, open, clap, ride, bajo, sub,
  lalala.sometimesBy(.2, x=>x.add(note(12))), lalalaEco, cuerdas,
  cuerdasLargas.gain(.28), rodillo.gain(.25))
const coda = stack(kick, hats, clap.gain(.5), bajo.gain(.75),
  lalala.gain(.45).room(.7), cuerdasLargas)
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 · TR-909 · el zumbido serrado (crush+shape) + sidechain exagerado
// 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)

// ── SUB (la misma línea, una octava abajo en seno) ──
const sub = note("c1 ~ c1 eb1 ~ c1 f1 eb1").s("sine")
  .decay(.25).sustain(.2).gain(.65).orbit(1)

// ── BATERÍA 909 (sidechain exagerado: duckdepth .85) ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
  .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0)
const kickDemoledor = s("bd*4").bank("RolandTR909").shape(.65).distort(1.25).gain(1.12)
  .duck("1:2").duckattack(.15).duckdepth(.85).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.48).pan(.58).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.52 .24 .38 .24]*4").pan(rand.range(.4,.6)).orbit(0)
const open = s("~ ~ [~ oh] ~").bank("RolandTR909").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)

// ── PAD (respiro entre zumbidos) ──
const pad = note("[c3,eb3,g3]").s("supersaw").unison(5).spread(.6)
  .lpf(sine.slow(32).range(350,1600)).attack(.6).release(1.2)
  .room(.6).rsize(6).gain(.35).orbit(4)

// ── SECCIONES (los builds suben con hpf, el drop lo suelta todo) ──
const intro = stack(kick, hats, sub.gain(.35))
const introB = stack(kick, hats, clap.gain(.5), sub.gain(.5))
const riffIn = stack(kick, hats, clap, riff.lpf(sine.slow(8).range(200,900)).gain(.7))
const build = stack(kick, hats16, clap, riff.hpf(saw.slow(8).range(60,2400)), sub)
const buildFin = stack(kickDemoledor, rodillo,
  riff.hpf(saw.slow(4).range(200,3000)).gain(.8))
const dropA = stack(kickDemoledor, hats16, open, clap, riff, sub)
const dropAvar = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub)
const breakdown = stack(pad, riff.lpf(500).gain(.55).room(.6), hats.gain(.3), sub.gain(.3))
const breakBuild = stack(pad, riff.hpf(saw.slow(8).range(60,2800)).gain(.75),
  rodillo, hats16.gain(.4))
const dropB = stack(kickDemoledor, hats16, open, clap, riff, riffAlto, sub)
const dropBFull = stack(kickDemoledor, hats16, open, clap,
  riff.sometimesBy(.2, x=>x.add(note(12))), riffAlto, sub, pad.gain(.3))
const coda = stack(kick, hats, clap.gain(.5), riff.lpf(700).gain(.7), sub)
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 · TR-909 · sidechain EXTREMO (duckdepth .9): todo el track respira
// 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)

// ── BAJO PEGADO AL KICK (corcheas que el duck convierte en bomba) ──
const bajo = note("b1!8").add(note("<0 0 -2 -4>"))
  .s("sawtooth").lpf(800).lpq(5)
  .attack(.001).decay(.2).sustain(.35).release(.04)
  .shape(.4).gain(.95).orbit(1)
const sub = note("<b1 b1 a1 g1>").s("sine")
  .attack(.02).decay(.5).sustain(.4).gain(.5).orbit(1)

// ── BATERÍA 909 (el kick manda: duckdepth .9, duckattack .2) ──
const kick = s("bd*4").bank("RolandTR909").shape(.5).gain(1.08)
  .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0)
const kickPump = s("bd*4").bank("RolandTR909").shape(.6).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.2).duckdepth(.9).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.7).orbit(0)
const hatsMin = s("[~ hh]*4").bank("RolandTR909").gain(.32).pan(.55).orbit(0)
const open = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.3).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.22).pan(.4).orbit(0)
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 CON PUMP FALSO (saw.fast(4) simula el sidechain en la órbita 4) ──
const pad = note("<[b2,d3,fs3] [b2,d3,fs3] [a2,cs3,e3] [g2,b2,d3]>")
  .s("supersaw").unison(5).spread(.6).lpf(1000)
  .attack(.05).release(.6)
  .gain(saw.fast(4).range(.12,.45)).room(.5).rsize(5).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,
  hookStab.lpf(saw.slow(16).range(400,2400)).gain(.6))
const buildFin = stack(kickPump, rodillo, bajo, hookStab.gain(.75))
const dropA = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab)
const dropAvar = stack(kickPump, hatsMin, open, clap, bajo, sub,
  hookStab, hookOctava, pad)
const breakdown = stack(pad, hook.gain(.55).room(.7), hatsMin.gain(.25), sub.gain(.35))
const breakBuild = stack(pad, hookStab.gain(.7), rodillo, kick.gain(.95), bajo)
const dropB = stack(kickPump, hatsMin, open, clap, bajo, sub, hookStab, hookOctava)
const dropBFull = stack(kickPump, hatsMin, open, clap, ride, bajo, sub,
  hookStab.sometimesBy(.2, x=>x.add(note(12))), hookOctava, pad, rodillo.gain(.22))
const coda = stack(kick, hatsMin, clap.gain(.5), bajo.gain(.8),
  hook.gain(.45).room(.6), pad.gain(.3))
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 · TR-909 + east · los tambores SON el hook
// 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)

// ── BATERÍA 909 ──
const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.1).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.1).gain(1.1)
  .duck("1:2").duckattack(.1).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.2).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .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)

// ── BAJO PUNCHY (stabs sincopados, deja hueco a los tambores) ──
const bajo = note("d2 ~ ~ d2 ~ ~ d2 ~ d2 ~ ~ d2 ~ f2 e2 ~")
  .s("sawtooth").lpf(900).lpq(7).attack(.002).decay(.14).sustain(.15).release(.04)
  .shape(.35).gain(.9).orbit(1)
const bajoSub = note("d1 ~ d1 d1 ~ d1 ~ ~").s("sine")
  .decay(.25).sustain(.25).gain(.7).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)

// ── TEXTURA / DRONE OSCURO ──
const drone = note("[d2,a2,d3]").s("sawtooth").lpf(500)
  .attack(1.2).release(2).room(.7).rsize(7).gain(.35).orbit(4)

// ── SECCIONES ──
const introPerc = stack(kick, taikoA, hats)
const percDobla = stack(kick, taikoA, taikoB, hats, clap.gain(.45))
const tribalFull = stack(kick, taikoA, taikoB, taikoC, toms, hats16, clap)
const rodilloTom = stack(kickHard, tomsRodillo, taikoSolo.gain(.8))
const dropPerc = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap, bajo, bajoSub)
const dropMelodia = stack(kickHard, taikoA, taikoB, toms, hats16, clap, bajo, bajoSub,
  hook.lpf(saw.slow(16).range(400,1800)).gain(.6))
const breakTribal = stack(taikoSolo, toms.gain(.6), drone, bajoSub.gain(.35), shaker.gain(.5))
const buildTribal = stack(taikoSolo, tomsRodillo, hats16.gain(.4), drone,
  hook.gain(.5).room(.6))
const dropTotal = stack(kickHard, taikoA, taikoB, taikoC, toms, hats16, shaker, clap,
  bajo, bajoSub, hook, hookOctava)
const dropTotalVar = stack(kickHard, taikoA.sometimesBy(.25, x=>x.speed(1.3)), taikoB, taikoC,
  toms.every(4, x=>x.fast(2)), hats16, clap,
  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub, hook, hookOctava, drone)
const dropPercFin = stack(kickHard, taikoA, taikoB, taikoC, toms,
  tomsRodillo.degradeBy(.5).gain(.5), hats16, shaker, clap, bajo, bajoSub)
const coda = stack(kick, taikoA, hats, hook.gain(.4).room(.6), bajoSub.gain(.4))
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 · TR-909 · supersaw con portamento (penv) + FX espaciales
// 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)

// ── BAJO ROLLING (16avos con acentos, progresión Am→G→F) ──
const bajo = note("a1*16").add(note("<0 0 -2 -4>"))
  .s("sawtooth").lpf(perlin.slow(8).range(450,1100)).lpq(9)
  .attack(.001).decay(.09).sustain(.2).release(.03)
  .shape(.3).gain("[1 .55 .75 .55]*4").orbit(1)
const bajoSub = note("<a1 a1 g1 f1>").s("sine")
  .attack(.02).decay(.4).sustain(.5).gain(.6).orbit(1)

// ── BATERÍA 909 TRANCE ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.15).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.25).gain(.75).orbit(0)
const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0)
const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.4).orbit(0)
const rodillo = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.2,.85)).speed(saw.slow(4).range(1,1.4)).orbit(0)

// ── ATMÓSFERA CÓSMICA ──
const espacio = s("<space:1 space:3 space:0 space:4>").slow(2)
  .gain(.4).room(.8).rsize(8).lpf(3000)
  .pan(sine.slow(16).range(.2,.8)).orbit(4)
const pad = note("<[a2,c3,e3] [a2,c3,e3] [g2,b2,d3] [f2,a2,c3]>")
  .s("sawtooth").lpf(700).attack(.9).release(1.6)
  .room(.7).rsize(7).gain(.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,
  riff.lpf(saw.slow(16).range(350,2200)).gain(.55))
const buildFin = stack(kickHard, rodillo, bajo, riff.gain(.65))
const dropA = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub, riff)
const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub,
  riff, riffOctava)
const breakCosmos = stack(espacio, pad, riffCosmico.gain(.6),
  bajoSub.gain(.35), hats.gain(.25))
const breakBuild = stack(espacio.gain(.3), pad, riffCosmico.gain(.7),
  rodillo, hats16.gain(.4))
const dropDelay = stack(kickHard, hats16, hatsOff, clap, bajo, bajoSub,
  riffCosmico.gain(.75))
const dropTotal = stack(kickHard, hats16, hatsOff, clap, ride, bajo, bajoSub,
  riff, riffOctava, pad.gain(.3))
const dropTotalVar = stack(kickHard, hats16, hatsOff, clap, ride,
  bajo.sometimesBy(.3, x=>x.add(note(12)).gain(.5)), bajoSub,
  riff.every(4, x=>x.iter(4)), riffOctava, espacio.gain(.25))
const coda = stack(kick, hats, bajo.lpf(550).gain(.7),
  riff.gain(.45).room(.7), pad)
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 · TR-909 · filtros que respiran + swing suave y elegante
// 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)

// ── STABS DE ACORDE (a contratiempo, como el sample original) ──
const stabs = note("~ [fs3,a3,cs4,e4] ~ [fs3,a3,cs4,e4]")
  .s("sawtooth").lpf(1500).attack(.005).decay(.15).sustain(0).release(.08)
  .hpf(300).room(.3).rsize(3).gain(.55)
  .phaser(.3).phaserdepth(.3).orbit(3)

// ── BAJO DISCO CON OCTAVAS (progresión F#m→F#m→A→B) ──
const bajo = note("fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2] fs1 [~ fs2]")
  .add(note("<0 0 3 5>"))
  .s("sawtooth").lpf(750).lpq(4).attack(.003).decay(.16).sustain(.3).release(.05)
  .shape(.2).gain(.9).swingBy(.06, 8).orbit(1)
const bajoSub = note("<fs1 fs1 a1 b1>").s("sine")
  .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1)

// ── BATERÍA 909 CÁLIDA CON SWING ──
const kick = s("bd*4").bank("RolandTR909").shape(.25).gain(1)
  .duck("1:2").duckattack(.13).duckdepth(.45).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(3).gain(.7).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).swingBy(.08, 8).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.4 .18 .28 .18]*4").swingBy(.08, 8).pan(rand.range(.4,.6)).orbit(0)
const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.4).orbit(0)
const rimGroove = s("~ ~ rim ~ ~ rim ~ ~").bank("LinnDrum")
  .gain(.4).swingBy(.08, 8).pan(.35).orbit(0)

// ── PAD SUAVE (strings de terciopelo) ──
const pad = note("[fs3,a3,cs4]").add(note("<0 0 3 5>"))
  .s("supersaw").unison(4).spread(.5)
  .lpf(sine.slow(24).range(400,1400)).attack(.7).release(1.2)
  .room(.6).rsize(6).gain(.32).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, hatOpen, clap.gain(.4), bajo.lpf(450).gain(.65))
const groove = stack(kick, hats, hats16, clap, rimGroove, bajo,
  riffRespira.gain(.6))
const grooveFin = stack(kick, hats16, clap, bajo,
  riff.hpf(saw.slow(4).range(40,900)).gain(.7))
const dropFiltrado = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
  bajo, bajoSub, riffRespira, stabs.gain(.4))
const dropFunk = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
  bajo, bajoSub, riff, stabs, riffOctava)
const breakSedoso = stack(pad, riff.gain(.5).room(.6).lpf(900),
  hats.gain(.3), bajoSub.gain(.35), rimGroove.gain(.25))
const breakBuild = stack(pad, riffRespira.gain(.7), stabs.gain(.4),
  hats16.gain(.35), bajo.lpf(500).gain(.6))
const dropAbierto = stack(kick, hats, hats16, hatOpen, clap, rimGroove,
  bajo, bajoSub, riff.lpf(2600), stabs, riffOctava, pad.gain(.22))
const dropAbiertoVar = stack(kick, hats16, hatOpen, clap, rimGroove,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  riff.every(4, x=>x.rev()), stabs, riffOctava, pad.gain(.22))
const 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)
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 · TR-808 · bajazo + risa maníaca (white+vowel+stut) · oscuro y chulesco
// 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) ──
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)

// ── BEAT 808 HIP-HOP-TECHNO (bombo con huecos, tresillo 3-3-2) ──
const kick = s("bd ~ ~ bd ~ ~ bd ~").bank("RolandTR808").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.08).duckdepth(.45).orbit(0)
const kickDuro = s("bd ~ [~ bd] bd ~ ~ bd ~").bank("RolandTR808")
  .shape(.5).distort(1.05).gain(1.1)
  .duck("1:2").duckattack(.08).duckdepth(.55).orbit(0)
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")
  .gain("[.5 .3]*4").sometimesBy(.15, x=>x.ply(2)).pan(.6).orbit(0)
const hatOpen = s("~ ~ [~ oh] ~").bank("RolandTR808").gain(.4).orbit(0)
const cowRim = s("~ ~ ~ rim").bank("RolandTR808").gain(.35).pan(.3).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)

// ── ATMÓSFERA OSCURA ──
const pad = note("[e2,g2,b2]").s("sawtooth").lpf(450)
  .attack(1.1).release(2).room(.65).rsize(7).gain(.35).orbit(4)
const viento = s("wind:2").slow(2).gain(.3).lpf(2000)
  .room(.7).rsize(8).pan(sine.slow(12).range(.3,.7)).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),
  bajo, risa.gain(.35))
const dropBajo = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim,
  bajo, bajoSub)
const dropBajoHook = stack(kickDuro, hats, hatOpen, snare, snareGhost,
  bajo, bajoSub, hook)
const breakRisa = stack(risa, viento, pad, bajoSub.gain(.35),
  hats.gain(.25), hook.gain(.4).room(.6))
const breakBuild = stack(risa.degradeBy(.15).gain(.6), pad,
  snareGhost.fast(2).gain(.35), bajo.lpf(500).gain(.7), hook.gain(.5))
const dropTotal = stack(kickDuro, hats, hatOpen, snare, snareGhost, cowRim,
  bajoSucio, bajoSub, hook, hookOctava)
const dropTotalVar = stack(kickDuro, hats, hatOpen, snare,
  bajoSucio.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  hook.every(4, x=>x.iter(4)), hookOctava, risa.degradeBy(.6).gain(.35))
const 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)
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 · TR-909 · riff masivo + multitud de estadio + rodillos militares
// 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)

// ── LA MULTITUD (oleadas de ruido blanco, estadio) ──
const multitud = s("white*2").attack(.35).decay(.6).sustain(.3).release(.5)
  .lpf(1500).hpf(300).gain(sine.slow(8).range(.12,.3))
  .pan(sine.slow(5).range(.3,.7)).room(.6).rsize(8).orbit(4)

// ── BATERÍA 909 MILITAR ──
const stomp = s("bd ~ bd ~").bank("RolandTR909").shape(.5).gain(1.1).orbit(0)
const stompClap = s("~ ~ cp ~").bank("RolandTR909").room(.4).rsize(5).gain(.8).orbit(0)
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
  .duck("1:2").duckattack(.12).duckdepth(.65).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.5).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
const sdGhost = s("sd(5,16,2)").bank("RolandTR909").gain(.28)
  .pan(rand.range(.3,.7)).orbit(0)
const rodilloMil = s("sd*16").bank("RolandTR909")
  .gain(saw.slow(4).range(.25,.9)).speed(saw.slow(4).range(1,1.3)).orbit(0)

// ── CUERDAS ÉPICAS (Em→Em→C→B) ──
const cuerdas = note("<[e3,g3,b3] [e3,g3,b3] [c3,g3,c4] [b2,ds3,fs3]>")
  .s("supersaw").unison(6).spread(.8)
  .lpf(sine.slow(32).range(400,2200)).attack(.5).release(1)
  .room(.6).rsize(7).gain(.38).orbit(4)

// ── SECCIONES ──
const introStomp = stack(stomp, stompClap, multitud)
const introRiff = stack(kick, hats, riff.lpf(500).gain(.6), multitud.gain(.15))
const build = stack(kick, hats16, clap, sdGhost, riff, riffSub.gain(.4),
  cuerdas.gain(.25))
const buildFin = stack(kickHard, rodilloMil, riff, riffLead.gain(.4))
const dropRiff = stack(kickHard, hats16, hats, clap, sdGhost,
  riff, riffSub)
const dropRiffVar = stack(kickHard, hats16, hats, clap, ride, sdGhost,
  riff, riffSub, riffLead.gain(.45), multitud.gain(.12))
const breakEstadio = stack(multitud.gain(.3), cuerdas,
  riffLead.gain(.55).room(.8), stomp.gain(.5), stompClap.gain(.5))
const breakBuild = stack(multitud.gain(.2), cuerdas, riff.lpf(800).gain(.7),
  rodilloMil, hats16.gain(.4))
const dropOctavas = stack(kickHard, hats16, hats, clap, sdGhost,
  riffOctavas, riffSub, riffLead.gain(.5))
const dropOctavasFull = stack(kickHard, hats16, hats, clap, ride, sdGhost,
  riffOctavas, riffSub, riffLead, cuerdas.gain(.28), multitud.gain(.12))
const dropFinal = stack(kickHard, hats16, hats, clap, ride,
  riffOctavas.sometimesBy(.2, x=>x.ply(2)), riffSub,
  riffLead.every(4, x=>x.add(note(12)).gain(.4)), cuerdas.gain(.3))
const coda = stack(kick, hats, clap, riff.lpf(700).gain(.7),
  riffSub.gain(.5), cuerdas, multitud.gain(.15))
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 · TR-909 · tipo Afterlife: supersaw suave + arpegio contrapunto
// 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)

// ── 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, progresión Am→Am→G→F) ──
const bajo = note("a1*8").add(note("<0 0 -2 -4>"))
  .s("sawtooth").lpf(600).lpq(6).attack(.002).decay(.14).sustain(.25).release(.04)
  .shape(.25).gain("[.9 .55]*4").orbit(1)
const bajoSub = note("<a1 a1 g1 f1>").s("sine")
  .attack(.05).decay(.5).sustain(.5).gain(.55).orbit(1)

// ── BATERÍA 909 ELEGANTE ──
const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.02)
  .duck("1:2").duckattack(.14).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.45).gain(1.08)
  .duck("1:2").duckattack(.14).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.65).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).pan(.6).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.42 .2 .3 .2]*4").pan(rand.range(.4,.6)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.25).pan(.35).orbit(0)
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 ──
const pad = note("<[a2,c3,e3,g3] [a2,c3,e3,g3] [g2,b2,d3,f3] [f2,a2,c3,e3]>")
  .s("sawtooth").lpf(550).attack(1).release(1.8)
  .room(.75).rsize(8).gain(.4).orbit(4)
const cuerdas = note("<a3 a3 g3 f3>").s("supersaw").unison(5).spread(.7)
  .lpf(sine.slow(32).range(350,1800)).attack(.6).release(1)
  .vib(4).vibmod(.15).room(.6).rsize(6).gain(.3).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, bajo, arpegio, hook.gain(.6))
const dropA = stack(kickHard, hats16, hats, clap, bajo, bajoSub,
  arpegio, hook)
const dropAvar = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub,
  arpegio, hook, hookEco, cuerdas)
const breakdown = stack(pad, cuerdas, hook.gain(.6).room(.85).rsize(9),
  arpegio.lpf(800).gain(.4), bajoSub.gain(.3))
const breakBuild = stack(pad, cuerdas, hook.gain(.7), arpegio,
  rodillo, hats16.gain(.35))
const dropB = stack(kickHard, hats16, hats, clap, bajo, bajoSub,
  arpegio, hook, hookEco)
const dropBFull = stack(kickHard, hats16, hats, clap, ride, bajo, bajoSub,
  arpegio.sometimesBy(.2, x=>x.add(note(12)).gain(.4)), hook, hookEco,
  cuerdas, pad.gain(.2))
const dropBvar = stack(kickHard, hats16, clap, ride,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  arpegio, hook.every(4, x=>x.iter(4)), hookEco, cuerdas)
const coda = stack(kick, hats, bajo.lpf(500).gain(.65),
  hook.gain(.45).room(.7), arpegio.gain(.4), pad)
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 · TR-909 · arpegio ABBA con phaser + tick-tock de reloj
// 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)

// ── TICK-TOCK DE RELOJ (rim panorámico, como el original) ──
const reloj = s("rim*4").bank("RolandTR909")
  .speed("1 .82 1 .82").pan("0.15 0.85 0.15 0.85")
  .gain(.6).room(.4).rsize(4)
  .delay(.3).delaytime(.375).delayfeedback(.4).orbit(3)

// ── BAJO DISCO CON OCTAVAS (Dm→Dm→Dm→C) ──
const bajo = note("d1 [~ d2] d1 [~ d2] d1 [~ d2] d1 [~ d2]")
  .add(note("<0 0 0 -2>"))
  .s("sawtooth").lpf(800).lpq(4).attack(.003).decay(.15).sustain(.3).release(.05)
  .shape(.2).gain(.9).orbit(1)
const bajoSub = note("<d1 d1 d1 c1>").s("sine")
  .attack(.03).decay(.4).sustain(.45).gain(.55).orbit(1)

// ── STRINGS DISCO (supersaw brillante) ──
const cuerdas = note("<[d3,f3,a3] [d3,f3,a3] [d3,f3,a3] [c3,e3,g3]>")
  .s("supersaw").unison(6).spread(.8)
  .lpf(sine.slow(16).range(500,2000)).attack(.4).release(.9)
  .room(.55).rsize(6).gain(.4).orbit(4)

// ── BATERÍA 909 DISCO ──
const kick = s("bd*4").bank("RolandTR909").shape(.35).gain(1.05)
  .duck("1:2").duckattack(.12).duckdepth(.5).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.5).distort(1.05).gain(1.1)
  .duck("1:2").duckattack(.12).duckdepth(.6).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.55).pan(.6).orbit(0)
const hatOpen = s("~ ~ ~ [~ oh]").bank("RolandTR909").gain(.45).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.48 .22 .34 .22]*4").pan(rand.range(.4,.6)).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)

// ── 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, bajo, arpegio,
  hook.lpf(900).gain(.5))
const dropDisco = stack(kickHard, hats16, hats, hatOpen, clap,
  bajo, bajoSub, arpegio, hook)
const dropDiscoVar = stack(kickHard, hats16, hats, hatOpen, clap,
  bajo, bajoSub, arpegio, arpegioAlto, hook, cuerdas.gain(.3))
const breakReloj = stack(reloj, cuerdas, hook.gain(.55).room(.75),
  bajoSub.gain(.3), hats.gain(.25))
const breakBuild = stack(reloj.gain(.4), cuerdas, hook.gain(.65),
  arpegio.lpf(saw.slow(8).range(600,2200)).gain(.6),
  rodillo, hats16.gain(.35))
const dropBrillante = stack(kickHard, hats16, hats, hatOpen, clap,
  bajo, bajoSub, arpegio.lpf(2400), arpegioAlto, hook, cuerdas.gain(.32))
const dropBrillanteVar = stack(kickHard, hats16, hatOpen, clap,
  bajo.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  arpegio.every(4, x=>x.rev()), arpegioAlto, hook, cuerdas.gain(.32),
  reloj.gain(.25))
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)
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 · TR-909 + piano · nocturno, sensual, subida lenta
// 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)

// ── BAJO PROFUNDO Y REDONDO (triangle, sigue la progresión) ──
const bajo = note("a1 ~ [~ a1] ~ a1 ~ [~ a1] ~").add(note("<0 -2 -4 -2>"))
  .s("triangle").lpf(500).attack(.01).decay(.3).sustain(.5).release(.08)
  .shape(.15).gain(.95).orbit(1)
const bajoSub = note("<a1 g1 f1 g1>").s("sine")
  .attack(.05).decay(.5).sustain(.55).gain(.55).orbit(1)

// ── BATERÍA 909 SEDOSA ──
const kick = s("bd*4").bank("RolandTR909").shape(.3).gain(1)
  .duck("1:2").duckattack(.15).duckdepth(.45).orbit(0)
const kickHondo = s("bd*4").bank("RolandTR909").shape(.4).gain(1.06)
  .duck("1:2").duckattack(.15).duckdepth(.55).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.35).rsize(4).gain(.6).orbit(0)
const hats = s("[~ hh]*4").bank("RolandTR909").gain(.45).hpf(8000).pan(.6).orbit(0)
const 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 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 ──
const voz = note("<a3 g3 f3 g3>").s("sawtooth").vowel("<o a u a>")
  .attack(.7).release(1.2).lpf(1500)
  .room(.7).rsize(8).gain(.35).orbit(4)
const pad = note("<[a2,c3,e3] [g2,b2,d3] [f2,a2,c3] [g2,b2,d3]>")
  .s("sawtooth").lpf(sine.slow(32).range(350,900)).attack(1.2).release(2)
  .room(.75).rsize(8).gain(.38).orbit(4)

// ── SECCIONES ──
const intro = stack(kick, hats, bajoSub.gain(.4))
const introB = stack(kick, hats, rimSuave, clap.gain(.4),
  bajo.lpf(350).gain(.7))
const groove = stack(kick, hats, hats16, clap, rimSuave, bajo, bajoSub,
  piano.lpf(saw.slow(32).range(600,3500)).gain(.6))
const grooveFin = stack(kickHondo, rodillo, bajo, piano.gain(.7))
const dropPiano = stack(kickHondo, hats, hats16, clap, rimSuave,
  bajo, bajoSub, piano)
const dropPianoVar = stack(kickHondo, hats, hats16, clap, rimSuave,
  bajo, bajoSub, piano, pianoAlto, voz)
const breakPiano = stack(pianoSolo, bajoSub.gain(.25), hats.gain(.2))
const breakBuild = stack(pianoSolo.gain(.75), pad, voz,
  rodillo, hats16.gain(.3), bajo.lpf(400).gain(.6))
const dropAbierto = stack(kickHondo, hats, hats16, clap, rimSuave,
  bajo, bajoSub, piano, pianoAlto, pad.gain(.25))
const dropAbiertoVar = stack(kickHondo, hats16, clap, rimSuave,
  bajo.sometimesBy(.2, x=>x.add(note(12)).gain(.5)), bajoSub,
  piano.every(4, x=>x.rev()), pianoAlto, voz, pad.gain(.25))
const 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)
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 · TR-909 · cuerdas supersaw masivas · el cierre épico de la colección
// 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)

// ── CUERDAS MASIVAS (Am→Dm→C→Em, unison 7 spread .9) ──
const cuerdas = note("<[a2,c3,e3] [d3,f3,a3] [c3,e3,g3] [e3,g3,b3]>")
  .s("supersaw").unison(7).spread(.9)
  .lpf(sine.slow(32).range(400,2400)).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).gain(.95).orbit(1)
const bajoFin = note("a1*8").add(note("<0 5 3 7>"))
  .s("sawtooth").lpf(perlin.slow(8).range(500,1200)).lpq(7)
  .attack(.001).decay(.1).sustain(.2).release(.03)
  .shape(.35).gain("[1 .6]*4").orbit(1)
const bajoSub = note("<a1 d2 c2 e2>").s("sine")
  .attack(.03).decay(.5).sustain(.5).gain(.55).orbit(1)

// ── BATERÍA 909 BIG ROOM ──
const kick = s("bd*4").bank("RolandTR909").shape(.4).gain(1.05)
  .duck("1:2").duckattack(.11).duckdepth(.55).orbit(0)
const kickHard = s("bd*4").bank("RolandTR909").shape(.55).distort(1.2).gain(1.1)
  .duck("1:2").duckattack(.11).duckdepth(.7).orbit(0)
const clap = s("~ cp ~ cp").bank("RolandTR909").room(.3).gain(.75).orbit(0)
const hats = s("hh*8").bank("RolandTR909").gain(.4).pan(.6).orbit(0)
const hatsOff = s("[~ oh]*4").bank("RolandTR909").gain(.55).orbit(0)
const hats16 = s("hh*16").bank("RolandTR909")
  .gain("[.5 .25 .35 .25]*4").pan(rand.range(.35,.65)).orbit(0)
const ride = s("rd*8").bank("RolandTR909").gain(.3).pan(.35).orbit(0)
const crash = s("cr/4").bank("RolandTR909").gain(.5).room(.5).rsize(5).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)

// ── 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, bajo, melodia.gain(.65))
const dropA = stack(kickHard, hats16, hatsOff, clap, crash,
  bajo, bajoSub, melodia, cuerdas.gain(.3))
const dropAvar = stack(kickHard, hats16, hatsOff, clap, ride, crash,
  bajo, bajoSub, melodia, melodiaOctava, cuerdas.gain(.35))
const breakdown = stack(melodiaSola, cuerdas, cuerdasBajas)
const breakBuild = stack(melodiaSola.gain(.75), cuerdas, cuerdasBajas,
  rodilloLargo, hats16.gain(.3), bajo.lpf(450).gain(.5))
const buildFin2 = stack(kickHard, rodillo, melodia, cuerdas.gain(.4))
const dropFinal = stack(kickHard, hats16, hatsOff, clap, crash,
  bajoFin, bajoSub, melodia, melodiaOctava)
const dropFinalFull = stack(kickHard, hats16, hatsOff, clap, ride, crash,
  bajoFin, bajoSub, melodia, melodiaOctava, cuerdas.gain(.4),
  cuerdasBajas.gain(.3))
const dropFinalVar = stack(kickHard, hats16, hatsOff, clap, ride,
  bajoFin.sometimesBy(.25, x=>x.add(note(12)).gain(.5)), bajoSub,
  melodia, melodiaOctava.every(4, x=>x.add(note(12)).gain(.2)),
  cuerdas.gain(.4))
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))
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]
)`,
  },
];