Ir al contenido
Molto

Dependencias

Versiones exactas, las dos tablas de dependencias, los tres tipos de recipe, Molto.lock y las cachés que hay detrás.

[deps]
sqlite = "3.53.4"                        # una coordenada de registry, en esa versión exacta
gtk    = "4.14.0"                        # un paquete de plataforma: el GTK de cada plataforma
http   = { path = "modules/http" }       # un directorio en el que estás trabajando

[dev-deps]
moltest = { git = "https://github.com/moltobuild/moltest", tag = "v0.3.0" }  # sólo en tests/
molto add sqlite                        # la última release, escrita en el manifiesto como exacta
molto add sqlite@3.53.4                 # esa
molto add git+https://github.com/moltobuild/moltest#v0.3.0 -d   # un tag de git, a [dev-deps]
molto add tinytest --dev --path ../tt   # un directorio local, a [dev-deps]
molto remove sqlite

Dependencias de desarrollo que conviene conocer

Tres paquetes del ecosistema Molto existen para usarse como [dev-deps]. Ninguno llega a lo que distribuyes:

Paquete Qué es
moltest El framework de tests que prepara molto new: registra los tests y es dueño de main() (mode = "single")
moltest_coverage Cierra molto test --profile coverage con un informe, lcov y JSON, y un umbral opcional
moltest_mock Fakes para los archivos de [[test.isolated]], los tests que enlazan sin las fuentes que sustituyen
[dev-deps]
moltest          = { git = "https://github.com/moltobuild/moltest", tag = "v0.3.0" }
moltest_coverage = { git = "https://github.com/moltobuild/moltest-coverage", tag = "v0.2.1" }
moltest_mock     = { git = "https://github.com/moltobuild/moltest-mock", tag = "v0.4.0" }

Cuatro reglas sostienen casi todo el comportamiento

Las versiones son exactas. ^, ~ y >= se rechazan, no se interpretan. Un rango dejaría entrar en tu build una release que nadie ha leído, sin diff.

Una versión por paquete, contando las dos tablas a la vez. Un binario de tests enlaza los objetos de src/ junto a los de los tests, y dos versiones ahí son símbolos duplicados.

Las dependencias de desarrollo no son transitivas, y sus directorios de include se ponen únicamente en la línea de comandos que compila tests/. Un archivo de src/ que incluya una de ellas falla al compilar, en el primer build. Esa es la garantía, no una convención documentada.

Ambas tablas fallan en cerrado. Una clave desconocida, dos orígenes, un rango o una clave especificada pero no implementada (artifact, optional, features, default_features) es un error que nombra la dependencia: justo lo contrario que la mayor parte del manifiesto, que descarta lo que no conoce.

Declarar una

[deps]
yyjson = "1.2.32"                                              # atajo de { version = … }
sqlite = { git = "https://github.com/sqlite/sqlite", tag = "3.50.0" }
http   = { path = "modules/http" }
zlib   = { archive = "https://…", sha256 = "…" }
fast   = { version = "2.0.0", registry = "myorg" }

[registries]
myorg = "https://registry.example.com"

Claves de origen, hace falta exactamente una: version, git, path o archive. Modificadores: branch / tag / rev junto a git y como mucho uno de ellos, sha256 obligatorio con archive, y registry, que debe estar declarado en [registries].

Las opciones de molto add se llaman igual que las claves, así que lo que tecleas y lo que acaba en el manifiesto coinciden. add y remove editan líneas en vez de reescribir el archivo: los comentarios, la alineación y el orden de las claves sobreviven, volver a añadir un nombre con otra versión lo sustituye en su sitio, y cualquier edición que dejaría un manifiesto ilegible se rechaza antes de tocar el archivo.

recipe.toml

Una dependencia que no es un paquete Molto se describe con un recipe: lo sirve el registry para una coordenada, o está en la raíz del código de una dependencia path o git, que sin él se rechaza con exactamente ese mensaje. Un recipe tiene una de tres formas, declarada en vez de deducida:

