wasm-idle 0.7.2 → 1.0.0

package/dist/playground/java.js

@@ -1,68 +1,492 @@
 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 { resolveJavaSourceIdentity } from './javaSource';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { createWasmIdleSharedBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerProgress } from './workerProgress';
+const OUTPUT_ENCODER = new TextEncoder();
+const abortReason = (signal, phase) => signal.reason !== undefined
+    ? signal.reason
+    : new DOMException(phase === 'startup' ? 'Java runtime startup aborted' : 'Java execution aborted', 'AbortError');
 class Java {
     output = null;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
+    buffer = createWasmIdleSharedBuffer(1024);
     pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
     exit = true;
     baseUrl = '';
-    activeReject = null;
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
     assetBridge = null;
-    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
-        return new Promise(async (resolve, reject) => {
-            this.pendingInput = [];
-            this.waitingForInput = false;
-            this.pendingEof = false;
-            const assetConfig = resolveRuntimeAssetConfig('java', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
-            this.baseUrl = assetConfig.baseUrl;
-            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
-            if (needsWorkerReset && this.worker) {
-                this.worker.terminate();
+    activeOperation = null;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('Java sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'JAVA',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'Java',
+        onDispose: (worker) => {
+            if (this.worker === worker) {
+                const assetBridge = this.assetBridge;
                 delete this.worker;
                 this.assetBridge = null;
+                try {
+                    assetBridge?.dispose();
+                }
+                catch {
+                    // Asset cleanup must not replace the worker operation result.
+                }
+            }
+            this.exit = true;
+            this.waitingForInput = false;
+            this.pendingEof = false;
+        }
+    });
+    disposedConfigurationError() {
+        return new RuntimeConfigurationError('Java sandbox is disposed', {
+            phase: 'dispose',
+            runtimeId: 'JAVA'
+        });
+    }
+    requireOperationIdle() {
+        if (this.disposed)
+            throw this.disposedConfigurationError();
+        if (!this.activeOperation)
+            return;
+        throw new BusyError('Java runtime already has an active operation', {
+            runtimeId: 'JAVA',
+            phase: this.activeOperation.phase
+        });
+    }
+    beginOperation(phase) {
+        this.requireOperationIdle();
+        const operation = {
+            token: Symbol(phase),
+            phase,
+            cancelled: false,
+            cleanedUp: false,
+            cleanups: [],
+            explicitStdin: false
+        };
+        this.activeOperation = operation;
+        return operation;
+    }
+    isOperationActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.cancelled;
+    }
+    releaseOperation(operation) {
+        if (this.activeOperation?.token !== operation.token)
+            return false;
+        this.activeOperation = null;
+        return true;
+    }
+    cleanupOperation(operation) {
+        if (operation.cleanedUp)
+            return;
+        operation.cleanedUp = true;
+        const cleanups = operation.cleanups.splice(0);
+        for (const cleanup of cleanups) {
+            try {
+                cleanup();
+            }
+            catch {
+                // Caller-owned lifecycle cleanup must not replace the operation result.
+            }
+        }
+    }
+    releaseBeforeSession(operation, reason) {
+        const outcome = operation.cancelled ? operation.cancellationReason : reason;
+        this.releaseOperation(operation);
+        this.cleanupOperation(operation);
+        return outcome;
+    }
+    bindPreSessionAbort(operation, signal) {
+        if (!signal || !this.isOperationActive(operation))
+            return () => undefined;
+        let registered = false;
+        let unbound = false;
+        const unbind = () => {
+            if (unbound)
+                return;
+            unbound = true;
+            if (registered)
+                signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            if (this.disposed || !this.isOperationActive(operation))
+                return;
+            let reason;
+            try {
+                reason = abortReason(signal, operation.phase);
+            }
+            catch (error) {
+                reason = error;
+            }
+            operation.cancelled = true;
+            operation.cancellationReason = reason;
+            this.releaseOperation(operation);
+            this.cleanupOperation(operation);
+        };
+        operation.cleanups.push(unbind);
+        try {
+            registered = true;
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            if (this.isOperationActive(operation)) {
+                operation.cancelled = true;
+                operation.cancellationReason = error;
+                this.releaseOperation(operation);
+                this.cleanupOperation(operation);
+            }
+        }
+        return unbind;
+    }
+    bindAbortSignal(operation, signal) {
+        if (!signal || !this.isOperationActive(operation))
+            return;
+        let registered = false;
+        const onAbort = () => {
+            if (this.disposed || !this.isOperationActive(operation))
+                return;
+            let reason;
+            try {
+                reason = abortReason(signal, operation.phase);
+            }
+            catch (error) {
+                reason = error;
+            }
+            this.cancelOperation(operation, reason);
+        };
+        operation.cleanups.push(() => {
+            if (!registered)
+                return;
+            try {
+                signal.removeEventListener('abort', onAbort);
+            }
+            catch {
+                // Listener cleanup must not replace the operation result.
+            }
+        });
+        try {
+            registered = true;
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+        }
+    }
+    bindOperationTimeout(operation, timeoutMs) {
+        if (!this.isOperationActive(operation))
+            return;
+        let timeout;
+        operation.cleanups.push(() => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+        });
+        try {
+            timeout = setTimeout(() => {
+                if (!this.isOperationActive(operation))
+                    return;
+                const label = operation.phase === 'startup' ? 'startup' : 'execution';
+                this.cancelOperation(operation, new TimeoutError(`Java ${label} timed out after ${timeoutMs} ms`, {
+                    phase: operation.phase,
+                    runtimeId: 'JAVA',
+                    timeoutMs
+                }));
+            }, timeoutMs);
+            if (operation.cleanedUp)
+                clearTimeout(timeout);
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+        }
+    }
+    resetExplicitStdinState() {
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.waitingForInput = false;
+        try {
+            resetBufferedStdin(this.buffer);
+        }
+        catch {
+            // Explicit stdin never consumes the shared terminal buffer.
+        }
+    }
+    finishExplicitStdin(operation) {
+        if (!operation.explicitStdin)
+            return;
+        operation.explicitStdin = false;
+        this.resetExplicitStdinState();
+    }
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        let activeOperation;
+        try {
+            activeOperation = this.beginOperation('startup');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let signal;
+        let limits;
+        let unbindPreSessionAbort = () => undefined;
+        try {
+            signal = options.signal;
+            unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java runtime startup cancelled'));
             }
-            if (!this.worker) {
-                this.worker = new (await import('./worker/java?worker')).default();
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'java', assetConfig, progress);
-                this.worker.onmessage = (event) => {
-                    if (this.assetBridge?.handleMessage(event))
+            limits = resolveExecutionLimits(options.limits);
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java runtime startup cancelled'));
+            }
+            unbindPreSessionAbort();
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, error));
+        }
+        if (!this.isOperationActive(activeOperation)) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java runtime startup cancelled'));
+        }
+        const loadPromise = this.workerSession.load(async (resolve, reject) => {
+            const resolveLoad = () => {
+                if (!this.releaseOperation(activeOperation))
+                    return;
+                resolve();
+                this.cleanupOperation(activeOperation);
+            };
+            const rejectLoad = (reason) => {
+                if (!this.releaseOperation(activeOperation))
+                    return;
+                reject(reason);
+                this.cleanupOperation(activeOperation);
+            };
+            try {
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                let resolverAssets = runtimeAssets;
+                if (runtimeAssets && typeof runtimeAssets === 'object') {
+                    const runtimeConfig = runtimeAssets.java;
+                    if (!this.isOperationActive(activeOperation))
                         return;
-                    if (event.data?.load)
-                        resolve();
-                    if (event.data?.error)
-                        reject(event.data.error);
-                };
-                this.worker.postMessage({
-                    load: true,
-                    assets: {
-                        baseUrl: assetConfig.baseUrl,
-                        useAssetBridge: assetConfig.useAssetBridge
+                    let java;
+                    if (runtimeConfig) {
+                        const baseUrl = runtimeConfig.baseUrl;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
+                        const loader = runtimeConfig.loader;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
+                        const integritySource = runtimeConfig.integrity;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
+                        let integrity;
+                        if (integritySource) {
+                            integrity = Object.create(null);
+                            const assets = Object.keys(integritySource);
+                            if (!this.isOperationActive(activeOperation))
+                                return;
+                            for (const asset of assets) {
+                                const entry = integritySource[asset];
+                                if (!this.isOperationActive(activeOperation))
+                                    return;
+                                let snapshot;
+                                if (typeof entry === 'string') {
+                                    snapshot = entry;
+                                }
+                                else {
+                                    const sha256 = entry.sha256;
+                                    if (!this.isOperationActive(activeOperation))
+                                        return;
+                                    const bytes = entry.bytes;
+                                    if (!this.isOperationActive(activeOperation))
+                                        return;
+                                    const mediaType = entry.mediaType;
+                                    if (!this.isOperationActive(activeOperation))
+                                        return;
+                                    const uncompressedSha256 = entry.uncompressedSha256;
+                                    if (!this.isOperationActive(activeOperation))
+                                        return;
+                                    const uncompressedBytes = entry.uncompressedBytes;
+                                    if (!this.isOperationActive(activeOperation))
+                                        return;
+                                    snapshot = {
+                                        sha256,
+                                        bytes,
+                                        mediaType,
+                                        uncompressedSha256,
+                                        uncompressedBytes
+                                    };
+                                }
+                                Object.defineProperty(integrity, asset, {
+                                    value: snapshot,
+                                    enumerable: true,
+                                    configurable: true,
+                                    writable: true
+                                });
+                            }
+                        }
+                        const allowedBaseUrlsSource = runtimeConfig.allowedBaseUrls;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
+                        const allowedBaseUrls = allowedBaseUrlsSource
+                            ? [...allowedBaseUrlsSource]
+                            : undefined;
+                        if (!this.isOperationActive(activeOperation))
+                            return;
+                        java = { baseUrl, loader, integrity, allowedBaseUrls };
                     }
-                });
+                    let rootUrl;
+                    let rootUrlRead = false;
+                    const operationIsActive = () => this.isOperationActive(activeOperation);
+                    resolverAssets = {
+                        get rootUrl() {
+                            if (!rootUrlRead) {
+                                rootUrlRead = true;
+                                rootUrl = runtimeAssets.rootUrl;
+                                if (!operationIsActive())
+                                    return undefined;
+                            }
+                            return rootUrl;
+                        },
+                        java
+                    };
+                }
+                const assetConfig = resolveRuntimeAssetConfig('java', resolverAssets, currentUrl);
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                for (const asset of TEAVM_RUNTIME_ASSET_NAMES) {
+                    const receipt = assetConfig.integrity?.[asset];
+                    const bytes = typeof receipt === 'object' ? receipt.bytes : undefined;
+                    if (bytes !== undefined && bytes > limits.maxAssetBytes) {
+                        throw new AssetTooLargeError(`TeaVM runtime receipt exceeds the ${limits.maxAssetBytes} byte limit for ${asset}`, {
+                            actual: bytes,
+                            limit: limits.maxAssetBytes,
+                            runtimeId: 'JAVA'
+                        });
+                    }
+                }
+                this.baseUrl = assetConfig.baseUrl;
+                const needsWorkerReset = !this.worker ||
+                    !this.assetBridge ||
+                    !this.assetBridge.matches(assetConfig, limits.maxAssetBytes);
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                if (needsWorkerReset && this.worker) {
+                    this.workerSession.reset();
+                }
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                if (!this.worker) {
+                    const WorkerConstructor = (await import('./worker/java?worker'))
+                        .default;
+                    if (!this.isOperationActive(activeOperation))
+                        return;
+                    const worker = new WorkerConstructor();
+                    if (!this.isOperationActive(activeOperation)) {
+                        worker.terminate();
+                        return;
+                    }
+                    this.worker = worker;
+                    this.workerSession.attach(worker);
+                    const assetBridge = new WorkerAssetBridge(worker, 'java', assetConfig, progress, limits.maxAssetBytes);
+                    if (!this.isOperationActive(activeOperation) || this.worker !== worker) {
+                        assetBridge.dispose();
+                        return;
+                    }
+                    this.assetBridge = assetBridge;
+                    let handler;
+                    const ownsWorker = () => this.worker === worker &&
+                        worker.onmessage === handler &&
+                        this.assetBridge === assetBridge;
+                    const ownsLoad = () => ownsWorker() && this.isOperationActive(activeOperation);
+                    const failLoad = (error) => {
+                        if (!ownsLoad())
+                            return;
+                        rejectLoad(error);
+                    };
+                    handler = (event) => {
+                        if (!ownsWorker())
+                            return;
+                        try {
+                            if (assetBridge.handleMessage(event))
+                                return;
+                            if (!ownsLoad())
+                                return;
+                            if (event.data?.load) {
+                                resolveLoad();
+                                return;
+                            }
+                            if (event.data?.error)
+                                rejectLoad(event.data.error);
+                        }
+                        catch (error) {
+                            failLoad(error);
+                        }
+                    };
+                    worker.onmessage = handler;
+                    worker.postMessage({
+                        load: true,
+                        assets: {
+                            baseUrl: assetConfig.baseUrl,
+                            useAssetBridge: assetConfig.useAssetBridge
+                        }
+                    });
+                }
+                else {
+                    const worker = this.worker;
+                    const assetBridge = this.assetBridge;
+                    if (!assetBridge)
+                        return rejectLoad('Worker asset bridge unavailable');
+                    assetBridge.rebind(worker, assetConfig, progress, limits.maxAssetBytes);
+                    if (!this.isOperationActive(activeOperation) ||
+                        this.worker !== worker ||
+                        this.assetBridge !== assetBridge) {
+                        return;
+                    }
+                    resolveLoad();
+                }
             }
-            else {
-                if (!this.assetBridge)
-                    return reject('Worker asset bridge unavailable');
-                this.assetBridge.rebind(this.worker, assetConfig, progress);
-                resolve();
+            catch (error) {
+                rejectLoad(error);
             }
         });
+        const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs);
+        this.bindOperationTimeout(activeOperation, timeoutMs);
+        this.bindAbortSignal(activeOperation, signal);
+        return loadPromise.finally(() => {
+            this.releaseOperation(activeOperation);
+            this.cleanupOperation(activeOperation);
+        });
     }
     write(input) {
+        if (this.disposed)
+            return;
         this.pendingInput.push(input);
         this.pendingEof = false;
         this.flushPendingInput();
     }
     eof() {
+        if (this.disposed)
+            return;
         this.pendingEof = true;
         this.flushPendingInput();
     }
