const mcpp::manifest::Manifest& workspace,

const std::filesystem::path& wsRoot = {}) {

auto copy_from = [&](mcpp::manifest::DependencySpec& spec,

const mcpp::manifest::DependencySpec& wsSpec) {

spec.version = wsSpec.version;

spec.path = wsSpec.path;

spec.git = wsSpec.git;

spec.gitRev = wsSpec.gitRev;

spec.gitRefKind = wsSpec.gitRefKind;

if (!spec.path.empty() && !wsRoot.empty()) {

std::filesystem::path p(spec.path);

if (p.is_relative()) {

spec.path = std::filesystem::weakly_canonical(wsRoot / p).string();

}

}

spec.inheritWorkspace = false;

};

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()) {

copy_from(spec, it->second);

continue;

}

// Try short name for default-ns deps

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

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

copy_from(spec, shortIt->second);

}

}

};

merge_map(member.dependencies);

merge_map(member.devDependencies);

merge_map(member.buildDependencies);

const mcpp::manifest::Manifest& workspace,

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

if (!member.indices.empty() || workspace.indices.empty()) return;

member.indices = workspace.indices;

for (auto& [_, idx] : member.indices) {

if (idx.is_local() && idx.path.is_relative()) {

// This is an ownership/anchoring operation, not a request to

// resolve filesystem aliases. weakly_canonical can rewrite a

// Windows short/case-preserving workspace path into a different

// spelling before the inherited index is opened. Keep the path

// rooted exactly where the workspace manifest declared it; the

// normal reader remains responsible for existence/readability.

idx.path = (wsRoot / idx.path).lexically_normal();

}

}

const std::filesystem::path& wsRoot,

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

if (!workspace.workspace.present) return false;

std::error_code ec;

auto want = std::filesystem::weakly_canonical(candidate, ec);

if (ec) { ec.clear(); want = candidate.lexically_normal(); }

for (auto const& m : workspace.workspace.members) {

auto member = std::filesystem::weakly_canonical(wsRoot / m, ec);

if (ec) { ec.clear(); member = (wsRoot / m).lexically_normal(); }

if (member == want) return true;

}

return false;

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

const auto& inh = workspace.workspace.inherited;

// `standardDeclared` and not `standard != "c++23"`: a member that

// deliberately pins c++23 under a c++26 workspace must keep it, and that is

// indistinguishable from the default without the bit.

if (inh.standardDeclared && !member.package.standardDeclared) {

member.package.standard = inh.standard;

member.language.standard = inh.standard;

member.package.standardDeclared = true;

// `cppStandard` was normalised by the parser from the member's own

// value; it has to be re-derived, or the inherited spelling would sit

// in `package.standard` while every build surface kept reading the

// default out of the normalised copy.

if (auto cfg = mcpp::manifest::normalize_cpp_standard(inh.standard))

member.cppStandard = *cfg;

}

if (member.package.version.empty()) member.package.version = inh.version;

if (member.package.license.empty()) member.package.license = inh.license;

if (member.package.description.empty()) member.package.description = inh.description;

if (member.package.repo.empty()) member.package.repo = inh.repo;

if (member.package.authors.empty()) member.package.authors = inh.authors;

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

// `(namespace, name)`, the identity `mcpp.xlings.address_set` defines,

// spelled here from the same parser rather than imported. Importing that

// module here makes GCC 16.1 fail with an internal compiler error

// (segmentation fault) at `import mcpp.cli;` in src/main.cpp. Measured.

auto package_key = [](std::string_view address) {

const auto e = mcpp::manifest::parse_address(address);

return (e.ns.empty() ? std::string("xim") : e.ns) + ":" + e.target;

};

std::set<std::string> own;

for (auto const& a : member.xlings.deps) own.insert(package_key(a));

for (auto const& cc : member.conditionalConfigs)

for (auto const& a : cc.xlings.deps) own.insert(package_key(a));

// Copies the entries of `from` whose package the member does not declare,

// with the pin and the tier each address carries.

