cibuildmp 0.4.1__tar.gz → 0.4.2__tar.gz

{cibuildmp-0.4.1 → cibuildmp-0.4.2}/.github/workflows/test-all-platforms.yml

@@ -23,11 +23,16 @@ name: Test platforms
 # first place -- not upload order, not sorted (docs/records/0065).
 
 on:
-  pull_request:
-    paths-ignore:
-      - "**.md"
-      - "docs/**"
-      - "LICENSE"
+  # No `pull_request` any more: the full real matrix (200+ identifiers,
+  # bucketed across up to 20 concurrent jobs) takes far too long to run on
+  # every PR for how rarely its answer actually changes -- `push`/`pull_request`
+  # CI already runs `tests.yml`'s own unit suite and `build-examples.yml`'s
+  # narrower matrix on every change; this file is for the full sweep,
+  # wanted only occasionally, not gating every PR's own turnaround time.
+  # Weekly by default -- change the cron below, or just run
+  # `workflow_dispatch` by hand whenever a real answer is wanted sooner.
+  schedule:
+    - cron: "0 3 * * 0"
   workflow_dispatch:
     inputs:
       build:
@@ -50,15 +55,12 @@ concurrency:
 
 jobs:
   plan:
-    # A Dependabot PR only ever touches `.github/dependabot.yml` itself or
-    # a `docker/*.Dockerfile` -- a base-image bump, which
-    # `verify-docker-images.yml` already build-checks directly. Running
-    # this file's own 200+-identifier functional matrix on every one of
-    # those (paths-ignore below only excludes **.md/docs/**/LICENSE, not
-    # docker/**) burns the same concurrent-job budget this file's own
-    # header comment already flags as the real ceiling, for a change this
-    # matrix has nothing useful to say about. See docs/records/0068.
-    if: github.actor != 'dependabot[bot]'
+    # No `if: github.actor != 'dependabot[bot]'` guard here any more --
+    # record 0068 added it specifically for the `pull_request` trigger a
+    # Dependabot docker/dependabot.yml PR would otherwise fire this on;
+    # dropping that trigger entirely (this file's own header comment) makes
+    # the guard moot, not just redundant, since `schedule`/`workflow_dispatch`
+    # never runs as that actor in the first place.
     runs-on: ubuntu-latest
     outputs:
       identifiers: ${{ steps.plan.outputs.identifiers }}
@@ -124,10 +126,11 @@ jobs:
   # passed back through `build`'s own outputs.
   aggregate-results:
     needs: [plan, build]
-    # `always()` alone would still run this after `plan`'s own actor guard
-    # skips it, with nothing to aggregate -- same guard, so a skipped plan
-    # means a skipped aggregate too, not a report over zero buckets.
-    if: always() && github.actor != 'dependabot[bot]'
+    # `always()`: render a summary even if a bucket in `build` failed --
+    # `test-platforms.yml`'s own `--keep-going` (record 0063) means a real
+    # failure there still uploads a report, and this is what turns every
+    # bucket's own report into the one table worth looking at.
+    if: always()
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7

cibuildmp-0.4.2/.github/workflows/test-upstream-natmod.yml

