warpo 3.1.2 → 3.2.0

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";
@@ -23,7 +24,7 @@ async function buildModule(source, extraSources = []) {
     const name = path.basename(source, ".ts");
     let buildOutput = "";
     const exitCode = await build({
-        argv: [source, ...extraSources, "-o", output, "--debug", "--use", "abort="],
+        argv: [source, ...extraSources, "-o", output, "--debug", "--enable-feature", "tail-call", "--use", "abort="],
         cwd: TEST_MODULE_DIR,
         onStdout: (chunk) => {
             buildOutput += chunk;
@@ -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,89 @@ 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 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 +304,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 +322,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/);
@@ -263,6 +356,240 @@ void describe("WarpoDebugSession", () => {
         const d = assertDefined(variablesResponse.body.variables.find((candidate) => candidate.name === "d"));
         assert.equal(d.type, "f64");
     });
+    void it("should stop in every instantiated generic function", { timeout: 10000 }, async () => {
+        const source = sourcePath("debugger_generic_function.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 4;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "main",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const firstStackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const firstFrame = assertDefined(firstStackTraceResponse.body.stackFrames[0]);
+        const firstVariablesResponse = await readFrameLocals(dc, firstFrame);
+        const firstValue = assertDefined(findVariable(firstVariablesResponse.body.variables, "value"));
+        const secondStop = waitForBreakpointStop(dc);
+        await dc.continueRequest({ threadId: 1 });
+        await secondStop;
+        const secondStackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const secondFrame = assertDefined(secondStackTraceResponse.body.stackFrames[0]);
+        const secondVariablesResponse = await readFrameLocals(dc, secondFrame);
+        const secondValue = assertDefined(findVariable(secondVariablesResponse.body.variables, "value"));
+        assert.deepEqual([firstValue.type, secondValue.type].toSorted((left, right) => (left ?? "").localeCompare(right ?? "")), ["f64", "i32"]);
+        assert.match(firstFrame.name, /identity</);
+        assert.match(secondFrame.name, /identity</);
+    });
+    void it("should remove a breakpoint from a concrete function", { timeout: 5000 }, 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 terminatedPromise = dc.waitForEvent("terminated");
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [],
+        });
+        await dc.continueRequest({ threadId: 1 });
+        await terminatedPromise;
+    });
+    void it("should remove breakpoints from every instantiated generic function", { timeout: 10000 }, async () => {
+        const source = sourcePath("debugger_generic_function.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 4;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: breakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "main",
+        };
+        await launchAndWaitForBreakpoint(dc, launchArgs);
+        const terminatedPromise = dc.waitForEvent("terminated");
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [],
+        });
+        await dc.continueRequest({ threadId: 1 });
+        await terminatedPromise;
+    });
+    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;
+        const addedBreakpointLine = 8;
+        await dc.initializeRequest();
+        await dc.setBreakpointsRequest({
+            source: { path: source },
+            breakpoints: [{ line: initialBreakpointLine }],
+        });
+        const launchArgs = {
+            program: output,
+            launchType: "wasm file",
+            runtime: "node",
+            entryFunctionName: "_start",
+        };
+        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({
+            source: { path: source },
+            breakpoints: [{ line: addedBreakpointLine }],
+        });
+        assert.equal(breakpointResponse.body.breakpoints[0].line, addedBreakpointLine);
+        await secondStop;
+        const stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        assert.equal(assertDefined(stackTraceResponse.body.stackFrames[0]).line, addedBreakpointLine);
+        await dc.disconnectRequest({ terminateDebuggee: true });
+    });
+    void it("should expose this in a class member function", { timeout: 5000 }, async () => {
+        const source = sourcePath("debugger_member_function.ts");
+        const output = await buildModule(source);
+        const breakpointLine = 12;
+        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 stackTraceResponse = await dc.stackTraceRequest({ threadId: 1, startFrame: 0, levels: 1 });
+        const frame = assertDefined(stackTraceResponse.body.stackFrames[0]);
+        assert.match(frame.name, /Counter#add/);
+        const variablesResponse = await readFrameLocals(dc, frame);
+        const thisVariable = assertDefined(findVariable(variablesResponse.body.variables, "this"));
+        assert.ok(thisVariable.type?.endsWith("Counter"));
+        assert.ok(thisVariable.variablesReference > 0);
+        const thisFieldsResponse = await dc.variablesRequest({ variablesReference: thisVariable.variablesReference });
+        const value = assertDefined(thisFieldsResponse.body.variables.find((candidate) => candidate.name === "value"));
+        assert.equal(value.type, "i32");
+        assert.equal(value.value, "40");
+        const delta = assertDefined(findVariable(variablesResponse.body.variables, "delta"));
+        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);
@@ -328,7 +655,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 }],
@@ -356,6 +682,184 @@ 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 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");
@@ -420,7 +924,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];
@@ -473,7 +977,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];
@@ -511,7 +1015,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];
@@ -567,6 +1071,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);
@@ -583,7 +1160,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];
@@ -629,7 +1206,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];
@@ -675,7 +1252,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];
@@ -737,7 +1314,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];
@@ -798,7 +1375,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];
@@ -882,7 +1459,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];
@@ -958,7 +1535,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]);
@@ -1003,7 +1580,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 });
@@ -1079,7 +1656,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");