wasm-idle 0.4.0 → 0.4.1

package/dist/playground/assets.js

@@ -0,0 +1,97 @@
+import { normalizeTeaVmBaseUrl, resolveTeaVmBaseUrl } from './teavmConfig';
+export const PYTHON_RUNTIME_LOAD_ASSETS = [
+    'pyodide.asm.js',
+    'pyodide-lock.json',
+    'pyodide.asm.wasm',
+    'python_stdlib.zip'
+];
+export const JAVA_RUNTIME_LOAD_ASSETS = [
+    'compiler.wasm-runtime.js',
+    'compiler.wasm',
+    'compile-classlib-teavm.bin',
+    'runtime-classlib-teavm.bin'
+];
+const PYTHON_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/python/';
+const JAVA_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/java/';
+const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
+    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return currentUrl ? new URL(normalized, currentUrl).href : normalized;
+};
+const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
+const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
+const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolvePythonBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.python;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolvePythonBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: PYTHON_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolvePythonBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+const resolveJavaBaseUrl = (rootUrl = '', currentUrl = '') => resolveTeaVmBaseUrl(rootUrl, currentUrl);
+const resolveJavaRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolveJavaBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.java;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: currentUrl
+                ? new URL(normalizeTeaVmBaseUrl(runtimeConfig.baseUrl), currentUrl).href
+                : normalizeTeaVmBaseUrl(runtimeConfig.baseUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolveJavaBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: JAVA_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolveJavaBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
+    return runtime === 'python'
+        ? resolvePythonRuntimeAssetConfig(options, currentUrl)
+        : resolveJavaRuntimeAssetConfig(options, currentUrl);
+}

package/dist/playground/clang.d.ts