form Qué describe Lo consume Molto
source Fuentes que se descargan y compilan como parte de tu build: SQLite, zlib, libpng Sí
platform Archivos que ya publica el repositorio de cada plataforma: GTK Sí
binary Un artefacto ya construido y guardado en el registry: toolchains y herramientas Lo usa pickup

Un recipe de fuentes

schema  = 1
form    = "source"
kind    = "package"
name    = "sqlite"
version = "3.53.4"
target  = "any"

[source]
archive = "https://sqlite.org/2025/sqlite-amalgamation-3530400.zip"
sha256  = "…"
compression_format = "zip"                     # zip | tar | tar.gz | tar.bz2 | tar.xz | tar.zst
strip_prefix = "sqlite-amalgamation-3530400"

[build]
system = "none"                                # make | cmake | autotools | meson | none

[artifacts]
type    = "source"                             # source | static | shared
sources = ["sqlite3.c"]
exclude = ["shell.c"]
include = ["."]
link    = ["m", "pthread"]
defines = ["SQLITE_THREADSAFE=1"]

Hoy sólo se puede consumir [artifacts] type = "source". Molto compila el código como unidades de traducción propias, fundiendo los includes, defines, flags y links del recipe en el build. static y shared se rechazan con un mensaje, y también cualquier [build] system que no sea none: nunca se ejecuta ningún sistema de build. Nada dentro de Molto invoca make, cmake ni meson.

Un recipe nunca lleva un script. Ni para descomprimir ni para construir. Por eso compression_format nombra un conjunto acotado y [build] nombra un sistema en lugar de una línea de comandos: un recipe capaz de ejecutar una cadena convertiría cada dependencia en una ejecución remota.

compression_format se declara, nunca se deduce: una URL puede acabar en .zip y servir un tarball. Ausente significa deducirlo de la extensión, para recipes escritos antes de que existiera la clave.

[[provide]] cubre la librería cuyo configure sólo escribe una cabecera que el propio proyecto ya trae con otro nombre: el pnglibconf.h de libpng, el config.h de pcre2. Copia a su sitio un archivo que el código ya contiene antes de compilar nada, sin leerlo y sin ejecutar nada:

[[provide]]
file = "pnglibconf.h"
from = "scripts/pnglibconf.h.prebuilt"

Un recipe de plataforma

molto add gtk

GTK es el caso que ninguna de las otras formas puede servir: construirlo exige ejecutar su propio sistema de build, y volver a alojarlo haría que el registry redistribuyera binarios que no construyó. Todas las plataformas ya lo publican, así que un recipe de plataforma fija, para cada una, los archivos exactos que sirve el repositorio de esa plataforma —cada uno con su SHA-256— y con qué compila y enlaza quien lo consume:

Plataforma Archivos Runtime
Ubuntu, Fedora, Arch Los paquetes de desarrollo: cabeceras y .pc El GTK propio de la máquina, enlazado por soname
Windows Paquetes de MSYS2, el cierre completo Incluido; las DLL se copian junto al ejecutable
macOS (arm64) Bottles de Homebrew, el cierre completo Incluido, encontrado mediante un rpath

Primero se pregunta a la máquina: si pkg-config encuentra GTK con sus cabeceras, se usa ese y no se descarga nada. Si no, Molto elige la plataforma que corresponde a esta máquina, descarga los archivos con curl a su caché, verifica cada digest y los desempaqueta él mismo: .deb, .rpm, paquetes de pacman y bottles. No se ejecuta ningún gestor de paquetes, ni nada de dentro de un paquete: los scripts de mantenedor y los hooks de instalación nunca se leen. Los bottles se reubican y se vuelven a firmar, porque sus rutas de librería nombran el prefijo de Homebrew.

Un recipe así es largo, así que se genera en vez de escribirse a mano: un script lee el índice de cada repositorio y fija el cierre. La especificación es la RFC-0022.

