feat: carry the accelerator dimension from descriptor to refusal

The comparison added earlier had no reader: nothing populated the field, so it
was empty everywhere and accepted everything. This connects both ends.

An artifact declares what device code it carries in a separate descriptor
field, in one wire form that is also the diagnostic form, so what a publisher
writes is what a refusal prints back. A build declares what it targets through
[build] accel, overridden for one build by --accel, which is the relationship
--target already has with [toolchain]. --no-accel is not the absence of
--accel: it is an explicit request for none, which is what a user needs in
order to take the CPU-only variant of a package that also publishes device
builds.

A build that asks for no accelerator is satisfied by every artifact
vacuously. That is correct rather than permissive, and it is why a descriptor
lists its CPU-only variant first: the first accepted artifact wins, so an older
mcpp that does not know this field at all still selects the variant that runs
anywhere.

Author: speak-agent

modules/manifest/src/toml.cppm

@@ -1524,6 +1524,10 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             return std::unexpected(error(origin, *err));
         m.buildConfig.moduleExtensions = *v;
     }
+    // [build] accel — the accelerator backends and device architectures this
+    // build targets. One spelling with the descriptor field and the diagnostic,
+    // so what a user writes is what a refusal prints back at them.
+    if (auto v = doc->get_string("build.accel")) m.buildConfig.accel = *v;
     // [build] build_program_timeout — seconds a build.mcpp may run; 0 = no
     // limit. `optional` is load-bearing: with a plain int, "absent" and
     // "explicitly 0" would be the same value, and every project that never

modules/manifest/src/types.cppm

