Upgrade Emscripten to 5.0.6

[krauthaufen]

Second-run Emsdk 5.0.6 + LLVM 23 toolchain bump — replay plan

Supersedes ~\dev\emsdk_plan_5.0.6.md and ~\dev\WSL-plan.md for execution.
The two old documents remain canonical for why decisions were made.
This document is the how for a clean restart that avoids every blind
alley the first run hit.

Goals and ground rules

• Start from upstream pins (the SHAs emscripten-releases ties together
  for the 5.0.6 release), not from existing dotnet fork tips.
• Produce one replayable, intent-organised set of _2 branches across
  six repos. Push only to pavelsavara/<repo> remotes; do not touch
  dotnet/<repo> remotes from this plan.
• Apply the dotnet engineering as intent-grouped commits (Arcade
  scaffolding / dotnet build patches / mono-LLVM API extensions / etc.)
  instead of mechanically replaying historical conflict resolutions.
• Reduce CodeQL/Component-Governance scan surface by deleting whole
  categories (tests, fuzzers, docs, examples, vendored fixtures,
  benchmarks, unused tooling). Each category is a separate commit on
  the upstream base, applied before the dotnet engineering commits,
  and each must keep the artefacts we ship buildable.
• Linux-x64 only this round. Other RIDs after linux-x64 is green.
• Long-lived interactive WSL shell is assumed open at ~/dev/. All
  repos are clones at ~/dev/<repo> (the user moved them from ~/work/).
• Build IDs match today: OfficialBuildId=20260503.2 →
  encoded 26253.2 (Arcade formula 26*1000 + 5*50 + 3 = 26253).
  Toolchain prerelease: 11.0.0-alpha.1.26253.2. Emsdk prerelease:
  11.0.0-preview.4.26253.2. LLVM prerelease: 23.1.0-alpha.1.26253.2.
• Do not push to dotnet/* remotes. Pavel reviews on
  pavelsavara/* before any upstream PR.

Upstream pins (same hashes that emscripten-releases tied to 5.0.6)

Read from chromium.googlesource.com/emscripten-releases/+/<5.0.6-tag>/DEPS
where <5.0.6-tag> = 1724b50443d92e23ef2a56abf0dc501206839cef.

Component	Upstream repo	Pinned SHA / version
llvm-project	llvm/llvm-project	bbeae6932d653b8a71a3a985af0ccf97e13e2e08
binaryen	WebAssembly/binaryen	54f9f7afa703ade4a34aa3291abbe237bb0cd8a4
emscripten	emscripten-core/emscripten	6ea9c28c38cdd40c1032fa04400c9d16230ee180 (= tag 5.0.6)
emsdk	emscripten-core/emsdk	tag 5.0.6
node	nodejs/node	v22.16.0 (= upstream emsdk default at 5.0.6)
cpython	python/cpython	v3.13.3 (= upstream emsdk Python at 5.0.6)
icu (this is a dotnet-only consumer; no upstream pin needed)	dotnet/icu dotnet/main tip	latest at start of work

v22.16.0 is the default emsdk install for 5.0.6 (24.7.0 was offered
but not default). The first run picked 24.7.0 and absorbed ~6044 merge
conflicts; the second run picks 22.16.0 to minimise that surface.

Branch naming (_2 suffix)

Repo	Base	New branch name
pavelsavara/llvm-project	upstream llvm-project bbeae6932d65	dotnet/main-23.x_2
pavelsavara/binaryen	upstream binaryen 54f9f7af	dotnet/main-bump-binaryen-5.0.6_2
pavelsavara/emscripten	upstream emscripten tag 5.0.6 (6ea9c28c)	dotnet/main-bump-emscripten-5.0.6_2
pavelsavara/emsdk	upstream emsdk tag 5.0.6	bump_to_5_0_6_2
pavelsavara/node	upstream node tag v22.16.0	dotnet/bump-node-22.16.0_2
pavelsavara/cpython	upstream cpython tag v3.13.3	bump-python-3.13.3_2
pavelsavara/icu	dotnet/icu dotnet/main tip	dotnet/bump-icu-llvm23_2
pavelsavara/runtime	dotnet/runtime main tip	dotnet/bump-llvm23-emsdk506_2

Conventions:

• <base> = first commit on the new branch matches the upstream pin
  exactly (no dotnet content yet).
• Followed by scan-area-reduction commits, one per category.
• Followed by dotnet engineering commits, grouped by intent.
• Followed by bump-specific commits (cgmanifest hash bumps, version
  files, eng/Versions.props updates).
• Tag the merge-base SHA with a local lightweight tag
  replay/upstream-base so future replays do not re-search for it.

Build/replay sequencing (dependency order)

LLVM 23 ────┐
             ├──→ Binaryen ──┐
Emscripten ─┘                ├──→ Emsdk ──→ Runtime smoke build
Node ───────────────────────┘            ↑
CPython ─────────────────────────────────┤
ICU (dotnet-only, depends on Emsdk) ─────┘

1. LLVM 23 unblocks the LLVM SDK transport (consumed by mono-LLVM in
   runtime) and is also a prerequisite for the libc++/libc++abi shared
   objects that emsdk's clang loads at runtime. Build first.
2. Binaryen 5.0.6 commit unblocks the binaryen transport package.
3. Emscripten 5.0.6 commit unblocks the Microsoft.NET.Runtime.Emscripten.5.0.6.Sdk
   transport. Has NO build dependency on LLVM/binaryen — those are
   consumed at emcc invocation time, not at emscripten pack time.
   Can therefore run in parallel with steps 1–2.
4. Node v22.16.0 unblocks Microsoft.NET.Runtime.Emscripten.5.0.6.Node transport.
5. CPython 3.13.3 unblocks Microsoft.NET.Runtime.Emscripten.5.0.6.Python transport.
6. Emsdk consumes the LLVM/Binaryen/Emscripten/Node/Python transports
   and produces the workload-installable Sdk packages.
7. ICU rebuilds against the new emsdk for the threading transport.
8. Runtime consumes everything; this is the smoke build.

Linux-x64 only this round. Step 1 is the long pole (~1 h); steps 2–5
are minutes each.

Scan-area reduction — categories applied as separate commits

Apply BEFORE dotnet engineering commits. One commit per category. Order
chosen so each commit alone keeps linux-x64 artefacts buildable.

For each category below, the deletion is a git rm -r --cached followed
by working-tree removal, then commit. After each commit, run a quick
grep -r for any reference from the keep-list to the delete-list and
either delete the reference or move the cited file into a "kept"
location. The keep-list is the set of files actually exercised by the
linux-x64 build path.

Category groups (per repo)

LLVM (dotnet/main-23.x_2)

1. Lit / unit tests: llvm/test, llvm/unittests, clang/test,
   clang/unittests, clang/INPUTS, lld/test, lld/unittests,
   mlir/test, mlir/unittests, flang/test, flang/unittests,
   polly/test, polly/unittests, compiler-rt/test,
   compiler-rt/unittests, libcxx/test, libcxxabi/test,
   bolt/test, bolt/unittests, lldb/test, lldb/unittests,
   libc/test, pstl/test, clang-tools-extra/test,
   clang-tools-extra/clangd/test, clang-tools-extra/clangd/unittests.
2. Fuzzers / corpora: llvm/utils/lit/tests/Inputs,
   clang/tools/clang-fuzzer, compiler-rt/lib/fuzzer/tests,
   compiler-rt/lib/fuzzer/test, compiler-rt/lib/sanitizer_common/tests,
   lld/COFF/InputFiles.cpp (fuzzer wiring lines only — surgical),
   clang/test/fuzzer, anything matching **/fuzz*/** outside our
   keep-list.
3. Docs & examples: llvm/docs, llvm/examples, clang/docs,
   clang/examples, lld/docs, mlir/docs, mlir/examples,
   flang/docs, flang/examples, lldb/docs, bolt/docs,
   polly/docs, clang-tools-extra/docs, libc/docs,
   compiler-rt/docs, pstl/docs.
4. Vendored test fixtures: llvm/utils/unittest/googletest,
   llvm/utils/unittest/googlemock,
   third-party/unittest,
   third-party/benchmark,
   clang/test/Driver/Inputs,
   any *goldens* directories.
5. Benchmarks: llvm/benchmarks, libc/benchmarks,
   mlir/benchmark, compiler-rt/lib/scudo/standalone/benchmarks.
6. Tooling we never ship: all of bolt/, flang/, mlir/,
   polly/, pstl/, libc/, clang-tools-extra/ (we ship clang and
   lld and the Mono LLVM libs; the rest is dead weight). Confirm with
   dotnet/llvm-project's eng/llvm-build.proj keep-list before
   deleting; if any are referenced by build, instead delete only the
   <subproj>/test, <subproj>/unittests, <subproj>/docs,
   <subproj>/examples, <subproj>/benchmarks subtrees from inside.

After each LLVM category commit, confirm the linux-x64 LLVM SDK pack
still produces clang-23, lld-23, llc, llvm-config, libc++, libc++abi
by running the eng/llvm-build.* proj from dotnet/llvm-project's
existing eng/.

Binaryen (dotnet/main-bump-binaryen-5.0.6_2)

1. Lit / unit tests: test/, scripts/test/.
2. Fuzzers: scripts/fuzz_*.py, fuzz/, all *.fuzz corpora.
3. Docs & examples: media/, *.md examples in test/example/
   (already covered by category 1; double-check after category 1).
4. Vendored fixtures: third_party/ if present (binaryen vendors
   gtest).
5. Benchmarks: none separate from test/; skip.
6. Unused tooling: auto_update_tests.py, check.py (not used by
   the dotnet pack).

Emscripten (dotnet/main-bump-emscripten-5.0.6_2)

1. Tests: test/ (all of it).
2. Fuzzers: tests/fuzzing (subfolder of test/ — covered by 1).
3. Docs & examples: site/, media/, top-level AUTHORS is kept;
   ChangeLog.md is kept (referenced by version checks).
4. Vendored fixtures: third_party/ (some test reference data).
5. Benchmarks: any tests/benchmark* (covered by 1).
6. Unused tooling: the tests/test_*.py runners (covered by 1).

Emsdk (bump_to_5_0_6_2)

1. Tests: test/.
2. Fuzzers: none.
3. Docs: docs/.
4. Vendored fixtures: bazel/test_external/,
   bazel/test_secondary_lto_cache/ (the bazel test scaffolding is
   not consumed by .NET pack).
5. Benchmarks: none.
6. Unused tooling: bazel/ entirely (we don't ship bazel).

Node (dotnet/bump-node-22.16.0_2)

1. Tests: test/, deps/v8/test/,
   deps/openssl/openssl/test/, deps/icu*/test/, deps/cares/test/,
   deps/zlib/test/, deps/uv/test/, deps/llhttp/test/.
