test_manifest.cpp

#include <gtest/gtest.h>

import std;
import mcpp.manifest;
import mcpp.libs.toml;
import mcpp.pm.dep_spec;
import mcpp.platform.axis;
import mcpp.platform;

TEST(Manifest, CppFlyStandard) {
    // standard = "c++fly": latest level + all experimental gates (design
    // 2026-07-14-std-features-experimental-gate-design.md §5.1).
    auto cfg = mcpp::manifest::normalize_cpp_standard("c++fly");
    ASSERT_TRUE(cfg.has_value());
    EXPECT_EQ(cfg->canonical, "c++fly");
    EXPECT_EQ(cfg->level, 1000);          // above c++latest's 999
    EXPECT_TRUE(cfg->experimental);
    EXPECT_FALSE(mcpp::manifest::normalize_cpp_standard("c++latest")->experimental);
    EXPECT_FALSE(mcpp::manifest::normalize_cpp_standard("c++26")->experimental);
    auto bad = mcpp::manifest::normalize_cpp_standard("c++flyy");
    ASSERT_FALSE(bad.has_value());
    EXPECT_NE(bad.error().find("c++fly"), std::string::npos);  // listed in the allow-list message
}

TEST(Manifest, Cpp20Standard) {
    // C++20 is the floor of the allow-list: named modules are a C++20 feature,
    // so nothing below it exists for this build model
    // (.agents/docs/2026-07-31-cpp20-standard-support-design.md).
    auto cfg = mcpp::manifest::normalize_cpp_standard("c++20");
    ASSERT_TRUE(cfg.has_value());
    EXPECT_EQ(cfg->canonical, "c++20");
    EXPECT_EQ(cfg->flag, "-std=c++20");
    EXPECT_EQ(cfg->level, 20);
    EXPECT_FALSE(cfg->gnuDialect);
    EXPECT_FALSE(cfg->experimental);

    // Aliases, symmetric with the existing c++2b / c++2c handling.
    auto alias = mcpp::manifest::normalize_cpp_standard("C++2a");   // also case-folded
    ASSERT_TRUE(alias.has_value());
    EXPECT_EQ(alias->canonical, "c++20");
    EXPECT_EQ(alias->level, 20);

    auto gnu = mcpp::manifest::normalize_cpp_standard("gnu++20");
    ASSERT_TRUE(gnu.has_value());
    EXPECT_EQ(gnu->canonical, "gnu++20");
    EXPECT_EQ(gnu->flag, "-std=gnu++20");
    EXPECT_EQ(gnu->level, 20);
    EXPECT_TRUE(gnu->gnuDialect);
    EXPECT_EQ(mcpp::manifest::normalize_cpp_standard("gnu++2a")->canonical, "gnu++20");

    // Below the floor stays rejected, and the message advertises the floor.
    auto bad = mcpp::manifest::normalize_cpp_standard("c++17");
    ASSERT_FALSE(bad.has_value());
    EXPECT_NE(bad.error().find("c++20"), std::string::npos) << bad.error();
}

TEST(Manifest, CppStandardLevelName) {
    EXPECT_EQ(mcpp::manifest::cpp_standard_level_name(20), "c++20");
    EXPECT_EQ(mcpp::manifest::cpp_standard_level_name(23), "c++23");
    EXPECT_EQ(mcpp::manifest::cpp_standard_level_name(26), "c++26");
}

TEST(Manifest, MinimalValid) {
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[targets.hello]
kind = "bin"
main = "src/main.cpp"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->package.name,    "hello");
    EXPECT_EQ(m->package.version, "0.1.0");
    EXPECT_EQ(m->language.standard, "c++23");
    EXPECT_TRUE(m->language.modules);
    ASSERT_EQ(m->targets.size(), 1u);
    EXPECT_EQ(m->targets[0].name, "hello");
    EXPECT_EQ(m->targets[0].kind, mcpp::manifest::Target::Binary);
}

TEST(Manifest, XlingsSubosPreservesDeclarationPresence) {
    auto absent = mcpp::manifest::parse_string(R"(
[package]
name = "absent"
version = "0.1.0"
)");
    ASSERT_TRUE(absent.has_value()) << absent.error().format();
    EXPECT_FALSE(absent->xlings.subosDeclared);

    auto explicitDefault = mcpp::manifest::parse_string(R"(
[package]
name = "explicit"
version = "0.1.0"
[xlings]
subos = "default"
)");
    ASSERT_TRUE(explicitDefault.has_value()) << explicitDefault.error().format();
    EXPECT_TRUE(explicitDefault->xlings.subosDeclared);
    EXPECT_EQ(explicitDefault->xlings.subos, "default");

    auto empty = mcpp::manifest::parse_string(R"(
[package]
name = "bad"
version = "0.1.0"
[xlings]
subos = ""
)");
    ASSERT_TRUE(empty.has_value()) << empty.error().format();
    EXPECT_TRUE(empty->xlings.subosDeclared);
    EXPECT_TRUE(empty->xlings.subos.empty());
}

TEST(Manifest, SharedTargetSoname) {
    constexpr auto src = R"(
[package]
name = "dep"
version = "0.1.0"
[build]
sources = ["src/*.c"]
[targets.dep]
kind = "shared"
soname = "libdep.so.1"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->targets.size(), 1u);
    EXPECT_EQ(m->targets[0].kind, mcpp::manifest::Target::SharedLibrary);
    EXPECT_EQ(m->targets[0].soname, "libdep.so.1");
}

TEST(Manifest, RejectsSonameOnANonLibraryTarget) {
    // ⚠️ NARROWED from "non-shared" to "non-library" (#519). A soname is the
    // name a library is FOUND by, and a package needs to be able to state it
    // while still being consumed as a static library — otherwise two copies
    // of one library can never resolve to a single file. An EXECUTABLE still
    // has no business declaring one.
    constexpr auto src = R"(
[package]
name = "app"
version = "0.1.0"
[targets.app]
kind = "bin"
main = "src/main.cpp"
soname = "libapp.so.1"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("soname is only valid for library targets"),
              std::string::npos);
}

TEST(Manifest, PackageStandardCpp26AcceptedAndMirrored) {
    constexpr auto src = R"(
[package]
name = "hello26"
version = "0.1.0"
standard = "c++26"
[modules]
sources = ["src/**/*.cppm"]
[targets.hello26]
kind = "bin"
main = "src/main.cpp"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->package.standard, "c++26");
    EXPECT_EQ(m->language.standard, "c++26");
}

TEST(Manifest, LegacyLanguageCpp2cNormalizesToCpp26) {
    constexpr auto src = R"(
[package]
name = "hello26"
version = "0.1.0"
[language]
standard = "c++2c"
[modules]
sources = ["src/**/*.cppm"]
[targets.hello26]
kind = "bin"
main = "src/main.cpp"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->package.standard, "c++26");
    EXPECT_EQ(m->language.standard, "c++26");
}

TEST(Manifest, RejectsStdFlagInCxxflags) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[build]
cxxflags = ["-std=c++26"]
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("[package].standard"), std::string::npos)
        << m.error().message;
}

TEST(Manifest, RejectMissingVersion) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("package.version"), std::string::npos);
}

TEST(Manifest, AcceptsCpp20WithImportStd) {
    // Was RejectImportStdWithoutCpp23: it asserted this manifest is rejected,
    // but the only thing rejecting it was the standard allow-list (there has
    // never been an import_std-specific rule) — so the test's name described
    // coverage it did not have. C++20 is legal now, and `import std;` is
    // available there on every toolchain mcpp ships, so the same manifest must
    // parse, with the legacy [language] section still mirroring to the new home.
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[language]
standard = "c++20"
import_std = true
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
)");
    ASSERT_TRUE(m.has_value()) << m.error().message;
    EXPECT_EQ(m->package.standard, "c++20");     // canonical, mirrored from [language]
    EXPECT_EQ(m->language.standard, "c++20");
    EXPECT_EQ(m->cppStandard.level, 20);
    EXPECT_EQ(m->cppStandard.flag, "-std=c++20");
}

TEST(Manifest, RejectsStandardBelowCpp20) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
standard = "c++17"
[targets.x]
kind = "bin"
main = "src/main.cpp"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("c++17"), std::string::npos)
        << m.error().message;
}

TEST(Manifest, RejectModulesFalse) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[language]
standard = "c++23"
modules = false
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
)");
    ASSERT_FALSE(m.has_value());
}

TEST(Manifest, ParsesDependencies) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
[dependencies]
"mcpplibs.primitives" = "0.0.1"
[dev-dependencies]
"gtest" = "1.15.2"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->dependencies.size(), 1u);
    EXPECT_EQ(m->dependencies.at("mcpplibs.primitives").version, "0.0.1");
    EXPECT_EQ(m->devDependencies.at("gtest").version, "1.15.2");
}

TEST(Manifest, ParsesDependencyVisibility) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
[dependencies.compat]
imgui = { version = "1.92.8", visibility = "private" }
glfw = { version = "3.4", visibility = "interface" }
opengl = "2026.05.31"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 3u);
    EXPECT_EQ(m->dependencies.at("compat.imgui").visibility, "private");
    EXPECT_EQ(m->dependencies.at("compat.glfw").visibility, "interface");
    EXPECT_EQ(m->dependencies.at("compat.opengl").visibility, "public");
}

// #242 — consumer-side `default-features = false`: a consumer opts out of a
// dependency's own [features].default set (Cargo parity). The flag parses into
// DependencySpec.defaultFeatures; explicitly requested `features = [...]` still
// come through. Default (omitted) stays true.
TEST(Manifest, ParsesDependencyDefaultFeaturesOptOut) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[modules]
sources = ["src/**/*.cppm"]
[targets.x]
kind = "bin"
main = "src/main.cpp"
[dependencies.compat]
ffmpeg = { version = "6.1", default-features = false, features = ["avcodec"] }
zlib = "1.3"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 2u);
    // Opt-out dependency: flag is false, but the explicit feature still parses.
    const auto& ff = m->dependencies.at("compat.ffmpeg");
    EXPECT_FALSE(ff.defaultFeatures);
    ASSERT_EQ(ff.features.size(), 1u);
    EXPECT_EQ(ff.features[0], "avcodec");
    EXPECT_EQ(ff.version, "6.1");
    // Bare-string dependency: defaultFeatures defaults to true.
    EXPECT_TRUE(m->dependencies.at("compat.zlib").defaultFeatures);
}

TEST(Manifest, RejectsInvalidDependencyVisibility) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"
[dependencies.compat]
imgui = { version = "1.92.8", visibility = "implementation" }
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("visibility"), std::string::npos);
}

TEST(Manifest, DefaultTemplateRoundTrip) {
    auto src = mcpp::manifest::default_template("hello");
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->package.name, "hello");
}

TEST(ManifestEditor, UpsertsCanonicalDependencyByExactPackageId) {
    constexpr std::string_view source = R"([package]
name = "app"
version = "0.1.0"

[dependencies.compat]
widget = "1.0.0"
)";
    auto edited = mcpp::manifest::upsert_dependency_text(source, {
        .namespace_ = "acme",
        .shortName = "widget",
        .version = "2.0.0",
        .features = {"gui", "vulkan"},
    });
    ASSERT_TRUE(edited.has_value()) << edited.error();
    EXPECT_NE(edited->find("[dependencies.acme]\nwidget = { version = \"2.0.0\", features = [\"gui\", \"vulkan\"] }"),
              std::string::npos);
    auto parsed = mcpp::manifest::parse_string(*edited);
    ASSERT_TRUE(parsed.has_value()) << parsed.error().format();
    ASSERT_EQ(parsed->dependencies.size(), 2u);
    EXPECT_EQ(parsed->dependencies.at("acme.widget").namespace_, "acme");
    EXPECT_EQ(parsed->dependencies.at("acme.widget").shortName, "widget");
    EXPECT_EQ(parsed->dependencies.at("acme.widget").version, "2.0.0");
    EXPECT_EQ(parsed->dependencies.at("acme.widget").features,
              (std::vector<std::string>{"gui", "vulkan"}));
    EXPECT_EQ(parsed->dependencies.at("compat.widget").version, "1.0.0");
}

TEST(ManifestEditor, ReplacesCanonicalEntryAndRejectsInvalidSource) {
    constexpr std::string_view source = R"([package]
name = "app"
version = "0.1.0"

[dependencies.acme]
widget = "1.0.0"
)";
    auto edited = mcpp::manifest::upsert_dependency_text(source, {
        .namespace_ = "acme",
        .shortName = "widget",
        .version = "3.0.0",
    });
    ASSERT_TRUE(edited.has_value()) << edited.error();
    auto parsed = mcpp::manifest::parse_string(*edited);
    ASSERT_TRUE(parsed.has_value()) << parsed.error().format();
    EXPECT_EQ(parsed->dependencies.at("acme.widget").version, "3.0.0");
    EXPECT_EQ(std::ranges::count(*edited, '\n'),
              std::ranges::count(source, '\n'));

    auto invalid = mcpp::manifest::upsert_dependency_text(
        "[package\nname = \"broken\"", {
            .namespace_ = "acme",
            .shortName = "widget",
            .version = "1.0.0",
        });
    ASSERT_FALSE(invalid.has_value());
    EXPECT_NE(invalid.error().find("invalid manifest"), std::string::npos);
}

TEST(ListXpkgVersions, MultipleEntriesAcrossPlatforms) {
    constexpr auto src = R"(
package = {
    name = "foo",
    xpm = {
        linux = {
            ["0.1.0"] = { url = "u1", sha256 = "x" },
            ["0.2.0"] = { url = "u2", sha256 = "y" },
            ["1.0.0"] = { url = "u3", sha256 = "z" },
        },
        macosx = {
            ["0.1.0"] = { url = "u1m", sha256 = "x" },
        },
    },
}
)";
    auto linux = mcpp::manifest::list_xpkg_versions(src, mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_EQ(linux.size(), 3u);
    EXPECT_EQ(linux[0], "0.1.0");
    EXPECT_EQ(linux[1], "0.2.0");
    EXPECT_EQ(linux[2], "1.0.0");

    auto mac = mcpp::manifest::list_xpkg_versions(src, mcpp::platform::TargetPlatform::for_lint_of("macosx"));
    ASSERT_EQ(mac.size(), 1u);
    EXPECT_EQ(mac[0], "0.1.0");

    auto win = mcpp::manifest::list_xpkg_versions(src, mcpp::platform::TargetPlatform::for_lint_of("windows"));
    EXPECT_TRUE(win.empty());
}

TEST(ListXpkgVersions, MissingXpmReturnsEmpty) {
    constexpr auto src = R"(package = { name = "foo" })";
    EXPECT_TRUE(mcpp::manifest::list_xpkg_versions(src, mcpp::platform::TargetPlatform::for_lint_of("linux")).empty());
}

// #363: `["25.0.4"] = { ref = "25.0.4.7.1" }` is a POINTER at another entry,
// not a release. Shape copied from the real jdk-corretto / jdk-temurin
// descriptors. Treating it as a version gave range resolution a candidate that
// ties with (or truncates to something other than) its own target.
TEST(ListXpkgVersions, AliasEntriesAreFlagged) {
    constexpr auto src = R"(
package = {
    name = "jdk",
    xpm = {
        linux = {
            ["latest"]     = { ref = "25.0.4.7.1" },
            ["25.0.4"]     = { ref = "25.0.4.7.1" },
            ["25.0.4.7.1"] = { url = "u", sha256 = "z" },
        },
    },
}
)";
    auto e = mcpp::manifest::list_xpkg_version_entries(
        src, mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_EQ(e.size(), 3u);
    EXPECT_EQ(e[0].version, "latest");      EXPECT_TRUE (e[0].alias);
    EXPECT_EQ(e[1].version, "25.0.4");      EXPECT_TRUE (e[1].alias);
    EXPECT_EQ(e[2].version, "25.0.4.7.1");  EXPECT_FALSE(e[2].alias);
    EXPECT_TRUE(e[0].sha256.empty());
    EXPECT_TRUE(e[1].sha256.empty());
    EXPECT_EQ(e[2].sha256, "z");

    // The keys-only view is unchanged for every existing caller.
    auto keys = mcpp::manifest::list_xpkg_versions(
        src, mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_EQ(keys.size(), 3u);
    EXPECT_EQ(keys[2], "25.0.4.7.1");
}

// The scanner used to walk the platform table character by character, so a
// bracket key nested inside a version's own body (mirror tables write
// `["GLOBAL"] = "https://..."`) counted as a published version.
TEST(ListXpkgVersions, NestedBracketKeysAreNotVersions) {
    constexpr auto src = R"(
package = {
    name = "foo",
    xpm = {
        linux = {
            ["1.0.0"] = {
                url = { ["GLOBAL"] = "u-global", ["CN"] = "u-cn" },
                sha256 = "z",
            },
            ["1.1.0"] = { url = "u", sha256 = "z" },
        },
    },
}
)";
    auto keys = mcpp::manifest::list_xpkg_versions(
        src, mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_EQ(keys.size(), 2u);
    EXPECT_EQ(keys[0], "1.0.0");
    EXPECT_EQ(keys[1], "1.1.0");
}

TEST(Manifest, BuildCflagsCxxflagsAndCStandard) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
sources    = ["src/**/*.{cppm,c}"]
cflags     = ["-Wall", "-DFOO=1"]
cxxflags   = ["-Wextra"]
ldflags    = ["-lfoo", "-Wl,--as-needed"]
c_standard = "c11"
[targets.x]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.cflags.size(), 2u);
    EXPECT_EQ(m->buildConfig.cflags[0], "-Wall");
    EXPECT_EQ(m->buildConfig.cflags[1], "-DFOO=1");
    ASSERT_EQ(m->buildConfig.cxxflags.size(), 1u);
    EXPECT_EQ(m->buildConfig.cxxflags[0], "-Wextra");
    ASSERT_EQ(m->buildConfig.ldflags.size(), 2u);
    EXPECT_EQ(m->buildConfig.ldflags[0], "-lfoo");
    EXPECT_EQ(m->buildConfig.ldflags[1], "-Wl,--as-needed");
    EXPECT_EQ(m->buildConfig.cStandard, "c11");
}

// #296: [build].defines is sugar for `-D<x>` on both C and C++ channels; it
// must parse into buildConfig.defines so prepare_build can fold it into flags
// before the P1689 scan and fingerprint. Order is preserved because the fold
// appends in declaration order and "last flag wins" is the override semantics.
TEST(Manifest, BuildDefinesParsesIntoSeparateVector) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
defines = ["TEST_USE_MODULES", "VALUE=42"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.defines.size(), 2u);
    EXPECT_EQ(m->buildConfig.defines[0], "TEST_USE_MODULES");
    EXPECT_EQ(m->buildConfig.defines[1], "VALUE=42");
    // A well-formed [build] must not warn — the unknown-key guard below is
    // only allowed to fire on keys the parser genuinely does not read.
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

// ── #540: the three vocabularies, and the drift that keeps happening ────────
//
// `kKnownBuildKeys`, `kKnownConditionalBuildKeys` and the xpkg `target_cfg`
// list are hand-written transcriptions of sets that exist elsewhere in
// machine-readable form — the `doc->get_*()` reads immediately above them, and
// `BuildInputs`'s member list. All three had drifted, in different directions,
// and `kKnownBuildKeys` had drifted TWICE: the comment beside it narrates the
// `bmi_schedule` occurrence in detail while three keys eight lines above it
// were in the same state.
//
// The user-visible cost is not a missing warning. It is a warning that is
// FALSE — "[build] has unsupported key 'std-module' (ignored)" for a key read
// a few hundred lines above and taking full effect — which is worse than
// silence, because the only sentence mcpp offers about the key says the
// opposite of what happens.
//
// ⚠️ THE LIST BELOW IS ANOTHER COPY, AND THAT IS THE POINT. A copy that fails
// loudly when it disagrees is the whole difference from the arrangement that
// let this happen twice. Add a key to the parser, add it here; if you forget,
// the negative control at the bottom of each test still passes and this one
// goes red.
TEST(Manifest, EveryBuildKeyTheParserReadsIsAccepted) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
allow_host_libs       = false
bmi_schedule          = "auto"
build_program_timeout = 120
c_standard            = "c17"
cache                 = "local"
cflags                = ["-Wall"]
cxxflags              = ["-Wall"]
cxx_runtime           = "self-contained"
default-profile       = "release"
defines               = ["A=1"]
dependency_linkage    = "static"
dialect_cxxflags      = ["-fno-rtti"]
include_dirs          = ["include"]
include_dirs_after    = ["compat"]
private_include_dirs  = ["internal"]
jobs                  = 4
ldflags               = ["-Wl,--as-needed"]
macos_deployment_target = "14.0"
module_extensions     = [".ixx"]
flags                 = []
profile               = "release"
target                = "x86_64-linux-gnu"
sources               = ["src/**/*.cpp"]
static_stdlib         = false
std-module            = "gen/std.cppm"
std-compat-module     = "gen/std.compat.cppm"
std-module-flags      = ["-D_GNU_SOURCE"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    std::string all;
    for (auto const& w : m->schemaWarnings) { all += w; all += '\n'; }
    EXPECT_TRUE(m->schemaWarnings.empty())
        << "a key the parser reads was reported as unsupported:\n" << all;
    // The three that were absent, asserted individually so a regression names
    // itself rather than arriving as "some warning appeared".
    EXPECT_EQ(m->stdModule,       "gen/std.cppm");
    EXPECT_EQ(m->stdCompatModule, "gen/std.compat.cppm");
    ASSERT_EQ(m->buildConfig.stdModuleFlags.size(), 1u);
    EXPECT_EQ(m->buildConfig.stdModuleFlags[0], "-D_GNU_SOURCE");
}

