wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/haskell.js

@@ -0,0 +1,465 @@
+import { ConsoleStdout, Directory, File, OpenFile, PreopenDirectory, WASI, wasi } from '@bjorn3/browser_wasi_shim';
+import { installWasiExtractionQuota } from '@wasm-idle/llvm-core';
+import { loadVerifiedHaskellRuntimeAssets, snapshotHaskellRuntimeAssetConfig } from '../haskellAssets';
+import { waitForBufferedStdin } from '../stdinBuffer';
+let moduleUrl = '';
+let rootfsUrl = '';
+let bsdtarUrl = '';
+let integrity = null;
+let maxAssetBytes = 128 * 1024 * 1024;
+let mainSoPath = '/tmp/libplayground001.so';
+let searchDirs = ['/tmp/clib', '/tmp/hslib/lib/wasm32-wasi-ghc-9.14.0.20251031-inplace'];
+let loadedAssetKey = '';
+let runtimePromise = null;
+let activeStderrCollector = null;
+let activeDiagnosticPaths = null;
+const encoder = new TextEncoder();
+const workspaceRootName = 'wasm-idle-workspace';
+const workspaceRootPath = `/tmp/${workspaceRootName}`;
+class HaskellStdin {
+    fixedStdin = false;
+    initialStdinPending = false;
+    initialStdin = null;
+    buffer = null;
+    chunk = new Uint8Array(0);
+    offset = 0;
+    log = false;
+    reset({ stdin, buffer, log }) {
+        this.fixedStdin = typeof stdin === 'string';
+        this.initialStdinPending = this.fixedStdin;
+        this.initialStdin = typeof stdin === 'string' ? stdin : null;
+        this.buffer = buffer ? new Int32Array(buffer) : null;
+        this.chunk = new Uint8Array(0);
+        this.offset = 0;
+        this.log = log;
+    }
+    fd_fdstat_get() {
+        const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
+        fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
+        fdstat.fs_rights_inherited = 0n;
+        return { ret: wasi.ERRNO_SUCCESS, fdstat };
+    }
+    fd_filestat_get() {
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            filestat: new wasi.Filestat(0n, wasi.FILETYPE_CHARACTER_DEVICE, 0n)
+        };
+    }
+    fd_read(size) {
+        if (this.offset >= this.chunk.length) {
+            const nextChunk = this.readNextChunk();
+            if (nextChunk === null) {
+                this.chunk = new Uint8Array(0);
+                this.offset = 0;
+                return { ret: wasi.ERRNO_SUCCESS, data: new Uint8Array(0) };
+            }
+            this.chunk = encoder.encode(nextChunk);
+            this.offset = 0;
+        }
+        const end = Math.min(this.offset + size, this.chunk.length);
+        const data = this.chunk.slice(this.offset, end);
+        this.offset = end;
+        return { ret: wasi.ERRNO_SUCCESS, data };
+    }
+    readNextChunk() {
+        if (this.initialStdinPending) {
+            this.initialStdinPending = false;
+            const chunk = this.initialStdin ?? '';
+            this.initialStdin = null;
+            this.logRead(chunk);
+            return chunk;
+        }
+        if (this.fixedStdin) {
+            this.logRead(null);
+            return null;
+        }
+        if (!this.buffer) {
+            this.logRead(null);
+            return null;
+        }
+        const chunk = waitForBufferedStdin(this.buffer, () => postMessage({ buffer: true }));
+        this.logRead(chunk);
+        return chunk;
+    }
+    logRead(chunk) {
+        if (!this.log)
+            return;
+        if (chunk === null) {
+            console.log('[wasm-idle:haskell-stdin] fd_read(bytes=0, eof=true)');
+            return;
+        }
+        console.log(`[wasm-idle:haskell-stdin] fd_read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+    }
+}
+function postProgress(percent) {
+    postMessage({ progress: { percent: Math.max(0, Math.min(100, percent)) } });
+}
+function outputLine(line) {
+    postMessage({ output: line.endsWith('\n') ? line : `${line}\n` });
+}
+function remapDiagnosticPath(line) {
+    const match = /^(.*?)(:\d+:\d+:\s+(?:error|warning):)/i.exec(line);
+    if (!match)
+        return line;
+    const workspacePath = activeDiagnosticPaths?.get(match[1]);
+    return workspacePath ? `${workspacePath}${line.slice(match[1].length)}` : line;
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function instantiateResult(result) {
+    return result instanceof WebAssembly.Instance ? result : result.instance;
+}
+function installRootfsExtractionWasiPatches(tarWasi, pendingSymlinks) {
+    const extractionQuota = installWasiExtractionQuota(tarWasi, {
+        label: 'Haskell rootfs'
+    });
+    tarWasi.wasiImport.fd_filestat_set_times = () => wasi.ERRNO_SUCCESS;
+    tarWasi.wasiImport.path_filestat_set_times = () => wasi.ERRNO_SUCCESS;
+    tarWasi.wasiImport.path_symlink = (oldPathPointer, oldPathLength, fd, newPathPointer, newPathLength) => {
+        if (!tarWasi.fds[fd])
+            return wasi.ERRNO_BADF;
+        const symlink = extractionQuota.readSymlink(tarWasi, oldPathPointer, oldPathLength, newPathPointer, newPathLength);
+        extractionQuota.recordEntry(symlink.path);
+        pendingSymlinks.push(symlink);
+        return wasi.ERRNO_SUCCESS;
+    };
+}
+function materializeRootfsSymlinks(rootfs, pendingSymlinks) {
+    for (const symlink of pendingSymlinks) {
+        const linkPath = symlink.path;
+        const { ret, inode_obj: inode } = rootfs.path_lookup(symlink.resolvedTarget, 0);
+        if (ret !== wasi.ERRNO_SUCCESS || !inode) {
+            throw new Error(`failed to resolve Haskell rootfs symlink ${linkPath} -> ${symlink.target}`);
+        }
+        const linkRet = rootfs.path_link(linkPath, inode, false);
+        if (linkRet !== wasi.ERRNO_SUCCESS) {
+            throw new Error(`failed to materialize Haskell rootfs symlink ${linkPath}`);
+        }
+    }
+}
+async function unpackRootfs(bsdtarBytes, rootfsBytes) {
+    const rootfs = new PreopenDirectory('/', new Map());
+    const pendingSymlinks = [];
+    let tarOutput = '';
+    const tarStdout = ConsoleStdout.lineBuffered((line) => {
+        tarOutput += `${line}\n`;
+    });
+    const tarStderr = ConsoleStdout.lineBuffered((line) => {
+        tarOutput += `${line}\n`;
+    });
+    const tarWasi = new WASI(['bsdtar.wasm', '-x'], [], [
+        new OpenFile(new File(new Uint8Array(), { readonly: true })),
+        tarStdout,
+        tarStderr,
+        rootfs
+    ], { debug: false });
+    installRootfsExtractionWasiPatches(tarWasi, pendingSymlinks);
+    postProgress(75);
+    const tarInstance = instantiateResult(await WebAssembly.instantiate(bsdtarBytes, {
+        wasi_snapshot_preview1: tarWasi.wasiImport
+    }));
+    tarWasi.fds[0] = new OpenFile(new File(rootfsBytes, { readonly: true }));
+    const exitCode = tarWasi.start(tarInstance);
+    if (typeof exitCode === 'number' && exitCode !== 0) {
+        throw new Error(tarOutput || `bsdtar exited with code ${exitCode}`);
+    }
+    materializeRootfsSymlinks(rootfs, pendingSymlinks);
+    postProgress(90);
+    return rootfs;
+}
+async function createRuntime() {
+    if (!moduleUrl || !rootfsUrl || !bsdtarUrl || !integrity) {
+        throw new Error('Haskell runtime is not configured. Set PUBLIC_WASM_HASKELL_MODULE_URL, PUBLIC_WASM_HASKELL_ROOTFS_URL, and PUBLIC_WASM_HASKELL_BSDTAR_URL, or runtimeAssets.haskell.');
+    }
+    const assetKey = JSON.stringify({
+        moduleUrl,
+        rootfsUrl,
+        bsdtarUrl,
+        integrity,
+        maxAssetBytes,
+        mainSoPath,
+        searchDirs
+    });
+    if (loadedAssetKey === assetKey && runtimePromise) {
+        return await runtimePromise;
+    }
+    const pendingRuntime = (async () => {
+        postProgress(5);
+        const verified = await loadVerifiedHaskellRuntimeAssets({
+            moduleUrl,
+            rootfsUrl,
+            bsdtarUrl,
+            integrity,
+            maxAssetBytes
+        }, {
+            onProgress({ asset, loaded, total }) {
+                if (!total || total <= 0)
+                    return;
+                const [start, end] = asset === 'dyld.mjs'
+                    ? [5, 15]
+                    : asset === 'bsdtar.wasm'
+                        ? [15, 25]
+                        : [25, 70];
+                postProgress(start + ((end - start) * loaded) / total);
+            }
+        });
+        const rootfs = await unpackRootfs(verified.bsdtarBytes, verified.rootfsBytes);
+        const verifiedModuleUrl = URL.createObjectURL(new Blob([verified.moduleSource], { type: 'text/javascript' }));
+        let dyldModule;
+        try {
+            dyldModule = await import(/* @vite-ignore */ verifiedModuleUrl);
+        }
+        finally {
+            URL.revokeObjectURL(verifiedModuleUrl);
+        }
+        if (typeof dyldModule.main !== 'function' ||
+            typeof dyldModule.DyLDBrowserHost !== 'function') {
+            throw new Error('wasm-haskell module must export main and DyLDBrowserHost');
+        }
+        const stdin = new HaskellStdin();
+        const host = new dyldModule.DyLDBrowserHost({
+            rootfs,
+            stdin,
+            stdout: outputLine,
+            stderr(line) {
+                const mappedLine = remapDiagnosticPath(line);
+                activeStderrCollector?.(mappedLine);
+                outputLine(mappedLine);
+            }
+        });
+        const dyld = await dyldModule.main({
+            rpc: host,
+            searchDirs,
+            mainSoPath,
+            args: [mainSoPath.split('/').pop() || 'libplayground001.so', '+RTS', '-c', '-RTS'],
+            isIserv: false
+        });
+        const exportedMain = dyld?.exportFuncs?.myMain;
+        if (typeof exportedMain !== 'function') {
+            throw new Error('wasm-haskell runtime did not export myMain');
+        }
+        const mainFunc = await exportedMain('/tmp/hslib/lib');
+        if (typeof mainFunc !== 'function') {
+            throw new Error('wasm-haskell myMain did not return a callable function');
+        }
+        postProgress(100);
+        return { mainFunc, rootfs, stdin };
+    })();
+    loadedAssetKey = assetKey;
+    runtimePromise = pendingRuntime;
+    try {
+        return await pendingRuntime;
+    }
+    catch (error) {
+        if (runtimePromise === pendingRuntime) {
+            runtimePromise = null;
+            loadedAssetKey = '';
+        }
+        throw error;
+    }
+}
+export function parseHaskellDiagnostics(output) {
+    const diagnostics = [];
+    const lines = output.split(/\r\n|\r|\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = /^(.*?):(\d+):(\d+):\s+(error|warning):\s*(.*)$/i.exec(lines[index]);
+        if (!match)
+            continue;
+        let message = match[5].trim();
+        if (!message) {
+            for (const extraLine of lines.slice(index + 1)) {
+                const trimmed = extraLine.trim();
+                if (!trimmed || trimmed === '|' || /^\d+\s+\|/.test(trimmed))
+                    continue;
+                message = trimmed;
+                break;
+            }
+        }
+        diagnostics.push({
+            fileName: match[1] || null,
+            lineNumber: Math.max(1, Number(match[2] || 1)),
+            columnNumber: Math.max(1, Number(match[3] || 1)),
+            severity: match[4].toLowerCase() === 'warning' ? 'warning' : 'error',
+            message: message || lines[index]
+        });
+    }
+    return diagnostics;
+}
+function createWorkspaceTree() {
+    return { directories: new Map(), files: new Map() };
+}
+function encodeWorkspacePath(path) {
+    return path
+        .split('/')
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+}
+function addWorkspaceFile(tree, encodedPath, content) {
+    const pathParts = encodedPath.split('/');
+    const fileName = pathParts.pop();
+    if (!fileName)
+        throw new Error(`Invalid Haskell workspace path: ${encodedPath}`);
+    let directory = tree;
+    for (const pathPart of pathParts) {
+        if (directory.files.has(pathPart)) {
+            throw new Error(`Haskell workspace path collides with a file: ${encodedPath}`);
+        }
+        let child = directory.directories.get(pathPart);
+        if (!child) {
+            child = createWorkspaceTree();
+            directory.directories.set(pathPart, child);
+        }
+        directory = child;
+    }
+    if (directory.directories.has(fileName)) {
+        throw new Error(`Haskell workspace path collides with a directory: ${encodedPath}`);
+    }
+    directory.files.set(fileName, encoder.encode(content));
+}
+function materializeWorkspaceTree(tree) {
+    const contents = [];
+    for (const [name, directory] of tree.directories) {
+        contents.push([name, materializeWorkspaceTree(directory)]);
+    }
+    for (const [name, content] of tree.files) {
+        contents.push([name, new File(content, { readonly: true })]);
+    }
+    return new Directory(contents);
+}
+function addImportRoot(importRoots, seen, encodedDirectory) {
+    const root = encodedDirectory ? `${workspaceRootPath}/${encodedDirectory}` : workspaceRootPath;
+    if (seen.has(root))
+        return;
+    seen.add(root);
+    importRoots.push(root);
+}
+function addFileImportRoots(importRoots, seen, encodedPath) {
+    const directoryParts = encodedPath.split('/').slice(0, -1);
+    for (let length = directoryParts.length; length >= 0; length -= 1) {
+        addImportRoot(importRoots, seen, directoryParts.slice(0, length).join('/'));
+    }
+}
+function mountWorkspace(rootfs, code, activePath, workspaceFiles) {
+    const sourceFiles = new Map();
+    for (const file of workspaceFiles) {
+        if (file.path !== activePath)
+            sourceFiles.set(file.path, file.content);
+    }
+    sourceFiles.set(activePath, code);
+    const tree = createWorkspaceTree();
+    const diagnosticPaths = new Map([
+        ['/tmp/Main.hs', activePath],
+        ['tmp/Main.hs', activePath],
+        ['Main.hs', activePath]
+    ]);
+    const encodedPaths = new Map();
+    for (const [path, content] of sourceFiles) {
+        const encodedPath = encodeWorkspacePath(path);
+        encodedPaths.set(path, encodedPath);
+        addWorkspaceFile(tree, encodedPath, content);
+        const absolutePath = `${workspaceRootPath}/${encodedPath}`;
+        diagnosticPaths.set(absolutePath, path);
+        diagnosticPaths.set(absolutePath.slice(1), path);
+    }
+    let tmp = rootfs.dir.contents.get('tmp');
+    if (tmp === undefined) {
+        tmp = new Directory(new Map());
+        rootfs.dir.contents.set('tmp', tmp);
+    }
+    if (!(tmp instanceof Directory)) {
+        throw new Error('Haskell runtime rootfs /tmp entry is not a directory');
+    }
+    tmp.contents.set(workspaceRootName, materializeWorkspaceTree(tree));
+    const importRoots = [];
+    const seenImportRoots = new Set();
+    const encodedActivePath = encodedPaths.get(activePath);
+    if (encodedActivePath) {
+        addFileImportRoots(importRoots, seenImportRoots, encodedActivePath);
+    }
+    for (const [path, encodedPath] of encodedPaths) {
+        if (path !== activePath)
+            addFileImportRoots(importRoots, seenImportRoots, encodedPath);
+    }
+    return {
+        diagnosticPaths,
+        importRoots,
+        hasAuxiliaryFiles: sourceFiles.size > 1
+    };
+}
+function appendWorkspaceCompilerArgs(ghcArgs, workspace) {
+    if (!workspace.hasAuxiliaryFiles)
+        return ghcArgs;
+    const internalArgs = ['-fforce-recomp', `-i${workspace.importRoots.join(':')}`];
+    return [...internalArgs, ghcArgs].filter(Boolean).join(' ');
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, rootfsUrl: nextRootfsUrl, bsdtarUrl: nextBsdtarUrl, integrity: nextIntegrity, maxAssetBytes: nextMaxAssetBytes, mainSoPath: nextMainSoPath, searchDirs: nextSearchDirs, code, prepare, buffer, stdin, ghcArgs = '', activePath = 'main.hs', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            const nextConfig = snapshotHaskellRuntimeAssetConfig({
+                moduleUrl: nextModuleUrl,
+                rootfsUrl: nextRootfsUrl,
+                bsdtarUrl: nextBsdtarUrl,
+                integrity: nextIntegrity,
+                maxAssetBytes: nextMaxAssetBytes
+            });
+            moduleUrl = nextConfig.moduleUrl;
+            rootfsUrl = nextConfig.rootfsUrl;
+            bsdtarUrl = nextConfig.bsdtarUrl;
+            integrity = nextConfig.integrity;
+            maxAssetBytes = nextConfig.maxAssetBytes;
+            mainSoPath = nextMainSoPath || mainSoPath;
+            searchDirs =
+                Array.isArray(nextSearchDirs) && nextSearchDirs.length
+                    ? nextSearchDirs
+                    : searchDirs;
+            if (log) {
+                console.log(`[wasm-idle:haskell-worker] load moduleUrl=${moduleUrl} rootfsUrl=${rootfsUrl} bsdtarUrl=${bsdtarUrl}`);
+            }
+            await createRuntime();
+            postMessage({ load: true });
+            return;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const runtime = await createRuntime();
+        const source = String(code ?? '');
+        const workspace = mountWorkspace(runtime.rootfs, source, activePath, workspaceFiles);
+        const compilerArgs = appendWorkspaceCompilerArgs(String(ghcArgs || ''), workspace);
+        runtime.stdin.reset({ stdin, buffer, log: !!log });
+        let stderrText = '';
+        try {
+            activeDiagnosticPaths = workspace.diagnosticPaths;
+            activeStderrCollector = (line) => {
+                stderrText += line.endsWith('\n') ? line : `${line}\n`;
+            };
+            if (log) {
+                console.log(`[wasm-idle:haskell-worker] run start activePath=${activePath} ghcArgs=${JSON.stringify(compilerArgs)} bytes=${source.length}`);
+            }
+            await runtime.mainFunc(compilerArgs, source);
+        }
+        catch (error) {
+            for (const diagnostic of parseHaskellDiagnostics(stderrText)) {
+                postMessage({ diagnostic });
+            }
+            throw new Error(stderrText.trim() || formatError(error), { cause: error });
+        }
+        finally {
+            activeStderrCollector = null;
+            activeDiagnosticPaths = null;
+        }
+        for (const diagnostic of parseHaskellDiagnostics(stderrText)) {
+            postMessage({ diagnostic });
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:haskell-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/java.js

@@ -1,4 +1,5 @@
 import { prepareJavaStdinInjection } from '../javaStdin';
+import { resolveJavaSourceIdentity } from '../javaSource';
 import { waitForBufferedStdin } from '../stdinBuffer';
 import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
 let compilerLib = null;
@@ -14,7 +15,9 @@ let compiledCode = '';
 let compiledStdin = '';
 let compiledMainClass = '';
 let compiledWasm = null;
-let currentSourcePath = '';
+let compiledActivePath = '';
+let compiledWorkspaceFiles = [];
+let currentSourcePaths = new Set();
 const decoder = new TextDecoder();
 const toInt8Array = (bytes) => new Int8Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
 const flushStdout = () => {
@@ -42,7 +45,7 @@ const pushStderr = (charCode) => {
 self.addEventListener('message', async (event) => {
     if (handleWorkerAssetMessage(event.data))
         return;
-    const { load, assets, buffer, code, prepare, args = [], stdin = '' } = event.data;
+    const { load, assets, buffer, code, prepare, args = [], stdin = '', hasExplicitStdin = false, activePath, workspaceFiles = [] } = event.data;
     try {
         if (load) {
             const runtimeAssets = assets;
@@ -72,6 +75,9 @@ self.addEventListener('message', async (event) => {
                 compiledStdin = '';
                 compiledMainClass = '';
                 compiledWasm = null;
+                compiledActivePath = '';
+                compiledWorkspaceFiles = [];
+                currentSourcePaths = new Set();
             }
             self.postMessage({ load: true });
             return;
@@ -80,23 +86,36 @@ self.addEventListener('message', async (event) => {
             throw new Error('TeaVM compiler not loaded');
         stdoutBuffer = '';
         stderrBuffer = '';
-        const stdinInjection = prepareJavaStdinInjection(code, stdin);
+        const explicitStdin = hasExplicitStdin === true;
+        const stdinInjection = prepareJavaStdinInjection(code, stdin, explicitStdin);
+        const sourceIdentity = resolveJavaSourceIdentity(code);
+        const sourcePath = typeof activePath === 'string' && activePath ? activePath : sourceIdentity.sourcePath;
+        const sourceFileName = sourcePath.split('/').pop() || sourcePath;
+        if (!Array.isArray(workspaceFiles) ||
+            !workspaceFiles.every((file) => file && typeof file.path === 'string' && typeof file.content === 'string')) {
+            throw new Error('Invalid Java workspace files');
+        }
+        const sourceFiles = workspaceFiles;
+        const workspaceChanged = compiledActivePath !== sourcePath ||
+            compiledWorkspaceFiles.length !== sourceFiles.length ||
+            compiledWorkspaceFiles.some((file, index) => file.path !== sourceFiles[index]?.path ||
+                file.content !== sourceFiles[index]?.content);
+        if (stdinInjection.usesStdin &&
+            stdinInjection.helperSourcePath &&
+            (sourcePath === stdinInjection.helperSourcePath ||
+                sourceFiles.some((file) => file.path === stdinInjection.helperSourcePath))) {
+            throw new Error(`Java workspace conflicts with generated stdin helper: ${stdinInjection.helperSourcePath}`);
+        }
         if (prepare ||
             compiledCode !== code ||
             compiledStdin !== stdinInjection.stdinCacheKey ||
+            workspaceChanged ||
             !compiledWasm) {
-            const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
-            const typeMatch = code.match(/^\s*public\s+(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m) ||
-                code.match(/^\s*(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m);
-            const className = typeMatch?.[1];
-            if (!className)
-                throw new Error('Java source must define a top-level class, record, enum, or interface');
-            const packageName = packageMatch?.[1] || '';
-            const sourcePath = packageName
-                ? `${packageName.replaceAll('.', '/')}/${className}.java`
-                : `${className}.java`;
-            const mainClass = packageName ? `${packageName}.${className}` : className;
-            currentSourcePath = sourcePath;
+            const mainClass = sourceIdentity.mainClass;
+            currentSourcePaths = new Set([sourcePath, ...sourceFiles.map((file) => file.path)].flatMap((path) => [
+                path,
+                path.split('/').pop() || path
+            ]));
             const diagnosticLines = [];
             const diagnosticRegistration = compiler.onDiagnostic((diagnostic) => {
                 const severity = diagnostic.severity
@@ -107,9 +126,7 @@ self.addEventListener('message', async (event) => {
                     : 'TeaVM';
                 diagnosticLines.push(`${location}: ${severity}: ${diagnostic.message}`);
                 const fileName = diagnostic.fileName ? String(diagnostic.fileName) : null;
-                if (fileName &&
-                    fileName !== currentSourcePath &&
-                    fileName !== currentSourcePath.split('/').pop()) {
+                if (fileName && !currentSourcePaths.has(fileName)) {
                     return;
                 }
                 self.postMessage({
@@ -136,11 +153,19 @@ self.addEventListener('message', async (event) => {
             compiler.clearSourceFiles?.();
             compiler.clearInputClassFiles?.();
             compiler.clearOutputFiles?.();
-            compiler.addSourceFile(sourcePath, stdinInjection.transformedCode);
+            // TeaVM derives packages from source text but validates public types against the basename.
+            compiler.addSourceFile(sourceFileName, stdinInjection.transformedCode);
+            for (const file of sourceFiles) {
+                compiler.addSourceFile(file.path.split('/').pop() || file.path, file.content);
+            }
             if (stdinInjection.usesStdin &&
                 stdinInjection.helperSourcePath &&
                 stdinInjection.helperSource) {
-                compiler.addSourceFile(stdinInjection.helperSourcePath, stdinInjection.helperSource);
+                compiler.addSourceFile(stdinInjection.helperSourcePath.split('/').pop() ||
+                    stdinInjection.helperSourcePath, stdinInjection.helperSource);
+                currentSourcePaths.add(stdinInjection.helperSourcePath);
+                currentSourcePaths.add(stdinInjection.helperSourcePath.split('/').pop() ||
+                    stdinInjection.helperSourcePath);
             }
             const javacOk = compiler.compile();
             if (!javacOk) {
@@ -166,12 +191,16 @@ self.addEventListener('message', async (event) => {
             compiledStdin = stdinInjection.stdinCacheKey;
             compiledMainClass = mainClass;
             compiledWasm = new Uint8Array(compiler.getWebAssemblyOutputFile('app.wasm'));
+            compiledActivePath = sourcePath;
+            compiledWorkspaceFiles = sourceFiles.map((file) => ({ ...file }));
         }
         if (prepare) {
             self.postMessage({ results: true });
             return;
         }
         stdinBufferJava = new Int32Array(buffer);
+        stdinChunkJava = explicitStdin ? new Uint8Array(0) : new TextEncoder().encode(stdin);
+        stdinChunkOffsetJava = 0;
         const workerGlobal = globalThis;
         const previousWindow = workerGlobal.window;
         workerGlobal.window = workerGlobal;
@@ -181,6 +210,8 @@ self.addEventListener('message', async (event) => {
                     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;
@@ -200,6 +231,14 @@ self.addEventListener('message', async (event) => {
                     enabled: false
                 }
             });
+            self.postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'Java program started'
+                }
+            });
             module.exports.main(args);
             flushStdout();
             flushStderr();

package/dist/playground/worker/lisp.d.ts

@@ -0,0 +1 @@
+export {};