fix: a cross target's toolchain section is not the build program's; a test name is not another's directory; CI findings

- Under a cross `--target`, a `[target.<t>] toolchain` names the target's
  compiler; the build program takes the spec it replaced, as under a row's pin
  (mcpp's own tree built on Windows for x86_64-linux-musl compiled its build
  program with the musl cross gcc). e2e 1051.
- A test name that is another's directory (`unit`, `unit/own`) is refused,
  naming both.
- The rows' snapshot keeps LF on every checkout (.gitattributes).
- e2e 298 leaves out x86_64-windows-gnu, whose MinGW-w64 payload llvm pairs
  with; openkal-cross names the openkal macOS identity, aarch64-macos-musl.
- The stray empty `.edited` is removed; e2e 859 names a missing record.

Co-authored-by: speak-agent <248744407+speak-agent@users.noreply.github.com>

Author: Sunrisepeak

.edited

@@ -1,2 +1,4 @@
 # The cross-host admission compares the exact source bytes compiled by each host.
 tests/fixtures/openkal-hosted-threads/src/main.cpp.in text eol=lf
+# The rows' snapshot is compared line by line with what the engine answers, in its own bytes.
+tests/fixtures/target-rows.snapshot text eol=lf

.gitattributes

@@ -292,7 +292,9 @@ jobs:
           # `openkal-llvm-runtime`'s own CI under qemu; it has no runner here to
           # execute on, and a build-only cell in a workflow whose point is
           # running would be the weaker claim.
-          for t in x86_64-linux-gnu aarch64-macos x86_64-windows-gnu; do
+          # The macOS identity over openkal is `aarch64-macos-musl` on every host (SPEC-016 §4): on a
+          # macOS host `aarch64-macos` is the Apple SDK's.
+          for t in x86_64-linux-gnu aarch64-macos-musl x86_64-windows-gnu; do
             rm -rf target
             # The upstream manifest may pin an older LLVM line. The invocation
             # selects this candidate explicitly, including on the ARM64 host.
@@ -301,12 +303,12 @@ jobs:
             [ -n "$a" ] || { echo "::error::$t produced no artefact on ${{ matrix.host }}"; exit 1; }
             case "$t" in
               x86_64-windows-gnu) cp "$a" "$RUNNER_TEMP/out/windows.exe" ;;
-              aarch64-macos)      cp "$a" "$RUNNER_TEMP/out/macos"       ;;
+              aarch64-macos-musl) cp "$a" "$RUNNER_TEMP/out/macos"       ;;
               *)                  cp "$a" "$RUNNER_TEMP/out/linux"       ;;
             esac
             "$READOBJ" --file-headers "$a" > "$RUNNER_TEMP/out/$t.headers.txt"
             case "$t" in
-              aarch64-macos) arch=aarch64 ;;
+              aarch64-macos-musl) arch=aarch64 ;;
               *) arch=x86_64 ;;
             esac
             grep -q "Arch: $arch" "$RUNNER_TEMP/out/$t.headers.txt" \
@@ -319,7 +321,7 @@ jobs:
             thread_bin=$(cat "$RUNNER_TEMP/threads-binary.txt")
             case "$t" in
               x86_64-windows-gnu) thread_output=windows-threads.exe ;;
-              aarch64-macos) thread_output=macos-threads ;;
+              aarch64-macos-musl) thread_output=macos-threads ;;
               *) thread_output=linux-threads ;;
             esac
             cp "$thread_bin" "$RUNNER_TEMP/out/$thread_output"
@@ -355,7 +357,7 @@ jobs:
       # costs.
       #
       # LEG 3 IS THE ENGINE: the same idiom, over the openkal stack, for
-      # `aarch64-macos`, built by the mcpp under test. Measured on the token
+      # `aarch64-macos-musl`, built by the mcpp under test. Measured on the token
       # this step was written for, the two readings are
       #
       #     -fno-builtin-memset_pattern16   1 reference, and the link fails
@@ -444,10 +446,10 @@ jobs:
           [ "$(refs "$W/narrow.o")" = 1 ] || { echo "::error::leg 2: clang now honours -fno-builtin-memset_pattern16, and mcpp.toolchain.cenv can emit the narrower token"; exit 1; }
           [ "$(refs "$W/blunt.o")" = 0 ] || { echo "::error::leg 2: -fno-builtin no longer withdraws the pattern fill"; exit 1; }
 
-          (cd "$W" && "$MCPP_UNDER_TEST" build --target aarch64-macos)
+          (cd "$W" && "$MCPP_UNDER_TEST" build --target aarch64-macos-musl)
           obj=$(find "$W/target" -name 'main.o' | head -1)
           [ -n "$obj" ] || { echo "::error::leg 3 produced no object to read"; exit 1; }
