feat(0.0.50): macOS min-version support — static LLVM libc++ + explicit deployment target

Released macosx-arm64 binaries carried LC_BUILD_VERSION minos=15.0 and
dynamically linked the SYSTEM /usr/lib/libc++.1.dylib, so they only ran
on macOS 15: dyld refuses older minos, and lowering minos alone dies at
launch on macOS 14 with a missing libc++ symbol
(__ZNSt3__119__is_posix_terminalEP7__sFILE — std::print support added in
LLVM-18-era libc++; verified on macos-14 CI).

- flags.cppm: implement staticStdlib (the manifest default, previously
  silently ignored on the clang route) for the macOS link path — link
  LLVM's own libc++.a/libc++abi.a via -nostdlib++ instead of -lc++,
  falling back to -lc++ when the archives are absent. Mirror
  MACOSX_DEPLOYMENT_TARGET onto compile and link command lines so ninja
  commands don't depend on env propagation.
- cli.cppm: fold MACOSX_DEPLOYMENT_TARGET into the BMI fingerprint —
  the deployment target changes the effective compile triple
  (arm64-apple-macosxNN), and a std.pcm built for one target cannot be
  loaded by a TU compiled for another (config-mismatch observed on CI).
- main.cpp: __APPLE__ exit guard (_Exit after stream flush) — static
  libc++'s static destruction can SIGABRT on exit; same guard xlings
  uses.
- release.yml (macos job): MACOSX_DEPLOYMENT_TARGET=11.0 + staged-archive
  ldflags injection for the self-build (the bootstrap mcpp predates this
  change), with minos/no-dylib assertions.
- version 0.0.50.

Design: xlings .agents/docs/2026-06-05-macos-min-version-support.md

Author: Sunrisepeak

.github/workflows/release.yml

@@ -317,16 +317,48 @@ jobs:
           echo "XLINGS_BIN=$HOME/.xlings/subos/default/bin/xlings" >> "$GITHUB_ENV"
 
       - name: Build mcpp from source (self-host)
+        env:
+          # macOS min-version support: target the first arm64 macOS so the
+          # release runs on 11.0+ instead of only the runner's OS (15).
+          # Requires static LLVM libc++ (injected below) — the system
+          # libc++ on older macOS lacks LLVM-20-era C++23 symbols
+          # (std::print's __is_posix_terminal etc.; verified on macos-14
+          # CI). See xlings .agents/docs/2026-06-05-macos-min-version-support.md.
+          MACOSX_DEPLOYMENT_TARGET: '11.0'
         run: |
           export PATH="$HOME/.xlings/subos/default/bin:$PATH"
           export MCPP_VENDORED_XLINGS="$XLINGS_BIN"
+
+          # Warm the toolchain so the llvm payload exists, then inject the
+          # static libc++ archives via [build] ldflags. The bootstrap mcpp
+          # predates the flags.cppm staticStdlib/clang implementation
+          # shipped in this very release — from the next release on, the
+          # injection is redundant (but harmless).
           "$MCPP" build
+          LLVM_ROOT=$(find "$HOME/.mcpp/registry/data/xpkgs/xim-x-llvm" -maxdepth 1 -mindepth 1 -type d | head -1)
+          test -f "$LLVM_ROOT/lib/libc++.a"
+          test -f "$LLVM_ROOT/lib/libc++abi.a"
+          if ! grep -q '^ldflags' mcpp.toml; then
+            sed -i '' "s|^\[build\]|[build]\nldflags = [\"-nostdlib++\", \"$LLVM_ROOT/lib/libc++.a\", \"$LLVM_ROOT/lib/libc++abi.a\"]|" mcpp.toml
+          fi
+          grep -n 'ldflags' mcpp.toml
+
+          "$MCPP" build --no-cache
           MCPP_BIN=$(find target -path "*/bin/mcpp" | head -1)
           MCPP_BIN=$(cd "$(dirname "$MCPP_BIN")" && pwd)/$(basename "$MCPP_BIN")
           test -x "$MCPP_BIN"
           file "$MCPP_BIN"
           otool -L "$MCPP_BIN"