[about] es de donde sale la licencia de una dependencia, y molto metadata reporta exactamente lo que encuentre ahí. Un recipe que no declara ninguna produce un componente sin campo licenses: silencio en vez de una afirmación.

Resolución

  1. Lee [deps], [dev-deps] y Molto.lock si está.
  2. Para una coordenada, pregunta al registry una vez por nombre. Sin @<versión>, molto add elige la más nueva por precedencia semver, no por orden de cadena, y escribe ese número en el manifiesto.
  3. Descarga lo que no esté cacheado, recorre el [deps] de cada recipe y repite.
  4. Rechaza una resolución con la que el lock no esté de acuerdo; en caso contrario escribe Molto.lock.

Dos versiones de un mismo paquete es tu decisión, no la de Molto. No hay rango que ensanchar ni versión más alta que elegir, así que todo el trabajo del mensaje es decir quién pidió qué:

molto: sqlite is required at two versions
    3.50.3  ← your Project.toml
    3.53.4  ← required by http 1.2.0

Molto.lock

Se genera, se commitea, se ordena por nombre y con cada lista ordenada, de modo que su diff merezca leerse, que es justo el sentido de commitearlo.

version = 1
root = "app"

[[package]]
name = "a"
version = "1.0.0"
source = "registry+https://…"
checksum = "…"                # se omite en una dependencia path, nunca se escribe vacío
scopes = ["runtime", "dev"]
dependencies = ["b"]

Un lock ausente, ilegible, que no sea TOML válido o que venga de un formato más nuevo recibe el mismo trato: resolver otra vez. Un lock cuyas dependencias directas ya no coinciden con el manifiesto está caducado, y se vuelve a resolver en vez de parchearse.

Las cachés

Ruta (Linux y macOS) Qué
~/.cache/molto/sources/<nombre>/<versión>/<target> Un árbol descargado, una vez por coordenada, sellado al terminar
~/.cache/molto/objects Objetos compilados de dependencias, indexados por el comando de compilación completo
~/.cache/molto/platforms/<nombre>/<versión>/<plataforma> Un paquete de plataforma, desempaquetado y sellado
~/.cache/molto/downloads Los archivos de los que se hacen los paquetes de plataforma, por digest
~/.config/molto/credentials.toml El token del registry, modo 0600

En Windows todo vive bajo %APPDATA%\molto, con la caché en cache\. $MOLTO_CACHE reubica la caché y $MOLTO_HOME todo lo demás. Un directorio sin su sello son los restos de una descarga interrumpida: se borra, no se lee.

La caché de objetos cubre sólo dependencias. Reutilizar un objeto exige saber que la fuente y cada cabecera que incluye son idénticas, y en una dependencia la coordenada responde por el árbol inmutable entero. Las fuentes propias de un proyecto son mutables y su grafo de cabeceras se desconoce hasta que el compilador ha corrido: ese es el problema de ccache, y Molto no intenta ser uno. Una dependencia path queda fuera por la misma razón: sus bytes son lo que haya en disco ahora mismo.

Descargar delega en curl, tar, unzip y git, con el mismo razonamiento que delegar en un compilador en vez de enlazar uno, y en zstd para los paquetes de plataforma: todo Linux al que sirven lo trae de base, y en Windows Molto lo descarga una vez a su caché.

El registry

Las lecturas son públicas; sólo publicar necesita token. molto login cambia correo y contraseña por uno, o guarda con --token uno copiado de la página de cuenta. El token nunca aparece en argv: ps lo puede leer cualquiera, así que la cabecera va por un archivo de configuración de curl creado con permisos 0600 y borrado después.

molto publish envía primero el blob y al final la fila; --pack <dir> crea antes el archivo. Un recipe source o platform es el artefacto entero, así que se envía solo, sin archivo alguno. --dry-run lee y comprueba sin enviar nada, que es la única forma de revisar un recipe: una coordenada publicada es inmutable.