2. Fuzzers: test/fuzzers/, deps/openssl/openssl/fuzz/,
   deps/v8/test/fuzzer/.
3. Docs: doc/api/, doc/changelogs/, doc/contributing/.
   Keep doc/node.1 only if shipped (we don't — drop).
4. Vendored fixtures: test/fixtures/ (covered by 1),
   deps/icu-small/'s test files only.
5. Benchmarks: benchmark/.
6. Unused tooling: tools/icu/icu_*.json test data,
   tools/eslint* (the arcade dotnet/node pack does not lint).

CPython (bump-python-3.13.3_2)

1. Tests: Lib/test/, Lib/idlelib/idle_test/,
   Lib/distutils/tests/, all Modules/_test* test extension modules.
2. Fuzzers: Modules/_xxsubinterpretersmodule.c (no, keep — used);
   Lib/test/fuzz_* (covered by 1).
3. Docs: Doc/.
4. Vendored fixtures: Misc/NEWS.d/ (changelog fragments),
   Lib/test/data (covered by 1).
5. Benchmarks: Tools/benchmarks if present, pyperformance data.
6. Unused tooling: Tools/peg_generator/ (used during build —
   KEEP), Tools/buildbot/ (delete), Tools/msi/ (Windows-only
   installer — delete on linux-x64 round; restore for win-x64 round),
   PCbuild/ we keep because the dotnet PCbuild patches live there.

ICU (dotnet/bump-icu-llvm23_2)

ICU is a dotnet-only consumer; no upstream test/doc deletions are
needed — they were already curated by the existing dotnet/icu
dotnet/main. Just branch and apply the LLVM-23 / Emsdk-5.0.6 build
fix commits.

Runtime (dotnet/bump-llvm23-emsdk506_2)

No test deletions on runtime — runtime tests are not currently in our
delete scope and runtime CI gates merge.

Per-category commit message template

del: drop <category> from <repo> for scan-area reduction

Scope: <list-of-paths>
Reason: not consumed by linux-x64 .NET workload artefacts.
Keep-list verification: ran `grep -r '<delete-pattern>' <keep-paths>`
   and either removed the references or migrated cited files.

Inventory of dotnet patches across repos (organised by intent)

Authoritative source (May 2026): the currently-shipping
Microsoft.NET.Runtime.Emscripten.3.1.56.* transports.
Their producing branches are listed in
dotnet/runtime eng/Version.Details.xml. The first-run bump
commits on dotnet/main-bump-* are derivative and may have
dropped or merged things in ways that obscure intent. They appear
below only as "Hints from first run" subsections. The
categorisation that follows is grounded in the cumulative file
diff between each baseline tip and its actual upstream merge-base.

Method

For each repo, we computed:

• Baseline tip = the commit cited by dotnet/runtime for the
  shipping transport (read from eng/Version.Details.xml).
• Upstream merge-base = git merge-base <baseline> <upstream-default-or-release-branch>
  using the upstream branch the dotnet fork was originally built from
  (release/19.x for LLVM, v18.x for node, 3.11 for cpython,
  upstream main for binaryen / emscripten / emsdk).
• File-status counts (Added / Modified / Deleted) from
  git diff --name-status <merge-base>..<baseline>.

The Modified column is partly polluted by upstream PRs the dotnet
fork absorbed via merges. The Added and Deleted columns are clean
signals of dotnet engineering. Bespoke source modifications are
extracted as a small explicit list below.

Cumulative dotnet patch surface (May 2026)

Repo	Baseline tip	Files Added	Modified	Deleted	Notes
dotnet/llvm-project dotnet/main-19.x	db9a80a3e25e	241	46	112	Most M = LLVM 19 backports; D = utils/ curation.
dotnet/binaryen dotnet/main	2a0b11e92886	474	879	241	Bulk of M = upstream binaryen PRs absorbed via merge.
dotnet/emscripten dotnet/main	20abfbfbfdab	785	2105	2659	Heavy curation already done (D=2659 in test/).
dotnet/emsdk dotnet/main	dotnet/main HEAD	190	3	5	Cleanest fork. Only emsdk_manifest.json, emsdk.py, .gitignore modified.
dotnet/node dotnet/main	cfe285c85ac6	805	342	4688	Massive curation: D=2857 in tools/, D=1274 in test/, D=555 in deps/.
dotnet/cpython dotnet/main	c845d5de9eac	185	4	0	Cleanest source surface. Only PCbuild/find_python.bat, prepare_libffi.bat, get_externals.bat and .gitignore modified.

Cross-cutting "Arcade scaffolding" intent (every repo)

Every fork adds the same set of files. This is a single intent
applied as a single commit per repo on the _2 branches.

Universal additions:

• eng/ directory (Arcade-managed; ~150–180 files per repo).
• Directory.Build.props, Directory.Build.targets.
• global.json, NuGet.config, .config/.
• build.cmd, build.sh.
• cgmanifest.json (with the upstream pin SHA).
• es-metadata.yml.
• <repo>.proj top-level Arcade entry point.
• .azuredevops/ (CI).
• .CodeQL.yml (most repos).
• .npmrc (repos that consume npm during build).

Universal modifications:

• .gitignore (extend for eng/, artifacts/ outputs).

Replay action (every repo): copy eng/ and root scaffolding from
the shipping baseline tip onto the new upstream pin as a single
"eng: dotnet Arcade scaffolding (from )" commit.

Per-repo authoritative inventory

LLVM 19 → 23 (dotnet/main-23.x_2)

Bespoke source modifications outside eng/ (54 paths). Top-level:
dir.common.props (added — <LLVMVersion> fallback), .CodeQL.yml,
llvm.proj, nuget/ (60 added — per-component nuget layout). Inside
llvm/: 40 modified + 4 added.

Intent	Replay action on LLVM 23
dir.common.props: <LLVMVersion> fallback	Apply (eng commit). Bump default to 23.1.0.
nuget/ per-component nuget layout	Apply (eng commit). Refresh MONO_llvm_*_libs lists for LLVM 23 (LLVMSandboxIR, LLVMFrontendDirective, LLVMFrontendAtomic, LLVMObjectYAML, LLVMCGData, LLVMDebugInfoGSYM, LLVMDebugInfoDWARFLowLevel, LLVMFrontendHLSL).
llvm/CMakeLists.txt set(MONO_API_VERSION 1900) → 2300 + llvm/include/llvm/Config/llvm-config.h.cmake #cmakedefine MONO_API_VERSION + llvm/tools/llvm-config/llvm-config.cpp --mono-api-version switch	Forward-port as separate commit "llvm: emit MONO_API_VERSION for mono mini". Value 2300. Without this, runtime needs the LLVM_VERSION_MAJOR * 100 shim.
llvm/include/llvm-c/Core.h LLVMMono1CallConv = 22 + llvm/include/llvm/IR/CallingConv.h Mono = 22	Forward-port as separate commit "llvm: reserve calling-convention slot 22 for Mono".
Other llvm/ modifications (38 files)	Examine each. Most are likely 19.x backports. For LLVM 23, drop any that are now upstream; forward-port the rest. List below.
branchClassification.yml 19.x → 23.x	Apply (eng commit).
azure-pipelines-codeql.yml 19.x → 23.x	Apply (eng commit).
Build-hygiene PR #568 (remove Dockerfile.android-emulator, add .npmrc for lldb-dap and tree-sitter-mlir)	Apply as "ci: build hygiene from PR #568".
utils/ 96 deletions, clang/ 2, libcxx/ 2, bolt/ 1, libc/ 1, polly/ 1	Apply as scan-area-reduction commits. Re-derive against LLVM 23 layout (some paths may have moved).

The 38 "other llvm/ modifications" need per-file review. Ask
before LLVM 23 replay: read each diff hunk; for each, decide:
(a) already upstream in 23, drop; (b) still needed,
forward-port; (c) patch needs rewrite for new code shape.

Hints from first run: dotnet/llvm-project dotnet/main-23.x
HEAD dbebea9bc3b5 is a single squash commit. Use as a
sanity-check — if a file is in the squash but not in dotnet/main-19.x
diff, the squash author guessed; verify against this authoritative
list.

Binaryen (dotnet/main-bump-binaryen-5.0.6_2)

Bespoke source modifications outside eng/. Most of the "260
bespoke" src/ paths from the diff are upstream binaryen PRs the
fork absorbed via merge — NOT bespoke dotnet engineering. The truly
bespoke set is much smaller:

Intent	Files	Replay action
Arcade scaffolding	(universal set above)	Apply (eng commit).
Build-system tweaks for arcade pack	CMakeLists.txt, check.py, binaryen.proj	Apply (eng commit).
.CodeQL.yml	root	Apply (eng commit).
eng/patches/*.patch (libc++ refresh + symlink preservation recipe at pack time)	eng/patches/	Apply as separate commit "binaryen: eng/patches set for libc++ refresh + symlink preservation". This recipe was the fix for the LLVM-23-era libc++ packaging problem.
Stale submodule gitlinks (binaryen has 3 in upstream that arcade pack chokes on)	.gitmodules	Apply as "binaryen: drop stale submodule gitlinks".
Source-level patches (Windows-portability fixes, etc.)	1c7cda99f0e "Fix stack-use-after-scope on Windows in Precompute (#6643)" and similar	Re-apply selectively against 5.0.6. Many will already be upstream; check each.
Test-area curation	test/ D=237 (diff vs merge-base), test/ M=676 (mostly upstream PRs)	The D=237 are the dotnet-side scan-area reduction. Re-derive against the 5.0.6 tree.

Hints from first run: PR dotnet/binaryen#355 re-applied 8
named patches against 54f9f7af. Use as a checklist; do not assume
all 8 are still needed against 5.0.6 — re-evaluate each.

Emscripten (dotnet/main-bump-emscripten-5.0.6_2)

This is the heaviest bespoke fork because of all the Windows shims.

Intent	Files	Replay action
Arcade scaffolding	(universal set)	Apply (eng commit).
*.bat Windows shims (~30 files)	em++.bat, emar.bat, emcc.bat, embuilder.bat, emcmake.bat, emconfigure.bat, emdump.bat, emdwp.bat, emmake.bat, emnm.bat, emprofile.bat, emranlib.bat, emrun.bat, emscons.bat, emsize.bat, emstrip.bat, emsymbolizer.bat, em-config.bat, bootstrap.bat	Apply as single commit "emscripten: Windows .bat shims for all em* commands".
*.py shell-wrapper modifications	em++.py, emar.py, embuilder.py, emcc.py, emcmake.py, emmake.py, emranlib.py, emstrip.py, emsymbolizer.py	Examine each diff. Most are upstream; the dotnet bits are usually small (e.g. CodeQL header re-attach, subprocess shell-quoting).
tools/shared.py subprocess shell-quoting fix for Windows	tools/shared.py	Apply as separate commit "emscripten: subprocess shell-quoting fix for Windows shells".
src/jsifier.mjs rename + dotnet CodeQL suppressions ported across rename	src/jsifier.mjs	Apply as separate commit "emscripten: re-attach CodeQL suppressions to renamed jsifier.mjs". (Upstream renamed .js → .mjs in the 4.0 series.)
system/ modifications (1312 M, 341 A)	system/	Almost entirely upstream evolution absorbed via merge. Do NOT replay these as patches — let the upstream 5.0.6 tree provide them.
system/ deletions (47 D)	system/	The dotnet-side scan-area reduction. Re-derive against 5.0.6 tree.
test/ deletions (2583 D)	test/	Largest scan-area reduction in any repo. Re-derive against 5.0.6 tree.
package-lock.json regeneration (npm audit fix)	root	Apply (eng commit) — will need fresh npm audit fix against 5.0.6's package.json.
Makefile, requirements-dev.txt, .eslintrc.yml, .flake8, .mypy.ini, .prettierrc.yml, .git-blame-ignore-revs, SECURITY.md, AUTHORS, ChangeLog.md modifications	root	Apply (eng commit) — small wholesale replacement from baseline.
emscripten-version.txt	root	Apply as separate commit "emscripten: bump emscripten-version.txt to 5.0.6".

Hints from first run: PR dotnet/emscripten#240 resolved 19
conflicts after a git replace --graft trick. The graft was
discarded; final merge has clean 2-parent ancestry. The 19
conflict files are a hint at where bespoke patches live — but the
authoritative list is the file-status diff above.

Emsdk (bump_to_5_0_6_2)

Smallest patch surface. Total bespoke source modifications: 3 files.

Intent	Files	Replay action
Arcade scaffolding	(universal set; eng/ 179 files added)	Apply (eng commit).
emsdk_manifest.json: keep dotnet's *-dotnet virtual entries; drop upstream concrete node 22.16.0, node-big-endian-crosscompile, python 3.13.3 real downloads, binaryen main 32/64bit, mingw 7.1.0, ninja git-release, 32-bit linux SDK row	emsdk_manifest.json	Apply as separate commit "emsdk: replace concrete tool downloads with dotnet virtual entries". Keep fork-only win/aarch64 releases SDK row. Update Python virtual entry's activated_env to lib/python3.13/site-packages/certifi/cacert.pem.
emsdk.py activation env tweaks (SSL_CERT_FILE, etc.)	emsdk.py	Apply (eng commit).
.gitignore	root	Apply (eng commit).
.npmrc	root	Apply (eng commit).
docker/ 5 deletions	docker/	Apply as scan-area-reduction commit.
Workload manifest pack ids (Microsoft.NET.Workload.Emscripten.Current.Manifest-11.0.100.Transport)	eng/Versions.props	Apply (eng commit).
emscripten-version.txt (NOT in emsdk; lives in dotnet/runtime's src/mono/browser/)	n/a here	Handled in runtime branch.

Hints from first run: bump_to_5_0_6 branch's
emsdk_manifest.json resolution is correct as currently committed;
take it.

Node v18 → v22.16.0 (dotnet/bump-node-22.16.0_2)

Massive curation, modest bespoke source surface.

Intent	Files	Replay action
Arcade scaffolding	(universal set; eng/ 176 files added)	Apply (eng commit).
<NodeFiles Remove="…" /> to strip helper exes from transport (corepack, npm test runners, npx shim variants, etc.)	eng/Versions.props or node.proj	Apply (eng commit) — review the Remove list against v22.16.0 layout.
common.gypi build-system tweaks	common.gypi	Apply as separate commit "node: common.gypi adjustments for arcade build". Examine diff hunk-by-hunk.
vcbuild.bat Windows build wrapper	vcbuild.bat	Apply as separate commit "node: vcbuild.bat hooks for arcade pack".
.CodeQL.yml	root	Apply (eng commit).
.npmrc	root	Apply (eng commit).
deps/ modifications (333 M, 555 D)	deps/	Almost entirely upstream evolution absorbed via merges. Most modifications will already be in v22.16.0. The deletes are scan-area reduction (vendored test data, fuzzers). Re-derive against v22 tree.
tools/ deletions (2857 D)	tools/	Largest tools curation in any repo (eslint test runners, ICU JSON test data, V8 test fixtures). Re-derive against v22 tree.
test/ 56 added, 1274 deleted	test/	Adds = small dotnet-side smoke checks; deletes = scan-area reduction. Re-derive deletes; cherry-pick the 56 adds.
src/node_version.h	inside src/ (not root)	Apply as separate commit "node: sync node_version.h to v22.16.0" (NODE_MAJOR_VERSION 22, MINOR 16, PATCH 0, IS_LTS=1 — note v22.16 IS LTS, unlike the first run's v24.7 IS_LTS=0).
Vendored vulnerability fixes (npm CVE upgrade, recursive eslint symlink, zlib test data zip, V8 tools/package.json, ICU CodeQL warnings, Windows build issues)	various inside deps/ and tools/	Re-evaluate each against v22.16.0. Run CodeQL/CG scan against the post-merge tree before pushing; re-apply only patches whose original finding still fires.
cgmanifest.json commitHash → v22.16.0 SHA	root	Apply (eng commit).

Hints from first run: PR dotnet/node#335 is the v18→v24 merge
(NOT v22). It dropped 7 superseded patches without CG re-scan. Use
its dropped-patch list (npm vuln upgrade, node#277/261/255/119/37/81/190)
as a re-evaluation checklist for v22.

CPython 3.11 → 3.13.3 (bump-python-3.13.3_2)

Cleanest source surface among the high-touch repos. Only 4 modified
files (3 PCbuild .bat + .gitignore).

Intent	Files	Replay action
Arcade scaffolding	(universal set; eng/ 170 files added)	Apply (eng commit).
PCbuild/find_python.bat, PCbuild/prepare_libffi.bat, PCbuild/get_externals.bat dotnet build patches	PCbuild/*.bat	Apply as separate commit "cpython: PCbuild dotnet build patches". (Linux-only first round won't exercise these but keep them — needed for win-x64 round.)
.CodeQL.yml, .gitignore	root	Apply (eng commit).
eng/Versions.props PythonHexVersion 0x030D03F0, PythonMajorVersion 3.13	eng/Versions.props	Apply (eng commit).
cgmanifest.json commitHash → v3.13.3 SHA	root	Apply (eng commit).
eng/launchscript.sh shebang python@3.11 → python@3.13	eng/launchscript.sh	Apply (eng commit).
PEP 594/632 module removal reconciliation	various deletes inside Lib/	Take upstream v3.13.3 as-is — no separate dotnet action.

Hints from first run: PR dotnet/cpython#210 did exactly this:
3 PCbuild patches + version props + cgmanifest + shebang. Confirms
the inventory above.

ICU (dotnet/bump-icu-llvm23_2)

ICU is a dotnet-only consumer (no upstream merge-base analysis
applies). Only consumed change-set is in eng/.

Intent	Files	Replay action
eng/icu.proj Emscripten pack references 3.1.56 → 5.0.6	eng/icu.proj	Apply as separate commit "icu: bump Emscripten transport pin to 5.0.6".
Versions.props matching property renames	eng/Versions.props	Apply (eng commit).
PatchEmscripten target + eng/patches/emcc.py	eng/icu.proj, eng/patches/emcc.py	Drop both this round. First-run smoke test confirmed no longer needed at Emscripten 5.0.6 with Node ≥ v18.3.0. Commit "icu: drop PatchEmscripten — no longer needed at Emscripten 5.0.6".
Threading transport build wiring (runtimes/browser-wasm-threads/)	eng/icu.proj	Apply (eng commit).

Runtime (dotnet/bump-llvm23-emsdk506_2)

Branch from current dotnet/runtime main. Only the bump commits;
no upstream merge.

Intent	Files	Replay action
eng/Versions.props + eng/Version.Details.{xml,props} linux-x64 nupkg version bumps	eng/Versions.props, eng/Version.Details.{xml,props}	"eng: bump LLVM 23 + Binaryen 5.0.6 + Emsdk 5.0.6 + Node 22.16.0 + Python 3.13.3 + ICU transports to 26253.2 (linux-x64 only)".
src/mono/browser/emscripten-version.txt → 5.0.6-git	src/mono/browser/emscripten-version.txt	Apply (combine with eng commit).
src/mono/CMakeLists.txt LLVM gate	src/mono/CMakeLists.txt	Keep aligned with upstream MONO_API_VERSION form, value 2300. Refresh MONO_llvm_*_libs lists. Drop the first-run LLVM_VERSION_MAJOR * 100 shim — superseded by the LLVM _2 branch's forward-port.
src/mono/mono/mini/mini-llvm.c deprecation pragma	src/mono/mono/mini/mini-llvm.c	Apply as separate commit "mono: silence LLVM 23 deprecated-decl warnings in mini-llvm.c". Pragma must appear BOTH before AND after the #include "llvm-c/Core.h" block.
src/mono/mono/mini/mini-llvm.c #define LLVMMono1CallConv 22 shim	src/mono/mono/mini/mini-llvm.c	Drop this round — superseded by the LLVM _2 branch's forward-port of the calling-convention slot.
src/mono/mono/mini/mini-llvm-cpp.cpp Intrinsic::getDeclaration → getOrInsertDeclaration rename guard	src/mono/mono/mini/mini-llvm-cpp.cpp	Apply as separate commit "mono: use Intrinsic::getOrInsertDeclaration on LLVM 22+". Two call sites; #if LLVM_API_VERSION >= 2000.

Per-repo replay strategy decision

The cumulative diff surface drives strategy:

Repo	Patch surface (bespoke / scaffolding)	Recommended strategy
emsdk	3 modified, ~190 added	Start fresh from upstream tag 5.0.6 + apply Arcade scaffolding + emsdk_manifest.json patch + emsdk.py patch. Clean slate.
cpython	4 modified, ~185 added	Start fresh from upstream v3.13.3 + apply Arcade scaffolding + 3 PCbuild .bat patches + version props. Clean slate.
llvm-project	46 modified, 241 added	Start fresh from upstream bbeae6932d65 + Arcade scaffolding + dir.common.props + nuget/ layout + 5 LLVM source patches (MONO_API_VERSION, LLVMMono1CallConv, plus 3 to-be-classified). Clean slate.
binaryen	879 modified (most upstream)	Merge-based. Start from dotnet/main baseline 2a0b11e928, merge in upstream 54f9f7af. Resolve conflicts by taking upstream for src/, test/ (modulo dotnet curation deletes), keeping dotnet for eng/, root scaffolding, and the small bespoke set. The "fresh from upstream" approach would require re-doing 237 test deletions and re-applying scattered Windows-portability fixes — too risky.
emscripten	2105 modified, 2659 deleted	Merge-based. Same reasoning as binaryen but more so. Start from dotnet/main baseline 20abfbfbf, merge in upstream tag 5.0.6. Resolve conflicts by taking upstream for system/, test/, keeping dotnet for eng/, all *.bat Windows shims, root scaffolding, tools/shared.py Windows fix, src/jsifier.mjs CodeQL re-attach.
node	342 modified, 4688 deleted	Merge-based. Same reasoning. Start from dotnet/main baseline cfe285c85a, merge in upstream tag v22.16.0. Resolve by taking upstream for deps/, test/, tools/ (modulo dotnet curation deletes), keeping dotnet for eng/, common.gypi, vcbuild.bat, root scaffolding. Run a CodeQL/CG scan against the resolved tree before pushing; re-evaluate the 7 first-run-dropped patches at that point.
icu	dotnet-only	Branch from dotnet/icu dotnet/main; apply 3-line emscripten version bump + drop PatchEmscripten.
runtime	bump only	Branch from dotnet/runtime main; apply version bumps + 3 mono mini source patches.

This revises the original plan's "fresh from upstream" stance.
For binaryen / emscripten / node it would have re-introduced merge
risk that the existing dotnet baseline already absorbed — wasteful.
For emsdk / cpython / llvm-project / icu / runtime the fresh start
remains the cleanest path.

Branch table — updated to reflect strategy split

Repo	Strategy	Base for _2 branch
pavelsavara/llvm-project	Fresh	upstream llvm-project bbeae6932d65
pavelsavara/binaryen	Merge-based	dotnet/binaryen dotnet/main (baseline 2a0b11e928)
pavelsavara/emscripten	Merge-based	dotnet/emscripten dotnet/main (baseline 20abfbfbf)
pavelsavara/emsdk	Fresh	upstream emsdk tag 5.0.6
pavelsavara/node	Merge-based	dotnet/node dotnet/main (baseline cfe285c85a)
pavelsavara/cpython	Fresh	upstream cpython tag v3.13.3
pavelsavara/icu	Bump-only	dotnet/icu dotnet/main tip
pavelsavara/runtime	Bump-only	dotnet/runtime main tip

---

Inventory of dotnet patches across repos (informative — first-run analysis)

The section below is the first-run analysis. It enumerated
patches by inspecting the dotnet/main-bump-* branches, which were
derived from the shipping baseline. The analysis above (grounded
in the cumulative file diff against the upstream merge-base) is
the authoritative version. Keep this section for cross-reference
on which intent maps to which historical commit.

Cross-cutting intents (every repo)

Intent	Action on _2 branches
Arcade/eng scaffolding (eng/ dir, Directory.Build.props/targets, global.json, NuGet.config, dir.common.props, azure-pipelines*.yml, Versions.props, Version.Details.{xml,props})	Apply as a single "eng: dotnet Arcade scaffolding" commit. Take the latest version of these files from the existing dotnet fork tip; there is no value in replaying their evolution.
cgmanifest.json (Component Governance manifest)	Apply as part of the eng commit, with the upstream SHA from this run's pin (already recorded in the table above).
es-metadata.yml	Apply as part of the eng commit.
Disabling AzDO dependabot (.github/dependabot.yml removal)	Apply as part of the eng commit.
Top-level <repo>.proj Arcade entry point (llvm.proj, binaryen.proj, cpython.proj, etc.)	Apply as part of the eng commit.

LLVM 23 (dotnet/main-23.x_2)

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
LLVMVersion.cmake MAJOR=23 plus dotnet MONO_API_VERSION rule	Apply as separate commit "llvm: emit MONO_API_VERSION for mono mini" — value 2300. Critical: this is the patch the first run failed to forward-port; mono mini in runtime needs it. Without it, runtime's src/mono/CMakeLists.txt falls back to a LLVM_VERSION_MAJOR * 100 shim. Touches llvm/CMakeLists.txt (set(MONO_API_VERSION 2300)), llvm/include/llvm/Config/llvm-config.h.cmake (#cmakedefine MONO_API_VERSION ${MONO_API_VERSION}), llvm/tools/llvm-config/llvm-config.cpp (add --mono-api-version switch).
LLVMMono1CallConv = 22 calling convention slot	Apply as separate commit "llvm: reserve calling-convention slot 22 for Mono". Touches llvm/include/llvm-c/Core.h (LLVMMono1CallConv = 22) and llvm/include/llvm/IR/CallingConv.h (Mono = 22). Without this, runtime's mini-llvm.c needs a #define LLVMMono1CallConv 22 shim.
dir.common.props LLVMVersion fallback 23.1.0	Apply (eng commit).
branchClassification.yml adds 23.x to prod-branches	Apply (eng commit).
azure-pipelines-codeql.yml → 23.x	Apply (eng commit).
PR #568 build-hygiene set: remove Dockerfile.android-emulator; add .npmrc for lldb-dap and tree-sitter-mlir	Apply as "ci: build hygiene from PR #568".
Mono-LLVM shared-libs cmake list (MONO_llvm_*_libs in mono mini's CMakeLists referenced from runtime — does NOT live in llvm-project; lives in runtime).	n/a here — handled in runtime branch.

Binaryen (dotnet/main-bump-binaryen-5.0.6_2)

The first run had 8 dotnet patches re-applied. By intent:

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
eng/patches/*.patch (binaryen's quilt-style patches consumed at pack time — preserve symlinks, libc++ refresh recipe, etc.)	Apply as separate commit "binaryen: eng/patches set for libc++ refresh and symlink preservation". This is the recipe that fixed the LLVM-23-era libc++ packaging problem.
cgmanifest.json SHA bump	Apply (eng commit) with 54f9f7af value.
Submodule gitlinks removal (binaryen has 3 stray submodule pointers)	Apply as "binaryen: drop stale submodule gitlinks".
Build-system tweaks for arcade pack	Apply (eng commit).

Emscripten (dotnet/main-bump-emscripten-5.0.6_2)

The first run hit 19 conflicts; the non-mechanical ones are the only
intents that need explicit replay:

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
src/jsifier.mjs rename + dotnet CodeQL suppression headers ported across the rename	Apply as separate commit "emscripten: re-attach CodeQL suppressions to renamed jsifier.mjs".
embuilder.py upstream additions absorbed	Apply (eng commit) — this is fully upstream code now.
tools/shared.py subprocess fix for emar/emcc on Windows shells	Apply as separate commit "emscripten: subprocess shell-quoting fix for windows".
emar.bat / emcc.bat / emcmake.bat shims	Apply (eng commit).
ChangeLog.md reconciliation	Skip — no need to replay. Take upstream as-is.

Emsdk (bump_to_5_0_6_2)

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
emsdk_manifest.json: keep dotnet's *-dotnet virtual entries for llvm, node, python, emscripten, binaryen	Apply as separate commit "emsdk: replace concrete tool downloads with dotnet virtual entries". Drop upstream's concrete entries (node 22.16.0, node 24.7.0, node-big-endian-crosscompile, python 3.13.3 real downloads, binaryen main 32/64bit, mingw 7.1.0, ninja git-release). Drop upstream's 32-bit linux main SDK entry. Keep the fork-only win/aarch64 releases SDK row. Update the Python virtual entry's activated_env to lib/python3.13/site-packages/certifi/cacert.pem.
emscripten-version.txt consumed by runtime to pin the expected emsdk	Apply as separate commit "emsdk: bump emscripten-version pin to 5.0.6-git".
Workload manifest ids in eng/Versions.props (Microsoft.NET.Runtime.Emscripten.5.0.6.{Cache,Sdk,Node,Python})	Apply (eng commit).
emsdk.py activation env tweaks (SSL_CERT_FILE etc)	Apply (eng commit).
Workload manifest pack (Microsoft.NET.Workload.Emscripten.Current.Manifest-11.0.100.Transport)	Apply (eng commit).

Node (dotnet/bump-node-22.16.0_2)

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
<NodeFiles Remove="…" /> to strip helper exes from the transport (corepack, npm test runners, npx shim variants)	Apply (eng commit) — review the Remove list against v22.16.0 layout (the v18→v24 first-run drift is moot here since we're at v22).
src/node_version.h synced to 22.16.0 (NODE_MAJOR_VERSION/MINOR/PATCH, IS_LTS)	Apply as separate commit "node: sync node_version.h to v22.16.0".
cgmanifest.json commitHash → upstream v22.16.0 SHA	Apply (eng commit).
Re-evaluate the 7 dotnet patches the first run dropped: vendored npm CVE upgrade; node#277 recursive eslint symlink; node#261 zlib test data zip CodeQL; node#255 V8 tools/package.json; node#119, node#37, node#81, node#190 Windows build issues / ICU CodeQL	Action this round: apply all that still match v22.16.0 layout cleanly. Run a CodeQL scan against the resulting branch BEFORE pushing; any patch whose original CodeQL finding no longer fires gets a commit "node: remove dotnet patch X — superseded by upstream Y". The first run dropped these wholesale to get a green build; the second run is more rigorous.

CPython (bump-python-3.13.3_2)

Intent	Action
Arcade scaffolding	Apply (cross-cutting).
PCbuild/find_python.bat, PCbuild/prepare_libffi.bat, PCbuild/get_externals.bat dotnet-side patches	Apply as separate commit "cpython: PCbuild dotnet build patches". (Linux-only first run does not exercise these; keep them in tree because they survived auto-merge in the first run and we will need them for win-x64 round.)
eng/Versions.props PythonHexVersion 0x030D03F0, PythonMajorVersion 3.13	Apply (eng commit).
cgmanifest.json commitHash bump	Apply (eng commit).
eng/launchscript.sh shebang python@3.11 → python@3.13	Apply (eng commit).
PEP 594/632 module removal reconciliation	Take upstream as-is — no separate dotnet action.

ICU (dotnet/bump-icu-llvm23_2)

Intent	Action
eng/icu.proj Emscripten pack references 3.1.56 → 5.0.6 (3 lines)	Apply as separate commit "icu: bump Emscripten transport pin to 5.0.6".
Versions.props matching property renames	Apply (eng commit).
PatchEmscripten target + eng/patches/emcc.py	Action this round: drop both. First-run smoke test confirmed the pinned emcc.py patch is no longer needed at Emscripten 5.0.6 with Node ≥ v18.3.0 (the experimental-wasm-threads shim was the only reason for it). Commit "icu: drop PatchEmscripten — no longer needed at Emscripten 5.0.6".
Threading transport build wiring (runtimes/browser-wasm-threads/)	Apply (eng commit).

Runtime (dotnet/bump-llvm23-emsdk506_2)

Branch from current dotnet/runtime main. Apply only the bump
commits — no upstream merge:

Intent	Commit
eng/Versions.props + eng/Version.Details.{xml,props} linux-x64 nupkg version bumps	"eng: bump LLVM 23 + Binaryen 5.0.6 + Emsdk 5.0.6 + Node 22.16.0 + Python 3.13.3 + ICU transports to 26253.2 (linux-x64 only)".
src/mono/browser/emscripten-version.txt → 5.0.6-git	"mono: bump pinned emscripten version" (combine with eng commit if convenient).
src/mono/CMakeLists.txt LLVM gate: parse MONO_API_VERSION from llvm-config --mono-api-version	Action this round: the LLVM _2 branch above forward-ports the MONO_API_VERSION patch, so this file should NOT need the LLVM_VERSION_MAJOR * 100 shim that the first run committed. Keep the file aligned with the upstream MONO_API_VERSION form, value 2300. Refresh the four MONO_llvm_*_libs lists (LLVM 23 added LLVMSandboxIR, LLVMFrontendDirective, LLVMFrontendAtomic, LLVMObjectYAML, LLVMCGData, LLVMDebugInfoGSYM, LLVMDebugInfoDWARFLowLevel, LLVMFrontendHLSL).
src/mono/mono/mini/mini-llvm.c deprecation pragma	Apply as separate commit "mono: silence LLVM 23 deprecated-decl warnings in mini-llvm.c". The pragma must appear BOTH before AND after the #include "llvm-c/Core.h" block — LLVM headers internally pragma push/pop and reset suppression otherwise. Do not omit the second pragma; the first run wasted a build cycle on this.
src/mono/mono/mini/mini-llvm.c #define LLVMMono1CallConv 22 shim	Action this round: drop. The LLVM _2 branch forward-ports the calling-convention slot, so the runtime fallback is unnecessary.
src/mono/mono/mini/mini-llvm-cpp.cpp Intrinsic::getDeclaration → getOrInsertDeclaration rename guard	Apply as separate commit "mono: use Intrinsic::getOrInsertDeclaration on LLVM 22+". Two call sites; gate with #if LLVM_API_VERSION >= 2000.

Replay recipe (linux-x64, from cold, ~/dev/)

Assumes:

• Long-lived WSL session at ~/dev/.
• Each ~/dev/<repo> is a clone with pavelsavara and the upstream
  remote already added.
• ~/dev/.nuget/ will receive transports as they build.

Step 1 — Set up branches from upstream pins

cd ~/dev/llvm-project
git fetch llvm bbeae6932d653b8a71a3a985af0ccf97e13e2e08
git switch -c dotnet/main-23.x_2 bbeae6932d653b8a71a3a985af0ccf97e13e2e08
git tag replay/upstream-base
# (later) cherry-pick scan-area-reduction commits
# (later) cherry-pick dotnet engineering commits

cd ~/dev/binaryen
git fetch upstream 54f9f7afa703ade4a34aa3291abbe237bb0cd8a4
git switch -c dotnet/main-bump-binaryen-5.0.6_2 54f9f7afa703ade4a34aa3291abbe237bb0cd8a4
git tag replay/upstream-base

cd ~/dev/emscripten
git fetch emscripten-core 6ea9c28c38cdd40c1032fa04400c9d16230ee180
git switch -c dotnet/main-bump-emscripten-5.0.6_2 6ea9c28c38cdd40c1032fa04400c9d16230ee180
git tag replay/upstream-base

cd ~/dev/emsdk
git fetch emscripten-core tag 5.0.6
git switch -c bump_to_5_0_6_2 5.0.6
git tag replay/upstream-base

cd ~/dev/node
git fetch nodejs tag v22.16.0
git switch -c dotnet/bump-node-22.16.0_2 v22.16.0
git tag replay/upstream-base

cd ~/dev/cpython
git fetch python tag v3.13.3
git switch -c bump-python-3.13.3_2 v3.13.3
git tag replay/upstream-base

cd ~/dev/icu
git fetch dotnet dotnet/main
git switch -c dotnet/bump-icu-llvm23_2 dotnet/dotnet/main
# no replay/upstream-base tag — already a dotnet branch

cd ~/dev/runtime
git fetch dotnet main
git switch -c dotnet/bump-llvm23-emsdk506_2 dotnet/main

Step 2 — Apply scan-area-reduction commits (per repo, by category)

For each repo, in order, run the deletions and verify the keep-list
references. Pseudo-template:

cd ~/dev/<repo>
# Category 1: tests
git rm -rf <test-paths>
# verify nothing in keep-list references the deleted paths
grep -r --line-number '<deleted-pattern>' <keep-paths> || true
git commit -F <(printf 'del: drop tests from <repo> for scan-area reduction\n\nScope: <paths>\nReason: not consumed by linux-x64 artefacts.\n')
# Category 2: fuzzers
# ... etc

Step 3 — Apply dotnet engineering commits (intent-grouped)

For each repo, cherry-pick or hand-author the commits per the inventory
table above. Order: cross-cutting eng/Arcade commit first, then the
intent-specific commits.

For LLVM specifically, the historical "Initial dotnet engineering for
LLVM 23" squash on dotnet/main-23.x is a useful starting point — but
after the scan-area-reduction commits, not before. Cherry-pick its
file deltas after re-basing onto the post-deletion tree.

Step 4 — Build and pack each transport (linux-x64)

In dependency order. Each step writes a nupkg into ~/dev/.nuget/.

# 1. LLVM 23
cd ~/dev/llvm-project
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 2. Binaryen
cd ~/dev/binaryen
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 3. Emscripten (parallel-safe with 1 and 2)
cd ~/dev/emscripten
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 4. Node
cd ~/dev/node
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 5. CPython
cd ~/dev/cpython
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 6. Emsdk (consumes 1–5)
cd ~/dev/emsdk
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 7. ICU (consumes Emsdk)
cd ~/dev/icu
./build.sh -ci -pack -c Release \
  /p:OfficialBuildId=20260503.2 \
  /p:TargetRid=linux-x64

# 8. Runtime smoke
cd ~/dev/runtime
./build.sh mono+libs -os browser -c Debug 2>&1 | tee ~/work/runtime-build.log

After step 8, Microsoft.NETCore.App.Runtime.Mono.browser-wasm.11.0.0-dev.nupkg
should appear in the runtime artifact tree, mirroring the first run's
green outcome.

Step 5 — Smoke-test a sample app

The first run validated with a simple sample app (Hello, Browser!).
Repeat that here as the gate for "linux-x64 round complete".

Step 6 — Push to pavelsavara/<repo> only

for r in llvm-project binaryen emscripten emsdk node cpython icu runtime; do
  ( cd ~/dev/$r && git push pavelsavara HEAD )
done

Do not open PRs to dotnet/<repo> from this plan. Pavel reviews
the pavelsavara/<repo> branches first.

Blind-alley safety net (lessons from first run)

These are listed in emsdk_plan_5.0.6.md "Session notes 2026-05-03"
already; reproduced here so this single document is replay-complete.

1. emscripten-version.txt is checked-in. Bump in lockstep with
   the emsdk version.
2. AcquireEmscriptenSdk.targets only re-extracts when the dir is
   absent. Always rm -rf src/mono/browser/emsdk after bumping
   EmsdkPackageVersion.
3. MONO_API_VERSION patch must be forward-ported to dotnet/main-23.x —
   this round does it (separate commit). Skip the runtime-side
   LLVM_VERSION_MAJOR * 100 shim entirely.
4. LLVMMono1CallConv = 22 patch must be forward-ported —
   this round does it. Skip the runtime-side #define LLVMMono1CallConv 22
   shim entirely.
5. The deprecation pragma in mini-llvm.c must be repeated AFTER the
   LLVM include block. Do not rely on a single pragma above the
   includes.
6. Intrinsic::getDeclaration was renamed to getOrInsertDeclaration
   in LLVM 22. Two call sites in mini-llvm-cpp.cpp.
7. PowerShell mangles multi-line git commit -m. Use
   git commit -F <msgfile> with a file pre-converted with
   tr -d '\r'.
8. Bare git diff HEAD and git stash on /mnt/d/<repo> hang.
   Always run from ~/dev/<repo> (ext4) or scope to specific paths.
9. Two upstream packaging bugs to fix at the source this round, not
   hand-patch:
   • LLVM 23 SDK linux-x64 nupkg missing libc++.so.1 and
     libc++abi.so.1 symlinks. Fix in eng/llvm-build.proj pack step
     (preserve .so.1 symlinks alongside .so.1.0).
   • Emsdk 5.0.6 Sdk.linux-x64 nupkg ships stale LLVM-19-era libc++
     missing __hash_memory. Mirror the binaryen eng/patches recipe:
     pull libc++.so.1.0 / libc++abi.so.1.0 from the LLVM 23 SDK
     transport during emsdk pack.
   • Each fix lands as a commit on the corresponding _2 branch under
     "binaryen / emsdk: refresh libc++ from LLVM 23 SDK at pack time".

Out of scope this round

• Pushing to public dotnet/<repo> remotes.
• RIDs other than linux-x64.
• Threaded WASM smoke test.
• Mono mini port to InContext APIs.
• Workload manifest publishing for installation via dotnet workload install.

Open follow-ups (for round 3 and beyond)

• Other RIDs (linux-arm64, linux-musl-x64/arm64, osx-x64/arm64,
  win-x64/arm64).
• Re-evaluate the 7 dropped Node patches against v22.16.0 with a
  CodeQL/CG scan; either re-apply or document why upstream supersedes.
• Threaded WASM build (WasmEnableThreads=true) and the
  runtimes/browser-wasm-threads/ ICU output.
• Workload manifest rebuild
  (Microsoft.NET.Workload.Emscripten.Current.Manifest-11.0.100.Transport).
• Mono mini port to InContext APIs (drops the deprecation pragma
  entirely).

[dotnet-policy-service]

Tagging subscribers to 'arch-wasm': @lewing
See info in area-owners.md if you want to be subscribed.

[vulkan101]

I'd like to look at contributing to this, as I also have a need for updated emscripten version (bugs around memory growth with MEMORY64 option are resolved in 4.0.5).
From "Upgrading Emscripten" in the "Build WebAssembly" readme, bumping Emscripten version involves these steps:

• update https://github.com/dotnet/runtime/blob/main/src/mono/wasm/emscripten-version.txt
• bump emscripten versions in docker images in https://github.com/dotnet/dotnet-buildtools-prereqs-docker
• bump emscripten in https://github.com/dotnet/emsdk
• bump docker images in https://github.com/dotnet/icu, update emscripten files in eng/patches/
• update version number in docs
• update Microsoft.NET.Runtime.Emscripten.<emscripten version>.Node.win-x64 package name, version and sha hash in https://github.com/dotnet/runtime/blob/main/eng/Version.Details.xml and in https://github.com/dotnet/runtime/blob/main/eng/Versions.props. the sha is the commit hash in https://github.com/dotnet/emsdk and the package version can be found at https://dev.azure.com/dnceng/public/_packaging?_a=feed&feed=dotnet6
• update packages in the workload manifest https://github.com/dotnet/runtime/blob/main/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in

Do I need to do all the above for a local test? The "Build WebAssembly" doc is actually referenced by the "Building Mono" readme, and appears to be specific to mono. If someone could outline what I'd need to do in addition to/instead of this that would really help.

[lewing]

cc @radekdoulik @akoeplinger