wasm-idle 0.3.2 → 0.4.0

package/README.md

@@ -2,8 +2,10 @@
 
 ![wasm-idle](static/image.jpeg)
 
-Executes C++, Python Code with working stdio.
+Executes C++, Python, and Java code with working stdio.
 
 Refer to src/lib/clang.
 
-Powered by [wasm-clang](https://github.com/binji/wasm-clang) and Pyodide.
+Java uses TeaVM's browser compiler/runtime. TeaVM compiler/runtime/classlib assets are bundled under `static/teavm/` by default, and the asset base URL can be overridden with `PUBLIC_TEAVM_BASE_URL`.
+
+Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, and TeaVM.

package/dist/clang/app.d.ts

@@ -52,7 +52,8 @@ export default class App {
     constructor(module: WebAssembly.Module, memfs: MemFS, name: string, ...args: string[]);
     run(): Promise<boolean | undefined>;
     proc_exit(code: number): void;
-    __wasm_idle_debug_enter(functionId: number): number;
+    private pauseDebugSession;
+    __wasm_idle_debug_enter(functionId: number, line: number): number;
     __wasm_idle_debug_leave(functionId: number): number;
     __wasm_idle_debug_value_num(functionId: number, slot: number, value: number): number;
     __wasm_idle_debug_value_bool(functionId: number, slot: number, value: number): number;

package/dist/clang/app.js

@@ -68,135 +68,9 @@ export default class App {
     proc_exit(code) {
         throw new ProcExit(code);
     }
-    __wasm_idle_debug_enter(functionId) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        session.callDepth += 1;
-        session.currentFunctionId = functionId;
-        session.frames.push({
-            functionId,
-            functionName: session.functionMetadata[functionId] || `fn_${functionId}`,
-            line: 0,
-            values: new Map()
-        });
-        this.trace(`enter(function=${functionId}, depth=${session.callDepth})`);
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_leave(functionId) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        this.trace(`leave(function=${functionId}, depth=${session.callDepth})`);
-        session.callDepth = Math.max(0, session.callDepth - 1);
-        if (session.currentFunctionId === functionId)
-            session.currentFunctionId = 0;
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            if (session.frames[index]?.functionId === functionId) {
-                session.frames.splice(index, 1);
-                break;
-            }
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_num(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        if (functionId === 0) {
-            session.globalValues.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
-            return ESUCCESS;
-        }
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_bool(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        if (functionId === 0) {
-            session.globalValues.set(slot, value ? 'true' : 'false');
-            return ESUCCESS;
-        }
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, value ? 'true' : 'false');
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_addr(functionId, slot, value) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        if (functionId === 0) {
-            session.globalValues.set(slot, String(value >>> 0));
-            return ESUCCESS;
-        }
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, String(value >>> 0));
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_value_text(functionId, slot, ptr, len) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        this.mem?.check?.();
-        const text = this.mem?.readStr ? this.mem.readStr(ptr, len) : '?';
-        if (functionId === 0) {
-            session.globalValues.set(slot, text);
-            return ESUCCESS;
-        }
-        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
-            const frame = session.frames[index];
-            if (frame?.functionId !== functionId)
-                continue;
-            frame.values.set(slot, text);
-            break;
-        }
-        return ESUCCESS;
-    }
-    __wasm_idle_debug_line(functionId, line) {
-        const session = this.debugSession;
-        if (!session?.buffer)
-            return ESUCCESS;
-        if (session.resumeSkipActive) {
-            if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
-                return ESUCCESS;
-            }
-            session.resumeSkipActive = false;
-            session.resumeSkipFunctionId = 0;
-            session.resumeSkipLine = 0;
-        }
-        let reason = '';
-        if (session.pauseOnEntry)
-            reason = 'entry';
-        else if (session.breakpoints.has(line))
-            reason = 'breakpoint';
-        else if (session.stepArmed)
-            reason = 'step';
-        else if (session.nextLineArmed &&
-            functionId === session.nextLineFunctionId &&
-            line !== session.nextLineLine) {
-            reason = 'nextLine';
-        }
-        else if (session.stepOutArmed && session.callDepth <= session.stepOutDepth) {
-            reason = 'stepOut';
-        }
-        if (!reason)
+    pauseDebugSession(session, functionId, line, reason) {
+        const buffer = session.buffer;
+        if (!buffer)
             return ESUCCESS;
         session.currentFunctionId = functionId;
         session.currentLine = line;
@@ -314,14 +188,14 @@ export default class App {
                 .reverse()
                 .map((stackFrame) => ({ functionName: stackFrame.functionName, line: stackFrame.line }))
         });
-        const sequence = Atomics.load(session.buffer, 0);
+        const sequence = Atomics.load(buffer, 0);
         while (true) {
             if (session.interruptBuffer?.[0] === 2)
                 throw new AbortError();
-            Atomics.wait(session.buffer, 0, sequence, 100);
+            Atomics.wait(buffer, 0, sequence, 100);
             if (session.interruptBuffer?.[0] === 2)
                 throw new AbortError();
-            const command = Atomics.exchange(session.buffer, 1, 0);
+            const command = Atomics.exchange(buffer, 1, 0);
             if (command === 1) {
                 session.resumeSkipActive = true;
                 session.resumeSkipFunctionId = session.currentFunctionId;
@@ -354,6 +228,149 @@ export default class App {
             }
         }
     }
+    __wasm_idle_debug_enter(functionId, line) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        session.callDepth += 1;
+        session.currentFunctionId = functionId;
+        session.currentLine = line;
+        session.frames.push({
+            functionId,
+            functionName: session.functionMetadata[functionId] || `fn_${functionId}`,
+            line,
+            values: new Map()
+        });
+        this.trace(`enter(function=${functionId}, line=${line}, depth=${session.callDepth})`);
+        if (session.pauseOnEntry) {
+            return this.pauseDebugSession(session, functionId, line, 'entry');
+        }
+        if (session.stepArmed) {
+            return this.pauseDebugSession(session, functionId, line, 'step');
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_leave(functionId) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        this.trace(`leave(function=${functionId}, depth=${session.callDepth})`);
+        if (session.nextLineArmed && functionId === session.nextLineFunctionId) {
+            session.nextLineArmed = false;
+            session.stepArmed = true;
+        }
+        session.callDepth = Math.max(0, session.callDepth - 1);
+        if (session.currentFunctionId === functionId)
+            session.currentFunctionId = 0;
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            if (session.frames[index]?.functionId === functionId) {
+                session.frames.splice(index, 1);
+                break;
+            }
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_num(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
+            return ESUCCESS;
+        }
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, Number.isInteger(value) ? String(value) : `${value}`);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_bool(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, value ? 'true' : 'false');
+            return ESUCCESS;
+        }
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, value ? 'true' : 'false');
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_addr(functionId, slot, value) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (functionId === 0) {
+            session.globalValues.set(slot, String(value >>> 0));
+            return ESUCCESS;
+        }
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, String(value >>> 0));
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_value_text(functionId, slot, ptr, len) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        this.mem?.check?.();
+        const text = this.mem?.readStr ? this.mem.readStr(ptr, len) : '?';
+        if (functionId === 0) {
+            session.globalValues.set(slot, text);
+            return ESUCCESS;
+        }
+        for (let index = session.frames.length - 1; index >= 0; index -= 1) {
+            const frame = session.frames[index];
+            if (frame?.functionId !== functionId)
+                continue;
+            frame.values.set(slot, text);
+            break;
+        }
+        return ESUCCESS;
+    }
+    __wasm_idle_debug_line(functionId, line) {
+        const session = this.debugSession;
+        if (!session?.buffer)
+            return ESUCCESS;
+        if (session.resumeSkipActive) {
+            if (functionId === session.resumeSkipFunctionId && line === session.resumeSkipLine) {
+                return ESUCCESS;
+            }
+            session.resumeSkipActive = false;
+            session.resumeSkipFunctionId = 0;
+            session.resumeSkipLine = 0;
+        }
+        let reason = '';
+        if (session.pauseOnEntry)
+            reason = 'entry';
+        else if (session.breakpoints.has(line))
+            reason = 'breakpoint';
+        else if (session.stepArmed)
+            reason = 'step';
+        else if (session.nextLineArmed &&
+            functionId === session.nextLineFunctionId &&
+            line !== session.nextLineLine) {
+            reason = 'nextLine';
+        }
+        else if (session.stepOutArmed && session.callDepth <= session.stepOutDepth) {
+            reason = 'stepOut';
+        }
+        if (!reason)
+            return ESUCCESS;
+        return this.pauseDebugSession(session, functionId, line, reason);
+    }
     environ_sizes_get(environ_count_out, environ_buf_size_out) {
         this.mem.check();
         let size = 0;

package/dist/clang/index.js

@@ -151,7 +151,7 @@ export default class Clang {
                 '#include <string>',
                 '#include <type_traits>',
                 '#include <vector>',
-                'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_enter"))) void __wasm_idle_debug_enter(int functionId);',
+                'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_enter"))) void __wasm_idle_debug_enter(int functionId, int line);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_leave"))) void __wasm_idle_debug_leave(int functionId);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_value_num"))) void __wasm_idle_debug_value_num(int functionId, int slot, double value);',
                 'extern "C" __attribute__((import_module("env"), import_name("__wasm_idle_debug_value_bool"))) void __wasm_idle_debug_value_bool(int functionId, int slot, int value);',
@@ -584,7 +584,7 @@ export default class Clang {
                     nextVariableSlot = 1;
                     currentFunctionVariables = new Map();
                     currentFunctionContainers = new Map();
-                    instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId});`);
+                    instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId}, ${index + 1});`);
                     const parameterSource = startsInlineFunctionBody
                         ? normalized.slice(normalized.indexOf('(') + 1, normalized.lastIndexOf(')'))
                         : pendingFunctionHeader?.parameters || '';

