wasm-idle 0.7.2 → 1.0.0

package/dist/playground/ocaml.js

@@ -1,10 +1,50 @@
 import { resolveOcamlManifestUrl, resolveOcamlModuleUrl } from './assets';
 import {} from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { createWasmIdleSharedBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
+import { WASM_OCAML_RUNTIME_PROFILE } from './wasmOcamlVersion';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+const OCAML_EXECUTION_LIMIT_KEYS = [
+    'assetTimeoutMs',
+    'startupTimeoutMs',
+    'compileTimeoutMs',
+    'runTimeoutMs',
+    'maxOutputBytes',
+    'maxDiagnostics',
+    'maxWorkspaceBytes',
+    'maxAssetBytes',
+    'maxWasmMemoryBytes',
+    'maxWorkers',
+    'maxThreads'
+];
+const OCAML_WORKSPACE_LIMIT_KEYS = [
+    'maxFiles',
+    'maxFileBytes',
+    'maxTotalBytes',
+    'maxPathBytes',
+    'caseSensitive'
+];
+const OUTPUT_ENCODER = new TextEncoder();
+function snapshotOuterAssetReceipt(value, label) {
+    if (!value ||
+        !Number.isSafeInteger(value.bytes) ||
+        value.bytes <= 0 ||
+        typeof value.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(value.sha256)) {
+        throw new RuntimeConfigurationError(`OCaml ${label} receipt is invalid`, {
+            phase: 'startup',
+            runtimeId: 'OCAML'
+        });
+    }
+    return Object.freeze({ bytes: value.bytes, sha256: value.sha256 });
+}
+const receiptIdentity = (receipt) => `${receipt.bytes}:${receipt.sha256}`;
 class Ocaml {
     output = null;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
+    buffer = createWasmIdleSharedBuffer(1024);
     pendingInput = [];
     begin = 0;
     elapse = 0;
@@ -12,332 +52,854 @@ class Ocaml {
     exit = true;
     moduleUrl = '';
     manifestUrl = '';
-    activeReject = null;
+    moduleReceiptIdentity = '';
+    manifestReceiptIdentity = '';
+    maxAssetBytes = 0;
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
-    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
-        return new Promise(async (resolve, reject) => {
-            this.pendingInput = [];
+    activeOperation = null;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('OCaml sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'OCAML',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'OCaml',
+        onDispose: (worker) => {
+            if (this.worker === worker)
+                delete this.worker;
+            this.exit = true;
             this.waitingForInput = false;
             this.pendingEof = false;
-            resetBufferedStdin(this.buffer);
+        }
+    });
+    disposedConfigurationError() {
+        return new RuntimeConfigurationError('OCaml sandbox is disposed', {
+            phase: 'dispose',
+            runtimeId: 'OCAML'
+        });
+    }
+    beginOperation(phase) {
+        if (this.disposed)
+            throw this.disposedConfigurationError();
+        if (this.activeOperation) {
+            throw new BusyError('OCaml runtime already has an active operation', {
+                runtimeId: 'OCAML',
+                phase: this.activeOperation.phase
+            });
+        }
+        const operation = {
+            token: Symbol(phase),
+            phase,
+            cancelled: false,
+            explicitStdin: false,
+            sessionActive: false,
+            abortReasonReading: false
+        };
+        this.activeOperation = operation;
+        return operation;
+    }
+    completeOperation(operation) {
+        if (this.activeOperation?.token === operation.token)
+            this.activeOperation = null;
+        const timeout = operation.timeout;
+        operation.timeout = undefined;
+        if (timeout !== undefined) {
+            try {
+                clearTimeout(timeout);
+            }
+            catch {
+                // Timer cleanup must not replace the operation result.
+            }
+        }
+        const { signal, onAbort } = operation;
+        operation.signal = undefined;
+        operation.onAbort = undefined;
+        if (signal && onAbort) {
+            try {
+                signal.removeEventListener('abort', onAbort);
+            }
+            catch {
+                // Listener cleanup must not replace the operation result.
+            }
+        }
+    }
+    isOperationActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.cancelled;
+    }
+    ownsWorkerOperation(operation, worker, handler, uid) {
+        return (this.isOperationActive(operation) &&
+            this.worker === worker &&
+            worker.onmessage === handler &&
+            (uid === undefined || uid === this.uid));
+    }
+    releaseBeforeSession(operation, fallback) {
+        const outcome = operation.cancelled ? operation.cancellationReason : fallback;
+        this.completeOperation(operation);
+        return outcome;
+    }
+    resolveOperationLimits(operation, configured) {
+        if (configured === undefined)
+            return resolveExecutionLimits();
+        if (configured === null || typeof configured !== 'object') {
+            throw new TypeError('OCaml execution limits must be an object');
+        }
+        const snapshot = {};
+        for (const key of OCAML_EXECUTION_LIMIT_KEYS) {
+            const value = configured[key];
+            if (!this.isOperationActive(operation)) {
+                throw operation.cancellationReason ?? 'OCaml operation cancelled';
+            }
+            if (value !== undefined)
+                snapshot[key] = value;
+        }
+        return resolveExecutionLimits(snapshot);
+    }
+    resetExplicitStdinState(buffer) {
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.waitingForInput = false;
+        try {
+            resetBufferedStdin(buffer);
+        }
+        catch {
+            // Explicit stdin never consumes the shared terminal buffer.
+        }
+    }
+    finishExplicitStdin(operation) {
+        if (!operation.explicitStdin)
+            return;
+        operation.explicitStdin = false;
+        const buffer = operation.buffer;
+        if (buffer)
+            this.resetExplicitStdinState(buffer);
+    }
+    abortReason(signal, phase) {
+        const reason = signal.reason;
+        if (reason !== undefined)
+            return reason;
+        return new DOMException(phase === 'startup' ? 'OCaml runtime startup aborted' : 'OCaml execution aborted', 'AbortError');
+    }
+    bindAbortSignal(operation, signal) {
+        if (!signal || !this.isOperationActive(operation))
+            return;
+        const onAbort = () => {
+            if (this.disposed || !this.isOperationActive(operation) || operation.abortReasonReading)
+                return;
+            operation.abortReasonReading = true;
+            let reason;
+            try {
+                reason = this.abortReason(signal, operation.phase);
+            }
+            catch (error) {
+                reason = error;
+            }
+            finally {
+                operation.abortReasonReading = false;
+            }
+            if (!this.isOperationActive(operation))
+                return;
+            if (operation.sessionActive)
+                this.abortOperation(operation, reason);
+            else
+                this.cancelBeforeSession(operation, reason);
+        };
+        operation.signal = signal;
+        operation.onAbort = onAbort;
+        try {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        catch (error) {
+            if (!this.isOperationActive(operation))
+                return;
+            let signalAborted = false;
+            try {
+                signalAborted = signal.aborted;
+            }
+            catch {
+                if (!this.isOperationActive(operation))
+                    return;
+            }
+            if (signalAborted)
+                onAbort();
+            else
+                this.cancelBeforeSession(operation, error);
+            return;
+        }
+        if (!this.isOperationActive(operation))
+            return;
+        try {
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            if (this.isOperationActive(operation))
+                this.cancelBeforeSession(operation, error);
+        }
+    }
+    bindOperationTimeout(operation, timeoutMs) {
+        if (!this.isOperationActive(operation))
+            return;
+        let timeout;
+        try {
+            timeout = setTimeout(() => {
+                if (operation.timeout === timeout)
+                    operation.timeout = undefined;
+                if (!this.isOperationActive(operation))
+                    return;
+                const label = operation.phase === 'startup' ? 'startup' : 'execution';
+                this.abortOperation(operation, new TimeoutError(`OCaml ${label} timed out after ${timeoutMs} ms`, {
+                    phase: operation.phase,
+                    runtimeId: 'OCAML',
+                    timeoutMs
+                }));
+            }, timeoutMs);
+        }
+        catch (error) {
+            this.abortOperation(operation, error);
+            return;
+        }
+        if (!this.isOperationActive(operation)) {
+            try {
+                clearTimeout(timeout);
+            }
+            catch {
+                // The superseded timer can no longer own the operation.
+            }
+            return;
+        }
+        operation.timeout = timeout;
+    }
+    cancelBeforeSession(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.cancellationReason = reason;
+        this.completeOperation(operation);
+    }
+    abortOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.cancellationReason = reason;
+        this.finishExplicitStdin(operation);
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.workerSession.terminate(reason);
+        this.exit = true;
+        this.completeOperation(operation);
+    }
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        let operation;
+        try {
+            operation = this.beginOperation('startup');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let signal;
+        let limits;
+        let nextModuleUrl;
+        let nextManifestUrl;
+        let nextModuleReceipt;
+        let nextManifestReceipt;
+        let buffer;
+        try {
+            signal = options.signal;
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+            this.bindAbortSignal(operation, signal);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+            const configuredLimits = options.limits;
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+            limits = this.resolveOperationLimits(operation, configuredLimits);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
-            const nextModuleUrl = resolveOcamlModuleUrl(runtimeAssets, currentUrl);
-            const nextManifestUrl = resolveOcamlManifestUrl(runtimeAssets, currentUrl);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+            let resolverAssets = runtimeAssets;
+            let configuredModuleReceipt;
+            let configuredManifestReceipt;
+            if (runtimeAssets === null) {
+                resolverAssets = {};
+            }
+            else if (typeof runtimeAssets === 'object') {
+                const source = runtimeAssets.ocaml;
+                if (!this.isOperationActive(operation)) {
+                    return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+                }
+                const moduleUrl = source?.moduleUrl;
+                if (!this.isOperationActive(operation)) {
+                    return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+                }
+                const manifestUrl = source?.manifestUrl;
+                if (!this.isOperationActive(operation)) {
+                    return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+                }
+                configuredModuleReceipt = source?.moduleReceipt;
+                if (!this.isOperationActive(operation)) {
+                    return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+                }
+                configuredManifestReceipt = source?.manifestReceipt;
+                if (!this.isOperationActive(operation)) {
+                    return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+                }
+                let rootUrl;
+                let rootUrlRead = false;
+                resolverAssets = { ocaml: source ? { moduleUrl, manifestUrl } : undefined };
+                Object.defineProperty(resolverAssets, 'rootUrl', {
+                    get: () => {
+                        if (!rootUrlRead) {
+                            rootUrlRead = true;
+                            rootUrl = runtimeAssets.rootUrl;
+                        }
+                        if (!this.isOperationActive(operation)) {
+                            throw operation.cancellationReason;
+                        }
+                        return rootUrl;
+                    }
+                });
+            }
+            nextModuleUrl = resolveOcamlModuleUrl(resolverAssets, currentUrl);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+            nextManifestUrl = resolveOcamlManifestUrl(resolverAssets, currentUrl);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
             if (!nextModuleUrl || !nextManifestUrl) {
-                return reject('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
+                throw 'OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.';
+            }
+            const hasConfiguredReceipt = configuredModuleReceipt !== undefined || configuredManifestReceipt !== undefined;
+            if (hasConfiguredReceipt &&
+                (configuredModuleReceipt === undefined || configuredManifestReceipt === undefined)) {
+                throw new RuntimeConfigurationError('OCaml custom runtime assets require both module and manifest receipts', { phase: 'startup', runtimeId: 'OCAML' });
             }
+            nextModuleReceipt = snapshotOuterAssetReceipt(configuredModuleReceipt ?? WASM_OCAML_RUNTIME_PROFILE.moduleReceipt, 'module');
+            nextManifestReceipt = snapshotOuterAssetReceipt(configuredManifestReceipt ?? WASM_OCAML_RUNTIME_PROFILE.manifestReceipt, 'manifest');
+            if (nextModuleReceipt.bytes > limits.maxAssetBytes ||
+                nextManifestReceipt.bytes > limits.maxAssetBytes) {
+                throw new RuntimeConfigurationError(`OCaml outer runtime asset exceeds the ${limits.maxAssetBytes} byte limit`, { phase: 'startup', runtimeId: 'OCAML' });
+            }
+            buffer = this.buffer;
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'OCaml runtime startup cancelled'));
+            }
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(operation, error));
+        }
+        operation.sessionActive = true;
+        const loading = this.workerSession.load(async (resolve, reject) => {
+            if (!this.isOperationActive(operation))
+                return;
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            resetBufferedStdin(buffer);
+            if (!this.isOperationActive(operation))
+                return;
             const needsWorkerReset = !this.worker ||
                 this.moduleUrl !== nextModuleUrl ||
-                this.manifestUrl !== nextManifestUrl;
-            this.moduleUrl = nextModuleUrl;
-            this.manifestUrl = nextManifestUrl;
-            if (needsWorkerReset && this.worker) {
-                this.worker.terminate();
-                delete this.worker;
-            }
-            if (!this.worker) {
-                this.worker = new (await import('./worker/ocaml?worker')).default();
-                this.worker.onerror = (event) => {
-                    const location = event.filename && event.lineno
-                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
-                        : '';
-                    reject(`OCaml worker script error: ${event.message || 'unknown error'}${location}`);
-                };
-                this.worker.onmessageerror = () => {
-                    reject('OCaml worker message deserialization failed');
-                };
-                this.worker.onmessage = (event) => {
-                    if (event.data?.load) {
-                        progress?.set?.(1);
-                        resolve();
+                this.manifestUrl !== nextManifestUrl ||
+                this.moduleReceiptIdentity !== receiptIdentity(nextModuleReceipt) ||
+                this.manifestReceiptIdentity !== receiptIdentity(nextManifestReceipt) ||
+                this.maxAssetBytes !== limits.maxAssetBytes;
+            if (needsWorkerReset) {
+                const WorkerConstructor = (await import('./worker/ocaml?worker'))
+                    .default;
+                if (!this.isOperationActive(operation))
+                    return;
+                const worker = new WorkerConstructor();
+                if (!this.isOperationActive(operation)) {
+                    worker.terminate();
+                    return;
+                }
+                this.worker = worker;
+                this.workerSession.attach(worker);
+                if (!this.isOperationActive(operation) || this.worker !== worker) {
+                    if (this.worker === worker)
+                        delete this.worker;
+                    this.workerSession.release(worker);
+                    return;
+                }
+                const handler = (event) => {
+                    if (!this.ownsWorkerOperation(operation, worker, handler))
+                        return;
+                    try {
+                        const message = event.data;
+                        if (!this.ownsWorkerOperation(operation, worker, handler))
+                            return;
+                        const loaded = message?.load;
+                        if (!this.ownsWorkerOperation(operation, worker, handler))
+                            return;
+                        const error = message?.error;
+                        if (!this.ownsWorkerOperation(operation, worker, handler))
+                            return;
+                        if (loaded) {
+                            progress?.set?.(1);
+                            if (!this.ownsWorkerOperation(operation, worker, handler))
+                                return;
+                            worker.onmessage = null;
+                            this.moduleUrl = nextModuleUrl;
+                            this.manifestUrl = nextManifestUrl;
+                            this.moduleReceiptIdentity = receiptIdentity(nextModuleReceipt);
+                            this.manifestReceiptIdentity = receiptIdentity(nextManifestReceipt);
+                            this.maxAssetBytes = limits.maxAssetBytes;
+                            resolve();
+                            this.completeOperation(operation);
+                            return;
+                        }
+                        if (error !== undefined)
+                            reject(error);
+                    }
+                    catch (error) {
+                        reject(error);
                     }
-                    if (event.data?.error)
-                        reject(event.data.error);
                 };
-                this.worker.postMessage({
+                worker.onmessage = handler;
+                worker.postMessage({
                     load: true,
-                    moduleUrl: this.moduleUrl,
-                    manifestUrl: this.manifestUrl
+                    moduleUrl: nextModuleUrl,
+                    manifestUrl: nextManifestUrl,
+                    moduleReceipt: nextModuleReceipt,
+                    manifestReceipt: nextManifestReceipt,
+                    maxAssetBytes: limits.maxAssetBytes
                 });
             }
             else {
                 progress?.set?.(1);
+                if (!this.isOperationActive(operation))
+                    return;
                 resolve();
+                this.completeOperation(operation);
             }
         });
+        this.bindOperationTimeout(operation, Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs));
+        return loading.finally(() => this.completeOperation(operation));
     }
     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();
     }
-    flushPendingInput() {
+    flushPendingInput(buffer = this.activeOperation?.buffer ?? this.buffer) {
         if (!this.waitingForInput)
             return;
-        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+        if (flushQueuedStdin(this.pendingInput, buffer)) {
             this.waitingForInput = false;
             return;
         }
         if (this.pendingEof) {
-            flushBufferedEof(this.buffer);
+            flushBufferedEof(buffer);
             this.pendingEof = false;
             this.waitingForInput = false;
         }
     }
-    run(code, prepare, _log = true, _prog, _args = [], options = {}) {
-        this.exit = false;
-        return new Promise((resolve, reject) => {
-            if (!this.worker)
-                return reject('Worker not loaded');
-            const target = options.ocamlBackend || 'wasm';
-            const wasmBinaryenMode = options.ocamlWasmBinaryenMode || 'fast';
-            const _uid = ++this.uid;
-            this.activeReject = reject;
-            const handler = async (event) => {
-                if (!this.worker)
-                    return reject('Worker not loaded');
-                if (_uid !== this.uid)
-                    return (this.worker.onmessage = null);
-                const { output, results, error, diagnostic, progress, runtime } = event.data;
-                if (progress && typeof progress.percent === 'number') {
-                    _prog?.set?.(Math.max(0, Math.min(progress.percent / 100, 1)));
+    async run(code, prepare, _log = true, _prog, _args = [], options = {}) {
+        const operation = this.beginOperation('execute');
+        let signal;
+        let worker;
+        let target;
+        let wasmBinaryenMode;
+        let limits;
+        let workspace;
+        let stdin;
+        let buffer;
+        let outputCallback;
+        let onDiagnostic;
+        try {
+            signal = options.signal;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            this.bindAbortSignal(operation, signal);
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            const configuredWorker = this.worker;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            if (!configuredWorker)
+                throw 'Worker not loaded';
+            worker = configuredWorker;
+            const configuredTarget = options.ocamlBackend;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            target = configuredTarget || 'wasm';
+            const configuredBinaryenMode = options.ocamlWasmBinaryenMode;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            wasmBinaryenMode = configuredBinaryenMode || 'fast';
+            const configuredLimits = options.limits;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            limits = this.resolveOperationLimits(operation, configuredLimits);
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            const configuredWorkspaceLimits = options.workspaceLimits;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            if (configuredWorkspaceLimits !== undefined &&
+                (configuredWorkspaceLimits === null ||
+                    typeof configuredWorkspaceLimits !== 'object')) {
+                throw new TypeError('OCaml workspace limits must be an object');
+            }
+            const workspaceLimitSnapshot = {};
+            if (configuredWorkspaceLimits !== undefined) {
+                for (const key of OCAML_WORKSPACE_LIMIT_KEYS) {
+                    const value = configuredWorkspaceLimits[key];
+                    if (!this.isOperationActive(operation)) {
+                        throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+                    }
+                    if (value !== undefined) {
+                        Object.assign(workspaceLimitSnapshot, { [key]: value });
+                    }
                 }
-                if (event.data?.buffer) {
-                    this.waitingForInput = true;
-                    this.flushPendingInput();
+            }
+            validateExecutionWorkspace('', [], 'main.ml', workspaceLimitSnapshot);
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            const workspaceFilesSource = options.workspaceFiles;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            if (workspaceFilesSource !== undefined && !Array.isArray(workspaceFilesSource)) {
+                throw new TypeError('OCaml workspace files must be an array');
+            }
+            const workspaceFileCount = workspaceFilesSource?.length ?? 0;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            const maxFiles = workspaceLimitSnapshot.maxFiles ?? DEFAULT_WORKSPACE_LIMITS.maxFiles;
+            if (workspaceFileCount > maxFiles) {
+                throw new WorkspaceValidationError('file-count-limit', `Workspace contains ${workspaceFileCount} files; limit is ${maxFiles}`, { limit: maxFiles, actual: workspaceFileCount });
+            }
+            const workspaceFiles = [];
+            for (let index = 0; index < workspaceFileCount; index += 1) {
+                const file = workspaceFilesSource?.[index];
+                if (!this.isOperationActive(operation)) {
+                    throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
                 }
-                if (output)
-                    this.output(output);
-                if (diagnostic)
-                    this.oncompilerdiagnostic?.(diagnostic);
-                if (runtime) {
-                    const createdObjectUrls = [];
-                    const originalConsole = window.console;
-                    const originalFetch = window.fetch.bind(window);
-                    const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
-                    const originalInstantiateStreaming = WebAssembly.instantiateStreaming
-                        ? WebAssembly.instantiateStreaming.bind(WebAssembly)
-                        : undefined;
-                    const runtimePromiseKey = '__wasm_of_js_of_ocaml_runtime_promise';
-                    const assetResolverKey = '__wasm_of_js_of_ocaml_resolve_asset';
-                    const runtimeGlobal = window;
-                    const hadProcess = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'process');
-                    const hadRequire = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'require');
-                    const hadModule = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'module');
-                    const hadExports = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'exports');
-                    const originalProcess = runtimeGlobal.process;
-                    const originalRequire = runtimeGlobal.require;
-                    const originalModule = runtimeGlobal.module;
-                    const originalExports = runtimeGlobal.exports;
-                    originalConsole.log(`[wasm-idle:ocaml-runtime] start source=${String(runtime.sourcePath || '')} chars=${String(String(runtime.programSource || '').length)} assets=${String(Array.isArray(runtime.assetFiles) ? runtime.assetFiles.length : 0)}`);
-                    const sourceDir = String(runtime.sourcePath || '').replace(/\/[^/]+$/, '');
-                    const assetEntries = Array.isArray(runtime.assetFiles)
-                        ? runtime.assetFiles.map((assetFile) => {
-                            const copiedAssetData = new Uint8Array(assetFile.data.byteLength);
-                            copiedAssetData.set(assetFile.data);
-                            const objectUrl = URL.createObjectURL(new Blob([copiedAssetData], {
-                                type: assetFile.path.endsWith('.wasm')
-                                    ? 'application/wasm'
-                                    : 'application/octet-stream'
-                            }));
-                            createdObjectUrls.push(objectUrl);
-                            return {
-                                path: assetFile.path,
-                                basename: assetFile.path.split('/').at(-1) || assetFile.path,
-                                relativeFromSourceDir: assetFile.path.startsWith(`${sourceDir}/`)
-                                    ? assetFile.path.slice(sourceDir.length + 1)
-                                    : assetFile.path.replace(/^\/+/, ''),
-                                objectUrl
-                            };
-                        })
-                        : [];
-                    const emitOutput = (...args) => {
-                        const text = args.map((value) => String(value)).join(' ');
-                        this.output(text.endsWith('\n') ? text : `${text}\n`);
-                    };
-                    const resolveAssetUrl = (requestedAsset) => assetEntries
-                        .map((assetEntry) => {
-                        const candidates = [String(requestedAsset)];
-                        try {
-                            candidates.push(new URL(String(requestedAsset), window.location.href).pathname);
-                        }
-                        catch {
-                            // ignore URL parse errors
-                        }
-                        return candidates.some((candidate) => candidate === assetEntry.path ||
-                            candidate === assetEntry.relativeFromSourceDir ||
-                            candidate.endsWith(`/${assetEntry.relativeFromSourceDir}`) ||
-                            candidate.endsWith(`/${assetEntry.basename}`))
-                            ? assetEntry.objectUrl
-                            : null;
-                    })
-                        .find((candidate) => !!candidate) || null;
-                    window.console = {
-                        ...originalConsole,
-                        log: (...args) => {
-                            emitOutput(...args);
-                            originalConsole.log(...args);
-                        },
-                        info: (...args) => {
-                            emitOutput(...args);
-                            originalConsole.info(...args);
-                        },
-                        warn: (...args) => {
-                            emitOutput(...args);
-                            originalConsole.warn(...args);
-                        },
-                        error: (...args) => {
-                            emitOutput(...args);
-                            originalConsole.error(...args);
-                        }
-                    };
-                    window.fetch = (async (input, init) => {
-                        const requestUrl = typeof input === 'string'
-                            ? input
-                            : input instanceof URL
-                                ? input.toString()
-                                : input.url;
-                        const resolvedAssetUrl = resolveAssetUrl(requestUrl);
-                        if (resolvedAssetUrl) {
-                            return await originalFetch(resolvedAssetUrl, init);
-                        }
-                        return await originalFetch(input, init);
-                    });
-                    WebAssembly.instantiate = (async (source, importObject) => {
-                        return await originalInstantiate(source, importObject);
-                    });
-                    if (originalInstantiateStreaming) {
-                        WebAssembly.instantiateStreaming = (async (source, importObject) => {
-                            return await originalInstantiateStreaming(source, importObject);
-                        });
+                if (file === null || typeof file !== 'object' || Array.isArray(file)) {
+                    throw new TypeError('OCaml workspace file must be an object');
+                }
+                const path = file.path;
+                if (!this.isOperationActive(operation)) {
+                    throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+                }
+                const content = file.content;
+                if (!this.isOperationActive(operation)) {
+                    throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+                }
+                if (typeof content !== 'string') {
+                    throw new TypeError('OCaml workspace file content must be a string');
+                }
+                workspaceFiles.push({ path, content });
+            }
+            const configuredActivePath = options.activePath;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            workspace = validateExecutionWorkspace(code, workspaceFiles, configuredActivePath ?? 'main.ml', {
+                ...workspaceLimitSnapshot,
+                maxFileBytes: Math.min(workspaceLimitSnapshot.maxFileBytes ??
+                    DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                maxTotalBytes: Math.min(workspaceLimitSnapshot.maxTotalBytes ??
+                    DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+            });
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            stdin = options.stdin;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            buffer = this.buffer;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            outputCallback = this.output;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            onDiagnostic = this.oncompilerdiagnostic;
+            if (!this.isOperationActive(operation)) {
+                throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+            }
+            operation.buffer = buffer;
+            if (stdin !== undefined) {
+                operation.explicitStdin = true;
+                this.resetExplicitStdinState(buffer);
+                if (!this.isOperationActive(operation)) {
+                    throw this.releaseBeforeSession(operation, 'OCaml execution cancelled');
+                }
+            }
+        }
+        catch (error) {
+            throw this.releaseBeforeSession(operation, error);
+        }
+        const hasExplicitStdin = stdin !== undefined;
+        operation.sessionActive = true;
+        try {
+            this.exit = false;
+            return await new Promise((resolve, reject) => {
+                const runUid = ++this.uid;
+                let outputBytes = 0;
+                let diagnosticCount = 0;
+                const workerOperation = this.workerSession.beginRun(worker, reject);
+                this.bindOperationTimeout(operation, Math.min(2_147_483_647, limits.compileTimeoutMs + limits.runTimeoutMs));
+                if (!this.isOperationActive(operation))
+                    return;
+                let handler;
+                const ownsRun = () => this.ownsWorkerOperation(operation, worker, handler, runUid);
+                const failRun = (error, disposeWorker = false) => {
+                    if (!ownsRun())
+                        return;
+                    this.finishExplicitStdin(operation);
+                    if (worker.onmessage === handler)
+                        worker.onmessage = null;
+                    this.workerSession.complete(workerOperation);
+                    if (disposeWorker && this.worker === worker)
+                        this.workerSession.reset();
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.completeOperation(operation);
+                    reject(error);
+                };
+                handler = (event) => {
+                    if (!ownsRun()) {
+                        return;
                     }
-                    runtimeGlobal.process = undefined;
-                    runtimeGlobal.require = undefined;
-                    runtimeGlobal.module = undefined;
-                    runtimeGlobal.exports = undefined;
-                    runtimeGlobal[assetResolverKey] = resolveAssetUrl;
                     try {
-                        const normalizedSource = String(runtime.programSource || '').includes('($=>async a=>{')
-                            ? String(runtime.programSource).replace('($=>async a=>{', `globalThis.${runtimePromiseKey}=($=>async a=>{`)
-                            : String(runtime.programSource || '');
-                        const sourceWithAssetResolver = normalizedSource.replace(/function ([A-Za-z$_][\w$]*)\(([A-Za-z$_][\w$]*)\)\{const ([A-Za-z$_][\w$]*)=([A-Za-z$_][\w$]*)\?new URL\(\2,\4\):\2;return fetch\(\3\)\}/, `function $1($2){if(globalThis.${assetResolverKey}){const resolvedAsset=globalThis.${assetResolverKey}($2);if(resolvedAsset)return fetch(resolvedAsset)}const $3=$4?new URL($2,$4):$2;return fetch($3)}`);
-                        new Function(`${sourceWithAssetResolver}\n//# sourceURL=${String(runtime.sourcePath || 'ocaml-runtime.js')}`)();
-                        originalConsole.log('[wasm-idle:ocaml-runtime] script invoked');
-                        const runtimePromise = runtimeGlobal[runtimePromiseKey];
-                        originalConsole.log(`[wasm-idle:ocaml-runtime] runtime promise=${String(runtimePromise instanceof Promise)}`);
-                        if (runtimePromise instanceof Promise) {
-                            await runtimePromise;
-                        }
-                        this.elapse = Date.now() - this.begin;
-                        this.exit = true;
-                        this.activeReject = null;
-                        resolve(true);
-                    }
-                    catch (runtimeError) {
-                        this.elapse = Date.now() - this.begin;
-                        this.exit = true;
-                        this.activeReject = null;
-                        reject(runtimeError?.message || String(runtimeError));
-                    }
-                    finally {
-                        window.console = originalConsole;
-                        window.fetch = originalFetch;
-                        WebAssembly.instantiate = originalInstantiate;
-                        if (originalInstantiateStreaming) {
-                            WebAssembly.instantiateStreaming = originalInstantiateStreaming;
-                        }
-                        delete runtimeGlobal[runtimePromiseKey];
-                        delete runtimeGlobal[assetResolverKey];
-                        if (!hadProcess) {
-                            delete runtimeGlobal.process;
-                        }
-                        else {
-                            runtimeGlobal.process = originalProcess;
+                        const message = event.data;
+                        if (!ownsRun())
+                            return;
+                        const output = message?.output;
+                        if (!ownsRun())
+                            return;
+                        const results = message?.results;
+                        if (!ownsRun())
+                            return;
+                        const error = message?.error;
+                        if (!ownsRun())
+                            return;
+                        const diagnostic = message?.diagnostic;
+                        if (!ownsRun())
+                            return;
+                        const progress = message?.progress;
+                        if (!ownsRun())
+                            return;
+                        const runtime = message?.runtime;
+                        if (!ownsRun())
+                            return;
+                        const requestsInput = message?.buffer;
+                        if (!ownsRun())
+                            return;
+                        reportWorkerProgress(_prog, progress);
+                        if (!ownsRun()) {
+                            return;
                         }
-                        if (!hadRequire) {
-                            delete runtimeGlobal.require;
+                        if (requestsInput && !hasExplicitStdin) {
+                            this.waitingForInput = true;
+                            if (!prepare) {
+                                reportWorkerInputReady(_prog, 'OCaml runtime ready for input');
+                                if (!ownsRun())
+                                    return;
+                            }
+                            this.flushPendingInput(buffer);
+                            if (!ownsRun()) {
+                                return;
+                            }
                         }
-                        else {
-                            runtimeGlobal.require = originalRequire;
+                        if (output) {
+                            const actual = outputBytes + OUTPUT_ENCODER.encode(String(output)).byteLength;
+                            if (actual > limits.maxOutputBytes) {
+                                failRun(new OutputLimitError(`OCaml output exceeded ${limits.maxOutputBytes} bytes`, {
+                                    actual,
+                                    limit: limits.maxOutputBytes,
+                                    phase: 'execute',
+                                    runtimeId: 'OCAML'
+                                }), true);
+                                return;
+                            }
+                            outputBytes = actual;
+                            if (outputCallback != null) {
+                                Reflect.apply(outputCallback, this, [output]);
+                            }
+                            if (!ownsRun()) {
+                                return;
+                            }
                         }
-                        if (!hadModule) {
-                            delete runtimeGlobal.module;
+                        if (diagnostic) {
+                            const actual = diagnosticCount + 1;
+                            if (actual > limits.maxDiagnostics) {
+                                failRun(new DiagnosticLimitError(`OCaml diagnostics exceeded ${limits.maxDiagnostics} messages`, {
+                                    actual,
+                                    limit: limits.maxDiagnostics,
+                                    phase: 'execute',
+                                    runtimeId: 'OCAML'
+                                }), true);
+                                return;
+                            }
+                            diagnosticCount = actual;
+                            if (onDiagnostic != null)
+                                Reflect.apply(onDiagnostic, this, [diagnostic]);
+                            if (!ownsRun()) {
+                                return;
+                            }
                         }
-                        else {
-                            runtimeGlobal.module = originalModule;
+                        if (runtime) {
+                            failRun(new ProtocolError('Unexpected OCaml page runtime message', {
+                                phase: 'execute',
+                                runtimeId: 'OCAML'
+                            }), true);
+                            return;
                         }
-                        if (!hadExports) {
-                            delete runtimeGlobal.exports;
-                        }
-                        else {
-                            runtimeGlobal.exports = originalExports;
-                        }
-                        for (const objectUrl of createdObjectUrls) {
-                            URL.revokeObjectURL(objectUrl);
+                        if (results !== undefined) {
+                            this.finishExplicitStdin(operation);
+                            if (worker.onmessage === handler)
+                                worker.onmessage = null;
+                            this.elapse = Date.now() - this.begin;
+                            this.exit = true;
+                            this.waitingForInput = false;
+                            this.pendingEof = false;
+                            this.workerSession.complete(workerOperation);
+                            this.completeOperation(operation);
+                            resolve(results);
+                            return;
                         }
+                        if (error !== undefined)
+                            failRun(error);
+                    }
+                    catch (error) {
+                        failRun(error, true);
                     }
+                };
+                worker.onmessage = handler;
+                if (!ownsRun()) {
                     return;
                 }
-                if (results) {
-                    this.elapse = Date.now() - this.begin;
-                    this.exit = true;
-                    this.waitingForInput = false;
-                    this.pendingEof = false;
-                    this.activeReject = null;
-                    resolve(results);
+                this.begin = Date.now();
+                try {
+                    worker.postMessage({
+                        code,
+                        prepare,
+                        target,
+                        wasmBinaryenMode,
+                        log: _log,
+                        buffer,
+                        stdin,
+                        activePath: workspace.activePath,
+                        workspaceFiles: workspace.workspaceFiles
+                    });
                 }
-                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);
                 }
-            };
-            this.worker.onmessage = (event) => {
-                void handler(event);
-            };
-            this.begin = Date.now();
-            this.worker.postMessage({
-                code,
-                prepare,
-                target,
-                wasmBinaryenMode,
-                log: _log,
-                buffer: this.buffer
             });
-        });
+        }
+        finally {
+            this.finishExplicitStdin(operation);
+            this.completeOperation(operation);
+        }
     }
     kill() {
         this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const operation = this.activeOperation;
+        if (operation) {
+            if (operation.sessionActive)
+                this.abortOperation(operation, reason);
+            else
+                this.cancelBeforeSession(operation, reason);
+            return;
+        }
         this.waitingForInput = false;
         this.pendingEof = false;
         this.uid += 1;
-        this.worker?.terminate?.();
-        delete this.worker;
+        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.exit) {
             this.terminate();
         }
     }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const operation = this.activeOperation;
+        const operationBuffer = operation?.buffer;
+        delete this.worker;
+        this.moduleUrl = '';
+        this.manifestUrl = '';
+        this.moduleReceiptIdentity = '';
+        this.manifestReceiptIdentity = '';
+        this.maxAssetBytes = 0;
+        this.output = undefined;
+        this.oncompilerdiagnostic = undefined;
+        this.resetExplicitStdinState(this.buffer);
+        if (operationBuffer && operationBuffer !== this.buffer) {
+            try {
+                resetBufferedStdin(operationBuffer);
+            }
+            catch {
+                // A detached operation buffer is already outside the live host state.
+            }
+        }
+        if (operation) {
+            this.abortOperation(operation, this.disposeCancellation);
+        }
+        else {
+            this.uid += 1;
+            this.workerSession.terminate(this.disposeCancellation);
+            this.exit = true;
+        }
+        return this.disposePromise;
+    }
 }
 export default Ocaml;