std::println("mcpp v{} — modern C++23 build tool", mcpp::toolchain::MCPP_VERSION);

std::println("");

std::println("Usage:");

std::println("Project commands:");

std::println(" mcpp new <name> Create a new package skeleton");

std::println(" mcpp build [options] Build the current package");

std::println(" mcpp run [target] [-- args...] Build + run a binary target");

std::println(" mcpp test [-- args...] Build + run all tests/**/*.cpp");

std::println(" mcpp clean [--bmi-cache] Remove target/ (and optionally BMI cache)");

std::println(" mcpp add <pkg>[@<ver>] Add a dependency to mcpp.toml");

std::println(" mcpp remove <pkg> Remove a dependency from mcpp.toml");

std::println(" mcpp update [pkg] Re-resolve deps and rewrite mcpp.lock");

std::println(" mcpp search <keyword> Search packages in registries");

std::println(" mcpp publish [--dry-run] Publish package to default registry");

std::println(" mcpp pack [--mode <m>] Build + bundle into a distributable tarball");

std::println(" mcpp emit xpkg [-V VER] [-o FILE] Generate xpkg Lua entry");

std::println("");

std::println("Resource management:");

std::println(" mcpp toolchain install|list|default Manage mcpp's private toolchains");

std::println(" mcpp cache list|prune|clean|info Inspect/manage the global BMI cache");

std::println(" mcpp index list|add|remove|update Manage package registries");

std::println("");

std::println("About mcpp itself:");

std::println(" mcpp self doctor Diagnose mcpp environment health");

std::println(" mcpp self env Print mcpp paths and toolchain");

std::println(" mcpp self config [--mirror CN|GLOBAL] Show or modify mcpp's xlings config");

std::println(" mcpp self version Show mcpp version");

std::println(" mcpp self explain <CODE> Show extended description for an error code");

std::println(" mcpp --help / --version Help / version");

std::println("");

std::println("Build options:");

std::println(" --verbose, -v Verbose compiler output");

std::println(" --quiet, -q Suppress status output");

std::println(" --print-fingerprint Show toolchain fingerprint and 10 inputs");

std::println(" --no-cache Force-clear target/ before building");

std::println(" --no-color Disable colored output");

std::println("");

std::println("Docs: https://github.com/mcpp-community/mcpp/tree/main/docs");

auto p = std::filesystem::absolute(start);

while (true) {

if (std::filesystem::exists(p / "mcpp.toml")) return p;

auto parent = p.parent_path();

if (parent == p) return std::nullopt;

p = parent;

}

auto p = memberRoot.parent_path();

while (true) {

if (std::filesystem::exists(p / "mcpp.toml")) {

auto m = mcpp::manifest::load(p / "mcpp.toml");

if (m && m->workspace.present) {

// Verify memberRoot is in members list

auto rel = std::filesystem::relative(memberRoot, p);

for (auto& member : m->workspace.members) {

if (rel == std::filesystem::path(member)) return p;

}

}

}

auto parent = p.parent_path();

if (parent == p) break;

p = parent;

}

return {};

const mcpp::manifest::Manifest& workspace) {

auto merge_map = [&](std::map<std::string, mcpp::manifest::DependencySpec>& deps) {

for (auto& [name, spec] : deps) {

if (!spec.inheritWorkspace) continue;

// Try exact key match first

auto it = workspace.workspace.dependencies.find(name);

if (it != workspace.workspace.dependencies.end()) {

spec.version = it->second.version;

spec.inheritWorkspace = false;

continue;

}

// Try short name for default-ns deps

auto shortIt = workspace.workspace.dependencies.find(spec.shortName);

if (shortIt != workspace.workspace.dependencies.end()) {

spec.version = shortIt->second.version;

spec.inheritWorkspace = false;

}

}

};

merge_map(member.dependencies);

merge_map(member.devDependencies);

merge_map(member.buildDependencies);

const mcpp::toolchain::Fingerprint& fp,

const std::filesystem::path& root)

