mcpp-community
diff --git a/‎docs/07-build-mcpp.md‎
Lines changed: 1 addition & 0 deletions b/‎docs/07-build-mcpp.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎docs/zh/07-build-mcpp.md‎
Lines changed: 1 addition & 0 deletions b/‎docs/zh/07-build-mcpp.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎src/build/prepare.cppm‎
Lines changed: 109 additions & 31 deletions b/‎src/build/prepare.cppm‎
Lines changed: 109 additions & 31 deletions
diff --git a/‎tests/e2e/145_root_build_mcpp_dep_dirs.sh‎
Lines changed: 80 additions & 0 deletions b/‎tests/e2e/145_root_build_mcpp_dep_dirs.sh‎
Lines changed: 80 additions & 0 deletions
@@ -120,6 +120,7 @@ The running program receives the build context as `MCPP_*` variables
 | `MCPP_MANIFEST_DIR` | `mcpp::manifest_dir()` | the package root (= CWD) |
 | `MCPP_FEATURE_<NAME>` | `mcpp::has_feature("name")` | set to `1` per active feature (same `<NAME>` sanitization as the `MCPP_FEATURE_` compile macro) |
 | `MCPP_FEATURES` | — | comma-separated active feature list |
+| `MCPP_DEP_<NAME>_DIR` | `mcpp::dep_dir("name")` | the resolved install dir of each declared dependency (canonical **and** namespace-stripped name spellings; same `<NAME>` sanitization as `MCPP_FEATURE_`). Received by dependencies' build.mcpp **and** the root project's (the root runs after dependency resolution) |
 
 These values are folded into the re-run key **unconditionally** — changing the
 target, profile, or feature set re-runs the program without any
 
