recipe: Implement run

.dockerignore

@@ -1,4 +0,0 @@
-target
-build
-.git
-*.bak

.gitignore

@@ -1,4 +1,2 @@
 /target
 /build
-*.bak
-*.lock

Cargo.toml

@@ -1,23 +1,15 @@
 [package]
-name = "distro"
+name = "builder"
 version = "0.1.0"
 edition = "2024"
-license = "MIT"
 
 [dependencies]
-anyhow = "1.0"
+allocative = "0.3.4"
-clap = { version = "4.5", features = ["derive"] }
+anyhow = "1.0.102"
-hex = "0.4"
+clap = { version = "4.6.1", features = ["derive"] }
-reqwest = { version = "0.12", default-features = false, features = [
+either = "1.16.0"
-    "blocking",
+petgraph = "0.8.3"
-    "rustls-tls",
+smallvec = "1.15.1"
-] }
+starlark = "0.13.0"
-serde = { version = "1.0", features = ["derive"] }
+starlark_derive = "0.13.0"
-serde_json = "1.0"
+thiserror = "2.0.18"
-sha2 = "0.10"
-shell-escape = "0.1"
-starlark = "0.13"
-starlark_derive = "0.13"
-allocative = "0.3"
-tempfile = "3.10"
-walkdir = "2.5"

Dockerfile

@@ -1,58 +0,0 @@
-FROM docker.io/library/alpine:edge
-
-RUN apk upgrade --no-cache && \
-    apk add --no-cache \
-    alpine-sdk \
-    apk-tools \
-    autoconf \
-    automake \
-    bash \
-    bc \
-    bison \
-    bzip2 \
-    ca-certificates \
-    cmake \
-    coreutils \
-    curl \
-    file \
-    findutils \
-    flex \
-    gettext-dev \
-    git \
-    gzip \
-    elfutils-dev \
-    gmp-dev \
-    mpfr-dev \
-    mpc1-dev \
-    libtool \
-    linux-headers \
-    meson \
-    ninja \
-    openssl \
-    openssl-dev \
-    patch \
-    pkgconf \
-    python3 \
-    tar \
-    texinfo \
-    xz \
-    zstd
-
-RUN rm -rf /tmp/mkpkg-root /tmp/distro-preflight.apk /tmp/APKINDEX.adb /tmp/distro-preflight.rsa && \
-    openssl genrsa -out /tmp/distro-preflight.rsa 2048 >/dev/null 2>&1 && \
-    openssl rsa -in /tmp/distro-preflight.rsa -pubout -out /etc/apk/keys/distro-preflight.rsa.pub >/dev/null 2>&1 && \
-    mkdir -p /tmp/mkpkg-root/usr/share/distro && \
-    printf ok > /tmp/mkpkg-root/usr/share/distro/preflight && \
-    apk --sign-key /tmp/distro-preflight.rsa mkpkg \
-    --files /tmp/mkpkg-root \
-    --output /tmp/distro-preflight.apk \
-    --info name:distro-preflight \
-    --info version:0-r0 \
-    --info arch:noarch \
-    --info description:preflight \
-    --info license:MIT >/dev/null && \
-    apk --sign-key /tmp/distro-preflight.rsa mkndx -o /tmp/APKINDEX.adb /tmp/distro-preflight.apk >/dev/null && \
-    test -s /tmp/distro-preflight.apk && \
-    test -s /tmp/APKINDEX.adb
-
-WORKDIR /work

LICENSE

@@ -1,18 +0,0 @@
-MIT License
-
-Copyright (c) 2026 marv7000
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
-associated documentation files (the "Software"), to deal in the Software without restriction, including 
-without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
-copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 
-following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial 
-portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
-LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
-EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
-USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,2 +0,0 @@
-# distro
-

config.star

@@ -1,36 +1,64 @@
-container_runtime = "podman"
+arch = "x86_64"
-container_image = "localhost/distro-builder:latest"
+libc = "glibc"
-container_dockerfile = "Dockerfile"
 
-signing_key = "build/keys/distro.rsa"
+if libc == "glibc":
-signing_pubkey = "build/keys/distro.rsa.pub"
+  env = "gnu"
+elif libc == "musl":
+  env = "musl"
+else:
+  fail(f"Unknown libc: {libc}")
 
-target_arch = "x86_64"
+prefix = path("/usr")
-libc = "musl"
 
-host_cflags = "-O2 -pipe"
+host_cflags = ["-O2", "-pipe"]
-host_cxxflags = ""
+host_cxxflags = host_cflags + []
-host_ldflags = "-Wl,-O1 -Wl,--sort-common -Wl,--as-needed"
+host_ldflags = ["-Wl,-O1", "-Wl,--sort-common", "-Wl,--as-needed"]
 
-target_cflags = host_cflags
+target_cflags = host_cflags + []
-target_cxxflags = host_cxxflags
+target_cxxflags = host_cxxflags + []
-target_ldflags = host_ldflags + " -Wl,-z,now"
+target_ldflags = host_ldflags + ["-Wl,-z,now"]
+
+if arch == "x86_64":
+  flags = [
+    "-march=x86-64-v3",
+    "-mtune=generic",
+    "-fstack-clash-protection",
+    "-fstack-protector-strong",
+    "-fcf-protection",
+  ]
 
-if target_arch == "x86_64":
-    flags = " -march=x86-64-v3 -mtune=generic -fstack-clash-protection -fstack-protector-strong -fcf-protection"
   target_cflags += flags
   target_cxxflags += flags
-    target_ldflags += " -Wl,-z,pack-relative-relocs"
+  target_ldflags += ["-Wl,-z,pack-relative-relocs"]
 
-options = {
+config(
-    "libc": libc,
+  arch = arch,
-    "target_triple": target_arch + "-linux-" + libc,
+  recipes_dir = path("./recipes"),
-    "host_cflags": host_cflags,
+  host_recipes_dir = path("./host-recipes"),
-    "host_cxxflags": host_cxxflags,
+  container = podman(
-    "host_ldflags": host_ldflags,
+    image = "local/builder:latest",
-    "cflags": target_cflags,
+    dockerfile = path("./Dockerfile"),
-    "cxxflags": target_cxxflags,
+  ),
-    "ldflags": target_ldflags,
+
-    "wayland": True,
+  target_arch = arch,
-    "x11": True,
+  target_triple = f"{arch}-orchid-linux-{env}",
-}
+
+  libc = libc,
+
+  prefix = prefix,
+  bindir = prefix / "bin",
+  sbindir = prefix / "bin",
+  libdir = prefix / "lib",
+  libexecdir = prefix / "libexec",
+  includedir = prefix / "include",
+  sysconfdir = path("/etc"),
+  localstatedir = path("/var"),
+
+  host_cflags = " ".join(host_cflags),
+  host_cxxflags = " ".join(host_cxxflags),
+  host_ldflags = " ".join(host_ldflags),
+
+  cflags = " ".join(target_cflags),
+  cxxflags = " ".join(target_cxxflags),
+  ldflags = " ".join(target_ldflags),
+)

host-recipes/binutils.star

@@ -0,0 +1,39 @@
+version = "2.46.0"
+revision = 1
+metadata = meta(
+  description = "GNU binutils cross-compiled for the target triple",
+  license = "GPL-3.0-or-later",
+)
+source = tarball(
+  url = f"https://ftp.gnu.org/gnu/binutils/binutils-{version}.tar.xz",
+  sha256 = "d75a94f4d73e7a4086f7513e67e439e8fcdcbb726ffe63f4661744e6256b2cf2",
+  strip_components = 1,
+)
+
+def configure(ctx):
+  ctx.run(
+    ctx.source_dir / "configure",
+    "--prefix=" + options.prefix,
+    "--target=" + options.target_triple,
+    "--with-sysroot=" + ctx.sysroot_dir,
+    "--with-pic",
+    "--enable-cet",
+    "--enable-default-execstack=no",
+    "--enable-deterministic-archives",
+    "--enable-ld=default",
+    "--enable-new-dtags",
+    "--enable-plugins",
+    "--enable-relro",
+    "--enable-separate-code",
+    "--enable-threads",
+    "--disable-nls",
+    "--disable-werror",
+    # gprofng's libcollector relies on glibc-specific internals.
+    "--disable-gprofng",
+  env = {
+    "CFLAGS": options.host_cflags,
+    "CXXFLAGS": options.host_cxxflags,
+    "LDFLAGS": options.host_ldflags,
+  })
+
+_, build, install = autotools()

host-recipes/binutils/recipe.star

@@ -1,42 +0,0 @@
-name = "binutils"
-version = "2.46.0"
-revision = 1
-description = "GNU binutils cross-compiled for the target triple"
-license = "GPL-3.0-or-later"
-
-source = {
-    "url": "https://ftp.gnu.org/gnu/binutils/binutils-" + version + ".tar.xz",
-    "sha256": "d75a94f4d73e7a4086f7513e67e439e8fcdcbb726ffe63f4661744e6256b2cf2",
-    "strip_components": 1,
-}
-
-host_deps = []
-
-def configure(ctx):
-    ctx.run([
-        ctx.source_dir + "/configure",
-        "--prefix=" + ctx.prefix,
-        "--target=" + OPTIONS.target_triple,
-        "--with-sysroot=" + ctx.prefix + "/" + OPTIONS.target_triple,
-        "--disable-nls",
-        "--disable-werror",
-        "--enable-deterministic-archives",
-        "--enable-ld=default",
-        "--enable-plugins",
-        "--enable-threads",
-        "--with-system-zlib",
-        # gprofng's libcollector does not build against musl/recent gcc.
-        "--disable-gprofng",
-    ], env = {
-        "CFLAGS": OPTIONS.host_cflags,
-        "CXXFLAGS": OPTIONS.host_cxxflags,
-        "LDFLAGS": OPTIONS.host_ldflags,
-    })
-
-def build(ctx):
-    ctx.run(["make", "-j" + str(ctx.jobs)])
-
-def install(ctx, pkg):
-    ctx.run(["make", "DESTDIR=" + pkg.destdir, "install"])
-    # Drop static archives we don't need on the cross side.
-    ctx.run(["sh", "-c", "rm -f " + pkg.destdir + ctx.prefix + "/lib/*.a"])

host-recipes/gcc/recipe.star

@@ -1,48 +0,0 @@
-name = "gcc"
-version = "16.1.0"
-revision = 1
-description = "GNU GCC cross-compiler (bootstrap stage, C/C++ only)"
-license = "GPL-3.0-or-later"
-
-source = {
-    "url": f"https://ftp.gnu.org/gnu/gcc/gcc-{version}/gcc-{version}.tar.xz",
-    "sha256": "50efb4d94c3397aff3b0d61a5abd748b4dd31d9d3f2ab7be05b171d36a510f79",
-    "strip_components": 1,
-}
-
-host_deps = ["binutils"]
-
-def configure(ctx):
-    ctx.run([
-        ctx.source_dir + "/configure",
-        "--prefix=" + ctx.prefix,
-        "--target=" + OPTIONS.target_triple,
-        "--with-sysroot=" + ctx.prefix + "/" + OPTIONS.target_triple,
-        "--without-headers",
-        "--with-newlib",
-        "--enable-languages=c,c++",
-        "--enable-default-pie",
-        "--enable-default-ssp",
-        "--disable-nls",
-        "--disable-shared",
-        "--disable-threads",
-        "--disable-libssp",
-        "--disable-libgomp",
-        "--disable-libquadmath",
-        "--disable-libatomic",
-        "--disable-libvtv",
-        "--disable-multilib",
-    ], env = {
-        "CFLAGS": OPTIONS.host_cflags,
-        "CXXFLAGS": OPTIONS.host_cxxflags,
-        "LDFLAGS": OPTIONS.host_ldflags,
-    })
-
-def build(ctx):
-    jobs = "-j" + str(ctx.jobs)
-    ctx.run(["make", jobs, "all-gcc"])
-    ctx.run(["make", jobs, "all-target-libgcc"])
-
-def install(ctx, pkg):
-    ctx.run(["make", "DESTDIR=" + pkg.destdir, "install-gcc"])
-    ctx.run(["make", "DESTDIR=" + pkg.destdir, "install-target-libgcc"])

lib/common.star

@@ -1,99 +0,0 @@
-# Commonly used helpers, auto-loaded into every recipe.
-
-def _toolchain_env(ctx):
-    sysroot_flag = " --sysroot=" + ctx.sysroot
-    return {
-        "CFLAGS": OPTIONS.cflags + sysroot_flag,
-        "CXXFLAGS": OPTIONS.cxxflags + sysroot_flag,
-        "LDFLAGS": OPTIONS.ldflags + sysroot_flag,
-    }
-
-# Autotools
-
-def autotools_configure(ctx, extra_args = [], extra_env = {}):
-    args = [
-        ctx.source_dir + "/configure",
-        "--prefix=" + ctx.prefix,
-        "--sysconfdir=/etc",
-        "--localstatedir=/var",
-        "--bindir=" + ctx.prefix + "/bin",
-        "--sbindir=" + ctx.prefix + "/bin",
-        "--libdir=" + ctx.prefix + "/lib",
-        "--with-sysroot=" + ctx.sysroot,
-        "--disable-static",
-        "--enable-shared",
-    ]
-    args.append("--host=" + OPTIONS.target_triple)
-    args.extend(extra_args)
-
-    envs = _toolchain_env(ctx)
-    envs.update(extra_env)
-
-    ctx.run(args, env = envs)
-
-def autotools_build(ctx, extra_args = []):
-    args = ["make", "-j" + str(ctx.jobs)]
-    args.extend(extra_args)
-    ctx.run(args)
-
-def autotools_check(ctx, extra_args = []):
-    args = ["make", "check", "-j" + str(ctx.jobs)]
-    args.extend(extra_args)
-    ctx.run(args)
-
-def autotools_install(ctx, pkg, extra_args = []):
-    args = ["make", "install", "DESTDIR=" + pkg.destdir]
-    args.extend(extra_args)
-    ctx.run(args)
-
-def autotools(configure_args = [], configure_env = [], build_args = [], install_args = []):
-    def _configure(ctx):
-        autotools_configure(ctx, extra_args = configure_args, extra_env = configure_env)
-    def _build(ctx):
-        autotools_build(ctx, extra_args = build_args)
-    def _install(ctx, pkg):
-        autotools_install(ctx, pkg, extra_args = install_args)
-    return _configure, _build, _install
-
-# Meson
-
-def meson_configure(ctx, extra_args = []):
-    args = [
-        "meson",
-        "setup",
-        ctx.build_dir,
-        ctx.source_dir,
-        "--prefix=" + ctx.prefix,
-    ]
-    args.extend(extra_args)
-    ctx.run(args, env = _toolchain_env(ctx))
-
-def meson_build(ctx):
-    ctx.run(["meson", "compile", "-C", ctx.build_dir, "-j" + str(ctx.jobs)])
-
-def meson_install(ctx, pkg):
-    ctx.run(["meson", "install", "-C", ctx.build_dir, "--destdir", pkg.destdir])
-
-def meson(configure_args = [], build_args = [], install_args = []):
-    def _configure(ctx):
-        meson_configure(ctx, extra_args = configure_args)
-    def _build(ctx):
-        meson_build(ctx, extra_args = build_args)
-    def _install(ctx, pkg):
-        meson_install(ctx, pkg, extra_args = install_args)
-    return _configure, _build, _install
-
-# Make
-
-def make(ctx, target = None, extra_args = []):
-    args = ["make", "-C", ctx.source_dir, "O=" + ctx.build_dir,
-            "-j" + str(ctx.jobs)]
-    args.extend(extra_args)
-    if target:
-        args.append(target)
-    ctx.run(args)
-
-def make_install(ctx, pkg, extra_args = []):
-    args = ["make", "-C", ctx.build_dir, "DESTDIR=" + pkg.destdir, "install"]
-    args.extend(extra_args)
-    ctx.run(args)

recipes/limine/recipe.star

@@ -1,25 +0,0 @@
-name = "limine"
-version = "12.2.0"
-revision = 1
-description = "Modern, secure, portable, multiprotocol bootloader and boot manager"
-license = "BSD-2-Clause"
-
-source = {
-    "url": f"https://github.com/Limine-Bootloader/Limine/releases/download/v{version}/limine-{version}.tar.gz",
-    "sha256": "db8a119878cfeead63c0a78236c577c40539c5759496950ea0ed32a6cf567865",
-    "strip_components": 1,
-}
-
-host_deps = ["binutils", "gcc"]
-deps = [OPTIONS.libc]
-
-def configure(ctx):
-    toolchain = OPTIONS.target_triple + "-"
-    autotools_configure(ctx, extra_env = {
-        "TOOLCHAIN_FOR_TARGET": toolchain,
-        "LD_FOR_TARGET": toolchain + "ld",
-        "OBJCOPY_FOR_TARGET": toolchain + "objcopy",
-        "OBJDUMP_FOR_TARGET": toolchain + "objdump",
-    })
-
-_, build, install = autotools()

recipes/linux-headers.star

@@ -0,0 +1,20 @@
+version = "7.0.9"
+revision = 1
+metadata = meta(
+  description = "Linux kernel headers for userspace development",
+  license = "GPL-2.0-only",
+)
+source = tarball(
+  url = f"https://cdn.kernel.org/pub/linux/kernel/v7.x/linux-{version}.tar.xz",
+  sha256 = "ac07acdf76cf4621cc5187a2670270a1a699533c8a6b225e4878c416ad83f1c4",
+  strip_components = 1,
+)
+
+def build(ctx):
+  ctx.run("cp", "-rp", ctx.source_dir / ".", ctx.build_dir)
+  ctx.run("make", "headers_install", "ARCH=" + options.target_arch)
+  ctx.run("find", ctx.build_dir / "usr" / "include", "-type", "f", "!", "-name", "*.h", "-delete")
+
+def install(ctx):
+  ctx.run("mkdir", "-p", ctx.dest_dir / options.prefix)
+  ctx.run("cp", "-rp", ctx.build_dir / "usr" / "include", ctx.dest_dir / options.prefix)

recipes/linux/recipe.star

@@ -1,37 +0,0 @@
-name = "linux"
-version = "7.0.9"
-revision = 1
-description = "Linux kernel"
-license = "GPL-2.0-only"
-
-source = {
-    "url": f"https://cdn.kernel.org/pub/linux/kernel/v7.x/linux-{version}.tar.xz",
-    "sha256": "ac07acdf76cf4621cc5187a2670270a1a699533c8a6b225e4878c416ad83f1c4",
-    "strip_components": 1,
-}
-
-host_deps = ["binutils", "gcc"]
-
-def _make_args(ctx, *args):
-    result = [
-        "make",
-        "-C", ctx.source_dir,
-        "O=" + ctx.build_dir,
-        "ARCH=x86_64",
-        "CROSS_COMPILE=" + OPTIONS.target_triple + "-",
-        "-j" + str(ctx.jobs),
-    ]
-    result.extend(args)
-    return result
-
-def configure(ctx):
-    ctx.run(_make_args(ctx, "defconfig"))
-
-def build(ctx):
-    ctx.run(_make_args(ctx, "bzImage"))
-
-def install(ctx, pkg):
-    ctx.install(
-        ctx.build_dir + "/arch/x86/boot/bzImage",
-        pkg.destdir + "/boot/vmlinuz-" + version,
-    )

recipes/musl/recipe.star

@@ -1,31 +0,0 @@
-name = "musl"
-version = "1.2.6"
-revision = 1
-description = "Musl C library"
-license = "MIT"
-
-source = {
-    "url": f"https://musl.libc.org/releases/musl-{version}.tar.gz",
-    "sha256": "d585fd3b613c66151fc3249e8ed44f77020cb5e6c1e635a616d3f9f82460512a",
-    "strip_components": 1,
-}
-
-host_deps = ["binutils", "gcc"]
-
-def configure(ctx):
-    ctx.run(
-        [
-            ctx.source_dir + "/configure",
-            "--prefix=/usr",
-            "--syslibdir=/lib",
-            "--target=" + OPTIONS.target_triple,
-        ],
-        env = {
-            "CC": OPTIONS.target_triple + "-gcc",
-            "CFLAGS": OPTIONS.cflags,
-            "LDFLAGS": OPTIONS.ldflags,
-        },
-    )
-
-build = autotools_build
-install = autotools_install

src/apk.rs

