warpo 3.1.1 → 3.1.3

package/dist/debug_server/debugSession.js

@@ -1,30 +1,75 @@
 // Copyright (C) 2025 wasm-ecosystem
 // SPDX-License-Identifier: Apache-2.0
-import { LoggingDebugSession, InitializedEvent, Thread, Breakpoint, LoadedSourceEvent, StoppedEvent, ContinuedEvent, logger, } from "@vscode/debugadapter";
+import { LoggingDebugSession, InitializedEvent, Thread, Breakpoint, Source, Scope, StackFrame, LoadedSourceEvent, OutputEvent, StoppedEvent, ContinuedEvent, TerminatedEvent, logger, } from "@vscode/debugadapter";
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
 import * as path from "node:path";
+import { BuiltinContainerKind, resolveArrayElementSize, } from "../dwarf/classDebugInfo.js";
+import { ARRAY_DATA_START_OFFSET, ARRAY_LENGTH_OFFSET, AS_STRING_CLASS_NAME, OBJECT_RTID_OFFSET, OBJECT_RTID_SIZE, OBJECT_RTSIZE_OFFSET, OBJECT_RTSIZE_SIZE, SMALL_TUPLE_BITMAP_SIZE, SMALL_TUPLE_SLOT_SIZE, } from "../runtime/objectLayout.js";
+import { normalizeDebugPath } from "./debugPath.js";
 import { NodeDebugger } from "./nodeDebugger.js";