+          echo "=== LC_BUILD_VERSION (must be minos 11.0) ==="
+          otool -l "$MCPP_BIN" | grep -A4 LC_BUILD_VERSION | head -6
+          otool -l "$MCPP_BIN" | grep -A4 LC_BUILD_VERSION | grep -q "minos 11.0" \
+            || { echo "FAIL: expected minos 11.0"; exit 1; }
+          if otool -L "$MCPP_BIN" | grep -q "libc++"; then
+            echo "FAIL: still linked against system libc++"; exit 1
+          fi
           "$MCPP_BIN" --version
+          # Restore the manifest so packaging sees a clean tree.
+          git checkout -- mcpp.toml
           echo "MCPP_BIN=$MCPP_BIN" >> "$GITHUB_ENV"
 
       - name: Package macOS release

mcpp.toml

@@ -1,6 +1,6 @@
 [package]
 name        = "mcpp"
-version     = "0.0.49"
+version     = "0.0.50"
 description = "Modern C++ build & package management tool"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]

src/build/flags.cppm

@@ -6,6 +6,9 @@
 //
 // See .agents/docs/2026-05-12-compile-commands-design.md.
 
+module;
+#include <cstdlib>
+
 export module mcpp.build.flags;
 
 import std;
@@ -120,6 +123,9 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     std::string link_toolchain_flags;
     bool isClangWithCfg = false;
     std::filesystem::path cfgPath;
