wasm-idle 1.0.7 → 1.0.9

package/dist/playground/postgresql.js

@@ -0,0 +1,543 @@
+import { resolvePostgresqlRuntimeModuleUrl } from './assets';
+import { WorkerSession } from './workerSession';
+import { reportWorkerProgress } from './workerProgress';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+const OUTPUT_ENCODER = new TextEncoder();
+const abortReason = (signal, phase) => signal.reason !== undefined
+    ? signal.reason
+    : new DOMException(phase === 'startup'
+        ? 'PostgreSQL runtime startup aborted'
+        : 'PostgreSQL execution aborted', 'AbortError');
+class Postgresql {
+    output = null;
+    worker = null;
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    moduleUrl = '';
+    oncompilerdiagnostic;
+    activeOperation = null;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('PostgreSQL sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'POSTGRESQL',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'PostgreSQL',
+        onDispose: (worker) => {
+            if (this.worker !== worker)
+                return;
+            delete this.worker;
+            this.exit = true;
+        }
+    });
+    beginOperation(phase) {
+        if (this.disposed) {
+            throw new RuntimeConfigurationError('PostgreSQL sandbox is disposed', {
+                phase: 'dispose',
+                runtimeId: 'POSTGRESQL'
+            });
+        }
+        if (this.activeOperation) {
+            throw new BusyError('PostgreSQL runtime already has an active operation', {
+                runtimeId: 'POSTGRESQL',
+                phase: this.activeOperation.phase
+            });
+        }
+        const operation = {
+            token: Symbol(phase),
+            phase,
+            cancelled: false,
+            cleanedUp: false,
+            cleanups: []
+        };
+        this.activeOperation = operation;
+        return operation;
+    }
+    isOperationActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.cancelled;
+    }
+    releaseOperation(operation) {
+        if (this.activeOperation?.token !== operation.token)
+            return false;
+        this.activeOperation = null;
+        return true;
+    }
+    cleanupOperation(operation) {
+        if (operation.cleanedUp)
+            return;
+        operation.cleanedUp = true;
+        const cleanups = operation.cleanups.splice(0);
+        for (const cleanup of cleanups) {
+            try {
+                cleanup();
+            }
+            catch {
+                // Caller-owned lifecycle cleanup must not replace the operation result.
+            }
+        }
+    }
+    releaseBeforeSession(operation, reason) {
+        const outcome = operation.cancelled ? operation.cancellationReason : reason;
+        this.releaseOperation(operation);
+        this.cleanupOperation(operation);
+        return outcome;
+    }
+    bindPreSessionAbort(operation, signal) {
+        if (!signal || !this.isOperationActive(operation))
+            return () => undefined;
+        let registered = false;
+        let unbound = false;
+        const unbind = () => {
+            if (unbound)
+                return;
+            unbound = true;
+            if (registered)
+                signal.removeEventListener('abort', onAbort);
+        };
+        const onAbort = () => {
+            if (!this.isOperationActive(operation))
+                return;
+            let reason;
+            try {
+                reason = abortReason(signal, operation.phase);
+            }
+            catch (error) {
+                reason = error;
+            }
+            operation.cancelled = true;
+            operation.cancellationReason = reason;
+            this.releaseOperation(operation);
+            this.cleanupOperation(operation);
+        };
+        operation.cleanups.push(unbind);
+        try {
+            registered = true;
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            if (this.isOperationActive(operation)) {
+                operation.cancelled = true;
+                operation.cancellationReason = error;
+                this.releaseOperation(operation);
+                this.cleanupOperation(operation);
+            }
+        }
+        return unbind;
+    }
+    bindAbortSignal(operation, signal) {
+        if (!signal || !this.isOperationActive(operation))
+            return;
+        let registered = false;
+        const onAbort = () => {
+            if (!this.isOperationActive(operation))
+                return;
+            let reason;
+            try {
+                reason = abortReason(signal, operation.phase);
+            }
+            catch (error) {
+                reason = error;
+            }
+            this.cancelOperation(operation, reason);
+        };
+        operation.cleanups.push(() => {
+            if (registered)
+                signal.removeEventListener('abort', onAbort);
+        });
+        try {
+            registered = true;
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+        }
+    }
+    bindOperationTimeout(operation, timeoutMs) {
+        if (!this.isOperationActive(operation))
+            return;
+        let timeout;
+        operation.cleanups.push(() => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+        });
+        try {
+            timeout = setTimeout(() => {
+                if (!this.isOperationActive(operation))
+                    return;
+                const label = operation.phase === 'startup' ? 'startup' : 'execution';
+                this.cancelOperation(operation, new TimeoutError(`PostgreSQL ${label} timed out after ${timeoutMs} ms`, {
+                    phase: operation.phase,
+                    runtimeId: 'POSTGRESQL',
+                    timeoutMs
+                }));
+            }, timeoutMs);
+            if (operation.cleanedUp)
+                clearTimeout(timeout);
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+        }
+    }
+    cancelOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.cancellationReason = reason;
+        this.activeOperation = null;
+        this.uid += 1;
+        this.exit = true;
+        this.workerSession.terminate(reason);
+        this.cleanupOperation(operation);
+    }
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        let activeOperation;
+        try {
+            activeOperation = this.beginOperation('startup');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let limits;
+        let signal;
+        let unbindPreSessionAbort = () => undefined;
+        try {
+            signal = options.signal;
+            unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation)) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL runtime startup cancelled'));
+            }
+            limits = resolveExecutionLimits(options.limits);
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL runtime startup cancelled'));
+            }
+            unbindPreSessionAbort();
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, error));
+        }
+        if (!this.isOperationActive(activeOperation)) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL runtime startup cancelled'));
+        }
+        const loading = this.workerSession.load(async (resolve, reject) => {
+            const resolveOperation = () => {
+                if (!this.releaseOperation(activeOperation))
+                    return;
+                resolve();
+                this.cleanupOperation(activeOperation);
+            };
+            const rejectOperation = (reason) => {
+                if (!this.releaseOperation(activeOperation))
+                    return;
+                reject(reason);
+                this.cleanupOperation(activeOperation);
+            };
+            try {
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                const nextModuleUrl = resolvePostgresqlRuntimeModuleUrl(runtimeAssets, currentUrl);
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                if (this.worker && this.moduleUrl !== nextModuleUrl)
+                    this.workerSession.reset();
+                this.moduleUrl = nextModuleUrl;
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                if (!this.worker) {
+                    const WorkerConstructor = (await import('./worker/postgresql?worker')).default;
+                    if (!this.isOperationActive(activeOperation))
+                        return;
+                    const worker = new WorkerConstructor();
+                    if (!this.isOperationActive(activeOperation)) {
+                        try {
+                            worker.terminate();
+                        }
+                        catch {
+                            // The unattached worker is already detached.
+                        }
+                        return;
+                    }
+                    this.worker = worker;
+                    this.workerSession.attach(worker);
+                    let handler;
+                    handler = (event) => {
+                        if (!this.isOperationActive(activeOperation) ||
+                            this.worker !== worker ||
+                            worker.onmessage !== handler) {
+                            return;
+                        }
+                        try {
+                            if (event.data?.load) {
+                                progress?.set?.(1);
+                                if (!this.isOperationActive(activeOperation) ||
+                                    this.worker !== worker ||
+                                    worker.onmessage !== handler) {
+                                    return;
+                                }
+                                resolveOperation();
+                                return;
+                            }
+                            if (event.data?.error !== undefined) {
+                                rejectOperation(event.data.error);
+                            }
+                        }
+                        catch (error) {
+                            rejectOperation(error);
+                        }
+                    };
+                    worker.onmessage = handler;
+                    worker.postMessage({
+                        load: true,
+                        moduleUrl: this.moduleUrl,
+                        log: _log
+                    });
+                }
+                else {
+                    const worker = this.worker;
+                    progress?.set?.(1);
+                    if (!this.isOperationActive(activeOperation) || this.worker !== worker)
+                        return;
+                    resolveOperation();
+                }
+            }
+            catch (error) {
+                rejectOperation(error);
+            }
+        });
+        const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs);
+        this.bindOperationTimeout(activeOperation, timeoutMs);
+        this.bindAbortSignal(activeOperation, signal);
+        return loading.finally(() => {
+            this.releaseOperation(activeOperation);
+            this.cleanupOperation(activeOperation);
+        });
+    }
+    write() { }
+    eof() { }
+    run(code, prepare, _log = true, _prog, _args = [], options = {}) {
+        let activeOperation;
+        try {
+            activeOperation = this.beginOperation('execute');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let limits;
+        let signal;
+        let unbindPreSessionAbort = () => undefined;
+        let workspace;
+        let stdin;
+        try {
+            signal = options.signal;
+            unbindPreSessionAbort = this.bindPreSessionAbort(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation)) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL execution cancelled'));
+            }
+            limits = resolveExecutionLimits(options.limits);
+            workspace = validateExecutionWorkspace(code, options.workspaceFiles ?? [], options.activePath ?? 'main.sql', {
+                ...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)
+            });
+            stdin = options.stdin;
+            if (!this.isOperationActive(activeOperation) || signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL execution cancelled'));
+            }
+            unbindPreSessionAbort();
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, error));
+        }
+        if (!this.isOperationActive(activeOperation)) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'PostgreSQL execution cancelled'));
+        }
+        const worker = this.worker;
+        if (!worker) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Worker not loaded'));
+        }
+        this.exit = false;
+        const running = new Promise((resolve, reject) => {
+            const runUid = ++this.uid;
+            let diagnosticCount = 0;
+            let outputBytes = 0;
+            const workerOperation = this.workerSession.beginRun(worker, reject);
+            const timeoutMs = Math.min(2_147_483_647, limits.compileTimeoutMs + limits.runTimeoutMs);
+            this.bindOperationTimeout(activeOperation, timeoutMs);
+            this.bindAbortSignal(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation))
+                return;
+            let handler;
+            const ownsRun = () => this.isOperationActive(activeOperation) &&
+                this.worker === worker &&
+                worker.onmessage === handler &&
+                runUid === this.uid;
+            const claimRun = () => {
+                if (!ownsRun())
+                    return false;
+                this.elapse = Date.now() - this.begin;
+                this.exit = true;
+                this.workerSession.complete(workerOperation);
+                this.releaseOperation(activeOperation);
+                this.cleanupOperation(activeOperation);
+                try {
+                    if (worker.onmessage === handler)
+                        worker.onmessage = null;
+                }
+                catch {
+                    // Handler cleanup must not replace the execution result.
+                }
+                return true;
+            };
+            const failRun = (reason, disposeWorker = false) => {
+                if (disposeWorker) {
+                    if (!ownsRun())
+                        return;
+                    this.cancelOperation(activeOperation, reason);
+                    return;
+                }
+                if (!claimRun())
+                    return;
+                reject(reason);
+            };
+            handler = (event) => {
+                if (this.worker !== worker ||
+                    worker.onmessage !== handler ||
+                    !this.isOperationActive(activeOperation)) {
+                    return;
+                }
+                try {
+                    const { output, results, error, diagnostic, progress } = event.data;
+                    reportWorkerProgress(_prog, progress);
+                    if (!ownsRun())
+                        return;
+                    if (typeof output === 'string' && output.length > 0) {
+                        const actual = outputBytes + OUTPUT_ENCODER.encode(output).byteLength;
+                        if (actual > limits.maxOutputBytes) {
+                            failRun(new OutputLimitError(`PostgreSQL output exceeded ${limits.maxOutputBytes} bytes`, {
+                                actual,
+                                limit: limits.maxOutputBytes,
+                                phase: 'execute',
+                                runtimeId: 'POSTGRESQL'
+                            }), true);
+                            return;
+                        }
+                        outputBytes = actual;
+                        this.output?.(output);
+                        if (!ownsRun())
+                            return;
+                    }
+                    if (diagnostic !== undefined) {
+                        const actual = diagnosticCount + 1;
+                        if (actual > limits.maxDiagnostics) {
+                            failRun(new DiagnosticLimitError(`PostgreSQL diagnostics exceeded ${limits.maxDiagnostics} messages`, {
+                                actual,
+                                limit: limits.maxDiagnostics,
+                                phase: 'execute',
+                                runtimeId: 'POSTGRESQL'
+                            }), true);
+                            return;
+                        }
+                        diagnosticCount = actual;
+                        this.oncompilerdiagnostic?.(diagnostic);
+                        if (!ownsRun())
+                            return;
+                    }
+                    if (results !== undefined) {
+                        if (!claimRun())
+                            return;
+                        resolve(results);
+                        return;
+                    }
+                    if (error !== undefined)
+                        failRun(error);
+                }
+                catch (error) {
+                    failRun(error, true);
+                }
+            };
+            worker.onmessage = handler;
+            this.begin = Date.now();
+            try {
+                worker.postMessage({
+                    code,
+                    prepare,
+                    activePath: workspace.activePath ?? 'main.sql',
+                    workspaceFiles: workspace.workspaceFiles,
+                    stdin,
+                    log: _log
+                });
+            }
+            catch (error) {
+                failRun(error);
+            }
+        });
+        return running.finally(() => {
+            if (this.releaseOperation(activeOperation))
+                this.exit = true;
+            this.cleanupOperation(activeOperation);
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const activeOperation = this.activeOperation;
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, reason);
+            return;
+        }
+        this.uid += 1;
+        this.workerSession.terminate(reason);
+        this.exit = true;
+    }
+    async clear() {
+        if (this.disposed)
+            return;
+        if (this.activeOperation) {
+            this.terminate();
+            return;
+        }
+        const worker = this.worker;
+        if (worker) {
+            try {
+                worker.onmessage = null;
+            }
+            catch {
+                // Idle handler cleanup is best effort.
+            }
+        }
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const activeOperation = this.activeOperation;
+        delete this.worker;
+        this.moduleUrl = '';
+        this.output = null;
+        this.oncompilerdiagnostic = undefined;
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, this.disposeCancellation);
+        }
+        else {
+            this.uid += 1;
+            this.workerSession.terminate(this.disposeCancellation);
+            this.exit = true;
+        }
+        return this.disposePromise;
+    }
+}
+export default Postgresql;

