fix: a pack of several members resolves a target name for the member an action is for, fails a member alone in the distribution step, and reports the members in [workspace] members order

- ${mcpp.target_file:<name>} is resolved by mcpp::build::resolve_target_file:
  the unit of the member the referring package acts for, and a refusal when
  several members define the name and the package acts for none of them.
- With several members the distribution drive keeps going; each member's
  declared products are removed before it, so a file present after it is this
  pack's; a member without a staged tree whose provider reads it fails alone.
- The members are reported, and the exit status chosen, in [workspace]
  members order across configurations.
- e2e 870.

Author: speak-agent

.agents/docs/2026-09-30-member-selection-and-build-program-cost-plan.md

@@ -906,6 +906,23 @@ reuse of a stale compile. It found, and the integration corrected:
 - the announcement of a multi-member test plan, which named the virtual root;
 - comments and documentation that no longer described the code.
 
+A second review, of the pack change alone, found no change to the pack of one
+member, and three defects in the pack of several, which are corrected (e2e 870):
+
+- `${mcpp.target_file:<name>}` resolved to the last link unit of that name in
+  the plan, so a member's distributable could be built from another member's
+  program of the same target name. The name is now resolved for the member the
+  action's package acts for, and refused when that is none of the members that
+  define it.
+- One member's failing distribution step, or a member without a staged tree
+  whose provider reads it, failed every member of its configuration. The drive
+  keeps going when several members are packed, each member's declared products
+  are removed before it, so that a file present after it is this pack's, and a
+  member without a tree is failed alone and the pass prepared again for the
+  others.
+- The members were reported in the order of their configurations. They are
+  reported in `[workspace] members` order.
+
 ### 15.4 Verification before the pull request
 
 - Unit tests: 142 passed.

CHANGELOG.md

@@ -75,9 +75,12 @@ exits 101 (both under **Changed**).
   configuration. A positional target, several `--target` values, an `--output`
   that is a file, a member no provider of the requested format acts for, and
   two members that would write one destination are refused before anything is
-  compiled. `mcpp pack -p <member>` keeps its meaning. The JSON envelope adds
+  compiled. A member whose distribution step fails is reported by name and the
+  others are packed; the members are reported in `[workspace] members` order,
+  and `${mcpp.target_file:<name>}` names the target of the member an action is
+  for. `mcpp pack -p <member>` keeps its meaning. The JSON envelope adds
   `data.stages` and a `member` field per artifact when several members are
-  packed (e2e 867 to 869).
+  packed (e2e 867 to 870).
 
 ### Fixed
 

docs/10-pack-and-release.md

@@ -210,8 +210,9 @@ What each member receives is what `mcpp pack -p <member>` gives it:
   outputs are verified to exist and are reported as `Packed` for that member.
 
 `--workspace` packs a member only if it has a program target, and says which it
-skipped. A member named with `-p` that has none is refused. Members are packed in
-`[workspace] members` order, whatever order `-p` names them in. A member that
+skipped. A member named with `-p` that has none is refused. Members are packed
+one configuration at a time and reported in `[workspace] members` order, whatever
+order `-p` names them in. A member that
 fails, for instance one whose provider submitted nothing for the requested
 format, is reported by name and the others are packed; the exit status is
 non-zero if any member failed. One member, whether named with one `-p` or by the

docs/zh/10-pack-and-release.md

@@ -186,7 +186,7 @@ mcpp pack -p cli -p gui --format release
   所代表的成员。每个成员的输出都会核实存在，并以该成员的 `Packed` 报告。
 
 `--workspace` 只打包有程序 target 的成员，并说明跳过了哪些；用 `-p` 点名的成员若没有
-程序 target 则被拒绝。成员按 `[workspace] members` 的顺序打包，与 `-p` 的书写顺序无关。
+程序 target 则被拒绝。成员按配置逐组打包，按 `[workspace] members` 的顺序报告，与 `-p` 的书写顺序无关。
 某个成员失败（例如它的提供者对所请求的格式什么也没有提交）时，按名字报告，其余成员
 照常打包；只要有一个成员失败，退出状态就非零。一个成员 —— 无论是用一个 `-p` 点名，还是
 由命令所在的目录决定 —— 与以前完全一样地打包：`mcpp pack -p X` 只规划 X 的闭包。在虚拟

src/build/plan.cppm

