wasm-idle 0.7.2 → 1.0.0

package/dist/playground/gleam.js

@@ -0,0 +1,33 @@
+import { resolveGleamRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+export const GLEAM_WORKER_IDLE_TIMEOUT_MS = 60_000;
+class Gleam extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'GLEAM',
+            displayName: 'Gleam',
+            defaultActivePath: 'main.gleam',
+            moduleWorker: true,
+            workerLifetime: {
+                mode: 'persistent',
+                idleTimeoutMs: GLEAM_WORKER_IDLE_TIMEOUT_MS,
+                evictOnMemoryPressure: true
+            },
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\bwasm_idle\/stdin\b|\bstdin\.read_line\s*\(/
+            },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveGleamRuntimeAssetConfig(runtimeAssets, currentUrl);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Custom Gleam runtime URLs require a manifest fingerprint and worker receipt.', { runtimeId: 'GLEAM' });
+                }
+                return resolved;
+            }
+        });
+    }
+}
+export default Gleam;

package/dist/playground/go.d.ts

@@ -1,31 +1,37 @@
 import { type PlaygroundRuntimeAssets } from './assets';
-import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
-import type { Sandbox } from './sandbox';
+import { type DebugCommand, type DebugSessionEvent, type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Go implements Sandbox {
     output: any;
+    ondebug?: (event: DebugSessionEvent) => void;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    debugBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     exit: boolean;
     compilerUrl: string;
-    activeReject: ((reason: string) => void) | null;
+    manifestUrl: string;
+    private compilerLimitsKey;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
-    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>): Promise<void>;
+    private activeExplicitStdinCleanup;
+    private activeLoadSignalCleanup;
+    private activeRunSignalCleanup;
+    private readonly workerSession;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
-    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private resetStdinState;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    debugCommand(command: DebugCommand): void;
+    setBreakpoints(lines: number[]): void;
     kill(): void;
-    terminate(): void;
+    terminate(reason?: unknown): void;
     clear(): Promise<void>;
 }
 export default Go;

package/dist/playground/go.js

