sergio/takana

`.run` no dice nada; `.sh` dice lo que el fichero ES —una cabecera POSIX de shell con el sistema
pegado detrás— y se puede leer con `head` antes de correrlo, que es justamente lo que uno quiere
poder hacer con algo que va a formatear un disco.

⚠ Y por eso el vhost gana un `Content-Disposition: attachment`. `.sh` invita al navegador a
MOSTRARLO en vez de bajarlo: 580 MiB de binario volcados en una pestaña. La cabecera lo cierra para
las siete descargas a la vez y no depende de que Caddy adivine el tipo — hoy no manda ningún
`Content-Type` para estos ficheros, los sirve sin sniffear.

La tabla del sitio pasa de enlazar el TAMAÑO a enlazar el NOMBRE del fichero, con el tamaño debajo:
siete enlaces, cada uno diciendo qué se baja. Un «137 MiB» subrayado no se lee como una descarga.

Y vuelve el bloque de verificación, que se había perdido al reescribir la sección, con la distinción
que importa: el `.sha256` de al lado comprueba que la BAJADA llegó entera; el que el fichero lleva
adentro comprueba su propio CONTENIDO antes de desempaquetarlo. Son dos cosas distintas a propósito.

diff --git a/scripts/instalador-autoextraible.sh b/scripts/instalador-autoextraible.sh
index 1c7af910..cb07a0ce 100755
--- a/scripts/instalador-autoextraible.sh
+++ b/scripts/instalador-autoextraible.sh
@@ -7,9 +7,9 @@
 # quien ya sabe; no sirve para publicar. Lo que se publica tiene que ser **un fichero**: se baja, se
 # le da permiso de ejecución, se corre, y él se encarga.
 #
-#     curl -LO https://takana-os.net/descargas/takana-instalador.run
-#     chmod +x takana-instalador.run
-#     sudo ./takana-instalador.run
+#     curl -LO https://takana-os.net/descargas/takana-instalador.sh
+#     chmod +x takana-instalador.sh
+#     sudo ./takana-instalador.sh
 #
 # ── CÓMO ESTÁ HECHO ───────────────────────────────────────────────────────────────────────────
 # Cabecera `sh` + payload `tar.gz` pegado detrás, separado por OFFSET DE BYTES y no por número de
@@ -26,7 +26,7 @@
 set -eu
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
 PAQUETE="${PAQUETE:-work/instalador-salida}"
-SALIDA="${SALIDA:-work/takana-instalador.run}"
+SALIDA="${SALIDA:-work/takana-instalador.sh}"
 while [ $# -gt 0 ]; do
     case "$1" in
         --paquete) PAQUETE="${2:?}"; shift 2 ;;
@@ -66,11 +66,11 @@ cat > "$TMP/cabecera" <<HDREOF
 #!/bin/sh
 # takana — instalador. UN fichero: adentro viene todo y no baja nada de internet.
 #
-#   sudo ./takana-instalador.run              mirar, preguntar e instalar
-#   sudo ./takana-instalador.run --check      ¿se puede sin USB? No toca nada.
-#   sudo ./takana-instalador.run --survey     ¿qué hay en los discos? No toca nada.
-#        ./takana-instalador.run --extraer D  sólo desempaquetar en D, sin correr nada
-#        ./takana-instalador.run --sha256     el sha256 del payload que trae adentro
+#   sudo ./takana-instalador.sh              mirar, preguntar e instalar
+#   sudo ./takana-instalador.sh --check      ¿se puede sin USB? No toca nada.
+#   sudo ./takana-instalador.sh --survey     ¿qué hay en los discos? No toca nada.
+#        ./takana-instalador.sh --extraer D  sólo desempaquetar en D, sin correr nada
+#        ./takana-instalador.sh --sha256     el sha256 del payload que trae adentro
 #
 # Lo que hay adentro: el programa \`takana\` (ELF estático, corre en cualquier Linux x86-64), el
 # instalador que corre en RAM, su kernel, y el censo del terreno.
@@ -235,5 +235,5 @@ echo
 echo "✓ $SALIDA  ($(( $(wc -c < "$SALIDA") / 1048576 )) MiB)"
 echo "  sha256: $(sha256sum "$SALIDA" | cut -d' ' -f1)"
 echo