// The negative control. Without it the test above passes against a parser whose
// unknown-key check has been deleted outright, which is the failure mode a
// "no warnings" assertion invites.
TEST(Manifest, AnUnknownBuildKeyIsStillReported) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
std_module = "gen/std.cppm"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    // The underscore spelling is the plausible typo for the hyphenated key, so
    // it is the one worth holding: accepting it silently is how `schedule` got
    // in while `bmi_schedule` was being reported as unsupported.
    EXPECT_NE(m->schemaWarnings[0].find("std_module"), std::string::npos)
        << m->schemaWarnings[0];
    // The message must carry the SAME list the check uses — it used to be a
    // third hand-written copy and had drifted from both others.
    EXPECT_NE(m->schemaWarnings[0].find("std-module"), std::string::npos)
        << "the message must name the supported keys it actually checks against";
}

// `kKnownConditionalBuildKeys`' own comment says its vocabulary "is exactly
// that struct's members" and "MUST stay in sync with the reads above and with
// types.cppm's BuildInputs". It was two members short of that claim, and one of
// the two — `private_include_dirs` — is ACCEPTED by the xpkg descriptor's
// `target_cfg` block, the other grammar for this same axis. So one spelling of
// a conditional private include directory worked and the other reported the
// key as unsupported.
TEST(Manifest, EveryConditionalBuildKeyTheAxisCarriesIsAccepted) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.'cfg(linux)'.build]
cflags               = ["-Wall"]
cxxflags             = ["-Wall"]
defines              = ["A=1"]
include_dirs         = ["include"]
include_dirs_after   = ["compat"]
ldflags              = ["-Wl,--as-needed"]
private_include_dirs = ["internal"]
sources              = ["src/extra.cpp"]
std-module-flags     = ["-D_GNU_SOURCE"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    std::string all;
    for (auto const& w : m->schemaWarnings) { all += w; all += '\n'; }
    EXPECT_TRUE(m->schemaWarnings.empty())
        << "a BuildInputs member the axis carries was reported unsupported:\n" << all;
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    auto const& in = m->conditionalConfigs[0].inputs;
    // #494 moved `std-module-flags` onto BuildInputs specifically so this axis
    // could carry it — "membership here is what makes the cfg axis carry it",
    // with -D_GNU_SOURCE right for musl and glibc and wrong for picolibc as the
    // stated case. The member and the merge landed; the READ did not.
    ASSERT_EQ(in.stdModuleFlags.size(), 1u);
    EXPECT_EQ(in.stdModuleFlags[0], "-D_GNU_SOURCE");
    ASSERT_EQ(in.privateIncludeDirs.size(), 1u);
    EXPECT_EQ(in.privateIncludeDirs[0].generic_string(), "internal");
}

TEST(Manifest, AnUnknownConditionalBuildKeyIsStillReported) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.'cfg(linux)'.build]
static_stdlib = true
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("static_stdlib"), std::string::npos)
        << m->schemaWarnings[0];
    // Built from the list, not written beside it: the prose form named eight
    // keys and was two behind the check it was describing.
    EXPECT_NE(m->schemaWarnings[0].find("std-module-flags"), std::string::npos)
        << "the message must be generated from the same list the check uses";
}

// #540: `[features]` was the one structured section with no schema check at
// all, so a misplaced `include_dirs` inside a feature built successfully with
// zero diagnostics — while the identical misplacement in `[build]` or
// `[target.<pred>.build]` is reported.
TEST(Manifest, EveryFeatureKeyTheParserReadsIsAccepted) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[features]
full = { implies = ["fast"], forward = ["dep/feat"], defines = ["WITH_FULL"], sources = ["src/full.cpp"], requires = ["cap"], provides = ["cap2"], flags = [] }
fast = []
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    std::string all;
    for (auto const& w : m->schemaWarnings) { all += w; all += '\n'; }
    EXPECT_TRUE(m->schemaWarnings.empty())
        << "a feature key the parser reads was reported as unsupported:\n" << all;
}

TEST(Manifest, AnUnknownFeatureKeyIsReported) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[features]
fast = { implies = [], include_dirs = ["nope"] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("include_dirs"), std::string::npos)
        << m->schemaWarnings[0];
    EXPECT_NE(m->schemaWarnings[0].find("fast"), std::string::npos)
        << "the message must name WHICH feature carries the key";
}

// `deps` is reserved rather than wrong — the parser's own comment has promised
// it since Feature System v2 — so it is reported as reserved. Saying
// "unsupported" would deny a documented plan; saying nothing is what let it
// look implemented.
TEST(Manifest, AReservedFeatureKeySaysItIsReserved) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[features]
fast = { implies = [], deps = ["zlib"] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("reserved"), std::string::npos)
        << m->schemaWarnings[0];
}

// #296: `defines` is a BuildInputs member, NOT a BuildConfig-only field — so
// the cfg axis carries it like any other build input. This is the regression
// that matters: a platform-only macro must be expressible, because a key that
// parses unconditionally but vanishes under `[target.'cfg(...)'.build]` is the
// exact silent-drop failure #296 was filed for, just one section over.
TEST(Manifest, ConditionalBuildDefinesAreCarriedByTheCfgAxis) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
defines = ["BASE"]
[target.'cfg(windows)'.build]
defines = ["USE_WIN32", "WINVER=0x0A00"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    EXPECT_EQ(m->conditionalConfigs[0].predicate, "cfg(windows)");
    ASSERT_EQ(m->conditionalConfigs[0].inputs.defines.size(), 2u);
    EXPECT_EQ(m->conditionalConfigs[0].inputs.defines[0], "USE_WIN32");
    EXPECT_EQ(m->conditionalConfigs[0].inputs.defines[1], "WINVER=0x0A00");
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

// A conditional section carrying ONLY `defines` must still be recorded — the
// emptiness gate that decides whether to push a ConditionalConfig has to know
// about every BuildInputs member, or the section is dropped before it is ever
// evaluated.
TEST(Manifest, ConditionalSectionWithOnlyDefinesIsRecorded) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.'cfg(linux)'.build]
defines = ["ONLY_DEFINE"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    ASSERT_EQ(m->conditionalConfigs[0].inputs.defines.size(), 1u);
    EXPECT_EQ(m->conditionalConfigs[0].inputs.defines[0], "ONLY_DEFINE");
}

// The single additive merge must carry `defines` too — merge_conditional_
// build_inputs routes the cfg axis through append(), so a member missing here
// is a member that silently never reaches the build.
TEST(Manifest, AppendBuildInputsMergesDefines) {
    mcpp::manifest::BuildInputs dst, src;
    dst.defines = {"BASE"};
    src.defines = {"COND"};
    mcpp::manifest::append(dst, src);
    ASSERT_EQ(dst.defines.size(), 2u);
    EXPECT_EQ(dst.defines[0], "BASE");
    // Conditional entries land AFTER the base ones so GNU last-wins gives the
    // conditional rule precedence (an off-OS `-U` after the base `-D`).
    EXPECT_EQ(dst.defines[1], "COND");
}

// #296 root cause: an unknown [build] key used to vanish without a word, and
// the build then failed much later with a module-graph divergence naming
// neither the key nor the manifest. Same policy as [targets.<name>]: a schema
// warning (an error under --strict).
TEST(Manifest, UnknownBuildKeyIsReportedNotSilentlyDropped) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
cxxflags = ["-Wall"]
defnes   = ["TYPO"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("defnes"), std::string::npos)
        << m->schemaWarnings[0];
    EXPECT_NE(m->schemaWarnings[0].find("[build]"), std::string::npos)
        << m->schemaWarnings[0];
    // The key is still ignored — this is a warning, not a parse failure.
    EXPECT_EQ(m->buildConfig.cxxflags.size(), 1u);
}

// The conditional axis may only contribute build INPUTS, so a selection knob
// under it is inexpressible by construction. Say so rather than dropping it.
TEST(Manifest, UnknownConditionalBuildKeyIsReported) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.'cfg(windows)'.build]
cxxflags      = ["-DOK"]
static_stdlib = false
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("static_stdlib"), std::string::npos)
        << m->schemaWarnings[0];
    EXPECT_NE(m->schemaWarnings[0].find("cfg(windows)"), std::string::npos)
        << m->schemaWarnings[0];
}

// Every key the [build] parser actually reads must be absent from the
// unknown-key warning — a guard that fires on a supported key is worse than
// no guard, because --strict turns it into a build failure.
TEST(Manifest, EverySupportedBuildKeyPassesTheUnknownKeyGuard) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
sources                 = ["src/**/*.cpp"]
cflags                  = ["-O2"]
cxxflags                = ["-Wall"]
ldflags                 = ["-lm"]
defines                 = ["A"]
flags                   = [{ glob = "src/*.c", defines = ["B"] }]
include_dirs            = ["include"]
include_dirs_after      = ["vendor"]
dialect_cxxflags        = ["-fcontracts"]
c_standard              = "c11"
target                  = "x86_64-linux-musl"
static_stdlib           = true
allow_host_libs         = false
profile                 = "dev"
macos_deployment_target = "14.0"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

// `default-profile` is the canonical spelling of the `profile` alias; both
// must clear the guard.
TEST(Manifest, BuildDefaultProfileSpellingPassesTheUnknownKeyGuard) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
default-profile = "dev"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.defaultProfile, "dev");
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

// #249: `[build] include_dirs_after` parses into buildConfig.includeDirsAfter
// — the -idirafter channel (searched AFTER the toolchain's system dirs), so
// an extracted-tarball root containing a file named like a standard header
// (ffmpeg's VERSION vs libc++'s <version> on case-insensitive macOS) can't
// shadow it while its real headers stay findable.
TEST(Manifest, BuildIncludeDirsAfterToml) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
sources           = ["src/**/*.cpp"]
include_dirs      = ["include"]
include_dirs_after = ["*", "vendor/include"]
[targets.x]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.includeDirs.size(), 1u);
    EXPECT_EQ(m->buildConfig.includeDirs[0], "include");
    ASSERT_EQ(m->buildConfig.includeDirsAfter.size(), 2u);
    EXPECT_EQ(m->buildConfig.includeDirsAfter[0], "*");
    EXPECT_EQ(m->buildConfig.includeDirsAfter[1], "vendor/include");
}

// Feature System v2 Stage 1: a [features] entry may be a TABLE carrying
// package-owned `defines` (and `implies`), while the array shorthand keeps
// meaning "implied features". See
// .agents/docs/2026-06-29-feature-capability-model-design.md.
TEST(Manifest, FeatureTableFormDefinesAndImplies) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
default  = ["base"]
base     = []
accel    = { defines = ["APP_ACCEL=1", "APP_FAST"], implies = ["base"] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    // Array shorthand still registers an implied-feature list.
    ASSERT_TRUE(m->featuresMap.contains("default"));
    ASSERT_EQ(m->featuresMap["default"].size(), 1u);
    EXPECT_EQ(m->featuresMap["default"][0], "base");

    // Table form: `implies` flows into featuresMap, `defines` into featureDefines.
    ASSERT_TRUE(m->featuresMap.contains("accel"));
    ASSERT_EQ(m->featuresMap["accel"].size(), 1u);
    EXPECT_EQ(m->featuresMap["accel"][0], "base");

    ASSERT_TRUE(m->buildConfig.featureDefines.contains("accel"));
    ASSERT_EQ(m->buildConfig.featureDefines["accel"].size(), 2u);
    EXPECT_EQ(m->buildConfig.featureDefines["accel"][0], "APP_ACCEL=1");
    EXPECT_EQ(m->buildConfig.featureDefines["accel"][1], "APP_FAST");

    // A feature with no defines contributes no featureDefines entry.
    EXPECT_FALSE(m->buildConfig.featureDefines.contains("base"));
}

// Feature System v2 Stage 3: capabilities. A feature may `requires`/`provides`
// abstract capabilities; the package may `provides` them at package level; and
// the root [capabilities] table pins providers.
TEST(Manifest, CapabilitiesProvidesRequiresAndPins) {
    constexpr auto src = R"(
[package]
name     = "x"
version  = "0.1.0"
provides = ["blas"]
[targets.x]
kind = "lib"
[features]
default     = []
use_blas    = { requires = ["blas"] }
provide_lap = { provides = ["lapack"] }
[capabilities]
blas = "openblas"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    ASSERT_EQ(m->provides.size(), 1u);
    EXPECT_EQ(m->provides[0], "blas");

    ASSERT_TRUE(m->featureRequires.contains("use_blas"));
    ASSERT_EQ(m->featureRequires["use_blas"].size(), 1u);
    EXPECT_EQ(m->featureRequires["use_blas"][0], "blas");

    ASSERT_TRUE(m->featureProvides.contains("provide_lap"));
    EXPECT_EQ(m->featureProvides["provide_lap"][0], "lapack");

    ASSERT_TRUE(m->capabilityPins.contains("blas"));
    EXPECT_EQ(m->capabilityPins["blas"], "openblas");
}

// The Lua descriptor surface (index packages) parses package-level `provides`
// and feature-scoped `requires`/`provides`/`defines`.
TEST(SynthesizeFromXpkgLua, CapabilitiesAndFeatureDefines) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "compat.eigen",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources  = { "*/anchor.c" },
        provides = { "blas" },
        targets  = { ["eigen"] = { kind = "lib" } },
        features = {
            ["use_blas"]   = { defines = { "EIGEN_USE_BLAS" }, requires = { "blas" } },
            ["eigen_blas"] = { sources = { "*/blas/*.cpp" },   provides = { "blas" } },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "compat.eigen", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();

    ASSERT_EQ(m->provides.size(), 1u);
    EXPECT_EQ(m->provides[0], "blas");

    ASSERT_TRUE(m->buildConfig.featureDefines.contains("use_blas"));
    EXPECT_EQ(m->buildConfig.featureDefines["use_blas"][0], "EIGEN_USE_BLAS");
    ASSERT_TRUE(m->featureRequires.contains("use_blas"));
    EXPECT_EQ(m->featureRequires["use_blas"][0], "blas");
    ASSERT_TRUE(m->featureProvides.contains("eigen_blas"));
    EXPECT_EQ(m->featureProvides["eigen_blas"][0], "blas");
    // sources still gated as before.
    ASSERT_TRUE(m->buildConfig.featureSources.contains("eigen_blas"));
}

// #253: a [features] table-form entry may carry `flags` — per-feature per-glob
// compile flags, the same entry grammar as [build].flags. Parsed into
// buildConfig.featureFlags keyed by feature; base globFlags stay untouched at
// parse time (activation folds them in later, in prepare_build).
TEST(Manifest, FeatureFlagsTomlTableForm) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[build]
flags = [{ glob = "src/base/**", defines = ["BASE"] }]
[features]
default = []
simd    = { sources = ["src/simd/**"], flags = [
              { glob = "src/simd/**/*.avx2.cpp", cxxflags = ["-mavx2"], defines = ["HAVE_AVX2"] },
              { glob = "src/simd/**/*.neon.cpp", cxxflags = ["-mfpu=neon"] } ] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    ASSERT_TRUE(m->buildConfig.featureFlags.contains("simd"));
    auto& ff = m->buildConfig.featureFlags["simd"];
    ASSERT_EQ(ff.size(), 2u);   // declaration order preserved
    EXPECT_EQ(ff[0].glob, "src/simd/**/*.avx2.cpp");
    ASSERT_EQ(ff[0].cxxflags.size(), 1u);
    EXPECT_EQ(ff[0].cxxflags[0], "-mavx2");
    ASSERT_EQ(ff[0].defines.size(), 1u);
    EXPECT_EQ(ff[0].defines[0], "HAVE_AVX2");
    EXPECT_EQ(ff[1].glob, "src/simd/**/*.neon.cpp");
    // Parse-time base globFlags carry ONLY the [build].flags entry.
    ASSERT_EQ(m->buildConfig.globFlags.size(), 1u);
    EXPECT_EQ(m->buildConfig.globFlags[0].glob, "src/base/**");
    // Gated sources still land in featureSources alongside.
    ASSERT_TRUE(m->buildConfig.featureSources.contains("simd"));
}

// #253: feature `flags` entries share [build].flags' closed grammar — a
// missing `glob` and an unknown entry key are hard errors naming the
// feature-scoped anchoring key.
TEST(Manifest, FeatureFlagsTomlErrors) {
    constexpr auto missingGlob = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
simd = { flags = [{ cxxflags = ["-mavx2"] }] }
)";
    auto m1 = mcpp::manifest::parse_string(missingGlob);
    ASSERT_FALSE(m1.has_value());
    EXPECT_NE(m1.error().message.find("[features].simd.flags"), std::string::npos)
        << m1.error().message;
    EXPECT_NE(m1.error().message.find("glob"), std::string::npos);

    constexpr auto badKey = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
simd = { flags = [{ glob = "src/**", ldflags = ["-lfoo"] }] }
)";
    auto m2 = mcpp::manifest::parse_string(badKey);
    ASSERT_FALSE(m2.has_value());
    EXPECT_NE(m2.error().message.find("ldflags"), std::string::npos)
        << m2.error().message;
}

// #253 Lua descriptor surface: `features.<name>.flags` parses into
// featureFlags (same entry grammar as the build-level `flags` key) and is a
// KNOWN subfield — it must not land in xpkgUnknownKeys.
TEST(SynthesizeFromXpkgLua, FeatureFlagsParse) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "compat.opencv",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/core/*.cpp" },
        targets = { ["opencv"] = { kind = "lib" } },
        flags   = { { glob = "*/core/*.cpp", defines = { "BASE" } } },
        features = {
            ["dnn"] = {
                sources = { "*/3rdparty/mlas/lib/*.cpp" },
                flags = {
                    { glob = "**/3rdparty/mlas/**",
                      defines = { "BUILD_MLAS_NO_ONNXRUNTIME=1", "MLAS_GEMM_ONLY=1" } },
                    { glob = "**/modules/dnn/**/*.avx2.cpp",
                      cxxflags = { "-mavx2" } },
                },
            },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "compat.opencv", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_TRUE(m->xpkgUnknownKeys.empty());

    ASSERT_TRUE(m->buildConfig.featureFlags.contains("dnn"));
    auto& ff = m->buildConfig.featureFlags["dnn"];
    ASSERT_EQ(ff.size(), 2u);
    EXPECT_EQ(ff[0].glob, "**/3rdparty/mlas/**");
    ASSERT_EQ(ff[0].defines.size(), 2u);
    EXPECT_EQ(ff[0].defines[0], "BUILD_MLAS_NO_ONNXRUNTIME=1");
    EXPECT_EQ(ff[1].glob, "**/modules/dnn/**/*.avx2.cpp");
    // Base per-glob flags untouched at parse time.
    ASSERT_EQ(m->buildConfig.globFlags.size(), 1u);
    EXPECT_EQ(m->buildConfig.globFlags[0].glob, "*/core/*.cpp");

    // Unknown entry subkey is a hard error carrying the feature-scoped label.
    constexpr auto bad = R"(
package = {
    spec = "1",
    name = "compat.opencv",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources  = { "*/core/*.cpp" },
        features = { ["dnn"] = { flags = { { glob = "x", ldflags = { "-lfoo" } } } } },
    },
}
)";
    auto mb = mcpp::manifest::synthesize_from_xpkg_lua(bad, "compat.opencv", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_FALSE(mb.has_value());
    EXPECT_NE(mb.error().message.find("features.dnn.flags"), std::string::npos)
        << mb.error().message;
}

