#!/usr/bin/env bash
# Interfaz común para operaciones habituales con gestores de paquetes.
# Los nombres de paquetes se pasan como argumentos separados, nunca como
# fragmentos que se evalúan en un shell.
set -u

PROGRAMA=${0##*/}
DIR_PROGRAMA=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
SUMMAPACK_ROOT=$(cd -- "$DIR_PROGRAMA/.." 2>/dev/null && pwd || true)
if [[ -d $DIR_PROGRAMA/packlets ]]; then
    DIR_PACKLETS=$DIR_PROGRAMA/packlets
else
    DIR_PACKLETS=$SUMMAPACK_ROOT/share/summapack/sp/packlets
fi

uso() {
    cat <<'EOF'
Uso:
  sp [--distro DISTRO] [--ensayo] [--sin-upgrade] [--para FORMA] [--arbol [DIR]]
     [--sitio] ACCION OBJETO...

Para los proyectos Simusol (install tabular2, calcula...):
  --prefijo DIR     con --para fuentes: donde instalar (make install con
                    --prefix DIR). Con un DIR escribible por el usuario,
                    p.ej. ~/.local, instala en el home SIN root
  --para FORMA      fuentes (compilar e instalar aca, make install con su
                    lista; lo mismo que install SOURCE), fuentes-paquete
                    (compilar aca y armar e instalar .deb/.rpm), o un
                    formato armado: deb, ututo2027, fedora, suse, arch, rpm, tgz; sin
                    --para, el armado de esta distribucion
  --arbol [DIR]     tomar del directorio de fuentes (con o sin SVN), aunque el
                    sitio vaya adelante; si el arbol trae algo que la
                    version publicada no tiene, sube la version (sin comitear)
  --sitio           tomar del sitio de descargas
                    SIN NINGUNA DE LAS DOS SE TOMA LA MAS NUEVA: se mira el
                    arbol que haya --el de donde se corre sp, o el de ~/svn
                    que tenga el proyecto-- y gana la version mas nueva

Acciones de Babel:
  install PAQUETE...             Instalar paquetes externos o proyectos Simusol conocidos
  install todos                    Instalar los proyectos del conjunto Siru y Calcula
  estado                           Consultar sus paquetes y versiones instaladas
  reanudar [ID]                    Continuar un lote del árbol desde el primer pendiente
  install PERL MODULO...         Preferir paquete de la distribución; si falta, usar cpanm
  install CPAN MODULO...         Instalar módulos Perl ausentes mediante cpanm
  install WORLD|SYSTEM|CACHE     Actualizar paquetes, distribución o caché
  remove PAQUETE...              Quitar paquetes (lo instalado desde fuentes con
                                 sp --para fuentes, con su lista)
  list-source                    Lo instalado desde fuentes, con su version
  manifiesto [LUGAR/]NOMBRE      Generar el MANIFIESTO (las fuentes del paquete)
                                 o sincronizar svn/git con el
  paquete [LUGAR/]NOMBRE         Armar un proyecto desde su .summa, en el formato
                                 de esta maquina (deb, rpm, pacman o tgz)
  binarios [LUGAR/]NOMBRE [DISTRO...]  Los binarios de un proyecto, armados en
                                 el Podman de cada distribucion: ubuntu,
                                 fedora, suse, ututo2027 (sin ninguna, las
                                 cuatro). Los de ututo2027 llevan su marca:
                                 NOMBRE_VERSION+ututo2027_ARQ.deb
  iso ututo2027                  La ISO de Ututo 2027, desde nuestras fuentes:
                                 adentro, cada proyecto se instala con
                                 sp --para fuentes-paquete install, y las
                                 fuentes quedan en la ISO (/usr/src/ututo2027)
  fuentes [LUGAR/]NOMBRE [SALIDA]  Las fuentes de distribucion: el tarball del
                                 programa (.orig.tar.gz), el paquete fuente de
                                 Debian (.dsc) y el de RPM (.src.rpm). De ahi
                                 se sigue con las herramientas de la distro
  subir [LUGAR/]NOMBRE           Subir lo armado al servidor de descargas
                                 (desde su .summa, con todo comiteado), como UNSTABLE.
                                 Con --tipo distro, las fuentes por formato de
                                 sp fuentes, a PROYECTO/fuentes-distro/VERSION/
  estable [LUGAR/]NOMBRE         Lo subido de NOMBRE pasa a estable
  clean WORLD|CACHE              Limpiar dependencias o caché
  fix WORLD|SYSTEM               Reparar dependencias o sincronizar el sistema
  search [NAMES] TEXTO           Buscar paquetes
  info PAQUETE...                Mostrar información de paquetes
  buildtools                     Preparar herramientas de desarrollo de esta distribución
  podman ENTORNO                 Descargar y etiquetar una imagen base limpia

Tipos de objeto:
  PAQ, DEB, RPM, TGZ, SUMMA, SOURCE, PERL, CPAN; NAMES para búsquedas

Órdenes de packlet:
  update | distupdate | refresh | depclean | buildtools
  addrepo REPO | delrepo REPO    (APT, DNF y Zypper)

Sin ninguna orden, corrido desde el arbol de svn, cuando summapack no esta
instalado o lo instalado es mas viejo que el arbol: instala o actualiza
summapack del arbol, sin el servidor. Revisa lo que hace falta para fabricar
paquetes e instala solo lo que falte --si no falta nada no usa la red--, arma
el paquete de la distribucion (deb, rpm o tgz) con la version del arbol y lo
instala. Si esas herramientas no estan y no se las puede traer, escribe a mano
los tres paquetes --deb, rpm y tgz, sin dpkg-dev ni rpmbuild
(hacer-pkg-minimo)-- de summapack y, si hay compilador, de la biblioteca
mem_util tambien, e instala los que entienda el gestor de la maquina. Con
--ensayo dice que haria.

Conjuntos: WORLD, SYSTEM, ALL, CACHE. ALL todavía no está instrumentado.
Los packlets de gestores disponibles son APT, DNF, Zypper, Pacman, Portage y URPMI; TGZ usa
instalar-tgz, y SUMMA/SOURCE usan bajar-paquetes.

Opciones:
  --distro DISTRO   Seleccionar una distribución concreta o familia; por defecto se detecta
                    con /etc/os-release
  --ensayo          Mostrar los comandos nativos sin ejecutarlos
  --sin-upgrade     Evitar la actualización conjunta de Pacman al pedir refresh
  -h, --help        Mostrar esta ayuda

Familias reconocidas: debian/ubuntu, fedora/dnf, opensuse/zypper, arch/pacman,
gentoo/ututo/portage y mandriva/urpmi. OpenMandriva actual usa DNF.
Los nombres de paquete de referencia Debian se traducen con diccionariodepaquetes de SummaPack.
ENTORNO admite ubuntu/debian/fedora/suse/arch con sufijo -viejo o -actual.
EOF
}

error() {
    printf '%s: %s\n' "$PROGRAMA" "$*" >&2
}

ensayo=0
sin_upgrade=0
distro_dada=
# como instalar nuestros proyectos (pedido del autor, 19/10/2026: el usuario
# usa solo sp, no bajar-paquetes): --para fuentes | fuentes-paquete | deb |
# fedora | suse | arch ...; --arbol [DIR]: las fuentes del arbol de svn
para_dada=
arbol_dado=
sin_arbol=0
# cual fuente se pidio: arbol, sitio, o vacio --que es "la mas nueva"--. Va
# al motor, que sin esto no puede distinguir un arbol pedido con --arbol de
# uno encontrado por omision, y trataria a los dos igual.
fuente_dada=
# --refrescar: refrescar los indices aunque ya se hayan refrescado hoy
refrescar=0
prefijo_dado=

# EL ARBOL MANDA SOBRE EL SERVIDOR. Pedido del autor, 18/11/2026: "sp no debe
# bajar del servidor si tiene arbol"; "cuando el arbol es mas nuevo que el
# servidor usar arbol". Hasta hoy el arbol se usaba SOLO con --arbol, y sin
# esa opcion sp bajaba las fuentes publicadas y les estampaba el numero de
# revision del arbol: salian paquetes que decian r8979 con el codigo de
# r6440 adentro (comprobado en dia-simusol, donde el simscrptl.sh del
# paquete tenia 120 bytes y el del arbol 5916). El numero avanzaba y el
# codigo no.
#
# Encontrado el arbol, quien compara es bajar-paquetes, que ya toma del
# arbol la version completa (sp-version: AÑO.MAYOR.MENOR.rREV-N, con +local
# si hay cambios sin comitear) y construye desde ahi solo si lo instalado no
# llega a esa version. Asi "mas nuevo" se decide con numeros y no a ojo.
#
# COMO SE BUSCA: primero hacia arriba desde donde se corre --la carpeta que
# tiene .svn y proyectos adentro (NOMBRE/NOMBRE.summa)--, que es el caso de
# correr sp parado en el arbol. Si por ahi no aparece, se busca el proyecto
# pedido abajo de ~/svn, pero SOLO uno que de verdad lo tenga: con varios
# arboles al lado (siru, calcula, termo) elegir al voleo seria peor que no
# elegir. Si no aparece ninguno, se sigue como siempre, con el servidor.
arbol_con_proyectos () {   # arbol_con_proyectos DIR: DIR es un arbol de proyectos
    [[ -d $1/.svn ]] && compgen -G "$1/*/*.summa" >/dev/null
}
buscar_arbol () {          # buscar_arbol [PROYECTO...]: escribe el arbol y vuelve 0
    local d=$PWD c p
    while [[ $d == /* && $d != / ]]; do
        if arbol_con_proyectos "$d"; then printf '%s\n' "$d"; return 0; fi
        d=$(dirname -- "$d")
    done
    local raiz=${HOME:-/root}/svn
    [[ -d $raiz ]] || return 1
    for c in "$raiz" "$raiz"/*; do
        [[ -d $c ]] || continue
        arbol_con_proyectos "$c" || continue
        for p in "$@"; do
            p=${p##*/}
            [[ -f $c/$p/$p.summa ]] || continue
            printf '%s\n' "$c"; return 0
        done
    done
    return 1
}
while (($#)); do
    case $1 in
        --ensayo) ensayo=1; shift ;;
        --sin-upgrade) sin_upgrade=1; shift ;;
        --distro)
            (($# >= 2)) || { error 'falta DISTRO después de --distro'; exit 2; }
            distro_dada=$2
            shift 2
            ;;
        --para)
            (($# >= 2)) || { error 'falta FORMA después de --para (fuentes, fuentes-paquete, deb, ututo2027, fedora, suse, arch)'; exit 2; }
            para_dada=$2
            shift 2
            ;;
        --prefijo)
            # instalar desde fuentes en otro prefijo (p.ej. ~/.local, sin
            # root): va a bajar-paquetes --prefijo; solo con --para fuentes
            (($# >= 2)) || { error 'falta DIR después de --prefijo (p.ej. ~/.local)'; exit 2; }
            prefijo_dado=$2
            shift 2
            ;;
        --arbol)
            fuente_dada=arbol
            arbol_dado=${HOME:-/root}/svn
            if (($# >= 2)) && [[ -d $2 ]]; then arbol_dado=$(cd -- "$2" && pwd); shift; fi
            shift
            ;;
        --sitio) fuente_dada=sitio; sin_arbol=1; shift ;;
        --refrescar) refrescar=1; shift ;;
        -h|--help|--ayuda) uso; exit 0 ;;
        --) shift; break ;;
        -*) error "opción desconocida: $1"; uso >&2; exit 2 ;;
        *) break ;;
    esac