@@ -112,6 +112,7 @@ int main() {
 | `MCPP_MANIFEST_DIR` | `mcpp::manifest_dir()` | 包根(= CWD) |
 | `MCPP_FEATURE_<NAME>` | `mcpp::has_feature("name")` | 每个活跃 feature 置 `1`(`<NAME>` 消毒规则与 `MCPP_FEATURE_` 编译宏一致) |
 | `MCPP_FEATURES` | — | 活跃 feature 逗号列表 |
+| `MCPP_DEP_<NAME>_DIR` | `mcpp::dep_dir("name")` | 每个已声明依赖解析后的安装目录(canonical 名与去命名空间短名两种拼写都可用;`<NAME>` 消毒规则同 `MCPP_FEATURE_`)。依赖包的 build.mcpp **和**根工程的 build.mcpp 都能拿到(根工程的 build.mcpp 在依赖解析之后运行) |
 
 这些契约值**无条件**折入重跑键——换 target、换 profile、开关 feature 都会触发重跑,
 不需要任何 `rerun-if-env-changed` 声明。
 
@@ -1129,20 +1129,24 @@ prepare_build(bool print_fingerprint,
     // self-describing. See docs: 2026-05-21-linux-sysroot-missing-kernel-headers.md
 
     // ── L3: project-local `build.mcpp` imperative build program ─────────────
-    // Compiled with the HOST toolchain and run now — after target resolution
-    // + the L1 cfg-flag merge (buildConfig flags are final) and BEFORE the
-    // modgraph scan (so its `generated=` sources are picked up). Its stdout
-    // directives augment buildConfig; a declared-input cache re-runs it only
-    // when its source/inputs/env/contract change. It cannot gate the top-level
-    // dependency graph (leaf-only rule). Under a cross --target it runs with a
-    // host-resolved toolchain and sees MCPP_TARGET = the cross triple (G3).
-    // Dependencies' build.mcpp run in a later pass (G2), after their features
-    // are known. See .agents/docs/2026-06-30-l3-build-mcpp-implementation-design.md
-    // and 2026-07-17-asm-sources-and-general-build-capabilities-design.md §2.4.
+    // The ROOT program is compiled with the HOST toolchain and run AFTER
+    // dependency resolution + feature activation (so it receives
+    // MCPP_DEP_<NAME>_DIR like a dependency's does — design §3.1 item 4) and
+    // BEFORE the modgraph scan (so its `generated=`/`source=` sources are
+    // picked up) — see the call site further below, after the dep build.mcpp
+    // loop. Its stdout directives augment buildConfig; a declared-input cache
+    // re-runs it only when its source/inputs/env/contract change. It cannot
+    // gate the top-level dependency graph (leaf-only rule). Under a cross
+    // --target it runs with a host-resolved toolchain and sees MCPP_TARGET =
+    // the cross triple (G3).
+    // See .agents/docs/2026-06-30-l3-build-mcpp-implementation-design.md,
+    // 2026-07-17-asm-sources-and-general-build-capabilities-design.md §2.4 and
+    // 2026-07-19-large-source-pkg-platform-fixes-and-buildmcpp-generation-design.md.
     // Root [generated_files]: materialize before build.mcpp and the modgraph
-    // scan so synthesized sources are globbed like any on-disk file. (The
-    // per-dependency call sits in the dep resolution loop below; the root
-    // manifest needs its own.)
+    // scan so synthesized sources are globbed like any on-disk file — and
+    // BEFORE dependency resolution, since generated_files may produce
+    // build.mcpp itself. (The per-dependency call sits in the dep resolution
+    // loop below; the root manifest needs its own.)
     if (!m->buildConfig.generatedFiles.empty()) {
         if (auto r = materialize_generated_files(*root, *m); !r) {
             return std::unexpected(r.error());
@@ -1204,21 +1208,6 @@ prepare_build(bool print_fingerprint,
         return *hostTcCache;
     };
 
-    if (std::filesystem::exists(*root / "build.mcpp")) {
-        auto host = host_tc_for_build_program();
-        if (!host) return std::unexpected(host.error());
-        mcpp::build::BuildProgramEnv bpEnv;
-        bpEnv.targetTriple = resolvedTargetCanonical;
-        bpEnv.profile      = effectiveProfile;
-        bpEnv.features     = feature_closure(*m, parse_feature_request(overrides.features));
-        if (auto bp = mcpp::build::run_build_program(
-                *m, *root, host->first, host->second,
-                m->cppStandard.canonical, bpEnv);
-            !bp) {
-            return std::unexpected(bp.error());
-        }
-    }
-
     // Resolve dependencies: walk the **transitive** graph from the main
     // manifest, BFS-style. Each unique `(namespace, shortName)` is fetched
     // once, its `[build].include_dirs` are propagated to the main
@@ -3051,9 +3040,8 @@ prepare_build(bool print_fingerprint,
             // under BOTH its canonical package name AND its namespace-stripped
             // short name, so `mcpp::dep_dir("compat.zlib")` and
             // `mcpp::dep_dir("zlib")` both resolve regardless of which spelling
-            // the author used in `deps`. (The ROOT project's own build.mcpp runs
-            // before dependency resolution, so it does not yet receive these —
-            // tracked as a follow-up in the #230-#243 ledger.)
+            // the author used in `deps`. (The ROOT project's build.mcpp gets
+            // the same treatment at its own call site right after this loop.)
             for (auto const& edge : dependencyEdges) {
                 if (edge.consumerPackageIndex != i) continue;
                 auto const& depPkg = packages[edge.dependencyPackageIndex];
@@ -3176,6 +3164,96 @@ prepare_build(bool print_fingerprint,
         }
     }
 
+    // ── L3: ROOT build.mcpp (moved after dependency resolution, design §3.1
+    // item 4) ────────────────────────────────────────────────────────────────
+    // Runs HERE — after dep resolution + feature activation (so the contract
+    // env can expose MCPP_DEP_<NAME>_DIR exactly like the dep loop above does)
+    // and BEFORE the modgraph scan / flag canonicalization / fingerprint (so
+    // its generated=/source= sources and flag directives are fully visible).
+    // Ordering invariants preserved relative to the pre-move call site:
+    // materialize_generated_files (may produce build.mcpp itself) and the L1
+    // cfg merge still run earlier — ONLY this call moved later.
+    //
+    // One wrinkle the old ordering hid: back then apply() mutated *m BEFORE
+    // `packages[0] = makePackageRoot(*root, *m)` snapshotted buildConfig into
+    // privateBuild/manifest — the copies the scan and per-TU flag assembly
+    // actually read. Now the snapshot (and root feature activation on it)
+    // already happened, so mirror the directive TAILS into packages[0]
+    // explicitly, the same way the dep loop does for its package.
+    if (std::filesystem::exists(*root / "build.mcpp")) {
+        auto host = host_tc_for_build_program();
+        if (!host) return std::unexpected(host.error());
+        mcpp::build::BuildProgramEnv bpEnv;
+        bpEnv.targetTriple = resolvedTargetCanonical;
+        bpEnv.profile      = effectiveProfile;
+        // Same expression as the pre-move call site (and same order), so the
+        // contract hash — and therefore the build.mcpp cache — is unchanged
+        // across the move for feature-identical builds.
+        bpEnv.features     = feature_closure(*m, parse_feature_request(overrides.features));
+        // mcpp#241 (root): the root's resolved direct deps, from the same
+        // authoritative edge graph as the dep loop (consumer index 0 = root),
+        // emitted under canonical AND namespace-stripped names.
+        for (auto const& edge : dependencyEdges) {
+            if (edge.consumerPackageIndex != 0) continue;
+            auto const& depPkg = packages[edge.dependencyPackageIndex];
+            const auto& canon = depPkg.manifest.package.name;
+            bpEnv.depDirs.emplace_back(canon, depPkg.root);
+            if (auto dot = canon.rfind('.'); dot != std::string::npos
+                    && dot + 1 < canon.size())
+                bpEnv.depDirs.emplace_back(canon.substr(dot + 1), depPkg.root);
+        }
+        auto& bcRoot = m->buildConfig;
+        const auto rcN = bcRoot.cflags.size(), rcxN = bcRoot.cxxflags.size(),
+                   rldN = bcRoot.ldflags.size(), rsrcN = bcRoot.sources.size(),
+                   rincN = bcRoot.includeDirs.size(),
+                   rincAfterN = bcRoot.includeDirsAfter.size(),
+                   rmodN = m->modules.sources.size();
+        if (auto bp = mcpp::build::run_build_program(
+                *m, *root, host->first, host->second,
+                m->cppStandard.canonical, bpEnv);
+            !bp) {
+            return std::unexpected(bp.error());
+        }
+        auto& pkg0 = packages[0];
+        // Sources → the scan walks packages[0].manifest, not *m.
+        pkg0.manifest.buildConfig.sources.insert(
+            pkg0.manifest.buildConfig.sources.end(),
+            bcRoot.sources.begin() + rsrcN, bcRoot.sources.end());
+        pkg0.manifest.modules.sources.insert(
+            pkg0.manifest.modules.sources.end(),
+            m->modules.sources.begin() + rmodN, m->modules.sources.end());
+        // Compile flags → the root's TUs read privateBuild (and the
+        // fingerprint folds packages[].manifest.buildConfig via
+        // canonical_package_build_metadata) — mirror both, as the old
+        // pre-snapshot ordering implicitly did.
+        pkg0.privateBuild.cflags.insert(pkg0.privateBuild.cflags.end(),
+            bcRoot.cflags.begin() + rcN, bcRoot.cflags.end());
+        pkg0.privateBuild.cxxflags.insert(pkg0.privateBuild.cxxflags.end(),
+            bcRoot.cxxflags.begin() + rcxN, bcRoot.cxxflags.end());
+        pkg0.manifest.buildConfig.cflags.insert(
+            pkg0.manifest.buildConfig.cflags.end(),
+            bcRoot.cflags.begin() + rcN, bcRoot.cflags.end());
+        pkg0.manifest.buildConfig.cxxflags.insert(
+            pkg0.manifest.buildConfig.cxxflags.end(),
+            bcRoot.cxxflags.begin() + rcxN, bcRoot.cxxflags.end());
+        // Link flags → the final link reads *m (already applied); keep the
+        // linkUsage snapshot equivalent too.
+        pkg0.linkUsage.ldflags.insert(pkg0.linkUsage.ldflags.end(),
+            bcRoot.ldflags.begin() + rldN, bcRoot.ldflags.end());
+        pkg0.manifest.buildConfig.ldflags.insert(
+            pkg0.manifest.buildConfig.ldflags.end(),
+            bcRoot.ldflags.begin() + rldN, bcRoot.ldflags.end());
+        // include-dir directives: PRIVATE (already absolute from parse_line) —
+        // privateBuild only, never publicUsage (see the dep loop's rationale).
+        for (auto it = bcRoot.includeDirs.begin() + rincN;
+             it != bcRoot.includeDirs.end(); ++it)
+            appendUniquePath(pkg0.privateBuild.includeDirs, *it);
+        pkg0.manifest.buildConfig.includeDirsAfter.insert(
+            pkg0.manifest.buildConfig.includeDirsAfter.end(),
+            bcRoot.includeDirsAfter.begin() + rincAfterN,
+            bcRoot.includeDirsAfter.end());
+    }
+
     // [targets.*] required_features gate: a target is emitted only when ALL its
     // required features are active in this build; otherwise it is silently
     // skipped. A pure build-selection knob — it runs before the modgraph/plan
 
@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# requires: gcc
+# P1 (large-source-pkg design §3.1 item 4): the ROOT project's build.mcpp now
+# runs AFTER dependency resolution and receives MCPP_DEP_<NAME>_DIR exactly
+# like a dependency's build.mcpp does (mcpp#241 contract, previously dep-only:
+# the root ran before resolution and saw none). Scenario mirrors
+# 125_build_mcpp_dep_dir.sh, but the build.mcpp asserting dep_dir() is the
+# ROOT's own: root -> datad (path dep); root build.mcpp reads
+# dep_dir("datad"), fails loudly if unset, and generates a source returning
+# it; main prints it; the test asserts it is datad's real root.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+# data-asset dependency
+mkdir -p datad/src
+echo 'int datad_touch() { return 1; }' > datad/src/d.cpp
+cat > datad/mcpp.toml <<'EOF'
+[package]
+name    = "datad"
+version = "0.1.0"
+[modules]
+sources = ["src/**/*.cpp"]
+[targets.datad]
+kind = "lib"
+EOF
+
+# ROOT project whose own build.mcpp locates datad's dir
+mkdir -p rootp/src
+cat > rootp/build.mcpp <<'EOF'
+#include <cstdio>
+#include <string>
+import mcpp;
+int main() {
+    const char* d = mcpp::dep_dir("datad");
+    if (d == nullptr || d[0] == '\0') {
+        std::fprintf(stderr, "build.mcpp: MCPP_DEP_DATAD_DIR not set for the ROOT\n");
+        return 1;   // the moved call point must expose the contract var
+    }
+    std::string out = "src/depdir.cpp";
+    std::FILE* f = std::fopen(out.c_str(), "w");
+    std::fprintf(f, "const char* root_datad_dir() { return \"%s\"; }\n", d);
+    std::fclose(f);
+    mcpp::generated("src/depdir.cpp");
+    return 0;
+}
+EOF
+cat > rootp/src/main.cpp <<'EOF'
+import std;
+extern const char* root_datad_dir();
+int main() {
+    std::println("DEPDIR={}", root_datad_dir());
+    return 0;
+}
+EOF
+cat > rootp/mcpp.toml <<'EOF'
+[package]
+name    = "rootp"
+version = "0.1.0"
+[modules]
+sources = ["src/**/*.cpp"]
+[dependencies]
+datad = { path = "../datad" }
+[targets.rootp]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+
+cd rootp
+"$MCPP" build > build.log 2>&1 || { cat build.log; echo "FAIL: build failed"; exit 1; }
+
+out="$("$MCPP" run 2>&1 | grep '^DEPDIR=' | tail -1)"
+dir="${out#DEPDIR=}"
+[[ -n "$dir" ]] || { echo "FAIL: empty dep dir (root contract var missing)"; exit 1; }
+[[ -d "$dir" ]] || { echo "FAIL: dep dir does not exist: $dir"; exit 1; }
+[[ "$(basename "$dir")" == "datad" ]] || { echo "FAIL: dep dir is not datad's root: $dir"; exit 1; }
+
+echo "OK"