// #253: per-OS descriptor sections participate in `features` via the same
// textual-splice additive overlay every mcpp-segment key gets — same-named
// features merge per-subkey by APPEND (base body first, OS body second), and a
// per-OS section may register an OS-only feature. Locked here because the
// common/delta pattern (neutral common payload + per-OS delta) depends on it.
TEST(SynthesizeFromXpkgLua, PerOsFeaturesAdditiveMerge) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "compat.opencv",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/core/*.cpp" },
        features = {
            ["dnn"] = {
                defines = { "HAVE_OPENCV_DNN" },
                sources = { "*/modules/dnn/src/*.cpp" },
            },
        },
        linux = {
            features = {
                ["dnn"] = {
                    sources = { "*/3rdparty/mlas/lib/x86_64/*.S" },
                    flags   = { { glob = "**/3rdparty/mlas/**", defines = { "MLAS_X86" } } },
                },
                ["vaapi"] = { defines = { "HAVE_VAAPI" } },
            },
        },
        macosx = {
            features = {
                ["dnn"] = { sources = { "*/modules/dnn/neon/*.cpp" } },
            },
        },
    },
}
)";
    // linux leg: neutral payload + linux delta, macosx section invisible.
    auto ml = mcpp::manifest::synthesize_from_xpkg_lua(
        lua, "compat.opencv", "1.0.0", mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_TRUE(ml.has_value()) << ml.error().format();
    ASSERT_TRUE(ml->buildConfig.featureSources.contains("dnn"));
    {
        auto& srcs = ml->buildConfig.featureSources["dnn"];
        ASSERT_EQ(srcs.size(), 2u);   // append order: neutral first, OS delta after
        EXPECT_EQ(srcs[0], "*/modules/dnn/src/*.cpp");
        EXPECT_EQ(srcs[1], "*/3rdparty/mlas/lib/x86_64/*.S");
    }
    ASSERT_TRUE(ml->buildConfig.featureFlags.contains("dnn"));
    EXPECT_EQ(ml->buildConfig.featureFlags["dnn"][0].glob, "**/3rdparty/mlas/**");
    // OS-only feature registered (requestable) on this leg only.
    EXPECT_TRUE(ml->featuresMap.contains("vaapi"));
    ASSERT_TRUE(ml->buildConfig.featureDefines.contains("vaapi"));
    EXPECT_EQ(ml->buildConfig.featureDefines["vaapi"][0], "HAVE_VAAPI");

    // macosx leg: NEON delta instead, no mlas flags, no vaapi.
    auto mm = mcpp::manifest::synthesize_from_xpkg_lua(
        lua, "compat.opencv", "1.0.0", mcpp::platform::TargetPlatform::for_lint_of("macosx"));
    ASSERT_TRUE(mm.has_value()) << mm.error().format();
    {
        auto& srcs = mm->buildConfig.featureSources["dnn"];
        ASSERT_EQ(srcs.size(), 2u);
        EXPECT_EQ(srcs[0], "*/modules/dnn/src/*.cpp");
        EXPECT_EQ(srcs[1], "*/modules/dnn/neon/*.cpp");
    }
    EXPECT_FALSE(mm->buildConfig.featureFlags.contains("dnn"));
    EXPECT_FALSE(mm->featuresMap.contains("vaapi"));
}

// Feature System v2 Stage 2a: optional deps activated by a feature.
// TOML surface uses a dedicated [feature-deps.<name>] section.
// ⚠️ The fixture used to say `zlib = "1.3.x"`, which cannot resolve: a trailing
// `.x` is not a selector this resolver has. It went unnoticed because the same
// form was in the documented `[feature-deps]` example, and because a fixture
// only has to PARSE — nothing here ever asked the index for that package. It
// reached a published package (`std-freestanding` 0.3.0) before it was measured.
TEST(Manifest, FeatureDepsTomlSection) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
default = []
backend = []
[feature-deps.backend]
zlib = "1.3"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_TRUE(m->featureDeps.contains("backend"));
    EXPECT_EQ(m->featureDeps["backend"].size(), 1u);
    // The optional dep is NOT in the always-on dependency set.
    EXPECT_FALSE(m->dependencies.contains("zlib"));
}

// Lua descriptor surface: a feature carries `deps` (nested table) + `implies`.
TEST(SynthesizeFromXpkgLua, FeatureDepsAndImplies) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "compat.eigen",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/anchor.c" },
        targets = { ["eigen"] = { kind = "lib" } },
        features = {
            ["use_blas"]         = { defines = { "EIGEN_USE_BLAS" }, requires = { "blas" } },
            ["backend-openblas"] = { implies = { "use_blas" }, deps = { ["compat.openblas"] = "0.3.x" } },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "compat.eigen", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    // implies recorded in featuresMap
    ASSERT_TRUE(m->featuresMap.contains("backend-openblas"));
    ASSERT_EQ(m->featuresMap["backend-openblas"].size(), 1u);
    EXPECT_EQ(m->featuresMap["backend-openblas"][0], "use_blas");
    // deps recorded in featureDeps, NOT in the always-on dependency set
    ASSERT_TRUE(m->featureDeps.contains("backend-openblas"));
    EXPECT_EQ(m->featureDeps["backend-openblas"].size(), 1u);
    EXPECT_TRUE(m->dependencies.empty());
}

// Feature System v2 #243: dep/feat forwarding (Cargo parity). A `[features]`
// implied-feature token containing '/' means "when this feature is active,
// request <depFeature> from dependency <depKey>". It is split out of the
// implies list into featureForwards; plain names stay implies.
TEST(Manifest, FeatureForwardTomlArrayAndImplies) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
default = []
dnn = ["dnn-local", "compat.opencv/dnn"]
[dependencies]
compat.opencv = { version = "0.0.3", default-features = false }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    // The plain name stays an implied feature.
    ASSERT_TRUE(m->featuresMap.contains("dnn"));
    ASSERT_EQ(m->featuresMap["dnn"].size(), 1u);
    EXPECT_EQ(m->featuresMap["dnn"][0], "dnn-local");

    // The `dep/feat` token becomes a forward (depKey verbatim = stableMapKey).
    ASSERT_TRUE(m->featureForwards.contains("dnn"));
    ASSERT_EQ(m->featureForwards["dnn"].size(), 1u);
    EXPECT_EQ(m->featureForwards["dnn"][0].first,  "compat.opencv");
    EXPECT_EQ(m->featureForwards["dnn"][0].second, "dnn");
}

// The table form accepts forwards both mixed into `implies` and via the
// dedicated self-documenting `forward` key; both feed featureForwards.
TEST(Manifest, FeatureForwardTableForms) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
[features]
default = []
a = { implies = ["base", "dep.one/x"] }
b = { forward = ["dep.two/y", "dep.two/z"] }
base = []
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    // `implies` keeps the plain name, forwards the slashed token.
    ASSERT_EQ(m->featuresMap["a"].size(), 1u);
    EXPECT_EQ(m->featuresMap["a"][0], "base");
    ASSERT_TRUE(m->featureForwards.contains("a"));
    ASSERT_EQ(m->featureForwards["a"].size(), 1u);
    EXPECT_EQ(m->featureForwards["a"][0].first,  "dep.one");
    EXPECT_EQ(m->featureForwards["a"][0].second, "x");

    // Dedicated `forward` key: all tokens are forwards; feature has no implies.
    EXPECT_TRUE(m->featuresMap["b"].empty());
    ASSERT_TRUE(m->featureForwards.contains("b"));
    ASSERT_EQ(m->featureForwards["b"].size(), 2u);
    EXPECT_EQ(m->featureForwards["b"][0].first,  "dep.two");
    EXPECT_EQ(m->featureForwards["b"][0].second, "y");
    EXPECT_EQ(m->featureForwards["b"][1].second, "z");
}

// The Lua descriptor surface splits `dep/feat` tokens the same way (one shared
// split point, two grammars).
TEST(SynthesizeFromXpkgLua, FeatureForwardParse) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "opencv",
    xpm  = { linux = { ["0.0.3"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/anchor.c" },
        targets = { ["opencv"] = { kind = "lib" } },
        features = {
            ["dnn"] = { sources = { "*/dnn.cppm" }, implies = { "compat.opencv/dnn" } },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "opencv", "0.0.3", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    // The forward token left featuresMap for featureForwards.
    EXPECT_TRUE(m->featuresMap["dnn"].empty());
    ASSERT_TRUE(m->featureForwards.contains("dnn"));
    ASSERT_EQ(m->featureForwards["dnn"].size(), 1u);
    EXPECT_EQ(m->featureForwards["dnn"][0].first,  "compat.opencv");
    EXPECT_EQ(m->featureForwards["dnn"][0].second, "dnn");
    // sources still gated normally (untouched by the split).
    ASSERT_TRUE(m->buildConfig.featureSources.contains("dnn"));
}

// mcpp#237: an unknown mcpp-segment key is collected (so the build path can
// surface it) and the did-you-mean helper maps well-known confusables +
// edit-distance typos back to the closed key vocabulary.
TEST(XpkgUnknownKeys, CollectedAndDidYouMean) {
    // `dependencies` is the canonical wrong spelling of `deps` (issue #237).
    EXPECT_EQ(mcpp::manifest::closest_known_xpkg_key("dependencies"), "deps");
    EXPECT_EQ(mcpp::manifest::closest_known_xpkg_key("dependency"),   "deps");
    // single-typo of a real key resolves via edit distance.
    EXPECT_EQ(mcpp::manifest::closest_known_xpkg_key("cxxflag"),      "cxxflags");
    EXPECT_EQ(mcpp::manifest::closest_known_xpkg_key("feature"),      "features");
    // a genuinely unrelated key has no suggestion.
    EXPECT_EQ(mcpp::manifest::closest_known_xpkg_key("wibble"),       "");

    // The build-path synthesizer records the unknown key rather than dropping
    // it silently.
    constexpr auto lua = R"(
package = {
    name = "x",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/a.c" },
        targets = { ["x"] = { kind = "lib" } },
        dependencies = { ["zlib"] = "1.3.x" },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "x", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->xpkgUnknownKeys.size(), 1u);
    EXPECT_EQ(m->xpkgUnknownKeys[0], "dependencies");
}

// A feature's UNKNOWN sub-key (e.g. an unsupported `include_dirs`) is recorded
// as `features.<name>.<sub>` instead of being silently swallowed — the
// adoption-site warning (warn_unknown_xpkg_keys) then names it. Known sub-keys
// keep parsing around it.
TEST(XpkgUnknownKeys, FeatureSubKeyRecorded) {
    constexpr auto lua = R"(
package = {
    name = "x",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/a.c" },
        targets = { ["x"] = { kind = "lib" } },
        features = {
            ["opt"] = {
                include_dirs = { "inc" },
                defines = { "OPT_ON" },
            },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "x", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->xpkgUnknownKeys.size(), 1u);
    EXPECT_EQ(m->xpkgUnknownKeys[0], "features.opt.include_dirs");
    // the known sub-key after the unknown one still parsed.
    ASSERT_TRUE(m->buildConfig.featureDefines.contains("opt"));
    EXPECT_EQ(m->buildConfig.featureDefines.at("opt").size(), 1u);
}

TEST(Manifest, BuildMacosDeploymentTarget) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
macos_deployment_target = "11.0"
[targets.x]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.macosDeploymentTarget, "11.0");
}

TEST(Manifest, BuildMacosDeploymentTargetDefaultsEmpty) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[targets.x]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_TRUE(m->buildConfig.macosDeploymentTarget.empty());
}

TEST(Manifest, RuntimeConfig) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[runtime]
library_dirs = ["runtime/lib", "plugins"]
dlopen_libs = ["libGLX.so.0", "libGL.so.1"]
capabilities = ["x11.display", "opengl.glx.driver"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->runtimeConfig.libraryDirs.size(), 2u);
    EXPECT_EQ(m->runtimeConfig.libraryDirs[0], "runtime/lib");
    EXPECT_EQ(m->runtimeConfig.libraryDirs[1], "plugins");
    ASSERT_EQ(m->runtimeConfig.dlopenLibs.size(), 2u);
    EXPECT_EQ(m->runtimeConfig.dlopenLibs[0], "libGLX.so.0");
    EXPECT_EQ(m->runtimeConfig.dlopenLibs[1], "libGL.so.1");
    ASSERT_EQ(m->runtimeConfig.capabilities.size(), 2u);
    EXPECT_EQ(m->runtimeConfig.capabilities[0], "x11.display");
    EXPECT_EQ(m->runtimeConfig.capabilities[1], "opengl.glx.driver");
}

TEST(SynthesizeFromXpkgLua, CflagsCxxflagsLdflagsAndCStandard) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "tinyc",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources    = { "*/src/*.c" },
        cflags     = { "-Wall", "-Dunused" },
        cxxflags   = { "-Wextra" },
        ldflags    = { "-ltinyc" },
        c_standard = "c11",
        targets    = { ["tinyc"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyc", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.cflags.size(), 2u);
    EXPECT_EQ(m->buildConfig.cflags[0], "-Wall");
    EXPECT_EQ(m->buildConfig.cflags[1], "-Dunused");
    ASSERT_EQ(m->buildConfig.cxxflags.size(), 1u);
    EXPECT_EQ(m->buildConfig.cxxflags[0], "-Wextra");
    ASSERT_EQ(m->buildConfig.ldflags.size(), 1u);
    EXPECT_EQ(m->buildConfig.ldflags[0], "-ltinyc");
    EXPECT_EQ(m->buildConfig.cStandard, "c11");
    ASSERT_EQ(m->modules.sources.size(), 1u);
    EXPECT_EQ(m->modules.sources[0], "*/src/*.c");
}

TEST(SynthesizeFromXpkgLua, SharedTargetSoname) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "tinyshared",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/*.c" },
        targets = { ["tinyshared"] = { kind = "shared", soname = "libtinyshared.so.1" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyshared", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->targets.size(), 1u);
    EXPECT_EQ(m->targets[0].kind, mcpp::manifest::Target::SharedLibrary);
    EXPECT_EQ(m->targets[0].soname, "libtinyshared.so.1");
}

TEST(SynthesizeFromXpkgLua, FeatureGatedSources) {
    // gtest-style: gtest_main.cc listed in base `sources` (old-mcpp compat) AND
    // under the `main` feature → featureSources records it; the feature is
    // registered in featuresMap. prepare_build later gates it (off by default).
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "gtestlike",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources  = { "*/src/all.cc", "*/src/main.cc" },
        targets  = { ["gtestlike"] = { kind = "lib" } },
        features = {
            ["main"] = { sources = { "*/src/main.cc" } },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "gtestlike", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    // base sources keep both (old mcpp ignores `features` → no regression)
    ASSERT_EQ(m->buildConfig.sources.size(), 2u);
    // the `main` feature is registered + carries its gated source
    ASSERT_TRUE(m->featuresMap.contains("main"));
    ASSERT_TRUE(m->buildConfig.featureSources.contains("main"));
    ASSERT_EQ(m->buildConfig.featureSources.at("main").size(), 1u);
    EXPECT_EQ(m->buildConfig.featureSources.at("main")[0], "*/src/main.cc");
}

TEST(SynthesizeFromXpkgLua, RuntimeConfig) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "glfw",
    xpm  = { linux = { ["3.4"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/context.c" },
        runtime = {
            library_dirs = { "mcpp_generated/runtime/lib" },
            dlopen_libs = { "libGLX.so.0", "libGL.so.1" },
            capabilities = { "x11.display", "opengl.glx.driver" },
        },
        targets = { ["glfw"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "glfw", "3.4", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->runtimeConfig.libraryDirs.size(), 1u);
    EXPECT_EQ(m->runtimeConfig.libraryDirs[0], "mcpp_generated/runtime/lib");
    ASSERT_EQ(m->runtimeConfig.dlopenLibs.size(), 2u);
    EXPECT_EQ(m->runtimeConfig.dlopenLibs[0], "libGLX.so.0");
    EXPECT_EQ(m->runtimeConfig.dlopenLibs[1], "libGL.so.1");
    ASSERT_EQ(m->runtimeConfig.capabilities.size(), 2u);
    EXPECT_EQ(m->runtimeConfig.capabilities[0], "x11.display");
    EXPECT_EQ(m->runtimeConfig.capabilities[1], "opengl.glx.driver");
}

TEST(SynthesizeFromXpkgLua, AppliesCurrentPlatformMcppOverlay) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "tinyc",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources      = { "*/src/common.c" },
        include_dirs = { "*/include" },
        cflags       = { "-DCOMMON=1" },
        deps         = { ["compat.base"] = "1.0.0" },
        targets      = { ["tinyc"] = { kind = "lib" } },
        linux = {
            sources      = { "*/src/linux.c" },
            include_dirs = { "*/src/linux" },
            cflags       = { "-DLINUX=1" },
            deps         = { ["compat.x11"] = "1.8.13" },
        },
        macosx = {
            sources      = { "*/src/cocoa.m" },
            include_dirs = { "*/src/macos" },
            cflags       = { "-DMACOS=1" },
            deps         = { ["compat.cocoa"] = "1.0.0" },
        },
        windows = {
            sources      = { "*/src/win32.c" },
            include_dirs = { "*/src/win32" },
            cflags       = { "-DWINDOWS=1" },
            deps         = { ["compat.win32"] = "1.0.0" },
        },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyc", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();

    std::string expectedSource = "*/src/linux.c";
    std::string expectedInclude = "*/src/linux";
    std::string expectedCflag = "-DLINUX=1";
    std::string expectedDep = "compat.x11";
    if constexpr (mcpp::platform::is_macos) {
        expectedSource = "*/src/cocoa.m";
        expectedInclude = "*/src/macos";
        expectedCflag = "-DMACOS=1";
        expectedDep = "compat.cocoa";
    } else if constexpr (mcpp::platform::is_windows) {
        expectedSource = "*/src/win32.c";
        expectedInclude = "*/src/win32";
        expectedCflag = "-DWINDOWS=1";
        expectedDep = "compat.win32";
    }

    ASSERT_EQ(m->modules.sources.size(), 2u);
    EXPECT_EQ(m->modules.sources[0], "*/src/common.c");
    EXPECT_EQ(m->modules.sources[1], expectedSource);
    ASSERT_EQ(m->buildConfig.includeDirs.size(), 2u);
    EXPECT_EQ(m->buildConfig.includeDirs[0], "*/include");
    EXPECT_EQ(m->buildConfig.includeDirs[1], expectedInclude);
    ASSERT_EQ(m->buildConfig.cflags.size(), 2u);
    EXPECT_EQ(m->buildConfig.cflags[0], "-DCOMMON=1");
    EXPECT_EQ(m->buildConfig.cflags[1], expectedCflag);
    EXPECT_EQ(m->dependencies.count("compat.base"), 1u);
    EXPECT_EQ(m->dependencies.count(expectedDep), 1u);

    // osOverride seam (`mcpp xpkg parse --all-os`): a foreign OS section is
    // spliced on request, independent of the running host — the build path
    // (empty override) above stays host-selected. Reuses this fixture.
    auto win = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyc", "1.0.0", mcpp::platform::TargetPlatform::for_lint_of("windows"));
    ASSERT_TRUE(win.has_value()) << win.error().format();
    ASSERT_EQ(win->modules.sources.size(), 2u);
    EXPECT_EQ(win->modules.sources[1], "*/src/win32.c");
    ASSERT_EQ(win->buildConfig.cflags.size(), 2u);
    EXPECT_EQ(win->buildConfig.cflags[1], "-DWINDOWS=1");
    EXPECT_EQ(win->dependencies.count("compat.win32"), 1u);
}

TEST(SynthesizeFromXpkgLua, GeneratedFiles) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "tinyc",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/*.c" },
        generated_files = {
            ["mcpp_generated/include/config.h"] = "#pragma once\n#define TINYC_OK 1\n",
        },
        include_dirs = { "mcpp_generated/include" },
        targets = { ["tinyc"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyc", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.generatedFiles.size(), 1u);
    auto it = m->buildConfig.generatedFiles.find("mcpp_generated/include/config.h");
    ASSERT_NE(it, m->buildConfig.generatedFiles.end());
    EXPECT_EQ(it->second, "#pragma once\n#define TINYC_OK 1\n");
}

// #249: the xpkg descriptor body accepts `include_dirs_after` alongside
// `include_dirs` and keeps the two channels separate (after-dirs are never
// upgraded to -I).
TEST(SynthesizeFromXpkgLua, IncludeDirsAfter) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "tinyc",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources            = { "*/src/*.c" },
        include_dirs       = { "*/include" },
        include_dirs_after = { "*" },
        targets = { ["tinyc"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "tinyc", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.includeDirs.size(), 1u);
    EXPECT_EQ(m->buildConfig.includeDirs[0], "*/include");
    ASSERT_EQ(m->buildConfig.includeDirsAfter.size(), 1u);
    EXPECT_EQ(m->buildConfig.includeDirsAfter[0], "*");
    EXPECT_TRUE(m->xpkgUnknownKeys.empty());
}

TEST(Manifest, DependenciesFlatDefaultNamespace) {
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"
[dependencies]
gtest = "1.15.2"
foo   = { path = "../foo" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 2u);
    auto& g = m->dependencies.at("gtest");
    EXPECT_EQ(g.namespace_, "mcpplibs");
    EXPECT_EQ(g.shortName,  "gtest");
    EXPECT_EQ(g.version,    "1.15.2");
    auto& f = m->dependencies.at("foo");
    EXPECT_EQ(f.namespace_, "mcpplibs");
    EXPECT_EQ(f.shortName,  "foo");
    EXPECT_EQ(f.path,       "../foo");
}

TEST(Manifest, DependenciesNamespacedSubtable) {
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"

[dependencies.mcpplibs]
cmdline   = "0.0.2"
templates = { version = "0.0.1" }

[dependencies]
gtest = "1.15.2"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 3u);

    auto& cmdline = m->dependencies.at("mcpplibs.cmdline");
    EXPECT_EQ(cmdline.namespace_, "mcpplibs");
    EXPECT_EQ(cmdline.shortName,  "cmdline");
    EXPECT_EQ(cmdline.version,    "0.0.2");
    EXPECT_FALSE(cmdline.legacyDottedKey);

    auto& tmpl = m->dependencies.at("mcpplibs.templates");
    EXPECT_EQ(tmpl.namespace_, "mcpplibs");
    EXPECT_EQ(tmpl.shortName,  "templates");
    EXPECT_EQ(tmpl.version,    "0.0.1");

    auto& gtest = m->dependencies.at("gtest");
    EXPECT_EQ(gtest.namespace_, "mcpplibs");
    EXPECT_EQ(gtest.shortName,  "gtest");
    EXPECT_EQ(gtest.version,    "1.15.2");
}

TEST(Manifest, DependenciesLegacyDottedKeyStillParsed) {
    // Pre-namespace-aware mcpp.toml: quoted dotted key.
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"

[dependencies]
"mcpplibs.cmdline" = "0.0.2"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 1u);
    auto& s = m->dependencies.at("mcpplibs.cmdline");
    EXPECT_EQ(s.namespace_, "mcpplibs");
    EXPECT_EQ(s.shortName,  "cmdline");
    EXPECT_EQ(s.version,    "0.0.2");
    EXPECT_TRUE(s.legacyDottedKey);
}

TEST(Manifest, DependenciesDottedSelectorIsOneExactIdentity) {
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"

[dependencies]
capi.lua = "0.0.3"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 1u);

    auto& s = m->dependencies.at("capi.lua");
    EXPECT_EQ(s.namespace_, "capi");
    EXPECT_EQ(s.shortName,  "lua");
    EXPECT_EQ(s.version,    "0.0.3");
    EXPECT_FALSE(s.legacyDottedKey);
    EXPECT_TRUE(s.legacyCandidateSearch);
    ASSERT_EQ(s.candidates.size(), 1u);
    EXPECT_EQ(s.candidates[0].namespace_, "capi");
    EXPECT_EQ(s.candidates[0].shortName, "lua");
}