@@ -80,82 +504,280 @@ class Java {
         }
     }
     run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        let activeOperation;
+        try {
+            activeOperation = this.beginOperation('execute');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const worker = this.worker;
+        if (!worker) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Worker not loaded'));
+        }
+        const assetBridge = this.assetBridge;
+        const baseUrl = this.baseUrl;
+        let signal;
+        let unbindPreSessionAbort = () => undefined;
+        let programArgs;
+        let limits;
+        let workspace;
+        let stdin;
+        try {
+            signal = options.signal;
+            unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation)) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java execution cancelled'));
+            }
+            programArgs = resolveSandboxExecutionArgs('JAVA', args, options).programArgs;
+            const { sourcePath } = resolveJavaSourceIdentity(code);
+            limits = resolveExecutionLimits(options.limits);
+            const workspaceFiles = options.workspaceFiles ?? [];
+            const activePath = options.activePath ?? sourcePath;
+            const workspaceLimitsSource = options.workspaceLimits;
+            const workspaceLimits = workspaceLimitsSource
+                ? {
+                    maxFiles: workspaceLimitsSource.maxFiles,
+                    maxFileBytes: workspaceLimitsSource.maxFileBytes,
+                    maxTotalBytes: workspaceLimitsSource.maxTotalBytes,
+                    maxPathBytes: workspaceLimitsSource.maxPathBytes,
+                    caseSensitive: workspaceLimitsSource.caseSensitive
+                }
+                : {};
+            workspace = validateExecutionWorkspace(code, workspaceFiles, activePath, {
+                ...workspaceLimits,
+                maxFileBytes: Math.min(workspaceLimits.maxFileBytes ?? DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                maxTotalBytes: Math.min(workspaceLimits.maxTotalBytes ?? DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+            });
+            stdin = options.stdin;
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java execution cancelled'));
+            }
+            unbindPreSessionAbort();
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, error));
+        }
+        if (!this.isOperationActive(activeOperation)) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Java execution cancelled'));
+        }
+        const hasExplicitStdin = stdin !== undefined;
+        if (hasExplicitStdin) {
+            activeOperation.explicitStdin = true;
+            this.resetExplicitStdinState();
+        }
         this.exit = false;