@@ -686,6 +686,19 @@ expand_manifest_include_entry(const std::filesystem::path& root,
 // ends up spelled two ways.
 std::string qualified_package_name(const mcpp::manifest::Manifest& manifest);
 
+// What `${mcpp.target_file:<name>}` names in `plan`: the build-dir-relative
+// output of the link unit of that target name. A plan of several members may
+// hold a target of one name in each of them; the name then means the unit of
+// `actingMember`, the member the referring package acts for. `output` is empty
+// when no unit has the name. `members` is non-empty when the name is ambiguous:
+// several members define it and none of them is `actingMember`.
+struct TargetFileAnswer {
+    std::string              output;
+    std::vector<std::string> members;
+};
+TargetFileAnswer resolve_target_file(const BuildPlan& plan, std::string_view name,
+                                     std::string_view actingMember);
+
 // The objects a package contributes to an image that links it whole: its
 // module units, which link unconditionally, then its implementation units, in
 // plan order. A shared library that carries a private copy of a graph C++
@@ -3289,6 +3302,22 @@ make_plan(const mcpp::manifest::Manifest&         manifest,
     return plan;
 }
 
+TargetFileAnswer resolve_target_file(const BuildPlan& plan, std::string_view name,
+                                     std::string_view actingMember) {
+    TargetFileAnswer answer;
+    std::set<std::string> members;
+    for (auto const& lu : plan.linkUnits) {
+        if (lu.targetName != name) continue;
+        answer.output = lu.output.generic_string();
+        if (!actingMember.empty() && lu.memberOf == actingMember) return {answer.output, {}};
+        if (!lu.memberOf.empty()) members.insert(lu.memberOf);
+    }
+    // One member's plan, and a name one member defines, resolve as they always
+    // have: to the one unit, or to the last of the units that share the name.
+    if (members.size() > 1) answer.members.assign(members.begin(), members.end());
+    return answer;
+}
+
 std::vector<std::filesystem::path>
 package_link_objects(const BuildPlan& plan, std::string_view packageName) {
     std::vector<std::filesystem::path> objects;

src/build/prepare/plan.cpp

@@ -917,6 +917,9 @@ static std::expected<void, std::string> step13_build_graph_actions(PrepareState&
         // become an edge with a blank path, and ninja reports that far away
         // from the typo that caused it.
         std::set<std::string> unresolvedTargets;
+        // Names several members define, used by a package acting for none of
+        // them (`resolve_target_file`): refused, never resolved by member order.
+        std::map<std::string, std::vector<std::string>> ambiguousTargets;
         std::set<std::string> unresolvedArtifacts;
         // `${mcpp.stage_dir}` used where there is no staged tree, and used by an
         // action whose role runs before the link. Both are refusals rather than
@@ -953,6 +956,7 @@ static std::expected<void, std::string> step13_build_graph_actions(PrepareState&
         // The stage of the package being collected, as `collect` sets it: that of
         // the member it acts for (`PrepareState::packStageOf`), or why it has none.
         const BuildOverrides::PackStage* stage = nullptr;
+        std::string actingMember;   // the member the package acts for (actingMemberOf)
         std::string stageShared;
         bool stagePass = false;
         auto substitute = [&](std::string s, const char* actionId,
@@ -1005,12 +1009,10 @@ static std::expected<void, std::string> step13_build_graph_actions(PrepareState&
                 // "missing and no known rule to make it". Commands run with
                 // cwd = the build dir, so the relative form is also what the
                 // tool being invoked should receive.
-                std::string resolved;
-                for (auto const& lu : ctx.plan.linkUnits)
-                    if (lu.targetName == name)
-                        resolved = lu.output.generic_string();
-                if (resolved.empty()) unresolvedTargets.insert(name);
-                s.replace(p, close - p + 1, resolved);
+                auto answer = mcpp::build::resolve_target_file(ctx.plan, name, actingMember);
+                if (answer.output.empty()) unresolvedTargets.insert(name);
+                else if (!answer.members.empty()) ambiguousTargets[name] = answer.members;
+                s.replace(p, close - p + 1, answer.output);
             }
             // `${mcpp.artifact:<package>/<target>}` (mcpp#711): a dependency's
             // program that an edge requested with `artifacts = [...]`, spelled
@@ -1048,6 +1050,7 @@ static std::expected<void, std::string> step13_build_graph_actions(PrepareState&
             // mcpp#534's ordering edge is scoped to this name.
             auto owner = mcpp::build::qualified_package_name(mm);
             stage = state.packStageOf(packageIndex);
+            actingMember = state.actingMemberOf(packageIndex);
             stagePass = stage && !stage->dir.empty();
             stageShared = stage || state.overrides.pack_stages.empty()
                 ? std::string{} : state.packSharedWhy(packageIndex);
@@ -1166,6 +1169,13 @@ static std::expected<void, std::string> step13_build_graph_actions(PrepareState&
                 bad, known.empty() ? std::string("none") : known));
         }
 
+        for (auto const& [n, in] : ambiguousTargets)
+            return std::unexpected(std::format(
+                "build.mcpp action references ${{mcpp.target_file:{}}}, a target of "
+                "each of the members {}, and its package acts for none of them.\n"
+                "  use: select one of the members, or give the targets distinct names",
+                n, std::format("{}", in)));
+
         if (!unresolvedArtifacts.empty()) {
             std::string bad, known;
             for (auto const& n : unresolvedArtifacts) bad += (bad.empty() ? "" : ", ") + n;

src/build/prepare/state.cppm

@@ -391,6 +391,18 @@ struct PrepareState {
         auto stage = stages.find(pack_owner(name, reach->second));
         return stage == stages.end() ? nullptr : &stage->second;
     }
+    // The selected member package `i` acts for in a plan of several members:
+    // itself when it is one, the one member whose closure reaches it when
+    // exactly one does, and none (empty) otherwise, by `pack_owner`'s rule. It
+    // is what a name the package's actions use is resolved against when two
+    // members give that name to different things (`${mcpp.target_file:}`).
+    std::string actingMemberOf(std::size_t i) {
+        if (selectedMemberCount() < 2 || i >= packages.size()) return {};
+        computePackReach();
+        const auto name = mcpp::build::qualified_package_name(packages[i].manifest);
+        auto reach = packReach.find(name);
+        return reach == packReach.end() ? std::string{} : pack_owner(name, reach->second);
+    }
     // The packaging pass's values of a build program's environment, for the
     // program of package `i`. A package that acts for no packed member is told
     // nothing, not even the format: its answer cannot depend on a request it

src/cli/cmd_publish.cppm

@@ -398,7 +398,7 @@ PackMembers pack_members(const mcpplibs::cmdline::ParsedArgs& parsed) {
         out.rc = 2;
         return out;
     }
-    out.several = mcpp::pack::MemberPack{sel.root, std::move(*groups), {}};
+    out.several = mcpp::pack::MemberPack{sel.root, std::move(*groups), {}, packable};
     return out;
 }