TEST(Manifest, DependencySelectorsRejectUnsafeOrAmbiguousSegments) {
    const std::vector<std::string> invalid{
        "acme/widget", "acme widget", "acme[widget",
        "acme=widget", "acme#widget", "acme..widget",
    };
    for (auto const& selector : invalid) {
        auto src = std::format(R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
"{}" = "1.0.0"
)", selector);
        auto m = mcpp::manifest::parse_string(src);
        EXPECT_FALSE(m.has_value()) << selector;
        if (!m) EXPECT_NE(m.error().message.find("invalid package selector"),
                          std::string::npos) << m.error().format();
    }
}

TEST(Manifest, DependenciesNamespacedSubtableNestedDottedKeyIsCanonical) {
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"

[dependencies.mcpplibs]
capi.lua = "0.0.3"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 1u);

    auto& s = m->dependencies.at("mcpplibs.capi.lua");
    EXPECT_EQ(s.namespace_, "mcpplibs.capi");
    EXPECT_EQ(s.shortName,  "lua");
    EXPECT_EQ(s.version,    "0.0.3");
    EXPECT_FALSE(s.legacyDottedKey);
    EXPECT_FALSE(s.legacyCandidateSearch);
    ASSERT_EQ(s.candidates.size(), 1u);
    EXPECT_EQ(s.candidates[0].namespace_, "mcpplibs.capi");
    EXPECT_EQ(s.candidates[0].shortName, "lua");
}

TEST(Manifest, DependenciesInlineSpecCoexistsWithSubtable) {
    // `bar = { git = "...", tag = "..." }` looks like a subtable but has
    // only dep-spec keys → treated as inline spec under default ns.
    // `[dependencies.acme]` is a real namespace subtable.
    constexpr auto src = R"(
[package]
name    = "x"
version = "0.1.0"

[dependencies]
bar = { git = "https://example.com/bar.git", tag = "v1" }

[dependencies.acme]
util = "2.0.0"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 2u);
    auto& bar = m->dependencies.at("bar");
    EXPECT_EQ(bar.namespace_, "mcpplibs");
    EXPECT_EQ(bar.shortName,  "bar");
    EXPECT_EQ(bar.git,        "https://example.com/bar.git");
    EXPECT_EQ(bar.gitRev,     "v1");
    EXPECT_EQ(bar.gitRefKind, "tag");

    auto& util = m->dependencies.at("acme.util");
    EXPECT_EQ(util.namespace_, "acme");
    EXPECT_EQ(util.shortName,  "util");
    EXPECT_EQ(util.version,    "2.0.0");
}

TEST(SynthesizeFromXpkgLua, DepsKeySplitNamespace) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "consumer",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/*.cppm" },
        deps    = {
            ["mbedtls"]          = "3.6.1",
            ["mcpplibs.cmdline"] = "0.0.2",
        },
        targets = { ["consumer"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "consumer", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 2u);

    auto& a = m->dependencies.at("mbedtls");
    EXPECT_EQ(a.namespace_, "mcpplibs");
    EXPECT_EQ(a.shortName,  "mbedtls");
    EXPECT_EQ(a.version,    "3.6.1");

    auto& b = m->dependencies.at("mcpplibs.cmdline");
    EXPECT_EQ(b.namespace_, "mcpplibs");
    EXPECT_EQ(b.shortName,  "cmdline");
    EXPECT_EQ(b.version,    "0.0.2");
}

TEST(SynthesizeFromXpkgLua, DepsDottedSelectorsAreExact) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "consumer",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/*.cppm" },
        deps    = {
            ["capi.lua"]     = "0.0.3",
            ["imgui.core"]   = "0.0.1",
            ["compat.gtest"] = "1.15.2",
        },
        targets = { ["consumer"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(src, "consumer", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->dependencies.size(), 3u);

    auto& lua = m->dependencies.at("capi.lua");
    EXPECT_EQ(lua.namespace_, "capi");
    EXPECT_EQ(lua.shortName, "lua");
    EXPECT_EQ(lua.version, "0.0.3");
    EXPECT_TRUE(lua.legacyCandidateSearch);
    ASSERT_EQ(lua.candidates.size(), 1u);
    EXPECT_EQ(lua.candidates[0].namespace_, "capi");
    EXPECT_EQ(lua.candidates[0].shortName, "lua");

    auto& imgui = m->dependencies.at("imgui.core");
    EXPECT_EQ(imgui.namespace_, "imgui");
    EXPECT_EQ(imgui.shortName, "core");
    EXPECT_EQ(imgui.version, "0.0.1");
    EXPECT_TRUE(imgui.legacyCandidateSearch);
    ASSERT_EQ(imgui.candidates.size(), 1u);
    EXPECT_EQ(imgui.candidates[0].namespace_, "imgui");
    EXPECT_EQ(imgui.candidates[0].shortName, "core");

    auto& gtest = m->dependencies.at("compat.gtest");
    EXPECT_EQ(gtest.namespace_, "compat");
    EXPECT_EQ(gtest.shortName, "gtest");
    EXPECT_EQ(gtest.version, "1.15.2");
    EXPECT_TRUE(gtest.legacyCandidateSearch);
    ASSERT_EQ(gtest.candidates.size(), 1u);
    EXPECT_EQ(gtest.candidates[0].namespace_, "compat");
    EXPECT_EQ(gtest.candidates[0].shortName, "gtest");
}

TEST(SynthesizeFromXpkgLua, InvalidDependencySelectorIsAnError) {
    constexpr auto src = R"(
package = {
    spec = "1",
    name = "consumer",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "*/src/*.cppm" },
        deps = { ["acme/widget"] = "1.0.0" },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(
        src, "consumer", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("invalid package selector"),
              std::string::npos) << m.error().format();
}

TEST(Manifest, WorkspaceSectionParsed) {
    constexpr auto src = R"(
[workspace]
members = ["libs/core", "libs/http", "apps/server"]
exclude = ["libs/experimental"]

[workspace.dependencies]
cmdline = "0.0.2"

[workspace.dependencies.compat]
gtest = "1.15.2"
mbedtls = "3.6.1"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_TRUE(m->workspace.present);
    ASSERT_EQ(m->workspace.members.size(), 3u);
    EXPECT_EQ(m->workspace.members[0], "libs/core");
    EXPECT_EQ(m->workspace.members[1], "libs/http");
    EXPECT_EQ(m->workspace.members[2], "apps/server");
    ASSERT_EQ(m->workspace.exclude.size(), 1u);
    EXPECT_EQ(m->workspace.exclude[0], "libs/experimental");
    ASSERT_EQ(m->workspace.dependencies.size(), 3u);
    auto& gt = m->workspace.dependencies.at("compat.gtest");
    EXPECT_EQ(gt.version, "1.15.2");
    EXPECT_EQ(gt.namespace_, "compat");
}

TEST(Manifest, WorkspaceDependenciesUseExactDottedSelectors) {
    constexpr auto src = R"(
[workspace]
members = ["libs/core"]

[workspace.dependencies]
capi.lua = "0.0.3"
imgui.core = "0.0.1"
compat.gtest = "1.15.2"
mcpplibs.templates = "0.0.1"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->workspace.dependencies.size(), 4u);

    auto& lua = m->workspace.dependencies.at("capi.lua");
    EXPECT_EQ(lua.namespace_, "capi");
    EXPECT_EQ(lua.shortName, "lua");
    EXPECT_EQ(lua.version, "0.0.3");
    EXPECT_TRUE(lua.legacyCandidateSearch);
    ASSERT_EQ(lua.candidates.size(), 1u);
    EXPECT_EQ(lua.candidates[0].namespace_, "capi");
    EXPECT_EQ(lua.candidates[0].shortName, "lua");

    auto& imgui = m->workspace.dependencies.at("imgui.core");
    EXPECT_EQ(imgui.namespace_, "imgui");
    EXPECT_EQ(imgui.shortName, "core");
    EXPECT_EQ(imgui.version, "0.0.1");
    EXPECT_TRUE(imgui.legacyCandidateSearch);
    ASSERT_EQ(imgui.candidates.size(), 1u);
    EXPECT_EQ(imgui.candidates[0].namespace_, "imgui");
    EXPECT_EQ(imgui.candidates[0].shortName, "core");

    auto& gt = m->workspace.dependencies.at("compat.gtest");
    EXPECT_EQ(gt.namespace_, "compat");
    EXPECT_EQ(gt.shortName, "gtest");
    EXPECT_EQ(gt.version, "1.15.2");
    EXPECT_TRUE(gt.legacyCandidateSearch);
    ASSERT_EQ(gt.candidates.size(), 1u);
    EXPECT_EQ(gt.candidates[0].namespace_, "compat");
    EXPECT_EQ(gt.candidates[0].shortName, "gtest");

    auto& tmpl = m->workspace.dependencies.at("mcpplibs.templates");
    EXPECT_EQ(tmpl.namespace_, "mcpplibs");
    EXPECT_EQ(tmpl.shortName, "templates");
    EXPECT_EQ(tmpl.version, "0.0.1");
    EXPECT_FALSE(tmpl.legacyCandidateSearch);
    ASSERT_EQ(tmpl.candidates.size(), 1u);
    EXPECT_EQ(tmpl.candidates[0].namespace_, "mcpplibs");
    EXPECT_EQ(tmpl.candidates[0].shortName, "templates");
}

TEST(Manifest, WorkspaceTrueInDependency) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[dependencies.compat]
mbedtls = { workspace = true }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto& s = m->dependencies.at("compat.mbedtls");
    EXPECT_TRUE(s.inheritWorkspace);
    EXPECT_EQ(s.namespace_, "compat");
    EXPECT_EQ(s.shortName, "mbedtls");
}

TEST(Manifest, IndicesDefaultKeyNormalizesToDefaultNamespace) {
    // R6: `[indices] default = {...}` (the canonical spelling) is a
    // redirect for the DEFAULT namespace (bare `gtest = "1.15.2"` deps),
    // not a literal index named "default". It must be stored under
    // kDefaultNamespace so the two short-circuits in prepare.cppm
    // (usesBuiltinIndex / findIndexForNs) can find it.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
default = { path = "../local-pkgs" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->indices.find(std::string(mcpp::manifest::kDefaultNamespace));
    ASSERT_NE(it, m->indices.end())
        << "[indices] default = {...} must normalize to kDefaultNamespace";
    EXPECT_EQ(it->second.path.string(), "../local-pkgs");
    EXPECT_FALSE(it->second.is_builtin());
    EXPECT_EQ(m->indices.find("default"), m->indices.end())
        << "the literal key \"default\" must not survive normalization";
}

TEST(Manifest, IndicesEmptyStringKeyNormalizesToDefaultNamespace) {
    // The empty-quoted key `""` is also accepted as a spelling of the
    // default-namespace redirect.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
"" = { path = "../local-pkgs" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->indices.find(std::string(mcpp::manifest::kDefaultNamespace));
    ASSERT_NE(it, m->indices.end())
        << "[indices] \"\" = {...} must normalize to kDefaultNamespace";
    EXPECT_EQ(it->second.path.string(), "../local-pkgs");
}

TEST(Manifest, IndicesDefaultKeyWithUrlIsRejected) {
    // R6's design goal is redirecting the default namespace to a LOCAL
    // index checkout (`path = ...`), so the index repo can test module
    // packages. The `url` form is not a design requirement, and silently
    // accepting it is worse than rejecting it: is_builtin() (index_spec
    // .cppm) treats any "mcpplibs"-named entry with an empty `path` as
    // builtin, so a `default = { url = ... }` redirect would silently
    // no-op — every consumer falls through to the real builtin registry
    // and the configured url is just ignored, with no error surfaced.
    // Reject it loudly at parse time instead.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
default = { url = "https://example.com/mcpp-index.git" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value())
        << "[indices] default = { url = ... } must be rejected, not silently "
           "accepted as a no-op redirect";
    EXPECT_NE(m.error().format().find("path"), std::string::npos)
        << "error should mention that only 'path' is supported for the "
           "default-namespace redirect; got: " << m.error().format();
}

TEST(Manifest, IndicesMcpplibsUrlPinStillAccepted) {
    // A literal `[indices] mcpplibs = { url = ..., rev = ... }` is a
    // DIFFERENT key spelling from the `default`/`""` alias — it pins the
    // real builtin registry to a commit, not a default-namespace redirect
    // — and must keep working even though it also normalizes to the
    // kDefaultNamespace map slot and also carries a `url`.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
mcpplibs = { url = "https://example.com/mcpp-index.git", rev = "abc123" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->indices.find(std::string(mcpp::manifest::kDefaultNamespace));
    ASSERT_NE(it, m->indices.end());
    EXPECT_EQ(it->second.url, "https://example.com/mcpp-index.git");
    EXPECT_EQ(it->second.rev, "abc123");
    EXPECT_TRUE(it->second.is_builtin());
}

TEST(Manifest, IndicesDefaultAndMcpplibsCollisionRejected) {
    // `default`, `""`, and a literal `mcpplibs` key all normalize to the
    // same map slot (kDefaultNamespace). Declaring more than one must be a
    // parse error, not a silent last-writer-wins clobber.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
mcpplibs = { path = "../local-pkgs-a" }
default = { path = "../local-pkgs-b" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value())
        << "[indices] mcpplibs + default together must be rejected as a "
           "collision on the same default-namespace slot";
    EXPECT_NE(m.error().format().find("collide"), std::string::npos)
        << "error should mention the collision; got: " << m.error().format();
}

TEST(Manifest, WorkspaceDependenciesPathFormFlatKey) {
    // #224: `[workspace.dependencies] ylib = { path = "ylib" }` — a plain
    // (non-namespaced, non-dotted) top-level key with an inline path table
    // — must parse to a path-form DependencySpec, not get misrouted into
    // the namespace/selector-table parsers (which would treat "path" as a
    // nested selector key).
    constexpr auto src = R"(
[workspace]
members = ["a"]

[workspace.dependencies]
ylib = { path = "ylib" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_TRUE(m->workspace.dependencies.contains("ylib"))
        << "workspace.dependencies must contain a flat 'ylib' key";
    auto& s = m->workspace.dependencies.at("ylib");
    EXPECT_EQ(s.path, "ylib");
    EXPECT_TRUE(s.version.empty());
}

TEST(Manifest, NoWorkspaceSectionMeansNotPresent) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value());
    EXPECT_FALSE(m->workspace.present);
}

TEST(Manifest, LibRootInferredFromPackageName) {
    constexpr auto src = R"(
[package]
name    = "mcpplibs.tinyhttps"
version = "0.2.0"
[targets.tinyhttps]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_TRUE(m->lib.path.empty());
    EXPECT_TRUE(mcpp::manifest::has_lib_target(*m));
    auto root = mcpp::manifest::resolve_lib_root_path(*m);
    EXPECT_EQ(root, std::filesystem::path("src/tinyhttps.cppm"));
}

TEST(Manifest, LibRootBareNameNoNamespace) {
    constexpr auto src = R"(
[package]
name    = "gtest"
version = "1.0.0"
[targets.gtest]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto root = mcpp::manifest::resolve_lib_root_path(*m);
    EXPECT_EQ(root, std::filesystem::path("src/gtest.cppm"));
}

TEST(Manifest, LibRootExplicitOverride) {
    constexpr auto src = R"(
[package]
name    = "mcpplibs.tinyhttps"
version = "0.2.0"
[lib]
path = "src/api.cppm"
[targets.tinyhttps]
kind = "lib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->lib.path.string(), "src/api.cppm");
    auto root = mcpp::manifest::resolve_lib_root_path(*m);
    EXPECT_EQ(root.string(), "src/api.cppm");
}

TEST(Manifest, HasLibTargetFalseForBareBinaryManifest) {
    // No [targets.*] declared → parse_string leaves targets empty.
    // load() would later infer a bin/lib from sources, but parse_string
    // alone leaves it bare; either way no lib target.
    constexpr auto src = R"(
[package]
name    = "mcpp"
version = "0.0.2"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_FALSE(mcpp::manifest::has_lib_target(*m));
}

TEST(Manifest, ParsesPerTargetFlagsAndRequiredFeatures) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[targets.server]
kind     = "bin"
main     = "src/server.cpp"
defines  = ["BUILD_SERVER=1", "PORT=8080"]
cxxflags = ["-fno-exceptions"]
cflags   = ["-DPURE_C"]
required_features = ["server"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->targets.size(), 1u);
    auto& t = m->targets[0];
    ASSERT_EQ(t.defines.size(), 2u);
    EXPECT_EQ(t.defines[0], "BUILD_SERVER=1");
    EXPECT_EQ(t.defines[1], "PORT=8080");
    ASSERT_EQ(t.cxxflags.size(), 1u);
    EXPECT_EQ(t.cxxflags[0], "-fno-exceptions");
    ASSERT_EQ(t.cflags.size(), 1u);
    EXPECT_EQ(t.cflags[0], "-DPURE_C");
    ASSERT_EQ(t.requiredFeatures.size(), 1u);
    EXPECT_EQ(t.requiredFeatures[0], "server");
    EXPECT_TRUE(m->schemaWarnings.empty());
}

TEST(Manifest, WarnsOnUnsupportedTargetKey) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[targets.app]
kind   = "bin"
main   = "src/main.cpp"
cxxfalgs = ["-DTYPO"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("cxxfalgs"), std::string::npos);
    EXPECT_NE(m->schemaWarnings[0].find("unsupported key"), std::string::npos);
}

TEST(Manifest, RejectsStdFlagInTargetCxxflags) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[targets.app]
kind     = "bin"
main     = "src/main.cpp"
cxxflags = ["-std=c++20"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("[package].standard"), std::string::npos);
}

TEST(ListXpkgVersions, IgnoresCommentedEntries) {
    constexpr auto src = R"(
package = {
    xpm = {
        linux = {
            -- ["1.2.3"] = { ... },   -- this is a comment
            ["0.1.0"] = { url = "u" },
        },
    },
}
)";
    auto v = mcpp::manifest::list_xpkg_versions(src, mcpp::platform::TargetPlatform::for_lint_of("linux"));
    ASSERT_EQ(v.size(), 1u);
    EXPECT_EQ(v[0], "0.1.0");
}

// ─── xpkg_lua_identity_matches — descriptor identity gate ───────────
//
// Regression cover for the compat.zlib vs upstream bare zlib.lua collision:
// a file found by a candidate filename must DECLARE the requested package.

namespace {
constexpr std::string_view kCompatZlibLua = R"(
package = {
    namespace   = "compat",
    name        = "compat.zlib",
    version     = "1.3.2",
    mcpp = {
        sources = { "*.c" },
    },
}
)";

// Upstream xim zlib: declares a bare name and NO namespace, no mcpp block.
constexpr std::string_view kUpstreamZlibLua = R"(
package = {
    name = "zlib",
    description = "A massively spiffy yet delicately unobtrusive compression library",
}
)";
}  // namespace

TEST(XpkgIdentity, CompatDescriptorMatchesCompatRequest) {
    EXPECT_TRUE(mcpp::manifest::xpkg_lua_identity_matches(
        kCompatZlibLua, "compat", "zlib"));
}

TEST(XpkgIdentity, UpstreamBareZlibDoesNotMatchCompatRequest) {
    // The crux of the incident: a foreign bare `zlib.lua` must be rejected for
    // a `compat.zlib` request, no matter that the candidate filename matched.
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        kUpstreamZlibLua, "compat", "zlib"));
}

TEST(XpkgIdentity, DescriptorDeclaringNamespaceMatchesOnlyThatNamespace) {
    // When a descriptor DECLARES its namespace, it matches that namespace and no
    // other. (Index-owned namespace for *no-namespace* descriptors — attributing
    // a bare `zlib.lua` to its owning index as `(xim, zlib)` — is deferred to the
    // §4.1 follow-up, since the content-only gate cannot know a file's index.)
    constexpr std::string_view ximZlib =
        R"(package = { namespace = "xim", name = "zlib" })";
    EXPECT_TRUE(mcpp::manifest::xpkg_lua_identity_matches(
        ximZlib, "xim", "zlib", /*allowLegacyBareDefault=*/false));
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        ximZlib, "compat", "zlib"));
}