done

# SIN PEDIR FUENTE, LA MAS NUEVA (pedido del autor, 19/11/2026): se mira el
# arbol que haya y mas abajo gana la version mas nueva entre el arbol y el
# sitio. --arbol toma del arbol y --sitio toma del sitio, sin comparar.
if [[ -z $arbol_dado && $sin_arbol == 0 ]]; then
    if arbol_dado=$(buscar_arbol "$@"); then
        printf 'sp: fuentes del arbol %s (--sitio para tomarlas del sitio)\n' "$arbol_dado"
    else
        arbol_dado=
    fi
fi

# sp sin ninguna orden, corrido desde el arbol de svn, cuando summapack no
# esta instalado o lo instalado es mas viejo que el arbol: se instala o se
# actualiza solo, sin el servidor de descargas. Primero revisa e instala lo
# que hace falta para fabricar paquetes, despues arma el paquete de la
# distribucion (deb, rpm o tgz) y recien entonces lo instala. Si lo instalado
# ya esta al dia no cambia nada: falta la operacion, como siempre.
# Pedido del autor, 02/11/2026.
autoinstalar=0
if (($# == 0)) && [[ -f $SUMMAPACK_ROOT/summapack.summa && -f $SUMMAPACK_ROOT/MANIFIESTO ]]; then
    autoinstalar=1
    operacion=autoinstalar
else
    (($#)) || { error 'falta la operación'; uso >&2; exit 2; }
    operacion=$1
    shift
fi

if [[ $operacion == reanudar ]]; then
    (($# <= 1)) || { error 'uso: sp reanudar [ID]'; exit 2; }
    registros=${XDG_STATE_HOME:-$HOME/.local/state}/summapack/corridas
    candidatas=()
    for dir in "$registros"/sp.*; do
        [[ ! -L $dir && -O $dir && ! -L $dir/pendientes && -f $dir/pendientes && ( $# == 0 || ${dir##*/} == "$1" ) ]] || continue
        candidatas+=("$dir")
    done
    if ((${#candidatas[@]} != 1)); then
        if ((${#candidatas[@]} == 0)); then error 'no hay una corrida pendiente con esa selección'
        else printf 'Seleccione una corrida con sp reanudar ID:\n' >&2
            for dir in "${candidatas[@]}"; do printf '  %s\n' "${dir##*/}" >&2; done
        fi
        exit 2
    fi
    export SP_CORRIDA=${candidatas[0]}
    exec 8<"$SP_CORRIDA"
    flock -n -x 8 || { error 'la corrida está en ejecución'; exit 1; }
    args=()
    while IFS= read -r -d '' arg; do args+=("$arg"); done < "$SP_CORRIDA/pendientes"
    ((${#args[@]} >= 2)) && [[ -d ${args[0]} ]] || { error 'falta el árbol o el registro está incompleto'; exit 1; }
    opciones=()
    ((ensayo == 0)) || opciones+=(--ensayo)
    exec "$DIR_PROGRAMA/sp" "${opciones[@]}" --arbol "${args[0]}" --para fuentes-paquete install SOURCE "${args[@]:1}"
fi

# subir un proyecto al servidor de descargas desde la carpeta de su .summa,
# con svn y todo comiteado (sp-subir; pedido del autor, 18/10/2026)
# el MANIFIESTO de un proyecto (los archivos de sus fuentes; sp-manifiesto):
# lo genera si no esta, si esta sincroniza el sistema de versiones con el
if [[ $operacion == manifiesto ]]; then
    (($# == 1)) || { error 'uso: sp manifiesto [LUGAR/]NOMBRE'; exit 2; }
    m=$DIR_PROGRAMA/sp-manifiesto
    [[ -x $m ]] || m=$SUMMAPACK_ROOT/bin/sp-manifiesto
    [[ -x $m ]] || { error 'falta sp-manifiesto (de summapack)'; exit 1; }
    case $1 in */*) lugar=${1%/*} ;; *) lugar=. ;; esac
    [[ -f $lugar/${1##*/}.summa ]] || { error "no esta $lugar/${1##*/}.summa: correr desde la carpeta del proyecto o dar LUGAR/NOMBRE"; exit 1; }
    if [[ -f $lugar/MANIFIESTO ]]; then exec "$m" sincronizar "$lugar"; else exec "$m" generar "$lugar"; fi
fi

# las fuentes de distribucion (sp-fuentes; pedido del autor, 16/11/2026): de
# nuestras fuentes, las de deb, rpm y tgz; no compila ni sube nada
if [[ $operacion == fuentes ]]; then
    (($# >= 1 && $# <= 2)) || { error 'uso: sp fuentes [LUGAR/]NOMBRE [SALIDA]'; exit 2; }
    f=$DIR_PROGRAMA/sp-fuentes
    [[ -x $f ]] || f=$SUMMAPACK_ROOT/bin/sp-fuentes
    [[ -x $f ]] || { error 'falta sp-fuentes (de summapack)'; exit 1; }
    exec "$f" "$@"
fi

# los binarios de un proyecto para una distribucion, armados en el Podman de
# esa distribucion (pedido del autor, 16/11/2026: todo se hace con sp). Los
# deja donde los busca sp subir. El motor es distros/armar-paquetes.
if [[ $operacion == binarios ]]; then
    (($# >= 1)) || { error 'uso: sp binarios [LUGAR/]NOMBRE [DISTRO...]   (ubuntu, fedora, suse, ututo2027; sin ninguna, las cuatro)'; exit 2; }
    a=$SUMMAPACK_ROOT/distros/armar-paquetes
    [[ -x $a ]] || { error 'sp binarios se corre desde el arbol de summapack (falta distros/armar-paquetes)'; exit 1; }
    nombre=${1##*/}; shift
    (($#)) || set -- ubuntu fedora suse ututo2027
    entornos=()
    for d in "$@"; do
        case $d in
            ubuntu|fedora|suse) entornos+=("$d-viejo") ;;
            ututo2027|ututo) entornos+=(ututo2027) ;;
            *) error "sp binarios: distribucion desconocida: $d (ubuntu, fedora, suse, ututo2027)"; exit 2 ;;
        esac
    done
    exec "$a" --proyecto "$nombre" "${entornos[@]}"
fi

# la ISO de Ututo 2027, desde nuestras fuentes (distros/armar-iso)
if [[ $operacion == iso ]]; then
    a=$SUMMAPACK_ROOT/distros/armar-iso
    [[ -x $a ]] || { error 'sp iso se corre desde el arbol de summapack (falta distros/armar-iso)'; exit 1; }
    exec "$a" "$@"
fi

if [[ $operacion == subir || $operacion == estable || $operacion == paquete ]]; then
    subir=$DIR_PROGRAMA/sp-subir
    [[ -x $subir ]] || subir=$SUMMAPACK_ROOT/bin/sp-subir
    [[ -x $subir ]] || { error 'falta sp-subir (de summapack)'; exit 1; }
    if [[ $operacion == estable ]]; then exec "$subir" --estable-modo "$@"; fi
    if [[ $operacion == paquete ]]; then exec "$subir" --paquete-modo "$@"; fi
    exec "$subir" "$@"
fi

# Lo instalado desde fuentes en forma directa (sp --para fuentes): cada
# proyecto tiene su lista en PREFIX/var/lib/sp/instalados/NOMBRE.json
# (sp-instalados). remove lo desinstala con esa lista, sin las fuentes;
# list-source dice que hay. Pedido del autor, 18/10/2026. No depende de la
# distribucion: va antes de detectarla.
prefijos_fuentes=(/usr/local /usr "${HOME:-/root}/.local")
sp_instalados=$DIR_PROGRAMA/sp-instalados
[[ -x $sp_instalados ]] || sp_instalados=$SUMMAPACK_ROOT/bin/sp-instalados
[[ -x $sp_instalados ]] || sp_instalados=$(command -v sp-instalados || true)
instalado_fuentes_en() {
    local p
    for p in "${prefijos_fuentes[@]}"; do
        [[ -f $p/var/lib/sp/instalados/$1.json ]] && { printf '%s' "$p"; return 0; }
    done
    for p in "${prefijos_fuentes[@]}"; do   # la lista de summapack de antes
        [[ $1 == summapack && -f $p/share/summapack/install-manifest.json ]] && { printf '%s' "$p"; return 0; }
    done
    return 1
}
if [[ $operacion == list-source ]]; then
    [[ -n $sp_instalados ]] || { error 'falta sp-instalados (de summapack)'; exit 1; }
    for p in "${prefijos_fuentes[@]}"; do
        [[ -d $p/var/lib/sp/instalados || -f $p/share/summapack/install-manifest.json ]] && "$sp_instalados" listar --prefix "$p"
    done
    exit 0
fi
if [[ $operacion == remove ]] && (($#)); then
    resto=()
    for nombre in "$@"; do
        if pre=$(instalado_fuentes_en "$nombre"); then
            [[ -n $sp_instalados ]] || { error 'falta sp-instalados (de summapack)'; exit 1; }
            if ((ensayo)); then
                printf '[ensayo] %s desinstalar %s --prefix %s\n' "$sp_instalados" "$nombre" "$pre"
            elif [[ -w $pre ]]; then
                "$sp_instalados" desinstalar "$nombre" --prefix "$pre" || exit $?
            else
                sudo -- "$sp_instalados" desinstalar "$nombre" --prefix "$pre" || exit $?
            fi
        else
            resto+=("$nombre")
        fi
    done
    ((${#resto[@]})) || exit 0
    set -- "${resto[@]}"
fi

if [[ $operacion == podman ]]; then
    (($# == 1)) || { error 'podman requiere exactamente un ENTORNO'; exit 2; }
    SP_ENSAYO=$ensayo "$DIR_PACKLETS/podman.sh" "$1"
    exit $?
fi

familia_de() {
    local id=${1,,}
    id=${id%%:*}
    case $id in
        apt|debian|ubuntu|linuxmint|pop|raspbian|kali|elementary|zorin) printf apt ;;
        dnf|fedora|rhel|redhat|centos|rocky|almalinux|ol|nobara) printf dnf ;;
        zypper|suse|opensuse|opensuse-leap|opensuse-tumbleweed|sles|sled) printf zypper ;;
        pacman|arch|archlinux|manjaro|endeavouros) printf pacman ;;
        portage|gentoo|ututo) printf portage ;;
        urpmi|mandriva|mandrake) printf urpmi ;;
        openmandriva|openmandriva-lx) printf dnf ;;
        *) return 1 ;;
    esac
}

detectar_distro() {
    local detector resultado
    detector=$SUMMAPACK_ROOT/bin/distro.sh
    [[ -r $detector ]] || { error "falta el detector de distribuciones: $detector"; return 1; }
    resultado=$(sh "$detector") || return 1
    familia_de "$resultado" >/dev/null || return 1
    printf '%s' "$resultado"
}

if [[ -n $distro_dada ]]; then
    distro_detectada=${distro_dada,,}
    familia=$(familia_de "$distro_detectada") || {
        error "distribución no reconocida: $distro_dada"
        exit 2
    }
else
    distro_detectada=$(detectar_distro) || {
        error 'distro.sh no identificó una distribución con packlet; use --distro'
        exit 2
    }
    familia=$(familia_de "$distro_detectada")
fi
distro_detectada=${distro_detectada,,}
distro_detectada=${distro_detectada%%:*}

gestor_disponible() {
    local gestor
    case $familia in
        apt) gestor=apt-get ;;
        dnf) gestor=dnf ;;
        zypper) gestor=zypper ;;
        pacman) gestor=pacman ;;
        portage) gestor=emerge ;;
        urpmi) gestor=urpmi ;;
    esac
    command -v "$gestor" >/dev/null 2>&1 || {
        error "la familia $familia requiere $gestor, pero no está disponible"
        return 1
    }
}

# Los sellos pertenecen al usuario que invoca sp; el gestor puede usar sudo.
directorio_refresco=${SP_REFRESH_STATE_DIR:-${XDG_CACHE_HOME:-${HOME:-/tmp}/.cache}/summapack/sp}
sello_refresco=$directorio_refresco/refresh-$distro_detectada

vigencia_refresco=43200

marca_vigente() {
    local sello=$1 ahora fecha
    [[ -f $sello ]] || return 1
    ahora=$(date +%s) || return 1
    fecha=$(stat -c %Y -- "$sello") || return 1
    ((fecha <= ahora && ahora - fecha < vigencia_refresco))
}

registrar_marca() {
    local sello=$1
    ((ensayo)) && return 0
    mkdir -p -- "$directorio_refresco" && touch -- "$sello"
}

resolver_paquete() {
    local nombre=$1 distro_diccionario distro_respaldo= valor_respaldo= archivo linea clave distro valor
    local exigir_equivalencia=0 equivalencia=0
    case $familia in
        apt)
            case $distro_detectada in
                ubuntu|linuxmint|pop|elementary|zorin) distro_diccionario=UBUNTU; distro_respaldo=DEBIAN ;;
                *) distro_diccionario=DEBIAN ;;
            esac
            ;;
        dnf)
            if [[ $distro_detectada == openmandriva || $distro_detectada == openmandriva-lx ]]; then
                distro_diccionario=OPENMANDRIVA; exigir_equivalencia=1
            else
                distro_diccionario=FEDORA
            fi
            ;;
        zypper) distro_diccionario=SUSE ;;
        pacman) distro_diccionario=ARCH ;;
        portage)
            if [[ $distro_detectada == ututo ]]; then
                distro_diccionario=UTUTO; distro_respaldo=GENTOO
            else
                distro_diccionario=GENTOO
            fi
            exigir_equivalencia=1
            ;;
        urpmi) distro_diccionario=MANDRIVA; exigir_equivalencia=1 ;;
    esac
    archivo=${SUMMAPACK_DICCIONARIO:-}
    if [[ -z $archivo ]]; then
        for archivo in \
            "$SUMMAPACK_ROOT/share/summapack/data/diccionariodepaquetes" \
            "$DIR_PROGRAMA/../share/summapack/data/diccionariodepaquetes" \
            /usr/share/summapack/data/diccionariodepaquetes \
            /usr/local/share/summapack/data/diccionariodepaquetes; do
            [[ -r $archivo ]] && break
        done
    fi
    [[ -r $archivo ]] || { error 'no encuentro diccionariodepaquetes de SummaPack'; return 1; }
    while IFS= read -r linea || [[ -n $linea ]]; do
        linea=${linea%%#*}
        [[ $linea =~ ^[[:space:]]*$ ]] && continue
        IFS=: read -r clave distro valor _ <<< "$linea"
        clave=${clave//[[:space:]]/}
        distro=${distro//[[:space:]]/}
        valor=${valor#"${valor%%[![:space:]]*}"}
        valor=${valor%"${valor##*[![:space:]]}"}
        if [[ ${clave,,} == "${1,,}" && -n $distro_respaldo && $distro == "$distro_respaldo" ]]; then
            valor_respaldo=$valor
            continue
        fi
        if [[ ${clave,,} == "${1,,}" && $distro == "$distro_diccionario" ]]; then
            equivalencia=1
            if [[ $valor == - ]]; then
                return 3
            fi
            # alternativas "a|b" del diccionario (19/10/2026): aca, la primera
            [[ -z $valor ]] || nombre=${valor%%|*}
            break
        fi
    done < "$archivo"
    if [[ $nombre == "$1" && -n $valor_respaldo && $valor_respaldo != - ]]; then
        nombre=$valor_respaldo
        equivalencia=1
    elif [[ $nombre == "$1" && $valor_respaldo == - ]]; then
        return 3
    fi
    if ((exigir_equivalencia && !equivalencia)); then
        error "no hay equivalencia de $1 para $distro_diccionario en diccionariodepaquetes"
        return 2
    fi
    printf '%s' "$nombre"
}

resolver_simusol() {
    local archivo nombre pedido
    archivo=${SP_PROYECTOS:-}
    if [[ -z $archivo ]]; then
        for archivo in \
            "$SUMMAPACK_ROOT/share/summapack/data/proyectos-simusol" \
            "$DIR_PROGRAMA/../share/summapack/data/proyectos-simusol" \
            /usr/share/summapack/data/proyectos-simusol \
            /usr/local/share/summapack/data/proyectos-simusol; do
            [[ -r $archivo ]] && break
        done
    fi
    [[ -r $archivo ]] || { error 'no encuentro proyectos-simusol de SummaPack'; return 2; }
    while IFS=: read -r nombre pedido; do
        [[ -n $nombre && $nombre != \#* ]] || continue
        if [[ $nombre == "$1" ]]; then printf '%s' "$pedido"; return 0; fi
    done < "$archivo"
    return 1
}

validar_paquetes() {
    local nombre resuelto estado
    local -a equivalentes
    (($#)) || { error 'indique al menos un paquete'; return 2; }
    PAQUETES_RESUELTOS=()
    PAQUETES_OMITIDOS=()
    for nombre in "$@"; do
        [[ -n $nombre && $nombre != -* ]] || {
            error "nombre de paquete inválido: $nombre"
            return 2
        }
        if resuelto=$(resolver_paquete "$nombre"); then
            read -r -a equivalentes <<< "$resuelto"
            ((${#equivalentes[@]})) || { error "equivalencia vacía para $nombre"; return 2; }
            PAQUETES_RESUELTOS+=("${equivalentes[@]}")
        else
            estado=$?
            if ((estado == 3)) && [[ $operacion == install || $operacion == buildtools ]]; then
                PAQUETES_OMITIDOS+=("$nombre")
            elif ((estado == 3)); then
                error "$nombre no tiene paquete en $distro_detectada según diccionariodepaquetes; se omite solo al instalar dependencias"
                return 2
            else
                return 2
            fi
        fi
    done
}

mostrar_comando() {
    local prefijo=$1
    shift
    if ((ensayo)); then
        printf 'Ensayo:' >&2
    else
        printf 'Ejecutando:' >&2
    fi
    [[ -n $prefijo ]] && printf ' %s' "$prefijo" >&2
    printf ' %q' "$@" >&2
    printf '\n' >&2
}

ejecutar() {
    local requiere_privilegios=$1
    shift
    local prefijo=
    if ((requiere_privilegios)) && ((EUID != 0)); then
        if command -v sudo >/dev/null 2>&1; then
            prefijo=sudo
        elif ((!ensayo)); then
            error 'esta operación necesita privilegios; ejecute como root o instale/configure sudo'
            return 1
        else
            prefijo=sudo
        fi
    fi
    mostrar_comando "$prefijo" "$@"
    ((ensayo)) && return 0
    if [[ $prefijo == sudo ]]; then
        sudo -- "$@"
    else
        "$@"
    fi
}

validar_busqueda() {
    (($#)) || { error 'indique el texto de búsqueda'; return 2; }
    BUSQUEDA=$*
    [[ $BUSQUEDA != -* ]] || { error 'el texto de búsqueda no puede comenzar con guion'; return 2; }
}

ejecutar_packlet_sin_preparar() {
    local orden=$1 privilegios=$2; shift 2
    local packlet=$DIR_PACKLETS/$familia.sh
    [[ -x $packlet ]] || { error "no hay packlet para $familia"; return 2; }
    if ((!ensayo)); then gestor_disponible || return 3; fi
    if ((ensayo)); then
        SP_ENSAYO=1 SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" "$orden" "$@"
    elif ((privilegios)) && ((EUID != 0)); then
        command -v sudo >/dev/null 2>&1 || { error 'esta operación necesita root o sudo'; return 1; }
        sudo -- env SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" "$orden" "$@"
    else
        SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" "$orden" "$@"
    fi
}

refrescar_indices() {
    if [[ $familia == pacman ]] && ((sin_upgrade)); then
        error 'Pacman sincroniza y actualiza juntos; use sp update para hacerlo explícitamente'
        return 2
    fi
    ejecutar_packlet_sin_preparar refresh 1 || return $?
    registrar_marca "$sello_refresco"
}

ejecutar_packlet() {
    local orden=$1 privilegios=$2; shift 2
    case $orden in
        refresh) refrescar_indices; return $? ;;
        update|distupdate)
            if [[ $familia != pacman ]] && ! marca_vigente "$sello_refresco"; then
                refrescar_indices || return $?
            fi
            ejecutar_packlet_sin_preparar "$orden" "$privilegios" "$@" || return $?
            if [[ $familia == pacman ]]; then registrar_marca "$sello_refresco"; fi
            return $? ;;
        install|buildtools)
            # En Arch una sincronización implica una actualización completa.
            # Usar aquí los índices locales y dejar -Syu para la orden expresa.
            if [[ $familia != pacman ]] && ! marca_vigente "$sello_refresco"; then
                refrescar_indices || return $?
            fi ;;
    esac
    ejecutar_packlet_sin_preparar "$orden" "$privilegios" "$@" || return $?
    if ((!ensayo)) && [[ $orden == addrepo || $orden == delrepo ]]; then
        rm -f -- "$sello_refresco"
    fi
}

despachar_conjunto() {
    local conjunto=${1^^}; shift
    (($# == 0)) || { error "$conjunto no admite argumentos adicionales"; return 2; }
    case $conjunto in
        WORLD) ejecutar_packlet update 1 ;;
        SYSTEM) ejecutar_packlet distupdate 1 ;;
        CACHE) ejecutar_packlet refresh 1 ;;
        ALL) error 'install ALL todavía no está instrumentado en el modelo de SummaPack'; return 2 ;;
        *) return 1 ;;
    esac
}

despachar_archivo() {
    local tipo=${1^^}; shift
    (($#)) || { error "falta archivo para el objeto $tipo"; return 2; }
    case $tipo in
        TGZ)
            local packlet=$DIR_PACKLETS/tgz.sh
            if ((!ensayo)) && ((EUID != 0)); then
                command -v sudo >/dev/null 2>&1 || { error 'instalar TGZ necesita root o sudo'; return 1; }
                sudo -- env SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" install "$@"
            else
                SP_ENSAYO=$ensayo SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" install "$@"
            fi
            ;;
        DEB)
            [[ $familia == apt ]] || { error 'el objeto DEB requiere una distribución APT'; return 2; }
            local -a archivos=()
            local archivo
            for archivo in "$@"; do
                [[ $archivo == *.deb && -f $archivo ]] || { error "no es un archivo DEB existente: $archivo"; return 2; }
                if [[ $archivo == /* ]]; then archivos+=("$archivo"); else archivos+=("./$archivo"); fi
            done
            ejecutar_packlet_sin_preparar install-local-deb 1 "${archivos[@]}"
            ;;
        RPM)
            [[ $familia == dnf || $familia == zypper ]] || { error 'el objeto RPM requiere Fedora o SUSE'; return 2; }
            local -a archivos=()
            local archivo
            for archivo in "$@"; do
                [[ $archivo == *.rpm && -f $archivo ]] || { error "no es un archivo RPM existente: $archivo"; return 2; }
                if [[ $archivo == /* ]]; then archivos+=("$archivo"); else archivos+=("./$archivo"); fi
            done
            ejecutar_packlet_sin_preparar install-local-rpm 1 "${archivos[@]}"
            ;;
        *) error "tipo de objeto no instrumentado: $tipo"; return 2 ;;
    esac
}

despachar_summa() {
    local tipo=${1^^}; shift
    (($#)) || { error "falta proyecto o archivo para $tipo"; return 2; }
    if [[ $tipo == SOURCE && $# == 1 && $fuente_dada != sitio ]]; then
        local formato=
        case $1 in
            *.tar.gz|*.tar.xz|*.tar.bz2)
                if [[ -f $1 && -z $prefijo_dado && ${para_dada:-fuentes-paquete} == fuentes-paquete ]]; then formato=gnu; fi ;;
            *.dsc) [[ ! -f $1 ]] || formato=deb ;;
            *.src.rpm) [[ ! -f $1 ]] || formato=rpm ;;
            */PKGBUILD|PKGBUILD) [[ ! -f $1 ]] || formato=arch ;;
            */*|.|..) [[ ! -f $1/debian/changelog || ! -f $1/debian/control ]] || formato=deb ;;
        esac
        if [[ -n $formato ]]; then
            [[ -z $prefijo_dado && ${para_dada:-fuentes-paquete} == fuentes-paquete ]] || {
                error 'un paquete fuente de distribución se instala vía paquete'; return 2; }
            case $formato/$familia in
                gnu/*|deb/apt|rpm/dnf|rpm/zypper|arch/pacman) ;;
                *) error "el paquete fuente $formato no corresponde al gestor $familia"; return 2 ;;
            esac
            SP_ENSAYO=$ensayo SP_FUENTE_DIR="$1" SP_FAMILIA=$familia "$DIR_PACKLETS/fuente-$formato.sh" install
            return $?
        fi
    fi
    local packlet=$DIR_PACKLETS/summapack.sh orden
    case $tipo in SUMMA) orden=install-summa ;; SOURCE) orden=install-source ;; esac
    # --para fuentes o fuentes-paquete: desde las fuentes; --arbol tambien
    case $para_dada in fuentes|fuentes-paquete) orden=install-source ;; esac
    if [[ -n $arbol_dado && -z $para_dada ]]; then orden=install-source; fi
    # DEL ARBOL SE INSTALA COMO PAQUETE, no con make install suelto. Pedido
    # del autor, 19/11/2026: "mi camino es del arbol, make install, via
    # paquete". Importa donde quedan los archivos: 'fuentes' instala en
    # /usr/local y hay proyectos que solo andan en /usr --dia-simusol pone
    # sus cosas en /usr/share/dia y Dia solo lee las de su propio prefijo--,
    # asi que una instalacion en /usr/local queda invisible sin que nada lo
    # avise. 'fuentes-paquete' compila aca y arma e instala el paquete de la
    # distribucion, que va a /usr. Con --para explicito manda lo que se pida.
    if [[ -z $para_dada && -n $arbol_dado ]]; then
        para_dada=fuentes-paquete
    fi
    if [[ -n $prefijo_dado ]]; then
        # --prefijo es de la instalacion desde fuentes (make install con
        # --prefix): con un paquete nativo no tiene sentido
        [[ $orden == install-source && $para_dada != fuentes-paquete ]] || {
            error '--prefijo es solo para --para fuentes (make install); un paquete nativo va a /usr'; return 2; }
    fi
    # con un prefijo que el usuario puede escribir (p.ej. ~/.local) no hace
    # falta root: make install corre como uno mismo
    local sin_root=0
    [[ $orden == install-source && $para_dada == fuentes-paquete ]] && sin_root=1
    if [[ -n $prefijo_dado ]]; then
        local padre=$prefijo_dado
        while [[ ! -d $padre ]]; do padre=$(dirname "$padre"); done
        [[ -w $padre ]] && sin_root=1
    fi
    if ((!ensayo)) && ((EUID != 0)) && ((!sin_root)); then
        command -v sudo >/dev/null 2>&1 || { error "instalar $tipo necesita root o sudo"; return 1; }
        sudo -- env SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" SP_FAMILIA="$familia" SP_PARA="$para_dada" SP_ARBOL="$arbol_dado" SP_FUENTE="$fuente_dada" SP_REFRESCAR="$refrescar" SP_PREFIJO="$prefijo_dado" "$packlet" "$orden" "$@"
    else
        SP_ENSAYO=$ensayo SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" SP_FAMILIA="$familia" SP_PARA="$para_dada" SP_ARBOL="$arbol_dado" SP_FUENTE="$fuente_dada" SP_REFRESCAR="$refrescar" SP_PREFIJO="$prefijo_dado" "$packlet" "$orden" "$@"
    fi
}

despachar_cpan() {
    local modulo
    (($#)) || { error 'CPAN requiere al menos un módulo Perl'; return 2; }
    for modulo in "$@"; do
        [[ $modulo =~ ^[A-Za-z_][A-Za-z_0-9]*(::[A-Za-z_][A-Za-z_0-9]*)*$ ]] || {
            error "nombre de módulo Perl inválido: $modulo"
            return 2
        }
    done
    for modulo in "$@"; do
        if perl "-M$modulo" -e 1 >/dev/null 2>&1; then
            printf '%s: módulo Perl ya disponible: %s\n' "$PROGRAMA" "$modulo" >&2
            continue
        fi
        if ((!ensayo)); then
            command -v cpanm >/dev/null 2>&1 || { error 'falta cpanm para instalar módulos Perl'; return 3; }
        fi
        ejecutar 1 cpanm "$modulo" || return $?
    done
}

despachar_perl() {
    local modulo archivo clave distro nombre _ paquete resuelto
    local -a equivalentes
    (($#)) || { error 'PERL requiere al menos un módulo'; return 2; }
    archivo=${SUMMAPACK_DICCIONARIO:-}
    if [[ -z $archivo ]]; then
        for archivo in \
            "$SUMMAPACK_ROOT/share/summapack/data/diccionariodepaquetes" \
            /usr/share/summapack/data/diccionariodepaquetes \
            /usr/local/share/summapack/data/diccionariodepaquetes; do
            [[ -r $archivo ]] && break
        done
    fi
    [[ -r $archivo ]] || { error 'no encuentro diccionariodepaquetes'; return 2; }
    for modulo in "$@"; do
        [[ $modulo =~ ^[A-Za-z_][A-Za-z_0-9]*(::[A-Za-z_][A-Za-z_0-9]*)*$ ]] || {
            error "nombre de módulo Perl inválido: $modulo"; return 2;
        }
        if perl "-M$modulo" -e 1 >/dev/null 2>&1; then
            printf '%s: módulo Perl ya disponible: %s\n' "$PROGRAMA" "$modulo" >&2
            continue
        fi
        paquete=
        while IFS=: read -r clave distro nombre _; do
            [[ $distro == PERL && -n $clave ]] || continue
            if [[ ${nombre//--/::} == "$modulo" ]]; then paquete=$clave; break; fi
        done < "$archivo"
        if [[ -n $paquete ]]; then
            resuelto=$(resolver_paquete "$paquete") || return $?
            if [[ $familia == apt || $resuelto != "$paquete" ]]; then
                read -r -a equivalentes <<< "$resuelto"
                ((${#equivalentes[@]})) || { error "equivalencia vacía para $paquete"; return 2; }
                ejecutar_packlet install 1 "${equivalentes[@]}" || return $?
                continue
            fi
        fi
        despachar_cpan "$modulo" || return $?
    done
}

# el arranque del arbol: dependencias, paquete, instalacion (ver arriba)
# lo minimo para fabricar un paquete de summapack con sp paquete (svn
# dpkg-buildpackage dh fakeroot autoreconf libtoolize gcc) mas lo que usan
# sus reglas. Los nombres se traducen por distribucion.
HERRAMIENTAS_PAQUETE=(subversion dpkg-dev debhelper fakeroot autoconf automake
    libtool pkg-config gcc make rsync python3 gzip sed grep)
# las ordenes sin las cuales sp paquete no arma el paquete normal. Si falta
# alguna queda el
# paquete minimo (hacer-pkg-minimo), que no necesita ninguna.
ORDENES_PAQUETE=(svn dpkg-buildpackage dh fakeroot autoreconf libtoolize gcc)

summapack_instalado() {
    case $familia in
        apt)    [[ $(dpkg-query -W -f='${Status}' summapack 2>/dev/null) == *' installed'* ]] ;;
        dnf|zypper) rpm -q summapack >/dev/null 2>&1 ;;
        *)      command -v bajar-paquetes >/dev/null 2>&1 ;;
    esac
}

# La version instalada; vacia si no se la puede averiguar (sin gestor de
# paquetes solo se sabe si esta o no esta).
summapack_version_instalada() {
    case $familia in
        apt)        dpkg-query -W -f='${Version}' summapack 2>/dev/null ;;
        dnf|zypper) rpm -q --qf '%{VERSION}-%{RELEASE}' summapack 2>/dev/null ;;
    esac
}

# ¿Esta instalado este paquete? 0 si esta, 1 si falta, 2 si no se puede
# preguntar (sin gestor de paquetes que lleve una lista).
paquete_instalado() {
    case $familia in
        apt)        [[ $(dpkg-query -W -f='${Status}' "$1" 2>/dev/null) == *' installed'* ]] ;;
        dnf|zypper) rpm -q "$1" >/dev/null 2>&1 ;;
        *)          return 2 ;;
    esac
}

# ¿La primera version es mas vieja que la segunda? Con el comparador del
# gestor donde lo hay; si no, con el orden de version de sort.
version_mas_vieja() {
    case $familia in
        apt) dpkg --compare-versions "$1" lt "$2" ;;
        *)   [[ $1 != "$2" && $(printf '%s\n%s\n' "$1" "$2" | sort -V | head -n1) == "$1" ]] ;;
    esac
}

cartel_instalado() {
    ((ensayo == 0)) || return 0
    printf '\n========================================\n%s instalado%s\n' "$1" "${2:-}"
}

if ((autoinstalar)); then
    # la version del arbol: la que se instalaria
    sp_version=$DIR_PROGRAMA/sp-version
    [[ -x $sp_version ]] || sp_version=$SUMMAPACK_ROOT/bin/sp-version
    [[ -x $sp_version ]] || { error 'falta sp-version (de summapack)'; exit 1; }
    version=$("$sp_version" "$SUMMAPACK_ROOT") || exit 1

    if summapack_instalado; then
        # instalado: se actualiza solo si el arbol trae una version mas nueva.
        # Si no se puede averiguar cual esta instalada no se adivina: falta la
        # operacion, como siempre. Pedido del autor, 02/11/2026.
        instalada=$(summapack_version_instalada)
        if [[ -z $instalada ]] || ! version_mas_vieja "$instalada" "$version"; then
            error 'falta la operación'
            uso >&2
            exit 2
        fi
        printf '%s: summapack instalado es %s y el arbol trae %s; se arma desde %s y se actualiza\n' \
            "$PROGRAMA" "$instalada" "$version" "$SUMMAPACK_ROOT" >&2
    else
        printf '%s: summapack no esta instalado; se arma desde %s y se instala\n' \
            "$PROGRAMA" "$SUMMAPACK_ROOT" >&2
    fi

    # 1. lo que hace falta para fabricar paquetes. Con internet se instala lo
    # que falte; sin internet tiene que poder seguir igual, asi que primero se
    # mira que falta y solo se llama al gestor si hay algo que traer: estando
    # todo, no se refresca ni se actualiza la distribucion y no se usa la red.
    # Pedido del autor, 02/11/2026.
    validar_paquetes "${HERRAMIENTAS_PAQUETE[@]}" || exit $?
    faltantes=()
    for herramienta in "${PAQUETES_RESUELTOS[@]}"; do
        # 2 (no se puede preguntar): que decida el gestor, como antes
        paquete_instalado "$herramienta" || faltantes+=("$herramienta")
    done
    if ((${#faltantes[@]})); then
        printf '%s: faltan herramientas para fabricar el paquete: %s\n' \
            "$PROGRAMA" "${faltantes[*]}" >&2
        ejecutar_packlet install 1 "${faltantes[@]}" || {
            error "no se pudieron instalar: ${faltantes[*]}"
            error 'se sigue con lo que haya en la maquina'
        }
    else
        printf '%s: las herramientas para fabricar el paquete ya estan; no se usa la red\n' \
            "$PROGRAMA" >&2
    fi

    # 1b. si no estan las ordenes que sp paquete exige para el paquete normal,
    # queda el ultimo recurso: los paquetes minimos, escritos a mano con
    # herramientas propias (bash, tar, gzip y python3; dpkg-deb si esta, que
    # es el exacto) en los tres formatos --deb, rpm y tgz-- e instalado el que
    # entienda el gestor de la maquina, o puestos los archivos en su lugar si
    # no hay gestor ni descompresores. Son los de summapack y, si hay
    # compilador, los de la biblioteca mem_util tambien. El recorrido completo
    # esta en doc/instalar-sin-red-ni-herramientas.md. Pedido del autor,
    # 02/11/2026.
    faltan_ordenes=()
    for orden_paquete in "${ORDENES_PAQUETE[@]}"; do
        command -v "$orden_paquete" >/dev/null 2>&1 || faltan_ordenes+=("$orden_paquete")
    done
    if ((${#faltan_ordenes[@]})); then
        printf '%s: no estan %s: se arman a mano los paquetes minimos, con herramientas propias\n' \
            "$PROGRAMA" "${faltan_ordenes[*]}" >&2
        minimo=$SUMMAPACK_ROOT/bin/hacer-pkg-minimo
        [[ -x $minimo ]] || { error 'falta bin/hacer-pkg-minimo (de summapack)'; exit 1; }
        if ((ensayo)); then
            "$minimo" --prueba --instalar "$SUMMAPACK_ROOT"
            exit $?
        fi
        "$minimo" --instalar "$SUMMAPACK_ROOT" || exit $?
        cartel_instalado sp " (SummaPack $version)"
        exit 0
    fi

    # 2. el paquete, con la version del arbol (sp paquete)
    subir=$DIR_PROGRAMA/sp-subir
    [[ -x $subir ]] || subir=$SUMMAPACK_ROOT/bin/sp-subir
    [[ -x $subir ]] || { error 'falta sp-subir (de summapack)'; exit 1; }
    if ((ensayo)); then
        printf '%s: [ensayo] %s --paquete-modo %s/summapack\n' "$PROGRAMA" "$subir" "$SUMMAPACK_ROOT" >&2
    else
        "$subir" --paquete-modo "$SUMMAPACK_ROOT/summapack" || { error 'no se pudo armar el paquete'; exit 1; }
    fi

    # 3. instalar lo que se acaba de armar
    case $familia in
        apt)        tipo=DEB; patron=("$SUMMAPACK_ROOT"/*_"$version"_*.deb) ;;
        dnf|zypper) tipo=RPM; patron=("$SUMMAPACK_ROOT"/*-"$version".*.rpm) ;;
        *)          tipo=TGZ; patron=("$SUMMAPACK_ROOT"/*_"$version"_*.tgz) ;;
    esac
    armados=()
    for f in ${patron[@]+"${patron[@]}"}; do [[ -f $f ]] && armados+=("$f"); done
    ((${#armados[@]})) || {
        if ((ensayo)); then
            printf '%s: [ensayo] instalar los %s de %s que deje el paso 2\n' "$PROGRAMA" "$tipo" "$version" >&2
            exit 0
        fi
        error "el paso 2 no dejo ningun $tipo de la version $version en $SUMMAPACK_ROOT"
        exit 1
    }
    despachar_archivo "$tipo" "${armados[@]}" || exit $?
    cartel_instalado sp " (SummaPack $version)"
    exit 0
fi

if [[ $operacion == estado || ( $operacion == install && $# == 1 && ${1:-} == todos ) ]]; then
    if [[ $operacion == estado && $# != 0 ]]; then error "uso: sp estado"; exit 2; fi
    catalogo=$SUMMAPACK_ROOT/share/summapack/data/conjunto-siru-calcula
    [[ -r $catalogo ]] || { error "falta $catalogo"; exit 1; }
    proyectos=()
    faltan=0
    while IFS=: read -r proyecto binarios; do
        [[ -n $proyecto && $proyecto != \#* ]] || continue
        proyectos+=("$proyecto")
        [[ $operacion == estado ]] || continue
        for binario in $binarios; do
            case $familia in
                apt) dato=$(dpkg-query -W -f='${Status} ${Version}' "$binario" 2>/dev/null) || dato=
                     case $dato in 'install ok installed '*) dato=${dato#install ok installed } ;; *) dato= ;; esac ;;
                dnf|zypper|urpmi) dato=$(rpm -q --qf '%{VERSION}-%{RELEASE}' "$binario" 2>/dev/null) || dato= ;;
                pacman) dato=$(pacman -Q "$binario" 2>/dev/null) || dato= ;;
                *) dato= ;;
            esac
            if [[ -z $dato && -r /var/lib/summapack/tgz/$binario.version ]]; then
                read -r dato < "/var/lib/summapack/tgz/$binario.version"
            fi
            if [[ -z $dato ]]; then dato=pendiente; faltan=$((faltan+1)); fi
            printf '%-23s %-23s %s\n' "$proyecto" "$binario" "$dato"
        done
    done < "$catalogo"
    if [[ $operacion == estado ]]; then
        printf '%s proyectos; %s paquetes pendientes\n' "${#proyectos[@]}" "$faltan"
        ((faltan == 0)); exit $?
    fi
    despachar_summa SUMMA "${proyectos[@]}"
    exit $?
fi

case $operacion in
    install)
        (($#)) || { error 'install requiere paquetes u objeto'; exit 2; }
        case ${1^^} in
            WORLD|SYSTEM|ALL|CACHE) despachar_conjunto "$@"; exit $? ;;
            REPO) shift; ejecutar_packlet addrepo 1 "$@"; exit $? ;;
            SUMMA|SOURCE) tipo=$1; shift; despachar_summa "$tipo" "$@"; exit $? ;;
            CPAN|PERL|DEB|RPM|TGZ)
                tipo=${1^^}; shift
                case $tipo in
                    CPAN) despachar_cpan "$@" ;;
                    PERL) despachar_perl "$@" ;;
                    DEB|RPM|TGZ) despachar_archivo "$tipo" "$@" ;;
                esac || exit $?
                for objeto in "$@"; do cartel_instalado "${objeto##*/}"; done
                exit 0 ;;
            EBUILD|PKG|TXZ|TBZ|SVN|CPAN|SH|LSH|COMMAND)
                error "objeto $1 todavía no tiene packlet instrumentado"; exit 2 ;;
            PAQ|PACKAGES) shift ;;
        esac
        paquetes_externos=() paquetes_simusol=()
        for nombre in "$@"; do
            if pedido=$(resolver_simusol "$nombre"); then
                paquetes_simusol+=("$pedido")
            else
                estado=$?
                ((estado == 1)) || exit "$estado"
                paquetes_externos+=("$nombre")
            fi
        done
        if ((${#paquetes_externos[@]})); then
            validar_paquetes "${paquetes_externos[@]}" || exit $?
        else
            PAQUETES_RESUELTOS=() PAQUETES_OMITIDOS=()
        fi
        ((${#PAQUETES_OMITIDOS[@]} == 0)) || printf '%s: no hace falta en %s: %s\n' "$PROGRAMA" "$distro_detectada" "${PAQUETES_OMITIDOS[*]}" >&2
        if ((${#PAQUETES_RESUELTOS[@]})); then
            ejecutar_packlet install 1 "${PAQUETES_RESUELTOS[@]}" || exit $?
            for nombre in "${PAQUETES_RESUELTOS[@]}"; do cartel_instalado "$nombre"; done
        fi
        if [[ $fuente_dada == arbol && ${para_dada:-fuentes-paquete} == fuentes-paquete ]] && ((${#paquetes_simusol[@]})); then
            despachar_summa SUMMA "${paquetes_simusol[@]}"
            exit $?
        fi
        for pedido in "${paquetes_simusol[@]}"; do
            despachar_summa SUMMA "$pedido" || exit $?
        done
        exit 0
        ;;
    remove)
        (($#)) || { error 'remove requiere paquetes u objeto'; exit 2; }
        case ${1^^} in
            REPO) shift; ejecutar_packlet delrepo 1 "$@"; exit $? ;;
            TGZ)
                shift
                (($#)) || { error 'remove TGZ requiere el nombre del paquete'; exit 2; }
                packlet=$DIR_PACKLETS/tgz.sh
                if ((!ensayo)) && ((EUID != 0)); then sudo -- env SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" remove "$@"; else SP_ENSAYO=$ensayo SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" remove "$@"; fi
                exit $? ;;
            PAQ|PACKAGES) shift ;;
            DEB|RPM|EBUILD|SUMMA|PKG|TXZ|TBZ|SOURCE|SVN|CPAN|SH|LSH|COMMAND)
                error "remove no admite el objeto de archivo $1; indique el nombre del paquete instalado"; exit 2 ;;
        esac
        validar_paquetes "$@" || exit $?
        ejecutar_packlet remove 1 "${PAQUETES_RESUELTOS[@]}"
        exit $?
        ;;
    clean)
        (($# == 1)) || { error 'clean requiere WORLD o CACHE'; exit 2; }
        case ${1^^} in
            WORLD) ejecutar_packlet depclean 1 ;;
            CACHE) ejecutar_packlet clean 1 ;;
            *) error 'clean admite WORLD o CACHE en esta etapa'; exit 2 ;;
        esac
        exit $?
        ;;
    fix)
        (($# <= 1)) || { error 'fix admite como máximo WORLD o SYSTEM'; exit 2; }
        if (($#)) && [[ ${1^^} != WORLD && ${1^^} != SYSTEM ]]; then error 'fix admite WORLD o SYSTEM'; exit 2; fi
        ejecutar_packlet fix 1
        exit $?
        ;;
    search)
        [[ ${1:-} == NAMES || ${1:-} == NAME ]] && shift
        orden=search
        if [[ ${1:-} == all || ${1:-} == ALL ]]; then orden=search-all; shift; fi
        validar_busqueda "$@" || exit $?
        ejecutar_packlet "$orden" 0 "$BUSQUEDA"
        exit $?
        ;;
    info)
        (($#)) || { error 'info requiere paquetes u objeto'; exit 2; }
        if (($# == 1)) && [[ ${1^^} == WORLD || ${1^^} == SYSTEM || ${1^^} == ALL || ${1^^} == CACHE ]]; then
            ejecutar_packlet stats 0
            exit $?
        fi
        case ${1^^} in
            TGZ) packlet=$DIR_PACKLETS/tgz.sh; SP_ENSAYO=$ensayo SP_SUMMAPACK_ROOT="$SUMMAPACK_ROOT" "$packlet" info; exit $? ;;
            PAQ|PACKAGES) shift ;;
            DEB|RPM|EBUILD|SUMMA|PKG|TXZ|TBZ|SOURCE|SVN|CPAN|SH|LSH|COMMAND)
                error "info no tiene packlet para el objeto $1"; exit 2 ;;
        esac
        validar_paquetes "$@" || exit $?
        ejecutar_packlet info 0 "${PAQUETES_RESUELTOS[@]}"
        exit $?
        ;;
    update|distupdate|refresh|depclean|buildtools)
        (($# == 0)) || { error "$operacion no recibe argumentos"; exit 2; }
        case $operacion in
            update) ejecutar_packlet update 1 ;;
            distupdate) ejecutar_packlet distupdate 1 ;;
            refresh) ejecutar_packlet refresh 1 ;;
            depclean) ejecutar_packlet depclean 1 ;;
            buildtools)
                herramientas=(build-essential gfortran cmake autoconf automake libtool pkg-config
                    bison flex git curl tar gzip xz-utils python3 perl dpkg-dev debhelper fakeroot
                    rpm rsync findutils which file diffutils ca-certificates patchelf m4
                    bzip2 libgsl-dev libopenblas-dev libsuitesparse-dev libpcre2-dev
                    libreadline-dev libncurses-dev)
                validar_paquetes "${herramientas[@]}" || exit $?
                ejecutar_packlet buildtools 1 "${PAQUETES_RESUELTOS[@]}"
                ;;
        esac
        exit $?
        ;;
    addrepo|delrepo)
        (($#)) || { error "$operacion requiere un repositorio"; exit 2; }
        case $operacion in addrepo) ejecutar_packlet addrepo 1 "$@" ;; delrepo) ejecutar_packlet delrepo 1 "$@" ;; esac
        exit $?
        ;;
    *)
        error "acción desconocida: $operacion"
        uso >&2
        exit 2
        ;;
esac
