wasm-idle 1.0.11 → 1.0.12

package/dist/playground/python.js

@@ -5,11 +5,14 @@ import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdi
 import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerProgress } from './workerProgress';
-import { BusyError, TimeoutError, resolveExecutionLimits } from '@wasm-idle/core';
+import { BusyError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
 const debugBreakpointBufferInts = 1028;
-const abortReason = (signal, phase) => signal.reason !== undefined
+const outputEncoder = new TextEncoder();
+const abortReason = (signal, phase, label = 'Python') => signal.reason !== undefined
     ? signal.reason
-    : new DOMException(phase === 'startup' ? 'Python runtime startup aborted' : 'Python execution aborted', 'AbortError');
+    : new DOMException(phase === 'startup'
+        ? `${label} runtime startup aborted`
+        : `${label} execution aborted`, 'AbortError');
 class Python {
     ts = Date.now();
     output = null;
@@ -37,6 +40,25 @@ class Python {
     workerExtensionKey;
     /** Language executed by the shared Pyodide worker; subclasses run other Python-hosted languages. */
     workerLanguage = 'python';
+    get usesInterpreterStdio() {
+        return this.workerLanguage === 'aheui' || this.workerLanguage === 'apecode';
+    }
+    get runtimeId() {
+        if (this.workerLanguage === 'apecode')
+            return 'APECODE';
+        return this.workerLanguage === 'aheui' ? 'AHEUI' : 'PYTHON3';
+    }
+    get runtimeLabel() {
+        if (this.workerLanguage === 'apecode')
+            return 'APECode';
+        return this.workerLanguage === 'aheui' ? 'Aheui' : 'Python';
+    }
+    resetInterpreterInput() {
+        if (!this.usesInterpreterStdio)
+            return;
+        this.pendingInput = [];
+        resetBufferedStdin(this.buffer);
+    }
     /** Extra worker load configuration for Python-hosted languages, keyed for worker reuse. */
     workerLoadExtension(_runtimeAssets, _currentUrl) {
         return undefined;
@@ -57,10 +79,10 @@ class Python {
     });
     beginOperation(phase) {
         if (this.disposed)
-            throw new Error('Python runtime has been disposed');
+            throw new Error(`${this.runtimeLabel} runtime has been disposed`);
         if (this.activeOperation) {
-            throw new BusyError('Python runtime already has an active operation', {
-                runtimeId: 'PYTHON3',
+            throw new BusyError(`${this.runtimeLabel} runtime already has an active operation`, {
+                runtimeId: this.runtimeId,
                 phase: this.activeOperation.phase
             });
         }
@@ -110,6 +132,7 @@ class Python {
         this.activeOperation = null;
         this.waitingForInput = false;
         this.pendingEof = false;
+        this.resetInterpreterInput();
         this.uid += 1;
         this.exit = true;
         this.workerSession.terminate(reason);
@@ -124,7 +147,7 @@ class Python {
                 return;
             let reason;
             try {
-                reason = abortReason(signal, operation.phase);
+                reason = abortReason(signal, operation.phase, this.runtimeLabel);
             }
             catch (error) {
                 reason = error;
@@ -145,9 +168,10 @@ class Python {
             this.cancelOperation(operation, error);
         }
     }
-    bindStartupTimeout(operation, timeoutMs) {
+    bindOperationTimeout(operation, timeoutMs) {
         if (!this.isOperationActive(operation))
             return;
+        timeoutMs = Math.min(2_147_483_647, timeoutMs);
         let timeout;
         operation.cleanups.push(() => {
             if (timeout !== undefined)
@@ -157,9 +181,9 @@ class Python {
             timeout = setTimeout(() => {
                 if (!this.isOperationActive(operation))
                     return;
-                this.cancelOperation(operation, new TimeoutError(`Python startup timed out after ${timeoutMs} ms`, {
-                    phase: 'startup',
-                    runtimeId: 'PYTHON3',
+                this.cancelOperation(operation, new TimeoutError(`${this.runtimeLabel} ${operation.phase === 'startup' ? 'startup' : 'execution'} timed out after ${timeoutMs} ms`, {
+                    phase: operation.phase,
+                    runtimeId: this.runtimeId,
                     timeoutMs
                 }));
             }, timeoutMs);
@@ -187,7 +211,7 @@ class Python {
                 return Promise.reject(this.releaseBeforeSession(operation, 'Python runtime startup cancelled'));
             }
             if (signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(operation, abortReason(signal, 'startup')));
+                return Promise.reject(this.releaseBeforeSession(operation, abortReason(signal, 'startup', this.runtimeLabel)));
             }
         }
         catch (error) {
@@ -300,7 +324,7 @@ class Python {
             }
         });
         const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs);
-        this.bindStartupTimeout(operation, timeoutMs);
+        this.bindOperationTimeout(operation, timeoutMs);
         this.bindAbortSignal(operation, signal);
         return loading.finally(() => {
             this.releaseOperation(operation);
@@ -346,6 +370,7 @@ class Python {
         let activePath;
         let debugPath;
         let workspaceFiles;
+        let limits;
         try {
             signal = options.signal;
             debug = !!options.debug;
@@ -355,6 +380,24 @@ class Python {
             activePath = options.activePath;
             debugPath = options.debugPath;
             workspaceFiles = options.workspaceFiles;
+            if (this.usesInterpreterStdio) {
+                limits = resolveExecutionLimits(options.limits);
+                if (_args.length || options.programArgs?.length) {
+                    throw new RuntimeConfigurationError(`${this.runtimeLabel} does not accept program arguments`, { runtimeId: this.runtimeId });
+                }
+                if (debug || (options.debugMode && options.debugMode !== 'none')) {
+                    throw new RuntimeConfigurationError(`${this.runtimeLabel} debugging is not supported`, { runtimeId: this.runtimeId });
+                }
+                const workspace = validateExecutionWorkspace(code, workspaceFiles ?? [], activePath ?? (this.workerLanguage === 'apecode' ? 'main.ape' : 'main.aheui'), {
+                    ...options.workspaceLimits,
+                    maxFileBytes: Math.min(options.workspaceLimits?.maxFileBytes ??
+                        DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                    maxTotalBytes: Math.min(options.workspaceLimits?.maxTotalBytes ??
+                        DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+                });
+                activePath = workspace.activePath;
+                workspaceFiles = workspace.workspaceFiles;
+            }
             const persistentCache = options.persistentCache;
             if (!this.isOperationActive(activeOperation)) {
                 return Promise.reject(this.releaseBeforeSession(activeOperation, 'Python execution cancelled'));
@@ -370,14 +413,22 @@ class Python {
         if (!worker || this.worker !== worker) {
             return Promise.reject(this.releaseBeforeSession(activeOperation, 'Worker not loaded'));
         }
+        this.resetInterpreterInput();
+        if (this.usesInterpreterStdio) {
+            this.waitingForInput = false;
+            this.pendingEof = false;
+        }
         this.exit = false;
         const running = new Promise((resolve, reject) => {
             const workerOperation = this.workerSession.beginRun(worker, reject);
+            if (limits)
+                this.bindOperationTimeout(activeOperation, prepare ? limits.compileTimeoutMs : limits.runTimeoutMs);
             this.bindAbortSignal(activeOperation, signal);
             if (!this.isOperationActive(activeOperation))
                 return;
             const interrupt = new Uint8Array(this.interruptBuffer), runUid = ++this.uid;
             let handler;
+            let outputBytes = 0;
             const ownsRun = () => this.isOperationActive(activeOperation) &&
                 this.worker === worker &&
                 worker.onmessage === handler &&
@@ -387,6 +438,7 @@ class Python {
                 this.exit = true;
                 this.waitingForInput = false;
                 this.pendingEof = false;
+                this.resetInterpreterInput();
             };
             const claimRun = () => {
                 if (!ownsRun())
@@ -431,7 +483,7 @@ class Python {
                                 kind: 'ready',
                                 state: 'waiting-input',
                                 reason: 'stdin-request',
-                                label: 'Python program is waiting for input'
+                                label: `${this.runtimeLabel} program is waiting for input`
                             });
                         }
                         this.waitingForInput = true;
@@ -443,8 +495,21 @@ class Python {
                         this.image?.(payload);
                     if (!ownsRun())
                         return;
-                    if (output)
+                    if (output) {
+                        if (limits) {
+                            outputBytes += outputEncoder.encode(output).byteLength;
+                            if (outputBytes > limits.maxOutputBytes) {
+                                failRun(new OutputLimitError(`${this.runtimeLabel} output exceeded the configured byte limit`, {
+                                    runtimeId: this.runtimeId,
+                                    phase: 'execute',
+                                    actual: outputBytes,
+                                    limit: limits.maxOutputBytes
+                                }), true);
+                                return;
+                            }
+                        }
                         this.output?.(output);
+                    }
                     if (!ownsRun())
                         return;
                     if (debugEvent)
@@ -502,6 +567,7 @@ class Python {
                 this.exit = true;
                 this.waitingForInput = false;
                 this.pendingEof = false;
+                this.resetInterpreterInput();
             }
             this.cleanupOperation(activeOperation);
         });

package/dist/playground/ruby.d.ts

@@ -2,6 +2,7 @@ import { type PlaygroundRuntimeAssets } from './assets';
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Ruby implements Sandbox {
+    private readonly workerLanguage;
     output: any;
     worker?: Worker;
     buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
@@ -21,6 +22,11 @@ declare class Ruby implements Sandbox {
     private disposePromise;
     private readonly disposeCancellation;
     private readonly workerSession;
+    constructor(workerLanguage?: 'ruby' | 'golfscript');
+    private get runtimeId();
+    private get runtimeLabel();
+    private get defaultSourcePath();
+    private validateRuntimeNamespace;
     private beginOperation;
     private isOperationActive;
     private releaseOperation;

package/dist/playground/ruby.js

@@ -1,16 +1,20 @@
-import { resolveRubyRuntimeAssetConfig } from './assets';
+import { resolveRubyRuntimeAssetConfig, resolveGolfscriptRuntimeAssetConfig } from './assets';
+import { GOLFSCRIPT_RUNTIME_DIRECTORY, WASM_GOLFSCRIPT_INTERPRETER_RECEIPT } from './wasmGolfscriptVersion';
 import { createRubyRuntimeOwnedPreflightDelivery, preflightVerifiedRubyRuntimeAssets } from './rubyAssets';
 import { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
-import { BusyError, AssetTooLargeError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RUBY_MAX_ASSET_BYTES, RUBY_MAX_MANIFEST_BYTES, RUBY_MAX_MODULE_BYTES, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, AssetTooLargeError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RUBY_MAX_ASSET_BYTES, RUBY_MAX_MANIFEST_BYTES, RUBY_MAX_MODULE_BYTES, RuntimeConfigurationError, TimeoutError, fetchPinnedRuntimeAsset, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
 const OUTPUT_ENCODER = new TextEncoder();
-const abortReason = (signal, phase) => signal.reason !== undefined
+const abortReason = (signal, phase, label) => signal.reason !== undefined
     ? signal.reason
-    : new DOMException(phase === 'startup' ? 'Ruby runtime startup aborted' : 'Ruby execution aborted', 'AbortError');
+    : new DOMException(phase === 'startup'
+        ? `${label} runtime startup aborted`
+        : `${label} execution aborted`, 'AbortError');
 class Ruby {
+    workerLanguage;
     output = null;
     worker;
     buffer = createWasmIdleSharedBuffer(1024);
@@ -28,32 +32,57 @@ class Ruby {
     activeOperation = null;
     disposed = false;
     disposePromise = null;
-    disposeCancellation = new CancelledError('Ruby sandbox disposed', {
-        phase: 'dispose',
-        runtimeId: 'RUBY',
-        recoverable: false
-    });
-    workerSession = new WorkerSession({
-        label: 'Ruby',
-        onDispose: (worker) => {
-            if (this.worker !== worker)
-                return;
-            delete this.worker;
-            this.exit = true;
-            this.waitingForInput = false;
-            this.pendingEof = false;
+    disposeCancellation;
+    workerSession;
+    constructor(workerLanguage = 'ruby') {
+        this.workerLanguage = workerLanguage;
+        this.disposeCancellation = new CancelledError(`${this.runtimeLabel} sandbox disposed`, {
+            phase: 'dispose',
+            runtimeId: this.runtimeId,
+            recoverable: false
+        });
+        this.workerSession = new WorkerSession({
+            label: this.runtimeLabel,
+            onDispose: (worker) => {
+                if (this.worker !== worker)
+                    return;
+                delete this.worker;
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+            }
+        });
+    }
+    get runtimeId() {
+        return this.workerLanguage === 'golfscript' ? 'GOLFSCRIPT' : 'RUBY';
+    }
+    get runtimeLabel() {
+        return this.workerLanguage === 'golfscript' ? 'GolfScript' : 'Ruby';
+    }
+    get defaultSourcePath() {
+        return this.workerLanguage === 'golfscript' ? 'main.gs' : 'main.rb';
+    }
+    validateRuntimeNamespace(activePath, files) {
+        if (this.workerLanguage !== 'golfscript')
+            return;
+        if ([activePath ?? this.defaultSourcePath, ...files.map((file) => file.path)].some((path) => path === GOLFSCRIPT_RUNTIME_DIRECTORY ||
+            path.startsWith(`${GOLFSCRIPT_RUNTIME_DIRECTORY}/`))) {
+            throw new RuntimeConfigurationError('GolfScript workspace conflicts with its private runtime mount', {
+                phase: 'configuration',
+                runtimeId: this.runtimeId
+            });
         }
-    });
+    }
     beginOperation(phase) {
         if (this.disposed) {
-            throw new RuntimeConfigurationError('Ruby sandbox is disposed', {
+            throw new RuntimeConfigurationError(`${this.runtimeLabel} sandbox is disposed`, {
                 phase: 'dispose',
-                runtimeId: 'RUBY'
+                runtimeId: this.runtimeId
             });
         }
         if (this.activeOperation) {
-            throw new BusyError('Ruby runtime already has an active operation', {
-                runtimeId: 'RUBY',
+            throw new BusyError(`${this.runtimeLabel} runtime already has an active operation`, {
+                runtimeId: this.runtimeId,
                 phase: this.activeOperation.phase
             });
         }
@@ -115,7 +144,7 @@ class Ruby {
                 return;
             let reason;
             try {
-                reason = abortReason(signal, operation.phase);
+                reason = abortReason(signal, operation.phase, this.runtimeLabel);
             }
             catch (error) {
                 reason = error;
@@ -151,7 +180,7 @@ class Ruby {
                 return;
             let reason;
             try {
-                reason = abortReason(signal, operation.phase);
+                reason = abortReason(signal, operation.phase, this.runtimeLabel);
             }
             catch (error) {
                 reason = error;
@@ -185,9 +214,9 @@ class Ruby {
                 if (!this.isOperationActive(operation))
                     return;
                 const label = operation.phase === 'startup' ? 'startup' : 'execution';
-                this.cancelOperation(operation, new TimeoutError(`Ruby ${label} timed out after ${timeoutMs} ms`, {
+                this.cancelOperation(operation, new TimeoutError(`${this.runtimeLabel} ${label} timed out after ${timeoutMs} ms`, {
                     phase: operation.phase,
-                    runtimeId: 'RUBY',
+                    runtimeId: this.runtimeId,
                     timeoutMs
                 }));
             }, timeoutMs);
@@ -252,6 +281,7 @@ class Ruby {
         }
         let limits;
         let nextConfig;
+        let golfscriptConfig;
         let startupContext;
         let nextAssetKey;
         let signal;
@@ -260,32 +290,37 @@ class Ruby {
             signal = options.signal;
             unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
             if (!this.isOperationActive(activeOperation)) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} runtime startup cancelled`));
             }
             limits = resolveExecutionLimits(options.limits);
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} runtime startup cancelled`));
             }
-            const workspace = validateExecutionWorkspace(_code, options.workspaceFiles ?? [], options.activePath ?? 'main.rb', {
+            const workspace = validateExecutionWorkspace(_code, options.workspaceFiles ?? [], options.activePath ?? this.defaultSourcePath, {
                 ...options.workspaceLimits,
                 maxFileBytes: Math.min(options.workspaceLimits?.maxFileBytes ??
                     DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
                 maxTotalBytes: Math.min(options.workspaceLimits?.maxTotalBytes ??
                     DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
             });
+            this.validateRuntimeNamespace(workspace.activePath, workspace.workspaceFiles);
             startupContext = {
-                args: [...resolveSandboxExecutionArgs('RUBY', _args, options).programArgs],
-                activePath: workspace.activePath ?? 'main.rb',
+                args: [...resolveSandboxExecutionArgs(this.runtimeId, _args, options).programArgs],
+                activePath: workspace.activePath ?? this.defaultSourcePath,
                 workspaceFiles: workspace.workspaceFiles.map((file) => ({
                     path: file.path,
                     content: file.content
                 }))
             };
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} runtime startup cancelled`));
             }
             const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
             nextConfig = resolveRubyRuntimeAssetConfig(runtimeAssets, currentUrl);
+            golfscriptConfig =
+                this.workerLanguage === 'golfscript'
+                    ? resolveGolfscriptRuntimeAssetConfig(runtimeAssets, currentUrl)
+                    : undefined;
             const effectiveMaxAssetBytes = Math.min(limits.maxAssetBytes, RUBY_MAX_ASSET_BYTES);
             if (!nextConfig.splitStdlib) {
                 for (const [label, bytes, limit] of [
@@ -311,26 +346,30 @@ class Ruby {
                     ]
                 ]) {
                     if ((bytes ?? 0) > limit) {
-                        throw new AssetTooLargeError(`Ruby runtime ${label} exceeds the ${limit} byte limit`, {
+                        throw new AssetTooLargeError(`${this.runtimeLabel} runtime ${label} exceeds the ${limit} byte limit`, {
                             actual: bytes,
                             limit,
                             phase: 'asset',
                             profileId: nextConfig.preflightProfile.profileId,
-                            runtimeId: 'RUBY'
+                            runtimeId: this.runtimeId
                         });
                     }
                 }
             }
-            nextAssetKey = JSON.stringify([nextConfig.preflightKey, effectiveMaxAssetBytes]);
+            nextAssetKey = JSON.stringify([
+                nextConfig.preflightKey,
+                effectiveMaxAssetBytes,
+                ...(golfscriptConfig ? [golfscriptConfig.assetKey] : [])
+            ]);
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} runtime startup cancelled`));
             }
         }
         catch (error) {
             return Promise.reject(this.releaseBeforeSession(activeOperation, error));
         }
         if (!this.isOperationActive(activeOperation)) {
-            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby runtime startup cancelled'));
+            return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} runtime startup cancelled`));
         }
         unbindPreSessionAbort();
         const loading = this.workerSession.load(async (resolve, reject) => {
@@ -364,7 +403,7 @@ class Ruby {
                         return;
                     preflightController.abort(activeOperation.cancellationReason ??
                         signal?.reason ??
-                        new DOMException('Ruby runtime preflight retired', 'AbortError'));
+                        new DOMException(`${this.runtimeLabel} runtime preflight retired`, 'AbortError'));
                 });
                 const payload = await preflightVerifiedRubyRuntimeAssets(nextConfig, {
                     limits,
@@ -373,6 +412,15 @@ class Ruby {
                         progress?.set?.(totalBytes > 0 ? Math.min(0.9, (loadedBytes / totalBytes) * 0.9) : 0);
                     }
                 });
+                const interpreterBytes = golfscriptConfig
+                    ? Uint8Array.from(await fetchPinnedRuntimeAsset({
+                        url: golfscriptConfig.interpreterUrl,
+                        receipt: WASM_GOLFSCRIPT_INTERPRETER_RECEIPT,
+                        maxAssetBytes: limits.maxAssetBytes,
+                        persistentCache: options.persistentCache,
+                        signal: preflightController.signal
+                    }))
+                    : undefined;
                 if (!this.isOperationActive(activeOperation) || signal?.aborted)
                     return;
                 const delivery = createRubyRuntimeOwnedPreflightDelivery(payload);
@@ -431,17 +479,20 @@ class Ruby {
                     const location = event.filename && event.lineno
                         ? ` (${event.filename}:${event.lineno}:${event.colno})`
                         : '';
-                    rejectOperation(`Ruby worker script error: ${event.message || 'unknown error'}${location}`);
+                    rejectOperation(`${this.runtimeLabel} worker script error: ${event.message || 'unknown error'}${location}`);
                 };
-                worker.onmessageerror = () => rejectOperation('Ruby worker message deserialization failed');
+                worker.onmessageerror = () => rejectOperation(`${this.runtimeLabel} worker message deserialization failed`);
                 const transferables = delivery.consume();
                 try {
                     worker.postMessage({
                         load: true,
                         runtimePreflight: delivery.payload,
                         startupContext,
-                        maxAssetBytes: Math.min(limits.maxAssetBytes, RUBY_MAX_ASSET_BYTES)
-                    }, [...transferables]);
+                        maxAssetBytes: Math.min(limits.maxAssetBytes, RUBY_MAX_ASSET_BYTES),
+                        ...(interpreterBytes
+                            ? { language: 'golfscript', interpreterBytes }
+                            : {})
+                    }, [...transferables, ...(interpreterBytes ? [interpreterBytes.buffer] : [])]);
                 }
                 finally {
                     delivery.retire();
@@ -501,32 +552,33 @@ class Ruby {
             signal = options.signal;
             unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
             if (!this.isOperationActive(activeOperation)) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby execution cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} execution cancelled`));
             }
             limits = resolveExecutionLimits(options.limits);
-            const workspace = validateExecutionWorkspace(code, options.workspaceFiles ?? [], options.activePath ?? 'main.rb', {
+            const workspace = validateExecutionWorkspace(code, options.workspaceFiles ?? [], options.activePath ?? this.defaultSourcePath, {
                 ...options.workspaceLimits,
                 maxFileBytes: Math.min(options.workspaceLimits?.maxFileBytes ??
                     DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
                 maxTotalBytes: Math.min(options.workspaceLimits?.maxTotalBytes ??
                     DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
             });
-            const programArgs = resolveSandboxExecutionArgs('RUBY', args, options).programArgs;
+            this.validateRuntimeNamespace(workspace.activePath, workspace.workspaceFiles);
+            const programArgs = resolveSandboxExecutionArgs(this.runtimeId, args, options).programArgs;
             const stdin = options.stdin;
             if (stdin !== undefined && typeof stdin !== 'string') {
-                throw new RuntimeConfigurationError('Ruby stdin must be a string', {
+                throw new RuntimeConfigurationError(`${this.runtimeLabel} stdin must be a string`, {
                     phase: 'execute',
-                    runtimeId: 'RUBY'
+                    runtimeId: this.runtimeId
                 });
             }
             request = {
                 programArgs,
                 stdin,
-                activePath: workspace.activePath ?? 'main.rb',
+                activePath: workspace.activePath ?? this.defaultSourcePath,
                 workspaceFiles: workspace.workspaceFiles
             };
             if (!this.isOperationActive(activeOperation) || signal?.aborted) {
-                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby execution cancelled'));
+                return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} execution cancelled`));
             }
             unbindPreSessionAbort();
         }
@@ -534,7 +586,7 @@ class Ruby {
             return Promise.reject(this.releaseBeforeSession(activeOperation, error));
         }
         if (!this.isOperationActive(activeOperation)) {
-            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Ruby execution cancelled'));
+            return Promise.reject(this.releaseBeforeSession(activeOperation, `${this.runtimeLabel} execution cancelled`));
         }
         const worker = this.worker;
         if (!worker) {
@@ -603,7 +655,7 @@ class Ruby {
                     if (buffer && !hasExplicitStdin) {
                         this.waitingForInput = true;
                         if (!prepare) {
-                            reportWorkerInputReady(_prog, 'Ruby runtime ready for input');
+                            reportWorkerInputReady(_prog, `${this.runtimeLabel} runtime ready for input`);
                             if (!ownsRun())
                                 return;
                         }
@@ -617,11 +669,11 @@ class Ruby {
                     if (typeof output === 'string' && output.length > 0) {
                         const actual = outputBytes + OUTPUT_ENCODER.encode(output).byteLength;
                         if (actual > limits.maxOutputBytes) {
-                            failRun(new OutputLimitError(`Ruby output exceeded ${limits.maxOutputBytes} bytes`, {
+                            failRun(new OutputLimitError(`${this.runtimeLabel} output exceeded ${limits.maxOutputBytes} bytes`, {
                                 actual,
                                 limit: limits.maxOutputBytes,
                                 phase: 'execute',
-                                runtimeId: 'RUBY'
+                                runtimeId: this.runtimeId
                             }), true);
                             return;
                         }
@@ -633,11 +685,11 @@ class Ruby {
                     if (diagnostic !== undefined) {
                         const actual = diagnosticCount + 1;
                         if (actual > limits.maxDiagnostics) {
-                            failRun(new DiagnosticLimitError(`Ruby diagnostics exceeded ${limits.maxDiagnostics} messages`, {
+                            failRun(new DiagnosticLimitError(`${this.runtimeLabel} diagnostics exceeded ${limits.maxDiagnostics} messages`, {
                                 actual,
                                 limit: limits.maxDiagnostics,
                                 phase: 'execute',
-                                runtimeId: 'RUBY'
+                                runtimeId: this.runtimeId
                             }), true);
                             return;
                         }

package/dist/playground/wasiInterpreters.d.ts

@@ -0,0 +1,15 @@
+export type WasiInterpreterProfile = {
+    readonly id: string;
+    readonly folder: string;
+    readonly fileName: string;
+    readonly sourcePath: string;
+    readonly sourcePathPrefix?: string;
+    readonly maxSourcePathBytes?: number;
+    readonly maxSourceBytes?: number;
+    readonly minSourceCharacters?: number;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly sha256: string;
+    readonly bytes: number;
+};
+export declare const WASI_INTERPRETERS: Readonly<Record<string, WasiInterpreterProfile>>;