{

auto triple = tc.targetTriple.empty() ? std::string{"unknown"} : tc.targetTriple;

return root / "target" / triple / fp.hex;

std::vector<int> out;

int cur = 0;

bool any = false;

for (char c : s) {

if (c >= '0' && c <= '9') { cur = cur * 10 + (c - '0'); any = true; }

else if (c == '.') {

if (any) { out.push_back(cur); cur = 0; any = false; }

else { out.clear(); break; }

} else {

break; // non-numeric tail (e.g. "-musl")

}

}

if (any) out.push_back(cur);

return out;

std::vector<std::string> available)

{

if (available.empty()) return std::nullopt;

auto want = parse_version_components(partial);

auto matches = [&](const std::vector<int>& cand) {

if (want.size() > cand.size()) return false;

for (std::size_t i = 0; i < want.size(); ++i)

if (cand[i] != want[i]) return false;

return true;

};

std::optional<std::string> best;

std::vector<int> bestVec;

for (auto& v : available) {

auto comps = parse_version_components(v);

if (comps.empty()) continue;

if (!matches(comps)) continue;

if (!best || std::lexicographical_compare(

bestVec.begin(), bestVec.end(), comps.begin(), comps.end()))

{

best = v;

bestVec = std::move(comps);

}

}

return best;

std::string_view ximName)

{

std::vector<std::string> out;

auto root = pkgsDir / std::format("xim-x-{}", ximName);

std::error_code ec;

if (!std::filesystem::exists(root, ec)) return out;

for (auto& v : std::filesystem::directory_iterator(root, ec)) {

if (v.is_directory(ec)) out.push_back(v.path().filename().string());

}

return out;

std::string_view ximName)