-echo "  curl -LO https://takana-os.net/descargas/takana-instalador.run"
-echo "  chmod +x takana-instalador.run && sudo ./takana-instalador.run"
+echo "  curl -LO https://takana-os.net/descargas/takana-instalador.sh"
+echo "  chmod +x takana-instalador.sh && sudo ./takana-instalador.sh"
diff --git a/scripts/instalador-variantes.sh b/scripts/instalador-variantes.sh
index db0820d5..d3f2736f 100755
--- a/scripts/instalador-variantes.sh
+++ b/scripts/instalador-variantes.sh
@@ -59,11 +59,11 @@ perfiles_de() {
     esac
 }
 
-# ── QUÉ MEDIOS TIENE CADA VARIANTE, Y POR QUÉ `full` NO TIENE .run ────────────────────────────
+# ── QUÉ MEDIOS TIENE CADA VARIANTE, Y POR QUÉ `full` NO TIENE FICHERO ÚNICO ────────────────────────────
 # El fichero único carga el instalador ENTERO en memoria —es lo que le permite soltar el disco— y
 # en RAM viven a la vez el initramfs comprimido y su contenido desempaquetado. El generador ya lo
 # comprueba y se niega por encima del 40 % de la RAM; con `full` (3,2 GiB) eso pide ~8 GiB en la
-# máquina donde se instale, o sea que el `.run` sería un fichero de 1,5 GiB que en la mitad de las
+# máquina donde se instale, o sea que el fichero único sería uno de 1,5 GiB que en la mitad de las
 # máquinas no se puede usar. **El USB no tiene ese límite**: corre desde el propio medio.
 #
 # ⚠ Y hay un defecto conocido en esa guarda: mide la RAM de la máquina que CONSTRUYE, no la de la
@@ -130,18 +130,18 @@ for v in $VARIANTES; do
     echo "════ $v ════════════════════════════════════════════════════════════════════════"
 
   if echo " $(medios_de "$v") " | grep -q ' run '; then
-    echo "  ── el fichero que se baja (.run) — perfiles: $(perfiles_de "$v" run)"
+    echo "  ── el fichero que se baja (.sh) — perfiles: $(perfiles_de "$v" run)"
     compone "$v" run
     ROOTFS="$L" KERNEL="$KERNEL" SALIDA="$SALIDA/paquete-$v" ./scripts/instalador-paquete.sh \
         > "work/.variante-$v-paquete.log" 2>&1 || {
         echo "     ✗ falló el paquete — ver work/.variante-$v-paquete.log" >&2; tail -6 "work/.variante-$v-paquete.log" >&2; exit 1; }
-    PAQUETE="$SALIDA/paquete-$v" SALIDA="$SALIDA/takana-instalador-$v.run" ./scripts/instalador-autoextraible.sh \
+    PAQUETE="$SALIDA/paquete-$v" SALIDA="$SALIDA/takana-instalador-$v.sh" ./scripts/instalador-autoextraible.sh \
         > "work/.variante-$v-run.log" 2>&1 || {
         echo "     ✗ falló el autoextraíble — ver work/.variante-$v-run.log" >&2; tail -6 "work/.variante-$v-run.log" >&2; exit 1; }
-    echo "     $SALIDA/takana-instalador-$v.run  $(( $(wc -c < "$SALIDA/takana-instalador-$v.run") / 1048576 )) MiB"
+    echo "     $SALIDA/takana-instalador-$v.sh  $(( $(wc -c < "$SALIDA/takana-instalador-$v.sh") / 1048576 )) MiB"
     rm -rf "$L"
   else
-    echo "  ── sin .run: este rootfs no entra en RAM en una máquina normal (sólo USB)"
+    echo "  ── sin fichero único: este rootfs no entra en RAM en una máquina normal (sólo USB)"
   fi
 
     echo "  ── la imagen USB — perfiles: $(perfiles_de "$v" usb)"
@@ -156,4 +156,4 @@ done
 
 echo
 echo "✓ en $SALIDA:"