@@ -1,46 +0,0 @@
-use crate::config::Config;
-use crate::recipe::OutputPackage;
-use std::path::Path;
-
-#[derive(Debug, Clone)]
-pub struct ApkPackagePlan {
-    pub args: Vec<String>,
-}
-
-pub fn mkpkg_plan(
-    config: &Config,
-    package: &OutputPackage,
-    files_root: &Path,
-    output_dir: &Path,
-) -> ApkPackagePlan {
-    let file_name = format!(
-        "{}-{}-r{}.apk",
-        package.name, package.version, package.revision
-    );
-    let output = output_dir.join(file_name);
-    let version = format!("{}-r{}", package.version, package.revision);
-    let mut args = vec![
-        "mkpkg".to_owned(),
-        "--files".to_owned(),
-        files_root.display().to_string(),
-        "--output".to_owned(),
-        output.display().to_string(),
-        "--info".to_owned(),
-        format!("name:{}", package.name),
-        "--info".to_owned(),
-        format!("version:{version}"),
-        "--info".to_owned(),
-        format!("arch:{}", config.target_arch),
-        "--info".to_owned(),
-        format!("description:{}", package.description),
-        "--info".to_owned(),
-        format!("license:{}", package.license),
-        "--info".to_owned(),
-        format!("origin:{}", package.recipe),
-    ];
-    for dep in &package.deps {
-        args.push("--info".to_owned());
-        args.push(format!("depends:{dep}"));
-    }
-    ApkPackagePlan { args }
-}

src/build.rs

@@ -1,949 +0,0 @@
-use crate::apk;
-use crate::config::Config;
-use crate::graph::PackageGraph;
-use crate::log;
-use crate::patches;
-use crate::phase::{PhaseCommand, PhaseEnv, SourceDir, collect_phase_commands};
-use crate::recipe::{OutputPackage, PackageKind, Recipe, RecipeSet};
-use crate::source;
-use anyhow::{Context, Result, anyhow, bail};
-use sha2::{Digest, Sha256};
-use std::cell::{Cell, RefCell};
-use std::collections::HashSet;
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
-
-const C_SOURCE: &str = "/source";
-const C_BUILD: &str = "/builddir";
-const C_DEST: &str = "/dest";
-const C_SYSROOT: &str = "/sysroot";
-const HOST_PREFIX: &str = "/usr/local";
-const TARGET_PREFIX: &str = "/usr";
-
-#[derive(Debug)]
-pub struct Builder {
-    repo: PathBuf,
-    config: Config,
-    skip_checks: bool,
-    preflight_done: Cell<bool>,
-    built_recipes: RefCell<HashSet<String>>,
-}
-
-impl Builder {
-    pub fn new(repo: PathBuf, config: Config, skip_checks: bool) -> Self {
-        Self {
-            repo,
-            config,
-            skip_checks,
-            preflight_done: Cell::new(false),
-            built_recipes: RefCell::default(),
-        }
-    }
-
-    pub fn build(
-        &self,
-        recipes: &RecipeSet,
-        graph: &PackageGraph,
-        package: Option<&str>,
-        rebuild: bool,
-    ) -> Result<()> {
-        self.preflight_container()?;
-        let (label, order) = match package {
-            Some(p) => (p.to_owned(), graph.build_order(p)?),
-            None => ("<all>".to_owned(), graph.build_order_all()?),
-        };
-        log::step(
-            "plan",
-            &format!("{label}: {} package(s) [{}]", order.len(), order.join(", ")),
-        );
-        for output_name in order {
-            let output = graph.output(&output_name)?;
-            let recipe = recipes.recipe_for_package(&output_name)?;
-            self.ensure_source(recipe)?;
-            // Only force a rebuild of the explicitly requested package;
-            // dependencies stay cached when their manifest is up to date.
-            // With no package (build all), every package honours --rebuild.
-            let force = rebuild && package.map_or(true, |p| p == output_name);
-            match output.kind {
-                PackageKind::Host => self.build_host(recipe, output, force)?,
-                PackageKind::Target => self.build_target(recipe, output, force)?,
-            }
-        }
-        self.repo_index()?;
-        Ok(())
-    }
-
-    pub fn fetch(&self, recipes: &RecipeSet, package: &str) -> Result<()> {
-        let recipe = recipes.recipe_by_user_ref(package)?;
-        log::step("fetch", &recipe.key());
-        source::fetch_sources(recipe, &self.source_cache_dir())?;
-        Ok(())
-    }
-
-    pub fn shell(&self, recipes: &RecipeSet, graph: &PackageGraph, package: &str) -> Result<()> {
-        graph.output(package)?;
-        let recipe = recipes.recipe_for_package(package)?;
-        self.preflight_container()?;
-        let source = self.unpacked_source_dir(recipe);
-        let build = self.build_dir(recipe);
-        fs::create_dir_all(&source)?;
-        fs::create_dir_all(&build)?;
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-it")
-            .arg("-v")
-            .arg(format!("{}:{C_SOURCE}:ro", source.display()))
-            .arg("-v")
-            .arg(format!("{}:{C_BUILD}", build.display()))
-            .arg("-w")
-            .arg(C_BUILD)
-            .arg(&self.config.container_image)
-            .arg("/bin/sh")
-            .status()?;
-        if !status.success() {
-            bail!("container shell exited with {status}");
-        }
-        Ok(())
-    }
-
-    pub fn repo_index(&self) -> Result<()> {
-        self.preflight_container()?;
-        let repo = self.pkgs_dir();
-        fs::create_dir_all(&repo)?;
-        // Nothing to index yet — leave it alone so callers don't trip on a
-        // failing `*.apk` glob.
-        let has_apks = fs::read_dir(&repo)?.any(|e| {
-            e.ok()
-                .and_then(|e| e.path().extension().map(|x| x == "apk"))
-                .unwrap_or(false)
-        });
-        if !has_apks {
-            return Ok(());
-        }
-        log::step(
-            "index",
-            &format!("signing repository at {}", repo.display()),
-        );
-        let key = self.abs_config_path(&self.config.signing_key);
-        let pubkey = self.abs_config_path(&self.config.signing_pubkey);
-        if !key.exists() || !pubkey.exists() {
-            bail!("signing key is not configured or missing; run `distro init-key` first");
-        }
-        let index_name = "APKINDEX.tar.gz";
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:/repo", repo.display()))
-            .arg("-v")
-            .arg(format!("{}:/keys/distro.rsa:ro", key.display()))
-            .arg("-v")
-            .arg(format!(
-                "{}:/etc/apk/keys/distro.rsa.pub:ro",
-                pubkey.display()
-            ))
-            .arg(&self.config.container_image)
-            .arg("/bin/sh")
-            .arg("-lc")
-            .arg(format!(
-                "cd /repo && apk --sign-key /keys/distro.rsa mkndx -o {index_name} *.apk"
-            ))
-            .status()
-            .context("failed to run repository index command")?;
-        if !status.success() {
-            bail!("repository index command failed with {status}");
-        }
-        Ok(())
-    }
-
-    pub fn init_key(&self) -> Result<()> {
-        let key = self.abs_config_path(&self.config.signing_key);
-        let pubkey = self.abs_config_path(&self.config.signing_pubkey);
-        if key.exists() && pubkey.exists() {
-            log::skip("init-key", "signing key already present");
-            return Ok(());
-        }
-        log::step("init-key", &format!("generating {}", key.display()));
-        let key_dir = key
-            .parent()
-            .ok_or_else(|| anyhow!("invalid signing key path"))?;
-        let key_name = key
-            .file_name()
-            .ok_or_else(|| anyhow!("invalid signing key path"))?
-            .to_string_lossy();
-        fs::create_dir_all(key_dir)?;
-        self.preflight_container()?;
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:/keys", key_dir.display()))
-            .arg(&self.config.container_image)
-            .arg("/bin/sh")
-            .arg("-lc")
-            .arg(format!(
-                "openssl genrsa -out /keys/{key_name} 4096 && \
-                 openssl rsa -in /keys/{key_name} -pubout -out /keys/{key_name}.pub"
-            ))
-            .status()
-            .context("failed to run key generation command")?;
-        if !status.success() {
-            bail!("key generation failed with {status}");
-        }
-        Ok(())
-    }
-
-    pub fn rootfs(&self, root: &Path, packages: &[String]) -> Result<()> {
-        self.preflight_container()?;
-        let pubkey = self.abs_config_path(&self.config.signing_pubkey);
-        if !pubkey.exists() {
-            bail!("rootfs requires a configured public signing key; run `distro init-key` first");
-        }
-        fs::create_dir_all(root)?;
-        log::step(
-            "rootfs",
-            &format!(
-                "{} -> {} [{}]",
-                packages.join(", "),
-                root.display(),
-                root.display()
-            ),
-        );
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:/rootfs", root.display()))
-            .arg("-v")
-            .arg(format!("{}:/repo:ro", self.pkgs_root().display()))
-            .arg("-v")
-            .arg(format!(
-                "{}:/etc/apk/keys/distro.rsa.pub:ro",
-                pubkey.display()
-            ))
-            .arg(&self.config.container_image)
-            .arg("apk")
-            .arg("--root")
-            .arg("/rootfs")
-            .arg("--keys-dir")
-            .arg("/etc/apk/keys")
-            .arg("--initdb")
-            .arg("--repository")
-            .arg("/repo")
-            .arg("add")
-            .args(packages)
-            .status()
-            .context("failed to run rootfs apk command")?;
-        if !status.success() {
-            bail!("rootfs creation failed with {status}");
-        }
-        Ok(())
-    }
-
-    // --- per-recipe build steps -------------------------------------------
-
-    fn build_host(&self, recipe: &Recipe, output: &OutputPackage, rebuild: bool) -> Result<()> {
-        let manifest = self.manifest_path(&output.key());
-        let hash = self.manifest_hash(recipe)?;
-        if !rebuild && fs::read_to_string(&manifest).ok().as_deref() == Some(hash.as_str()) {
-            log::skip("up-to-date", &output.key());
-            return Ok(());
-        }
-        log::step(
-            "build",
-            &format!("{} {}-r{}", output.key(), recipe.version, recipe.revision),
-        );
-        let build_dir = self.host_build_dir(recipe);
-        let dest_dir = self.host_pkg_dir(recipe);
-        let source_dir = self.unpacked_source_dir(recipe);
-        // A rebuild starts from a clean build dir; sources stay shared.
-        if rebuild {
-            Self::recreate(&build_dir)?;
-        } else {
-            fs::create_dir_all(&build_dir)?;
-        }
-        Self::recreate(&dest_dir)?;
-        fs::create_dir_all(&build_dir)?;
-
-        let env = PhaseEnv {
-            source_dir: source_dir_env(recipe),
-            build_dir: C_BUILD,
-            dest_dir: C_DEST,
-            prefix: HOST_PREFIX,
-            sysroot: C_SYSROOT,
-        };
-        self.run_recipe_phases(
-            recipe,
-            output,
-            &env,
-            &source_dir,
-            &build_dir,
-            &dest_dir,
-            None,
-        )?;
-
-        fs::create_dir_all(manifest.parent().unwrap())?;
-        fs::write(manifest, hash)?;
-        Ok(())
-    }
-
-    fn build_target(&self, recipe: &Recipe, output: &OutputPackage, rebuild: bool) -> Result<()> {
-        let manifest = self.manifest_path(&output.key());
-        let hash = self.manifest_hash(recipe)?;
-        if !rebuild && fs::read_to_string(&manifest).ok().as_deref() == Some(hash.as_str()) {
-            log::skip("up-to-date", &output.key());
-            return Ok(());
-        }
-        log::step(
-            "build",
-            &format!("{} {}-r{}", output.key(), recipe.version, recipe.revision),
-        );
-        let build_dir = self.build_dir(recipe);
-        let source_dir = self.unpacked_source_dir(recipe);
-        // A rebuild starts from a clean build dir; sources stay shared.
-        if rebuild {
-            Self::recreate(&build_dir)?;
-        } else {
-            fs::create_dir_all(&build_dir)?;
-        }
-
-        let dest_tmp =
-            tempfile::tempdir_in(&build_dir).context("failed to create ephemeral destdir")?;
-        let dest_dir = dest_tmp.path();
-
-        let sysroot = self.materialize_sysroot(recipe)?;
-        let env = PhaseEnv {
-            source_dir: source_dir_env(recipe),
-            build_dir: C_BUILD,
-            dest_dir: C_DEST,
-            prefix: TARGET_PREFIX,
-            sysroot: C_SYSROOT,
-        };
-        self.run_recipe_phases(
-            recipe,
-            output,
-            &env,
-            &source_dir,
-            &build_dir,
-            dest_dir,
-            sysroot.as_ref().map(|s| s.path()),
-        )?;
-
-        self.apk_mkpkg(output, dest_dir)?;
-
-        fs::create_dir_all(manifest.parent().unwrap())?;
-        fs::write(manifest, hash)?;
-        Ok(())
-    }
-
-    fn run_recipe_phases(
-        &self,
-        recipe: &Recipe,
-        output: &OutputPackage,
-        env: &PhaseEnv<'_>,
-        source_dir: &Path,
-        build_dir: &Path,
-        dest_dir: &Path,
-        target_sysroot: Option<&Path>,
-    ) -> Result<()> {
-        let host_sandbox = self.materialize_host_sandbox(recipe)?;
-        let recipe_already_built = self.built_recipes.borrow().contains(&recipe.key());
-
-        // configure/build/check run at most once per recipe per invocation.
-        let mut shared_phases: Vec<(&str, bool)> = Vec::new();
-        if !recipe_already_built {
-            if let Some(p) = recipe.configure_fn.as_deref() {
-                shared_phases.push((p, false));
-            }
-            if let Some(p) = recipe.build_fn.as_deref() {
-                shared_phases.push((p, false));
-            }
-            if !self.skip_checks {
-                if let Some(p) = recipe.check_fn.as_deref() {
-                    shared_phases.push((p, false));
-                }
-            }
-        }
-        // install runs per output (each output has its own destdir/install_fn).
-        let install_phase = (output.install_fn.as_str(), true);
-
-        let mut commands: Vec<PhaseCommand> = Vec::new();
-        for (phase, takes_pkg) in shared_phases.iter().chain(std::iter::once(&install_phase)) {
-            let pkg = if *takes_pkg {
-                Some((output.name.as_str(), C_DEST))
-            } else {
-                None
-            };
-            let owner = if *takes_pkg {
-                output.key()
-            } else {
-                recipe.key()
-            };
-            log::info("phase", &format!("{phase} {owner}"));
-            commands.extend(collect_phase_commands(
-                &recipe.path,
-                &self.repo,
-                &self.config,
-                phase,
-                env,
-                pkg,
-            )?);
-        }
-        if commands.is_empty() {
-            self.built_recipes.borrow_mut().insert(recipe.key());
-            return Ok(());
-        }
-
-        self.run_in_container(
-            source_dir,
-            build_dir,
-            dest_dir,
-            host_sandbox.as_ref().map(|s| s.path()),
-            target_sysroot,
-            &commands,
-        )?;
-        self.built_recipes.borrow_mut().insert(recipe.key());
-        Ok(())
-    }
-
-    fn run_in_container(
-        &self,
-        source_dir: &Path,
-        build_dir: &Path,
-        dest_dir: &Path,
-        host_sandbox: Option<&Path>,
-        target_sysroot: Option<&Path>,
-        commands: &[PhaseCommand],
-    ) -> Result<()> {
-        fs::create_dir_all(dest_dir)?;
-        let mut process = Command::new(&self.config.container_runtime);
-        process
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:{C_SOURCE}:ro", source_dir.display()))
-            .arg("-v")
-            .arg(format!("{}:{C_BUILD}", build_dir.display()))
-            .arg("-v")
-            .arg(format!("{}:{C_DEST}", dest_dir.display()))
-            .arg("-w")
-            .arg(C_BUILD);
-        if let Some(sandbox) = host_sandbox {
-            // Host packages are configured with --prefix=/usr/local, so we
-            // bind the assembled tree exactly there (matching Jinx). This
-            // means rpaths, --print-search-dirs, pkg-config lookups, etc.
-            // all keep working with no extra environment fiddling.
-            process
-                .arg("-v")
-                .arg(format!("{}:{HOST_PREFIX}:ro", sandbox.display()));
-        }
-        if let Some(sysroot) = target_sysroot {
-            process
-                .arg("-v")
-                .arg(format!("{}:{C_SYSROOT}:ro", sysroot.display()))
-                .arg("-e")
-                .arg(format!("PKG_CONFIG_SYSROOT_DIR={C_SYSROOT}"))
-                .arg("-e")
-                .arg(format!("SYSROOT={C_SYSROOT}"));
-        }
-        process
-            .arg(&self.config.container_image)
-            .arg("/bin/sh")
-            .arg("-c")
-            .arg(build_phase_script(commands));
-        let status = process
-            .status()
-            .context("failed to start container for phase commands")?;
-        if !status.success() {
-            bail!("phase commands failed with {status}");
-        }
-        Ok(())
-    }
-
-    fn apk_mkpkg(&self, output: &OutputPackage, dest_dir: &Path) -> Result<()> {
-        let repo = self.pkgs_dir();
-        fs::create_dir_all(&repo)?;
-        let signing_key = self.abs_config_path(&self.config.signing_key);
-        if !signing_key.exists() {
-            bail!("package signing key is missing; run `distro init-key` first");
-        }
-        log::step("package", &format!("{} -> {}", output.name, repo.display()));
-        let plan = apk::mkpkg_plan(&self.config, output, Path::new(C_DEST), Path::new("/out"));
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:{C_DEST}:ro", dest_dir.display()))
-            .arg("-v")
-            .arg(format!("{}:/out", repo.display()))
-            .arg("-v")
-            .arg(format!("{}:/keys/distro.rsa:ro", signing_key.display()))
-            .arg(&self.config.container_image)
-            .arg("apk")
-            .arg("--sign-key")
-            .arg("/keys/distro.rsa")
-            .args(plan.args)
-            .status()
-            .context("failed to run apk mkpkg command")?;
-        if !status.success() {
-            bail!("apk mkpkg failed with {status}");
-        }
-        Ok(())
-    }
-
-    // --- source preparation (Jinx-style persistent sources/<recipe>/) ------
-
-    fn ensure_source(&self, recipe: &Recipe) -> Result<()> {
-        let cached = source::fetch_sources(recipe, &self.source_cache_dir())?;
-
-        let unpacked = self.unpacked_source_dir(recipe);
-        let version_stamp = self.source_stamp(recipe, "version");
-        let want_version = format!("{}-r{}", recipe.version, recipe.revision);
-        let need_extract =
-            fs::read_to_string(&version_stamp).ok().as_deref() != Some(&want_version);
-
-        if need_extract {
-            log::info("unpack", &recipe.key());
-            if unpacked.exists() {
-                fs::remove_dir_all(&unpacked)?;
-            }
-            fs::create_dir_all(&unpacked)?;
-            for (src, tarball) in recipe.sources.iter().zip(cached.iter()) {
-                let dest = if src.name.is_empty() {
-                    unpacked.clone()
-                } else {
-                    unpacked.join(&src.name)
-                };
-                self.extract_tarball(tarball, &dest, src.strip_components)?;
-            }
-            fs::write(&version_stamp, &want_version)?;
-            let patched = self.source_stamp(recipe, "patched");
-            let _ = fs::remove_file(&patched);
-        }
-
-        let patched_stamp = self.source_stamp(recipe, "patched");
-        if !patched_stamp.exists() {
-            self.apply_patches(recipe, &unpacked)?;
-            fs::write(&patched_stamp, "")?;
-        }
-        Ok(())
-    }
-
-    fn extract_tarball(&self, tarball: &Path, dest: &Path, strip_components: u32) -> Result<()> {
-        fs::create_dir_all(dest)?;
-        log::info(
-            "extract",
-            &format!("{} -> {}", tarball.display(), dest.display()),
-        );
-        let strip = if strip_components > 0 {
-            format!("--strip-components={strip_components}")
-        } else {
-            String::new()
-        };
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:/in.tar:ro", tarball.display()))
-            .arg("-v")
-            .arg(format!("{}:/out", dest.display()))
-            .arg(&self.config.container_image)
-            .arg("/bin/sh")
-            .arg("-c")
-            .arg(format!("tar -xf /in.tar -C /out {strip}"))
-            .status()
-            .context("failed to unpack source archive")?;
-        if !status.success() {
-            bail!("source unpack failed with {status}");
-        }
-        Ok(())
-    }
-
-    fn apply_patches(&self, recipe: &Recipe, source_dir: &Path) -> Result<()> {
-        let patches = patches::discover(&recipe.dir)?;
-        if patches.is_empty() {
-            return Ok(());
-        }
-        if recipe.sources.iter().any(|s| !s.name.is_empty()) {
-            bail!(
-                "recipe `{}` has patches/ but uses multi-source layout; \
-                 apply patches yourself via ctx.run in the configure phase",
-                recipe.id
-            );
-        }
-        for patch in patches {
-            log::info(
-                "patch",
-                &format!(
-                    "{} <- {}",
-                    recipe.id,
-                    patch
-                        .file_name()
-                        .map(|n| n.to_string_lossy().into_owned())
-                        .unwrap_or_default(),
-                ),
-            );
-            let status = Command::new(&self.config.container_runtime)
-                .arg("run")
-                .arg("--rm")
-                .arg("-v")
-                .arg(format!("{}:/source", source_dir.display()))
-                .arg("-v")
-                .arg(format!("{}:/patch.diff:ro", patch.display()))
-                .arg(&self.config.container_image)
-                .arg("patch")
-                .arg("-d")
-                .arg("/source")
-                .arg("-p1")
-                .arg("-i")
-                .arg("/patch.diff")
-                .status()
-                .context("failed to apply patch")?;
-            if !status.success() {
-                bail!("patch {} failed with {status}", patch.display());
-            }
-        }
-        Ok(())
-    }
-
-    // --- host sandbox / target sysroot materialization --------------------
-
-    /// Assemble all `host_deps` into a single ephemeral tree that we can mount
-    /// at `/usr/local` inside the container. Following Jinx, we hard-link
-    /// rather than byte-copy so this is essentially free. The returned
-    /// `TempDir` cleans up when dropped.
-    fn materialize_host_sandbox(&self, recipe: &Recipe) -> Result<Option<tempfile::TempDir>> {
-        if recipe.host_deps.is_empty() {
-            return Ok(None);
-        }
-        fs::create_dir_all(self.repo.join("build"))?;
-        let sandbox = tempfile::Builder::new()
-            .prefix(&format!("host-sandbox-{}-", recipe.id))
-            .tempdir_in(self.repo.join("build"))
-            .context("failed to create host sandbox tempdir")?;
-        log::info(
-            "host-sandbox",
-            &format!("{} <- [{}]", recipe.id, recipe.host_deps.join(", ")),
-        );
-        for dep in &recipe.host_deps {
-            let source = self.host_pkg_dir_by_id(dep).join("usr/local");
-            if !source.exists() {
-                bail!(
-                    "host dependency `{dep}` has not been built at {}",
-                    source.display()
-                );
-            }
-            hardlink_tree(&source, sandbox.path())?;
-        }
-        Ok(Some(sandbox))
-    }
-
-    fn materialize_sysroot(&self, recipe: &Recipe) -> Result<Option<tempfile::TempDir>> {
-        let mut deps: Vec<String> = recipe
-            .build_deps
-            .iter()
-            .chain(recipe.deps.iter())
-            .cloned()
-            .collect();
-        deps.sort();
-        deps.dedup();
-        if deps.is_empty() {
-            return Ok(None);
-        }
-        // The local repo index must be present and current so apk can resolve
-        // and verify the just-built target packages.
-        self.repo_index()?;
-        let pubkey = self.abs_config_path(&self.config.signing_pubkey);
-        if !pubkey.exists() {
-            bail!("target dependency sysroot requires a configured public signing key");
-        }
-        fs::create_dir_all(self.repo.join("build"))?;
-        let sysroot = tempfile::Builder::new()
-            .prefix(&format!("sysroot-{}-", recipe.id))
-            .tempdir_in(self.repo.join("build"))
-            .context("failed to create sysroot tempdir")?;
-        log::info(
-            "sysroot",
-            &format!("{} <- [{}]", recipe.id, deps.join(", ")),
-        );
-        let status = Command::new(&self.config.container_runtime)
-            .arg("run")
-            .arg("--rm")
-            .arg("-v")
-            .arg(format!("{}:/sysroot", sysroot.path().display()))
-            .arg("-v")
-            .arg(format!("{}:/repo:ro", self.pkgs_root().display()))
-            .arg("-v")
-            .arg(format!(
-                "{}:/etc/apk/keys/distro.rsa.pub:ro",
-                pubkey.display()
-            ))
-            .arg(&self.config.container_image)
-            .arg("apk")
-            .arg("--root")
-            .arg("/sysroot")
-            .arg("--keys-dir")
-            .arg("/etc/apk/keys")
-            .arg("--initdb")
-            .arg("--repository")
-            .arg("/repo")
-            .arg("add")
-            .args(&deps)
-            .status()
-            .context("failed to install target dependency sysroot")?;
-        if !status.success() {
-            bail!("target dependency sysroot install failed with {status}");
-        }
-        Ok(Some(sysroot))
-    }
-
-    // --- preflight & container image --------------------------------------
-
-    fn preflight_container(&self) -> Result<()> {
-        if self.preflight_done.get() {
-            return Ok(());
-        }
-        let status = Command::new(&self.config.container_runtime)
-            .arg("--version")
-            .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .status()
-            .with_context(|| {
-                format!(
-                    "{} is required but was not found",
-                    self.config.container_runtime
-                )
-            })?;
-        if !status.success() {
-            bail!(
-                "{} preflight failed with {status}",
-                self.config.container_runtime
-            );
-        }
-        let dockerfile = self.abs_config_path(&self.config.container_dockerfile);
-        self.ensure_container_image(&dockerfile)?;
-        self.preflight_done.set(true);
-        Ok(())
-    }
-
-    fn ensure_container_image(&self, dockerfile: &Path) -> Result<()> {
-        if !dockerfile.exists() {
-            bail!(
-                "configured container Dockerfile does not exist: {}",
-                dockerfile.display()
-            );
-        }
-        let hash = self.container_build_hash(dockerfile)?;
-        let stamp = self.repo.join("build/container-image.hash");
-        if fs::read_to_string(&stamp).ok().as_deref() == Some(hash.as_str())
-            && self.container_image_exists()?
-        {
-            return Ok(());
-        }
-        log::step(
-            "image",
-            &format!(
-                "building {} from {}",
-                self.config.container_image,
-                dockerfile.display()
-            ),
-        );
-        let status = Command::new(&self.config.container_runtime)
-            .arg("build")
-            .arg("-f")
-            .arg(dockerfile)
-            .arg("-t")
-            .arg(&self.config.container_image)
-            .arg(&self.repo)
-            .status()
-            .with_context(|| {
-                format!(
-                    "failed to build container image `{}` from {}",
-                    self.config.container_image,
-                    dockerfile.display()
-                )
-            })?;
-        if !status.success() {
-            bail!(
-                "container image build failed for `{}` with {status}",
-                self.config.container_image
-            );
-        }
-        fs::create_dir_all(stamp.parent().unwrap())?;
-        fs::write(stamp, hash)?;
-        Ok(())
-    }
-
-    fn container_image_exists(&self) -> Result<bool> {
-        let status = Command::new(&self.config.container_runtime)
-            .arg("image")
-            .arg("exists")
-            .arg(&self.config.container_image)
-            .status()
-            .with_context(|| {
-                format!(
-                    "failed to inspect container image `{}`",
-                    self.config.container_image
-                )
-            })?;
-        Ok(status.success())
-    }
-
-    fn container_build_hash(&self, dockerfile: &Path) -> Result<String> {
-        let mut hasher = Sha256::new();
-        hasher.update(fs::read(dockerfile)?);
-        hasher.update(self.config.container_image.as_bytes());
-        Ok(hex::encode(hasher.finalize()))
-    }
-
-    fn manifest_hash(&self, recipe: &Recipe) -> Result<String> {
-        let mut hasher = Sha256::new();
-        hasher.update(self.config.target_arch.as_bytes());
-        hasher.update(recipe.version.as_bytes());
-        hasher.update(recipe.revision.to_le_bytes());
-        for source in &recipe.sources {
-            hasher.update(source.url.as_bytes());
-            hasher.update(source.sha256.as_bytes());
-        }
-        for patch in patches::discover(&recipe.dir)? {
-            hasher.update(patch.display().to_string().as_bytes());
-            hasher.update(fs::read(patch)?);
-        }
-        Ok(hex::encode(hasher.finalize()))
-    }
-
-    // --- path helpers -----------------------------------------------------
-
-    fn source_cache_dir(&self) -> PathBuf {
-        self.repo.join("build/cache/sources")
-    }
-    fn unpacked_source_dir(&self, recipe: &Recipe) -> PathBuf {
-        self.repo.join("build/sources").join(recipe.slug())
-    }
-    fn source_stamp(&self, recipe: &Recipe, kind: &str) -> PathBuf {
-        self.repo
-            .join("build/sources")
-            .join(format!("{}.{kind}", recipe.slug()))
-    }
-    fn build_dir(&self, recipe: &Recipe) -> PathBuf {
-        self.repo.join("build/builds").join(&recipe.id)
-    }
-    fn host_build_dir(&self, recipe: &Recipe) -> PathBuf {
-        self.repo.join("build/host-builds").join(&recipe.id)
-    }
-    fn host_pkg_dir(&self, recipe: &Recipe) -> PathBuf {
-        self.repo.join("build/host-pkgs").join(&recipe.id)
-    }
-    fn host_pkg_dir_by_id(&self, host_recipe_id: &str) -> PathBuf {
-        self.repo.join("build/host-pkgs").join(host_recipe_id)
-    }
-    /// Root of the target package repo. apk treats this as the repo root and
-    /// expects `<root>/<arch>/APKINDEX.tar.gz` underneath.
-    fn pkgs_root(&self) -> PathBuf {
-        self.repo.join("build/pkgs")
-    }
-    /// Arch-specific package directory: where .apk files and the index live.
-    fn pkgs_dir(&self) -> PathBuf {
-        self.pkgs_root().join(&self.config.target_arch)
-    }
-    fn manifest_path(&self, output_key: &str) -> PathBuf {
-        // Output keys may contain `:` (e.g. `host:gcc`); the manifest file
-        // name uses the filesystem-safe slug form instead.
-        let safe = output_key.replace(':', "-");
-        self.repo
-            .join("build/manifests")
-            .join(format!("{safe}.hash"))
-    }
-    fn abs_config_path(&self, path: &Path) -> PathBuf {
-        if path.is_absolute() {
-            path.to_path_buf()
-        } else {
-            self.repo.join(path)
-        }
-    }
-
-    fn recreate(path: &Path) -> Result<()> {
-        if path.exists() {
-            fs::remove_dir_all(path)?;
-        }
-        fs::create_dir_all(path)?;
-        Ok(())
-    }
-}
-
-fn build_phase_script(commands: &[PhaseCommand]) -> String {
-    let mut parts: Vec<String> = Vec::with_capacity(commands.len() + 1);
-    parts.push("set -e".to_owned());
-    for cmd in commands {
-        let mut tokens: Vec<String> = Vec::with_capacity(cmd.env.len() + cmd.argv.len());
-        for (k, v) in &cmd.env {
-            let value = shell_escape::unix::escape(v.as_str().into()).into_owned();
-            tokens.push(format!("{k}={value}"));
-        }
-        for arg in &cmd.argv {
-            tokens.push(shell_escape::unix::escape(arg.as_str().into()).into_owned());
-        }
-        parts.push(tokens.join(" "));
-    }
-    parts.join("\n")
-}
-
-/// Expose `/source` as a string for single-source recipes, or a struct of
-/// `/source/<name>` paths for multi-source recipes.
-fn source_dir_env(recipe: &Recipe) -> SourceDir {
-    if recipe.sources.iter().all(|s| s.name.is_empty()) {
-        SourceDir::Single(C_SOURCE.to_owned())
-    } else {
-        let map = recipe
-            .sources
-            .iter()
-            .map(|s| (s.name.clone(), format!("{C_SOURCE}/{}", s.name)))
-            .collect();
-        SourceDir::Many(map)
-    }
-}
-
-/// Mirror `src` into `dst` using hard links for regular files (and preserving
-/// symlinks). This matches Jinx's `cp -Pplr`: no bytes are copied, just inode
-/// references, so assembling a host-deps sandbox is essentially free.
-fn hardlink_tree(src: &Path, dst: &Path) -> Result<()> {
-    fs::create_dir_all(dst)?;
-    for entry in walkdir::WalkDir::new(src) {
-        let entry = entry?;
-        let relative = entry.path().strip_prefix(src)?;
-        if relative.as_os_str().is_empty() {
-            continue;
-        }
-        let target = dst.join(relative);
-        let file_type = entry.file_type();
-        if file_type.is_dir() {
-            fs::create_dir_all(&target)?;
-        } else if file_type.is_symlink() {
-            if let Some(parent) = target.parent() {
-                fs::create_dir_all(parent)?;
-            }
-            let link_target = fs::read_link(entry.path())?;
-            // Replace any pre-existing entry (multiple host deps may ship the
-            // same symlink path).
-            let _ = fs::remove_file(&target);
-            std::os::unix::fs::symlink(&link_target, &target)?;
-        } else if file_type.is_file() {
-            if let Some(parent) = target.parent() {
-                fs::create_dir_all(parent)?;
-            }
-            if target.exists() {
-                continue;
-            }
-            fs::hard_link(entry.path(), &target).with_context(|| {
-                format!(
-                    "failed to hard-link {} -> {}",
-                    entry.path().display(),
-                    target.display()
-                )
-            })?;
-        }
-    }
-    Ok(())
-}