{

if (ximName.empty()) return {};

std::string subdir(1, ximName[0]);

std::string fname = std::string(ximName) + ".lua";

auto try_load = [&](const std::filesystem::path& p)

-> std::optional<std::vector<std::string>>

{

std::error_code ec;

if (!std::filesystem::exists(p, ec)) return std::nullopt;

std::ifstream is(p);

std::string body((std::istreambuf_iterator<char>(is)), {});

return mcpp::manifest::list_xpkg_versions(body, "linux");

};

auto data = cfg.xlingsHome() / "data";

if (auto v = try_load(data / "xim-pkgindex" / "pkgs" / subdir / fname); v)

return std::move(*v);

std::error_code ec;

auto repos = data / "xim-index-repos";

if (std::filesystem::exists(repos, ec)) {

for (auto& repo : std::filesystem::directory_iterator(repos, ec)) {

auto cand = repo.path() / "pkgs" / subdir / fname;

if (auto v = try_load(cand); v) return std::move(*v);

}

}

return {};

std::string name;

double downloaded = 0;

double total = 0;

bool started = false;

bool finished = false;

auto p = *pos;

while (p < payload.size() && (payload[p] == ' ' || payload[p] == '\n')) ++p;

if (p >= payload.size() || payload[p] != '{') { *pos = p; return {}; }

auto start = p;

int depth = 0;

bool in_string = false;

for (; p < payload.size(); ++p) {

char c = payload[p];

if (in_string) {

if (c == '\\' && p + 1 < payload.size()) { ++p; continue; }

if (c == '"') in_string = false;

continue;

}

if (c == '"') in_string = true;

else if (c == '{') ++depth;

else if (c == '}') { if (--depth == 0) { ++p; break; } }

}

*pos = p;

return payload.substr(start, (p == payload.size() ? p : p) - start);

auto get_str = [&](std::string_view key) -> std::string {

std::string n = std::format("\"{}\":\"", key);

auto q = obj.find(n);

if (q == std::string_view::npos) return "";

q += n.size();

std::string out;

while (q < obj.size() && obj[q] != '"') {

if (obj[q] == '\\' && q + 1 < obj.size()) { out.push_back(obj[q+1]); q += 2; continue; }

out.push_back(obj[q++]);

}

return out;

};

auto get_num = [&](std::string_view key) -> double {

std::string n = std::format("\"{}\":", key);

auto q = obj.find(n);

if (q == std::string_view::npos) return 0;

q += n.size();

auto e = q;

while (e < obj.size()

&& (std::isdigit(static_cast<unsigned char>(obj[e]))

|| obj[e] == '.' || obj[e] == '-' || obj[e] == '+'

|| obj[e] == 'e' || obj[e] == 'E')) ++e;

try { return std::stod(std::string(obj.substr(q, e - q))); }

catch (...) { return 0; }

};

auto get_bool = [&](std::string_view key) -> bool {

std::string n = std::format("\"{}\":", key);

auto q = obj.find(n);

if (q == std::string_view::npos) return false;

q += n.size();

return obj.size() - q >= 4 && obj.substr(q, 4) == "true";

};

InstallProgressFile f;

f.name = get_str("name");

f.downloaded = get_num("downloadedBytes");

f.total = get_num("totalBytes");

f.started = get_bool("started");

f.finished = get_bool("finished");

return f;

{

std::vector<InstallProgressFile> out;

constexpr std::string_view kKey{"\"files\":["};

auto p = payload.find(kKey);

if (p == std::string_view::npos) return out;

p += kKey.size();

while (p < payload.size()) {

while (p < payload.size() && (payload[p] == ' ' || payload[p] == '\n'

|| payload[p] == ',')) ++p;

if (p >= payload.size() || payload[p] == ']') break;

if (payload[p] != '{') break;

auto obj = scan_one_object(payload, &p);

if (obj.empty()) break;

auto f = parse_one_install_file(obj);

if (!f.name.empty()) out.push_back(std::move(f));

}

return out;

std::string n = std::format("\"{}\":", key);

auto q = payload.find(n);

if (q == std::string_view::npos) return 0;

q += n.size();

auto e = q;

while (e < payload.size()

&& (std::isdigit(static_cast<unsigned char>(payload[e]))

|| payload[e] == '.' || payload[e] == '-' || payload[e] == '+'

|| payload[e] == 'e' || payload[e] == 'E')) ++e;

try { return std::stod(std::string(payload.substr(q, e - q))); }

catch (...) { return 0; }

std::filesystem::path project_root = {})

{

mcpp::ui::PathContext ctx;

ctx.project_root = std::move(project_root);

if (cfg) ctx.mcpp_home = cfg->mcppHome;

if (auto* h = std::getenv("HOME"); h && *h) ctx.home = h;

return ctx;

auto bar = std::make_shared<std::optional<mcpp::ui::ProgressBar>>();

auto active = std::make_shared<std::string>();

auto finished = std::make_shared<std::unordered_set<std::string>>();

return [bar, active, finished](const mcpp::config::BootstrapProgress& ev) {

// Process newly-finished entries.

for (auto& f : ev.files) {

if (finished->contains(f.name)) continue;

if (!f.finished) continue;

if (*active == f.name) {

if (*bar) (*bar)->finish();

bar->reset();

active->clear();

}

finished->insert(f.name);

}

// Pick what to display: prefer continuing with `*active` if it's

// still in the array and not finished, otherwise the first

// started+unfinished entry.

const mcpp::config::BootstrapFile* current = nullptr;

for (auto& f : ev.files) {

if (f.name == *active && !f.finished

&& !finished->contains(f.name)) { current = &f; break; }

}

if (!current) {

for (auto& f : ev.files) {

if (finished->contains(f.name)) continue;

if (f.started && !f.finished) { current = &f; break; }

}

}

if (!current) return;

if (current->name != *active) {

if (*bar) (*bar)->finish();

*active = current->name;

bar->emplace("Downloading", current->name);

}

if (current->totalBytes > 0) {

(*bar)->update_bytes(static_cast<std::size_t>(current->downloadedBytes),

static_cast<std::size_t>(current->totalBytes),

ev.elapsedSec);

}

};

std::optional<mcpp::ui::ProgressBar> bar_;

std::string active_;

std::unordered_set<std::string> finished_;

void on_data(const mcpp::fetcher::DataEvent& d) override {

if (d.dataKind != "download_progress") return;

auto files = parse_all_install_files(d.payloadJson);

if (files.empty()) return;

// 1. Process any newly-finished entries. Each file is reported

// twice with finished=true (xlings quirk); the `finished_`

// set dedupes both that AND the rotation case where the

// same file shows up at a different array slot in a later

// event.

for (auto& f : files) {

if (finished_.contains(f.name)) continue;

if (!f.finished) continue;

if (active_ == f.name) {

if (bar_) bar_->finish();

bar_.reset();

active_.clear();

}

finished_.insert(f.name);

}

// 2. Pick what to display. Prefer continuing with the current

// `active_` if it's still in the array and not finished —

// otherwise the first started+unfinished entry. This stops

// the bar from flickering between names when xlings reshuffles

// files[] across events during a multi-package install.

const InstallProgressFile* current = nullptr;

for (auto& f : files) {

if (f.name == active_ && !f.finished

&& !finished_.contains(f.name)) { current = &f; break; }

}

if (!current) {

for (auto& f : files) {

if (finished_.contains(f.name)) continue;

if (f.started && !f.finished) { current = &f; break; }

}

}

if (!current) return;

if (current->name != active_) {

if (bar_) bar_->finish();

active_ = current->name;

bar_.emplace("Downloading", current->name);

}

if (current->total > 0) {

double elapsed = extract_payload_number(d.payloadJson, "elapsedSec");

bar_->update_bytes(static_cast<std::size_t>(current->downloaded),

static_cast<std::size_t>(current->total),

elapsed);

}

}

~CliInstallProgress() override { if (bar_) bar_->finish(); }

std::string s;

s += "-std="; s += m.language.standard;

s += " -fmodules";

return s;

while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front())))

