fix(pack): one Error per module, and route the named target both ways

Two problems the first push found, one from CI and one from running the
previous release side by side.

`mcpp.pack.library` exported a `mcpp::pack::Error` and `mcpp.pack` already
had one. A name attaches to exactly one module, and mcpp.pack.library_pipeline
imports both — clang refuses outright ("cannot be attached to other modules"),
GCC accepted it. Every Windows and macOS job failed on it while the Linux ones
were green, which is the whole argument for the three-platform matrix.

`mcpp pack` in a workspace root stopped working. Routing on
`[targets.<n>].kind` means something reads the manifest before the build does,
and a workspace root has no targets of its own — a virtual one has no
`[package]` either — so the new router read an empty list and concluded there
was nothing to pack. Found by running the previous release against
examples/04-workspace and comparing; e2e 249 is that comparison made permanent.

And the positional was accepted but never reached the application pipeline, so
a project with two `bin` targets would take `mcpp pack app2` and bundle app1 —
succeeding with the wrong answer. e2e 250 pins both directions plus the
refusal for an unknown name.

Author: speak-agent

src/cli/cmd_publish.cppm

@@ -88,7 +88,7 @@ export int cmd_pack(const mcpplibs::cmdline::ParsedArgs& parsed) {
             "bundle wraps one executable, and one executable has one target.");
         return 2;
     }
-    return mcpp::pack::build_and_pack(std::move(opts), modeFromUser);
+    return mcpp::pack::build_and_pack(std::move(opts), modeFromUser, route->targetName);
 }
 
 } // namespace mcpp::cli

src/pack/library.cppm

@@ -79,28 +79,33 @@ struct LibraryPackPlan {
     std::vector<LibraryLeg> legs;
 };
 
-struct Error { std::string message; };
+// NOT `Error`. `mcpp.pack` already exports a `mcpp::pack::Error`, and a name
+// can only be attached to one module — clang rejects the second outright
+// ("cannot be attached to other modules"), and mcpp.pack.library_pipeline
+// imports both. GCC accepted it, which is exactly why the Windows leg of CI
+// is the one that found this.
+struct LibraryPackError { std::string message; };
 
 // Stage, drop, describe, archive. Returns the path a caller should report.
 //
 // The digests it records come from mcpp.pack.digest, which the CONSUMER also
 // uses — one derivation, verified from both ends.