@@ -0,0 +1,131 @@
+name: Test upstream natmod
+
+# Builds every one of MicroPython's own eleven `examples/natmod/*` modules
+# through cibuildmp's real natmod path -- docs/records/0055 scoped why this
+# fixture matters (it tests upstream's own natmod contract, not the one this
+# project wrote for itself in `examples/template/natmod`) and found that
+# contract does not fit unmodified; docs/records/0072 is the mechanism
+# actually landed here and explains every choice below in full.
+#
+# build-features0: one job, deliberately building *two* arches for the same
+# tag in a single invocation, not two separate single-arch jobs: [0055]'s own
+# guard survey is entirely about what happens when cibuildmp builds several
+# targets back to back in one checkout (a stale artifact, or an unscoped
+# `build/`, silently carrying the *previous* target's binary into the next
+# one's output) -- a job that only ever builds one target at a time would
+# never actually exercise that risk. `verify_output()` (build.py, already
+# part of every real build) is the check that would catch it: a wrong arch
+# code in the .mpy header fails the build outright rather than shipping
+# silently wrong -- but `examples/natmod/cibuildmp.toml`'s own
+# `pre-build-command` (record 0072) removes the possibility structurally,
+# for this same reason armv7emsp is a second *real* cross-compiled arch here
+# and not just a second easy one: it shares this checkout and this same
+# invocation with x64, the one thing a single-arch job can never test.
+#
+# build-upstream-natmod: the other ten modules, one `x64` build each (no
+# arch-collision risk to re-prove per module -- that mechanism is
+# `examples/natmod/cibuildmp.toml`'s own, verified once above, not a
+# property of any one module's Makefile). `CIBMP_MODULE_DIR` overrides that
+# file's own `features0` default per matrix entry -- `{micropython}` resolves
+# the same way regardless of which layer supplied `module-dir` (record 0072).
+# `btree` needs no `micropython-submodules` entry for its own
+# `lib/berkeley-db-1.xx`: `sources.fetch_micropython()` prefers the release
+# tarball, which already vendors every `lib/` submodule -- confirmed 2026-08-31
+# against a real, tarball-fetched v1.29.0 checkout, on the bare host (no
+# Docker in that session), building and `verify_output()`-checking all eleven
+# modules for `x64` -- not assumed from [0055]'s own original, narrower
+# "needs a submodule" citation (see docs/records/0072's own addendum).
+#
+# `examples/natmod/cibuildmp.toml` carries the whole mechanism otherwise --
+# `make-target = "all"` (upstream's examples define no `dist` target at all)
+# and its own `pre-build-command` clearing every `.mpy` plus the whole build
+# tree before *every single* build. No job here sets either directly -- a
+# bare `cibuildmp examples/natmod --build <identifier>` run, CI or local,
+# resolves identically to what a job here does (module-dir aside, for the
+# ten `CIBMP_MODULE_DIR`-overridden ones).
+#
+# No `docker/setup-qemu-action` needed anywhere here, unlike
+# test-upstream-usermodule.yml's rp2/esp32/qemu legs: `dockerrun.platform_for()`
+# resolves every non-`unix` port -- natmod included -- to a flat
+# `linux/amd64`, confirmed directly against that function's own source, so
+# every natmod image already runs native on a `ubuntu-latest` runner
+# regardless of which arch's toolchain it carries.
+#
+# push: (no branches: filter), same reasoning build-examples.yml's own header
+# already documents -- this needs to run on every push to a dev branch too.
+
+on:
+  push:
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "docs/**"
+      - "LICENSE"
+  workflow_dispatch:
+
+concurrency:
+  group: test-upstream-natmod-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # Single source of truth for this job -- bump here, not by hand in the
+  # `build` line below, when this fixture moves to a newer tag. `mpy6.3`
+  # is that tag's own natmod ABI (`identifier_format = "mpy{mpy}-{tag}-
+  # {arch}"`, resources/build-platforms.toml), not an independent value --
+  # a tag bump that also changes ABI needs this updated too.
+  CIBMP_UPSTREAM_ABI_TAG: mpy6.3-v1.29.0
+
+jobs:
+  # x64: a plain native arch, no cross-compiler at all (`images.x64 =
+  # "natmod_host"`) -- the cheapest possible leg.
+  #
+  # armv7emsp: a real cross-compiled arch (`arm-none-eabi-`, `images.
+  # armv7emsp = "arm_embedded"`) sharing this same checkout and this same
+  # `cibuildmp` invocation with x64 above -- the leg that actually exercises
+  # [0055]'s own finding, not just a second easy arch for breadth's sake.
+  build-features0:
+    runs-on: ubuntu-latest
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build upstream examples/natmod/features0 (x64 + armv7emsp)
+        uses: ./
+        with:
+          package-dir: examples/natmod
+          build: "${{ env.CIBMP_UPSTREAM_ABI_TAG }}-x64 ${{ env.CIBMP_UPSTREAM_ABI_TAG }}-armv7emsp"
+
+      - name: List built artifacts
+        run: ls -laR examples/natmod/mpyhouse
+
+  build-upstream-natmod:
+    strategy:
+      fail-fast: false
+      matrix:
+        module:
+          - features1
+          - features2
+          - features3
+          - features4
+          - heapq
+          - random
+          - re
+          - deflate
+          - framebuf
+          - btree
+    runs-on: ubuntu-latest
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+      CIBMP_MODULE_DIR: "{micropython}/examples/natmod/${{ matrix.module }}"
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build upstream examples/natmod/${{ matrix.module }} (x64)
+        uses: ./
+        with:
+          package-dir: examples/natmod
+          build: "${{ env.CIBMP_UPSTREAM_ABI_TAG }}-x64"
+
+      - name: List built artifacts
+        run: ls -laR examples/natmod/mpyhouse