TEST(XpkgIdentity, NoDeclaredNameIsAcceptedLeniently) {
    // A descriptor without a package.name cannot be verified → accepted.
    constexpr std::string_view noName = R"(package = { version = "1.0.0" })";
    EXPECT_TRUE(mcpp::manifest::xpkg_lua_identity_matches(noName, "compat", "zlib"));
}

TEST(XpkgIdentity, DefaultNamespaceBareNameGatedByFlag) {
    // Default-namespace (mcpplibs) bare-named legacy descriptor: accepted only
    // when the legacy-bare flag is on.
    constexpr std::string_view bareDefault = R"(package = { name = "cmdline" })";
    EXPECT_TRUE(mcpp::manifest::xpkg_lua_identity_matches(
        bareDefault, "mcpplibs", "cmdline", /*allowLegacyBareDefault=*/true));
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        bareDefault, "mcpplibs", "cmdline", /*allowLegacyBareDefault=*/false));
}

TEST(XpkgIdentity, EmptyNamespaceDiscoveryMatchesNamespacedDescriptor) {
    // `mcpp new --template llmapi` reads with an empty (unknown) namespace and
    // derives the real namespace from the file. A namespaced descriptor must
    // still be discoverable by its short name.
    constexpr std::string_view llmapi = R"(
package = { namespace = "mcpplibs", name = "mcpplibs.llmapi", version = "0.2.8" }
)";
    EXPECT_TRUE(mcpp::manifest::xpkg_lua_identity_matches(llmapi, "", "llmapi"));
    // ...but it is NOT a match for a different short name.
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(llmapi, "", "zlib"));
}

TEST(XpkgIdentity, DefaultNamespaceRequestDoesNotMatchCompatPackage) {
    // Namespace omission now means exactly mcpplibs. A compat package must be
    // selected as `compat.gtest`, never smuggled through an identity alias.
    constexpr std::string_view compatGtest =
        R"(package = { namespace = "compat", name = "compat.gtest", version = "1.15.2" })";
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        compatGtest, "mcpplibs", "gtest"));
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        compatGtest, "mcpplibs", "gtest", /*allowLegacyBareDefault=*/false));
    // But a different default-ns name does not match it.
    EXPECT_FALSE(mcpp::manifest::xpkg_lua_identity_matches(
        compatGtest, "mcpplibs", "zlib"));
}

// ─── xpkg_wire_address — the address xlings is asked to install ─────
//
// REGRESSION LOCK for the 2026-07-25 CI break (6 of 7 workflows red on main).
// Once a descriptor is selected by an explicit `compat.gtest` request, the
// wire address has to come from THAT descriptor — both halves. Taking the name from the
// descriptor and the namespace from the request emitted `mcpplibs:gtest`, which
// no index is keyed by; it only ever worked because the literal name used to
// read `compat.gtest`, so a hardcoded `compat.<short>` retry caught it. The
// index's SPEC-001 short-name migration removed that coincidence.

TEST(XpkgWireAddress, CompatDescriptorAddressesCompat) {
    constexpr std::string_view compatGtest =
        R"(package = { namespace = "compat", name = "gtest", version = "1.15.2" })";
    auto addr = mcpp::manifest::xpkg_wire_address(compatGtest, "compat", "gtest");
    EXPECT_EQ(addr.ns, "compat");
    EXPECT_EQ(addr.name, "gtest");
    EXPECT_EQ(addr.target, "compat:gtest");   // NOT "mcpplibs:gtest"
}

TEST(XpkgWireAddress, DefaultNamespaceDescriptorIsUnchanged) {
    // The 8 mcpplibs descriptors in the live index must address exactly as
    // before — this fix moves only the packages that were already broken.
    constexpr std::string_view cmdline =
        R"(package = { namespace = "mcpplibs", name = "cmdline", version = "0.0.1" })";
    auto addr = mcpp::manifest::xpkg_wire_address(cmdline, "mcpplibs", "cmdline");
    EXPECT_EQ(addr.target, "mcpplibs:cmdline");
}

TEST(XpkgWireAddress, LegacyFqnDescriptorKeepsItsLiteralName) {
    // Pre-SPEC-001 spelling. The literal `name` IS the index's key, so it goes
    // out verbatim — only the namespace half is corrected.
    constexpr std::string_view legacy =
        R"(package = { namespace = "compat", name = "compat.zlib", version = "1.3.2" })";
    auto addr = mcpp::manifest::xpkg_wire_address(legacy, "mcpplibs", "zlib");
    EXPECT_EQ(addr.ns, "compat");
    EXPECT_EQ(addr.name, "compat.zlib");
    EXPECT_EQ(addr.target, "compat:compat.zlib");
}

TEST(XpkgWireAddress, QualifiedRequestIsUnchanged) {
    // `[dependencies.compat] gtest = ...` already worked (this is the spelling
    // every mcpp-index example uses, which is why the index CI stayed green).
    constexpr std::string_view compatGtest =
        R"(package = { namespace = "compat", name = "gtest", version = "1.15.2" })";
    auto addr = mcpp::manifest::xpkg_wire_address(compatGtest, "compat", "gtest");
    EXPECT_EQ(addr.target, "compat:gtest");
}

TEST(XpkgWireAddress, NestedNamespaceIsUnchanged) {
    constexpr std::string_view capiLua =
        R"(package = { namespace = "mcpplibs.capi", name = "lua", version = "5.4.7" })";
    auto addr = mcpp::manifest::xpkg_wire_address(capiLua, "mcpplibs.capi", "lua");
    EXPECT_EQ(addr.target, "mcpplibs.capi:lua");
}

TEST(XpkgWireAddress, DescriptorWithoutNamespaceInheritsTheRequest) {
    // A no-namespace descriptor inherits the namespace owned by the index it
    // was found in — at this seam, the request coordinate. Same rule the
    // identity gate used to accept it.
    constexpr std::string_view bare = R"(package = { name = "cmdline" })";
    auto addr = mcpp::manifest::xpkg_wire_address(bare, "mcpplibs", "cmdline");
    EXPECT_EQ(addr.ns, "mcpplibs");
    EXPECT_EQ(addr.target, "mcpplibs:cmdline");
}

TEST(XpkgWireAddress, NamespacelessRequestAddressesTheBareLiteral) {
    // xim upstream packages (`opencv`) have no namespace on either side.
    constexpr std::string_view opencv = R"(package = { name = "opencv" })";
    auto addr = mcpp::manifest::xpkg_wire_address(opencv, "", "opencv");
    EXPECT_EQ(addr.ns, "");
    EXPECT_EQ(addr.target, "opencv");
}

TEST(XpkgWireAddress, NoDescriptorKeepsTheHistoricalDerivation) {
    // Index not synced yet: mcpp has nothing to read, so it must NOT invent a
    // new address — the failure has to stay exactly where it was.
    auto addr = mcpp::manifest::xpkg_wire_address("", "mcpplibs", "gtest");
    EXPECT_EQ(addr.name, "mcpplibs.gtest");
    EXPECT_EQ(addr.target, "mcpplibs:mcpplibs.gtest");

    auto bare = mcpp::manifest::xpkg_wire_address("", "", "opencv");
    EXPECT_EQ(bare.target, "opencv");
}

TEST(XpkgWireAddress, DescriptorWithoutNameFallsBackToDerivation) {
    // A descriptor that declares no `name` cannot supply a wire key (the
    // identity gate accepts it leniently, so it can reach here).
    constexpr std::string_view noName = R"(package = { version = "1.0.0" })";
    auto addr = mcpp::manifest::xpkg_wire_address(noName, "mcpplibs", "gtest");
    EXPECT_EQ(addr.target, "mcpplibs:mcpplibs.gtest");
}

// ─── INV-NAME: xpkg_name_form_violation (#278) ──────────────────────
//
// `package.name` is a SINGLE ATOMIC SEGMENT; all hierarchy lives in
// `package.namespace` (SPEC-001 §3.2). The legacy fully-qualified spelling
// (`namespace="compat", name="compat.zlib"`) stays accepted for compatibility.

TEST(XpkgNameForm, ShortNameIsCanonical) {
    // SPEC-001 form: namespace carries the path, name is one segment.
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation("chriskohlhoff", "asio")
                     .has_value());
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation("mcpplibs.capi", "lua")
                     .has_value());
}

TEST(XpkgNameForm, FqnFormIsClean) {
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation(
        "chriskohlhoff", "chriskohlhoff.asio").has_value());
}

TEST(XpkgNameForm, NoNamespaceIsClean) {
    // xim upstream packages declare no namespace and are keyed by the bare
    // name — legal, and outside INV-NAME's scope.
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation("", "opencv")
                     .has_value());
}

TEST(XpkgNameForm, NoNameIsClean) {
    // Cannot verify → lenient, matching the identity gate's stance.
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation("compat", "")
                     .has_value());
}

TEST(XpkgNameForm, CompatAliasIsClean) {
    // Legacy descriptors repeat the declared namespace in package.name. That
    // source shape remains valid even though consumers now select compat
    // explicitly.
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation("compat", "compat.gtest")
                     .has_value());
}

TEST(XpkgNameForm, NestedNamespaceIsClean) {
    EXPECT_FALSE(mcpp::manifest::xpkg_name_form_violation(
        "mcpplibs.capi", "mcpplibs.capi.lua").has_value());
}

TEST(XpkgNameForm, PrefixWithoutShortSegmentIsAViolation) {
    // `name` equal to the namespace itself carries no short segment.
    EXPECT_TRUE(mcpp::manifest::xpkg_name_form_violation("compat", "compat.")
                    .has_value());
}

TEST(XpkgNameForm, FromLuaAcceptsBothCanonicalAndLegacy) {
    constexpr std::string_view shortLua =
        R"(package = { namespace = "aimol", name = "tensorvia-cpu" })";
    constexpr std::string_view legacyFqnLua =
        R"(package = { namespace = "aimol", name = "aimol.tensorvia-cpu" })";
    // Canonical short-name form and the legacy FQN spelling both resolve to
    // the same identity, so both are accepted.
    EXPECT_FALSE(
        mcpp::manifest::xpkg_name_form_violation_from_lua(shortLua).has_value());
    EXPECT_FALSE(
        mcpp::manifest::xpkg_name_form_violation_from_lua(legacyFqnLua).has_value());
    // But a short name that still carries a dot is rejected.
    constexpr std::string_view nonAtomic =
        R"(package = { namespace = "mcpplibs", name = "capi.lua" })";
    EXPECT_TRUE(
        mcpp::manifest::xpkg_name_form_violation_from_lua(nonAtomic).has_value());
}

// ─── canonical_xpkg_identity — the unified (ns, name) model (§4.2) ───
//
// Identity is a 2-tuple: ns is a hierarchical namespace path, name is a single
// atomic segment. Every surface spelling normalizes to this tuple.

namespace {
mcpp::manifest::XpkgIdentity id(std::string_view ns, std::string_view name,
                                std::string_view indexNs = {}) {
    return mcpp::manifest::canonical_xpkg_identity(ns, name, indexNs);
}
mcpp::manifest::XpkgIdentity want(std::string n, std::string s) {
    return mcpp::manifest::XpkgIdentity{std::move(n), std::move(s)};
}
}  // namespace

TEST(CanonicalIdentity, PrefixEmbeddedNameCollapses) {
    // ns=compat, name=compat.zlib  →  (compat, zlib)
    EXPECT_EQ(id("compat", "compat.zlib"), want("compat", "zlib"));
}

TEST(CanonicalIdentity, BareNameCombinesWithNamespace) {
    // ns=mcpplibs, name=cmdline  →  (mcpplibs, cmdline)
    EXPECT_EQ(id("mcpplibs", "cmdline"), want("mcpplibs", "cmdline"));
}

TEST(CanonicalIdentity, AlreadyQualifiedNameIsIdempotent) {
    EXPECT_EQ(id("mcpplibs", "mcpplibs.cmdline"), want("mcpplibs", "cmdline"));
}

TEST(CanonicalIdentity, NoNamespaceInheritsOwningIndex) {
    // ns=∅, name=zlib, index=xim  →  (xim, zlib)
    EXPECT_EQ(id("", "zlib", "xim"), want("xim", "zlib"));
    EXPECT_EQ(id("", "tinycfg", "local-dev"), want("local-dev", "tinycfg"));
}

TEST(CanonicalIdentity, DeclaredNamespaceWinsOverIndexDefault) {
    EXPECT_EQ(id("compat", "compat.zlib", "xim"), want("compat", "zlib"));
}

TEST(CanonicalIdentity, DottedNameWithNoNamespaceIsNotReinterpreted) {
    // SPEC-001: identity is exactly what the descriptor declares. A dotted
    // `name` with no namespace is NOT silently split into one — that inferred
    // a namespace nobody wrote. It stays literal here and is rejected by
    // xpkg_name_form_violation instead.
    EXPECT_EQ(id("", "a.b"), want("", "a.b"));
    EXPECT_EQ(id("", "x.y.z"), want("", "x.y.z"));
    EXPECT_TRUE(mcpp::manifest::xpkg_name_form_violation("", "a.b").has_value());
}

TEST(CanonicalIdentity, HierarchicalNamespaceIsSupported) {
    // ns=a.b, name=c  →  (a.b, c) ; name is the single trailing segment.
    EXPECT_EQ(id("a.b", "c"), want("a.b", "c"));
    EXPECT_EQ(id("mcpplibs.capi", "lua"), want("mcpplibs.capi", "lua"));
    // Legacy FQN spelling under the SAME namespace strips the prefix.
    EXPECT_EQ(id("mcpplibs.capi", "mcpplibs.capi.lua"),
              want("mcpplibs.capi", "lua"));
    // But a shorter declared namespace no longer "absorbs" the extra segment:
    // the descriptor said mcpplibs, so the identity is mcpplibs — the leftover
    // dot makes it a form violation rather than a silent (mcpplibs.capi, lua).
    EXPECT_EQ(id("mcpplibs", "mcpplibs.capi.lua"), want("mcpplibs", "capi.lua"));
    EXPECT_TRUE(mcpp::manifest::xpkg_name_form_violation(
        "mcpplibs", "mcpplibs.capi.lua").has_value());
}

TEST(CanonicalIdentity, BareNameNoNamespaceNoIndexStaysRootless) {
    // The incident villain: a foreign bare descriptor with nothing to anchor it.
    EXPECT_EQ(id("", "zlib"), want("", "zlib"));
}

TEST(CanonicalIdentity, FromLuaReadsDeclaredFields) {
    constexpr std::string_view lua =
        R"(package = { namespace = "compat", name = "compat.zlib" })";
    EXPECT_EQ(mcpp::manifest::canonical_xpkg_identity_from_lua(lua),
              want("compat", "zlib"));
    // No-namespace descriptor + owning index.
    constexpr std::string_view bare = R"(package = { name = "tinycfg" })";
    EXPECT_EQ(mcpp::manifest::canonical_xpkg_identity_from_lua(bare, "local-dev"),
              want("local-dev", "tinycfg"));
    // No declared name → empty identity.
    constexpr std::string_view noName = R"(package = { version = "1.0" })";
    EXPECT_EQ(mcpp::manifest::canonical_xpkg_identity_from_lua(noName),
              want("", ""));
}

// ── Descriptor grammar v2: Lua long-bracket strings + block comments ──
// Design: .agents/docs/2026-07-08-index-version-semantics-and-descriptor-grammar-design.md (D1)