s.erase(0, 1);

while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back())))

s.pop_back();

return s;

std::ifstream is(path);

if (!is) return false;

std::string line;

while (std::getline(is, line)) {

line = trim_copy(std::move(line));

std::size_t i = std::string::npos;

if (line.starts_with("import ")) {

i = 7;

} else if (line.starts_with("export import ")) {

i = 14;

}

if (i == std::string::npos) continue;

while (i < line.size() && std::isspace(static_cast<unsigned char>(line[i])))

++i;

std::string name;

while (i < line.size()

&& (std::isalnum(static_cast<unsigned char>(line[i]))

|| line[i] == '_' || line[i] == '.' || line[i] == ':')) {

name.push_back(line[i]);

++i;

}

if (is_std_module(name)) return true;

}

return false;

const mcpp::manifest::Manifest& manifest,

const std::filesystem::path& projectRoot) {

for (auto& u : graph.units) {

for (auto& req : u.requires_) {

if (is_std_module(req.logicalName))

return true;

}

}

// Some target entry files can be added to the plan after the package scan.

// Check them here so std BMI setup matches what make_plan will compile.

for (auto& t : manifest.targets) {

if (!t.main.empty() && source_file_imports_std(projectRoot / t.main))

return true;

}

return false;

const std::filesystem::path& loader,

const std::string& rpath,

const std::filesystem::path& patchelfBin)

