wasm-idle 0.4.1 → 0.6.0

package/dist/clang/index.js

@@ -137,6 +137,8 @@ export default class Clang {
     debugPauseOnEntry = false;
     debugBuffer;
     debugInterruptBuffer;
+    debugWatchBuffer;
+    debugWatchResultBuffer;
     onDebugEvent;
     debugVariableMetadata = {};
     debugGlobalMetadata = [];
@@ -185,7 +187,7 @@ export default class Clang {
         this.traceStartedAt = Date.now();
     }
     trace(message) {
-        if (!this.debug)
+        if (!this.debug || !this.log)
             return;
         const elapsed = Date.now() - this.traceStartedAt;
         this.stdout(`\x1b[2m[debug +${elapsed}ms] ${message}\x1b[0m\n`);
@@ -231,11 +233,98 @@ export default class Clang {
             let currentFunctionContainers = new Map();
             let inBlockComment = false;
             let pendingFunctionHeader;
+            const debugStructTypes = new Map();
+            let structName = '';
+            let structFields = [];
+            let structInBlockComment = false;
+            for (const rawLine of lines) {
+                let structLine = rawLine;
+                if (structInBlockComment) {
+                    const commentEnd = structLine.indexOf('*/');
+                    if (commentEnd === -1)
+                        continue;
+                    structLine = structLine.slice(commentEnd + 2);
+                    structInBlockComment = false;
+                }
+                const commentStart = structLine.indexOf('/*');
+                if (commentStart !== -1) {
+                    const commentEnd = structLine.indexOf('*/', commentStart + 2);
+                    if (commentEnd === -1) {
+                        structInBlockComment = true;
+                        structLine = structLine.slice(0, commentStart);
+                    }
+                    else {
+                        structLine =
+                            structLine.slice(0, commentStart) + structLine.slice(commentEnd + 2);
+                    }
+                }
+                const lineComment = structLine.indexOf('//');
+                if (lineComment !== -1)
+                    structLine = structLine.slice(0, lineComment);
+                const normalizedStructLine = structLine.trim();
+                if (!structName) {
+                    const structMatch = normalizedStructLine.match(/^struct\s+([A-Za-z_]\w*)\s*\{$/);
+                    if (structMatch?.[1]) {
+                        structName = structMatch[1];
+                        structFields = [];
+                    }
+                    continue;
+                }
+                if (normalizedStructLine === '};') {
+                    let structOffset = 0;
+                    let structAlignment = 1;
+                    const resolvedFields = [];
+                    for (const field of structFields) {
+                        const fieldSize = field.kind === 'double'
+                            ? 8
+                            : field.kind === 'bool' || field.kind === 'char'
+                                ? 1
+                                : 4;
+                        if (structOffset % fieldSize !== 0) {
+                            structOffset += fieldSize - (structOffset % fieldSize);
+                        }
+                        resolvedFields.push({
+                            name: field.name,
+                            kind: field.kind,
+                            offset: structOffset
+                        });
+                        structOffset += fieldSize;
+                        structAlignment = Math.max(structAlignment, fieldSize);
+                    }
+                    if (structOffset % structAlignment !== 0) {
+                        structOffset += structAlignment - (structOffset % structAlignment);
+                    }
+                    debugStructTypes.set(structName, {
+                        fields: resolvedFields,
+                        size: Math.max(structOffset, 1)
+                    });
+                    structName = '';
+                    structFields = [];
+                    continue;
+                }
+                const structFieldMatch = normalizedStructLine.match(/^(?:const\s+)?(?:(?:unsigned|signed)\s+)?(?:(?:short|long long|long)\s+)?(int|float|double|bool|char)\s+(.+);$/);
+                if (!structFieldMatch)
+                    continue;
+                for (const declaration of structFieldMatch[2].split(',')) {
+                    const declarator = declaration.split('=')[0]?.trim() || '';
+                    if (!declarator || /[*&\[]/.test(declarator))
+                        continue;
+                    const name = declarator.match(/([A-Za-z_]\w*)\s*$/)?.[1];
+                    if (!name)
+                        continue;
+                    structFields.push({
+                        name,
+                        kind: structFieldMatch[1]
+                    });
+                }
+            }
             this.debugVariableMetadata = {};
             this.debugGlobalMetadata = [];
             this.debugFunctionMetadata = {};
             const globalInitialization = [];
             const instrumented = [
+                '#include <cstdio>',
+                '#include <iostream>',
                 '#include <map>',
                 '#include <set>',
                 '#include <string>',
@@ -388,6 +477,29 @@ export default class Clang {
                         globalInitialization.push(`${kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(0, ${slot}, ${name});`);
                     }
                 }
+                const globalStructArrayMatch = isTopLevelDeclarationContext &&
+                    normalized.match(/^(?:const\s+)?([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*\[(\d+)\]\s*(?:=.*)?;$/);
+                if (globalStructArrayMatch) {
+                    const structType = debugStructTypes.get(globalStructArrayMatch[1]);
+                    if (structType) {
+                        const slot = nextVariableSlot++;
+                        this.debugGlobalMetadata = [
+                            ...this.debugGlobalMetadata,
+                            {
+                                slot,
+                                name: globalStructArrayMatch[2],
+                                kind: 'array',
+                                length: Number(globalStructArrayMatch[3]),
+                                dimensions: [Number(globalStructArrayMatch[3])],
+                                structFields: structType.fields,
+                                structSize: structType.size,
+                                fromLine: index + 1,
+                                toLine: Number.MAX_SAFE_INTEGER
+                            }
+                        ];
+                        globalInitialization.push(`__wasm_idle_debug_value_addr(0, ${slot}, (int)((unsigned long long)(${globalStructArrayMatch[2]})));`);
+                    }
+                }
                 if (inFunctionBody &&
                     normalized &&
                     !normalized.startsWith('#') &&
@@ -522,7 +634,7 @@ export default class Clang {
                                 slot,
                                 kind,
                                 fromLine: index + 1,
-                                toLine: index + 1
+                                toLine: Number.MAX_SAFE_INTEGER
                             });
                             this.debugVariableMetadata[currentFunctionId] = [
                                 ...(this.debugVariableMetadata[currentFunctionId] || []),
@@ -531,7 +643,7 @@ export default class Clang {
                                     name,
                                     kind,
                                     fromLine: index + 1,
-                                    toLine: index + 1
+                                    toLine: Number.MAX_SAFE_INTEGER
                                 }
                             ];
                         }
@@ -551,10 +663,23 @@ export default class Clang {
                                 continue;
                             if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
                                 new RegExp(`\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`).test(normalized) ||
-                                new RegExp(`&\\s*${escapedName}\\b`).test(normalized)) {
+                                new RegExp(`&\\s*${escapedName}\\b`).test(normalized) ||
+                                new RegExp(`\\b(?:cin|std::cin)\\b[^;]*>>\\s*${escapedName}\\b`).test(normalized)) {
                                 trailingInstrumentation.push(`${indent}${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name});`);
                             }
                         }
+                        for (const [name, variable] of globalVariables) {
+                            if (currentFunctionVariables.has(name) ||
+                                currentFunctionContainers.has(name))
+                                continue;
+                            const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                            if (new RegExp(`(?:^|[^\\w])(?:\\+\\+|--)\\s*${escapedName}\\b`).test(normalized) ||
+                                new RegExp(`\\b${escapedName}\\s*(?:[+\\-*/%]?=|\\+\\+|--)`).test(normalized) ||
+                                new RegExp(`&\\s*${escapedName}\\b`).test(normalized) ||
+                                new RegExp(`\\b(?:cin|std::cin)\\b[^;]*>>\\s*${escapedName}\\b`).test(normalized)) {
+                                trailingInstrumentation.push(`${indent}${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(0, ${variable.slot}, ${name});`);
+                            }
+                        }
                     }
                     if (/^return\b/.test(normalized))
                         leadingInstrumentation.push(`${indent}__wasm_idle_debug_leave(${currentFunctionId});`);
@@ -618,6 +743,7 @@ export default class Clang {
                                     const initSource = segments[0].trim();
                                     const updateSource = segments[2].trim();
                                     const initHooks = [];
+                                    const conditionHooks = [];
                                     const updateHooks = [];
                                     const initLooksLikeDeclaration = /^(?:const\s+)?(?:(?:unsigned|signed)\s+)?(?:(?:short|long long|long)\s+)?(?:int|float|double|bool|char)\b/.test(initSource);
                                     for (const [name, variable] of currentFunctionVariables) {
@@ -627,6 +753,10 @@ export default class Clang {
                                             mutationPattern.test(initSource)) {
                                             initHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
                                         }
+                                        if (initLooksLikeDeclaration &&
+                                            mutationPattern.test(initSource)) {
+                                            conditionHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
+                                        }
                                         if (mutationPattern.test(updateSource)) {
                                             updateHooks.push(`${variable.kind === 'bool' ? '__wasm_idle_debug_value_bool' : '__wasm_idle_debug_value_num'}(${currentFunctionId}, ${variable.slot}, ${name})`);
                                         }
@@ -639,7 +769,7 @@ export default class Clang {
                                         : segments[2];
                                     rewrittenLine =
                                         line.slice(0, openIndex + 1) +
-                                            `${instrumentedInit}; (__wasm_idle_debug_line(${currentFunctionId}, ${index + 1}), (${segments[1].trim()})); ${instrumentedUpdate}` +
+                                            `${instrumentedInit}; (${conditionHooks.length ? `${conditionHooks.join(', ')}, ` : ''}__wasm_idle_debug_line(${currentFunctionId}, ${index + 1}), (${segments[1].trim()})); ${instrumentedUpdate}` +
                                             line.slice(closeIndex);
                                 }
                             }
@@ -680,6 +810,12 @@ export default class Clang {
                     currentFunctionVariables = new Map();
                     currentFunctionContainers = new Map();
                     instrumented.push(`${indent}    __wasm_idle_debug_enter(${currentFunctionId}, ${index + 1});`);
+                    if (functionName === 'main') {
+                        instrumented.push(`${indent}    std::cout.setf(std::ios::unitbuf);`);
+                        instrumented.push(`${indent}    std::cerr.setf(std::ios::unitbuf);`);
+                        instrumented.push(`${indent}    setvbuf(stdout, nullptr, _IONBF, 0);`);
+                        instrumented.push(`${indent}    setvbuf(stderr, nullptr, _IONBF, 0);`);
+                    }
                     const parameterSource = startsInlineFunctionBody
                         ? normalized.slice(normalized.indexOf('(') + 1, normalized.lastIndexOf(')'))
                         : pendingFunctionHeader?.parameters || '';
@@ -847,7 +983,10 @@ export default class Clang {
         app.debugSession = {
             buffer: this.debugBuffer,
             interruptBuffer: this.debugInterruptBuffer,
+            watchBuffer: this.debugWatchBuffer,
+            watchResultBuffer: this.debugWatchResultBuffer,
             breakpoints: new Set(this.debugBreakpoints),
+            breakpointVersion: 0,
             pauseOnEntry: this.debugPauseOnEntry,
             stepArmed: this.debugPauseOnEntry,
             nextLineArmed: false,
@@ -878,13 +1017,15 @@ export default class Clang {
         return stillRunning ? app : null;
     }
     async compileLink(code, options = {}) {
-        const { language = 'CPP', args = [], compileArgs = args, debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
+        const { language = 'CPP', args = [], compileArgs = args, debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer, watchBuffer, watchResultBuffer } = options;
         const input = language === 'C' ? `test.c` : `test.cc`, obj = `test.o`, wasm = `test.wasm`;
         this.beginTrace(debug);
         this.debugBreakpoints = new Set(debug ? breakpoints : []);
         this.debugPauseOnEntry = debug && pauseOnEntry;
         this.debugBuffer = debugBuffer;
         this.debugInterruptBuffer = interruptBuffer;
+        this.debugWatchBuffer = watchBuffer;
+        this.debugWatchResultBuffer = watchResultBuffer;
         const buildKey = JSON.stringify({
             code,
             language,
@@ -913,7 +1054,7 @@ export default class Clang {
         return (this.wasm = await this.hostLogAsync(`Compiling ${wasm}`, WebAssembly.compile(wasmBytes)));
     }
     async compileLinkRun(code, options = {}) {
-        const { language = 'CPP', args = [], compileArgs = args, programArgs = [], debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer } = options;
+        const { language = 'CPP', args = [], compileArgs = args, programArgs = [], debug = false, breakpoints = [], pauseOnEntry = false, cppVersion, cVersion, debugBuffer, interruptBuffer, watchBuffer, watchResultBuffer } = options;
         this.debug = debug;
         return await this.run(await this.compileLink(code, {
             language,
@@ -924,7 +1065,9 @@ export default class Clang {
             cppVersion,
             cVersion,
             debugBuffer,
-            interruptBuffer
+            interruptBuffer,
+            watchBuffer,
+            watchResultBuffer
         }), true, `test.wasm`, ...programArgs);
     }
 }

package/dist/clangd/worker.js

@@ -26,6 +26,7 @@ const stdinReady = async () => {
     }
 };
 let writer = null;
+let clangdRuntime = null;
 const stdout = (charCode) => {
     const json = jsonStream.insert(charCode);
     if (json && writer)
@@ -36,7 +37,22 @@ const onAbort = () => {
     writer?.end();
     self.reportError?.('clangd aborted');
 };
+const syncWorkspaceFile = (filePath) => {
+    if (!clangdRuntime)
+        return;
+    const normalizedFilePath = filePath.startsWith(CLANGD_WORKSPACE_PATH)
+        ? filePath
+        : `${CLANGD_WORKSPACE_PATH}/${filePath.replace(/^\/+/, '')}`;
+    const lastSlash = normalizedFilePath.lastIndexOf('/');
+    const directoryPath = lastSlash > 0 ? normalizedFilePath.slice(0, lastSlash) : CLANGD_WORKSPACE_PATH;
+    clangdRuntime.FS.mkdirTree(directoryPath);
+    clangdRuntime.FS.writeFile(normalizedFilePath, '');
+};
 self.addEventListener('message', async (event) => {
+    if (event.data?.type === 'sync-file' && typeof event.data?.name === 'string') {
+        syncWorkspaceFile(event.data.name);
+        return;
+    }
     if (event.data?.type !== 'init')
         return;
     const baseUrl = normalizeClangdBaseUrl(event.data.baseUrl);
@@ -91,7 +107,7 @@ self.addEventListener('message', async (event) => {
         const wasmBlob = new Blob([wasmBytes.buffer], { type: 'application/wasm' });
         const wasmDataUrl = URL.createObjectURL(wasmBlob);
         const { default: Clangd } = await jsModule;
-        const clangd = await Clangd({
+        clangdRuntime = await Clangd({
             thisProgram: '/usr/bin/clangd',
             mainScriptUrlOrBlob: jsDataUrl,
             locateFile: (path, prefix) => path.endsWith('.wasm') ? wasmDataUrl : `${prefix}${path}`,
@@ -102,14 +118,14 @@ self.addEventListener('message', async (event) => {
             onExit: onAbort,
             onAbort
         });
-        clangd.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
-        clangd.FS.writeFile(CLANGD_CPP_FILE_PATH, '');
-        clangd.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
+        clangdRuntime.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
+        syncWorkspaceFile(CLANGD_CPP_FILE_PATH);
+        clangdRuntime.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
             CompileFlags: {
                 Add: createClangdCompileFlags()
             }
         }));
-        clangd.callMain([]);
+        clangdRuntime.callMain([]);
         writer = new BrowserMessageWriter(self);
         const reader = new BrowserMessageReader(self);
         reader.listen((data) => {

package/dist/debug/controller.svelte.d.ts

@@ -0,0 +1,43 @@
+import type { DebugLanguageAdapter } from './language';
+import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable } from '../playground/options';
+import type { TerminalControl } from '../terminal';
+export type DebugWatchValue = {
+    expression: string;
+    value: string;
+};
+export type DebugSessionControllerOptions = {
+    terminal?: TerminalControl;
+    adapter?: DebugLanguageAdapter | null;
+    breakpoints?: number[];
+    cursorLine?: number | null;
+    syncBreakpointsWhile?: boolean | (() => boolean);
+};
+export declare function createDebugSessionController(options?: DebugSessionControllerOptions): {
+    readonly active: boolean;
+    readonly paused: boolean;
+    readonly pausedLine: number | null;
+    readonly locals: DebugVariable[];
+    readonly callStack: DebugFrame[];
+    readonly runToCursorLine: number | null;
+    readonly breakpoints: number[];
+    readonly effectiveBreakpoints: number[];
+    readonly cursorLine: number | null;
+    readonly canRunToCursor: boolean;
+    watchInput: string;
+    readonly watchExpressions: string[];
+    readonly watchValues: DebugWatchValue[];
+    begin: () => void;
+    reset: () => void;
+    handleEvent: (event: DebugSessionEvent) => void;
+    setTerminal: (terminal?: TerminalControl) => void;
+    setAdapter: (adapter: DebugLanguageAdapter | null) => void;
+    setBreakpoints: (lines: number[]) => void;
+    setCursorLine: (line: number | null) => void;
+    sendCommand: (command: DebugCommand) => Promise<boolean>;
+    runToCursor: (targetLine?: number | null) => Promise<boolean>;
+    stop: () => Promise<boolean>;
+    addWatchExpression: (expression?: string) => boolean;
+    removeWatchExpression: (expression: string) => void;
+    clearWatches: () => void;
+};
+export type DebugSessionController = ReturnType<typeof createDebugSessionController>;

package/dist/debug/controller.svelte.js

@@ -0,0 +1,268 @@
+import { fromStore, get, writable } from 'svelte/store';
+export function createDebugSessionController(options = {}) {
+    const activeStore = writable(false);
+    const pausedStore = writable(false);
+    const pausedLineStore = writable(null);
+    const localsStore = writable([]);
+    const callStackStore = writable([]);
+    const runToCursorLineStore = writable(null);
+    const watchInputStore = writable('');
+    const watchExpressionsStore = writable([]);
+    const watchValuesStore = writable([]);
+    const breakpointsStore = writable([...(options.breakpoints || [])]);
+    const cursorLineStore = writable(options.cursorLine ?? null);
+    const terminalStore = writable(options.terminal);
+    const adapterStore = writable(options.adapter ?? null);
+    const activeState = fromStore(activeStore);
+    const pausedState = fromStore(pausedStore);
+    const pausedLineState = fromStore(pausedLineStore);
+    const localsState = fromStore(localsStore);
+    const callStackState = fromStore(callStackStore);
+    const runToCursorLineState = fromStore(runToCursorLineStore);
+    const watchInputState = fromStore(watchInputStore);
+    const watchExpressionsState = fromStore(watchExpressionsStore);
+    const watchValuesState = fromStore(watchValuesStore);
+    const breakpointsState = fromStore(breakpointsStore);
+    const cursorLineState = fromStore(cursorLineStore);
+    const terminalState = fromStore(terminalStore);
+    const adapterState = fromStore(adapterStore);
+    let watchRequestVersion = 0;
+    function shouldSyncBreakpoints() {
+        if (typeof options.syncBreakpointsWhile === 'function') {
+            return options.syncBreakpointsWhile();
+        }
+        if (typeof options.syncBreakpointsWhile === 'boolean') {
+            return options.syncBreakpointsWhile;
+        }
+        return get(activeStore);
+    }
+    function getEffectiveBreakpoints() {
+        const lines = [...get(breakpointsStore)];
+        const runToCursorLine = get(runToCursorLineStore);
+        if (runToCursorLine !== null && !lines.includes(runToCursorLine))
+            lines.push(runToCursorLine);
+        return lines.sort((left, right) => left - right);
+    }
+    function refreshWatchValues() {
+        const expressions = [...get(watchExpressionsStore)];
+        const adapter = get(adapterStore);
+        const localVariables = [...get(localsStore)];
+        const paused = get(pausedStore);
+        const terminal = get(terminalStore);
+        const version = ++watchRequestVersion;
+        if (!expressions.length) {
+            watchValuesStore.set([]);
+            return;
+        }
+        if (paused && terminal?.debugEvaluate) {
+            watchValuesStore.set(expressions.map((expression) => ({ expression, value: '...' })));
+            (async () => {
+                const resolved = [];
+                for (const expression of expressions) {
+                    resolved.push({
+                        expression,
+                        value: await terminal.debugEvaluate(expression)
+                    });
+                }
+                if (version === watchRequestVersion)
+                    watchValuesStore.set(resolved);
+            })().catch(() => {
+                if (version === watchRequestVersion) {
+                    watchValuesStore.set(expressions.map((expression) => ({ expression, value: 'error' })));
+                }
+            });
+            return;
+        }
+        watchValuesStore.set(expressions.map((expression) => {
+            try {
+                return {
+                    expression,
+                    value: adapter ? adapter.evaluateExpression(expression, localVariables) : 'error'
+                };
+            }
+            catch (error) {
+                return {
+                    expression,
+                    value: error instanceof Error && error.message === 'unavailable' ? '?' : 'error'
+                };
+            }
+        }));
+    }
+    function syncBreakpoints() {
+        const terminal = get(terminalStore);
+        if (!shouldSyncBreakpoints() || !terminal?.setBreakpoints)
+            return;
+        void terminal.setBreakpoints(getEffectiveBreakpoints());
+    }
+    function clearPauseState() {
+        runToCursorLineStore.set(null);
+        pausedLineStore.set(null);
+        localsStore.set([]);
+        callStackStore.set([]);
+        pausedStore.set(false);
+    }
+    function reset() {
+        activeStore.set(false);
+        clearPauseState();
+        refreshWatchValues();
+    }
+    function begin() {
+        activeStore.set(true);
+        clearPauseState();
+        refreshWatchValues();
+        syncBreakpoints();
+    }
+    function handleEvent(event) {
+        if (event.type === 'pause') {
+            activeStore.set(true);
+            runToCursorLineStore.set(null);
+            pausedLineStore.set(event.line);
+            localsStore.set(event.locals);
+            callStackStore.set(event.callStack);
+            pausedStore.set(true);
+            refreshWatchValues();
+            return;
+        }
+        if (event.type === 'resume') {
+            pausedStore.set(false);
+            pausedLineStore.set(null);
+            localsStore.set([]);
+            callStackStore.set([]);
+            refreshWatchValues();
+            return;
+        }
+        reset();
+    }
+    function setTerminal(terminal) {
+        terminalStore.set(terminal);
+        refreshWatchValues();
+        syncBreakpoints();
+    }
+    function setAdapter(adapter) {
+        adapterStore.set(adapter);
+        refreshWatchValues();
+    }
+    function setBreakpoints(lines) {
+        breakpointsStore.set([...lines]);
+        syncBreakpoints();
+    }
+    function setCursorLine(line) {
+        cursorLineStore.set(line);
+    }
+    function addWatchExpression(expression) {
+        const watchInput = get(watchInputStore);
+        const watchExpressions = get(watchExpressionsStore);
+        const nextExpression = (expression || watchInput).trim();
+        if (!nextExpression || watchExpressions.includes(nextExpression))
+            return false;
+        watchExpressionsStore.set([...watchExpressions, nextExpression]);
+        watchInputStore.set('');
+        refreshWatchValues();
+        return true;
+    }
+    function removeWatchExpression(expression) {
+        watchExpressionsStore.set(get(watchExpressionsStore).filter((entry) => entry !== expression));
+        refreshWatchValues();
+    }
+    function clearWatches() {
+        watchInputStore.set('');
+        watchExpressionsStore.set([]);
+        refreshWatchValues();
+    }
+    async function sendCommand(command) {
+        const terminal = get(terminalStore);
+        if (!terminal || !get(pausedStore))
+            return false;
+        await terminal.debugCommand(command);
+        return true;
+    }
+    async function runToCursor(targetLine = get(cursorLineStore)) {
+        const terminal = get(terminalStore);
+        const breakpoints = get(breakpointsStore);
+        if (!terminal ||
+            !get(pausedStore) ||
+            !targetLine ||
+            targetLine === get(pausedLineStore) ||
+            !terminal.setBreakpoints) {
+            return false;
+        }
+        const nextBreakpoints = breakpoints.includes(targetLine)
+            ? [...breakpoints]
+            : [...breakpoints, targetLine].sort((left, right) => left - right);
+        runToCursorLineStore.set(breakpoints.includes(targetLine) ? null : targetLine);
+        await terminal.setBreakpoints(nextBreakpoints);
+        await terminal.debugCommand('continue');
+        return true;
+    }
+    async function stop() {
+        const terminal = get(terminalStore);
+        if (!terminal)
+            return false;
+        reset();
+        await terminal.stop?.();
+        return true;
+    }
+    return {
+        get active() {
+            return activeState.current;
+        },
+        get paused() {
+            return pausedState.current;
+        },
+        get pausedLine() {
+            return pausedLineState.current;
+        },
+        get locals() {
+            return localsState.current;
+        },
+        get callStack() {
+            return callStackState.current;
+        },
+        get runToCursorLine() {
+            return runToCursorLineState.current;
+        },
+        get breakpoints() {
+            return breakpointsState.current;
+        },
+        get effectiveBreakpoints() {
+            return getEffectiveBreakpoints();
+        },
+        get cursorLine() {
+            return cursorLineState.current;
+        },
+        get canRunToCursor() {
+            const cursorLine = cursorLineState.current;
+            const terminal = terminalState.current;
+            return (pausedState.current &&
+                cursorLine !== null &&
+                cursorLine > 0 &&
+                cursorLine !== pausedLineState.current &&
+                !!terminal?.setBreakpoints);
+        },
+        get watchInput() {
+            return watchInputState.current;
+        },
+        set watchInput(value) {
+            watchInputStore.set(value);
+        },
+        get watchExpressions() {
+            return watchExpressionsState.current;
+        },
+        get watchValues() {
+            return watchValuesState.current;
+        },
+        begin,
+        reset,
+        handleEvent,
+        setTerminal,
+        setAdapter,
+        setBreakpoints,
+        setCursorLine,
+        sendCommand,
+        runToCursor,
+        stop,
+        addWatchExpression,
+        removeWatchExpression,
+        clearWatches
+    };
+}

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

@@ -1 +1,2 @@
-export { MonacoDebugView } from './monaco';
+export { MonacoDebugView, attachMonacoDebugActions } from './monaco';
+export type { MonacoDebugActionsOptions } from './monaco';

package/dist/debug/editor/index.js

@@ -1 +1 @@
-export { MonacoDebugView } from './monaco';
+export { MonacoDebugView, attachMonacoDebugActions } from './monaco';

package/dist/debug/editor/monaco.d.ts

@@ -1,6 +1,11 @@
 import type { DebugVariable } from '../../playground/options';
 import type { DebugLanguageAdapter } from '../language';
 import type monaco from 'monaco-editor';
+export type MonacoDebugActionsOptions = {
+    runToCursorLabel?: string;
+    onCursorLineChange?: (line: number | null) => void;
+    onRunToCursor?: (line: number | null) => void;
+};
 export declare class MonacoDebugView {
     Monaco: typeof monaco;
     editor: monaco.editor.IStandaloneCodeEditor;
@@ -16,3 +21,6 @@ export declare class MonacoDebugView {
     setPauseState(pausedLine: number | null, locals: DebugVariable[], adapter: DebugLanguageAdapter | null): void;
     dispose(): void;
 }
+export declare function attachMonacoDebugActions(editor: monaco.editor.IStandaloneCodeEditor, options?: MonacoDebugActionsOptions): {
+    dispose(): void;
+};