wasm-idle 1.0.12 → 1.1.0

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).
 
@@ -91,9 +94,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               | -     |
@@ -252,10 +257,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.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`                                                                                                                                                                                                       |
 | 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 +301,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.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`                                                                                                                                                                                   |
 | 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`                                                                                                                                                                                                                        |
@@ -584,6 +591,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).
 

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),

package/dist/playground/commonlisp.d.ts

@@ -0,0 +1,8 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Real upstream ECL (Embeddable Common-Lisp) built to Wasm by the wasm-llvm producer. */
+export default class CommonLisp extends StaticWorkerRuntimeSandbox {
+    readonly evidence: {
+        current: unknown;
+    };
+    constructor();
+}

package/dist/playground/commonlisp.js

@@ -0,0 +1,33 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { preflightCommonLispRuntimeAssets, resolveCommonLispRuntimeAssetConfig } from './commonlispAssets';
+/** Real upstream ECL (Embeddable Common-Lisp) built to Wasm by the wasm-llvm producer. */
+export default class CommonLisp extends StaticWorkerRuntimeSandbox {
+    evidence;
+    constructor() {
+        const evidence = { current: undefined };
+        super({
+            displayName: 'Common Lisp',
+            languageId: 'COMMONLISP',
+            defaultActivePath: 'main.lisp',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            onEvidence(value) {
+                evidence.current = value;
+            },
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\(\s*(?:read|read-line|read-char|read-byte|peek-char)\b|\*standard-input\*/i
+            },
+            resolveRuntimeAssets: resolveCommonLispRuntimeAssetConfig,
+            async preflightRuntimeAssets(urls, context) {
+                evidence.current = undefined;
+                return context.createOwnedDelivery(await preflightCommonLispRuntimeAssets(urls.baseUrl, context));
+            }
+        });
+        this.evidence = evidence;
+    }
+}

package/dist/playground/commonlispAssets.d.ts

@@ -0,0 +1,30 @@
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
+import type { PlaygroundRuntimeAssets } from './assets';
+export declare const COMMONLISP_INITIAL_MEMORY_BYTES: number;
+/** ecl.wasm is delivered as the producer's pinned gzip bytes; `.bin` keeps hosts from adding
+ * Content-Encoding, so the browser never transparently decodes it before verification. */
+export declare const COMMONLISP_WASM_STORAGE_PATH = "ecl.wasm.gz.bin";
+export declare const COMMONLISP_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
+export declare function resolveCommonLispRuntimeAssetConfig(assets: string | PlaygroundRuntimeAssets, currentUrl: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestFingerprint: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
+    workerReceipt: {
+        readonly bytes: 11814;
+        readonly sha256: "46b24c0fbde93dfaa71ddbce697d717c772ad8fd03f8486ad2102c41145606c6";
+    };
+};
+export declare function preflightCommonLispRuntimeAssets(baseUrl: string, options: {
+    limits: ExecutionLimits;
+    persistentCache?: RuntimeAssetCacheOptions;
+    signal?: AbortSignal;
+    reportProgress?: (value: number, stage: string) => void;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Readonly<{
+    fingerprint: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
+    'producer-receipt.json': Uint8Array<ArrayBufferLike>;
+    'ecl.mjs': Uint8Array<ArrayBufferLike>;
+    'ecl.wasm': Uint8Array<ArrayBuffer>;
+}>>;
+/** Decode the verified gzip delivery into an exactly sized buffer and verify the logical receipt. */
+export declare function decompressCommonLispWasm(compressed: Uint8Array, signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;

package/dist/playground/commonlispAssets.js

@@ -0,0 +1,184 @@
+import { AssetIntegrityError, defineRuntimeRegistryManifest, UnsupportedBrowserFeatureError, preflightRuntimeAssets, ResourceLimitError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { WASM_COMMONLISP_PROFILE as profile } from './wasmCommonLispVersion';
+export const COMMONLISP_INITIAL_MEMORY_BYTES = 64 * 1024 * 1024;
+/** ecl.wasm is delivered as the producer's pinned gzip bytes; `.bin` keeps hosts from adding
+ * Content-Encoding, so the browser never transparently decodes it before verification. */
+export const COMMONLISP_WASM_STORAGE_PATH = 'ecl.wasm.gz.bin';
+const identityAsset = (name, mediaType) => ({
+    key: name,
+    path: name,
+    compressedSha256: profile.assets[name].sha256,
+    uncompressedSha256: profile.assets[name].sha256,
+    compressedBytes: profile.assets[name].bytes,
+    uncompressedBytes: profile.assets[name].bytes,
+    encoding: 'identity',
+    mediaType
+});
+const deliveryAssets = [
+    identityAsset('producer-receipt.json', 'application/json'),
+    identityAsset('ecl.mjs', 'text/javascript'),
+    {
+        key: 'ecl.wasm',
+        path: COMMONLISP_WASM_STORAGE_PATH,
+        compressedSha256: profile.assets['ecl.wasm.gz'].sha256,
+        uncompressedSha256: profile.runtime['ecl.wasm'].sha256,
+        compressedBytes: profile.assets['ecl.wasm.gz'].bytes,
+        uncompressedBytes: profile.runtime['ecl.wasm'].bytes,
+        encoding: 'gzip',
+        mediaType: 'application/wasm'
+    }
+];
+export const COMMONLISP_RUNTIME_MANIFEST = defineRuntimeRegistryManifest({
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/commonlisp',
+    revision: profile.assets['producer-receipt.json'].sha256,
+    runtimes: [
+        {
+            runtimeId: 'COMMONLISP',
+            identity: {
+                languageId: 'COMMONLISP',
+                implementationId: 'ecl-emscripten',
+                implementationVersion: profile.version,
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.assets['producer-receipt.json'].sha256,
+                    protocolVersion: 1,
+                    trustProfileId: profile.profileId,
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm', 'wasm-exceptions', 'decompression-stream'],
+            assetRoot: '.',
+            assets: deliveryAssets,
+            contracts: {
+                routeId: 'COMMONLISP',
+                runtimeAssetKey: 'commonlisp',
+                documentationId: 'commonlisp',
+                syncTarget: 'wasm-commonlisp',
+                browserTestId: 'COMMONLISP'
+            }
+        }
+    ]
+});
+export function resolveCommonLispRuntimeAssetConfig(assets, currentUrl) {
+    const root = typeof assets === 'string' ? assets : assets.rootUrl || '';
+    const override = typeof assets === 'string' ? undefined : assets.commonlisp?.baseUrl;
+    const baseUrl = new URL(override ?? `${root.replace(/\/+$/, '')}/wasm-commonlisp/`, currentUrl);
+    if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('Common Lisp requires a credential-free HTTP(S) asset directory.', { runtimeId: 'COMMONLISP' });
+    }
+    if (!baseUrl.pathname.endsWith('/'))
+        baseUrl.pathname += '/';
+    const workerUrl = new URL('runner-worker.js', baseUrl);
+    workerUrl.searchParams.set('v', profile.workerReceipt.sha256);
+    return {
+        baseUrl: baseUrl.href,
+        workerUrl: workerUrl.href,
+        manifestFingerprint: profile.assets['producer-receipt.json'].sha256,
+        workerReceipt: profile.workerReceipt
+    };
+}
+export async function preflightCommonLispRuntimeAssets(baseUrl, options) {
+    if (options.limits.maxWasmMemoryBytes < COMMONLISP_INITIAL_MEMORY_BYTES) {
+        throw new ResourceLimitError('Common Lisp needs at least 64 MiB of Wasm memory.', {
+            runtimeId: 'COMMONLISP',
+            phase: 'asset',
+            resource: 'wasm-memory',
+            actual: COMMONLISP_INITIAL_MEMORY_BYTES,
+            limit: options.limits.maxWasmMemoryBytes
+        });
+    }
+    const loaded = new Map();
+    const total = deliveryAssets.reduce((sum, asset) => sum + asset.compressedBytes, 0);
+    const result = await preflightRuntimeAssets({
+        manifest: COMMONLISP_RUNTIME_MANIFEST,
+        runtimeId: 'COMMONLISP',
+        rootUrl: baseUrl,
+        assetUrls: Object.fromEntries(deliveryAssets.map((asset) => [
+            asset.key,
+            new URL(`${asset.path}?v=${asset.compressedSha256}`, baseUrl)
+        ])),
+        limits: options.limits,
+        persistentCache: options.persistentCache,
+        signal: options.signal,
+        fetch: options.fetch,
+        redirect: 'error',
+        requireExactResponseUrl: true,
+        maxConcurrentDownloads: 2,
+        maxTotalDeliveryBytes: total,
+        reportProgress(progress) {
+            loaded.set(progress.assetKey, progress.loadedBytes);
+            options.reportProgress?.(0.04 + (0.13 * [...loaded.values()].reduce((a, b) => a + b, 0)) / total, `Verifying ECL ${progress.assetKey}`);
+        }
+    });
+    const wasm = await decompressCommonLispWasm(result.assets['ecl.wasm'].bytes, options.signal);
+    return Object.freeze({
+        fingerprint: profile.assets['producer-receipt.json'].sha256,
+        'producer-receipt.json': result.assets['producer-receipt.json'].bytes,
+        'ecl.mjs': result.assets['ecl.mjs'].bytes,
+        'ecl.wasm': wasm
+    });
+}
+/** Decode the verified gzip delivery into an exactly sized buffer and verify the logical receipt. */
+export async function decompressCommonLispWasm(compressed, signal) {
+    const context = { runtimeId: 'COMMONLISP', profileId: profile.profileId };
+    if (typeof DecompressionStream !== 'function')
+        throw new UnsupportedBrowserFeatureError('DecompressionStream(gzip)', {
+            ...context,
+            phase: 'asset'
+        });
+    const expected = profile.runtime['ecl.wasm'];
+    const body = new Response(Uint8Array.from(compressed)).body;
+    const reader = body.pipeThrough(new DecompressionStream('gzip')).getReader();
+    const wasm = new Uint8Array(expected.bytes);
+    let offset = 0;
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (offset + value.byteLength > wasm.byteLength)
+                throw new AssetIntegrityError('ECL ecl.wasm gzip output exceeds its receipt', context);
+            wasm.set(value, offset);
+            offset += value.byteLength;
+        }
+    }
+    catch (error) {
+        void reader.cancel().catch(() => undefined);
+        if (error instanceof AssetIntegrityError || signal?.aborted)
+            throw error;
+        throw new AssetIntegrityError('ECL ecl.wasm gzip decompression failed', {
+            ...context,
+            cause: error
+        });
+    }
+    if (offset !== wasm.byteLength)
+        throw new AssetIntegrityError('ECL ecl.wasm gzip output is truncated', context);
+    await verifyRuntimeAssetIntegrity({
+        asset: 'ecl.wasm',
+        bytes: wasm,
+        expected: {
+            ...expected,
+            uncompressedSha256: expected.sha256,
+            uncompressedBytes: expected.bytes
+        },
+        stage: 'uncompressed',
+        mimeType: 'application/wasm',
+        ...context
+    });
+    return wasm;
+}

package/dist/playground/index.d.ts

@@ -1,6 +1,6 @@
 import type { BoundSandbox, PlaygroundBinding, Sandbox, SandboxRuntimeAssets } from './sandbox';
 import { type PlaygroundBindingOptions } from '@wasm-idle/core';
-export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "OBJECTIVECXX" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "GOLFSCRIPT" | "APECODE" | "AHEUI" | "PYTHON3" | "BRAINFUCK" | "BEFUNGE93" | "WHITESPACE" | "MALBOLGE" | "UHMLANG" | "LOLCODE" | "WASM" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "RESCRIPT" | "C3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "GRAIN" | "HY" | "FORTRAN" | "LFORTRAN" | "COBOL" | "V" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "LUA" | "FENNEL" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "POSTGRESQL" | "PHP")[];
+export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "OBJECTIVECXX" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "GOLFSCRIPT" | "APECODE" | "AHEUI" | "PYTHON3" | "BRAINFUCK" | "BEFUNGE93" | "WHITESPACE" | "MALBOLGE" | "UHMLANG" | "LOLCODE" | "WASM" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "RESCRIPT" | "C3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "GRAIN" | "HY" | "FORTRAN" | "LFORTRAN" | "LEAN4" | "COBOL" | "V" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "LUA" | "FENNEL" | "ZIG" | "LISP" | "COMMONLISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "POSTGRESQL" | "PHP")[];
 export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): PlaygroundBinding;
 declare function playground(language: string): Promise<Sandbox>;
 declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets, options?: PlaygroundBindingOptions): Promise<BoundSandbox>;

package/dist/playground/index.js

@@ -312,6 +312,13 @@ const sandboxRoutes = [
             return new LFortran();
         }
     },
+    {
+        languageId: 'LEAN4',
+        load: async () => {
+            const { default: Lean4 } = await import('./lean4');
+            return new Lean4();
+        }
+    },
     {
         languageId: 'FORTRAN',
         load: async () => {
@@ -410,6 +417,13 @@ const sandboxRoutes = [
             return new Lisp();
         }
     },
+    {
+        languageId: 'COMMONLISP',
+        load: async () => {
+            const { default: CommonLisp } = await import('./commonlisp');
+            return new CommonLisp();
+        }
+    },
     {
         languageId: 'RUBY',
         load: async () => {

package/dist/playground/javaRuntimeStdin.d.ts

@@ -0,0 +1,9 @@
+import { type PreparedJavaStdinInjection } from './javaStdin';
+/** Browser execution input is runtime data. Retain the snapshot API for standalone callers. */
+export declare function prepareJavaRuntimeStdinInjection(code: string): PreparedJavaStdinInjection;
+/** Single cursor shared by compatibility byte reads and bounded block reads. */
+export declare function createJavaStdinBridge(initialInput: string, explicit: boolean, readInput: () => string | null, maxChunkBytes?: number): {
+    readByte(): number;
+    readChunk(): Int8Array | null;
+    dispose(): void;
+};

package/dist/playground/javaRuntimeStdin.js

@@ -0,0 +1,145 @@
+import { prepareJavaStdinInjection } from './javaStdin';
+/** Browser execution input is runtime data. Retain the snapshot API for standalone callers. */
+export function prepareJavaRuntimeStdinInjection(code) {
+    const injection = prepareJavaStdinInjection(code, '', false);
+    if (!injection.usesStdin || !injection.helperSourcePath)
+        return injection;
+    const parts = injection.helperSourcePath.split('/');
+    const className = parts.pop().replace(/\.java$/, '');
+    const packageName = parts.join('.');
+    return {
+        ...injection,
+        stdinCacheKey: 'host-chunks-v2-jso',
+        helperSource: `${packageName ? `package ${packageName};\n\n` : ''}import java.io.InputStream;
+import org.teavm.jso.JSObject;
+import org.teavm.jso.browser.Window;
+import org.teavm.jso.core.JSFunction;
+import org.teavm.jso.core.JSMapLike;
+import org.teavm.jso.core.JSObjects;
+import org.teavm.jso.typedarrays.Int8Array;
+
+final class ${className} extends InputStream {
+    private static final ${className} INSTANCE = new ${className}();
+    private byte[] chunk = new byte[0];
+    private int position = 0;
+    private boolean ended = false;
+
+    private ${className}() {}
+
+    static InputStream open() {
+        return INSTANCE;
+    }
+
+    // Use classlib overlay methods: the pinned source compiler cannot compile @JSBody.
+    // A host call obtains a block; copying its bytes keeps Java array ownership explicit.
+    private static byte[] readFromHost() {
+        Window current = Window.current();
+        if (current == null) return null;
+        JSMapLike<JSObject> globals = current.cast();
+        JSObject stdin = globals.get("wasmIdleJavaStdin");
+        if (stdin == null) return null;
+        JSMapLike<JSObject> input = stdin.cast();
+        if (JSObjects.hasProperty(stdin, "readChunk")) {
+            JSFunction readChunk = input.get("readChunk").cast();
+            JSObject result = (JSObject) readChunk.call(stdin);
+            if (result == null) return null;
+            Int8Array array = result.cast();
+            byte[] next = new byte[array.getLength()];
+            for (int i = 0; i < next.length; i++) next[i] = array.get(i);
+            return next;
+        }
+        JSFunction readByte = input.get("readByte").cast();
+        Object value = readByte.call(stdin);
+        int next = value != null ? Integer.parseInt(value.toString()) : -1;
+        return next < 0 ? null : new byte[] { (byte) next };
+    }
+
+    private boolean ensureChunk() {
+        while (position == chunk.length && !ended) {
+            byte[] next = readFromHost();
+            position = 0;
+            if (next == null) {
+                chunk = new byte[0];
+                ended = true;
+            } else {
+                chunk = next;
+            }
+        }
+        return position < chunk.length;
+    }
+
+    @Override
+    public int read() {
+        return ensureChunk() ? chunk[position++] & 0xff : -1;
+    }
+
+    @Override
+    public int read(byte[] bytes, int offset, int length) {
+        if (bytes == null) throw new NullPointerException();
+        if (offset < 0 || length < 0 || length > bytes.length - offset) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (length == 0) return 0;
+        if (!ensureChunk()) return -1;
+        int count = Math.min(length, chunk.length - position);
+        System.arraycopy(chunk, position, bytes, offset, count);
+        position += count;
+        return count;
+    }
+
+    @Override
+    public int available() {
+        return chunk.length - position;
+    }
+}
+`
+    };
+}
+/** Single cursor shared by compatibility byte reads and bounded block reads. */
+export function createJavaStdinBridge(initialInput, explicit, readInput, maxChunkBytes = 4096) {
+    if (!Number.isSafeInteger(maxChunkBytes) || maxChunkBytes < 1) {
+        throw new RangeError('Java stdin chunk size must be a positive safe integer');
+    }
+    const encoder = new TextEncoder();
+    let bytes = encoder.encode(initialInput);
+    let offset = 0;
+    let ended = false;
+    function ensureBytes() {
+        while (offset === bytes.length && !ended) {
+            const input = explicit ? null : readInput();
+            bytes = input === null ? new Uint8Array(0) : encoder.encode(input);
+            offset = 0;
+            ended = input === null;
+        }
+        return offset < bytes.length;
+    }
+    function releaseConsumed() {
+        if (offset === bytes.length) {
+            bytes = new Uint8Array(0);
+            offset = 0;
+        }
+    }
+    return {
+        readByte() {
+            if (!ensureBytes())
+                return -1;
+            const value = bytes[offset++];
+            releaseConsumed();
+            return value;
+        },
+        readChunk() {
+            if (!ensureBytes())
+                return null;
+            const count = Math.min(maxChunkBytes, bytes.length - offset);
+            const chunk = new Int8Array(bytes.buffer, bytes.byteOffset + offset, count);
+            offset += count;
+            releaseConsumed();
+            return chunk;
+        },
+        dispose() {
+            bytes = new Uint8Array(0);
+            offset = 0;
+            ended = true;
+        }
+    };
+}

package/dist/playground/lean4.d.ts

@@ -0,0 +1,13 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Upstream Lean 4 frontend and IR interpreter (`lean --run`) compiled to wasm32 Emscripten. */
+export default class Lean4 extends StaticWorkerRuntimeSandbox {
+    readonly defaultExecutionLimits: Readonly<{
+        maxWasmMemoryBytes: number;
+    }>;
+    readonly evidence: {
+        current: unknown;
+    };
+    constructor();
+    load(...args: Parameters<StaticWorkerRuntimeSandbox['load']>): Promise<void>;
+    run(...args: Parameters<StaticWorkerRuntimeSandbox['run']>): Promise<string | boolean>;
+}