TEST(XpkgLongBracket, GeneratedFilesMultiline) {
    // Content carries braces, quotes, an embedded `]]` (level-2 brackets),
    // and a leading newline that Lua semantics strip.
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "lbtest",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "mcpp_generated/gen.cc" },
        generated_files = {
            ["mcpp_generated/gen.cc"] = [==[
export module gen;
int f() { return "x]]y"[0]; }
]==],
        },
        targets = { ["gen"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "lbtest", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_TRUE(m->buildConfig.generatedFiles.contains("mcpp_generated/gen.cc"));
    EXPECT_EQ(m->buildConfig.generatedFiles["mcpp_generated/gen.cc"],
              "export module gen;\nint f() { return \"x]]y\"[0]; }\n");
}

TEST(XpkgLongBracket, BlockCommentWithBracesAndFakeMcpp) {
    // A block comment containing braces and the literal text `mcpp = {`
    // must neither corrupt the structural depth count nor false-match
    // the segment locator.
    constexpr auto lua = R"(
--[==[
decoy: mcpp = { sources = { "WRONG" } } }}}}
]==]
package = {
    spec = "1",
    name = "cmt",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        --[[ inline block comment { with braces } ]]
        sources = { [[src/*.cpp]] },
        targets = { ["cmt"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "cmt", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->modules.sources.size(), 1u);
    EXPECT_EQ(m->modules.sources[0], "src/*.cpp");
}

TEST(XpkgLongBracket, NoLeadingNewlineKeptVerbatim) {
    // Without a newline after the opening bracket, content starts
    // immediately; CRLF right after the bracket is stripped as one break.
    constexpr auto lua =
        "package = {\n"
        "    spec = \"1\",\n"
        "    name = \"nl\",\n"
        "    xpm  = { linux = { [\"1.0.0\"] = { url = \"u\", sha256 = \"h\" } } },\n"
        "    mcpp = {\n"
        "        sources = { \"g.cc\" },\n"
        "        generated_files = { [\"g.cc\"] = [[inline]], [\"h.cc\"] = [[\r\ncrlf]] },\n"
        "        targets = { [\"nl\"] = { kind = \"lib\" } },\n"
        "    },\n"
        "}\n";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "nl", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.generatedFiles["g.cc"], "inline");
    EXPECT_EQ(m->buildConfig.generatedFiles["h.cc"], "crlf");
}

TEST(XpkgLongBracket, UnknownKeysRecordedSchemaAccepted) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "uk",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        schema  = "0.1",
        sources = { "a.c" },
        bogus_key = "x",
        future_table = { nested = { 1, 2 } },
        targets = { ["uk"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "uk", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->xpkgUnknownKeys.size(), 2u);
    EXPECT_EQ(m->xpkgUnknownKeys[0], "bogus_key");
    EXPECT_EQ(m->xpkgUnknownKeys[1], "future_table");
}

// ── scan_overrides: author-asserted scan results ──
// Design: .agents/docs/2026-07-08-scanner-backend-abstraction-design.md §3-pre

TEST(ScanOverrides, XpkgSegmentParses) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    namespace = "fmtlib",
    name = "fmtlib.fmt",
    xpm  = { linux = { ["12.2.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources  = { "*/src/fmt.cc" },
        cxxflags = { "-DFMT_IMPORT_STD" },
        scan_overrides = {
            ["*/src/fmt.cc"] = { provides = { "fmt" }, imports = { "std" } },
        },
        targets  = { ["fmt"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "fmtlib.fmt", "12.2.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->modules.scanOverrides.size(), 1u);
    auto& ov = m->modules.scanOverrides.at("*/src/fmt.cc");
    ASSERT_EQ(ov.provides.size(), 1u);
    EXPECT_EQ(ov.provides[0], "fmt");
    ASSERT_EQ(ov.imports.size(), 1u);
    EXPECT_EQ(ov.imports[0], "std");
    EXPECT_TRUE(m->xpkgUnknownKeys.empty());
}

TEST(ScanOverrides, XpkgRejectsEmptyDeclaration) {
    constexpr auto lua = R"(
package = {
    spec = "1",
    name = "so",
    xpm  = { linux = { ["1.0.0"] = { url = "u", sha256 = "h" } } },
    mcpp = {
        sources = { "a.cc" },
        scan_overrides = { ["a.cc"] = { } },
        targets = { ["so"] = { kind = "lib" } },
    },
}
)";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "so", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("neither provides nor imports"),
              std::string::npos) << m.error().format();
}

TEST(ScanOverrides, TomlParses) {
    constexpr auto src = R"(
[package]
name = "app"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm", "vendor/fmt.cc"]
["scan_overrides"."vendor/fmt.cc"]
provides = ["fmt"]
imports  = ["std"]
[targets.app]
kind = "bin"
main = "src/main.cpp"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->modules.scanOverrides.size(), 1u);
    auto& ov = m->modules.scanOverrides.at("vendor/fmt.cc");
    EXPECT_EQ(ov.provides, std::vector<std::string>{"fmt"});
    EXPECT_EQ(ov.imports,  std::vector<std::string>{"std"});
}

// ── declarative source-set parity: mcpp.toml ↔ xpkg descriptor ───────────────
// One data model, two grammars (manifest.cppm): what a descriptor can express
// through `features.<f>.sources` / `generated_files`, mcpp.toml must express
// identically. This test locks the symmetry as a contract.

TEST(Manifest, FeatureSourcesParseFromToml) {
    constexpr auto src = R"(
[package]
name = "sym"
version = "1.0.0"
[features]
default = []
compiled = { sources = ["src/impl/**"], defines = ["SYM_COMPILED"] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_TRUE(m->buildConfig.featureSources.contains("compiled"));
    EXPECT_EQ(m->buildConfig.featureSources.at("compiled"),
              (std::vector<std::string>{"src/impl/**"}));
    ASSERT_TRUE(m->buildConfig.featureDefines.contains("compiled"));
}

TEST(Manifest, GeneratedFilesParseFromToml) {
    constexpr auto src = R"(
[package]
name = "genf"
version = "1.0.0"

[generated_files]
"src/gen/wrap.cppm" = """
module;
export module wrap;
"""
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->buildConfig.generatedFiles.size(), 1u);
    auto it = m->buildConfig.generatedFiles.find(
        std::filesystem::path("src/gen/wrap.cppm"));
    ASSERT_NE(it, m->buildConfig.generatedFiles.end());
    EXPECT_EQ(it->second, "module;\nexport module wrap;\n");
}

TEST(Manifest, GeneratedFilesRejectEscapingPaths) {
    for (auto path : { "\"../evil.cpp\"", "\"/abs/evil.cpp\"", "\"a/../../evil.cpp\"" }) {
        auto src = std::format(R"(
[package]
name = "genf"
version = "1.0.0"
[generated_files]
{} = "x"
)", path);
        auto m = mcpp::manifest::parse_string(src);
        EXPECT_FALSE(m.has_value()) << "path accepted: " << path;
    }
}

TEST(Manifest, TomlAndXpkgFeatureSourcesAreSymmetric) {
    constexpr auto toml = R"(
[package]
name = "sym"
version = "1.0.0"
[features]
compiled = { sources = ["src/impl/**"], defines = ["SYM_COMPILED"] }
[generated_files]
"src/gen/wrap.cppm" = "module;\nexport module wrap;\n"
)";
    constexpr auto lua = R"(
package = { name = "sym" }
mcpp = {
    sources = { "src/**/*.cpp" },
    features = {
        compiled = { sources = { "src/impl/**" }, defines = { "SYM_COMPILED" } },
    },
    generated_files = {
        ["src/gen/wrap.cppm"] = "module;\nexport module wrap;\n",
    },
}
)";
    auto mt = mcpp::manifest::parse_string(toml);
    ASSERT_TRUE(mt.has_value()) << mt.error().format();
    auto mx = mcpp::manifest::synthesize_from_xpkg_lua(lua, "sym", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(mx.has_value()) << mx.error().format();

    EXPECT_EQ(mt->buildConfig.featureSources, mx->buildConfig.featureSources);
    EXPECT_EQ(mt->buildConfig.featureDefines, mx->buildConfig.featureDefines);
    EXPECT_EQ(mt->buildConfig.generatedFiles, mx->buildConfig.generatedFiles);
}

TEST(Manifest, CfgConditionalSourcesParseFromToml) {
    constexpr auto src = R"(
[package]
name = "condsrc"
version = "1.0.0"

[target.'cfg(arch = "x86_64")'.build]
sources  = ["src/x86/**/*.asm", "!src/x86/legacy/**"]
cxxflags = ["-DHAVE_X86=1"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    auto& cc = m->conditionalConfigs[0];
    EXPECT_EQ(cc.predicate, "cfg(arch = \"x86_64\")");
    EXPECT_EQ(cc.inputs.sources, (std::vector<std::string>{
        "src/x86/**/*.asm", "!src/x86/legacy/**"}));
    EXPECT_EQ(cc.inputs.cxxflags, (std::vector<std::string>{"-DHAVE_X86=1"}));
}

TEST(Manifest, TargetCfgParsesFromXpkgSymmetrically) {
    constexpr auto lua = R"(
package = { name = "condsrc" }
mcpp = {
    sources = { "src/**/*.c" },
    target_cfg = {
        ['cfg(arch = "x86_64")'] = {
            sources  = { "src/x86/**/*.asm" },
            cxxflags = { "-DHAVE_X86=1" },
        },
        ['cfg(windows)'] = {
            ldflags = { "-lws2_32" },
        },
    },
}
)";
    auto mx = mcpp::manifest::synthesize_from_xpkg_lua(lua, "condsrc", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(mx.has_value()) << mx.error().format();
    ASSERT_EQ(mx->conditionalConfigs.size(), 2u);
    EXPECT_EQ(mx->conditionalConfigs[0].predicate, "cfg(arch = \"x86_64\")");
    EXPECT_EQ(mx->conditionalConfigs[0].inputs.sources,
              (std::vector<std::string>{"src/x86/**/*.asm"}));
    EXPECT_EQ(mx->conditionalConfigs[1].predicate, "cfg(windows)");
    EXPECT_EQ(mx->conditionalConfigs[1].inputs.ldflags,
              (std::vector<std::string>{"-lws2_32"}));
}

TEST(Manifest, PerGlobFlagsParseOrderedFromToml) {
    constexpr auto src = R"(
[package]
name = "globf"
version = "1.0.0"

[build]
flags = [
  { glob = "third_party/**", cflags = ["-w"], cxxflags = ["-w"] },
  { glob = "src/simd/**/*.avx2.cpp", cxxflags = ["-mavx2"], defines = ["HAVE_AVX2"] },
  { glob = "src/x86/**/*.asm", asmflags = ["-DPIC"] },
]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto& gfs = m->buildConfig.globFlags;
    ASSERT_EQ(gfs.size(), 3u);
    // Declaration order IS the data (override semantics ride on it).
    EXPECT_EQ(gfs[0].glob, "third_party/**");
    EXPECT_EQ(gfs[0].cxxflags, (std::vector<std::string>{"-w"}));
    EXPECT_EQ(gfs[1].glob, "src/simd/**/*.avx2.cpp");
    EXPECT_EQ(gfs[1].defines, (std::vector<std::string>{"HAVE_AVX2"}));
    EXPECT_EQ(gfs[2].asmflags, (std::vector<std::string>{"-DPIC"}));
}

TEST(Manifest, PerGlobFlagsRejectUnknownKeysAndMissingGlob) {
    auto bad1 = mcpp::manifest::parse_string(R"(
[package]
name = "globf"
version = "1.0.0"
[build]
flags = [{ glob = "src/**", ldflags = ["-lfoo"] }]
)");
    EXPECT_FALSE(bad1.has_value());   // ldflags is not per-TU — closed grammar

    auto bad2 = mcpp::manifest::parse_string(R"(
[package]
name = "globf"
version = "1.0.0"
[build]
flags = [{ cxxflags = ["-w"] }]
)");
    EXPECT_FALSE(bad2.has_value());   // missing glob
}

TEST(Manifest, PerGlobFlagsParseFromXpkgSymmetrically) {
    constexpr auto lua = R"(
package = { name = "globf" }
mcpp = {
    sources = { "src/**/*.cpp" },
    flags = {
        { glob = "third_party/**", cxxflags = { "-w" } },
        { glob = "src/simd/**", cxxflags = { "-mavx2" }, defines = { "HAVE_AVX2" } },
    },
}
)";
    auto mx = mcpp::manifest::synthesize_from_xpkg_lua(lua, "globf", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(mx.has_value()) << mx.error().format();
    ASSERT_EQ(mx->buildConfig.globFlags.size(), 2u);
    EXPECT_EQ(mx->buildConfig.globFlags[0].glob, "third_party/**");
    EXPECT_EQ(mx->buildConfig.globFlags[1].cxxflags,
              (std::vector<std::string>{"-mavx2"}));
    EXPECT_EQ(mx->buildConfig.globFlags[1].defines,
              (std::vector<std::string>{"HAVE_AVX2"}));
}

TEST(Manifest, AllowsBuildFlagsArrayOfTablesSyntax) {
    // `[[build.flags]]` header form must still parse at the manifest layer
    // (not just the lower libs/toml layer) — the closed-grammar guard must
    // allowlist exactly this path.
    constexpr auto src = R"(
[package]
name = "globf"
version = "1.0.0"

[[build.flags]]
glob = "third_party/**"
cxxflags = ["-w"]

[[build.flags]]
glob = "src/x86/**/*.asm"
asmflags = ["-DPIC"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto& gfs = m->buildConfig.globFlags;
    ASSERT_EQ(gfs.size(), 2u);
    EXPECT_EQ(gfs[0].glob, "third_party/**");
    EXPECT_EQ(gfs[0].cxxflags, (std::vector<std::string>{"-w"}));
    EXPECT_EQ(gfs[1].glob, "src/x86/**/*.asm");
    EXPECT_EQ(gfs[1].asmflags, (std::vector<std::string>{"-DPIC"}));
}

// Closed-grammar guard (review fix on #227/#228): `[[dependencies]]` is a
// doubled-bracket typo for `[dependencies]`. Before this guard it parsed
// silently as an array-of-tables at that path; every consumer reads
// [dependencies] via get_table(), which returns nullptr for a non-table
// Value, so the whole section (all dependencies) silently vanished with no
// error and no warning. It must now be a loud parse error.
TEST(Manifest, RejectsArrayOfTablesTypoOnDependencies) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"

[[dependencies]]
gtest = "1.15.2"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("array-of-tables"), std::string::npos)
        << m.error().message;
    EXPECT_NE(m.error().message.find("dependencies"), std::string::npos)
        << m.error().message;
}

// Same guard, a different non-allowlisted path — confirms the check isn't
// hardcoded to just "dependencies".
TEST(Manifest, RejectsArrayOfTablesTypoOnToolchain) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "x"
version = "0.1.0"

[[toolchain]]
linux = "gcc@15.1.0"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("array-of-tables"), std::string::npos)
        << m.error().message;
}

// #258: `[target.'cfg(<os>)'.build]` accepts the same per-glob `flags` array
// `[build]` does. Before this, the conditional reader knew exactly four keys
// and dropped everything else silently, so a per-OS flag table was
// inexpressible in mcpp.toml while the xpkg descriptor's mcpp.<os> sections
// supported it — manifest-built packages were second-class.
TEST(Manifest, ConditionalSectionCarriesPerGlobFlags) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_cond_flags";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "condflags"
version = "0.1.0"

[build]
flags = [{ glob = "src/zlib/**", defines = ["HAVE_UNISTD_H=1"] }]

[target.'cfg(windows)'.build]
cflags = ["-DWIN32"]
include_dirs = ["vendor/win/include"]
flags = [
  { glob = "src/zlib/**", defines = ["NO_FSEEKO"], cflags = ["-UHAVE_UNISTD_H"] },
]
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);

    // Base table is unconditional.
    ASSERT_EQ(m->buildConfig.globFlags.size(), 1u);
    EXPECT_EQ(m->buildConfig.globFlags[0].glob, "src/zlib/**");

    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    auto& cc = m->conditionalConfigs[0];
    EXPECT_EQ(cc.predicate, "cfg(windows)");
    ASSERT_EQ(cc.inputs.globFlags.size(), 1u);
    EXPECT_EQ(cc.inputs.globFlags[0].glob, "src/zlib/**");
    EXPECT_EQ(cc.inputs.globFlags[0].defines,
              (std::vector<std::string>{"NO_FSEEKO"}));
    // The removal case: a windows-only -U that must land AFTER the base -D.
    EXPECT_EQ(cc.inputs.globFlags[0].cflags,
              (std::vector<std::string>{"-UHAVE_UNISTD_H"}));
    ASSERT_EQ(cc.inputs.includeDirs.size(), 1u);
    EXPECT_EQ(cc.inputs.includeDirs[0], std::filesystem::path("vendor/win/include"));
    std::filesystem::remove_all(tmp);
}

// The array-of-tables spelling must reach the same place, and must be
// allowlisted by the #227 closed-grammar guard.
TEST(Manifest, ConditionalPerGlobFlagsAcceptArrayOfTablesSpelling) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_cond_flags_aot";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "condflagsaot"
version = "0.1.0"

[[target.'cfg(linux)'.build.flags]]
glob = "src/**"
defines = ["ON_LINUX=1"]
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    ASSERT_EQ(m->conditionalConfigs[0].inputs.globFlags.size(), 1u);
    EXPECT_EQ(m->conditionalConfigs[0].inputs.globFlags[0].defines,
              (std::vector<std::string>{"ON_LINUX=1"}));
    std::filesystem::remove_all(tmp);
}

// Parity: the xpkg descriptor's target_cfg gets the same key, and its
// unknown-key policy stays a HARD ERROR. Sharing a parser must not be read
// as licence to relax a grammar that was already closed (#263 tracks making
// the policies consistent across sections; this test pins that #258 did not
// quietly change one).
TEST(Manifest, XpkgTargetCfgCarriesPerGlobFlagsAndStillRejectsUnknownKeys) {
    // Custom delimiter: the descriptor contains `)"` inside ["cfg(windows)"],
    // which would terminate a plain R"( ... )".
    const char* lua = R"LUA(
mcpp = {
    sources = { "src/**" },
    target_cfg = {
        ["cfg(windows)"] = {
            cflags = { "-DWIN32" },
            flags = { { glob = "src/z/**", defines = { "NO_FSEEKO" } } },
        },
    },
}
)LUA";
    auto m = mcpp::manifest::synthesize_from_xpkg_lua(lua, "p", "1.0.0", mcpp::platform::HostPlatform::current());
    ASSERT_TRUE(m) << (m ? "" : m.error().message);
    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    ASSERT_EQ(m->conditionalConfigs[0].inputs.globFlags.size(), 1u);
    EXPECT_EQ(m->conditionalConfigs[0].inputs.globFlags[0].glob, "src/z/**");

    const char* bad = R"LUA(
mcpp = {
    sources = { "src/**" },
    target_cfg = { ["cfg(windows)"] = { linkage = { "static" } } },
}
)LUA";
    auto bm = mcpp::manifest::synthesize_from_xpkg_lua(bad, "p", "1.0.0", mcpp::platform::HostPlatform::current());
    EXPECT_FALSE(bm) << "unknown target_cfg key must stay a hard error";
}

// #254: the host and target platform axes are distinct types, so an API
// states which one it wants and a call site must name the one it supplies.
// Before this, both were std::string_view and mixing them cost nothing —
// which is exactly how every xpkg per-OS splice ended up keyed on a
// compile-time HOST constant while [target.'cfg(...)'] was evaluated against
// the resolved TARGET.
TEST(PlatformAxis, HostAndTargetAreNotInterchangeable) {
    using mcpp::platform::HostPlatform;
    using mcpp::platform::TargetPlatform;

    static_assert(!std::is_convertible_v<HostPlatform, TargetPlatform>,
                  "the host axis must not silently become the target axis");
    static_assert(!std::is_convertible_v<TargetPlatform, HostPlatform>,
                  "the target axis must not silently become the host axis");
    // And neither is constructible from a bare string: passing "linux"
    // where an axis is expected is the bug class this type exists to stop.
    static_assert(!std::is_constructible_v<TargetPlatform, std::string_view>);
    static_assert(!std::is_constructible_v<HostPlatform, std::string_view>);

    // The triple vocabulary says "macos"; xpkg descriptors say "macosx".
    // That translation belongs to the axis, not to every call site.
    EXPECT_EQ(TargetPlatform::for_os("macos").key(), "macosx");
    EXPECT_EQ(TargetPlatform::for_os("macosx").key(), "macosx");
    EXPECT_EQ(TargetPlatform::for_os("windows").key(), "windows");
    EXPECT_EQ(TargetPlatform::for_os("linux").key(), "linux");
    // An absent/unknown os token keeps the pre-#254 behaviour: host.
    EXPECT_EQ(TargetPlatform::for_os("").key(),
              HostPlatform::current().key());
}

// The behaviour half: a descriptor's per-OS section must be spliced for the
// TARGET. Native builds cannot observe this (host == target), which is why
// three-platform CI never caught it.
TEST(Manifest, XpkgPerOsSectionSplicesForTheTargetNotTheHost) {
    const char* lua = R"LUA(
mcpp = {
    sources = { "base.cpp" },
    linux   = { sources = { "linux_only.cpp" } },
    macosx  = { sources = { "macos_only.cpp" } },
    windows = { sources = { "windows_only.cpp" } },
}
)LUA";
    auto has = [](const mcpp::manifest::Manifest& m, std::string_view glob) {
        return std::ranges::find(m.modules.sources, glob) != m.modules.sources.end();
    };

    for (auto [tripleOs, expected] : std::initializer_list<
             std::pair<std::string_view, std::string_view>>{
             {"linux", "linux_only.cpp"},
             {"macos", "macos_only.cpp"},
             {"windows", "windows_only.cpp"}}) {
        auto m = mcpp::manifest::synthesize_from_xpkg_lua(
            lua, "p", "1.0.0", mcpp::platform::TargetPlatform::for_os(tripleOs));
        ASSERT_TRUE(m) << (m ? "" : m.error().message);
        EXPECT_TRUE(has(*m, expected))
            << "target os " << tripleOs << " must splice its own section";
        EXPECT_TRUE(has(*m, "base.cpp"));
        // and must NOT carry the other legs
        for (std::string_view other : {"linux_only.cpp", "macos_only.cpp",
                                       "windows_only.cpp"}) {
            if (other == expected) continue;
            EXPECT_FALSE(has(*m, other))
                << "target os " << tripleOs << " must not carry " << other;
        }
    }
}

// Zero behaviour change for native builds is the safety net for #254: when
// host == target the splice must be byte-identical to what it always was.
TEST(Manifest, NativeBuildSpliceIsUnchanged) {
    const char* lua = R"LUA(
mcpp = {
    sources = { "base.cpp" },
    linux   = { sources = { "linux_only.cpp" }, cxxflags = { "-DL" } },
    macosx  = { sources = { "macos_only.cpp" }, cxxflags = { "-DM" } },
    windows = { sources = { "windows_only.cpp" }, cxxflags = { "-DW" } },
}
)LUA";
    auto host = mcpp::manifest::synthesize_from_xpkg_lua(
        lua, "p", "1.0.0", mcpp::platform::HostPlatform::current());
    auto nativeTarget = mcpp::manifest::synthesize_from_xpkg_lua(
        lua, "p", "1.0.0",
        mcpp::platform::TargetPlatform::for_lint_of(
            mcpp::platform::HostPlatform::current().key()));
    ASSERT_TRUE(host);
    ASSERT_TRUE(nativeTarget);
    EXPECT_EQ(host->modules.sources, nativeTarget->modules.sources);
    EXPECT_EQ(host->buildConfig.cxxflags, nativeTarget->buildConfig.cxxflags);
}

TEST(Manifest, IndicesArtifactAndSourceParsedAndPinSuppresses) {
    // #269: [indices] entries may declare an xlings >= 0.4.68 artifact
    // source. rev/tag/branch pins force git (the artifact channel only
    // tracks the latest pointer), which artifact_applicable() encodes.
    constexpr auto src = R"(
[package]
name = "hello"
version = "0.1.0"
[language]
standard = "c++23"
[modules]
sources = ["src/**/*.cppm"]
[indices]
fast   = { url = "https://example.com/i.git", artifact = "https://example.com/res/i", source = "auto" }
pinned = { url = "https://example.com/i.git", artifact = "https://example.com/res/i", rev = "abc123" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto& fast = m->indices.at("fast");
    EXPECT_EQ(fast.artifact, "https://example.com/res/i");
    EXPECT_EQ(fast.source, "auto");
    EXPECT_TRUE(fast.artifact_applicable());
    auto& pinned = m->indices.at("pinned");
    EXPECT_EQ(pinned.artifact, "https://example.com/res/i");
    EXPECT_FALSE(pinned.artifact_applicable());
}

// #359: `reexport = true` on a dependency edge — the knob that lets a library
// hand its build-time provisions (tools, host module, dependency dir) to its
// own consumers. Off by default, deliberately: the edge's `visibility` already
// defaults to "public", so riding that would have made every dependency at
// every depth able to push entries into a consumer's tool namespace silently.
TEST(Manifest, DependencyReexportIsOptIn) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_dep_reexport";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "reexporter"
version = "0.1.0"

[dependencies.compat]
protobuf = { version = "35.1", tools = ["protoc"], reexport = true }
zlib     = { version = "1.3.1", tools = ["minigzip"] }
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);

    const mcpp::pm::DependencySpec* pb = nullptr;
    const mcpp::pm::DependencySpec* zl = nullptr;
    for (auto const& [k, spec] : m->dependencies) {
        if (spec.shortName == "protobuf") pb = &spec;
        if (spec.shortName == "zlib")     zl = &spec;
    }
    ASSERT_NE(pb, nullptr);
    ASSERT_NE(zl, nullptr);
    EXPECT_TRUE(pb->reexport);
    EXPECT_FALSE(zl->reexport);
}

// #359 D3a: the conditional channel carried three of the four dependency maps
// and silently lacked `feature-deps`. A library that puts a host tool behind a
// feature has no other way to say "not on this platform", and an unconditional
// declaration turns an unsupported platform into a hard error raised from
// inside the LIBRARY's manifest, which its user cannot work around.
//
// The FEATURE is registered regardless of the predicate — only what it pulls
// in is conditional — so requesting it on a non-matching platform is not an
// unknown-feature error.
TEST(Manifest, ConditionalFeatureDepsAreParsedAndTheFeatureIsRegistered) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_cond_feature_deps";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "condfeatdeps"
version = "0.1.0"

