wasm-idle 1.0.12 → 1.1.0

package/dist/playground/lean4.js

@@ -0,0 +1,50 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { LEAN4_DEFAULT_WASM_MEMORY_BYTES, preflightLean4RuntimeAssets, resolveLean4RuntimeAssetConfig } from './lean4Assets';
+function lean4ExecutionOptions(options = {}) {
+    return {
+        ...options,
+        limits: {
+            ...options.limits,
+            maxWasmMemoryBytes: options.limits?.maxWasmMemoryBytes ?? LEAN4_DEFAULT_WASM_MEMORY_BYTES
+        }
+    };
+}
+/** Upstream Lean 4 frontend and IR interpreter (`lean --run`) compiled to wasm32 Emscripten. */
+export default class Lean4 extends StaticWorkerRuntimeSandbox {
+    defaultExecutionLimits = Object.freeze({
+        maxWasmMemoryBytes: LEAN4_DEFAULT_WASM_MEMORY_BYTES
+    });
+    evidence;
+    constructor() {
+        const evidence = { current: undefined };
+        super({
+            displayName: 'Lean 4',
+            languageId: 'LEAN4',
+            defaultActivePath: 'Main.lean',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            onEvidence(value) {
+                evidence.current = value;
+            },
+            stdin: { mode: 'streaming', sourceHintPattern: /\b(?:getStdin|getLine|readToEnd)\b/u },
+            resolveRuntimeAssets: resolveLean4RuntimeAssetConfig,
+            async preflightRuntimeAssets(urls, context) {
+                evidence.current = undefined;
+                return context.createOwnedDelivery(await preflightLean4RuntimeAssets(urls.baseUrl, context));
+            }
+        });
+        this.evidence = evidence;
+    }
+    async load(...args) {
+        args[4] = lean4ExecutionOptions(args[4]);
+        return super.load(...args);
+    }
+    async run(...args) {
+        args[5] = lean4ExecutionOptions(args[5]);
+        return super.run(...args);
+    }
+}

package/dist/playground/lean4Assets.d.ts

