Add feature tools (#709) and target artifact dependencies (#711)

#709 `[features.<f>] tools = ["<bin>"]` names the package's own programs
a feature needs on the build machine. On every edge into the package,
the active features' tools are requested as if the edge had written
`tools = [...]`: built once for the host, reachable through
`mcpp::dep_bin`. A name that is not a `kind = "bin"` target of the
package is refused at load, naming the bin targets.

#711 `x = { ..., artifacts = ["<bin>"] }` asks for the dependency's
program built for the consumer's target and profile, as a link unit of
the consumer's own plan, written to `bin/` beside its programs. The
unit links the dependency's objects and those of every package it
reaches; a package reached only through artifact edges is kept out of
the consumer's images, since the edge takes the program and not the
code. A package asked for artifacts is scanned and configured here even
when all its targets are programs. `${mcpp.artifact:<package>/<target>}`
names the output in actions, `mcpp pack` stages it beside the program,
and `mcpp run` and the program-selection sites ignore it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MajuX4J8ewFeWvZJjzRJt5

Author: claude

modules/manifest/src/dep_spec.cppm

@@ -67,6 +67,15 @@ struct DependencySpec {
     // Empty by default: the cost (e.g. protobuf's libprotoc is ~157 extra TUs)
     // is paid by the consumer, so nothing is built unless someone asks.
     std::vector<std::string>    tools;
+    // mcpp#711: programs of the dependency that this consumer SHIPS -- the
+    // names of its `kind = "bin"` targets, built for the consumer's TARGET and
+    // profile as link units of the consumer's own plan, beside its programs in
+    // `bin/`. The counterpart of `tools` (built for the build machine, in a
+    // nested sub-build): a GUI that carries its updater executable wants the
+    // updater for the machine the GUI runs on. An edge that names artifacts
+    // takes the dependency's programs and not its code: nothing of the
+    // package is linked into the consumer through this edge.
+    std::vector<std::string>    artifacts;
     // #355 step 5: compile this dependency's lib-root module interface FOR THE
     // HOST and make it importable from the consumer's build.mcpp — the
     // mechanism behind reusable build rules distributed as ordinary packages

modules/manifest/src/toml.cppm

@@ -1014,6 +1014,14 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
                     if (!devExts.empty())
                         m.featureDeviceExtensions[fname] = std::move(devExts);
                 }
+                // The host tools this feature makes available (mcpp#709). Which
+                // targets exist is known only after target inference, so the
+                // names are checked in `load`, where the list is complete.
+                {
+                    std::vector<std::string> tools;
+                    read_str_array(ft, "tools", tools);
+                    if (!tools.empty()) m.featureTools[fname] = std::move(tools);
+                }
                 // The module a consumer's build program imports for this rule.
                 if (auto it = ft.find("rule_module");
                     it != ft.end() && it->second.is_string())
@@ -1101,6 +1109,8 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
                     // and `tools = [...]` made ordinary builds of rule packages
                     // routine.
                     "device_extensions", "rule_module",
+                    // mcpp#709: the host tools a feature makes available.
+                    "tools",
                 };
                 for (auto& [fkey, fignored] : fval.as_table()) {
                     (void)fignored;
@@ -1842,7 +1852,7 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             || k == "rev"    || k == "tag"     || k == "branch"
             || k == "features" || k == "default-features"
             || k == "workspace" || k == "visibility"
-            || k == "backend"  || k == "tools"
+            || k == "backend"  || k == "tools" || k == "artifacts"
             || k == "host-module" || k == "reexport"
             || k == "linkage";
     };
@@ -2018,6 +2028,12 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             for (auto& tv : it->second.as_array())
                 if (tv.is_string()) spec.tools.push_back(tv.as_string());
         }