@@ -1,7 +1,9 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import type { PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 import type { Writable } from 'svelte/store';
 declare class Clang implements Sandbox {
+    language: 'C' | 'CPP';
     ts: number;
     output: any;
     ondebug?: (event: DebugSessionEvent) => void;
@@ -17,7 +19,10 @@ declare class Clang implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    constructor(language: 'C' | 'CPP');
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, _progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;

package/dist/playground/clang.js

@@ -1,5 +1,7 @@
+import { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 class Clang {
+    language;
     ts = Date.now();
     output = null;
     ondebug;
@@ -15,12 +17,16 @@ class Clang {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
-    load(path, code = '', log = true, args = [], _options = {}) {
+    constructor(language) {
+        this.language = language;
+    }
+    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, _progress) {
         return new Promise(async (resolve) => {
             this.log = log;
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
+            const path = typeof runtimeAssets === 'string' ? runtimeAssets : runtimeAssets?.rootUrl || '';
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -59,6 +65,7 @@ class Clang {
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (!this.worker)
@@ -106,7 +113,11 @@ class Clang {
                 interrupt: this.interruptBuffer,
                 context: {},
                 log,
-                args,
+                language: this.language,
+                compileArgs,
+                programArgs,
+                cppVersion: options.cppVersion,
+                cVersion: options.cVersion,
                 debug: !!options.debug,
                 breakpoints: [...(options.breakpoints || [])],
                 pauseOnEntry: !!options.pauseOnEntry

package/dist/playground/index.js

@@ -14,8 +14,10 @@ export default async function load(language) {
             sandbox = new Python();
             break;
         case 'C':
+            sandbox = new Clang('C');
+            break;
         case 'CPP':
-            sandbox = new Clang();
+            sandbox = new Clang('CPP');
             break;
         case 'JAVA':
             sandbox = new Java();

package/dist/playground/java.d.ts

@@ -1,4 +1,6 @@
-import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 declare class Java implements Sandbox {
     output: any;
@@ -14,7 +16,10 @@ declare class Java implements Sandbox {
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
-    load(path: string, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    assetBridge: WorkerAssetBridge | null;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;

package/dist/playground/java.js

@@ -1,5 +1,7 @@
+import { resolveSandboxExecutionArgs } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
-import { resolveTeaVmBaseUrl } from './teavmConfig';
 class Java {
     output = null;
     worker = null;
@@ -14,23 +16,43 @@ class Java {
     oncompilerdiagnostic;
     waitingForInput = false;
     pendingEof = false;
-    load(path, _code = '', _log = true, _args = [], _options = {}) {
+    assetBridge = null;
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
         return new Promise(async (resolve, reject) => {
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
-            this.baseUrl = resolveTeaVmBaseUrl(path, typeof window !== 'undefined' ? window.location.href : '');
+            const assetConfig = resolveRuntimeAssetConfig('java', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            this.baseUrl = assetConfig.baseUrl;
+            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+                this.assetBridge = null;
+            }
             if (!this.worker) {
                 this.worker = new (await import('./worker/java?worker')).default();
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'java', assetConfig, progress);
                 this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
                     if (event.data?.load)
                         resolve();
                     if (event.data?.error)
                         reject(event.data.error);
                 };
-                this.worker.postMessage({ load: true, baseUrl: this.baseUrl });
+                this.worker.postMessage({
+                    load: true,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
             }
             else {
+                if (!this.assetBridge)
+                    return reject('Worker asset bridge unavailable');
+                this.assetBridge.rebind(this.worker, assetConfig, progress);
                 resolve();
             }
         });
@@ -62,9 +84,12 @@ class Java {
         return new Promise((resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            const { programArgs } = resolveSandboxExecutionArgs('JAVA', args, options);
             const _uid = ++this.uid;
             this.activeReject = reject;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
@@ -101,7 +126,7 @@ class Java {
                 code,
                 prepare,
                 buffer: this.buffer,
-                args,
+                args: programArgs,
                 stdin: options.stdin || '',
                 baseUrl: this.baseUrl
             });
@@ -118,6 +143,7 @@ class Java {
         this.uid += 1;
         this.worker?.terminate?.();
         delete this.worker;
+        this.assetBridge = null;
         this.exit = true;
     }
     async clear() {

package/dist/playground/javaStdin.js

@@ -1,11 +1,238 @@
 const JAVA_STDIN_HELPER_CLASS = 'WasmIdleStdin';
+const JAVA_SCANNER_COMPAT_SENTINEL = '// wasm-idle Scanner compatibility shim';
+const JAVA_SCANNER_COMPAT_SHIM = `${JAVA_SCANNER_COMPAT_SENTINEL}
+final class Scanner implements AutoCloseable {
+    private final java.io.InputStream input;
+    private int bufferedChar = Integer.MIN_VALUE;
+    private String bufferedToken = null;
+    private boolean closed = false;
+
+    Scanner(java.io.InputStream input) {
+        this.input = input;
+    }
+
+    Scanner(String source) {
+        this(
+            new java.io.ByteArrayInputStream(
+                source != null ? source.getBytes() : new byte[0]
+            )
+        );
+    }
+
+    private void ensureOpen() {
+        if (closed) {
+            throw new IllegalStateException("Scanner closed");
+        }
+    }
+
+    private int readByteInternal() {
+        try {
+            return input.read();
+        } catch (java.io.IOException error) {
+            throw new RuntimeException(error);
+        }
+    }
+
+    private int readByte() {
+        ensureOpen();
+        if (bufferedChar != Integer.MIN_VALUE) {
+            int value = bufferedChar;
+            bufferedChar = Integer.MIN_VALUE;
+            return value;
+        }
+        return readByteInternal();
+    }
+
+    private int peekByte() {
+        ensureOpen();
+        if (bufferedChar == Integer.MIN_VALUE) {
+            bufferedChar = readByteInternal();
+        }
+        return bufferedChar;
+    }
+
+    private boolean isWhitespace(int value) {
+        return value == ' ' || value == '\\n' || value == '\\r' || value == '\\t' || value == '\\f';
+    }
+
+    private boolean skipWhitespace() {
+        int value = peekByte();
+        while (value != -1 && isWhitespace(value)) {
+            readByte();
+            value = peekByte();
+        }
+        return value != -1;
+    }
+
+    private String readTokenValue() {
+        java.lang.StringBuilder token = new java.lang.StringBuilder();
+        int value = peekByte();
+        while (value != -1 && !isWhitespace(value)) {
+            token.append((char) readByte());
+            value = peekByte();
+        }
+        return token.toString();
+    }
+
+    public boolean hasNext() {
+        ensureOpen();
+        if (bufferedToken != null) {
+            return true;
+        }
+        if (!skipWhitespace()) {
+            return false;
+        }
+        bufferedToken = readTokenValue();
+        return true;
+    }
+
+    public String next() {
+        ensureOpen();
+        if (bufferedToken != null) {
+            String token = bufferedToken;
+            bufferedToken = null;
+            return token;
+        }
+        if (!skipWhitespace()) {
+            throw new RuntimeException("No more tokens");
+        }
+        return readTokenValue();
+    }
+
+    public String nextLine() {
+        ensureOpen();
+        java.lang.StringBuilder line = new java.lang.StringBuilder();
+        if (bufferedToken != null) {
+            line.append(bufferedToken);
+            bufferedToken = null;
+        }
+        int value = peekByte();
+        if (line.length() == 0 && value == -1) {
+            return "";
+        }
+        if (line.length() == 0 && value == '\\r') {
+            readByte();
+            if (peekByte() == '\\n') {
+                readByte();
+            }
+            return "";
+        }
+        if (line.length() == 0 && value == '\\n') {
+            readByte();
+            return "";
+        }
+        while (true) {
+            value = readByte();
+            if (value == -1 || value == '\\n' || value == '\\r') {
+                break;
+            }
+            line.append((char) value);
+        }
+        if (value == '\\r' && peekByte() == '\\n') {
+            readByte();
+        }
+        return line.toString();
+    }
+
+    public int nextInt() {
+        return Integer.parseInt(next());
+    }
+
+    public long nextLong() {
+        return Long.parseLong(next());
+    }
+
+    public float nextFloat() {
+        return Float.parseFloat(next());
+    }
+
+    public double nextDouble() {
+        return Double.parseDouble(next());
+    }
+
+    public boolean hasNextInt() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Integer.parseInt(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextLong() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Long.parseLong(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextFloat() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Float.parseFloat(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public boolean hasNextDouble() {
+        if (!hasNext()) {
+            return false;
+        }
+        try {
+            Double.parseDouble(bufferedToken);
+            return true;
+        } catch (RuntimeException error) {
+            return false;
+        }
+    }
+
+    public void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        try {
+            input.close();
+        } catch (java.io.IOException error) {
+            throw new RuntimeException(error);
+        }
+    }
+}`;
 export const prepareJavaStdinInjection = (code, stdin) => {
     const usesStdin = code.includes('System.in');
+    const usesScanner = /\bScanner\b/.test(code) &&
+        !code.includes(JAVA_SCANNER_COMPAT_SENTINEL) &&
+        !/\b(?:class|interface|enum|record)\s+Scanner\b/.test(code) &&
+        !/^[ \t]*import[ \t]+(?!java\.util\.Scanner\b)(?!static\b)[\w.]+\.Scanner[ \t]*;[ \t]*$/m.test(code);
     if (!usesStdin) {
+        if (!usesScanner) {
+            return {
+                usesStdin: false,
+                stdinCacheKey: '',
+                transformedCode: code,
+                helperSourcePath: null,
+                helperSource: null
+            };
+        }
+        const transformedCode = code
+            .replace(/^[ \t]*import[ \t]+java\.util\.Scanner[ \t]*;[ \t]*$/gm, (match) => match.replace(/[^\r\n]/g, ' '))
+            .replaceAll(/\bjava\.util\.Scanner\b/g, 'Scanner');
         return {
             usesStdin: false,
             stdinCacheKey: '',
-            transformedCode: code,
+            transformedCode: `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`,
             helperSourcePath: null,
             helperSource: null
         };
@@ -15,7 +242,13 @@ export const prepareJavaStdinInjection = (code, stdin) => {
     const helperSourcePath = packageName
         ? `${packageName.replaceAll('.', '/')}/${JAVA_STDIN_HELPER_CLASS}.java`
         : `${JAVA_STDIN_HELPER_CLASS}.java`;
-    const transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    let transformedCode = code.replaceAll('System.in', `${JAVA_STDIN_HELPER_CLASS}.open()`);
+    if (usesScanner) {
+        transformedCode = transformedCode
+            .replace(/^[ \t]*import[ \t]+java\.util\.Scanner[ \t]*;[ \t]*$/gm, (match) => match.replace(/[^\r\n]/g, ' '))
+            .replaceAll(/\bjava\.util\.Scanner\b/g, 'Scanner');
+        transformedCode = `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`;
+    }
     const encodedBytes = [...new TextEncoder().encode(stdin)].join(', ');
     return {
         usesStdin: true,

package/dist/playground/options.d.ts

@@ -46,4 +46,13 @@ export interface SandboxExecutionOptions {
     breakpoints?: number[];
     pauseOnEntry?: boolean;
     stdin?: string;
+    compileArgs?: string[];
+    programArgs?: string[];
+    cppVersion?: string;
+    cVersion?: string;
 }
+export interface ResolvedSandboxExecutionArgs {
+    compileArgs: string[];
+    programArgs: string[];
+}
+export declare function resolveSandboxExecutionArgs(language: string, args?: string[], options?: SandboxExecutionOptions): ResolvedSandboxExecutionArgs;

package/dist/playground/options.js

@@ -1 +1,15 @@
-export {};
+function cloneArgs(value) {
+    return Array.isArray(value) ? [...value] : [];
+}
+export function resolveSandboxExecutionArgs(language, args = [], options = {}) {
+    if (language === 'C' || language === 'CPP') {
+        return {
+            compileArgs: cloneArgs(options.compileArgs ?? args),
+            programArgs: cloneArgs(options.programArgs)
+        };
+    }
+    return {
+        compileArgs: cloneArgs(options.compileArgs),
+        programArgs: cloneArgs(options.programArgs ?? args)
+    };
+}

package/dist/playground/python.d.ts

@@ -1,4 +1,6 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 declare class Python implements Sandbox {
     ts: number;
@@ -22,7 +24,10 @@ declare class Python implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
-    load(path: string, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    assetBridge: WorkerAssetBridge | null;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;
     eof(): void;
     private flushPendingInput;

package/dist/playground/python.js

@@ -1,3 +1,5 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 class Python {
     ts = Date.now();
@@ -17,17 +19,44 @@ class Python {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
-    load(path, code = '', log = true, _args = [], _options = {}) {
-        return new Promise(async (resolve) => {
+    assetBridge = null;
+    load(runtimeAssets = '', code = '', log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
             this.pendingInput = [];
             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;
+            }
             if (!this.worker) {
                 this.worker = new (await import('./worker/python?worker')).default();
-                this.worker.onmessage = () => resolve();
-                this.worker.postMessage({ load: true, path, log, code });
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'python', assetConfig, progress);
+                this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        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
+                    }
+                });
             }
             else {
+                if (!this.assetBridge)
+                    return reject('Worker asset bridge unavailable');
+                this.assetBridge.rebind(this.worker, assetConfig, progress);
                 this.worker.postMessage({ log });
                 resolve();
             }
@@ -62,6 +91,8 @@ class Python {
                 return reject('Worker not loaded');
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
@@ -131,7 +162,8 @@ class Python {
         Atomics.store(control, 1, 5);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
-        return (await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ?? '?';
+        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
+            '?');
     }
     kill() {
         this.terminate();
@@ -159,6 +191,7 @@ class Python {
         if (!this.exit) {
             this.worker?.terminate?.();
             delete this.worker;
+            this.assetBridge = null;
             this.exit = true;
         }
     }