feat(build): an object action's outputs reach a static library, not only a linked image

A package whose device code is its point declares `kind = "lib"`. Until this,
the actions its build program emitted were dropped — with a warning, and with
the archive coming out containing none of them:

    build.mcpp action 'cuda:wkv' has role = "object" but this build produces
    no executable, shared library or test binary to link its outputs into

Measured on llama.cpp's CUDA backend, which is 305 `.cu` files behind exactly
such a target: every action reported that line and the build succeeded, having
produced a library with no device code in it.

The archive rule already consumes `lu.objects`; a static library was simply
absent from the predicate that decides which link units an object action
attaches to. The objects an action produced belong there for the same reason a
compiled `.cpp`'s do — a target's content is what it was told to contain.

e2e 608 asserts the member list of the archive rather than the exit status: an
`ar` handed nothing still writes a well-formed archive and reports success.
This is the engine half of the multi-device design's C-6.

Author: speak-agent

src/build/prepare.cppm

@@ -9582,8 +9582,19 @@ prepare_build(bool print_fingerprint,
                 // under plain `mcpp build`, where that unit does not exist.
                 // (`[resources]` makes the opposite call on purpose: an icon
                 // belongs to what ships, not to a test runner.)
+                //
+                // ⭐⭐ A STATIC LIBRARY IS ONE OF THEM, and leaving it out was
+                // the whole of what C-6 needed. A package whose device code is
+                // its point -- ggml's CUDA backend is 305 `.cu` files behind a
+                // `kind = "lib"` target -- emitted its actions, watched every
+                // one of them be dropped with a warning, and produced an
+                // archive with no device code in it. The archive rule already
+                // consumes `lu.objects`, so the objects an action produced
+                // belong there for exactly the reason a compiled `.cpp`'s do:
+                // the target's content is what it was told to contain.
                 const bool image = lu.kind == mcpp::build::LinkUnit::Binary
                                 || lu.kind == mcpp::build::LinkUnit::SharedLibrary
+                                || lu.kind == mcpp::build::LinkUnit::StaticLibrary
                                 || lu.kind == mcpp::build::LinkUnit::TestBinary;
                 const bool wanted = a.targets.empty()
                     ? image
@@ -9602,11 +9613,12 @@ prepare_build(bool print_fingerprint,
             if (!attached && a.targets.empty()) {
                 mcpp::diag::degraded("action/no-target", std::format(
                     "build.mcpp action '{}' has role = \"object\" but this build "
-                    "produces no executable, shared library or test binary to "
-                    "link its outputs into", a.id.empty() ? "<unnamed>" : a.id),
+                    "produces no target to put its outputs into",
+                    a.id.empty() ? "<unnamed>" : a.id),
                     "the action never runs and its outputs are never produced",
-                    "add a [targets.<name>] that links, or name the targets "
-                    "explicitly with .target(\"…\")");
+                    "add a [targets.<name>] — a bin, a lib, a shared lib or a "
+                    "test all take one — or name the targets explicitly with "
+                    ".target(\"…\")");
             }
         }
         if (!unknownObjectTargets.empty()) {
@@ -9620,7 +9632,7 @@ prepare_build(bool print_fingerprint,
                 "  targets in this build: [{}]\n"
                 "  (a target gated by required_features is absent unless those "
                 "features are active; test binaries exist only under `mcpp "
-                "test`, so name none and the outputs reach every image "
+                "test`, so name none and the outputs reach every target "
                 "including them)",
                 bad, known.empty() ? std::string("none") : known));
         }

tests/e2e/608_object_actions_reach_a_static_library.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# requires: gcc
+# An `object`-role action's outputs join a STATIC LIBRARY, not only an
+# executable. That is the engine half of the multi-device design's C-6: a
+# package whose device code is its point declares `kind = "lib"`, and until
+# this the actions it emitted were dropped with a warning and the archive came
+# out with none of them in it.
+#
+# Nothing here names a device. The "device compiler" is the toolchain's own C
+# compiler and the property under test is which link units an action attaches
+# to, which is not a vendor question.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+"$MCPP" new archived > /dev/null; cd archived
+rm -f src/*.cppm src/main.cpp
+mkdir -p src
+cat > src/host.c <<'EOF2'
+extern int from_action(void);
+int host_value(void) { return from_action(); }
+EOF2
+cat > mcpp.toml <<'EOF2'
+[package]
+name = "archived"
+version = "0.1.0"
+[language]
+standard = "c++23"
+[build]
+sources = ["src/*.c"]
+[targets.archived]
+kind = "lib"
+EOF2
+cat > build.mcpp <<'EOF2'
+import std;
+import mcpp;
+int main() {
+    const std::string out  = std::string(mcpp::out_dir());
+    const std::string src  = out + "/piece.c";
+    { std::ofstream f(src, std::ios::trunc);
+      f << "int from_action(void) { return 7; }\n"; }
+    const std::string obj = out + "/piece.o";
+    mcpp::action a;
+    a.id = "piece"; a.role = "object"; a.description = "compile the piece";
+    a.arg((std::string(mcpp::toolchain_dir()) + "/bin/gcc").c_str());
+    a.arg("-c"); a.arg(src.c_str()); a.arg("-o"); a.arg(obj.c_str());
+    a.input(src.c_str());
+    a.output(obj.c_str());
+    a.submit();
+    return 0;
+}
+EOF2
+
+# ── One: the action runs and its object is IN the archive ────────────────
+"$MCPP" build > build.log 2>&1 || { cat build.log; echo "FAIL: the build failed"; exit 1; }
+
+grep -q "produces no target" build.log && {
+    cat build.log
+    echo "FAIL: the action was dropped for want of a linked image"
+    exit 1
+}
+
+lib=$(find target -name 'libarchived.a' | head -1)
+[ -n "$lib" ] || { echo "FAIL: no static library was produced"; exit 1; }
+
+# ⭐ THE MEMBER LIST IS THE ASSERTION, not the exit status: an `ar` that was
+# handed nothing still writes a well-formed archive and reports success.
+members=$(ar t "$lib" 2>/dev/null | tr '\n' ' ')
+case "$members" in
+    *piece.o*) ;;
+    *) echo "FAIL: piece.o is not a member of the archive (members: $members)"; exit 1 ;;
+esac
+echo "PASS: an object action's output is archived into a static library"
+
+# ── Two: the symbol is really there ─────────────────────────────────────
+if command -v nm > /dev/null 2>&1; then
+    nm "$lib" 2>/dev/null | grep -q "from_action" || {
+        echo "FAIL: the archive has the member but not its symbol"; exit 1; }
+    echo "PASS: the archived member carries its symbol"
+fi
+
+echo "PASS: object actions reach a static library"