const BuildContext* ctx = nullptr;

// Prepended to every set name: empty for a single package, `<member>/` for

// a member of a workspace document.

std::string setPrefix;

// Where the planning pass wrote (BuildOverrides::work_dir): the build

// programs' caches, and so their declared inputs, are under it.

std::filesystem::path workDir;

// Test discovery (`[test] discover`, relative to `testRoot`): a new file

// matching it is a new test target, and so a new unit in the document.

std::filesystem::path testRoot;

std::vector<std::string> testDiscover;

nlohmann::json database;

// The same units as a JSON Compilation Database: the entries `mcpp build

// --configure-only` writes to compile_commands.json, from the same record.

nlohmann::json compileCommands = nlohmann::json::array();

std::vector<std::string> watch;

std::string inputsFingerprint;

// Conditions found while rendering, at the severity the command reports

// them: most are warnings the document is still complete despite, and a

// failed build program (#699 item 2, E3) is an error whose `path` names

// its `build.mcpp`, rewritten here to the workspace-relative form.

std::vector<PlanNote> notes;

auto n = p;

n.make_preferred();

return n.string();

return m.package.namespace_.empty()

? m.package.name

: m.package.namespace_ + "." + m.package.name;

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

std::filesystem::path w{std::string(word)};

const auto want = path.lexically_normal();

if (w.lexically_normal() == want) return true;

if (!w.is_absolute() && !cwd.empty() && (cwd / w).lexically_normal() == want)

return true;

return false;

const std::vector<mcpp::build::UnitInvocation>& invocations) {

nlohmann::json out = nlohmann::json::array();

using C = mcpp::toolchain::CompilerId;

std::error_code ec;

if (tc.compiler == C::Clang) {

const auto dm = mcpp::toolchain::resolve_clang_driver(tc);

const bool read = std::ranges::any_of(invocations, [](auto const& inv) {

return std::ranges::find(inv.arguments, "--no-default-config") == inv.arguments.end();

});

if (dm.hasCfg && read) out.push_back(native_string(dm.cfgPath));

} else if (tc.compiler == C::GCC && !tc.targetTriple.empty()) {

const auto machine = tc.binaryPath.parent_path().parent_path()

/ "lib" / "gcc" / tc.targetTriple;

const auto major = tc.version.substr(0, tc.version.find('.'));

for (auto const& version : {tc.version, major}) {

const auto specs = machine / version / "specs";

if (!version.empty() && std::filesystem::is_regular_file(specs, ec)) {

out.push_back(native_string(specs));

break;

}

}

}

return out;

std::vector<std::vector<std::string>> semantic;

for (auto const& u : set["translation-units"]) {

auto args = u["arguments"].get<std::vector<std::string>>();

std::vector<std::string> rest(args.size() > 1 ? args.begin() + 1 : args.end(), args.end());

const std::filesystem::path cwd{u["work-directory"].get<std::string>()};

const auto n = rest.size();

if (n >= 4 && rest[n - 4] == "-c" && rest[n - 2] == "-o"

&& names_path(rest[n - 3], u["source"].get<std::string>(), cwd)

&& names_path(rest[n - 1], u["object"].get<std::string>(), cwd))

rest.resize(n - 4);

semantic.push_back(std::move(rest));

}

std::vector<std::string> baseline;

if (!semantic.empty()) {

baseline = semantic.front();

for (auto const& unit : semantic) {

std::size_t k = 0;

while (k < baseline.size() && k < unit.size() && baseline[k] == unit[k]) ++k;

baseline.resize(k);

}

}

std::size_t i = 0;

for (auto& u : set["translation-units"]) {

const auto& unit = semantic[i++];

u["local-arguments"] = std::vector<std::string>(

unit.begin() + static_cast<std::ptrdiff_t>(baseline.size()), unit.end());

}

set["baseline-arguments"] = std::move(baseline);

return !tc.driverIdent.empty()

? mcpp::toolchain::hash_string(tc.driverIdent)

: (tc.binaryPath.empty() ? std::string{}

: mcpp::toolchain::hash_file(tc.binaryPath));

std::string_view compilerTriple,

const std::vector<mcpp::build::UnitInvocation>& invocations) {

nlohmann::json j{

{"family", std::string(tc.compiler_name())},

{"version", tc.version},

{"driver", tc.binaryPath.string()},

{"target", std::string(compilerTriple)},

{"config-files", config_files(tc, invocations)},

};

if (!tc.sysroot.empty()) j["sysroot"] = native_string(tc.sysroot);

if (!tc.stdlibId.empty()) {

nlohmann::json stdlib{{"name", std::string(stdlib_name(tc.stdlibId))}};

if (!tc.stdlibVersion.empty()) stdlib["version"] = tc.stdlibVersion;

j["stdlib"] = std::move(stdlib);

}

if (auto id = build_id(tc); !id.empty()) j["build-id"] = id;

return j;

bool library = false, program = false;

for (auto const& t : m.targets) {

using K = mcpp::manifest::Target::Kind;

if (t.kind == K::Library || t.kind == K::SharedLibrary) library = true;

if (t.kind == K::Binary || t.kind == K::Application) program = true;

}

return library ? "library" : program ? "executable" : "other";

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

auto rel = p.lexically_normal().lexically_relative(root.lexically_normal());

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

auto first = rel.begin();

if (first != rel.end() && *first == "..") return std::nullopt;

auto s = rel.generic_string();

return s == "." ? std::string{} : s;

std::string familyName;

std::string kind;

nlohmann::json units = nlohmann::json::array();

// S1 section 7.2: the files this plan generates and the set's units

// compile or include, and the generated include directories they name.

nlohmann::json generated = nlohmann::json::array();

std::set<std::string> generatedDirs;

using D = mcpp::modgraph::ModuleDeclaration;

switch (declaration) {

case D::None: return "non-module";

case D::Interface: return "module-interface";

case D::InterfacePartition: return "module-partition-interface";

case D::ImplementationPartition: return "module-partition-implementation";

case D::Implementation: return "module-implementation";

case D::Unknown: return "unknown";

}

return "unknown";

if (stdlibId == "libstdc++") return "libstdc++";

if (stdlibId == "libc++") return "libc++";

if (stdlibId.starts_with("msvc")) return "msvc-stl";

return "other";

std::span<const std::filesystem::path> failedMemberRoots,

const std::filesystem::path& workspaceRoot,

std::string_view selector) {

Rendered r;

nlohmann::json toolchains = nlohmann::json::object();

nlohmann::json sets = nlohmann::json::array();

std::set<std::string> watch;

std::set<std::filesystem::path> inputFiles;

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

const auto normal = p.lexically_normal();

std::error_code ec;

if (std::filesystem::is_regular_file(normal, ec)) inputFiles.insert(normal);

if (auto rel = relative_to(normal, workspaceRoot); rel && !rel->empty())

watch.insert(*rel);

else

watch.insert(native_string(normal));

};

