fix: rebuild and relink on what changed, submodules at their revisions, and mingw found where it is

- Shaders record the files glslang opened (a depfile) and their settings
  (source path, stage, entry point, defines, include directories) in the
  build directory, and rebuild when an included file or a setting changes,
  not only the shader's own source.
- An executable relinks when its link command changed, not only when an
  object is newer: a link flag in project.cpp, or a dependency's library
  that moved (an ExternalDependency built into a new cache directory). The
  command is recorded beside the objects; its flags come from ordered sets,
  so the order the dependency threads finish in can't change it.
- An external's newest artifact counts its libDirs and versioned .so names.
- Submodules are checked out at the revisions the fetched commit records,
  from the URLs its .gitmodules gives, after every clone, switch, checkout
  and pull, so a pinned commit builds against its own submodules, and one
  moved by hand is put back; with no .gitmodules, git isn't asked.
- Each external clone's fetch and build hold a file lock: parallel builds
  pulled into one clone at once ("cannot lock ref").
- mingw:
  - -stdlib=libstdc++ always;
  - the std module's source is found through libstdc++.modules.json in the
    mingw toolchain's own library directories (the generic lib/ holds the
    host's Linux one), asking the compiler once a run;
  - a toolchain that isn't there is a build error saying where it looked,
    not std::terminate;
  - CRAFTER_MINGW_DIR names the prefix, the directory holding
    x86_64-w64-mingw32/ and lib/gcc/;
  - inside the Flatpak the host's /usr mingw is used.
- RunScript's exit-status check reads as the one range it is.
- Tests: ConcurrentExternalFetch, ExternalArtifactTime, GitSubmodules,
  LinkFlagsChange, MingwMissing, ShaderIncludeChange; ShaderCompile and
  ToolchainResolve extended.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

implementations/Crafter.Build-External.cpp

@@ -36,6 +36,18 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
         if (r.exitCode != 0) return std::format("`{}` failed (exit {}): {}", cmd, r.exitCode, r.output);
         return std::nullopt;
     };
+    // Submodules follow the checkout only when asked to: after every clone,
+    // switch, checkout or pull, so they match the revision that was fetched
+    // instead of whichever one was checked out before, from the URLs that
+    // revision's .gitmodules gives (sync). A no-op, and offline, when they
+    // already match, which puts back submodules moved by hand; and no git at
+    // all without any.
+    auto updateSubmodules = [&runGit](const fs::path& dir) -> std::optional<std::string> {
+        if (!fs::exists(dir / ".gitmodules")) return std::nullopt;
+        const std::string quoted = ShellQuote(dir.string());
+        if (auto err = runGit(std::format("git -C {} submodule sync --recursive", quoted))) return err;
+        return runGit(std::format("git -C {} submodule update --init --recursive", quoted));
+    };
 
     if (fs::exists(cloneDir)) {
         CommandResult remote = RunCommandChecked(std::format("git -C {} remote get-url origin", ShellQuote(cloneDir.string())));
@@ -51,6 +63,9 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
                 if (auto err = runGit(std::format("git -C {} fetch origin", ShellQuote(cloneDir.string())))) return *err;
                 if (auto err = runGit(std::format("git -C {} checkout {}", ShellQuote(cloneDir.string()), ShellQuote(source.commit)))) return *err;
             }
+            // Also when the commit already matched: a clone made before
+            // submodules were updated has them at the default branch's.
+            if (auto err = updateSubmodules(cloneDir)) return *err;
             return "";
         } else {
             // No commit pinned — pull latest. The user opted into "track latest"
@@ -61,6 +76,7 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
             } else {
                 if (auto err = runGit(std::format("git -C {} pull", ShellQuote(cloneDir.string())))) return *err;
             }
+            if (auto err = updateSubmodules(cloneDir)) return *err;
             return "";
         }
     }
@@ -73,7 +89,9 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
     fs::path tmpDir = cloneDir;
     tmpDir += std::format(".tmp.{:08x}{:08x}", rd(), rd());
 
-    if (auto err = runGit(std::format("git clone --recursive {} {}", ShellQuote(source.url), ShellQuote(tmpDir.string())))) {
+    // Not --recursive: that checks out the default branch's submodules, and
+    // the requested revision's come once it is checked out.
+    if (auto err = runGit(std::format("git clone {} {}", ShellQuote(source.url), ShellQuote(tmpDir.string())))) {
         if (fs::exists(tmpDir)) fs::remove_all(tmpDir);
         return *err;
     }
@@ -89,6 +107,10 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
             return *err;
         }
     }