[target.'cfg(not(windows))'.feature-deps.codegen]
"compat.protobuf" = { version = "35.1", tools = ["protoc"], reexport = true }
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);

    EXPECT_TRUE(m->featuresMap.contains("codegen"));
    // Not folded into the unconditional map: that happens in prepare, after
    // the predicate is evaluated against the RESOLVED target.
    EXPECT_TRUE(m->featureDeps.empty());

    ASSERT_EQ(m->conditionalConfigs.size(), 1u);
    auto const& cc = m->conditionalConfigs[0];
    EXPECT_EQ(cc.predicate, "cfg(not(windows))");
    ASSERT_TRUE(cc.featureDeps.contains("codegen"));
    ASSERT_EQ(cc.featureDeps.at("codegen").size(), 1u);
    auto const& spec = cc.featureDeps.at("codegen").begin()->second;
    EXPECT_EQ(spec.shortName, "protobuf");
    ASSERT_EQ(spec.tools.size(), 1u);
    EXPECT_EQ(spec.tools[0], "protoc");
    EXPECT_TRUE(spec.reexport);
}

// A dependency-spec key must be listed in TWO places in the TOML reader: the
// predicate that tells an inline spec from a nested namespace table, and the
// filler that reads the value. Miss the first and the diagnostic is actively
// misleading — the table is taken for a namespace and the user is told their
// bool "must be a string, inline dep table, or nested table". #359 hit exactly
// that while adding `reexport`.
//
// One manifest using every key at once is the cheapest way to keep the two in
// sync: a key added to the filler but not the predicate fails this test.
TEST(Manifest, EveryDependencySpecKeyIsAccepted) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_dep_spec_keys";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "depspeckeys"
version = "0.1.0"

[dependencies.compat]
everything = { version = "1.0.0", features = ["x"], default-features = false, visibility = "private", backend = "openblas", tools = ["t"], host-module = true, reexport = true, linkage = "shared" }
bygit      = { git = "https://example.invalid/x.git", tag = "v1", visibility = "interface" }
bypath     = { path = "../sibling" }
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);

    const mcpp::pm::DependencySpec* all = nullptr;
    for (auto const& [k, spec] : m->dependencies)
        if (spec.shortName == "everything") all = &spec;
    ASSERT_NE(all, nullptr);
    EXPECT_EQ(all->version, "1.0.0");
    EXPECT_EQ(all->visibility, "private");
    EXPECT_FALSE(all->defaultFeatures);
    EXPECT_TRUE(all->hostModule);
    EXPECT_TRUE(all->reexport);
    ASSERT_EQ(all->tools.size(), 1u);
    EXPECT_EQ(all->tools[0], "t");
    // `backend = "openblas"` is sugar for requesting the backend-<impl> feature.
    EXPECT_NE(std::find(all->features.begin(), all->features.end(), "backend-openblas"),
              all->features.end());
    EXPECT_EQ(all->linkage, "shared");
}

// ── #519: the dependency-form axis ────────────────────────────────────────

namespace {

std::expected<mcpp::manifest::Manifest, mcpp::manifest::ManifestError>
load_inline(std::string_view name, std::string_view body) {
    auto tmp = std::filesystem::temp_directory_path()
             / std::format("mcpp_{}_{}", name, std::random_device{}());
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    { std::ofstream os(path); os << body; }
    return mcpp::manifest::load(path);
}

} // namespace

TEST(Manifest, DependencyLinkageDefaultsToEmptyMeaningStatic) {
    auto m = load_inline("deplinkage_default", R"(
[package]
name = "x"
version = "0.1.0"
)");
    ASSERT_TRUE(m);
    EXPECT_TRUE(m->buildConfig.dependencyLinkage.empty());
}

TEST(Manifest, DependencyLinkageIsAClosedVocabulary) {
    auto ok = load_inline("deplinkage_ok", R"(
[package]
name = "x"
version = "0.1.0"
[build]
dependency_linkage = "shared"
)");
    ASSERT_TRUE(ok);
    EXPECT_EQ(ok->buildConfig.dependencyLinkage, "shared");

    // ⚠️ "dynamic" is the LIBC axis' word. Accepting it here would silently
    // mean "static", because that is what an unparsed value resolves to.
    auto bad = load_inline("deplinkage_bad", R"(
[package]
name = "x"
version = "0.1.0"
[build]
dependency_linkage = "dynamic"
)");
    EXPECT_FALSE(bad);
}

TEST(Manifest, ProfileDependencyLinkageIsOptionalSoItDoesNotResetBuild) {
    // Resolving a profile REPLACES the whole Profile struct, so a plain field
    // would make any declared profile silently undo `[build]`.
    auto m = load_inline("deplinkage_profile", R"(
[package]
name = "x"
version = "0.1.0"
[build]
dependency_linkage = "shared"
[profile.dev]
opt = "0"
[profile.fast]
dependency_linkage = "static"
)");
    ASSERT_TRUE(m);
    ASSERT_TRUE(m->profiles.contains("dev"));
    EXPECT_FALSE(m->profiles.at("dev").dependencyLinkage.has_value());
    ASSERT_TRUE(m->profiles.contains("fast"));
    ASSERT_TRUE(m->profiles.at("fast").dependencyLinkage.has_value());
    EXPECT_EQ(*m->profiles.at("fast").dependencyLinkage, "static");
}

TEST(Manifest, ADependencyEdgeLinkageIsAClosedVocabularyToo) {
    auto bad = load_inline("edge_linkage_bad", R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
zlib = { version = "1.0.0", linkage = "dynamic" }
)");
    EXPECT_FALSE(bad);
}

TEST(Manifest, ALibraryTargetMayDeclareASoname) {
    // ⚠️ This used to make the WHOLE MANIFEST FAIL TO LOAD, in both parsers.
    // A soname is the name a library is FOUND by, and it is the only way two
    // copies of one library can resolve to a single file — so a package has
    // to be able to state it while still being consumed as a static library,
    // which is the normal case.
    auto m = load_inline("soname_on_lib", R"(
[package]
name = "z"
version = "0.1.0"
[targets.z]
kind = "lib"
soname = "libz.so.1"
)");
    ASSERT_TRUE(m) << (m ? "" : m.error().message);
    ASSERT_EQ(m->targets.size(), 1u);
    EXPECT_EQ(m->targets[0].soname, "libz.so.1");
}

TEST(Manifest, ASonameOnABinaryTargetIsStillRefused) {
    auto m = load_inline("soname_on_bin", R"(
[package]
name = "z"
version = "0.1.0"
[targets.z]
kind = "bin"
main = "src/main.cpp"
soname = "libz.so.1"
)");
    EXPECT_FALSE(m);
}

TEST(Manifest, ASonameMustStillBeABasename) {
    auto m = load_inline("soname_path", R"(
[package]
name = "z"
version = "0.1.0"
[targets.z]
kind = "lib"
soname = "lib/libz.so.1"
)");
    EXPECT_FALSE(m);
}

// #359: a manifest written for a NEWER mcpp must still load.
//
// What made this impossible was that one predicate served two purposes: it
// decided "inline dep spec vs nested namespace table" AND enumerated the
// vocabulary. A key the reader did not know therefore did not read as an
// unknown option — the table failed the discriminator, was taken for a
// namespace, and the user was told their `reexport = true` "must be a string,
// inline dep table, or nested table". A published package could consequently
// never adopt a new key: every older client failed to load it outright.
//
// The discriminator is now "does it name a source", which a namespace table
// cannot accidentally satisfy, and an unrecognized key is a recorded
// degradation (--strict still refuses it).
TEST(Manifest, UnknownDependencyKeyDegradesInsteadOfFailingTheLoad) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_dep_future_key";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "futurekey"
version = "0.1.0"

[dependencies]
zlib = { version = "1.3.1", some-future-field = true }
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);

    const mcpp::pm::DependencySpec* z = nullptr;
    for (auto const& [k, spec] : m->dependencies)
        if (spec.shortName == "zlib") z = &spec;
    ASSERT_NE(z, nullptr);
    EXPECT_EQ(z->version, "1.3.1");   // the part this reader understands still applies

    bool warned = false;
    for (auto const& w : m->schemaWarnings)
        if (w.find("some-future-field") != std::string::npos) warned = true;
    EXPECT_TRUE(warned) << "the ignored key must be reported, not swallowed";
}

// The discriminator must not mistake a namespace subtable for an inline spec.
// `[dependencies.compat] zlib = "1.3.1"` has one key, `zlib`, which names no
// source — so it is a namespace, and the entry below it is the dependency.
TEST(Manifest, NamespaceSubtableIsNotMistakenForAnInlineSpec) {
    auto tmp = std::filesystem::temp_directory_path() / "mcpp_ns_vs_spec";
    std::filesystem::create_directories(tmp);
    auto path = tmp / "mcpp.toml";
    {
        std::ofstream os(path);
        os << R"(
[package]
name = "nsvsspec"
version = "0.1.0"

[dependencies.compat]
zlib = "1.3.1"
gtest = { version = "1.15.2", features = ["main"] }
)";
    }
    auto m = mcpp::manifest::load(path);
    ASSERT_TRUE(m) << (m ? "" : m.error().message);
    std::set<std::string> got;
    for (auto const& [k, spec] : m->dependencies) {
        got.insert(spec.shortName);
        EXPECT_EQ(spec.namespace_, "compat") << spec.shortName;
    }
    EXPECT_TRUE(got.contains("zlib"));
    EXPECT_TRUE(got.contains("gtest"));
}

// `cxx_runtime` gained a third role key. The table is validated by an explicit
// whitelist, so a new spelling that nobody added there is rejected with a
// message naming the key — which is the behaviour, not an accident.
TEST(Manifest, CxxRuntimeAcceptsThePerRoleTableIncludingShared) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[build]
cxx_runtime = { default = "self-contained", tests = "host-coupled", shared = "toolchain-coupled" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.cxxRuntime,       "self-contained");
    EXPECT_EQ(m->buildConfig.cxxRuntimeTests,  "host-coupled");
    EXPECT_EQ(m->buildConfig.cxxRuntimeShared, "toolchain-coupled");
    // And it must not be reported as an unsupported [build] key. The whole
    // feature is reachable only through this spelling, so a warning saying it
    // is "ignored" would be both noisy and false.
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

TEST(Manifest, CxxRuntimeRejectsAnUnknownRoleKey) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[build]
cxx_runtime = { sharedd = "self-contained" }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().format().find("sharedd"), std::string::npos)
        << m.error().format();
}

// The scalar spelling still means "every role", including shared libraries.
TEST(Manifest, CxxRuntimeScalarStillAppliesToEveryRole) {
    constexpr auto src = R"(
[package]
name    = "app"
version = "0.1.0"
[build]
cxx_runtime = "host-coupled"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.cxxRuntime, "host-coupled");
    EXPECT_TRUE(m->buildConfig.cxxRuntimeShared.empty());
    EXPECT_TRUE(m->schemaWarnings.empty());
}

TEST(Manifest, BmiScheduleKey) {
    // The KEY SPELLING, not just the field. `[build] bmi_schedule` reaches the
    // build only through this one string in mcpp.manifest.toml, and nothing
    // downstream can tell a mistyped key from an absent one: the value silently
    // stays empty, `requested_switch` returns "auto", and the build quietly uses
    // the default schedule. Every other test would still pass.
    //
    // It was called `schedule` until it was renamed to agree with its own
    // environment override, `MCPP_BMI_SCHEDULE`. This is what makes the next
    // such rename fail loudly instead of silently.
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[build]
bmi_schedule = "on"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->buildConfig.bmiSchedule, "on");

    // And the old spelling must NOT still work: leaving it accepted would mean
    // two keys for one switch, which is how a rename ends up half-done.
    constexpr auto old_key = R"(
[package]
name = "x"
version = "0.1.0"
[build]
schedule = "on"
)";
    auto o = mcpp::manifest::parse_string(old_key);
    ASSERT_TRUE(o.has_value()) << o.error().format();
    EXPECT_TRUE(o->buildConfig.bmiSchedule.empty())
        << "the pre-rename key `schedule` is still being read";

    // ⚠️ AND THE PARSER MUST NOT WARN ABOUT ITS OWN KEY.
    //
    // Checking only the VALUE is what let this ship broken. The rename reached
    // the read (`build.bmi_schedule`) but not the accepted-key list, which kept
    // the old `schedule` — so the assertions above passed while a user writing
    // the one documented way to enable the feature got
    //
    //     [build] has unsupported key 'bmi_schedule' (ignored)
    //
    // and that message is FALSE: the value is read. The only way to turn the
    // feature on announced that it had been ignored, and the dead `schedule`
    // was accepted in silence. Both halves of the rename are pinned now.
    for (const auto& w : m->schemaWarnings)
        EXPECT_EQ(w.find("bmi_schedule"), std::string::npos)
            << "the parser reads `bmi_schedule` but also warns about it: " << w;

    EXPECT_TRUE(std::ranges::any_of(o->schemaWarnings,
                                    [](const std::string& w) {
                                        return w.find("schedule") != std::string::npos;
                                    }))
        << "the dead key `schedule` is accepted silently — an unread key that "
           "produces no diagnostic is a typo that costs a debugging session";
}

// #418 — an unsupported SCALAR under `[target.<triple>]` is reported; the
// conditional sub-TABLES are not.
//
// `[target.<triple>]` had no unknown-key check at all, so `cxx_runtime_tests`
// — a key that existed on the struct, was parsed nowhere and applied nowhere —
// was accepted in silence. A configuration key that does nothing is worse than
// one that does not exist.
//
// ⚠️ AND THE CHECK MUST NOT SEE THE CONDITIONAL CHANNEL. TOML presents
// `[target.<pred>.dependencies]` as a KEY of `[target.<pred>]`, so a
// hand-written "known keys" list has to enumerate `build`, `dependencies`,
// `dev-dependencies`, `build-dependencies`, `feature-deps` too — and that list
// is precisely what this codebase has watched drift twice (ConditionalConfig's
// own comments on #258 and #359). The first version of this check did exactly
// that and warned about a documented feature. Scalars only; tables are skipped
// on principle, not by enumeration.
TEST(Manifest, PerTargetUnknownScalarWarnsButSubTablesDoNot) {
    constexpr auto src = R"(
[package]
name = "t"
version = "0.1.0"

[target.'cfg(unix)'.dependencies]
dep = { path = "dep" }

[target.x86_64-linux-gnu]
linkage = "dynamic"
cxx_runtime_tests = "host-coupled"

[target.x86_64-linux-gnu.build]
defines = ["FOO=1"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();

    auto mentions = [&](std::string_view needle) {
        return std::ranges::any_of(m->schemaWarnings, [&](const std::string& w) {
            return w.find(needle) != std::string::npos;
        });
    };

    EXPECT_TRUE(mentions("cxx_runtime_tests"))
        << "a per-target scalar that nothing reads must be reported, not dropped";

    // The conditional channel is not a typo, and warning about it would be a
    // false positive on a documented feature (e2e 195 uses it).
    EXPECT_FALSE(mentions("'dependencies'"))
        << "[target.<pred>.dependencies] is the conditional channel, not an unknown key";
    EXPECT_FALSE(mentions("'build'"))
        << "[target.<pred>.build] is the conditional channel, not an unknown key";

    // ...and the field itself is gone, so nothing downstream can read it.
    EXPECT_EQ(m->targetOverrides.at("x86_64-linux-gnu").cxxRuntime, "");
}

// ── [target.<triple>].runner ────────────────────────────────────────────────

TEST(Manifest, TargetRunnerParsesAndDoesNotWarn) {
    constexpr auto src = R"(
[package]
name = "fw"
version = "0.1.0"

[target.riscv64-none-elf]
runner = ["qemu-system-riscv64", "-machine", "virt", "-kernel"]
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->targetOverrides.find("riscv64-none-elf");
    ASSERT_NE(it, m->targetOverrides.end());
    ASSERT_EQ(it->second.runner.size(), 4u);
    EXPECT_EQ(it->second.runner.front(), "qemu-system-riscv64");
    EXPECT_EQ(it->second.runner.back(),  "-kernel");
    // ⚠️ The unknown-key sweep is about SCALARS ("a scalar that does
    // nothing"). It skipped tables but not arrays, so this key was reported as
    // "unsupported key 'runner' (ignored)" while in fact being honoured —
    // worse than either statement being true. Seen in CI.
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

TEST(Manifest, TargetRunnerRejectsShapesThatWouldRunNothing) {
    // An empty template would exec nothing and report success.
    constexpr auto empty = R"(
[package]
name = "fw"
version = "0.1.0"
[target.riscv64-none-elf]
runner = []
)";
    EXPECT_FALSE(mcpp::manifest::parse_string(empty).has_value());

    // A bare string is the shape a user reaches for first; taking it would
    // mean guessing where the word boundaries are.
    constexpr auto scalar = R"(
[package]
name = "fw"
version = "0.1.0"
[target.riscv64-none-elf]
runner = "qemu-system-riscv64 -kernel"
)";
    EXPECT_FALSE(mcpp::manifest::parse_string(scalar).has_value());
}

// ── [target.<triple>].sysroot — the target's C library, per project ──────────
//
// The axis exists because the target table binds one C library per triple, and
// three independent needs want to disagree with it: a kernel wants none, a
// project on a vendor SDK wants that SDK's newlib, and a `std-freestanding`
// stack over openkal wants openkal's C library.

TEST(Manifest, TargetSysrootOverrideIsParsed) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.riscv64-none-elf]
sysroot = "xim:newlib-riscv@4.4"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->targetOverrides.find("riscv64-none-elf");
    ASSERT_NE(it, m->targetOverrides.end());
    ASSERT_TRUE(it->second.sysrootDeclared);
    EXPECT_EQ(it->second.sysroot, "xim:newlib-riscv@4.4");
    EXPECT_TRUE(m->schemaWarnings.empty())
        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
}

// ⚠️ The distinction this test pins is the reason the field is an optional.
// An empty string is a REQUEST (no C library), not an absence.
TEST(Manifest, TargetSysrootEmptyStringIsRecordedAsPresent) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.riscv64-none-elf]
sysroot = ""
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->targetOverrides.find("riscv64-none-elf");
    ASSERT_NE(it, m->targetOverrides.end());
    ASSERT_TRUE(it->second.sysrootDeclared);
    EXPECT_TRUE(it->second.sysroot.empty());
}

TEST(Manifest, TargetSysrootAbsentIsNotDeclared) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.riscv64-none-elf]
linkage = "static"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    auto it = m->targetOverrides.find("riscv64-none-elf");
    ASSERT_NE(it, m->targetOverrides.end());
    EXPECT_FALSE(it->second.sysrootDeclared);
}

// A bare name is the plausible typo, and accepting it would install nothing
// and then fail much later naming a missing libc.
TEST(Manifest, TargetSysrootRejectsANonXpkgReference) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.riscv64-none-elf]
sysroot = "newlib"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().format().find("xpkg reference"), std::string::npos);
}

// The unknown-scalar sweep must not report a key it now honours — the exact
// shape of #418, where a key was reported as ignored while being applied.
TEST(Manifest, TargetSysrootIsNotReportedAsUnsupported) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[target.riscv64-none-elf]
sysroot = ""
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << m.error().format();
    for (auto const& w : m->schemaWarnings)
        EXPECT_EQ(w.find("sysroot"), std::string::npos) << w;
}

// ── Dependency version requirements are checked where they are written ───────
//
// ⚠️ The parser that decides which published version satisfies a requirement
// existed all along; the dependency reader did not use it, and handed its
// string to the installer instead. A requirement the matcher could never
// satisfy therefore reached the network and came back as
// `E_NOT_FOUND: package '…@0.1.x' not found` — naming the PACKAGE, which
// exists. This repository's own documentation recommended that form.

// ⚠️ PARSE-acceptance, which is a weaker property than installability and was
// measured to be weaker: `"0.0"` parses here and then fails at fetch with
// `install path missing`. The check added below is a manifest check and has no
// business ruling on the installer's path derivation, so this test pins what
// the PARSER must keep accepting and says nothing about what fetches.
TEST(Manifest, DependencyVersionParserAcceptsEveryEstablishedForm) {
    // ⭐ This test exists to prevent the check from NARROWING anything.
    for (const char* v : { "0.0.1", "0.0", "^0.0.1", ">=0.0.1, <0.1.0", "*" }) {
        auto src = std::format(R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
cmdline = "{}"
)", v);
        auto m = mcpp::manifest::parse_string(src);
        EXPECT_TRUE(m.has_value()) << v << ": " << (m ? "" : m.error().format());
    }
}

// ⚠️ REPORTED, NOT REJECTED, and the distinction is load-bearing. The first
// version of this check returned an error, and a project pinned to a PUBLISHED
// package carrying such a string stopped loading entirely — including when the
// offending entry belonged to a feature nobody activates. Published data must
// not be invalidated by a new program any more than the reverse.
TEST(Manifest, DependencyVersionReportsATrailingXWithoutFailingTheLoad) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
cmdline = "0.0.x"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    bool found = false;
    for (auto const& w : m->schemaWarnings)
        if (w.find("not a requirement") != std::string::npos) found = true;
    EXPECT_TRUE(found) << "no warning naming the requirement";
    // ⭐ And it must say that the PACKAGE is not the problem, because the
    // failure the reader will otherwise see names exactly that.
    for (auto const& w : m->schemaWarnings)
        if (w.find("not a requirement") != std::string::npos)
            EXPECT_NE(w.find("PACKAGE"), std::string::npos) << w;
}

TEST(Manifest, DependencyVersionReportsTrailingGarbage) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
cmdline = "1.2.3abc"
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value());
    EXPECT_FALSE(m->schemaWarnings.empty());
}