+        // mcpp#711: `artifacts = ["updater"]` -- the dependency's programs,
+        // built for this package's target and shipped beside its own.
+        if (auto it = sub.find("artifacts"); it != sub.end() && it->second.is_array()) {
+            for (auto& av : it->second.as_array())
+                if (av.is_string()) spec.artifacts.push_back(av.as_string());
+        }
         // #355 step 5: `host-module = true` — make this dependency's lib-root
         // module importable from build.mcpp (reusable rules as packages).
         if (auto it = sub.find("host-module"); it != sub.end() && it->second.is_bool()) {
@@ -4329,6 +4345,27 @@ std::expected<Manifest, ManifestError> load(const std::filesystem::path& path,
     // M5.0: defaults + target inference (uses filesystem context relative to mcpp.toml).
     apply_defaults_and_infer(*m, path.parent_path());
 
+    // `[features].<f>.tools` names this package's own programs (mcpp#709), and
+    // an inferred target exists only after the inference above.
+    for (auto it = m->featureTools.begin(); it != m->featureTools.end(); ++it) {
+        for (auto const& name : it->second) {
+            const Target* target = nullptr;
+            for (std::size_t i = 0; i < m->targets.size(); ++i)
+                if (m->targets[i].name == name) { target = &m->targets[i]; break; }
+            if (target != nullptr && target->kind == Target::Binary) continue;
+            std::string bins;
+            for (std::size_t i = 0; i < m->targets.size(); ++i)
+                if (m->targets[i].kind == Target::Binary)
+                    bins += (bins.empty() ? "" : ", ") + m->targets[i].name;
+            return std::unexpected(ManifestError{std::format(
+                "[features.{}] tools names '{}', which is not a `kind = \"bin\"` "
+                "target of this package (its bin targets: {}). A feature makes "
+                "the package's own programs available as host tools.",
+                it->first, name, bins.empty() ? std::string("none") : bins),
+                path, 0, 0});
+        }
+    }
+
     // A `[target.<sel>.targets.<name>]` row names a target, and an undeclared
     // library target exists only after the inference above, so the name is
     // checked here rather than where the row is parsed.

modules/manifest/src/types.cppm

@@ -2070,6 +2070,14 @@ struct Manifest {
     // feature is a build rule, here is what it compiles and here is how to
     // reach it". A feature with one and not the other is refused at parse time.
     std::map<std::string, std::string> featureRuleModule;
+    // `[features].<f>.tools` -- this package's own `kind = "bin"` targets that
+    // the feature makes available as host tools (mcpp#709). A consumer on whose
+    // behalf the feature is active receives each one as if its dependency edge
+    // had written `tools = [...]`: built once for the build machine, reachable
+    // from its build program through `mcpp::dep_bin`. The key moves a request a
+    // package already knows it needs into the package, so a consumer that
+    // enables a rule does not also have to name the rule's tools.
+    std::map<std::string, std::vector<std::string>> featureTools;
     // Feature System v2 Stage 2a — dependencies activated by a feature. A dep
     // declared ONLY here is optional: pulled into the resolution worklist only
     // when its feature is active (root --features or a dep spec's features=[...]).

src/build/execute.cppm

@@ -562,6 +562,9 @@ compute_run_targets(const mcpp::build::BuildPlan& plan) {
     std::vector<std::pair<std::string, std::string>> out;
     for (auto& lu : plan.linkUnits) {
         if (lu.kind != mcpp::build::LinkUnit::Binary) continue;
+        // A dependency's program shipped with this one (mcpp#711) is not a
+        // program of this package, and `mcpp run` does not choose it.
+        if (!lu.artifactOf.empty()) continue;
         out.emplace_back(lu.targetName, lu.output.generic_string());
     }
     return out;
@@ -2219,6 +2222,7 @@ export int build_run_target(const std::optional<std::string>& targetName,
     const mcpp::build::LinkUnit* chosen = nullptr;
     for (auto& lu : ctx->plan.linkUnits) {
         if (lu.kind != mcpp::build::LinkUnit::Binary) continue;
+        if (!lu.artifactOf.empty()) continue;   // mcpp#711; see compute_run_targets
         if (targetName && lu.targetName != *targetName) continue;
         chosen = &lu;
         if (targetName) break;