refactor(build): include-dir[-after] directives converge on the typed #249 channel

Review pass over the merged P0+P1 branch. Two spellings of the same
decision survived the parallel tracks:

- dep loop: after-dirs were spelled as raw private '-idirafter <dir>'
  flag pairs (written before #249 landed privateBuild.includeDirsAfter);
  the raw spelling bypasses the typed channel's per-dialect degradations
  (cl.exe /I, NASM -I). Now appendUniquePath into the typed slot.
- root: after-dirs reached only the fingerprint mirror
  (manifest.buildConfig), never privateBuild — scanned units read
  privateBuild.includeDirsAfter, so 'mcpp:include-dir-after=' on the
  root was inert on compile edges. Both channels now mirrored for both
  kinds, matching the flag mirrors above.

e2e 144 upgraded from 'directive accepted' to asserting -idirafter
reaches build.ninja.

Author: Sunrisepeak

src/build/prepare.cppm

@@ -3086,18 +3086,13 @@ prepare_build(bool print_fingerprint,
             for (auto it = bcDep.includeDirs.begin() + incN;
                  it != bcDep.includeDirs.end(); ++it)
                 appendUniquePath(pkg.privateBuild.includeDirs, *it);
-            // No privateBuild slot exists for after-dirs (the -idirafter
-            // emission chain is #249's); spell them as private compile flags
-            // (two argv tokens, matching host_base_flags) so a dep gets the
-            // semantics today.
+            // After-dirs ride the same typed #249 channel
+            // (privateBuild.includeDirsAfter → per-unit -idirafter), which
+            // owns the per-dialect degradations (cl.exe /I, NASM -I) a raw
+            // flag spelling would bypass.
             for (auto it = bcDep.includeDirsAfter.begin() + incAfterN;
-                 it != bcDep.includeDirsAfter.end(); ++it) {
-                for (auto* dst : { &pkg.privateBuild.cflags,
-                                   &pkg.privateBuild.cxxflags }) {
-                    dst->push_back("-idirafter");
-                    dst->push_back(*it);
-                }
-            }
+                 it != bcDep.includeDirsAfter.end(); ++it)
+                appendUniquePath(pkg.privateBuild.includeDirsAfter, *it);
         }
 
         // apply() may have added interface defines to packages' publicUsage
@@ -3243,11 +3238,20 @@ prepare_build(bool print_fingerprint,
         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).
+        // include-dir[/-after] directives: PRIVATE (already absolute from
+        // parse_line) — privateBuild only, never publicUsage (see the dep
+        // loop's rationale). privateBuild is what scanned units read
+        // (scanner → localIncludeDirs[After]); the manifest mirror keeps the
+        // fingerprint metadata equivalent, same as the flag mirrors above.
         for (auto it = bcRoot.includeDirs.begin() + rincN;
              it != bcRoot.includeDirs.end(); ++it)
             appendUniquePath(pkg0.privateBuild.includeDirs, *it);
+        pkg0.manifest.buildConfig.includeDirs.insert(
+            pkg0.manifest.buildConfig.includeDirs.end(),
+            bcRoot.includeDirs.begin() + rincN, bcRoot.includeDirs.end());
+        for (auto it = bcRoot.includeDirsAfter.begin() + rincAfterN;
+             it != bcRoot.includeDirsAfter.end(); ++it)
+            appendUniquePath(pkg0.privateBuild.includeDirsAfter, *it);
         pkg0.manifest.buildConfig.includeDirsAfter.insert(
             pkg0.manifest.buildConfig.includeDirsAfter.end(),
             bcRoot.includeDirsAfter.begin() + rincAfterN,

tests/e2e/144_build_mcpp_include_dir.sh

@@ -5,9 +5,9 @@
 # (`mcpp:cxxflag=-I…` + `mcpp:cflag=-I…`, unnormalized). Scenario: build.mcpp
 # writes a header under MCPP_OUT_DIR and points include-dir at it (absolute);
 # a source #includes it; the build succeeds with NO -I flag emitted manually.
-# Also: `mcpp:include-dir-after=` is accepted (no unknown-directive warning)
-# and both round-trip the directive cache. Its -idirafter ninja emission for
-# the root lands with #249; this test pins the directive+cache surface.
+# Also: `mcpp:include-dir-after=` rides the typed #249 channel end-to-end —
+# the emitted build.ninja must carry -idirafter for the directive dir — and
+# both directives round-trip the directive cache.
 set -e
 
 TMP=$(mktemp -d)
@@ -64,6 +64,13 @@ grep -q "ignoring unknown directive" build1.log && {
 out="$("$MCPP" run 2>&1 | grep '^ANSWER=' | tail -1)"
 [[ "$out" == "ANSWER=42" ]] || { echo "FAIL: include dir not on the -I chain: $out"; exit 1; }
 
+# include-dir-after reaches the compile edges as -idirafter (typed #249
+# channel: privateBuild.includeDirsAfter → localIncludeDirsAfter).
+ninja_file=$(find target -name build.ninja | head -1)
+grep -q -- "-idirafter.*vendor/sysinc" "$ninja_file" || {
+    echo "FAIL: include-dir-after not emitted as -idirafter in build.ninja";
+    grep -n "local_includes" "$ninja_file" | head; exit 1; }
+
 # Cache round-trip: touch a source (defeats the whole-build fast path, keeps
 # build.mcpp inputs unchanged) → the cached include-dir record must reapply
 # without a re-run, and the header must still resolve.