wasm-idle 0.7.2 → 1.0.0

package/dist/playground/bash.js

@@ -0,0 +1,1096 @@
+import { resolveBashRuntimeAssetConfig } from './assets';
+import { BASH_WORKER_PROTOCOL_VERSION, isBashWorkerToHostMessage } from './bashWorkerProtocol';
+import { reportWorkerProgress } from './workerProgress';
+import { AssetTooLargeError, AssetIntegrityError, AssetNotFoundError, BusyError, CancelledError, CompileError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, ProtocolError, ResourceLimitError, RuntimeConfigurationError, RuntimeExecutionError, TimeoutError, UnsupportedBrowserFeatureError, UnsupportedLanguageError, WasmIdleError, WorkerStartupError, preflightBashRuntimeAssets, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const textEncoder = new TextEncoder();
+const abortReason = (signal, phase) => signal.reason !== undefined
+    ? signal.reason
+    : new DOMException(phase === 'startup' ? 'Bash runtime startup aborted' : 'Bash execution aborted', 'AbortError');
+const createBashConfigIdentity = (preflightKey, limits) => JSON.stringify([
+    preflightKey,
+    {
+        maxAssetBytes: limits.maxAssetBytes,
+        maxWasmMemoryBytes: limits.maxWasmMemoryBytes,
+        maxWorkers: limits.maxWorkers,
+        maxThreads: limits.maxThreads
+    }
+]);
+class Bash {
+    output;
+    oncompilerdiagnostic;
+    webcUrl = '';
+    pendingInput = [];
+    pendingEof = false;
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    activeOperation = null;
+    readyWorker = null;
+    loadedConfig = null;
+    requestUid = 0;
+    sessionUid = 0;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('Bash sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'BASH',
+        recoverable: false
+    });
+    load(runtimeAssets = '', _code = '', log = true, _args = [], options = {}, progress) {
+        if (this.disposed) {
+            return Promise.reject(new RuntimeConfigurationError('Bash sandbox is disposed', {
+                phase: 'dispose',
+                runtimeId: 'BASH'
+            }));
+        }
+        if (this.activeOperation) {
+            return Promise.reject(new BusyError('Bash runtime already has an active operation', {
+                phase: this.activeOperation.stage,
+                runtimeId: 'BASH'
+            }));
+        }
+        let resolvePromise;
+        let rejectPromise;
+        const promise = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const operation = {
+            config: null,
+            decoders: { stderr: new TextDecoder(), stdout: new TextDecoder() },
+            handle: null,
+            kind: 'load',
+            outputBytes: 0,
+            progress,
+            executionReady: false,
+            reject: rejectPromise,
+            requestId: 0,
+            resolve: () => resolvePromise(),
+            settled: false,
+            started: false,
+            stage: 'startup',
+            stdinReady: false,
+            token: Symbol('bash-load')
+        };
+        this.activeOperation = operation;
+        try {
+            const signal = options.signal;
+            this.requireActive(operation);
+            if (signal?.aborted)
+                throw abortReason(signal, 'startup');
+            const limits = resolveExecutionLimits(options.limits);
+            this.requireActive(operation);
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const resolved = resolveBashRuntimeAssetConfig(runtimeAssets, currentUrl);
+            this.requireActive(operation);
+            const config = {
+                ...resolved,
+                identity: createBashConfigIdentity(resolved.preflightKey, limits),
+                limits
+            };
+            operation.config = config;
+            operation.signal = signal;
+            this.bindAbort(operation);
+            this.requireActive(operation);
+            if (this.readyWorker?.ready && this.readyWorker.identity === config.identity) {
+                progress?.set?.(1, 'Bash runtime ready');
+                this.requireActive(operation);
+                this.loadedConfig = config;
+                this.webcUrl = config.webcUrl;
+                this.finishOperation(operation);
+                return promise;
+            }
+            this.bindTimeout(operation, Math.min(MAX_TIMER_DELAY_MS, limits.assetTimeoutMs + limits.startupTimeoutMs));
+            this.requireActive(operation);
+            void this.createWorker(operation)
+                .then((handle) => {
+                if (!this.isActive(operation)) {
+                    this.retireWorker(handle);
+                    return;
+                }
+                this.dispatchLoad(operation, handle, log);
+            })
+                .catch(() => undefined);
+        }
+        catch (error) {
+            this.failOperation(operation, error, false);
+        }
+        return promise;
+    }
+    run(code, prepare, log = true, progress, args = [], options = {}) {
+        if (this.disposed) {
+            return Promise.reject(new RuntimeConfigurationError('Bash sandbox is disposed', {
+                phase: 'dispose',
+                runtimeId: 'BASH'
+            }));
+        }
+        if (this.activeOperation) {
+            return Promise.reject(new BusyError('Bash runtime already has an active operation', {
+                phase: this.activeOperation.stage,
+                runtimeId: 'BASH'
+            }));
+        }
+        if (prepare)
+            return Promise.resolve(true);
+        if (!this.loadedConfig)
+            return Promise.reject(new Error('Bash runtime is not loaded'));
+        let resolvePromise;
+        let rejectPromise;
+        const promise = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const operation = {
+            config: this.loadedConfig,
+            decoders: { stderr: new TextDecoder(), stdout: new TextDecoder() },
+            handle: null,
+            kind: 'run',
+            outputBytes: 0,
+            progress,
+            executionReady: false,
+            reject: rejectPromise,
+            requestId: 0,
+            resolve: (value) => resolvePromise(value),
+            settled: false,
+            started: false,
+            stage: this.readyWorker ? 'execute' : 'startup',
+            stdinReady: false,
+            token: Symbol('bash-run')
+        };
+        this.activeOperation = operation;
+        try {
+            const signal = options.signal;
+            this.requireActive(operation);
+            if (signal?.aborted)
+                throw abortReason(signal, operation.stage);
+            const limits = resolveExecutionLimits(options.limits);
+            this.requireActive(operation);
+            if (!this.readyWorker) {
+                const loadedConfig = this.requireConfig(operation);
+                const startupLimits = {
+                    ...limits,
+                    assetTimeoutMs: Math.min(loadedConfig.limits.assetTimeoutMs, limits.assetTimeoutMs),
+                    maxAssetBytes: Math.min(loadedConfig.limits.maxAssetBytes, limits.maxAssetBytes),
+                    maxThreads: Math.min(loadedConfig.limits.maxThreads, limits.maxThreads),
+                    maxWasmMemoryBytes: Math.min(loadedConfig.limits.maxWasmMemoryBytes, limits.maxWasmMemoryBytes),
+                    maxWorkers: Math.min(loadedConfig.limits.maxWorkers, limits.maxWorkers),
+                    startupTimeoutMs: Math.min(loadedConfig.limits.startupTimeoutMs, limits.startupTimeoutMs)
+                };
+                operation.config = {
+                    ...loadedConfig,
+                    identity: createBashConfigIdentity(loadedConfig.preflightKey, startupLimits),
+                    limits: startupLimits
+                };
+            }
+            const programArgsSource = options.programArgs ?? args;
+            if (!Array.isArray(programArgsSource)) {
+                throw new TypeError('Bash program arguments must be an array');
+            }
+            const programArgs = [...programArgsSource];
+            const workspaceFilesSource = options.workspaceFiles ?? [];
+            if (!Array.isArray(workspaceFilesSource)) {
+                throw new TypeError('Bash workspace files must be an array');
+            }
+            const workspaceFiles = workspaceFilesSource.map((file) => ({
+                path: file.path,
+                content: file.content
+            }));
+            const activePath = options.activePath ?? 'main.sh';
+            const workspaceLimitSource = options.workspaceLimits ?? {};
+            const workspaceLimits = {
+                maxFiles: workspaceLimitSource.maxFiles ?? DEFAULT_WORKSPACE_LIMITS.maxFiles,
+                maxFileBytes: Math.min(workspaceLimitSource.maxFileBytes ?? DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                maxTotalBytes: Math.min(workspaceLimitSource.maxTotalBytes ?? DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes),
+                maxPathBytes: workspaceLimitSource.maxPathBytes ?? DEFAULT_WORKSPACE_LIMITS.maxPathBytes,
+                caseSensitive: workspaceLimitSource.caseSensitive ?? DEFAULT_WORKSPACE_LIMITS.caseSensitive
+            };
+            const workspace = validateExecutionWorkspace(code, workspaceFiles, activePath, workspaceLimits);
+            this.requireActive(operation);
+            const stdin = options.stdin;
+            this.requireActive(operation);
+            operation.signal = signal;
+            operation.runRequest = {
+                activePath: workspace.activePath ?? 'main.sh',
+                code,
+                limits,
+                log,
+                programArgs,
+                stdin,
+                workspaceFiles: workspace.workspaceFiles,
+                workspaceLimits
+            };
+            this.bindAbort(operation);
+            this.requireActive(operation);
+            const needsStartup = !this.readyWorker;
+            const startupConfig = this.requireConfig(operation);
+            const timeoutMs = Math.min(MAX_TIMER_DELAY_MS, limits.compileTimeoutMs +
+                limits.runTimeoutMs +
+                (needsStartup
+                    ? startupConfig.limits.assetTimeoutMs +
+                        startupConfig.limits.startupTimeoutMs
+                    : 0));
+            this.bindTimeout(operation, timeoutMs);
+            this.requireActive(operation);
+            operation.started = true;
+            this.begin = Date.now();
+            this.exit = false;
+            if (stdin !== undefined) {
+                this.pendingInput = [];
+                this.pendingEof = false;
+            }
+            if (this.readyWorker) {
+                operation.handle = this.readyWorker;
+                operation.stage = 'execute';
+                this.dispatchRun(operation, this.readyWorker);
+            }
+            else {
+                void this.createWorker(operation)
+                    .then((handle) => {
+                    if (!this.isActive(operation)) {
+                        this.retireWorker(handle);
+                        return;
+                    }
+                    this.dispatchLoad(operation, handle, false);
+                })
+                    .catch(() => undefined);
+            }
+        }
+        catch (error) {
+            this.failOperation(operation, error, false);
+        }
+        return promise;
+    }
+    write(input) {
+        if (this.disposed)
+            return;
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        const operation = this.activeOperation;
+        if (operation?.kind === 'run' && operation.stdinReady)
+            this.flushStdin(operation);
+    }
+    eof() {
+        if (this.disposed)
+            return;
+        this.pendingEof = true;
+        const operation = this.activeOperation;
+        if (operation?.kind === 'run' && operation.stdinReady)
+            this.flushStdin(operation);
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const operation = this.activeOperation;
+        if (operation) {
+            this.failOperation(operation, reason, true);
+            return;
+        }
+        const readyWorker = this.readyWorker;
+        if (readyWorker)
+            this.retireWorker(readyWorker);
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.exit = true;
+    }
+    async clear() {
+        if (this.disposed)
+            return;
+        this.terminate();
+        const readyWorker = this.readyWorker;
+        if (readyWorker)
+            this.retireWorker(readyWorker);
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.loadedConfig = null;
+        this.webcUrl = '';
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const operation = this.activeOperation;
+        const readyWorker = this.readyWorker;
+        this.readyWorker = null;
+        this.loadedConfig = null;
+        this.webcUrl = '';
+        this.output = undefined;
+        this.oncompilerdiagnostic = undefined;
+        this.pendingInput = [];
+        this.pendingEof = false;
+        if (operation)
+            this.failOperation(operation, this.disposeCancellation, true);
+        if (readyWorker)
+            this.retireWorker(readyWorker);
+        this.exit = true;
+        return this.disposePromise;
+    }
+    isActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.settled;
+    }
+    requireActive(operation) {
+        if (!this.isActive(operation))
+            throw new Error('Bash operation was superseded');
+    }
+    requireConfig(operation) {
+        if (!operation.config) {
+            throw new RuntimeConfigurationError('Bash operation has no runtime configuration', {
+                phase: 'startup',
+                runtimeId: 'BASH'
+            });
+        }
+        return operation.config;
+    }
+    retireDelivery(operation) {
+        const delivery = operation.delivery;
+        if (!delivery || delivery.state === 'retired')
+            return;
+        delivery.state = 'retired';
+        delivery.payload = null;
+        delivery.transferables.length = 0;
+        operation.delivery = undefined;
+    }
+    bindAbort(operation) {
+        const signal = operation.signal;
+        if (!signal)
+            return;
+        const onAbort = () => {
+            if (!this.isActive(operation))
+                return;
+            let reason;
+            try {
+                reason = abortReason(signal, operation.stage);
+            }
+            catch (error) {
+                reason = error;
+            }
+            if (this.isActive(operation))
+                this.failOperation(operation, reason, true);
+        };
+        operation.onAbort = onAbort;
+        try {
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            if (this.isActive(operation))
+                this.failOperation(operation, error, true);
+        }
+    }
+    bindTimeout(operation, timeoutMs) {
+        try {
+            operation.timeout = setTimeout(() => {
+                if (!this.isActive(operation))
+                    return;
+                const phase = operation.stage === 'startup' ? 'startup' : 'execute';
+                this.failOperation(operation, new TimeoutError(`Bash ${operation.stage} timed out after ${timeoutMs} ms`, {
+                    phase,
+                    runtimeId: 'BASH',
+                    timeoutMs
+                }), true);
+            }, timeoutMs);
+        }
+        catch (error) {
+            this.failOperation(operation, error, false);
+        }
+    }
+    cleanupOperation(operation) {
+        if (operation.timeout !== undefined) {
+            try {
+                clearTimeout(operation.timeout);
+            }
+            catch {
+                // Timer cleanup must not replace the operation result.
+            }
+            operation.timeout = undefined;
+        }
+        if (operation.signal && operation.onAbort) {
+            try {
+                operation.signal.removeEventListener('abort', operation.onAbort);
+            }
+            catch {
+                // Listener cleanup must not replace the operation result.
+            }
+            operation.onAbort = undefined;
+        }
+    }
+    finishOperation(operation, value) {
+        if (!this.isActive(operation))
+            return;
+        operation.settled = true;
+        this.activeOperation = null;
+        this.cleanupOperation(operation);
+        operation.preflightController = undefined;
+        this.retireDelivery(operation);
+        if (operation.kind === 'run') {
+            if (operation.runRequest?.stdin !== undefined) {
+                this.pendingInput = [];
+                this.pendingEof = false;
+            }
+            this.elapse = Date.now() - this.begin;
+            this.exit = true;
+        }
+        operation.resolve(value);
+    }
+    failOperation(operation, reason, retireHandle) {
+        if (!this.isActive(operation))
+            return;
+        operation.settled = true;
+        this.activeOperation = null;
+        this.cleanupOperation(operation);
+        try {
+            operation.preflightController?.abort(reason);
+        }
+        catch {
+            // Preserve the original failure.
+        }
+        operation.preflightController = undefined;
+        this.retireDelivery(operation);
+        if (retireHandle && operation.handle)
+            this.retireWorker(operation.handle);
+        if (operation.kind === 'run' && operation.started) {
+            this.pendingInput = [];
+            this.pendingEof = false;
+            this.elapse = Date.now() - this.begin;
+            this.exit = true;
+        }
+        operation.reject(reason);
+    }
+    async createWorker(operation) {
+        const config = this.requireConfig(operation);
+        const preflightController = new AbortController();
+        operation.preflightController = preflightController;
+        const loadedByAsset = new Map();
+        const deliveryTotal = config.preflightProfile.manifestReceipt.bytes +
+            config.preflightProfile.sdkJavaScriptReceipt.bytes +
+            config.preflightProfile.wasmerWasmReceipt.bytes +
+            config.preflightProfile.webcReceipt.bytes;
+        let payload = null;
+        try {
+            payload = await preflightBashRuntimeAssets({
+                baseUrl: config.baseUrl,
+                manifestUrl: config.manifestUrl,
+                sdkJavaScriptUrl: config.moduleUrl,
+                wasmerWasmUrl: config.wasmerWasmUrl,
+                webcUrl: config.webcUrl,
+                profile: config.preflightProfile,
+                limits: config.limits,
+                signal: preflightController.signal,
+                reportProgress: ({ assetKey, loadedBytes }) => {
+                    loadedByAsset.set(assetKey, loadedBytes);
+                    let totalLoaded = 0;
+                    for (const loaded of loadedByAsset.values())
+                        totalLoaded += loaded;
+                    operation.progress?.set?.(Math.min(0.75, (totalLoaded / deliveryTotal) * 0.75), `Verifying Bash ${assetKey}`);
+                },
+                reportDecompressionProgress: (asset, loadedBytes, totalBytes) => {
+                    operation.progress?.set?.(0.75 + Math.min(0.2, (loadedBytes / totalBytes) * 0.2), `Decompressing Bash ${asset}`);
+                }
+            });
+        }
+        catch (error) {
+            this.failOperation(operation, error, false);
+            throw error;
+        }
+        finally {
+            operation.preflightController = undefined;
+        }
+        if (!this.isActive(operation)) {
+            payload = null;
+            throw new Error('Bash operation was cancelled');
+        }
+        let WorkerConstructor;
+        try {
+            WorkerConstructor = (await import('./worker/bash?worker')).default;
+        }
+        catch (cause) {
+            const error = new WorkerStartupError('Failed to load the Bash outer worker module', {
+                cause,
+                runtimeId: 'BASH'
+            });
+            this.failOperation(operation, error, false);
+            payload = null;
+            throw error;
+        }
+        if (!this.isActive(operation)) {
+            payload = null;
+            throw new Error('Bash operation was cancelled');
+        }
+        let worker;
+        try {
+            worker = new WorkerConstructor();
+        }
+        catch (cause) {
+            const error = new WorkerStartupError('Failed to start the Bash outer worker', {
+                cause,
+                runtimeId: 'BASH'
+            });
+            this.failOperation(operation, error, false);
+            payload = null;
+            throw error;
+        }
+        const sessionId = ++this.sessionUid;
+        if (!Object.isFrozen(payload)) {
+            try {
+                worker.terminate();
+            }
+            catch {
+                // Preserve the ownership contract failure.
+            }
+            const error = new ProtocolError('Bash preflight payload must be frozen', {
+                runtimeId: 'BASH'
+            });
+            this.failOperation(operation, error, false);
+            payload = null;
+            throw error;
+        }
+        const transferables = [];
+        const uniqueBuffers = new Set();
+        for (const bytes of [
+            payload.manifestBytes,
+            payload.sdkJavaScriptBytes,
+            payload.wasmerWasmBytes,
+            payload.webcBytes
+        ]) {
+            const buffer = bytes.buffer;
+            if (bytes.byteLength <= 0 ||
+                bytes.byteOffset !== 0 ||
+                bytes.byteLength !== buffer.byteLength ||
+                Object.prototype.toString.call(buffer) !== '[object ArrayBuffer]' ||
+                (typeof SharedArrayBuffer === 'function' && buffer instanceof SharedArrayBuffer) ||
+                uniqueBuffers.has(buffer)) {
+                try {
+                    worker.terminate();
+                }
+                catch {
+                    // Preserve the ownership contract failure.
+                }
+                const error = new ProtocolError('Bash preflight payload must own four unique whole ArrayBuffers', { runtimeId: 'BASH' });
+                this.failOperation(operation, error, false);
+                payload = null;
+                throw error;
+            }
+            uniqueBuffers.add(buffer);
+            transferables.push(buffer);
+        }
+        const handle = {
+            identity: config.identity,
+            ready: false,
+            retired: false,
+            sessionId,
+            worker
+        };
+        operation.handle = handle;
+        operation.delivery = {
+            identity: config.identity,
+            payload,
+            sessionId,
+            state: 'available',
+            transferables
+        };
+        payload = null;
+        worker.onmessage = (event) => {
+            this.handleWorkerMessage(handle, event.data);
+        };
+        worker.onerror = (event) => {
+            this.handleWorkerFailure(handle, event);
+        };
+        worker.onmessageerror = (event) => {
+            this.handleWorkerProtocolFailure(handle, event);
+        };
+        return handle;
+    }
+    dispatchLoad(operation, handle, log) {
+        if (!this.isActive(operation) || operation.handle !== handle)
+            return;
+        const config = this.requireConfig(operation);
+        const delivery = operation.delivery;
+        if (!delivery ||
+            delivery.state !== 'available' ||
+            delivery.identity !== config.identity ||
+            delivery.sessionId !== handle.sessionId ||
+            !delivery.payload ||
+            delivery.transferables.length !== 4) {
+            this.failOperation(operation, new ProtocolError('Bash preflight delivery is unavailable or stale', {
+                runtimeId: 'BASH'
+            }), true);
+            return;
+        }
+        operation.stage = 'startup';
+        operation.requestId = ++this.requestUid;
+        const runtimePreflight = delivery.payload;
+        const transferables = delivery.transferables.splice(0);
+        delivery.payload = null;
+        delivery.state = 'consumed';
+        const message = {
+            type: 'load',
+            protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+            sessionId: handle.sessionId,
+            requestId: operation.requestId,
+            runtimePreflight,
+            limits: config.limits,
+            log
+        };
+        try {
+            this.postMessage(operation, handle, message, transferables);
+        }
+        finally {
+            this.retireDelivery(operation);
+        }
+    }
+    dispatchRun(operation, handle) {
+        const request = operation.runRequest;
+        if (!request || !this.isActive(operation) || operation.handle !== handle)
+            return;
+        operation.stage = 'execute';
+        operation.requestId = ++this.requestUid;
+        const message = {
+            type: 'run',
+            protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+            sessionId: handle.sessionId,
+            requestId: operation.requestId,
+            code: request.code,
+            activePath: request.activePath,
+            workspaceFiles: request.workspaceFiles,
+            programArgs: request.programArgs,
+            stdin: request.stdin,
+            limits: request.limits,
+            workspaceLimits: request.workspaceLimits,
+            log: request.log
+        };
+        this.postMessage(operation, handle, message);
+    }
+    postMessage(operation, handle, message, transfer = []) {
+        if (!this.isActive(operation) || operation.handle !== handle)
+            return;
+        try {
+            handle.worker.postMessage(message, transfer);
+        }
+        catch (cause) {
+            this.failOperation(operation, new ProtocolError(`Failed to send Bash worker ${message.type} message`, {
+                cause,
+                runtimeId: 'BASH'
+            }), true);
+        }
+    }
+    handleWorkerMessage(handle, message) {
+        const operation = this.activeOperation;
+        if (!operation || operation.handle !== handle || handle.retired)
+            return;
+        if (!message || typeof message !== 'object') {
+            this.failProtocol(operation, 'Bash worker returned a non-object message', message);
+            return;
+        }
+        const envelope = message;
+        if (envelope.protocolVersion !== BASH_WORKER_PROTOCOL_VERSION) {
+            this.failProtocol(operation, `Unsupported Bash worker protocol version: ${String(envelope.protocolVersion)}`, message);
+            return;
+        }
+        if (!Number.isSafeInteger(envelope.sessionId) ||
+            envelope.sessionId <= 0 ||
+            !Number.isSafeInteger(envelope.requestId) ||
+            envelope.requestId <= 0) {
+            this.failProtocol(operation, 'Bash worker returned an invalid request identity', message);
+            return;
+        }
+        if (envelope.sessionId !== handle.sessionId) {
+            this.failProtocol(operation, 'Bash worker returned an unexpected session identity', message);
+            return;
+        }
+        if (operation.requestId === 0) {
+            this.failProtocol(operation, 'Bash worker responded before request dispatch', message);
+            return;
+        }
+        if (envelope.requestId < operation.requestId)
+            return;
+        if (envelope.requestId !== operation.requestId) {
+            this.failProtocol(operation, 'Bash worker returned a future request identity', message);
+            return;
+        }
+        if (!isBashWorkerToHostMessage(message)) {
+            this.failProtocol(operation, 'Bash worker returned an invalid message', message);
+            return;
+        }
+        switch (message.type) {
+            case 'progress':
+                try {
+                    operation.progress?.set?.(message.value, message.stage);
+                }
+                catch (error) {
+                    this.failOperation(operation, error, true);
+                }
+                return;
+            case 'loaded': {
+                if (operation.stage !== 'startup') {
+                    this.failProtocol(operation, 'Bash worker loaded outside startup', message);
+                    return;
+                }
+                if (operation.kind === 'run') {
+                    handle.ready = true;
+                    this.readyWorker = handle;
+                    this.dispatchRun(operation, handle);
+                    return;
+                }
+                try {
+                    operation.progress?.set?.(1, 'Bash runtime ready');
+                }
+                catch (error) {
+                    this.failOperation(operation, error, true);
+                    return;
+                }
+                if (!this.isActive(operation))
+                    return;
+                const config = this.requireConfig(operation);
+                const previousWorker = this.readyWorker;
+                handle.ready = true;
+                this.readyWorker = handle;
+                this.loadedConfig = config;
+                this.webcUrl = config.webcUrl;
+                this.finishOperation(operation);
+                if (previousWorker && previousWorker !== handle)
+                    this.retireWorker(previousWorker);
+                return;
+            }
+            case 'execution-ready':
+                if (operation.kind !== 'run' || operation.stage !== 'execute') {
+                    this.failProtocol(operation, 'Bash worker reported execution readiness outside execution', message);
+                    return;
+                }
+                if (operation.executionReady)
+                    return;
+                operation.executionReady = true;
+                try {
+                    reportWorkerProgress(operation.progress, message.progress);
+                }
+                catch (error) {
+                    this.failOperation(operation, error, true);
+                    return;
+                }
+                return;
+            case 'stdin-ready':
+                if (operation.kind !== 'run' || operation.stage !== 'execute') {
+                    this.failProtocol(operation, 'Bash worker requested stdin outside execution', message);
+                    return;
+                }
+                if (!operation.executionReady) {
+                    operation.executionReady = true;
+                    try {
+                        reportWorkerProgress(operation.progress, {
+                            kind: 'ready',
+                            state: 'waiting-input',
+                            reason: 'stdin-request',
+                            label: 'Bash process is ready for input'
+                        });
+                    }
+                    catch (error) {
+                        this.failOperation(operation, error, true);
+                        return;
+                    }
+                    if (!this.isActive(operation))
+                        return;
+                }
+                operation.stdinReady = true;
+                this.flushStdin(operation);
+                return;
+            case 'output':
+                this.handleOutput(operation, message.stream, message.bytes);
+                return;
+            case 'result':
+                if (operation.kind !== 'run' || operation.stage !== 'execute') {
+                    this.failProtocol(operation, 'Bash worker returned a result outside execution', message);
+                    return;
+                }
+                this.flushDecodedOutput(operation);
+                if (this.isActive(operation))
+                    this.finishOperation(operation, message.result);
+                return;
+            case 'error':
+                this.failOperation(operation, this.deserializeWorkerError(message.error, message.phase), true);
+                return;
+            default:
+                this.failProtocol(operation, 'Bash worker returned an unknown message', message);
+        }
+    }
+    handleOutput(operation, stream, bytes) {
+        if (operation.kind !== 'run' || operation.stage !== 'execute') {
+            this.failProtocol(operation, 'Bash worker emitted output outside execution', bytes);
+            return;
+        }
+        if (!ArrayBuffer.isView(bytes) ||
+            Object.prototype.toString.call(bytes) !== '[object Uint8Array]') {
+            this.failProtocol(operation, 'Bash worker output must be Uint8Array bytes', bytes);
+            return;
+        }
+        const actual = operation.outputBytes + bytes.byteLength;
+        const limit = operation.runRequest?.limits.maxOutputBytes ?? 0;
+        if (actual > limit) {
+            this.failOperation(operation, new OutputLimitError(`Bash output exceeded ${limit} bytes`, {
+                actual,
+                limit,
+                phase: 'execute',
+                runtimeId: 'BASH'
+            }), true);
+            return;
+        }
+        operation.outputBytes = actual;
+        const output = operation.decoders[stream].decode(bytes, { stream: true });
+        if (!output)
+            return;
+        try {
+            this.output?.(output);
+        }
+        catch (error) {
+            this.failOperation(operation, error, true);
+        }
+    }
+    flushDecodedOutput(operation) {
+        for (const stream of ['stdout', 'stderr']) {
+            let output;
+            try {
+                output = operation.decoders[stream].decode();
+            }
+            catch (error) {
+                this.failProtocol(operation, 'Bash output was not valid streaming UTF-8', error);
+                return;
+            }
+            if (!output)
+                continue;
+            try {
+                this.output?.(output);
+            }
+            catch (error) {
+                this.failOperation(operation, error, true);
+                return;
+            }
+        }
+    }
+    flushStdin(operation) {
+        const handle = operation.handle;
+        if (!handle || !this.isActive(operation) || !operation.stdinReady)
+            return;
+        while (this.pendingInput.length > 0 && this.isActive(operation)) {
+            const input = this.pendingInput.shift();
+            const bytes = textEncoder.encode(input);
+            const message = {
+                type: 'stdin',
+                protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+                sessionId: handle.sessionId,
+                requestId: operation.requestId,
+                bytes
+            };
+            this.postMessage(operation, handle, message, [bytes.buffer]);
+        }
+        if (this.pendingEof && this.isActive(operation)) {
+            this.pendingEof = false;
+            this.postMessage(operation, handle, {
+                type: 'stdin-eof',
+                protocolVersion: BASH_WORKER_PROTOCOL_VERSION,
+                sessionId: handle.sessionId,
+                requestId: operation.requestId
+            });
+        }
+    }
+    handleWorkerFailure(handle, event) {
+        const operation = this.activeOperation;
+        if (handle.retired)
+            return;
+        if (!operation || operation.handle !== handle) {
+            if (this.readyWorker === handle)
+                this.retireWorker(handle);
+            return;
+        }
+        const location = event.filename && event.lineno
+            ? ` (${event.filename}:${event.lineno}:${event.colno})`
+            : '';
+        const message = `Bash outer worker script error: ${event.message || 'unknown error'}${location}`;
+        const error = operation.stage === 'startup'
+            ? new WorkerStartupError(message, { cause: event, runtimeId: 'BASH' })
+            : new RuntimeExecutionError(message, {
+                cause: event,
+                phase: 'execute',
+                runtimeId: 'BASH'
+            });
+        this.failOperation(operation, error, true);
+    }
+    handleWorkerProtocolFailure(handle, cause) {
+        const operation = this.activeOperation;
+        if (handle.retired)
+            return;
+        if (!operation || operation.handle !== handle) {
+            if (this.readyWorker === handle)
+                this.retireWorker(handle);
+            return;
+        }
+        this.failOperation(operation, new ProtocolError('Bash worker message deserialization failed', {
+            cause,
+            runtimeId: 'BASH'
+        }), true);
+    }
+    failProtocol(operation, message, cause) {
+        this.failOperation(operation, new ProtocolError(message, { cause, runtimeId: 'BASH' }), true);
+    }
+    deserializeWorkerError(error, phase) {
+        const context = {
+            cause: error,
+            phase,
+            ...(error.profileId ? { profileId: error.profileId } : {}),
+            ...(error.recoverable === undefined ? {} : { recoverable: error.recoverable }),
+            runtimeId: 'BASH'
+        };
+        let deserialized;
+        if (phase === 'protocol' || error.code === 'protocol') {
+            deserialized = new ProtocolError(error.message, context);
+        }
+        else {
+            switch (error.code) {
+                case 'unsupported-language':
+                    deserialized = error.languageId
+                        ? new UnsupportedLanguageError(error.languageId, context)
+                        : new WasmIdleError(error.message, {
+                            ...context,
+                            code: 'unsupported-language'
+                        });
+                    break;
+                case 'busy':
+                    deserialized = new BusyError(error.message, context);
+                    break;
+                case 'runtime-configuration':
+                    deserialized = new RuntimeConfigurationError(error.message, context);
+                    break;
+                case 'asset-not-found':
+                    deserialized = new AssetNotFoundError(error.message, context);
+                    break;
+                case 'asset-integrity':
+                    deserialized = new AssetIntegrityError(error.message, context);
+                    break;
+                case 'asset-too-large':
+                    deserialized = new AssetTooLargeError(error.message, {
+                        ...context,
+                        actual: error.actual,
+                        limit: error.limit
+                    });
+                    break;
+                case 'worker-startup':
+                    deserialized = new WorkerStartupError(error.message, context);
+                    break;
+                case 'compile':
+                    deserialized = new CompileError(error.message, context);
+                    break;
+                case 'runtime':
+                    deserialized = new RuntimeExecutionError(error.message, context);
+                    break;
+                case 'timeout':
+                    deserialized =
+                        error.timeoutMs === undefined
+                            ? new WasmIdleError(error.message, { ...context, code: 'timeout' })
+                            : new TimeoutError(error.message, {
+                                ...context,
+                                timeoutMs: error.timeoutMs
+                            });
+                    break;
+                case 'cancelled':
+                    deserialized = new CancelledError(error.message, context);
+                    break;
+                case 'resource-limit':
+                    deserialized =
+                        error.actual === undefined ||
+                            error.limit === undefined ||
+                            error.resource === undefined
+                            ? new WasmIdleError(error.message, {
+                                ...context,
+                                code: 'resource-limit'
+                            })
+                            : new ResourceLimitError(error.message, {
+                                ...context,
+                                actual: error.actual,
+                                limit: error.limit,
+                                resource: error.resource
+                            });
+                    break;
+                case 'output-limit':
+                    deserialized =
+                        error.actual === undefined || error.limit === undefined
+                            ? new WasmIdleError(error.message, {
+                                ...context,
+                                code: 'output-limit'
+                            })
+                            : new OutputLimitError(error.message, {
+                                ...context,
+                                actual: error.actual,
+                                limit: error.limit
+                            });
+                    break;
+                case 'diagnostic-limit':
+                    deserialized =
+                        error.actual === undefined || error.limit === undefined
+                            ? new WasmIdleError(error.message, {
+                                ...context,
+                                code: 'diagnostic-limit'
+                            })
+                            : new DiagnosticLimitError(error.message, {
+                                ...context,
+                                actual: error.actual,
+                                limit: error.limit
+                            });
+                    break;
+                case 'unsupported-browser-feature':
+                    deserialized = error.feature
+                        ? new UnsupportedBrowserFeatureError(error.feature, context)
+                        : new WasmIdleError(error.message, {
+                            ...context,
+                            code: 'unsupported-browser-feature'
+                        });
+                    break;
+                default:
+                    deserialized =
+                        phase === 'execute'
+                            ? new RuntimeExecutionError(error.message, context)
+                            : new WorkerStartupError(error.message, context);
+            }
+        }
+        if (deserialized.name === 'WasmIdleError' && error.name) {
+            deserialized.name = error.name;
+        }
+        if (error.stack)
+            deserialized.stack = error.stack;
+        return deserialized;
+    }
+    retireWorker(handle) {
+        if (handle.retired)
+            return;
+        handle.retired = true;
+        if (this.readyWorker === handle)
+            this.readyWorker = null;
+        try {
+            handle.worker.onmessage = null;
+        }
+        catch {
+            // Handler cleanup remains best effort.
+        }
+        try {
+            handle.worker.onerror = null;
+        }
+        catch {
+            // Handler cleanup remains best effort.
+        }
+        try {
+            handle.worker.onmessageerror = null;
+        }
+        catch {
+            // Handler cleanup remains best effort.
+        }
+        try {
+            handle.worker.terminate();
+        }
+        catch {
+            // The worker may already be detached.
+        }
+    }
+}
+export default Bash;