wasm-idle 0.7.2 → 1.0.0

package/dist/playground/python.js

@@ -1,17 +1,25 @@
 import { WorkerAssetBridge } from './assetBridge';
 import { resolveRuntimeAssetConfig } from './assets';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
+import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerProgress } from './workerProgress';
+import { BusyError, TimeoutError, resolveExecutionLimits } from '@wasm-idle/core';
+const debugBreakpointBufferInts = 1028;
+const abortReason = (signal, phase) => signal.reason !== undefined
+    ? signal.reason
+    : new DOMException(phase === 'startup' ? 'Python runtime startup aborted' : 'Python execution aborted', 'AbortError');
 class Python {
     ts = Date.now();
     output = null;
     ondebug;
     image;
     worker = null;
-    buffer = new SharedArrayBuffer(1024);
-    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
-    watchBuffer = new SharedArrayBuffer(1024);
-    watchResultBuffer = new SharedArrayBuffer(1024);
-    interruptBuffer = new SharedArrayBuffer(1);
+    buffer = createWasmIdleSharedBuffer(1024);
+    debugBuffer = createWasmIdleSharedBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
+    watchBuffer = createWasmIdleSharedBuffer(1024);
+    watchResultBuffer = createWasmIdleSharedBuffer(1024);
+    interruptBuffer = createWasmIdleSharedBuffer(1);
     pendingInput = [];
     begin = 0;
     elapse = 0;
@@ -20,48 +28,264 @@ class Python {
     pendingEof = false;
     exit = true;
     assetBridge = null;
-    activeReject = null;
-    load(runtimeAssets = '', code = '', log = true, _args = [], _options = {}, progress) {
-        return new Promise(async (resolve, reject) => {
-            this.pendingInput = [];
+    activeOperation = null;
+    workerSession = new WorkerSession({
+        label: 'Python',
+        onDispose: (worker) => {
+            if (this.worker !== worker)
+                return;
+            delete this.worker;
+            this.assetBridge?.dispose();
+            this.assetBridge = null;
+            this.exit = true;
             this.waitingForInput = false;
             this.pendingEof = false;
-            const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
-            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
-            if (needsWorkerReset && this.worker) {
-                this.worker.terminate();
-                delete this.worker;
-                this.assetBridge = null;
+            this.ondebug?.({ type: 'stop' });
+        }
+    });
+    beginOperation(phase) {
+        if (this.activeOperation) {
+            throw new BusyError('Python runtime already has an active operation', {
+                runtimeId: 'PYTHON3',
+                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;
+        for (const cleanup of operation.cleanups.splice(0)) {
+            try {
+                cleanup();
             }
-            if (!this.worker) {
-                this.worker = new (await import('./worker/python?worker')).default();
-                this.assetBridge = new WorkerAssetBridge(this.worker, 'python', assetConfig, progress);
-                this.worker.onmessage = (event) => {
-                    if (this.assetBridge?.handleMessage(event))
+            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;
+    }
+    cancelOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        operation.cancelled = true;
+        operation.cancellationReason = reason;
+        this.activeOperation = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.exit = true;
+        this.workerSession.terminate(reason);
+        this.cleanupOperation(operation);
+    }
+    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);
+        }
+    }
+    bindStartupTimeout(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;
+                this.cancelOperation(operation, new TimeoutError(`Python startup timed out after ${timeoutMs} ms`, {
+                    phase: 'startup',
+                    runtimeId: 'PYTHON3',
+                    timeoutMs
+                }));
+            }, timeoutMs);
+            if (operation.cleanedUp)
+                clearTimeout(timeout);
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+        }
+    }
+    load(runtimeAssets = '', code = '', log = true, _args = [], options = {}, progress) {
+        let operation;
+        try {
+            operation = this.beginOperation('startup');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let limits;
+        let signal;
+        try {
+            signal = options.signal;
+            limits = resolveExecutionLimits(options.limits);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(this.releaseBeforeSession(operation, 'Python runtime startup cancelled'));
+            }
+            if (signal?.aborted) {
+                return Promise.reject(this.releaseBeforeSession(operation, abortReason(signal, 'startup')));
+            }
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(operation, error));
+        }
+        const loading = this.workerSession.load(async (resolve, reject) => {
+            const resolveOperation = () => {
+                if (!this.releaseOperation(operation))
+                    return;
+                resolve();
+                this.cleanupOperation(operation);
+            };
+            const rejectOperation = (reason) => {
+                if (!this.releaseOperation(operation))
+                    return;
+                reject(reason);
+                this.cleanupOperation(operation);
+            };
+            try {
+                if (!this.isOperationActive(operation))
+                    return;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                const assetConfig = resolveRuntimeAssetConfig('python', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+                if (!this.isOperationActive(operation))
+                    return;
+                const needsWorkerReset = !this.worker ||
+                    !this.assetBridge ||
+                    !this.assetBridge.matches(assetConfig, limits.maxAssetBytes);
+                if (needsWorkerReset && this.worker)
+                    this.workerSession.reset();
+                if (!this.isOperationActive(operation))
+                    return;
+                if (!this.worker) {
+                    const WorkerConstructor = (await import('./worker/python?worker'))
+                        .default;
+                    if (!this.isOperationActive(operation))
+                        return;
+                    const worker = new WorkerConstructor();
+                    if (!this.isOperationActive(operation)) {
+                        worker.terminate();
                         return;
-                    if (event.data?.load)
-                        resolve();
-                    if (event.data?.error)
-                        reject(event.data.error);
-                };
-                this.worker.postMessage({
-                    load: true,
-                    log,
-                    code,
-                    assets: {
-                        baseUrl: assetConfig.baseUrl,
-                        useAssetBridge: assetConfig.useAssetBridge
                     }
-                });
+                    this.worker = worker;
+                    this.workerSession.attach(worker);
+                    const assetBridge = new WorkerAssetBridge(worker, 'python', assetConfig, progress, limits.maxAssetBytes);
+                    if (!this.isOperationActive(operation) || this.worker !== worker) {
+                        assetBridge.dispose();
+                        return;
+                    }
+                    this.assetBridge = assetBridge;
+                    let handler;
+                    handler = (event) => {
+                        if (this.worker !== worker || worker.onmessage !== handler)
+                            return;
+                        try {
+                            if (this.assetBridge?.handleMessage(event))
+                                return;
+                            if (!this.isOperationActive(operation))
+                                return;
+                            reportWorkerProgress(progress, event.data?.progress);
+                            if (event.data?.load) {
+                                progress?.set?.(1);
+                                resolveOperation();
+                                return;
+                            }
+                            if (event.data?.error !== undefined)
+                                rejectOperation(event.data.error);
+                        }
+                        catch (error) {
+                            if (this.isOperationActive(operation))
+                                rejectOperation(error);
+                            else
+                                this.workerSession.terminate(error);
+                        }
+                    };
+                    worker.onmessage = handler;
+                    worker.postMessage({
+                        load: true,
+                        log,
+                        code,
+                        assets: {
+                            baseUrl: assetConfig.baseUrl,
+                            maxAssetBytes: limits.maxAssetBytes,
+                            useAssetBridge: assetConfig.useAssetBridge
+                        }
+                    });
+                    return;
+                }
+                const worker = this.worker;
+                if (!this.assetBridge) {
+                    rejectOperation('Worker asset bridge unavailable');
+                    return;
+                }
+                this.assetBridge.rebind(worker, assetConfig, progress, limits.maxAssetBytes);
+                progress?.set?.(1);
+                if (!this.isOperationActive(operation) || this.worker !== worker)
+                    return;
+                resolveOperation();
             }
-            else {
-                if (!this.assetBridge)
-                    return reject('Worker asset bridge unavailable');
-                this.assetBridge.rebind(this.worker, assetConfig, progress);
-                this.worker.postMessage({ log });
-                resolve();
+            catch (error) {
+                rejectOperation(error);
             }
         });
+        const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs);
+        this.bindStartupTimeout(operation, timeoutMs);
+        this.bindAbortSignal(operation, signal);
+        return loading.finally(() => {
+            this.releaseOperation(operation);
+            this.cleanupOperation(operation);
+        });
     }
     write(input) {
         this.pendingInput.push(input);
@@ -86,67 +310,177 @@ class Python {
         }
     }
     run(code, prepare, _log = true, _prog, _args = [], options = {}) {
+        let activeOperation;
+        try {
+            activeOperation = this.beginOperation('execute');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const worker = this.worker;
+        let signal;
+        let debug;
+        let breakpoints;
+        let stdin;
+        let pauseOnEntry;
+        let activePath;
+        let debugPath;
+        let workspaceFiles;
+        try {
+            signal = options.signal;
+            debug = !!options.debug;
+            breakpoints = [...(options.breakpoints || [])];
+            stdin = options.stdin;
+            pauseOnEntry = !!options.pauseOnEntry;
+            activePath = options.activePath;
+            debugPath = options.debugPath;
+            workspaceFiles = options.workspaceFiles;
+            if (!this.isOperationActive(activeOperation)) {
+                return Promise.reject(this.releaseBeforeSession(activeOperation, 'Python execution cancelled'));
+            }
+            if (debug)
+                requireSharedArrayBuffer('Python debugging');
+            this.setBreakpoints(debug ? breakpoints : []);
+        }
+        catch (error) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, error));
+        }
+        if (!worker || this.worker !== worker) {
+            return Promise.reject(this.releaseBeforeSession(activeOperation, 'Worker not loaded'));
+        }
         this.exit = false;
-        return new Promise(async (resolve, reject) => {
-            if (!this.worker)
-                return reject('Worker not loaded');
-            this.activeReject = reject;
-            const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
-            const handler = (event) => {
-                if (this.assetBridge?.handleMessage(event))
+        const running = new Promise((resolve, reject) => {
+            const workerOperation = this.workerSession.beginRun(worker, reject);
+            this.bindAbortSignal(activeOperation, signal);
+            if (!this.isOperationActive(activeOperation))
+                return;
+            const interrupt = new Uint8Array(this.interruptBuffer), runUid = ++this.uid;
+            let handler;
+            const ownsRun = () => this.isOperationActive(activeOperation) &&
+                this.worker === worker &&
+                worker.onmessage === handler &&
+                runUid === this.uid;
+            const settleRunState = () => {
+                this.elapse = Date.now() - this.begin;
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+            };
+            const claimRun = () => {
+                if (!ownsRun())
+                    return false;
+                settleRunState();
+                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 (!this.worker)
-                    return reject('Worker not loaded');
-                if (_uid !== this.uid)
-                    return (this.worker.onmessage = null);
-                const { output, results, log, error, buffer, type, data: payload, debugEvent } = event.data;
-                if (buffer) {
-                    this.waitingForInput = true;
-                    this.flushPendingInput();
                 }
-                if (type === 'img' && payload)
-                    this.image?.(payload);
-                if (output)
-                    this.output(output);
-                if (debugEvent)
-                    this.ondebug?.(debugEvent);
-                if (results) {
-                    this.elapse = Date.now() - this.begin;
-                    this.exit = true;
-                    this.waitingForInput = false;
-                    this.pendingEof = false;
-                    this.activeReject = null;
-                    this.ondebug?.({ type: 'stop' });
-                    resolve(results);
+                if (!claimRun())
+                    return;
+                reject(reason);
+            };
+            handler = (event) => {
+                if (!ownsRun())
+                    return;
+                try {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    const { output, results, log, error, buffer, type, data: payload, debugEvent } = event.data;
+                    reportWorkerProgress(_prog, event.data?.progress);
+                    if (!ownsRun())
+                        return;
+                    if (buffer) {
+                        if (!prepare) {
+                            _prog?.report?.({
+                                kind: 'ready',
+                                state: 'waiting-input',
+                                reason: 'stdin-request',
+                                label: 'Python program is waiting for input'
+                            });
+                        }
+                        this.waitingForInput = true;
+                        this.flushPendingInput();
+                        if (!ownsRun())
+                            return;
+                    }
+                    if (type === 'img' && payload)
+                        this.image?.(payload);
+                    if (!ownsRun())
+                        return;
+                    if (output)
+                        this.output?.(output);
+                    if (!ownsRun())
+                        return;
+                    if (debugEvent)
+                        this.ondebug?.(debugEvent);
+                    if (!ownsRun())
+                        return;
+                    if (log)
+                        console.log(log);
+                    if (results !== undefined) {
+                        this.ondebug?.({ type: 'stop' });
+                        if (!claimRun())
+                            return;
+                        resolve(results);
+                        return;
+                    }
+                    if (error !== undefined) {
+                        this.ondebug?.({ type: 'stop' });
+                        failRun(error);
+                    }
                 }
-                if (log)
-                    console.log(log);
-                if (error) {
-                    this.elapse = Date.now() - this.begin;
-                    this.exit = true;
-                    this.waitingForInput = false;
-                    this.pendingEof = false;
-                    this.activeReject = null;
-                    this.ondebug?.({ type: 'stop' });
-                    reject(error);
+                catch (error) {
+                    failRun(error, true);
                 }
             };
             interrupt[0] = 0;
-            this.worker.onmessage = handler;
+            worker.onmessage = handler;
             this.begin = Date.now();
-            this.worker.postMessage({
-                code,
-                prepare,
-                buffer: this.buffer,
-                debugBuffer: this.debugBuffer,
-                watchBuffer: this.watchBuffer,
-                watchResultBuffer: this.watchResultBuffer,
-                interrupt: this.interruptBuffer,
-                context: {},
-                debug: !!options.debug,
-                breakpoints: [...(options.breakpoints || [])],
-                pauseOnEntry: !!options.pauseOnEntry
-            });
+            try {
+                worker.postMessage({
+                    code,
+                    prepare,
+                    buffer: this.buffer,
+                    debugBuffer: this.debugBuffer,
+                    watchBuffer: this.watchBuffer,
+                    watchResultBuffer: this.watchResultBuffer,
+                    interrupt: this.interruptBuffer,
+                    context: {},
+                    stdin,
+                    debug,
+                    breakpoints,
+                    pauseOnEntry,
+                    activePath,
+                    debugPath,
+                    workspaceFiles
+                });
+            }
+            catch (error) {
+                failRun(error);
+            }
+        });
+        return running.finally(() => {
+            if (this.isOperationActive(activeOperation)) {
+                this.releaseOperation(activeOperation);
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+            }
+            this.cleanupOperation(activeOperation);
         });
     }
     debugCommand(command) {
@@ -156,6 +490,17 @@ class Python {
         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);
+    }
     async debugEvaluate(expression) {
         if (!this.worker)
             throw new Error('Worker not loaded');
@@ -172,9 +517,12 @@ class Python {
     kill() {
         this.terminate();
     }
-    terminate() {
-        this.activeReject?.('Process terminated');
-        this.activeReject = null;
+    terminate(reason = 'Process terminated') {
+        const activeOperation = this.activeOperation;
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, reason);
+            return;
+        }
         this.waitingForInput = false;
         this.pendingEof = false;
         this.uid += 1;
@@ -182,9 +530,7 @@ class Python {
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
-        this.worker?.terminate?.();
-        delete this.worker;
-        this.assetBridge = null;
+        this.workerSession.terminate(reason);
         this.exit = true;
     }
     async clear() {
@@ -201,9 +547,7 @@ class Python {
         debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));
         if (!this.exit) {
-            this.worker?.terminate?.();
-            delete this.worker;
-            this.assetBridge = null;
+            this.workerSession.terminate();
             this.exit = true;
         }
     }

package/dist/playground/pythonPackageLock.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedPythonPackageLock {
+    lock: Record<string, unknown>;
+    packageAssets: Set<string>;
+}
+export declare function parsePythonPackageLock(bytes: Uint8Array): ParsedPythonPackageLock;
+export declare const readPythonPackageAssets: (bytes: Uint8Array) => Set<string>;

package/dist/playground/pythonPackageLock.js

@@ -0,0 +1,56 @@
+import { ProtocolError } from '@wasm-idle/core';
+const strictDecoder = new TextDecoder('utf-8', { fatal: true });
+const pythonPackageAssetPattern = /^[A-Za-z0-9][A-Za-z0-9._+-]*\.(?:whl|tar|zip)$/u;
+const MAX_PYTHON_PACKAGE_ASSETS = 4096;
+const MAX_PYTHON_PACKAGE_ASSET_NAME_LENGTH = 1024;
+export function parsePythonPackageLock(bytes) {
+    let lock;
+    try {
+        lock = JSON.parse(strictDecoder.decode(bytes));
+    }
+    catch {
+        throw new ProtocolError('Python runtime lock file is not valid UTF-8 JSON', {
+            phase: 'asset',
+            runtimeId: 'python'
+        });
+    }
+    if (typeof lock !== 'object' ||
+        lock === null ||
+        !('packages' in lock) ||
+        typeof lock.packages !== 'object' ||
+        lock.packages === null ||
+        Array.isArray(lock.packages)) {
+        throw new ProtocolError('Python runtime lock file has an invalid packages map', {
+            phase: 'asset',
+            runtimeId: 'python'
+        });
+    }
+    const entries = Object.values(lock.packages);
+    if (entries.length > MAX_PYTHON_PACKAGE_ASSETS) {
+        throw new ProtocolError('Python runtime lock file has too many package assets', {
+            phase: 'asset',
+            runtimeId: 'python'
+        });
+    }
+    const packageAssets = new Set();
+    for (const entry of entries) {
+        if (typeof entry !== 'object' || entry === null || !('file_name' in entry)) {
+            throw new ProtocolError('Python runtime lock file has an invalid package entry', {
+                phase: 'asset',
+                runtimeId: 'python'
+            });
+        }
+        const asset = entry.file_name;
+        if (typeof asset !== 'string' ||
+            asset.length > MAX_PYTHON_PACKAGE_ASSET_NAME_LENGTH ||
+            !pythonPackageAssetPattern.test(asset)) {
+            throw new ProtocolError('Python runtime lock file has an unsafe package asset name', {
+                phase: 'asset',
+                runtimeId: 'python'
+            });
+        }
+        packageAssets.add(asset);
+    }
+    return { lock: lock, packageAssets };
+}
+export const readPythonPackageAssets = (bytes) => parsePythonPackageLock(bytes).packageAssets;