wasm-idle 1.0.12 → 1.1.2

package/README.md

@@ -10,6 +10,9 @@ PostgreSQL, and PHP code.
 Experimental LFortran execution is available separately from f2c Fortran; see
 [the LFortran consumer contract and local setup](docs/lfortran.md).
 
+Lean 4 runs the upstream `lean --run` interpreter in the browser; see
+[Lean 4 browser execution](docs/lean4.md).
+
 V runs the real V 0.5.2 compiler in the browser and compiles its C output with the shared
 llvm-core Clang host; see [the V browser integration](docs/v-browser.md).
 
@@ -22,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
@@ -91,9 +121,11 @@ debug runtime; the remaining debug-enabled languages retain wasm-idle's trace co
 | Fennel         | fennel.lua on Wasmoon                        | Yes   | syntax               | -     |
 | Zig            | zig_small.wasm                               | Yes   | syntax               | -     |
 | Scheme         | Puppy Scheme / wasm-lisp                     | Yes   | syntax               | -     |
+| Common Lisp    | ECL 26.5.5 (Embeddable Common-Lisp) WASM     | Yes   | syntax               | -     |
 | Ruby           | CRuby WASI                                   | Yes   | syntax               | -     |
 | Haskell        | ghc-in-browser                               | Yes   | syntax               | -     |
 | LFortran       | LFortran LLVM evaluator (experimental)       | Yes   | compiler diagnostics | -     |
+| Lean 4         | Lean 4.34.1 lean --run (Emscripten)          | Yes   | compiler diagnostics | -     |
 | Fortran        | f2c + @wasm-idle/llvm-core                   | Yes   | Fortran LSP          | -     |
 | COBOL          | GnuCOBOL 3.2 + @wasm-idle/llvm-core          | Yes   | syntax               | -     |
 | V              | V 0.5.2 + @wasm-idle/llvm-core               | Yes   | syntax               | -     |
@@ -213,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
@@ -222,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
@@ -252,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.0.12 / 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.12 / 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.12                                                                                       | `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.12; 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                                                                                                                                                                                |
@@ -296,12 +336,14 @@ variables or import SvelteKit modules.
 | Fennel<br>`FENNEL`                 | static wasm-fennel `fennel-1.6.1.lua.gz` (official Fennel 1.6.1) on wasm-lua@0.1.0                                                                                             | receipt-verified `fennel.lua` compiler evaluated by the Wasmoon Lua VM; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `runtimeAssets.fennel.compilerUrl` or `PUBLIC_WASM_FENNEL_COMPILER_URL` plus the Lua module URL; `programArgs`                                                                                                                                                                                                                                   |
 | Zig<br>`ZIG`                       | static wasm-zig assets / `zig_small.wasm` + `std.tar.gz`                                                                                                                       | native gzip delivery for the tar standard library; default target `wasm64-wasi`; Zig compile args are appended; supports `stdin`, `compileArgs`, `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                          | `runtimeAssets.zig.compilerUrl`/`stdlibUrl` or `PUBLIC_WASM_ZIG_*`; `zigTargetTriple`, `activePath`, `workspaceFiles`                                                                                                                                                                                                                            |
 | Scheme<br>`LISP`                   | wasm-lisp@0.1.0 / Puppy Scheme WASM component                                                                                                                                  | receipt-verified Puppy Scheme compiler/runtime; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | `runtimeAssets.lisp.{moduleUrl,manifestUrl,manifestFingerprint}` or `PUBLIC_WASM_LISP_{MODULE_URL,MANIFEST_URL,MANIFEST_FINGERPRINT}`; `programArgs`                                                                                                                                                                                             |
+| Common Lisp<br>`COMMONLISP`        | receipt-pinned `wasm-llvm/producer/ecl-browser` ECL 26.5.5 artifacts downloaded into `static/wasm-commonlisp`                                                                  | real upstream ECL bytecode compiler/interpreter LOADs the active file in a fresh Worker; shared-ring stdin serves READ-LINE/READ with EOF; unhandled conditions print to stderr and fail the run; recursion deeper than the browser call stack (about 150 levels in a Chromium Worker) fails as a stack-overflow error                                                                                                                                                                                                                                                  | `runtimeAssets.commonlisp.baseUrl` relocates the reviewed bundle; `stdin`, `activePath`, workspace files loadable with `LOAD`, cancellation and Wasm memory limits; no program arguments, native compiler or contrib modules                                                                                                                     |
 | Ruby<br>`RUBY`                     | receipt-pinned `static/wasm-ruby` profile produced from @ruby/3.4-wasm-wasi@2.10.1 + @ruby/wasm-wasi@2.10.1                                                                    | host-verifies the manifest, canonical stored module and gzip bytes, and logical WASM before transferring three owned buffers to a no-fetch CRuby 3.4 worker; supports `stdin`, `programArgs`, and workspace files                                                                                                                                                                                                                                                                                                                                                       | `rootUrl` mirrors reuse the bundled profile; explicit `runtimeAssets.ruby` overrides require one complete profile and same-origin canonical paths; URL-only `PUBLIC_WASM_RUBY_*` overrides fail closed; `stdin`, `programArgs`, `workspaceFiles`                                                                                                 |
 | 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                                                                                                                            |
-| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.0.12                                                                                               | 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.12                                                                                    | 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.12                                                                   | 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`                                                                                                                                                                                   |
+| 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.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`                                                                                                                                                                                                                        |
@@ -346,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
@@ -381,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:
 
@@ -408,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
@@ -470,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
@@ -584,6 +658,9 @@ browser UI thread.
 C3 local asset setup, byte I/O ABI, and its 1 GiB default memory budget are documented in
 [C3 browser integration](docs/c3-browser.md).
 
+Common Lisp (ECL) asset download, stdin behaviour and limits are documented in
+[Common Lisp browser integration](docs/commonlisp.md).
+
 Grain's pinned upstream compiler, stdin model, and asset refresh are documented in
 [Grain browser integration](docs/grain-browser.md).
 
@@ -617,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
@@ -776,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
@@ -845,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.
@@ -907,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',
@@ -916,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
 	}
 };
 ```
@@ -924,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.
@@ -980,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';
@@ -995,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
@@ -1009,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/applicationAssets.js

@@ -256,6 +256,8 @@ export function createApplicationRuntimeAssets(rootUrl) {
             integrity: HASKELL_RUNTIME_ASSET_RECEIPTS
         },
         lfortran: { baseUrl: asset('wasm-lfortran/') },
+        lean4: { baseUrl: asset('wasm-lean4/') },
+        commonlisp: { baseUrl: asset('wasm-commonlisp/') },
         fortran: {
             baseUrl: asset('wasm-fortran/'),
             f2cWasmUrl: asset('wasm-fortran/f2c.wasm', WASM_FORTRAN_EXECUTION_ASSET_VERSION),