cibuildmp 0.3.0__tar.gz

cibuildmp-0.3.0/.github/actions/build-natmod/action.yml

@@ -0,0 +1,133 @@
+name: Build natmod arch
+description: >
+  Installs whatever cross toolchain a single dynruntime.mk ARCH needs (a
+  plain apt package, the xtensa-lx106 tarball, or esp-idf -- picked per
+  ARCH, matching dynruntime.mk's own CROSS choices), builds mpy-cross, then
+  runs `make ARCH=<arch> dist` in the natmod directory.
+
+  Requires MPY_DIR to already be exported (e.g. by the fetch-micropython or
+  clone-micropython action from this same repo) and the calling repo's own
+  checkout to already have happened, submodules included if the natmod
+  Makefile needs any.
+
+inputs:
+  arch:
+    description: >
+      dynruntime.mk ARCH to build: x64, x86, armv6m, armv7m, armv7emsp,
+      armv7emdp, rv32imc, rv64imc, xtensa, or xtensawin. (aarch64 has no
+      dynruntime.mk ARCH at all as of MicroPython <= v1.28 -- build it via
+      a usermod instead.)
+    required: true
+  natmod_dir:
+    description: Path to the directory containing natmod/Makefile, relative to the workspace root.
+    required: false
+    default: natmod
+  esp_idf_ver:
+    description: esp-idf tag to install for the xtensawin toolchain.
+    required: false
+    default: v5.4
+  extra_pip:
+    description: >
+      Extra space-separated pip packages to install alongside pyelftools/ar
+      (both always installed -- mpy_ld.py needs them for every ARCH).
+    required: false
+    default: ''
+  pre_build_command:
+    description: >
+      Optional shell command run once inside natmod_dir, after mpy-cross is
+      built and before `make dist` -- e.g. a7p's `make fetch-nanopb`, which
+      the natmod Makefile needs vendored in before it can build any ARCH.
+    required: false
+    default: ''
+
+runs:
+  using: composite
+  steps:
+    - name: Install cross-compiler
+      shell: bash
+      run: |
+        set -e
+        case "${{ inputs.arch }}" in
+          x64|xtensa|xtensawin)
+            # x64 needs no cross toolchain at all; xtensa/xtensawin are
+            # handled by their own steps below, not a plain apt package.
+            exit 0
+            ;;
+          x86)
+            PKGS="gcc-multilib"
+            ;;
+          armv6m|armv7m|armv7emsp|armv7emdp)
+            PKGS="gcc-arm-none-eabi libnewlib-arm-none-eabi"
+            ;;
+          rv32imc|rv64imc)
+            PKGS="gcc-riscv64-unknown-elf picolibc-riscv64-unknown-elf"
+            ;;
+          *)
+            echo "::error::build-natmod: unknown ARCH '${{ inputs.arch }}'"
+            exit 1
+            ;;
+        esac
+        # apt-get update first: the runner image's baked-in package index
+        # can already be stale by the time a job runs, pointing at a
+        # gcc/glibc revision the mirror has since superseded (404 Not Found
+        # on install rather than a version error) -- seen for real on the
+        # x86 leg across every repo this action was extracted from.
+        sudo apt-get update -q
+        sudo apt-get install -y $PKGS
+
+    - name: Install xtensa (esp8266) toolchain
+      if: inputs.arch == 'xtensa'
+      shell: bash
+      # Same tarball MicroPython's own ci_esp8266_setup uses -- no apt
+      # package exists for this target.
+      run: |
+        wget -q https://micropython.org/resources/xtensa-lx106-elf-standalone.tar.gz
+        tar xzf xtensa-lx106-elf-standalone.tar.gz
+        echo "$PWD/xtensa-lx106-elf/bin" >> "$GITHUB_PATH"
+
+    - name: Install esp-idf (xtensawin toolchain)
+      if: inputs.arch == 'xtensawin'
+      shell: bash
+      # Deliberately not `git clone --recursive`: this only ever wants the
+      # xtensa-esp32s3-elf- toolchain that install.sh downloads separately
+      # from GitHub releases, not a full esp32 port build against IDF's own
+      # components (bt/mbedtls/lwip/openthread/...) -- so nothing here
+      # touches IDF_PATH or any esp-idf header/component, and the
+      # submodule init (most of a --recursive clone's cost) buys nothing.
+      env:
+        IDF_VER: ${{ inputs.esp_idf_ver }}
+      run: |
+        git clone --depth 1 --branch "$IDF_VER" https://github.com/espressif/esp-idf.git
+        ./esp-idf/install.sh
+
+    - name: Install Python deps for mpy_ld.py
+      shell: bash
+      run: pip install pyelftools ar ${{ inputs.extra_pip }}
+
+    - name: Build mpy-cross
+      shell: bash
+      run: make -C "$MPY_DIR/mpy-cross"
+
+    - name: Build ${{ inputs.arch }}
+      shell: bash
+      working-directory: ${{ inputs.natmod_dir }}
+      # esp-idf's own venv shadows the system pip install above the moment
+      # export.sh is sourced -- mpy_ld.py then runs under *that* python, so
+      # pyelftools/ar have to be reinstalled inside this same shell right
+      # before the build, not just once earlier in the job. A real failure
+      # without it: "RuntimeError: Please run 'pip install ar' to link .a
+      # files" even though the step above already ran.
+      # pre_build_command runs via `${{ ... || ':' }}` rather than an
+      # `if [ -n ... ]; then ... fi` guard: when the input is empty, that
+      # guard's then-body would be blank text with nothing else on the
+      # line, and bash rejects an empty compound-command body at parse
+      # time ("syntax error near unexpected token `fi'") even though the
+      # condition is false and the body would never run. `:` is a real,
+      # always-present no-op command, so the line is never empty.
+      run: |
+        if [ "${{ inputs.arch }}" = "xtensawin" ]; then
+          source "$GITHUB_WORKSPACE/esp-idf/export.sh"
+          pip install pyelftools ar ${{ inputs.extra_pip }}
+        fi
+        ${{ inputs.pre_build_command || ':' }}
+        make ARCH=${{ inputs.arch }} MPY_DIR="$MPY_DIR" dist

