wasm-idle 1.1.0 → 1.1.2

package/README.md

@@ -25,6 +25,33 @@ Verified downloads can be retained across reloads using a version-pinned, capaci
 CacheStorage/IndexedDB cache. See [persistent asset cache configuration and coverage](docs/runtime-asset-cache.md)
 for global/per-call opt-out, cleanup and prefetch APIs.
 
+## Getting started
+
+You need Node.js `^22.22.2`, `^24.15.0`, or `>=26.0.0`, and pnpm 12.9.1. These come from the root
+`package.json` `engines` and `packageManager` fields, and `.npmrc` sets `engine-strict=true`.
+`.tool-versions` pins Node.js 24.20.0 for asdf/mise.
+
+```bash
+pnpm install
+pnpm dev
+```
+
+`pnpm dev` builds the public workspace packages, then starts Vite with the cross-origin isolation
+headers that `SharedArrayBuffer` requires. The app is served under the `/wasm-idle` base path, for
+example `http://localhost:5173/wasm-idle/`.
+
+Most runtime assets are checked in under `static/`. Some compiler payloads are gitignored and must
+be prepared locally before those languages can run:
+
+- `pnpm run prepare:test-assets` downloads the pinned Clang (with its matching clangd), OCaml,
+  C3, LFortran, Lean 4, and Common Lisp payloads. Pass group names, for example
+  `-- clang ocaml`, to prepare only some of them.
+- `pnpm run prepare:wasm-debug-release` adds the LLDB debug runtime. Without it, C, C++, and
+  `wasm32-wasip1` Rust debug sessions use the trace fallback.
+
+Other runtimes are refreshed from their producers with the `sync:*` scripts described under
+[Monorepo layout](#monorepo-layout).
+
 ## Language support policy
 
 wasm-idle language support must run user code through the real language implementation in the
@@ -218,6 +245,7 @@ multi-module guests, and Rust WASI Preview 2/3 debugging remain outside the supp
 
 ```sh
 cd ../wasm-llvm
+WASM_LLVM_CLANG_ARTIFACT_DIR=/path/to/verified-clang-artifacts \
 WASM_LLVM_LLDB_ARTIFACT_DIR=/path/to/lldb-artifacts \
 WASM_LLVM_WAMR_ARTIFACT_DIR=/path/to/wamr-artifacts \
 pnpm prepare:clang-release
@@ -227,9 +255,16 @@ WASM_RUST_PRODUCER_OUTPUT_ROOT=/path/to/rust-producer-output \
 pnpm --dir runtimes/wasm-rust build:producer
 pnpm sync:wasm-rust
 pnpm sync:wasm-debug ../wasm-llvm/out/clang-browser
-WASM_IDLE_BROWSER_SERVER_MODE=dev pnpm test:browser:debug:lldb
+pnpm test:browser:debug:lldb
 ```
 
+The Clang artifact directory must contain the verified build receipt and its matching raw-input
+identities. The producer rejects historical artifacts without that evidence when assembling a new
+release. For the already reviewed bundled debugger, use `pnpm prepare:wasm-debug-release` in
+`wasm-idle` to install the immutable release selected by the tracked profile.
+The browser command uses the qualified preview path; development-server LLDB qualification is
+tracked separately.
+
 The synchronized manifest rejects missing hashes, incompatible Clang/LLDB revisions, and stale
 worker sidecars. The strict browser test covers real C, C++, and Rust breakpoint, step, output, and
 termination paths and rejects trace fallback or a missing debug asset. The Rust producer build is
@@ -257,10 +292,10 @@ variables or import SvelteKit modules.
 | Malbolge<br>`MALBOLGE`             | Original Ben Olmstead interpreter, TryItOnline/malbolge b0869870 (public domain), compiled with WASI SDK 33                                                                    | Runs the original 59049-cell ternary and self-modifying interpreter; source-file input is separate from byte stdin/stdout; EOF stores 59048; requires at least two non-whitespace source bytes                                                                                                                                                                                                                                                                                                                                                                          | `runtimeAssets.rootUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed interpreter argv; prepare compiles the runtime without executing or validating the source                                                                                                                                                                                |
 | Whitespace<br>`WHITESPACE`         | koturn/Whitespace 22a57aab (MIT), compiled with WASI SDK 33                                                                                                                    | Runs the upstream Whitespace 0.3 interpreter with a documented divisor-guard correction, copy/slide, heap, labels, calls and signed 32-bit integers; character/numeric stdin and exact stdout; character EOF is -1; source limit 65535 UTF-8 bytes                                                                                                                                                                                                                                                                                                                      | `runtimeAssets.rootUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed interpreter argv; prepare compiles the runtime without executing or validating the source                                                                                                                                                                                |
 | C3<br>`C3`                         | wasm-llvm/c3-browser: C3 0.8.3 / LLVM 22.1.8                                                                                                                                   | Verified c3c and builtin LLD compile real C3 in a fresh browser Worker; UTF-8 env.readByte/env.writeByte ABI and exported main; std::io and WASI unavailable                                                                                                                                                                                                                                                                                                                                                                                                            | `runtimeAssets.c3.baseUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed compiler flags and bounded Wasm memories                                                                                                                                                                                                                              |
-| C<br>`C`                           | @wasm-idle/llvm-core@1.1.0 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang` for `wasm32-wasi`; default `-std=gnu11`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                        |
-| C++<br>`CPP`                       | @wasm-idle/llvm-core@1.1.0 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                           | `clang++` for `wasm32-wasi`; default `-std=gnu++20`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                           | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cppVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                      |
-| Objective-C<br>`OBJC`              | GNUstep libobjc2 v2.3 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.1.0                                                                                        | `clang -x objective-c -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi`; links `libobjc.a`, `libgnustep-base.a`, and `libffi.a` when Foundation is imported; Foundation headers are inlined from `foundation-headers.json`; includes a constructor wrapper for Objective-C class registration; auto-compiles `.m`/`.mm`/`.c` workspace files; trace debug instruments active source and uses wasm-idle controls; supports `stdin` and `programArgs`; large Objective-C assets may be served as gzip-only `.gz` files through the service worker or worker fallback | `runtimeAssets.objectivec.baseUrl`/`libobjcUrl`/`headersUrl`/`libgnustepBaseUrl`/`libgnustepBaseObjectUrl`/`foundationHeadersUrl`/`libffiUrl` or `PUBLIC_WASM_OBJECTIVEC_*`; `runtimeAssets.clang.baseUrl`/`loader` for the clang toolchain; `activePath`, `workspaceFiles`, `compileArgs`, `debug`, `breakpoints`, `pauseOnEntry`               |
-| Objective-C++<br>`OBJECTIVECXX`    | Same GNUstep libobjc2 v2.3 + libc++ assets as Objective-C from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.1.0; no extra compiler assets                                 | `clang -x objective-c++ -std=gnu++20 -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi` with libc++ headers; active file defaults to `main.mm`; links `libobjc.a` (plus GNUstep Base and `libffi.a` when Foundation is imported); auto-compiles `.mm`/`.m`/`.c` workspace files; supports `stdin` and `programArgs`; trace debugging is not supported                                                                                                                                                                                                               | Shares `runtimeAssets.objectivec` and `runtimeAssets.clang` with Objective-C; `activePath`, `workspaceFiles`, `compileArgs`, `programArgs`                                                                                                                                                                                                       |
+| C<br>`C`                           | @wasm-idle/llvm-core@1.0.11 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                          | `clang` for `wasm32-wasi`; default `-std=gnu11`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                        |
+| C++<br>`CPP`                       | @wasm-idle/llvm-core@1.0.11 / Clang 22.1.8 WASI sysroot from the `wasm-llvm` producer                                                                                          | `clang++` for `wasm32-wasi`; default `-std=gnu++20`; LLDB mode compiles untouched source with embedded DWARF at `-g -O0` and runs it in WAMR; normal runs still use the browser WASI host; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                           | `runtimeAssets.clang.baseUrl`/`loader` or `rootUrl`; `compileArgs`, `programArgs`, `cppVersion`, `activePath`, `workspaceFiles`, `debugMode`, `breakpoints`, `pauseOnEntry`                                                                                                                                                                      |
+| Objective-C<br>`OBJC`              | GNUstep libobjc2 v2.3 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.11                                                                                       | `clang -x objective-c -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi`; links `libobjc.a`, `libgnustep-base.a`, and `libffi.a` when Foundation is imported; Foundation headers are inlined from `foundation-headers.json`; includes a constructor wrapper for Objective-C class registration; auto-compiles `.m`/`.mm`/`.c` workspace files; trace debug instruments active source and uses wasm-idle controls; supports `stdin` and `programArgs`; large Objective-C assets may be served as gzip-only `.gz` files through the service worker or worker fallback | `runtimeAssets.objectivec.baseUrl`/`libobjcUrl`/`headersUrl`/`libgnustepBaseUrl`/`libgnustepBaseObjectUrl`/`foundationHeadersUrl`/`libffiUrl` or `PUBLIC_WASM_OBJECTIVEC_*`; `runtimeAssets.clang.baseUrl`/`loader` for the clang toolchain; `activePath`, `workspaceFiles`, `compileArgs`, `debug`, `breakpoints`, `pauseOnEntry`               |
+| Objective-C++<br>`OBJECTIVECXX`    | Same GNUstep libobjc2 v2.3 + libc++ assets as Objective-C from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.11; no extra compiler assets                                | `clang -x objective-c++ -std=gnu++20 -fobjc-runtime=gnustep-2.0 -fblocks` for `wasm32-wasi` with libc++ headers; active file defaults to `main.mm`; links `libobjc.a` (plus GNUstep Base and `libffi.a` when Foundation is imported); auto-compiles `.mm`/`.m`/`.c` workspace files; supports `stdin` and `programArgs`; trace debugging is not supported                                                                                                                                                                                                               | Shares `runtimeAssets.objectivec` and `runtimeAssets.clang` with Objective-C; `activePath`, `workspaceFiles`, `compileArgs`, `programArgs`                                                                                                                                                                                                       |
 | Python<br>`PYTHON3`                | static ESM `static/pyodide/pyodide.mjs` / pyodide@314.0.7                                                                                                                      | loads `pyodide.mjs`, `pyodide.asm.mjs`, `pyodide.asm.wasm`, and `python_stdlib.zip` from the configured static asset tree on demand; supports `stdin`, workspace files, and trace debugging                                                                                                                                                                                                                                                                                                                                                                             | `runtimeAssets.python.baseUrl`/`loader` or `rootUrl`; `stdin`, `activePath`, `workspaceFiles`, `debug`, `breakpoints`, `pauseOnEntry`, `debugPath`                                                                                                                                                                                               |
 | Befunge-93<br>`BEFUNGE93`          | catseye/Befunge-93 8fe4065c (BSD-3-Clause), compiled with WASI SDK 33                                                                                                          | Runs the original interpreter with an 80 by 25 wrapping playfield, signed 32-bit stack, string mode and self-modifying p/g instructions; character and integer stdin share the WASI terminal; character EOF is -1                                                                                                                                                                                                                                                                                                                                                       | `runtimeAssets.rootUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed quiet argv; prepare compiles the runtime without executing or validating the source                                                                                                                                                                                      |
 | Brainfuck<br>`BRAINFUCK`           | susam/bfc b1b92fc (MIT), compiled with WASI SDK 33                                                                                                                             | Runs the pinned upstream interpreter in a browser Worker with a fresh read-only source filesystem; 30000 wrapping 8-bit cells, UTF-8 byte stdin/stdout, EOF sets the cell to zero                                                                                                                                                                                                                                                                                                                                                                                       | `runtimeAssets.rootUrl`, `stdin`, `activePath`, `workspaceFiles`; fixed interpreter argv; prepare compiles the runtime without executing or validating the source                                                                                                                                                                                |
@@ -306,9 +341,9 @@ variables or import SvelteKit modules.
 | Haskell<br>`HASKELL`               | ghc-in-browser / GHC 9.14.0.20251031 WASI rootfs                                                                                                                               | loads `dyld.mjs`, `rootfs.tar.zst`, `bsdtar.wasm`; `compileArgs` become GHC args, otherwise legacy `args` become GHC args                                                                                                                                                                                                                                                                                                                                                                                                                                               | `runtimeAssets.haskell.moduleUrl`/`rootfsUrl`/`bsdtarUrl`; `mainSoPath`, `searchDirs`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                            |
 | LFortran<br>`LFORTRAN`             | receipt-pinned `wasm-llvm/producer/lfortran-browser` artifacts in `static/wasm-lfortran`                                                                                       | real LFortran 0.65.0-97-gab867a23 LLVM evaluator compiles and executes Emscripten side modules in a fresh Worker; shared-ring stdin supports delayed READ and EOF; experimental Fortran feature coverage                                                                                                                                                                                                                                                                                                                                                                | `runtimeAssets.lfortran.baseUrl` relocates the reviewed bundle; `stdin`, `activePath`, workspace data/include files, cancellation and execution limits; no program arguments or multi-file module build orchestration                                                                                                                            |
 | Lean 4<br>`LEAN4`                  | receipt-pinned `wasm-llvm/producer/lean-browser` release downloaded from its immutable commit into `static/wasm-lean4`                                                         | real Lean 4.34.1 frontend and IR interpreter (`lean --run`) built for wasm32 Emscripten with pthreads; imports a wasm32 `Init` library compiled by that build; shared-ring stdin supports interactive `getLine` and EOF                                                                                                                                                                                                                                                                                                                                                 | `runtimeAssets.lean4.baseUrl` relocates the reviewed bundle; `stdin`, program arguments, `activePath`, cancellation and execution limits; single-file programs importing `Init` only (no `Std`/`Lean` imports or Lake packages)                                                                                                                  |
-| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.1.0                                                                                                | runs `f2c.wasm` in WASI, compiles generated C with the llvm-core Clang host, links `libf2c.a`, then executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.fortran.baseUrl`/`f2cWasmUrl`/`libf2cUrl`/`f2cHeaderUrl`/`analyzerUrl` or `PUBLIC_WASM_FORTRAN_*`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                        |
-| COBOL<br>`COBOL`                   | GnuCOBOL 3.2 + GMP 6.3.0 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.1.0                                                                                     | native gzip delivery for the frontend Wasm and filesystem tar assets; translates free-format COBOL with the real GnuCOBOL `cobc` frontend, compiles the generated C with the llvm-core Clang host, links libcob/GMP, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                              | `runtimeAssets.cobol.baseUrl` or `PUBLIC_WASM_COBOL_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                           |
-| V<br>`V`                           | V 0.5.2 compiler, vlib and WASI C sysroot assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.1.0                                                                    | native gzip delivery for the compiler Wasm and filesystem tar assets; translates V to C with the real V compiler (built from the upstream `vc` bootstrap for WASI), compiles the generated C with the llvm-core Clang host, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                       | `runtimeAssets.v.baseUrl` or `PUBLIC_WASM_V_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                                   |
+| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.0.11                                                                                               | runs `f2c.wasm` in WASI, compiles generated C with the llvm-core Clang host, links `libf2c.a`, then executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.fortran.baseUrl`/`f2cWasmUrl`/`libf2cUrl`/`f2cHeaderUrl`/`analyzerUrl` or `PUBLIC_WASM_FORTRAN_*`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                        |
+| COBOL<br>`COBOL`                   | GnuCOBOL 3.2 + GMP 6.3.0 assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.11                                                                                    | native gzip delivery for the frontend Wasm and filesystem tar assets; translates free-format COBOL with the real GnuCOBOL `cobc` frontend, compiles the generated C with the llvm-core Clang host, links libcob/GMP, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                              | `runtimeAssets.cobol.baseUrl` or `PUBLIC_WASM_COBOL_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                           |
+| V<br>`V`                           | V 0.5.2 compiler, vlib and WASI C sysroot assets from the `wasm-llvm` producer + @wasm-idle/llvm-core@1.0.11                                                                   | native gzip delivery for the compiler Wasm and filesystem tar assets; translates V to C with the real V compiler (built from the upstream `vc` bootstrap for WASI), compiles the generated C with the llvm-core Clang host, and executes the resulting WASI module with `stdin` and `programArgs`                                                                                                                                                                                                                                                                       | `runtimeAssets.v.baseUrl` or `PUBLIC_WASM_V_BASE_URL`; `runtimeAssets.clang.baseUrl`/`loader` for the C backend; `activePath`, `workspaceFiles`, `compileArgs`                                                                                                                                                                                   |
 | R<br>`R`                           | versioned static `static/webr/<hash>/webr.js` / webr@0.6.0                                                                                                                     | loads the browser ESM entry `webr.js` and its WebR runtime files from the configured static asset tree on demand; supports `stdin`, `programArgs`, and workspace files                                                                                                                                                                                                                                                                                                                                                                                                  | `runtimeAssets.r.baseUrl` or `PUBLIC_WASM_R_BASE_URL`; `stdin`, `programArgs`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                                    |
 | Octave<br>`OCTAVE`                 | Octave 10.3.0 (octave-10.3.0-pl5321h996e327_3.tar.bz2)                                                                                                                         | Octave CLI Emscripten worker; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `runtimeAssets.octave.baseUrl`/`workerUrl`/`manifestUrl` or `PUBLIC_WASM_OCTAVE_*`                                                                                                                                                                                                                                                               |
 | DuckDB<br>`DUCKDB`                 | static ESM `static/wasm-duckdb/runtime.mjs` produced from @duckdb/duckdb-wasm@1.33.1-dev57.0                                                                                   | selects the best DuckDB-Wasm MVP/EH bundle on demand and creates a fresh in-memory database per run; `stdin` is registered as `stdin.txt` and `/dev/stdin` rather than terminal stdin                                                                                                                                                                                                                                                                                                                                                                                   | `runtimeAssets.duckdb.moduleUrl` or `PUBLIC_WASM_DUCKDB_MODULE_URL` or `rootUrl`; `stdin`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                        |
@@ -353,19 +388,25 @@ toolchains can be consumed from pinned external runtime repositories:
 - `packages/react`: React hooks around `@wasm-idle/core`.
 - `packages/vue`: Vue composables around `@wasm-idle/core`.
 - `packages/node`: Node.js host helpers for Node-capable sandbox loaders.
-- `runtimes/*`: imported runtime/compiler packages such as `wasm-rust`,
-  `wasm-of-js-of-ocaml`, `wasm-go`, `wasm-dotnet`, `wasm-typescript`,
-  `wasm-wat`, `wasm-lua`, `wasm-lisp`, `wasm-elixir`, `wasm-tcl`, `wasm-awk`,
-  `wasm-forth`, `wasm-j`, `wasm-bqn`, `wasm-janet`,
-  `pyodide`, `teavm`, `assemblyscript`, `ruby`, `r`, and `js-sandbox`.
+- `runtimes/*`: imported runtime/compiler packages `wasm-rust`, `wasm-of-js-of-ocaml`, `wasm-go`,
+  `wasm-d`, `wasm-dotnet`, `wasm-typescript`, `wasm-wat`, `wasm-lua`, `wasm-lisp`, `wasm-elixir`,
+  `wasm-awk`, `wasm-bash`, `wasm-clojurescript`, `pyodide`, `teavm`, `ruby`, `r`, and
+  `js-sandbox`. `wasm-pascal` holds the pas2js compiler wrapper sources and is not a workspace
+  package.
+- `runtimes/esolangs`: pinned upstream interpreter sources and licenses for the esoteric
+  languages. `pnpm build:esolangs` and the Aheui, APECode, and GolfScript sync scripts turn them
+  into `static/wasm-<language>/` assets.
 - `runtimes/wasm-tinygo`: the public `TINYGO` browser compiler consumer plus an explicitly labeled
   legacy AST-to-C development harness. Static releases publish only the receipt-verified upstream
   consumer and its source-pinned toolchain assets.
+- `runtimes/wasm-kotlin` and `runtimes/wasm-scala`: internal compiler candidates. They are not
+  registered playground languages or workspace packages.
 - `producers/wasm-php`: standalone, locked producer for the checked-in PHP 8.4 page asset. It is
   outside the root workspace and is never published as an npm package.
-- `static/wasm-zig`, `static/wasm-haskell`, `static/wasm-julia`, and `static/wasm-nim`: bundled browser runtime and
-  compiler assets synced from
-  upstream asset builds rather than local workspace packages.
+- `static/wasm-zig`, `static/wasm-haskell`, `static/wasm-julia`, `static/wasm-nim`,
+  `static/wasm-tcl`, `static/wasm-forth`, `static/wasm-j`, `static/wasm-bqn`, and
+  `static/wasm-janet`: bundled browser runtime and compiler assets synced from upstream asset
+  builds rather than local workspace packages.
 
 Deployment builds retain both legacy `.gz` and canonical `.gz.bin` URLs by default.
 After building and compressing the page, `pnpm run compact:build-runtimes` reports
@@ -388,9 +429,24 @@ pnpm sync:runtime list
 pnpm sync:runtimes
 ```
 
-The runtime sync scripts default to `runtimes/<name>/dist`; optional source and target arguments are
-for alternate build directories inside the current checkout. PHP is the exception:
-`sync:wasm-php` consumes `producers/wasm-php/dist` or `WASM_IDLE_WASM_PHP_DIST`.
+`pnpm sync:runtime list` prints every runtime the wrapper knows. It marks `manual` runtimes, which
+`pnpm sync:runtimes` skips unless `--include-manual` is passed, and `source-required` runtimes,
+which need an explicit source directory and never run from `sync:runtimes`.
+
+Default sources differ by runtime:
+
+- Runtimes with sources under `runtimes/`, such as `wasm-go`, `wasm-d`, `wasm-dotnet`,
+  `wasm-lua`, `wasm-wat`, `wasm-typescript`, `wasm-lisp`, `wasm-awk`, `wasm-pascal`, and
+  `wasm-bash`, read `runtimes/<name>/dist`.
+- Some read an installed npm package, such as `webr` or `swipl-wasm`.
+- Some download a pinned upstream release, such as Tcl, Perl, and Octave.
+- Julia and Nim re-verify the checked-in assets and download their pinned release only when those
+  assets are missing.
+- J, BQN, and Janet prefer a sibling checkout and otherwise reuse the checked-in assets.
+- Rust, TinyGo, and ClojureScript re-verify and redeploy the checked-in `static/` snapshot.
+
+The optional `[sourceDir] [targetDir]` arguments override these defaults. `sync:wasm-php` is not
+part of the wrapper; it consumes `producers/wasm-php/dist` or `WASM_IDLE_WASM_PHP_DIST`.
 
 Published packages are built in workspace dependency order. Before publishing, run:
 
@@ -415,7 +471,7 @@ opaque, receipt-pinned storage paths; these files are deployed page assets, not
 contents.
 
 PHP is built independently under `producers/wasm-php`, with its own lockfile and exact
-`@php-wasm/web-8-4@3.1.34` and `@php-wasm/universal@3.1.34` dependencies. Refresh the checked-in
+`@php-wasm/web-8-4@3.1.57` and `@php-wasm/universal@3.1.57` dependencies. Refresh the checked-in
 page asset only when changing that producer:
 
 ```bash
@@ -477,15 +533,26 @@ cd wasm-idle
 pnpm run sync:wasm-julia
 ```
 
-Nim browser execution uses the `benagastov/Nim-WASM-Compiler` asset pipeline under
+Nim compiler preparation is owned by `wasm-llvm/producer/nim-browser`; the pinned
+`benagastov/Nim-WASM-Compiler` distribution is delivered under
 `static/wasm-nim/`: Nim 2.2.4 compiled to WebAssembly emits C, then bundled clang/lld WebAssembly
-assets link a runnable WASI module. Refresh the vendored worker/runtime assets with:
+assets link a runnable WASI module. Package the compiler artifacts with the producer,
+then publish the verified bundle and current consumer Worker:
 
 ```bash
-cd wasm-idle
-pnpm run sync:wasm-nim
+# In wasm-llvm: migrate existing verified assets or select a pinned upstream source.
+pnpm package:nim -- --from-runtime /path/to/wasm-idle/static/wasm-nim --out out/nim-browser
+# In wasm-idle:
+pnpm sync:wasm-nim /path/to/wasm-llvm/out/nim-browser
 ```
 
+D compiler source patches, porting probes and artifact packaging live in
+`wasm-llvm/producer/d-browser`. Import its verified output through
+`WASM_LLVM_D_ARTIFACT_DIR` when building `runtimes/wasm-d`; see [the D browser integration](docs/d-browser.md).
+C3 and LFortran continue using their existing `wasm-llvm` producers. Compiler preparation for
+these four paths belongs to the producer repository, while execution and cache ownership belong
+to `wasm-idle`.
+
 ## Rust browser integration
 
 The demo app publishes the workspace `wasm-rust` compiler as a receipt-pinned executable graph
@@ -627,7 +694,8 @@ are bounded and verified against the exact expanded size and SHA-256.
 
 The preparer rejects source or target paths outside their configured roots, checks each redirect
 before following it, writes atomically, and reuses only matching files. With no group argument,
-it prepares both the Clang delivery bundle and the complete OCaml browser compiler graph.
+it prepares the Clang delivery bundle with its matching clangd assets, the complete OCaml browser
+compiler graph, and the C3, LFortran, Lean 4, and Common Lisp payloads.
 `WASM_IDLE_TEST_ASSET_BASE_URL` can select a compatible mirror with the same receipt-verified bytes.
 For protected local browser tests, provide `WASM_IDLE_TEST_BYPASS_COOKIE` through the environment
 in `dev_bypass_waf=<value>` form; the browser cookie jar scopes it to the test origin. Asset
@@ -786,8 +854,8 @@ and other workspace `.sql` files run first. Preloaded stdin is exposed as the se
 `/dev/blob` (`COPY t FROM '/dev/blob'` or `pg_read_file('/dev/blob')`). Override the module with
 `PUBLIC_WASM_POSTGRESQL_MODULE_URL` or `runtimeAssets.postgresql.moduleUrl`.
 PHP dynamically imports the checked-in `static/wasm-php/runtime.mjs` output from the standalone
-`producers/wasm-php` build. That producer pins `@php-wasm/web-8-4@3.1.34` and
-`@php-wasm/universal@3.1.34`. It always creates PHP 8.4; there is no version field or
+`producers/wasm-php` build. That producer pins `@php-wasm/web-8-4@3.1.57` and
+`@php-wasm/universal@3.1.57`. It always creates PHP 8.4; there is no version field or
 environment-based version selector. Override only the module location with
 `PUBLIC_WASM_PHP_MODULE_URL` or `runtimeAssets.php.moduleUrl`. A custom host must serve the entry's
 sibling chunks and assets with compatible CORS and cross-origin isolation headers; a cross-origin
@@ -855,6 +923,9 @@ the Rust worker:
 
 - `wasm32-wasip1` runs as preview1 core wasm through `@bjorn3/browser_wasi_shim`
 - `wasm32-wasip2` runs as a preview2 component through `preview2-shim` plus transpiled `jco` output
+- `wasm32-wasip3` also returns a component and runs on the same preview2 path. This works only
+  while emitted components keep transitional WASIp2 imports; preview3 imports are rejected until a
+  browser preview3 shim exists
 
 C-family compilation remains hosted by `@wasm-idle/llvm-core`, while Rust delegates artifact
 execution to `wasm-rust` so the selected target and returned artifact format stay aligned.
@@ -917,7 +988,9 @@ const runtimeAssets: PlaygroundRuntimeAssets = {
 		stdlibUrl: 'https://cdn.example.com/wasm-zig/std.tar.gz'
 	},
 	lisp: {
-		moduleUrl: 'https://cdn.example.com/wasm-lisp/index.js'
+		moduleUrl: 'https://cdn.example.com/wasm-lisp/index.js',
+		manifestUrl: 'https://cdn.example.com/wasm-lisp/runtime-manifest.v2.json',
+		manifestFingerprint: '<runtime-manifest-fingerprint>'
 	},
 	haskell: {
 		moduleUrl: 'https://cdn.example.com/wasm-haskell/dyld.mjs',
@@ -926,7 +999,9 @@ const runtimeAssets: PlaygroundRuntimeAssets = {
 	},
 	nim: {
 		baseUrl: 'https://cdn.example.com/wasm-nim/',
-		workerUrl: 'https://cdn.example.com/wasm-nim/runner-worker.js'
+		workerUrl: 'https://cdn.example.com/wasm-nim/runner-worker.js',
+		// Complete identity and receipt bundle for the served bytes; see below.
+		...nimTrustBundle
 	}
 };
 ```
@@ -934,12 +1009,22 @@ const runtimeAssets: PlaygroundRuntimeAssets = {
 Static module overrides such as PHP's `moduleUrl` identify an entry module, not a self-contained
 file. Mirror its complete sibling asset tree at the same relative paths. Cross-origin asset hosts
 must provide compatible CORS and COEP/CORP headers and cannot rely on wasm-idle's same-origin gzip
-service worker.
+service worker. The checkout stores several files from the example above only as `.gz`, for
+example `wasm-zig/zig_small.wasm.gz`, `wasm-wat/index.js.gz`, `wasm-lisp/index.js.gz`, and
+`wasm-haskell/bsdtar.wasm.gz`. A host for those URLs must return the decompressed bytes, either as
+a decompressed file or as that `.gz` served with `Content-Encoding: gzip`; Zig's `std.tar.gz` is
+served as stored.
 
 Verified static runtimes such as Janet and Julia intentionally omit URL-only examples: a custom
 `baseUrl`, `manifestUrl`, or `workerUrl` must be accompanied by every identity and asset-receipt
 field declared by that runtime's asset config, including the matching `workerReceipt`. Partial
-trust bundles fail closed instead of borrowing receipts from bundled executable bytes.
+trust bundles fail closed instead of borrowing receipts from bundled executable bytes. In the Nim
+entry above, `nimTrustBundle` stands for `profileId`, `artifactRevision`, `nimRevision`,
+`llvmRevision`, `memfsRevision`, `emscriptenRevision`, `manifestFingerprint`, `manifestReceipt`,
+`nimJavaScriptReceipt`, `nimWasmReceipt`, `nimbaseReceipt`, `clangJavaScriptReceipt`,
+`clangWasmReceipt`, `lldWasmReceipt`, `memfsWasmReceipt`, `sysrootReceipt`, and `workerReceipt`. An
+explicit Nim `manifestUrl` must be `runtime-manifest.v2.json?v=<manifestFingerprint>` under
+`baseUrl`. A `rootUrl` mirror of the bundled Nim files needs no `nim` entry.
 
 The bundled C/C++ app uses receipt-pinned Clang language sysroots: C initially downloads only the
 C base, while C++ or a mixed/opaque-language build loads the C++ add-on before compiling or linking.
@@ -990,8 +1075,8 @@ The pack contains the same locked upstream files, not an import-based subset. Ea
 ### Retaining compiler caches across editor navigation
 
 Create one `createRuntimeSession(assets)` owner per browser application and use
-`session.createBinding()` for each editor or execution panel. C/C++ and Python
-keep immutable compiler/runtime modules outside their disposable execution Workers:
+`session.createBinding()` for each editor or execution panel. Clang consumers, Rust,
+TinyGo, D, C3, Nim, LFortran and Python share a bounded owner for verified assets and compiler modules:
 
 ```ts
 import { createRuntimeSession } from 'wasm-idle';
@@ -1005,12 +1090,14 @@ await panel.dispose(); // close this panel; retain the session's cache
 
 const nextPanel = session.createBinding(); // another problem, same language
 await nextPanel.load('PYTHON');
-await session.selectLanguage('CPP'); // release old-language panels and cache
+await session.selectLanguage('CPP'); // release old-language panels; retain verified assets
 await session.dispose(); // full, terminal release of this owner
 ```
 
-Selecting a language does not download assets. The owner retains only one language;
-selecting an unsupported/server-only language also releases the previous cache.
+Selecting a language does not download assets. Only the selected language keeps active
+execution leases; verified compiler assets survive language changes until LRU eviction
+or session disposal. Selecting an unsupported/server-only language releases active leases
+without clearing the session's verified assets.
 Executions never share mutable Wasm instances, user files or stdin. C/C++ additionally
 reuse compiled programs when source, workspace and compiler options match, while
 custom loaders and debugging retain the original execution path. Python still creates
@@ -1019,7 +1106,23 @@ a fresh interpreter after `clear()`; module reuse does not eliminate interpreter
 The asset cache is LRU-bounded to 64 entries and 256 MiB of logical asset bytes
 (not a measurement of the browser engine's compiled-code memory). C/C++ program
 artifacts are independently bounded to 8 entries and 32 MiB. `getCacheStats()` exposes
-cache counters for diagnostics. Other languages currently keep their existing lifecycle.
+cache counters for diagnostics. COBOL, Fortran, V and Objective-C/Objective-C++ connect
+their Clang asset bridges to this same owner. Rust, TinyGo, D, C3, Nim and LFortran use one-shot MessagePorts
+to request compiler modules from the session after checking the pinned artifact receipt.
+The host verifies the bytes again before returning a module, including on cache hits.
+Nim also passes verified Clang, LLD and MemFS modules to its nested compiler Worker.
+C3 partitions its transformed compiler by the configured memory cap; LFortran shares
+its compiler module while generating fresh dynamic side modules in each execution.
+Cache identities include artifact receipts, authorization profiles and compilation
+settings; TinyGo also separates the memory-cap transformation used for each toolchain.
+
+`@wasm-idle/core` exports `WorkerSession`, `RuntimeAssetCache` and the
+`createRuntimeWasmModuleService` / `serveRuntimeWasmModule` / `requestRuntimeWasmModule`
+helpers for hosts implementing the same ownership model. Cancelling one request closes
+its subscription without terminating another request that uses the same immutable
+module. Compiler instances, linear memory, files and compiler helper threads remain
+owned by individual jobs; this cache does not combine the LLVM binaries embedded in
+different toolchains.
 
 ### Optional idle runtime prewarming
 

package/dist/playground/assetBridge.js

@@ -201,20 +201,22 @@ const expectedAssetsForRuntime = (runtime, languageSysroots = false) => {
     }
     return assets;
 };
-const integrityKey = (config) => JSON.stringify(Object.entries(config.integrity || {})
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([asset, entry]) => [
-    asset,
-    typeof entry === 'string'
-        ? entry
-        : {
-            sha256: entry.sha256,
-            bytes: entry.bytes,
-            mediaType: entry.mediaType,
-            uncompressedSha256: entry.uncompressedSha256,
-            uncompressedBytes: entry.uncompressedBytes
-        }
-]));
+// Read the contract fields directly: valid receipts can use inherited or hidden getters.
+const snapshotIntegrityEntry = (receipt) => typeof receipt === 'string'
+    ? receipt
+    : Object.freeze({
+        sha256: receipt.sha256,
+        bytes: receipt.bytes,
+        mediaType: receipt.mediaType,
+        uncompressedSha256: receipt.uncompressedSha256,
+        uncompressedBytes: receipt.uncompressedBytes
+    });
+const integrityKey = (config) => {
+    const integrity = config.integrity || {};
+    return JSON.stringify(Object.getOwnPropertyNames(integrity)
+        .sort((left, right) => left.localeCompare(right))
+        .map((asset) => [asset, snapshotIntegrityEntry(integrity[asset])]));
+};
 const allowedBaseUrlsKey = (config) => JSON.stringify([...(config.allowedBaseUrls || [])].sort());
 class RuntimeLoadProgress {
     samples = new Map();
@@ -550,7 +552,6 @@ export class WorkerAssetBridge {
         const generation = this.generation;
         const controller = new AbortController();
         const progress = this.progress;
-        const context = this.captureLoadContext();
         const receiveProgress = (event) => {
             if (controller.signal.aborted || generation !== this.generation)
                 return;
@@ -561,15 +562,33 @@ export class WorkerAssetBridge {
                 progress.activity(event.phase, event.asset);
             }
         };
-        const loadContext = (report) => ({
-            ...context,
-            progress: {
-                update: (asset, loaded, total) => report({ kind: 'download', asset, loaded, total }, `download:${asset}`),
-                activity: (phase, asset) => report({ kind: 'activity', asset, phase }, `activity:${asset}`)
+        // A rebind to the same worker aborts this load, but that worker still awaits a reply.
+        const replySuperseded = () => {
+            if (this.state !== 'active' || this.worker !== worker)
+                return;
+            try {
+                worker.postMessage({
+                    assetResponse: {
+                        id: request.id,
+                        ok: false,
+                        error: `Runtime asset ${request.asset} request was superseded by a rebind`
+                    }
+                });
             }
-        });
+            catch {
+                // The worker may already be terminated.
+            }
+        };
         this.activeLoads.add(controller);
         try {
+            const context = this.captureLoadContext();
+            const loadContext = (report) => ({
+                ...context,
+                progress: {
+                    update: (asset, loaded, total) => report({ kind: 'download', asset, loaded, total }, `download:${asset}`),
+                    activity: (phase, asset) => report({ kind: 'activity', asset, phase }, `activity:${asset}`)
+                }
+            });
             this.validateAssetRequest(loadContext(receiveProgress), request.asset);
             const identity = [
                 this.runtime,
@@ -650,7 +669,7 @@ export class WorkerAssetBridge {
                     });
                 }
                 if (controller.signal.aborted || generation !== this.generation)
-                    return;
+                    return replySuperseded();
                 worker.postMessage({ assetResponse: { id: request.id, ok: true, module } });
                 return;
             }
@@ -659,7 +678,7 @@ export class WorkerAssetBridge {
                 this.pythonPackageAssets = readPythonPackageAssets(loaded.bytes);
             }
             if (controller.signal.aborted || generation !== this.generation)
-                return;
+                return replySuperseded();
             const buffer = transferBuffer(loaded.bytes, this.cache ? false : loaded.transferOwnership);
             worker.postMessage({
                 assetResponse: {
@@ -672,7 +691,7 @@ export class WorkerAssetBridge {
         }
         catch (error) {
             if (controller.signal.aborted || generation !== this.generation)
-                return;
+                return replySuperseded();
             try {
                 worker.postMessage({
                     assetResponse: {
@@ -691,8 +710,24 @@ export class WorkerAssetBridge {
         }
     }
     captureLoadContext() {
+        const config = { ...this.config };
+        const integrity = config.integrity;
+        // Cache identity and verification must observe the same receipt, even if a caller
+        // updates its configuration while an asynchronous asset load is in progress.
+        // The built-in Clang map and its receipts are frozen; its identity also selects
+        // verified streaming, so only caller-owned maps need a new snapshot.
+        if (integrity && integrity !== BUNDLED_CLANG_ASSET_INTEGRITY) {
+            config.integrity = Object.freeze(Object.fromEntries(
+            // Authorization accepts own map entries regardless of enumerability.
+            Object.getOwnPropertyNames(integrity).map((asset) => [
+                asset,
+                snapshotIntegrityEntry(integrity[asset])
+            ])));
+        }
+        if (config.allowedBaseUrls)
+            config.allowedBaseUrls = [...config.allowedBaseUrls];
         return {
-            config: { ...this.config },
+            config,
             maxAssetBytes: this.maxAssetBytes,
             expectedAssets: new Set(this.expectedAssets),
             pythonPackageAssets: new Set(this.pythonPackageAssets),
@@ -743,6 +778,7 @@ export class WorkerAssetBridge {
             throw runtimeAssetAbortReason(signal);
         if (this.runtime === 'python' && asset === 'pyodide-lock.json')
             readPythonPackageAssets(runtimeBytes);
+        await loaded.persist?.();
         return {
             bytes: runtimeBytes,
             mimeType: loaded.mimeType,
@@ -768,8 +804,10 @@ export class WorkerAssetBridge {
             if (!signal.aborted)
                 context.progress.update(asset, loaded, total);
         };
-        if (context.config.loader) {
-            const pendingResult = Promise.resolve(context.config.loader({
+        // Do not expose the private verification context as a custom loader's receiver.
+        const loader = context.config.loader;
+        if (loader) {
+            const pendingResult = Promise.resolve(loader({
                 runtime: this.runtime,
                 asset,
                 reportProgress,
@@ -930,7 +968,8 @@ export class WorkerAssetBridge {
                     'bridge-v1',
                     context.config.baseUrl,
                     allowedBaseUrlsKey(context.config),
-                    maxAssetBytes
+                    maxAssetBytes,
+                    expected?.mediaType
                 ])
             }
             : undefined;
@@ -943,13 +982,44 @@ export class WorkerAssetBridge {
             if (bytes) {
                 requireRuntimeAssetSize(asset, bytes.byteLength, maxAssetBytes);
                 context.progress.update(asset, bytes.byteLength, bytes.byteLength);
-                return { bytes, mimeType: receipt?.mediaType, transferOwnership: true };
+                // A hit was validated against this same expected MIME type before it was stored.
+                return {
+                    bytes,
+                    mimeType: expected?.mediaType ?? receipt?.mediaType,
+                    transferOwnership: true
+                };
             }
         }
         const loaded = await this.fetchAssetFromNetwork(context, url, asset, signal, maxAssetBytes);
+        if (receipt) {
+            // Verify even when storage is disabled, unavailable or skipped. A body that the browser
+            // HTTP-decoded and that lost its gzip header is checked against the logical receipt.
+            const decoded = !!loaded.contentEncoding && !(loaded.bytes[0] === 0x1f && loaded.bytes[1] === 0x8b);
+            if (decoded && receipt.uncompressedSha256 !== undefined) {
+                await verifyRuntimeAssetIntegrity({
+                    asset,
+                    bytes: loaded.bytes,
+                    expected: {
+                        sha256: receipt.sha256,
+                        uncompressedSha256: receipt.uncompressedSha256,
+                        uncompressedBytes: receipt.uncompressedBytes
+                    },
+                    stage: 'uncompressed'
+                });
+            }
+            else if (!decoded || !asset.endsWith('.gz')) {
+                // Unpaired receipts for other assets already describe their logical bytes.
+                await verifyRuntimeAssetIntegrity({
+                    asset,
+                    bytes: loaded.bytes,
+                    expected: { sha256: receipt.sha256, bytes: receipt.bytes }
+                });
+            }
+            // A decoded .gz body with an unpaired receipt is left to runtime validation.
+        }
         if (identity && !loaded.contentEncoding) {
-            // Only checksum-matching bytes are published. Existing runtime validation still runs.
-            await writePersistentRuntimeAsset({
+            // A hit skips the response MIME check, so publish only bytes that passed it.
+            loaded.persist = () => writePersistentRuntimeAsset({
                 identity,
                 cache: persistentCache,
                 signal,
@@ -1177,6 +1247,11 @@ export class WorkerAssetBridge {
         if (url.hash) {
             throw new Error(`Runtime asset ${asset} URL must not include a fragment`);
         }
+        // The prefix check below sees `/base/..%2fother` as inside `/base/`, but a server that
+        // decodes the separator before resolving dot segments serves `/other`.
+        if (/%2f|%5c/iu.test(url.pathname)) {
+            throw new Error(`Runtime asset ${asset} URL must not include encoded path separators`);
+        }
         const allowed = [context.config.baseUrl, ...(context.config.allowedBaseUrls || [])].some((baseUrl) => {
             let base;
             try {

package/dist/playground/assets.d.ts

@@ -663,12 +663,12 @@ export interface ResolvedZigRuntimeAssetConfig {
     integrity: ZigExecutionAssetReceipts;
 }
 export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.mjs", "pyodide.asm.mjs", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
-export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
+export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compiler.wasm-deobfuscator.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
 export declare const CLANG_RUNTIME_LOAD_ASSETS: readonly ["runtime-manifest.v1.json", "bin/memfs.wasm.gz", "bin/clang.wasm.gz", "bin/lld.wasm.gz", "bin/sysroot.tar.gz"];
 export declare const CLANGD_RUNTIME_LOAD_ASSETS: readonly ["clangd.js", "clangd.wasm.gz", "clangd.headers.json.gz"];
 export declare const RUNTIME_LOAD_ASSETS: {
     python: readonly ["pyodide.mjs", "pyodide.asm.mjs", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
-    java: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
+    java: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compiler.wasm-deobfuscator.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
     clang: readonly ["runtime-manifest.v1.json", "bin/memfs.wasm.gz", "bin/clang.wasm.gz", "bin/lld.wasm.gz", "bin/sysroot.tar.gz"];
     clangd: readonly ["clangd.js", "clangd.wasm.gz", "clangd.headers.json.gz"];
 };