auto watch_glob = [&](const std::filesystem::path& root, std::string_view glob) {

if (glob.empty() || glob.starts_with('!')) return;

const auto matches = mcpp::modgraph::expand_glob(root, glob);

for (auto const& f : matches) inputFiles.insert(f.lexically_normal());

if (auto rel = relative_to(root, workspaceRoot)) {

watch.insert(rel->empty() ? std::string(glob)

: *rel + "/" + std::string(glob));

} else {

for (auto const& f : matches) watch.insert(native_string(f.lexically_normal()));

}

};

watch_file(workspaceRoot / "mcpp.toml");

watch_file(mcpp::home::root() / "config.toml");

for (auto const& member : members) {

const auto& ctx = *member.ctx;

// The triple as the compiler spells it (`x86_64-pc-windows-msvc`),

// which is what S1 asks for; mcpp's own spelling when none was resolved.

const std::string compilerTriple = ctx.plan.targetSide.llvmTriple.empty()

? ctx.tc.targetTriple : ctx.plan.targetSide.llvmTriple;

const auto tcId = toolchain_id(ctx.tc, compilerTriple);

const auto rootName = qualified_name(ctx.manifest);

std::set<std::filesystem::path> testSources;

for (auto const& t : ctx.manifest.targets) {

if (t.kind != mcpp::manifest::Target::TestBinary || t.main.empty()) continue;

std::filesystem::path main{t.main};

testSources.insert((main.is_absolute() ? main : ctx.projectRoot / main)

.lexically_normal());

}

std::vector<std::string> order;

std::map<std::string, SetData> groups;

auto set_for = [&](const std::string& name, const std::string& family,

const std::string& kind) -> SetData& {

auto [it, inserted] = groups.try_emplace(name);

if (inserted) {

order.push_back(name);

it->second.familyName = family;

it->second.kind = kind;

}

return it->second;

};

// GENERATED FILES (S1 0.3.0 section 7.2, mcpp#724). A planning pass

// runs no action (SPEC-005 R2.5), so a file a rule generates is absent

// from the directory this document names until a build writes it. The

// plan knows each generating step; the document states it, together

// with the path the build of the same configuration writes, so that a

// reader can tell "not built yet" from "missing" without knowing how

// the planning directory maps onto the project's own `target/`.

const auto planRoot = member.workDir.empty() ? ctx.projectRoot : member.workDir;

const auto generatedTree = (planRoot / "target" / ".build-mcpp").lexically_normal();

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

if (!member.workDir.empty())

if (auto rel = relative_to(p, member.workDir); rel && !rel->empty())

return native_string(ctx.projectRoot / std::filesystem::path(*rel));

return native_string(p);

};