cibuildmp-0.3.0/.github/actions/build-usermod-armv7m/action.yml

@@ -0,0 +1,98 @@
+name: Build usermod armv7m
+description: >
+  Builds a MicroPython ports/qemu "usermod" (a C module compiled straight
+  into the port via USER_C_MODULES=) into a firmware.elf for the given
+  BOARD= (default MPS2_AN385, a Cortex-M3). Installs the arm-none-eabi
+  toolchain, builds mpy-cross, then runs the port build under it.
+
+  QEMU itself is deliberately NOT installed here: it is a runtime emulator
+  for testing the resulting firmware.elf, not a build dependency -- same
+  split build-usermod-rp2040 uses for the rp2040py emulator. Callers
+  install qemu-system-arm (and whatever their own test harness needs,
+  e.g. pyserial) themselves, alongside their own run_qemu.py-equivalent.
+
+  Requires MPY_DIR to already be exported (fetch-micropython or
+  clone-micropython) and the calling repo already checked out, same
+  contract as build-usermod-unix/build-usermod-rp2040.
+
+inputs:
+  board:
+    description: Value for BOARD=. Defaults to MPS2_AN385 (Cortex-M3, no FPU).
+    required: false
+    default: MPS2_AN385
+  user_c_modules:
+    description: Value for USER_C_MODULES=. Defaults to the workspace root.
+    required: false
+    default: ''
+  frozen_manifest:
+    description: >
+      Value for FROZEN_MANIFEST=. Defaults to usermod/manifest.py under the
+      workspace root. ports/qemu ships no boards/manifest.py of its own --
+      unlike unix/rp2/esp32, there is no port default to combine with, so a
+      caller-written manifest here only ever needs to freeze its own module.
+    required: false
+    default: ''
+  extra_make_args:
+    description: >
+      Extra space-separated VAR=value pairs appended to the build command,
+      e.g. a module's own precision define.
+    required: false
+    default: ''
+  build_dir:
+    description: >
+      Value for BUILD=. Defaults to usermod/build/armv7m under the
+      workspace root. A bare relative value (no leading /) resolves against
+      $MPY_DIR/ports/qemu instead, same as make -C's own relative-path
+      handling -- pass one when the caller wants the port's own
+      board-named default (build-$(BOARD)) instead.
+    required: false
+    default: ''
+
+outputs:
+  build_dir:
+    description: >
+      The BUILD= directory actually used (resolved default included), so
+      the caller can find firmware.elf without recomputing it.
+    value: ${{ steps.vars.outputs.build_dir }}
+
+runs:
+  using: composite
+  steps:
+    - name: Resolve build settings
+      id: vars
+      shell: bash
+      run: |
+        set -e
+        BUILD="${{ inputs.build_dir }}"
+        FM="${{ inputs.frozen_manifest }}"
+        UCM="${{ inputs.user_c_modules }}"
+        {
+          echo "user_c_modules=${UCM:-$GITHUB_WORKSPACE}"
+          echo "frozen_manifest=${FM:-$GITHUB_WORKSPACE/usermod/manifest.py}"
+          echo "build_dir=${BUILD:-$GITHUB_WORKSPACE/usermod/build/armv7m}"
+        } >> "$GITHUB_OUTPUT"
+
+    - name: Install toolchain
+      shell: bash
+      # apt-get update first -- a bare apt-get install against the runner
+      # image's stale package index intermittently 404s on a mirror.
+      run: |
+        sudo apt-get update -q
+        sudo apt-get install -y --no-install-recommends \
+          gcc-arm-none-eabi libnewlib-arm-none-eabi
+
+    - name: Build mpy-cross
+      shell: bash
+      # Explicitly, before FROZEN_MANIFEST ever appears on a command line --
+      # py/mkenv.mk's auto-build rule for it races/leaks under -j. Same fix
+      # every other action here uses.
+      run: make -C "$MPY_DIR/mpy-cross" -j"$(nproc)"
+
+    - name: Build usermod (armv7m, ${{ inputs.board }})
+      shell: bash
+      run: |
+        make -C "$MPY_DIR/ports/qemu" BOARD="${{ inputs.board }}" \
+          BUILD="${{ steps.vars.outputs.build_dir }}" \
+          USER_C_MODULES="${{ steps.vars.outputs.user_c_modules }}" \
+          FROZEN_MANIFEST="${{ steps.vars.outputs.frozen_manifest }}" \
+          ${{ inputs.extra_make_args }} -j"$(nproc)"