-          echo "engine, aarch64-macos over openkal: $(refs "$obj")"
+          echo "engine, aarch64-macos-musl over openkal: $(refs "$obj")"
           [ "$(refs "$obj")" = 0 ] || { echo "::error::leg 3: builtins = \"iso\" did not withdraw memset_pattern16"; exit 1; }
 
       - uses: actions/upload-artifact@v4

.github/workflows/openkal-cross.yml

@@ -97,6 +97,14 @@
   the conflict is reported (B2).
 - `mcpp pack` no longer packs one program of several without a word (B3).
 - A static ELF is not run to learn its closure.
+- A build program under a cross `--target` whose `[target.<t>] toolchain`
+  names the target's compiler is compiled by the spec that section replaced,
+  as under a row's pin: mcpp's own tree, built on Windows for
+  `x86_64-linux-musl`, compiled its build program with the musl cross gcc.
+- A test name that is another's directory (`unit` and `unit/own`) is refused,
+  naming both; the two programs were a file and a directory of one path.
+- The repository's stray empty `.edited` is removed; e2e 859 fails naming the
+  missing record rather than writing one in the working directory.
 
 ## [2026.11.8.1] - 2026-11-08
 

CHANGELOG.md

@@ -61,7 +61,9 @@ below a glob's fixed directory one program, named by the directory
 it, its cases are all of theirs, and it begins at the file that defines `main`
 when one does, else as a file that defines none does. Two files of one directory
 that define `main` are refused, naming both; a file directly in the fixed
-directory stays a program of its own. A program of many files is linked once
+directory stays a program of its own. A test's name is the path of its program,
+so a name that is another's directory (`unit` and `unit/own`) is refused,
+naming both (2026.11.9.1+). A program of many files is linked once
 where a program per file is linked once per file, which is what a suite of many
 small files spends its build time on.
 

docs/08-testing.md

@@ -54,7 +54,8 @@ discover = ["checks/**/*.cpp", "!checks/fixtures/**"]
 一个程序，以目录命名（`tests/unit/*.cpp` 为程序 `unit`）：每个文件是它的一个翻译单元，
 它的用例是这些文件的全部用例；有文件定义 `main` 时以该文件为起点，否则按不定义 `main`
 的文件的规则开始。同一目录中两个定义 `main` 的文件会被拒绝并点出两者；直接位于固定
-目录中的文件仍各自是一个程序。多文件的程序只链接一次，而每文件一个程序时每个文件链接
+目录中的文件仍各自是一个程序。测试的名字是其程序的路径，因此一个名字是另一个名字的目录
+（`unit` 与 `unit/own`）时被拒绝并点出两者（2026.11.9.1+）。多文件的程序只链接一次，而每文件一个程序时每个文件链接
 一次，后者正是由许多小文件组成的套件在构建上花费的时间。
 
 使用测试协议的程序**按其用例所在文件各起一个进程**运行（2026.11.9.1+）：mcpp 先列出多文件程序的用例，

docs/zh/08-testing.md

@@ -550,6 +550,12 @@ static void step1_apply_target_section(PrepareState& state,
                 : state.overrides.target_triple,
             state.m->sourcePath.filename().string()));
     if (!e.toolchain.empty() && !state.tcFromCommandLine && !state.tcFromConsumer) {
+        // A CROSS TARGET'S SECTION NAMES THE TARGET'S COMPILER, NOT THE HOST'S:
+        // the spec it replaced is what the build program resolves, as a row's
+        // pin's is (`[target.x86_64-linux-musl] toolchain = "gcc@16.1.0"` on a
+        // Windows host whose `[toolchain] windows` is llvm).
+        if (!state.overrides.target_triple.empty() && state.tcSpec && *state.tcSpec != e.toolchain)
+            state.hostSpecBeforeRowPin = *state.tcSpec;
         state.tcSpec   = e.toolchain;
         state.tcOrigin = TcOrigin::TargetSection;
     }

src/build/prepare/toolchain.cpp

