wasm-idle 0.7.2 → 1.0.0

package/dist/playground/tinygo.js

@@ -1,29 +1,88 @@
-import { resolveRustCompilerUrl, resolveTinyGoHostCompileUrls, resolveTinyGoModuleUrl } from './assets';
-import { resolveSandboxExecutionArgs } from './options';
+import { resolveRustCompilerUrl, resolveTinyGoModuleUrl } from './assets';
+import { loadVerifiedTinyGoExecutableGraph } from './tinygoExecutableGraph';
+import { WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE, WASM_TINYGO_RUNTIME_PROFILE } from './wasmTinyGoVersion';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { createWasmIdleSharedBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerProgress } from './workerProgress';
+import { BusyError, CancelledError, DEFAULT_EXECUTION_LIMITS, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, WorkspaceValidationError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
 const ACTIVITY_PREFIX_PATTERN = /^\[\d{2}:\d{2}:\d{2}\]\s?/gm;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const TINYGO_BROWSER_COMPILER_DEFAULT_MAX_WASM_MEMORY_BYTES = 2 * 1024 * 1024 * 1024;
+const EXECUTION_LIMIT_KEYS = Object.keys(DEFAULT_EXECUTION_LIMITS);
+const OUTPUT_ENCODER = new TextEncoder();
+const TINYGO_TARGETS = new Set(['wasm', 'wasip1', 'wasip2', 'wasip3']);
+function snapshotTinyGoRuntimeProfile(config) {
+    const profileFields = [
+        'profileId',
+        'protocolVersion',
+        'manifestPath',
+        'manifestFingerprint',
+        'manifestReceipt',
+        'assetReceipts'
+    ];
+    const hasOverride = profileFields.some((field) => config?.[field] !== undefined);
+    const source = hasOverride ? config : WASM_TINYGO_RUNTIME_PROFILE;
+    if (!source ||
+        typeof source.profileId !== 'string' ||
+        typeof source.protocolVersion !== 'number' ||
+        typeof source.manifestPath !== 'string' ||
+        typeof source.manifestFingerprint !== 'string' ||
+        !source.manifestReceipt ||
+        !source.assetReceipts) {
+        throw new RuntimeConfigurationError('TinyGo runtime profile overrides must provide the complete profile and receipt set', { runtimeId: 'TINYGO' });
+    }
+    const assetReceipts = Object.fromEntries(Object.entries(source.assetReceipts).map(([assetPath, receipt]) => [
+        assetPath,
+        Object.freeze(typeof receipt === 'string' ? { sha256: receipt } : { ...receipt })
+    ]));
+    return Object.freeze({
+        profileId: source.profileId,
+        protocolVersion: source.protocolVersion,
+        manifestPath: source.manifestPath,
+        manifestFingerprint: source.manifestFingerprint,
+        manifestReceipt: Object.freeze({ ...source.manifestReceipt }),
+        assetReceipts: Object.freeze(assetReceipts)
+    });
+}
+function snapshotTinyGoExecutableGraphFingerprint(config) {
+    const configuredFingerprint = config?.executableGraphFingerprint;
+    if (configuredFingerprint !== undefined &&
+        configuredFingerprint !== WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.fingerprint) {
+        throw new RuntimeConfigurationError('TinyGo executable graph overrides must match the bundled receipt profile', { phase: 'asset', runtimeId: 'TINYGO' });
+    }
+    return WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE.fingerprint;
+}
+const abortReason = (signal, phase) => {
+    const reason = signal.reason;
+    return reason !== undefined
+        ? reason
+        : new DOMException(phase === 'startup' ? 'TinyGo startup aborted' : 'TinyGo execution aborted', 'AbortError');
+};
 class TinyGo {
     output = null;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
+    buffer = createWasmIdleSharedBuffer(1024);
     pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
     exit = true;
     moduleUrl = '';
-    hostCompileUrl = '';
-    hostCompileUrls = [];
+    executableGraphFingerprint = '';
     rustRuntimeBaseUrl = '';
+    oncompilerdiagnostic;
     assetLoader = undefined;
-    assetPacks = undefined;
+    runtimeProfile = undefined;
+    executableGraph = null;
     runtime = null;
+    runtimeToken = null;
     runtimePromise = null;
+    runtimePromiseToken = null;
     loadPromise = null;
     compiledArtifact = null;
     compiledArtifactExecutionError = '';
     compiledCacheKey = '';
-    activeReject = null;
     waitingForInput = false;
     pendingEof = false;
     lastActivityLog = '';
@@ -32,195 +91,817 @@ class TinyGo {
     runtimeProgressEnd = 0;
     runtimeProgressValue = 0;
     runtimeProgressAssets = new Map();
-    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
-        return new Promise(async (resolve, reject) => {
-            this.pendingInput = [];
-            this.waitingForInput = false;
-            this.pendingEof = false;
-            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
-            const nextModuleUrl = resolveTinyGoModuleUrl(runtimeAssets, currentUrl);
-            const nextHostCompileUrls = resolveTinyGoHostCompileUrls(runtimeAssets, currentUrl);
-            const nextRustCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
-            const nextRustRuntimeBaseUrl = nextRustCompilerUrl
-                ? new URL('./runtime/', nextRustCompilerUrl).toString()
-                : '';
-            if (!nextModuleUrl && nextHostCompileUrls.length === 0) {
-                return reject('TinyGo runtime is not configured. Set PUBLIC_WASM_TINYGO_MODULE_URL, PUBLIC_WASM_TINYGO_HOST_COMPILE_URL, runtimeAssets.tinygo.moduleUrl, or runtimeAssets.tinygo.hostCompileUrl.');
-            }
-            if ((this.moduleUrl && this.moduleUrl !== nextModuleUrl) ||
-                this.hostCompileUrls.join('\n') !== nextHostCompileUrls.join('\n') ||
-                this.rustRuntimeBaseUrl !== nextRustRuntimeBaseUrl) {
-                this.disposeRuntime();
-                this.compiledArtifact = null;
-                this.compiledArtifactExecutionError = '';
-                this.compiledCacheKey = '';
-            }
-            const nextAssetLoader = typeof runtimeAssets === 'object' ? runtimeAssets?.tinygo?.assetLoader : undefined;
-            const nextAssetPacks = typeof runtimeAssets === 'object' ? runtimeAssets?.tinygo?.assetPacks : undefined;
-            this.moduleUrl = nextModuleUrl;
-            this.hostCompileUrl = nextHostCompileUrls[0] || '';
-            this.hostCompileUrls = nextHostCompileUrls;
-            this.rustRuntimeBaseUrl = nextRustRuntimeBaseUrl;
-            this.assetLoader = nextAssetLoader;
-            this.assetPacks = nextAssetPacks;
+    runtimeProgressOwner = null;
+    activeOperation = null;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('TinyGo sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'TINYGO',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'TinyGo',
+        onDispose: (worker) => {
+            if (this.worker === worker)
+                delete this.worker;
+            this.exit = true;
+            this.clearPendingStdin();
+        }
+    });
+    disposedConfigurationError() {
+        return new RuntimeConfigurationError('TinyGo sandbox is disposed', {
+            phase: 'dispose',
+            runtimeId: 'TINYGO'
+        });
+    }
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        return this.executeOperation('startup', options, async (operation) => {
             try {
-                progress?.set?.(0.25);
-                await this.ensureWorker();
-                progress?.set?.(0.5);
-                if (nextHostCompileUrls.length === 0 && nextModuleUrl) {
-                    await this.ensureRuntime();
+                this.assertOperation(operation);
+                this.clearPendingStdin();
+                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                this.assertOperation(operation);
+                const nextModuleUrl = resolveTinyGoModuleUrl(runtimeAssets, currentUrl);
+                this.assertOperation(operation);
+                const nextRustCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
+                this.assertOperation(operation);
+                const nextRustRuntimeBaseUrl = nextRustCompilerUrl
+                    ? new URL('./runtime/', nextRustCompilerUrl).toString()
+                    : '';
+                this.assertOperation(operation);
+                let nextAssetLoader;
+                let tinyGoAssets;
+                if (typeof runtimeAssets === 'object' && runtimeAssets !== null) {
+                    tinyGoAssets = runtimeAssets.tinygo;
+                    this.assertOperation(operation);
+                    nextAssetLoader = tinyGoAssets?.assetLoader;
+                    this.assertOperation(operation);
+                }
+                const nextRuntimeProfile = snapshotTinyGoRuntimeProfile(tinyGoAssets);
+                this.assertOperation(operation);
+                const nextExecutableGraphFingerprint = snapshotTinyGoExecutableGraphFingerprint(tinyGoAssets);
+                this.assertOperation(operation);
+                if (!nextModuleUrl) {
+                    throw new Error('TinyGo runtime is not configured. Set PUBLIC_WASM_TINYGO_MODULE_URL or runtimeAssets.tinygo.moduleUrl.');
                 }
+                if ((this.moduleUrl && this.moduleUrl !== nextModuleUrl) ||
+                    this.rustRuntimeBaseUrl !== nextRustRuntimeBaseUrl ||
+                    this.assetLoader !== nextAssetLoader ||
+                    this.executableGraphFingerprint !== nextExecutableGraphFingerprint ||
+                    this.runtimeProfile?.manifestFingerprint !==
+                        nextRuntimeProfile.manifestFingerprint) {
+                    this.disposeRuntime();
+                    this.assertOperation(operation);
+                    this.compiledArtifact = null;
+                    this.compiledArtifactExecutionError = '';
+                    this.compiledCacheKey = '';
+                }
+                this.assetLoader = nextAssetLoader;
+                this.runtimeProfile = nextRuntimeProfile;
+                this.executableGraphFingerprint = nextExecutableGraphFingerprint;
+                this.moduleUrl = nextModuleUrl;
+                this.rustRuntimeBaseUrl = nextRustRuntimeBaseUrl;
+                progress?.set?.(0.25);
+                this.assertOperation(operation);
+                await this.ensureRuntime(operation);
+                this.assertOperation(operation);
+                progress?.set?.(0.75);
+                this.assertOperation(operation);
+                await this.ensureWorker(operation);
+                this.assertOperation(operation);
                 progress?.set?.(1);
-                resolve();
+                this.assertOperation(operation);
+            }
+            catch (error) {
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        });
+    }
+    beginOperation(phase) {
+        if (this.disposed)
+            throw this.disposedConfigurationError();
+        if (this.activeOperation) {
+            throw new BusyError('TinyGo runtime already has an active operation', {
+                runtimeId: 'TINYGO',
+                phase: this.activeOperation.phase
+            });
+        }
+        const operation = {
+            token: Symbol(phase),
+            phase,
+            controller: new AbortController(),
+            cancelled: false,
+            diagnosticCount: 0,
+            outputBytes: 0,
+            hasExplicitWasmMemoryLimit: false
+        };
+        this.activeOperation = operation;
+        return operation;
+    }
+    completeOperation(operation) {
+        if (this.activeOperation?.token === operation.token) {
+            this.activeOperation = null;
+        }
+    }
+    isOperationActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.cancelled;
+    }
+    assertOperation(operation) {
+        if (!this.isOperationActive(operation)) {
+            throw operation.reason ?? 'Process terminated';
+        }
+    }
+    snapshotExecutionLimits(operation, configured) {
+        const snapshot = {};
+        if (configured) {
+            for (const key of EXECUTION_LIMIT_KEYS) {
+                this.assertOperation(operation);
+                const enumerable = Object.prototype.propertyIsEnumerable.call(configured, key);
+                this.assertOperation(operation);
+                if (!enumerable)
+                    continue;
+                const value = configured[key];
+                this.assertOperation(operation);
+                if (value !== undefined)
+                    snapshot[key] = value;
+            }
+        }
+        operation.hasExplicitWasmMemoryLimit = Object.prototype.hasOwnProperty.call(snapshot, 'maxWasmMemoryBytes');
+        const limits = resolveExecutionLimits(snapshot);
+        this.assertOperation(operation);
+        return limits;
+    }
+    executeOperation(phase, options, execute, snapshot) {
+        let operation;
+        try {
+            operation = this.beginOperation(phase);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let signal;
+            let onAbort;
+            let deadline;
+            const cleanup = () => {
+                delete operation.reject;
+                this.completeOperation(operation);
+                if (deadline !== undefined) {
+                    const settledDeadline = deadline;
+                    deadline = undefined;
+                    try {
+                        clearTimeout(settledDeadline);
+                    }
+                    catch {
+                        // Timer cleanup must not replace the operation result.
+                    }
+                }
+                if (signal && onAbort) {
+                    try {
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    catch {
+                        // Cleanup must not replace the operation result.
+                    }
+                }
+            };
+            const resolveOperation = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(value);
+            };
+            const rejectOperation = (reason) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(reason);
+            };
+            operation.reject = rejectOperation;
+            try {
+                signal = options.signal;
+            }
+            catch (error) {
+                rejectOperation(operation.cancelled ? operation.reason : error);
+                return;
+            }
+            if (settled)
+                return;
+            let preAborted = false;
+            try {
+                preAborted = signal?.aborted === true;
+            }
+            catch (error) {
+                rejectOperation(error);
+                return;
+            }
+            if (settled)
+                return;
+            if (preAborted && signal) {
+                try {
+                    rejectOperation(abortReason(signal, phase));
+                }
+                catch (error) {
+                    rejectOperation(error);
+                }
+                return;
+            }
+            onAbort = signal
+                ? () => {
+                    if (!this.isOperationActive(operation))
+                        return;
+                    let reason;
+                    try {
+                        reason = abortReason(signal, phase);
+                    }
+                    catch (error) {
+                        reason = error;
+                    }
+                    if (this.isOperationActive(operation)) {
+                        this.cancelOperation(operation, reason);
+                    }
+                }
+                : undefined;
+            if (signal && onAbort) {
+                try {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                catch (error) {
+                    rejectOperation(error);
+                    return;
+                }
+                if (settled)
+                    return;
+                try {
+                    if (signal.aborted)
+                        onAbort();
+                }
+                catch (error) {
+                    rejectOperation(error);
+                    return;
+                }
+            }
+            if (settled)
+                return;
+            let limits;
+            try {
+                const configuredLimits = options.limits;
+                if (settled)
+                    return;
+                limits = this.snapshotExecutionLimits(operation, configuredLimits);
+            }
+            catch (error) {
+                rejectOperation(operation.cancelled ? operation.reason : error);
+                return;
+            }
+            if (settled)
+                return;
+            operation.limits = limits;
+            const timeoutMs = Math.min(MAX_TIMER_DELAY_MS, phase === 'startup'
+                ? limits.assetTimeoutMs + limits.startupTimeoutMs
+                : limits.compileTimeoutMs + limits.runTimeoutMs);
+            let scheduledDeadline;
+            try {
+                scheduledDeadline = setTimeout(() => {
+                    if (!this.isOperationActive(operation))
+                        return;
+                    const label = phase === 'startup' ? 'runtime startup' : 'execution';
+                    this.cancelOperation(operation, new TimeoutError(`TinyGo ${label} timed out after ${timeoutMs} ms`, {
+                        phase,
+                        runtimeId: 'TINYGO',
+                        timeoutMs
+                    }));
+                }, timeoutMs);
+            }
+            catch (error) {
+                rejectOperation(error);
+                return;
+            }
+            if (settled || !this.isOperationActive(operation)) {
+                try {
+                    clearTimeout(scheduledDeadline);
+                }
+                catch {
+                    // A synchronously settled deadline is already detached.
+                }
+                return;
+            }
+            deadline = scheduledDeadline;
+            let request;
+            try {
+                this.assertOperation(operation);
+                request = snapshot ? snapshot(operation) : undefined;
             }
             catch (error) {
-                reject(error instanceof Error ? error.message : String(error));
+                rejectOperation(operation.cancelled ? operation.reason : error);
+                return;
             }
+            if (settled || !this.isOperationActive(operation))
+                return;
+            void Promise.resolve()
+                .then(() => {
+                this.assertOperation(operation);
+                return execute(operation, request);
+            })
+                .then((value) => {
+                if (this.isOperationActive(operation))
+                    resolveOperation(value);
+            }, (error) => {
+                if (this.isOperationActive(operation))
+                    rejectOperation(error);
+            });
         });
     }
+    emitOutput(operation, data) {
+        this.assertOperation(operation);
+        const limit = operation.limits?.maxOutputBytes ?? DEFAULT_EXECUTION_LIMITS.maxOutputBytes;
+        const actual = operation.outputBytes + OUTPUT_ENCODER.encode(data).byteLength;
+        this.assertOperation(operation);
+        if (actual > limit) {
+            operation.outputBytes = actual;
+            this.cancelOperation(operation, new OutputLimitError(`TinyGo output exceeded ${limit} bytes`, {
+                actual,
+                limit,
+                phase: 'execute',
+                runtimeId: 'TINYGO'
+            }));
+            return false;
+        }
+        operation.outputBytes = actual;
+        try {
+            const output = this.output;
+            this.assertOperation(operation);
+            if (output)
+                Reflect.apply(output, this, [data]);
+        }
+        catch (error) {
+            if (this.isOperationActive(operation))
+                this.cancelOperation(operation, error);
+            return false;
+        }
+        return this.isOperationActive(operation);
+    }
+    emitCompilerDiagnostic(operation, diagnostic) {
+        this.assertOperation(operation);
+        try {
+            if (!diagnostic || typeof diagnostic !== 'object') {
+                throw new RuntimeConfigurationError('TinyGo runtime emitted an invalid compiler diagnostic', { phase: operation.phase, runtimeId: 'TINYGO' });
+            }
+            const message = diagnostic.message;
+            this.assertOperation(operation);
+            const rawSeverity = diagnostic.severity;
+            this.assertOperation(operation);
+            const rawFileName = diagnostic.fileName;
+            this.assertOperation(operation);
+            const rawLineNumber = diagnostic.lineNumber;
+            this.assertOperation(operation);
+            const rawColumnNumber = diagnostic.columnNumber;
+            this.assertOperation(operation);
+            const rawEndColumnNumber = diagnostic.endColumnNumber;
+            this.assertOperation(operation);
+            if (typeof message !== 'string' || message.length === 0) {
+                throw new RuntimeConfigurationError('TinyGo runtime emitted a compiler diagnostic without a message', { phase: operation.phase, runtimeId: 'TINYGO' });
+            }
+            const actual = operation.diagnosticCount + 1;
+            const limit = operation.limits?.maxDiagnostics ?? DEFAULT_EXECUTION_LIMITS.maxDiagnostics;
+            if (actual > limit) {
+                operation.diagnosticCount = actual;
+                this.cancelOperation(operation, new DiagnosticLimitError(`TinyGo diagnostics exceeded ${limit} messages`, {
+                    actual,
+                    limit,
+                    phase: operation.phase,
+                    runtimeId: 'TINYGO'
+                }));
+                this.assertOperation(operation);
+            }
+            operation.diagnosticCount = actual;
+            const compilerDiagnostic = {
+                message,
+                severity: rawSeverity === 'error' || rawSeverity === 'warning' ? rawSeverity : 'other',
+                lineNumber: Number.isSafeInteger(rawLineNumber) && Number(rawLineNumber) >= 0
+                    ? Number(rawLineNumber)
+                    : 1
+            };
+            if (rawFileName === null || typeof rawFileName === 'string') {
+                compilerDiagnostic.fileName = rawFileName;
+            }
+            if (Number.isSafeInteger(rawColumnNumber) && Number(rawColumnNumber) >= 0) {
+                compilerDiagnostic.columnNumber = Number(rawColumnNumber);
+            }
+            if (Number.isSafeInteger(rawEndColumnNumber) && Number(rawEndColumnNumber) >= 0) {
+                compilerDiagnostic.endColumnNumber = Number(rawEndColumnNumber);
+            }
+            const callback = this.oncompilerdiagnostic;
+            this.assertOperation(operation);
+            if (callback)
+                Reflect.apply(callback, this, [compilerDiagnostic]);
+            this.assertOperation(operation);
+        }
+        catch (error) {
+            if (this.isOperationActive(operation))
+                this.cancelOperation(operation, error);
+            this.assertOperation(operation);
+        }
+    }
+    clearPendingStdin() {
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.waitingForInput = false;
+    }
     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() {
         if (!this.waitingForInput)
             return;
-        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+        const buffer = this.activeOperation?.buffer ?? 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;
         }
     }
-    async ensureWorker() {
+    async ensureWorker(operation) {
+        this.assertOperation(operation);
         if (this.worker)
             return;
-        if (this.loadPromise) {
-            await this.loadPromise;
+        const pendingLoad = this.loadPromise;
+        if (pendingLoad) {
+            await pendingLoad;
+            this.assertOperation(operation);
             return;
         }
-        this.loadPromise = new Promise(async (resolve, reject) => {
-            this.worker = new (await import('./worker/tinygo?worker')).default();
-            this.worker.onerror = (event) => {
-                const location = event.filename && event.lineno
-                    ? ` (${event.filename}:${event.lineno}:${event.colno})`
-                    : '';
-                reject(`TinyGo worker script error: ${event.message || 'unknown error'}${location}`);
-            };
-            this.worker.onmessageerror = () => {
-                reject('TinyGo worker message deserialization failed');
-            };
-            this.worker.onmessage = (event) => {
-                if (event.data?.load)
-                    resolve();
-                if (event.data?.error)
-                    reject(event.data.error);
-            };
-            this.worker.postMessage({ load: true });
-        }).finally(() => {
-            this.loadPromise = null;
-        });
-        await this.loadPromise;
+        const loadPromise = (async () => {
+            const WorkerConstructor = (await import('./worker/tinygo?worker'))
+                .default;
+            this.assertOperation(operation);
+            const worker = new WorkerConstructor();
+            if (!this.isOperationActive(operation)) {
+                worker.terminate();
+                this.assertOperation(operation);
+            }
+            this.worker = worker;
+            const workerLoad = this.workerSession.waitForLoad(worker, (resolve, reject) => {
+                if (!this.isOperationActive(operation) || this.worker !== worker) {
+                    return reject(operation.reason ?? 'Worker not loaded');
+                }
+                worker.onmessage = (event) => {
+                    if (!this.isOperationActive(operation) || this.worker !== worker)
+                        return;
+                    const message = event.data ?? {};
+                    if (message.load) {
+                        resolve();
+                        return;
+                    }
+                    if (Object.prototype.hasOwnProperty.call(message, 'error')) {
+                        reject(message.error);
+                    }
+                };
+                worker.postMessage({ load: true });
+            });
+            if (!this.isOperationActive(operation) || this.worker !== worker) {
+                this.workerSession.terminate(operation.reason ?? 'Worker not loaded');
+            }
+            await workerLoad;
+            this.assertOperation(operation);
+            if (this.worker !== worker)
+                throw operation.reason ?? 'Worker not loaded';
+        })();
+        this.loadPromise = loadPromise;
+        try {
+            await loadPromise;
+        }
+        finally {
+            if (this.loadPromise === loadPromise)
+                this.loadPromise = null;
+        }
     }
-    disposeRuntime() {
-        this.runtime?.dispose?.();
+    detachRuntime() {
+        const runtime = this.runtime;
+        const executableGraph = this.executableGraph;
         this.runtime = null;
+        this.executableGraph = null;
+        this.runtimeToken = null;
         this.runtimePromise = null;
+        this.runtimePromiseToken = null;
         this.lastActivityLog = '';
         this.compiledArtifactExecutionError = '';
+        this.runtimeProgress = undefined;
+        this.runtimeProgressOwner = null;
+        this.runtimeProgressAssets.clear();
+        try {
+            executableGraph?.dispose();
+        }
+        catch {
+            // Executable graph cleanup must not replace the lifecycle result.
+        }
+        return runtime;
+    }
+    disposeRuntimeHooks(runtime) {
+        try {
+            runtime?.dispose?.();
+        }
+        catch {
+            // Runtime cleanup must not replace the lifecycle result.
+        }
+    }
+    disposeRuntime() {
+        this.disposeRuntimeHooks(this.detachRuntime());
     }
-    async ensureRuntime() {
+    reportRuntimeProgress(runtimeToken, progress) {
+        const owner = this.runtimeProgressOwner;
+        if (!owner ||
+            owner.runtimeToken !== runtimeToken ||
+            this.activeOperation?.token !== owner.operationToken ||
+            !this.runtimeProgress) {
+            return;
+        }
+        const total = progress.total && progress.total > 0 ? progress.total : progress.loaded;
+        const key = progress.assetUrl || progress.assetPath;
+        this.runtimeProgressAssets.set(key, {
+            loaded: Math.max(0, progress.loaded),
+            total: Math.max(1, total)
+        });
+        let loaded = 0;
+        let size = 0;
+        for (const entry of this.runtimeProgressAssets.values()) {
+            loaded += Math.min(entry.loaded, entry.total);
+            size += entry.total;
+        }
+        if (size <= 0)
+            return;
+        const nextValue = this.runtimeProgressStart +
+            ((this.runtimeProgressEnd - this.runtimeProgressStart) * loaded) / size;
+        if (nextValue <= this.runtimeProgressValue)
+            return;
+        this.runtimeProgressValue = nextValue;
+        this.runtimeProgress.set?.(nextValue);
+    }
+    requireRuntimeAssetLimitSetter(runtime) {
+        const setMaxAssetBytes = runtime.setMaxAssetBytes;
+        if (typeof setMaxAssetBytes !== 'function') {
+            throw new RuntimeConfigurationError('TinyGo runtime module must implement setMaxAssetBytes()', { runtimeId: 'TINYGO' });
+        }
+        return (maxAssetBytes) => setMaxAssetBytes.call(runtime, maxAssetBytes);
+    }
+    async ensureRuntime(operation) {
+        this.assertOperation(operation);
         if (this.runtime) {
             return this.runtime;
         }
-        if (this.runtimePromise) {
-            return await this.runtimePromise;
+        const pendingRuntime = this.runtimePromise;
+        if (pendingRuntime) {
+            const runtime = await pendingRuntime;
+            this.assertOperation(operation);
+            return runtime;
         }
         const moduleUrl = this.moduleUrl;
-        this.runtimePromise = (async () => {
-            const runtimeModule = (await import(
-            /* @vite-ignore */ moduleUrl));
-            if (typeof runtimeModule.createBundledTinyGoRuntime === 'function') {
-                this.runtime = runtimeModule.createBundledTinyGoRuntime({
-                    assetLoader: this.assetLoader,
-                    assetPacks: this.assetPacks,
-                    rustRuntimeBaseUrl: this.rustRuntimeBaseUrl || undefined,
-                    onProgress: (progress) => {
-                        if (!this.runtimeProgress)
-                            return;
-                        const total = progress.total && progress.total > 0 ? progress.total : progress.loaded;
-                        const key = progress.assetUrl || progress.assetPath;
-                        this.runtimeProgressAssets.set(key, {
-                            loaded: Math.max(0, progress.loaded),
-                            total: Math.max(1, total)
-                        });
-                        let loaded = 0;
-                        let size = 0;
-                        for (const entry of this.runtimeProgressAssets.values()) {
-                            loaded += Math.min(entry.loaded, entry.total);
-                            size += entry.total;
-                        }
-                        if (size <= 0)
-                            return;
-                        const nextValue = this.runtimeProgressStart +
-                            ((this.runtimeProgressEnd - this.runtimeProgressStart) * loaded) / size;
-                        if (nextValue <= this.runtimeProgressValue)
-                            return;
-                        this.runtimeProgressValue = nextValue;
-                        this.runtimeProgress.set?.(nextValue);
-                    }
+        const runtimeToken = Symbol('runtime');
+        const runtimePromiseToken = Symbol('runtime-startup');
+        this.runtimePromiseToken = runtimePromiseToken;
+        const assetLoader = this.assetLoader;
+        const runtimeProfile = this.runtimeProfile;
+        const rustRuntimeBaseUrl = this.rustRuntimeBaseUrl;
+        const maxAssetBytes = operation.limits?.maxAssetBytes ?? DEFAULT_EXECUTION_LIMITS.maxAssetBytes;
+        const assetTimeoutMs = operation.limits?.assetTimeoutMs ?? DEFAULT_EXECUTION_LIMITS.assetTimeoutMs;
+        let nextRuntime = null;
+        let nextExecutableGraph = null;
+        const runtimePromise = (async () => {
+            try {
+                if (!runtimeProfile) {
+                    throw new RuntimeConfigurationError('TinyGo runtime profile is not configured', {
+                        runtimeId: 'TINYGO'
+                    });
+                }
+                nextExecutableGraph = await loadVerifiedTinyGoExecutableGraph({
+                    moduleUrl,
+                    profile: WASM_TINYGO_EXECUTABLE_GRAPH_PROFILE,
+                    signal: operation.controller.signal,
+                    maxAssetBytes,
+                    assetTimeoutMs
                 });
-                return this.runtime;
-            }
-            if (typeof runtimeModule.createTinyGoRuntime === 'function') {
-                this.runtime = runtimeModule.createTinyGoRuntime({
-                    assetBaseUrl: new URL('./', moduleUrl).toString(),
-                    assetLoader: this.assetLoader,
-                    assetPacks: this.assetPacks,
-                    rustRuntimeBaseUrl: this.rustRuntimeBaseUrl || undefined,
-                    onProgress: (progress) => {
-                        if (!this.runtimeProgress)
+                this.assertOperation(operation);
+                const executableGraph = nextExecutableGraph;
+                const runtimeModule = (await import(
+                /* @vite-ignore */ executableGraph.entryUrl));
+                this.assertOperation(operation);
+                const commonOptions = {
+                    assetLoader,
+                    maxAssetBytes,
+                    rustRuntimeBaseUrl: rustRuntimeBaseUrl || undefined,
+                    onCompilerDiagnostic: (diagnostic) => {
+                        const owner = this.runtimeProgressOwner;
+                        const activeOperation = this.activeOperation;
+                        const runtime = this.runtime;
+                        if (!owner ||
+                            !activeOperation ||
+                            owner.operationToken !== activeOperation.token ||
+                            owner.runtimeToken !== runtimeToken ||
+                            this.runtimeToken !== runtimeToken ||
+                            !runtime ||
+                            !this.isOperationActive(activeOperation)) {
                             return;
-                        const total = progress.total && progress.total > 0 ? progress.total : progress.loaded;
-                        const key = progress.assetUrl || progress.assetPath;
-                        this.runtimeProgressAssets.set(key, {
-                            loaded: Math.max(0, progress.loaded),
-                            total: Math.max(1, total)
-                        });
-                        let loaded = 0;
-                        let size = 0;
-                        for (const entry of this.runtimeProgressAssets.values()) {
-                            loaded += Math.min(entry.loaded, entry.total);
-                            size += entry.total;
                         }
-                        if (size <= 0)
-                            return;
-                        const nextValue = this.runtimeProgressStart +
-                            ((this.runtimeProgressEnd - this.runtimeProgressStart) * loaded) / size;
-                        if (nextValue <= this.runtimeProgressValue)
+                        this.emitCompilerDiagnostic(activeOperation, diagnostic);
+                    },
+                    onLogAppended: (_entry) => {
+                        const owner = this.runtimeProgressOwner;
+                        const activeOperation = this.activeOperation;
+                        const runtime = this.runtime;
+                        if (!owner ||
+                            !activeOperation ||
+                            owner.operationToken !== activeOperation.token ||
+                            owner.runtimeToken !== runtimeToken ||
+                            this.runtimeToken !== runtimeToken ||
+                            !runtime ||
+                            !this.isOperationActive(activeOperation)) {
                             return;
-                        this.runtimeProgressValue = nextValue;
-                        this.runtimeProgress.set?.(nextValue);
-                    }
-                });
-                return this.runtime;
+                        }
+                        this.emitActivityLog(runtime, activeOperation);
+                    },
+                    onProgress: (progress) => this.reportRuntimeProgress(runtimeToken, progress)
+                };
+                if (typeof runtimeModule.loadTinyGoUpstreamToolchainAssets === 'function' &&
+                    typeof runtimeModule.compileTinyGoInDisposableWorker === 'function') {
+                    let activityLog = '';
+                    let artifact = null;
+                    let workspaceFiles = null;
+                    let target = 'wasip1';
+                    let assetLimit = maxAssetBytes;
+                    let wasmMemoryLimit = DEFAULT_EXECUTION_LIMITS.maxWasmMemoryBytes;
+                    let controller = null;
+                    let assetsPromise = null;
+                    const loadUpstreamAssets = runtimeModule.loadTinyGoUpstreamToolchainAssets;
+                    const compileUpstream = runtimeModule.compileTinyGoInDisposableWorker;
+                    const appendLog = (line) => {
+                        activityLog += `[${new Date().toTimeString().slice(0, 8)}] ${line}\n`;
+                        commonOptions.onLogAppended({ line });
+                    };
+                    nextRuntime = {
+                        async boot() {
+                            if (!assetsPromise) {
+                                controller = new AbortController();
+                                assetsPromise = loadUpstreamAssets({
+                                    assetBaseUrl: executableGraph.assetBaseUrl,
+                                    profile: runtimeProfile,
+                                    ...(assetLoader ? { loader: assetLoader } : {}),
+                                    onProgress: commonOptions.onProgress,
+                                    signal: controller.signal,
+                                    maxAssetBytes: assetLimit
+                                });
+                            }
+                            const pendingAssets = assetsPromise;
+                            try {
+                                await pendingAssets;
+                            }
+                            catch (error) {
+                                if (assetsPromise === pendingAssets)
+                                    assetsPromise = null;
+                                throw error;
+                            }
+                            appendLog('upstream TinyGo toolchain assets loaded');
+                        },
+                        async plan() {
+                            if (!assetsPromise)
+                                throw new Error('upstream TinyGo assets are not loaded');
+                            appendLog('upstream TinyGo receipt validation scheduled in compiler worker');
+                            return { target: 'wasip1', implementation: 'upstream-tinygo-0.40.1' };
+                        },
+                        async execute() {
+                            if (target !== 'wasip1') {
+                                throw new Error('The upstream TinyGo browser compiler supports only wasip1');
+                            }
+                            if (!workspaceFiles)
+                                throw new Error('TinyGo workspace is not configured');
+                            const assets = await assetsPromise;
+                            if (!assets)
+                                throw new Error('upstream TinyGo assets are not loaded');
+                            controller = new AbortController();
+                            const compileFiles = { ...workspaceFiles };
+                            if (!Object.prototype.hasOwnProperty.call(compileFiles, 'go.mod')) {
+                                compileFiles['go.mod'] =
+                                    'module wasm-idle.local/main\n\ngo 1.24.0\n';
+                            }
+                            const result = await compileUpstream(assets, { workspaceFiles: compileFiles, package: '.' }, {
+                                signal: controller.signal,
+                                maxWasmMemoryBytes: wasmMemoryLimit,
+                                onPhase: (phase) => appendLog(`upstream TinyGo phase: ${phase}`)
+                            });
+                            artifact = {
+                                path: '/work/program.wasm',
+                                bytes: Uint8Array.from(result.wasm),
+                                artifactKind: 'execution',
+                                runnable: true,
+                                entrypoint: '_start'
+                            };
+                            appendLog(`upstream TinyGo artifact ready: ${artifact.path}`);
+                        },
+                        reset() {
+                            controller?.abort(new Error('TinyGo runtime reset'));
+                            controller = null;
+                            artifact = null;
+                            activityLog = '';
+                        },
+                        readActivityLog: () => activityLog,
+                        readBuildArtifact: () => artifact,
+                        setBuildRequestOverrides(overrides) {
+                            target = overrides?.target ?? 'wasip1';
+                        },
+                        setMaxAssetBytes(value) {
+                            if (assetLimit !== value) {
+                                controller?.abort(new Error('TinyGo asset quota changed'));
+                                controller = null;
+                                assetsPromise = null;
+                            }
+                            assetLimit = value;
+                        },
+                        setMaxWasmMemoryBytes(value) {
+                            wasmMemoryLimit = value;
+                        },
+                        setWorkspaceFiles(files) {
+                            workspaceFiles = files ? { ...files } : null;
+                        },
+                        dispose() {
+                            controller?.abort(new Error('TinyGo runtime disposed'));
+                            controller = null;
+                            workspaceFiles = null;
+                            artifact = null;
+                        }
+                    };
+                }
+                else if (typeof runtimeModule.createBundledTinyGoRuntime === 'function') {
+                    nextRuntime = runtimeModule.createBundledTinyGoRuntime(commonOptions);
+                }
+                else if (typeof runtimeModule.createTinyGoRuntime === 'function') {
+                    nextRuntime = runtimeModule.createTinyGoRuntime({
+                        assetBaseUrl: executableGraph.assetBaseUrl,
+                        ...commonOptions
+                    });
+                }
+                else {
+                    throw new Error('TinyGo runtime module must export createBundledTinyGoRuntime or createTinyGoRuntime');
+                }
+                this.assertOperation(operation);
+                this.requireRuntimeAssetLimitSetter(nextRuntime);
+                this.assertOperation(operation);
+                if (this.runtimePromiseToken !== runtimePromiseToken) {
+                    throw operation.reason ?? 'TinyGo runtime startup superseded';
+                }
+                const runtime = nextRuntime;
+                const committedExecutableGraph = nextExecutableGraph;
+                nextRuntime = null;
+                nextExecutableGraph = null;
+                this.runtime = runtime;
+                this.executableGraph = committedExecutableGraph;
+                this.runtimeToken = runtimeToken;
+                return runtime;
             }
-            throw new Error('TinyGo runtime module must export createBundledTinyGoRuntime or createTinyGoRuntime');
-        })().catch((error) => {
-            this.disposeRuntime();
-            throw error;
-        });
-        return await this.runtimePromise;
+            finally {
+                try {
+                    nextRuntime?.dispose?.();
+                }
+                catch {
+                    // A stale runtime must not replace the active lifecycle result.
+                }
+                try {
+                    nextExecutableGraph?.dispose();
+                }
+                catch {
+                    // A stale executable graph must not replace the active lifecycle result.
+                }
+            }
+        })();
+        this.runtimePromise = runtimePromise;
+        try {
+            return await runtimePromise;
+        }
+        finally {
+            if (this.runtimePromise === runtimePromise) {
+                this.runtimePromise = null;
+                this.runtimePromiseToken = null;
+            }
+        }
     }
-    emitActivityLog(hooks) {
+    emitActivityLog(hooks, operation) {
+        this.assertOperation(operation);
         const nextActivityLog = hooks.readActivityLog();
         const delta = nextActivityLog.startsWith(this.lastActivityLog)
             ? nextActivityLog.slice(this.lastActivityLog.length)
@@ -229,8 +910,10 @@ class TinyGo {
         if (!delta)
             return;
         const sanitized = delta.replace(ACTIVITY_PREFIX_PATTERN, '');
-        if (sanitized)
-            this.output?.(sanitized);
+        if (sanitized && !this.emitOutput(operation, sanitized)) {
+            this.assertOperation(operation);
+        }
+        this.assertOperation(operation);
     }
     extractCompileFailure() {
         const sanitized = this.lastActivityLog.replace(ACTIVITY_PREFIX_PATTERN, '');
@@ -245,143 +928,96 @@ class TinyGo {
         }
         return 'TinyGo compilation failed';
     }
-    async compileArtifact(code, target = 'wasm', log = true, prog) {
-        const hostCompileTarget = target === 'wasm' ? 'wasip1' : target;
+    async compileArtifact(operation, workspaceFiles, target = 'wasm', log = true, prog) {
+        this.assertOperation(operation);
+        const maxWasmMemoryBytes = operation.hasExplicitWasmMemoryLimit
+            ? (operation.limits?.maxWasmMemoryBytes ?? DEFAULT_EXECUTION_LIMITS.maxWasmMemoryBytes)
+            : TINYGO_BROWSER_COMPILER_DEFAULT_MAX_WASM_MEMORY_BYTES;
         const compileCacheKey = JSON.stringify({
-            code,
-            hostCompileUrls: this.hostCompileUrls,
             moduleUrl: this.moduleUrl,
-            target
+            executableGraphFingerprint: this.executableGraphFingerprint,
+            maxAssetBytes: operation.limits?.maxAssetBytes ?? DEFAULT_EXECUTION_LIMITS.maxAssetBytes,
+            maxWasmMemoryBytes,
+            target,
+            workspaceFiles
         });
         if (this.compiledArtifact && this.compiledCacheKey === compileCacheKey) {
             return;
         }
-        const unavailableHostCompileUrls = [];
-        if (this.hostCompileUrls.length > 0) {
-            prog?.set?.(0.05);
-            for (const hostCompileUrl of this.hostCompileUrls) {
-                let hostCompileResponse = null;
-                try {
-                    hostCompileResponse = await fetch(hostCompileUrl, {
-                        method: 'POST',
-                        headers: {
-                            'content-type': 'application/json'
-                        },
-                        body: JSON.stringify({
-                            source: code,
-                            target: hostCompileTarget
-                        })
-                    });
-                }
-                catch (error) {
-                    unavailableHostCompileUrls.push(hostCompileUrl);
-                    if (!this.moduleUrl && hostCompileUrl === this.hostCompileUrls.at(-1)) {
-                        throw error;
-                    }
-                    continue;
-                }
-                if (hostCompileResponse?.ok) {
-                    const payload = (await hostCompileResponse.json());
-                    const artifactBase64 = payload.artifact?.bytesBase64 || '';
-                    if (!payload.artifact?.path || !artifactBase64) {
-                        throw new Error('TinyGo host compile did not return a wasm artifact');
-                    }
-                    const artifactBytes = Uint8Array.from(atob(artifactBase64), (char) => char.charCodeAt(0));
-                    this.compiledArtifact = artifactBytes;
-                    this.compiledArtifactExecutionError =
-                        payload.artifact.runnable === false
-                            ? payload.artifact.artifactKind === 'probe'
-                                ? 'TinyGo host compile returned a non-runnable probe artifact without a supported WASI entrypoint.'
-                                : payload.artifact.reason === 'bootstrap-artifact'
-                                    ? 'TinyGo host compile returned a bootstrap artifact and cannot execute it yet.'
-                                    : 'TinyGo host compile returned a non-runnable artifact without a supported WASI entrypoint.'
-                            : '';
-                    this.compiledCacheKey = compileCacheKey;
-                    prog?.set?.(0.95);
-                    if (log) {
-                        for (const line of payload.logs || []) {
-                            this.output?.(line.endsWith('\n') ? line : `${line}\n`);
-                        }
-                        this.output?.(`tinygo artifact ready: ${payload.artifact.path}\n`);
-                    }
-                    return;
-                }
-                if (hostCompileResponse &&
-                    hostCompileResponse.status !== 404 &&
-                    hostCompileResponse.status !== 405 &&
-                    hostCompileResponse.status !== 501) {
-                    let failureMessage = 'TinyGo host compile failed';
-                    try {
-                        const payload = await hostCompileResponse.json();
-                        if (typeof payload?.error === 'string' && payload.error) {
-                            failureMessage = payload.error;
-                        }
-                    }
-                    catch {
-                        const responseText = await hostCompileResponse.text();
-                        if (responseText.trim()) {
-                            failureMessage = responseText.trim();
-                        }
-                    }
-                    throw new Error(failureMessage);
-                }
-                if (hostCompileResponse) {
-                    unavailableHostCompileUrls.push(hostCompileUrl);
-                }
-            }
+        const runtime = await this.ensureRuntime(operation);
+        this.assertOperation(operation);
+        const runtimeToken = this.runtimeToken;
+        if (!runtimeToken || this.runtime !== runtime) {
+            throw operation.reason ?? 'TinyGo compiler runtime is not available';
         }
-        if (!this.moduleUrl) {
-            if (unavailableHostCompileUrls.length > 0) {
-                throw new Error(`TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}.`);
-            }
-            throw new Error('TinyGo host compile endpoint is unavailable.');
-        }
-        const runtime = await this.ensureRuntime();
+        this.requireRuntimeAssetLimitSetter(runtime)(operation.limits?.maxAssetBytes ?? DEFAULT_EXECUTION_LIMITS.maxAssetBytes);
+        runtime.setMaxWasmMemoryBytes?.(maxWasmMemoryBytes);
+        this.assertOperation(operation);
         runtime.reset();
+        this.assertOperation(operation);
         this.lastActivityLog = runtime.readActivityLog();
-        runtime.setWorkspaceFiles({ 'main.go': code });
+        this.assertOperation(operation);
+        runtime.setWorkspaceFiles(workspaceFiles);
+        this.assertOperation(operation);
         runtime.setBuildRequestOverrides?.({ target });
+        this.assertOperation(operation);
         this.runtimeProgress = prog;
+        this.runtimeProgressOwner = {
+            operationToken: operation.token,
+            runtimeToken
+        };
         this.runtimeProgressAssets.clear();
         this.runtimeProgressStart = 0.05;
         this.runtimeProgressEnd = 0.35;
         this.runtimeProgressValue = 0.05;
         try {
             prog?.set?.(0.05);
+            this.assertOperation(operation);
             await runtime.boot();
-            this.emitActivityLog(runtime);
+            this.assertOperation(operation);
+            this.emitActivityLog(runtime, operation);
             this.runtimeProgressAssets.clear();
             this.runtimeProgressStart = 0.35;
             this.runtimeProgressEnd = 0.65;
             this.runtimeProgressValue = Math.max(this.runtimeProgressValue, 0.35);
             prog?.set?.(this.runtimeProgressValue);
+            this.assertOperation(operation);
             await runtime.plan();
-            this.emitActivityLog(runtime);
+            this.assertOperation(operation);
+            this.emitActivityLog(runtime, operation);
             this.runtimeProgressAssets.clear();
             this.runtimeProgressStart = 0.65;
             this.runtimeProgressEnd = 0.92;
             this.runtimeProgressValue = Math.max(this.runtimeProgressValue, 0.65);
             prog?.set?.(this.runtimeProgressValue);
+            this.assertOperation(operation);
             await runtime.execute();
-            this.emitActivityLog(runtime);
+            this.assertOperation(operation);
+            this.emitActivityLog(runtime, operation);
             prog?.set?.(0.95);
+            this.assertOperation(operation);
         }
         finally {
-            this.runtimeProgress = undefined;
-            this.runtimeProgressAssets.clear();
+            if (this.runtimeProgressOwner?.operationToken === operation.token &&
+                this.runtimeProgressOwner.runtimeToken === runtimeToken) {
+                this.runtimeProgress = undefined;
+                this.runtimeProgressOwner = null;
+                this.runtimeProgressAssets.clear();
+            }
         }
+        this.assertOperation(operation);
         const artifact = runtime.readBuildArtifact();
+        this.assertOperation(operation);
         if (!artifact) {
             const compileFailure = this.extractCompileFailure();
-            if (/(?:probe-only|supported WASI entrypoint|no host compile seam is configured)/i.test(compileFailure)) {
-                throw new Error(unavailableHostCompileUrls.length > 0
-                    ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime could not produce a runnable execution artifact: ${compileFailure}.`
-                    : `TinyGo browser runtime could not produce a runnable execution artifact: ${compileFailure}.`);
+            if (/(?:probe-only|supported WASI entrypoint)/i.test(compileFailure)) {
+                throw new Error(`TinyGo browser runtime could not produce a runnable execution artifact: ${compileFailure}.`);
             }
             throw new Error(compileFailure);
         }
-        const runtimeLogLines = runtime
-            .readActivityLog()
+        const runtimeActivityLog = runtime.readActivityLog();
+        this.assertOperation(operation);
+        const runtimeLogLines = runtimeActivityLog
             .replace(ACTIVITY_PREFIX_PATTERN, '')
             .split('\n')
             .map((line) => line.trim())
@@ -394,122 +1030,359 @@ class TinyGo {
                 break;
             }
         }
-        this.compiledArtifact = new Uint8Array(artifact.bytes);
-        this.compiledArtifactExecutionError =
-            artifact.runnable === false
-                ? browserRuntimeFailure !== ''
-                    ? unavailableHostCompileUrls.length > 0
-                        ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime could not produce a runnable execution artifact: ${browserRuntimeFailure}.`
-                        : `TinyGo browser runtime could not produce a runnable execution artifact: ${browserRuntimeFailure}.`
-                    : artifact.reason === 'bootstrap-artifact'
-                        ? unavailableHostCompileUrls.length > 0
-                            ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a bootstrap artifact and cannot execute it yet.`
-                            : 'TinyGo browser runtime produced a bootstrap artifact and cannot execute it yet.'
-                        : artifact.artifactKind === 'probe'
-                            ? unavailableHostCompileUrls.length > 0
-                                ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a non-runnable probe artifact without a supported WASI entrypoint.`
-                                : 'TinyGo browser runtime produced a non-runnable probe artifact without a supported WASI entrypoint.'
-                            : unavailableHostCompileUrls.length > 0
-                                ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a non-runnable artifact without a supported WASI entrypoint.`
-                                : 'TinyGo browser runtime produced a non-runnable artifact without a supported WASI entrypoint.'
-                : '';
+        const compiledArtifact = new Uint8Array(artifact.bytes);
+        const compiledArtifactExecutionError = artifact.runnable === false
+            ? browserRuntimeFailure !== ''
+                ? `TinyGo browser runtime could not produce a runnable execution artifact: ${browserRuntimeFailure}.`
+                : artifact.reason === 'bootstrap-artifact'
+                    ? 'TinyGo browser runtime produced a bootstrap artifact and cannot execute it yet.'
+                    : artifact.artifactKind === 'probe'
+                        ? 'TinyGo browser runtime produced a non-runnable probe artifact without a supported WASI entrypoint.'
+                        : 'TinyGo browser runtime produced a non-runnable artifact without a supported WASI entrypoint.'
+            : '';
+        this.assertOperation(operation);
+        this.compiledArtifact = compiledArtifact;
+        this.compiledArtifactExecutionError = compiledArtifactExecutionError;
         this.compiledCacheKey = compileCacheKey;
         if (log) {
-            this.output?.(`tinygo artifact ready: ${artifact.path}\n`);
+            this.emitOutput(operation, `tinygo artifact ready: ${artifact.path}\n`);
+            this.assertOperation(operation);
         }
     }
     run(code, prepare, _log = true, _prog, args = [], options = {}) {
-        this.exit = false;
-        return new Promise(async (resolve, reject) => {
+        return this.executeOperation('execute', options, async (operation, request) => {
+            this.exit = false;
             try {
                 this.begin = Date.now();
-                await this.ensureWorker();
-                const target = options.tinygoTarget || 'wasm';
-                await this.compileArtifact(code, target, _log, prepare ? _prog : undefined);
+                await this.compileArtifact(operation, request.workspaceFiles, request.target, _log, prepare ? _prog : undefined);
+                this.assertOperation(operation);
                 if (prepare) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
-                    resolve(true);
-                    return;
+                    return true;
                 }
                 if (this.compiledArtifactExecutionError) {
                     throw new Error(this.compiledArtifactExecutionError);
                 }
+                await this.ensureWorker(operation);
+                this.assertOperation(operation);
                 if (!this.worker || !this.compiledArtifact) {
                     throw new Error('TinyGo runtime did not prepare an artifact');
                 }
-                const { programArgs } = resolveSandboxExecutionArgs('TINYGO', args, options);
-                const _uid = ++this.uid;
-                this.activeReject = reject;
-                this.worker.onmessage = (event) => {
-                    if (!this.worker)
-                        return reject('Worker not loaded');
-                    if (_uid !== this.uid)
-                        return (this.worker.onmessage = null);
-                    const { output, results, error, buffer } = event.data;
-                    if (buffer) {
-                        this.waitingForInput = true;
-                        this.flushPendingInput();
-                    }
-                    if (output)
-                        this.output?.(output);
-                    if (results) {
-                        this.elapse = Date.now() - this.begin;
-                        this.exit = true;
-                        this.waitingForInput = false;
-                        this.pendingEof = false;
-                        this.activeReject = null;
-                        resolve(results);
+                const worker = this.worker;
+                const compiledArtifact = this.compiledArtifact;
+                const buffer = request.buffer;
+                const hasExplicitStdin = request.stdin !== undefined;
+                if (hasExplicitStdin) {
+                    this.clearPendingStdin();
+                }
+                const runUid = ++this.uid;
+                return await new Promise((resolve, reject) => {
+                    const workerOperation = this.workerSession.beginRun(worker, reject);
+                    const handleMessage = (event) => {
+                        if (!this.isOperationActive(operation) ||
+                            this.worker !== worker ||
+                            runUid !== this.uid) {
+                            if (worker.onmessage === handleMessage)
+                                worker.onmessage = null;
+                            return;
+                        }
+                        const message = event.data ?? {};
+                        const hasResults = Object.prototype.hasOwnProperty.call(message, 'results');
+                        const hasError = Object.prototype.hasOwnProperty.call(message, 'error');
+                        const { output, results, error, buffer, progress } = message;
+                        if (buffer && !hasExplicitStdin) {
+                            if (!prepare) {
+                                _prog?.report?.({
+                                    kind: 'ready',
+                                    state: 'waiting-input',
+                                    reason: 'stdin-request',
+                                    label: 'TinyGo program is waiting for input'
+                                });
+                            }
+                            this.waitingForInput = true;
+                            this.flushPendingInput();
+                        }
+                        reportWorkerProgress(_prog, progress);
+                        if (!this.isOperationActive(operation) || this.worker !== worker)
+                            return;
+                        if (output) {
+                            if (!this.emitOutput(operation, output))
+                                return;
+                        }
+                        if (hasResults) {
+                            if (worker.onmessage === handleMessage)
+                                worker.onmessage = null;
+                            this.elapse = Date.now() - this.begin;
+                            this.exit = true;
+                            this.clearPendingStdin();
+                            this.workerSession.complete(workerOperation);
+                            resolve(results);
+                            return;
+                        }
+                        if (hasError) {
+                            if (worker.onmessage === handleMessage)
+                                worker.onmessage = null;
+                            this.elapse = Date.now() - this.begin;
+                            this.exit = true;
+                            this.clearPendingStdin();
+                            this.workerSession.complete(workerOperation);
+                            reject(error);
+                        }
+                    };
+                    worker.onmessage = handleMessage;
+                    try {
+                        worker.postMessage({
+                            artifact: new Uint8Array(compiledArtifact),
+                            buffer,
+                            args: request.programArgs,
+                            log: _log,
+                            stdin: request.stdin
+                        });
                     }
-                    if (error) {
-                        this.elapse = Date.now() - this.begin;
-                        this.exit = true;
-                        this.waitingForInput = false;
-                        this.pendingEof = false;
-                        this.activeReject = null;
-                        reject(error);
+                    catch (error) {
+                        this.workerSession.terminate(error);
                     }
-                };
-                this.worker.postMessage({
-                    artifact: new Uint8Array(this.compiledArtifact),
-                    buffer: this.buffer,
-                    args: programArgs,
-                    log: _log
                 });
             }
             catch (error) {
-                this.elapse = Date.now() - this.begin;
-                this.exit = true;
-                this.waitingForInput = false;
-                this.pendingEof = false;
-                this.activeReject = null;
-                reject(error instanceof Error ? error.message : String(error));
+                if (this.isOperationActive(operation)) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.clearPendingStdin();
+                    throw error instanceof Error ? error.message : String(error);
+                }
+                throw error;
+            }
+        }, (operation) => {
+            this.assertOperation(operation);
+            if (typeof code !== 'string') {
+                throw new TypeError('TinyGo source code must be a string');
+            }
+            const configuredTarget = options.tinygoTarget;
+            this.assertOperation(operation);
+            const target = configuredTarget ?? 'wasip1';
+            if (!TINYGO_TARGETS.has(target)) {
+                throw new TypeError('TinyGo target must be wasm, wasip1, wasip2, or wasip3');
+            }
+            const workspaceLimitsSource = options.workspaceLimits;
+            this.assertOperation(operation);
+            let workspaceLimits = {};
+            if (workspaceLimitsSource !== undefined) {
+                if (workspaceLimitsSource === null ||
+                    typeof workspaceLimitsSource !== 'object' ||
+                    Array.isArray(workspaceLimitsSource)) {
+                    throw new TypeError('TinyGo workspace limits must be an object');
+                }
+                const maxFiles = workspaceLimitsSource.maxFiles;
+                this.assertOperation(operation);
+                const maxFileBytes = workspaceLimitsSource.maxFileBytes;
+                this.assertOperation(operation);
+                const maxTotalBytes = workspaceLimitsSource.maxTotalBytes;
+                this.assertOperation(operation);
+                const maxPathBytes = workspaceLimitsSource.maxPathBytes;
+                this.assertOperation(operation);
+                const caseSensitive = workspaceLimitsSource.caseSensitive;
+                this.assertOperation(operation);
+                workspaceLimits = {
+                    maxFiles,
+                    maxFileBytes,
+                    maxTotalBytes,
+                    maxPathBytes,
+                    caseSensitive
+                };
+            }
+            for (const name of [
+                'maxFiles',
+                'maxFileBytes',
+                'maxTotalBytes',
+                'maxPathBytes'
+            ]) {
+                const value = workspaceLimits[name];
+                if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+                    throw new WorkspaceValidationError('invalid-limit', `Workspace limit ${name} must be a non-negative safe integer`);
+                }
+            }
+            if (workspaceLimits.caseSensitive !== undefined &&
+                typeof workspaceLimits.caseSensitive !== 'boolean') {
+                throw new WorkspaceValidationError('invalid-limit', 'Workspace limit caseSensitive must be a boolean');
+            }
+            const workspaceFilesSource = options.workspaceFiles;
+            this.assertOperation(operation);
+            const sourceFiles = workspaceFilesSource ?? [];
+            if (!Array.isArray(sourceFiles)) {
+                throw new TypeError('TinyGo workspace files must be an array');
+            }
+            const workspaceFileCount = sourceFiles.length;
+            this.assertOperation(operation);
+            const maxFiles = workspaceLimits.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 = sourceFiles[index];
+                this.assertOperation(operation);
+                if (file === null || typeof file !== 'object') {
+                    throw new TypeError('TinyGo workspace file must be an object');
+                }
+                const path = file.path;
+                this.assertOperation(operation);
+                const content = file.content;
+                this.assertOperation(operation);
+                if (typeof path !== 'string') {
+                    throw new TypeError('TinyGo workspace file path must be a string');
+                }
+                if (typeof content !== 'string') {
+                    throw new TypeError(`TinyGo workspace file ${path} must contain a string`);
+                }
+                workspaceFiles.push({ path, content });
+            }
+            const configuredActivePath = options.activePath;
+            this.assertOperation(operation);
+            const activePath = configuredActivePath ?? 'main.go';
+            const maxWorkspaceBytes = operation.limits?.maxWorkspaceBytes ??
+                DEFAULT_EXECUTION_LIMITS.maxWorkspaceBytes;
+            const workspace = validateExecutionWorkspace(code, workspaceFiles, activePath, {
+                ...workspaceLimits,
+                maxFileBytes: Math.min(workspaceLimits.maxFileBytes ?? DEFAULT_WORKSPACE_LIMITS.maxFileBytes, maxWorkspaceBytes),
+                maxTotalBytes: Math.min(workspaceLimits.maxTotalBytes ?? DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, maxWorkspaceBytes)
+            });
+            this.assertOperation(operation);
+            if (workspace.activePath !== 'main.go') {
+                throw new RuntimeConfigurationError('TinyGo runtime currently requires activePath to be main.go', { phase: 'execute', runtimeId: 'TINYGO' });
             }
+            const runtimeWorkspace = Object.fromEntries([
+                ['main.go', code],
+                ...workspace.workspaceFiles.map((file) => [file.path, file.content])
+            ]);
+            const configuredProgramArgs = options.programArgs;
+            this.assertOperation(operation);
+            const sourceArgs = configuredProgramArgs ?? args;
+            if (!Array.isArray(sourceArgs)) {
+                throw new TypeError('TinyGo program arguments must be an array');
+            }
+            const argCount = sourceArgs.length;
+            this.assertOperation(operation);
+            const programArgs = [];
+            for (let index = 0; index < argCount; index += 1) {
+                const argument = sourceArgs[index];
+                this.assertOperation(operation);
+                if (typeof argument !== 'string') {
+                    throw new TypeError(`TinyGo program argument ${index} must be a string`);
+                }
+                programArgs.push(argument);
+            }
+            const stdin = options.stdin;
+            this.assertOperation(operation);
+            if (stdin !== undefined && typeof stdin !== 'string') {
+                throw new TypeError('TinyGo stdin must be a string');
+            }
+            const buffer = this.buffer;
+            this.assertOperation(operation);
+            operation.buffer = buffer;
+            return { buffer, programArgs, stdin, target, workspaceFiles: runtimeWorkspace };
         });
     }
+    resetOwnedBuffers(operationBuffer) {
+        const buffers = new Set([this.buffer]);
+        if (operationBuffer)
+            buffers.add(operationBuffer);
+        for (const buffer of buffers) {
+            try {
+                resetBufferedStdin(buffer);
+            }
+            catch {
+                // Stdin cleanup must not replace the lifecycle result.
+            }
+        }
+    }
+    cancelOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.reason = reason;
+        try {
+            operation.controller.abort(reason);
+        }
+        catch {
+            // Cancellation must continue even if AbortController cleanup fails.
+        }
+        const reject = operation.reject;
+        this.completeOperation(operation);
+        this.uid += 1;
+        this.clearPendingStdin();
+        this.exit = true;
+        this.loadPromise = null;
+        this.runtimeProgress = undefined;
+        this.runtimeProgressOwner = null;
+        this.runtimeProgressAssets.clear();
+        this.compiledArtifact = null;
+        this.compiledArtifactExecutionError = '';
+        this.compiledCacheKey = '';
+        this.resetOwnedBuffers(operation.buffer);
+        this.workerSession.terminate(reason);
+        this.disposeRuntime();
+        reject?.(reason);
+    }
     kill() {
         this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
-        this.waitingForInput = false;
-        this.pendingEof = false;
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const operation = this.activeOperation;
+        if (operation) {
+            this.cancelOperation(operation, reason);
+            return;
+        }
+        this.clearPendingStdin();
         this.uid += 1;
-        this.worker?.terminate?.();
-        delete this.worker;
+        this.resetOwnedBuffers();
+        this.workerSession.terminate(reason);
         this.exit = true;
     }
     async clear() {
-        this.pendingInput = [];
-        this.waitingForInput = false;
-        this.pendingEof = false;
-        if (this.worker)
-            this.worker.onmessage = null;
-        resetBufferedStdin(this.buffer);
-        if (!this.exit) {
-            this.terminate();
+        if (this.disposed)
+            return;
+        this.terminate();
+        this.loadPromise = null;
+        this.disposeRuntime();
+        this.compiledArtifact = null;
+        this.compiledArtifactExecutionError = '';
+        this.compiledCacheKey = '';
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const operation = this.activeOperation;
+        const runtime = this.detachRuntime();
+        delete this.worker;
+        this.moduleUrl = '';
+        this.executableGraphFingerprint = '';
+        this.rustRuntimeBaseUrl = '';
+        this.assetLoader = undefined;
+        this.runtimeProfile = undefined;
+        this.output = undefined;
+        this.oncompilerdiagnostic = undefined;
+        this.loadPromise = null;
+        this.compiledArtifact = null;
+        this.compiledArtifactExecutionError = '';
+        this.compiledCacheKey = '';
+        this.clearPendingStdin();
+        this.resetOwnedBuffers(operation?.buffer);
+        if (operation) {
+            this.cancelOperation(operation, this.disposeCancellation);
+        }
+        else {
+            this.uid += 1;
+            this.workerSession.terminate(this.disposeCancellation);
+            this.exit = true;
         }
+        this.disposeRuntimeHooks(runtime);
+        return this.disposePromise;
     }
 }
 export default TinyGo;