+    if (auto err = updateSubmodules(tmpDir)) {
+        fs::remove_all(tmpDir);
+        return *err;
+    }
 
     std::error_code ec;
     fs::rename(tmpDir, cloneDir, ec);
@@ -124,6 +146,10 @@ std::string BuildInjectedCMakeFlags(const fs::path& cmakeBuildDir, std::string_v
         out += " -DCMAKE_SYSTEM_NAME=Windows";
         out += std::format(" -DCMAKE_C_COMPILER_TARGET={}", target);
         out += std::format(" -DCMAKE_CXX_COMPILER_TARGET={}", target);
+        // The libstdc++ and the mingw-w64 install the project's own compiles
+        // use (GetBaseCommand).
+        out += " -DCMAKE_CXX_FLAGS=-stdlib=libstdc++";
+        if (!tc.mingwSysroot.empty()) out += std::format(" -DCMAKE_SYSROOT={}", ShellQuote(tc.mingwSysroot.string()));
     }
     fs::path absBuildDir = fs::absolute(cmakeBuildDir);
     out += std::format(" -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY={}", ShellQuote(absBuildDir.string()));
@@ -227,6 +253,9 @@ ExternalBuildResult Crafter::BuildExternal(const ExternalDependency& dep, std::s
     }
 
     fs::path cloneDir = ExternalCloneDir(dep, target);
+    // Builds running side by side (tests built in parallel, two
+    // crafter-builds) share the clone: one fetches and builds it at a time.
+    FileLock lock(fs::path(std::format("{}.lock", cloneDir.string())));
 
     std::string fetchErr = FetchGit(dep.source, cloneDir);
     if (!fetchErr.empty()) {
@@ -273,13 +302,20 @@ ExternalBuildResult Crafter::BuildExternal(const ExternalDependency& dep, std::s
             result.linkFlags.push_back(std::format("-l{}", lib));
         }
 
-        if (fs::exists(cmakeBuildDir)) {
-            for (const auto& entry : fs::directory_iterator(cmakeBuildDir)) {
-                if (!entry.is_regular_file()) continue;
-                const fs::path& p = entry.path();
-                if (p.extension() != ".a" && p.extension() != ".so") continue;
+        // The newest library in every directory the link searches: the build
+        // directory and the libDirs, where projects like msquic put theirs,
+        // versioned names (libmsquic.so.2) included.
+        auto isLibrary = [](const std::string& name) {
+            return name.ends_with(".a") || name.ends_with(".so") || name.contains(".so.") || name.ends_with(".dll");
+        };
+        std::vector<fs::path> searched = { cmakeBuildDir };
+        for (const fs::path& libDir : dep.libDirs) searched.push_back(libDir.is_absolute() ? libDir : cmakeBuildDir / libDir);
+        for (const fs::path& dir : searched) {
+            std::error_code listEc;
+            for (fs::directory_iterator it(dir, listEc), end; !listEc && it != end; it.increment(listEc)) {
                 std::error_code ec;
-                fs::file_time_type t = entry.last_write_time(ec);
+                if (!it->is_regular_file(ec) || !isLibrary(it->path().filename().string())) continue;
+                fs::file_time_type t = it->last_write_time(ec);
                 if (!ec && t > result.latestArtifact) result.latestArtifact = t;
             }
         }
@@ -355,6 +391,8 @@ Configuration* Crafter::GitProject(const GitProjectSpec& spec) {
     fs::path cloneDir = externalRoot / std::format("{}-{}", name, srcHash);
 
     {
+        // One fetch of a clone at a time, as in BuildExternal.
+        FileLock lock(fs::path(std::format("{}.lock", cloneDir.string())));
         const bool exists = fs::exists(cloneDir);
         Progress::Task task(std::format("{} {}", exists ? "Updating" : "Cloning", name));
         if (std::string err = FetchGit(spec.source, cloneDir); !err.empty()) {
@@ -396,6 +434,8 @@ fs::path Crafter::GitFetch(const GitSource& source) {
     fs::path cloneDir = externalRoot / std::format("{}-{:016x}", name, key);
 
     {
+        // One fetch of a clone at a time, as in BuildExternal.
+        FileLock lock(fs::path(std::format("{}.lock", cloneDir.string())));
         const bool exists = fs::exists(cloneDir);
         Progress::Task task(std::format("{} {}", exists ? "Updating" : "Cloning", name));
         if (std::string err = FetchGit(source, cloneDir); !err.empty()) {