@@ -0,0 +1,25 @@
+import { type ExecutionLimits, type RuntimeAssetCacheOptions } from '@wasm-idle/core';
+import type { PlaygroundRuntimeAssets } from './assets';
+/** Linear memory needed to start Lean, import Init, and interpret a small program. */
+export declare const LEAN4_INITIAL_MEMORY_BYTES: number;
+/** Default limit: importing the 277 MB Init library grows the heap to about 370 MiB. */
+export declare const LEAN4_DEFAULT_WASM_MEMORY_BYTES: number;
+export declare const LEAN4_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
+export declare function resolveLean4RuntimeAssetConfig(runtimeAssets: string | PlaygroundRuntimeAssets, currentUrl: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestFingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+    workerReceipt: {
+        readonly bytes: 15759;
+        readonly sha256: "469ef5ec7accf4c221d06134ccd4989f14e9229c61dd35c386617a015aec6f03";
+    };
+};
+export declare function preflightLean4RuntimeAssets(baseUrl: string, options: {
+    limits: ExecutionLimits;
+    persistentCache?: RuntimeAssetCacheOptions;
+    signal?: AbortSignal;
+    reportProgress?: (value: number, stage: string) => void;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Readonly<{
+    fingerprint: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+}>>;

package/dist/playground/lean4Assets.js

@@ -0,0 +1,123 @@
+import { defineRuntimeRegistryManifest, preflightRuntimeAssets, ResourceLimitError, RuntimeConfigurationError } from '@wasm-idle/core';
+import { WASM_LEAN4_PROFILE as profile } from './wasmLean4Version';
+/** Linear memory needed to start Lean, import Init, and interpret a small program. */
+export const LEAN4_INITIAL_MEMORY_BYTES = 256 * 1024 * 1024;
+/** Default limit: importing the 277 MB Init library grows the heap to about 370 MiB. */
+export const LEAN4_DEFAULT_WASM_MEMORY_BYTES = 1024 ** 3;
+const assets = Object.entries(profile.assets);
+function mediaType(name) {
+    if (name.endsWith('.mjs'))
+        return 'text/javascript';
+    if (name.endsWith('.json'))
+        return 'application/json';
+    if (name.startsWith('lean.wasm'))
+        return 'application/wasm';
+    return 'application/octet-stream';
+}
+export const LEAN4_RUNTIME_MANIFEST = defineRuntimeRegistryManifest({
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/lean4',
+    revision: profile.assets['producer-receipt.json'].sha256,
+    runtimes: [
+        {
+            runtimeId: 'LEAN4',
+            identity: {
+                languageId: 'LEAN4',
+                implementationId: 'lean4-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', 'shared-array-buffer'],
+            assetRoot: '.',
+            assets: assets.map(([name, receipt]) => ({
+                key: name,
+                path: name,
+                compressedSha256: receipt.sha256,
+                uncompressedSha256: receipt.uncompressed?.sha256 ?? receipt.sha256,
+                compressedBytes: receipt.bytes,
+                uncompressedBytes: receipt.uncompressed?.bytes ?? receipt.bytes,
+                encoding: receipt.encoding ?? 'identity',
+                mediaType: mediaType(name)
+            })),
+            contracts: {
+                routeId: 'LEAN4',
+                runtimeAssetKey: 'lean4',
+                documentationId: 'lean4',
+                syncTarget: 'sync:wasm-lean4',
+                browserTestId: 'LEAN4'
+            }
+        }
+    ]
+});
+export function resolveLean4RuntimeAssetConfig(runtimeAssets, currentUrl) {
+    const root = typeof runtimeAssets === 'string' ? runtimeAssets : runtimeAssets.rootUrl || '';
+    const override = typeof runtimeAssets === 'string' ? undefined : runtimeAssets.lean4?.baseUrl;
+    const baseUrl = new URL(override ?? `${root.replace(/\/+$/, '')}/wasm-lean4/`, currentUrl);
+    if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('Lean 4 requires a credential-free HTTP(S) asset directory.', { runtimeId: 'LEAN4' });
+    }
+    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 preflightLean4RuntimeAssets(baseUrl, options) {
+    if (options.limits.maxWasmMemoryBytes < LEAN4_INITIAL_MEMORY_BYTES) {
+        throw new ResourceLimitError('Lean 4 needs at least 256 MiB of Wasm memory.', {
+            runtimeId: 'LEAN4',
+            phase: 'asset',
+            resource: 'wasm-memory',
+            actual: LEAN4_INITIAL_MEMORY_BYTES,
+            limit: options.limits.maxWasmMemoryBytes
+        });
+    }
+    const loaded = new Map();
+    const total = assets.reduce((sum, [, asset]) => sum + asset.bytes, 0);
+    const result = await preflightRuntimeAssets({
+        manifest: LEAN4_RUNTIME_MANIFEST,
+        runtimeId: 'LEAN4',
+        rootUrl: baseUrl,
+        assetUrls: Object.fromEntries(assets.map(([name, asset]) => [name, new URL(`${name}?v=${asset.sha256}`, baseUrl)])),
+        limits: options.limits,
+        persistentCache: options.persistentCache,
+        signal: options.signal,
+        fetch: options.fetch,
+        redirect: 'error',
+        requireExactResponseUrl: true,
+        maxConcurrentDownloads: 3,
+        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, `Downloading Lean 4 ${progress.assetKey}`);
+        }
+    });
+    return Object.freeze({
+        fingerprint: profile.assets['producer-receipt.json'].sha256,
+        ...Object.fromEntries(Object.entries(result.assets).map(([name, asset]) => [name, asset.bytes]))
+    });
+}

package/dist/playground/loadingProgress.js