src/cli.rs

@@ -1,119 +1,137 @@
-use crate::build::Builder;
+use crate::{
-use crate::config::Config;
+    container::{ContainerManager, PodmanRuntime},
-use crate::graph::PackageGraph;
+    eval::{
-use crate::recipe::RecipeSet;
+        Config, ContainerConfig, ContainerManagerWrapper, Context, Path, config_globals,
-use anyhow::{Context, Result, bail};
+        eval_files, types_globals,
+    },
+    log,
+    plan::{Plan, PlanKey},
+    recipe::RecipeSet,
+};
+
 use clap::{Parser, Subcommand};
-use std::fs;
+use starlark::{
-use std::path::PathBuf;
+    environment::{GlobalsBuilder, Module},
+    eval,
+    values::Value,
+};
+use std::{cell::Cell, path::PathBuf, sync::Arc};
 
 #[derive(Debug, Parser)]
-#[command(name = "distro", version)]
+struct Cli {
-pub struct Cli {
+    #[arg(
-    #[arg(long, default_value = ".")]
+        long,
-    pub repo: PathBuf,
+        short = 'C',
-
+        default_value = ".",
-    #[arg(long)]
+        help = "Directory containing the configuration and recipe files"
-    pub skip_checks: bool,
+    )]
-
+    root: PathBuf,
     #[command(subcommand)]
-    pub command: Command,
+    command: Command,
+}
+
+#[derive(Debug, Parser)]
+#[command(about = "Fetch sources for the given recipes")]
+struct FetchCommand {
+    #[arg(
+        required = true,
+        help = "List of recipes to fetch, host recipes should be prefixed with `host:`"
+    )]
+    recipes: Vec<String>,
+    #[arg(long, short = 'n', help = "Print what will be done and exit")]
+    dry_run: bool,
+}
+
+#[derive(Debug, Parser)]
+#[command(about = "Build the given recipes")]
+struct BuildCommand {
+    #[arg(
+        required = true,
+        help = "List of recipes to build, host recipes should be prefixed with `host:`"
+    )]
+    recipes: Vec<String>,
+    #[arg(long, short, help = "Perform a full rebuild of the given recipes")]
+    rebuild: bool,
+    #[arg(long, short = 'n', help = "Print what will be done and exit")]
+    dry_run: bool,
 }
 
 #[derive(Debug, Subcommand)]
-pub enum Command {
+enum Command {
-    Build {
+    Fetch(FetchCommand),
-        package: Option<String>,
+    Build(BuildCommand),
-    },
-    Rebuild {
-        package: Option<String>,
-    },
-    Fetch {
-        package: String,
-    },
-    Graph {
-        package: Option<String>,
-    },
-    List,
-    Info {
-        package: String,
-    },
-    Clean,
-    Shell {
-        package: String,
-    },
-    RepoIndex,
-    InitKey,
-    Rootfs {
-        root: PathBuf,
-        packages: Vec<String>,
-    },
-    Update {
-        #[arg(long)]
-        bump: bool,
-        packages: Vec<String>,
-    },
 }
 
-pub fn run(cli: Cli) -> Result<()> {
+pub fn run() -> anyhow::Result<()> {
-    let repo = cli.repo.canonicalize().unwrap_or(cli.repo);
+    let cli = Cli::parse();
-    match &cli.command {
+    let root_path = cli.root.canonicalize().unwrap_or(cli.root);
-        Command::Clean => {
+
-            let build = repo.join("build");
+    let config: Config = {
-            if build.exists() {
+        let cell = Cell::new(None);
-                fs::remove_dir_all(&build)
+        let config_path = root_path.join("config.star");
-                    .with_context(|| format!("failed to remove {}", build.display()))?;
+
-            }
+        eval_files(
-            Ok(())
+            &[&config_path],
-        }
+            &GlobalsBuilder::standard()
-        Command::InitKey => {
+                .with(types_globals)
-            let config = Config::load(&repo.join("config.star"))?;
+                .with(config_globals)
-            Builder::new(repo, config, cli.skip_checks).init_key()
+                .build(),
-        }
+            None,
-        _ => {
+            None,
-            let config = Config::load(&repo.join("config.star"))?;
+            Some(&cell),
-            let recipes = RecipeSet::load(&repo, &config)?;
+        )?;
-            if let Command::Update { bump, packages } = &cli.command {
+
-                return crate::update::run(&recipes, packages, *bump);
+        cell.take()
-            }
+            .ok_or_else(|| anyhow::anyhow!("`config` was not called"))?
-            let graph = PackageGraph::new(&recipes)?;
+    };
-            let builder = Builder::new(repo, config, cli.skip_checks);
+
+    let container_runtime = match config.container() {
+        ContainerConfig::Podman(_) => Arc::new(PodmanRuntime::new()?),
+    };
+
+    let container_manager = ContainerManager::new(container_runtime);
+    let mut recipes = RecipeSet::new(&config);
+
+    recipes.load_recipes(
+        &root_path.join(config.recipes_dir()),
+        &root_path.join(config.host_recipes_dir()),
+    )?;
+
+    // let wrapper = ContainerManagerWrapper(&container_manager);
+    // for (name, recipe) in recipes.packages.iter() {
+    //     println!("{name}: {:#?}", recipe);
+
+    //     let mo = Module::new();
+    //     let mut eval = eval::Evaluator::new(&mo);
+    //     eval.extra = Some(&wrapper);
+    //     eval.eval_function(
+    //         recipe.build.unwrap().0.to_value(),
+    //         &[mo.heap().alloc(Context {
+    //             source_dir: Path::new("/source"),
+    //             build_dir: Path::new("/build"),
+    //             jobs: 4,
+    //         })],
+    //         &[],
+    //     )
+    //     .unwrap();
+    // }
+
+    let mut plan = Plan::new(&recipes);
+
     match cli.command {
-                Command::Build { package } => {
+        Command::Fetch(_) => {}
-                    builder.build(&recipes, &graph, package.as_deref(), false)
+        Command::Build(cmd) => {
+            for recipe in cmd.recipes.iter() {
+                plan.add_wanted(if let Some(recipe) = recipe.strip_prefix("host:") {
+                    PlanKey::ToolInstall(recipe.to_string())
+                } else {
+                    PlanKey::PkgPackage(recipe.clone())
+                });
             }
-                Command::Rebuild { package } => {
-                    builder.build(&recipes, &graph, package.as_deref(), true)
         }
-                Command::Fetch { package } => builder.fetch(&recipes, &package),
-                Command::Graph { package } => {
-                    for line in graph.render(package.as_deref())? {
-                        println!("{line}");
     }
+
+    log!("plan", "{:#?}", plan.steps());
+
     Ok(())
 }
-                Command::List => {
-                    for output in graph.outputs() {
-                        println!("{output}");
-                    }
-                    Ok(())
-                }
-                Command::Info { package } => {
-                    let output = graph.output(&package)?;
-                    println!("{}", serde_json::to_string_pretty(output)?);
-                    Ok(())
-                }
-                Command::Shell { package } => builder.shell(&recipes, &graph, &package),
-                Command::RepoIndex => builder.repo_index(),
-                Command::Rootfs { root, packages } => {
-                    if packages.is_empty() {
-                        bail!("rootfs requires at least one package");
-                    }
-                    builder.rootfs(&root, &packages)
-                }
-                Command::Update { .. } => unreachable!(),
-                Command::Clean | Command::InitKey => unreachable!(),
-            }
-        }
-    }
-}

src/config.rs

@@ -1,37 +0,0 @@
-use crate::starlark::{eval_file, get_json_map, get_string, get_string_default};
-use anyhow::{Context, Result};
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Config {
-    pub target_arch: String,
-    pub options: BTreeMap<String, JsonValue>,
-    pub container_runtime: String,
-    pub container_image: String,
-    pub container_dockerfile: PathBuf,
-    pub signing_key: PathBuf,
-    pub signing_pubkey: PathBuf,
-}
-
-impl Config {
-    pub fn load(path: &Path) -> Result<Self> {
-        let module = eval_file(path, None, None)
-            .with_context(|| format!("failed to evaluate {}", path.display()))?;
-        Ok(Self {
-            target_arch: get_string(&module, "target_arch")?,
-            options: get_json_map(&module, "options")?,
-            container_runtime: get_string_default(&module, "container_runtime", "podman")?,
-            container_image: get_string(&module, "container_image")?,
-            container_dockerfile: PathBuf::from(get_string_default(
-                &module,
-                "container_dockerfile",
-                "Dockerfile",
-            )?),
-            signing_key: PathBuf::from(get_string(&module, "signing_key")?),
-            signing_pubkey: PathBuf::from(get_string(&module, "signing_pubkey")?),
-        })
-    }
-}

src/container/mod.rs

@@ -0,0 +1,99 @@
+use std::{
+    collections::HashMap,
+    path::Path,
+    sync::{Arc, Mutex},
+};
+
+mod podman;
+
+pub use podman::PodmanRuntime;
+
+#[derive(Clone)]
+pub struct Container {
+    id: String,
+    runtime: Arc<dyn ContainerRuntime>,
+}
+
+impl Container {
+    fn new(id: String, runtime: Arc<dyn ContainerRuntime>) -> Self {
+        Self { id, runtime }
+    }
+
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+
+    pub fn exec<'a, 'e, 'c>(
+        &self,
+        argv: impl Into<Vec<&'a str>>,
+        env: impl Into<Vec<(&'e str, &'e str)>>,
+        cwd: impl Into<&'c Path>,
+    ) -> anyhow::Result<()> {
+        self.runtime
+            .exec(self.id(), argv.into(), env.into(), cwd.into())
+    }
+}
+
+pub trait ContainerRuntime {
+    /// Starts a new container, returns the ID.
+    fn start_container(
+        &self,
+        image_name: &str,
+        mounts: &[(&Path, &str, bool)],
+    ) -> anyhow::Result<String>;
+
+    /// Stops a container.
+    fn stop_container(&self, container_id: &str);
+
+    /// Executes a command in a container.
+    fn exec(
+        &self,
+        container_id: &str,
+        argv: Vec<&str>,
+        env: Vec<(&str, &str)>,
+        cwd: &Path,
+    ) -> anyhow::Result<()>;
+}
+
+pub struct ContainerManager {
+    inner: Mutex<ContainerManagerInner>,
+}
+
+struct ContainerManagerInner {
+    containers: HashMap<String, Container>,
+    runtime: Arc<dyn ContainerRuntime>,
+}
+
+impl ContainerManager {
+    pub fn new(runtime: Arc<dyn ContainerRuntime>) -> Self {
+        Self {
+            inner: Mutex::new(ContainerManagerInner {
+                containers: HashMap::new(),
+                runtime,
+            }),
+        }
+    }
+
+    pub fn container(&self, name: &str) -> anyhow::Result<Container> {
+        let mut inner = self.inner.lock().unwrap();
+        if inner.containers.get(name).is_none() {
+            let container_id = inner.runtime.start_container("alpine:edge", &[])?;
+
+            crate::log!("info", "Started new container ({container_id})");
+
+            let container = Container::new(container_id, inner.runtime.clone());
+            inner.containers.insert(name.into(), container);
+        }
+
+        Ok(inner.containers.get(name).cloned().unwrap())
+    }
+}
+
+impl Drop for ContainerManager {
+    fn drop(&mut self) {
+        let inner = self.inner.lock().unwrap();
+        for (_, container) in inner.containers.iter() {
+            inner.runtime.stop_container(container.id());
+        }
+    }
+}

src/container/podman.rs

@@ -0,0 +1,101 @@
+use crate::container::ContainerRuntime;
+
+use anyhow::Context;
+use std::{
+    path::Path,
+    process::{Command, Stdio},
+};
+
+pub struct PodmanRuntime;
+
+impl PodmanRuntime {
+    pub fn new() -> anyhow::Result<Self> {
+        let output = Command::new("podman").arg("--version").output()?;
+
+        if output.status.success() {
+            Ok(Self)
+        } else {
+            anyhow::bail!(
+                "Could not execute `podman --version` - make sure you have podman installed."
+            );
+        }
+    }
+}
+
+impl ContainerRuntime for PodmanRuntime {
+    fn start_container(
+        &self,
+        image_name: &str,
+        mounts: &[(&Path, &str, bool)],
+    ) -> anyhow::Result<String> {
+        let mut cmd = Command::new("podman");
+
+        cmd.arg("run");
+        cmd.arg("--detach");
+        cmd.arg("--read-only");
+        cmd.arg("--network=none");
+        cmd.arg("--userns=keep-id");
+        cmd.arg("--tmpfs").arg("/builder/dest");
+        cmd.arg("--tmpfs").arg("/builder/sysroot");
+
+        for &(host, container, read_only) in mounts {
+            cmd.arg("--volume").arg(format!(
+                "{}:{}{}",
+                host.display(),
+                container,
+                if read_only { ":ro" } else { "" }
+            ));
+        }
+
+        cmd.arg(image_name);
+        cmd.arg("sleep").arg("infinity");
+
+        let output = cmd.output()?;
+
+        if output.status.success() {
+            Ok(String::from_utf8(output.stdout)
+                .context("container ID is not valid UTF-8")?
+                .trim()
+                .into())
+        } else {
+            todo!()
+        }
+    }
+
+    fn stop_container(&self, container_id: &str) {
+        Command::new("podman")
+            .arg("kill")
+            .arg(container_id)
+            .output()
+            .unwrap();
+    }
+
+    fn exec(
+        &self,
+        container_id: &str,
+        argv: Vec<&str>,
+        env: Vec<(&str, &str)>,
+        cwd: &Path,
+    ) -> anyhow::Result<()> {
+        let mut cmd = Command::new("podman");
+
+        cmd.arg("exec");
+        cmd.arg("--workdir").arg(cwd);
+
+        for (key, value) in env {
+            cmd.arg("--env").arg(format!("{key}={value}"));
+        }
+
+        cmd.arg(container_id);
+        cmd.args(argv);
+        cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit());
+
+        let output = cmd.output()?;
+
+        if output.status.success() {
+            Ok(())
+        } else {
+            anyhow::bail!("Failed to execute command");
+        }
+    }
+}

src/eval/config.rs

@@ -0,0 +1,154 @@
+use crate::eval::Path;
+
+use allocative::Allocative;
+use starlark::{
+    collections::SmallMap,
+    environment::GlobalsBuilder,
+    eval::Evaluator,
+    starlark_module, starlark_simple_value,
+    values::{StarlarkValue, Value, ValueLike, none::NoneType},
+};
+use starlark_derive::{NoSerialize, ProvidesStaticType, starlark_value};
+use std::{
+    cell::Cell,
+    collections::HashMap,
+    path::{Path as StdPath, PathBuf},
+};
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct PodmanConfig {
+    image: String,
+    dockerfile: PathBuf,
+}
+
+impl std::fmt::Display for PodmanConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "podman_config")
+    }
+}
+
+starlark_simple_value!(PodmanConfig);
+
+#[starlark_value(type = "podman_config")]
+impl<'v> StarlarkValue<'v> for PodmanConfig {}
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub enum ContainerConfig {
+    Podman(PodmanConfig),
+}
+
+impl std::fmt::Display for ContainerConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "container_config")
+    }
+}
+
+starlark_simple_value!(ContainerConfig);
+
+#[starlark_value(type = "container_config")]
+impl<'v> StarlarkValue<'v> for ContainerConfig {}
+
+#[derive(Debug, Clone, Allocative, ProvidesStaticType)]
+pub enum ConfigValue {
+    String(String),
+    Integer(i32),
+    Bool(bool),
+    Path(Path),
+}
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct Config {
+    arch: String,
+    container: ContainerConfig,
+    recipes_dir: Path,
+    host_recipes_dir: Path,
+
+    options: HashMap<String, ConfigValue>,
+}
+
+impl Config {
+    pub fn arch(&self) -> &str {
+        &self.arch
+    }
+
+    pub fn container(&self) -> &ContainerConfig {
+        &self.container
+    }
+
+    pub fn recipes_dir(&self) -> &StdPath {
+        &self.recipes_dir.path()
+    }
+
+    pub fn host_recipes_dir(&self) -> &StdPath {
+        &self.host_recipes_dir.path()
+    }
+
+    pub fn options(&self) -> &HashMap<String, ConfigValue> {
+        &self.options
+    }
+}
+
+impl std::fmt::Display for Config {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "container_config")
+    }
+}
+
+starlark_simple_value!(Config);
+
+#[starlark_value(type = "config")]
+impl<'v> StarlarkValue<'v> for Config {}
+
+#[starlark_module]
+pub fn config_globals(b: &mut GlobalsBuilder) {
+    fn podman(
+        #[starlark(require = named)] image: &str,
+        #[starlark(require = named)] dockerfile: &Path,
+    ) -> anyhow::Result<ContainerConfig> {
+        Ok(ContainerConfig::Podman(PodmanConfig {
+            image: image.to_string(),
+            dockerfile: dockerfile.path().to_owned(),
+        }))
+    }
+
+    fn config(
+        #[starlark(require = named)] arch: &str,
+        #[starlark(require = named)] container: &ContainerConfig,
+        #[starlark(require = named)] recipes_dir: &Path,
+        #[starlark(require = named)] host_recipes_dir: &Path,
+        #[starlark(kwargs)] kwargs: SmallMap<&str, Value>,
+        eval: &mut Evaluator,
+    ) -> anyhow::Result<NoneType> {
+        let config = eval
+            .extra
+            .and_then(|extra| extra.downcast_ref::<Cell<Option<Config>>>())
+            .ok_or_else(|| anyhow::anyhow!("`config` called outside of config.star"))?;
+
+        config.set(Some(Config {
+            arch: arch.to_string(),
+            container: container.clone(),
+            recipes_dir: recipes_dir.clone(),
+            host_recipes_dir: host_recipes_dir.clone(),
+            options: kwargs
+                .iter()
+                .map(|(&k, v)| {
+                    let value = if let Some(str) = v.unpack_str() {
+                        ConfigValue::String(str.to_string())
+                    } else if let Some(num) = v.unpack_i32() {
+                        ConfigValue::Integer(num)
+                    } else if let Some(bool) = v.unpack_bool() {
+                        ConfigValue::Bool(bool)
+                    } else if let Some(path) = v.downcast_ref::<Path>() {
+                        ConfigValue::Path(path.clone())
+                    } else {
+                        anyhow::bail!("config option must be a `string`, `int`, `bool` or `path`");
+                    };
+
+                    Ok((k.to_string(), value))
+                })
+                .collect::<Result<_, _>>()?,
+        }));
+
+        Ok(NoneType)
+    }
+}

src/eval/mod.rs

@@ -0,0 +1,96 @@
+use starlark::{
+    any::AnyLifetime,
+    environment::{FrozenModule, Globals, Module},
+    eval::Evaluator,
+    syntax::{AstModule, Dialect, DialectTypes},
+    values::{UnpackValue, Value, type_repr::StarlarkTypeRepr},
+};
+use std::path::Path as StdPath;
+
+mod config;
+mod recipe;
+mod types;
+
+#[allow(unused_imports)]
+pub use config::*;
+#[allow(unused_imports)]
+pub use recipe::*;
+#[allow(unused_imports)]
+pub use types::*;
+
+pub trait UnpackCloned: Sized + StarlarkTypeRepr {
+    fn unpack_cloned(value: Value<'_>) -> Option<Self>;
+}
+
+impl<T> UnpackCloned for T
+where
+    for<'v> T: UnpackValue<'v>,
+{
+    fn unpack_cloned(value: Value<'_>) -> Option<Self> {
+        T::unpack_value(value).unwrap()
+    }
+}
+
+pub fn eval_files(
+    path: &[&StdPath],
+    globals: &Globals,
+    lib_module: Option<&FrozenModule>,
+    config: Option<&Config>,
+    extra: Option<&dyn AnyLifetime>,
+) -> anyhow::Result<Module> {
+    use anyhow::Context;
+
+    let module = Module::new();
+
+    if let Some(lib_module) = lib_module {
+        module.import_public_symbols(lib_module);
+    }
+
+    if let Some(config) = config {
+        module.set("options", module.heap().alloc(config.clone()));
+    }
+
+    let mut paths = path.to_vec();
+
+    paths.sort();
+
+    let ast_modules = paths
+        .iter()
+        .map(|&path| {
+            let module = AstModule::parse_file(path, &default_dialect())
+                .map_err(|err| anyhow::anyhow!("{err}"))
+                .context(format!("parsing file {:?}", path.display()))?;
+
+            Ok((path, module))
+        })
+        .collect::<anyhow::Result<Vec<(&StdPath, AstModule)>>>()?;
+
+    for (path, ast) in ast_modules {
+        let mut eval = Evaluator::new(&module);
+
+        if let Some(extra) = extra {
+            eval.extra = Some(extra);
+        }
+
+        eval.eval_module(ast, globals)
+            .map_err(|err| anyhow::anyhow!("{err}"))
+            .context(format!("evaluating file {:?}", path.display()))?;
+    }
+
+    Ok(module)
+}
+
+fn default_dialect() -> Dialect {
+    Dialect {
+        enable_def: true,
+        enable_lambda: true,
+        enable_load: false,
+        enable_keyword_only_arguments: false,
+        enable_positional_only_arguments: false,
+        enable_types: DialectTypes::Disable,
+        enable_load_reexport: false,
+        enable_top_level_stmt: true,
+        enable_f_strings: true,
+        ..Dialect::Standard
+    }
+}

src/eval/recipe.rs

@@ -0,0 +1,202 @@
+use std::cell::Cell;
+
+use allocative::Allocative;
+use starlark::{
+    environment::{GlobalsBuilder, Methods, MethodsBuilder, MethodsStatic},
+    eval::Evaluator,
+    starlark_module, starlark_simple_value,
+    typing::Ty,
+    values::{
+        Heap, StarlarkValue, UnpackValue, Value, ValueLike, none::NoneType, tuple::UnpackTuple,
+        type_repr::StarlarkTypeRepr,
+    },
+};
+use starlark_derive::{NoSerialize, ProvidesStaticType, starlark_value};
+
+use crate::{
+    container::{Container, ContainerManager},
+    eval::{Path, UnpackCloned},
+    log,
+    recipe::Source,
+};
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct TarballSource {
+    url: String,
+    sha256: String,
+    strip_components: u32,
+}
+
+impl std::fmt::Display for TarballSource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "tarball")
+    }
+}
+
+starlark_simple_value!(TarballSource);
+
+#[starlark_value(type = "tarball")]
+impl<'v> StarlarkValue<'v> for TarballSource {}
+
+impl UnpackCloned for TarballSource {
+    fn unpack_cloned(value: Value<'_>) -> Option<Self> {
+        value.downcast_ref().cloned()
+    }
+}
+
+impl Source for TarballSource {}
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct Metadata {
+    maintainer: Option<String>,
+    description: Option<String>,
+    license: Option<String>,
+    website: Option<String>,
+}
+
+impl std::fmt::Display for Metadata {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "metadata")
+    }
+}
+
+starlark_simple_value!(Metadata);
+
+#[starlark_value(type = "metadata")]
+impl<'v> StarlarkValue<'v> for Metadata {}
+
+impl UnpackCloned for Metadata {
+    fn unpack_cloned(value: Value<'_>) -> Option<Self> {
+        value.downcast_ref().cloned()
+    }
+}
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct Context {
+    pub source_dir: Path,
+    pub build_dir: Path,
+    pub jobs: i32,
+}
+
+impl std::fmt::Display for Context {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "context")
+    }
+}
+
+starlark_simple_value!(Context);
+
+#[derive(Debug)]
+struct RunArg(pub String);
+
+impl UnpackValue<'_> for RunArg {
+    type Error = anyhow::Error;
+
+    fn unpack_value_impl(value: Value) -> anyhow::Result<Option<Self>> {
+        Ok(if let Some(str) = value.unpack_str() {
+            Some(RunArg(str.to_owned()))
+        } else if let Some(int) = value.unpack_i32() {
+            Some(RunArg(int.to_string()))
+        } else if let Some(path) = value.downcast_ref::<Path>() {
+            Some(RunArg(path.path().to_str().unwrap_or("").to_string()))
+        } else {
+            None
+        })
+    }
+}
+
+impl StarlarkTypeRepr for RunArg {
+    type Canonical = Self;
+
+    fn starlark_type_repr() -> starlark::typing::Ty {
+        Ty::string()
+    }
+}
+
+#[derive(ProvidesStaticType)]
+pub struct ContainerManagerWrapper<'a>(pub &'a ContainerManager);
+
+#[starlark_module]
+fn context_methods(b: &mut MethodsBuilder) {
+    fn run(
+        #[starlark(this)] this: &Context,
+        #[starlark(args)] args: UnpackTuple<RunArg>,
+        eval: &mut Evaluator,
+    ) -> anyhow::Result<NoneType> {
+        let ContainerManagerWrapper(container_manager) = eval
+            .extra
+            .and_then(|extra| extra.downcast_ref())
+            .ok_or_else(|| anyhow::anyhow!("`config` called outside of config.star"))?;
+
+        let argv = args.items.iter().map(|x| x.0.as_str()).collect::<Vec<_>>();
+
+        log!("run", "Running command: {argv:?}");
+
+        container_manager
+            .container("changeme")? // TODO
+            .exec(argv, [], std::path::Path::new("/"))?;
+
+        Ok(NoneType)
+    }
+}
+
+#[starlark_value(type = "context")]
+impl<'v> StarlarkValue<'v> for Context {
+    fn get_methods() -> Option<&'static Methods> {
+        static RES: MethodsStatic = MethodsStatic::new();
+        RES.methods(context_methods)
+    }
+
+    fn has_attr(&self, attr: &str, _heap: &Heap) -> bool {
+        match attr {
+            "source_dir" => true,
+            "build_dir" => true,
+            "jobs" => true,
+            _ => false,
+        }
+    }
+
+    fn get_attr(&self, attr: &str, heap: &'v Heap) -> Option<Value<'v>> {
+        match attr {
+            "source_dir" => Some(heap.alloc(self.source_dir.clone())),
+            "build_dir" => Some(heap.alloc(self.build_dir.clone())),
+            "jobs" => Some(heap.alloc(self.jobs)),
+            _ => None,
+        }
+    }
+}
+
+impl UnpackCloned for Context {
+    fn unpack_cloned(value: Value<'_>) -> Option<Self> {
+        value.downcast_ref().cloned()
+    }
+}
+
+#[starlark_module]
+pub fn recipe_globals(b: &mut GlobalsBuilder) {
+    fn tarball(
+        #[starlark(require = named)] url: &str,
+        #[starlark(require = named)] sha256: &str,
+        #[starlark(require = named, default = 0)] strip_components: u32,
+    ) -> anyhow::Result<TarballSource> {
+        Ok(TarballSource {
+            url: url.to_string(),
+            sha256: sha256.to_string(),
+            strip_components,
+        })
+    }
+
+    fn meta(
+        #[starlark(require = named)] maintainer: Option<&str>,
+        #[starlark(require = named)] description: Option<&str>,
+        #[starlark(require = named)] license: Option<&str>,
+        #[starlark(require = named)] website: Option<&str>,
+    ) -> anyhow::Result<Metadata> {
+        Ok(Metadata {
+            maintainer: maintainer.map(|x| x.to_string()),
+            description: description.map(|x| x.to_string()),
+            license: license.map(|x| x.to_string()),
+            website: website.map(|x| x.to_string()),
+        })
+    }
+}

src/eval/types.rs

@@ -0,0 +1,64 @@
+use allocative::Allocative;
+use starlark::{
+    environment::GlobalsBuilder,
+    starlark_module, starlark_simple_value,
+    values::{Heap, StarlarkValue, Value, ValueLike},
+};
+use starlark_derive::{NoSerialize, ProvidesStaticType, starlark_value};
+use std::path::{Path as StdPath, PathBuf};
+
+#[derive(Debug, Clone, Allocative, NoSerialize, ProvidesStaticType)]
+pub struct Path {
+    inner: PathBuf,
+}
+
+impl Path {
+    pub fn new(value: impl Into<PathBuf>) -> Self {
+        Self {
+            inner: value.into(),
+        }
+    }
+
+    pub fn path(&self) -> &StdPath {
+        &self.inner
+    }
+}
+
+impl std::fmt::Display for Path {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "path({:?})", self.inner)
+    }
+}
+
+starlark_simple_value!(Path);
+
+#[starlark_value(type = "path")]
+impl<'v> StarlarkValue<'v> for Path {
+    fn div(&self, other: Value<'v>, heap: &'v Heap) -> starlark::Result<Value<'v>> {
+        let rhs = if let Some(str) = other.unpack_str() {
+            str.to_string()
+        } else if let Some(path) = other.downcast_ref::<Path>() {
+            path.inner.to_str().unwrap_or("").to_string()
+        } else {
+            return Err(starlark::Error::new_other(anyhow::anyhow!(
+                "expected a `string` or `path`, got `{}`",
+                other.get_type()
+            )));
+        };
+
+        Ok(heap.alloc(Path {
+            inner: self
+                .inner
+                .join(rhs.trim_start_matches(std::path::MAIN_SEPARATOR_STR)),
+        }))
+    }
+}
+
+#[starlark_module]
+pub fn types_globals(b: &mut GlobalsBuilder) {
+    fn path(value: &str) -> anyhow::Result<Path> {
+        Ok(Path {
+            inner: PathBuf::from(value),
+        })
+    }
+}

src/graph.rs

@@ -1,135 +0,0 @@
-use crate::recipe::{OutputPackage, PackageKind, RecipeSet, unresolved_deps};
-use anyhow::{Result, anyhow, bail};
-use std::collections::{BTreeMap, BTreeSet};
-
-#[derive(Debug, Clone)]
-pub struct PackageGraph {
-    outputs: BTreeMap<String, OutputPackage>,
-    target_edges: BTreeMap<String, Vec<String>>,
-    host_edges: BTreeMap<String, Vec<String>>,
-}
-
-impl PackageGraph {
-    pub fn new(recipes: &RecipeSet) -> Result<Self> {
-        let missing = unresolved_deps(recipes);
-        if !missing.is_empty() {
-            bail!("unresolved local dependencies:\n{}", missing.join("\n"));
-        }
-        let mut target_edges = BTreeMap::new();
-        let mut host_edges = BTreeMap::new();
-        for recipe in recipes.recipes.values() {
-            // host_deps always resolve into the host namespace.
-            let host_dep_keys: Vec<String> = recipe
-                .host_deps
-                .iter()
-                .map(|d| PackageKind::Host.key(d))
-                .collect();
-            for output in &recipe.outputs {
-                let key = output.key();
-                let mut edges = output.all_target_deps();
-                if output.name == recipe.name {
-                    edges.extend(recipe.build_deps.iter().cloned());
-                    edges.extend(recipe.deps.iter().cloned());
-                }
-                match output.kind {
-                    PackageKind::Host => {
-                        host_edges.insert(key, host_dep_keys.clone());
-                    }
-                    PackageKind::Target => {
-                        let mut deps = host_dep_keys.clone();
-                        deps.extend(edges);
-                        target_edges.insert(key, deps);
-                    }
-                }
-            }
-        }
-        Ok(Self {
-            outputs: recipes.outputs.clone(),
-            target_edges,
-            host_edges,
-        })
-    }
-
-    pub fn output(&self, package: &str) -> Result<&OutputPackage> {
-        self.outputs
-            .get(package)
-            .ok_or_else(|| anyhow!("unknown package `{package}`"))
-    }
-
-    pub fn outputs(&self) -> impl Iterator<Item = &str> {
-        self.outputs.keys().map(String::as_str)
-    }
-
-    pub fn build_order(&self, package: &str) -> Result<Vec<String>> {
-        self.output(package)?;
-        let mut visiting = BTreeSet::new();
-        let mut visited = BTreeSet::new();
-        let mut order = Vec::new();
-        self.visit(package, &mut visiting, &mut visited, &mut order)?;
-        Ok(order)
-    }
-
-    /// Topologically-ordered list of every output in the graph (host + target).
-    pub fn build_order_all(&self) -> Result<Vec<String>> {
-        let mut visiting = BTreeSet::new();
-        let mut visited = BTreeSet::new();
-        let mut order = Vec::new();
-        for package in self.outputs.keys() {
-            self.visit(package, &mut visiting, &mut visited, &mut order)?;
-        }
-        Ok(order)
-    }
-
-    fn visit(
-        &self,
-        package: &str,
-        visiting: &mut BTreeSet<String>,
-        visited: &mut BTreeSet<String>,
-        order: &mut Vec<String>,
-    ) -> Result<()> {
-        if visited.contains(package) {
-            return Ok(());
-        }
-        if !visiting.insert(package.to_owned()) {
-            bail!("dependency cycle involving `{package}`");
-        }
-        let deps = self
-            .target_edges
-            .get(package)
-            .or_else(|| self.host_edges.get(package))
-            .cloned()
-            .unwrap_or_default();
-        for dep in deps {
-            self.visit(&dep, visiting, visited, order)?;
-        }
-        visiting.remove(package);
-        visited.insert(package.to_owned());
-        order.push(package.to_owned());
-        Ok(())
-    }
-
-    pub fn render(&self, package: Option<&str>) -> Result<Vec<String>> {
-        match package {
-            Some(package) => {
-                let order = self.build_order(package)?;
-                Ok(order
-                    .into_iter()
-                    .map(|pkg| format!("{pkg}: {:?}", self.edges(&pkg)))
-                    .collect())
-            }
-            None => Ok(self
-                .outputs
-                .keys()
-                .map(|pkg| format!("{pkg}: {:?}", self.edges(pkg)))
-                .collect()),
-        }
-    }
-
-    fn edges(&self, package: &str) -> Vec<String> {
-        self.target_edges
-            .get(package)
-            .or_else(|| self.host_edges.get(package))
-            .cloned()
-            .unwrap_or_default()
-    }
-}

src/log.rs

@@ -1,35 +1,20 @@
-//! Tiny stderr logger. We use a consistent `==> <action>: <details>` prefix
+use std::{io::IsTerminal, sync::LazyLock};
-//! so progress messages are easy to scan during long builds.
 
-use std::io::{IsTerminal, Write};
+static IS_STDERR_TERMINAL: LazyLock<bool> = LazyLock::new(|| std::io::stderr().is_terminal());
 
+pub fn __emit(color: &str, action: &str, args: std::fmt::Arguments) {
     const ARROW: &str = "==>";
 
-fn paint(color: &str, text: &str) -> String {
+    if *IS_STDERR_TERMINAL {
-    if std::io::stderr().is_terminal() {
+        eprintln!("\x1b[{color}m{ARROW}\x1b[0m \x1b[1m{action}\x1b[0m {args}");
-        format!("\x1b[{color}m{text}\x1b[0m")
     } else {
-        text.to_owned()
+        eprintln!("{ARROW} {action} {args}");
     }
 }
 
-fn emit(color: &str, action: &str, details: &str) {
+#[macro_export]
-    let arrow = paint(color, ARROW);
+macro_rules! log {
-    let action = paint("1", action);
+    ($action:literal, $($arg:tt)*) => {{
-    let _ = writeln!(std::io::stderr(), "{arrow} {action} {details}");
+        $crate::log::__emit("1;34", $action, format_args!($($arg)*));
-}
+    }};
-
-/// Major step, e.g. starting a build or packaging an output.
-pub fn step(action: &str, details: &str) {
-    emit("1;34", action, details); // bold blue
-}
-
-/// Cache hit / skipped work.
-pub fn skip(action: &str, details: &str) {
-    emit("1;33", action, details); // bold yellow
-}
-
-/// Sub-step inside a larger action.
-pub fn info(action: &str, details: &str) {
-    emit("1;32", action, details); // bold green
 }

src/main.rs

@@ -1,21 +1,136 @@
-mod apk;
+use crate::{
-mod build;
+    container::{ContainerManager, PodmanRuntime},
+    plan::{Plan, PlanKey},
+    recipe::{PackageRecipe, RecipeSet, SourceRecipe, ToolRecipe},
+};
+
+use std::{path::Path, sync::Arc};
+
 mod cli;
-mod config;
+mod container;
-mod graph;
+mod eval;
 mod log;
-mod patches;
+mod plan;
-mod phase;
 mod recipe;
-mod rewrite;
-mod source;
-mod starlark;
-mod update;
 
-use anyhow::Result;
+fn main() -> anyhow::Result<()> {
-use clap::Parser;
+    cli::run()
 
-fn main() -> Result<()> {
+    // let podman_runtime = Arc::new(PodmanRuntime::new()?);
-    let cli = cli::Cli::parse();
+    // let mut container_manager = ContainerManager::new(podman_runtime);
-    cli::run(cli)
+
+    // container_manager.container("example")?.exec(
+    //     vec!["sh", "-c", "uname -a && id"],
+    //     vec![],
+    //     Path::new("/"),
+    // )?;
+
+    // let mut recipes = RecipeSet::default();
+
+    // recipes.load_recipes(Path::new("./recipes"), Path::new("./host-recipes"))?;
+
+    // recipes.add_source(
+    //     "binutils-2.46",
+    //     SourceRecipe {
+    //         name: "binutils-2.46".into(),
+    //     },
+    // );
+
+    // recipes.add_source(
+    //     "gcc-16.1.0",
+    //     SourceRecipe {
+    //         name: "gcc-16.1.0".into(),
+    //     },
+    // );
+
+    // recipes.add_source(
+    //     "linux-7.0.9",
+    //     SourceRecipe {
+    //         name: "linux-7.0.9".into(),
+    //     },
+    // );
+
+    // recipes.add_source(
+    //     "glibc-2.41",
+    //     SourceRecipe {
+    //         name: "glibc-2.41".into(),
+    //     },
+    // );
+
+    // recipes.add_source(
+    //     "bash-5.3",
+    //     SourceRecipe {
+    //         name: "bash-5.3".into(),
+    //     },
+    // );
+
+    // recipes.add_tool(
+    //     "binutils",
+    //     ToolRecipe {
+    //         name: "binutils".into(),
+    //         sources: vec!["binutils-2.46".into()],
+    //         tools_wanted: vec![],
+    //         pkgs_wanted: vec![],
+    //     },
+    // );
+
+    // recipes.add_tool(
+    //     "gcc-bootstrap",
+    //     ToolRecipe {
+    //         name: "gcc-bootstrap".into(),
+    //         sources: vec!["gcc-16.1.0".into()],
+    //         tools_wanted: vec!["binutils".into()],
+    //         pkgs_wanted: vec![],
+    //     },
+    // );
+
+    // recipes.add_tool(
+    //     "gcc",
+    //     ToolRecipe {
+    //         name: "gcc".into(),
+    //         sources: vec!["gcc-16.1.0".into()],
+    //         tools_wanted: vec!["binutils".into()],
+    //         pkgs_wanted: vec!["glibc".into()],
+    //     },
+    // );
+
+    // recipes.add_package(
+    //     "linux-headers",
+    //     PackageRecipe {
+    //         name: "linux-headers".into(),
+    //         sources: vec!["linux-7.0.9".into()],
+    //         tools_wanted: vec![],
+    //         pkgs_wanted: vec![],
+    //     },
+    // );
+
+    // recipes.add_package(
+    //     "glibc",
+    //     PackageRecipe {
+    //         name: "glibc".into(),
+    //         sources: vec!["glibc-2.41".into()],
+    //         tools_wanted: vec!["gcc-bootstrap".into()],
+    //         pkgs_wanted: vec!["linux-headers".into()],
+    //     },
+    // );
+
+    // recipes.add_package(
+    //     "bash",
+    //     PackageRecipe {
+    //         name: "bash".into(),
+    //         sources: vec!["bash-5.3".into()],
+    //         tools_wanted: vec!["gcc".into()],
+    //         pkgs_wanted: vec!["glibc".into()],
+    //     },
+    // );
+
+    // let mut plan = Plan::new(&recipes);
+
+    // plan.add_wanted(PlanKey::PkgPackage(
+    //     recipes.package("bash").expect("back package"),
+    // ));
+
+    // println!("{:#?}", plan.steps()?);
+
+    // Ok(())
 }

src/patches.rs

@@ -1,19 +0,0 @@
-use anyhow::Result;
-use std::path::{Path, PathBuf};
-
-pub fn discover(recipe_dir: &Path) -> Result<Vec<PathBuf>> {
-    let patch_dir = recipe_dir.join("patches");
-    if !patch_dir.exists() {
-        return Ok(Vec::new());
-    }
-    let mut patches = Vec::new();
-    for entry in std::fs::read_dir(&patch_dir)? {
-        let entry = entry?;
-        let path = entry.path();
-        if path.extension().and_then(|ext| ext.to_str()) == Some("patch") {
-            patches.push(path);
-        }
-    }
-    patches.sort();
-    Ok(patches)
-}

src/phase.rs

@@ -1,213 +0,0 @@
-use crate::config::Config;
-use crate::starlark::{eval_content_with_extra, prepend_common_lib_load};
-use allocative::Allocative;
-use anyhow::{Result, anyhow, bail};
-use serde::{Deserialize, Serialize};
-use starlark::environment::{GlobalsBuilder, LibraryExtension};
-use starlark::eval::Evaluator;
-use starlark::starlark_module;
-use starlark::values::none::NoneType;
-use starlark::values::{ProvidesStaticType, Value};
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::path::Path;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Allocative)]
-pub struct PhaseCommand {
-    pub argv: Vec<String>,
-    /// Extra environment variables exported just for this command, in the
-    /// order the recipe supplied them. Empty means "inherit only".
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub env: Vec<(String, String)>,
-}
-
-/// How `ctx.source_dir` is exposed to Starlark.
-///
-/// * `Single` is a single container path (e.g. `/source`), used when the
-///   recipe declared a `source = {...}` form.
-/// * `Many` is a map of source name to container path, exposed as a
-///   `struct(...)` (e.g. `ctx.source_dir.linux`), used when the recipe
-///   declared `sources = {"linux": {...}, ...}`.
-#[derive(Debug, Clone)]
-pub enum SourceDir {
-    Single(String),
-    Many(BTreeMap<String, String>),
-}
-
-/// Per-phase paths exposed to Starlark as `ctx.source_dir`, `ctx.build_dir`,
-/// `ctx.dest_dir`, `ctx.prefix`, `ctx.sysroot` (Jinx-inspired).
-#[derive(Debug, Clone)]
-pub struct PhaseEnv<'a> {
-    pub source_dir: SourceDir,
-    pub build_dir: &'a str,
-    pub dest_dir: &'a str,
-    pub prefix: &'a str,
-    pub sysroot: &'a str,
-}
-
-#[derive(Debug, Default, ProvidesStaticType, Allocative)]
-struct CommandStore {
-    commands: RefCell<Vec<PhaseCommand>>,
-}
-
-impl CommandStore {
-    fn push(&self, command: PhaseCommand) {
-        self.commands.borrow_mut().push(command);
-    }
-}
-
-#[starlark_module]
-fn phase_globals(builder: &mut GlobalsBuilder) {
-    fn ctx_run<'v>(
-        argv: Value<'v>,
-        #[starlark(require = named, default = NoneType)] env: Value<'v>,
-        eval: &mut Evaluator,
-    ) -> anyhow::Result<NoneType> {
-        let json = argv.to_json()?;
-        let values: Vec<String> = serde_json::from_str(&json)
-            .map_err(|err| anyhow!("ctx.run expects a list of strings: {err}"))?;
-        if values.is_empty() {
-            bail!("ctx.run argv cannot be empty");
-        }
-        let env_vars = parse_env(env)?;
-        store(eval)?.push(PhaseCommand {
-            argv: values,
-            env: env_vars,
-        });
-        Ok(NoneType)
-    }
-
-    fn ctx_install(
-        src: &str,
-        dst: &str,
-        #[starlark(require = named, default = "644")] mode: &str,
-        eval: &mut Evaluator,
-    ) -> anyhow::Result<NoneType> {
-        store(eval)?.push(PhaseCommand {
-            argv: vec![
-                "install".to_owned(),
-                format!("-Dm{mode}"),
-                src.to_owned(),
-                dst.to_owned(),
-            ],
-            env: Vec::new(),
-        });
-        Ok(NoneType)
-    }
-}
-
-fn parse_env(value: Value<'_>) -> anyhow::Result<Vec<(String, String)>> {
-    if value.is_none() {
-        return Ok(Vec::new());
-    }
-    let json = value.to_json()?;
-    let map: serde_json::Map<String, serde_json::Value> = serde_json::from_str(&json)
-        .map_err(|err| anyhow!("ctx.run env must be a dict of string -> string: {err}"))?;
-    let mut out = Vec::with_capacity(map.len());
-    for (key, val) in map {
-        let serde_json::Value::String(val) = val else {
-            bail!("ctx.run env value for `{key}` must be a string");
-        };
-        if key.is_empty() || key.contains('=') {
-            bail!("ctx.run env key `{key}` is not a valid variable name");
-        }
-        out.push((key, val));
-    }
-    Ok(out)
-}
-
-fn store<'a, 'b, 'c, 'd>(eval: &'a Evaluator<'b, 'c, 'd>) -> anyhow::Result<&'a CommandStore> {
-    eval.extra
-        .ok_or_else(|| anyhow!("ctx command used without command store"))?
-        .downcast_ref::<CommandStore>()
-        .ok_or_else(|| anyhow!("command store has the wrong type"))
-}
-
-pub fn collect_phase_commands(
-    recipe_path: &Path,
-    repo_root: &Path,
-    config: &Config,
-    phase: &str,
-    env: &PhaseEnv<'_>,
-    package: Option<(&str, &str)>,
-) -> Result<Vec<PhaseCommand>> {
-    validate_identifier(phase)?;
-    let raw = std::fs::read_to_string(recipe_path)?;
-    // Auto-load helpers from `lib/common.star` so recipes never need an
-    // explicit `load()` for the canonical helpers.
-    let mut content = prepend_common_lib_load(Some(repo_root), Some(config), &raw)?;
-    let jobs = std::thread::available_parallelism()
-        .map(|j| j.get())
-        .unwrap_or(1);
-    let source_dir_expr = source_dir_literal(&env.source_dir)?;
-    let ctx_literal = format!(
-        "struct(run = ctx_run, install = ctx_install, jobs = {jobs}, \
-         source_dir = {sd}, build_dir = {bd}, dest_dir = {dd}, prefix = {pf}, sysroot = {sr})",
-        sd = source_dir_expr,
-        bd = serde_json::to_string(env.build_dir)?,
-        dd = serde_json::to_string(env.dest_dir)?,
-        pf = serde_json::to_string(env.prefix)?,
-        sr = serde_json::to_string(env.sysroot)?,
-    );
-    let call = match package {
-        Some((name, destdir)) => format!(
-            "\n__ctx = {ctx_literal}\n__pkg = struct(name = {n}, destdir = {d})\n{phase}(__ctx, __pkg)\n",
-            n = serde_json::to_string(name)?,
-            d = serde_json::to_string(destdir)?,
-        ),
-        None => format!("\n__ctx = {ctx_literal}\n{phase}(__ctx)\n"),
-    };
-    content.push_str(&call);
-    let globals = GlobalsBuilder::extended_by(&[LibraryExtension::StructType])
-        .with(phase_globals)
-        .build();
-    let cmd_store = CommandStore::default();
-    eval_content_with_extra(
-        recipe_path,
-        content,
-        Some(config),
-        Some(repo_root),
-        globals,
-        Some(&cmd_store),
-    )?;
-    Ok(cmd_store.commands.into_inner())
-}
-
-fn source_dir_literal(source_dir: &SourceDir) -> Result<String> {
-    match source_dir {
-        SourceDir::Single(path) => Ok(serde_json::to_string(path)?),
-        SourceDir::Many(map) => {
-            let mut fields = Vec::with_capacity(map.len());
-            for (name, path) in map {
-                if !is_valid_field_name(name) {
-                    bail!("source name `{name}` is not a valid Starlark identifier");
-                }
-                fields.push(format!("{name} = {}", serde_json::to_string(path)?));
-            }
-            Ok(format!("struct({})", fields.join(", ")))
-        }
-    }
-}
-
-fn is_valid_field_name(name: &str) -> bool {
-    let mut chars = name.chars();
-    match chars.next() {
-        Some(c) if c == '_' || c.is_ascii_alphabetic() => {}
-        _ => return false,
-    }
-    chars.all(|c| c == '_' || c.is_ascii_alphanumeric())
-}
-
-fn validate_identifier(name: &str) -> Result<()> {
-    let mut chars = name.chars();
-    let Some(first) = chars.next() else {
-        bail!("phase function name cannot be empty");
-    };
-    if !(first == '_' || first.is_ascii_alphabetic()) {
-        bail!("invalid phase function name `{name}`");
-    }
-    if chars.any(|ch| !(ch == '_' || ch.is_ascii_alphanumeric())) {
-        bail!("invalid phase function name `{name}`");
-    }
-    Ok(())
-}

src/plan.rs

@@ -0,0 +1,222 @@
+use crate::recipe::{PackageRecipe, RecipeSet, SourceRecipe, ToolRecipe};
+
+use petgraph::{
+    Direction,
+    graph::{DiGraph, NodeIndex},
+};
+use smallvec::{SmallVec, smallvec};
+use std::{
+    cmp::Reverse,
+    collections::{BinaryHeap, HashMap, HashSet},
+};
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum PlanError {
+    #[error("missing source recipe '{0}'")]
+    MissingSource(String),
+    #[error("missing tool recipe '{0}'")]
+    MissingTool(String),
+    #[error("missing package recipe '{0}'")]
+    MissingPackage(String),
+    #[error("plan cycle detected")]
+    CycleDetected,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PlanKey {
+    SourceFetch(String),
+    SourcePatch(String),
+    SourcePrepare(String),
+
+    ToolConfigure(String),
+    ToolBuild(String),
+    ToolInstall(String),
+
+    PkgConfigure(String),
+    PkgBuild(String),
+    PkgInstall(String),
+    PkgPackage(String),
+}
+
+impl PlanKey {
+    fn weight(&self) -> i8 {
+        match self {
+            PlanKey::SourceFetch(_) => 0,
+            PlanKey::SourcePatch(_) => 1,
+            PlanKey::SourcePrepare(_) => 2,
+            PlanKey::ToolConfigure(_) => 3,
+            PlanKey::ToolBuild(_) => 4,
+            PlanKey::ToolInstall(_) => 5,
+            PlanKey::PkgConfigure(_) => 6,
+            PlanKey::PkgBuild(_) => 7,
+            PlanKey::PkgInstall(_) => 8,
+            PlanKey::PkgPackage(_) => 9,
+        }
+    }
+
+    fn dependencies(&self, recipes: &RecipeSet) -> Result<SmallVec<[PlanKey; 8]>, PlanError> {
+        match self {
+            PlanKey::SourceFetch(_) => Ok(smallvec![]),
+            PlanKey::SourcePatch(recipe) => Ok(smallvec![PlanKey::SourceFetch(recipe.clone())]),
+            PlanKey::SourcePrepare(recipe) => Ok(smallvec![PlanKey::SourcePatch(recipe.clone())]),
+            PlanKey::ToolConfigure(recipe) => {
+                let recipe = recipes
+                    .tool(recipe)
+                    .ok_or(PlanError::MissingTool(recipe.clone()))?;
+
+                let source_deps = recipe.sources.iter().map(|name| {
+                    recipes
+                        .source(name)
+                        .map(|_| PlanKey::SourcePrepare(name.to_string()))
+                        .ok_or(PlanError::MissingSource(name.to_string()))
+                });
+
+                let tool_deps = recipe.tools_wanted.iter().map(|name| {
+                    recipes
+                        .tool(name)
+                        .map(|_| PlanKey::ToolInstall(name.to_string()))
+                        .ok_or(PlanError::MissingTool(name.to_string()))
+                });
+
+                let pkg_deps = recipe.pkgs_wanted.iter().map(|name| {
+                    recipes
+                        .package(name)
+                        .map(|_| PlanKey::PkgPackage(name.to_string()))
+                        .ok_or(PlanError::MissingPackage(name.to_string()))
+                });
+
+                source_deps.chain(tool_deps).chain(pkg_deps).collect()
+            }
+            PlanKey::ToolBuild(recipe) => Ok(smallvec![PlanKey::ToolConfigure(recipe.clone())]),
+            PlanKey::ToolInstall(recipe) => Ok(smallvec![PlanKey::ToolBuild(recipe.clone())]),
+            PlanKey::PkgConfigure(recipe) => {
+                let recipe = recipes
+                    .package(recipe)
+                    .ok_or(PlanError::MissingPackage(recipe.clone()))?;
+
+                let source_deps = recipe.sources.iter().map(|name| {
+                    recipes
+                        .source(name)
+                        .map(|_| PlanKey::SourcePrepare(name.to_string()))
+                        .ok_or(PlanError::MissingSource(name.to_string()))
+                });
+
+                let tool_deps = recipe.tools_wanted.iter().map(|name| {
+                    recipes
+                        .tool(name)
+                        .map(|_| PlanKey::ToolInstall(name.to_string()))
+                        .ok_or(PlanError::MissingTool(name.to_string()))
+                });
+
+                let pkg_deps = recipe.pkgs_wanted.iter().map(|name| {
+                    recipes
+                        .package(name)
+                        .map(|_| PlanKey::PkgPackage(name.to_string()))
+                        .ok_or(PlanError::MissingPackage(name.to_string()))
+                });
+
+                source_deps.chain(tool_deps).chain(pkg_deps).collect()
+            }
+            PlanKey::PkgBuild(recipe) => Ok(smallvec![PlanKey::PkgConfigure(recipe.clone())]),
+            PlanKey::PkgInstall(recipe) => Ok(smallvec![PlanKey::PkgBuild(recipe.clone())]),
+            PlanKey::PkgPackage(recipe) => Ok(smallvec![PlanKey::PkgInstall(recipe.clone())]),
+        }
+    }
+
+    fn is_active(&self) -> bool {
+        true
+    }
+}
+
+pub struct Plan<'a> {
+    recipes: &'a RecipeSet<'a>,
+    wanted: HashSet<PlanKey>,
+}
+
+impl<'a> Plan<'a> {
+    pub fn new(recipes: &'a RecipeSet) -> Self {
+        Self {
+            recipes,
+            wanted: HashSet::new(),
+        }
+    }
+
+    pub fn add_wanted(&mut self, key: PlanKey) {
+        self.wanted.insert(key);
+    }
+
+    pub fn steps(&self) -> Result<Vec<PlanKey>, PlanError> {
+        let mut stack: Vec<_> = self.wanted.iter().cloned().collect();
+        let mut graph: DiGraph<_, ()> = DiGraph::new();
+        let mut nodes = HashMap::new();
+
+        while let Some(node) = stack.pop() {
+            let node_idx = match nodes.get(&node) {
+                Some(&idx) => idx,
+                None => {
+                    let idx = graph.add_node(node.clone());
+                    nodes.insert(node.clone(), idx);
+                    idx
+                }
+            };
+
+            for dep in node.dependencies(self.recipes)? {
+                let dep_idx = match nodes.get(&dep) {
+                    Some(&idx) => idx,
+                    None => {
+                        let idx = graph.add_node(dep.clone());
+                        nodes.insert(dep.clone(), idx);
+                        stack.push(dep);
+                        idx
+                    }
+                };
+
+                graph.update_edge(dep_idx, node_idx, ());
+            }
+        }
+
+        // petgraph::algo::toposort(&graph, None)
+        //     .and_then(|nodes| {
+        //         Ok(nodes
+        //             .iter()
+        //             .map(|&k| graph[k])
+        //             .filter(|node| node.is_active())
+        //             .collect())
+        //     })
+        //     .map_err(|_| PlanError::CycleDetected)
+
+        let mut in_degree: HashMap<NodeIndex, usize> = graph
+            .node_indices()
+            .map(|i| (i, graph.neighbors_directed(i, Direction::Incoming).count()))
+            .collect();
+
+        let mut heap: BinaryHeap<(Reverse<i8>, NodeIndex)> = in_degree
+            .iter()
+            .filter(|&(_, d)| *d == 0)
+            .map(|(&i, _)| (Reverse(graph[i].weight()), i))
+            .collect();
+
+        let mut result = Vec::with_capacity(graph.node_count());
+
+        while let Some((_, idx)) = heap.pop() {
+            result.push(graph[idx].clone());
+
+            for neighbor in graph.neighbors_directed(idx, Direction::Outgoing) {
+                let d = in_degree.get_mut(&neighbor).unwrap();
+                *d -= 1;
+                if *d == 0 {
+                    heap.push((Reverse(graph[neighbor].weight()), neighbor));
+                }
+            }
+        }
+
+        if result.len() != graph.node_count() {
+            Err(PlanError::CycleDetected)
+        } else {
+            result.retain(|node| node.is_active());
+
+            Ok(result)
+        }
+    }
+}

src/recipe.rs

@@ -1,439 +1,256 @@
-use crate::config::Config;
+use anyhow::Context;
-use crate::starlark::{
+use starlark::{
-    eval_content, get_i32_default, get_json, get_string, get_string_default, get_string_vec,
+    environment::{FrozenModule, GlobalsBuilder, Module},
-    has_name, prepend_common_lib_load,
+    eval,
+    values::{
+        UnpackValue,
+        typing::{FrozenStarlarkCallable, StarlarkCallable, StarlarkCallableParamSpec},
+    },
+};
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
 };
-use anyhow::{Result, anyhow, bail};
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::collections::{BTreeMap, BTreeSet};
-use std::path::{Path, PathBuf};
-use walkdir::WalkDir;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+use crate::eval::{
-pub enum PackageKind {
+    Config, Metadata, TarballSource, UnpackCloned, eval_files, recipe_globals, types_globals,
-    Host,
+};
-    Target,
-}
 
-impl PackageKind {
+pub struct SourceRecipe {
-    /// Canonical `host:`/bare key form used across the graph, CLI and
-    /// manifest layer. Host and target trees are completely separate
-    /// namespaces — they may share names.
-    pub fn key(&self, name: &str) -> String {
-        match self {
-            PackageKind::Host => format!("host:{name}"),
-            PackageKind::Target => name.to_owned(),
-        }
-    }
-
-    /// Filesystem-safe variant of [`PackageKind::key`] (no `:`), used to
-    /// derive build/source/manifest directory names.
-    pub fn slug(&self, name: &str) -> String {
-        match self {
-            PackageKind::Host => format!("host-{name}"),
-            PackageKind::Target => name.to_owned(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Source {
-    /// Empty for the single-`source` form, otherwise the dict key from `sources`.
     pub name: String,
-    pub url: String,
+    pub source: Box<dyn Source>,
-    pub sha256: String,
-    /// Number of leading path components to strip when extracting (tar's
-    /// `--strip-components`). `0` means strip nothing.
-    pub strip_components: u32,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub trait Source {}
-pub struct OutputPackage {
+
+pub struct ToolRecipe {
     pub name: String,
-    /// Canonical key of the owning recipe (see [`PackageKind::key`]).
+    pub sources: Vec<String>,
-    pub recipe: String,
+    pub tools_wanted: Vec<String>,
-    pub kind: PackageKind,
+    pub pkgs_wanted: Vec<String>,
+}
+
+#[derive(Debug)]
+pub struct PackageRecipe {
+    pub name: String,
+    pub meta: Option<Metadata>,
     pub version: String,
-    pub revision: i32,
+    pub revision: u32,
-    pub description: String,
+    pub sources: Vec<String>,
-    pub license: String,
+    pub tools_wanted: Vec<String>,
-    /// Target packages installed into the build sysroot. Not propagated as
+    pub pkgs_wanted: Vec<String>,
-    /// apk `depends:` metadata.
+    pub module: FrozenModule,
-    pub build_deps: Vec<String>,
+    pub configure: Option<FrozenStarlarkCallable>,
-    /// Target packages declared as runtime dependencies (apk `depends:`).
+    pub build: Option<FrozenStarlarkCallable>,
-    /// Also installed into the sysroot so the recipe can link against them.
+    pub install: Option<FrozenStarlarkCallable>,
-    pub deps: Vec<String>,
-    pub install_fn: String,
 }
 
-impl OutputPackage {
+pub struct RecipeSet<'a> {
-    pub fn key(&self) -> String {
+    sources: HashMap<String, SourceRecipe>,
-        self.kind.key(&self.name)
+    tools: HashMap<String, ToolRecipe>,
+    pub packages: HashMap<String, PackageRecipe>,
+    config: &'a Config,
 }
 
-    /// Union of build- and run-dependencies (used to materialize the sysroot
+impl<'a> RecipeSet<'a> {
-    /// and to compute the build graph).
+    fn add_source(&mut self, name: &str, recipe: SourceRecipe) -> anyhow::Result<()> {
-    pub fn all_target_deps(&self) -> Vec<String> {
+        if self.sources.insert(name.to_string(), recipe).is_some() {
-        let mut out = self.build_deps.clone();
+            anyhow::bail!("source '{name}' already exists");
-        out.extend(self.deps.iter().cloned());
-        out
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Recipe {
-    pub id: String,
-    pub path: PathBuf,
-    pub dir: PathBuf,
-    pub name: String,
-    pub kind: PackageKind,
-    pub version: String,
-    pub revision: i32,
-    pub description: String,
-    pub license: String,
-    pub sources: Vec<Source>,
-    pub host_deps: Vec<String>,
-    pub build_deps: Vec<String>,
-    pub deps: Vec<String>,
-    pub outputs: Vec<OutputPackage>,
-    pub configure_fn: Option<String>,
-    pub build_fn: Option<String>,
-    pub check_fn: Option<String>,
-}
-
-impl Recipe {
-    /// Canonical key (`host:<id>` or `<id>`), used as the recipe-level
-    /// identifier in graphs, manifests and CLI references.
-    pub fn key(&self) -> String {
-        self.kind.key(&self.id)
-    }
-
-    /// Filesystem-safe variant of [`Recipe::key`].
-    pub fn slug(&self) -> String {
-        self.kind.slug(&self.id)
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct RecipeSet {
-    pub recipes: BTreeMap<String, Recipe>,
-    pub outputs: BTreeMap<String, OutputPackage>,
-}
-
-impl RecipeSet {
-    /// Discover recipes under `repo_root`:
-    /// * `recipes/<name>/recipe.star`      → target packages
-    /// * `host-recipes/<name>/recipe.star` → host packages
-    pub fn load(repo_root: &Path, config: &Config) -> Result<Self> {
-        let mut recipes = BTreeMap::new();
-        for (subdir, kind) in [
-            ("recipes", PackageKind::Target),
-            ("host-recipes", PackageKind::Host),
-        ] {
-            let root = repo_root.join(subdir);
-            if !root.exists() {
-                continue;
-            }
-            for entry in WalkDir::new(&root).follow_links(false) {
-                let entry = entry?;
-                if entry.file_type().is_file() && entry.file_name() == "recipe.star" {
-                    let recipe = Recipe::load(entry.path(), config, repo_root, kind.clone())?;
-                    let key = recipe.key();
-                    if recipes.insert(key.clone(), recipe).is_some() {
-                        bail!("duplicate recipe `{key}` below {}", root.display());
-                    }
-                }
-            }
-        }
-
-        let mut outputs = BTreeMap::new();
-        for recipe in recipes.values() {
-            for output in &recipe.outputs {
-                let key = output.key();
-                if outputs.insert(key.clone(), output.clone()).is_some() {
-                    bail!("duplicate package output `{key}`");
-                }
-            }
-        }
-        Ok(Self { recipes, outputs })
-    }
-
-    /// Look up a recipe by the package key produced by an output.
-    pub fn recipe_for_package(&self, package: &str) -> Result<&Recipe> {
-        let output = self
-            .outputs
-            .get(package)
-            .ok_or_else(|| anyhow!("unknown package `{package}`"))?;
-        self.recipes.get(&output.recipe).ok_or_else(|| {
-            anyhow!(
-                "package `{package}` references missing recipe `{}`",
-                output.recipe
-            )
-        })
-    }
-
-    /// Resolve a user-supplied reference (recipe key, output key, or bare
-    /// id — provided it isn't ambiguous between the host and target trees).
-    pub fn recipe_by_user_ref(&self, name: &str) -> Result<&Recipe> {
-        if let Some(recipe) = self.recipes.get(name) {
-            return Ok(recipe);
-        }
-        if self.outputs.contains_key(name) {
-            return self.recipe_for_package(name);
-        }
-        // Bare id: search both trees, error on ambiguity.
-        let host_key = PackageKind::Host.key(name);
-        let target_key = PackageKind::Target.key(name);
-        match (self.recipes.get(&host_key), self.recipes.get(&target_key)) {
-            (Some(_), Some(_)) => bail!(
-                "`{name}` is ambiguous: matches both `{host_key}` and `{target_key}`; \
-                 use the explicit form"
-            ),
-            (Some(r), None) | (None, Some(r)) => Ok(r),
-            (None, None) => bail!("unknown recipe `{name}`"),
-        }
-    }
-}
-
-impl Recipe {
-    pub fn load(path: &Path, config: &Config, repo_root: &Path, kind: PackageKind) -> Result<Self> {
-        // Auto-load helpers from `lib/common.star` so recipes never need an
-        // explicit `load()` for the canonical helpers.
-        let raw = std::fs::read_to_string(path)?;
-        let content = prepend_common_lib_load(Some(repo_root), Some(config), &raw)?;
-        let module = eval_content(
-            path,
-            content,
-            Some(config),
-            Some(repo_root),
-            starlark::environment::Globals::standard(),
-        )?;
-        let dir = path
-            .parent()
-            .unwrap_or_else(|| Path::new("."))
-            .to_path_buf();
-        let id = dir
-            .file_name()
-            .and_then(|name| name.to_str())
-            .ok_or_else(|| anyhow!("recipe path has no package directory: {}", path.display()))?
-            .to_owned();
-        let name = get_string(&module, "name")?;
-        let version = get_string(&module, "version")?;
-        let revision = get_i32_default(&module, "revision", 0)?;
-        let description = get_string_default(&module, "description", "???")?;
-        let license = get_string_default(&module, "license", "???")?;
-        let build_deps = get_string_vec(&module, "build_deps")?;
-        let deps = get_string_vec(&module, "deps")?;
-        let host_deps = get_string_vec(&module, "host_deps")?;
-        let sources = parse_sources(get_json(&module, "sources")?, get_json(&module, "source")?)?;
-        let subpackages = parse_subpackages(get_json(&module, "subpackages")?)?;
-        let mut outputs = Vec::new();
-        let recipe_key = kind.key(&id);
-        outputs.push(OutputPackage {
-            name: name.clone(),
-            recipe: recipe_key.clone(),
-            kind: kind.clone(),
-            version: version.clone(),
-            revision,
-            description: description.clone(),
-            license: license.clone(),
-            build_deps: build_deps.clone(),
-            deps: deps.clone(),
-            install_fn: "install".to_owned(),
-        });
-        for subpkg in subpackages {
-            let sub_name = subpkg
-                .get("name")
-                .and_then(JsonValue::as_str)
-                .ok_or_else(|| anyhow!("subpackage in `{name}` is missing string `name`"))?
-                .to_owned();
-            outputs.push(OutputPackage {
-                name: sub_name,
-                recipe: recipe_key.clone(),
-                kind: kind.clone(),
-                version: version.clone(),
-                revision,
-                description: subpkg
-                    .get("description")
-                    .and_then(JsonValue::as_str)
-                    .unwrap_or(&description)
-                    .to_owned(),
-                license: subpkg
-                    .get("license")
-                    .and_then(JsonValue::as_str)
-                    .unwrap_or(&license)
-                    .to_owned(),
-                build_deps: json_string_list(subpkg.get("build_deps"), "subpackage build_deps")?
-                    .unwrap_or_default(),
-                deps: json_string_list(subpkg.get("deps"), "subpackage deps")?.unwrap_or_default(),
-                install_fn: subpkg
-                    .get("install")
-                    .and_then(JsonValue::as_str)
-                    .unwrap_or("install")
-                    .to_owned(),
-            });
-        }
-        validate_required(&outputs)?;
-        Ok(Self {
-            id,
-            path: path.to_path_buf(),
-            dir,
-            name,
-            kind,
-            version,
-            revision,
-            description,
-            license,
-            sources,
-            host_deps,
-            build_deps,
-            deps,
-            outputs,
-            configure_fn: has_name(&module, "configure").then_some("configure".to_owned()),
-            build_fn: has_name(&module, "build").then_some("build".to_owned()),
-            check_fn: has_name(&module, "check").then_some("check".to_owned()),
-        })
-    }
-}
-
-fn validate_required(outputs: &[OutputPackage]) -> Result<()> {
-    for output in outputs {
-        if output.name.trim().is_empty() {
-            bail!("package output name cannot be empty");
-        }
-        for (field, value) in [
-            ("version", &output.version),
-            ("description", &output.description),
-            ("license", &output.license),
-        ] {
-            if value.trim().is_empty() {
-                bail!(
-                    "package `{}` has empty required field `{field}`",
-                    output.name
-                );
-            }
-        }
         }
         Ok(())
     }
 
-fn parse_sources(
+    fn add_tool(&mut self, name: &str, recipe: ToolRecipe) -> anyhow::Result<()> {
-    sources: Option<JsonValue>,
+        if self.tools.insert(name.to_string(), recipe).is_some() {
-    legacy_source: Option<JsonValue>,
+            anyhow::bail!("tool '{name}' already exists");
-) -> Result<Vec<Source>> {
-    match (sources, legacy_source) {
-        (Some(_), Some(_)) => bail!("recipe defines both `sources` and `source`; use only one"),
-        (None, None) => Ok(Vec::new()),
-        (None, Some(single)) => {
-            let obj = single
-                .as_object()
-                .ok_or_else(|| anyhow!("`source` must be a dict"))?;
-            Ok(vec![parse_source_entry(String::new(), obj)?])
-        }
-        (Some(multi), None) => {
-            let obj = multi
-                .as_object()
-                .ok_or_else(|| anyhow!("`sources` must be a dict of {{name: source}}"))?;
-            obj.iter()
-                .map(|(name, value)| {
-                    if name.is_empty() {
-                        bail!("source name in `sources` cannot be empty");
-                    }
-                    let entry = value
-                        .as_object()
-                        .ok_or_else(|| anyhow!("source `{name}` must be a dict"))?;
-                    parse_source_entry(name.clone(), entry)
-                })
-                .collect()
-        }
         }
+        Ok(())
     }
 
-fn parse_source_entry(name: String, obj: &serde_json::Map<String, JsonValue>) -> Result<Source> {
+    fn add_package(&mut self, name: &str, recipe: PackageRecipe) -> anyhow::Result<()> {
-    let url = obj
+        if self.packages.insert(name.to_string(), recipe).is_some() {
-        .get("url")
+            anyhow::bail!("package '{name}' already exists");
-        .and_then(JsonValue::as_str)
+        }
-        .ok_or_else(|| anyhow!("source entry missing string `url`"))?
+        Ok(())
-        .to_owned();
+    }
-    let sha256 = obj
+
-        .get("sha256")
+    fn load_tool_recipe(&mut self, name: &str, path: &Path) -> anyhow::Result<()> {
-        .and_then(JsonValue::as_str)
+        Ok(())
-        .unwrap_or("???")
+    }
-        .to_owned();
+
-    let strip_components = match obj.get("strip_components") {
+    fn load_package_recipe(&mut self, name: &str, path: &Path) -> anyhow::Result<()> {
-        None => 0,
+        let module = eval_files(
-        Some(JsonValue::Number(n)) => n
+            &[path],
-            .as_u64()
+            &GlobalsBuilder::standard()
-            .and_then(|v| u32::try_from(v).ok())
+                .with(types_globals)
-            .ok_or_else(|| anyhow!("source `strip_components` must be a non-negative integer"))?,
+                .with(recipe_globals)
-        Some(_) => bail!("source `strip_components` must be an integer"),
+                .build(),
-    };
+            None,
-    Ok(Source {
+            Some(self.config),
+            None,
+        )?;
+
+        let module = module.freeze().map_err(|err| anyhow::anyhow!("{err:?}"))?;
+
+        let version: String = get_value(&module, "version")?;
+        let revision: u32 = get_value_option(&module, "revision")?.unwrap_or(1);
+        let metadata: Option<Metadata> = get_value_option(&module, "metadata")?;
+        let source: TarballSource = get_value(&module, "source")?;
+
+        let configure = get_frozen_callable(&module, "configure")?;
+        let build = get_frozen_callable(&module, "build")?;
+        let install = get_frozen_callable(&module, "install")?;
+
+        self.add_source(
             name,
-        url,
+            SourceRecipe {
-        sha256,
+                name: name.to_string(),
-        strip_components,
+                source: Box::new(source),
-    })
+            },
+        )?;
+
+        self.add_package(
+            name,
+            PackageRecipe {
+                name: name.to_string(),
+                meta: metadata,
+                version,
+                revision,
+                sources: vec![name.to_string()],
+                tools_wanted: vec![],
+                pkgs_wanted: vec![],
+                module,
+                configure,
+                build,
+                install,
+            },
+        )
     }
 
-fn parse_subpackages(value: Option<JsonValue>) -> Result<Vec<serde_json::Map<String, JsonValue>>> {
+    pub fn new(config: &'a Config) -> Self {
-    match value {
+        Self {
-        Some(JsonValue::Array(values)) => values
+            sources: HashMap::new(),
-            .into_iter()
+            tools: HashMap::new(),
+            packages: HashMap::new(),
+            config,
+        }
+    }
+
+    pub fn load_recipes(
+        &mut self,
+        recipes_dir: &Path,
+        host_recipes_dir: &Path,
+    ) -> anyhow::Result<()> {
+        for (dir, tool_recipe) in [(recipes_dir, false), (host_recipes_dir, true)] {
+            for entry in std::fs::read_dir(dir)? {
+                let entry = entry.context("reading directory entry")?;
+
+                if let Some((name, path)) = get_recipe_name_and_patch(&entry)? {
+                    if tool_recipe {
+                        self.load_tool_recipe(&name, &path)?;
+                    } else {
+                        self.load_package_recipe(&name, &path)?;
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn source(&self, name: &str) -> Option<&SourceRecipe> {
+        self.sources.get(name)
+    }
+
+    pub fn tool(&self, name: &str) -> Option<&ToolRecipe> {
+        self.tools.get(name)
+    }
+
+    pub fn package(&self, name: &str) -> Option<&PackageRecipe> {
+        self.packages.get(name)
+    }
+}
+
+fn get_recipe_name_and_patch(
+    entry: &std::fs::DirEntry,
+) -> anyhow::Result<Option<(String, PathBuf)>> {
+    let file_type = entry.file_type()?;
+    let path = entry.path();
+
+    if file_type.is_dir() {
+        let recipe_path = path.join("recipe.star");
+
+        if recipe_path.exists() {
+            return Ok(Some((
+                entry.file_name().to_str().unwrap_or("").to_string(),
+                recipe_path,
+            )));
+        }
+    } else {
+        let name = path.file_stem().unwrap().to_str().unwrap_or("").to_string();
+        let extension = path
+            .extension()
+            .ok_or(anyhow::anyhow!("File did not have an extension"))?;
+
+        if extension == "star" {
+            return Ok(Some((name, path)));
+        }
+    }
+
+    Ok(None)
+}
+
+fn get_value_option<T: UnpackCloned>(
+    module: &FrozenModule,
+    name: &str,
+) -> anyhow::Result<Option<T>> {
+    module
+        .get_option(name)?
         .map(|value| {
-                value
+            T::unpack_cloned(value.value()).ok_or_else(|| {
-                    .as_object()
+                anyhow::anyhow!(
-                    .cloned()
+                    "`{name}` should be of type `{}` but got `{}`",
-                    .ok_or_else(|| anyhow!("subpackages entries must be objects"))
+                    T::starlark_type_repr(),
+                    value.value().get_type()
+                )
             })
-            .collect(),
+        })
-        Some(_) => bail!("subpackages must be a list of objects"),
+        .transpose()
-        None => Ok(Vec::new()),
-    }
 }
 
-fn json_string_list(value: Option<&JsonValue>, label: &str) -> Result<Option<Vec<String>>> {
+fn get_value<T: UnpackCloned>(module: &FrozenModule, name: &str) -> anyhow::Result<T> {
-    match value {
+    let value = module
-        Some(JsonValue::Array(values)) => values
+        .get_option(name)?
-            .iter()
+        .ok_or_else(|| anyhow::anyhow!("`{name}` is required"))?;
-            .map(|value| {
+
-                value
+    T::unpack_cloned(value.value()).ok_or_else(|| {
-                    .as_str()
+        anyhow::anyhow!(
-                    .map(ToOwned::to_owned)
+            "`{name}` should be of type `{}` but got `{}`",
-                    .ok_or_else(|| anyhow!("{label} must contain only strings"))
+            T::starlark_type_repr(),
+            value.value().get_type()
+        )
     })
-            .collect::<Result<Vec<_>>>()
-            .map(Some),
-        Some(_) => bail!("{label} must be a string list"),
-        None => Ok(None),
-    }
 }
 
-pub fn unresolved_deps(recipes: &RecipeSet) -> Vec<String> {
+fn get_frozen_callable<P: StarlarkCallableParamSpec>(
-    let names: BTreeSet<_> = recipes.outputs.keys().cloned().collect();
+    module: &FrozenModule,
-    let mut missing = Vec::new();
+    name: &str,
-    for recipe in recipes.recipes.values() {
+) -> anyhow::Result<Option<FrozenStarlarkCallable<P>>> {
-        // host_deps always refer to host outputs (canonical `host:<name>`);
+    let Some(value) = module.get_option(name)? else {
-        // build_deps / deps refer to target outputs (bare names).
+        return Ok(None);
-        for dep in &recipe.host_deps {
+    };
-            let key = PackageKind::Host.key(dep);
+
-            if !names.contains(&key) {
+    let callable = StarlarkCallable::unpack_value(value.value())
-                missing.push(format!("{} -> {key}", recipe.key()));
+        .map_err(|err| anyhow::anyhow!("{err}"))?
-            }
+        .ok_or_else(|| {
-        }
+            anyhow::anyhow!(
-        for dep in recipe.build_deps.iter().chain(recipe.deps.iter()) {
+                "`{name}` should be callable but got `{}`",
-            if !names.contains(dep) {
+                value.value().get_type()
-                missing.push(format!("{} -> {dep}", recipe.key()));
+            )
-            }
+        })?;
-        }
+
-        for output in &recipe.outputs {
+    callable
-            for dep in output.build_deps.iter().chain(output.deps.iter()) {
+        .unpack_frozen()
-                if !names.contains(dep) {
+        .ok_or_else(|| anyhow::anyhow!("`{name}` was callable but not frozen"))
-                    missing.push(format!("{} -> {dep}", output.key()));
+        .map(Some)
-                }
-            }
-        }
-    }
-    missing
 }

src/rewrite.rs

@@ -1,39 +0,0 @@
-use anyhow::{Context, Result};
-use std::fs;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Rewrite {
-    pub field: String,
-    pub old: String,
-    pub new: String,
-}
-
-pub fn backup_path(path: &Path) -> PathBuf {
-    let mut backup = path.as_os_str().to_os_string();
-    backup.push(".bak");
-    PathBuf::from(backup)
-}
-
-pub fn rewrite_placeholders(path: &Path, rewrites: &[Rewrite]) -> Result<bool> {
-    if rewrites.is_empty() {
-        return Ok(false);
-    }
-    let original =
-        fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
-    let mut updated = original.clone();
-    for rewrite in rewrites {
-        let quoted_old = format!("{} = \"{}\"", rewrite.field, rewrite.old);
-        let quoted_new = format!("{} = \"{}\"", rewrite.field, rewrite.new);
-        updated = updated.replacen(&quoted_old, &quoted_new, 1);
-        let dict_old = format!("\"{}\": \"{}\"", rewrite.field, rewrite.old);
-        let dict_new = format!("\"{}\": \"{}\"", rewrite.field, rewrite.new);
-        updated = updated.replacen(&dict_old, &dict_new, 1);
-    }
-    if updated == original {
-        return Ok(false);
-    }
-    fs::write(backup_path(path), original)?;
-    fs::write(path, updated)?;
-    Ok(true)
-}

src/source.rs

@@ -1,73 +0,0 @@
-use crate::log;
-use crate::recipe::Recipe;
-use crate::rewrite::{Rewrite, rewrite_placeholders};
-use anyhow::{Context, Result, bail};
-use sha2::{Digest, Sha256};
-use std::fs;
-use std::io::Read;
-use std::path::{Path, PathBuf};
-
-pub fn fetch_sources(recipe: &Recipe, cache_dir: &Path) -> Result<Vec<PathBuf>> {
-    fs::create_dir_all(cache_dir)?;
-    let mut rewrites = Vec::new();
-    let mut paths = Vec::new();
-    for source in &recipe.sources {
-        let label = if source.name.is_empty() {
-            recipe.key()
-        } else {
-            format!("{}:{}", recipe.key(), source.name)
-        };
-        let cached = source.sha256 != "???" && cache_dir.join(&source.sha256).exists();
-        if cached {
-            log::skip("cached", &format!("{label} ({})", source.url));
-            paths.push(cache_dir.join(&source.sha256));
-            continue;
-        }
-        log::step("fetch", &format!("{label} <- {}", source.url));
-        let bytes = download(&source.url)?;
-        let actual = sha256_hex(&bytes);
-        if source.sha256 == "???" {
-            log::info("sha256", &format!("{label} = {actual}"));
-            rewrites.push(Rewrite {
-                field: "sha256".into(),
-                old: "???".into(),
-                new: actual.clone(),
-            });
-        } else if source.sha256 != actual {
-            bail!(
-                "checksum mismatch for {}: expected {}, got {}",
-                source.url,
-                source.sha256,
-                actual
-            );
-        }
-        let path = cache_dir.join(&actual);
-        if !path.exists() {
-            fs::write(&path, &bytes)
-                .with_context(|| format!("failed to write {}", path.display()))?;
-        }
-        paths.push(path);
-    }
-    rewrite_placeholders(&recipe.path, &rewrites)?;
-    Ok(paths)
-}
-
-fn download(url: &str) -> Result<Vec<u8>> {
-    if let Some(path) = url.strip_prefix("file://") {
-        return Ok(fs::read(path)?);
-    }
-    // Some mirrors reject requests without a User-Agent with HTTP 403, so set an explicit one.
-    let client = reqwest::blocking::Client::builder()
-        .user_agent(concat!("distro/", env!("CARGO_PKG_VERSION")))
-        .build()?;
-    let mut response = client.get(url).send()?.error_for_status()?;
-    let mut bytes = Vec::new();
-    response.read_to_end(&mut bytes)?;
-    Ok(bytes)
-}
-
-pub fn sha256_hex(bytes: &[u8]) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update(bytes);
-    hex::encode(hasher.finalize())
-}

src/starlark.rs

@@ -1,513 +0,0 @@
-use crate::config::Config;
-use allocative::{Allocative, Visitor, ident_key};
-use anyhow::{Result, anyhow, bail};
-use serde_json::Value as JsonValue;
-use starlark::environment::{FrozenModule, Globals, Module};
-use starlark::eval::{Evaluator, FileLoader};
-use starlark::starlark_simple_value;
-use starlark::syntax::{AstModule, Dialect};
-use starlark::values::dict::AllocDict;
-use starlark::values::{AnyLifetime, Heap, NoSerialize, ProvidesStaticType, StarlarkValue, Value};
-use starlark_derive::starlark_value;
-use std::collections::{BTreeMap, HashMap};
-use std::fmt::{self, Display};
-use std::mem;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone, ProvidesStaticType, NoSerialize)]
-pub struct OptionsValue {
-    values: BTreeMap<String, JsonValue>,
-}
-
-impl OptionsValue {
-    fn new(values: BTreeMap<String, JsonValue>) -> Result<Self> {
-        for key in values.keys() {
-            validate_starlark_identifier(key)?;
-        }
-        Ok(Self { values })
-    }
-}
-
-impl Display for OptionsValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "options")
-    }
-}
-
-starlark_simple_value!(OptionsValue);
-
-impl Allocative for OptionsValue {
-    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
-        let mut visitor = visitor.enter_self(self);
-        visitor.visit_simple(
-            ident_key!(values),
-            mem::size_of::<(String, JsonValue)>() * self.values.len(),
-        );
-        visitor.exit();
-    }
-}
-
-#[starlark_value(type = "options")]
-impl<'v> StarlarkValue<'v> for OptionsValue {
-    fn get_attr(&self, attr: &str, heap: &'v Heap) -> Option<Value<'v>> {
-        self.values.get(attr).map(|value| heap.alloc(value))
-    }
-}
-
-#[derive(Debug, Clone, ProvidesStaticType, NoSerialize, Allocative)]
-pub struct SettingsValue {
-    target_arch: String,
-    container_runtime: String,
-    container_image: String,
-    container_dockerfile: String,
-    options: BTreeMap<String, String>,
-}
-
-impl From<&Config> for SettingsValue {
-    fn from(config: &Config) -> Self {
-        Self {
-            target_arch: config.target_arch.clone(),
-            container_runtime: config.container_runtime.clone(),
-            container_image: config.container_image.clone(),
-            container_dockerfile: config.container_dockerfile.display().to_string(),
-            options: config
-                .options
-                .iter()
-                .map(|(key, value)| (key.clone(), option_value_to_string(value)))
-                .collect(),
-        }
-    }
-}
-
-impl Display for SettingsValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "settings")
-    }
-}
-
-starlark_simple_value!(SettingsValue);
-
-#[starlark_value(type = "settings")]
-impl<'v> StarlarkValue<'v> for SettingsValue {
-    fn get_attr(&self, attr: &str, heap: &'v Heap) -> Option<Value<'v>> {
-        match attr {
-            "target_arch" => Some(heap.alloc(self.target_arch.as_str())),
-            "container_runtime" => Some(heap.alloc(self.container_runtime.as_str())),
-            "container_image" => Some(heap.alloc(self.container_image.as_str())),
-            "container_dockerfile" => Some(heap.alloc(self.container_dockerfile.as_str())),
-            "options" => Some(heap.alloc(AllocDict(self.options.clone()))),
-            _ => None,
-        }
-    }
-}
-
-pub fn eval_file(
-    path: &Path,
-    settings: Option<&Config>,
-    repo_root: Option<&Path>,
-) -> Result<Module> {
-    let content = std::fs::read_to_string(path)?;
-    eval_content(path, content, settings, repo_root, Globals::standard())
-}
-
-/// Path of the implicit helper library auto-loaded into every recipe.
-pub const COMMON_LIB_MODULE: &str = "//lib:common.star";
-const COMMON_LIB_RELATIVE: &str = "lib/common.star";
-const OPTIONS_NAME: &str = "OPTIONS";
-
-/// Names exported by `lib/common.star`, if the file exists. Empty otherwise.
-pub fn common_lib_names(repo_root: &Path, settings: Option<&Config>) -> Result<Vec<String>> {
-    let path = repo_root.join(COMMON_LIB_RELATIVE);
-    if !path.exists() {
-        return Ok(Vec::new());
-    }
-    let module = eval_file(&path, settings, Some(repo_root))?;
-    Ok(module
-        .names()
-        .map(|n| n.as_str().to_owned())
-        .filter(|n| !n.starts_with('_') && n != "settings" && n != OPTIONS_NAME)
-        .collect())
-}
-
-/// Prepend an implicit `load("//lib:common.star", ...)` so every recipe sees
-/// the shared helpers without an explicit import. Does nothing if there's no
-/// `lib/common.star` or no repo root.
-pub fn prepend_common_lib_load(
-    repo_root: Option<&Path>,
-    settings: Option<&Config>,
-    content: &str,
-) -> Result<String> {
-    let Some(root) = repo_root else {
-        return Ok(content.to_owned());
-    };
-    let names = common_lib_names(root, settings)?;
-    if names.is_empty() {
-        return Ok(content.to_owned());
-    }
-    let names_lit = names
-        .iter()
-        .map(|n| format!("{:?}", n))
-        .collect::<Vec<_>>()
-        .join(", ");
-    Ok(format!(
-        "load(\"{COMMON_LIB_MODULE}\", {names_lit})\n{content}"
-    ))
-}
-
-pub fn eval_content(
-    path: &Path,
-    content: String,
-    settings: Option<&Config>,
-    repo_root: Option<&Path>,
-    globals: Globals,
-) -> Result<Module> {
-    eval_content_with_extra(path, content, settings, repo_root, globals, None)
-}
-
-pub fn eval_content_with_extra<'a>(
-    path: &Path,
-    content: String,
-    settings: Option<&Config>,
-    repo_root: Option<&Path>,
-    globals: Globals,
-    extra: Option<&'a dyn AnyLifetime<'a>>,
-) -> Result<Module> {
-    let filename = path.display().to_string();
-    validate_options_source(path, &content)?;
-    let ast = AstModule::parse(
-        &filename,
-        content,
-        &Dialect {
-            enable_f_strings: true,
-            enable_top_level_stmt: true,
-            ..Dialect::Standard
-        },
-    )
-    .map_err(|err| anyhow!("{err}"))?;
-    let loader = match repo_root {
-        Some(root) => Some(RepoFileLoader::new(root, settings, globals.clone(), &ast)?),
-        None if !ast.loads().is_empty() => {
-            bail!(
-                "load() requires a repo root while evaluating {}",
-                path.display()
-            )
-        }
-        None => None,
-    };
-    let module = Module::new();
-    let protected_options = if let Some(config) = settings {
-        Some(set_config_values(&module, config)?)
-    } else {
-        None
-    };
-    {
-        let mut eval = Evaluator::new(&module);
-        if let Some(loader) = &loader {
-            eval.set_loader(loader);
-        }
-        eval.extra = extra;
-        eval.eval_module(ast, &globals)
-            .map_err(|err| anyhow!("{err}"))?;
-    }
-    validate_options_binding(path, &module, protected_options)?;
-    Ok(module)
-}
-
-fn validate_options_source(path: &Path, content: &str) -> Result<()> {
-    let line_offset = implicit_common_load_line_offset(content);
-    for (index, line) in content.lines().enumerate() {
-        let code = line.split('#').next().unwrap_or_default().trim_start();
-        if defines_or_reassigns_options(code) {
-            let line = (index + 1).saturating_sub(line_offset).max(1);
-            bail!(
-                "{}:{} must not define or reassign `{OPTIONS_NAME}`",
-                path.display(),
-                line
-            );
-        }
-    }
-    Ok(())
-}
-
-fn implicit_common_load_line_offset(content: &str) -> usize {
-    content
-        .lines()
-        .next()
-        .is_some_and(|line| line.starts_with(&format!("load(\"{COMMON_LIB_MODULE}\",")))
-        as usize
-}
-
-fn defines_or_reassigns_options(code: &str) -> bool {
-    let Some(rest) = code.strip_prefix(OPTIONS_NAME) else {
-        return defines_options_function(code) || binds_options_loop_variable(code);
-    };
-    let rest = rest.trim_start();
-    rest.starts_with('=')
-        || rest.starts_with("+=")
-        || rest.starts_with("-=")
-        || rest.starts_with("*=")
-        || rest.starts_with("/=")
-        || rest.starts_with("%=")
-        || rest.starts_with("&=")
-        || rest.starts_with("|=")
-        || rest.starts_with("^=")
-}
-
-fn defines_options_function(code: &str) -> bool {
-    code.strip_prefix("def ")
-        .and_then(|rest| rest.trim_start().strip_prefix(OPTIONS_NAME))
-        .is_some_and(|rest| rest.trim_start().starts_with('('))
-}
-
-fn binds_options_loop_variable(code: &str) -> bool {
-    code.strip_prefix("for ")
-        .and_then(|rest| rest.trim_start().strip_prefix(OPTIONS_NAME))
-        .is_some_and(|rest| rest.trim_start().starts_with("in "))
-}
-
-fn validate_options_binding(
-    path: &Path,
-    module: &Module,
-    expected: Option<Value<'_>>,
-) -> Result<()> {
-    let Some(expected) = expected else {
-        return Ok(());
-    };
-    let actual = module.get(OPTIONS_NAME).ok_or_else(|| {
-        anyhow!(
-            "{} removed the protected `{OPTIONS_NAME}` binding",
-            path.display()
-        )
-    })?;
-    if !actual.ptr_eq(expected) {
-        bail!(
-            "{} must not define or reassign `{OPTIONS_NAME}`",
-            path.display()
-        );
-    }
-    Ok(())
-}
-
-#[derive(Clone)]
-struct RepoFileLoader {
-    modules: HashMap<String, FrozenModule>,
-}
-
-impl RepoFileLoader {
-    fn new(
-        repo_root: &Path,
-        settings: Option<&Config>,
-        globals: Globals,
-        ast: &AstModule,
-    ) -> Result<Self> {
-        let mut modules = HashMap::new();
-        for load in ast.loads() {
-            load_module(
-                repo_root,
-                settings,
-                globals.clone(),
-                load.module_id,
-                &mut modules,
-            )?;
-        }
-        Ok(Self { modules })
-    }
-}
-
-impl FileLoader for RepoFileLoader {
-    fn load(&self, path: &str) -> starlark::Result<FrozenModule> {
-        self.modules
-            .get(path)
-            .cloned()
-            .ok_or_else(|| starlark::Error::new_other(anyhow!("unknown Starlark module `{path}`")))
-    }
-}
-
-fn load_module(
-    repo_root: &Path,
-    settings: Option<&Config>,
-    globals: Globals,
-    module_id: &str,
-    modules: &mut HashMap<String, FrozenModule>,
-) -> Result<()> {
-    if modules.contains_key(module_id) {
-        return Ok(());
-    }
-    let path = resolve_load_path(repo_root, module_id)?;
-    let content = std::fs::read_to_string(&path)?;
-    let filename = path.display().to_string();
-    validate_options_source(&path, &content)?;
-    let ast =
-        AstModule::parse(&filename, content, &Dialect::Standard).map_err(|err| anyhow!("{err}"))?;
-    for load in ast.loads() {
-        load_module(
-            repo_root,
-            settings,
-            globals.clone(),
-            load.module_id,
-            modules,
-        )?;
-    }
-    let nested_loader = RepoFileLoader {
-        modules: modules.clone(),
-    };
-    let module = Module::new();
-    let protected_options = if let Some(config) = settings {
-        Some(set_config_values(&module, config)?)
-    } else {
-        None
-    };
-    {
-        let mut eval = Evaluator::new(&module);
-        eval.set_loader(&nested_loader);
-        eval.eval_module(ast, &globals)
-            .map_err(|err| anyhow!("{err}"))?;
-    }
-    validate_options_binding(&path, &module, protected_options)?;
-    let frozen = module.freeze().map_err(|err| anyhow!("{err:?}"))?;
-    modules.insert(module_id.to_owned(), frozen);
-    Ok(())
-}
-
-fn set_config_values<'v>(module: &'v Module, config: &Config) -> Result<Value<'v>> {
-    module.set("settings", module.heap().alloc(SettingsValue::from(config)));
-    let options = module
-        .heap()
-        .alloc(OptionsValue::new(config.options.clone())?);
-    module.set(OPTIONS_NAME, options);
-    Ok(options)
-}
-
-fn validate_starlark_identifier(name: &str) -> Result<()> {
-    let mut chars = name.chars();
-    let Some(first) = chars.next() else {
-        bail!("config option name cannot be empty");
-    };
-    if !(first == '_' || first.is_ascii_alphabetic()) {
-        bail!("config option `{name}` is not a valid Starlark identifier");
-    }
-    if chars.any(|ch| !(ch == '_' || ch.is_ascii_alphanumeric())) {
-        bail!("config option `{name}` is not a valid Starlark identifier");
-    }
-    if matches!(
-        name,
-        "and"
-            | "as"
-            | "assert"
-            | "break"
-            | "class"
-            | "continue"
-            | "def"
-            | "del"
-            | "elif"
-            | "else"
-            | "except"
-            | "finally"
-            | "for"
-            | "from"
-            | "global"
-            | "if"
-            | "import"
-            | "in"
-            | "is"
-            | "lambda"
-            | "load"
-            | "not"
-            | "or"
-            | "pass"
-            | "return"
-            | "try"
-            | "while"
-            | "with"
-            | "yield"
-    ) {
-        bail!("config option `{name}` is a reserved Starlark keyword");
-    }
-    Ok(())
-}
-
-fn resolve_load_path(repo_root: &Path, module_id: &str) -> Result<PathBuf> {
-    let relative = if let Some(stripped) = module_id.strip_prefix("//") {
-        stripped.replace(':', "/")
-    } else {
-        module_id.to_owned()
-    };
-    let path = repo_root.join(relative);
-    let canonical_root = repo_root
-        .canonicalize()
-        .unwrap_or_else(|_| repo_root.to_path_buf());
-    let canonical_path = path.canonicalize().unwrap_or(path);
-    if !canonical_path.starts_with(&canonical_root) {
-        bail!("Starlark load escapes repo root: {module_id}");
-    }
-    Ok(canonical_path)
-}
-
-fn option_value_to_string(value: &JsonValue) -> String {
-    match value {
-        JsonValue::String(value) => value.clone(),
-        JsonValue::Bool(value) => value.to_string(),
-        JsonValue::Number(value) => value.to_string(),
-        JsonValue::Null => "null".to_owned(),
-        JsonValue::Array(_) | JsonValue::Object(_) => value.to_string(),
-    }
-}
-
-pub fn get_string(module: &Module, name: &str) -> Result<String> {
-    module
-        .get(name)
-        .and_then(|v| v.unpack_str().map(ToOwned::to_owned))
-        .ok_or_else(|| anyhow!("missing or non-string Starlark variable `{name}`"))
-}
-
-pub fn get_string_default(module: &Module, name: &str, default: &str) -> Result<String> {
-    Ok(match module.get(name) {
-        Some(value) => value
-            .unpack_str()
-            .ok_or_else(|| anyhow!("non-string Starlark variable `{name}`"))?
-            .to_owned(),
-        None => default.to_owned(),
-    })
-}
-
-pub fn get_i32_default(module: &Module, name: &str, default: i32) -> Result<i32> {
-    Ok(match module.get(name) {
-        Some(value) => value
-            .unpack_i32()
-            .ok_or_else(|| anyhow!("non-integer Starlark variable `{name}`"))?,
-        None => default,
-    })
-}
-
-pub fn has_name(module: &Module, name: &str) -> bool {
-    module.get(name).is_some()
-}
-
-pub fn get_json(module: &Module, name: &str) -> Result<Option<JsonValue>> {
-    match module.get(name) {
-        Some(value) => Ok(Some(serde_json::from_str(&value.to_json()?)?)),
-        None => Ok(None),
-    }
-}
-
-pub fn get_string_vec(module: &Module, name: &str) -> Result<Vec<String>> {
-    match get_json(module, name)? {
-        Some(JsonValue::Array(values)) => values
-            .into_iter()
-            .map(|value| match value {
-                JsonValue::String(s) => Ok(s),
-                _ => bail!("`{name}` must be a list of strings"),
-            })
-            .collect(),
-        Some(_) => bail!("`{name}` must be a list of strings"),
-        None => Ok(Vec::new()),
-    }
-}
-
-pub fn get_json_map(module: &Module, name: &str) -> Result<BTreeMap<String, JsonValue>> {
-    match get_json(module, name)? {
-        Some(JsonValue::Object(values)) => Ok(values.into_iter().collect()),
-        Some(_) => bail!("`{name}` must be a dict"),
-        None => Ok(BTreeMap::new()),
-    }
-}

src/update.rs

@@ -1,256 +0,0 @@
-//! `distro update` — check repology for newer upstream versions and bump
-//! recipes in-place.
-//!
-//! For each requested recipe we query
-//! `https://repology.org/api/v1/project/<name>` and pick the highest version
-//! among entries whose `status` is `"newest"` or `"unique"` (i.e. not
-//! outdated, not rolling/devel, not ignored). If that version is strictly
-//! greater than the recipe's current `version`, we rewrite:
-//!
-//! * `version = "..."` → the new upstream version
-//! * `revision = N`    → `revision = 1`
-//! * every `"sha256": "..."` → `"sha256": "???"` so the next fetch fills it
-//!
-//! Repology asks API clients to set a descriptive User-Agent.
-
-use crate::log;
-use crate::recipe::{Recipe, RecipeSet};
-use anyhow::{Context, Result, bail};
-use serde::Deserialize;
-use std::cmp::Ordering;
-use std::fs;
-use std::path::Path;
-
-const REPOLOGY_API: &str = "https://repology.org/api/v1/project";
-
-#[derive(Debug, Deserialize)]
-struct RepologyEntry {
-    #[serde(default)]
-    version: String,
-    #[serde(default)]
-    status: String,
-}
-
-pub fn run(recipes: &RecipeSet, names: &[String], bump: bool) -> Result<()> {
-    let targets: Vec<&Recipe> = if names.is_empty() {
-        recipes.recipes.values().collect()
-    } else {
-        let mut out = Vec::with_capacity(names.len());
-        for name in names {
-            out.push(recipes.recipe_by_user_ref(name)?);
-        }
-        out
-    };
-
-    let client = reqwest::blocking::Client::builder()
-        .user_agent(concat!(
-            "distro/",
-            env!("CARGO_PKG_VERSION"),
-            " (+repology version checker)"
-        ))
-        .build()?;
-
-    let mut outdated = 0usize;
-    let mut bumped = 0usize;
-    let mut up_to_date = 0usize;
-    let mut errored = 0usize;
-
-    for recipe in targets {
-        match check_one(&client, recipe) {
-            Ok(Some(new_version)) => {
-                if bump {
-                    bump_recipe(&recipe.path, &new_version)?;
-                    log::step(
-                        "bump",
-                        &format!("{}: {} -> {}", recipe.key(), recipe.version, new_version),
-                    );
-                    bumped += 1;
-                } else {
-                    log::step(
-                        "outdated",
-                        &format!("{}: {} -> {}", recipe.key(), recipe.version, new_version),
-                    );
-                    outdated += 1;
-                }
-            }
-            Ok(None) => {
-                log::skip(
-                    "up-to-date",
-                    &format!("{} {}", recipe.key(), recipe.version),
-                );
-                up_to_date += 1;
-            }
-            Err(e) => {
-                log::info("error", &format!("{}: {e}", recipe.key()));
-                errored += 1;
-            }
-        }
-    }
-
-    if bump {
-        log::step(
-            "summary",
-            &format!("{bumped} bumped, {up_to_date} up-to-date, {errored} errored"),
-        );
-    } else {
-        log::step(
-            "summary",
-            &format!(
-                "{outdated} outdated, {up_to_date} up-to-date, {errored} errored (re-run with --bump to rewrite recipes)"
-            ),
-        );
-    }
-    Ok(())
-}
-
-fn check_one(client: &reqwest::blocking::Client, recipe: &Recipe) -> Result<Option<String>> {
-    let url = format!("{REPOLOGY_API}/{}", recipe.name);
-    let resp = client
-        .get(&url)
-        .send()
-        .with_context(|| format!("GET {url}"))?;
-    if resp.status() == reqwest::StatusCode::NOT_FOUND {
-        bail!("repology has no project named `{}`", recipe.name);
-    }
-    let entries: Vec<RepologyEntry> = serde_json::from_slice(&resp.error_for_status()?.bytes()?)
-        .context("failed to parse repology response")?;
-    let latest = entries
-        .iter()
-        .filter(|e| matches!(e.status.as_str(), "newest" | "unique"))
-        .map(|e| e.version.as_str())
-        .max_by(|a, b| natural_cmp(a, b));
-    match latest {
-        Some(v) if natural_cmp(v, &recipe.version) == Ordering::Greater => Ok(Some(v.to_owned())),
-        _ => Ok(None),
-    }
-}
-
-fn bump_recipe(path: &Path, new_version: &str) -> Result<()> {
-    let original =
-        fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
-    let mut out = String::with_capacity(original.len());
-    let mut version_replaced = false;
-    let mut revision_replaced = false;
-    for line in original.split_inclusive('\n') {
-        let trimmed = line.trim_start();
-        if !version_replaced && trimmed.starts_with("version") {
-            if let Some(replaced) = replace_string_assignment(line, "version", new_version) {
-                out.push_str(&replaced);
-                version_replaced = true;
-                continue;
-            }
-        }
-        if !revision_replaced && trimmed.starts_with("revision") {
-            if let Some(replaced) = replace_int_assignment(line, "revision", 1) {
-                out.push_str(&replaced);
-                revision_replaced = true;
-                continue;
-            }
-        }
-        out.push_str(line);
-    }
-    if !version_replaced {
-        bail!("could not find `version = \"...\"` in {}", path.display());
-    }
-    // Reset every sha256 placeholder so the next fetch re-derives it.
-    out = out.replace("\"sha256\": \"", "\x00sha256_marker\x00\"");
-    out = regex_lite_replace_sha(&out);
-    out = out.replace("\x00sha256_marker\x00\"", "\"sha256\": \"");
-    fs::write(path, out).with_context(|| format!("failed to write {}", path.display()))?;
-    Ok(())
-}
-
-/// Replace every quoted sha256 value with `"???"`, leaving keys/whitespace
-/// alone. Avoids a full regex dep by walking the string by hand.
-fn regex_lite_replace_sha(input: &str) -> String {
-    let mut out = String::with_capacity(input.len());
-    let bytes = input.as_bytes();
-    let needle = b"\x00sha256_marker\x00\"";
-    let mut i = 0;
-    while i < bytes.len() {
-        if bytes[i..].starts_with(needle) {
-            out.push_str("\x00sha256_marker\x00\"???\"");
-            i += needle.len();
-            // skip the original value up to the closing quote
-            while i < bytes.len() && bytes[i] != b'"' {
-                i += 1;
-            }
-            if i < bytes.len() {
-                i += 1; // consume the closing quote we replaced
-            }
-        } else {
-            out.push(bytes[i] as char);
-            i += 1;
-        }
-    }
-    out
-}
-
-fn replace_string_assignment(line: &str, key: &str, new_value: &str) -> Option<String> {
-    // Match `<key><space>=<space>"value"` while preserving surrounding text
-    // (indentation, trailing newline).
-    let stripped = line.strip_prefix(key)?;
-    let rest = stripped.trim_start_matches(|c: char| c == ' ' || c == '\t');
-    let after_eq = rest.strip_prefix('=')?.trim_start();
-    let after_quote = after_eq.strip_prefix('"')?;
-    let end = after_quote.find('"')?;
-    let trailing = &after_quote[end + 1..];
-    Some(format!("{key} = \"{new_value}\"{trailing}"))
-}
-
-fn replace_int_assignment(line: &str, key: &str, new_value: i32) -> Option<String> {
-    let stripped = line.strip_prefix(key)?;
-    let rest = stripped.trim_start_matches(|c: char| c == ' ' || c == '\t');
-    let after_eq = rest.strip_prefix('=')?.trim_start();
-    let end = after_eq.find(|c: char| !c.is_ascii_digit())?;
-    let trailing = &after_eq[end..];
-    Some(format!("{key} = {new_value}{trailing}"))
-}
-
-/// dpkg-ish natural comparison: split into runs of digits and non-digits and
-/// compare numerically where both sides are digits, lexicographically
-/// otherwise. Good enough for upstream tarball versions.
-fn natural_cmp(a: &str, b: &str) -> Ordering {
-    let mut ai = a.chars().peekable();
-    let mut bi = b.chars().peekable();
-    loop {
-        match (ai.peek().copied(), bi.peek().copied()) {
-            (None, None) => return Ordering::Equal,
-            (None, _) => return Ordering::Less,
-            (_, None) => return Ordering::Greater,
-            (Some(x), Some(y)) if x.is_ascii_digit() && y.is_ascii_digit() => {
-                let mut na = String::new();
-                while let Some(&c) = ai.peek() {
-                    if c.is_ascii_digit() {
-                        na.push(c);
-                        ai.next();
-                    } else {
-                        break;
-                    }
-                }
-                let mut nb = String::new();
-                while let Some(&c) = bi.peek() {
-                    if c.is_ascii_digit() {
-                        nb.push(c);
-                        bi.next();
-                    } else {
-                        break;
-                    }
-                }
-                let xa: u64 = na.parse().unwrap_or(0);
-                let xb: u64 = nb.parse().unwrap_or(0);
-                match xa.cmp(&xb) {
-                    Ordering::Equal => continue,
-                    other => return other,
-                }
-            }
-            (Some(x), Some(y)) => match x.cmp(&y) {
-                Ordering::Equal => {
-                    ai.next();
-                    bi.next();
-                }
-                other => return other,
-            },
-        }
-    }
-}