// A path or git dependency has no version, and requiring one would break every
// workspace member.
TEST(Manifest, DependencyWithoutAVersionIsUnaffected) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
local = { path = "../local" }
)";
    auto m = mcpp::manifest::parse_string(src);
    EXPECT_TRUE(m.has_value()) << (m ? "" : m.error().format());
}

// The long form reaches a different code path than the bare string, and only
// one of the two used to set `spec.version`. Both are checked.
TEST(Manifest, LongFormDependencyVersionIsCheckedToo) {
    constexpr auto src = R"(
[package]
name = "x"
version = "0.1.0"
[dependencies]
cmdline = { version = "0.0.x", features = ["a"] }
)";
    auto m = mcpp::manifest::parse_string(src);
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    bool found = false;
    for (auto const& w : m->schemaWarnings)
        if (w.find("not a requirement") != std::string::npos) found = true;
    EXPECT_TRUE(found);
}

// ─── [hooks] — project build lifecycle commands (#496) ───────────────────
//
// The section is parsed here rather than by the module that runs the commands,
// so this is where its grammar is pinned. The invocation policy (what a
// failure costs, when each event fires) is e2e 314's subject.

namespace {
constexpr std::string_view kHookPreamble = R"(
[package]
name = "x"
version = "0.1.0"
)";

std::expected<mcpp::manifest::Manifest, mcpp::manifest::ManifestError>
parse_with_hooks(std::string_view hooksSection) {
    return mcpp::manifest::parse_string(
        std::string(kHookPreamble) + std::string(hooksSection));
}
}  // namespace

TEST(ManifestHooks, AbsentSectionIsInertButNotDisabled) {
    auto m = mcpp::manifest::parse_string(kHookPreamble);
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    // `enabled` defaults to true and says nothing about whether there is work
    // to do; `active()` is the predicate the fast path is allowed to consult.
    EXPECT_TRUE(m->hooks.enabled);
    EXPECT_FALSE(m->hooks.active());
    EXPECT_EQ(m->hooks.timeoutSeconds, 10);
    // Experimental: a hook may not decide whether a build succeeded, so this
    // defaults to false and is the only value the parser accepts.
    EXPECT_FALSE(m->hooks.sideEffect);
}

// ⚠️ The experimental gate. Refused rather than downgraded: honouring it would
// give an experimental feature a veto over every build, and ignoring it would
// leave the project believing its build is gated on a notifier when nothing
// is. Both silent options are worse than the error.
TEST(ManifestHooks, SideEffectTrueIsRefusedWhileTheFeatureIsExperimental) {
    auto m = parse_with_hooks(R"(
[hooks]
build_finished = "echo done"
side_effect = true
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("experimental"), std::string::npos)
        << m.error().message;
    EXPECT_NE(m.error().message.find("side_effect"), std::string::npos)
        << m.error().message;
}

// The key stays in the vocabulary: writing the value that IS the current
// behaviour must keep working, so a manifest does not have to change when the
// feature is promoted.
TEST(ManifestHooks, SideEffectFalseIsAcceptedSoTheKeyStaysReserved) {
    auto m = parse_with_hooks(R"(
[hooks]
build_finished = "echo done"
side_effect = false
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_FALSE(m->hooks.sideEffect);
}

TEST(ManifestHooks, CommandsAndPolicyAreRead) {
    auto m = parse_with_hooks(R"(
[hooks]
build_start = "echo start"
build_failed = "echo failed"
build_finished = "echo finished"
timeout_seconds = 30
side_effect = false
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.buildStart.cmd, "echo start");
    EXPECT_EQ(m->hooks.buildFailed.cmd, "echo failed");
    EXPECT_EQ(m->hooks.buildFinished.cmd, "echo finished");
    EXPECT_EQ(m->hooks.timeoutSeconds, 30);
    EXPECT_FALSE(m->hooks.sideEffect);
    EXPECT_TRUE(m->hooks.active());
}

// `enabled = false` has to switch off a table that still names commands —
// otherwise the only way to silence hooks is to delete them.
TEST(ManifestHooks, DisabledTableIsNotActive) {
    auto m = parse_with_hooks(R"(
[hooks]
build_start = "echo start"
enabled = false
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.buildStart.cmd, "echo start");
    EXPECT_FALSE(m->hooks.active());
}

// Policy without a command is not work: a table that only raises the timeout
// must leave the fast path alone.
TEST(ManifestHooks, PolicyOnlyTableIsNotActive) {
    auto m = parse_with_hooks(R"(
[hooks]
timeout_seconds = 60
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_FALSE(m->hooks.active());
    EXPECT_EQ(m->hooks.timeoutSeconds, 60);
}

// Both ends of the documented range are the range: the largest accepted value
// is asserted next to the smallest rejected one, so a change to either is a
// change to a test.
TEST(ManifestHooks, TheDocumentedTimeoutCeilingIsAccepted) {
    auto m = parse_with_hooks(R"(
[hooks]
build_start = "echo start"
timeout_seconds = 86400
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.timeoutSeconds, 86400);
}

TEST(ManifestHooks, ValueErrorsAreRejectedWithTheKeyNamed) {
    struct Case { std::string_view section; std::string_view needle; };
    for (auto const& c : {
        Case{R"([hooks]
timeout_seconds = 0)", "timeout_seconds"},
        Case{R"([hooks]
timeout_seconds = "10")", "timeout_seconds"},
        Case{R"([hooks]
build_start = "")", "build_start"},
        Case{R"([hooks]
build_finished = 7)", "build_finished"},
        Case{R"([hooks]
enabled = "yes")", "enabled"},
        Case{R"([hooks]
side_effect = 1)", "side_effect"},
        // The upper bound is documented (1–86400), so it is asserted. An
        // undocumented ceiling and no ceiling look the same from outside.
        Case{R"([hooks]
timeout_seconds = 86401)", "timeout_seconds"},
    }) {
        auto m = parse_with_hooks(c.section);
        ASSERT_FALSE(m.has_value()) << c.section;
        EXPECT_NE(m.error().message.find(c.needle), std::string::npos)
            << c.section << " -> " << m.error().message;
    }
}

// `hooks = "…"` is the shape a user reaches for when they want one command
// and no table. Saying so beats parsing nothing and running nothing.
TEST(ManifestHooks, AScalarHooksKeyIsRejected) {
    auto m = mcpp::manifest::parse_string(R"(
hooks = "echo hi"

[package]
name = "x"
version = "0.1.0"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("[hooks]"), std::string::npos)
        << m.error().message;
}

// An unknown KEY is a warning, not an error — the same split [build] uses.
// A manifest written for a later mcpp (say, a `build_cancelled` event) still
// loads on this one, while a typo is still reported.
TEST(ManifestHooks, UnknownKeyWarnsInsteadOfFailing) {
    auto m = parse_with_hooks(R"(
[hooks]
build_start = "echo start"
build_stared = "echo typo"
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    bool found = false;
    for (auto const& w : m->schemaWarnings)
        if (w.find("build_stared") != std::string::npos) found = true;
    EXPECT_TRUE(found);
    EXPECT_TRUE(m->hooks.active());
}

// ─── The table form, and the interval each event names ───────────────────

TEST(ManifestHooks, ABareStringIsSugarForATable) {
    auto m = parse_with_hooks(R"(
[hooks]
build_start = "echo start"
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.buildStart.cmd, "echo start");
    EXPECT_EQ(m->hooks.buildStart.timeoutSeconds, 0);   // 0 = inherit
    EXPECT_FALSE(m->hooks.buildStart.loop);
}

// The per-event value wins over the table's, and 0 is what makes "not given"
// expressible — without it there is no way to tell an inherited 10 from a
// declared one.
TEST(ManifestHooks, APerEventTimeoutOverridesTheTableDefault) {
    auto m = parse_with_hooks(R"(
[hooks]
timeout_seconds = 10
build_finished = { cmd = "slow-notifier", timeout_seconds = 45 }
build_start = "echo start"
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.timeout_for(m->hooks.buildFinished), 45);
    EXPECT_EQ(m->hooks.timeout_for(m->hooks.buildStart), 10);
}

TEST(ManifestHooks, DuringBuildIsReadAndMakesTheTableActive) {
    auto m = parse_with_hooks(R"(
[hooks]
during_build = { cmd = "play bgm.mp3", loop = true }
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    EXPECT_EQ(m->hooks.duringBuild.cmd, "play bgm.mp3");
    EXPECT_TRUE(m->hooks.duringBuild.loop);
    EXPECT_TRUE(m->hooks.active());
}

// ⭐ The two keys that only exist for one interval. Accepted-and-ignored is
// the failure mode this rejects: the user writes `loop` on `build_start`,
// nothing repeats, and the feature looks broken rather than misused. Each
// message names the event that does support the key.
TEST(ManifestHooks, AKeyOfferedToTheWrongIntervalIsRejected) {
    auto loopOnSelfClosing = parse_with_hooks(R"(
[hooks]
build_start = { cmd = "play bgm.mp3", loop = true }
)");
    ASSERT_FALSE(loopOnSelfClosing.has_value());
    EXPECT_NE(loopOnSelfClosing.error().message.find("during_build"),
              std::string::npos) << loopOnSelfClosing.error().message;

    auto timeoutOnSpanning = parse_with_hooks(R"(
[hooks]
during_build = { cmd = "play bgm.mp3", timeout_seconds = 30 }
)");
    ASSERT_FALSE(timeoutOnSpanning.has_value());
    EXPECT_NE(timeoutOnSpanning.error().message.find("timeout_seconds"),
              std::string::npos) << timeoutOnSpanning.error().message;
}

TEST(ManifestHooks, ATableWithoutCmdIsRejected) {
    for (std::string_view section : {
        R"([hooks]
during_build = { loop = true })",
        R"([hooks]
build_start = { cmd = "" })",
        R"([hooks]
build_start = 42)",
    }) {
        auto m = parse_with_hooks(section);
        ASSERT_FALSE(m.has_value()) << section;
        EXPECT_NE(m.error().message.find("cmd"), std::string::npos)
            << section << " -> " << m.error().message;
    }
}

TEST(ManifestHooks, AnUnknownKeyInsideAnEventTableWarns) {
    auto m = parse_with_hooks(R"(
[hooks]
during_build = { cmd = "play bgm.mp3", lopo = true }
)");
    ASSERT_TRUE(m.has_value()) << (m ? "" : m.error().format());
    bool found = false;
    for (auto const& w : m->schemaWarnings)
        if (w.find("lopo") != std::string::npos) found = true;
    EXPECT_TRUE(found);
    EXPECT_TRUE(m->hooks.active());
}

// ─── #544: array keys in the [target.<triple>] sweep; [xlings] per host ────

// The sweep skipped arrays by design (so that `runner`, an array it reads, was
// not reported as unsupported), which also let an array-valued typo pass in
// silence and left `runner` out of the "supported keys" list. Both halves of
// the issue's third ask are pinned here; TargetRunnerParsesAndDoesNotWarn
// above keeps the other direction (the real key stays unreported).
TEST(Manifest, TargetSweepReportsArrayTyposAndListsRunner) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[target.aarch64-linux-musl]
runnerX = ["qemu-aarch64-static"]
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("'runnerX'"), std::string::npos) << m->schemaWarnings[0];
    EXPECT_NE(m->schemaWarnings[0].find(
                  "Supported keys: cxx_runtime, linkage, runner, sysroot, toolchain"),
              std::string::npos) << m->schemaWarnings[0];
}

// `[xlings]` mirrors `.xlings.json`, whose values may be an object keyed by
// platform. The parser resolves the form against this host at load, so the
// assertions below are written in terms of host_platform_key() rather than a
// fixed platform: the same test file runs on all three CI hosts.
TEST(Manifest, XlingsDepsAcceptPerPlatformEntries) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings]
deps = ["xim:ninja", { linux = "qemu-user-aarch64" }, { windows = "nasm", default = "yasm" }]
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    const auto host = mcpp::manifest::host_platform_key();
    std::vector<std::string> want{"xim:ninja"};
    if (host == "linux") want.push_back("qemu-user-aarch64");
    want.push_back(host == "windows" ? "nasm" : "yasm");
    EXPECT_EQ(m->xlings.deps, want);
}

TEST(Manifest, XlingsWorkspaceAcceptsPerPlatformValues) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
gcc = { linux = "15.1.0" }
llvm = { macos = "20", default = "22" }
xmake = "3.0.7"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    const auto host = mcpp::manifest::host_platform_key();
    if (host == "linux") EXPECT_EQ(m->xlings.workspace.at("gcc"), "15.1.0");
    else                 EXPECT_EQ(m->xlings.workspace.count("gcc"), 0u);
    // `host_platform_key()` is xlings' spelling, `macosx`, since 2026.9.3.1.
    // Comparing against "macos" here made this the one assertion in the file
    // that could only fail on a macOS runner — and it did.
    EXPECT_EQ(m->xlings.workspace.at("llvm"), host == "macosx" ? "20" : "22");
    EXPECT_EQ(m->xlings.workspace.at("xmake"), "3.0.7");
}

TEST(Manifest, XlingsUnknownPlatformKeyIsAnError) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings]
deps = [{ linxu = "qemu-user-aarch64" }]
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("linxu"), std::string::npos) << m.error().message;
    EXPECT_NE(m.error().message.find("linux, macosx (or macos), windows, default"),
              std::string::npos)
        << m.error().message;
    EXPECT_NE(m.error().message.find("deps[0]"), std::string::npos) << m.error().message;
}

TEST(Manifest, XlingsWorkspaceNonStringLeafIsAnError) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
gcc = { linux = 15 }
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("[xlings.workspace] gcc"), std::string::npos)
        << m.error().message;
}

// The resolution rule itself, with the platform passed explicitly so all
// three hosts' answers are asserted on every host.
TEST(Manifest, ResolveHostValueTable) {
    using mcpp::manifest::resolve_host_value;
    auto d = mcpp::libs::toml::parse(R"(v = { linux = "a", macosx = "b", default = "c" })");
    ASSERT_TRUE(d.has_value());
    const auto& v = d->root().at("v");
    EXPECT_EQ(resolve_host_value(v, "linux").value().value(), "a");
    EXPECT_EQ(resolve_host_value(v, "macos").value().value(), "b");   // macosx alias
    EXPECT_EQ(resolve_host_value(v, "windows").value().value(), "c");
    auto e = mcpp::libs::toml::parse(R"(v = { linux = "a" })");
    ASSERT_TRUE(e.has_value());
    EXPECT_FALSE(resolve_host_value(e->root().at("v"), "windows").value().has_value());
    auto s = mcpp::libs::toml::parse(R"(v = "plain")");
    ASSERT_TRUE(s.has_value());
    EXPECT_EQ(resolve_host_value(s->root().at("v"), "windows").value().value(), "plain");
}

// ── `[xlings.workspace]` as the one table (2026-09-03) ─────────────────────
//
// The design is `.agents/docs/2026-09-03-xlings-workspace-as-the-one-table.md`.
// Each entry produces two projections — an install address and a resolution
// pin — and the assertions are on both, because a test that checked only one
// could not tell a dropped namespace from a dropped version.

TEST(Manifest, XlingsWorkspaceProducesAnAddressAndAPin) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
cmake = "3.28"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->xlings.workspace.at("cmake"), "3.28");
    ASSERT_EQ(m->xlings.deps.size(), 1u);
    EXPECT_EQ(m->xlings.deps[0], "cmake@3.28");
}

TEST(Manifest, XlingsWorkspaceNamespaceOnEitherHalfIsTheSameEntry) {
    auto onValue = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
picolibc-riscv = "xim:1.8.12"
)");
    ASSERT_TRUE(onValue.has_value()) << onValue.error().format();
    auto onKey = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
"xim:picolibc-riscv" = "1.8.12"
)");
    ASSERT_TRUE(onKey.has_value()) << onKey.error().format();
    EXPECT_EQ(onValue->xlings.deps, onKey->xlings.deps);
    EXPECT_EQ(onValue->xlings.workspace, onKey->xlings.workspace);
    EXPECT_EQ(onValue->xlings.deps.at(0), "xim:picolibc-riscv@1.8.12");
    EXPECT_EQ(onValue->xlings.workspace.at("picolibc-riscv"), "xim:1.8.12");
}

TEST(Manifest, XlingsWorkspaceDisagreeingNamespacesAreRefused) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
"xim:foo" = "other:1.0"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("xim"), std::string::npos) << m.error().message;
    EXPECT_NE(m.error().message.find("other"), std::string::npos) << m.error().message;
}

TEST(Manifest, XlingsWorkspaceNamingOnePackageTwiceIsRefused) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
foo = "1.0"
"xim:foo" = "2.0"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("twice"), std::string::npos) << m.error().message;
    EXPECT_NE(m.error().message.find("xim:foo"), std::string::npos) << m.error().message;
}

// `""` is the authored spelling for "present, version unconstrained"; it is
// what `d2mcpp/.xlings.json` already writes. Both halves are asserted: an
// address with no `@`, and no pin at all.
TEST(Manifest, XlingsWorkspaceEmptyVersionAsksOnlyForPresence) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
code = ""
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->xlings.deps.at(0), "code");
    EXPECT_TRUE(m->xlings.workspace.at("code").empty());
}

// The descriptor emitter needs every platform, and the host resolution has
// already discarded two of them — so the unresolved declaration is kept.
TEST(Manifest, XlingsWorkspaceKeepsEveryPlatformForTheEmitter) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
qemu = { linux = "9.2.4-1", windows = "9.2.4-2" }
ninja = "1.12.1"
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    const auto& byPlat = m->xlings.workspaceByPlatform;
    ASSERT_TRUE(byPlat.contains("linux"));
    ASSERT_TRUE(byPlat.contains("windows"));
    EXPECT_NE(std::ranges::find(byPlat.at("linux"), "qemu@9.2.4-1"),
              byPlat.at("linux").end());
    EXPECT_NE(std::ranges::find(byPlat.at("windows"), "qemu@9.2.4-2"),
              byPlat.at("windows").end());
    // A plain string speaks for every platform, macosx included, even though
    // `qemu` named none there.
    ASSERT_TRUE(byPlat.contains("macosx"));
    EXPECT_NE(std::ranges::find(byPlat.at("macosx"), "ninja@1.12.1"),
              byPlat.at("macosx").end());
    EXPECT_EQ(std::ranges::find(byPlat.at("macosx"), "qemu@9.2.4-1"),
              byPlat.at("macosx").end());
}

// `deps` is honoured and reported. Refusing it would reach a DEPENDENCY's
// manifest, which a consumer that pinned that package cannot edit.
TEST(Manifest, XlingsDepsIsHonouredAndReported) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings]
deps = ["xim:qemu-riscv@9.2.4-1"]
)");
    ASSERT_TRUE(m.has_value()) << m.error().format();
    EXPECT_EQ(m->xlings.deps.at(0), "xim:qemu-riscv@9.2.4-1");
    ASSERT_EQ(m->schemaWarnings.size(), 1u);
    EXPECT_NE(m->schemaWarnings[0].find("[xlings.workspace]"), std::string::npos)
        << m->schemaWarnings[0];
    // The message shows the line to write, in the RECOMMENDED spelling: the
    // namespace on the key, which is what an author writes and what every
    // official package uses.
    EXPECT_NE(m->schemaWarnings[0].find("\"xim:qemu-riscv\" = \"9.2.4-1\""),
              std::string::npos) << m->schemaWarnings[0];
}

// `envs` was materialised and read by nothing, while the documentation said it
// reached the tool environment. A key that does nothing is worse when
// something claims it does, so this is an error rather than a warning.
TEST(Manifest, XlingsEnvsIsRefused) {
    auto m = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.envs]
OPENBLAS_NUM_THREADS = "1"
)");
    ASSERT_FALSE(m.has_value());
    EXPECT_NE(m.error().message.find("[xlings.envs]"), std::string::npos)
        << m.error().message;
}

// `macos` and `macosx` are one platform under two vocabularies — mcpp's triple
// says the first, a descriptor and xlings' project file say the second. The
// rule lives in mcpp.platform.axis; this asserts the manifest reaches it,
// on every host, by resolving explicitly rather than against this one.
TEST(Manifest, XlingsWorkspaceAcceptsBothMacosSpellings) {
    auto with_macos = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
llvm = { macos = "20", default = "22" }
)");
    ASSERT_TRUE(with_macos.has_value()) << with_macos.error().format();
    auto with_macosx = mcpp::manifest::parse_string(R"(
[package]
name = "app"
version = "0.1.0"
[xlings.workspace]
llvm = { macosx = "20", default = "22" }
)");
    ASSERT_TRUE(with_macosx.has_value()) << with_macosx.error().format();
    // Same platform, so the same per-platform declaration and the same
    // host-resolved answer, whichever way it was written.
    EXPECT_EQ(with_macos->xlings.workspaceByPlatform,
              with_macosx->xlings.workspaceByPlatform);
    EXPECT_EQ(with_macos->xlings.workspace, with_macosx->xlings.workspace);
    EXPECT_NE(std::ranges::find(with_macos->xlings.workspaceByPlatform.at("macosx"),
                                "llvm@20"),
              with_macos->xlings.workspaceByPlatform.at("macosx").end());
    EXPECT_NE(std::ranges::find(with_macos->xlings.workspaceByPlatform.at("linux"),
                                "llvm@22"),
              with_macos->xlings.workspaceByPlatform.at("linux").end());
}