wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/php.js

@@ -0,0 +1,261 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { importRuntimeModule } from '../runtimeModule';
+const encoder = new TextEncoder();
+let stdinBufferPhp = null;
+let runtimeModuleUrl = '';
+let phpPromise = null;
+let workspaceDirty = false;
+function postProgress(percent) {
+    postMessage({ progress: { percent: Math.max(0, Math.min(100, percent)) } });
+}
+async function loadPhp(moduleUrl, log = true) {
+    if (!moduleUrl)
+        throw new Error('PHP runtime module URL is not configured.');
+    if (runtimeModuleUrl !== moduleUrl) {
+        runtimeModuleUrl = moduleUrl;
+        phpPromise = null;
+        workspaceDirty = false;
+    }
+    if (phpPromise)
+        return await phpPromise;
+    phpPromise = (async () => {
+        postProgress(5);
+        const runtime = await importRuntimeModule(moduleUrl);
+        const php = await runtime.createPhp84();
+        postProgress(95);
+        php.mkdir('/workspace');
+        if (log) {
+            console.log('[wasm-idle:php-worker] PHP 8.4 ready');
+        }
+        postProgress(100);
+        return php;
+    })();
+    return await phpPromise;
+}
+function prepareWorkspace(php) {
+    if (workspaceDirty) {
+        php.rmdir('/workspace', { recursive: true });
+        php.mkdir('/workspace');
+    }
+    workspaceDirty = true;
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..' && !part.includes('\0'))
+        .join('/');
+}
+function dirname(path) {
+    const slashIndex = path.lastIndexOf('/');
+    return slashIndex === -1 ? '' : path.slice(0, slashIndex);
+}
+function mkdirp(php, path) {
+    const normalized = normalizeWorkspacePath(path);
+    if (!normalized)
+        return;
+    let current = '';
+    for (const part of normalized.split('/')) {
+        current += `/${part}`;
+        try {
+            php.mkdir(current);
+        }
+        catch {
+            // Existing directories throw from the Emscripten FS API.
+        }
+    }
+}
+function writeWorkspaceFile(php, path, content) {
+    const normalized = normalizeWorkspacePath(path);
+    if (!normalized)
+        return;
+    const fullPath = `/workspace/${normalized}`;
+    mkdirp(php, dirname(`workspace/${normalized}`));
+    php.writeFile(fullPath, content);
+}
+function phpString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+function skipPhpTrivia(code, offset) {
+    let cursor = offset;
+    while (cursor < code.length) {
+        if (/\s/u.test(code[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        if (code.startsWith('//', cursor) ||
+            (code[cursor] === '#' && !code.startsWith('#[', cursor))) {
+            const newline = code.indexOf('\n', cursor + 1);
+            cursor = newline === -1 ? code.length : newline + 1;
+            continue;
+        }
+        if (code.startsWith('/*', cursor)) {
+            const commentEnd = code.indexOf('*/', cursor + 2);
+            cursor = commentEnd === -1 ? code.length : commentEnd + 2;
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+function startsWithPhpKeyword(code, offset, keyword) {
+    if (code.slice(offset, offset + keyword.length).toLowerCase() !== keyword)
+        return false;
+    return !/[A-Za-z0-9_\u0080-\uffff]/u.test(code[offset + keyword.length] || '');
+}
+function findPhpHeaderDelimiter(code, offset, delimiters) {
+    let quote = '';
+    let parentheses = 0;
+    let brackets = 0;
+    for (let cursor = offset; cursor < code.length; cursor += 1) {
+        const character = code[cursor];
+        if (quote) {
+            if (character === '\\')
+                cursor += 1;
+            else if (character === quote)
+                quote = '';
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            continue;
+        }
+        if (code.startsWith('//', cursor) ||
+            (character === '#' && !code.startsWith('#[', cursor))) {
+            const newline = code.indexOf('\n', cursor + 1);
+            if (newline === -1)
+                return -1;
+            cursor = newline;
+            continue;
+        }
+        if (code.startsWith('/*', cursor)) {
+            const commentEnd = code.indexOf('*/', cursor + 2);
+            if (commentEnd === -1)
+                return -1;
+            cursor = commentEnd + 1;
+            continue;
+        }
+        if (character === '(')
+            parentheses += 1;
+        else if (character === ')')
+            parentheses = Math.max(0, parentheses - 1);
+        else if (character === '[')
+            brackets += 1;
+        else if (character === ']')
+            brackets = Math.max(0, brackets - 1);
+        else if (parentheses === 0 && brackets === 0 && delimiters.has(character))
+            return cursor;
+    }
+    return -1;
+}
+function argvPreludeInsertionOffset(code, openingTagEnd) {
+    let cursor = skipPhpTrivia(code, openingTagEnd);
+    while (startsWithPhpKeyword(code, cursor, 'declare')) {
+        const declarationEnd = findPhpHeaderDelimiter(code, cursor + 'declare'.length, new Set([';']));
+        if (declarationEnd === -1)
+            return cursor;
+        cursor = skipPhpTrivia(code, declarationEnd + 1);
+    }
+    if (startsWithPhpKeyword(code, cursor, 'namespace') &&
+        (/\s/u.test(code[cursor + 'namespace'.length] || '') ||
+            code[cursor + 'namespace'.length] === '{')) {
+        const namespaceEnd = findPhpHeaderDelimiter(code, cursor + 'namespace'.length, new Set([';', '{']));
+        if (namespaceEnd !== -1)
+            return namespaceEnd + 1;
+    }
+    return cursor;
+}
+function injectArgv(code, activePath, args) {
+    const argv = [activePath, ...args].map(phpString).join(', ');
+    const prelude = `$argv = array(${argv});\n$argc = count($argv);\n$_SERVER['argv'] = $argv;\n$_SERVER['argc'] = $argc;\n`;
+    const openingTag = code.match(/^\s*<\?php\b/i);
+    if (openingTag) {
+        const insertAt = argvPreludeInsertionOffset(code, openingTag[0].length);
+        return `${code.slice(0, insertAt)}\n${prelude}${code.slice(insertAt)}`;
+    }
+    return `<?php\n${prelude}\n?>\n${code}`;
+}
+function codeMightReadStdin(code) {
+    return /php:\/\/input|STDIN|stream_get_contents|file_get_contents|fgets\s*\(/.test(code);
+}
+function readInitialStdin(code, initialStdin, log = true) {
+    if (typeof initialStdin === 'string')
+        return initialStdin;
+    if (!codeMightReadStdin(code))
+        return '';
+    const chunk = waitForBufferedStdin(stdinBufferPhp, () => postMessage({ buffer: true }));
+    if (log) {
+        console.log(chunk == null
+            ? '[wasm-idle:php-stdin] read(bytes=0, eof=true)'
+            : `[wasm-idle:php-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+    }
+    return chunk || '';
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, buffer, code, prepare, args = [], stdin, activePath = 'main.php', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            const moduleUrl = nextModuleUrl || runtimeModuleUrl;
+            if (log)
+                console.log(`[wasm-idle:php-worker] load PHP 8.4 module=${moduleUrl}`);
+            await loadPhp(moduleUrl, log);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferPhp = new Int32Array(buffer);
+        const php = await loadPhp(runtimeModuleUrl, log);
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        prepareWorkspace(php);
+        for (const file of workspaceFiles) {
+            await writeWorkspaceFile(php, file.path, file.content);
+        }
+        const normalizedActivePath = normalizeWorkspacePath(activePath) || 'main.php';
+        const scriptPath = `/workspace/${normalizedActivePath}`;
+        writeWorkspaceFile(php, normalizedActivePath, injectArgv(code, normalizedActivePath, args));
+        if (log) {
+            console.log(`[wasm-idle:php-worker] run start bytes=${code.length} activePath=${activePath}`);
+        }
+        const body = readInitialStdin(code, stdin, log);
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'PHP program started'
+            }
+        });
+        const response = await php.run({
+            scriptPath,
+            body,
+            env: {
+                USER: 'jungol'
+            },
+            $_SERVER: {
+                SCRIPT_FILENAME: scriptPath,
+                SCRIPT_NAME: `/${normalizedActivePath}`
+            }
+        });
+        if (response.text)
+            postMessage({ output: response.text });
+        if (response.errors)
+            postMessage({ output: response.errors });
+        if (response.exitCode !== 0) {
+            throw new Error(response.errors
+                ? `PHP program exited with code ${response.exitCode}\n${response.errors}`
+                : `PHP program exited with code ${response.exitCode}`);
+        }
+        if (log) {
+            console.log(`[wasm-idle:php-worker] run settled exitCode=${response.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:php-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/python.js

@@ -1,5 +1,7 @@
 import { flushQueuedStdin, readBufferedStdin, waitForBufferedStdin } from '../stdinBuffer';
-import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
+import { isSharedBufferBackedView } from '../sharedBuffer';
+import { parsePythonPackageLock } from '../pythonPackageLock';
+import { configureWorkerRuntimeAssetAllowlist, configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from './assets';
 self.document = {
     querySelector() {
         return null;
@@ -8,7 +10,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, baseUrl = '', packageBaseUrl = '';
+let stdinBufferPyodide, debugBufferPyodide, watchBufferPyodide, watchResultBufferPyodide, interruptBufferPyodide, pyodide, baseUrl = '', useAssetBridge = false;
 const imageHook = `
 if not globals().get("__wasm_idle_img_inited__", False):
     globals()["__wasm_idle_img_inited__"] = True
@@ -152,53 +154,121 @@ if not globals().get("__wasm_idle_img_inited__", False):
     except Exception:
         pass
 `;
-const cdnFallbackUrl = (version) => version ? `https://cdn.jsdelivr.net/pyodide/v${version}/full/` : '';
+const pyodideVersionPattern = /^[0-9]{1,6}\.[0-9]{1,6}\.[0-9]{1,6}(?:[A-Za-z0-9._+-]{0,64})?$/u;
+const directPyodideRuntimeAssets = [
+    'pyodide.mjs',
+    'pyodide.asm.js',
+    'pyodide-lock.json',
+    'pyodide.asm.wasm',
+    'python_stdlib.zip'
+];
+const resolvePinnedPackageBaseUrl = (version) => {
+    if (typeof version !== 'string' || !pyodideVersionPattern.test(version)) {
+        throw new Error('Pyodide runtime version is invalid');
+    }
+    return new URL(`v${encodeURIComponent(version)}/full/`, 'https://cdn.jsdelivr.net/pyodide/')
+        .href;
+};
+function postProgress(percent, stage) {
+    self.postMessage({ progress: { percent, stage } });
+}
+async function importRuntimeAssetModule(asset) {
+    const loaded = await loadWorkerRuntimeAsset(asset);
+    const moduleUrl = URL.createObjectURL(new Blob([loaded.bytes.slice().buffer], {
+        type: loaded.mimeType || 'text/javascript'
+    }));
+    try {
+        return await import(/* @vite-ignore */ moduleUrl);
+    }
+    finally {
+        URL.revokeObjectURL(moduleUrl);
+    }
+}
 async function loadPyodide(path) {
     if (pyodide)
         return;
-    const { loadPyodide } = await import('pyodide');
-    pyodide = await loadPyodide({ indexURL: path });
-    packageBaseUrl = path;
-    const setCdnUrl = pyodide?.setCdnUrl;
-    if (typeof setCdnUrl === 'function')
-        setCdnUrl(packageBaseUrl);
+    const runtimeBaseUrl = path.endsWith('/') ? path : `${path}/`;
+    await importRuntimeAssetModule('pyodide.asm.js');
+    const runtimeModule = (await importRuntimeAssetModule('pyodide.mjs'));
+    let packageBaseUrl = runtimeBaseUrl;
+    let lockFileContents;
+    if (!useAssetBridge) {
+        packageBaseUrl = resolvePinnedPackageBaseUrl(runtimeModule.version);
+        const loadedLock = await loadWorkerRuntimeAsset('pyodide-lock.json');
+        const parsedLock = parsePythonPackageLock(loadedLock.bytes);
+        // The interceptor caps downloaded (including browser-decoded transport) archive bytes.
+        // Pyodide owns package extraction after receiving that bounded archive.
+        configureWorkerRuntimeAssetAllowlist({
+            baseUrl: packageBaseUrl,
+            assets: [...parsedLock.packageAssets],
+            runtimeAssets: directPyodideRuntimeAssets
+        });
+        lockFileContents = parsedLock.lock;
+    }
+    const { loadPyodide } = runtimeModule;
+    pyodide = await loadPyodide({
+        indexURL: path,
+        packageBaseUrl,
+        ...(lockFileContents ? { lockFileContents } : {})
+    });
 }
 async function loadPackages(code) {
     if (!code)
         return;
-    try {
-        await pyodide.loadPackagesFromImports(code);
-    }
-    catch (e) {
-        const fallback = cdnFallbackUrl(pyodide?.version || '');
-        const setCdnUrl = pyodide?.setCdnUrl;
-        if (fallback && fallback !== packageBaseUrl && typeof setCdnUrl === 'function') {
-            setCdnUrl(fallback);
-            packageBaseUrl = fallback;
-            await pyodide.loadPackagesFromImports(code);
-            return;
-        }
-        throw e;
+    await pyodide.loadPackagesFromImports(code);
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replaceAll('\\', '/')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..')
+        .join('/');
+}
+function writeWorkspaceFiles(files = []) {
+    const fs = pyodide.FS;
+    for (const file of files) {
+        const safePath = normalizeWorkspacePath(file.path);
+        if (!safePath)
+            continue;
+        const directory = safePath.split('/').slice(0, -1).join('/');
+        if (directory)
+            fs.mkdirTree(directory);
+        fs.writeFile(safePath, file.content, { encoding: 'utf8' });
     }
 }
 self.onmessage = async (event) => {
     if (handleWorkerAssetMessage(event.data))
         return;
-    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, assets, prepare, debug = false, breakpoints = [], pauseOnEntry = false } = event.data;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, assets, prepare, stdin, debug = false, breakpoints = [], pauseOnEntry = false, activePath, debugPath, workspaceFiles } = event.data;
     if (load) {
-        const runtimeAssets = assets;
-        baseUrl = runtimeAssets?.baseUrl || baseUrl;
-        configureWorkerRuntimeAssets(runtimeAssets || null);
-        postMessage({ output: 'Loading Pyodide...' });
-        await loadPyodide(baseUrl);
-        postMessage({ output: ' Done.\n\r' });
-        postMessage({ load: true });
+        try {
+            const runtimeAssets = assets;
+            baseUrl = runtimeAssets?.baseUrl || baseUrl;
+            useAssetBridge = runtimeAssets?.useAssetBridge === true;
+            configureWorkerRuntimeAssets(runtimeAssets || null);
+            postMessage({ output: 'Loading Pyodide...' });
+            postProgress(2, 'Loading Pyodide module');
+            await loadPyodide(baseUrl);
+            postProgress(100, 'Pyodide runtime ready');
+            postMessage({ output: ' Done.\n\r' });
+            postMessage({ load: true });
+        }
+        catch (e) {
+            self.postMessage({ error: e.message || 'Unknown error' });
+        }
     }
     else if (prepare) {
         postMessage({ output: 'Loading packages...' });
         try {
+            postProgress(5, 'Preparing Python workspace');
             await loadPyodide(baseUrl);
-            await loadPackages(code);
+            writeWorkspaceFiles(workspaceFiles);
+            postProgress(15, 'Resolving Python imports');
+            await loadPackages([
+                code,
+                ...(workspaceFiles || []).map((file) => file.content)
+            ].join('\n'));
+            postProgress(100, 'Python packages ready');
             postMessage({ output: ' Done.\n\r' });
             self.postMessage({ results: true });
         }
@@ -206,16 +276,32 @@ self.onmessage = async (event) => {
             self.postMessage({ error: e.message || 'Unknown error' });
         }
     }
-    else if (code) {
-        await loadPyodide(baseUrl);
-        await loadPackages(code);
+    else if (typeof code === 'string') {
+        try {
+            await loadPyodide(baseUrl);
+            writeWorkspaceFiles(workspaceFiles);
+            await loadPackages([
+                code,
+                ...(workspaceFiles || []).map((file) => file.content)
+            ].join('\n'));
+        }
+        catch (e) {
+            self.postMessage({ error: e.message || 'Unknown error' });
+            return;
+        }
         const ts = Date.now();
         stdinBufferPyodide = new Int32Array(buffer);
         debugBufferPyodide = new Int32Array(debugBuffer);
         watchBufferPyodide = new Int32Array(watchBuffer);
         watchResultBufferPyodide = new Int32Array(watchResultBuffer);
         interruptBufferPyodide = new Uint8Array(interrupt);
-        pyodide.setInterruptBuffer(interruptBufferPyodide);
+        if (debug && !isSharedBufferBackedView(debugBufferPyodide)) {
+            self.postMessage({ error: 'Python debugging requires SharedArrayBuffer.' });
+            return;
+        }
+        if (isSharedBufferBackedView(interruptBufferPyodide)) {
+            pyodide.setInterruptBuffer(interruptBufferPyodide);
+        }
         const toPythonStr = (obj) => {
             if (obj === true)
                 return 'True';
@@ -227,13 +313,21 @@ self.onmessage = async (event) => {
                 return 'None';
             return obj.toString();
         };
+        const hasInitialStdin = typeof stdin === 'string';
+        let initialStdin = hasInitialStdin ? stdin : null;
         self.prompt = self['__pyodide__input_' + ts] = (output) => {
             if (output)
                 postMessage({ output });
+            if (hasInitialStdin) {
+                const chunk = initialStdin;
+                initialStdin = null;
+                return chunk;
+            }
             return waitForBufferedStdin(stdinBufferPyodide, () => postMessage({ buffer: true }));
         };
         self['__pyodide__output_' + ts] = (...data) => {
-            let sep = ' ', end = '\r\n', output = '', clear = [];
+            let sep = ' ', end = '\r\n', output = '';
+            const clear = [];
             for (const i of data) {
                 if (i?.end !== undefined)
                     end = toPythonStr(i.end);
@@ -256,9 +350,26 @@ self.onmessage = async (event) => {
         const debugWaitName = `__wasm_idle_python_debug_wait_${ts}`;
         const debugReadWatchName = `__wasm_idle_python_debug_watch_read_${ts}`;
         const debugWriteWatchName = `__wasm_idle_python_debug_watch_write_${ts}`;
+        const debugReadBreakpointsName = `__wasm_idle_python_debug_breakpoints_${ts}`;
+        const executionReadyName = `__wasm_idle_python_execution_ready_${ts}`;
+        let executionReadyReported = false;
+        self[executionReadyName] = () => {
+            if (executionReadyReported)
+                return;
+            executionReadyReported = true;
+            delete self[executionReadyName];
+            postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'Python program started'
+                }
+            });
+        };
         self[debugPauseName] = (line, reason, localsJson, callStackJson) => {
-            let locals = [];
-            let callStack = [];
+            let locals;
+            let callStack;
             try {
                 locals = JSON.parse(localsJson);
             }
@@ -298,7 +409,21 @@ self.onmessage = async (event) => {
         self[debugWriteWatchName] = (value) => {
             flushQueuedStdin([value], watchResultBufferPyodide);
         };
-        const userFilename = '__wasm_idle_user__.py';
+        self[debugReadBreakpointsName] = () => {
+            const version = Atomics.load(debugBufferPyodide, 2);
+            const count = Math.max(0, Math.min(Atomics.load(debugBufferPyodide, 3), debugBufferPyodide.length - 4));
+            const lines = [];
+            for (let index = 0; index < count; index += 1) {
+                const line = Atomics.load(debugBufferPyodide, 4 + index);
+                if (Number.isInteger(line) && line > 0)
+                    lines.push(line);
+            }
+            return JSON.stringify({ version, lines });
+        };
+        const executionFilename = normalizeWorkspacePath(activePath || '') || '__wasm_idle_user__.py';
+        const debugFilename = normalizeWorkspacePath(debugPath || '') || executionFilename;
+        const executionFilenameLiteral = JSON.stringify(executionFilename);
+        const debugFilenameLiteral = JSON.stringify(debugFilename);
         const normalizedBreakpoints = JSON.stringify([...(Array.isArray(breakpoints) ? breakpoints : [])]
             .map((value) => Number(value))
             .filter((value) => Number.isInteger(value) && value > 0));
@@ -309,14 +434,20 @@ import inspect
 import json
 import sys
 from js import __pyodide__input_${ts}, __pyodide__output_${ts}
+from js import ${executionReadyName} as __wasm_idle_execution_ready
 ${debug ? `from js import ${debugPauseName}, ${debugWaitName}` : ''}
 ${debug ? `from js import ${debugReadWatchName}, ${debugWriteWatchName}` : ''}
+${debug ? `from js import ${debugReadBreakpointsName}` : ''}
 
 __wasm_idle_input = __pyodide__input_${ts}
 def __wasm_idle_input_wrapper(prompt = ""):
     value = __wasm_idle_input(prompt)
     if value is None:
         raise EOFError
+    if value.endswith("\\r\\n"):
+        value = value[:-2]
+    elif value.endswith("\\n") or value.endswith("\\r"):
+        value = value[:-1]
     return value
 __wasm_idle_output = __pyodide__output_${ts}
 builtins.input = __wasm_idle_input_wrapper
@@ -327,6 +458,7 @@ ${imageHook}
 ${debug
                 ? `
 __wasm_idle_debug_breakpoints = set(${normalizedBreakpoints})
+__wasm_idle_debug_breakpoint_version = -1
 __wasm_idle_debug_pause_on_entry = ${pauseOnEntry ? 'True' : 'False'}
 __wasm_idle_debug_step_mode = None
 __wasm_idle_debug_resume_skip = None
@@ -334,11 +466,21 @@ __wasm_idle_debug_next_depth = None
 __wasm_idle_debug_next_line = None
 __wasm_idle_debug_step_out_depth = None
 
+def __wasm_idle_debug_refresh_breakpoints():
+    global __wasm_idle_debug_breakpoints
+    global __wasm_idle_debug_breakpoint_version
+    snapshot = json.loads(${debugReadBreakpointsName}())
+    version = int(snapshot.get("version", -1))
+    if version == __wasm_idle_debug_breakpoint_version:
+        return
+    __wasm_idle_debug_breakpoint_version = version
+    __wasm_idle_debug_breakpoints = set(int(line) for line in snapshot.get("lines", []) if int(line) > 0)
+
 def __wasm_idle_debug_depth(frame):
     depth = 0
     current = frame
     while current is not None:
-        if current.f_code.co_filename == "${userFilename}":
+        if current.f_code.co_filename == ${debugFilenameLiteral}:
             depth += 1
         current = current.f_back
     return depth
@@ -402,7 +544,7 @@ def __wasm_idle_debug_stack(frame):
     stack = []
     current = frame
     while current is not None:
-        if current.f_code.co_filename == "${userFilename}":
+        if current.f_code.co_filename == ${debugFilenameLiteral}:
             stack.append({"functionName": current.f_code.co_name, "line": current.f_lineno})
         current = current.f_back
     return stack
@@ -415,11 +557,12 @@ def __wasm_idle_debug_trace(frame, event, arg):
     global __wasm_idle_debug_next_line
     global __wasm_idle_debug_step_out_depth
 
-    if frame.f_code.co_filename != "${userFilename}":
+    if frame.f_code.co_filename != ${debugFilenameLiteral}:
         return None
     if event != "line":
         return __wasm_idle_debug_trace
 
+    __wasm_idle_debug_refresh_breakpoints()
     depth = __wasm_idle_debug_depth(frame)
     line = frame.f_lineno
     if __wasm_idle_debug_resume_skip == (depth, line):
@@ -478,15 +621,27 @@ sys.settrace(__wasm_idle_debug_trace)
                 : ''}
 
 try:
-    __wasm_idle_globals = {"__name__": "__main__"}
+    __wasm_idle_globals = {
+        "__name__": "__main__",
+        ${JSON.stringify(executionReadyName)}: __wasm_idle_execution_ready,
+    }
+    __wasm_idle_compiled = compile(
+        ${JSON.stringify(code)},
+        ${executionFilenameLiteral},
+        "exec",
+        flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT,
+    )
+    __wasm_idle_globals.pop(${JSON.stringify(executionReadyName)})()
     __wasm_idle_result = eval(
-        compile(${JSON.stringify(code)}, "${userFilename}", "exec", flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT),
+        __wasm_idle_compiled,
         __wasm_idle_globals,
         __wasm_idle_globals,
     )
     if inspect.isawaitable(__wasm_idle_result):
         await __wasm_idle_result
 finally:
+    __wasm_idle_globals.pop(${JSON.stringify(executionReadyName)}, None)
+    del __wasm_idle_execution_ready
     sys.settrace(None)
     ${debug
                 ? `
@@ -504,10 +659,12 @@ finally:
             self.postMessage({ error: e.message || 'Unknown error' });
         }
         finally {
+            delete self[executionReadyName];
             delete self[debugPauseName];
             delete self[debugWaitName];
             delete self[debugReadWatchName];
             delete self[debugWriteWatchName];
+            delete self[debugReadBreakpointsName];
         }
     }
 };

package/dist/playground/worker/r.d.ts

@@ -0,0 +1 @@
+export {};