cibuildmp-0.4.2/.github/workflows/test-upstream-usermodule.yml

@@ -0,0 +1,241 @@
+name: Test upstream usercmodule
+
+# Builds MicroPython's own `examples/usercmodule/` (cexample, cppexample,
+# subpackage) through cibuildmp's real usermod path -- docs/records/0054
+# scoped why this fixture matters (it tests upstream's own module contract,
+# not one this project wrote for itself); docs/records/0069 is the mechanism
+# actually landed here and explains every choice below in full.
+#
+# Six jobs, one per port cibuildmp drives a usermod build for -- widened
+# from the original narrow unix+rp2 slice ([0054]'s own "one Make port and
+# one CMake port is enough to answer the three questions above") once that
+# slice came back green, per [0054]'s own "widen only if it finds
+# something." Still nowhere near build-examples.yml's much broader
+# examples/template matrix: one representative identifier per port, not
+# each port's own full arch/board matrix.
+#
+# No job here sets `CIBMP_USER_C_MODULES`/`CIBMP_EXTRA_MAKE_ARGS`/
+# `CIBMP_EXTRA_CMAKE_ARGS`, and none of them ever resolves the pinned
+# checkout itself. Both used to be true: every job called
+# `sources.fetch_micropython()` directly, in its own pre-fetch step, then
+# exported the real checkout path by hand -- necessary back when this
+# project had no way to name "a path inside whatever checkout cibuildmp
+# itself is about to fetch" from outside cibuildmp, and no way to say "this
+# one identifier needs this one extra flag" from inside a config file
+# meant to be shared by all six. `examples/usercmodule/cibuildmp.toml` now
+# carries all of it -- no `user-c-modules =` at all any more, for any
+# port: the built-in "." default is already right on both sides once
+# each side has its own real entry point (`micropython.cmake` for the two
+# CMake ports, `{cexample,cppexample,subpackage}/micropython.mk` for the
+# four Make ports -- see that toml's own header comment), plus
+# `[override."*-wasm32"]`'s own `extra-make-args` -- so a bare
+# `cibuildmp examples/usercmodule --build <identifier>` run, CI or local,
+# resolves identically to what a job here does. `build` stays out of that
+# file on purpose (see its own header comment): each job below still wants
+# exactly one identifier per push, not this fixture's full six-port sweep,
+# and that is the one thing a shared config file cannot express per-job.
+#
+# An even leaner shape was tried before any of this and reverted: pin
+# `CIBMP_CACHE_PATH` to a fixed, known directory so the checkout's
+# eventual path becomes computable without fetching it at all. That broke
+# the workflow file outright, twice, for a GitHub Actions job-level-`env:`
+# scoping rule this session could not conclusively pin down live -- see
+# docs/records/0069 for the full account, kept for whoever revisits it
+# rather than guessed away.
+#
+# push: (no branches: filter), same reasoning build-examples.yml's own header
+# already documents -- this needs to run on every push to a dev branch too.
+
+on:
+  push:
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "docs/**"
+      - "LICENSE"
+  workflow_dispatch:
+
+concurrency:
+  group: test-upstream-usermodule-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # Single source of truth for every job below -- bump here, not six
+  # times, when this fixture moves to a newer tag.
+  CIBMP_UPSTREAM_TAG: v1.29.0
+
+jobs:
+  # ── unix: the Make side ─────────────────────────────────────────────
+  #
+  # py/py.mk's own `<USER_C_MODULES>/*/micropython.mk` glob finds
+  # `examples/usercmodule/{cexample,cppexample,subpackage}/micropython.mk`
+  # -- this fixture's own thin wrappers, each `include`ing upstream's real
+  # file via `$(TOP)` (see `cexample/micropython.mk`'s own header comment)
+  # -- with `user-c-modules` at its built-in "." default, no override
+  # needed. Never vendored (0054): the real content still comes from the
+  # pinned checkout, only three one-line `include` shims live in this repo.
+  build-unix:
+    runs-on: ubuntu-latest
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build upstream examples/usercmodule (unix, native)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-manylinux_2_28_x86_64
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse
+
+      # A linked binary is not the same claim as one whose modules actually
+      # run -- unix is the one port here whose own output this runner can
+      # simply execute (a real manylinux_2_28 binary runs unmodified on a
+      # newer-glibc host, the whole point of the manylinux floor), unlike
+      # rp2's own firmware.uf2, which needs real hardware. See
+      # smoke_test.py's own header for what it actually exercises.
+      - name: "Smoke test (unix): run the built binary against smoke_test.py"
+        run: |
+          set -euo pipefail
+          identifier="${CIBMP_UPSTREAM_TAG}-manylinux_2_28_x86_64"
+          bin="examples/usercmodule/mpyhouse/${identifier}/micropython-${identifier}"
+          "$bin" examples/usercmodule/smoke_test.py
+
+  # ── rp2: the CMake side ──────────────────────────────────────────────
+  #
+  # Chosen over esp32 purely on cost -- usermod/build_rp2.py's own docstring:
+  # the Pico SDK arrives as `lib/` submodules of the MicroPython checkout
+  # itself, no separate host-side toolchain resolver the way esp32's
+  # ESP-IDF needs. Nothing here is rp2-specific; widening to esp32/windows/
+  # webassembly/qemu is exactly [0054]'s own "widen only if it finds
+  # something" (docs/records/0069).
+  #
+  # This is also the leg that actually answers [0054]'s biggest open
+  # question for one real toolchain: whether cppexample's `-lstdc++` is
+  # satisfiable on a bare-metal cross target. Deliberately not skipped --
+  # a red leg here is a real finding to record, not a bug in this workflow.
+  #
+  # examples/usercmodule/micropython.cmake resolves the pinned checkout
+  # itself, via MICROPY_DIR -- a CMake variable every CMake port already
+  # sets before it ever include()s a user module (rp2/CMakeLists.txt's own
+  # `get_filename_component(MICROPY_DIR "../.." ABSOLUTE)`, well before its
+  # own `include(${MICROPY_DIR}/py/usermod.cmake)`) -- with `user-c-modules`
+  # at its built-in "." default, same as every other port here now.
+  build-rp2:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+      - uses: docker/setup-qemu-action@v4
+
+      - name: Build upstream examples/usercmodule (rp2)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-rp2-RPI_PICO
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse
+
+  # ── esp32: the second CMake port, and the second bare-metal toolchain ──
+  #
+  # [0054]'s own list of unanswered families after [0069]: esp32 is the
+  # ESP-IDF one -- a cmake-driven port like rp2, but a materially different
+  # toolchain (Xtensa/RISC-V via idf.py, not arm-none-eabi via the Pico
+  # SDK). Fully containerized since [0028] (no host-side ESP-IDF resolver
+  # left).
+  #
+  # Same MICROPY_DIR mechanism as build-rp2 above: MICROPY_DIR is set at
+  # the very top of ports/esp32/main/CMakeLists.txt
+  # (`if(NOT MICROPY_DIR) get_filename_component(...)`), well before it --
+  # via ports/esp32/CMakeLists.txt -- reaches `include(${MICROPY_DIR}/py/
+  # usermod.cmake)`.
+  build-esp32:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+      - uses: docker/setup-qemu-action@v4
+
+      - name: Build upstream examples/usercmodule (esp32)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-esp32-ESP32_GENERIC
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse
+
+  # ── windows, webassembly, qemu: the remaining three Make ports ──────────
+  #
+  # Same mechanism as build-unix above (the same three wrapper files,
+  # already discovered by py.mk's own glob), one representative identifier
+  # per port rather than each port's own full arch matrix -- [0054]'s own
+  # "widen only if it finds something", not a cost-blind repeat of
+  # build-examples.yml's broader coverage. No smoke test for any of the
+  # three: none of their outputs (a .exe, a .wasm, a qemu ELF) runs
+  # directly on this runner the way unix's manylinux binary does (record
+  # 0069's own reasoning for why rp2 has none either).
+  build-windows:
+    runs-on: ubuntu-latest
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build upstream examples/usercmodule (windows)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-win_amd64
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse
+
+  # `examples/usercmodule/cibuildmp.toml`'s own `[override."*-wasm32"]`
+  # carries this identifier's own `extra-make-args` (CXX=em++ plus the
+  # CXXFLAGS_MOD fix for two real, separate upstream ports/webassembly/
+  # Makefile bugs -- see that file's own comment for both). Nothing
+  # webassembly-specific is set here any more.
+  build-webassembly:
+    runs-on: ubuntu-latest
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Build upstream examples/usercmodule (webassembly)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-wasm32
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse
+
+  build-qemu:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      CIBMP_VERSION: 0.0.0-ci
+    steps:
+      - uses: actions/checkout@v7
+      - uses: docker/setup-qemu-action@v4
+
+      - name: Build upstream examples/usercmodule (qemu)
+        uses: ./
+        with:
+          package-dir: examples/usercmodule
+          build: ${{ env.CIBMP_UPSTREAM_TAG }}-qemu-MPS2_AN385
+
+      - name: List built artifacts
+        run: ls -laR examples/usercmodule/mpyhouse