const auto flags = mcpp::build::compute_flags(ctx.plan);

auto invocations = mcpp::build::unit_invocations(ctx.plan, flags);

if (!toolchains.contains(tcId))

toolchains[tcId] = toolchain_json(ctx.tc, compilerTriple, invocations);

for (auto& inv : invocations) {

const auto& cu = *inv.unit;

const bool isTest = testSources.contains(cu.source.lexically_normal());

const std::string package = cu.packageName.empty() ? rootName : cu.packageName;

const std::string kind = isTest ? "test"

: package == rootName ? target_kind(ctx.manifest)

: "library";

auto& set = set_for(member.setPrefix + package + (isTest ? ":test" : ""),

package, kind);

for (auto const* dirs : {&cu.localIncludeDirs, &cu.localIncludeDirsAfter})

for (auto const& dir : *dirs)

if (relative_to(dir, generatedTree))

set.generatedDirs.insert(native_string(dir.lexically_normal()));

nlohmann::json provides = nlohmann::json::object();

if (!cu.providesModule.empty()) provides[cu.providesModule] = "";

nlohmann::json requires_ = nlohmann::json::array();

for (auto const& name : cu.imports) requires_.push_back(name);

r.compileCommands.push_back(nlohmann::json{

{"directory", inv.directory},

{"file", inv.file},

{"arguments", inv.arguments},

{"output", inv.output},

});

set.units.push_back(nlohmann::json{

{"source", std::move(inv.file)},

{"work-directory", std::move(inv.directory)},

{"arguments", std::move(inv.arguments)},

{"object", std::move(inv.output)},

{"private", false},

{"provides", std::move(provides)},

{"requires", std::move(requires_)},

{"ide", {{"role", std::string(role_name(cu.declaration))}}},

});

}

// D5a/D5b (design 2026-09-26 §3.5): the standard-library units,

// already recovered onto the plan (prepare.cppm, from the same

// derivation `ensure_built` and `describe_std_module` both read), so

// this rendering cannot list a command or a BMI path that

// compile_commands.json (mcpp.build.compile_commands) disagrees with

// (P1). S1-12-1: they are translation units of the build like any

// other, so `--spec compile-commands` lists them too.

if (!ctx.plan.stdModuleUnits.empty()) {

auto& set = set_for(member.setPrefix + std::string(kStdSetName),

std::string(kStdSetName), "library");

for (auto const& unit : ctx.plan.stdModuleUnits) {

const auto sourceStr = native_string(unit.source);

const auto objectStr = native_string(unit.object);

const auto workDirStr = native_string(unit.workDirectory);

r.compileCommands.push_back(nlohmann::json{

{"directory", workDirStr},

{"file", sourceStr},

{"arguments", unit.arguments},

{"output", objectStr},

});

nlohmann::json requires_ = nlohmann::json::array();

for (auto const& name : unit.requiresModules) requires_.push_back(name);

set.units.push_back(nlohmann::json{

{"source", sourceStr},

{"work-directory", workDirStr},

{"arguments", unit.arguments},

{"object", objectStr},

{"private", false},

// D5b, S1-8-6: the path of the BMI the build writes, in

// the shared std cache that `emit` and the build share.

// The planning pass never compiles (SPEC-005 R2.2), but

// this path is the cache key's, not a compiler output it

// would have to run to learn.

{"provides", {{unit.module, native_string(unit.bmi)}}},

{"requires", std::move(requires_)},

{"ide", {{"role", "module-interface"}}},

});

}

}

// A recovery failure is now reported where the recovery runs

// (prepare.cppm, onto BuildContext::planNotes) and reaches `r.notes`

// through the unconditional copy below, with every other plan note.

