warpo 3.1.3 → 3.2.1

package/dist/debug_server/tests/debugSession.test.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { DebugClient } from "@vscode/debugadapter-testsupport";
 import * as assert from "node:assert/strict";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { describe, it, beforeEach, afterEach } from "node:test";
 import { fileURLToPath } from "node:url";
@@ -73,8 +74,13 @@ function findVariable(variables, name) {
 async function launchAndWaitForBreakpoint(dc, launchArgs) {
     const stoppedPromise = waitForBreakpointStop(dc);
     await dc.launchRequest(launchArgs);
+    await dc.configurationDoneRequest({});
     await stoppedPromise;
 }
+async function launchAndConfigure(dc, launchArgs) {
+    await dc.launchRequest(launchArgs);
+    await dc.configurationDoneRequest({});
+}
 async function readFrameLocals(dc, frame) {
     const scopesResponse = await dc.scopesRequest({ frameId: frame.id });
     const localsScope = assertDefined(scopesResponse.body.scopes.find((scope) => scope.name.startsWith("Local:")));
@@ -132,18 +138,49 @@ void describe("WarpoDebugSession", () => {
             await waitForExit(serverChild, 1000);
         }
     });
-    void it("should accept breakpoints and return them verified", async () => {
+    void it("should return breakpoints unverified before a wasm module is loaded", async () => {
         await dc.initializeRequest();
         const response = await dc.setBreakpointsRequest({
             source: { path: "test.ts" },
             breakpoints: [{ line: 5 }, { line: 10 }],
         });
         assert.equal(response.body.breakpoints.length, 2);
-        assert.equal(response.body.breakpoints[0].verified, true);
+        assert.equal(response.body.breakpoints[0].verified, false);
         assert.equal(response.body.breakpoints[0].line, 5);
-        assert.equal(response.body.breakpoints[1].verified, true);
+        assert.equal(response.body.breakpoints[1].verified, false);
         assert.equal(response.body.breakpoints[1].line, 10);
     });
+    void it("should reject breakpoints without wasm bytecode mappings", { timeout: 10000 }, async () => {
+        const source = sourcePath("debugger_breakpoint_validation.ts");
+        const output = await buildModule(source);
+        const validLine = 7;
+        await dc.initializeRequest();
+        const initialResponse = await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: validLine }],
+        });
+        assert.equal(initialResponse.body.breakpoints[0].verified, false);
+        const breakpointChangedPromise = dc.waitForEvent("breakpoint");
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const breakpointChangedEvent = await breakpointChangedPromise;
+        const breakpointChangedBody = breakpointChangedEvent.body;
+        assert.equal(breakpointChangedBody?.reason, "changed");
+        assert.equal(breakpointChangedBody?.breakpoint?.verified, true);
+        const response = await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: 5 }, { line: 6 }, { line: validLine }],
+        });
+        assert.equal(response.body.breakpoints[0].verified, false);
+        assert.equal(response.body.breakpoints[1].verified, false);
+        assert.equal(response.body.breakpoints[2].verified, true);
+        await dc.disconnectRequest({ terminateDebuggee: true });
+    });
     void it("should stop in a unit test after returning from main", { timeout: 15000 }, async () => {
         const testSource = sourcePath("unittest_debug.case.ts");
         const implementationSource = sourcePath("unittest_debug.ts");
@@ -173,33 +210,128 @@ void describe("WarpoDebugSession", () => {
         assert.equal(assertDefined(stackTraceResponse.body.stackFrames[0]).source?.path, normalizeDebugPath(testSource));
         assert.equal(stackTraceResponse.body.stackFrames[0].line, 9);
     });
+    void it("should step over a JavaScript import during step into", { timeout: 15000 }, async () => {
+        const implementationSource = sourcePath("debugger_import.ts");
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: implementationSource },
+            breakpoints: [{ line: 7 }],
+        });
+        const launchArgs = {
+            launchType: "unittest",
+            runtime: "node",
+            cwd: TEST_MODULE_DIR,
+            warpoPath: WARPO_CLI,
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(implementationSource));
+        assert.equal(frame.line, 8);
+    });
     void it("should report the built wasm as a loaded source on launch", { timeout: 5000 }, async () => {
         const source = sourcePath("debugger_basic.ts");
         const output = await buildModule(source);
         const breakpointLine = 13;
+        const traceFile = path.join(TEST_MODULE_DIR, "build", "test_debug_trace.log");
+        if (fs.existsSync(traceFile)) {
+            fs.unlinkSync(traceFile);
+        }
         await dc.initializeRequest();
         const breakpointResponse = await dc.setBreakpointsRequest({
             source: { path: source },
             breakpoints: [{ line: breakpointLine }],
         });
         assert.equal(breakpointResponse.body.breakpoints.length, 1);
-        assert.equal(breakpointResponse.body.breakpoints[0].verified, true);
+        assert.equal(breakpointResponse.body.breakpoints[0].verified, false);
         assert.equal(breakpointResponse.body.breakpoints[0].line, breakpointLine);
         const launchArgs = {
             program: output,
             launchType: "wasm file",
             runtime: "node",
             entryFunctionName: "_start",
+            debugSessionLogFile: traceFile,
         };
         const loadedSourcePromise = waitForLoadedWasmSource(dc, output);
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         const loadedSourceEvent = await loadedSourcePromise;
         const loadedSourceBody = loadedSourceEvent.body;
         await stoppedPromise;
         assert.equal(loadedSourceBody?.reason, "new");
         assert.equal(loadedSourceBody?.source?.path, path.resolve(output));
         assert.equal(loadedSourceBody?.source?.name, path.basename(output));
+        assert.equal(fs.existsSync(traceFile), true, "debugSessionLogFile should be created on launch");
+        if (fs.existsSync(traceFile)) {
+            fs.unlinkSync(traceFile);
+        }
+    });
+    void it("should stop at a breakpoint in the AssemblyScript standard library", { timeout: 15000 }, async () => {
+        const source = sourcePath("debugger_std_array.ts");
+        const stdSource = path.resolve(DIRNAME, "..", "..", "..", "assemblyscript", "std", "assembly", "array.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 101;
+        const traceFile = path.join(TEST_MODULE_DIR, "build", "test_std_breakpoint_trace.log");
+        if (fs.existsSync(traceFile)) {
+            fs.unlinkSync(traceFile);
+        }
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: stdSource },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints[0].verified, false);
+        const breakpointChangedPromise = dc.waitForEvent("breakpoint");
+        const stoppedPromise = waitForBreakpointStop(dc);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+            debugSessionLogFile: traceFile,
+        };
+        await launchAndConfigure(dc, launchArgs);
+        const breakpointChangedEvent = await breakpointChangedPromise;
+        const breakpointChangedBody = breakpointChangedEvent.body;
+        assert.equal(breakpointChangedBody?.reason, "changed");
+        assert.equal(breakpointChangedBody?.breakpoint?.verified, true);
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(stdSource));
+        assert.equal(frame.line, breakpointLine);
+        assert.equal(fs.existsSync(traceFile), true, "debugSessionLogFile should be created on launch");
+        if (fs.existsSync(traceFile)) {
+            fs.unlinkSync(traceFile);
+        }
+    });
+    void it("should restart the debuggee and restore breakpoints", { timeout: 10000 }, async () => {
+        const source = sourcePath("debugger_basic.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 13;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const restartedStop = waitForBreakpointStop(dc);
+        await dc.restartRequest({});
+        await restartedStop;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(source));
+        assert.equal(frame.line, breakpointLine);
+        await dc.disconnectRequest({ terminateDebuggee: true });
     });
     void it("should reject a wasm launch when the file is missing", { timeout: 5000 }, async () => {
         await dc.initializeRequest();
@@ -211,7 +343,7 @@ void describe("WarpoDebugSession", () => {
         };
         const stderrPromise = waitForStderrOutput(dc);
         const terminatedPromise = dc.waitForEvent("terminated");
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         const stderrEvent = await stderrPromise;
         const stderrBody = stderrEvent.body;
         assert.match(stderrBody?.output ?? "", /Wasm file not found/);
@@ -229,7 +361,7 @@ void describe("WarpoDebugSession", () => {
         };
         const stderrPromise = waitForStderrOutput(dc);
         const terminatedPromise = dc.waitForEvent("terminated");
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         const stderrEvent = await stderrPromise;
         const stderrBody = stderrEvent.body;
         assert.match(stderrBody?.output ?? "", /Failed to load wasm module/);
@@ -342,7 +474,7 @@ void describe("WarpoDebugSession", () => {
         await dc.continueRequest({ threadId: 1 });
         await terminatedPromise;
     });
-    void it("should add a breakpoint while the program is executing", { timeout: 10000 }, async () => {
+    void it("should add breakpoints after launch and while the program is executing", { timeout: 10000 }, async () => {
         const source = sourcePath("debugger_breakpoint_update.ts");
         const output = await buildModule(source);
         const initialBreakpointLine = 6;
@@ -358,7 +490,15 @@ void describe("WarpoDebugSession", () => {
             runtime: "node",
             entryFunctionName: "_start",
         };
-        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const firstStop = waitForBreakpointStop(dc);
+        await dc.launchRequest(launchArgs);
+        const initialBreakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: initialBreakpointLine }],
+        });
+        assert.equal(initialBreakpointResponse.body.breakpoints[0].line, initialBreakpointLine);
+        await dc.configurationDoneRequest({});
+        await firstStop;
         const secondStop = waitForBreakpointStop(dc);
         await dc.continueRequest({ threadId: 1 });
         const breakpointResponse = await dc.setBreakpointsRequest({
@@ -402,6 +542,93 @@ void describe("WarpoDebugSession", () => {
         assert.equal(delta.type, "i32");
         assert.equal(delta.value, "2");
     });
+    void it("should expose a function object's name without its runtime fields", { timeout: 10000 }, async () => {
+        const source = sourcePath("debugger_function_closure.ts");
+        const output = await buildModule(source);
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: 25 }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        const variablesResponse = await readFrameLocals(dc, frame);
+        const f1 = assertDefined(findVariable(variablesResponse.body.variables, "f1"));
+        assert.ok(f1.variablesReference > 0);
+        const f1FieldsResponse = await dc.variablesRequest({ variablesReference: f1.variablesReference });
+        assert.deepEqual(f1FieldsResponse.body.variables.map((variable) => variable.name), ["name", "[[scopes]]"]);
+        const f1Name = assertDefined(findVariable(f1FieldsResponse.body.variables, "name"));
+        assert.match(f1Name.value, /outer/);
+        assert.equal(f1Name.type, "string");
+        assert.equal(f1Name.variablesReference, 0);
+        const f1Scopes = assertDefined(findVariable(f1FieldsResponse.body.variables, "[[scopes]]"));
+        assert.equal(f1Scopes.value, "Scopes[2]");
+        assert.equal(f1Scopes.type, "Scopes");
+        assert.ok(f1Scopes.variablesReference > 0);
+        const f1ScopeArrayResponse = await dc.variablesRequest({ variablesReference: f1Scopes.variablesReference });
+        assert.deepEqual(f1ScopeArrayResponse.body.variables.map((variable) => variable.name), ["0", "1"]);
+        const f1MiddleScope = assertDefined(findVariable(f1ScopeArrayResponse.body.variables, "0"));
+        assert.equal(f1MiddleScope.value, "Closure(middle)");
+        assert.ok(f1MiddleScope.variablesReference > 0);
+        const f1MiddleScopeResponse = await dc.variablesRequest({ variablesReference: f1MiddleScope.variablesReference });
+        const f1CapturedB = assertDefined(findVariable(f1MiddleScopeResponse.body.variables, "b"));
+        assert.equal(f1CapturedB.value, "2");
+        assert.equal(f1CapturedB.type, "i32");
+        const f1OuterScope = assertDefined(findVariable(f1ScopeArrayResponse.body.variables, "1"));
+        assert.equal(f1OuterScope.value, "Closure(outer)");
+        assert.ok(f1OuterScope.variablesReference > 0);
+        const f1OuterScopeResponse = await dc.variablesRequest({ variablesReference: f1OuterScope.variablesReference });
+        const f1CapturedA = assertDefined(findVariable(f1OuterScopeResponse.body.variables, "a"));
+        assert.equal(f1CapturedA.value, "5");
+        assert.equal(f1CapturedA.type, "i32");
+        const f1CapturedC = assertDefined(findVariable(f1OuterScopeResponse.body.variables, "c"));
+        assert.ok(f1CapturedC.variablesReference > 0);
+        const f1CapturedCResponse = await dc.variablesRequest({ variablesReference: f1CapturedC.variablesReference });
+        const f1CapturedCValue = assertDefined(findVariable(f1CapturedCResponse.body.variables, "a"));
+        assert.equal(f1CapturedCValue.value, "10");
+        assert.equal(f1CapturedCValue.type, "i32");
+        const f2 = assertDefined(findVariable(variablesResponse.body.variables, "f2"));
+        assert.ok(f2.variablesReference > 0);
+        const f2FieldsResponse = await dc.variablesRequest({ variablesReference: f2.variablesReference });
+        assert.deepEqual(f2FieldsResponse.body.variables.map((variable) => variable.name), ["name", "[[scopes]]"]);
+        const f2Name = assertDefined(findVariable(f2FieldsResponse.body.variables, "name"));
+        assert.match(f2Name.value, /outer/);
+        assert.equal(f2Name.type, "string");
+        assert.equal(f2Name.variablesReference, 0);
+        const f2Scopes = assertDefined(findVariable(f2FieldsResponse.body.variables, "[[scopes]]"));
+        assert.equal(f2Scopes.value, "Scopes[2]");
+        assert.equal(f2Scopes.type, "Scopes");
+        assert.ok(f2Scopes.variablesReference > 0);
+        const f2ScopeArrayResponse = await dc.variablesRequest({ variablesReference: f2Scopes.variablesReference });
+        assert.deepEqual(f2ScopeArrayResponse.body.variables.map((variable) => variable.name), ["0", "1"]);
+        const f2MiddleScope = assertDefined(findVariable(f2ScopeArrayResponse.body.variables, "0"));
+        assert.equal(f2MiddleScope.value, "Closure(middle)");
+        assert.ok(f2MiddleScope.variablesReference > 0);
+        const f2MiddleScopeResponse = await dc.variablesRequest({ variablesReference: f2MiddleScope.variablesReference });
+        const f2CapturedB = assertDefined(findVariable(f2MiddleScopeResponse.body.variables, "b"));
+        assert.equal(f2CapturedB.value, "2");
+        assert.equal(f2CapturedB.type, "i32");
+        const f2OuterScope = assertDefined(findVariable(f2ScopeArrayResponse.body.variables, "1"));
+        assert.equal(f2OuterScope.value, "Closure(outer)");
+        assert.ok(f2OuterScope.variablesReference > 0);
+        const f2OuterScopeResponse = await dc.variablesRequest({ variablesReference: f2OuterScope.variablesReference });
+        const f2CapturedA = assertDefined(findVariable(f2OuterScopeResponse.body.variables, "a"));
+        assert.equal(f2CapturedA.value, "10");
+        assert.equal(f2CapturedA.type, "i32");
+        const f2CapturedC = assertDefined(findVariable(f2OuterScopeResponse.body.variables, "c"));
+        assert.ok(f2CapturedC.variablesReference > 0);
+        const f2CapturedCResponse = await dc.variablesRequest({ variablesReference: f2CapturedC.variablesReference });
+        const f2CapturedCValue = assertDefined(findVariable(f2CapturedCResponse.body.variables, "a"));
+        assert.equal(f2CapturedCValue.value, "15");
+        assert.equal(f2CapturedCValue.type, "i32");
+    });
     void it("should expose wasm call stack frames after hitting a breakpoint", { timeout: 5000 }, async () => {
         const source = sourcePath("debugger_basic.ts");
         const output = await buildModule(source);
@@ -467,7 +694,6 @@ void describe("WarpoDebugSession", () => {
         const calleeSource = sourcePath("debugger_callee.ts");
         const output = await buildModule(entrySource, [calleeSource]);
         const breakpointLine = 41;
-        await dc.initializeRequest();
         await dc.setBreakpointsRequest({
             source: { path: calleeSource },
             breakpoints: [{ line: breakpointLine }],
@@ -495,6 +721,241 @@ void describe("WarpoDebugSession", () => {
         assert.equal(callerSeed.type, "i32");
         assert.equal(callerSeed.value, "23");
     });
+    void it("should step into a callee", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 5 }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 11);
+    });
+    void it("should skip library frames during step into", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_closure_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 11 }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "main",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 6);
+    });
+    void it("should step within a standard library function", { timeout: 15000 }, async () => {
+        const source = sourcePath("debugger_string_stepping.ts");
+        const stdSource = path.resolve(DIRNAME, "..", "..", "..", "assemblyscript", "std", "assembly", "string.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 102;
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: stdSource },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints[0].verified, false);
+        const breakpointChangedPromise = dc.waitForEvent("breakpoint");
+        const stoppedPromise = waitForBreakpointStop(dc);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndConfigure(dc, launchArgs);
+        await breakpointChangedPromise;
+        await stoppedPromise;
+        const firstStackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const firstFrame = assertDefined(firstStackTraceResponse.body.stackFrames[0]);
+        assert.equal(firstFrame.source?.path, normalizeDebugPath(stdSource));
+        assert.equal(firstFrame.line, breakpointLine);
+        const nextStoppedPromise = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await nextStoppedPromise;
+        const nextStackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const nextFrame = assertDefined(nextStackTraceResponse.body.stackFrames[0]);
+        assert.equal(nextFrame.source?.path, normalizeDebugPath(stdSource));
+        assert.notEqual(nextFrame.line, breakpointLine);
+    });
+    void it("should pause at a valid source line", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_pause.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 4 }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const continuedPromise = dc.waitForEvent("continued");
+        await dc.continueRequest({ threadId: 1 });
+        await continuedPromise;
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.pauseRequest({ threadId: 1 });
+        const stoppedEvent = await stoppedPromise;
+        const stoppedBody = stoppedEvent.body;
+        assert.equal(stoppedBody?.reason, "pause");
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.ok(frame.line > 0);
+        const terminatedPromise = dc.waitForEvent("terminated");
+        await dc.terminateRequest({ restart: false });
+        await terminatedPromise;
+    });
+    void it("should step out of a callee and stop at the caller", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 5 }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const enteredCallee = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await enteredCallee;
+        const returnedToCaller = dc.waitForEvent("stopped");
+        await dc.stepOutRequest({ threadId: 1 });
+        await returnedToCaller;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.match(frame.name, /_start/);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 5);
+    });
+    void it("should step over a callee and stop at the caller's next line", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 5 }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints.length, 1);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.nextRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 6);
+    });
+    void it("should step over a function-object call and stop at the caller's next line", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 18 }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints.length, 1);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "indirectStart",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.nextRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 19);
+    });
+    void it("should step into a function-object call", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 18 }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints.length, 1);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "indirectStart",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.stepInRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 11);
+    });
+    void it("should step over a call that is the last instruction of a function", { timeout: 10000 }, async () => {
+        const entrySource = sourcePath("debugger_stepping.ts");
+        const output = await buildModule(entrySource);
+        await dc.initializeRequest();
+        const breakpointResponse = await dc.setBreakpointsRequest({
+            source: { path: entrySource },
+            breakpoints: [{ line: 24 }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints.length, 1);
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "tailCallStart",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const stoppedPromise = dc.waitForEvent("stopped");
+        await dc.nextRequest({ threadId: 1 });
+        await stoppedPromise;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.match(frame.name, /tailCallStart/);
+        assert.equal(frame.source?.path, normalizeDebugPath(entrySource));
+        assert.equal(frame.line, 29);
+    });
     void it("should stop on a return breakpoint before evaluating its value", { timeout: 5000 }, async () => {
         const entrySource = sourcePath("debugger_caller.ts");
         const calleeSource = sourcePath("debugger_callee.ts");
@@ -559,7 +1020,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -612,7 +1073,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -650,7 +1111,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -706,6 +1167,79 @@ void describe("WarpoDebugSession", () => {
             { name: "2", type: "u8", value: "34", variablesReference: 0 },
         ]);
     });
+    void it("should display utf8.ConstStr values", { timeout: 5000 }, async () => {
+        const source = sourcePath("debugger_utf8_const_str.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 11;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        const { variablesResponse } = await launchAndReadTopFrameLocals(dc, launchArgs);
+        const value = assertDefined(findVariable(variablesResponse.body.variables, "s"));
+        assert.equal(value.type, "~lib/warpo/utf8/const_str/ConstStr");
+        assert.equal(value.value, '"abcdef"');
+        assert.equal(value.variablesReference, 0);
+    });
+    void it("should expand typed array values by index", { timeout: 5000 }, async () => {
+        const source = sourcePath("debugger_typed_array.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 41;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        const { variablesResponse } = await launchAndReadTopFrameLocals(dc, launchArgs);
+        const expected = [
+            { name: "int8", type: "~lib/typedarray/Int8Array", elementType: "i8", values: ["-8", "8"] },
+            { name: "uint8", type: "~lib/typedarray/Uint8Array", elementType: "u8", values: ["9", "19"] },
+            {
+                name: "uint8Clamped",
+                type: "~lib/typedarray/Uint8ClampedArray",
+                elementType: "u8",
+                values: ["29", "39"],
+            },
+            { name: "int16", type: "~lib/typedarray/Int16Array", elementType: "i16", values: ["-49", "49"] },
+            { name: "uint16", type: "~lib/typedarray/Uint16Array", elementType: "u16", values: ["59", "69"] },
+            { name: "int32", type: "~lib/typedarray/Int32Array", elementType: "i32", values: ["-79", "79"] },
+            { name: "uint32", type: "~lib/typedarray/Uint32Array", elementType: "u32", values: ["89", "99"] },
+            { name: "int64", type: "~lib/typedarray/Int64Array", elementType: "i64", values: ["-109", "109"] },
+            { name: "uint64", type: "~lib/typedarray/Uint64Array", elementType: "u64", values: ["119", "129"] },
+            { name: "float32", type: "~lib/typedarray/Float32Array", elementType: "f32", values: ["1.5", "2.5"] },
+            { name: "float64", type: "~lib/typedarray/Float64Array", elementType: "f64", values: ["3.5", "4.5"] },
+        ];
+        for (const expectedArray of expected) {
+            const variable = assertDefined(findVariable(variablesResponse.body.variables, expectedArray.name));
+            assert.equal(variable.type, expectedArray.type);
+            assert.ok(variable.variablesReference > 0);
+            const elementsResponse = await dc.variablesRequest({ variablesReference: variable.variablesReference });
+            assert.deepEqual(elementsResponse.body.variables.map((element) => ({
+                name: element.name,
+                type: element.type,
+                value: element.value,
+                variablesReference: element.variablesReference,
+            })), expectedArray.values.map((value, index) => ({
+                name: index.toString(),
+                type: expectedArray.elementType,
+                value,
+                variablesReference: 0,
+            })));
+        }
+    });
     void it("should expand class array elements as objects", { timeout: 5000 }, async () => {
         const source = sourcePath("debugger_class_array.ts");
         const output = await buildModule(source);
@@ -722,7 +1256,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -768,7 +1302,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -814,7 +1348,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -876,7 +1410,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -937,7 +1471,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -1021,7 +1555,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = stackTraceResponse.body.stackFrames[0];
@@ -1097,7 +1631,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const stoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await stoppedPromise;
         const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
@@ -1142,7 +1676,7 @@ void describe("WarpoDebugSession", () => {
             entryFunctionName: "_start",
         };
         const firstStoppedPromise = waitForBreakpointStop(dc);
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         await firstStoppedPromise;
         const firstStackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
         const firstScopesResponse = await dc.scopesRequest({ frameId: firstStackTraceResponse.body.stackFrames[0].id });
@@ -1218,7 +1752,7 @@ void describe("WarpoDebugSession", () => {
         };
         const stoppedPromise = dc.waitForEvent("stopped");
         const terminatedPromise = dc.waitForEvent("terminated");
-        await dc.launchRequest(launchArgs);
+        await launchAndConfigure(dc, launchArgs);
         const stoppedEvent = await stoppedPromise;
         const stoppedBody = stoppedEvent.body;
         assert.equal(stoppedBody?.reason, "exception");