auto take = [&](const mcpp::manifest::XlingsConfig& from,

mcpp::manifest::XlingsConfig& to) {

std::vector<std::string> taken;

for (auto const& a : from.deps) {

if (own.contains(package_key(a))) continue;

taken.push_back(a);

const auto target = mcpp::manifest::parse_address(a).target;

if (auto pin = from.workspace.find(target); pin != from.workspace.end())

to.workspace.try_emplace(pin->first, pin->second);

if (auto w = from.depWhen.find(a); w != from.depWhen.end())

to.depWhen.try_emplace(a, w->second);

}

to.deps.insert(to.deps.begin(), taken.begin(), taken.end());

};

take(workspace.xlings, member.xlings);

std::vector<mcpp::manifest::ConditionalConfig> rows;

for (auto const& cc : workspace.conditionalConfigs) {

if (cc.xlings.deps.empty()) continue;

mcpp::manifest::ConditionalConfig row;

row.predicate = cc.predicate;

take(cc.xlings, row.xlings);

if (!row.xlings.deps.empty()) rows.push_back(std::move(row));

}

member.conditionalConfigs.insert(member.conditionalConfigs.begin(),

std::make_move_iterator(rows.begin()),

std::make_move_iterator(rows.end()));

const mcpp::manifest::Manifest& workspace,

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

if (member.toolchain.byPlatform.empty())

member.toolchain = workspace.toolchain;

for (auto& [triple, entry] : workspace.targetOverrides)

if (!member.targetOverrides.contains(triple))

member.targetOverrides[triple] = entry;

inherit_workspace_indices(member, workspace, wsRoot);

const mcpp::manifest::Manifest& workspace,

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

merge_workspace_deps(member, workspace, wsRoot);

inherit_workspace_root_position(member, workspace, wsRoot);

inherit_workspace_xlings(member, workspace);

// The two halves, each with a second caller of its own: a member reached

// as a sibling.s `path` dependency needs both, at two different points.

// (The "still missing after inheritance" refusal is

// `workspace_inheritance_error`, called by each site.)

inherit_workspace_package(member, workspace);

inherit_workspace_build(member, workspace, wsRoot);

const mcpp::manifest::Manifest& workspace,

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

const auto& inh = workspace.workspace.inherited;

if (!inh.buildPresent) return;

auto& b = member.buildConfig;

const auto& w = inh.build;

{

auto prepend = [](auto& dst, const auto& src) {

if (src.empty()) return;

dst.insert(dst.begin(), src.begin(), src.end());

};

prepend(b.cflags, w.cflags);

prepend(b.cxxflags, w.cxxflags);

prepend(b.ldflags, w.ldflags);

prepend(b.defines, w.defines);

prepend(b.dialectCxxflags, w.dialectCxxflags);

// A RELATIVE INCLUDE DIRECTORY IN THE WORKSPACE MANIFEST WAS WRITTEN

// AGAINST THE WORKSPACE ROOT, and every member would otherwise resolve

// it against its own directory.

//

// This is #224 for a new key: `[indices].path` and

// `[workspace.dependencies] path` are anchored for exactly this reason,

// and a third relative-path key that skipped it would silently point at

// `<member>/shared/inc` for a directory that lives at

// `<workspace>/shared/inc`. The failure is a missing header, three

// members deep, naming neither the manifest that declared it nor the

// root it was declared against.

//

// Anchored rather than refused: an absolute include directory is

// already accepted by `expandIncludeDirs`, so the anchored form needs

// no new handling downstream.

auto anchored = [&](const std::vector<std::filesystem::path>& src) {

std::vector<std::filesystem::path> out;

out.reserve(src.size());

for (auto const& d : src)

out.push_back(d.is_absolute() ? d

: (wsRoot / d).lexically_normal());

return out;

};

prepend(b.includeDirs, anchored(w.includeDirs));

prepend(b.includeDirsAfter, anchored(w.includeDirsAfter));

prepend(b.privateIncludeDirs, anchored(w.privateIncludeDirs));

if (b.cStandard.empty()) b.cStandard = w.cStandard;

if (b.linkage.empty()) b.linkage = w.linkage;

if (b.target.empty()) b.target = w.target;

if (b.cxxRuntime.empty()) b.cxxRuntime = w.cxxRuntime;

if (b.dependencyLinkage.empty()) b.dependencyLinkage = w.dependencyLinkage;

if (b.macosDeploymentTarget.empty())

b.macosDeploymentTarget = w.macosDeploymentTarget;

if (b.iosDeploymentTarget.empty())

b.iosDeploymentTarget = w.iosDeploymentTarget;

}