{

using Role = mcpp::manifest::BuildAction::Role;

for (auto const& a : ctx.plan.actions) {

if (a.role != Role::Source || a.outputs.empty()) continue;

const std::string package = a.packageName.empty() ? rootName : a.packageName;

nlohmann::json inputs = nlohmann::json::array();

for (auto const& in : a.inputs)

inputs.push_back(native_string(std::filesystem::path(in).lexically_normal()));

const nlohmann::json generator{

{"id", a.id},

{"inputs", std::move(inputs)},

{"arguments", a.command},

{"work-directory", native_string(a.cwd.empty()

? ctx.plan.outputDir

: std::filesystem::path(a.cwd))},

};

// SPEC-005 R3.12: every set of the package lists what its build

// program generates, its test set included, since the units

// that include a header are not known without preprocessing.

// `kind` is per set: `source` where a unit of that set is

// compiled from the file.

for (auto& [name, set] : groups) {

if (set.familyName != package) continue;

for (auto const& out : a.outputs) {

const auto p = std::filesystem::path(out).lexically_normal();

const auto path = native_string(p);

const bool isUnit = std::ranges::any_of(set.units, [&](auto const& u) {

return u.value("source", "") == path;

});

set.generated.push_back(nlohmann::json{

{"path", path},

{"build-path", build_path(p)},

{"kind", isUnit ? "source" : "header"},

{"generator", generator},

});

}

}

}

for (auto& [name, set] : groups)

for (auto const& dir : set.generatedDirs)

set.generated.push_back(nlohmann::json{

{"path", dir},

{"build-path", build_path(std::filesystem::path(dir))},

{"kind", "directory"},

});

}

for (auto const& name : order) {

auto& set = groups.at(name);

nlohmann::json visible = nlohmann::json::array();

for (auto const& other : order)

if (other != name) visible.push_back(other);

nlohmann::json setJson{

{"name", name},

{"family-name", set.familyName},

{"visible-sets", std::move(visible)},

{"translation-units", std::move(set.units)},

{"ide", {

{"toolchain", tcId},

{"configuration", ctx.profile},

{"kind", set.kind},

}},

};

if (!set.generated.empty())

setJson["ide"]["generated"] = std::move(set.generated);

split_baseline(setJson);

sets.push_back(std::move(setJson));

}

watch_file(ctx.projectRoot / "mcpp.lock");

for (auto const& sp : ctx.sourcePackages) {

watch_file(sp.root / "mcpp.toml");

std::error_code ec;

if (std::filesystem::exists(sp.root / "build.mcpp", ec))

watch_file(sp.root / "build.mcpp");

for (auto const& g : sp.sources) watch_glob(sp.root, g);

}

for (auto const& g : member.testDiscover) watch_glob(member.testRoot, g);

// Only an editable package's build program inputs can change: a store

// package's are fixed by the version its manifest and lock name.

std::set<std::filesystem::path> editableRoots;

for (auto const& sp : ctx.sourcePackages) editableRoots.insert(sp.root.lexically_normal());

for (auto const& declared : mcpp::build::declared_program_inputs(member.workDir)) {

if (!editableRoots.contains(declared.root.lexically_normal())) continue;

for (auto const& f : declared.files) watch_file(f);

for (auto const& g : declared.globs) watch_glob(declared.root, g);

}

for (auto note : ctx.planNotes) {

// `note.path`, when set, is the absolute path a `plan_only`

// branch recorded (#699 item 2, E3); every other `path` in this

// document is relative to the workspace root, and a note's is

// rewritten to match before it reaches the command.

if (!note.path.empty()) {

const std::filesystem::path abs{note.path};

if (auto rel = relative_to(abs, workspaceRoot); rel && !rel->empty())

note.path = *rel;

else

note.path = native_string(abs.lexically_normal());

}

r.notes.push_back(std::move(note));

}

}

// Every member whose planning failed still has its likely cause watched

// (#699 item 1, E1): editing its `mcpp.toml`, or the `build.mcpp` that may

// have failed, is what should make a consumer ask again for the members

// that could not be described this time.

for (auto const& failedRoot : failedMemberRoots) {

watch_file(failedRoot / "mcpp.toml");

std::error_code ec;

if (std::filesystem::exists(failedRoot / "build.mcpp", ec))

watch_file(failedRoot / "build.mcpp");

}

r.database = nlohmann::json{

{"version", 1},

{"revision", 0},

{"ide", {

{"profile-version", std::string(kProfileVersion)},

{"generator", {

{"name", "mcpp"},

{"version", std::string(mcpp::toolchain::MCPP_VERSION)},

}},

{"toolchains", std::move(toolchains)},

}},

{"sets", std::move(sets)},

};

r.watch.assign(watch.begin(), watch.end());

std::string digest = "mcpp-build-database-inputs-v1\x1f";

digest += mcpp::toolchain::MCPP_VERSION;

digest += '\x1f';

digest += selector;

digest += '\n';

for (auto const& f : inputFiles) {

digest += f.generic_string();

digest += '\x1f';

digest += mcpp::toolchain::hash_file(f);

digest += '\n';

}

r.inputsFingerprint = "fnv1a:" + mcpp::toolchain::hash_string(digest);

return r;