+    // LLVM root of a clang-with-cfg toolchain — used by the macOS link
+    // path below to locate libc++.a/libc++abi.a for staticStdlib.
+    std::filesystem::path llvmRootForStdlib;
     if (mcpp::toolchain::is_clang(plan.toolchain)) {
         cfgPath = plan.toolchain.binaryPath.parent_path()
                   / (plan.toolchain.binaryPath.stem().string() + ".cfg");
@@ -131,6 +137,22 @@ CompileFlags compute_flags(const BuildPlan& plan) {
         auto llvmRoot = plan.toolchain.binaryPath.parent_path().parent_path();
         auto libcxxInclude = llvmRoot / "include" / "c++" / "v1";
         compile_toolchain_flags = " --no-default-config -nostdinc++";
+        // macOS deployment target: make MACOSX_DEPLOYMENT_TARGET explicit
+        // on the command line so (a) the ninja commands don't depend on
+        // env propagation and (b) the value participates in the BMI
+        // fingerprint via canonical flags — mixing targets in one sandbox
+        // otherwise reuses a std.pcm built for a different
+        // arm64-apple-macosxNN triple and dies with a config mismatch
+        // (observed on macos CI). The link side is added to f.ld below
+        // (the macOS link path doesn't consume link_toolchain_flags).
+        if (mcpp::platform::is_macos) {
+            if (const char* dt = std::getenv("MACOSX_DEPLOYMENT_TARGET");
+                dt && *dt) {
+                compile_toolchain_flags +=
+                    std::string(" -mmacosx-version-min=") + dt;
+            }
+        }
+        llvmRootForStdlib = llvmRoot;
         // libc++ headers
         compile_toolchain_flags += " -isystem" + escape_path(libcxxInclude);
         if (!plan.toolchain.targetTriple.empty()) {
@@ -309,7 +331,38 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     if constexpr (mcpp::platform::is_windows) {
         f.ld = user_ldflags + link_extra;
     } else if constexpr (mcpp::platform::needs_explicit_libcxx) {
-        f.ld = std::format("{}{}{} -lc++{}{}", full_static, static_stdlib, b_flag, user_ldflags, link_extra);
+        // macOS. Two min-version concerns (see xlings
+        // .agents/docs/2026-06-05-macos-min-version-support.md):
+        //
+        // 1. stdlib linkage — `-lc++` resolves to the SYSTEM
+        //    /usr/lib/libc++.1.dylib, which caps the deployment floor at
+        //    the build host's OS: e.g. std::print's __is_posix_terminal
+        //    support symbol only exists in macOS 15's libc++, so a
+        //    minos-14 binary dies at launch on 14 (dyld missing-symbol
+        //    abort; verified on macos-14 CI). With staticStdlib (the
+        //    manifest default — previously silently ignored on the clang
+        //    route), link LLVM's own libc++.a/libc++abi.a instead:
+        //    runtime deps shrink to libSystem and the floor drops to
+        //    11.0 (first arm64 macOS). Falls back to -lc++ when the
+        //    archives are absent.
+        // 2. deployment target — mirror MACOSX_DEPLOYMENT_TARGET onto the
+        //    link command line so it doesn't depend on env propagation.
+        std::string stdlib_link = " -lc++";
+        if (f.staticStdlib && !llvmRootForStdlib.empty()) {
+            auto libcxxA    = llvmRootForStdlib / "lib" / "libc++.a";
+            auto libcxxAbiA = llvmRootForStdlib / "lib" / "libc++abi.a";
+            if (std::filesystem::exists(libcxxA)
+                && std::filesystem::exists(libcxxAbiA)) {
+                stdlib_link = " -nostdlib++ " + escape_path(libcxxA)
+                            + " " + escape_path(libcxxAbiA);
+            }
+        }
+        std::string version_min;
+        if (const char* dt = std::getenv("MACOSX_DEPLOYMENT_TARGET"); dt && *dt) {
+            version_min = std::string(" -mmacosx-version-min=") + dt;
+        }
+        f.ld = std::format("{}{}{}{}{}{}{}", full_static, static_stdlib, b_flag,
+                           version_min, stdlib_link, user_ldflags, link_extra);
     } else {
         f.ld = std::format("{}{}{}{}{}{}{}{}", full_static, static_stdlib, link_toolchain_flags, b_flag,
                            runtime_dirs, payload_ld, user_ldflags, link_extra);

src/cli.cppm

@@ -587,6 +587,17 @@ std::string canonical_compile_flags(const mcpp::manifest::Manifest& m) {
     std::string s;
     s += "-std="; s += m.package.standard;
     s += " -fmodules";
+    // macOS deployment target changes the effective compile triple
+    // (arm64-apple-macosxNN) — a std.pcm built for one target cannot be
+    // loaded by a TU compiled for another. Fold it into the fingerprint
+    // so switching MACOSX_DEPLOYMENT_TARGET rebuilds the BMI cache
+    // instead of dying with a module config mismatch.
+    if constexpr (mcpp::platform::is_macos) {
+        if (const char* dt = std::getenv("MACOSX_DEPLOYMENT_TARGET"); dt && *dt) {
+            s += " macos_deployment_target=";
+            s += dt;
+        }
+    }
     if (!m.buildConfig.cStandard.empty()) {
         s += " c_standard=";
         s += m.buildConfig.cStandard;

src/main.cpp

@@ -5,5 +5,17 @@ import std;
 import mcpp.cli;
 
 int main(int argc, char* argv[]) {
-    return mcpp::cli::run(argc, argv);
+    int rc = mcpp::cli::run(argc, argv);
+#ifdef __APPLE__
+    // With statically linked libc++ (the macOS release linkage since
+    // 0.0.50), static destruction can SIGABRT on exit — same issue xlings
+    // guards against. A CLI tool needs no destructor-based cleanup; skip
+    // static dtors entirely. _Exit bypasses atexit handlers too, so flush
+    // the standard streams explicitly first.
+    std::cout.flush();
+    std::cerr.flush();
+    std::_Exit(rc);
+#else
+    return rc;
+#endif
 }

src/toolchain/fingerprint.cppm

@@ -18,7 +18,7 @@ import mcpp.toolchain.detect;
 
 export namespace mcpp::toolchain {
 
-inline constexpr std::string_view MCPP_VERSION = "0.0.49";
+inline constexpr std::string_view MCPP_VERSION = "0.0.50";
 
 struct FingerprintInputs {
     Toolchain                       toolchain;