@@ -89,7 +89,10 @@ export function createLoadingProgressController({ onChange }) {
         const estimate = typeof event.estimatedFraction === 'number' && Number.isFinite(event.estimatedFraction)
             ? event.estimatedFraction
             : estimatedPhaseProgress[event.phase];
-        const estimatedValue = Math.min(0.99, Math.max(state.value, estimate, 0));
+        // Cap new estimates, not a previously completed byte measurement. Otherwise a
+        // late unmeasured sample regresses the same visible phase from 100% to 99%.
+        // A different measured phase still uses its own local denominator below.
+        const estimatedValue = Math.max(state.value, Math.min(0.99, Math.max(estimate, 0)));
         const { measurement } = event;
         if (!measurement) {
             state = {

package/dist/playground/wasmCommonLispVersion.d.ts

@@ -0,0 +1,32 @@
+export declare const WASM_COMMONLISP_PROFILE: {
+    readonly schemaVersion: 1;
+    readonly profileId: "ecl-26.5.5-emscripten-6.0.0-wasm-llvm-71568b3";
+    readonly licenseExpression: "LGPL-2.1-or-later";
+    readonly source: "74780fa2cd2874889793a657d55b557488d3e346";
+    readonly version: "26.5.5";
+    readonly producerRevision: "71568b3cb598c0705bd75a59730ffd74ef8dee2d";
+    readonly assets: {
+        readonly 'producer-receipt.json': {
+            readonly bytes: 6154;
+            readonly sha256: "56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071";
+        };
+        readonly 'ecl.mjs': {
+            readonly bytes: 77142;
+            readonly sha256: "c9a2df8f418f637a2f5dc4a52842463a5a9df1a2dc5d24038ad01adb93969fa7";
+        };
+        readonly 'ecl.wasm.gz': {
+            readonly bytes: 1535867;
+            readonly sha256: "2d8d273a602db2e9677dd185351cf3019f3c31be0e0d6b4c14f7356f8f353a16";
+        };
+    };
+    readonly runtime: {
+        readonly 'ecl.wasm': {
+            readonly bytes: 4560196;
+            readonly sha256: "9aa43374a0fd991d841628eb209fbfd78e938636732692662f719383e52184c4";
+        };
+    };
+    readonly workerReceipt: {
+        readonly bytes: 11814;
+        readonly sha256: "46b24c0fbde93dfaa71ddbce697d717c772ad8fd03f8486ad2102c41145606c6";
+    };
+};

package/dist/playground/wasmCommonLispVersion.js

@@ -0,0 +1,33 @@
+// Generated by sync:wasm-commonlisp from the reviewed asset lock.
+export const WASM_COMMONLISP_PROFILE = {
+    schemaVersion: 1,
+    profileId: 'ecl-26.5.5-emscripten-6.0.0-wasm-llvm-71568b3',
+    licenseExpression: 'LGPL-2.1-or-later',
+    source: '74780fa2cd2874889793a657d55b557488d3e346',
+    version: '26.5.5',
+    producerRevision: '71568b3cb598c0705bd75a59730ffd74ef8dee2d',
+    assets: {
+        'producer-receipt.json': {
+            bytes: 6154,
+            sha256: '56f1eb7cf6470619cb3393e99d5c8ad1841a001ab758f388c006ca1d801ba071'
+        },
+        'ecl.mjs': {
+            bytes: 77142,
+            sha256: 'c9a2df8f418f637a2f5dc4a52842463a5a9df1a2dc5d24038ad01adb93969fa7'
+        },
+        'ecl.wasm.gz': {
+            bytes: 1535867,
+            sha256: '2d8d273a602db2e9677dd185351cf3019f3c31be0e0d6b4c14f7356f8f353a16'
+        }
+    },
+    runtime: {
+        'ecl.wasm': {
+            bytes: 4560196,
+            sha256: '9aa43374a0fd991d841628eb209fbfd78e938636732692662f719383e52184c4'
+        }
+    },
+    workerReceipt: {
+        bytes: 11814,
+        sha256: '46b24c0fbde93dfaa71ddbce697d717c772ad8fd03f8486ad2102c41145606c6'
+    }
+};

package/dist/playground/wasmLean4Version.d.ts

@@ -0,0 +1,110 @@
+export declare const WASM_LEAN4_PROFILE: {
+    readonly schemaVersion: 1;
+    readonly profileId: "lean4-4.34.1-wasm32-emscripten-v1";
+    readonly source: "5045d0056413266e57c625dcd7c365b10e377c52";
+    readonly version: "4.34.1";
+    readonly license: "Apache-2.0 AND MIT";
+    readonly producer: {
+        readonly repository: "https://github.com/seo-rii/wasm-llvm";
+        readonly revision: "5369745f777673710c25cd67c52310b004cfe41a";
+        readonly path: "artifacts/lean-browser";
+    };
+    readonly assets: {
+        readonly 'producer-receipt.json': {
+            readonly upstream: "producer-receipt.json";
+            readonly bytes: 4596;
+            readonly sha256: "e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1";
+        };
+        readonly 'lean.mjs': {
+            readonly upstream: "lean.mjs";
+            readonly bytes: 108528;
+            readonly sha256: "16d6d6cb07c844bedf745f856a364ec61e86c13c4fe13a2e57c0c698a5c5f727";
+        };
+        readonly 'lean.wasm.gz.bin': {
+            readonly upstream: "lean.wasm.gz";
+            readonly logicalName: "lean.wasm";
+            readonly encoding: "gzip";
+            readonly bytes: 20239874;
+            readonly sha256: "89dc3cb841d487f9e29c1dc3069e7aeb1a63e5ec0267b8250552e3fe90f855bf";
+            readonly uncompressed: {
+                readonly bytes: 113033667;
+                readonly sha256: "d81dbde2ba4aaf0546affca2756477b6d1365a5633080d7119f737e5906ed919";
+            };
+        };
+        readonly 'lean-init.index.json': {
+            readonly upstream: "lean-init.index.json";
+            readonly bytes: 321866;
+            readonly sha256: "030b375cee435f12f7163c58c16d128340f9e20fa27a77ab646198be61906555";
+        };
+        readonly 'lean-init-00.pack.gz.bin': {
+            readonly upstream: "lean-init-00.pack.gz";
+            readonly logicalName: "lean-init-00.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 22626621;
+            readonly sha256: "c2cea0798b8b3e910188eb79d3d0101452c874f693294d2cf8c360fde125c08e";
+            readonly uncompressed: {
+                readonly bytes: 50331648;
+                readonly sha256: "19734bd892d96cbf4ec7b1d13e1bdccbbee022f3288908ee535e2facfc99d483";
+            };
+        };
+        readonly 'lean-init-01.pack.gz.bin': {
+            readonly upstream: "lean-init-01.pack.gz";
+            readonly logicalName: "lean-init-01.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 22633878;
+            readonly sha256: "6e65383d8de425a0c0f5b48430aa5be7c9f2066138080bf213a0435b0fd1d874";
+            readonly uncompressed: {
+                readonly bytes: 50331648;
+                readonly sha256: "2ea9fcd0ede724bfc93bf032b7ee3d09724fbd83a17afaaaad534859e74b1200";
+            };
+        };
+        readonly 'lean-init-02.pack.gz.bin': {
+            readonly upstream: "lean-init-02.pack.gz";
+            readonly logicalName: "lean-init-02.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 23039094;
+            readonly sha256: "57cc57d61067fc77d8b72008299e25956a121cd3fdf628941420966de1f762e5";
+            readonly uncompressed: {
+                readonly bytes: 50331648;
+                readonly sha256: "75273ea353191316cb8fc31900ef36ffa7424a4bd62061cdbbba8477510ed3bc";
+            };
+        };
+        readonly 'lean-init-03.pack.gz.bin': {
+            readonly upstream: "lean-init-03.pack.gz";
+            readonly logicalName: "lean-init-03.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 22382973;
+            readonly sha256: "e310ddf310d6d89dc7cc583f01213a1eab2684c1ada9e77368ca16637009d72a";
+            readonly uncompressed: {
+                readonly bytes: 50331648;
+                readonly sha256: "480c12f5b808c18f692e9f5f5666bee3c6a2b0473075a3dd1417039b2bf05553";
+            };
+        };
+        readonly 'lean-init-04.pack.gz.bin': {
+            readonly upstream: "lean-init-04.pack.gz";
+            readonly logicalName: "lean-init-04.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 21886461;
+            readonly sha256: "f1345c223483bbb8e3c25e73042c5526efbd24301df95c74d30b4799493e6697";
+            readonly uncompressed: {
+                readonly bytes: 50331648;
+                readonly sha256: "5daed6ecf33bfb049e294c72ed161d6a0260440aa371b2be34f26b78377e1178";
+            };
+        };
+        readonly 'lean-init-05.pack.gz.bin': {
+            readonly upstream: "lean-init-05.pack.gz";
+            readonly logicalName: "lean-init-05.pack";
+            readonly encoding: "gzip";
+            readonly bytes: 9812693;
+            readonly sha256: "9f8deb32469cbe66669381c8f0fb5d379d506f7935beb29393b19d2c52ac8a52";
+            readonly uncompressed: {
+                readonly bytes: 24923128;
+                readonly sha256: "73ca4bd7a0d07f15d3b88298b7dd273406a92e36da96cb555ebb986ee85b7b14";
+            };
+        };
+    };
+    readonly workerReceipt: {
+        readonly bytes: 15759;
+        readonly sha256: "469ef5ec7accf4c221d06134ccd4989f14e9229c61dd35c386617a015aec6f03";
+    };
+};

package/dist/playground/wasmLean4Version.js

@@ -0,0 +1,111 @@
+// Generated by sync:wasm-lean4 from the reviewed asset lock.
+export const WASM_LEAN4_PROFILE = {
+    schemaVersion: 1,
+    profileId: 'lean4-4.34.1-wasm32-emscripten-v1',
+    source: '5045d0056413266e57c625dcd7c365b10e377c52',
+    version: '4.34.1',
+    license: 'Apache-2.0 AND MIT',
+    producer: {
+        repository: 'https://github.com/seo-rii/wasm-llvm',
+        revision: '5369745f777673710c25cd67c52310b004cfe41a',
+        path: 'artifacts/lean-browser'
+    },
+    assets: {
+        'producer-receipt.json': {
+            upstream: 'producer-receipt.json',
+            bytes: 4596,
+            sha256: 'e60eb3fdcc108fa7c6127c5a8925ffb622706facb17bc4f84e9ed27f82495fa1'
+        },
+        'lean.mjs': {
+            upstream: 'lean.mjs',
+            bytes: 108528,
+            sha256: '16d6d6cb07c844bedf745f856a364ec61e86c13c4fe13a2e57c0c698a5c5f727'
+        },
+        'lean.wasm.gz.bin': {
+            upstream: 'lean.wasm.gz',
+            logicalName: 'lean.wasm',
+            encoding: 'gzip',
+            bytes: 20239874,
+            sha256: '89dc3cb841d487f9e29c1dc3069e7aeb1a63e5ec0267b8250552e3fe90f855bf',
+            uncompressed: {
+                bytes: 113033667,
+                sha256: 'd81dbde2ba4aaf0546affca2756477b6d1365a5633080d7119f737e5906ed919'
+            }
+        },
+        'lean-init.index.json': {
+            upstream: 'lean-init.index.json',
+            bytes: 321866,
+            sha256: '030b375cee435f12f7163c58c16d128340f9e20fa27a77ab646198be61906555'
+        },
+        'lean-init-00.pack.gz.bin': {
+            upstream: 'lean-init-00.pack.gz',
+            logicalName: 'lean-init-00.pack',
+            encoding: 'gzip',
+            bytes: 22626621,
+            sha256: 'c2cea0798b8b3e910188eb79d3d0101452c874f693294d2cf8c360fde125c08e',
+            uncompressed: {
+                bytes: 50331648,
+                sha256: '19734bd892d96cbf4ec7b1d13e1bdccbbee022f3288908ee535e2facfc99d483'
+            }
+        },
+        'lean-init-01.pack.gz.bin': {
+            upstream: 'lean-init-01.pack.gz',
+            logicalName: 'lean-init-01.pack',
+            encoding: 'gzip',
+            bytes: 22633878,
+            sha256: '6e65383d8de425a0c0f5b48430aa5be7c9f2066138080bf213a0435b0fd1d874',
+            uncompressed: {
+                bytes: 50331648,
+                sha256: '2ea9fcd0ede724bfc93bf032b7ee3d09724fbd83a17afaaaad534859e74b1200'
+            }
+        },
+        'lean-init-02.pack.gz.bin': {
+            upstream: 'lean-init-02.pack.gz',
+            logicalName: 'lean-init-02.pack',
+            encoding: 'gzip',
+            bytes: 23039094,
+            sha256: '57cc57d61067fc77d8b72008299e25956a121cd3fdf628941420966de1f762e5',
+            uncompressed: {
+                bytes: 50331648,
+                sha256: '75273ea353191316cb8fc31900ef36ffa7424a4bd62061cdbbba8477510ed3bc'
+            }
+        },
+        'lean-init-03.pack.gz.bin': {
+            upstream: 'lean-init-03.pack.gz',
+            logicalName: 'lean-init-03.pack',
+            encoding: 'gzip',
+            bytes: 22382973,
+            sha256: 'e310ddf310d6d89dc7cc583f01213a1eab2684c1ada9e77368ca16637009d72a',
+            uncompressed: {
+                bytes: 50331648,
+                sha256: '480c12f5b808c18f692e9f5f5666bee3c6a2b0473075a3dd1417039b2bf05553'
+            }
+        },
+        'lean-init-04.pack.gz.bin': {
+            upstream: 'lean-init-04.pack.gz',
+            logicalName: 'lean-init-04.pack',
+            encoding: 'gzip',
+            bytes: 21886461,
+            sha256: 'f1345c223483bbb8e3c25e73042c5526efbd24301df95c74d30b4799493e6697',
+            uncompressed: {
+                bytes: 50331648,
+                sha256: '5daed6ecf33bfb049e294c72ed161d6a0260440aa371b2be34f26b78377e1178'
+            }
+        },
+        'lean-init-05.pack.gz.bin': {
+            upstream: 'lean-init-05.pack.gz',
+            logicalName: 'lean-init-05.pack',
+            encoding: 'gzip',
+            bytes: 9812693,
+            sha256: '9f8deb32469cbe66669381c8f0fb5d379d506f7935beb29393b19d2c52ac8a52',
+            uncompressed: {
+                bytes: 24923128,
+                sha256: '73ca4bd7a0d07f15d3b88298b7dd273406a92e36da96cb555ebb986ee85b7b14'
+            }
+        }
+    },
+    workerReceipt: {
+        bytes: 15759,
+        sha256: '469ef5ec7accf4c221d06134ccd4989f14e9229c61dd35c386617a015aec6f03'
+    }
+};

package/dist/playground/worker/java.js

@@ -1,5 +1,5 @@
 import { acceptCompiledTeaVmModule, loadStreamingJavaCompiler } from './javaStreaming';
-import { prepareJavaStdinInjection } from '../javaStdin';
+import { createJavaStdinBridge, prepareJavaRuntimeStdinInjection } from '../javaRuntimeStdin';
 import { resolveJavaSourceIdentity } from '../javaSource';
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
@@ -9,9 +9,6 @@ let runtimeLoad = null;
 let loadedBaseUrl = '';
 let stdoutBuffer = '';
 let stderrBuffer = '';
-let stdinBufferJava = null;
-let stdinChunkJava = new Uint8Array(0);
-let stdinChunkOffsetJava = 0;
 let compiledCode = '';
 let compiledStdin = '';
 let compiledMainClass = '';
@@ -111,7 +108,7 @@ self.addEventListener('message', async (event) => {
         stdoutBuffer = '';
         stderrBuffer = '';
         const explicitStdin = hasExplicitStdin === true;
-        const stdinInjection = prepareJavaStdinInjection(code, stdin, explicitStdin);
+        const stdinInjection = prepareJavaRuntimeStdinInjection(code);
         const sourceIdentity = resolveJavaSourceIdentity(code);
         const sourcePath = typeof activePath === 'string' && activePath ? activePath : sourceIdentity.sourcePath;
         const sourceFileName = sourcePath.split('/').pop() || sourcePath;
@@ -233,29 +230,19 @@ self.addEventListener('message', async (event) => {
             self.postMessage({ results: true });
             return;
         }
-        stdinBufferJava = new Int32Array(buffer);
-        stdinChunkJava = explicitStdin ? new Uint8Array(0) : new TextEncoder().encode(stdin);
-        stdinChunkOffsetJava = 0;
+        const stdinBufferJava = new Int32Array(buffer);
+        const stdinBridge = createJavaStdinBridge(stdin, explicitStdin, () => {
+            // Publish prompts before the host blocks waiting for interactive input.
+            flushStdout();
+            flushStderr();
+            return waitForBufferedStdin(stdinBufferJava, () => self.postMessage({ buffer: true }));
+        });
         const workerGlobal = globalThis;
         const previousWindow = workerGlobal.window;
+        const hadStdinBridge = Object.prototype.hasOwnProperty.call(workerGlobal, 'wasmIdleJavaStdin');
+        const previousStdinBridge = workerGlobal.wasmIdleJavaStdin;
         workerGlobal.window = workerGlobal;
-        workerGlobal.wasmIdleJavaStdin = {
-            readByte() {
-                while (true) {
-                    if (stdinChunkOffsetJava < stdinChunkJava.length) {
-                        return stdinChunkJava[stdinChunkOffsetJava++] ?? -1;
-                    }
-                    if (explicitStdin)
-                        return -1;
-                    const chunk = waitForBufferedStdin(stdinBufferJava, () => self.postMessage({ buffer: true }));
-                    if (chunk === null) {
-                        return -1;
-                    }
-                    stdinChunkJava = new TextEncoder().encode(chunk);
-                    stdinChunkOffsetJava = 0;
-                }
-            }
-        };
+        workerGlobal.wasmIdleJavaStdin = stdinBridge;
         try {
             const module = await runtimeLoad(compiledWasm, {
                 installImports(imports) {
@@ -280,16 +267,17 @@ self.addEventListener('message', async (event) => {
             self.postMessage({ results: true, mainClass: compiledMainClass });
         }
         finally {
-            delete workerGlobal.wasmIdleJavaStdin;
+            stdinBridge.dispose();
+            if (hadStdinBridge)
+                workerGlobal.wasmIdleJavaStdin = previousStdinBridge;
+            else
+                delete workerGlobal.wasmIdleJavaStdin;
             if (previousWindow === undefined) {
                 Reflect.deleteProperty(workerGlobal, 'window');
             }
             else {
                 workerGlobal.window = previousWindow;
             }
-            stdinChunkJava = new Uint8Array(0);
-            stdinChunkOffsetJava = 0;
-            stdinBufferJava = null;
         }
     }
     catch (error) {