@@ -121,10 +121,16 @@ step3_define_host_tc_closures_and_refresh_index(PrepareState& state) {
         if (!state.bootstrapSpec.empty()) return state.bootstrapSpec;
         if (!state.tcSpec) return {};
         if (state.overrides.target_triple.empty()) return *state.tcSpec;
-        return (state.tcOrigin == TcOrigin::TargetPin && state.hostSpecBeforeRowPin.has_value()
-                && !state.hostSpecBeforeRowPin->empty() && *state.hostSpecBeforeRowPin != "system")
-            ? *state.hostSpecBeforeRowPin
-            : (state.tcOrigin == TcOrigin::TargetPin ? state.native_first_run_spec() : *state.tcSpec);
+        // The target's own choice -- a row's pin or a `[target.<t>] toolchain`
+        // -- is not the host's: the spec it replaced is. A pin that replaced
+        // nothing gives the native default (#622); a section that replaced
+        // nothing names the only compiler the project states.
+        const bool targetChose = state.tcOrigin == TcOrigin::TargetPin
+                              || state.tcOrigin == TcOrigin::TargetSection;
+        if (targetChose && state.hostSpecBeforeRowPin.has_value() && !state.hostSpecBeforeRowPin->empty()
+            && *state.hostSpecBeforeRowPin != "system")
+            return *state.hostSpecBeforeRowPin;
+        return state.tcOrigin == TcOrigin::TargetPin ? state.native_first_run_spec() : *state.tcSpec;
     };
     state.host_tc_for_build_program = [&]() -> std::expected<
             std::pair<std::filesystem::path, mcpp::toolchain::Toolchain>, std::string> {

src/build/prepare/xlings.cpp

@@ -192,6 +192,17 @@ discover_test_targets(const std::filesystem::path& manifestRoot,
         }
         result.targets.push_back(std::move(target));
     }
+    // A TEST'S NAME IS A PATH OF ITS PROGRAM (`bin/<name>`): one name that is
+    // another's directory would make one program a directory of the other's.
+    // The names are sorted: the first name below `<name>/` is the one to ask.
+    for (auto it = seenNames.begin(); it != seenNames.end(); ++it) {
+        auto next = seenNames.lower_bound(it->first + "/");
+        if (next == seenNames.end() || !next->first.starts_with(it->first + "/")) continue;
+        return std::unexpected(std::format(
+            "test '{}' ({}) is a directory of test '{}' ({}): a test's name is the path of its "
+            "program, and one cannot be both; move one of them",
+            it->first, it->second.generic_string(), next->first, next->second.generic_string()));
+    }
     return result;
 }
 

src/build/test_targets.cppm

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# requires: elf llvm gcc musl
+source "$(dirname "${BASH_SOURCE[0]}")/_toolchain_env.sh"
+# 1051 -- a cross target's `[target.<t>] toolchain` names the target's compiler, not the one the
+# build program is compiled with.
+#
+# A build program is compiled and run on this machine. `[target.x86_64-linux-musl] toolchain =
+# "gcc@16.1.0"` replaces the project's `[toolchain]` for the target; the build program takes the
+# spec it replaced, as it takes the one a row's pin replaced (657). Measured on mcpp's own tree,
+# built on Windows for x86_64-linux-musl: the build program was compiled by the musl cross gcc and
+# the host could not start it (error 8, executable format error).
+#
+# Criteria: under `--target x86_64-linux-musl` the build program's compiler is the `[toolchain]`
+# one (llvm), the target's is the section's (gcc), and the build program runs.
+set -e
+t=$(mktemp -d); trap 'rm -rf "$t"' EXIT
+fail() { echo "FAIL: $1"; [ -n "${2:-}" ] && printf '%s\n' "$2" | tail -20; exit 1; }
+[ "$(uname -m)" = x86_64 ] || { echo "SKIP: an x86_64 host"; exit 0; }
+mkdir -p "$t/src" && cd "$t"
+cat > mcpp.toml <<EOF
+[package]
+name    = "crossprog"
+version = "0.1.0"
+
+[toolchain]
+default = "llvm@${LLVM_VERSION:-23.1.3}"
+
+[target.x86_64-linux-musl]
+toolchain = "gcc@16.1.0"
+EOF
+cat > build.mcpp <<'EOF'
+import std;
+import mcpp;
+int main() {
+    std::ofstream(std::string(mcpp::out_dir()) + "/ran.txt") << "ran\n";
+}
+EOF
+echo 'int main() { return 0; }' > src/main.cpp
+out=$("$MCPP" build --target x86_64-linux-musl 2>&1) || fail "the cross build failed" "$out"
+grep -q 'host toolchain for build.mcpp: llvm' <<<"$out" \
+    || grep -Eq 'Resolved host toolchain for build.mcpp: clang' <<<"$out" \
+    || fail "the build program is not compiled by the [toolchain] compiler" "$out"
+grep -q 'x86_64-linux-musl-g++' <<<"$out" || fail "the target is not compiled by the section's gcc" "$out"
+find target -name ran.txt | grep -q . || fail "the build program did not run" "$(find target -maxdepth 4 | head)"
+echo "  ok  the build program takes the [toolchain] compiler; the target takes its section's"
+echo "PASS: 1051 a cross target's toolchain section is not the build program's"