-std::expected<std::filesystem::path, Error> run_library_pack(const LibraryPackPlan& plan);
+std::expected<std::filesystem::path, LibraryPackError> run_library_pack(const LibraryPackPlan& plan);
 
 } // namespace mcpp::pack
 
 namespace mcpp::pack {
 
 namespace {
 
-std::expected<void, Error> copy_into(const std::filesystem::path& src,
+std::expected<void, LibraryPackError> copy_into(const std::filesystem::path& src,
                                      const std::filesystem::path& dst)
 {
     std::error_code ec;
     std::filesystem::create_directories(dst.parent_path(), ec);
     std::filesystem::copy_file(src, dst,
         std::filesystem::copy_options::overwrite_existing, ec);
-    if (ec) return std::unexpected(Error{ std::format(
+    if (ec) return std::unexpected(LibraryPackError{ std::format(
         "cannot copy '{}' -> '{}': {}", src.string(), dst.string(), ec.message()) });
     return {};
 }
@@ -119,13 +124,13 @@ std::vector<std::filesystem::path> walk(const std::filesystem::path& root) {
 
 } // namespace
 
-std::expected<std::filesystem::path, Error>
+std::expected<std::filesystem::path, LibraryPackError>
 run_library_pack(const LibraryPackPlan& plan)
 {
     std::error_code ec;
     std::filesystem::remove_all(plan.stagingRoot, ec);
     std::filesystem::create_directories(plan.stagingRoot, ec);
-    if (ec) return std::unexpected(Error{ std::format(
+    if (ec) return std::unexpected(LibraryPackError{ std::format(
         "cannot create staging dir '{}': {}", plan.stagingRoot.string(), ec.message()) });
 
     // ── interface/ ────────────────────────────────────────────────────
@@ -141,7 +146,7 @@ run_library_pack(const LibraryPackPlan& plan)
         for (auto const& src : plan.interfaceSources) {
             auto name = src.filename().string();
             if (auto it = seen.find(name); it != seen.end()) {
-                return std::unexpected(Error{ std::format(
+                return std::unexpected(LibraryPackError{ std::format(
                     "two interface units are both called '{}':\n"
                     "  {}\n  {}\n"
                     "A package's interface is published flat, so their names must differ.",
@@ -171,7 +176,7 @@ run_library_pack(const LibraryPackPlan& plan)
     std::vector<PackageLeg> docLegs;
     for (auto const& leg : plan.legs) {
         if (!std::filesystem::exists(leg.artifact, ec)) {
-            return std::unexpected(Error{ std::format(
+            return std::unexpected(LibraryPackError{ std::format(
                 "the build for '{}' produced no artifact at '{}'",
                 leg.triple, leg.artifact.string()) });
         }
@@ -189,7 +194,7 @@ run_library_pack(const LibraryPackPlan& plan)
                 cmd += " " + mcpp::platform::shell::quote(m);
             auto r = mcpp::platform::process::capture(cmd + " 2>&1");
             if (r.exit_code != 0) {
-                return std::unexpected(Error{ std::format(
+                return std::unexpected(LibraryPackError{ std::format(
                     "cannot drop published interface objects from '{}' (rc={}): {}",
                     dst.string(), r.exit_code, r.output) });
             }
@@ -240,7 +245,7 @@ run_library_pack(const LibraryPackPlan& plan)
         doc.dependencies    = plan.dependencies;
 
         std::ofstream os(plan.stagingRoot / "mcpp.toml", std::ios::binary);
-        if (!os) return std::unexpected(Error{ std::format(
+        if (!os) return std::unexpected(LibraryPackError{ std::format(
             "cannot write '{}'", (plan.stagingRoot / "mcpp.toml").string()) });
         os << emit_package_manifest(doc);
     }
@@ -259,15 +264,15 @@ run_library_pack(const LibraryPackPlan& plan)
             });
         }
         if (auto r = zip::write(plan.archivePath, entries); !r)
-            return std::unexpected(Error{ r.error() });
+            return std::unexpected(LibraryPackError{ r.error() });
     } else {
         auto cmd = std::format("tar -czf {} -C {} {}",
             mcpp::platform::shell::quote(plan.archivePath.string()),
             mcpp::platform::shell::quote(plan.stagingRoot.parent_path().string()),
             mcpp::platform::shell::quote(plan.stagingRoot.filename().string()));
         auto r = mcpp::platform::process::capture(cmd + " 2>&1");
         if (r.exit_code != 0)
-            return std::unexpected(Error{ std::format(
+            return std::unexpected(LibraryPackError{ std::format(
                 "tar failed (rc={}): {}", r.exit_code, r.output) });
     }
     return plan.archivePath;

src/pack/pipeline.cppm

@@ -23,7 +23,15 @@ import mcpp.ui;
 namespace mcpp::pack {
 
 // Everything after CLI option parsing for `mcpp pack`.
-export int build_and_pack(Options opts, bool modeFromUser) {
+//
+// `wantTarget` is the target NAME the user asked for, empty when they did not.
+// It exists because `mcpp pack <name>` now routes on `[targets.<name>].kind`:
+// a name that resolves to a program has to reach the binary selection below,
+// or a project with two `bin` targets would accept `mcpp pack app2` and
+// silently bundle app1 — the shape where the command succeeds and the answer
+// is wrong.
+export int build_and_pack(Options opts, bool modeFromUser,
+                          const std::string& wantTarget = {}) {
     // `--target *-linux-musl` without an explicit `--mode` implies
     // `--mode static` — packaging a musl-static ELF as bundle-project
     // would feed patchelf a static binary and crash. The docs treat
@@ -83,8 +91,26 @@ export int build_and_pack(Options opts, bool modeFromUser) {
     }
 
     // ─── Pick the main binary target ─────────────────────────────────
+    //
+    // An explicitly named target wins over the package-name convention: the
+    // user said which one, and guessing past that is how `mcpp pack app2`
+    // would produce app1's bundle under app2's name.
     std::filesystem::path mainBinary;
+    if (!wantTarget.empty()) {
+        for (auto& lu : ctx->plan.linkUnits) {
+            if (lu.kind == mcpp::build::LinkUnit::Binary && lu.targetName == wantTarget) {
+                mainBinary = ctx->outputDir / lu.output;
+                break;
+            }
+        }
+        if (mainBinary.empty()) {
+            mcpp::ui::error(std::format(
+                "target '{}' is not a program in this build", wantTarget));
+            return 2;
+        }
+    }
     for (auto& lu : ctx->plan.linkUnits) {
+        if (!mainBinary.empty()) break;
         if (lu.kind == mcpp::build::LinkUnit::Binary
             && lu.targetName == ctx->manifest.package.name)
         {

src/pack/route.cppm

@@ -78,6 +78,17 @@ std::expected<PackRoute, std::string> route_pack_target(std::string_view request
             list.empty() ? "" : "; this package declares: ", list));
     }
 
+    // A WORKSPACE ROOT has no targets of its own — a virtual one has no
+    // `[package]` at all. `mcpp pack` there has always meant "pack the member",
+    // and the application pipeline is what resolves which member that is. So
+    // hand it straight through rather than reading the root's (empty) target
+    // list and concluding there is nothing to pack.
+    //
+    // Found by running the old binary and the new one against
+    // examples/04-workspace: the routing added here turned a working command
+    // into "this package declares no program and no library to pack".
+    if (m->targets.empty() && m->workspace.present) return PackRoute{ {}, false };
+
     // Nothing requested. A program is still the default — `mcpp pack` has
     // always meant "bundle this application" and a project that has one is
     // asking for that.

tests/e2e/249_pack_workspace_root_unchanged.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# requires: gcc
+# 249_pack_workspace_root_unchanged.sh — `mcpp pack` in a workspace root still
+# packs the member's program.
+#
+# Routing `mcpp pack` through `[targets.<n>].kind` means something has to read
+# the manifest before the build does. A workspace root has no targets of its
+# own — a virtual one has no `[package]` either — so the first version of that
+# routing read the root's empty target list and concluded there was nothing to
+# pack, turning a working command into an error.
+#
+# Caught by running the previous release against examples/04-workspace and
+# comparing. This test is that comparison, made permanent.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+mkdir -p ws/apps/hello/src ws/libs/mathcore/src
+
+cat > ws/mcpp.toml <<'EOF'
+[workspace]
+members = ["libs/mathcore", "apps/hello"]
+EOF
+
+cat > ws/libs/mathcore/mcpp.toml <<'EOF'
+[package]
+name    = "mathcore"
+version = "0.1.0"
+EOF
+cat > ws/libs/mathcore/src/mathcore.cppm <<'EOF'
+export module mathcore;
+export int core_answer() { return 42; }
+EOF
+
+cat > ws/apps/hello/mcpp.toml <<'EOF'
+[package]
+name    = "hello"
+version = "0.1.0"
+[dependencies]
+mathcore = { path = "../../libs/mathcore" }
+EOF
+cat > ws/apps/hello/src/main.cpp <<'EOF'
+#include <cstdio>
+import mathcore;
+int main() { std::printf("ok=%d\n", core_answer()); return 0; }
+EOF
+
+cd ws
+"$MCPP" pack --mode system > pack.log 2>&1 || {
+    cat pack.log
+    echo "FAIL: packing from a virtual workspace root stopped working"
+    exit 1
+}
+grep -q 'Packed' pack.log || { cat pack.log; echo "no archive reported"; exit 1; }
+[[ -n "$(find . -name 'hello-0.1.0-*.tar.gz' | head -1)" ]] || {
+    cat pack.log; echo "the member's archive was not produced"; find . -name '*.tar.gz'; exit 1; }
+
+echo "PASS: a workspace root still packs its member's program"

tests/e2e/250_pack_names_the_target.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# requires: gcc
+# 250_pack_names_the_target.sh — `mcpp pack <name>` packs the target it was
+# given, and refuses a name it cannot pack.
+#
+# The positional is what decides application-bundle vs library-package, so it
+# has to reach BOTH pipelines. It did not reach the application one at first:
+# a project with two `bin` targets accepted `mcpp pack app2` and bundled app1,
+# which is the shape where the command succeeds and the answer is wrong.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+mkdir -p two/src
+cat > two/src/alpha.cpp <<'EOF'
+#include <cstdio>
+int main() { std::printf("alpha\n"); return 0; }
+EOF
+cat > two/src/beta.cpp <<'EOF'
+#include <cstdio>
+int main() { std::printf("beta\n"); return 0; }
+EOF
+cat > two/mcpp.toml <<'EOF'
+[package]
+name    = "two"
+version = "0.1.0"
+
+[targets.alpha]
+kind = "bin"
+main = "src/alpha.cpp"
+
+[targets.beta]
+kind = "bin"
+main = "src/beta.cpp"
+EOF
+
+cd two
+
+# ── the named program is the one that gets bundled ─────────────────────
+"$MCPP" pack beta --mode system > beta.log 2>&1 || { cat beta.log; echo "pack beta failed"; exit 1; }
+staged="$(find target/dist -maxdepth 1 -type d -name 'two-0.1.0*' | head -1)"
+[[ -n "$staged" ]] || { cat beta.log; echo "no staging dir"; exit 1; }
+find "$staged" -type f -name 'beta*' | grep -q . || {
+    echo "FAIL: 'mcpp pack beta' did not bundle beta"; find "$staged" -type f; exit 1; }
+find "$staged" -type f -name 'alpha*' | grep -q . && {
+    echo "FAIL: 'mcpp pack beta' bundled alpha instead"; find "$staged" -type f; exit 1; }
+
+# ── and the other one, to prove the first result was not the default ───
+rm -rf target/dist
+"$MCPP" pack alpha --mode system > alpha.log 2>&1 || { cat alpha.log; echo "pack alpha failed"; exit 1; }
+staged="$(find target/dist -maxdepth 1 -type d -name 'two-0.1.0*' | head -1)"
+find "$staged" -type f -name 'alpha*' | grep -q . || {
+    echo "FAIL: 'mcpp pack alpha' did not bundle alpha"; find "$staged" -type f; exit 1; }
+
+# ── an unknown name is refused, and says what there is ─────────────────
+if "$MCPP" pack nosuch --mode system > bad.log 2>&1; then
+    cat bad.log; echo "FAIL: an unknown target name was accepted"; exit 1
+fi
+grep -q "no target named 'nosuch'" bad.log || { cat bad.log; echo "wrong refusal"; exit 1; }
+grep -q 'alpha' bad.log && grep -q 'beta' bad.log || {
+    cat bad.log; echo "the refusal did not list the available targets"; exit 1; }
+
+echo "PASS: mcpp pack packs the target it is given"