wasm-idle 1.0.0 → 1.0.4

package/README.md

@@ -221,9 +221,9 @@ when they exist.
 | Language / IDs                     | Package/version base                                                                                                                                                           | Execution defaults / flags                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Customization                                                                                                                                                                                                                                                                                                                                    |
 | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | 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.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.0.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.0.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`               |
+| C<br>`C`                           | @wasm-idle/llvm-core@1.0.3 / 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.3 / 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.3                                                                                        | `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`               |
 | Python<br>`PYTHON3`                | static ESM `static/pyodide/pyodide.mjs` / pyodide@0.29.3                                                                                                                       | loads `pyodide.mjs`, `pyodide.asm.js`, `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`                                                                                                                                                                                               |
 | Java<br>`JAVA`                     | @wasm-idle/runtime-teavm@0.0.0 / TeaVM compiler assets                                                                                                                         | `compiler.wasm` compiles Java to browser WASM/JS; supports `stdin` and `programArgs`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `runtimeAssets.java.baseUrl`/`loader` or `rootUrl`                                                                                                                                                                                                                                                                                               |
 | Rust<br>`RUST`                     | wasm-rust@0.1.0 / rust-1.99.0-browser-integrated-v1 + integrated LLVM/LLD 22.1.8 from the `wasm-llvm` producer; exact rustc/LLVM provenance is recorded for LLDB compatibility | browser host `wasm32-wasip1-threads`; default target `wasm32-wasip1`, selectable `wasm32-wasip1`, `wasm32-wasip2`, `wasm32-wasip3`; LLDB mode is currently limited to `wasm32-wasip1` and emits embedded DWARF with `-C debuginfo=2 -C opt-level=0`; normal Preview 1/2/3 execution remains unchanged; supports `stdin` and `programArgs`                                                                                                                                                                                                                               | `runtimeAssets.rust.compilerUrl`, `runtimeAssets.rust.debugModuleUrl`, or `PUBLIC_WASM_RUST_COMPILER_URL`; `rootUrl`, `rustTargetTriple`, `programArgs`, `debugMode`; compiler requests accept `edition`, `crateType`, `extendedTimeout`, `log`, and `onProgress`; runtime manifest controls compiler memory, timeout, and shared workspace size |
@@ -261,8 +261,8 @@ when they exist.
 | Ruby<br>`RUBY`                     | receipt-pinned `static/wasm-ruby` profile produced from @ruby/3.4-wasm-wasi@2.9.3-2.9.4 + @ruby/wasm-wasi@2.9.3-2.9.4                                                          | 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.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.0.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`                                                                                                                                                                           |
+| Fortran<br>`FORTRAN`               | Netlib f2c 2022-09-09 + `@cowasm/f2c 1.0.0` libf2c + @wasm-idle/llvm-core@1.0.3                                                                                                | 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.3                                                                                     | 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`                                                                                                                                                                           |
 | 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-dev45.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`                                                                                                                                                                                                                        |
@@ -552,6 +552,11 @@ from GitHub without WAF credentials. Update the snapshot URL and all changed rec
 do not replace a receipt with bytes from a mutable deployment URL. Receipt failures report both
 expected and actual byte counts and SHA-256 digests.
 
+The slim Clang snapshot is retained on `artifacts/slim-clang-20260927`. Keep that branch while
+the manifest references its commit; the snapshot preserves the pinned OCaml inputs and replaces
+only Clang delivery files and their build receipt. Updating this download source does not deploy
+GitHub Pages.
+
 OCaml preparation keeps these verified download inputs in a separate receipt-keyed cache,
 compiles the tracked TypeScript browser adapter with the producer's locked compiler, and syncs
 that adapter together with the verified native bundle. The sync derives the final
@@ -849,6 +854,11 @@ Verified static runtimes such as Janet and Julia intentionally omit URL-only exa
 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.
 
