V2: WASI, -r flag, CI pipeline, examples & tests cleanup

WASI / wasm32 target support
- Auto-detect /usr/share/wasi-sysroot on Linux when target starts_with("wasm32")
- Skip -march/-mtune for wasm (clang rejects them)
- Apply -fno-exceptions -fno-c++-static-destructors -mllvm -wasm-enable-sjlj
  -D_WASI_EMULATED_SIGNAL to wasm builds (compile + std PCM, kept in sync)
- .wasm output extension in expectedOutputFor and link command
- EnableWasiBrowserRuntime(cfg): opt-in helper that drops index.html +
  runtime.js next to the .wasm; runtime.js reads window.CRAFTER_WASM_URL
  set in the templated index.html so a single shim handles any output name

-r run flag in the CLI: build then exec the artifact (host targets only;
  rejects libraries; auto .exe/.wasm extension handling)

CI pipeline (.forgejo/workflows/ci.yaml)
- Triggers: PR/push to master + manual dispatch
- Single arch-latest container job: install deps, bootstrap, self-rebuild,
  run tests, cross-compile mingw, package both archives, upload artifacts
- Rolling 'latest' release published only on push/dispatch to master

mingw cross-compile from Linux now works end-to-end:
- ExternalDependency cache key includes target so per-target glslang builds
  don't collide; CMAKE_BUILD_TYPE=Release pinned (otherwise glslang appends
  'd' to lib names and breaks linking); cross-compile cmake flags
  (CMAKE_SYSTEM_NAME=Windows, CMAKE_*_COMPILER_TARGET=...)
- project.cpp accepts --target=<triple>; Linux-only -Wl,--export-dynamic
  and -ldl are gated; mingw glslang skips the standalone exe (its libgcc_eh
  link pulls pthread which mingw doesn't link by default)
- mingw compile uses -femulated-tls so std::__once_callable etc reference
  the same emutls symbols libstdc++ provides
- mingw link auto-adds -lstdc++exp -lpthread

GetCrafterBuildHome() exposed from the Platform module; LoadProject (Linux
+ Windows) now both use it instead of duplicating the resolution.

Examples reorg: hello-world, library, with-module, wasi, tests — each with
its own README. Tests reorg: per-test directory with inner/ fixture, no
shared tests/fixtures/ tree. New Wasi test verifies .wasm magic bytes.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

implementations/Crafter.Build-External.cpp

@@ -110,22 +110,37 @@ std::string FetchGit(const GitSource& source, const fs::path& cloneDir) {
     return "";
 }
 
-std::string BuildInjectedCMakeFlags(const fs::path& cmakeBuildDir) {
+std::string BuildInjectedCMakeFlags(const fs::path& cmakeBuildDir, std::string_view target) {
     std::string out;
+    // Without an explicit build type, some packages (glslang) append a 'd'
+    // suffix to library names assuming a debug build, breaking -l<name>
+    // linking. Pin to Release.
+    out += " -DCMAKE_BUILD_TYPE=Release";
     out += " -DCMAKE_C_COMPILER=clang";
     out += " -DCMAKE_CXX_COMPILER=clang++";
+    // Stdlib choice: libc++ for the Linux host build (matches how crafter-build
+    // itself is built with -stdlib=libc++); mingw cross-compile uses libstdc++
+    // shipped by the mingw-w64 toolchain so we leave the default; Windows
+    // native (msvc target) similarly uses libc++ via LIBCXX_DIR.
     #ifdef CRAFTER_BUILD_CONFIGURATION_TARGET_x86_64_pc_linux_gnu
-    out += " -DCMAKE_CXX_FLAGS=-stdlib=libc++";
-    out += " -DCMAKE_EXE_LINKER_FLAGS=-stdlib=libc++";
-    out += " -DCMAKE_SHARED_LINKER_FLAGS=-stdlib=libc++";
+    if (target == "x86_64-pc-linux-gnu") {
+        out += " -DCMAKE_CXX_FLAGS=-stdlib=libc++";
+        out += " -DCMAKE_EXE_LINKER_FLAGS=-stdlib=libc++";
+        out += " -DCMAKE_SHARED_LINKER_FLAGS=-stdlib=libc++";
+    }
     #endif
+    if (target == "x86_64-w64-mingw32") {
+        out += " -DCMAKE_SYSTEM_NAME=Windows";
+        out += std::format(" -DCMAKE_C_COMPILER_TARGET={}", target);
+        out += std::format(" -DCMAKE_CXX_COMPILER_TARGET={}", target);
+    }
     fs::path absBuildDir = fs::absolute(cmakeBuildDir);
     out += std::format(" -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY={}", ShellQuote(absBuildDir.string()));
     out += std::format(" -DCMAKE_LIBRARY_OUTPUT_DIRECTORY={}", ShellQuote(absBuildDir.string()));
     return out;
 }
 
-std::string ConfigureCMake(const fs::path& cloneDir, const fs::path& cmakeBuildDir, std::span<const std::string> options) {
+std::string ConfigureCMake(const fs::path& cloneDir, const fs::path& cmakeBuildDir, std::span<const std::string> options, std::string_view target) {
     fs::path optionsFile = cmakeBuildDir / ".crafter-options";
     std::string optionsKey = JoinOptions(options);
 
@@ -148,7 +163,7 @@ std::string ConfigureCMake(const fs::path& cloneDir, const fs::path& cmakeBuildD
     std::string cmd = std::format("cmake -S {} -B {}{}",
         ShellQuote(fs::absolute(cloneDir).string()),
         ShellQuote(fs::absolute(cmakeBuildDir).string()),
-        BuildInjectedCMakeFlags(cmakeBuildDir));
+        BuildInjectedCMakeFlags(cmakeBuildDir, target));
     if (!options.empty()) {
         cmd += " ";
         cmd += optionsKey;
@@ -176,6 +191,7 @@ std::string BuildCMake(const fs::path& cmakeBuildDir) {
 
 ExternalBuildResult Crafter::BuildExternal(
         const ExternalDependency& dep,
+        std::string_view target,
         std::atomic<bool>& cancelled) {
     ExternalBuildResult result;
 
@@ -197,8 +213,8 @@ ExternalBuildResult Crafter::BuildExternal(
         }
     }
 
-    std::string keyMaterial = std::format("{}|{}|{}|{}",
-        dep.source.url, dep.source.branch, dep.source.commit, JoinOptions(dep.options));
+    std::string keyMaterial = std::format("{}|{}|{}|{}|{}",
+        dep.source.url, dep.source.branch, dep.source.commit, JoinOptions(dep.options), target);
     std::size_t key = std::hash<std::string>{}(keyMaterial);
     fs::path cloneDir = externalRoot / std::format("{}-{:016x}", name, key);
 
@@ -213,7 +229,7 @@ ExternalBuildResult Crafter::BuildExternal(
     fs::path cmakeBuildDir;
     if (dep.builder == ExternalBuilder::CMake) {
         cmakeBuildDir = cloneDir / "build";
-        if (std::string err = ConfigureCMake(cloneDir, cmakeBuildDir, dep.options); !err.empty()) {
+        if (std::string err = ConfigureCMake(cloneDir, cmakeBuildDir, dep.options, target); !err.empty()) {
             result.error = std::format("cmake configure for '{}': {}", name, err);
             return result;
         }