warpo 3.1.0 → 3.1.2

package/dist/debug_server/nodeDebugger.js

@@ -9,6 +9,8 @@ import { DebuggerWasmModule } from "./debuggerWasmModule.js";
 const DIRNAME = path.dirname(fileURLToPath(import.meta.url));
 const DEBUG_SERVER_TRACE_ENABLED = process.env.WARPO_DEBUG_SERVER_TRACE === "1";
 const DEBUG_SERVER_TRACE_FILE = path.join(process.cwd(), ".warpo-debug-server-trace.log");
+const LINEAR_MEMORY_OBJECT_GROUP = "warpo-linear-memory";
+const NODE_WAITING_FOR_DEBUGGER_DISCONNECT = "Waiting for the debugger to disconnect...";
 if (DEBUG_SERVER_TRACE_ENABLED) {
     try {
         writeFileSync(DEBUG_SERVER_TRACE_FILE, "");
@@ -27,6 +29,25 @@ function trace(message) {
         }
     }
 }
+const READ_WASM_MEMORY_FUNCTION = function (address, byteLength) {
+    const buffer = this instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && this instanceof SharedArrayBuffer)
+        ? this
+        : this.buffer;
+    if (!(buffer instanceof ArrayBuffer) &&
+        !(typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer)) {
+        return;
+    }
+    if (address < 0 || byteLength < 0 || address + byteLength > buffer.byteLength) {
+        return;
+    }
+    return Array.from(new Uint8Array(buffer, address, byteLength));
+}.toString();
+const GET_WASM_MEMORY_BUFFER_FUNCTION = function () {
+    if (this instanceof ArrayBuffer || (typeof SharedArrayBuffer !== "undefined" && this instanceof SharedArrayBuffer)) {
+        return this;
+    }
+    return this.buffer;
+}.toString();
 function findFreePort() {
     return new Promise((resolve, reject) => {
         const srv = net.createServer();
@@ -51,28 +72,97 @@ export class NodeDebugger {
     name = "node";
     onModuleLoad;
     onPause;
+    onRuntimeError;
+    onRuntimeExit;
+    onLog;
     child;
     ws;
     cdpId = 0;
     pendingCommandCallbacks = new Map();
     paused = false;
     wasmFilePath;
+    wasmScriptId;
+    pausedCallFrames = [];
+    wasmMemoryBufferObjectId;
+    wasmGlobalsObjectId;
+    stderrOutput = "";
+    disposed = false;
+    runtimeExitPromise;
+    log(message) {
+        trace(message);
+        this.onLog?.(`[${this.name}] ${message}`);
+    }
     async launch(config) {
+        this.disposed = false;
         this.wasmFilePath = config.wasmFilePath;
         const port = await findFreePort();
-        this.child = spawn(process.execPath, [
-            `--inspect=${port}`,
-            path.join(DIRNAME, "wasmEntry.js"),
-            config.wasmFilePath,
-            config.entryFunctionName,
-            ...config.args.map(String),
-        ], { stdio: ["pipe", "pipe", "pipe"] });
+        this.log(`launch wasmFilePath=${config.wasmFilePath} inspectPort=${port}`);
+        const launchArgs = "cwd" in config
+            ? [`--inspect-brk=${port}`, config.warpoPath ?? path.join(DIRNAME, "..", "warpo.js"), "test"]
+            : [
+                `--inspect-brk=${port}`,
+                path.join(DIRNAME, "wasmEntry.js"),
+                config.wasmFilePath,
+                config.entryFunctionName,
+                ...config.args.map(String),
+            ];
+        this.child = spawn(process.execPath, launchArgs, {
+            cwd: "cwd" in config ? config.cwd : undefined,
+            env: getRuntimeEnv(),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.log(`runtime child spawned pid=${this.child.pid ?? "unknown"}`);
+        this.runtimeExitPromise = new Promise((resolve) => {
+            this.child?.once("exit", () => resolve());
+            this.child?.once("error", () => resolve());
+        });
+        this.child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (text) {
+                this.log(`runtime stdout: ${text}`);
+            }
+        });
+        this.child.stderr?.on("data", (chunk) => {
+            const stderr = parseRuntimeStderr(chunk.toString());
+            this.stderrOutput += stderr.output;
+            const text = stderr.output.trim();
+            if (text) {
+                this.log(`runtime stderr: ${text}`);
+            }
+            if (stderr.waitingForDebuggerDisconnect) {
+                this.log("runtime waiting for debugger disconnect -> close websocket");
+                this.ws?.close();
+            }
+        });
+        this.child.on("error", (error) => {
+            this.log(`runtime child error: ${error.message}`);
+            this.onRuntimeError?.(error.message);
+            this.onRuntimeExit?.();
+        });
+        this.child.on("exit", (code, signal) => {
+            this.log(`runtime exit code=${code ?? "null"} signal=${signal ?? "null"}`);
+            if (this.disposed) {
+                return;
+            }
+            if (code && code !== 0) {
+                this.onRuntimeError?.(this.stderrOutput.trim() || `Debug runtime exited with code ${code}`);
+            }
+            this.onRuntimeExit?.();
+        });
         const wsUrl = await this.fetchWsUrl(port);
-        await this.connectCDP(wsUrl);
+        this.log(`inspector websocket discovered: ${wsUrl}`);
+        await Promise.race([this.connectCDP(wsUrl), this.runtimeExitPromise]);
     }
     dispose() {
+        this.disposed = true;
         this.paused = false;
         this.wasmFilePath = undefined;
+        this.wasmScriptId = undefined;
+        this.pausedCallFrames = [];
+        this.wasmMemoryBufferObjectId = undefined;
+        this.wasmGlobalsObjectId = undefined;
+        this.stderrOutput = "";
+        this.runtimeExitPromise = undefined;
         this.ws?.close();
         this.child?.kill();
     }
@@ -85,28 +175,114 @@ export class NodeDebugger {
     async resume() {
         await this.waitForCommand("Debugger.resume");
         this.paused = false;
+        this.pausedCallFrames = [];
+        this.wasmMemoryBufferObjectId = undefined;
+        this.wasmGlobalsObjectId = undefined;
     }
     finishModuleLoad() {
+        this.log("finishModuleLoad -> Runtime.runIfWaitingForDebugger");
         this.sendCommand("Runtime.runIfWaitingForDebugger");
     }
-    setWasmBreakpoint(module, bytecodeOffset, callbacks) {
-        this.sendCommand("Debugger.setBreakpointByUrl", {
-            url: module.url,
-            lineNumber: 0,
-            columnNumber: bytecodeOffset,
-        }, {
-            onSuccess: () => {
-                trace(`setWasmBreakpoint success offset=${bytecodeOffset}`);
+    setWasmBreakpoint(module, wasmBytecodeOffset, callbacks) {
+        void (async () => {
+            try {
+                const location = this.resolveWasmBytecodeOffsetLocation(module, wasmBytecodeOffset);
+                this.log(`setWasmBreakpoint offset=${wasmBytecodeOffset} url=${module.url}`);
+                await this.waitForCommandResult("Debugger.setBreakpointByUrl", {
+                    lineNumber: location.lineNumber,
+                    url: module.url,
+                    columnNumber: location.columnNumber,
+                    condition: "",
+                });
+                this.log(`setWasmBreakpoint success offset=${wasmBytecodeOffset}`);
                 callbacks?.onSuccess?.();
-            },
-            onError: (error) => {
-                trace(`setWasmBreakpoint error offset=${bytecodeOffset} message=${error.message}`);
-                callbacks?.onError?.(error);
-            },
+            }
+            catch (error) {
+                const commandError = error instanceof Error ? error : new Error(String(error));
+                this.log(`setWasmBreakpoint error offset=${wasmBytecodeOffset} message=${commandError.message}`);
+                callbacks?.onError?.(commandError);
+            }
+        })();
+    }
+    resolveWasmBytecodeOffsetLocation(module, wasmBytecodeOffset) {
+        if (!module.url) {
+            throw new Error("Wasm script URL is not available");
+        }
+        return { scriptId: module.scriptId, lineNumber: 0, columnNumber: wasmBytecodeOffset };
+    }
+    resolveWasmLocationBytecodeOffset(location) {
+        if (location.lineNumber !== 0) {
+            return undefined;
+        }
+        return location.columnNumber;
+    }
+    getPausedWasmFrames() {
+        const frames = this.pausedCallFrames.map((callFrame) => this.toPausedWasmFrame(callFrame));
+        this.log(`getPausedWasmFrames count=${frames.length}`);
+        for (const [index, frame] of frames.entries()) {
+            this.log(`  wasm frame ${index}: name=${frame.functionName}, offset=${frame.wasmBytecodeOffset ?? "unknown"}`);
+        }
+        return frames;
+    }
+    async getPausedWasmFrameVariables(frameIndex) {
+        const callFrame = this.pausedCallFrames[frameIndex];
+        if (!callFrame) {
+            this.log(`getPausedWasmFrameVariables frameIndex=${frameIndex} unavailable`);
+            return [];
+        }
+        const variables = await this.getLocalScopeVariables(callFrame);
+        this.log(`getPausedWasmFrameVariables frameIndex=${frameIndex} variables=${variables.length}`);
+        return variables;
+    }
+    async getPausedWasmGlobalVariables() {
+        const globalsObjectId = await this.getWasmGlobalsObjectId();
+        if (!globalsObjectId) {
+            return [];
+        }
+        const globalsResult = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId: globalsObjectId,
+            ownProperties: true,
         });
+        const globals = Array.isArray(globalsResult.result) ? globalsResult.result.filter(isCDPPropertyDescriptor) : [];
+        const values = [];
+        for (const [globalIndex, global] of globals.entries()) {
+            if (!global.value) {
+                continue;
+            }
+            values.push({
+                globalIndex,
+                value: await this.readRemoteObjectValue(global.value),
+                type: global.value.description ?? global.value.type,
+            });
+        }
+        return values;
+    }
+    async readWasmMemory(address, byteLength) {
+        this.log(`readWasmMemory address=${address} byteLength=${byteLength}`);
+        const memoryBufferObjectId = await this.getWasmMemoryBufferObjectId();
+        if (!memoryBufferObjectId) {
+            this.log("readWasmMemory skipped: memory buffer unavailable");
+            return undefined;
+        }
+        this.log("readWasmMemory -> Runtime.callFunctionOn");
+        const result = await this.waitForCommandResult("Runtime.callFunctionOn", {
+            objectId: memoryBufferObjectId,
+            functionDeclaration: READ_WASM_MEMORY_FUNCTION,
+            arguments: [{ value: address }, { value: byteLength }],
+            silent: true,
+            returnByValue: true,
+        });
+        const remoteObject = getRuntimeEvaluateRemoteObject(result);
+        if (!Array.isArray(remoteObject?.value) || !remoteObject.value.every((value) => typeof value === "number")) {
+            this.log("readWasmMemory failed: runtime returned non-byte-array value");
+            return undefined;
+        }
+        this.log(`readWasmMemory success bytes=${remoteObject.value.length}`);
+        return Uint8Array.from(remoteObject.value);
     }
     async fetchWsUrl(port) {
         const deadline = Date.now() + 5000;
+        this.log(`waiting for inspector endpoint on port ${port}`);
         while (Date.now() < deadline) {
             try {
                 const resp = await fetch(`http://127.0.0.1:${port}/json`);
@@ -115,10 +291,12 @@ export class NodeDebugger {
                 }
                 const [info] = (await resp.json());
                 if (info?.webSocketDebuggerUrl) {
+                    this.log(`inspector endpoint ready on port ${port}`);
                     return info.webSocketDebuggerUrl;
                 }
             }
-            catch {
+            catch (error) {
+                trace(`inspector endpoint not ready: ${error instanceof Error ? error.message : "unknown error"}`);
                 // The inspector endpoint is not always ready immediately after spawn.
             }
             await wait(50);
@@ -133,15 +311,33 @@ export class NodeDebugger {
         if (callbacks) {
             this.pendingCommandCallbacks.set(id, callbacks);
         }
+        this.log(`CDP -> ${method} id=${id}`);
         this.ws.send(JSON.stringify({ id, method, params }));
+        return id;
     }
     waitForCommand(method, params) {
         return new Promise((resolve, reject) => {
-            this.sendCommand(method, params, {
+            const id = this.sendCommand(method, params, {
                 onSuccess: () => {
+                    this.log(`CDP command completed ${method} id=${id}`);
                     resolve();
                 },
                 onError: (error) => {
+                    this.log(`CDP command failed ${method} id=${id}: ${error.message}`);
+                    reject(error);
+                },
+            });
+        });
+    }
+    waitForCommandResult(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = this.sendCommand(method, params, {
+                onSuccess: (result) => {
+                    this.log(`CDP command completed ${method} id=${id}`);
+                    resolve(result ?? {});
+                },
+                onError: (error) => {
+                    this.log(`CDP command failed ${method} id=${id}: ${error.message}`);
                     reject(error);
                 },
             });
@@ -154,60 +350,143 @@ export class NodeDebugger {
             ws.addEventListener("open", () => {
                 void (async () => {
                     try {
-                        trace("ws open -> Debugger.enable");
+                        this.log("websocket open -> Runtime.enable");
+                        await this.waitForCommand("Runtime.enable");
+                        this.log("Runtime.enable complete -> Debugger.enable");
                         await this.waitForCommand("Debugger.enable");
-                        trace("Debugger.enable -> Debugger.setBreakpointsActive");
-                        await this.waitForCommand("Debugger.setBreakpointsActive", { active: true });
-                        trace("Debugger.setBreakpointsActive -> Runtime.runIfWaitingForDebugger");
+                        this.log("Debugger.enable complete -> Runtime.runIfWaitingForDebugger");
                         await this.waitForCommand("Runtime.runIfWaitingForDebugger");
-                        trace("Runtime.runIfWaitingForDebugger -> launch ready");
+                        this.log("Runtime.runIfWaitingForDebugger complete -> Debugger.setBreakpointsActive");
+                        await this.waitForCommand("Debugger.setBreakpointsActive", { active: true });
+                        this.log("Debugger.setBreakpointsActive complete -> Debugger.setPauseOnExceptions");
+                        await this.waitForCommand("Debugger.setPauseOnExceptions", { state: "all" });
+                        this.log("Debugger.setPauseOnExceptions complete -> launch ready");
                         resolve();
                     }
                     catch (error) {
+                        this.log(`CDP setup failed: ${error instanceof Error ? error.message : "unknown error"}`);
                         reject(error instanceof Error ? error : new Error(String(error)));
                     }
                 })();
             });
             ws.addEventListener("error", (e) => {
                 const message = e instanceof Error ? e.message : "WebSocket connection failed";
+                this.log(`websocket error: ${message}`);
                 reject(new Error(message));
             });
+            ws.addEventListener("close", (event) => {
+                this.log(`websocket close code=${event.code} reason=${event.reason || ""}`);
+            });
             ws.addEventListener("message", (ev) => {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 const msg = JSON.parse(String(ev.data));
-                if (typeof msg.id === "number") {
-                    this.handleCommandResponse(msg.id, msg);
-                    return;
-                }
-                if (msg.method === "Debugger.paused") {
-                    const reason = this.getPauseReason(msg.params);
-                    this.paused = true;
-                    trace(`Debugger.paused reason=${reason}`);
-                    void Promise.resolve(this.onPause?.({ reason })).catch((error) => {
-                        trace(`pause handler failed: ${error instanceof Error ? error.message : "unknown error"}`);
-                    });
-                    return;
-                }
-                if (msg.method === "Debugger.scriptParsed") {
-                    const params = msg.params;
-                    const lang = typeof params?.scriptLanguage === "string" ? params.scriptLanguage : "unknown";
-                    const url = typeof params?.url === "string" ? params.url : "";
-                    trace(`Debugger.scriptParsed language=${lang} url=${url}`);
-                    if (params && lang === "WebAssembly" && typeof params.scriptId === "string") {
-                        trace(`wasm module detected scriptId=${params.scriptId}`);
-                        void this.handleModuleLoad({
-                            scriptId: params.scriptId,
-                            url,
-                        }).catch((error) => {
-                            const message = error instanceof Error ? error.message : "unknown error";
-                            trace(`module load handler failed: ${message}`);
-                            process.stderr.write(`[node-debugger] module load handler failed: ${message}\n`);
-                        });
-                    }
-                }
+                this.handleCdpMessage(msg);
             });
         });
     }
+    handleCdpMessage(msg) {
+        if (typeof msg.id === "number") {
+            this.handleCommandResponse(msg.id, msg);
+            return;
+        }
+        if (msg.method === "Debugger.paused") {
+            this.handleDebuggerPaused(msg.params);
+            return;
+        }
+        if (msg.method === "Debugger.scriptParsed") {
+            this.handleScriptParsed(msg.params);
+        }
+    }
+    handleDebuggerPaused(params) {
+        const reason = this.getPauseReason(params);
+        this.pausedCallFrames = this.getPausedWasmCallFrames(params);
+        this.wasmMemoryBufferObjectId = undefined;
+        this.wasmGlobalsObjectId = undefined;
+        if (reason === "Break on start" && !this.wasmScriptId) {
+            this.log("Debugger.paused reason=Break on start location=inspect-brk startup");
+            void this.resumeInternalStartupPause();
+            return;
+        }
+        if (reason === "other" && this.wasmScriptId) {
+            this.log("Debugger.paused reason=other location=wasm pre-entry gate");
+            return;
+        }
+        const isExceptionPause = reason === "exception" || reason === "promiseRejection";
+        // CDP can only pause on exceptions for the whole Node process, not for a specific wasm module. We need
+        // "all" because the JavaScript wrapper can catch a wasm trap, but that also pauses for unrelated JavaScript
+        // exceptions. Treat the top frame belonging to our wasm module as the filter for a debugger-visible trap.
+        if (isExceptionPause && !this.isTopFrameWasm(params)) {
+            this.log(`Debugger.paused reason=${reason} outside wasm -> resume`);
+            void this.resumeIgnoredPause();
+            return;
+        }
+        const isWasmTrap = isExceptionPause;
+        if (isWasmTrap) {
+            this.paused = true;
+            this.log(`Debugger.paused reason=${reason} (wasm trap)`);
+            void this.notifyPause("exception");
+            return;
+        }
+        this.paused = true;
+        this.log(`Debugger.paused reason=${reason}`);
+        void this.notifyPause(reason);
+    }
+    async notifyPause(reason) {
+        try {
+            const pausedCallFrame = this.pausedCallFrames[0];
+            const wasmBytecodeOffset = pausedCallFrame
+                ? this.resolveWasmLocationBytecodeOffset(pausedCallFrame.location)
+                : undefined;
+            await this.onPause?.({ reason, wasmBytecodeOffset });
+        }
+        catch (error) {
+            this.log(`pause handler failed: ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
+    handleScriptParsed(params) {
+        const lang = typeof params?.scriptLanguage === "string" ? params.scriptLanguage : "unknown";
+        const url = typeof params?.url === "string" ? params.url : "";
+        this.log(`Debugger.scriptParsed language=${lang} url=${url}`);
+        if (!params || lang !== "WebAssembly" || typeof params.scriptId !== "string") {
+            return;
+        }
+        if (!this.isExpectedWasmModule(params)) {
+            this.log(`ignoring non-target wasm module scriptId=${params.scriptId} url=${url}`);
+            return;
+        }
+        this.wasmScriptId = params.scriptId;
+        this.log(`wasm module detected scriptId=${params.scriptId}`);
+        void this.handleModuleLoad({
+            scriptId: params.scriptId,
+            url,
+        }).catch((error) => {
+            const message = error instanceof Error ? error.message : "unknown error";
+            this.log(`module load handler failed: ${message}`);
+            process.stderr.write(`Module load handler failed: ${message}\n`);
+        });
+    }
+    isExpectedWasmModule(params) {
+        if (!this.wasmFilePath) {
+            return false;
+        }
+        return params.sourceMapURL === `${path.basename(this.wasmFilePath)}.map`;
+    }
+    async resumeInternalStartupPause() {
+        await this.resumeIgnoredPause("inspect-brk startup pause");
+    }
+    async resumeIgnoredPause(description = "non-wasm exception pause") {
+        try {
+            await this.waitForCommand("Debugger.resume");
+            this.paused = false;
+            this.pausedCallFrames = [];
+            this.wasmMemoryBufferObjectId = undefined;
+            this.wasmGlobalsObjectId = undefined;
+            this.log(`${description} resumed`);
+        }
+        catch (error) {
+            this.log(`failed to resume ${description}: ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
     handleCommandResponse(id, msg) {
         const callbacks = this.pendingCommandCallbacks.get(id);
         if (!callbacks) {
@@ -215,10 +494,12 @@ export class NodeDebugger {
         }
         this.pendingCommandCallbacks.delete(id);
         if (msg.error) {
+            this.log(`CDP <- error id=${id} message=${msg.error.message ?? "CDP command failed"}`);
             callbacks.onError?.(new Error(msg.error.message ?? "CDP command failed"));
             return;
         }
-        callbacks.onSuccess?.();
+        this.log(`CDP <- success id=${id}`);
+        callbacks.onSuccess?.(msg.result);
     }
     getPauseReason(params) {
         if (Array.isArray(params?.hitBreakpoints) && params.hitBreakpoints.length > 0) {
@@ -229,12 +510,262 @@ export class NodeDebugger {
         }
         return "unknown";
     }
+    getPausedWasmCallFrames(params) {
+        if (!Array.isArray(params?.callFrames)) {
+            return [];
+        }
+        const callFrames = params.callFrames.filter(isCDPCallFrame);
+        if (!this.wasmScriptId) {
+            this.log(`getPausedWasmCallFrames skipped ${callFrames.length} non-wasm startup frames before wasm script load`);
+            return [];
+        }
+        const wasmCallFrames = callFrames.filter((callFrame) => callFrame.location.scriptId === this.wasmScriptId);
+        this.log(`getPausedWasmCallFrames total=${callFrames.length} wasm=${wasmCallFrames.length}`);
+        return wasmCallFrames;
+    }
+    isTopFrameWasm(params) {
+        if (!Array.isArray(params?.callFrames) || !this.wasmScriptId) {
+            return false;
+        }
+        const topCallFrame = params.callFrames.find(isCDPCallFrame);
+        return topCallFrame?.location.scriptId === this.wasmScriptId;
+    }
+    toPausedWasmFrame(callFrame) {
+        return {
+            functionName: callFrame.functionName,
+            wasmBytecodeOffset: this.resolveWasmLocationBytecodeOffset(callFrame.location),
+        };
+    }
+    async getLocalScopeVariables(callFrame) {
+        const localScope = callFrame.scopeChain.find((scope) => scope.type === "local") ?? callFrame.scopeChain[0];
+        const objectId = localScope?.object.objectId;
+        if (!objectId) {
+            return [];
+        }
+        const result = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId,
+            ownProperties: true,
+        });
+        const properties = Array.isArray(result.result) ? result.result.filter(isCDPPropertyDescriptor) : [];
+        const variables = [];
+        for (const property of properties) {
+            if (!property.value) {
+                continue;
+            }
+            const localIndex = variables.length;
+            variables.push({
+                name: `local${localIndex}`,
+                value: await this.readRemoteObjectValue(property.value),
+                type: property.value.description ?? property.value.type,
+                localIndex,
+            });
+        }
+        return variables;
+    }
+    async getWasmMemoryBufferObjectId() {
+        if (this.wasmMemoryBufferObjectId) {
+            return this.wasmMemoryBufferObjectId;
+        }
+        this.log("getWasmMemoryBufferObjectId -> getWasmMemoryObjectId");
+        const memoryObjectId = await this.getWasmMemoryObjectId();
+        if (!memoryObjectId) {
+            this.log("getWasmMemoryBufferObjectId failed: memory object unavailable");
+            return undefined;
+        }
+        this.log("getWasmMemoryBufferObjectId -> Runtime.callFunctionOn buffer");
+        const bufferResult = await this.waitForCommandResult("Runtime.callFunctionOn", {
+            objectId: memoryObjectId,
+            functionDeclaration: GET_WASM_MEMORY_BUFFER_FUNCTION,
+            silent: true,
+            objectGroup: LINEAR_MEMORY_OBJECT_GROUP,
+        });
+        const bufferObject = getRuntimeEvaluateRemoteObject(bufferResult);
+        this.wasmMemoryBufferObjectId = bufferObject?.objectId;
+        this.log(`getWasmMemoryBufferObjectId result=${this.wasmMemoryBufferObjectId ?? "undefined"}`);
+        return this.wasmMemoryBufferObjectId;
+    }
+    async getWasmMemoryObjectId() {
+        const moduleScope = this.pausedCallFrames[0]?.scopeChain.find((scope) => scope.type === "module");
+        const objectId = moduleScope?.object.objectId;
+        if (!objectId) {
+            return undefined;
+        }
+        this.log("getWasmMemoryObjectId -> Runtime.getProperties module scope");
+        const result = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId,
+            ownProperties: false,
+        });
+        const properties = Array.isArray(result.result) ? result.result.filter(isCDPPropertyDescriptor) : [];
+        const memoriesProperty = properties.find((property) => property.name === "memories" && property.value?.objectId);
+        if (!memoriesProperty?.value?.objectId) {
+            return undefined;
+        }
+        this.log("getWasmMemoryObjectId -> Runtime.getProperties memories");
+        const memoriesResult = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId: memoriesProperty.value.objectId,
+            ownProperties: false,
+        });
+        const memories = Array.isArray(memoriesResult.result) ? memoriesResult.result.filter(isCDPPropertyDescriptor) : [];
+        const nestedMemory = memories.find((property) => property.value && isWasmMemoryObject(property.value));
+        this.log(`getWasmMemoryObjectId result=${nestedMemory?.value?.objectId ?? "undefined"}`);
+        return nestedMemory?.value?.objectId;
+    }
+    async getWasmGlobalsObjectId() {
+        if (this.wasmGlobalsObjectId) {
+            return this.wasmGlobalsObjectId;
+        }
+        const moduleScope = this.pausedCallFrames[0]?.scopeChain.find((scope) => scope.type === "module");
+        const moduleObjectId = moduleScope?.object.objectId;
+        if (!moduleObjectId) {
+            return undefined;
+        }
+        const moduleResult = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId: moduleObjectId,
+            ownProperties: false,
+        });
+        const moduleProperties = Array.isArray(moduleResult.result)
+            ? moduleResult.result.filter(isCDPPropertyDescriptor)
+            : [];
+        this.wasmGlobalsObjectId = moduleProperties.find((property) => property.name === "globals")?.value?.objectId;
+        return this.wasmGlobalsObjectId;
+    }
+    async readRemoteObjectValue(value) {
+        if (value.subtype !== "wasmvalue" || !value.objectId) {
+            return formatRemoteObject(value);
+        }
+        const result = await this.waitForCommandResult("Runtime.getProperties", {
+            objectId: value.objectId,
+            ownProperties: true,
+        });
+        const innerProperties = Array.isArray(result.result) ? result.result.filter(isCDPPropertyDescriptor) : [];
+        const valueProperty = innerProperties.find((property) => property.name === "value" || property.name === "0");
+        return valueProperty?.value ? formatRemoteObject(valueProperty.value) : formatRemoteObject(value);
+    }
     async handleModuleLoad(runtimeInfo) {
+        if (this.hasRuntimeExited()) {
+            this.log("skip wasm module load because runtime already exited");
+            return;
+        }
         if (!this.wasmFilePath) {
             throw new Error("wasm file path is not available");
         }
+        this.log(`loading wasm debug metadata from ${this.wasmFilePath}`);
         const module = await DebuggerWasmModule.load(this.wasmFilePath, runtimeInfo);
+        this.log(`wasm debug metadata loaded from ${module.sourceMapFilePath}`);
         void this.onModuleLoad?.(module);
     }
+    hasRuntimeExited() {
+        return this.child !== undefined && (this.child.exitCode !== null || this.child.signalCode !== null);
+    }
+}
+function parseRuntimeStderr(text) {
+    let waitingForDebuggerDisconnect = false;
+    const output = text
+        .split(/(?<=\n)/)
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (trimmed === NODE_WAITING_FOR_DEBUGGER_DISCONNECT) {
+            waitingForDebuggerDisconnect = true;
+            return false;
+        }
+        return (trimmed !== "" &&
+            !trimmed.startsWith("Debugger listening on") &&
+            !trimmed.startsWith("For help, see:") &&
+            trimmed !== "Debugger attached.");
+    })
+        .join("");
+    return { output, waitingForDebuggerDisconnect };
+}
+function getRuntimeEnv() {
+    const env = { ...process.env };
+    delete env.VSCODE_INSPECTOR_OPTIONS;
+    const nodeOptions = filterAutoAttachNodeOptions(env.NODE_OPTIONS);
+    if (nodeOptions) {
+        env.NODE_OPTIONS = nodeOptions;
+    }
+    else {
+        delete env.NODE_OPTIONS;
+    }
+    return env;
+}
+function filterAutoAttachNodeOptions(nodeOptions) {
+    if (!nodeOptions) {
+        return "";
+    }
+    const parts = nodeOptions.split(/\s+/).filter(Boolean);
+    const filtered = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const next = parts[i + 1];
+        if ((part === "--require" || part === "-r") && next && isVsCodeJsDebugBootloader(next)) {
+            i++;
+            continue;
+        }
+        if ((part.startsWith("--require=") || part.startsWith("-r=")) && isVsCodeJsDebugBootloader(part)) {
+            continue;
+        }
+        filtered.push(part);
+    }
+    return filtered.join(" ");
+}
+function isVsCodeJsDebugBootloader(value) {
+    return value.includes("js-debug") || value.includes("vscode-js-debug");
+}
+function isCDPPropertyDescriptor(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    return typeof value.name === "string";
+}
+function isCDPCallFrame(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const callFrame = value;
+    return (typeof callFrame.callFrameId === "string" &&
+        typeof callFrame.functionName === "string" &&
+        isCDPLocation(callFrame.location) &&
+        Array.isArray(callFrame.scopeChain));
+}
+function isCDPLocation(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const location = value;
+    return (typeof location.scriptId === "string" &&
+        typeof location.lineNumber === "number" &&
+        typeof location.columnNumber === "number");
+}
+function isWasmMemoryObject(value) {
+    return value.objectId !== undefined && value.subtype === "webassemblymemory";
+}
+function getRuntimeEvaluateRemoteObject(result) {
+    const remoteObject = result.result;
+    if (!remoteObject || typeof remoteObject !== "object") {
+        return undefined;
+    }
+    return remoteObject;
+}
+function formatRemoteObject(value) {
+    if (value.unserializableValue !== undefined) {
+        return value.unserializableValue;
+    }
+    const rawValue = value.value;
+    if (rawValue !== undefined) {
+        if (rawValue === null) {
+            return "null";
+        }
+        if (typeof rawValue === "object") {
+            return value.description ?? value.type ?? "<unavailable>";
+        }
+        if (typeof rawValue === "string") {
+            return rawValue;
+        }
+        if (typeof rawValue === "number" || typeof rawValue === "boolean" || typeof rawValue === "bigint") {
+            return rawValue.toString();
+        }
+        return value.description ?? value.type ?? "<unavailable>";
+    }
+    return value.description ?? value.type ?? "<unavailable>";
 }
 //# sourceMappingURL=nodeDebugger.js.map