{

if (!std::filesystem::exists(dir) || !std::filesystem::exists(patchelfBin))

return;

std::error_code ec;

for (auto it = std::filesystem::recursive_directory_iterator(dir, ec);

it != std::filesystem::recursive_directory_iterator{}; it.increment(ec))

{

if (ec) { ec.clear(); continue; }

if (!it->is_regular_file(ec)) continue;

auto path = it->path();

// Skip non-ELF (cheap magic check)

std::ifstream is(path, std::ios::binary);

char m[4]{};

is.read(m, 4);

if (!is || m[0] != 0x7f || m[1] != 'E' || m[2] != 'L' || m[3] != 'F')

continue;

is.close();

// Probe PT_INTERP — skip static binaries (no interp).

auto probe = std::format("{} --print-interpreter {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(path.string()));

auto probeResult = mcpp::platform::process::capture(probe);

bool hasInterp = (probeResult.exit_code == 0 && !probeResult.output.empty());

if (hasInterp) {

(void)mcpp::platform::process::run_silent(std::format(

"{} --set-interpreter {} {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(loader.string()),

mcpp::platform::shell::quote(path.string())));

}

// Always set RUNPATH (works on .so too — they need to find deps).

if (!rpath.empty()) {

(void)mcpp::platform::process::run_silent(std::format(

"{} --set-rpath {} {} 2>/dev/null",

mcpp::platform::shell::quote(patchelfBin.string()),

mcpp::platform::shell::quote(rpath),

mcpp::platform::shell::quote(path.string())));

}

}

constexpr std::string_view kLoader = "/ld-linux-x86-64.so.2";

auto pos = specsContent.find(kLoader);

if (pos == std::string::npos) return "";

// Walk backwards to find start of the absolute path

auto start = pos;

while (start > 0 && specsContent[start - 1] != ' '

&& specsContent[start - 1] != ':'

&& specsContent[start - 1] != ';'

&& specsContent[start - 1] != '\n') {

--start;

}

auto dir = specsContent.substr(start, pos - start);

// Sanity: must be absolute

if (dir.empty() || dir[0] != '/') return "";

// Skip if it already points to the target glibc (no fixup needed)

return dir;

const std::filesystem::path& glibcLibDir,

const std::filesystem::path& gccLibDir)

{

auto specsParent = gccPkgRoot / "lib" / "gcc" / "x86_64-linux-gnu";

if (!std::filesystem::exists(specsParent)) return;

auto loaderReplacement = (glibcLibDir / "ld-linux-x86-64.so.2").string();

auto rpathReplacement = std::format("{}:{}",

glibcLibDir.string(),

gccLibDir.string());

auto replace_all = [](std::string& s, std::string_view needle,

std::string_view rep)

{

for (std::size_t pos = 0;

(pos = s.find(needle, pos)) != std::string::npos;) {

s.replace(pos, needle.size(), rep);

pos += rep.size();

}

};

for (auto& sub : std::filesystem::directory_iterator(specsParent)) {

auto specs = sub.path() / "specs";

if (!std::filesystem::exists(specs)) continue;

std::ifstream is(specs);

std::stringstream ss; ss << is.rdbuf();

std::string content = ss.str();

auto bakedDir = detect_baked_lib_dir(content);

if (bakedDir.empty()) continue;

// Already pointing at the right place — no fixup needed.

if (bakedDir == glibcLibDir.string()) continue;

auto bakedLoader = bakedDir + "/ld-linux-x86-64.so.2";

// Order matters: replace the full loader file path first so the

// shorter dir pattern doesn't eat its prefix.

replace_all(content, bakedLoader, loaderReplacement);

replace_all(content, bakedDir, rpathReplacement);

std::ofstream os(specs);

os << content;

}

std::string name = parsed.positional(0);

if (name.empty()) {

std::println(stderr, "error: `mcpp new` requires a package name (e.g. `mcpp new hello`)");

return 2;

}

std::filesystem::path root = std::filesystem::current_path() / name;

if (std::filesystem::exists(root)) {

std::println(stderr, "error: '{}' already exists", root.string());

return 1;

}

std::error_code ec;

std::filesystem::create_directories(root / "src", ec);

if (ec) {

std::println(stderr, "error: cannot create '{}': {}", root.string(), ec.message());

return 1;

}

// mcpp.toml

{

std::ofstream os(root / "mcpp.toml");

os << mcpp::manifest::default_template(name);

}

// src/main.cpp — template with PROJECT placeholder, replaced with `name`.

{

std::string body = R"(// PROJECT — generated by `mcpp new`

)";

std::size_t pos;

while ((pos = body.find("PROJECT")) != std::string::npos) {

body.replace(pos, 7, name);

}

std::ofstream os(root / "src" / "main.cpp");

os << body;

}

// tests/test_smoke.cpp — bundled smoke test (`mcpp test` works out-of-the-box).

{

std::filesystem::create_directories(root / "tests", ec);

std::ofstream os(root / "tests" / "test_smoke.cpp");

os << R"(// Smoke test — verifies the project compiles + a binary runs.

)";

}

// .gitignore

{

std::ofstream os(root / ".gitignore");

os << "target/\n";

}

std::println("Created package '{}' at {}", name, root.string());

std::println("Next: cd {} && mcpp build && mcpp run (or `mcpp test`)", name);

return 0;

mcpp::manifest::Manifest manifest;

mcpp::toolchain::Toolchain tc;

mcpp::toolchain::Fingerprint fp;

std::filesystem::path projectRoot;

std::filesystem::path outputDir;

std::filesystem::path stdBmi;

std::filesystem::path stdObject;

mcpp::build::BuildPlan plan;

// M3.2 BMI cache: deps that did NOT hit cache and therefore need

// populate_from(...) AFTER backend.build succeeds.

struct CacheTask {

mcpp::bmi_cache::CacheKey key;

mcpp::bmi_cache::DepArtifacts artifacts;

};

std::vector<CacheTask> depsToPopulate;

// Names of deps that DID hit cache (for ui status output).

std::vector<std::string> cachedDepLabels; // "mcpplibs.cmdline v0.0.1"