package/dist/debug/expression.js

@@ -8,6 +8,38 @@ export function evaluateDebugExpression(expression, variables) {
         values.set(variable.name, variable.value);
     const parsedValues = new Map();
     const tokens = [];
+    const parseQuotedValue = (text, start) => {
+        const quote = text[start];
+        if (quote !== "'" && quote !== '"')
+            throw new Error('expected quoted string');
+        let index = start + 1;
+        let value = '';
+        while (index < text.length) {
+            const character = text[index];
+            if (!character)
+                break;
+            if (character === '\\') {
+                const escaped = text[index + 1];
+                if (!escaped)
+                    throw new Error('unterminated string literal');
+                if (escaped === 'n')
+                    value += '\n';
+                else if (escaped === 'r')
+                    value += '\r';
+                else if (escaped === 't')
+                    value += '\t';
+                else
+                    value += escaped;
+                index += 2;
+                continue;
+            }
+            if (character === quote)
+                return { value, next: index + 1 };
+            value += character;
+            index += 1;
+        }
+        throw new Error('unterminated string literal');
+    };
     for (let index = 0; index < source.length;) {
         const character = source[index];
         if (!character)
@@ -32,6 +64,12 @@ export function evaluateDebugExpression(expression, variables) {
             index += operator.length;
             continue;
         }
+        if (character === "'" || character === '"') {
+            const parsed = parseQuotedValue(source, index);
+            tokens.push({ type: 'string', value: parsed.value });
+            index = parsed.next;
+            continue;
+        }
         const number = source.slice(index).match(/^\d+(?:\.\d+)?/);
         if (number?.[0]) {
             tokens.push({ type: 'number', value: number[0] });
@@ -40,8 +78,26 @@ export function evaluateDebugExpression(expression, variables) {
         }
         const identifier = source.slice(index).match(/^[A-Za-z_]\w*/);
         if (identifier?.[0]) {
-            if (identifier[0] === 'true' || identifier[0] === 'false') {
-                tokens.push({ type: 'boolean', value: identifier[0] === 'true' });
+            if (identifier[0] === 'true' ||
+                identifier[0] === 'false' ||
+                identifier[0] === 'True' ||
+                identifier[0] === 'False') {
+                tokens.push({
+                    type: 'boolean',
+                    value: identifier[0] === 'true' || identifier[0] === 'True'
+                });
+            }
+            else if (identifier[0] === 'null' || identifier[0] === 'None') {
+                tokens.push({ type: 'null' });
+            }
+            else if (identifier[0] === 'and') {
+                tokens.push({ type: 'operator', value: '&&' });
+            }
+            else if (identifier[0] === 'or') {
+                tokens.push({ type: 'operator', value: '||' });
+            }
+            else if (identifier[0] === 'not') {
+                tokens.push({ type: 'operator', value: '!' });
             }
             else {
                 tokens.push({ type: 'identifier', value: identifier[0] });
@@ -81,16 +137,44 @@ export function evaluateDebugExpression(expression, variables) {
                 throw new Error('unsupported array preview');
             }
         }
-        if (character === "'") {
-            const end = text.indexOf("'", index + 1);
-            if (end === -1)
-                throw new Error('unsupported char preview');
-            return { value: text.slice(index + 1, end), next: end + 1 };
+        if (character === '(') {
+            index += 1;
+            const items = [];
+            while (true) {
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ')')
+                    return { value: items, next: index + 1 };
+                if (text.startsWith('...', index))
+                    throw new Error('unavailable');
+                const item = parsePreviewValue(text, index);
+                items.push(item.value);
+                index = item.next;
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ',') {
+                    index += 1;
+                    continue;
+                }
+                if (text[index] === ')')
+                    return { value: items, next: index + 1 };
+                throw new Error('unsupported tuple preview');
+            }
         }
+        if (character === "'" || character === '"')
+            return parseQuotedValue(text, index);
         if (text.startsWith('true', index))
             return { value: true, next: index + 4 };
         if (text.startsWith('false', index))
             return { value: false, next: index + 5 };
+        if (text.startsWith('True', index))
+            return { value: true, next: index + 4 };
+        if (text.startsWith('False', index))
+            return { value: false, next: index + 5 };
+        if (text.startsWith('null', index))
+            return { value: null, next: index + 4 };
+        if (text.startsWith('None', index))
+            return { value: null, next: index + 4 };
         const number = text.slice(index).match(/^-?\d+(?:\.\d+)?/);
         if (number?.[0])
             return { value: Number(number[0]), next: index + number[0].length };
@@ -102,17 +186,24 @@ export function evaluateDebugExpression(expression, variables) {
         const value = values.get(name);
         if (value == null || value === '?')
             throw new Error('unavailable');
-        if (value === 'true' || value === 'false') {
-            const parsed = value === 'true';
+        if (value === 'true' || value === 'false' || value === 'True' || value === 'False') {
+            const parsed = value === 'true' || value === 'True';
             parsedValues.set(name, parsed);
             return parsed;
         }
+        if (value === 'null' || value === 'None') {
+            parsedValues.set(name, null);
+            return null;
+        }
         const numeric = Number(value);
         if (!Number.isNaN(numeric)) {
             parsedValues.set(name, numeric);
             return numeric;
         }
-        if (value.startsWith('[')) {
+        if (value.startsWith('[') ||
+            value.startsWith('(') ||
+            value.startsWith("'") ||
+            value.startsWith('"')) {
             const parsed = parsePreviewValue(value).value;
             parsedValues.set(name, parsed);
             return parsed;
@@ -131,10 +222,21 @@ export function evaluateDebugExpression(expression, variables) {
             cursor += 1;
             return token.value;
         }
+        if (token.type === 'null') {
+            cursor += 1;
+            return null;
+        }
+        if (token.type === 'string') {
+            cursor += 1;
+            return token.value;
+        }
         if (token.type === 'identifier') {
             cursor += 1;
             let resolved = resolveIdentifierValue(token.value);
-            while (tokens[cursor]?.type === 'bracket' && tokens[cursor]?.value === '[') {
+            while (true) {
+                const bracket = tokens[cursor];
+                if (!bracket || bracket.type !== 'bracket' || bracket.value !== '[')
+                    break;
                 cursor += 1;
                 const index = Number(parseOr());
                 const closing = tokens[cursor];
@@ -201,8 +303,14 @@ export function evaluateDebugExpression(expression, variables) {
                 return left;
             cursor += 1;
             const right = parseMul();
-            if (operator.value === '+')
-                left = Number(left) + Number(right);
+            if (operator.value === '+') {
+                if (typeof left === 'string' || typeof right === 'string') {
+                    left = `${left ?? 'null'}${right ?? 'null'}`;
+                }
+                else {
+                    left = Number(left) + Number(right);
+                }
+            }
             if (operator.value === '-')
                 left = Number(left) - Number(right);
         }
@@ -215,14 +323,16 @@ export function evaluateDebugExpression(expression, variables) {
                 return left;
             cursor += 1;
             const right = parseAdd();
+            const leftValue = typeof left === 'string' && typeof right === 'string' ? left : Number(left);
+            const rightValue = typeof left === 'string' && typeof right === 'string' ? right : Number(right);
             if (operator.value === '<')
-                left = Number(left) < Number(right);
+                left = leftValue < rightValue;
             if (operator.value === '<=')
-                left = Number(left) <= Number(right);
+                left = leftValue <= rightValue;
             if (operator.value === '>')
-                left = Number(left) > Number(right);
+                left = leftValue > rightValue;
             if (operator.value === '>=')
-                left = Number(left) >= Number(right);
+                left = leftValue >= rightValue;
         }
     };
     const parseEquality = () => {
@@ -241,7 +351,10 @@ export function evaluateDebugExpression(expression, variables) {
     };
     const parseAnd = () => {
         let left = parseEquality();
-        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '&&') {
+        while (true) {
+            const operator = tokens[cursor];
+            if (!operator || operator.type !== 'operator' || operator.value !== '&&')
+                break;
             cursor += 1;
             left = Boolean(left) && Boolean(parseEquality());
         }
@@ -249,7 +362,10 @@ export function evaluateDebugExpression(expression, variables) {
     };
     const parseOr = () => {
         let left = parseAnd();
-        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '||') {
+        while (true) {
+            const operator = tokens[cursor];
+            if (!operator || operator.type !== 'operator' || operator.value !== '||')
+                break;
             cursor += 1;
             left = Boolean(left) || Boolean(parseAnd());
         }

package/dist/debug/index.d.ts

@@ -1,5 +1,5 @@
 export { evaluateDebugExpression } from './expression';
 export { selectInlineDebugLocals } from './locals';
-export { cppDebugLanguageAdapter } from './language';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter } from './language';
 export { MonacoDebugView } from './editor';
 export type { DebugLanguageAdapter } from './language';

package/dist/debug/index.js

@@ -1,4 +1,4 @@
 export { evaluateDebugExpression } from './expression';
 export { selectInlineDebugLocals } from './locals';
-export { cppDebugLanguageAdapter } from './language';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter } from './language';
 export { MonacoDebugView } from './editor';

package/dist/debug/language/index.d.ts

@@ -1,2 +1,3 @@
 export { cppDebugLanguageAdapter } from './cpp';
+export { pythonDebugLanguageAdapter } from './python';
 export type { DebugLanguageAdapter } from './types';

package/dist/debug/language/index.js

@@ -1 +1,2 @@
 export { cppDebugLanguageAdapter } from './cpp';
+export { pythonDebugLanguageAdapter } from './python';

package/dist/debug/language/python.d.ts

@@ -0,0 +1,2 @@
+import type { DebugLanguageAdapter } from './types';
+export declare const pythonDebugLanguageAdapter: DebugLanguageAdapter;

package/dist/debug/language/python.js

@@ -0,0 +1,14 @@
+import { evaluateDebugExpression } from '../expression';
+const selectInlinePythonLocals = (lineText, locals) => {
+    const sanitized = lineText
+        .replace(/#.*$/g, ' ')
+        .replace(/"(?:\\.|[^"\\])*"/g, ' ')
+        .replace(/'(?:\\.|[^'\\])*'/g, ' ');
+    const identifiers = new Set(sanitized.match(/[A-Za-z_]\w*/g) || []);
+    return locals.filter((variable) => identifiers.has(variable.name));
+};
+export const pythonDebugLanguageAdapter = {
+    id: 'python',
+    evaluateExpression: evaluateDebugExpression,
+    selectInlineLocals: selectInlinePythonLocals
+};

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };
 export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
+export type { CompilerDiagnostic } from './playground/options';
 export type { DebugLanguageAdapter } from './debug';

package/dist/index.js

@@ -1,5 +1,5 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };