add mdbook package (#71)

HW accel codecs bypass the CPU entirely — SIMD-optimized software
paths are irrelevant. Dropping x86asm removes ffmpeg's build-time
nasm dependency. nasm stays in setup.sh for x264 and libjpeg.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -23,13 +23,15 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/cache@v4
         with:
-          key: build-cache-v1-${{ matrix.platform }}-${{ hashFiles('build.sh', 'setup.sh', '*/pyproject.toml', '*/setup.py', '*/build.sh') }}
-          restore-keys: build-cache-v1-${{ matrix.platform }}-
+          key: build-cache-v2-${{ matrix.platform }}-${{ hashFiles('build.sh', 'setup.sh', '*/pyproject.toml', '*/setup.py', '*/build.sh') }}
+          restore-keys: build-cache-v2-${{ matrix.platform }}-
           path: |
             .uv-cache
             */*/install
             */*/toolchain
             */*/bin
+            */*-src
+            */build
       - name: Build wheels
         env:
           MANYLINUX: ${{ runner.os == 'Linux' && '1' || '0' }}
@@ -90,8 +92,8 @@ jobs:
           path: dist
       - uses: actions/cache/restore@v4
         with:
-          key: build-cache-v1-${{ matrix.platform }}-${{ hashFiles('build.sh', 'setup.sh', '*/pyproject.toml', '*/setup.py', '*/build.sh') }}
-          restore-keys: build-cache-v1-${{ matrix.platform }}-
+          key: build-cache-v2-${{ matrix.platform }}-${{ hashFiles('build.sh', 'setup.sh', '*/pyproject.toml', '*/setup.py', '*/build.sh') }}
+          restore-keys: build-cache-v2-${{ matrix.platform }}-
           path: |
             .uv-cache
             */*/install

.gitignore

@@ -2,6 +2,7 @@
 repo/
 .venv/
 __pycache__/
+uv.lock
 
 # agents
 .claude/
@@ -26,3 +27,6 @@ gcc-arm-none-eabi/gcc_arm_none_eabi/toolchain/
 
 # downloaded git-lfs
 git-lfs/git_lfs/bin/
+
+# downloaded mdbook
+mdbook/mdbook/bin/

README.md

@@ -42,9 +42,9 @@ contributions welcome for other platforms!
 
 ```python
 dependencies = [
-  # use the releases branch for pre-built wheels
-  "capnproto @ git+https://github.com/commaai/dependencies.git@releases#subdirectory=capnproto",
-  "ffmpeg @ git+https://github.com/commaai/dependencies.git@releases#subdirectory=ffmpeg",
+  # use per-package release branches for pre-built wheels
+  "capnproto @ git+https://github.com/commaai/dependencies.git@release-capnproto#subdirectory=capnproto",
+  "ffmpeg @ git+https://github.com/commaai/dependencies.git@release-ffmpeg#subdirectory=ffmpeg",
 
   # use the master branch to build the package on pip install
   "capnproto @ git+https://github.com/commaai/dependencies.git@master#subdirectory=capnproto",
@@ -58,4 +58,4 @@ to add a new package:
 * start a new top-level directory as a new package
 * `./test.sh` tests the building of all packages
 *  on pushes to `master`, wheels are built for our target platforms and pushed to a GitHub release
-*  the `releases` branch contains shim packages that allow pointing to a git branch and always getting the appropriate wheel for your platform
+*  each `release-<package>` branch contains a single shim package, so old lockfiles keep resolving even as new packages are added

_shim_setup.py

@@ -1,8 +1,10 @@
 """Shim setup.py: downloads pre-built wheels from GitHub Releases at install time."""
 import os
 import platform
+import time
 import zipfile
 from io import BytesIO
+from urllib.error import URLError
 from urllib.request import urlopen
 
 try:
@@ -32,7 +34,8 @@ PLATFORM_MAP = {
 
 class InstallPrebuilt(build_py):
   def run(self):
-    data_dir = os.path.join(_HERE, MODULE, DATADIR)
+    module_dir = os.path.join(_HERE, MODULE)
+    data_dir = os.path.join(module_dir, DATADIR)
 
     if not os.path.exists(os.path.join(data_dir, "bin")):
       key = (platform.system(), platform.machine())
@@ -44,7 +47,16 @@ class InstallPrebuilt(build_py):
       url = f"{REPO_URL}/releases/download/{TAG}/{whl_name}"
 
       print(f"Downloading {url} ...")
-      raw = urlopen(url).read()
+      for attempt in range(3):
+        try:
+          raw = urlopen(url, timeout=60).read()
+          break
+        except (URLError, OSError) as e:
+          if attempt == 2:
+            raise
+          wait = 2 ** attempt
+          print(f"Download failed ({e}), retrying in {wait}s ...")
+          time.sleep(wait)
 
       print(f"Extracting {DATADIR} ...")
       with zipfile.ZipFile(BytesIO(raw)) as zf:
@@ -67,6 +79,24 @@ class InstallPrebuilt(build_py):
                   os.chmod(dest, 0o755)
               break
 
+        # Also extract compiled extension modules (.so)
+        ext_prefix = f"{MODULE}/"
+        ext_alt_prefix = f"{MODULE}-{VERSION}.data/purelib/{MODULE}/"
+        for info in zf.infolist():
+          if not info.filename.endswith('.so'):
+            continue
+          for p in (ext_prefix, ext_alt_prefix):
+            if info.filename.startswith(p):
+              rel = info.filename[len(p):]
+              if rel and '/' not in rel:
+                dest = os.path.join(module_dir, rel)
+                os.makedirs(os.path.dirname(dest), exist_ok=True)
+                with open(dest, "wb") as f:
+                  f.write(zf.read(info))
+                if info.external_attr >> 16 & 0o111:
+                  os.chmod(dest, 0o755)
+              break
+
     super().run()
 
 

build.sh

@@ -34,6 +34,9 @@ fi
 if [[ -n "${BUILD_SH_IN_MANYLINUX:-}" ]]; then
   export PATH="/opt/python/cp312-cp312/bin:$PATH"
 
+  # cached *-src repos may be owned by the host runner user; tell git to trust them
+  git config --global --add safe.directory '*'
+
   ./setup.sh
 
   if [[ -z "${BUILD_SH_REUSE_MANYLINUX_ARTIFACTS:-}" ]]; then
@@ -45,10 +48,15 @@ if [[ -n "${BUILD_SH_IN_MANYLINUX:-}" ]]; then
   fi
 fi
 
+export CMAKE_C_COMPILER_LAUNCHER=ccache
+export CMAKE_CXX_COMPILER_LAUNCHER=ccache
+
 echo "Building workspace packages into dist"
 START_SECS=$SECONDS
 
-uv build --all-packages --wheel --out-dir dist --no-create-gitignore --no-build-logs
+mkdir -p dist/
+rm -rf dist/*
+uv build --all-packages --wheel --out-dir dist --no-create-gitignore
 
 if [[ -n "${BUILD_SH_IN_MANYLINUX:-}" ]]; then
   VENV_DIR="$ROOT_DIR/.venv-manylinux"

bzip2/build.sh

@@ -4,24 +4,19 @@ set -e
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
 cd "$DIR"
 
-VERSION="1.0.8"
+VERSION="bzip2-1.0.8"
 INSTALL_DIR="$DIR/bzip2/install"
 
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libbz2.a" ]; then
-  echo "bzip2 already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+CC="ccache ${CC:-cc}"
 
-# Download
-if [ ! -d "bzip2-src" ]; then
-  curl -L "https://sourceware.org/pub/bzip2/bzip2-${VERSION}.tar.gz" -o bzip2.tar.gz
-  mkdir -p bzip2-src
-  tar xzf bzip2.tar.gz -C bzip2-src --strip-components=1
-  rm bzip2.tar.gz
+# Clone/update source
+if [ ! -d "bzip2-src/.git" ]; then
+  rm -rf bzip2-src
+  git clone --depth 1 https://gitlab.com/bzip2/bzip2.git bzip2-src
 fi
+git -C bzip2-src fetch --depth 1 origin "$VERSION"
+git -C bzip2-src checkout --force FETCH_HEAD
 
 # Build static library with -fPIC
 cd bzip2-src
@@ -38,8 +33,5 @@ cp bzip2-src/libbz2.a "$INSTALL_DIR/lib/"
 # Headers
 cp bzip2-src/bzlib.h "$INSTALL_DIR/include/"
 
-# Clean up
-rm -rf bzip2-src
-
 echo "Installed bzip2 to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

bzip2/setup.py

@@ -15,11 +15,8 @@ class BuildBzip2(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "bzip2", "install", "lib", "libbz2.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

capnproto/build.sh

@@ -7,18 +7,15 @@ cd "$DIR"
 VERSION="1.0.1"
 INSTALL_DIR="$DIR/capnproto/install"
 
-# Idempotent: skip if already built
-if [ -x "$INSTALL_DIR/bin/capnp" ]; then
-  echo "capnproto already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
 
-# Clone
-if [ ! -d "capnproto-src" ]; then
-  git clone --depth 1 --branch "v${VERSION}" https://github.com/capnproto/capnproto.git capnproto-src
+# Clone/update source
+if [ ! -d "capnproto-src/.git" ]; then
+  rm -rf capnproto-src
+  git clone --depth 1 https://github.com/capnproto/capnproto.git capnproto-src
 fi
+git -C capnproto-src fetch --depth 1 origin "v${VERSION}"
+git -C capnproto-src checkout --force FETCH_HEAD
 
 # Build
 PREFIX="$DIR/build/prefix"
@@ -64,8 +61,5 @@ for obj in filesystem.c++.o main.c++.o test-helpers.c++.o; do
   ar d "$INSTALL_DIR/lib/libkj.a" "$obj" 2>/dev/null || true
 done
 
-# Clean up
-rm -rf capnproto-src "$DIR/build"
-
 echo "Installed capnproto to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

capnproto/setup.py

@@ -15,11 +15,8 @@ class BuildCapnproto(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "capnproto", "install", "bin", "capnp")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

cppcheck/build.sh

@@ -7,18 +7,16 @@ cd "$DIR"
 VERSION="2.16.0"
 INSTALL_DIR="$DIR/cppcheck/install"
 
-# Idempotent: skip if already built
-if [ -x "$INSTALL_DIR/cppcheck" ]; then
-  echo "cppcheck already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+CXX="ccache ${CXX:-c++}"
 
-# Clone
-if [ ! -d "cppcheck-src" ]; then
-  git clone --depth 1 --branch "$VERSION" https://github.com/danmar/cppcheck.git cppcheck-src
+# Clone/update source
+if [ ! -d "cppcheck-src/.git" ]; then
+  rm -rf cppcheck-src
+  git clone --depth 1 https://github.com/danmar/cppcheck.git cppcheck-src
 fi
+git -C cppcheck-src fetch --depth 1 origin "$VERSION"
+git -C cppcheck-src checkout --force FETCH_HEAD
 
 # Build
 cd cppcheck-src
@@ -35,8 +33,5 @@ cp -r cppcheck-src/cfg "$INSTALL_DIR/"
 cp -r cppcheck-src/platforms "$INSTALL_DIR/"
 strip "$INSTALL_DIR/cppcheck" 2>/dev/null || true
 
-# Clean up
-rm -rf cppcheck-src
-
 echo "Installed cppcheck to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

cppcheck/setup.py

@@ -15,11 +15,8 @@ class BuildCppcheck(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "cppcheck", "install", "cppcheck")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

eigen/build.sh

@@ -7,28 +7,19 @@ cd "$DIR"
 VERSION="3.4.0"
 INSTALL_DIR="$DIR/eigen/install"
 
-# Idempotent: skip if already present
-if [ -d "$INSTALL_DIR/eigen3/Eigen" ]; then
-  echo "eigen already present, skipping download."
-  exit 0
+# Clone/update source
+if [ ! -d "eigen-src/.git" ]; then
+  rm -rf eigen-src
+  git clone --depth 1 https://gitlab.com/libeigen/eigen.git eigen-src
 fi
+git -C eigen-src fetch --depth 1 origin "$VERSION"
+git -C eigen-src checkout --force FETCH_HEAD
 
-TARBALL="eigen-${VERSION}.tar.gz"
-URL="https://gitlab.com/libeigen/eigen/-/archive/${VERSION}/${TARBALL}"
-
-echo "Downloading Eigen ${VERSION} ..."
-curl -fSL -o "$TARBALL" "$URL"
-
-echo "Extracting headers ..."
+# Copy headers
 rm -rf "$INSTALL_DIR"
 mkdir -p "$INSTALL_DIR/eigen3"
-
-# Extract only the Eigen/ and unsupported/Eigen/ header directories
-tar --strip-components=1 -xzf "$TARBALL" -C "$INSTALL_DIR/eigen3" \
-  "eigen-${VERSION}/Eigen" \
-  "eigen-${VERSION}/unsupported"
-
-rm -f "$TARBALL"
+cp -r eigen-src/Eigen "$INSTALL_DIR/eigen3/"
+cp -r eigen-src/unsupported "$INSTALL_DIR/eigen3/"
 
 echo "Installed eigen to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

eigen/setup.py

@@ -15,11 +15,8 @@ class BuildEigen(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "eigen", "install", "eigen3", "Eigen")
-
-    if not os.path.isdir(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

ffmpeg/build.sh

@@ -4,24 +4,26 @@ set -e
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
 cd "$DIR"
 
+PLATFORM="$(uname -s)"
 FFMPEG_VERSION="7.1"
+ZLIB_VERSION="da607da739fa6047df13e66a2af6b8bec7c2a498"  # v1.3.2
+X264_BRANCH="stable"
+LIBDRM_VERSION="libdrm-2.4.124"
+LIBVA_VERSION="2.22.0"
 INSTALL_DIR="$DIR/ffmpeg/install"
 
-# Idempotent: skip if already built
-if [ -x "$INSTALL_DIR/bin/ffmpeg" ]; then
-  echo "ffmpeg already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+CC="ccache ${CC:-cc}"
 PREFIX="$DIR/build/prefix"
 mkdir -p "$DIR/build"
 
 # --- Build zlib (static) ---
-if [ ! -d "zlib-src" ]; then
-  git clone https://github.com/madler/zlib.git zlib-src
-  git -C zlib-src checkout da607da739fa6047df13e66a2af6b8bec7c2a498  # pin to v1.3.2
+if [ ! -d "zlib-src/.git" ]; then
+  rm -rf zlib-src
+  git clone --depth 1 https://github.com/madler/zlib.git zlib-src
 fi
+git -C zlib-src fetch --depth 1 origin "$ZLIB_VERSION"
+git -C zlib-src checkout --force "$ZLIB_VERSION"
 
 cd zlib-src
 ./configure --prefix="$PREFIX" --static
@@ -30,9 +32,12 @@ make install
 cd "$DIR"
 
 # --- Build x264 (static) ---
-if [ ! -d "x264-src" ]; then
-  git clone --depth 1 --branch stable https://code.videolan.org/videolan/x264.git x264-src
+if [ ! -d "x264-src/.git" ]; then
+  rm -rf x264-src
+  git clone --depth 1 https://code.videolan.org/videolan/x264.git x264-src
 fi
+git -C x264-src fetch --depth 1 origin "$X264_BRANCH"
+git -C x264-src checkout --force FETCH_HEAD
 
 cd x264-src
 CFLAGS="-fno-finite-math-only" ./configure \
@@ -46,14 +51,104 @@ make -j"$NJOBS"
 make install
 cd "$DIR"
 
-# --- Build FFmpeg ---
-if [ ! -d "ffmpeg-src" ]; then
-  git clone --depth 1 --branch "n${FFMPEG_VERSION}" https://github.com/FFmpeg/FFmpeg.git ffmpeg-src
+# --- Build nv-codec-headers (Linux only, for CUDA/NVDEC) ---
+if [ "$PLATFORM" = "Linux" ]; then
+  if [ ! -d "nv-codec-headers-src/.git" ]; then
+    rm -rf nv-codec-headers-src
+    git clone --depth 1 https://git.videolan.org/git/ffmpeg/nv-codec-headers.git nv-codec-headers-src
+  fi
+  make -C nv-codec-headers-src PREFIX="$PREFIX" install
 fi
 
+# --- Build Vulkan-Headers from source (Linux only, need >= 1.3.277 for FFmpeg 7.1) ---
+if [ "$PLATFORM" = "Linux" ]; then
+  if [ ! -d "vulkan-headers-src/.git" ]; then
+    rm -rf vulkan-headers-src
+    git clone --depth 1 https://github.com/KhronosGroup/Vulkan-Headers.git vulkan-headers-src
+  fi
+  cmake -S vulkan-headers-src -B vulkan-headers-src/build -DCMAKE_INSTALL_PREFIX="$PREFIX" >/dev/null
+  cmake --install vulkan-headers-src/build >/dev/null
+fi
+
+# --- Build libdrm + libva statically (Linux only, for VAAPI without runtime deps) ---
+if [ "$PLATFORM" = "Linux" ]; then
+  if ! command -v meson &>/dev/null; then
+    pip3 install --quiet meson ninja 2>/dev/null || python3 -m pip install --quiet meson ninja 2>/dev/null || true
+    command -v meson &>/dev/null || { echo "error: meson is required (apt install meson or pip install meson)" >&2; exit 1; }
+  fi
+
+  if [ ! -d "libdrm-src/.git" ]; then
+    rm -rf libdrm-src
+    git clone --depth 1 --branch "$LIBDRM_VERSION" https://gitlab.freedesktop.org/mesa/drm.git libdrm-src
+  fi
+  rm -rf libdrm-src/builddir
+  meson setup libdrm-src/builddir libdrm-src \
+    --prefix="$PREFIX" --libdir=lib --default-library=static \
+    -Dintel=disabled -Dradeon=disabled -Damdgpu=disabled -Dnouveau=disabled \
+    -Dvmwgfx=disabled -Dtests=false -Dman-pages=disabled -Dcairo-tests=disabled \
+    -Dvalgrind=disabled
+  ninja -C libdrm-src/builddir install
+
+  if [ ! -d "libva-src/.git" ]; then
+    rm -rf libva-src
+    git clone --depth 1 --branch "$LIBVA_VERSION" https://github.com/intel/libva.git libva-src
+  fi
+  rm -rf libva-src/builddir
+  # libva hardcodes shared_library(); patch to library() so --default-library=static works
+  sed -i 's/shared_library(/library(/g' libva-src/va/meson.build
+  PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" \
+  meson setup libva-src/builddir libva-src \
+    --prefix="$PREFIX" --libdir=lib --default-library=static \
+    -Ddisable_drm=false -Dwith_x11=no -Dwith_glx=no -Dwith_wayland=no \
+    -Dwith_win32=no -Denable_docs=false
+  ninja -C libva-src/builddir install
+fi
+
+# --- Build FFmpeg ---
+if [ ! -d "ffmpeg-src/.git" ]; then
+  rm -rf ffmpeg-src
+  git clone --depth 1 https://github.com/FFmpeg/FFmpeg.git ffmpeg-src
+fi
+git -C ffmpeg-src fetch --depth 1 origin "n${FFMPEG_VERSION}"
+git -C ffmpeg-src checkout --force FETCH_HEAD
+
 cd ffmpeg-src
+
+# Platform-specific hardware acceleration flags
+HW_FLAGS=()
+if [ "$PLATFORM" = "Linux" ]; then
+  HW_FLAGS+=(
+    # NVIDIA CUDA/NVDEC (uses dlopen at runtime)
+    --enable-ffnvcodec --enable-cuda --enable-cuvid --enable-nvdec
+    --enable-hwaccel=h264_nvdec,hevc_nvdec
+    --enable-decoder=h264_cuvid,hevc_cuvid
+
+    # VAAPI (Intel/AMD — libva linked statically, driver loaded via dlopen at runtime)
+    --enable-vaapi
+    --enable-hwaccel=h264_vaapi,hevc_vaapi
+
+    # V4L2 Memory-to-Memory (embedded: RPi, Qualcomm, Rockchip)
+    --enable-v4l2-m2m
+    --enable-decoder=h264_v4l2m2m,hevc_v4l2m2m
+    --enable-encoder=h264_v4l2m2m,hevc_v4l2m2m
+
+    # Vulkan video decode/encode (uses dlopen at runtime)
+    --enable-vulkan
+    --enable-hwaccel=h264_vulkan,hevc_vulkan
+    --enable-encoder=h264_vulkan,hevc_vulkan
+  )
+elif [ "$PLATFORM" = "Darwin" ]; then
+  HW_FLAGS+=(
+    # VideoToolbox (Apple Silicon / macOS)
+    --enable-videotoolbox
+    --enable-hwaccel=h264_videotoolbox,hevc_videotoolbox
+    --enable-encoder=h264_videotoolbox,hevc_videotoolbox
+  )
+fi
+
 PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" \
 ./configure \
+  --cc="${CC:-cc}" \
   --prefix="$PREFIX" \
   --enable-gpl \
   --enable-static \
@@ -64,6 +159,7 @@ PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" \
   --disable-doc \
   --disable-ffplay \
   --disable-autodetect \
+  --disable-x86asm \
   --disable-everything \
   --enable-encoder=libx264,aac,ffvhuff,rawvideo,png,mjpeg \
   --enable-decoder=h264,hevc,ffvhuff,aac,rawvideo,png,mjpeg,mp3,pcm_s16le \
@@ -74,7 +170,8 @@ PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}" \
   --enable-filter=blend,vflip,format,scale,aformat,anull,aresample,null \
   --enable-bsf=extract_extradata,h264_mp4toannexb,hevc_mp4toannexb \
   --extra-cflags="-I$PREFIX/include" \
-  --extra-ldflags="-L$PREFIX/lib"
+  --extra-ldflags="-L$PREFIX/lib" \
+  "${HW_FLAGS[@]}"
 make -j"$NJOBS"
 make install
 cd "$DIR"
@@ -88,7 +185,11 @@ cp "$PREFIX/bin/ffmpeg" "$INSTALL_DIR/bin/"
 cp "$PREFIX/bin/ffprobe" "$INSTALL_DIR/bin/"
 
 # Libraries
-for lib in libavformat.a libavcodec.a libavutil.a libswresample.a libx264.a libz.a; do
+LIBS="libavformat.a libavcodec.a libavutil.a libswresample.a libx264.a libz.a"
+if [ "$PLATFORM" = "Linux" ]; then
+  LIBS="$LIBS libva.a libva-drm.a libdrm.a"
+fi
+for lib in $LIBS; do
   cp "$PREFIX/lib/$lib" "$INSTALL_DIR/lib/"
 done
 
@@ -100,8 +201,5 @@ done
 # Strip binaries
 strip "$INSTALL_DIR/bin/ffmpeg" "$INSTALL_DIR/bin/ffprobe" 2>/dev/null || true
 
-# Clean up
-rm -rf zlib-src x264-src ffmpeg-src "$DIR/build"
-
 echo "Installed ffmpeg to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

ffmpeg/setup.py

@@ -15,11 +15,8 @@ class BuildFFmpeg(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "ffmpeg", "install", "bin", "ffmpeg")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

gcc-arm-none-eabi/build.sh

@@ -9,10 +9,11 @@ TOOLCHAIN_BASE="arm-gnu-toolchain-${TOOLCHAIN_VERSION}"
 GCC_VERSION="13.2.1"
 
 INSTALL_DIR="$DIR/gcc_arm_none_eabi/toolchain"
+VERSION_FILE="$INSTALL_DIR/.version"
 
-# Idempotent: skip if already built
-if [ -x "$INSTALL_DIR/bin/arm-none-eabi-gcc" ]; then
-  echo "Toolchain already present, skipping download."
+# Skip if already at correct version
+if [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$TOOLCHAIN_VERSION" ]; then
+  echo "Toolchain $TOOLCHAIN_VERSION already present, skipping."
   exit 0
 fi
 
@@ -112,6 +113,7 @@ find "$INSTALL_DIR" -type f \( -executable -o -name '*.so' \) -exec strip {} + 2
 # --- clean up download artifacts ---
 rm -rf "$EXTRACT_DIR"
 rm -f "$TARBALL"
+echo "$TOOLCHAIN_VERSION" > "$VERSION_FILE"
 
 echo "Installed to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

gcc-arm-none-eabi/setup.py

@@ -1,10 +1,8 @@
 import os
 import platform
 import subprocess
-import sys
 
 from setuptools.command.build_py import build_py
-from setuptools.dist import Distribution
 
 try:
   from wheel.bdist_wheel import bdist_wheel
@@ -17,13 +15,8 @@ class BuildToolchain(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    toolchain_marker = os.path.join(
-      pkg_dir, "gcc_arm_none_eabi", "toolchain", "bin", "arm-none-eabi-gcc"
-    )
-
-    if not os.path.exists(toolchain_marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

git-lfs/build.sh

@@ -6,10 +6,11 @@ cd "$DIR"
 
 VERSION="3.6.1"
 INSTALL_DIR="$DIR/git_lfs/bin"
+VERSION_FILE="$INSTALL_DIR/.version"
 
-# Idempotent: skip if already present
-if [ -x "$INSTALL_DIR/git-lfs" ]; then
-  echo "git-lfs already present, skipping download."
+# Skip if already at correct version
+if [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$VERSION" ]; then
+  echo "git-lfs $VERSION already present, skipping."
   exit 0
 fi
 
@@ -51,6 +52,7 @@ fi
 chmod +x "$INSTALL_DIR/git-lfs"
 
 rm -f "$FILENAME"
+echo "$VERSION" > "$VERSION_FILE"
 
 echo "Installed git-lfs to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

git-lfs/setup.py

@@ -15,11 +15,8 @@ class BuildGitLfs(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "git_lfs", "bin", "git-lfs")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

git/build.sh

@@ -0,0 +1,189 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
+cd "$DIR"
+
+VERSION="2.47.1"
+OPENSSL_VERSION="openssl-3.4.1"
+CURL_VERSION="curl-8_12_1"
+ZLIB_VERSION="v1.3.1"
+INSTALL_DIR="$DIR/git/install"
+VERSION_FILE="$INSTALL_DIR/.version"
+
+# Skip if already at correct version
+if [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$VERSION" ]; then
+  echo "git $VERSION already present, skipping."
+  exit 0
+fi
+
+PLATFORM="$(uname -s)"
+NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+PREFIX="$DIR/build/prefix"
+mkdir -p "$DIR/build"
+
+# --- Build zlib (static) ---
+if [ ! -d "zlib-src/.git" ]; then
+  rm -rf zlib-src
+  git clone --depth 1 https://github.com/madler/zlib.git zlib-src
+fi
+git -C zlib-src fetch --depth 1 origin "$ZLIB_VERSION"
+git -C zlib-src checkout --force FETCH_HEAD
+
+cd zlib-src
+./configure --prefix="$PREFIX" --static
+make -j"$NJOBS"
+make install
+cd "$DIR"
+
+# --- Build OpenSSL (static) ---
+if [ ! -d "openssl-src/.git" ]; then
+  rm -rf openssl-src
+  git clone --depth 1 https://github.com/openssl/openssl.git openssl-src
+fi
+git -C openssl-src fetch --depth 1 origin "$OPENSSL_VERSION"
+git -C openssl-src checkout --force FETCH_HEAD
+
+cd openssl-src
+./Configure \
+  --prefix="$PREFIX" \
+  --libdir=lib \
+  no-shared \
+  no-tests \
+  no-docs
+make -j"$NJOBS"
+make install_sw
+cd "$DIR"
+
+# --- Build curl (static, with openssl+zlib) ---
+if [ ! -d "curl-src/.git" ]; then
+  rm -rf curl-src
+  git clone --depth 1 https://github.com/curl/curl.git curl-src
+fi
+git -C curl-src fetch --depth 1 origin "$CURL_VERSION"
+git -C curl-src checkout --force FETCH_HEAD
+
+cd curl-src
+autoreconf -fi
+PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig" \
+./configure \
+  --prefix="$PREFIX" \
+  --with-openssl="$PREFIX" \
+  --with-zlib="$PREFIX" \
+  --disable-shared \
+  --enable-static \
+  --disable-ldap \
+  --disable-rtsp \
+  --disable-dict \
+  --disable-telnet \
+  --disable-tftp \
+  --disable-pop3 \
+  --disable-imap \
+  --disable-smb \
+  --disable-smtp \
+  --disable-gopher \
+  --disable-mqtt \
+  --disable-manual \
+  --disable-docs \
+  --without-libpsl \
+  --without-brotli \
+  --without-zstd \
+  --without-libidn2 \
+  --without-nghttp2 \
+  --without-librtmp
+make -j"$NJOBS"
+make install
+cd "$DIR"
+
+# --- Build git (with static curl+openssl+zlib) ---
+if [ ! -d "git-src/.git" ]; then
+  rm -rf git-src
+  git clone --depth 1 https://github.com/git/git.git git-src
+fi
+git -C git-src fetch --depth 1 origin "v${VERSION}"
+git -C git-src checkout --force FETCH_HEAD
+
+# Gather static link flags for curl and openssl dependencies
+# CURL_LIBCURL: used by git-remote-http, git-http-fetch, git-http-push
+# LIB_4_CRYPTO: used by git-imap-send and other direct openssl consumers
+# Both need transitive deps (-ldl, -lpthread) since we link statically
+CRYPTO_DEPS="-lpthread"
+CURL_EXTRA=""
+if [ "$PLATFORM" = "Linux" ]; then
+  CRYPTO_DEPS="$CRYPTO_DEPS -ldl"
+elif [ "$PLATFORM" = "Darwin" ]; then
+  CURL_EXTRA="-framework SystemConfiguration -framework Security -framework CoreFoundation"
+fi
+
+cd git-src
+make prefix="$PREFIX" \
+  RUNTIME_PREFIX=YesPlease \
+  NO_GETTEXT=YesPlease \
+  NO_TCLTK=YesPlease \
+  NO_PERL=YesPlease \
+  NO_PYTHON=YesPlease \
+  NO_EXPAT=YesPlease \
+  INSTALL_SYMLINKS=1 \
+  CURLDIR="$PREFIX" \
+  CURL_LIBCURL="-L$PREFIX/lib -lcurl -lssl -lcrypto -lz $CRYPTO_DEPS $CURL_EXTRA" \
+  OPENSSL_LIBSSL="-L$PREFIX/lib -lssl" \
+  LIB_4_CRYPTO="-lcrypto $CRYPTO_DEPS" \
+  ZLIB_PATH="$PREFIX" \
+  -j"$NJOBS" \
+  all
+make prefix="$PREFIX" \
+  RUNTIME_PREFIX=YesPlease \
+  NO_GETTEXT=YesPlease \
+  NO_TCLTK=YesPlease \
+  NO_PERL=YesPlease \
+  NO_PYTHON=YesPlease \
+  NO_EXPAT=YesPlease \
+  INSTALL_SYMLINKS=1 \
+  CURLDIR="$PREFIX" \
+  CURL_LIBCURL="-L$PREFIX/lib -lcurl -lssl -lcrypto -lz $CRYPTO_DEPS $CURL_EXTRA" \
+  OPENSSL_LIBSSL="-L$PREFIX/lib -lssl" \
+  LIB_4_CRYPTO="-lcrypto $CRYPTO_DEPS" \
+  ZLIB_PATH="$PREFIX" \
+  install
+cd "$DIR"
+
+# Assemble the package install directory
+# Only copy real files from libexec to avoid bloating the wheel with
+# copies of the main git binary (builtin commands are symlinks to git)
+rm -rf "$INSTALL_DIR"
+mkdir -p "$INSTALL_DIR/bin" "$INSTALL_DIR/libexec/git-core"
+
+# Main binary
+cp "$PREFIX/bin/git" "$INSTALL_DIR/bin/"
+
+# libexec/git-core: copy real files, resolve non-git symlinks, skip git symlinks
+cd "$PREFIX/libexec/git-core"
+for f in *; do
+  if [ -L "$f" ]; then
+    target="$(readlink "$f")"
+    # Skip symlinks to the main git binary (these are builtins)
+    case "$target" in
+      git|../../bin/git) continue ;;
+    esac
+    # Resolve other symlinks (e.g., git-remote-https -> git-remote-http)
+    cp -L "$f" "$INSTALL_DIR/libexec/git-core/$f"
+  elif [ -f "$f" ]; then
+    cp "$f" "$INSTALL_DIR/libexec/git-core/$f"
+  fi
+done
+cd "$DIR"
+
+# Copy git binary into libexec for builtin resolution
+cp "$PREFIX/bin/git" "$INSTALL_DIR/libexec/git-core/git"
+
+# Templates
+cp -r "$PREFIX/share" "$INSTALL_DIR/"
+
+# Strip binaries
+strip "$INSTALL_DIR/bin/git" "$INSTALL_DIR/libexec/git-core/git" 2>/dev/null || true
+find "$INSTALL_DIR/libexec/git-core" -maxdepth 1 -type f -perm /111 ! -name "*.sh" -exec strip {} \; 2>/dev/null || true
+
+echo "$VERSION" > "$VERSION_FILE"
+
+echo "Installed git to $INSTALL_DIR"
+du -sh "$INSTALL_DIR"

git/git/__init__.py

@@ -0,0 +1,17 @@
+import os
+import sys
+
+DIR = os.path.join(os.path.dirname(__file__), "install")
+BIN_DIR = os.path.join(DIR, "bin")
+
+
+def _run():
+  binary = os.path.join(BIN_DIR, "git")
+  os.execvp(binary, [binary] + sys.argv[1:])
+
+
+def smoketest():
+  import subprocess
+  binary = os.path.join(BIN_DIR, "git")
+  subprocess.run([binary, "--version"], check=True)
+  subprocess.run([binary, "ls-remote", "https://github.com/commaai/openpilot.git", "HEAD"], check=True)

git/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "git"
+version = "2.47.1"
+description = "Git distributed version control system"
+requires-python = ">=3.8"
+
+[project.scripts]
+git = "git:_run"
+
+[tool.setuptools.packages.find]
+include = ["git*"]
+
+[tool.setuptools.package-data]
+git = ["install/**/*"]

git/setup.py

@@ -0,0 +1,58 @@
+import os
+import platform
+import subprocess
+
+from setuptools.command.build_py import build_py
+
+try:
+  from wheel.bdist_wheel import bdist_wheel
+except ImportError:
+  bdist_wheel = None
+
+
+class BuildGit(build_py):
+  """Run build.sh to build git before collecting package data."""
+
+  def run(self):
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+
+    super().run()
+
+
+cmdclass = {"build_py": BuildGit}
+
+if bdist_wheel is not None:
+
+  class PlatformWheel(bdist_wheel):
+    """Produce a platform-specific, Python-version-agnostic wheel."""
+
+    def finalize_options(self):
+      super().finalize_options()
+      self.root_is_pure = False
+
+    def get_tag(self):
+      system = platform.system()
+      machine = platform.machine()
+
+      if system == "Linux":
+        plat = f"linux_{machine}"
+      elif system == "Darwin":
+        plat = "macosx_11_0_arm64"
+      else:
+        plat = f"{system.lower()}_{machine}"
+
+      return "py3", "none", plat
+
+  cmdclass["bdist_wheel"] = PlatformWheel
+
+
+def setup():
+  from setuptools import setup as _setup
+
+  _setup(cmdclass=cmdclass)
+
+
+if __name__ == "__main__":
+  setup()

imgui/build.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
+cd "$DIR"
+
+INSTALL_DIR="$DIR/imgui/install"
+NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+
+# Dear ImGui (docking branch, version 1.92.7)
+IMGUI_COMMIT="934c6a5f5ef2355d6df25395d555cb71f790c4e9"
+# ImPlot
+IMPLOT_COMMIT="93c801b4bb801c5c11031d880b6af1d1f70bd79d"
+
+# GLFW 3.4
+GLFW_COMMIT="7b6aead9fb88b3623e3b3725ebb42670cbe4c579"
+
+# Clone/update imgui
+if [ ! -d "imgui-src/.git" ]; then
+  rm -rf imgui-src
+  git clone --depth 1 https://github.com/ocornut/imgui.git imgui-src
+fi
+git -C imgui-src fetch --depth 1 origin "$IMGUI_COMMIT"
+git -C imgui-src checkout --force "$IMGUI_COMMIT"
+
+# Clone/update implot
+if [ ! -d "implot-src/.git" ]; then
+  rm -rf implot-src
+  git clone --depth 1 https://github.com/epezent/implot.git implot-src
+fi
+git -C implot-src fetch --depth 1 origin "$IMPLOT_COMMIT"
+git -C implot-src checkout --force "$IMPLOT_COMMIT"
+
+# Clone/update GLFW
+if [ ! -d "glfw-src/.git" ]; then
+  rm -rf glfw-src
+  git clone --depth 1 https://github.com/glfw/glfw.git glfw-src
+fi
+git -C glfw-src fetch --depth 1 origin "$GLFW_COMMIT"
+git -C glfw-src checkout --force "$GLFW_COMMIT"
+
+# Install GLFW build dependencies
+if [[ "$(uname)" == "Linux" ]]; then
+  if command -v dnf &>/dev/null; then
+    dnf install -y libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel libXi-devel mesa-libGL-devel \
+                   wayland-devel wayland-protocols-devel libxkbcommon-devel
+  elif command -v apt-get &>/dev/null; then
+    if [ "$(id -u)" -eq 0 ]; then
+      apt-get update && apt-get install -y libxcursor-dev libxi-dev libxinerama-dev libxrandr-dev libgl-dev \
+                                           libwayland-dev wayland-protocols libxkbcommon-dev
+    else
+      sudo apt-get update && sudo apt-get install -y libxcursor-dev libxi-dev libxinerama-dev libxrandr-dev libgl-dev \
+                                                     libwayland-dev wayland-protocols libxkbcommon-dev
+    fi
+  fi
+fi
+
+# Build GLFW static library
+cmake -B glfw-src/build -S glfw-src \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DBUILD_SHARED_LIBS=OFF \
+  -DGLFW_BUILD_EXAMPLES=OFF \
+  -DGLFW_BUILD_TESTS=OFF \
+  -DGLFW_BUILD_DOCS=OFF
+cmake --build glfw-src/build --parallel "$NJOBS"
+
+# Install headers
+rm -rf "$INSTALL_DIR"
+mkdir -p "$INSTALL_DIR/include" "$INSTALL_DIR/lib"
+
+# imgui headers
+cp imgui-src/imgui.h imgui-src/imgui_internal.h imgui-src/imconfig.h \
+   imgui-src/imstb_rectpack.h imgui-src/imstb_textedit.h imgui-src/imstb_truetype.h \
+   "$INSTALL_DIR/include/"
+cp imgui-src/backends/imgui_impl_opengl3.h imgui-src/backends/imgui_impl_opengl3_loader.h \
+   imgui-src/backends/imgui_impl_glfw.h \
+   "$INSTALL_DIR/include/"
+
+# implot headers
+cp implot-src/implot.h implot-src/implot_internal.h "$INSTALL_DIR/include/"
+
+# glfw
+cp glfw-src/build/src/libglfw3.a "$INSTALL_DIR/lib/"
+cp -r glfw-src/include/GLFW "$INSTALL_DIR/include/"
+
+# Build libimgui.a (imgui core + backends + implot)
+IMGUI_SRCS=(
+  imgui-src/imgui.cpp
+  imgui-src/imgui_draw.cpp
+  imgui-src/imgui_tables.cpp
+  imgui-src/imgui_widgets.cpp
+  imgui-src/imgui_demo.cpp
+  imgui-src/backends/imgui_impl_opengl3.cpp
+  imgui-src/backends/imgui_impl_glfw.cpp
+  implot-src/implot.cpp
+  implot-src/implot_items.cpp
+)
+OBJ_DIR="$(mktemp -d)"
+for src in "${IMGUI_SRCS[@]}"; do
+  obj="$OBJ_DIR/$(basename "${src%.cpp}.o")"
+  c++ -c -O2 -fPIC -I"$INSTALL_DIR/include" "$src" -o "$obj" &
+done
+wait
+ar rcs "$INSTALL_DIR/lib/libimgui.a" "$OBJ_DIR"/*.o
+rm -rf "$OBJ_DIR"
+
+# Bundle GLVND dispatchers so Linux users don't need system libGL
+if [[ "$(uname)" == "Linux" ]]; then
+  MESA_DIR="$INSTALL_DIR/lib/mesa"
+  mkdir -p "$MESA_DIR"
+  ldconfig 2>/dev/null || true
+  for lib in libGL.so.1 libGLX.so.0 libEGL.so.1 libOpenGL.so.0 libGLdispatch.so.0; do
+    src="$(ldconfig -p 2>/dev/null | grep -F "$lib" | awk '{print $NF}' | head -1)"
+    if [ -n "$src" ] && [ -f "$src" ]; then
+      cp -L "$src" "$MESA_DIR/"
+      # Create unversioned symlink for the linker
+      base="${lib%%.so.*}"
+      ln -sf "$lib" "$MESA_DIR/${base}.so"
+    fi
+  done
+fi
+
+echo "Installed imgui to $INSTALL_DIR"
+du -sh "$INSTALL_DIR"

imgui/imgui/__init__.py

@@ -0,0 +1,16 @@
+import os
+import platform as _platform
+
+DIR = os.path.join(os.path.dirname(__file__), "install")
+INCLUDE_DIR = os.path.join(DIR, "include")
+LIB_DIR = os.path.join(DIR, "lib")
+MESA_DIR = os.path.join(DIR, "lib", "mesa")
+
+
+def smoketest():
+  assert os.path.isfile(os.path.join(INCLUDE_DIR, "imgui.h")), "imgui.h not found"
+  assert os.path.isfile(os.path.join(LIB_DIR, "libimgui.a")), "libimgui.a not found"
+  assert os.path.isfile(os.path.join(LIB_DIR, "libglfw3.a")), "libglfw3.a not found"
+  assert os.path.isfile(os.path.join(INCLUDE_DIR, "GLFW", "glfw3.h")), "GLFW/glfw3.h not found"
+  if _platform.system() == "Linux":
+    assert os.path.isfile(os.path.join(MESA_DIR, "libGL.so.1")), "libGL.so.1 not found"

imgui/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "imgui"
+version = "1.92.7"
+description = "Dear ImGui + ImPlot + GLFW 3.4 (static)"
+requires-python = ">=3.8"
+
+[tool.setuptools]
+packages = ["imgui"]
+
+[tool.setuptools.package-data]
+imgui = ["install/**/*"]

imgui/setup.py

@@ -0,0 +1,58 @@
+import os
+import platform
+import subprocess
+
+from setuptools.command.build_py import build_py
+
+try:
+  from wheel.bdist_wheel import bdist_wheel
+except ImportError:
+  bdist_wheel = None
+
+
+class BuildImgui(build_py):
+  """Run build.sh to download imgui sources before collecting package data."""
+
+  def run(self):
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+
+    super().run()
+
+
+cmdclass = {"build_py": BuildImgui}
+
+if bdist_wheel is not None:
+
+  class PlatformWheel(bdist_wheel):
+    """Produce a platform-specific, Python-version-agnostic wheel."""
+
+    def finalize_options(self):
+      super().finalize_options()
+      self.root_is_pure = False
+
+    def get_tag(self):
+      system = platform.system()
+      machine = platform.machine()
+
+      if system == "Linux":
+        plat = f"linux_{machine}"
+      elif system == "Darwin":
+        plat = "macosx_11_0_arm64"
+      else:
+        plat = f"{system.lower()}_{machine}"
+
+      return "py3", "none", plat
+
+  cmdclass["bdist_wheel"] = PlatformWheel
+
+
+def setup():
+  from setuptools import setup as _setup
+
+  _setup(cmdclass=cmdclass)
+
+
+if __name__ == "__main__":
+  setup()

json11/build.sh

@@ -6,36 +6,26 @@ cd "$DIR"
 
 VERSION="db00e9369a92aa74bf630a2ffb092a4b0b132c01"
 INSTALL_DIR="$DIR/json11/install"
-VERSION_FILE="$INSTALL_DIR/VERSION"
-
-# Idempotent: skip if already built at this source revision.
-if [ -f "$INSTALL_DIR/lib/libjson11.a" ] && [ -f "$INSTALL_DIR/include/json11/json11.hpp" ] && \
-  [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$VERSION" ]; then
-  echo "json11 already present, skipping build."
-  exit 0
-fi
+CXX="ccache ${CXX:-c++}"
 
 if [ ! -d "$DIR/json11-src/.git" ]; then
-  git clone https://github.com/dropbox/json11.git json11-src
+  git clone --depth 1 https://github.com/dropbox/json11.git json11-src
 fi
 
-git -C json11-src fetch --force origin
+git -C json11-src fetch --depth 1 origin "$VERSION"
 git -C json11-src checkout --force "$VERSION"
 
 BUILD_DIR="$DIR/build"
-rm -rf "$BUILD_DIR" "$INSTALL_DIR"
-mkdir -p "$BUILD_DIR" "$INSTALL_DIR/lib" "$INSTALL_DIR/include/json11"
+mkdir -p "$BUILD_DIR"
+rm -rf "$INSTALL_DIR"
+mkdir -p "$INSTALL_DIR/lib" "$INSTALL_DIR/include/json11"
 
 CXX="${CXX:-c++}"
 AR="${AR:-ar}"
 
-"$CXX" -std=c++11 -fPIC -O2 -c "$DIR/json11-src/json11.cpp" -o "$BUILD_DIR/json11.o"
+$CXX -std=c++11 -fPIC -O2 -c "$DIR/json11-src/json11.cpp" -o "$BUILD_DIR/json11.o"
 "$AR" rcs "$INSTALL_DIR/lib/libjson11.a" "$BUILD_DIR/json11.o"
 cp "$DIR/json11-src/json11.hpp" "$INSTALL_DIR/include/json11/json11.hpp"
-echo "$VERSION" > "$VERSION_FILE"
-
-# Keep workspace small and deterministic across builds.
-rm -rf "$DIR/json11-src" "$BUILD_DIR"
 
 echo "Installed json11 to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

json11/setup.py

@@ -15,11 +15,8 @@ class BuildJson11(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "json11", "install", "lib", "libjson11.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

libjpeg/build.sh

@@ -7,18 +7,15 @@ cd "$DIR"
 VERSION="3.1.0"
 INSTALL_DIR="$DIR/libjpeg/install"
 
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libjpeg.a" ]; then
-  echo "libjpeg already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
 
-# Clone
-if [ ! -d "libjpeg-turbo-src" ]; then
-  git clone --depth 1 --branch "${VERSION}" https://github.com/libjpeg-turbo/libjpeg-turbo.git libjpeg-turbo-src
+# Clone/update source
+if [ ! -d "libjpeg-turbo-src/.git" ]; then
+  rm -rf libjpeg-turbo-src
+  git clone --depth 1 https://github.com/libjpeg-turbo/libjpeg-turbo.git libjpeg-turbo-src
 fi
+git -C libjpeg-turbo-src fetch --depth 1 origin "${VERSION}"
+git -C libjpeg-turbo-src checkout --force FETCH_HEAD
 
 # Build
 PREFIX="$DIR/build/prefix"
@@ -50,8 +47,5 @@ cp "$PREFIX/include/jconfig.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/jerror.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/jmorecfg.h" "$INSTALL_DIR/include/"
 
-# Clean up
-rm -rf libjpeg-turbo-src "$DIR/build"
-
 echo "Installed libjpeg to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

libjpeg/setup.py

@@ -15,11 +15,8 @@ class BuildLibjpeg(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "libjpeg", "install", "lib", "libjpeg.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

libusb/build.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
+cd "$DIR"
+
+VERSION="1.0.29"
+ARCHIVE="libusb-${VERSION}.tar.bz2"
+URL="https://github.com/libusb/libusb/releases/download/v${VERSION}/${ARCHIVE}"
+INSTALL_DIR="$DIR/libusb/install"
+SRC_DIR="$DIR/libusb-src"
+VERSION_FILE="$SRC_DIR/.version"
+
+NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+export CC="ccache ${CC:-cc}"
+
+if [ ! -f "$VERSION_FILE" ] || [ "$(cat "$VERSION_FILE")" != "$VERSION" ]; then
+  rm -rf "$SRC_DIR"
+  mkdir -p "$SRC_DIR"
+  curl -fSL "$URL" | tar xj --strip-components=1 -C "$SRC_DIR"
+  echo "$VERSION" > "$VERSION_FILE"
+fi
+
+PREFIX="$DIR/build/prefix"
+rm -rf "$DIR/build"
+mkdir -p "$DIR/build"
+
+CONFIGURE_ARGS=(
+  --prefix="$PREFIX"
+  --disable-shared
+  --enable-static
+)
+
+if [ "$(uname)" = "Linux" ]; then
+  CONFIGURE_ARGS+=(--disable-udev)
+fi
+
+cd "$SRC_DIR"
+CFLAGS="-O2 -fPIC" ./configure "${CONFIGURE_ARGS[@]}"
+make -j"$NJOBS"
+make install
+cd "$DIR"
+
+rm -rf "$INSTALL_DIR"
+mkdir -p "$INSTALL_DIR/lib/pkgconfig" "$INSTALL_DIR/include/libusb-1.0"
+
+cp "$PREFIX/lib/libusb-1.0.a" "$INSTALL_DIR/lib/"
+cp "$PREFIX/lib/pkgconfig/libusb-1.0.pc" "$INSTALL_DIR/lib/pkgconfig/"
+cp "$PREFIX/include/libusb-1.0/libusb.h" "$INSTALL_DIR/include/libusb-1.0/"
+
+echo "Installed libusb to $INSTALL_DIR"
+du -sh "$INSTALL_DIR"

libusb/libusb/__init__.py

@@ -0,0 +1,12 @@
+import os
+
+DIR = os.path.join(os.path.dirname(__file__), "install")
+LIB_DIR = os.path.join(DIR, "lib")
+INCLUDE_DIR = os.path.join(DIR, "include")
+PKGCONFIG_DIR = os.path.join(LIB_DIR, "pkgconfig")
+
+
+def smoketest():
+  assert os.path.isfile(os.path.join(LIB_DIR, "libusb-1.0.a")), "libusb-1.0.a not found"
+  assert os.path.isfile(os.path.join(INCLUDE_DIR, "libusb-1.0", "libusb.h")), "libusb.h not found"
+  assert os.path.isfile(os.path.join(PKGCONFIG_DIR, "libusb-1.0.pc")), "libusb-1.0.pc not found"

libusb/pyproject.toml

@@ -3,13 +3,13 @@ requires = ["setuptools>=64", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "openssl3"
-version = "3.4.1"
-description = "OpenSSL cryptography library (static build)"
+name = "libusb"
+version = "1.0.29"
+description = "libusb USB device access library (static build)"
 requires-python = ">=3.8"
 
 [tool.setuptools.packages.find]
-include = ["openssl3*"]
+include = ["libusb*"]
 
 [tool.setuptools.package-data]
-openssl3 = ["install/**/*"]
+libusb = ["install/**/*"]

libusb/setup.py

@@ -0,0 +1,58 @@
+import os
+import platform
+import subprocess
+
+from setuptools.command.build_py import build_py
+
+try:
+  from wheel.bdist_wheel import bdist_wheel
+except ImportError:
+  bdist_wheel = None
+
+
+class BuildLibusb(build_py):
+  """Run build.sh to compile libusb before collecting package data."""
+
+  def run(self):
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+
+    super().run()
+
+
+cmdclass = {"build_py": BuildLibusb}
+
+if bdist_wheel is not None:
+
+  class PlatformWheel(bdist_wheel):
+    """Produce a platform-specific, Python-version-agnostic wheel."""
+
+    def finalize_options(self):
+      super().finalize_options()
+      self.root_is_pure = False
+
+    def get_tag(self):
+      system = platform.system()
+      machine = platform.machine()
+
+      if system == "Linux":
+        plat = f"linux_{machine}"
+      elif system == "Darwin":
+        plat = "macosx_11_0_arm64"
+      else:
+        plat = f"{system.lower()}_{machine}"
+
+      return "py3", "none", plat
+
+  cmdclass["bdist_wheel"] = PlatformWheel
+
+
+def setup():
+  from setuptools import setup as _setup
+
+  _setup(cmdclass=cmdclass)
+
+
+if __name__ == "__main__":
+  setup()

libyuv/build.sh

@@ -6,25 +6,17 @@ cd "$DIR"
 
 VERSION="6067afde563c3946eebd94f146b3824ab7a97a9c"
 INSTALL_DIR="$DIR/libyuv/install"
-VERSION_FILE="$INSTALL_DIR/VERSION"
-
-# Idempotent: skip if already built at this source revision.
-if [ -f "$INSTALL_DIR/lib/libyuv.a" ] && [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$VERSION" ]; then
-  echo "libyuv already present, skipping build."
-  exit 0
-fi
 
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
 
 if [ ! -d "libyuv-src/.git" ]; then
-  git clone https://chromium.googlesource.com/libyuv/libyuv libyuv-src
+  git clone --depth 1 https://chromium.googlesource.com/libyuv/libyuv libyuv-src
 fi
 
-git -C libyuv-src fetch --force origin
+git -C libyuv-src fetch --depth 1 origin "$VERSION"
 git -C libyuv-src checkout --force "$VERSION"
 
-BUILD_DIR="$DIR/build/build"
-rm -rf "$DIR/build"
+BUILD_DIR="$DIR/build"
 mkdir -p "$BUILD_DIR"
 
 cmake -S "$DIR/libyuv-src" -B "$BUILD_DIR" \
@@ -47,10 +39,6 @@ rm -rf "$INSTALL_DIR"
 mkdir -p "$INSTALL_DIR"/{lib,include}
 cp "$LIBYUV_STATIC" "$INSTALL_DIR/lib/libyuv.a"
 cp -r "$DIR/libyuv-src/include/." "$INSTALL_DIR/include/"
-echo "$VERSION" > "$VERSION_FILE"
-
-# Keep workspace small and deterministic across builds.
-rm -rf "$DIR/libyuv-src" "$DIR/build"
 
 echo "Installed libyuv to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

libyuv/setup.py

@@ -15,11 +15,8 @@ class BuildLibyuv(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "libyuv", "install", "lib", "libyuv.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

mdbook/build.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
+cd "$DIR"
+
+VERSION="0.5.2"
+INSTALL_DIR="$DIR/mdbook/bin"
+VERSION_FILE="$INSTALL_DIR/.version"
+
+# Skip if already at correct version
+if [ -f "$VERSION_FILE" ] && [ "$(cat "$VERSION_FILE")" = "$VERSION" ]; then
+  echo "mdbook $VERSION already present, skipping."
+  exit 0
+fi
+
+OS="$(uname -s)"
+ARCH="$(uname -m)"
+
+case "${OS}-${ARCH}" in
+  Linux-x86_64)   TARGET="x86_64-unknown-linux-musl" ;;
+  Linux-aarch64)  TARGET="aarch64-unknown-linux-musl" ;;
+  Darwin-arm64)   TARGET="aarch64-apple-darwin" ;;
+  *)
+    echo "Unsupported platform: ${OS}-${ARCH}" >&2
+    exit 1
+    ;;
+esac
+
+FILENAME="mdbook-v${VERSION}-${TARGET}.tar.gz"
+URL="https://github.com/rust-lang/mdBook/releases/download/v${VERSION}/${FILENAME}"
+
+echo "Downloading $FILENAME ..."
+curl -fSL -o "$FILENAME" "$URL"
+
+echo "Extracting ..."
+mkdir -p "$INSTALL_DIR"
+tar -xzf "$FILENAME" -C "$INSTALL_DIR" mdbook
+
+chmod +x "$INSTALL_DIR/mdbook"
+
+rm -f "$FILENAME"
+echo "$VERSION" > "$VERSION_FILE"
+
+echo "Installed mdbook to $INSTALL_DIR"
+du -sh "$INSTALL_DIR"

mdbook/mdbook/__init__.py

@@ -0,0 +1,15 @@
+import os
+import sys
+
+BIN_DIR = os.path.join(os.path.dirname(__file__), "bin")
+
+
+def _run():
+  binary = os.path.join(BIN_DIR, "mdbook")
+  os.execvp(binary, [binary] + sys.argv[1:])
+
+
+def smoketest():
+  import subprocess
+  binary = os.path.join(BIN_DIR, "mdbook")
+  subprocess.run([binary, "--version"], check=True)

mdbook/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mdbook"
+version = "0.5.2"
+description = "mdBook command-line tool for creating books from Markdown"
+requires-python = ">=3.8"
+
+[project.scripts]
+mdbook = "mdbook:_run"
+
+[tool.setuptools.packages.find]
+include = ["mdbook*"]
+
+[tool.setuptools.package-data]
+mdbook = ["bin/**/*"]

mdbook/setup.py

@@ -10,21 +10,18 @@ except ImportError:
   bdist_wheel = None
 
 
-class BuildOpenssl(build_py):
-  """Run build.sh to compile OpenSSL before collecting package data."""
+class BuildMdbook(build_py):
+  """Run build.sh to download mdbook before collecting package data."""
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "openssl3", "install", "lib", "libcrypto.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 
 
-cmdclass = {"build_py": BuildOpenssl}
+cmdclass = {"build_py": BuildMdbook}
 
 if bdist_wheel is not None:
 

nanosvg/build.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -e
+
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
+cd "$DIR"
+
+COMMIT="5cefd9847949af6df13f65027fd43af5a7513633"
+INSTALL_DIR="$DIR/nanosvg/install"
+
+# Clone/update source
+if [ ! -d "nanosvg-src/.git" ]; then
+  rm -rf nanosvg-src
+  git clone --depth 1 https://github.com/memononen/nanosvg.git nanosvg-src
+fi
+git -C nanosvg-src fetch --depth 1 origin "$COMMIT"
+git -C nanosvg-src checkout --force FETCH_HEAD
+
+# Copy headers
+rm -rf "$INSTALL_DIR"
+mkdir -p "$INSTALL_DIR/include"
+cp nanosvg-src/src/nanosvg.h "$INSTALL_DIR/include/"
+cp nanosvg-src/src/nanosvgrast.h "$INSTALL_DIR/include/"
+
+echo "Installed nanosvg to $INSTALL_DIR"
+du -sh "$INSTALL_DIR"

nanosvg/nanosvg/__init__.py

@@ -0,0 +1,10 @@
+import os
+
+DIR = os.path.join(os.path.dirname(__file__), "install")
+INCLUDE_DIR = os.path.join(DIR, "include")
+LIB_DIR = DIR  # header-only; no libraries
+
+
+def smoketest():
+  assert os.path.isfile(os.path.join(INCLUDE_DIR, "nanosvg.h")), "nanosvg.h not found"
+  assert os.path.isfile(os.path.join(INCLUDE_DIR, "nanosvgrast.h")), "nanosvgrast.h not found"

nanosvg/pyproject.toml

@@ -3,13 +3,13 @@ requires = ["setuptools>=64", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "python3-dev"
-version = "3.12.8"
-description = "CPython development headers"
+name = "nanosvg"
+version = "0.0.1"
+description = "NanoSVG: simple SVG parser and rasterizer"
 requires-python = ">=3.8"
 
 [tool.setuptools.packages.find]
-include = ["python3_dev*"]
+include = ["nanosvg*"]
 
 [tool.setuptools.package-data]
-python3_dev = ["install/**/*"]
+nanosvg = ["install/**/*"]

nanosvg/setup.py

@@ -10,21 +10,18 @@ except ImportError:
   bdist_wheel = None
 
 
-class BuildPython3Dev(build_py):
-  """Run build.sh to download CPython headers before collecting package data."""
+class BuildNanosvg(build_py):
+  """Run build.sh to download nanosvg headers before collecting package data."""
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "python3_dev", "install", "include", "Python.h")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 
 
-cmdclass = {"build_py": BuildPython3Dev}
+cmdclass = {"build_py": BuildNanosvg}
 
 if bdist_wheel is not None:
 

ncurses/build.sh

@@ -6,31 +6,25 @@ cd "$DIR"
 
 VERSION="6.5"
 INSTALL_DIR="$DIR/ncurses/install"
-
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libncurses.a" ]; then
-  echo "ncurses already present, skipping build."
-  exit 0
-fi
+VERSION_FILE="$DIR/ncurses-src/.version"
 
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+export CC="ccache ${CC:-cc}"
 
-# Download
-TARBALL="ncurses-${VERSION}.tar.gz"
-if [ ! -f "$TARBALL" ]; then
-  curl -fsSL "https://ftp.gnu.org/gnu/ncurses/${TARBALL}" -o "$TARBALL"
-fi
-
-# Extract
-if [ ! -d "ncurses-${VERSION}" ]; then
-  tar xf "$TARBALL"
+# Download tarball (v6.5 tag doesn't exist on the GitHub mirror)
+if [ ! -f "$VERSION_FILE" ] || [ "$(cat "$VERSION_FILE")" != "$VERSION" ]; then
+  rm -rf ncurses-src
+  mkdir -p ncurses-src
+  curl -fSL "https://ftp.gnu.org/gnu/ncurses/ncurses-${VERSION}.tar.gz" \
+    | tar xz --strip-components=1 -C ncurses-src
+  echo "$VERSION" > "$VERSION_FILE"
 fi
 
 # Build
 PREFIX="$DIR/build/prefix"
 mkdir -p "$DIR/build"
 
-cd "ncurses-${VERSION}"
+cd ncurses-src
 CFLAGS="-fPIC" ./configure \
   --prefix="$PREFIX" \
   --without-shared \
@@ -66,8 +60,5 @@ cp "$PREFIX/include/unctrl.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/term.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/termcap.h" "$INSTALL_DIR/include/"
 
-# Clean up
-rm -rf "ncurses-${VERSION}" "$TARBALL" "$DIR/build"
-
 echo "Installed ncurses to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

ncurses/setup.py

@@ -15,11 +15,8 @@ class BuildNcurses(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "ncurses", "install", "lib", "libncurses.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

openssl3/build.sh

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
-cd "$DIR"
-
-VERSION="3.4.1"
-INSTALL_DIR="$DIR/openssl3/install"
-
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libcrypto.a" ]; then
-  echo "openssl already present, skipping build."
-  exit 0
-fi
-
-NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
-
-# Download
-TARBALL="openssl-${VERSION}.tar.gz"
-if [ ! -d "openssl-src" ]; then
-  curl -fSL -o "$TARBALL" "https://github.com/openssl/openssl/releases/download/openssl-${VERSION}/${TARBALL}"
-  mkdir -p openssl-src
-  tar -xf "$TARBALL" -C openssl-src --strip-components=1
-  rm -f "$TARBALL"
-fi
-
-# Configure
-PREFIX="$DIR/build/prefix"
-cd openssl-src
-
-if [ "$(uname)" = "Darwin" ]; then
-  TARGET="darwin64-arm64-cc"
-else
-  MACHINE="$(uname -m)"
-  if [ "$MACHINE" = "x86_64" ]; then
-    TARGET="linux-x86_64"
-  elif [ "$MACHINE" = "aarch64" ]; then
-    TARGET="linux-aarch64"
-  else
-    TARGET="linux-${MACHINE}"
-  fi
-fi
-
-./Configure "$TARGET" \
-  --prefix="$PREFIX" \
-  --libdir=lib \
-  no-shared \
-  no-tests \
-  no-docs \
-  no-apps \
-  -fPIC \
-  -Os
-
-# Build
-make -j"$NJOBS"
-make install_sw
-
-cd "$DIR"
-
-# Copy to package install dir
-rm -rf "$INSTALL_DIR"
-mkdir -p "$INSTALL_DIR"/{lib,include}
-
-# Libraries
-cp "$PREFIX/lib/libcrypto.a" "$INSTALL_DIR/lib/"
-cp "$PREFIX/lib/libssl.a" "$INSTALL_DIR/lib/"
-
-# Headers
-cp -r "$PREFIX/include/openssl" "$INSTALL_DIR/include/"
-
-# Clean up
-rm -rf openssl-src "$DIR/build"
-
-echo "Installed openssl to $INSTALL_DIR"
-du -sh "$INSTALL_DIR"

openssl3/openssl3/__init__.py

@@ -1,11 +0,0 @@
-import os
-
-DIR = os.path.join(os.path.dirname(__file__), "install")
-LIB_DIR = os.path.join(DIR, "lib")
-INCLUDE_DIR = os.path.join(DIR, "include")
-
-
-def smoketest():
-  assert os.path.isfile(os.path.join(LIB_DIR, "libcrypto.a")), "libcrypto.a not found"
-  assert os.path.isfile(os.path.join(LIB_DIR, "libssl.a")), "libssl.a not found"
-  assert os.path.isdir(os.path.join(INCLUDE_DIR, "openssl")), "openssl headers not found"

pyproject.toml

@@ -6,13 +6,17 @@ members = [
   "eigen",
   "ffmpeg",
   "gcc-arm-none-eabi",
+  "git",
   "git-lfs",
+  "imgui",
   "json11",
+  "libusb",
   "libjpeg",
   "libyuv",
+  "mdbook",
+  "nanosvg",
   "ncurses",
-  "openssl3",
-  "python3-dev",
+  "qt5",
   "raylib",
   "zeromq",
   "zstd",

python3-dev/build.sh

@@ -1,44 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
-cd "$DIR"
-
-VERSION="3.12.8"
-INSTALL_DIR="$DIR/python3_dev/install"
-
-# Idempotent: skip if already present
-if [ -f "$INSTALL_DIR/include/Python.h" ]; then
-  echo "python3-dev headers already present, skipping."
-  exit 0
-fi
-
-TARBALL="Python-${VERSION}.tgz"
-URL="https://www.python.org/ftp/python/${VERSION}/${TARBALL}"
-
-echo "Downloading CPython ${VERSION} source ..."
-curl -fSL -o "$TARBALL" "$URL"
-
-echo "Extracting ..."
-tar xzf "$TARBALL"
-
-cd "Python-${VERSION}"
-
-# Run configure to generate pyconfig.h for this platform
-echo "Running configure to generate pyconfig.h ..."
-./configure --disable-shared --without-ensurepip > /dev/null 2>&1
-
-cd "$DIR"
-
-# Copy headers
-rm -rf "$INSTALL_DIR"
-mkdir -p "$INSTALL_DIR/include"
-
-cp -r "Python-${VERSION}/Include/"* "$INSTALL_DIR/include/"
-cp "Python-${VERSION}/pyconfig.h" "$INSTALL_DIR/include/"
-
-# Clean up
-rm -rf "Python-${VERSION}" "$TARBALL"
-
-echo "Installed python3-dev headers to $INSTALL_DIR"
-du -sh "$INSTALL_DIR"

python3-dev/python3_dev/__init__.py

@@ -1,9 +0,0 @@
-import os
-
-DIR = os.path.join(os.path.dirname(__file__), "install")
-INCLUDE_DIR = os.path.join(DIR, "include")
-
-
-def smoketest():
-  assert os.path.isfile(os.path.join(INCLUDE_DIR, "Python.h")), "Python.h not found"
-  assert os.path.isfile(os.path.join(INCLUDE_DIR, "pyconfig.h")), "pyconfig.h not found"

raylib/build.sh

@@ -6,13 +6,8 @@ cd "$DIR"
 
 INSTALL_DIR="$DIR/raylib/install"
 
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libraylib.a" ]; then
-  echo "raylib already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+CC="ccache ${CC:-cc}"
 
 # Detect platform: PLATFORM_COMMA for comma devices, PLATFORM_DESKTOP otherwise
 RAYLIB_PLATFORM="${RAYLIB_PLATFORM:-PLATFORM_DESKTOP}"
@@ -33,6 +28,15 @@ if [[ "$(uname)" == "Linux" ]]; then
         sudo apt-get update && sudo apt-get install -y libdrm-dev libgbm-dev libgles2-mesa-dev libegl1-mesa-dev || true
       fi
     fi
+  elif [ "$RAYLIB_PLATFORM" = "PLATFORM_OFFSCREEN" ]; then
+    # offscreen (CI): needs EGL/GL dev packages (no X11)
+    if command -v apt-get &>/dev/null; then
+      if [ "$(id -u)" -eq 0 ]; then
+        apt-get update && apt-get install -y libegl-dev libgl-dev
+      else
+        sudo apt-get update && sudo apt-get install -y libegl-dev libgl-dev
+      fi
+    fi
   else
     # desktop: needs X11/GL dev packages
     if command -v dnf &>/dev/null; then
@@ -48,19 +52,20 @@ if [[ "$(uname)" == "Linux" ]]; then
 fi
 
 # Clone and build raylib C library
-RAYLIB_COMMIT="aa6ade09ac4bfb2847a356535f2d9f87e49ab089"
+RAYLIB_COMMIT="d9d7cc1353ec0f73c97e84ddf0973983d1ee25e2"
 
-if [ ! -d "raylib-src" ]; then
-  git clone -b master --no-tags https://github.com/commaai/raylib.git raylib-src
+if [ ! -d "raylib-src/.git" ]; then
+  rm -rf raylib-src
+  git clone --depth 1 -b platform-offscreen --no-tags https://github.com/commaai/raylib.git raylib-src
 fi
 
 cd raylib-src
-git fetch origin "$RAYLIB_COMMIT"
+git fetch --depth 1 origin "$RAYLIB_COMMIT"
 git reset --hard "$RAYLIB_COMMIT"
-git clean -xdff .
 
 cd src
-make -j"$NJOBS" PLATFORM="$RAYLIB_PLATFORM"
+make clean
+make -j"$NJOBS" PLATFORM="$RAYLIB_PLATFORM" CC="${CC:-gcc}"
 
 cd "$DIR"
 
@@ -71,13 +76,46 @@ mkdir -p "$INSTALL_DIR"/{lib,include}
 cp raylib-src/src/libraylib.a "$INSTALL_DIR/lib/"
 cp raylib-src/src/raylib.h raylib-src/src/raymath.h raylib-src/src/rlgl.h "$INSTALL_DIR/include/"
 
+# On x86_64 Linux, also build the offscreen variant for CI headless rendering
+if [[ "$(uname)" == "Linux" && "$(uname -m)" == "x86_64" && "$RAYLIB_PLATFORM" != "PLATFORM_OFFSCREEN" ]]; then
+  echo "Building offscreen variant..."
+
+  # Install EGL/GL dev packages needed for offscreen build + bundling
+  if command -v dnf &>/dev/null; then
+    dnf install -y mesa-libEGL-devel mesa-libGL-devel libglvnd-opengl libglvnd-core-devel 2>/dev/null || true
+  elif command -v apt-get &>/dev/null; then
+    if [ "$(id -u)" -eq 0 ]; then
+      apt-get update && apt-get install -y libegl-dev libgl-dev
+    else
+      sudo apt-get update && sudo apt-get install -y libegl-dev libgl-dev
+    fi
+  fi
+
+  cd raylib-src/src
+  make clean
+  make -j"$NJOBS" PLATFORM=PLATFORM_OFFSCREEN CC="${CC:-gcc}"
+  cp libraylib.a "$INSTALL_DIR/lib/libraylib_offscreen.a"
+  cd "$DIR"
+
+  # Bundle GLVND dispatchers so offscreen rendering works without extra system packages
+  MESA_DIR="$INSTALL_DIR/lib/mesa"
+  mkdir -p "$MESA_DIR"
+  ldconfig 2>/dev/null || true
+  for lib in libEGL.so.1 libOpenGL.so.0 libGLdispatch.so.0; do
+    src="$(ldconfig -p 2>/dev/null | grep "$lib" | grep -E 'x86.64|libc6,' | awk '{print $NF}' | head -1)"
+    if [ -n "$src" ] && [ -f "$src" ]; then
+      cp -L "$src" "$MESA_DIR/"
+      # Create unversioned symlink for the linker
+      base="${lib%%.so.*}"
+      ln -sf "$lib" "$MESA_DIR/${base}.so"
+    fi
+  done
+fi
+
 # Download raygui header
 RAYGUI_COMMIT="76b36b597edb70ffaf96f046076adc20d67e7827"
 curl -fsSLo "$INSTALL_DIR/include/raygui.h" \
   "https://raw.githubusercontent.com/raysan5/raygui/$RAYGUI_COMMIT/src/raygui.h"
 
-# Clean up source
-rm -rf raylib-src
-
 echo "Installed raylib to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

raylib/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=64", "wheel"]
+requires = ["setuptools>=64", "wheel", "cffi>=1.17.1"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "raylib"
-version = "5.5.0.2"
+version = "5.5.0.8"
 description = "raylib + pyray Python bindings (commaai fork)"
 requires-python = ">=3.8"
 dependencies = ["cffi>=1.17.1"]
@@ -13,4 +13,4 @@ dependencies = ["cffi>=1.17.1"]
 include = ["raylib*", "pyray*"]
 
 [tool.setuptools.package-data]
-raylib = ["install/**/*"]
+raylib = ["install/**/*", "_raylib_cffi*.so"]

raylib/raylib/__init__.py

@@ -1,26 +1,60 @@
 import os
+import platform as _platform
 
 DIR = os.path.join(os.path.dirname(__file__), "install")
 LIB_DIR = os.path.join(DIR, "lib")
 INCLUDE_DIR = os.path.join(DIR, "include")
 
 
+def _detect_platform():
+  """Auto-detect the raylib platform. In CI on Linux x86_64, use offscreen EGL rendering."""
+  explicit = os.environ.get("RAYLIB_PLATFORM", "")
+  if explicit:
+    return explicit
+  if os.environ.get("CI") and _platform.system() == "Linux" and _platform.machine() == "x86_64":
+    return "PLATFORM_OFFSCREEN"
+  return ""
+
+
 def smoketest():
   assert os.path.isfile(os.path.join(LIB_DIR, "libraylib.a")), "libraylib.a not found"
   assert os.path.isfile(os.path.join(INCLUDE_DIR, "raylib.h")), "raylib.h not found"
 
 
-# Build CFFI extension on first import if not already compiled
+# Build CFFI extension on first import if not already compiled,
+# or rebuild if the target platform changed since last build.
 def _ensure_cffi_built():
   import glob
   import subprocess
   import sys
   pkg_dir = os.path.dirname(__file__)
-  if not glob.glob(os.path.join(pkg_dir, "_raylib_cffi*")):
+  platform_marker = os.path.join(pkg_dir, ".raylib_platform")
+  requested = _detect_platform()
+
+  # Export so build.py picks it up
+  if requested:
+    os.environ["RAYLIB_PLATFORM"] = requested
+    # Mesa llvmpipe for software rendering in headless CI
+    if requested == "PLATFORM_OFFSCREEN":
+      os.environ.setdefault("LIBGL_ALWAYS_SOFTWARE", "1")
+
+  cffi_files = glob.glob(os.path.join(pkg_dir, "_raylib_cffi*"))
+
+  # Rebuild if platform changed
+  if cffi_files and requested:
+    built_for = open(platform_marker).read().strip() if os.path.isfile(platform_marker) else ""
+    if built_for != requested:
+      for f in cffi_files:
+        os.remove(f)
+      cffi_files = []
+
+  if not cffi_files:
     build_script = os.path.join(pkg_dir, "build.py")
     if os.path.isfile(build_script) and os.path.isfile(os.path.join(LIB_DIR, "libraylib.a")):
       try:
         subprocess.check_call([sys.executable, build_script], cwd=os.path.dirname(pkg_dir))
+        with open(platform_marker, "w") as f:
+          f.write(requested)
       except subprocess.CalledProcessError:
         pass
 

raylib/raylib/build.py

@@ -93,7 +93,7 @@ def build_ffi():
       '-framework', 'CoreVideo',
     ]
     libraries = []
-    extra_compile_args = ["-Wno-error=incompatible-function-pointer-types", "-D_CFFI_NO_LIMITED_API"]
+    extra_compile_args = ["-Wno-error=incompatible-function-pointer-types"]
   else:
     print("BUILDING FOR LINUX")
     extra_link_args = [
@@ -104,15 +104,26 @@ def build_ffi():
     if RAYLIB_PLATFORM == "PLATFORM_COMMA":
       extra_link_args.remove('-lGL')
       extra_link_args += ['-lGLESv2', '-lEGL', '-lgbm', '-ldrm']
+    elif RAYLIB_PLATFORM == "PLATFORM_OFFSCREEN":
+      # Use offscreen variant if available, otherwise fall back to default
+      offscreen_lib = os.path.join(RAYLIB_LIB_PATH, 'libraylib_offscreen.a')
+      if os.path.isfile(offscreen_lib):
+        extra_link_args[extra_link_args.index('-lraylib')] = '-lraylib_offscreen'
+      extra_link_args.remove('-lGL')
+      # Use bundled GLVND dispatchers if available, with RPATH for runtime
+      mesa_dir = os.path.join(RAYLIB_LIB_PATH, 'mesa')
+      if os.path.isdir(mesa_dir):
+        extra_link_args += [f'-L{mesa_dir}', f'-Wl,-rpath,$ORIGIN/install/lib/mesa']
+      extra_link_args += ['-lOpenGL', '-lEGL']
     else:
       extra_link_args += ['-lX11']
-    extra_compile_args = ["-Wno-incompatible-pointer-types", "-D_CFFI_NO_LIMITED_API"]
+    extra_compile_args = ["-Wno-incompatible-pointer-types"]
     libraries = []
 
   print("extra_link_args: " + str(extra_link_args))
   ffibuilder.set_source("raylib._raylib_cffi",
                         ffi_includes,
-                        py_limited_api=False,
+                        py_limited_api=True,
                         include_dirs=[RAYLIB_INCLUDE_PATH],
                         extra_link_args=extra_link_args,
                         extra_compile_args=extra_compile_args,

raylib/raylib/version.py

@@ -1 +1 @@
-__version__ = "5.5.0.2"
+__version__ = "5.5.0.8"

raylib/setup.py

@@ -1,6 +1,8 @@
+import glob
 import os
 import platform
 import subprocess
+import sys
 
 from setuptools import setup
 from setuptools.command.build_py import build_py
@@ -12,15 +14,19 @@ except ImportError:
 
 
 class BuildRaylib(build_py):
-  """Run build.sh to compile the C library before collecting package data."""
+  """Run build.sh to compile the C library and CFFI extension before collecting package data."""
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "raylib", "install", "lib", "libraylib.a")
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    # Build CFFI extension so it's included in the wheel
+    cffi_so = glob.glob(os.path.join(pkg_dir, "raylib", "_raylib_cffi*"))
+    if not cffi_so:
+      build_cffi = os.path.join(pkg_dir, "raylib", "build.py")
+      if os.path.isfile(build_cffi):
+        subprocess.check_call([sys.executable, build_cffi], cwd=pkg_dir)
 
     super().run()
 

release.sh

@@ -29,7 +29,7 @@ for toml in */pyproject.toml; do
 done
 shopt -u nullglob
 
-TOKEN="$(gh auth token 2>/dev/null)" || { echo "set GH_TOKEN to publish shim branch" >&2; exit 1; }
+TOKEN="$(gh auth token 2>/dev/null)" || { echo "set GH_TOKEN to publish shim branches" >&2; exit 1; }
 
 TMP_DIR="$(mktemp -d)"
 python3 - "$TMP_DIR" "$REPO" <<'PY'
@@ -55,12 +55,33 @@ for toml in sorted(pathlib.Path(".").glob("*/pyproject.toml")):
   datadir = patterns[0].split("/", 1)[0] if patterns and patterns[0] else ""
   scripts = data.get("project", {}).get("scripts", {}) or {}
 
-  pkg_dir = tmp_dir / pkg
+  repo_dir = tmp_dir / pkg
+  pkg_dir = repo_dir / pkg
   mod_dir = pkg_dir / module
   mod_dir.mkdir(parents=True, exist_ok=True)
-  shutil.copy2(pathlib.Path(pkg) / module / "__init__.py", mod_dir / "__init__.py")
+
+  # copy all .py files from the main module
+  src_mod = pathlib.Path(pkg) / module
+  for py_file in src_mod.glob("*.py"):
+    shutil.copy2(py_file, mod_dir / py_file.name)
+
+  # copy extra packages (e.g. pyray for raylib)
+  pkgs_val = data.get("tool", {}).get("setuptools", {}).get("packages", {})
+  include_patterns = pkgs_val.get("find", {}).get("include", []) if isinstance(pkgs_val, dict) else []
+  extra_packages = []
+  for pattern in include_patterns:
+    p = pattern.rstrip("*")
+    if p and p != module and p != f"{module}/":
+      src_extra = pathlib.Path(pkg) / p
+      if src_extra.is_dir():
+        dst_extra = pkg_dir / p
+        shutil.copytree(src_extra, dst_extra, dirs_exist_ok=True)
+        extra_packages.append(pattern)
+
   shutil.copy2(shim_setup, pkg_dir / "setup.py")
 
+  deps = data.get("project", {}).get("dependencies", [])
+
   lines = [
     "[build-system]",
     'requires = ["setuptools>=64", "wheel", \'tomli; python_version < \"3.11\"\']',
@@ -73,18 +94,22 @@ for toml in sorted(pathlib.Path(".").glob("*/pyproject.toml")):
     'requires-python = ">=3.8"',
   ]
 
+  if deps:
+    lines.append(f"dependencies = {json.dumps(deps)}")
+
   if scripts:
     lines += ["", "[project.scripts]"]
     for name, target in scripts.items():
       lines.append(f'"{name}" = {json.dumps(target)}')
 
+  find_include = [f"{module}*"] + extra_packages
   lines += [
     "",
     "[tool.setuptools.packages.find]",
-    f'include = ["{module}*"]',
+    f"include = {json.dumps(find_include)}",
     "",
     "[tool.setuptools.package-data]",
-    f'{module} = ["{datadir}/**/*"]',
+    f'{module} = ["{datadir}/**/*", "*.so"]',
     "",
     "[tool.shim]",
     f'repo_url = "{repo_url}"',
@@ -95,14 +120,25 @@ for toml in sorted(pathlib.Path(".").glob("*/pyproject.toml")):
   (pkg_dir / "pyproject.toml").write_text("\n".join(lines) + "\n")
 PY
 
-(
-  cd "$TMP_DIR"
-  git init
-  git checkout -b releases
-  git add .
-  git -c user.name="github-actions[bot]" -c user.email="github-actions[bot]@users.noreply.github.com" commit -m "update shim packages"
-  git remote add origin "https://x-access-token:${TOKEN}@github.com/${REPO}.git"
-  git push -f origin releases
-)
+shopt -s nullglob
+for repo_dir in "$TMP_DIR"/*; do
+  [[ -d "$repo_dir" ]] || continue
+
+  pkg="$(basename "$repo_dir")"
+  branch="release-$pkg"
+
+  echo "[$pkg] Publishing shim branch $branch"
+
+  (
+    cd "$repo_dir"
+    git init
+    git checkout -b "$branch"
+    git add "$pkg"
+    git -c user.name="github-actions[bot]" -c user.email="github-actions[bot]@users.noreply.github.com" commit -m "update $pkg shim"
+    git remote add origin "https://x-access-token:${TOKEN}@github.com/${REPO}.git"
+    git push -f origin "$branch"
+  )
+done
+shopt -u nullglob
 
 rm -rf "$TMP_DIR"

setup.sh

@@ -15,12 +15,12 @@ run_as_root() {
 }
 
 if [ "$(uname)" = "Darwin" ]; then
-  brew install nasm pkg-config
+  brew install nasm pkg-config ccache autoconf automake libtool
 elif command -v dnf &>/dev/null; then
-  dnf install -y nasm cmake gcc-c++ pkgconfig git perl-IPC-Cmd
+  dnf install -y nasm cmake gcc-c++ pkgconfig git perl-IPC-Cmd ccache autoconf automake libtool
 elif command -v apt-get &>/dev/null; then
   run_as_root apt-get update
-  run_as_root apt-get install -y nasm cmake g++ pkg-config curl
+  run_as_root apt-get install -y nasm cmake g++ pkg-config curl ccache autoconf automake libtool
 fi
 
 if ! command -v uv &>/dev/null; then

zeromq/build.sh

@@ -7,18 +7,15 @@ cd "$DIR"
 VERSION="4.3.5"
 INSTALL_DIR="$DIR/zeromq/install"
 
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libzmq.a" ]; then
-  echo "zeromq already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
 
-# Clone
-if [ ! -d "libzmq-src" ]; then
-  git clone --depth 1 --branch "v${VERSION}" https://github.com/zeromq/libzmq.git libzmq-src
+# Clone/update source
+if [ ! -d "libzmq-src/.git" ]; then
+  rm -rf libzmq-src
+  git clone --depth 1 https://github.com/zeromq/libzmq.git libzmq-src
 fi
+git -C libzmq-src fetch --depth 1 origin "v${VERSION}"
+git -C libzmq-src checkout --force FETCH_HEAD
 
 # Build
 PREFIX="$DIR/build/prefix"
@@ -54,8 +51,5 @@ cp "$PREFIX/lib/libzmq.a" "$INSTALL_DIR/lib/"
 cp "$PREFIX/include/zmq.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/zmq_utils.h" "$INSTALL_DIR/include/"
 
-# Clean up
-rm -rf libzmq-src "$DIR/build"
-
 echo "Installed zeromq to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

zeromq/setup.py

@@ -15,11 +15,8 @@ class BuildZeromq(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "zeromq", "install", "lib", "libzmq.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()
 

zstd/build.sh

@@ -7,18 +7,15 @@ cd "$DIR"
 VERSION="1.5.6"
 INSTALL_DIR="$DIR/zstd/install"
 
-# Idempotent: skip if already built
-if [ -f "$INSTALL_DIR/lib/libzstd.a" ]; then
-  echo "zstd already present, skipping build."
-  exit 0
-fi
-
 NJOBS="$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)"
 
-# Clone
-if [ ! -d "zstd-src" ]; then
-  git clone --depth 1 --branch "v${VERSION}" https://github.com/facebook/zstd.git zstd-src
+# Clone/update source
+if [ ! -d "zstd-src/.git" ]; then
+  rm -rf zstd-src
+  git clone --depth 1 https://github.com/facebook/zstd.git zstd-src
 fi
+git -C zstd-src fetch --depth 1 origin "v${VERSION}"
+git -C zstd-src checkout --force FETCH_HEAD
 
 # Build
 PREFIX="$DIR/build/prefix"
@@ -52,8 +49,5 @@ cp "$PREFIX/include/zstd.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/zstd_errors.h" "$INSTALL_DIR/include/"
 cp "$PREFIX/include/zdict.h" "$INSTALL_DIR/include/"
 
-# Clean up
-rm -rf zstd-src "$DIR/build"
-
 echo "Installed zstd to $INSTALL_DIR"
 du -sh "$INSTALL_DIR"

zstd/setup.py

@@ -15,11 +15,8 @@ class BuildZstd(build_py):
 
   def run(self):
     pkg_dir = os.path.dirname(os.path.abspath(__file__))
-    marker = os.path.join(pkg_dir, "zstd", "install", "lib", "libzstd.a")
-
-    if not os.path.exists(marker):
-      build_script = os.path.join(pkg_dir, "build.sh")
-      subprocess.check_call(["bash", build_script], cwd=pkg_dir)
+    build_script = os.path.join(pkg_dir, "build.sh")
+    subprocess.check_call(["bash", build_script], cwd=pkg_dir)
 
     super().run()