@@ -570,6 +570,11 @@ struct BuildConfig : BuildInputs {
     // Scoped to the declaring package — a dependency is classified by its own
     // manifest, never by its consumer's.
     std::vector<std::string>            moduleExtensions;
+    // [build] accel — which accelerator backends and device architectures this
+    // build targets, in the wire form mcpp.pack.abi_tag reads. Empty means the
+    // build asks for none, and then every prebuilt artifact satisfies it
+    // vacuously; ordering in the descriptor is what makes the CPU variant win.
+    std::string                         accel;
     // [build] build_program_timeout — seconds this package's build.mcpp may
     // run before mcpp kills it. 0 = no limit; nullopt = use the built-in 600.
     //
@@ -752,6 +757,14 @@ struct RuntimeArtifact {
     std::filesystem::path path;
     std::string           provenance;
     std::string           abi;
+    // What device code this artifact carries, in the wire form
+    // mcpp.pack.abi_tag reads: `cuda12.8+{sm_80,sm_90f} ptx>=90`.
+    //
+    // A separate field rather than a segment of `abi`, because an architecture
+    // list is a set and the tag is a dash-joined string whose triple already
+    // carries a variable number of dashes. Empty means the artifact carries no
+    // device code, which constrains nothing.
+    std::string           accel;
     std::string           digest;
     std::string           hostFingerprint;
 };

modules/manifest/src/xpkg.cppm

@@ -1941,6 +1941,7 @@ synthesize_from_xpkg_lua(std::string_view luaContent,
                             else if (field == "path") path = std::move(value);
                             else if (field == "provenance") artifact.provenance = std::move(value);
                             else if (field == "abi") artifact.abi = std::move(value);
+                            else if (field == "accel") artifact.accel = std::move(value);
                             else if (field == "digest") artifact.digest = std::move(value);
                             else if (field == "host_fingerprint")
                                 artifact.hostFingerprint = std::move(value);

src/build/prepare.cppm

@@ -839,6 +839,10 @@ export struct BuildOverrides {
     std::shared_ptr<const mcpp::platform::runtime::RuntimeBinding>
         inherited_runtime_binding;
     std::string target_triple;       // empty = host triple, fall through to [toolchain]
+    // --accel: the device backends and architectures this build targets, in
+    // the wire form mcpp.pack.abi_tag reads. Overrides `[build] accel`, the
+    // same relationship --target has with [toolchain].
+    std::string accel;
     bool        force_static = false; // --static (or implied by musl target)
     std::string package_filter;      // -p <name>: only build this workspace member
     // --profile <name>. Empty = fall through to `[build] default-profile`, then
@@ -8994,8 +8998,14 @@ prepare_build(bool print_fingerprint,
                   auto t = mcpp::toolchain::triple::parse(tc->targetTriple);
                   return t ? t->str() : tc->targetTriple;
               }();
-        const auto currentTag = mcpp::pack::cxx_surface_tag(
+        auto currentTag = mcpp::pack::cxx_surface_tag(
             *tc, canonicalTriple, m->cppStandard.level);
+        // What THIS build targets on the device axis. Absent means it asks for
+        // no accelerator, and every artifact then satisfies it vacuously —
+        // which is correct, and is why a descriptor lists its CPU-only variant
+        // first: the first accepted artifact wins.
+        currentTag.accel = mcpp::pack::parse_accel(
+            overrides.accel.empty() ? m->buildConfig.accel : overrides.accel);
         for (std::size_t i = 1; i < packages.size(); ++i) {
             auto const& pkg = packages[i];
             if (!mcpp::pack::is_distribution_package(pkg.manifest)) continue;

src/cli.cppm

@@ -367,6 +367,10 @@ int run(int argc, char** argv) {
                 .help("Deprecated alias for --cache=off (also clears the build dir)"))
             .option(cl::Option("target").takes_value().help(
                 "Build for <triple> (e.g. x86_64-linux-musl); looks up [target.<triple>] in mcpp.toml"))
+            .option(cl::Option("accel").takes_value().value_name("SPEC")
+                .help("Device backends and architectures, e.g. 'cuda12.8+{sm_89}'; overrides [build] accel"))
+            .option(cl::Option("no-accel")
+                .help("Target no accelerator, ignoring [build] accel"))
             .option(cl::Option("static").help(
                 "Force static linking (-static). On Linux, prefer pairing with --target <arch>-linux-musl"))
             .option(cl::Option("package").short_name('p').takes_value().value_name("NAME")

src/cli/cmd_build.cppm

@@ -90,6 +90,13 @@ export int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
 
     mcpp::build::BuildOverrides ov;
     if (auto t = parsed.value("target")) ov.target_triple = *t;
+    // --accel / --no-accel stand to `[build] accel` exactly as --target stands
+    // to [toolchain]: the manifest declares, the command line overrides for one
+    // build. --no-accel is not the absence of --accel; it is an explicit
+    // request for none, which is what a user needs in order to take a CPU-only
+    // variant of a package that also publishes device builds.
+    if (parsed.is_flag_set("no-accel"))       ov.accel = "(none)";
+    else if (auto a = parsed.value("accel"))  ov.accel = *a;
     if (auto p = parsed.value("package")) ov.package_filter = *p;
     // --cache global|local|off. --no-cache is the deprecated alias for off; the
     // old flag only ever cleared target/, which says nothing about a cache, so

src/pack/abi_tag.cppm

@@ -143,9 +143,22 @@ struct TagMismatch {
 // is compared as a floor, not for equality.
 std::vector<TagMismatch> tag_check(const AbiTag& published, const AbiTag& current);
 
-// One backend rendered for a diagnostic: `cuda12.8+{sm_80,sm_90} ptx>=80`.
+// The wire and diagnostic form of the device dimension:
+//
+//     cuda12.8+{sm_80,sm_90f} ptx>=90, rocm6.4+{gfx942}
+//
+// ONE form for both, so what a descriptor stores is what a refusal prints and
+// a reader never has to hold two spellings of the same fact in their head.
+// The backend is the leading run of letters and the version is what follows,
+// which parses because every backend name is alphabetic and every version
+// starts with a digit.
 std::string accel_str(std::span<const AccelSet> sets);
 
+// The inverse. Unparseable input yields an empty vector, which the comparison
+// reads as "carries no device code" — the same answer as a descriptor that
+// never mentioned the dimension, and the safe one.
+std::vector<AccelSet> parse_accel(std::string_view s);
+
 // The `c++NN` segment as its numeric level, or 0 when unparseable.
 int standard_level(std::string_view standardSegment);
 
@@ -224,6 +237,64 @@ std::string accel_str(std::span<const AccelSet> sets) {
     return out;
 }
 
+namespace {
+
+std::string_view trim_sv(std::string_view s) {
+    while (!s.empty() && (s.front() == ' ' || s.front() == '\t')) s.remove_prefix(1);
+    while (!s.empty() && (s.back()  == ' ' || s.back()  == '\t')) s.remove_suffix(1);
+    return s;
+}
+
+} // namespace
+
+std::vector<AccelSet> parse_accel(std::string_view s) {
+    std::vector<AccelSet> out;
+    for (std::size_t i = 0; i <= s.size(); ) {
+        auto comma = s.find(',', i);
+        // A comma inside `{...}` separates architectures, not backends.
+        auto open  = s.find('{', i);
+        auto close = s.find('}', i);
+        if (open != std::string_view::npos && close != std::string_view::npos
+            && comma != std::string_view::npos && comma > open && comma < close)
+            comma = s.find(',', close);
+        auto chunk = trim_sv(comma == std::string_view::npos
+                                 ? s.substr(i)
+                                 : s.substr(i, comma - i));
+        i = comma == std::string_view::npos ? s.size() + 1 : comma + 1;
+        if (chunk.empty() || chunk == "(none)") continue;
+
+        AccelSet a;
+        auto plus = chunk.find('+');
+        auto head = trim_sv(plus == std::string_view::npos ? chunk : chunk.substr(0, plus));
+        std::size_t n = 0;
+        while (n < head.size() && std::isalpha(static_cast<unsigned char>(head[n]))) ++n;
+        if (n == 0) continue;                        // no backend: not our form
+        a.backend = std::string(head.substr(0, n));
+        a.version = std::string(head.substr(n));
+
+        if (plus != std::string_view::npos) {
+            auto tail = chunk.substr(plus + 1);
+            if (auto o = tail.find('{'); o != std::string_view::npos) {
+                auto c = tail.find('}', o);
+                auto archs = tail.substr(o + 1,
+                    c == std::string_view::npos ? std::string_view::npos : c - o - 1);
+                for (std::size_t j = 0; j <= archs.size(); ) {
+                    auto k = archs.find(',', j);
+                    auto one = trim_sv(k == std::string_view::npos
+                                           ? archs.substr(j) : archs.substr(j, k - j));
+                    if (!one.empty()) a.archs.emplace_back(one);
+                    if (k == std::string_view::npos) break;
+                    j = k + 1;
+                }
+            }
+            if (auto pf = tail.find("ptx>="); pf != std::string_view::npos)
+                a.ptxFloor = std::string(trim_sv(tail.substr(pf + 5)));
+        }
+        out.push_back(std::move(a));
+    }
+    return out;
+}
+
 int accel_arch_level(std::string_view arch) {
     auto digits = arch;
     if      (digits.starts_with("sm_"))      digits.remove_prefix(3);

src/pack/prebuilt.cppm

@@ -107,6 +107,8 @@ check_prebuilt(const mcpp::manifest::Manifest& m, const PrebuiltCheck& in)
         publishedTags.push_back(a.abi);
         auto published = parse_abi_tag(a.abi);
         if (!published) { accepted = true; continue; }   // unreadable → lenient
+        // The device dimension travels beside the tag rather than inside it.
+        published->accel = parse_accel(a.accel);
         auto bad = tag_check(*published, in.current);
         if (bad.empty()) { accepted = true; break; }
         // Keep the CLOSEST refusal to show: the one that disagrees least is

tests/unit/test_abi_tag_accel.cpp

@@ -130,3 +130,32 @@ TEST(AbiTagAccel, AccelDoesNotMaskTheCxxDimensions) {
     ASSERT_EQ(bad.size(), 1u);
     EXPECT_EQ(bad[0].dimension, "compiler");
 }
+
+// ─── The wire form round-trips ─────────────────────────────────────────────
+
+TEST(AbiTagAccel, TheWireFormRoundTrips) {
+    std::vector<mcpp::pack::AccelSet> sets{
+        cuda({"sm_80", "sm_90f"}, "90"),
+        mcpp::pack::AccelSet{ .backend = "rocm", .version = "6.4",
+                              .archs = {"gfx942", "gfx10-3-generic"} },
+    };
+    auto text = mcpp::pack::accel_str(sets);
+    auto back = mcpp::pack::parse_accel(text);
+    ASSERT_EQ(back.size(), 2u);
+    EXPECT_EQ(back[0].backend,  "cuda");
+    EXPECT_EQ(back[0].version,  "12.8");
+    EXPECT_EQ(back[0].archs,    (std::vector<std::string>{"sm_80", "sm_90f"}));
+    EXPECT_EQ(back[0].ptxFloor, "90");
+    EXPECT_EQ(back[1].backend,  "rocm");
+    EXPECT_EQ(back[1].archs,    (std::vector<std::string>{"gfx942", "gfx10-3-generic"}));
+    EXPECT_TRUE(back[1].ptxFloor.empty());
+    EXPECT_EQ(mcpp::pack::accel_str(back), text);
+}
+
+TEST(AbiTagAccel, UnparseableTextMeansNoDeviceCode) {
+    // The safe answer, and the same one a descriptor that never mentioned the
+    // dimension gives: an artifact that states nothing constrains nothing.
+    EXPECT_TRUE(mcpp::pack::parse_accel("").empty());
+    EXPECT_TRUE(mcpp::pack::parse_accel("(none)").empty());
+    EXPECT_TRUE(mcpp::pack::parse_accel("12.8+{sm_90}").empty());  // no backend
+}