+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.
+Custom Clang loaders retain the original full sysroot path unless their host explicitly provides
+and verifies a matching profile pair.
+
 Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Clang custom loaders receive `bin/memfs.wasm.gz`, `bin/clang.wasm.gz`, `bin/lld.wasm.gz`, and `bin/sysroot.tar.gz`; COBOL loaders receive `cobc.wasm.gz`, `rootfs.tar.gz`, and `c-sysroot.tar.gz`. The shared loader pipes these gzip response bodies through native `DecompressionStream`. Legacy external manifests that still reference ZIP assets remain supported through the dynamically loaded `fflate` compatibility path. Zig custom loaders receive `zig_small.wasm` and `std.tar.gz`; an explicitly configured legacy `std.zip` URL remains compatible. Clangd custom loaders receive `clangd.js` and `clangd.wasm.gz`, with the worker decompressing the gzip payload before instantiation. Rust expects a logical, profile-pinned graph entry URL whose sibling inert storage exactly matches the generated receipts; it does not import that HTTP entry directly. C#, F#, and VB.NET expect a browser-loadable `wasm-dotnet` module with its language-specific static .NET `browser-wasm` runtime assets. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
 
 To reuse the same runtime asset configuration for both `<Terminal>` and direct `playground(...)`
@@ -881,3 +891,34 @@ Compiler assets produced by [`wasm-llvm`](https://github.com/seo-rii/wasm-llvm)
 external static hosting and loaded by `@wasm-idle/llvm-core`. Also powered by Pyodide, TeaVM, `wasm-rust`,
 `wasm-dotnet`, `wasm-of-js-of-ocaml`, `wasm-typescript`, `wasm-lisp`,
 `wasm-wat`, `wasm-lua`, `wasm-zig`, CBQN, Janet, AtomVM/Popcorn, and `ghc-in-browser`.
+
+### Ruby split standard library
+
+The bundled Ruby runtime also provides a verified `ruby.splitStdlib: true` profile. It compiles the genuine Ruby core Wasm while fetching the complete standard library and bundled gems as a separate read-only filesystem pack. The web demo selects this profile; library consumers retain the embedded-stdlib profile unless they opt in. Custom trust profiles continue to use the embedded path.
+
+The pack contains the same locked upstream files, not an import-based subset. Each execution gets fresh filesystem descriptors and directories. Both the host and worker verify fixed byte lengths and SHA-256 receipts before activation. Compiler payload size decreases, but total network transfer is not necessarily smaller.
+
+`node scripts/sync-runtime.mjs wasm-ruby` regenerates both profiles from the pinned producer inputs. `node scripts/sync-wasm-ruby-split.mjs --verify` additionally checks split-profile freshness without replacing published files.
+
+### Optional idle runtime prewarming
+
+`createPlaygroundBinding(assets, { prewarm: true })` enables explicit
+`binding.prewarm(language)` requests. The default is **false**: constructing a
+binding or selecting a language in an embedding does not start network requests.
+The first-party web demo opts in and exposes a **Prewarm** checkbox.
+
+```ts
+const binding = createPlaygroundBinding(assets, { prewarm: true });
+void binding.prewarm('JAVA'); // idle priority; runtime only, never executes source
+const sandbox = await binding.load('JAVA'); // claims the same prepared sandbox
+await binding.setPrewarmEnabled?.(false); // cancels unclaimed preparation only
+await binding.dispose?.();
+```
+
+Only one unclaimed runtime is retained per binding. Selecting another language
+cancels that speculative work. A foreground load starts queued preparation
+immediately and owns the result; subsequent toggles cannot terminate it.
+Speculative failures are discarded so ordinary loading can retry. Prewarming
+skips server-side rendering, hidden documents, save-data mode and 2G connections.
+All normal runtime integrity, startup timeout and execution-limit checks remain
+in place. This does not compile user source or preload every language at once.

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, Termin
 export type { CompilerDiagnostic, SandboxExecutionOptions } from './playground/options';
 export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { BoundSandbox, PlaygroundBinding, PlaygroundTerminalProps, SandboxProgress, SandboxRuntimeAssets } from './playground/sandbox';
+export type { PlaygroundBindingOptions } from "@wasm-idle/core";

package/dist/playground/applicationAssets.js

@@ -55,6 +55,7 @@ export function createApplicationRuntimeAssets(rootUrl) {
     const asset = createApplicationAssetResolver(normalizedRootUrl);
     return {
         rootUrl: normalizedRootUrl,
+        clang: { bundledLanguageSysroots: true },
         assemblyscript: {
             moduleUrl: asset('wasm-assemblyscript/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
         },
@@ -62,7 +63,7 @@ export function createApplicationRuntimeAssets(rootUrl) {
             moduleUrl: asset('wasm-duckdb/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
         },
         php: {
-            moduleUrl: asset('wasm-php/runtime.mjs', STATIC_RUNTIME_MODULE_VERSION)
+            moduleUrl: asset('wasm-php/startup.mjs', STATIC_RUNTIME_MODULE_VERSION)
         },
         rust: {
             compilerUrl: `${asset('wasm-rust/index.js', WASM_RUST_ASSET_VERSION)}&rustManifestBytes=${WASM_RUST_RUNTIME_PROFILE.manifestReceipt.bytes}&rustManifestSha256=${WASM_RUST_RUNTIME_PROFILE.manifestReceipt.sha256}`,
@@ -209,6 +210,7 @@ export function createApplicationRuntimeAssets(rootUrl) {
         },
         typescript: {
             moduleUrl: asset('wasm-typescript/index.js', WASM_TYPESCRIPT_ASSET_VERSION),
+            javascriptModuleUrl: asset('wasm-typescript/javascript.js', WASM_TYPESCRIPT_ASSET_VERSION),
             libUrl: asset('lsp/typescript-libs.json.gz', WASM_TYPESCRIPT_ASSET_VERSION)
         },
         wat: {
@@ -228,6 +230,7 @@ export function createApplicationRuntimeAssets(rootUrl) {
             manifestFingerprint: WASM_LISP_ASSET_VERSION
         },
         ruby: {
+            splitStdlib: true,
             baseUrl: asset('wasm-ruby/'),
             manifestUrl: asset(`wasm-ruby/${RUBY_RUNTIME_MANIFEST_PATH}`, RUBY_RUNTIME_BUNDLE.profile.manifestFingerprint),
             moduleUrl: asset(`wasm-ruby/${RUBY_RUNTIME_MODULE_STORAGE_PATH}`, RUBY_RUNTIME_BUNDLE.profile.moduleJavaScriptReceipt.sha256),

package/dist/playground/assetBridge.d.ts

@@ -5,16 +5,17 @@ export declare class WorkerAssetBridge {
     private worker;
     private readonly runtime;
     private config;
-    private readonly progress;
-    private readonly expectedAssets;
+    private progress;
+    private expectedAssets;
+    private languageSysroots;
     private pythonPackageAssets;
     private generation;
     private state;
     private readonly activeLoads;
     private maxAssetBytes;
-    constructor(worker: Worker, runtime: RuntimeAssetRuntime, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number);
-    matches(config: ResolvedRuntimeAssetConfig, maxAssetBytes?: number): boolean;
-    rebind(worker: Worker, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number): void;
+    constructor(worker: Worker, runtime: RuntimeAssetRuntime, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number, languageSysroots?: boolean);
+    matches(config: ResolvedRuntimeAssetConfig, maxAssetBytes?: number, languageSysroots?: boolean): boolean;
+    rebind(worker: Worker, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike, maxAssetBytes?: number, languageSysroots?: boolean): void;
     dispose(): void;
     resetProgress(progress?: ProgressLike): void;
     private configuredReceiptByteLimit;

package/dist/playground/assetBridge.js

@@ -2,6 +2,8 @@ import { RUNTIME_LOAD_ASSETS } from './assets';
 import { ProtocolError, verifyRuntimeAssetIntegrity, verifyRuntimeAssetPair } from '@wasm-idle/core';
 import { decompressGzip } from '@wasm-idle/llvm-core';
 import { readPythonPackageAssets } from './pythonPackageLock';
+import { BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES } from './clangAssetIntegrity';
+import { shouldStreamBundledClang } from './clangStreamingPolicy';
 const encoder = new TextEncoder();
 const DEFAULT_STREAM_BUFFER_BYTES = 64 * 1024;
 const MAX_RUNTIME_ASSET_BYTES = 128 * 1024 * 1024;
@@ -181,7 +183,18 @@ const transferBuffer = (bytes, transferOwnership = false) => {
         ? transferableBuffer
         : Uint8Array.from(canonicalBytes).buffer;
 };
-const expectedAssetsForRuntime = (runtime) => new Set(RUNTIME_LOAD_ASSETS[runtime]);
+const cSysrootAsset = BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES.c.asset;
+const cppAddonAsset = BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES.cppAddon.asset;
+const fullSysrootAsset = 'bin/sysroot.tar.gz';
+const canUseClangLanguageSysroots = (runtime, config, requested) => runtime === 'clang' && requested && config.useAssetBridge && shouldStreamBundledClang(config);
+const expectedAssetsForRuntime = (runtime, languageSysroots = false) => {
+    const assets = new Set(RUNTIME_LOAD_ASSETS[runtime]);
+    if (runtime === 'clang' && languageSysroots) {
+        assets.add(cSysrootAsset);
+        assets.add(cppAddonAsset);
+    }
+    return assets;
+};
 const integrityKey = (config) => JSON.stringify(Object.entries(config.integrity || {})
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([asset, entry]) => [
@@ -199,19 +212,29 @@ const integrityKey = (config) => JSON.stringify(Object.entries(config.integrity
 const allowedBaseUrlsKey = (config) => JSON.stringify([...(config.allowedBaseUrls || [])].sort());
 class RuntimeLoadProgress {
     samples = new Map();
+    optionalSamples = new Map();
     expectedAssets;
+    optionalAssets;
     phaseId;
     progress;
     lockedTotal;
     measurementInvalid = false;
-    constructor(runtime) {
+    constructor(runtime, languageSysroots = false) {
         this.expectedAssets = expectedAssetsForRuntime(runtime);
+        this.optionalAssets = new Set();
+        if (runtime === 'clang' && languageSysroots) {
+            this.expectedAssets.delete(fullSysrootAsset);
+            this.expectedAssets.add(cSysrootAsset);
+            this.optionalAssets.add(fullSysrootAsset);
+            this.optionalAssets.add(cppAddonAsset);
+        }
         this.phaseId = `${runtime}:runtime-assets`;
         this.reset();
     }
     reset(progress) {
         this.progress = progress;
         this.samples.clear();
+        this.optionalSamples.clear();
         this.lockedTotal = undefined;
         this.measurementInvalid = false;
         for (const asset of this.expectedAssets)
@@ -219,8 +242,53 @@ class RuntimeLoadProgress {
         this.emit();
     }
     update(asset, loaded, total) {
-        if (!this.expectedAssets.has(asset))
+        if (!this.expectedAssets.has(asset)) {
+            if (this.optionalAssets.has(asset) && this.progress) {
+                const previous = this.optionalSamples.get(asset) || { loaded: 0 };
+                // A completed optional transfer may receive a duplicate or an unrelated
+                // worker-side progress sample. Keep its final measurement terminal;
+                // a subsequent unmeasured activity would turn 100% back into 99%.
+                if (previous.total !== undefined && previous.loaded === previous.total)
+                    return;
+                const nextLoaded = Math.max(previous.loaded, loaded);
+                const nextTotal = total ?? previous.total;
+                const valid = Number.isSafeInteger(loaded) &&
+                    loaded >= 0 &&
+                    (total === undefined ||
+                        (Number.isSafeInteger(total) &&
+                            total > 0 &&
+                            (previous.total === undefined || previous.total === total))) &&
+                    (nextTotal === undefined || nextLoaded <= nextTotal);
+                if (valid) {
+                    this.optionalSamples.set(asset, {
+                        loaded: nextLoaded,
+                        ...(nextTotal === undefined ? {} : { total: nextTotal })
+                    });
+                }
+                const label = `Downloading ${asset}`;
+                if (this.progress.report) {
+                    this.progress.report({
+                        kind: 'activity',
+                        phase: 'downloading',
+                        phaseId: `${this.phaseId}:${asset}`,
+                        label,
+                        ...(valid && nextTotal !== undefined
+                            ? {
+                                measurement: {
+                                    kind: 'bytes',
+                                    completed: nextLoaded,
+                                    total: nextTotal
+                                }
+                            }
+                            : {})
+                    });
+                }
+                else {
+                    this.progress.set?.(valid && nextTotal !== undefined ? nextLoaded / nextTotal : 0, label);
+                }
+            }
             return;
+        }
         if (!Number.isSafeInteger(loaded) || loaded < 0) {
             this.measurementInvalid = true;
             this.emit();
@@ -309,22 +377,26 @@ export class WorkerAssetBridge {
     config;
     progress;
     expectedAssets;
+    languageSysroots;
     pythonPackageAssets = new Set();
     generation = 0;
     state = 'active';
     activeLoads = new Set();
     maxAssetBytes;
-    constructor(worker, runtime, config, progress, maxAssetBytes = MAX_RUNTIME_ASSET_BYTES) {
+    constructor(worker, runtime, config, progress, maxAssetBytes = MAX_RUNTIME_ASSET_BYTES, languageSysroots = false) {
         this.worker = worker;
         this.runtime = runtime;
         this.config = config;
         this.maxAssetBytes = requireBridgeMaxAssetBytes(maxAssetBytes);
-        this.progress = new RuntimeLoadProgress(runtime);
-        this.expectedAssets = expectedAssetsForRuntime(runtime);
+        this.languageSysroots = canUseClangLanguageSysroots(runtime, config, languageSysroots);
+        this.progress = new RuntimeLoadProgress(runtime, this.languageSysroots);
+        this.expectedAssets = expectedAssetsForRuntime(runtime, this.languageSysroots);
         this.progress.reset(progress);
     }
-    matches(config, maxAssetBytes = this.maxAssetBytes) {
+    matches(config, maxAssetBytes = this.maxAssetBytes, languageSysroots = this.languageSysroots) {
         return (this.state === 'active' &&
+            this.languageSysroots ===
+                canUseClangLanguageSysroots(this.runtime, config, languageSysroots) &&
             this.maxAssetBytes === requireBridgeMaxAssetBytes(maxAssetBytes) &&
             this.config.baseUrl === config.baseUrl &&
             this.config.loader === config.loader &&
@@ -332,7 +404,7 @@ export class WorkerAssetBridge {
             allowedBaseUrlsKey(this.config) === allowedBaseUrlsKey(config) &&
             this.config.useAssetBridge === config.useAssetBridge);
     }
-    rebind(worker, config, progress, maxAssetBytes = this.maxAssetBytes) {
+    rebind(worker, config, progress, maxAssetBytes = this.maxAssetBytes, languageSysroots = this.languageSysroots) {
         if (this.state === 'disposed') {
             throw new Error('Cannot rebind a disposed worker asset bridge');
         }
@@ -340,7 +412,8 @@ export class WorkerAssetBridge {
             throw new Error('Cannot rebind a worker asset bridge while another rebind is active');
         }
         const nextMaxAssetBytes = requireBridgeMaxAssetBytes(maxAssetBytes);
-        const preservePythonPackageAssets = this.matches(config, nextMaxAssetBytes);
+        const nextLanguageSysroots = canUseClangLanguageSysroots(this.runtime, config, languageSysroots);
+        const preservePythonPackageAssets = this.matches(config, nextMaxAssetBytes, nextLanguageSysroots);
         this.state = 'rebinding';
         const generation = ++this.generation;
         this.progress.reset();
@@ -354,6 +427,9 @@ export class WorkerAssetBridge {
             this.worker = worker;
             this.config = config;
             this.maxAssetBytes = nextMaxAssetBytes;
+            this.languageSysroots = nextLanguageSysroots;
+            this.expectedAssets = expectedAssetsForRuntime(this.runtime, nextLanguageSysroots);
+            this.progress = new RuntimeLoadProgress(this.runtime, nextLanguageSysroots);
             this.progress.reset(progress);
             if (this.state !== 'rebinding' || this.generation !== generation) {
                 throw new Error('Cannot rebind a disposed worker asset bridge');

package/dist/playground/assets.d.ts

@@ -30,6 +30,8 @@ export interface RuntimeAssetConfig {
     loaderKey?: string;
     integrity?: RuntimeAssetIntegrityMap;
     allowedBaseUrls?: string[];
+    /** Opt in to the pinned C/C++ sysroot split only for the built-in Clang asset profile. */
+    bundledLanguageSysroots?: boolean;
 }
 export interface RustRuntimeAssetConfig {
     compilerUrl?: string;
@@ -89,6 +91,8 @@ export interface ErlangRuntimeAssetConfig {
 }
 export interface TypeScriptRuntimeAssetConfig {
     moduleUrl?: string;
+    /** Optional official JavaScript-only bundle; must match its generated receipt. */
+    javascriptModuleUrl?: string;
     libUrl?: string;
 }
 export interface WatRuntimeAssetConfig {
@@ -142,6 +146,8 @@ export interface ResolvedLispRuntimeAssetConfig {
     manifestFingerprint: string;
 }
 export interface RubyRuntimeAssetConfig {
+    /** Keep full stdlib compatibility, but load its data separately from the core Wasm. */
+    splitStdlib?: boolean;
     baseUrl?: string;
     manifestUrl?: string;
     moduleUrl?: string;
@@ -159,6 +165,7 @@ export interface RubyRuntimeAssetConfig {
     wasmReceipt?: RuntimeAssetIntegrityEntry;
 }
 export interface ResolvedRubyRuntimeAssetConfig {
+    splitStdlib?: boolean;
     baseUrl: string;
     manifestUrl: string;
     moduleUrl: string;

package/dist/playground/assets.js

@@ -765,6 +765,7 @@ function snapshotRubyRuntimeAssetConfig(options) {
     const snapshot = {};
     for (const key of RUBY_RUNTIME_CONFIG_KEYS)
         snapshot[key] = source[key];
+    snapshot.splitStdlib = source.splitStdlib;
     return Object.freeze(snapshot);
 }
 function resolveRubyBaseUrlFromSnapshot(options, configured, currentUrl = '') {
@@ -784,6 +785,10 @@ export function resolveRubyBaseUrl(options, currentUrl = '') {
 }
 export function resolveRubyRuntimeAssetConfig(options, currentUrl = '') {
     const configured = snapshotRubyRuntimeAssetConfig(options);
+    if (configured?.splitStdlib !== undefined && typeof configured.splitStdlib !== 'boolean')
+        throw new RuntimeConfigurationError('Ruby splitStdlib must be a boolean', {
+            runtimeId: 'RUBY'
+        });
     const publicModuleUrl = (publicEnv.PUBLIC_WASM_RUBY_MODULE_URL || '').trim();
     const publicWasmUrl = (publicEnv.PUBLIC_WASM_RUBY_WASM_URL || '').trim();
     const usesCustomTrustBoundary = Boolean((configured && RUBY_RUNTIME_CONFIG_KEYS.some((key) => configured[key] !== undefined)) ||
@@ -810,6 +815,10 @@ export function resolveRubyRuntimeAssetConfig(options, currentUrl = '') {
     catch (cause) {
         throw new RuntimeConfigurationError('Ruby runtime custom assets require one complete profile and receipt bundle.', { cause, runtimeId: 'RUBY' });
     }
+    if (configured?.splitStdlib &&
+        JSON.stringify(preflightProfile) !==
+            JSON.stringify(snapshotRubyRuntimePreflightProfile(RUBY_RUNTIME_BUNDLE.profile)))
+        throw new RuntimeConfigurationError('Ruby split stdlib is supported only for the bundled profile', { runtimeId: 'RUBY' });
     const baseUrl = resolveRubyBaseUrlFromSnapshot(options, configured, currentUrl);
     const resolvePinnedUrl = (configuredUrl, path, pin) => {
         const sentinelOrigin = 'https://wasm-idle.invalid';
@@ -845,11 +854,13 @@ export function resolveRubyRuntimeAssetConfig(options, currentUrl = '') {
     const moduleUrl = resolvePinnedUrl(configured?.moduleUrl || publicModuleUrl, RUBY_RUNTIME_MODULE_STORAGE_PATH, preflightProfile.moduleJavaScriptReceipt.sha256);
     const wasmUrl = resolvePinnedUrl(configured?.wasmUrl || publicWasmUrl, RUBY_RUNTIME_WASM_STORAGE_PATH, preflightProfile.wasmReceipt.sha256);
     return {
+        ...(configured?.splitStdlib === true ? { splitStdlib: true } : {}),
         baseUrl,
         manifestUrl,
         moduleUrl,
         wasmUrl,
         preflightKey: JSON.stringify({
+            ...(configured?.splitStdlib === true ? { splitStdlib: true } : {}),
             baseUrl,
             manifestUrl,
             moduleUrl,

package/dist/playground/clang.js

@@ -1,3 +1,4 @@
+import { shouldStreamBundledClang } from './clangStreamingPolicy';
 import { WorkerAssetBridge } from './assetBridge';
 import { resolveDebugRuntimeUrls, resolveRuntimeAssetConfig } from './assets';
 import { LldbSandboxSession } from './lldbSession';
@@ -88,9 +89,13 @@ class Clang {
             this.debugRuntimeBaseUrl = debugRuntime.baseUrl;
             this.debugManifestUrl = debugRuntime.manifestUrl;
             this.debugManifestReceipt = debugRuntime.manifestReceipt;
+            const bundledAssets = shouldStreamBundledClang(assetConfig);
+            const languageSysrootProfiles = bundledAssets &&
+                typeof runtimeAssets !== 'string' &&
+                runtimeAssets.clang?.bundledLanguageSysroots === true;
             const needsWorkerReset = !this.worker ||
                 !this.assetBridge ||
-                !this.assetBridge.matches(assetConfig, limits.maxAssetBytes);
+                !this.assetBridge.matches(assetConfig, limits.maxAssetBytes, languageSysrootProfiles);
             if (needsWorkerReset && this.worker) {
                 this.workerSession.reset();
             }
@@ -102,7 +107,7 @@ class Clang {
                 if (!this.workerSession.attach(worker, operation))
                     return;
                 this.worker = worker;
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress, limits.maxAssetBytes);
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress, limits.maxAssetBytes, languageSysrootProfiles);
                 this.worker.onmessage = (event) => {
                     if (!this.workerSession.isActive(operation))
                         return;
@@ -116,6 +121,8 @@ class Clang {
                 };
                 this.worker.postMessage({
                     load: true,
+                    verifiedStreaming: bundledAssets,
+                    languageSysrootProfiles,
                     log,
                     code,
                     args,
@@ -128,7 +135,7 @@ class Clang {
                 });
             }
             else {
-                this.assetBridge?.rebind(this.worker, assetConfig, progress, limits.maxAssetBytes);
+                this.assetBridge?.rebind(this.worker, assetConfig, progress, limits.maxAssetBytes, languageSysrootProfiles);
                 this.worker.postMessage({ log });
                 resolve();
             }

package/dist/playground/clangAssetIntegrity.d.ts

@@ -1,3 +1,11 @@
+export declare const BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES: Readonly<{
+    c: Readonly<{
+        asset: "bin/c-sysroot.tar.gz";
+    }>;
+    cppAddon: Readonly<{
+        asset: "bin/cpp-addon.tar.gz";
+    }>;
+}>;
 export declare const BUNDLED_CLANG_ASSET_INTEGRITY: Readonly<{
     'runtime-manifest.v1.json': Readonly<{
         bytes: number;
@@ -29,4 +37,22 @@ export declare const BUNDLED_CLANG_ASSET_INTEGRITY: Readonly<{
         uncompressedBytes: number;
         uncompressedSha256: string;
     }>;
+    'bin/c-sysroot.tar.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'bin/cpp-addon.tar.gz': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
+    'language-sysroots.v1.json': Readonly<{
+        bytes: number;
+        sha256: string;
+        uncompressedBytes: number;
+        uncompressedSha256: string;
+    }>;
 }>;

package/dist/playground/clangAssetIntegrity.js

@@ -1,8 +1,15 @@
 const integrityEntry = (bytes, sha256, uncompressedBytes = bytes, uncompressedSha256 = sha256) => Object.freeze({ bytes, sha256, uncompressedBytes, uncompressedSha256 });
+export const BUNDLED_CLANG_LANGUAGE_SYSROOT_PROFILES = Object.freeze({
+    c: Object.freeze({ asset: 'bin/c-sysroot.tar.gz' }),
+    cppAddon: Object.freeze({ asset: 'bin/cpp-addon.tar.gz' })
+});
 export const BUNDLED_CLANG_ASSET_INTEGRITY = Object.freeze({
     'runtime-manifest.v1.json': integrityEntry(876, '1420808d0391ff2d8a2fdf2a9f6bbce8f728e06b1ed1651029ed80b226101444'),
     'bin/memfs.wasm.gz': integrityEntry(18_974, 'd86f141eacd58a93511fbfb7c4e81d498eb7106a8a57df1bea7d33df3ce1f403', 345_442, '2c72ee42bd9430029dda8c6bafc9f37143f6fe88d5f1ea950a70259ab748bcfe'),
-    'bin/clang.wasm.gz': integrityEntry(15_721_977, 'b1174438d9a67b7ff11e623541b9a0572c024a9e798084b9b021dd9da2da0874', 44_159_206, '60747a8272f337195c961fb7b7140f0789360267845016f1abb026f056aad083'),
-    'bin/lld.wasm.gz': integrityEntry(7_837_837, 'f842a9b5df3c6d326f0260bfd313c11c2e22bc8b8ae0387deede9a4af55779cd', 20_795_796, '14f08c475b24ef45313cab7a086693525955c2c000b833faaaf48ad35b2521f8'),
-    'bin/sysroot.tar.gz': integrityEntry(5_059_892, '68437624a81c465b93895615e7afd3f235ff256de17dc1927b124e783614e3e4', 19_312_640, '963478e663d6ee2a3ae418ce7427f4535fb59831bb933f95938ccb2253cbb388')
+    'bin/clang.wasm.gz': integrityEntry(13_121_917, '8dc032057fbeb41e4a9986dfc54b2336c17532033dee172eb0095eba9c5fbe75', 35_658_969, 'd92ef06cdd3fea88acf384db15a6f2a344790c05bcba8e9f13f5b75b36ad4a99'),
+    'bin/lld.wasm.gz': integrityEntry(6_417_339, '495813efde8f354c38483749cdface7a7d9e23c8411da45a6f5f80030159eb11', 16_171_013, '34d39bc410c098e7e09933b61cc8e28699447af9a28abf4544d71b6e9cad1f9d'),
+    'bin/sysroot.tar.gz': integrityEntry(5_059_493, 'c0ef46e903492383a3c7069bfd4aed0e764e8df988f92bb81eb96bea50bf2c00', 19_312_640, 'e122f1acec0642d62d8976101c542aaa5346460df6eae5a3f8efb594ff32f5ae'),
+    'bin/c-sysroot.tar.gz': integrityEntry(1_216_797, 'fb3e1cdacac3eceddcfe2e57cbbf78e593ec2a298f01acb61c06e4b9d24fbbee', 3_736_064, '720c620e459025e918747768b9f5f1aef7b48c6df1b34c1a31fb2e5b1b7a213e'),
+    'bin/cpp-addon.tar.gz': integrityEntry(3_840_608, '47e9946c5aaeb3b35a1d42d6a80eae8987c596f4f858b207e492c00d8680af9e', 15_572_992, '7d61b724d377dc4e5670725055fb2884ebc8153d697e05093992004d5859310d'),
+    'language-sysroots.v1.json': integrityEntry(175_348, 'd69acbdb636009dc5b2243f13f1580264f64a34362f0af67c9cd661388b565d0')
 });

package/dist/playground/clangStreamingPolicy.d.ts

@@ -0,0 +1,6 @@
+/** A custom loader or custom trust profile must keep using the asset bridge. */
+export declare function shouldStreamBundledClang(config: {
+    loader?: unknown;
+    integrity?: unknown;
+    allowedBaseUrls?: readonly string[];
+}): boolean;

package/dist/playground/clangStreamingPolicy.js

@@ -0,0 +1,7 @@
+import { BUNDLED_CLANG_ASSET_INTEGRITY } from './clangAssetIntegrity';
+/** A custom loader or custom trust profile must keep using the asset bridge. */
+export function shouldStreamBundledClang(config) {
+    return (!config.loader &&
+        config.allowedBaseUrls === undefined &&
+        config.integrity === BUNDLED_CLANG_ASSET_INTEGRITY);
+}

package/dist/playground/dotnet.js

@@ -443,7 +443,8 @@ class Dotnet {
                     };
                     worker.postMessage({
                         load: true,
-                        moduleUrl: nextModuleUrl
+                        moduleUrl: nextModuleUrl,
+                        language: this.compileLanguage
                     });
                 }
                 else {

package/dist/playground/index.d.ts

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

package/dist/playground/index.js

@@ -350,8 +350,8 @@ for (const languageId of supportedLanguageIds) {
     }
 }
 export const supportedLanguages = [...supportedLanguageIds];
-export function createPlaygroundBinding(runtimeAssets) {
-    return createCorePlaygroundBinding(runtimeAssets, playground);
+export function createPlaygroundBinding(runtimeAssets, options = {}) {
+    return createCorePlaygroundBinding(runtimeAssets, playground, options);
 }
 async function playground(language, runtimeAssets) {
     const normalizedLanguage = normalizeLanguageId(language);

package/dist/playground/java.js

@@ -1,7 +1,7 @@
 import { resolveSandboxExecutionArgs } from './options';
 import { WorkerAssetBridge } from './assetBridge';
 import { resolveRuntimeAssetConfig } from './assets';
-import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TEAVM_RUNTIME_ASSET_NAMES, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TEAVM_RUNTIME_ASSET_NAMES, TEAVM_RUNTIME_ASSET_RECEIPTS, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
 import { resolveJavaSourceIdentity } from './javaSource';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
@@ -447,7 +447,13 @@ class Java {
                         load: true,
                         assets: {
                             baseUrl: assetConfig.baseUrl,
-                            useAssetBridge: assetConfig.useAssetBridge
+                            useAssetBridge: assetConfig.useAssetBridge,
+                            maxAssetBytes: limits.maxAssetBytes,
+                            streamCompiler: !assetConfig.loader && TEAVM_RUNTIME_ASSET_NAMES.every((asset) => {
+                                const receipt = assetConfig.integrity?.[asset];
+                                const expected = TEAVM_RUNTIME_ASSET_RECEIPTS[asset];
+                                return typeof receipt === 'object' && receipt.bytes === expected.bytes && receipt.sha256 === expected.sha256;
+                            })
                         }
                     });
                 }