+import { loadConfig } from "../test_runner/config.js";
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return "unknown error";
+}
+async function resolveUnitTestWasmPath(cwd) {
+    const configPath = path.join(cwd, "as-test.config.js");
+    let outputFolder = "coverage";
+    if (existsSync(configPath)) {
+        const config = await loadConfig(configPath);
+        if (typeof config.output === "string") {
+            outputFolder = config.output;
+        }
+    }
+    return path.resolve(cwd, outputFolder, "test.instrumented.wasm");
+}
 export class WarpoDebugSession extends LoggingDebugSession {
     static threadId = 1;
     breakpointId = 0;
     requestedBreakpointsBySource = new Map();
-    pendingBreakpointUpdatesBySource = new Map();
+    pendingBreakpointSources = new Set();
+    variableContainers = new Map();
+    pausedStackFramesById = new Map();
+    nextVariablesReference = 1;
     loadedModule;
     runtime;
+    stoppedWasmBytecodeOffset;
+    stoppedForTrap = false;
+    debugSessionLogging = false;
     log(msg) {
         logger.log(msg);
-    }
-    normalizeSourcePath(filePath) {
-        if (filePath === "") {
-            return "";
+        if (this.debugSessionLogging) {
+            this.sendEvent(new OutputEvent(`${msg}\n`, "stdout"));
         }
-        return path.resolve(filePath).replaceAll("\\", "/");
     }
     sendStoppedEvent(runtime, info) {
         this.log(`[${runtime.name}] Paused: ${info.reason}`);
-        const reason = info.reason === "breakpoint" ? "breakpoint" : "pause";
+        this.clearVariableContainers();
+        let reason;
+        if (info.reason === "breakpoint") {
+            reason = "breakpoint";
+        }
+        else if (info.reason === "exception") {
+            reason = "exception";
+        }
+        else {
+            reason = "pause";
+        }
+        this.log(`Sending stopped event: reason=${reason}, threadId=${WarpoDebugSession.threadId}`);
         this.sendEvent(new StoppedEvent(reason, WarpoDebugSession.threadId, info.reason));
     }
     handleRuntimePause(runtime, info) {
+        this.stoppedWasmBytecodeOffset = info.wasmBytecodeOffset;
+        this.stoppedForTrap = info.reason === "exception";
+        if (info.reason === "other" && !this.loadedModule) {
+            return;
+        }
         this.applyPendingBreakpointUpdates(runtime, () => {
             if (info.reason === "other") {
                 void runtime.resume().catch((error) => {
@@ -42,11 +87,12 @@ export class WarpoDebugSession extends LoggingDebugSession {
         response.body.supportsSetVariable = false;
         response.body.supportsBreakpointLocationsRequest = false;
         response.body.supportsLoadedSourcesRequest = true;
+        response.body.supportsEvaluateForHovers = false;
         this.sendResponse(response);
         this.sendEvent(new InitializedEvent());
     }
     setBreakPointsRequest(response, args) {
-        const sourcePath = this.normalizeSourcePath(args.source.path || "");
+        const sourcePath = normalizeDebugPath(args.source.path || "");
         const clientLines = args.breakpoints || [];
         const bps = clientLines.map((bp) => {
             const id = ++this.breakpointId;
@@ -60,15 +106,23 @@ export class WarpoDebugSession extends LoggingDebugSession {
             return info;
         });
         this.requestedBreakpointsBySource.set(sourcePath, bps);
-        this.pendingBreakpointUpdatesBySource.set(sourcePath, [...bps]);
+        this.pendingBreakpointSources.clear();
+        for (const pendingSourcePath of this.requestedBreakpointsBySource.keys()) {
+            this.pendingBreakpointSources.add(pendingSourcePath);
+        }
         const breakpoints = bps.map((bp) => {
             const dbp = new Breakpoint(bp.verified, bp.line);
             dbp.id = bp.id;
             return dbp;
         });
         response.body = { breakpoints };
-        this.sendResponse(response);
-        this.requestBreakpointUpdate();
+        if (this.runtime?.isPaused() && this.loadedModule) {
+            this.requestBreakpointUpdate(() => this.sendResponse(response));
+        }
+        else {
+            this.sendResponse(response);
+            this.requestBreakpointUpdate();
+        }
     }
     configurationDoneRequest(response, _args) {
         super.configurationDoneRequest(response, _args);
@@ -79,9 +133,17 @@ export class WarpoDebugSession extends LoggingDebugSession {
     }
     async doLaunchRequest(response, args) {
         try {
-            this.log(`Launch requested for: ${args.program}`);
+            this.debugSessionLogging = args.debugSessionLogging ?? false;
             const launchType = args.launchType ?? "wasm file";
-            if (launchType === "wasm file") {
+            const cwd = args.cwd ?? process.cwd();
+            const program = launchType === "unittest" ? await resolveUnitTestWasmPath(cwd) : args.program;
+            if (!program) {
+                this.sendErrorResponse(response, 1, "No program specified for launch");
+                return;
+            }
+            const wasmFilePath = path.resolve(program);
+            this.log(`Launch requested for: ${program}`);
+            if (launchType === "wasm file" || launchType === "unittest") {
                 const runtimeName = args.runtime ?? "node";
                 let runtime;
                 if (runtimeName === "node") {
@@ -91,34 +153,60 @@ export class WarpoDebugSession extends LoggingDebugSession {
                     this.sendErrorResponse(response, 1, `Unknown runtime "${runtimeName}"`);
                     return;
                 }
-                runtime.onModuleLoad = (module) => {
-                    this.loadedModule = module;
-                    this.log(`Wasm module loaded: ${module.wasmFilePath} (reported as ${module.url}, scriptId: ${module.scriptId})`);
+                runtime.onModuleLoad = (wasmModule) => {
+                    this.loadedModule = wasmModule;
+                    this.log(`Wasm module loaded: ${wasmModule.wasmFilePath} (reported as ${wasmModule.url}, scriptId: ${wasmModule.scriptId})`);
                     this.sendEvent(new LoadedSourceEvent("new", {
-                        name: path.basename(module.wasmFilePath),
-                        path: module.wasmFilePath,
+                        name: path.basename(wasmModule.wasmFilePath),
+                        path: wasmModule.wasmFilePath,
                     }));
                     this.sendEvent(new LoadedSourceEvent("new", {
-                        name: path.basename(module.sourceMapFilePath),
-                        path: module.sourceMapFilePath,
+                        name: path.basename(wasmModule.sourceMapFilePath),
+                        path: wasmModule.sourceMapFilePath,
                     }));
                     this.applyPendingBreakpointUpdates(runtime, () => {
+                        if (runtime.isPaused()) {
+                            void runtime.resume().catch((error) => {
+                                const message = error instanceof Error ? error.message : "unknown error";
+                                this.log(`Failed to resume after module load: ${message}`);
+                            });
+                            return;
+                        }
                         runtime.finishModuleLoad();
                     });
                 };
                 runtime.onPause = (info) => {
                     this.handleRuntimePause(runtime, info);
                 };
+                runtime.onRuntimeError = (message) => {
+                    this.sendEvent(new OutputEvent(`${message}\n`, "stderr"));
+                };
+                runtime.onRuntimeExit = () => {
+                    this.handleRuntimeExit(runtime);
+                };
+                runtime.onLog = (message) => {
+                    this.log(message);
+                };
                 this.disposeLoadedModule();
                 this.runtime?.dispose();
                 this.runtime = runtime;
-                await runtime.launch({
-                    wasmFilePath: path.resolve(args.program),
-                    entryFunctionName: args.entryFunctionName ?? "main",
-                    args: args.args ?? [],
-                });
+                await runtime.launch(launchType === "unittest"
+                    ? {
+                        wasmFilePath,
+                        cwd,
+                        warpoPath: args.warpoPath,
+                    }
+                    : {
+                        wasmFilePath,
+                        entryFunctionName: args.entryFunctionName ?? "main",
+                        args: args.args ?? [],
+                    });
                 this.log(`[${runtime.name}] Runtime launched`);
             }
+            else {
+                this.sendErrorResponse(response, 1, `Unknown launch type "${launchType}"`);
+                return;
+            }
             this.sendResponse(response);
         }
         catch (error) {
@@ -132,32 +220,793 @@ export class WarpoDebugSession extends LoggingDebugSession {
         };
         this.sendResponse(response);
     }
+    stackTraceRequest(response, args) {
+        this.doStackTraceRequest(response, args);
+    }
+    scopesRequest(response, args) {
+        this.doScopesRequest(response, args);
+    }
+    variablesRequest(response, args) {
+        void this.doVariablesRequest(response, args).catch((error) => {
+            const message = formatUnknownError(error);
+            this.log(`Variables request failed: ${message}`);
+            this.sendErrorResponse(response, 1, `Variables request failed: ${message}`);
+        });
+    }
     continueRequest(response, _args) {
-        void this.doContinueRequest(response);
+        this.doContinueRequest(response);
     }
     disconnectRequest(response, _args) {
-        this.disposeLoadedModule();
-        this.pendingBreakpointUpdatesBySource.clear();
         this.runtime?.dispose();
         this.runtime = undefined;
+        this.resetRuntimeState();
+        this.debugSessionLogging = false;
+        this.dispose();
         this.log("Debug session ended.");
         this.sendResponse(response);
     }
-    async doContinueRequest(response) {
+    doStackTraceRequest(response, args) {
+        const runtime = this.runtime;
+        const frames = runtime ? runtime.getPausedWasmFrames() : [];
+        this.log(`StackTrace request: threadId=${args.threadId}, startFrame=${args.startFrame ?? 0}, levels=${args.levels ?? "all"}, runtimeFrames=${frames.length}`);
+        this.pausedStackFramesById.clear();
+        const stackFrames = frames.map((frame, index) => {
+            const id = index + 1;
+            this.pausedStackFramesById.set(id, { ...frame, frameIndex: index });
+            const sourceLocation = this.resolveSourceLocation(frame.wasmBytecodeOffset);
+            const sourceLabel = sourceLocation
+                ? `${path.basename(sourceLocation.sourcePath)}:${sourceLocation.sourceLine}`
+                : "unknown";
+            this.log(`  frame ${id}: index=${index}, name=${frame.functionName || "wasm"}, offset=${frame.wasmBytecodeOffset ?? "unknown"}, source=${sourceLabel}`);
+            const source = sourceLocation
+                ? new Source(path.basename(sourceLocation.sourcePath), sourceLocation.sourcePath)
+                : undefined;
+            return new StackFrame(id, frame.functionName || "wasm", source, sourceLocation?.sourceLine ?? 0, 1);
+        });
+        const startFrame = args.startFrame ?? 0;
+        const requestedStackFrames = args.levels === undefined
+            ? stackFrames.slice(startFrame)
+            : stackFrames.slice(startFrame, startFrame + args.levels);
+        response.body = {
+            stackFrames: requestedStackFrames,
+            totalFrames: stackFrames.length,
+        };
+        this.log(`StackTrace response: returned=${requestedStackFrames.length}, total=${stackFrames.length}`);
+        this.sendResponse(response);
+    }
+    resolveSourceLocation(wasmBytecodeOffset) {
+        const wasmModule = this.loadedModule;
+        if (!wasmModule || wasmBytecodeOffset === undefined) {
+            return undefined;
+        }
+        return wasmModule.resolveSourceLocation(wasmBytecodeOffset);
+    }
+    doScopesRequest(response, args) {
+        this.log(`Scopes request: frameId=${args.frameId}`);
+        const scopes = this.resolveLocalScopes(args.frameId);
+        response.body = { scopes };
+        this.sendResponse(response);
+    }
+    async doVariablesRequest(response, args) {
+        const variableContainer = this.variableContainers.get(args.variablesReference);
+        switch (variableContainer?.kind) {
+            case "locals": {
+                this.log(`Variables request: locals for frameId=${variableContainer.frameId}, scopeIndex=${variableContainer.scopeIndex}`);
+                response.body = {
+                    variables: await this.resolveLocalScopeVariables(variableContainer.frameId, variableContainer.scopeIndex),
+                };
+                break;
+            }
+            case "object": {
+                response.body = { variables: await this.decodeObjectAtAddress(variableContainer.address) };
+                break;
+            }
+            case "map-entry": {
+                response.body = {
+                    variables: [variableContainer.key, variableContainer.value].map((variable) => this.toDebugProtocolVariable(variable)),
+                };
+                break;
+            }
+            default: {
+                this.log(`Warning: unknown variables reference ${args.variablesReference}`);
+                response.body = { variables: [] };
+                break;
+            }
+        }
+        this.sendResponse(response);
+    }
+    resolveLocalScopes(frameId) {
+        const runtimeFrame = this.resolvePausedStackFrame(frameId);
+        const wasmModule = this.loadedModule;
+        if (!runtimeFrame || !wasmModule) {
+            this.log(`Scopes unavailable: frameId=${frameId}, hasFrame=${runtimeFrame !== undefined}, hasModule=${wasmModule !== undefined}`);
+            return [];
+        }
+        const wasmBytecodeOffset = runtimeFrame.wasmBytecodeOffset;
+        if (wasmBytecodeOffset === undefined) {
+            this.log(`Error: scopes unavailable: frame ${frameId} has no wasm bytecode offset`);
+            return [];
+        }
+        const sourceVariableScopes = wasmModule.getVariableScopesAtBytecodeOffset(wasmBytecodeOffset);
+        if (!sourceVariableScopes || sourceVariableScopes.length === 0) {
+            this.log(`Scopes response: frameId=${frameId}, no scopes`);
+            return [];
+        }
+        this.log(`Scopes response: frameId=${frameId}, scopes=${sourceVariableScopes.map((scope) => scope.name).join(", ")}`);
+        return sourceVariableScopes.map((scope, index) => new Scope(scope.name, this.createVariableContainer({ kind: "locals", frameId, scopeIndex: index }), false));
+    }
+    async resolveLocalScopeVariables(frameId, scopeIndex) {
+        const runtimeFrame = this.resolvePausedStackFrame(frameId);
+        const wasmModule = this.loadedModule;
+        const runtime = this.runtime;
+        if (!runtimeFrame || !wasmModule || !runtime) {
+            this.log(`Local variables unavailable: frameId=${frameId}, hasFrame=${runtimeFrame !== undefined}, hasModule=${wasmModule !== undefined}, hasRuntime=${runtime !== undefined}`);
+            return [];
+        }
+        const wasmBytecodeOffset = runtimeFrame.wasmBytecodeOffset;
+        if (wasmBytecodeOffset === undefined) {
+            this.log(`Error: local variables unavailable: frame ${frameId} has no wasm bytecode offset`);
+            return [];
+        }
+        const sourceVariableScopes = wasmModule.getVariableScopesAtBytecodeOffset(wasmBytecodeOffset);
+        if (!sourceVariableScopes) {
+            this.log(`Error: local variables unavailable: no source variables at wasm bytecode offset ${wasmBytecodeOffset}`);
+            return [];
+        }
+        const sourceVariableScope = sourceVariableScopes[scopeIndex];
+        if (!sourceVariableScope) {
+            this.log(`Error: local variables unavailable: no scope at index ${scopeIndex}`);
+            return [];
+        }
+        const runtimeVariables = await runtime.getPausedWasmFrameVariables(runtimeFrame.frameIndex);
+        this.log(`Local variables resolved: frameId=${frameId}, frameIndex=${runtimeFrame.frameIndex}, offset=${wasmBytecodeOffset}, scopeIndex=${scopeIndex}, scope=${sourceVariableScope.name}, runtimeVariables=${runtimeVariables.length}`);
+        const runtimeVariablesByIndex = new Map();
+        for (const variable of runtimeVariables) {
+            runtimeVariablesByIndex.set(variable.localIndex, variable);
+        }
+        const sourceVariables = sourceVariableScope.variables;
+        const rawWasmValues = await this.resolveRawWasmValues(sourceVariables, runtimeVariablesByIndex, runtime);
+        const closureTupleValuesByLevel = await this.readClosureTupleChain(sourceVariableScope.rootClosureEnvLocalIndex, runtimeVariablesByIndex);
+        const scopeTupleLevel = sourceVariableScope.tupleLevel ?? 0;
+        const rawLocalValues = sourceVariables.map((variable) => {
+            if (variable.kind === "closure") {
+                const elementIndex = variable.fieldOffset / SMALL_TUPLE_SLOT_SIZE;
+                const levelValues = closureTupleValuesByLevel.get(scopeTupleLevel);
+                const tupleRawValue = levelValues?.get(elementIndex);
+                if (tupleRawValue === undefined) {
+                    return { name: variable.name, value: "<unavailable>", typeName: variable.typeName };
+                }
+                return { name: variable.name, value: tupleRawValue, typeName: variable.typeName };
+            }
+            const wasmRawValue = rawWasmValues.get(variable);
+            assert(wasmRawValue !== undefined);
+            return { name: variable.name, value: wasmRawValue, typeName: variable.typeName };
+        });
+        const variables = await Promise.all(rawLocalValues.map((variable) => this.toDebugSessionVariableValue(variable.name, variable.typeName, variable.value)));
+        return variables.map((variable) => this.toDebugProtocolVariable(variable));
+    }
+    async decodeObjectAtAddress(address) {
+        const fields = await this.resolveObjectFields(address);
+        return fields.map((variable) => this.toDebugProtocolVariable(variable));
+    }
+    async resolveRawWasmValues(sourceVariables, runtimeVariablesByIndex, runtime) {
+        const rawWasmValues = new Map();
+        let runtimeGlobalsByIndex;
+        for (const variable of sourceVariables) {
+            if (variable.kind === "wasm-local") {
+                const runtimeVariable = runtimeVariablesByIndex.get(variable.localIndex);
+                assert(runtimeVariable !== undefined);
+                rawWasmValues.set(variable, runtimeVariable.value);
+            }
+            else if (variable.kind === "wasm-global") {
+                if (runtimeGlobalsByIndex === undefined) {
+                    const pausedWasmGlobalVariables = await runtime.getPausedWasmGlobalVariables();
+                    runtimeGlobalsByIndex = new Map(pausedWasmGlobalVariables.map((runtimeVariable) => [runtimeVariable.globalIndex, runtimeVariable.value]));
+                }
+                rawWasmValues.set(variable, runtimeGlobalsByIndex.get(variable.globalIndex) ?? "<unavailable>");
+            }
+        }
+        return rawWasmValues;
+    }
+    async readClosureTupleChain(closureEnvLocalIndex, runtimeVariablesByIndex) {
+        const closureTupleValuesByLevel = new Map();
+        if (closureEnvLocalIndex === undefined) {
+            return closureTupleValuesByLevel;
+        }
+        const closureEnvVariable = runtimeVariablesByIndex.get(closureEnvLocalIndex);
+        if (closureEnvVariable === undefined) {
+            return closureTupleValuesByLevel;
+        }
+        let address = Number(closureEnvVariable.value);
+        if (!Number.isInteger(address) || address <= 0) {
+            return closureTupleValuesByLevel;
+        }
+        let level = 0;
+        while (true) {
+            const tupleValues = await this.readTupleElementValues(address);
+            const levelValues = new Map();
+            for (const [index, value] of tupleValues.entries()) {
+                levelValues.set(index, value.value);
+            }
+            closureTupleValuesByLevel.set(level, levelValues);
+            const parentAddress = levelValues.get(0);
+            if (parentAddress === undefined) {
+                break;
+            }
+            const parentAddressNumber = Number(parentAddress);
+            if (!Number.isInteger(parentAddressNumber) || parentAddressNumber <= 0) {
+                break;
+            }
+            address = parentAddressNumber;
+            level++;
+        }
+        return closureTupleValuesByLevel;
+    }
+    resolvePausedStackFrame(frameId) {
+        return this.pausedStackFramesById.get(frameId);
+    }
+    async toDebugSessionVariable(variable, name = variable.name, typeName = variable.type) {
+        return this.toDebugSessionVariableValue(name, typeName, variable.value);
+    }
+    async toDebugSessionVariableValue(name, typeName, value) {
+        if (typeName !== undefined) {
+            const objectAddress = this.parseObjectAddress(typeName, value);
+            if (objectAddress) {
+                if (typeName === AS_STRING_CLASS_NAME) {
+                    const stringValue = await this.decodeStringAtAddress(typeName, objectAddress);
+                    return this.createClassVariable(name, typeName, objectAddress, stringValue);
+                }
+                return this.createClassVariable(name, typeName, objectAddress);
+            }
+        }
+        return {
+            kind: "basic",
+            name,
+            value,
+            typeName,
+        };
+    }
+    toDebugProtocolVariable(variable, options = {}) {
+        const isExpandableClass = variable.kind === "class" && variable.displayValue === undefined;
+        const showClassNameInName = options.showClassNameInName ?? true;
+        return {
+            name: isExpandableClass && showClassNameInName ? `${variable.name}: ${variable.typeName}` : variable.name,
+            value: this.getVariableDisplayValue(variable),
+            type: variable.kind === "map-entry" ? undefined : variable.typeName,
+            variablesReference: this.getVariableReference(variable, isExpandableClass),
+        };
+    }
+    getVariableDisplayValue(variable) {
+        switch (variable.kind) {
+            case "basic": {
+                return variable.value;
+            }
+            case "class": {
+                return variable.displayValue ?? "";
+            }
+            case "map-entry": {
+                return "";
+            }
+        }
+    }
+    getVariableReference(variable, isExpandableClass) {
+        if (isExpandableClass && variable.kind === "class") {
+            return this.toObjectVariablesReference(variable.address);
+        }
+        if (variable.kind === "map-entry") {
+            return this.createVariableContainer({ kind: "map-entry", key: variable.key, value: variable.value });
+        }
+        return 0;
+    }
+    createClassVariable(name, typeName, address, displayValue) {
+        return { kind: "class", name, typeName, address, displayValue };
+    }
+    parseObjectAddress(typeName, value) {
+        if (!this.loadedModule?.getClassLayout(typeName)) {
+            return undefined;
+        }
+        const address = Number(value);
+        return Number.isInteger(address) && address > 0 ? address : undefined;
+    }
+    toObjectVariablesReference(address) {
+        return this.createVariableContainer({ kind: "object", address });
+    }
+    createVariableContainer(variableContainer) {
+        const variablesReference = this.nextVariablesReference++;
+        this.variableContainers.set(variablesReference, variableContainer);
+        return variablesReference;
+    }
+    clearVariableContainers() {
+        this.variableContainers.clear();
+        this.pausedStackFramesById.clear();
+    }
+    async readTupleElementValues(address, classLayout) {
+        if (!this.runtime) {
+            this.log(`Warning: cannot expand tuple at ${address}: runtime is not active`);
+            return [];
+        }
+        const tupleClassLayout = classLayout ?? (await this.resolveRuntimeClassLayout(address));
+        if (!tupleClassLayout) {
+            this.log(`Warning: cannot expand tuple at ${address}: runtime class layout is missing`);
+            return [];
+        }
+        if (tupleClassLayout.builtinKind !== BuiltinContainerKind.SmallTuple) {
+            this.log(`Warning: cannot expand tuple at ${address}: runtime class layout is not tuple`);
+            return [];
+        }
+        const payloadSize = await this.resolveRuntimeObjectPayloadSize(address, tupleClassLayout);
+        if (payloadSize === undefined) {
+            return [];
+        }
+        const memory = await this.runtime.readWasmMemory(address, payloadSize);
+        if (!memory) {
+            this.log(`Warning: cannot expand tuple at ${address}: tuple memory is unavailable`);
+            return [];
+        }
+        const view = new DataView(memory.buffer, memory.byteOffset, memory.byteLength);
+        assert.equal(tupleClassLayout.builtinKind, BuiltinContainerKind.SmallTuple);
+        if (view.byteLength <= SMALL_TUPLE_BITMAP_SIZE) {
+            return [];
+        }
+        const elementAreaSize = view.byteLength - SMALL_TUPLE_BITMAP_SIZE;
+        if (elementAreaSize % SMALL_TUPLE_SLOT_SIZE !== 0) {
+            this.log(`Error: cannot expand tuple at ${address}: tuple element area is not slot aligned`);
+            return [];
+        }
+        const bitmap = view.getBigUint64(elementAreaSize, true);
+        const values = [];
+        for (let index = 0; index < elementAreaSize / SMALL_TUPLE_SLOT_SIZE; index++) {
+            const offset = index * SMALL_TUPLE_SLOT_SIZE;
+            const isReference = (bitmap & (1n << BigInt(index))) !== 0n;
+            const value = isReference
+                ? this.decodeTupleReferenceValue(view, offset)
+                : this.decodeTupleBasicValue(view, offset);
+            values.push({ value, isReference });
+        }
+        return values;
+    }
+    async decodeTupleElements(address, classLayout) {
+        const values = await this.readTupleElementValues(address, classLayout);
+        return Promise.all(values.map((value, index) => value.isReference
+            ? this.decodeTupleReferenceElement(index.toString(), value.value)
+            : this.toDebugSessionVariableValue(index.toString(), "usize", value.value)));
+    }
+    async resolveObjectFields(address) {
+        const wasmModule = this.loadedModule;
+        if (!wasmModule) {
+            this.log(`Warning: cannot expand object at ${address}: wasm module is not loaded`);
+            return [];
+        }
+        if (!this.runtime) {
+            this.log(`Warning: cannot expand object at ${address}: runtime is not active`);
+            return [];
+        }
+        const classLayout = await this.resolveRuntimeClassLayout(address);
+        if (!classLayout) {
+            this.log(`Warning: cannot expand object at ${address}: runtime class layout is missing`);
+            return [];
+        }
+        if (classLayout.builtinKind === BuiltinContainerKind.SmallTuple) {
+            return this.decodeTupleElements(address, classLayout);
+        }
+        const payloadSize = await this.resolveRuntimeObjectPayloadSize(address, classLayout);
+        if (payloadSize === undefined) {
+            return [];
+        }
+        const memory = await this.runtime.readWasmMemory(address, payloadSize);
+        if (!memory) {
+            this.log(`Warning: cannot expand object at ${address}: object memory is unavailable`);
+            return [];
+        }
+        const view = new DataView(memory.buffer, memory.byteOffset, memory.byteLength);
+        if (classLayout.builtinKind === BuiltinContainerKind.ArrayBuffer) {
+            return this.decodeArrayBufferElements(view);
+        }
+        if (classLayout.builtinKind === BuiltinContainerKind.Array) {
+            return this.decodeArrayElements(address, view, classLayout);
+        }
+        if (classLayout.builtinKind === BuiltinContainerKind.StaticArray) {
+            return this.decodeStaticArrayElements(address, view, classLayout);
+        }
+        if (this.isSetClassLayout(classLayout)) {
+            return this.decodeSetElements(address, view, classLayout);
+        }
+        if (this.isMapClassLayout(classLayout)) {
+            return this.decodeMapElements(address, view, classLayout);
+        }
+        return Promise.all(classLayout.fields.map((field) => this.decodeFieldVariable(view, field)));
+    }
+    async resolveRuntimeObjectPayloadSize(address, classLayout) {
+        if (classLayout.builtinKind !== BuiltinContainerKind.SmallTuple &&
+            classLayout.builtinKind !== BuiltinContainerKind.StaticArray &&
+            classLayout.builtinKind !== BuiltinContainerKind.ArrayBuffer) {
+            return classLayout.byteSize;
+        }
+        const sizeMemory = await this.runtime?.readWasmMemory(address + OBJECT_RTSIZE_OFFSET, OBJECT_RTSIZE_SIZE);
+        if (!sizeMemory) {
+            this.log(`Warning: cannot read object size at ${address + OBJECT_RTSIZE_OFFSET}`);
+            return undefined;
+        }
+        const sizeView = new DataView(sizeMemory.buffer, sizeMemory.byteOffset, sizeMemory.byteLength);
+        return sizeView.getUint32(0, true);
+    }
+    decodeTupleReferenceValue(view, offset) {
+        if (offset + SMALL_TUPLE_SLOT_SIZE > view.byteLength) {
+            return "<unavailable>";
+        }
+        const elementAddress = view.getUint32(offset, true);
+        return elementAddress === 0 ? "null" : elementAddress.toString();
+    }
+    decodeTupleBasicValue(view, offset) {
+        return this.decodeFieldValue(view, {
+            name: "",
+            typeName: "usize",
+            offset,
+            size: SMALL_TUPLE_SLOT_SIZE,
+            isReference: false,
+        });
+    }
+    async decodeTupleReferenceElement(name, value) {
+        const elementAddress = Number(value);
+        if (elementAddress === 0) {
+            return { kind: "basic", name, value: "null", typeName: undefined };
+        }
+        if (!Number.isInteger(elementAddress) || elementAddress <= 0) {
+            return { kind: "basic", name, value, typeName: undefined };
+        }
+        const classLayout = await this.resolveRuntimeClassLayout(elementAddress);
+        if (!classLayout) {
+            this.log(`Error: cannot expand tuple reference at ${elementAddress}: runtime class layout is missing`);
+            return { kind: "basic", name, value: elementAddress.toString(), typeName: undefined };
+        }
+        if (classLayout.name === AS_STRING_CLASS_NAME) {
+            const stringValue = await this.decodeStringAtAddress(classLayout.name, elementAddress);
+            return this.createClassVariable(name, classLayout.name, elementAddress, stringValue);
+        }
+        return this.createClassVariable(name, classLayout.name, elementAddress);
+    }
+    async decodeArrayElements(address, view, classLayout) {
+        assert.equal(classLayout.builtinKind, BuiltinContainerKind.Array);
+        const elementTypeName = classLayout.templateType;
+        if (elementTypeName === undefined) {
+            this.log(`Error: cannot expand array at ${address}: element type is unavailable`);
+            return [];
+        }
+        if (ARRAY_LENGTH_OFFSET + 4 > view.byteLength) {
+            this.log(`Error: cannot expand array at ${address}: array header is unavailable`);
+            return [];
+        }
+        const dataStart = view.getUint32(ARRAY_DATA_START_OFFSET, true);
+        const length = view.getUint32(ARRAY_LENGTH_OFFSET, true);
+        const elementSize = resolveArrayElementSize(elementTypeName, classLayout.templateTypeIsReference === true);
+        const elementsMemory = await this.runtime?.readWasmMemory(dataStart, length * elementSize);
+        if (!elementsMemory) {
+            this.log(`Error: cannot expand array at ${address}: array elements memory is unavailable`);
+            return [];
+        }
+        const elementsView = new DataView(elementsMemory.buffer, elementsMemory.byteOffset, elementsMemory.byteLength);
+        return this.decodeArrayElementVariables(elementsView, length, elementTypeName, elementSize, classLayout.templateTypeIsReference === true);
+    }
+    decodeArrayBufferElements(view) {
+        const elements = [];
+        for (let index = 0; index < view.byteLength; index++) {
+            elements.push({
+                kind: "basic",
+                name: index.toString(),
+                value: view.getUint8(index).toString(),
+                typeName: "u8",
+            });
+        }
+        return elements;
+    }
+    async decodeStaticArrayElements(address, view, classLayout) {
+        assert.equal(classLayout.builtinKind, BuiltinContainerKind.StaticArray);
+        const elementTypeName = classLayout.templateType;
+        if (elementTypeName === undefined) {
+            this.log(`Error: cannot expand static array at ${address}: element type is unavailable`);
+            return [];
+        }
+        const elementSize = resolveArrayElementSize(elementTypeName, classLayout.templateTypeIsReference === true);
+        if (view.byteLength % elementSize !== 0) {
+            this.log(`Error: cannot expand static array at ${address}: payload size is not element aligned`);
+            return [];
+        }
+        return this.decodeArrayElementVariables(view, view.byteLength / elementSize, elementTypeName, elementSize, classLayout.templateTypeIsReference === true);
+    }
+    async decodeArrayElementVariables(view, length, elementTypeName, elementSize, isReference) {
+        const elementVariables = [];
+        for (let index = 0; index < length; index++) {
+            elementVariables.push(this.decodeFieldVariable(view, {
+                name: index.toString(),
+                typeName: elementTypeName,
+                offset: index * elementSize,
+                size: elementSize,
+                isReference,
+            }));
+        }
+        return Promise.all(elementVariables);
+    }
+    async decodeSetElements(address, view, classLayout) {
+        const elementTypeName = classLayout.templateType;
+        if (elementTypeName === undefined) {
+            this.log(`Error: cannot expand set at ${address}: element type is unavailable`);
+            return [];
+        }
+        const entryLayout = classLayout.entryLayout;
+        if (entryLayout === undefined) {
+            this.log(`Error: cannot expand set at ${address}: entry layout is unavailable`);
+            return [];
+        }
+        const entriesView = await this.readMapOrSetEntries(address, view, entryLayout.size, "set");
+        if (!entriesView) {
+            return [];
+        }
+        const entriesOffset = view.getInt32(16, true);
+        if (entriesOffset <= 0) {
+            return [];
+        }
+        const elementSize = resolveArrayElementSize(elementTypeName, classLayout.templateTypeIsReference === true);
+        const elements = [];
+        for (let entryIndex = 0; entryIndex < entriesOffset; entryIndex++) {
+            const entryBase = entryIndex * entryLayout.size;
+            const taggedNextOffset = entryBase + entryLayout.size - 4;
+            if (taggedNextOffset + 4 > entriesView.byteLength) {
+                break;
+            }
+            const taggedNext = entriesView.getUint32(taggedNextOffset, true);
+            if (taggedNext & 1) {
+                continue;
+            }
+            elements.push(this.decodeFieldVariable(entriesView, {
+                name: elements.length.toString(),
+                typeName: elementTypeName,
+                offset: entryBase,
+                size: elementSize,
+                isReference: classLayout.templateTypeIsReference === true,
+            }));
+        }
+        return Promise.all(elements);
+    }
+    async decodeMapElements(address, view, classLayout) {
+        const entryLayout = classLayout.entryLayout;
+        if (entryLayout === undefined) {
+            this.log(`Error: cannot expand map at ${address}: entry layout is unavailable`);
+            return [];
+        }
+        const entryClass = this.getMapOrSetEntryClassLayout(classLayout.name);
+        const keyField = entryClass?.fields.find((field) => field.name === "key");
+        const valueField = entryClass?.fields.find((field) => field.name === "value");
+        if (!keyField || !valueField) {
+            this.log(`Error: cannot expand map at ${address}: key/value entry fields are unavailable`);
+            return [];
+        }
+        const entriesView = await this.readMapOrSetEntries(address, view, entryLayout.size, "map");
+        if (!entriesView) {
+            return [];
+        }
+        const entriesOffset = view.getInt32(16, true);
+        const elements = [];
+        for (let entryIndex = 0; entryIndex < entriesOffset; entryIndex++) {
+            const entryBase = entryIndex * entryLayout.size;
+            const taggedNextOffset = entryBase + entryLayout.size - 4;
+            if (taggedNextOffset + 4 > entriesView.byteLength) {
+                break;
+            }
+            const taggedNext = entriesView.getUint32(taggedNextOffset, true);
+            if (taggedNext & 1) {
+                continue;
+            }
+            elements.push(this.decodeMapEntry(entriesView, elements.length.toString(), entryBase, keyField, valueField));
+        }
+        return Promise.all(elements);
+    }
+    isSetClassLayout(classLayout) {
+        return classLayout.name.startsWith("~lib/set/Set<");
+    }
+    isMapClassLayout(classLayout) {
+        return classLayout.name.startsWith("~lib/map/Map<");
+    }
+    getMapOrSetEntryClassLayout(className) {
+        if (className.startsWith("~lib/set/Set<")) {
+            return this.loadedModule?.getInternalClassLayout(className.replace("~lib/set/Set<", "~lib/set/SetEntry<"));
+        }
+        if (className.startsWith("~lib/map/Map<")) {
+            return this.loadedModule?.getInternalClassLayout(className.replace("~lib/map/Map<", "~lib/map/MapEntry<"));
+        }
+        return undefined;
+    }
+    async decodeMapEntry(entriesView, name, entryBase, keyField, valueField) {
+        const [key, value] = await Promise.all([
+            this.decodeFieldVariable(entriesView, { ...keyField, name: "key", offset: entryBase + keyField.offset }),
+            this.decodeFieldVariable(entriesView, { ...valueField, name: "value", offset: entryBase + valueField.offset }),
+        ]);
+        return { kind: "map-entry", name, key, value };
+    }
+    async readMapOrSetEntries(address, view, entrySize, containerKind) {
+        if (view.byteLength < 20) {
+            this.log(`Error: cannot expand ${containerKind} at ${address}: ${containerKind} header is unavailable`);
+            return undefined;
+        }
+        const entriesPtr = view.getUint32(8, true);
+        const entriesOffset = view.getInt32(16, true);
+        if (entriesPtr === 0 || entriesOffset <= 0) {
+            return new DataView(new ArrayBuffer(0));
+        }
+        const entriesMemory = await this.runtime?.readWasmMemory(entriesPtr, entriesOffset * entrySize);
+        if (!entriesMemory) {
+            this.log(`Error: cannot expand ${containerKind} at ${address}: ${containerKind} entries memory is unavailable`);
+            return undefined;
+        }
+        return new DataView(entriesMemory.buffer, entriesMemory.byteOffset, entriesMemory.byteLength);
+    }
+    async resolveRuntimeClassLayout(address) {
+        const header = await this.runtime?.readWasmMemory(address + OBJECT_RTID_OFFSET, OBJECT_RTID_SIZE);
+        if (!header) {
+            this.log(`Warning: cannot read object RTID at ${address + OBJECT_RTID_OFFSET}`);
+            return undefined;
+        }
+        const headerView = new DataView(header.buffer, header.byteOffset, header.byteLength);
+        const rtid = headerView.getUint32(0, true);
+        const classLayout = this.loadedModule?.getClassLayoutByRtid(rtid);
+        if (!classLayout) {
+            this.log(`Warning: cannot resolve class layout for RTID ${rtid}`);
+        }
+        return classLayout;
+    }
+    async decodeFieldVariable(view, field) {
+        const value = this.decodeFieldValue(view, field);
+        const address = field.isReference ? this.parseObjectAddress(field.typeName, value) : undefined;
+        if (address) {
+            if (field.typeName === AS_STRING_CLASS_NAME) {
+                const stringValue = await this.decodeStringAtAddress(field.typeName, address);
+                return this.createClassVariable(field.name, field.typeName, address, stringValue);
+            }
+            return this.createClassVariable(field.name, field.typeName, address);
+        }
+        return {
+            kind: "basic",
+            name: field.name,
+            value,
+            typeName: field.typeName,
+        };
+    }
+    decodeFieldValue(view, field) {
+        if (field.offset + field.size > view.byteLength) {
+            return "<unavailable>";
+        }
+        if (field.isReference) {
+            const address = view.getUint32(field.offset, true);
+            return address === 0 ? "null" : address.toString();
+        }
+        switch (field.typeName) {
+            case "bool": {
+                return String(view.getUint8(field.offset) !== 0);
+            }
+            case "i8": {
+                return view.getInt8(field.offset).toString();
+            }
+            case "u8": {
+                return view.getUint8(field.offset).toString();
+            }
+            case "i16": {
+                return view.getInt16(field.offset, true).toString();
+            }
+            case "u16": {
+                return view.getUint16(field.offset, true).toString();
+            }
+            case "i32":
+            case "isize": {
+                return view.getInt32(field.offset, true).toString();
+            }
+            case "u32":
+            case "usize": {
+                return view.getUint32(field.offset, true).toString();
+            }
+            case "i64": {
+                return view.getBigInt64(field.offset, true).toString();
+            }
+            case "u64": {
+                return view.getBigUint64(field.offset, true).toString();
+            }
+            case "f32": {
+                return view.getFloat32(field.offset, true).toString();
+            }
+            case "f64": {
+                return view.getFloat64(field.offset, true).toString();
+            }
+            default: {
+                return this.decodeIntegerBySize(view, field);
+            }
+        }
+    }
+    decodeIntegerBySize(view, field) {
+        switch (field.size) {
+            case 1: {
+                return view.getUint8(field.offset).toString();
+            }
+            case 2: {
+                return view.getUint16(field.offset, true).toString();
+            }
+            case 4: {
+                return view.getUint32(field.offset, true).toString();
+            }
+            case 8: {
+                return view.getBigUint64(field.offset, true).toString();
+            }
+            default: {
+                return "<unavailable>";
+            }
+        }
+    }
+    async decodeStringAtAddress(typeName, address) {
+        assert.equal(typeName, AS_STRING_CLASS_NAME);
         if (!this.runtime) {
+            this.log(`Error: cannot decode string at ${address}: runtime is not active`);
+            return "<unavailable>";
+        }
+        const sizeMemory = await this.runtime.readWasmMemory(address + OBJECT_RTSIZE_OFFSET, OBJECT_RTSIZE_SIZE);
+        if (!sizeMemory) {
+            this.log(`Error: cannot decode string at ${address}: string size memory is unavailable`);
+            return "<unavailable>";
+        }
+        const sizeView = new DataView(sizeMemory.buffer, sizeMemory.byteOffset, sizeMemory.byteLength);
+        const byteLength = sizeView.getUint32(0, true);
+        const stringMemory = await this.runtime.readWasmMemory(address, byteLength);
+        if (!stringMemory) {
+            this.log(`Error: cannot decode string at ${address}: string payload memory is unavailable`);
+            return "<unavailable>";
+        }
+        return JSON.stringify(Buffer.from(stringMemory).toString("utf16le"));
+    }
+    doContinueRequest(response) {
+        const runtime = this.runtime;
+        if (!runtime) {
             this.sendErrorResponse(response, 1, "No active runtime");
             return;
         }
+        response.body = { allThreadsContinued: true };
+        this.sendResponse(response);
+        if (this.stoppedForTrap) {
+            this.log("Continue requested from wasm trap; terminating debug session");
+            this.disposeRuntimeAndTerminate(runtime);
+            return;
+        }
+        void this.resumeRuntime(runtime);
+    }
+    async resumeRuntime(runtime) {
         try {
-            await this.runtime.resume();
-            response.body = { allThreadsContinued: true };
-            this.sendResponse(response);
-            this.sendEvent(new ContinuedEvent(WarpoDebugSession.threadId, true));
+            await runtime.resume();
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.sendErrorResponse(response, 1, `Continue failed: ${message}`);
+            this.log(`Continue failed: ${formatUnknownError(error)}`);
+            return;
+        }
+        if (this.runtime !== runtime) {
+            return;
+        }
+        this.clearVariableContainers();
+        this.stoppedWasmBytecodeOffset = undefined;
+        this.sendEvent(new ContinuedEvent(WarpoDebugSession.threadId, true));
+    }
+    handleRuntimeExit(runtime) {
+        if (this.runtime !== runtime) {
+            return;
+        }
+        this.disposeRuntimeAndTerminate(runtime);
+    }
+    disposeRuntimeAndTerminate(runtime) {
+        runtime.dispose();
+        if (this.runtime === runtime) {
+            this.runtime = undefined;
         }
+        this.resetRuntimeState();
+        this.sendEvent(new TerminatedEvent());
+    }
+    resetRuntimeState() {
+        this.disposeLoadedModule();
+        this.pendingBreakpointSources.clear();
+        this.stoppedWasmBytecodeOffset = undefined;
+        this.stoppedForTrap = false;
     }
     logAllBreakpoints() {
         this.log("=== Registered Breakpoints ===");
@@ -168,64 +1017,54 @@ export class WarpoDebugSession extends LoggingDebugSession {
         }
         this.log("==============================");
     }
-    requestBreakpointUpdate() {
-        if (!this.runtime || !this.loadedModule || this.pendingBreakpointUpdatesBySource.size === 0) {
+    requestBreakpointUpdate(onComplete) {
+        if (!this.runtime || !this.loadedModule || this.pendingBreakpointSources.size === 0) {
+            onComplete?.();
             return;
         }
         if (this.runtime.isPaused()) {
-            this.applyPendingBreakpointUpdates(this.runtime);
+            this.applyPendingBreakpointUpdates(this.runtime, onComplete);
             return;
         }
-        for (const sourcePath of this.pendingBreakpointUpdatesBySource.keys()) {
-            if (this.loadedModule.hasSource(sourcePath)) {
-                this.runtime.pause();
-                return;
-            }
-        }
+        this.runtime.pause();
     }
     applyPendingBreakpointUpdates(runtime, onComplete) {
-        const module = this.loadedModule;
-        if (!module) {
+        const wasmModule = this.loadedModule;
+        if (!wasmModule) {
             onComplete?.();
             return;
         }
-        for (const [sourcePath, breakpoints] of this.pendingBreakpointUpdatesBySource) {
-            if (breakpoints.length === 0) {
-                this.pendingBreakpointUpdatesBySource.delete(sourcePath);
-                continue;
-            }
-            if (!module.hasSource(sourcePath)) {
-                continue;
-            }
-            const breakpoint = breakpoints.shift();
-            if (!breakpoint) {
-                this.pendingBreakpointUpdatesBySource.delete(sourcePath);
-                continue;
-            }
-            if (breakpoints.length === 0) {
-                this.pendingBreakpointUpdatesBySource.delete(sourcePath);
-            }
-            const bytecodeOffset = module.findBytecodeOffset(breakpoint.source, breakpoint.line);
-            if (bytecodeOffset === undefined) {
-                this.log(`No source-map match for breakpoint ${path.basename(breakpoint.source)}:${breakpoint.line}`);
-                this.applyPendingBreakpointUpdates(runtime, onComplete);
-                return;
-            }
-            this.log(`Resolved breakpoint ${path.basename(breakpoint.source)}:${breakpoint.line} -> bytecode offset ${bytecodeOffset}`);
-            runtime.setWasmBreakpoint(module, bytecodeOffset, {
-                onSuccess: () => {
-                    this.applyPendingBreakpointUpdates(runtime, onComplete);
-                },
-                onError: (error) => {
-                    this.log(`Failed to set breakpoint ${path.basename(breakpoint.source)}:${breakpoint.line}: ${error.message}`);
-                    this.applyPendingBreakpointUpdates(runtime, onComplete);
-                },
-            });
+        if (this.pendingBreakpointSources.size === 0) {
+            onComplete?.();
             return;
         }
-        onComplete?.();
+        this.pendingBreakpointSources.clear();
+        const wasmBytecodeOffsets = new Set();
+        for (const [sourcePath, breakpoints] of this.requestedBreakpointsBySource) {
+            for (const breakpoint of breakpoints) {
+                const breakpointLocations = wasmModule.resolveBreakpointLocations(breakpoint);
+                if (breakpointLocations.length === 0) {
+                    this.log(`No source-map match for breakpoint ${path.basename(sourcePath)}:${breakpoint.line}`);
+                }
+                for (const location of breakpointLocations) {
+                    wasmBytecodeOffsets.add(location.wasmBytecodeOffset);
+                    this.log(`Resolved breakpoint ${path.basename(sourcePath)}:${breakpoint.line} -> ${location.wasmBytecodeOffset}`);
+                }
+            }
+        }
+        runtime.setWasmBreakpoints(wasmModule, Array.from(wasmBytecodeOffsets).toSorted((left, right) => left - right), {
+            onSuccess: () => {
+                this.log(`Breakpoint set installed: ${wasmBytecodeOffsets.size} locations`);
+                onComplete?.();
+            },
+            onError: (error) => {
+                this.log(`Failed to update breakpoints: ${error.message}`);
+                onComplete?.();
+            },
+        });
     }
     disposeLoadedModule() {
+        this.clearVariableContainers();
         this.loadedModule?.dispose();
         this.loadedModule = undefined;
     }