-ls -l "$SALIDA"/*.run "$SALIDA"/*.img 2>/dev/null | awk '{printf "  %-52s %s MiB\n", $9, int($5/1048576)}'
+ls -l "$SALIDA"/*.sh "$SALIDA"/*.img 2>/dev/null | awk '{printf "  %-52s %s MiB\n", $9, int($5/1048576)}'
diff --git a/scripts/metal-salto-test.sh b/scripts/metal-salto-test.sh
index 289e434e..ce60132f 100755
--- a/scripts/metal-salto-test.sh
+++ b/scripts/metal-salto-test.sh
@@ -30,7 +30,7 @@ PAQUETE="${PAQUETE:-work/instalador-salida}"
 REMOTO="/tmp/salto-test-$$"
 CONSERVAR=""; SOLO_VERIFICAR=""
 # ⚠ `VIA_RUN=1` prueba **el fichero que se publica**, no el paquete. Son cosas distintas: el paquete
-# es lo que arma el repo y el `.run` es lo que baja una persona, y entre uno y otro hay una cabecera
+# es lo que arma el repo y el `.sh` es lo que baja una persona, y entre uno y otro hay una cabecera
 # `sh`, un offset de bytes, una verificación de sha256 y un desempaquetado — o sea cuatro sitios
 # nuevos donde romperse, ninguno cubierto por probar el paquete.
 VIA_RUN="${VIA_RUN:-}"
@@ -125,10 +125,10 @@ TAKANA_BIN="${TAKANA_BIN:-$ROOT/target/x86_64-unknown-linux-musl/release/takana}
 [ -x "$TAKANA_BIN" ] || TAKANA_BIN="$ROOT/target/release/takana"
 cp "$TAKANA_BIN" "$T/bin/takana"; chmod 0755 "$T/bin/takana"
 if [ -n "$VIA_RUN" ]; then
-    RUN="${RUN:-work/takana-instalador.run}"
+    RUN="${RUN:-work/takana-instalador.sh}"
     [ -x "$RUN" ] || { echo "no encuentro $RUN (armalo con scripts/instalador-autoextraible.sh)" >&2; exit 1; }
     mkdir -p "$T/var/tmp"
-    cp "$RUN" "$T/takana-instalador.run"; chmod 0755 "$T/takana-instalador.run"
+    cp "$RUN" "$T/takana-instalador.sh"; chmod 0755 "$T/takana-instalador.sh"
     for a in tar gzip gunzip df expr; do ln -sf busybox "$T/bin/$a"; done
     rm -rf "$T/paquete"
 else
@@ -165,12 +165,12 @@ for w in $(cat /proc/cmdline 2>/dev/null); do
         test.esp=*)  ESPP="${w#test.esp=}" ;;
     esac
 done
-if [ -x /takana-instalador.run ]; then
+if [ -x /takana-instalador.sh ]; then
     # El camino del que BAJA UN FICHERO: la cabecera se desempaqueta sola y corre lo de adentro.
-    log "SALTO-TEST: ───── takana-instalador.run (el fichero publicado) ─────"
+    log "SALTO-TEST: ───── takana-instalador.sh (el fichero publicado) ─────"
     # `--jump`: desde el 2026-09-23 el salto sólo ocurre si el destino es la raíz VIVA, y acá no
     # lo es. Este arnés existe para probar el salto, así que lo pide explícitamente.
-    TAKANA_TMP=/var/tmp /takana-instalador.run --root "$DEST" --esp "$ESPP" \
+    TAKANA_TMP=/var/tmp /takana-instalador.sh --root "$DEST" --esp "$ESPP" \
         --jump --unattended --yes > /dev/console 2>&1
 else
     log "SALTO-TEST: ───── takana metal check ─────"
@@ -220,9 +220,9 @@ grep -q 'puede instalarse SIN USB' "$LOG" && ok "metal check: dice que SÍ (el k
 grep -q 'el terreno de esta máquina' "$LOG" && ok "metal survey: el censo salió por pantalla" \
     || falla "metal survey no imprimió el censo"
 if [ -n "$VIA_RUN" ]; then
-    grep -q 'payload verificado (sha256)' "$LOG" && ok "el .run verificó su propio payload" \
-        || falla "el .run no verificó el sha256 de su payload"
-    grep -q 'desempaquetando' "$LOG" && ok "el .run se desempaquetó solo" || falla "el .run no se desempaquetó"
+    grep -q 'payload verificado (sha256)' "$LOG" && ok "el .sh verificó su propio payload" \
+        || falla "el .sh no verificó el sha256 de su payload"
+    grep -q 'desempaquetando' "$LOG" && ok "el .sh se desempaquetó solo" || falla "el .sh no se desempaquetó"
 fi
 grep -q '⚡ saltando' "$LOG" && ok "metal install: anunció el salto" || falla "no anunció el salto"
 grep -q 'SALTO-TEST-FALLO' "$LOG" && falla "EL SALTO NO OCURRIÓ: el origen siguió vivo" \
diff --git a/web/takana-os.net/README.md b/web/takana-os.net/README.md
index 12410bb7..6995e26d 100644
--- a/web/takana-os.net/README.md
+++ b/web/takana-os.net/README.md
@@ -31,7 +31,8 @@ medidas: ninguna baja de 4,5:1.
 
 ## El instalador: `/descargas/` vive FUERA del repo
 
-`https://takana-os.net/descargas/takana-instalador.run` es **un fichero que trae todo adentro**:
+`https://takana-os.net/descargas/takana-instalador-<variante>.sh` es **un fichero que trae todo
+adentro**:
 cabecera `sh` + un `tar.gz` pegado detrás con el binario `takana`, el instalador que corre en RAM, su
 kernel y el censo del terreno. Se baja, se le da permiso y se corre; no baja nada más.
 
@@ -43,21 +44,27 @@ que está en `sdc` (255 G) y no en la raíz de 5,8 G, que se llena y tira la caj
 ```sh
 scripts/instalador-paquete.sh          # arma el paquete (y comprueba su coherencia)
 scripts/instalador-autoextraible.sh    # lo convierte en UN fichero, y lo desempaqueta para probarlo
-cp work/variantes/*.run work/variantes/*.img /work/sergio/descargas/
+cp work/variantes/*.sh work/variantes/*.img /work/sergio/descargas/
 ( cd /work/sergio/descargas && for f in takana-instalador-*; do case "$f" in *.sha256) ;; *) sha256sum "$f" > "$f.sha256";; esac; done )
 ```
 
 El `.sha256` que se publica al lado es **el del fichero entero**, para comprobar la descarga
-(`sha256sum -c takana-instalador.run.sha256`). Es distinto del que el `.run` lleva adentro, que es
-el **del payload** y lo verifica él solo antes de desempaquetar (`./takana-instalador.run --sha256`
+(`sha256sum -c takana-instalador.sh.sha256`). Es distinto del que el `.sh` lleva adentro, que es
+el **del payload** y lo verifica él solo antes de desempaquetar (`./takana-instalador.sh --sha256`
 lo imprime).
 
 ⚠ **El hash NO se escribe en `index.html`, y es deliberado.** La primera versión lo traía pegado en
 la página y habría empezado a mentir en el primer rebuild — que es el modo de fallo que este mismo
 README ya avisa para la sección «las decisiones». La página muestra el comando; el número lo sirve
-el fichero de al lado, que se regenera junto al `.run`.
+el fichero de al lado, que se regenera junto al `.sh`.
 
-⚠ `/descargas` queda **fuera del `encode`** del vhost: el `.run` ya viene comprimido, y volver a
+⚠ **La extensión es `.sh` y no `.run`, y por eso el vhost fuerza `Content-Disposition: attachment`.**
+`.sh` dice lo que el fichero ES —una cabecera de shell con el sistema pegado detrás, legible con
+`head` antes de correrlo— pero invita al navegador a MOSTRARLO: 580 MiB de binario volcados en una
+pestaña. La cabecera lo cierra para las siete descargas a la vez y no depende de que Caddy adivine
+el tipo (hoy no manda ningún `Content-Type` para estos ficheros).
+
+⚠ `/descargas` queda **fuera del `encode`** del vhost: el `.sh` ya viene comprimido, y volver a
 comprimirlo por HTTP gasta CPU en cada descarga sin ahorrar un byte.
 
 ### Las variantes: qué sistema se instala
@@ -65,11 +72,11 @@ comprimirlo por HTTP gasta CPU en cada descarga sin ahorrar un byte.
 `scripts/instalador-variantes.sh [servidor|mirada|full]` arma las tres, en sus dos medios.
 La diferencia es **qué rootfs se copia al disco**, no cómo: el instalador y el censo son los mismos.
 
-| variante | composición | .run | USB |
+| variante | composición | `.sh` | USB |
 |---|---|---|---|
 | `base` | sólo el piso de arranque | 137 MiB | 519 MiB |
 | `mirada` | + `[perfil.base]` + `[perfil.escritorio-mirada]` | 524 MiB | 1,6 GiB |
-| `servidor` | `.run`: `base` + `servidor-minimo` · USB: `base` + `servidor` | 580 MiB | 3,2 GiB |
+| `servidor` | `.sh`: `base` + `servidor-minimo` · USB: `base` + `servidor` | 580 MiB | 3,2 GiB |
 | `full` | + `base` + `cli` + `escritorio-mirada` + `servidor` | **no hay** | 3,5 GiB |
 
 ⚠ **«base» son DOS cosas con el mismo nombre y confundirlas da un rootfs que no arranca.** El
@@ -84,7 +91,7 @@ auditoría del bit de privilegio corre contra las declaraciones `[[setuid]]` del
 hidratando, así que al poner `escritorio-mirada` sobre `base` veía el `doas` 4755 que dejó `base`
 —declarado y legítimo— y lo denunciaba como un bit que nadie declaró.
 
-⚠ **`servidor` NO es la misma cosa en los dos medios, y es la misma física.** El `.run` carga el
+⚠ **`servidor` NO es la misma cosa en los dos medios, y es la misma física.** El `.sh` carga el
 sistema entero en memoria —es lo que le permite soltar el disco— así que cada MiB del rootfs es RAM
 exigida en la máquina de quien instala. Por ahí va `servidor-minimo`: **los mismos servicios uno por
 uno** (sshd, caddy, gitea, cron, hora, cortafuegos, los daemons propios), sin la cadena de compilar
@@ -94,7 +101,7 @@ destino de verdad. No es una opinión sobre qué debe llevar un servidor: es una
 MEDIO, y está escrita en los dos sitios —acá y en el `descripcion` del perfil— para que nadie la
 lea como un recorte arbitrario.
 
-⚠ **`full` no tiene `.run`, y es física.** El fichero único carga el instalador entero en memoria
+⚠ **`full` no tiene `.sh`, y es física.** El fichero único carga el instalador entero en memoria
 —es lo que le permite soltar el disco— y ahí viven a la vez el initramfs comprimido y su contenido
 desempaquetado. Con 3,2 GiB de rootfs eso pide ~8 GiB de RAM en la máquina donde se instale. El USB
 no tiene ese límite: corre desde el propio medio. La guarda que lo detecta **mide la RAM de la
@@ -176,6 +183,7 @@ takana-os.net, www.takana-os.net {
 	redir /descargas /descargas/ permanent
 	handle_path /descargas/* {
 		root * /work/sergio/descargas
+		header Content-Disposition "attachment"
 		file_server browse
 	}
 
diff --git a/web/takana-os.net/index.html b/web/takana-os.net/index.html
index 6b637886..2ad6beaf 100644
--- a/web/takana-os.net/index.html
+++ b/web/takana-os.net/index.html
@@ -52,7 +52,11 @@ h1,h2,h3{font-weight:600;letter-spacing:-.01em;line-height:1.15}
 .variantes th{text-align:left;font-weight:600;font-size:.78rem;letter-spacing:.06em;text-transform:uppercase;color:var(--tenue);padding:.4rem .6rem;border-bottom:1px solid var(--linea)}
 .variantes td{padding:.55rem .6rem;border-bottom:1px solid var(--linea);vertical-align:top}
 .variantes td:first-child{white-space:nowrap}
-.variantes td:nth-child(3),.variantes td:nth-child(4){white-space:nowrap;text-align:right}
+.variantes td:nth-child(3),.variantes td:nth-child(4){white-space:nowrap}
+.baja{display:block;font-family:var(--mono);font-size:.82rem;line-height:1.4;text-decoration:none;border-bottom:0}
+.baja:hover{text-decoration:underline}
+.baja em{display:block;font-family:var(--sans);font-style:normal;font-size:.76rem;color:var(--tenue)}
+.sinmedio{display:block;font-size:.8rem;color:var(--debil)}
 code{font:.86em/1.5 var(--mono);background:var(--papel2);border:1px solid var(--linea);
  border-radius:5px;padding:.08em .38em}
 :root[data-lang="es"] [data-l="en"],:root[data-lang="en"] [data-l="es"]{display:none!important}
@@ -242,9 +246,9 @@ footer.pie{border-top:1px solid var(--linea);background:var(--papel);padding:2.6
   <span data-l="en">There is no ISO to burn and no tree to copy: you download <strong>one file</strong>, make it executable and run it. Everything travels inside — the program, the installer that runs in RAM and its own kernel — so it <strong>downloads nothing from the internet while installing</strong>. A system installer that needs the network fails exactly where it costs most: on the machine that has no system yet.</span>
  </p>
 
-<pre><span class="p">$</span> curl -LO https://takana-os.net/descargas/takana-instalador-mirada.run
-<span class="p">$</span> chmod +x takana-instalador-mirada.run
-<span class="p">$</span> sudo ./takana-instalador-mirada.run</pre>
+<pre><span class="p">$</span> curl -LO https://takana-os.net/descargas/takana-instalador-mirada.sh
+<span class="p">$</span> chmod +x takana-instalador-mirada.sh
+<span class="p">$</span> sudo ./takana-instalador-mirada.sh</pre>
 
  <p>
   <span data-l="es">Eso hace las tres cosas por orden: comprueba si esta máquina puede instalarse <em>sin USB</em>, muestra el terreno —cada partición, su tamaño, qué hay dentro y si se puede usar— y recién entonces pregunta. Lo cifrado, lo de Windows, la swap, las particiones de arranque y lo que está montado <strong>no se ofrecen</strong>, y se muestran igual con el motivo escrito al lado.</span>
@@ -258,8 +262,8 @@ footer.pie{border-top:1px solid var(--linea);background:var(--papel);padding:2.6
 
  <h3><span data-l="es">Tres variantes</span><span data-l="en">Three variants</span></h3>
  <p>
-  <span data-l="es">La diferencia es <strong>qué sistema se instala</strong>, no cómo. Las tres traen el mismo instalador y el mismo censo; cambia el tamaño de lo que copian al disco.</span>
-  <span data-l="en">The difference is <strong>which system gets installed</strong>, not how. All three carry the same installer and the same survey; what changes is the size of what they copy to the disk.</span>
+  <span data-l="es">La diferencia es <strong>qué sistema se instala</strong>, no cómo. Las cuatro traen el mismo instalador y el mismo censo; cambia el tamaño de lo que copian al disco.</span>
+  <span data-l="en">The difference is <strong>which system gets installed</strong>, not how. All four carry the same installer and the same survey; what changes is the size of what they copy to the disk.</span>
  </p>
 
  <table class="variantes">
@@ -267,41 +271,46 @@ footer.pie{border-top:1px solid var(--linea);background:var(--papel);padding:2.6
    <th><span data-l="es">variante</span><span data-l="en">variant</span></th>
    <th><span data-l="es">qué trae</span><span data-l="en">what it carries</span></th>
    <th><span data-l="es">un archivo</span><span data-l="en">one file</span></th>
-   <th>USB</th>
+   <th><span data-l="es">imagen USB</span><span data-l="en">USB image</span></th>
   </tr>
   <tr>
    <td><code>base</code></td>
    <td><span data-l="es">el piso de arranque y nada más: arranca a una consola</span><span data-l="en">the boot floor and nothing else: it boots to a console</span></td>
-   <td><a href="/descargas/takana-instalador-base.run">137 MiB</a></td>
-   <td><a href="/descargas/takana-instalador-usb-base.img">519 MiB</a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-base.sh">takana-instalador-base.sh<em>137 MiB</em></a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-usb-base.img">takana-instalador-usb-base.img<em>519 MiB</em></a></td>
   </tr>
   <tr>
    <td><code>mirada</code></td>
    <td><span data-l="es">+ el userland completo + el escritorio propio de la suite</span><span data-l="en">+ the full userland + the suite's own desktop</span></td>
-   <td><a href="/descargas/takana-instalador-mirada.run">524 MiB</a></td>
-   <td><a href="/descargas/takana-instalador-usb-mirada.img">1,6 GiB</a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-mirada.sh">takana-instalador-mirada.sh<em>524 MiB</em></a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-usb-mirada.img">takana-instalador-usb-mirada.img<em>1,6 GiB</em></a></td>
   </tr>
   <tr>
    <td><code>servidor</code></td>
    <td><span data-l="es">+ el userland completo + los servicios. <strong>El archivo único trae el servidor mínimo</strong> —los mismos servicios, sin compilador ni toolbox— porque carga el sistema en memoria; <strong>el USB trae el servidor entero</strong>, que no tiene ese límite.</span><span data-l="en">+ the full userland + the services. <strong>The single file carries the minimal server</strong> — same services, no compiler and no toolbox — because it loads the system into memory; <strong>the USB carries the full server</strong>, which has no such limit.</span></td>
-   <td><a href="/descargas/takana-instalador-servidor.run">580 MiB</a></td>
-   <td><a href="/descargas/takana-instalador-usb-servidor.img">3,2 GiB</a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-servidor.sh">takana-instalador-servidor.sh<em>580 MiB</em></a></td>
+   <td><a class="baja" href="/descargas/takana-instalador-usb-servidor.img">takana-instalador-usb-servidor.img<em>3,2 GiB</em></a></td>
   </tr>
   <tr>
    <td><code>full</code></td>
    <td><span data-l="es">todo lo anterior junto, más el toolbox de línea de comandos</span><span data-l="en">all of the above together, plus the command-line toolbox</span></td>
-   <td><span data-l="es">— sólo USB</span><span data-l="en">— USB only</span></td>
-   <td><a href="/descargas/takana-instalador-usb-full.img">3,5 GiB</a></td>
+   <td><span class="sinmedio" data-l="es">no entra en memoria: sólo USB</span><span class="sinmedio" data-l="en">does not fit in memory: USB only</span></td>
+   <td><a class="baja" href="/descargas/takana-instalador-usb-full.img">takana-instalador-usb-full.img<em>3,5 GiB</em></a></td>
   </tr>
  </table>
 
  <p class="nota">
-  <span data-l="es">⚠ <strong>El archivo único carga el instalador ENTERO en memoria</strong> para poder soltar el disco, así que de las variantes grandes hace falta bastante RAM — y si no entra, el instalador lo dice y no lo intenta. El USB no tiene ese límite: corre desde el propio pendrive. Para <code>servidor</code> y para máquinas con poca memoria, <strong>el USB es el camino</strong>.</span>
-  <span data-l="en">⚠ <strong>The single file loads the WHOLE installer into memory</strong> so it can release the disk, so the larger variants need a fair amount of RAM — and if it does not fit, the installer says so instead of trying. The USB has no such limit: it runs from the stick itself. For <code>servidor</code> and for machines with little memory, <strong>the USB is the way</strong>.</span>
+  <span data-l="es">⚠ <strong>El archivo único carga el instalador ENTERO en memoria</strong> para poder soltar el disco, así que las variantes grandes piden bastante RAM — y si no entra, el instalador lo dice y no lo intenta. El USB no tiene ese límite: corre desde el propio pendrive. Se llama <code>.sh</code> porque <em>es</em> un guion de shell: una cabecera con el sistema pegado detrás, que se puede leer con <code>head</code> antes de correrlo.</span>
+  <span data-l="en">⚠ <strong>The single file loads the WHOLE installer into memory</strong> so it can release the disk, so the larger variants need a fair amount of RAM — and if it does not fit, the installer says so instead of trying. The USB has no such limit: it runs from the stick itself. It is called <code>.sh</code> because it <em>is</em> a shell script: a header with the system appended to it, readable with <code>head</code> before you run it.</span>
  </p>
 
-<pre><span class="p">$</span> curl -sO https://takana-os.net/descargas/takana-instalador-mirada.run.sha256
-<span class="p">$</span> sha256sum -c takana-instalador-mirada.run.sha256</pre>
+<pre><span class="p">$</span> curl -sO https://takana-os.net/descargas/takana-instalador-mirada.sh.sha256
+<span class="p">$</span> sha256sum -c takana-instalador-mirada.sh.sha256</pre>
+
+ <p class="nota">
+  <span data-l="es">Cada descarga publica su <code>.sha256</code> al lado, con el mismo nombre. Ése comprueba que la bajada llegó entera; el que el fichero lleva <em>adentro</em> comprueba su propio contenido antes de desempaquetarlo, y son dos cosas distintas a propósito.</span>
+  <span data-l="en">Every download publishes its <code>.sha256</code> next to it, under the same name. That one checks the download arrived whole; the one the file carries <em>inside</em> checks its own contents before unpacking, and they are deliberately two different things.</span>
+ </p>
 
  <h3><span data-l="es">Y si esta máquina no puede saltar: el USB</span><span data-l="en">And if this machine cannot jump: the USB</span></h3>
  <p>