{cibuildmp-0.4.1 → cibuildmp-0.4.2}/CHANGELOG.md

@@ -7,6 +7,69 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.2] - 2026-08-31
+
+### Added
+
+- **`{micropython}` — a placeholder in `user-c-modules` for a path inside the pinned
+  MicroPython checkout**, substituted with the real, already-fetched `mpy_dir` before any
+  Docker/mount step, uniformly for every usermod port. Closes the gap [0069] named and
+  deliberately left open ("no `{checkout}`-style template today"). Record 0071.
+- **The same `{micropython}` placeholder, and a real upstream-`examples/natmod` CI slice
+  covering all eleven upstream modules, for natmod.** `module-dir` can now name a path
+  inside the pinned checkout directly (`{micropython}/examples/natmod/<module>`), and
+  `collect_output()` gained a fallback for `py/dynruntime.mk`'s own `all` target, which —
+  unlike this project's own `dist` convention — leaves the merged `.mpy` sitting in
+  module-dir itself rather than under `build/<arch>*/`. `test-upstream-natmod.yml` builds
+  `features0` for two real arches (`x64`, `armv7emsp`) in one invocation — the multi-target
+  collision scenario record 0055's own guard survey was about — plus the other ten modules
+  (`features1`-`4`, `btree`, `deflate`, `framebuf`, `heapq`, `random`, `re`) each for `x64`.
+  Closes record 0055: neither of the two risks its own survey flagged (`btree`'s git
+  submodule, an rv32imc arch-flags collision) turned out to be a real blocker. Record 0072.
+- **The `[0054]`/`[0069]` upstream-`examples/usercmodule` fixture now covers all six usermod
+  ports**, not just `unix`/`rp2`: `esp32`, `windows`, `webassembly` and `qemu` all build
+  `cppexample`/`cexample`/`subpackage` in CI now too. `examples/usercmodule/cibuildmp.toml`
+  carries the whole thing — a `[override."*-manylinux* *-win* *-qemu-* *-wasm32"]` pointing
+  the four Make ports' `user-c-modules` straight at `{micropython}/examples/usercmodule`
+  (no vendoring, no wrapper file), the two CMake ports (`rp2`/`esp32`) reading `MICROPY_DIR`
+  directly inside `examples/usercmodule/micropython.cmake`. No job in
+  `test-upstream-usermodule.yml` resolves the checkout itself or sets
+  `CIBMP_USER_C_MODULES`/`CIBMP_EXTRA_MAKE_ARGS`/`CIBMP_EXTRA_CMAKE_ARGS` any more — a bare
+  `cibuildmp examples/usercmodule --build <identifier>` run, CI or local, now resolves
+  identically to what a job here does.
+
+### Changed
+
+- **`test-all-platforms.yml` no longer runs on `pull_request`** — the full real matrix
+  (200+ identifiers, bucketed across up to 20 concurrent jobs) took too long to gate every
+  PR's own turnaround time for how rarely its answer actually changes. Now `schedule`
+  (weekly) plus `workflow_dispatch` for an on-demand run; `push`/`pull_request` CI still
+  covers every change through `tests.yml`'s unit suite and `build-examples.yml`'s narrower
+  matrix. The `if: github.actor != 'dependabot[bot]'` guard record 0068 added specifically
+  for the now-gone `pull_request` trigger came out too, moot rather than just redundant.
+
+### Fixed
+
+- **`docker/windows.Dockerfile` installed only the C mingw-w64 cross-compilers
+  (`gcc-mingw-w64-*`), never the C++ ones (`g++-mingw-w64-*`)** — mingw-w64 fully supports
+  C++, this was a real gap in the image, not a port limitation. A C++ user module on
+  `windows` failed with "cannot execute `cc1plus`" (the C++ compiler backend didn't exist
+  at all) until this fixed it; republished, repinned in `pinned_docker_images.toml`.
+- **`ports/webassembly/Makefile` never overrides `CXX` from its own default (`g++`, the
+  host's real compiler), only `CC`/`LD` (to `emcc`)** — a C++ user module's real `.cpp`
+  compile was silently running through the wrong compiler entirely (confirmed live: the
+  failure's own `cc1plus` and "unrecognized command-line option" for a clang-only flag name
+  are exactly what a host `g++` invocation looks like, not `emcc`'s). Worked around through
+  `extra-make-args` (`CXX=em++`, emsdk's own C++ driver, already baked into the image) —
+  an upstream Makefile bug this project can reach without vendoring upstream's own file.
+- **Upstream's own `ports/webassembly/mpconfigport.h` unconditionally `#define _GNU_SOURCE`,
+  conflicting with emcc/clang's own built-in definition in C++ mode** (`-std=c++11`),
+  tripping `-Werror -Wmacro-redefined` once the `CXX` fix above let the right compiler run
+  at all. Reached through `py/mkrules.mk`'s own `CXXFLAGS_MOD` hook ("Add default C++
+  compiler flags based on CFLAGS. For use with C++ user modules" — that comment's own
+  words), via `extra-make-args`, with nothing to clobber (unlike [0066]'s own
+  `CMAKE_ARGS`/`IDFPY_FLAGS` trap): nothing in the tree ever assigns `CXXFLAGS_MOD` first.
+
 ## [0.4.1] - 2026-08-30
 
 ### Added
@@ -640,7 +703,8 @@ ballistics-lab/micropython-native-ci, but both tags exist here too, so every
 link resolves inside this repository -- the version line continues rather
 than restarting (see the 0.3.0a1 entry). -->
 
-[Unreleased]: https://github.com/ballistics-lab/cibuildmp/compare/v0.4.1...HEAD
+[Unreleased]: https://github.com/ballistics-lab/cibuildmp/compare/v0.4.2...HEAD
+[0.4.2]: https://github.com/ballistics-lab/cibuildmp/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/ballistics-lab/cibuildmp/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/ballistics-lab/cibuildmp/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/ballistics-lab/cibuildmp/compare/v0.3.0a1...v0.3.0

{cibuildmp-0.4.1/src/cibuildmp.egg-info → cibuildmp-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cibuildmp
-Version: 0.4.1
+Version: 0.4.2
 Summary: Build MicroPython native C extensions for every target, from one config — cibuildwheel for MicroPython
 Author-email: o-murphy <thehelixpg@gmail.com>
 License-Expression: MIT
@@ -110,7 +110,7 @@ On CI, use the action instead of installing the CLI yourself — it already
 runs on a bare runner with the runner's own Docker daemon reachable:
 
 ```yaml
-- uses: ballistics-lab/cibuildmp@v0.4.0
+- uses: ballistics-lab/cibuildmp@v0.4.1
   with:
     build: "mpy6.3-* v1.29.0-manylinux_2_28_x86_64"
 ```
@@ -324,8 +324,9 @@ executable bit intact (`unix`: one native image per arch/libc;
 `v1.29.0-qemu-MPS2_AN385` runs in its own matrix leg rather than sharing a
 job with already-proven cells, since it was the first build ever run
 through that path). `esp32` and `rp2` are not in that smoke test, but not
-because either is unproven -- both are exercised far more broadly, on
-every pull request, through `test-all-platforms.yml`'s own real matrix
+because either is unproven -- both are exercised far more broadly, on a
+weekly schedule (or manual dispatch any time sooner), through
+`test-all-platforms.yml`'s own real matrix
 (`bin/plan_test_matrix.py`, record 0065): 83 real `esp32` identifiers and
 74 real `rp2` ones, every board/tag row `resources/build-platforms.toml`
 carries, not a spot check. **Both build through the exact same `cibuildmp`
@@ -336,7 +337,7 @@ provisioned onto the bare host; record 0028 moved it fully into
 depends on that composite action's own toolchain-install path. `rp2`'s
 own driver landed the next day (record 0060), live-verified against
 `examples/template` first and now carrying its own share of every
-`test-all-platforms.yml` run since.
+scheduled `test-all-platforms.yml` run since.
 
 <table>
 <thead>
@@ -540,7 +541,7 @@ own driver landed the next day (record 0060), live-verified against
 
 [^cross]: The one target that still cross-compiles: pypa publishes no mipsel image and there's no Docker official image for 32-bit mipsel, so there's nothing to be native to.
 
-[^emulatedci]: `ppc64le`/`s390x`/`riscv64`, both libcs — native to no runner GitHub offers, so still QEMU-emulated, but no longer untested: `test-all-platforms.yml`'s own `unix-emulated` entry gives all six a real `test-emulated` CI leg on every push now (nine of the twelve (cell, tag) pairs green; the other three are the two ⚠️ rows below). Point `CIBMP_UNIX_<TARGET>_DOCKER_IMAGE` at a locally-built image, or an emulated one, to work on one of these locally. Record 0044's own 2026-08-29 addendum.
+[^emulatedci]: `ppc64le`/`s390x`/`riscv64`, both libcs — native to no runner GitHub offers, so still QEMU-emulated, but no longer untested: `test-all-platforms.yml`'s own `unix-emulated` entry gives all six a real `test-emulated` CI leg on its weekly schedule (or manual dispatch) now (nine of the twelve (cell, tag) pairs green; the other three are the two ⚠️ rows below). Point `CIBMP_UNIX_<TARGET>_DOCKER_IMAGE` at a locally-built image, or an emulated one, to work on one of these locally. Record 0044's own 2026-08-29 addendum.
 
 [^s390xclobbered]: `v1.28.0` only — `v1.29.0` of the identical cell is the ✅ above it. `mpy-cross`'s own `main.c` fails a real GCC `-Werror=clobbered` diagnostic specific to s390x's own register allocation around a `longjmp` call site (`parse_integer()`'s locals); `v1.29.0`'s `main.c` does not trip it. Skipped by exact identifier (`v1.28.0-manylinux_2_28_s390x`) in `test-all-platforms.yml` until fixed — not a QEMU/emulation problem, a real compile-time diagnostic. Record 0044's own 2026-08-29 addendum.
 
@@ -615,7 +616,7 @@ drivers are wired into the CLI too (see [Target support](#target-support)
 above), covering every port with a real driver, not just three. All three
 consuming repos have repinned and are fully migrated off every
 `build-usermod-*`/`fetch-micropython` composite action onto the unified
-CLI/action, `cibuildmp@v0.4.0`, CI green on each repo's current `main` (`a7p`
+CLI/action, `cibuildmp@v0.4.1`, CI green on each repo's current `main` (`a7p`
 and `micropython-wasm3` each keep their own genuine
 cross-compile-with-no-native-host cell, `unix-mipsel`, on the old composite
 action deliberately). See the tracker's own [0038] row for current status

{cibuildmp-0.4.1 → cibuildmp-0.4.2}/README.md

@@ -78,7 +78,7 @@ On CI, use the action instead of installing the CLI yourself — it already
 runs on a bare runner with the runner's own Docker daemon reachable:
 
 ```yaml
-- uses: ballistics-lab/cibuildmp@v0.4.0
+- uses: ballistics-lab/cibuildmp@v0.4.1
   with:
     build: "mpy6.3-* v1.29.0-manylinux_2_28_x86_64"
 ```
@@ -292,8 +292,9 @@ executable bit intact (`unix`: one native image per arch/libc;
 `v1.29.0-qemu-MPS2_AN385` runs in its own matrix leg rather than sharing a
 job with already-proven cells, since it was the first build ever run
 through that path). `esp32` and `rp2` are not in that smoke test, but not
-because either is unproven -- both are exercised far more broadly, on
-every pull request, through `test-all-platforms.yml`'s own real matrix
+because either is unproven -- both are exercised far more broadly, on a
+weekly schedule (or manual dispatch any time sooner), through
+`test-all-platforms.yml`'s own real matrix
 (`bin/plan_test_matrix.py`, record 0065): 83 real `esp32` identifiers and
 74 real `rp2` ones, every board/tag row `resources/build-platforms.toml`
 carries, not a spot check. **Both build through the exact same `cibuildmp`
@@ -304,7 +305,7 @@ provisioned onto the bare host; record 0028 moved it fully into
 depends on that composite action's own toolchain-install path. `rp2`'s
 own driver landed the next day (record 0060), live-verified against
 `examples/template` first and now carrying its own share of every
-`test-all-platforms.yml` run since.
+scheduled `test-all-platforms.yml` run since.
 
 <table>
 <thead>
@@ -508,7 +509,7 @@ own driver landed the next day (record 0060), live-verified against
 
 [^cross]: The one target that still cross-compiles: pypa publishes no mipsel image and there's no Docker official image for 32-bit mipsel, so there's nothing to be native to.
 
-[^emulatedci]: `ppc64le`/`s390x`/`riscv64`, both libcs — native to no runner GitHub offers, so still QEMU-emulated, but no longer untested: `test-all-platforms.yml`'s own `unix-emulated` entry gives all six a real `test-emulated` CI leg on every push now (nine of the twelve (cell, tag) pairs green; the other three are the two ⚠️ rows below). Point `CIBMP_UNIX_<TARGET>_DOCKER_IMAGE` at a locally-built image, or an emulated one, to work on one of these locally. Record 0044's own 2026-08-29 addendum.
+[^emulatedci]: `ppc64le`/`s390x`/`riscv64`, both libcs — native to no runner GitHub offers, so still QEMU-emulated, but no longer untested: `test-all-platforms.yml`'s own `unix-emulated` entry gives all six a real `test-emulated` CI leg on its weekly schedule (or manual dispatch) now (nine of the twelve (cell, tag) pairs green; the other three are the two ⚠️ rows below). Point `CIBMP_UNIX_<TARGET>_DOCKER_IMAGE` at a locally-built image, or an emulated one, to work on one of these locally. Record 0044's own 2026-08-29 addendum.
 
 [^s390xclobbered]: `v1.28.0` only — `v1.29.0` of the identical cell is the ✅ above it. `mpy-cross`'s own `main.c` fails a real GCC `-Werror=clobbered` diagnostic specific to s390x's own register allocation around a `longjmp` call site (`parse_integer()`'s locals); `v1.29.0`'s `main.c` does not trip it. Skipped by exact identifier (`v1.28.0-manylinux_2_28_s390x`) in `test-all-platforms.yml` until fixed — not a QEMU/emulation problem, a real compile-time diagnostic. Record 0044's own 2026-08-29 addendum.
 
@@ -583,7 +584,7 @@ drivers are wired into the CLI too (see [Target support](#target-support)
 above), covering every port with a real driver, not just three. All three
 consuming repos have repinned and are fully migrated off every
 `build-usermod-*`/`fetch-micropython` composite action onto the unified
-CLI/action, `cibuildmp@v0.4.0`, CI green on each repo's current `main` (`a7p`
+CLI/action, `cibuildmp@v0.4.1`, CI green on each repo's current `main` (`a7p`
 and `micropython-wasm3` each keep their own genuine
 cross-compile-with-no-native-host cell, `unix-mipsel`, on the old composite
 action deliberately). See the tracker's own [0038] row for current status

{cibuildmp-0.4.1 → cibuildmp-0.4.2}/docker/windows.Dockerfile

@@ -88,6 +88,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     xz-utils \
     gcc-mingw-w64-x86-64 \
     gcc-mingw-w64-i686 \
+    g++-mingw-w64-x86-64 \
+    g++-mingw-w64-i686 \
     && rm -rf /var/lib/apt/lists/*
 
 # Pinned to resources/usermod.toml's own [llvm-mingw] table (version