std::string target_triple; // empty = host triple, fall through to [toolchain]

bool force_static = false; // --static (or implied by musl target)

std::string package_filter; // -p <name>: only build this workspace member

bool includeDevDeps = false,

std::vector<mcpp::manifest::Target> extraTargets = {},

BuildOverrides overrides = {}) {

auto root = find_manifest_root(std::filesystem::current_path());

if (!root) {

return std::unexpected("no mcpp.toml found in current directory or any parent");

}

auto m = mcpp::manifest::load(*root / "mcpp.toml");

if (!m) return std::unexpected(m.error().format());

// ─── Workspace handling ────────────────────────────────────────────

// If the manifest has [workspace] and is a virtual workspace (no [package]),

// or if -p filter is set, switch to the target member's manifest.

std::optional<mcpp::manifest::Manifest> wsManifest; // keep workspace manifest alive

if (m->workspace.present) {

std::string targetMember;

if (!overrides.package_filter.empty()) {

// -p <name>: find matching member by directory basename or path

for (auto& mp : m->workspace.members) {

auto basename = std::filesystem::path(mp).filename().string();

if (basename == overrides.package_filter || mp == overrides.package_filter) {

targetMember = mp;

break;

}

}

if (targetMember.empty()) {

return std::unexpected(std::format(

"workspace member '{}' not found in [workspace].members",

overrides.package_filter));

}

} else if (m->package.name.empty()) {

// Virtual workspace: find a member with a binary target, or use last member.

for (auto& mp : m->workspace.members) {

auto memberDir = *root / mp;

auto mm = mcpp::manifest::load(memberDir / "mcpp.toml");

if (!mm) continue;

for (auto& t : mm->targets) {

if (t.kind == mcpp::manifest::Target::Binary) {

targetMember = mp;

break;

}

}

if (!targetMember.empty()) break;

}

if (targetMember.empty() && !m->workspace.members.empty()) {

targetMember = m->workspace.members.back();

}

}

// else: rooted workspace with [package] — build root normally.

if (!targetMember.empty()) {

auto memberDir = *root / targetMember;

if (!std::filesystem::exists(memberDir / "mcpp.toml")) {

return std::unexpected(std::format(

"workspace member '{}' has no mcpp.toml", targetMember));

}

wsManifest = std::move(*m); // preserve workspace manifest

m = mcpp::manifest::load(memberDir / "mcpp.toml");

if (!m) return std::unexpected(std::format(

"workspace member '{}': {}", targetMember, m.error().format()));

// Merge workspace dependency versions

merge_workspace_deps(*m, *wsManifest);

// Inherit workspace toolchain if member doesn't define one

if (m->toolchain.byPlatform.empty()) {

m->toolchain = wsManifest->toolchain;

}

// Inherit workspace target overrides

for (auto& [triple, entry] : wsManifest->targetOverrides) {

if (!m->targetOverrides.contains(triple)) {

m->targetOverrides[triple] = entry;

}

}

// Inherit workspace indices if member doesn't define any

if (m->indices.empty() && !wsManifest->indices.empty()) {

m->indices = wsManifest->indices;

}

mcpp::ui::status("Workspace", std::format("building member '{}'", targetMember));

root = memberDir;

}

} else {

// Not at workspace root — check if we're inside a workspace

auto wsRoot = find_workspace_root(*root);

if (!wsRoot.empty()) {

auto wsm = mcpp::manifest::load(wsRoot / "mcpp.toml");

if (wsm && wsm->workspace.present) {

merge_workspace_deps(*m, *wsm);

if (m->toolchain.byPlatform.empty()) {

m->toolchain = wsm->toolchain;

}

for (auto& [triple, entry] : wsm->targetOverrides) {

if (!m->targetOverrides.contains(triple)) {

m->targetOverrides[triple] = entry;

}

}

// Inherit workspace indices if member doesn't define any

if (m->indices.empty() && !wsm->indices.empty()) {

m->indices = wsm->indices;

}

}

}

}

// Inject synthetic targets (e.g. test binaries from `mcpp test`).

for (auto& t : extraTargets) m->targets.push_back(t);

// ─── Toolchain resolution (docs/21) ────────────────────────────────

// Priority chain:

// 1. mcpp.toml [toolchain].<platform> → resolve_xpkg_path → abs path