-        return new Promise((resolve, reject) => {
-            if (!this.worker)
-                return reject('Worker not loaded');
-            const { programArgs } = resolveSandboxExecutionArgs('JAVA', args, options);
+        const running = new Promise((resolve, reject) => {
             const _uid = ++this.uid;
-            this.activeReject = reject;
-            const handler = (event) => {
-                if (this.assetBridge?.handleMessage(event))
+            let diagnosticCount = 0;
+            let outputBytes = 0;
+            const operation = this.workerSession.beginRun(worker, reject);
+            const timeoutMs = Math.min(2_147_483_647, limits.compileTimeoutMs + limits.runTimeoutMs);
+            this.bindOperationTimeout(activeOperation, timeoutMs);
+            this.bindAbortSignal(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation))
+                return;
+            let handler;
+            const ownsWorker = () => this.worker === worker &&
+                worker.onmessage === handler &&
+                this.assetBridge === assetBridge;
+            const ownsRun = () => ownsWorker() && this.isOperationActive(activeOperation) && _uid === this.uid;
+            const claimRun = () => {
+                if (!ownsRun() || !this.workerSession.complete(operation))
+                    return false;
+                this.finishExplicitStdin(activeOperation);
+                this.elapse = Date.now() - this.begin;
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                this.releaseOperation(activeOperation);
+                this.cleanupOperation(activeOperation);
+                return true;
+            };
+            const failRun = (error, disposeWorker = false) => {
+                if (!ownsRun())
+                    return;
+                if (disposeWorker) {
+                    this.cancelOperation(activeOperation, error);
                     return;
-                if (!this.worker)
-                    return reject('Worker not loaded');
-                if (_uid !== this.uid)
-                    return (this.worker.onmessage = null);
-                const { output, results, error, buffer, diagnostic } = event.data;
-                if (buffer) {
-                    this.waitingForInput = true;
-                    this.flushPendingInput();
                 }
-                if (output)
-                    this.output(output);
-                if (diagnostic)
-                    this.oncompilerdiagnostic?.(diagnostic);
-                if (results) {
-                    this.elapse = Date.now() - this.begin;
-                    this.exit = true;
-                    this.waitingForInput = false;
-                    this.pendingEof = false;
-                    this.activeReject = null;
-                    resolve(results);
+                if (!claimRun())
+                    return;
+                reject(error);
+            };
+            handler = (event) => {
+                if (!ownsWorker())
+                    return;
+                try {
+                    if (assetBridge?.handleMessage(event))
+                        return;
+                    if (!ownsRun())
+                        return;
+                    const { output, results, error, buffer, diagnostic, progress } = event.data;
+                    if (buffer && !hasExplicitStdin) {
+                        if (!prepare) {
+                            _prog?.report?.({
+                                kind: 'ready',
+                                state: 'waiting-input',
+                                reason: 'stdin-request',
+                                label: 'Java program is waiting for input'
+                            });
+                        }
+                        this.waitingForInput = true;
+                        this.flushPendingInput();
+                        if (!ownsRun())
+                            return;
+                    }
+                    reportWorkerProgress(_prog, progress);
+                    if (!ownsRun())
+                        return;
+                    if (output) {
+                        const actual = outputBytes + OUTPUT_ENCODER.encode(String(output)).byteLength;
+                        if (actual > limits.maxOutputBytes) {
+                            failRun(new OutputLimitError(`Java output exceeded ${limits.maxOutputBytes} bytes`, {
+                                actual,
+                                limit: limits.maxOutputBytes,
+                                phase: 'execute',
+                                runtimeId: 'JAVA'
+                            }), true);
+                            return;
+                        }
+                        outputBytes = actual;
+                        this.output?.(output);
+                    }
+                    if (!ownsRun())
+                        return;
+                    if (diagnostic) {
+                        const actual = diagnosticCount + 1;
+                        if (actual > limits.maxDiagnostics) {
+                            failRun(new DiagnosticLimitError(`Java diagnostics exceeded ${limits.maxDiagnostics} messages`, {
+                                actual,
+                                limit: limits.maxDiagnostics,
+                                phase: 'execute',
+                                runtimeId: 'JAVA'
+                            }), true);
+                            return;
+                        }
+                        diagnosticCount = actual;
+                        this.oncompilerdiagnostic?.(diagnostic);
+                    }
+                    if (!ownsRun())
+                        return;
+                    if (results) {
+                        if (!claimRun())
+                            return;
+                        resolve(results);
+                        return;
+                    }
+                    if (error)
+                        failRun(error);
                 }
-                if (error) {
-                    this.elapse = Date.now() - this.begin;
-                    this.exit = true;
-                    this.waitingForInput = false;
-                    this.pendingEof = false;
-                    this.activeReject = null;
-                    reject(error);
+                catch (error) {
+                    failRun(error, true);
                 }
             };
-            this.worker.onmessage = handler;
+            worker.onmessage = handler;
+            if (!ownsRun())
+                return;
             this.begin = Date.now();
-            this.worker.postMessage({
-                code,
-                prepare,
-                buffer: this.buffer,
-                args: programArgs,
-                stdin: options.stdin || '',
-                baseUrl: this.baseUrl
-            });
+            try {
+                worker.postMessage({
+                    code,
+                    prepare,
+                    buffer: this.buffer,
+                    args: programArgs,
+                    stdin: stdin ?? '',
+                    hasExplicitStdin,
+                    baseUrl,
+                    activePath: workspace.activePath,
+                    workspaceFiles: workspace.workspaceFiles
+                });
+            }
+            catch (error) {
+                failRun(error, true);
+            }
+        });
+        return running.finally(() => {
+            if (this.releaseOperation(activeOperation)) {
+                this.finishExplicitStdin(activeOperation);
+                this.exit = true;
+            }
+            this.cleanupOperation(activeOperation);
         });
     }
+    cancelOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.cancellationReason = reason;
+        this.activeOperation = null;
+        this.uid += 1;
+        this.finishExplicitStdin(operation);
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.exit = true;
+        this.workerSession.terminate(reason);
+        this.cleanupOperation(operation);
+    }
     kill() {
         this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const activeOperation = this.activeOperation;
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, reason);
+            return;
+        }
         this.waitingForInput = false;
         this.pendingEof = false;
         this.uid += 1;
-        this.worker?.terminate?.();
-        delete this.worker;
-        this.assetBridge = null;
+        this.workerSession.terminate(reason);
         this.exit = true;
     }
     async clear() {
+        if (this.disposed)
+            return;
         this.pendingInput = [];
         this.waitingForInput = false;
         this.pendingEof = false;
-        if (this.worker)
-            this.worker.onmessage = null;
         resetBufferedStdin(this.buffer);
-        if (!this.exit) {
+        if (this.activeOperation) {
             this.terminate();
+            return;
+        }
+        if (this.worker)
+            this.worker.onmessage = null;
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const activeOperation = this.activeOperation;
+        const assetBridge = this.assetBridge;
+        delete this.worker;
+        this.assetBridge = null;
+        this.baseUrl = '';
+        this.output = undefined;
+        this.oncompilerdiagnostic = undefined;
+        this.resetExplicitStdinState();
+        try {
+            assetBridge?.dispose();
+        }
+        catch {
+            // Asset cleanup is best effort after host state becomes unreachable.
+        }
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, this.disposeCancellation);
+        }
+        else {
+            this.uid += 1;
+            this.workerSession.terminate(this.disposeCancellation);
+            this.exit = true;
         }
+        return this.disposePromise;
     }
 }
 export default Java;