cibuildmp-0.3.0/.github/actions/build-usermod-esp32/action.yml

@@ -0,0 +1,162 @@
+name: Build usermod esp32
+description: >
+  Builds a MicroPython ports/esp32 "usermod" (a C module compiled straight
+  into the port via USER_C_MODULES=) into a firmware.bin/micropython.bin
+  for the given BOARD= (default ESP32_GENERIC). Installs ESP-IDF, builds
+  mpy-cross, then runs the port build under it.
+
+  --recursive on the esp-idf clone, unlike a natmod build of the same
+  chip: a natmod only borrows the xtensa compiler install.sh downloads,
+  while a usermod compiles into a firmware built against IDF's own
+  components. install.sh <idf_target> limits the toolchain download to
+  the one chip family rather than every one IDF supports.
+
+  idf_target and board are deliberately separate inputs, not derived from
+  one another: install.sh's argument is the chip family (esp32, esp32s3,
+  ...), while BOARD= is the actual MicroPython board definition -- more
+  than one board can exist per chip family, so string-deriving one from
+  the other would silently break the day a second board per chip shows up.
+
+  No caching yet: every consumer's original recipe had none either, so
+  this preserves behavior exactly rather than mixing an extraction with a
+  new capability. Left as a known follow-up, not forgotten -- see this
+  repo's own README/CHANGELOG.
+
+  Requires MPY_DIR to already be exported (fetch-micropython or
+  clone-micropython) and the calling repo already checked out, same
+  contract as build-usermod-unix/build-usermod-rp2040.
+
+inputs:
+  board:
+    description: Value for BOARD=. Defaults to ESP32_GENERIC, the mainstream target.
+    required: false
+    default: ESP32_GENERIC
+  idf_target:
+    description: >
+      Chip family passed to esp-idf's install.sh (e.g. esp32, esp32s3).
+      Defaults to esp32. Kept separate from board -- see this action's own
+      header for why they must not be derived from one another.
+    required: false
+    default: esp32
+  idf_ver:
+    description: ESP-IDF version tag to clone (e.g. v5.5.1).
+    required: false
+    default: v5.5.1
+  user_c_modules:
+    description: >
+      Value for USER_C_MODULES=. Defaults to usermod/micropython.cmake
+      under the workspace root -- a *file*, like build-usermod-rp2040's own
+      user_c_modules: CMake's USER_C_MODULES takes a single .cmake entry
+      point, not a directory to glob.
+    required: false
+    default: ''
+  frozen_manifest:
+    description: Value for FROZEN_MANIFEST=. Defaults to usermod/manifest.py under the workspace root.
+    required: false
+    default: ''
+  extra_make_args:
+    description: >
+      Extra space-separated VAR=value pairs appended to the build command,
+      e.g. a module's own precision define.
+    required: false
+    default: ''
+
+outputs:
+  build_dir:
+    description: >
+      The port's own default build-$(BOARD) directory (relative to
+      $MPY_DIR/ports/esp32), so the caller can find
+      micropython.bin/firmware.bin without recomputing it. No build_dir
+      input to override this: see the "Build usermod" step's own comment
+      for why passing BUILD= at all -- not what it's set to -- breaks the
+      port's internal CMake-driven mpy-cross sub-build.
+    value: ${{ steps.vars.outputs.build_dir }}
+
+runs:
+  using: composite
+  steps:
+    - name: Resolve build settings
+      id: vars
+      shell: bash
+      run: |
+        set -e
+        FM="${{ inputs.frozen_manifest }}"
+        UCM="${{ inputs.user_c_modules }}"
+        {
+          echo "user_c_modules=${UCM:-$GITHUB_WORKSPACE/usermod/micropython.cmake}"
+          echo "frozen_manifest=${FM:-$GITHUB_WORKSPACE/usermod/manifest.py}"
+          echo "build_dir=build-${{ inputs.board }}"
+        } >> "$GITHUB_OUTPUT"
+
+    - name: Install esp-idf
+      shell: bash
+      run: |
+        git clone --depth 1 --recursive --branch "${{ inputs.idf_ver }}" \
+          https://github.com/espressif/esp-idf.git
+        ./esp-idf/install.sh "${{ inputs.idf_target }}"
+
+    - name: Build mpy-cross
+      shell: bash
+      # Before export.sh is sourced anywhere: mpy-cross is a host tool and
+      # has no business being built inside IDF's own python/toolchain
+      # environment. Explicit for the usual reason -- see build-usermod-unix's
+      # own comment on py/mkenv.mk's auto-build rule.
+      run: make -C "$MPY_DIR/mpy-cross" -j"$(nproc)"
+
+    - name: Build usermod (esp32, ${{ inputs.board }})
+      shell: bash
+      # source + make in the same step, not two: export.sh's env doesn't
+      # survive a composite action step boundary (each step is a fresh
+      # shell invocation), unlike $GITHUB_ENV-based exports.
+      # No BUILD= override, even though it would resolve to the exact same
+      # value (build-$(BOARD)) the port already defaults to: a real CI
+      # failure showed that passing it explicitly -- not what it's set to,
+      # the mere presence of BUILD= on the command line -- makes the port's
+      # own internal CMake-driven mpy-cross sub-build (build-$(BOARD)/mpy-cross,
+      # a separate copy from $MPY_DIR/mpy-cross above) pick up
+      # FROZEN_MANIFEST through MAKEFLAGS and fail with "undefined reference
+      # to mp_qstr_frozen_const_pool" -- the same symptom the explicit
+      # pre-build of $MPY_DIR/mpy-cross exists to prevent, just not reachable
+      # by that fix here since this is CMake's own separate copy, not
+      # py/mkrules.mk's auto-build rule. Every real caller wants the port's
+      # own default anyway (see build_dir's own description above), so this
+      # isn't a capability loss in practice.
+      run: |
+        source esp-idf/export.sh
+        make -C "$MPY_DIR/ports/esp32" \
+          BOARD="${{ inputs.board }}" \
+          USER_C_MODULES="${{ steps.vars.outputs.user_c_modules }}" \
+          FROZEN_MANIFEST="${{ steps.vars.outputs.frozen_manifest }}" \
+          ${{ inputs.extra_make_args }}
+
+    - name: Dump the IDF build logs on failure
+      if: failure()
+      shell: bash
+      # idf.py redirects the compiler's own stderr into
+      # build-*/log/idf_py_stderr_output_<pid> and prints only "ninja failed
+      # with exit code 1" to the console, so a failing compile leaves no
+      # diagnostic in the Actions log at all -- found on a real failure
+      # (o-murphy/micropython-wasm3's esp32 job, stopped in
+      # wasm3/source/m3_compile.c with nothing to say why). Surfaced here so
+      # every caller gets this for free, not just the one that hit it first.
+      #
+      # The log files turned out not to carry the diagnostic at all: idf.py's
+      # idf_py_stderr_output_* holds only its own bookkeeping ("Command:
+      # ninja all"), and the stdout copy of ninja's stream shows the failing
+      # target and then "ninja: build stopped" with nothing in between. So
+      # dump them for context, then get the real answer by re-running ninja
+      # verbosely in the same build directory: everything is already built
+      # except the one object that failed, so this recompiles just that and
+      # prints both the exact command line and the compiler's own output.
+      # `|| true` so this step reports rather than re-failing the job.
+      run: |
+        BUILD="${{ steps.vars.outputs.build_dir }}"
+        for f in "$BUILD"/log/idf_py_std*_output_*; do
+          [ -f "$f" ] || continue
+          echo "::group::$f"
+          tail -n 60 "$f"
+          echo "::endgroup::"
+        done
+        echo "--- re-running ninja verbosely to surface the diagnostic:"
+        source esp-idf/export.sh
+        ninja -C "$BUILD" -v -k 0 2>&1 | tail -n 120 || true