@@ -1,65 +1,199 @@
 import { resolveGoCompilerUrl } from './assets';
 import { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
+import { BusyError, TimeoutError, resolveExecutionLimits } from '@wasm-idle/core';
+const debugBreakpointBufferInts = 1028;
+function resolveGoManifestUrl(runtimeAssets, currentUrl, compilerUrl) {
+    const configured = typeof runtimeAssets === 'object' ? runtimeAssets.go?.manifestUrl?.trim() : undefined;
+    if (configured) {
+        return currentUrl ? new URL(configured, currentUrl).href : new URL(configured).href;
+    }
+    const compiler = currentUrl ? new URL(compilerUrl, currentUrl) : new URL(compilerUrl);
+    const manifest = new URL('./runtime/runtime-manifest.v1.json', compiler);
+    manifest.search = compiler.search;
+    return manifest.href;
+}
+function compilerRuntimeLimitsKey(limits) {
+    return [
+        limits.assetTimeoutMs,
+        limits.compileTimeoutMs,
+        limits.maxAssetBytes,
+        limits.maxWasmMemoryBytes
+    ].join(':');
+}
 class Go {
     output = null;
+    ondebug;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
+    buffer = createWasmIdleSharedBuffer(1024);
+    debugBuffer = createWasmIdleSharedBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
     pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
     exit = true;
     compilerUrl = '';
-    activeReject = null;
+    manifestUrl = '';
+    compilerLimitsKey = '';
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
-    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
-        return new Promise(async (resolve, reject) => {
-            this.pendingInput = [];
+    activeExplicitStdinCleanup = null;
+    activeLoadSignalCleanup = null;
+    activeRunSignalCleanup = null;
+    workerSession = new WorkerSession({
+        label: 'Go',
+        onDispose: (worker) => {
+            this.activeRunSignalCleanup?.();
+            this.activeRunSignalCleanup = null;
+            this.activeExplicitStdinCleanup?.();
+            if (this.worker === worker)
+                delete this.worker;
+            this.exit = true;
             this.waitingForInput = false;
             this.pendingEof = false;
-            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
-            const nextCompilerUrl = resolveGoCompilerUrl(runtimeAssets, currentUrl);
-            if (!nextCompilerUrl) {
-                return reject('Go runtime is not configured. Set PUBLIC_WASM_GO_COMPILER_URL or runtimeAssets.go.compilerUrl.');
+            this.ondebug?.({ type: 'stop' });
+        }
+    });
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        let limits;
+        try {
+            limits = resolveExecutionLimits(options.limits);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const signal = options.signal;
+        if (signal?.aborted) {
+            return Promise.reject(signal.reason ?? new DOMException('Go runtime startup aborted', 'AbortError'));
+        }
+        let onAbort;
+        let timeout;
+        let cleanedUp = false;
+        const cleanupSignal = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            if (signal && onAbort) {
+                try {
+                    signal.removeEventListener('abort', onAbort);
+                }
+                catch {
+                    // Cleanup must not replace the startup result.
+                }
             }
-            const needsWorkerReset = !this.worker || this.compilerUrl !== nextCompilerUrl;
-            this.compilerUrl = nextCompilerUrl;
-            if (needsWorkerReset && this.worker) {
-                this.worker.terminate();
-                delete this.worker;
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            if (this.activeLoadSignalCleanup === cleanupSignal) {
+                this.activeLoadSignalCleanup = null;
             }
-            if (!this.worker) {
-                this.worker = new (await import('./worker/go?worker')).default();
-                this.worker.onerror = (event) => {
-                    const location = event.filename && event.lineno
-                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
-                        : '';
-                    reject(`Go worker script error: ${event.message || 'unknown error'}${location}`);
-                };
-                this.worker.onmessageerror = () => {
-                    reject('Go worker message deserialization failed');
-                };
-                this.worker.onmessage = (event) => {
-                    if (event.data?.load) {
-                        progress?.set?.(1);
-                        resolve();
-                    }
-                    if (event.data?.error)
-                        reject(event.data.error);
-                };
-                this.worker.postMessage({
-                    load: true,
-                    compilerUrl: this.compilerUrl
-                });
+        };
+        onAbort = signal
+            ? () => {
+                if (this.activeLoadSignalCleanup !== cleanupSignal) {
+                    cleanupSignal();
+                    return;
+                }
+                const reason = signal.reason ??
+                    new DOMException('Go runtime startup aborted', 'AbortError');
+                cleanupSignal();
+                this.workerSession.terminate(reason);
             }
-            else {
-                progress?.set?.(1);
+            : undefined;
+        const loadPromise = this.workerSession.load(async (resolve, reject) => {
+            const resolveLoad = () => {
+                cleanupSignal();
                 resolve();
+            };
+            const rejectLoad = (reason) => {
+                cleanupSignal();
+                reject(reason);
+            };
+            try {
+                if (this.activeLoadSignalCleanup !== cleanupSignal || signal?.aborted)
+                    return;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                const nextCompilerUrl = resolveGoCompilerUrl(runtimeAssets, currentUrl);
+                if (!nextCompilerUrl) {
+                    return rejectLoad('Go runtime is not configured. Set PUBLIC_WASM_GO_COMPILER_URL or runtimeAssets.go.compilerUrl.');
+                }
+                const nextManifestUrl = resolveGoManifestUrl(runtimeAssets, currentUrl, nextCompilerUrl);
+                const nextCompilerLimitsKey = compilerRuntimeLimitsKey(limits);
+                const needsWorkerReset = !this.worker ||
+                    this.compilerUrl !== nextCompilerUrl ||
+                    this.manifestUrl !== nextManifestUrl ||
+                    this.compilerLimitsKey !== nextCompilerLimitsKey;
+                this.compilerUrl = nextCompilerUrl;
+                this.manifestUrl = nextManifestUrl;
+                this.compilerLimitsKey = nextCompilerLimitsKey;
+                if (needsWorkerReset && this.worker) {
+                    this.workerSession.reset();
+                }
+                if (!this.worker) {
+                    const WorkerConstructor = (await import('./worker/go?worker'))
+                        .default;
+                    if (this.activeLoadSignalCleanup !== cleanupSignal || signal?.aborted)
+                        return;
+                    const worker = new WorkerConstructor();
+                    if (this.activeLoadSignalCleanup !== cleanupSignal || signal?.aborted) {
+                        worker.terminate();
+                        return;
+                    }
+                    this.worker = worker;
+                    this.workerSession.attach(worker);
+                    worker.onmessage = (event) => {
+                        if (this.activeLoadSignalCleanup !== cleanupSignal ||
+                            signal?.aborted ||
+                            this.worker !== worker) {
+                            return;
+                        }
+                        if (event.data?.load) {
+                            progress?.set?.(1);
+                            resolveLoad();
+                        }
+                        if (event.data?.error)
+                            rejectLoad(event.data.error);
+                    };
+                    worker.postMessage({
+                        load: true,
+                        compilerUrl: this.compilerUrl,
+                        manifestUrl: this.manifestUrl,
+                        runtimeLimits: limits
+                    });
+                }
+                else {
+                    progress?.set?.(1);
+                    if (this.activeLoadSignalCleanup !== cleanupSignal || signal?.aborted)
+                        return;
+                    resolveLoad();
+                }
+            }
+            catch (error) {
+                rejectLoad(error);
             }
         });
+        this.activeLoadSignalCleanup = cleanupSignal;
+        if (signal && onAbort) {
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        timeout = setTimeout(() => {
+            if (this.activeLoadSignalCleanup !== cleanupSignal)
+                return;
+            this.workerSession.terminate(new TimeoutError(`Go startup timed out after ${limits.startupTimeoutMs} ms`, {
+                phase: 'startup',
+                runtimeId: 'GO',
+                timeoutMs: limits.startupTimeoutMs
+            }));
+        }, limits.startupTimeoutMs);
+        return loadPromise.finally(cleanupSignal);
     }
     write(input) {
         this.pendingInput.push(input);
@@ -83,82 +217,252 @@ class Go {
             this.waitingForInput = false;
         }
     }
+    resetStdinState() {
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        resetBufferedStdin(this.buffer);
+    }
     run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        if (options.debug)
+            requireSharedArrayBuffer('Go debugging');
+        if (!this.exit) {
+            const error = new BusyError('Go runtime already has an active execution', {
+                runtimeId: 'GO',
+                phase: 'execute'
+            });
+            this.terminate(error);
+            return Promise.reject(error);
+        }
+        let limits;
+        try {
+            limits = resolveExecutionLimits(options.limits);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const signal = options.signal;
+        if (signal?.aborted) {
+            return Promise.reject(signal.reason ?? new DOMException('Go execution aborted', 'AbortError'));
+        }
+        const worker = this.worker;
+        if (!worker)
+            return Promise.reject('Worker not loaded');
         this.exit = false;
         return new Promise((resolve, reject) => {
-            if (!this.worker)
-                return reject('Worker not loaded');
             const { programArgs } = resolveSandboxExecutionArgs('GO', args, options);
             const target = options.goTarget || 'wasip1/wasm';
             const _uid = ++this.uid;
-            this.activeReject = reject;
+            this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
+            const hasExplicitStdin = !options.debug && options.stdin !== undefined;
+            this.activeExplicitStdinCleanup?.();
+            let explicitStdinCleaned = false;
+            const cleanupExplicitStdin = () => {
+                if (!hasExplicitStdin || explicitStdinCleaned)
+                    return;
+                explicitStdinCleaned = true;
+                if (this.activeExplicitStdinCleanup === cleanupExplicitStdin) {
+                    this.activeExplicitStdinCleanup = null;
+                }
+                this.resetStdinState();
+            };
+            if (hasExplicitStdin) {
+                this.resetStdinState();
+                this.activeExplicitStdinCleanup = cleanupExplicitStdin;
+            }
+            let onAbort;
+            let timeout;
+            let activePhase = 'compile';
+            const armTimeout = (phase) => {
+                activePhase = phase;
+                if (timeout !== undefined)
+                    clearTimeout(timeout);
+                const timeoutMs = phase === 'compile' ? limits.compileTimeoutMs : limits.runTimeoutMs;
+                timeout = setTimeout(() => {
+                    if (this.activeRunSignalCleanup !== cleanupSignal ||
+                        this.worker !== worker ||
+                        _uid !== this.uid) {
+                        return;
+                    }
+                    this.terminate(new TimeoutError(`Go ${phase} timed out after ${timeoutMs} ms`, {
+                        phase,
+                        runtimeId: 'GO',
+                        timeoutMs
+                    }));
+                }, timeoutMs);
+            };
+            let signalCleanedUp = false;
+            const cleanupSignal = () => {
+                if (signalCleanedUp)
+                    return;
+                signalCleanedUp = true;
+                if (signal && onAbort) {
+                    try {
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    catch {
+                        // Cleanup must not replace the execution result.
+                    }
+                }
+                if (timeout !== undefined)
+                    clearTimeout(timeout);
+                if (this.activeRunSignalCleanup === cleanupSignal) {
+                    this.activeRunSignalCleanup = null;
+                }
+            };
+            const cleanup = () => {
+                cleanupSignal();
+                cleanupExplicitStdin();
+            };
+            const loadSignalCleanup = this.activeLoadSignalCleanup;
+            this.activeLoadSignalCleanup = null;
+            loadSignalCleanup?.();
+            const operation = this.workerSession.beginRun(worker, (reason) => {
+                cleanup();
+                reject(reason);
+            });
             const handler = (event) => {
-                if (!this.worker)
-                    return reject('Worker not loaded');
-                if (_uid !== this.uid)
-                    return (this.worker.onmessage = null);
-                const { output, results, error, buffer, diagnostic, progress } = event.data;
-                if (buffer) {
+                if (this.worker !== worker || worker.onmessage !== handler || _uid !== this.uid) {
+                    cleanup();
+                    if (worker.onmessage === handler)
+                        worker.onmessage = null;
+                    return;
+                }
+                const { output, results, error, buffer, diagnostic, progress, debugEvent, phase } = event.data;
+                if (phase === 'compile' || phase === 'execute') {
+                    if (phase !== activePhase)
+                        armTimeout(phase);
+                }
+                if (buffer && !hasExplicitStdin) {
                     this.waitingForInput = true;
+                    if (!prepare)
+                        reportWorkerInputReady(_prog, 'Go runtime ready for input');
                     this.flushPendingInput();
                 }
-                if (progress && typeof progress.percent === 'number') {
-                    _prog?.set?.(Math.max(0, Math.min(progress.percent / 100, 1)));
-                }
+                reportWorkerProgress(_prog, progress);
                 if (output)
                     this.output(output);
                 if (diagnostic)
                     this.oncompilerdiagnostic?.(diagnostic);
+                if (debugEvent)
+                    this.ondebug?.(debugEvent);
                 if (results) {
+                    cleanup();
+                    if (worker.onmessage === handler)
+                        worker.onmessage = null;
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
-                    this.activeReject = null;
+                    this.workerSession.complete(operation);
+                    this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
                 if (error) {
+                    cleanup();
+                    if (worker.onmessage === handler)
+                        worker.onmessage = null;
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
-                    this.activeReject = null;
+                    this.workerSession.complete(operation);
+                    this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
             };
-            this.worker.onmessage = handler;
+            onAbort = signal
+                ? () => {
+                    if (this.activeRunSignalCleanup !== cleanupSignal ||
+                        this.worker !== worker ||
+                        worker.onmessage !== handler ||
+                        _uid !== this.uid) {
+                        cleanup();
+                        return;
+                    }
+                    this.terminate(signal.reason ?? new DOMException('Go execution aborted', 'AbortError'));
+                }
+                : undefined;
+            this.activeRunSignalCleanup = cleanupSignal;
+            worker.onmessage = handler;
+            armTimeout('compile');
+            if (signal && onAbort) {
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+            }
+            if (this.worker !== worker || worker.onmessage !== handler || _uid !== this.uid)
+                return;
             this.begin = Date.now();
-            this.worker.postMessage({
-                code,
-                prepare,
-                buffer: this.buffer,
-                args: programArgs,
-                target,
-                log: _log
-            });
+            try {
+                worker.postMessage({
+                    code,
+                    prepare,
+                    buffer: this.buffer,
+                    debugBuffer: this.debugBuffer,
+                    stdin: options.stdin,
+                    args: programArgs,
+                    target,
+                    log: _log,
+                    debug: !!options.debug,
+                    breakpoints: [...(options.breakpoints || [])],
+                    pauseOnEntry: !!options.pauseOnEntry,
+                    runtimeLimits: limits
+                });
+            }
+            catch (error) {
+                cleanup();
+                if (worker.onmessage === handler)
+                    worker.onmessage = null;
+                this.workerSession.complete(operation);
+                this.exit = true;
+                reject(error);
+            }
         });
     }
+    debugCommand(command) {
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, command === 'stepInto' ? 2 : command === 'nextLine' ? 3 : command === 'stepOut' ? 4 : 1);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.ondebug?.({ type: 'resume', command });
+    }
+    setBreakpoints(lines) {
+        const control = new Int32Array(this.debugBuffer);
+        const next = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))]
+            .sort((left, right) => left - right)
+            .slice(0, Math.max(0, control.length - 4));
+        for (let index = 4; index < control.length; index += 1) {
+            Atomics.store(control, index, next[index - 4] || 0);
+        }
+        Atomics.store(control, 3, next.length);
+        Atomics.add(control, 2, 1);
+    }
     kill() {
         this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
+    terminate(reason = 'Process terminated') {
+        const loadSignalCleanup = this.activeLoadSignalCleanup;
+        this.activeLoadSignalCleanup = null;
+        loadSignalCleanup?.();
+        const runSignalCleanup = this.activeRunSignalCleanup;
+        this.activeRunSignalCleanup = null;
+        runSignalCleanup?.();
         this.waitingForInput = false;
         this.pendingEof = false;
         this.uid += 1;
-        this.worker?.terminate?.();
-        delete this.worker;
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.workerSession.terminate(reason);
         this.exit = true;
     }
     async clear() {
-        this.pendingInput = [];
-        this.waitingForInput = false;
-        this.pendingEof = false;
+        this.resetStdinState();
         if (this.worker)
             this.worker.onmessage = null;
-        resetBufferedStdin(this.buffer);
-        if (!this.exit) {
+        new Int32Array(this.debugBuffer).fill(0);
+        if (!this.exit || this.activeLoadSignalCleanup) {
             this.terminate();
         }
     }

package/dist/playground/goDebugInstrumentation.d.ts

@@ -0,0 +1 @@
+export declare function instrumentGoDebugSource(source: string): string;