package/dist/playground/python.d.ts

@@ -31,6 +31,11 @@ declare class Python implements Sandbox {
     private ownsRuntimeAssetCache;
     private disposed;
     private disposal?;
+    private workerExtensionKey?;
+    /** Language executed by the shared Pyodide worker; subclasses run other Python-hosted languages. */
+    protected readonly workerLanguage: 'python' | 'hy';
+    /** Extra worker load configuration for Python-hosted languages, keyed for worker reuse. */
+    protected workerLoadExtension(_runtimeAssets: string | PlaygroundRuntimeAssets, _currentUrl: string): Record<string, unknown> | undefined;
     private readonly workerSession;
     private beginOperation;
     private isOperationActive;

package/dist/playground/python.js

@@ -34,6 +34,13 @@ class Python {
     ownsRuntimeAssetCache = true;
     disposed = false;
     disposal;
+    workerExtensionKey;
+    /** Language executed by the shared Pyodide worker; subclasses run other Python-hosted languages. */
+    workerLanguage = 'python';
+    /** Extra worker load configuration for Python-hosted languages, keyed for worker reuse. */
+    workerLoadExtension(_runtimeAssets, _currentUrl) {
+        return undefined;
+    }
     workerSession = new WorkerSession({
         label: 'Python',
         onDispose: (worker) => {
@@ -206,10 +213,13 @@ class Python {
                 this.waitingForInput = false;
                 this.pendingEof = false;
                 const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '', options.persistentCache);
+                const extension = this.workerLoadExtension(runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+                const extensionKey = JSON.stringify(extension ?? null);
                 if (!this.isOperationActive(operation))
                     return;
                 const needsWorkerReset = !this.worker ||
                     !this.assetBridge ||
+                    this.workerExtensionKey !== extensionKey ||
                     !this.assetBridge.matches(assetConfig, limits.maxAssetBytes);
                 if (needsWorkerReset && this.worker)
                     this.workerSession.reset();
@@ -226,6 +236,7 @@ class Python {
                         return;
                     }
                     this.worker = worker;
+                    this.workerExtensionKey = extensionKey;
                     this.workerSession.attach(worker);
                     const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                     if (!this.isOperationActive(operation) || this.worker !== worker) {
@@ -263,6 +274,7 @@ class Python {
                         load: true,
                         log,
                         code,
+                        ...(extension ? { extension } : {}),
                         assets: {
                             baseUrl: assetConfig.baseUrl,
                             maxAssetBytes: limits.maxAssetBytes,
@@ -464,6 +476,7 @@ class Python {
                 worker.postMessage({
                     code,
                     prepare,
+                    language: this.workerLanguage,
                     buffer: this.buffer,
                     debugBuffer: this.debugBuffer,
                     watchBuffer: this.watchBuffer,

package/dist/playground/rescript.d.ts

@@ -0,0 +1,5 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+declare class ReScript extends StaticWorkerRuntimeSandbox {
+    constructor();
+}
+export default ReScript;

package/dist/playground/rescript.js

@@ -0,0 +1,58 @@
+import { resolveReScriptRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+class ReScript extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'RESCRIPT',
+            displayName: 'ReScript',
+            defaultActivePath: 'Main.res',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:readLineSync|readFileSync)\b|\/dev\/stdin\b/
+            },
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned',
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveReScriptRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = resolved.preflightProfile;
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('ReScript runtime requires a manifest fingerprint and worker receipt.', { runtimeId: 'RESCRIPT' });
+                }
+                return resolved;
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt?.bytes ?? 0) + (profile.compilerReceipt?.bytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'RESCRIPT',
+                    displayName: 'ReScript',
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    persistentCache: context.persistentCache,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        if (progress.kind === 'asset') {
+                            loadedByAsset.set(progress.progress.assetKey, progress.progress.loadedBytes);
+                            const loadedBytes = [...loadedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                            const fraction = totalDownloadBytes > 0 ? loadedBytes / totalDownloadBytes : 0;
+                            context.reportProgress(0.04 + Math.min(1, fraction) * 0.11, `Preflighting ReScript asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { loadedBytes, totalBytes } = progress;
+                        const fraction = totalBytes > 0 ? loadedBytes / totalBytes : 0;
+                        context.reportProgress(0.15 + Math.min(1, fraction) * 0.02, 'Decompressing verified ReScript compiler');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default ReScript;