cibuildmp-0.3.0/.github/actions/build-usermod-rp2040/action.yml

@@ -0,0 +1,145 @@
+name: Build usermod rp2040
+description: >
+  Builds a MicroPython ports/rp2 "usermod" (a C module compiled straight
+  into the port via USER_C_MODULES=) into a firmware.uf2 for the given
+  BOARD=. Installs the arm-none-eabi + CMake toolchain, builds mpy-cross,
+  then runs the port build under it.
+
+  Requires MPY_DIR to already be exported (fetch-micropython -- proven
+  sufficient for this port, see below -- or clone-micropython) and the
+  calling repo already checked out, same contract as build-usermod-unix
+  and build-usermod-webassembly.
+
+  Checkout note for callers migrating off clone-micropython +
+  pico_sdk_submodules: neither is required. ports/rp2/CMakeLists.txt
+  redirects PICO_TINYUSB_PATH/PICO_LWIP_PATH/PICO_BTSTACK_PATH/
+  PICO_CYW43_DRIVER_PATH at ${MICROPY_DIR}/lib/<name> -- MicroPython's own
+  top-level submodules, which the release tarball already vendors -- not
+  at pico-sdk's own nested vendored copies, so pico-sdk's internal
+  submodule tree is never actually touched by this build. Proven green
+  first on o-murphy/micropython-wasm3's rp2 row (plain fetch-micropython,
+  no submodule handling at all), then on ballistics-lab/micropython-bclibc
+  and o-murphy/a7p after switching off their original clone-micropython +
+  explicit submodule list + pico_sdk_submodules: "true".
+
+inputs:
+  board:
+    description: Value for BOARD=. Defaults to RPI_PICO.
+    required: false
+    default: RPI_PICO
+  user_c_modules:
+    description: >
+      Value for USER_C_MODULES=. Defaults to usermod/micropython.cmake
+      under the workspace root -- unlike build-usermod-unix/
+      build-usermod-webassembly's own user_c_modules, this one is a *file*,
+      not a directory: CMake's USER_C_MODULES takes a single .cmake entry
+      point to include, not a directory to glob.
+    required: false
+    default: ''
+  frozen_manifest:
+    description: Value for FROZEN_MANIFEST=. Defaults to usermod/manifest.py under the workspace root.
+    required: false
+    default: ''
+  extra_make_args:
+    description: >
+      Extra space-separated VAR=value pairs appended to the build command,
+      e.g. a module's own precision define.
+    required: false
+    default: ''
+  extra_cmake_args:
+    description: >
+      Extra arguments for a direct `cmake -S . -B <build_dir>` reconfigure
+      step run after the port's own first configure. Left empty (the
+      default), this action runs the port build in a single make
+      invocation. Needed because ports/rp2/Makefile builds its own cmake
+      arguments with `CMAKE_ARGS +=`, so a define passed straight on the
+      make command line replaces the whole accumulated set -- including
+      MICROPY_BOARD, USER_C_MODULES and MICROPY_FROZEN_MANIFEST -- rather
+      than adding to it. o-murphy/micropython-wasm3 needs
+      -DMICROPY_C_HEAP_SIZE=131072 here: rp2 defaults that to 0, and its
+      module allocates through the port's calloc(), which fails the
+      configure outright at 0.
+    required: false
+    default: ''
+  build_dir:
+    description: >
+      Value for BUILD=. Defaults to usermod/build/rp2040 under the
+      workspace root. A bare relative value (no leading /) resolves
+      against $MPY_DIR/ports/rp2 instead, same as make -C's own
+      relative-path handling -- pass one when the caller wants the port's
+      own board-named default (e.g. build-RPI_PICO) instead.
+    required: false
+    default: ''
+
+outputs:
+  build_dir:
+    description: >
+      The BUILD= directory actually used (resolved default included), so
+      the caller can find firmware.uf2 without recomputing it.
+    value: ${{ steps.vars.outputs.build_dir }}
+
+runs:
+  using: composite
+  steps:
+    - name: Resolve build settings
+      id: vars
+      shell: bash
+      run: |
+        set -e
+        BUILD="${{ inputs.build_dir }}"
+        FM="${{ inputs.frozen_manifest }}"
+        UCM="${{ inputs.user_c_modules }}"
+        {
+          echo "user_c_modules=${UCM:-$GITHUB_WORKSPACE/usermod/micropython.cmake}"
+          echo "frozen_manifest=${FM:-$GITHUB_WORKSPACE/usermod/manifest.py}"
+          echo "build_dir=${BUILD:-$GITHUB_WORKSPACE/usermod/build/rp2040}"
+        } >> "$GITHUB_OUTPUT"
+
+    - name: Install toolchain
+      shell: bash
+      # apt-get update first -- a bare apt-get install against the runner
+      # image's stale package index intermittently 404s on a mirror.
+      #
+      # libstdc++-arm-none-eabi-newlib: pico-sdk compiles one .cpp of its
+      # own, which fails with "cstdlib: No such file or directory" without
+      # it (a real CI failure on o-murphy/micropython-wasm3's rp2 row) --
+      # included here even though not every caller's build happens to
+      # exercise that file, since whether it does depends on pico-sdk
+      # internals no caller should have to know.
+      run: |
+        sudo apt-get update -q
+        sudo apt-get install -y \
+          cmake \
+          gcc-arm-none-eabi \
+          libnewlib-arm-none-eabi \
+          libstdc++-arm-none-eabi-newlib \
+          python3
+
+    - name: Build mpy-cross
+      shell: bash
+      # Explicitly, before FROZEN_MANIFEST ever appears on a command line --
+      # py/mkenv.mk's auto-build rule for mpy-cross resets USER_C_MODULES=
+      # for that recursive make but not FROZEN_MANIFEST=, which leaks
+      # through MAKEFLAGS and fails the sub-build. Same fix as
+      # build-usermod-unix/build-usermod-webassembly.
+      run: make -C "$MPY_DIR/mpy-cross"
+
+    - name: Build usermod (rp2040, ${{ inputs.board }})
+      shell: bash
+      # cd, not make -C: the extra_cmake_args branch below needs `cmake -S
+      # . -B $BUILD` to run from inside ports/rp2, same as
+      # o-murphy/micropython-wasm3's own recipe this was extracted from.
+      run: |
+        cd "$MPY_DIR/ports/rp2"
+        if [ -n "${{ inputs.extra_cmake_args }}" ]; then
+          make BOARD="${{ inputs.board }}" \
+            BUILD="${{ steps.vars.outputs.build_dir }}" \
+            USER_C_MODULES="${{ steps.vars.outputs.user_c_modules }}" \
+            FROZEN_MANIFEST="${{ steps.vars.outputs.frozen_manifest }}" || true
+          cmake -S . -B "${{ steps.vars.outputs.build_dir }}" ${{ inputs.extra_cmake_args }}
+        fi
+        make BOARD="${{ inputs.board }}" \
+          BUILD="${{ steps.vars.outputs.build_dir }}" \
+          USER_C_MODULES="${{ steps.vars.outputs.user_c_modules }}" \
+          FROZEN_MANIFEST="${{ steps.vars.outputs.frozen_manifest }}" \
+          ${{ inputs.extra_make_args }} -j"$(nproc)"