diff --git a/src/js/internal/debugger.ts b/src/js/internal/debugger.ts
index 2488a5995b9..8b9246fd3ca 100644
--- a/src/js/internal/debugger.ts
+++ b/src/js/internal/debugger.ts
@@ -146,14 +146,15 @@ export default function (
     return;
   }
 
-  if (isNodeInspector) {
-    // inspector.open(): CDP connections, URL reported back, control callback for close/forward.
-    // https://github.com/nodejs/node/blob/main/lib/inspector.js
-    let debug: Debugger | undefined;
+  // Control channel from the inspected thread to a node:inspector-owned
+  // server: close() stops it, open() restarts it here, and an in-process
+  // Session forwards Debugger.* to the shared backend. `initial` may be nil.
+  function createNodeInspectorControl(initial: Debugger | undefined) {
+    let debug = initial;
     let sessionBackend: Backend | undefined;
     let sessionAdapter: any;
     let sessionRefs = 0;
-    const control = (message: string) => {
+    function control(message: string) {
       let parsed: any;
       try {
         parsed = JSON.parse(message);
@@ -246,8 +247,15 @@ export default function (
           return;
         }
       }
-    };
+    }
+    return control;
+  }
 
+  if (isNodeInspector) {
+    // node:inspector's inspector.open(): serve CDP, report the URL back (for
+    // Node's "Debugger listening on ..." line), and hand back a control
+    // callback so the inspected thread can close the server / forward commands.
+    let debug: Debugger | undefined;
     try {
       debug = new Debugger(
         executionContextId,
@@ -264,11 +272,15 @@ export default function (
       // Register the control callback even though the server failed to start
       // (e.g. the port is in use), so a later inspector.open() can retry with
       // an "open" control message on this already-running debugger thread.
-      reportNodeInspectorServerStarted("", control, nodeInspectorListenErrorDetail(error));
+      reportNodeInspectorServerStarted(
+        "",
+        createNodeInspectorControl(undefined),
+        nodeInspectorListenErrorDetail(error),
+      );
       return;
     }
 
-    reportNodeInspectorServerStarted(debug.url!.href, control, undefined);
+    reportNodeInspectorServerStarted(debug.url!.href, createNodeInspectorControl(debug), undefined);
     return;
   }
 
@@ -289,8 +301,11 @@ export default function (
     exit("Failed to start inspector:\n", error);
   }
 
-  // If the user types --inspect, we print the URL to the console.
-  // If the user is using an editor extension, don't print anything.
+  const { cdpUrl } = debug;
+
+  // Print the URL for --inspect (not for editor extensions), *before*
+  // reportNodeInspectorServerStarted releases the inspected thread: Node's
+  // banner precedes script output and stderr-scraping tools rely on that order.
   if (!isAutomatic) {
     const debugUrl = debug.url;
     if (debugUrl) {
@@ -319,6 +334,13 @@ export default function (
     }
   }
 
+  // Report --inspect's CDP endpoint so node:inspector's url()/open()/close()
+  // behave as Node does for a CLI-started inspector; this also releases the
+  // inspected thread, which blocks on the report.
+  if (enableNodeCDP && cdpUrl) {
+    reportNodeInspectorServerStarted(cdpUrl, createNodeInspectorControl(debug), undefined);
+  }
+
   const notifyUrl = process.env["BUN_INSPECT_NOTIFY"] || "";
   if (notifyUrl) {
     // Only send this once.
diff --git a/src/js/internal/debugger/inspect.ts b/src/js/internal/debugger/inspect.ts
new file mode 100644
index 00000000000..c5ca01f067d
--- /dev/null
+++ b/src/js/internal/debugger/inspect.ts
@@ -0,0 +1,362 @@
+// Port of Node.js lib/internal/debugger/inspect.js (v26.3.0) — the entry
+// point for the `bun inspect` / `node inspect` CLI debugger.
+"use strict";
+
+const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePop,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  FunctionPrototypeBind,
+  Number,
+  PromisePrototypeThen,
+  PromiseResolve,
+  Proxy,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolSplit,
+  StringPrototypeEndsWith,
+  StringPrototypeSplit,
+} = require("internal/debugger/primordials");
+
+const { EventEmitter } = require("node:events");
+const util = require("node:util");
+const { setTimeout: pSetTimeout } = require("node:timers/promises");
+
+const InspectClient = require("internal/debugger/inspect_client");
+const { launchChildProcess, writeInspectUsageAndExit } = require("internal/debugger/inspect_helpers");
+const { parseProbeTokens, runProbeMode } = require("internal/debugger/inspect_probe");
+const createRepl = require("internal/debugger/inspect_repl");
+
+const debuglog = util.debuglog("inspect");
+
+// Node's process exit codes (internalBinding('errors').exitCodes upstream).
+const kGenericUserError = 1;
+const kInvalidCommandLineArgument = 9;
+const kNoFailure = 0;
+
+function createAgentProxy(domain, client) {
+  const agent = new EventEmitter();
+  agent.then = (then, _catch) => {
+    // TODO: potentially fetch the protocol and pretty-print it here.
+    const descriptor = {
+      [util.inspect.custom](depth, { stylize }) {
+        return stylize(`[Agent ${domain}]`, "special");
+      },
+    };
+    return PromisePrototypeThen(PromiseResolve(descriptor), then, _catch);
+  };
+
+  return new Proxy(agent, {
+    __proto__: null,
+    get(target, name) {
+      if (name in target) return target[name];
+      return function callVirtualMethod(params) {
+        return client.callMethod(`${domain}.${name}`, params);
+      };
+    },
+  });
+}
+
+class NodeInspector {
+  constructor(options, stdin, stdout) {
+    this.options = options;
+    this.stdin = stdin;
+    this.stdout = stdout;
+
+    this.paused = true;
+    this.child = null;
+
+    const { script } = options;
+    if (script) {
+      this._runScript = FunctionPrototypeBind(
+        launchChildProcess,
+        null,
+        [script, ...options.scriptArgs],
+        options.host,
+        options.port,
+        FunctionPrototypeBind(this.childPrint, this),
+        { __proto__: null, deferBreakToClient: true },
+      );
+    } else {
+      this._runScript = () => PromiseResolve([null, options.port, options.host]);
+    }
+
+    this.client = new InspectClient();
+
+    this.domainNames = ["Debugger", "HeapProfiler", "Profiler", "Runtime"];
+    ArrayPrototypeForEach(this.domainNames, domain => {
+      this[domain] = createAgentProxy(domain, this.client);
+    });
+    this.handleDebugEvent = (fullName, params) => {
+      const { 0: domain, 1: name } = StringPrototypeSplit(fullName, ".", 2);
+      if (domain in this) {
+        this[domain].emit(name, params);
+      }
+    };
+    this.client.on("debugEvent", this.handleDebugEvent);
+    const startRepl = createRepl(this);
+
+    // Handle all possible exits
+    process.on("exit", () => this.killChild());
+    const exitCodeZero = () => process.exit(kNoFailure);
+    process.once("SIGTERM", exitCodeZero);
+    process.once("SIGHUP", exitCodeZero);
+
+    (async () => {
+      try {
+        await this.run();
+        const repl = await startRepl();
+        this.repl = repl;
+        this.repl.on("exit", exitCodeZero);
+        this.paused = false;
+      } catch (error) {
+        process.nextTick(() => {
+          throw error;
+        });
+      }
+    })();
+  }
+
+  suspendReplWhile(fn) {
+    const { repl } = this;
+    if (repl) {
+      repl.pause();
+    }
+    this.stdin.pause();
+    this.paused = true;
+    return (async () => {
+      try {
+        await fn();
+        this.paused = false;
+        if (repl) {
+          repl.resume();
+          repl.displayPrompt();
+        }
+        this.stdin.resume();
+      } catch (error) {
+        process.nextTick(() => {
+          throw error;
+        });
+      }
+    })();
+  }
+
+  killChild() {
+    this.client.reset();
+    if (this.child) {
+      this.child.kill();
+      this.child = null;
+    }
+  }
+
+  async run() {
+    this.killChild();
+
+    const { 0: child, 1: port, 2: host } = await this._runScript();
+    this.child = child;
+
+    this.print(`connecting to ${host}:${port} ..`, false);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      debuglog("connection attempt #%d", attempt);
+      this.stdout.write(".");
+      try {
+        await this.client.connect(port, host);
+        debuglog("connection established");
+        if (this.options.script) {
+          // See launchChildProcess: the child is parked in --inspect-wait, so
+          // arm the break on its first statement before the REPL resumes it.
+          await this.client.callMethod("Debugger.enable");
+          await this.client.callMethod("Debugger.pause");
+        }
+        this.stdout.write(" ok\n");
+        return;
+      } catch (error) {
+        debuglog("connect failed", error);
+        await pSetTimeout(1000);
+      }
+    }
+    this.stdout.write(" failed to connect, please retry\n");
+    process.exit(kGenericUserError);
+  }
+
+  clearLine() {
+    if (this.stdout.isTTY) {
+      this.stdout.cursorTo(0);
+      this.stdout.clearLine(1);
+    } else {
+      this.stdout.write("\b");
+    }
+  }
+
+  print(text, appendNewline = false) {
+    this.clearLine();
+    this.stdout.write(appendNewline ? `${text}\n` : text);
+  }
+
+  #stdioBuffers = { stdout: "", stderr: "" };
+  childPrint(text, which) {
+    const lines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, this.#stdioBuffers[which] + text);
+
+    this.#stdioBuffers[which] = "";
+
+    if (lines[lines.length - 1] !== "") {
+      this.#stdioBuffers[which] = ArrayPrototypePop(lines);
+    }
+
+    const textToPrint = ArrayPrototypeJoin(
+      ArrayPrototypeMap(lines, chunk => `< ${chunk}`),
+      "\n",
+    );
+
+    if (lines.length) {
+      this.print(textToPrint, true);
+      if (!this.paused) {
+        this.repl.displayPrompt(true);
+      }
+    }
+
+    if (StringPrototypeEndsWith(textToPrint, "Waiting for the debugger to disconnect...\n")) {
+      this.killChild();
+    }
+  }
+}
+
+function parseInteractiveArgs(args) {
+  const target = ArrayPrototypeShift(args);
+  let host = "127.0.0.1";
+  let port = 9229;
+  let isRemote = false;
+  let script = target;
+  let scriptArgs = args;
+
+  const hostMatch = RegExpPrototypeExec(/^([^:]+):(\d+)$/, target);
+  const portMatch = RegExpPrototypeExec(/^--port=(\d+)$/, target);
+
+  if (hostMatch) {
+    // Connecting to remote debugger
+    host = hostMatch[1];
+    port = Number(hostMatch[2]);
+    isRemote = true;
+    script = null;
+  } else if (portMatch) {
+    // Start on custom port
+    port = Number(portMatch[1]);
+    script = args[0];
+    scriptArgs = ArrayPrototypeSlice(args, 1);
+  } else if (args.length === 1 && RegExpPrototypeExec(/^\d+$/, args[0]) !== null && target === "-p") {
+    // Start debugger against a given pid
+    const pid = Number(args[0]);
+    try {
+      process._debugProcess(pid);
+    } catch (e) {
+      if (e.code === "ESRCH") {
+        process.stderr.write(`Target process: ${pid} doesn't exist.\n`);
+        process.exit(kGenericUserError);
+      }
+      throw e;
+    }
+    script = null;
+    isRemote = true;
+  }
+
+  return {
+    host,
+    port,
+    isRemote,
+    script,
+    scriptArgs,
+  };
+}
+
+const kInspectArgOptions = {
+  __proto__: null,
+  expr: { type: "string" },
+  help: { type: "boolean", short: "h" },
+  json: { type: "boolean" },
+  // Port and timeout use type 'string' because parseArgs has no
+  // numeric type; the values are parsed to integers by parseProbeTokens().
+  port: { type: "string" },
+  preview: { type: "boolean" },
+  probe: { type: "string" },
+  timeout: { type: "string" },
+};
+
+// Returns { mode: 'help' | 'probe' | 'interactive', ... } for `inspect` args;
+// the first option/terminator/positional token decides the mode.
+function parseInspectMode(args) {
+  const { tokens } = util.parseArgs({
+    args,
+    allowPositionals: true,
+    options: kInspectArgOptions,
+    strict: false,
+    tokens: true,
+  });
+
+  for (const token of tokens) {
+    if (token.kind === "option") {
+      if (token.name === "help") return { mode: "help" };
+      if (token.name === "probe") {
+        // `--probe --help` / `--probe -h` (no value) consumes the help flag
+        // as the probe's "value"; surface help instead of a probe error.
+        if (!token.inlineValue && (token.value === "--help" || token.value === "-h")) {
+          return { mode: "help" };
+        }
+        return { mode: "probe", tokens, args };
+      }
+    }
+    if (token.kind === "option-terminator" || token.kind === "positional") {
+      break;
+    }
+  }
+  return { mode: "interactive" };
+}
+
+function startInspect(argv = ArrayPrototypeSlice(process.argv, 2), stdin = process.stdin, stdout = process.stdout) {
+  const invokedAs = `${process.argv0} ${process.argv[1]}`;
+
+  if (argv.length < 1) {
+    writeInspectUsageAndExit(invokedAs, undefined, kInvalidCommandLineArgument);
+  }
+
+  const parsed = parseInspectMode(argv);
+
+  if (parsed.mode === "help") {
+    writeInspectUsageAndExit(invokedAs);
+  }
+
+  if (parsed.mode === "probe") {
+    let probeOptions;
+    try {
+      probeOptions = parseProbeTokens(parsed.tokens, parsed.args);
+    } catch (error) {
+      writeInspectUsageAndExit(invokedAs, error.message, kInvalidCommandLineArgument);
+    }
+    runProbeMode(stdout, probeOptions);
+    return;
+  }
+
+  const options = parseInteractiveArgs(argv);
+  const inspector = new NodeInspector(options, stdin, stdout);
+
+  stdin.resume();
+
+  function handleUnexpectedError(e) {
+    if (e.code !== "ERR_DEBUGGER_STARTUP_ERROR") {
+      process.stderr.write(
+        "There was an internal error in Bun's debugger. Please report this bug.\n" + `${e.message}\n${e.stack}\n`,
+      );
+    } else {
+      process.stderr.write(e.message);
+      process.stderr.write("\n");
+    }
+    const { child } = inspector;
+    if (child) child.kill();
+    process.exit(kGenericUserError);
+  }
+
+  process.on("uncaughtException", handleUnexpectedError);
+}
+
+export default { start: startInspect };
diff --git a/src/js/internal/debugger/inspect_client.ts b/src/js/internal/debugger/inspect_client.ts
new file mode 100644
index 00000000000..d62d2f66b70
--- /dev/null
+++ b/src/js/internal/debugger/inspect_client.ts
@@ -0,0 +1,358 @@
+// Port of Node.js lib/internal/debugger/inspect_client.js (v26.3.0).
+"use strict";
+
+const {
+  ArrayPrototypeForEach,
+  ArrayPrototypePush,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  JSONParse,
+  JSONStringify,
+  ObjectKeys,
+  ObjectValues,
+  Promise,
+} = require("internal/debugger/primordials");
+
+const { Buffer } = require("node:buffer");
+const crypto = require("node:crypto");
+const { EventEmitter, once } = require("node:events");
+const http = require("node:http");
+
+const debuglog = require("node:util").debuglog("inspect");
+
+const kOpCodeText = 0x1;
+const kOpCodeClose = 0x8;
+
+const kFinalBit = 0x80;
+const kReserved1Bit = 0x40;
+const kReserved2Bit = 0x20;
+const kReserved3Bit = 0x10;
+const kOpCodeMask = 0xf;
+const kMaskBit = 0x80;
+const kPayloadLengthMask = 0x7f;
+
+const kMaxSingleBytePayloadLength = 125;
+const kMaxTwoBytePayloadLength = 0xffff;
+const kTwoBytePayloadLengthField = 126;
+const kEightBytePayloadLengthField = 127;
+const kMaskingKeyWidthInBytes = 4;
+
+// This guid is defined in the Websocket Protocol RFC
+// https://tools.ietf.org/html/rfc6455#section-1.3
+const WEBSOCKET_HANDSHAKE_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+function unpackError({ code, message }) {
+  const err = $ERR_DEBUGGER_ERROR(`${message}`);
+  err.code = code;
+  ErrorCaptureStackTrace(err, unpackError);
+  return err;
+}
+
+function validateHandshake(requestKey, responseKey) {
+  const expectedResponseKeyBase = requestKey + WEBSOCKET_HANDSHAKE_GUID;
+  const shasum = crypto.createHash("sha1");
+  shasum.update(expectedResponseKeyBase);
+  const shabuf = shasum.digest();
+
+  if (shabuf.toString("base64") !== responseKey) {
+    throw $ERR_DEBUGGER_ERROR(`WebSocket secret mismatch: ${requestKey} did not match ${responseKey}`);
+  }
+}
+
+function encodeFrameHybi17(payload) {
+  const dataLength = payload.length;
+
+  let singleByteLength;
+  let additionalLength;
+  if (dataLength > kMaxTwoBytePayloadLength) {
+    singleByteLength = kEightBytePayloadLengthField;
+    additionalLength = Buffer.alloc(8);
+    let remaining = dataLength;
+    for (let i = 0; i < 8; ++i) {
+      additionalLength[7 - i] = remaining & 0xff;
+      remaining >>= 8;
+    }
+  } else if (dataLength > kMaxSingleBytePayloadLength) {
+    singleByteLength = kTwoBytePayloadLengthField;
+    additionalLength = Buffer.alloc(2);
+    additionalLength[0] = (dataLength & 0xff00) >> 8;
+    additionalLength[1] = dataLength & 0xff;
+  } else {
+    additionalLength = Buffer.alloc(0);
+    singleByteLength = dataLength;
+  }
+
+  const header = Buffer.from([kFinalBit | kOpCodeText, kMaskBit | singleByteLength]);
+
+  const mask = Buffer.alloc(4);
+  const masked = Buffer.alloc(dataLength);
+  for (let i = 0; i < dataLength; ++i) {
+    masked[i] = payload[i] ^ mask[i % kMaskingKeyWidthInBytes];
+  }
+
+  return Buffer.concat([header, additionalLength, mask, masked]);
+}
+
+function decodeFrameHybi17(data) {
+  const dataAvailable = data.length;
+  const notComplete = { closed: false, payload: null, rest: data };
+  let payloadOffset = 2;
+  if (dataAvailable - payloadOffset < 0) return notComplete;
+
+  const firstByte = data[0];
+  const secondByte = data[1];
+
+  const final = (firstByte & kFinalBit) !== 0;
+  const reserved1 = (firstByte & kReserved1Bit) !== 0;
+  const reserved2 = (firstByte & kReserved2Bit) !== 0;
+  const reserved3 = (firstByte & kReserved3Bit) !== 0;
+  const opCode = firstByte & kOpCodeMask;
+  const masked = (secondByte & kMaskBit) !== 0;
+  const compressed = reserved1;
+  if (compressed) {
+    throw $ERR_DEBUGGER_ERROR("Compressed frames not supported");
+  }
+  if (!final || reserved2 || reserved3) {
+    throw $ERR_DEBUGGER_ERROR("Only compression extension is supported");
+  }
+
+  if (masked) {
+    throw $ERR_DEBUGGER_ERROR("Masked server frame - not supported");
+  }
+
+  let closed = false;
+  switch (opCode) {
+    case kOpCodeClose:
+      closed = true;
+      break;
+    case kOpCodeText:
+      break;
+    default:
+      throw $ERR_DEBUGGER_ERROR(`Unsupported op code ${opCode}`);
+  }
+
+  let payloadLength = secondByte & kPayloadLengthMask;
+  switch (payloadLength) {
+    case kTwoBytePayloadLengthField:
+      payloadOffset += 2;
+      payloadLength = (data[2] << 8) + data[3];
+      break;
+
+    case kEightBytePayloadLengthField:
+      payloadOffset += 8;
+      payloadLength = 0;
+      for (let i = 0; i < 8; ++i) {
+        payloadLength <<= 8;
+        payloadLength |= data[2 + i];
+      }
+      break;
+
+    default:
+    // Nothing. We already have the right size.
+  }
+  if (dataAvailable - payloadOffset - payloadLength < 0) return notComplete;
+
+  const payloadEnd = payloadOffset + payloadLength;
+  return {
+    payload: data.slice(payloadOffset, payloadEnd),
+    rest: data.slice(payloadEnd),
+    closed,
+  };
+}
+
+class Client extends EventEmitter {
+  constructor() {
+    super();
+    this.handleChunk = FunctionPrototypeBind(this._handleChunk, this);
+
+    this._port = undefined;
+    this._host = undefined;
+
+    this.reset();
+  }
+
+  _handleChunk(chunk) {
+    this._unprocessed = Buffer.concat([this._unprocessed, chunk]);
+
+    while (this._unprocessed.length > 2) {
+      const { closed, payload: payloadBuffer, rest } = decodeFrameHybi17(this._unprocessed);
+      this._unprocessed = rest;
+
+      if (closed) {
+        this.reset();
+        return;
+      }
+      if (payloadBuffer === null || payloadBuffer.length === 0) break;
+
+      const payloadStr = payloadBuffer.toString();
+      debuglog("< %s", payloadStr);
+      const lastChar = payloadStr[payloadStr.length - 1];
+      if (payloadStr[0] !== "{" || lastChar !== "}") {
+        throw $ERR_DEBUGGER_ERROR(`Payload does not look like JSON: ${payloadStr}`);
+      }
+      let payload;
+      try {
+        payload = JSONParse(payloadStr);
+      } catch (parseError) {
+        parseError.string = payloadStr;
+        throw parseError;
+      }
+
+      const { id, method, params, result, error } = payload;
+      if (id) {
+        const handler = this._pending[id];
+        if (handler) {
+          delete this._pending[id];
+          handler(error, result);
+        }
+      } else if (method) {
+        this.emit("debugEvent", method, params);
+        this.emit(method, params);
+      } else {
+        throw $ERR_DEBUGGER_ERROR(`Unsupported response: ${payloadStr}`);
+      }
+    }
+  }
+
+  reset() {
+    const pending = this._pending;
+    if (pending) {
+      ArrayPrototypeForEach(ObjectValues(pending), handler => {
+        handler({
+          code: "ERR_DEBUGGER_ERROR",
+          message: "Debugger session ended",
+        });
+      });
+    }
+    const { _http, _socket } = this;
+    if (_http) {
+      _http.destroy();
+    }
+    if (_socket) {
+      _socket.destroy();
+    }
+    this._http = null;
+    this._lastId = 0;
+    this._socket = null;
+    this._pending = {};
+    this._unprocessed = Buffer.alloc(0);
+  }
+
+  callMethod(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this._socket) {
+        reject($ERR_DEBUGGER_ERROR("Use `run` to start the app again."));
+        return;
+      }
+      const data = { id: ++this._lastId, method, params };
+      this._pending[data.id] = (error, result) => {
+        if (error) reject(unpackError(error));
+        else resolve(ObjectKeys(result).length ? result : undefined);
+      };
+      const json = JSONStringify(data);
+      debuglog("> %s", json);
+      this._socket.write(encodeFrameHybi17(Buffer.from(json)));
+    });
+  }
+
+  _fetchJSON(urlPath) {
+    return new Promise((resolve, reject) => {
+      const httpReq = http.get({
+        host: this._host,
+        port: this._port,
+        path: urlPath,
+      });
+
+      const chunks = [];
+
+      function onResponse(httpRes) {
+        function parseChunks() {
+          const resBody = Buffer.concat(chunks).toString();
+          const { statusCode } = httpRes;
+          if (statusCode !== 200) {
+            reject($ERR_DEBUGGER_ERROR(`Unexpected ${statusCode}: ${resBody}`));
+            return;
+          }
+          try {
+            resolve(JSONParse(resBody));
+          } catch {
+            reject($ERR_DEBUGGER_ERROR(`Response didn't contain JSON: ${resBody}`));
+          }
+        }
+
+        httpRes.on("error", reject);
+        httpRes.on("data", chunk => ArrayPrototypePush(chunks, chunk));
+        httpRes.on("end", parseChunks);
+      }
+
+      httpReq.on("error", reject);
+      httpReq.on("response", onResponse);
+    });
+  }
+
+  async connect(port, host) {
+    this._port = port;
+    this._host = host;
+    const urlPath = await this._discoverWebsocketPath();
+    return this._connectWebsocket(urlPath);
+  }
+
+  async _discoverWebsocketPath() {
+    const {
+      0: { webSocketDebuggerUrl },
+    } = await this._fetchJSON("/json");
+    const { pathname, search } = new URL(webSocketDebuggerUrl);
+    return `${pathname}${search}`;
+  }
+
+  _connectWebsocket(urlPath) {
+    this.reset();
+
+    const requestKey = crypto.randomBytes(16).toString("base64");
+    debuglog("request WebSocket", requestKey);
+
+    const httpReq = (this._http = http.request({
+      host: this._host,
+      port: this._port,
+      path: urlPath,
+      headers: {
+        "Connection": "Upgrade",
+        "Upgrade": "websocket",
+        "Sec-WebSocket-Key": requestKey,
+        "Sec-WebSocket-Version": "13",
+      },
+    }));
+    httpReq.on("error", e => {
+      this.emit("error", e);
+    });
+    httpReq.on("response", httpRes => {
+      const { statusCode } = httpRes;
+      if (statusCode >= 400) {
+        process.stderr.write(`Unexpected HTTP code: ${statusCode}\n`);
+        httpRes.pipe(process.stderr);
+      } else {
+        httpRes.pipe(process.stderr);
+      }
+    });
+
+    const handshakeListener = (res, socket) => {
+      validateHandshake(requestKey, res.headers["sec-websocket-accept"]);
+      debuglog("websocket upgrade");
+
+      this._socket = socket;
+      socket.on("data", this.handleChunk);
+      socket.on("close", () => {
+        this.emit("close");
+      });
+
+      this.emit("ready");
+    };
+
+    const onReady = once(this, "ready");
+    httpReq.on("upgrade", handshakeListener);
+    httpReq.end();
+    return onReady;
+  }
+}
+
+export default Client;
diff --git a/src/js/internal/debugger/inspect_helpers.ts b/src/js/internal/debugger/inspect_helpers.ts
new file mode 100644
index 00000000000..74a2ea0013f
--- /dev/null
+++ b/src/js/internal/debugger/inspect_helpers.ts
@@ -0,0 +1,185 @@
+// Port of Node.js lib/internal/debugger/inspect_helpers.js (v26.3.0) for the
+// `bun inspect` / `node inspect` CLI debugger.
+"use strict";
+
+const {
+  ArrayPrototypePushApply,
+  Number,
+  Promise,
+  RegExpPrototypeExec,
+  StringPrototypeEndsWith,
+} = require("internal/debugger/primordials");
+
+const { spawn } = require("node:child_process");
+const net = require("node:net");
+const { setInterval: pSetInterval, setTimeout: pSetTimeout } = require("node:timers/promises");
+
+// Node's exit code for an invalid command line argument.
+const kInvalidCommandLineArgument = 9;
+
+function ERR_DEBUGGER_STARTUP_ERROR(message, options?) {
+  const err = $ERR_DEBUGGER_STARTUP_ERROR(message);
+  const childStderr = options?.childStderr;
+  if (childStderr !== undefined) {
+    err.childStderr = childStderr;
+  }
+  return err;
+}
+
+const debugRegex = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//;
+
+async function portIsFree(host, port, timeout = 3000) {
+  if (port === 0) return; // Binding to a random port.
+
+  const retryDelay = 150;
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  pSetTimeout(timeout).then(() => ac.abort());
+
+  const asyncIterator = pSetInterval(retryDelay);
+  while (true) {
+    await asyncIterator.next();
+    if (signal.aborted) {
+      throw ERR_DEBUGGER_STARTUP_ERROR(`Timeout (${timeout}) waiting for ${host}:${port} to be free`);
+    }
+    const error = await new Promise(resolve => {
+      const socket = net.connect(port, host);
+      socket.on("error", resolve);
+      socket.on("connect", () => {
+        socket.end();
+        resolve();
+      });
+    });
+    if (error?.code === "ECONNREFUSED") {
+      return;
+    }
+  }
+}
+
+function ensureTrailingNewline(text) {
+  return StringPrototypeEndsWith(text, "\n") ? text : `${text}\n`;
+}
+
+function writeInspectUsageAndExit(invokedAs, message?, exitCode?) {
+  const code = exitCode ?? (message ? kInvalidCommandLineArgument : 0);
+  const out = code === 0 ? process.stdout : process.stderr;
+  if (message) {
+    out.write(`${message}\n`);
+  }
+  out.write(`Usage: ${invokedAs} [--port=<port>] [<node-option> ...]
+                      [<script> [<script-args>] | <host>:<port> | -p <pid>]
+       ${invokedAs} --probe <file>:<line>[:<col>] --expr <expr>
+                      [--probe <file>:<line>[:<col>] --expr <expr> ...]
+                      [--json] [--preview] [--timeout=<ms>] [--port=<port>]
+                      [--] [<node-option> ...] <script> [<script-args> ...]
+
+Interactive mode: Starts a live debugging session.
+
+Example:
+  $ node inspect script.js
+
+Options:
+  --port=<port>         Inspector port for the debuggee (default: 9229)
+  <script>              The script to launch and debug.
+  <host>:<port>         Remote debugger to connect to.
+  -p <pid>              Attach to a running Node.js process by PID
+
+Semantics:
+* If neither a script nor a host:port nor -p is provided, node inspect starts
+  the REPL.
+
+Non-interactive probe mode: Evaluates expressions whenever execution reaches
+specified source locations and prints all the evaluation results to stdout.
+
+Example:
+  $ node inspect --probe app.js:10 --expr "user"
+                 --probe src/utils.js:5:15 --expr "config.options"
+                 --json --preview -- --no-warnings app.js --arg-for-app=foo
+
+Options:
+  --probe <file>:<line>[:<col>]
+                    Source location of the probe. <file> is matched as a
+                    path suffix of every loaded script URL, anchored on
+                    a path separator. <line> and the optional <col> are
+                    1-based. If <col> is omitted, the probe binds to
+                    the first executable column on the line. This option
+                    must be immediately followed by a pairing --expr.
+  --expr <expr>     Expression to evaluate in the lexical scope of the
+                    preceding --probe each time execution reaches it.
+                    Avoid probing let/const-bound variables at their
+                    declaration site or a ReferenceError may be thrown.
+  --json            Output JSON if specified, otherwise human-readable text.
+  --preview         Include V8 object previews in JSON output.
+  --timeout <ms>    Global session timeout (default: 30000).
+  --port <port>     Inspector port for the debuggee (default: 0 = random).
+
+Semantics:
+* Multiple --probe/--expr pairs are allowed. Same-location --probes share
+  a pause and scope, their --exprs are evaluated in command-line order.
+* --probe utils.js:<line>[:<col>] matches every loaded utils.js. Pass a
+  fuller path e.g. src/utils.js to narrow the match.
+* Use -- before any Node.js flags intended for the child process.
+* Target errors are surfaced in the report as a terminal 'error' event.
+  The probing process exits 0 unless it encounters an error itself.
+
+See https://nodejs.org/api/debugger.html for details, including the
+probe output schema.
+`);
+  process.exit(code);
+}
+
+async function launchChildProcess(childArgs, inspectHost, inspectPort, childOutput, options = { __proto__: null }) {
+  if (!options.skipPortPreflight) {
+    await portIsFree(inspectHost, inspectPort);
+  }
+
+  // Bun's --inspect-brk injects a `debugger;`, making interactive sessions
+  // stop twice; `deferBreakToClient` uses --inspect-wait and arms the break in
+  // NodeInspector.run. Probe mode keeps --inspect-brk so the entry is parsed.
+  const args = [options.deferBreakToClient ? `--inspect-wait=${inspectPort}` : `--inspect-brk=${inspectPort}`];
+  ArrayPrototypePushApply(args, childArgs);
+
+  const child = spawn(process.execPath, args);
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", chunk => childOutput(chunk, "stdout"));
+  child.stderr.on("data", chunk => childOutput(chunk, "stderr"));
+
+  let stderrOutput = "";
+  return new Promise((resolve, reject) => {
+    function rejectLaunch(message) {
+      reject(ERR_DEBUGGER_STARTUP_ERROR(message, { childStderr: stderrOutput }));
+    }
+
+    function onExit(code, signal) {
+      const suffix = signal !== null ? ` (${signal})` : ` (code ${code})`;
+      rejectLaunch(`Target exited before the inspector was ready${suffix}`);
+    }
+
+    function onError(error) {
+      rejectLaunch(error.message);
+    }
+
+    function onStderr(text) {
+      stderrOutput += text;
+      const debug = RegExpPrototypeExec(debugRegex, stderrOutput);
+      if (debug) {
+        child.stderr.removeListener("data", onStderr);
+        child.removeListener("exit", onExit);
+        child.removeListener("error", onError);
+        resolve([child, Number(debug[2]), debug[1]]);
+      }
+    }
+
+    child.once("exit", onExit);
+    child.once("error", onError);
+    child.stderr.on("data", onStderr);
+  });
+}
+
+export default {
+  ensureTrailingNewline,
+  launchChildProcess,
+  writeInspectUsageAndExit,
+};
diff --git a/src/js/internal/debugger/inspect_probe.ts b/src/js/internal/debugger/inspect_probe.ts
new file mode 100644
index 00000000000..dbf3180168f
--- /dev/null
+++ b/src/js/internal/debugger/inspect_probe.ts
@@ -0,0 +1,1089 @@
+// Port of Node.js lib/internal/debugger/inspect_probe.js (v26.3.0) for the
+// `bun inspect` / `node inspect` CLI debugger.
+"use strict";
+
+const {
+  ArrayFrom,
+  ArrayIsArray,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  FunctionPrototypeBind,
+  JSONStringify,
+  NumberIsNaN,
+  NumberParseInt,
+  ObjectEntries,
+  PromiseWithResolvers,
+  RegExpPrototypeExec,
+  RegExpPrototypeSymbolSplit,
+  SafeMap,
+  SafeSet,
+  StringPrototypeIncludes,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
+  StringPrototypeTrim,
+  Symbol,
+  SideEffectFreeRegExpPrototypeSymbolReplace,
+} = require("internal/debugger/primordials");
+
+const { clearTimeout, setTimeout } = require("node:timers");
+const debug = require("node:util").debuglog("inspect_probe");
+
+const InspectClient = require("internal/debugger/inspect_client");
+const { ensureTrailingNewline, launchChildProcess } = require("internal/debugger/inspect_helpers");
+
+const kGenericUserError = 1;
+const kNoFailure = 0;
+
+const kProbeDefaultTimeout = 30000;
+const kProbeVersion = 2;
+const kProbeDisconnectSentinel = "Waiting for the debugger to disconnect...";
+const kProbeAttachedSentinel = "Debugger attached.";
+const kProbeListeningPrefix = "Debugger listening on ws://";
+const kProbeEndingPrefix = "Debugger ending on ws://";
+const kProbeHelpLine = "For help, see: https://nodejs.org/learn/getting-started/debugging";
+// Thrown by `callCdp` after `recordInspectorFailure` has handled the failure,
+// so callers can short-circuit without recording duplicate events.
+const kInspectorFailedSentinel = Symbol("probe.inspectorFailed");
+const kStartupTeardownAdvice =
+  "The target startup may have torn down the inspector. If startup does " +
+  "not touch the inspector, this is likely a Node.js bug. Please file an issue.";
+const kReviewProbeExprAdvice = "If the failure repeats, review the probe expression.";
+const kDigitsRegex = /^\d+$/;
+const kInspectPortRegex = /^--inspect-port=(\d+)$/;
+
+/**
+ * The probe request specified by --probe, serialized into the public report.
+ * @typedef {object} ProbeTarget
+ * @property {string} suffix The raw suffix supplied by the user.
+ * @property {number} line 1-based line number.
+ * @property {number} [column] 1-based column number.
+ */
+
+/**
+ * Location where the probe was evaluated, serialized into the public report.
+ * @typedef {object} Location
+ * @property {string} [url] V8-reported script URL, if known.
+ * @property {number} line 1-based line number.
+ * @property {number} column 1-based column number.
+ */
+
+/**
+ * Per-breakpoint state keyed by V8 `breakpointId` from `Debugger.setBreakpointByUrl`.
+ * @typedef {object} BreakpointDefinition
+ * @property {number[]} probeIndices Indices into probes that bound to this breakpoint.
+ */
+
+/**
+ * Per-probe state corresponds to each --probe --expr pair.
+ * @typedef {object} Probe
+ * @property {string} expr Expression to evaluate on hit.
+ * @property {ProbeTarget} target User's original --probe request shape.
+ * @property {number} hits Count of hits observed.
+ */
+
+function parseUnsignedInteger(value, name, allowZero = false) {
+  if (typeof value !== "string" || RegExpPrototypeExec(kDigitsRegex, value) === null) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`);
+  }
+  const parsed = NumberParseInt(value, 10);
+  if (NumberIsNaN(parsed) || (!allowZero && parsed < 1)) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR(`Invalid ${name}: ${value}`);
+  }
+  return parsed;
+}
+
+/**
+ * @param {string} text Raw `--probe` argument.
+ * @returns {ProbeTarget}
+ */
+function parseProbeTarget(text) {
+  // Accepts file:line or file:line:column formats.
+  // Non-greedy (.+?) allows Windows drive-letter paths like C:\foo.js:10.
+  const match = RegExpPrototypeExec(/^(.+?):(\d+)(?::(\d+))?$/, text);
+  if (match === null) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR(`Invalid probe location: ${text}`);
+  }
+
+  const suffix = match[1];
+  const line = parseUnsignedInteger(match[2], "probe location");
+  // Column is left as undefined if the user does not supply one.
+  const column = match[3] !== undefined ? parseUnsignedInteger(match[3], "probe location") : undefined;
+  return { suffix, line, column };
+}
+
+function formatTargetText(target) {
+  const { suffix, line, column } = target;
+  return column === undefined ? `${suffix}:${line}` : `${suffix}:${line}:${column}`;
+}
+
+function formatPendingProbeLocations(probes, pending) {
+  const seen = new SafeSet();
+  for (const probeIndex of pending) {
+    seen.add(formatTargetText(probes[probeIndex].target));
+  }
+  return ArrayPrototypeJoin(ArrayFrom(seen), ", ");
+}
+
+// Trim inspector-side noise lines from stderr for reporting child errors.
+function trimProbeChildStderr(stderr) {
+  const lines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, stderr);
+  const kept = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === "" && i === lines.length - 1) {
+      continue;
+    }
+    if (line === kProbeDisconnectSentinel) {
+      continue;
+    }
+    if (line === kProbeAttachedSentinel) {
+      continue;
+    }
+    if (line === kProbeHelpLine) {
+      continue;
+    }
+    if (StringPrototypeStartsWith(line, kProbeListeningPrefix)) {
+      continue;
+    }
+    if (StringPrototypeStartsWith(line, kProbeEndingPrefix)) {
+      continue;
+    }
+    // Bun's own inspector banner, printed alongside Node's listening line.
+    // Node targets have no equivalent, so reports must not carry it.
+    if (StringPrototypeIncludes(line, "--------------------- Bun Inspector ---------------------")) {
+      continue;
+    }
+    if (line === "Listening:" || line === "Inspect in browser:") {
+      continue;
+    }
+    const trimmed = StringPrototypeTrim(line);
+    if (StringPrototypeStartsWith(trimmed, "ws://") || StringPrototypeStartsWith(trimmed, "https://debug.bun.sh/#")) {
+      continue;
+    }
+    ArrayPrototypePush(kept, line);
+  }
+  return ArrayPrototypeJoin(kept, "\n");
+}
+
+function formatPreviewPropertyValue(property) {
+  if (property.type === "string") {
+    return JSONStringify(property.value ?? "");
+  }
+  return property.value ?? property.type;
+}
+
+function trimRemoteObject(result) {
+  if (result === undefined || result === null || typeof result !== "object") {
+    return result;
+  }
+
+  if (ArrayIsArray(result)) {
+    return ArrayPrototypeMap(result, trimRemoteObject);
+  }
+
+  const trimmed = { __proto__: null };
+  for (const { 0: key, 1: value } of ObjectEntries(result)) {
+    if (key === "objectId" || key === "className") {
+      continue;
+    }
+    trimmed[key] = trimRemoteObject(value);
+  }
+  return trimmed;
+}
+
+function stripProbePreviews(value) {
+  if (value === undefined || value === null || typeof value !== "object") {
+    return value;
+  }
+
+  if (ArrayIsArray(value)) {
+    return ArrayPrototypeMap(value, stripProbePreviews);
+  }
+
+  const stripped = { __proto__: null };
+  for (const { 0: key, 1: entry } of ObjectEntries(value)) {
+    if (key === "preview") {
+      continue;
+    }
+    stripped[key] = stripProbePreviews(entry);
+  }
+  return stripped;
+}
+
+// Format CDP RemoteObject values into more readable formats.
+function formatRemoteObject(result) {
+  if (result === undefined) {
+    return "undefined";
+  }
+
+  switch (result.type) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return JSONStringify(result.value);
+    case "number":
+      const { unserializableValue } = result;
+      if (unserializableValue !== undefined) {
+        return unserializableValue;
+      }
+      return `${result.value}`;
+    case "boolean":
+      return `${result.value}`;
+    case "symbol":
+      return result.description || "Symbol()";
+    case "bigint":
+      return result.unserializableValue ?? result.description ?? "0n";
+    case "function":
+      return result.description || "function()";
+    case "object":
+      if (result.subtype === "null") {
+        return "null";
+      }
+      if (result.subtype === "error") {
+        return result.description || "Error";
+      }
+      const { preview } = result;
+      if (preview !== undefined) {
+        const properties = ArrayPrototypeJoin(
+          ArrayPrototypeMap(
+            preview.properties,
+            preview.subtype === "array"
+              ? property => formatPreviewPropertyValue(property)
+              : property => `${property.name}: ${formatPreviewPropertyValue(property)}`,
+          ),
+          ", ",
+        );
+        const suffix = result.preview.overflow ? ", ..." : "";
+        if (result.preview.subtype === "array") {
+          return `[${properties}${suffix}]`;
+        }
+        return `{${properties}${suffix}}`;
+      }
+      return result.description || result.className || "Object";
+    default:
+      return `${result.value ?? result.description ?? ""}`;
+  }
+}
+
+function formatHitLocation(location) {
+  return `${location.url}:${location.line}:${location.column}`;
+}
+
+// Built human-readable text output for probe reports.
+function buildProbeTextReport(report) {
+  const lines = [];
+
+  for (const result of report.results) {
+    if (result.event === "hit") {
+      const probe = report.probes[result.probe];
+      // If Debugger.scriptParsed was missed and the URL is unknown, fall back to the user's
+      // probe target text for readability. This is unlikely unless there's a bug in V8.
+      const locText =
+        result.location.url !== undefined ? formatHitLocation(result.location) : formatTargetText(probe.target);
+      ArrayPrototypePush(lines, `Hit ${result.hit} at ${locText}`);
+      const hitError = result.error;
+      if (hitError !== undefined) {
+        ArrayPrototypePush(lines, `  [error] ${probe.expr} = ${hitError.message}`);
+      } else {
+        ArrayPrototypePush(lines, `  ${probe.expr} = ` + `${formatRemoteObject(result.result)}`);
+      }
+      continue;
+    }
+
+    if (result.event === "completed") {
+      ArrayPrototypePush(lines, "Completed");
+      continue;
+    }
+
+    if (result.event === "miss") {
+      ArrayPrototypePush(lines, `Missed probes: ` + `${formatPendingProbeLocations(report.probes, result.pending)}`);
+      continue;
+    }
+
+    if (result.event === "timeout") {
+      ArrayPrototypePush(lines, result.error.message);
+      continue;
+    }
+
+    if (result.event === "error") {
+      ArrayPrototypePush(lines, result.error.message);
+      const { stderr } = result.error;
+      if (stderr !== undefined) {
+        ArrayPrototypePush(lines, "  [stderr]");
+        const stderrLines = RegExpPrototypeSymbolSplit(/\r\n|\r|\n/g, stderr);
+        for (let i = 0; i < stderrLines.length; i++) {
+          if (stderrLines[i] === "" && i === stderrLines.length - 1) {
+            continue;
+          }
+          ArrayPrototypePush(lines, `  ${stderrLines[i]}`);
+        }
+      }
+    }
+  }
+
+  return ensureTrailingNewline(ArrayPrototypeJoin(lines, "\n"));
+}
+
+function parseProbeTokens(tokens, args) {
+  let port = 0;
+  let preview = false;
+  let timeout = kProbeDefaultTimeout;
+  let json = false;
+  let sawSeparator = false;
+  let childStartIndex = args.length;
+  let pendingTarget;
+  let expectedExprIndex = -1;
+  const probes = [];
+
+  for (const token of tokens) {
+    if (token.kind === "option-terminator") {
+      sawSeparator = true;
+      childStartIndex = token.index + 1;
+      break;
+    }
+
+    const tokenValue = token.value;
+    if (pendingTarget !== undefined) {
+      if (
+        token.kind === "option" &&
+        token.name === "expr" &&
+        token.index === expectedExprIndex &&
+        tokenValue !== undefined
+      ) {
+        ArrayPrototypePush(probes, {
+          expr: tokenValue,
+          target: pendingTarget,
+        });
+        pendingTarget = undefined;
+        continue;
+      }
+
+      throw $ERR_DEBUGGER_STARTUP_ERROR("Each --probe must be followed immediately by --expr <expr>");
+    }
+
+    if (token.kind === "positional") {
+      childStartIndex = token.index;
+      break;
+    }
+
+    switch (token.name) {
+      case "json":
+        json = true;
+        break;
+      case "timeout":
+        if (token.value === undefined) {
+          throw $ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`);
+        }
+        timeout = parseUnsignedInteger(token.value, "timeout", true);
+        break;
+      case "port":
+        if (token.value === undefined) {
+          throw $ERR_DEBUGGER_STARTUP_ERROR(`Missing value for ${token.rawName}`);
+        }
+        port = parseUnsignedInteger(token.value, "inspector port", true);
+        break;
+      case "preview":
+        preview = true;
+        break;
+      case "probe":
+        pendingTarget = parseProbeTarget(token.value);
+        expectedExprIndex = token.index + (token.inlineValue ? 1 : 2);
+        break;
+      case "expr":
+        throw $ERR_DEBUGGER_STARTUP_ERROR("Unexpected --expr before --probe");
+      default:
+        if (probes.length > 0) {
+          throw $ERR_DEBUGGER_STARTUP_ERROR("Use -- before child Node.js flags in probe mode");
+        }
+        throw $ERR_DEBUGGER_STARTUP_ERROR(`Unknown probe option: ${token.rawName}`);
+    }
+  }
+
+  if (pendingTarget !== undefined) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR("Each --probe must be followed immediately by --expr <expr>");
+  }
+
+  if (probes.length === 0) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR("Probe mode requires at least one --probe <loc> --expr <expr> group");
+  }
+
+  const childArgv = ArrayPrototypeSlice(args, childStartIndex);
+  if (childArgv.length === 0) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR("Probe mode requires a child script");
+  }
+
+  if (!sawSeparator && StringPrototypeStartsWith(childArgv[0], "-")) {
+    throw $ERR_DEBUGGER_STARTUP_ERROR("Use -- before child Node.js flags in probe mode");
+  }
+
+  let skipPortPreflight = port === 0;
+  for (const arg of childArgv) {
+    const inspectPortMatch = RegExpPrototypeExec(kInspectPortRegex, arg);
+    if (inspectPortMatch === null) {
+      continue;
+    }
+    if (inspectPortMatch[1] === "0") {
+      skipPortPreflight = true;
+      continue;
+    }
+    throw $ERR_DEBUGGER_STARTUP_ERROR("Only child --inspect-port=0 is supported in probe mode");
+  }
+
+  return {
+    host: "127.0.0.1",
+    port,
+    preview,
+    timeout,
+    json,
+    probes,
+    childArgv,
+    skipPortPreflight,
+  };
+}
+
+class ProbeInspectorSession {
+  constructor(options) {
+    this.options = options;
+    this.client = new InspectClient();
+    this.child = null;
+    this.cleanupStarted = false;
+    this.childStderr = "";
+    this.disconnectRequested = false;
+    this.finished = false;
+    // True once the inspector WebSocket connects. Event handlers ignore
+    // pre-connect exits/closes so launch/connect failures report through run().
+    this.connected = false;
+    // True once breakpoints are bound and the target is released from --inspect-brk
+    // via `Runtime.runIfWaitingForDebugger`.
+    // Distinguishes "exited before user code ran" from "exited during the live session".
+    this.started = false;
+    // A sliding buffer of at most kProbeDisconnectSentinel.length to detect disconnect.
+    this.disconnectSentinelBuffer = "";
+    /** @type {Map<string, BreakpointDefinition>} keyed by V8 breakpointId. */
+    this.breakpointDefinitions = new SafeMap();
+    /** @type {Map<string, string>} scriptId -> URL. */
+    this.scriptIdToUrl = new SafeMap();
+    this.results = [];
+    this.timeout = null;
+    // The currently-awaited CDP request, or null when no request is in flight.
+    /** @type {{ method: string, probe: { index: number, location: Location } | null } | null} */
+    this.inFlight = null;
+    // Most recently completed probe, used for `error.probe` when a non-evaluate CDP call rejects.
+    this.lastProbeIndex = null;
+    const { promise, resolve } = PromiseWithResolvers();
+    this.completionPromise = promise;
+    this.resolveCompletion = resolve;
+    /** @type {Probe[]} */
+    this.probes = ArrayPrototypeMap(options.probes, ({ expr, target }) => ({ expr, target, hits: 0 }));
+    this.onChildOutput = FunctionPrototypeBind(this.onChildOutput, this);
+    this.onChildExit = FunctionPrototypeBind(this.onChildExit, this);
+    this.onClientClose = FunctionPrototypeBind(this.onClientClose, this);
+    this.onPaused = FunctionPrototypeBind(this.onPaused, this);
+    this.onScriptParsed = FunctionPrototypeBind(this.onScriptParsed, this);
+  }
+
+  // Marking the probing process to exit with 0, recorded hits are trustworthy.
+  finishWithTrustedResult(terminal) {
+    this.finish(kNoFailure, terminal);
+  }
+
+  // Marking the probing process to exit with 1, recorded hits are best-effort.
+  finishWithUnreliableResult(terminal) {
+    this.finish(kGenericUserError, terminal);
+  }
+
+  finish(exitCode, terminal) {
+    if (this.finished) {
+      return;
+    }
+    debug("finish: exitCode=%d, terminal=%s", exitCode, terminal?.event);
+    this.finished = true;
+    if (this.timeout !== null) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    this.resolveCompletion({ exitCode, terminal });
+  }
+
+  getProbeTargetExitEvent(exitCode, signal) {
+    const pending = this.getPendingProbeIndices();
+    const how = signal !== null ? `with signal ${signal}` : `with code ${exitCode}`;
+    const status =
+      pending.length === 0 ? "target completion" : `probes: ${formatPendingProbeLocations(this.probes, pending)}`;
+    const error = {
+      __proto__: null,
+      code: "probe_target_exit",
+      message: `Target exited ${how} before ${status}`,
+    };
+    if (exitCode !== null) {
+      error.exitCode = exitCode;
+    }
+    if (signal !== null) {
+      error.signal = signal;
+    }
+    error.stderr = trimProbeChildStderr(this.childStderr);
+    return { event: "error", pending, error };
+  }
+
+  onChildOutput(text, which) {
+    if (which !== "stderr") {
+      return;
+    }
+
+    this.childStderr += text;
+
+    const combined = this.disconnectSentinelBuffer + text;
+    // Detect the disconnect sentinel.
+    if (this.connected && StringPrototypeIncludes(combined, kProbeDisconnectSentinel)) {
+      this.disconnectRequested = true;
+      this.client.reset();
+    }
+
+    const combinedLength = combined.length;
+    const sentinelLength = kProbeDisconnectSentinel.length;
+    if (combinedLength > sentinelLength) {
+      // Slide the buffer.
+      this.disconnectSentinelBuffer = StringPrototypeSlice(combined, combinedLength - sentinelLength);
+    } else {
+      this.disconnectSentinelBuffer = combined;
+    }
+  }
+
+  onChildExit(code, signal) {
+    debug(
+      "child exit: code=%s signal=%s connected=%s started=%s finished=%s inFlight=%j",
+      code,
+      signal,
+      this.connected,
+      this.started,
+      this.finished,
+      this.inFlight,
+    );
+    // Pre-connect exits are deliberately silent: the target never reached
+    // a state where probes could be set, so any report would be empty.
+    if (!this.connected) {
+      return;
+    }
+    if (this.finished) {
+      return;
+    }
+    if (this.inFlight !== null && this.inFlight.probe !== null) {
+      this.recordInspectorFailure({
+        reason: "Target process exited during probe evaluation",
+        advice: kReviewProbeExprAdvice,
+      });
+      return;
+    }
+    if (this.started && code === 0 && signal === null) {
+      const pending = this.getPendingProbeIndices();
+      this.finishWithTrustedResult(pending.length === 0 ? { event: "completed" } : { event: "miss", pending });
+      return;
+    }
+    this.finishWithTrustedResult(this.getProbeTargetExitEvent(code, signal));
+  }
+
+  onClientClose() {
+    debug(
+      "client close: disconnectRequested=%s finished=%s inFlight=%j",
+      this.disconnectRequested,
+      this.finished,
+      this.inFlight,
+    );
+    if (!this.connected) {
+      return;
+    }
+    if (this.disconnectRequested) {
+      return;
+    }
+    if (this.finished) {
+      return;
+    }
+
+    const { exitCode, signalCode } = this.child;
+    if (exitCode !== null || signalCode !== null) {
+      this.onChildExit(exitCode, signalCode);
+      return;
+    }
+    if (!this.started) {
+      this.recordInspectorFailure({
+        reason: "Inspector connection lost before probes started",
+        advice: kStartupTeardownAdvice,
+      });
+      return;
+    }
+    const inFlight = this.inFlight;
+    if (inFlight !== null) {
+      if (inFlight.probe !== null || this.lastProbeIndex !== null) {
+        this.recordInspectorFailure({
+          reason: "Inspector connection lost during probe activity",
+          advice:
+            "A probe expression may have caused the disconnection. " +
+            "If the failure repeats, review the probe expressions.",
+        });
+      } else {
+        this.recordInspectorFailure({
+          reason: "Inspector connection lost during inspector activity",
+          advice: "This is likely a Node.js bug. Please file an issue.",
+        });
+      }
+      return;
+    }
+    this.recordInspectorFailure({
+      reason: "Inspector connection lost",
+      advice:
+        "The target was likely terminated externally. If the failure " +
+        "persists, check the target's process environment.",
+    });
+  }
+
+  onPaused(params) {
+    this.handlePaused(params).catch(error => {
+      if (error === kInspectorFailedSentinel) {
+        return;
+      }
+      this.recordInspectorFailure({
+        reason: "Probe mode encountered an unexpected internal failure",
+        advice: "This is likely a Node.js bug. Please file an issue.",
+        internalError: error,
+      });
+    });
+  }
+
+  async handlePaused(params) {
+    if (this.finished) {
+      return;
+    }
+
+    const hitBreakpoints = params.hitBreakpoints;
+    if (hitBreakpoints === undefined || hitBreakpoints.length === 0) {
+      await this.resume();
+      return;
+    }
+
+    const topFrame = params.callFrames?.[0];
+    const callFrameId = topFrame?.callFrameId;
+    if (callFrameId === undefined) {
+      await this.resume();
+      return;
+    }
+
+    const { scriptId, lineNumber, columnNumber } = topFrame.location;
+    // `Debugger.scriptParsed` should always precede a pause for the same script.
+    // It should only be undefined if there's a bug (even in that case, just omit it).
+    const location = {
+      url: this.scriptIdToUrl.get(scriptId),
+      // CDP locations are 0-based, locations in public report are 1-based.
+      line: lineNumber + 1,
+      column: columnNumber + 1,
+    };
+    for (const breakpointId of hitBreakpoints) {
+      // The breakpoint ID is stable even for scripts parsed after the initial resolution
+      // so we can count on it here.
+      const definition = this.breakpointDefinitions.get(breakpointId);
+      if (definition === undefined) {
+        continue;
+      }
+
+      // Evaluate the expressions in the order they appear on the command line.
+      for (const probeIndex of definition.probeIndices) {
+        await this.evaluateProbe(callFrameId, probeIndex, location);
+        if (this.finished) {
+          break;
+        }
+      }
+    }
+
+    await this.resume();
+  }
+
+  async evaluateProbe(callFrameId, probeIndex, location) {
+    if (this.finished) {
+      return;
+    }
+    const probe = this.probes[probeIndex];
+    const evaluation = await this.callCdp(
+      "Debugger.evaluateOnCallFrame",
+      { callFrameId, expression: probe.expr, generatePreview: true },
+      { __proto__: null, index: probeIndex, location },
+    );
+    this.lastProbeIndex = probeIndex;
+
+    probe.hits++;
+    const result = { probe: probeIndex, event: "hit", hit: probe.hits, location };
+    const { exceptionDetails } = evaluation;
+    if (exceptionDetails !== undefined) {
+      result.error = {
+        __proto__: null,
+        message: evaluation.result?.description ?? "Probe expression failed",
+        details: { __proto__: null, exception: trimRemoteObject(exceptionDetails) },
+      };
+    } else {
+      result.result = trimRemoteObject(evaluation.result);
+    }
+    ArrayPrototypePush(this.results, result);
+  }
+
+  async resume() {
+    if (this.finished) {
+      return;
+    }
+    await this.callCdp("Debugger.resume");
+  }
+
+  async callCdp(method, params, probe = null) {
+    if (this.finished) {
+      throw kInspectorFailedSentinel;
+    }
+    this.inFlight = { __proto__: null, method, probe };
+    debug("CDP -> %s%s", method, probe !== null ? `, probe=${probe.index}` : "");
+    try {
+      const result = await this.client.callMethod(method, params);
+      // A timeout or process exit can finish the report while the CDP request
+      // is still outstanding. Ignore the late reply in that case.
+      if (this.finished) {
+        debug("CDP <- %s discarded (already finished)", method);
+        throw kInspectorFailedSentinel;
+      }
+      debug("CDP <- %s (success)", method);
+      return result;
+    } catch (err) {
+      if (err !== kInspectorFailedSentinel) {
+        // Already handled.
+        debug("CDP <- %s error: %s", method, err?.code);
+      }
+      if (this.disconnectRequested) {
+        // Only the in-flight evaluation gets attribution. Other rejections
+        // under disconnect are downstream noise.
+        if (probe !== null) {
+          this.recordInspectorFailure({
+            reason: "Target process exited during probe evaluation",
+            advice: kReviewProbeExprAdvice,
+          });
+        }
+        throw kInspectorFailedSentinel;
+      }
+      // Another event handler already recorded the terminal event.
+      if (this.finished) {
+        throw kInspectorFailedSentinel;
+      }
+      if (!this.started) {
+        this.recordInspectorFailure({
+          reason: "Probe mode failed before user code ran",
+          advice: kStartupTeardownAdvice,
+          cdpError: err,
+        });
+      } else if (method === "Debugger.evaluateOnCallFrame") {
+        this.recordInspectorFailure({
+          reason: "The inspector could not evaluate a probe expression",
+          advice: `The rejection details are recorded on the probe hit. ${kReviewProbeExprAdvice}`,
+          cdpError: err,
+        });
+      } else if (this.lastProbeIndex !== null) {
+        this.recordInspectorFailure({
+          reason: "Probe session failed after a probe evaluation",
+          advice: "If the failure repeats, review the most-recently-evaluated probe expression.",
+          cdpError: err,
+        });
+      } else {
+        this.recordInspectorFailure({
+          reason: "Probe session failed during inspector activity",
+          advice: "This is likely a Node.js bug. Please file an issue.",
+          cdpError: err,
+        });
+      }
+      throw kInspectorFailedSentinel;
+    } finally {
+      this.inFlight = null;
+    }
+  }
+
+  // Records the first inspector-side terminal for the session, later callers are ignored.
+  recordInspectorFailure({ reason, advice, cdpError, internalError }) {
+    if (this.finished) {
+      return;
+    }
+    debug(
+      'recordInspectorFailure "%s": inFlight=%j, lastProbeIndex=%s, cdpError=%j',
+      reason,
+      this.inFlight,
+      this.lastProbeIndex,
+      cdpError,
+    );
+    const child = this.child;
+    const exitedAbnormally =
+      child !== null && (child.signalCode !== null || (child.exitCode !== null && child.exitCode !== 0));
+    const inFlightProbe = this.inFlight === null ? null : this.inFlight.probe;
+    const { lastProbeIndex } = this;
+    // This normally emits `probe_failure`, but yields to `probe_target_exit` when the child
+    // has already exited abnormally and there is no in-flight probe to attribute to.
+    if (exitedAbnormally && inFlightProbe === null) {
+      this.finishWithTrustedResult(this.getProbeTargetExitEvent(child.exitCode, child.signalCode));
+      return;
+    }
+
+    const failedCdpMethod = this.inFlight === null ? null : this.inFlight.method;
+    let protocolError = null;
+    // // `ERR_DEBUGGER_ERROR` is a Node-internal code, not a CDP-level protocol code
+    const cdpErrorCode = cdpError?.code;
+    if (cdpError !== undefined && cdpErrorCode !== "ERR_DEBUGGER_ERROR") {
+      protocolError = { __proto__: null, message: cdpError.message, code: cdpErrorCode };
+    }
+    const protocolErrorGoesOnHit = protocolError !== null && failedCdpMethod === "Debugger.evaluateOnCallFrame";
+
+    let attribution = null;
+    if (inFlightProbe !== null) {
+      const { index, location } = inFlightProbe;
+      const error = { __proto__: null };
+      if (protocolErrorGoesOnHit) {
+        error.message = "Probe evaluation failed at the protocol layer";
+        error.details = { __proto__: null, protocolError };
+      } else {
+        error.message = "Probe evaluation did not complete";
+      }
+      this.probes[index].hits++;
+      ArrayPrototypePush(this.results, {
+        probe: index,
+        event: "hit",
+        hit: this.probes[index].hits,
+        location,
+        error,
+      });
+      attribution = index;
+    } else if (failedCdpMethod !== null && lastProbeIndex !== null) {
+      attribution = lastProbeIndex;
+    }
+    // When there is no in-flight CDP call (e.g. `onClientClose` after all probes hit), ignore
+    // `lastProbeIndex` since it can't be attributed to a specific probe.
+
+    const pending = this.getPendingProbeIndices();
+    const suffix = pending.length === 0 ? "" : ` before probes: ${formatPendingProbeLocations(this.probes, pending)}`;
+    const error = {
+      __proto__: null,
+      code: "probe_failure",
+      message: `${reason}${suffix}. ${advice}`,
+    };
+    if (attribution !== null) {
+      error.probe = attribution;
+    }
+    error.stderr = trimProbeChildStderr(this.childStderr);
+
+    let details;
+    if (failedCdpMethod !== null) {
+      details = { __proto__: null, lastCdpMethod: failedCdpMethod };
+      if (protocolError !== null && !protocolErrorGoesOnHit) {
+        details.protocolError = protocolError;
+      }
+    }
+    if (internalError !== undefined) {
+      details ??= { __proto__: null };
+      details.internalError = { __proto__: null, message: internalError?.message, stack: internalError?.stack };
+    }
+    if (details !== undefined) {
+      error.details = details;
+    }
+
+    this.finishWithUnreliableResult({ event: "error", pending, error });
+  }
+
+  startTimeout() {
+    this.timeout = setTimeout(() => {
+      debug(
+        "timeout fired: finished=%s, inFlight=%j, lastProbeIndex=%s",
+        this.finished,
+        this.inFlight,
+        this.lastProbeIndex,
+      );
+      if (this.finished) {
+        return;
+      }
+      const inFlight = this.inFlight;
+      if (inFlight !== null) {
+        const hasProbeAttribution = inFlight.probe !== null || this.lastProbeIndex !== null;
+        this.recordInspectorFailure({
+          reason: "Probe session timed out",
+          advice: hasProbeAttribution
+            ? "The probe expression may be slow, hanging, or interfering with the inspector connection. " +
+              "Try increasing `--timeout`; if the failure persists, review the probe expressions."
+            : "Try increasing `--timeout`; if the failure persists, please file an issue.",
+        });
+        return;
+      }
+      const pending = this.getPendingProbeIndices();
+      const message =
+        `Timed out after ${this.options.timeout}ms waiting for ` +
+        (pending.length === 0 ? "target completion" : `probes: ${formatPendingProbeLocations(this.probes, pending)}`);
+      this.finishWithUnreliableResult({
+        event: "timeout",
+        pending,
+        error: { code: "probe_timeout", message },
+      });
+    }, this.options.timeout);
+    this.timeout.unref();
+  }
+
+  attachListeners() {
+    this.child.on("exit", this.onChildExit);
+    this.client.on("close", this.onClientClose);
+    this.client.on("Debugger.paused", this.onPaused);
+    this.client.on("Debugger.scriptParsed", this.onScriptParsed);
+  }
+
+  onScriptParsed(params) {
+    // This map grows by the number of scripts parsed, which is limited, and is just a
+    // small string -> string map. The lifetime is bounded by probe timeout etc. so cleanup is overkill.
+    this.scriptIdToUrl.set(params.scriptId, params.url);
+  }
+
+  async bindBreakpoints() {
+    const uniqueTargets = new SafeMap();
+
+    for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) {
+      const { target } = this.probes[probeIndex];
+      const key = `${target.suffix}\n${target.line}\n${target.column ?? ""}`;
+      let entry = uniqueTargets.get(key);
+      if (entry === undefined) {
+        entry = { target, probeIndices: [] };
+        uniqueTargets.set(key, entry);
+      }
+      ArrayPrototypePush(entry.probeIndices, probeIndex);
+    }
+
+    for (const { target, probeIndices } of uniqueTargets.values()) {
+      // On Windows, normalize backslashes to forward slashes so the regex matches
+      // V8 script URLs which always use forward slashes.
+      const normalizedFile =
+        process.platform === "win32"
+          ? SideEffectFreeRegExpPrototypeSymbolReplace(/\\/g, target.suffix, "/")
+          : target.suffix;
+      const escapedPath = SideEffectFreeRegExpPrototypeSymbolReplace(/([/\\.?*()^${}|[\]])/g, normalizedFile, "\\$1");
+      // Let separators inside a multi-segment suffix match "\" too on win32
+      // (on POSIX a backslash is a legal filename character, so stays literal).
+      const pathPattern =
+        process.platform === "win32"
+          ? SideEffectFreeRegExpPrototypeSymbolReplace(/\\\//g, escapedPath, "[\\/\\\\]")
+          : escapedPath;
+      const params = {
+        urlRegex: `^(.*[\\/\\\\])?${pathPattern}$`,
+        // CDP locations are 0-based, the probe target from CLI is 1-based.
+        lineNumber: target.line - 1,
+      };
+      const { column } = target;
+      if (column !== undefined) {
+        // Only pass columnNumber to CDP when the user specifies one, otherwise let
+        // the inspector bind to the first executable column.
+        params.columnNumber = column - 1;
+      }
+
+      const result = await this.callCdp("Debugger.setBreakpointByUrl", params);
+      this.breakpointDefinitions.set(result.breakpointId, { probeIndices });
+    }
+  }
+
+  getPendingProbeIndices() {
+    const pending = [];
+    for (let probeIndex = 0; probeIndex < this.probes.length; probeIndex++) {
+      if (this.probes[probeIndex].hits === 0) {
+        ArrayPrototypePush(pending, probeIndex);
+      }
+    }
+    return pending;
+  }
+
+  buildReport({ exitCode, terminal }) {
+    const results = ArrayPrototypeSlice(this.results);
+    ArrayPrototypePush(results, terminal);
+    return {
+      code: exitCode,
+      report: {
+        v: kProbeVersion,
+        probes: ArrayPrototypeMap(this.probes, ({ expr, target }) => ({ expr, target })),
+        results,
+      },
+    };
+  }
+
+  async cleanup() {
+    if (this.cleanupStarted) {
+      return;
+    }
+    this.cleanupStarted = true;
+
+    if (this.timeout !== null) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+
+    this.client.reset();
+
+    if (this.child === null) {
+      return;
+    }
+
+    if (this.child.exitCode === null && this.child.signalCode === null) {
+      this.child.kill();
+    }
+  }
+
+  async run() {
+    try {
+      const { childArgv, host, port, skipPortPreflight } = this.options;
+      const {
+        0: child,
+        1: actualPort,
+        2: actualHost,
+      } = await launchChildProcess(childArgv, host, port, this.onChildOutput, { skipPortPreflight });
+      this.child = child;
+      // On Debugger.enable, V8 emits Debugger.scriptParsed for all existing scripts.
+      // Attach the listener early to make sure we don't miss any events.
+      this.attachListeners();
+
+      await this.client.connect(actualPort, actualHost);
+      this.connected = true;
+
+      try {
+        await this.callCdp("Runtime.enable");
+        await this.callCdp("Debugger.enable");
+        await this.bindBreakpoints();
+        this.started = true;
+        this.startTimeout();
+        await this.callCdp("Runtime.runIfWaitingForDebugger");
+      } catch (err) {
+        if (err !== kInspectorFailedSentinel) {
+          throw err;
+        }
+      }
+
+      const state = await this.completionPromise;
+      return this.buildReport(state);
+    } finally {
+      await this.cleanup();
+    }
+  }
+}
+
+async function runProbeMode(stdout, probeOptions) {
+  try {
+    const session = new ProbeInspectorSession(probeOptions);
+    const { code, report } = await session.run();
+    stdout.write(
+      probeOptions.json
+        ? `${JSONStringify(probeOptions.preview ? report : stripProbePreviews(report))}\n`
+        : buildProbeTextReport(report),
+    );
+    process.exit(code);
+  } catch (error) {
+    const { childStderr } = error;
+    if (childStderr) {
+      process.stderr.write(childStderr);
+    }
+    process.stderr.write(ensureTrailingNewline(error.message));
+    process.exit(kGenericUserError);
+  }
+}
+
+export default {
+  parseProbeTokens,
+  runProbeMode,
+};
diff --git a/src/js/internal/debugger/inspect_repl.ts b/src/js/internal/debugger/inspect_repl.ts
new file mode 100644
index 00000000000..a29bb9d8586
--- /dev/null
+++ b/src/js/internal/debugger/inspect_repl.ts
@@ -0,0 +1,1193 @@
+// Port of Node.js lib/internal/debugger/inspect_repl.js (v26.3.0) for the
+// `bun inspect` / `node inspect` CLI debugger.
+"use strict";
+
+const {
+  Array,
+  ArrayFrom,
+  ArrayPrototypeFilter,
+  ArrayPrototypeFind,
+  ArrayPrototypeForEach,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSome,
+  ArrayPrototypeSplice,
+  Date,
+  FunctionPrototypeCall,
+  JSONStringify,
+  MathMax,
+  ObjectAssign,
+  ObjectDefineProperty,
+  ObjectKeys,
+  ObjectValues,
+  Promise,
+  PromisePrototypeThen,
+  PromiseResolve,
+  ReflectGetOwnPropertyDescriptor,
+  ReflectOwnKeys,
+  RegExpPrototypeExec,
+  SafeMap,
+  SafePromiseAllReturnArrayLike,
+  SafePromiseAllReturnVoid,
+  SideEffectFreeRegExpPrototypeSymbolReplace,
+  String,
+  StringFromCharCode,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeRepeat,
+  StringPrototypeReplaceAll,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+  StringPrototypeToUpperCase,
+  StringPrototypeTrim,
+} = require("internal/debugger/primordials");
+
+const { validateString, validateNumber } = require("internal/validators");
+
+const FS = require("node:fs");
+const Path = require("node:path");
+const Repl = require("internal/debugger/repl");
+const vm = require("node:vm");
+const { fileURLToPath } = require("node:url");
+
+const customInspectSymbol = require("node:util").inspect.custom;
+const { inspect: utilInspect } = require("node:util");
+const debuglog = require("node:util").debuglog("inspect");
+
+// Inlined from Node's lib/internal/repl/utils.js (isObjectLiteral).
+const startsWithBraceRegExp = /^\s*{/;
+const endsWithSemicolonRegExp = /;\s*$/;
+function isObjectLiteral(code) {
+  return (
+    RegExpPrototypeExec(startsWithBraceRegExp, code) !== null &&
+    RegExpPrototypeExec(endsWithSemicolonRegExp, code) === null
+  );
+}
+const SHORTCUTS = {
+  cont: "c",
+  next: "n",
+  step: "s",
+  out: "o",
+  backtrace: "bt",
+  setBreakpoint: "sb",
+  clearBreakpoint: "cb",
+  run: "r",
+  exec: "p",
+};
+
+const HELP = StringPrototypeTrim(`
+run, restart, r       Run the application or reconnect
+kill                  Kill a running application or disconnect
+
+cont, c               Resume execution
+next, n               Continue to next line in current file
+step, s               Step into, potentially entering a function
+out, o                Step out, leaving the current function
+backtrace, bt         Print the current backtrace
+list                  Print the source around the current line where execution
+                      is currently paused
+setContextLineNumber  Set which lines to check for context
+setBreakpoint, sb     Set a breakpoint
+clearBreakpoint, cb   Clear a breakpoint
+breakpoints           List all known breakpoints
+breakOnException      Pause execution whenever an exception is thrown
+breakOnUncaught       Pause execution whenever an exception isn't caught
+breakOnNone           Don't pause on exceptions (this is the default)
+
+watch(expr)           Start watching the given expression
+unwatch(expr)         Stop watching an expression
+unwatch(index)        Stop watching an expression at specific index from watch list
+watchers              Print all watched expressions and their current values
+
+exec(expr), p(expr), exec expr, p expr
+                      Evaluate the expression and print the value
+repl                  Enter a debug repl that works like exec
+
+scripts               List application scripts that are currently loaded
+scripts(true)         List all scripts (including node-internals)
+
+profile               Start CPU profiling session.
+profileEnd            Stop current CPU profiling session.
+profiles              Array of completed CPU profiling sessions.
+profiles[n].save(filepath = 'node.cpuprofile')
+                      Save CPU profiling session to disk as JSON.
+
+takeHeapSnapshot(filepath = 'node.heapsnapshot')
+                      Take a heap snapshot and save to disk as JSON.
+`);
+
+const FUNCTION_NAME_PATTERN = /^(?:function\*? )?([^(\s]+)\(/;
+function extractFunctionName(description) {
+  const fnNameMatch = RegExpPrototypeExec(FUNCTION_NAME_PATTERN, description);
+  return fnNameMatch ? `: ${fnNameMatch[1]}` : "";
+}
+
+const builtinIds = require("node:module").builtinModules;
+function isNativeUrl(url) {
+  url = SideEffectFreeRegExpPrototypeSymbolReplace(/\.js$/, url, "");
+
+  return StringPrototypeStartsWith(url, "node:internal/") || ArrayPrototypeIncludes(builtinIds, url);
+}
+
+function getRelativePath(filenameOrURL) {
+  const dir = StringPrototypeSlice(Path.join(Path.resolve(), "x"), 0, -1);
+
+  const filename = StringPrototypeStartsWith(filenameOrURL, "file://") ? fileURLToPath(filenameOrURL) : filenameOrURL;
+
+  // Change path to relative, if possible
+  if (StringPrototypeStartsWith(filename, dir)) {
+    return StringPrototypeSlice(filename, dir.length);
+  }
+  return filename;
+}
+
+// Adds spaces and prefix to number
+// maxN is a maximum number we should have space for
+function leftPad(n, prefix, maxN) {
+  const s = n.toString();
+  const nchars = MathMax(2, String(maxN).length);
+  const nspaces = nchars - s.length;
+
+  return prefix + StringPrototypeRepeat(" ", nspaces) + s;
+}
+
+function markSourceColumn(sourceText, position, useColors) {
+  if (!sourceText) return "";
+
+  const head = StringPrototypeSlice(sourceText, 0, position);
+  let tail = StringPrototypeSlice(sourceText, position);
+
+  // Colourize char if stdout supports colours
+  if (useColors) {
+    tail = SideEffectFreeRegExpPrototypeSymbolReplace(/(.+?)([^\w]|$)/, tail, "\u001b[32m$1\u001b[39m$2");
+  }
+
+  // Return source line with coloured char at `position`
+  return head + tail;
+}
+
+function extractErrorMessage(stack) {
+  if (!stack) return "<unknown>";
+  const m = RegExpPrototypeExec(/^\w+: ([^\n]+)/, stack);
+  return m?.[1] ?? stack;
+}
+
+function convertResultToError(result) {
+  const { className, description } = result;
+  const err = $ERR_DEBUGGER_ERROR(extractErrorMessage(description));
+  err.stack = description;
+  ObjectDefineProperty(err, "name", { __proto__: null, value: className });
+  return err;
+}
+
+class PropertyPreview {
+  constructor(attributes) {
+    ObjectAssign(this, attributes);
+  }
+
+  [customInspectSymbol](depth, opts) {
+    switch (this.type) {
+      case "string":
+      case "undefined":
+        return utilInspect(this.value, opts);
+      case "number":
+      case "boolean":
+        return opts.stylize(this.value, this.type);
+      case "object":
+      case "symbol":
+        if (this.subtype === "date") {
+          return utilInspect(new Date(this.value), opts);
+        }
+        if (this.subtype === "array") {
+          return opts.stylize(this.value, "special");
+        }
+        return opts.stylize(this.value, this.subtype || "special");
+      default:
+        return this.value;
+    }
+  }
+}
+
+class ObjectPreview {
+  constructor(attributes) {
+    ObjectAssign(this, attributes);
+  }
+
+  [customInspectSymbol](depth, opts) {
+    switch (this.type) {
+      case "object": {
+        switch (this.subtype) {
+          case "date":
+            return utilInspect(new Date(this.description), opts);
+          case "null":
+            return utilInspect(null, opts);
+          case "regexp":
+            return opts.stylize(this.description, "regexp");
+          case "set": {
+            if (!this.entries) {
+              return `${this.description} ${this.overflow ? "{ ... }" : "{}"}`;
+            }
+            const values = ArrayPrototypeMap(this.entries, entry => utilInspect(new ObjectPreview(entry.value), opts));
+            return `${this.description} { ${ArrayPrototypeJoin(values, ", ")} }`;
+          }
+          case "map": {
+            if (!this.entries) {
+              return `${this.description} ${this.overflow ? "{ ... }" : "{}"}`;
+            }
+            const mappings = ArrayPrototypeMap(this.entries, entry => {
+              const key = utilInspect(new ObjectPreview(entry.key), opts);
+              const value = utilInspect(new ObjectPreview(entry.value), opts);
+              return `${key} => ${value}`;
+            });
+            return `${this.description} { ${ArrayPrototypeJoin(mappings, ", ")} }`;
+          }
+          case "array":
+          case undefined: {
+            if (this.properties.length === 0) {
+              return this.subtype === "array" ? "[]" : "{}";
+            }
+            const props = ArrayPrototypeMap(this.properties, (prop, idx) => {
+              const value = utilInspect(new PropertyPreview(prop));
+              if (prop.name === `${idx}`) return value;
+              return `${prop.name}: ${value}`;
+            });
+            if (this.overflow) {
+              ArrayPrototypePush(props, "...");
+            }
+            const singleLine = ArrayPrototypeJoin(props, ", ");
+            const propString = singleLine.length > 60 ? ArrayPrototypeJoin(props, ",\n  ") : singleLine;
+            return this.subtype === "array" ? `[ ${propString} ]` : `{ ${propString} }`;
+          }
+          default:
+            return this.description;
+        }
+      }
+      default:
+        return this.description;
+    }
+  }
+}
+
+class RemoteObject {
+  constructor(attributes) {
+    ObjectAssign(this, attributes);
+    if (this.type === "number") {
+      this.value = this.unserializableValue ? +this.unserializableValue : +this.value;
+    }
+  }
+
+  [customInspectSymbol](depth, opts) {
+    switch (this.type) {
+      case "boolean":
+      case "number":
+      case "string":
+      case "undefined":
+        return utilInspect(this.value, opts);
+      case "symbol":
+        return opts.stylize(this.description, "special");
+      case "function": {
+        const fnName = extractFunctionName(this.description);
+        const formatted = `[${this.className}${fnName}]`;
+        return opts.stylize(formatted, "special");
+      }
+      case "object":
+        switch (this.subtype) {
+          case "date":
+            return utilInspect(new Date(this.description), opts);
+          case "null":
+            return utilInspect(null, opts);
+          case "regexp":
+            return opts.stylize(this.description, "regexp");
+          case "map":
+          case "set": {
+            const preview = utilInspect(new ObjectPreview(this.preview), opts);
+            return `${this.description} ${preview}`;
+          }
+          default:
+            break;
+        }
+        const { preview } = this;
+        if (preview) {
+          return utilInspect(new ObjectPreview(preview), opts);
+        }
+        return this.description;
+      default:
+        return this.description;
+    }
+  }
+
+  static fromEvalResult({ result, wasThrown }) {
+    if (wasThrown) return convertResultToError(result);
+    return new RemoteObject(result);
+  }
+}
+
+class ScopeSnapshot {
+  constructor(scope, properties) {
+    ObjectAssign(this, scope);
+    this.properties = new SafeMap();
+    this.completionGroup = ArrayPrototypeMap(properties, prop => {
+      const value = new RemoteObject(prop.value);
+      this.properties.set(prop.name, value);
+      return prop.name;
+    });
+  }
+
+  [customInspectSymbol](depth, opts) {
+    const type = StringPrototypeToUpperCase(this.type[0]) + StringPrototypeSlice(this.type, 1);
+    const name = this.name ? `<${this.name}>` : "";
+    const prefix = `${type}${name} `;
+    return SideEffectFreeRegExpPrototypeSymbolReplace(/^Map /, utilInspect(this.properties, opts), prefix);
+  }
+}
+
+function copyOwnProperties(target, source) {
+  ArrayPrototypeForEach(ReflectOwnKeys(source), prop => {
+    const desc = ReflectGetOwnPropertyDescriptor(source, prop);
+    ObjectDefineProperty(target, prop, desc);
+  });
+}
+
+function aliasProperties(target, mapping) {
+  ArrayPrototypeForEach(ObjectKeys(mapping), key => {
+    const desc = ReflectGetOwnPropertyDescriptor(target, key);
+    ObjectDefineProperty(target, mapping[key], desc);
+  });
+}
+
+function createRepl(inspector) {
+  const { Debugger, HeapProfiler, Profiler, Runtime } = inspector;
+
+  let repl;
+
+  // Things we want to keep around
+  const history = { control: [], debug: [] };
+  const watchedExpressions = [];
+  const knownBreakpoints = [];
+  let heapSnapshotPromise = null;
+  let pauseOnExceptionState = "none";
+  let lastCommand;
+
+  // Things we need to reset when the app restarts
+  let knownScripts;
+  let currentBacktrace;
+  let selectedFrame;
+  let exitDebugRepl;
+  let contextLineNumber = 2;
+
+  function resetOnStart() {
+    knownScripts = {};
+    currentBacktrace = null;
+    selectedFrame = null;
+
+    if (exitDebugRepl) exitDebugRepl();
+    exitDebugRepl = null;
+  }
+  resetOnStart();
+
+  const INSPECT_OPTIONS = { colors: inspector.stdout.isTTY };
+  function inspect(value) {
+    return utilInspect(value, INSPECT_OPTIONS);
+  }
+
+  function print(value, addNewline = true) {
+    const text = typeof value === "string" ? value : inspect(value);
+    return inspector.print(text, addNewline);
+  }
+
+  function getCurrentLocation() {
+    if (!selectedFrame) {
+      throw $ERR_DEBUGGER_ERROR("Requires execution to be paused");
+    }
+    return selectedFrame.location;
+  }
+
+  function isCurrentScript(script) {
+    return selectedFrame && getCurrentLocation().scriptId === script.scriptId;
+  }
+
+  function formatScripts(displayNatives = false) {
+    function isVisible(script) {
+      if (displayNatives) return true;
+      return !script.isNative || isCurrentScript(script);
+    }
+
+    return ArrayPrototypeJoin(
+      ArrayPrototypeMap(ArrayPrototypeFilter(ObjectValues(knownScripts), isVisible), script => {
+        const isCurrent = isCurrentScript(script);
+        const { isNative, url } = script;
+        const name = `${getRelativePath(url)}${isNative ? " <native>" : ""}`;
+        return `${isCurrent ? "*" : " "} ${script.scriptId}: ${name}`;
+      }),
+      "\n",
+    );
+  }
+
+  function listScripts(displayNatives = false) {
+    print(formatScripts(displayNatives));
+  }
+  listScripts[customInspectSymbol] = function listWithoutInternal() {
+    return formatScripts();
+  };
+
+  const profiles = [];
+  class Profile {
+    constructor(data) {
+      this.data = data;
+    }
+
+    static createAndRegister({ profile }) {
+      const p = new Profile(profile);
+      ArrayPrototypePush(profiles, p);
+      return p;
+    }
+
+    [customInspectSymbol](depth, { stylize }) {
+      const { startTime, endTime } = this.data;
+      const MU = StringFromCharCode(956);
+      return stylize(`[Profile ${endTime - startTime}${MU}s]`, "special");
+    }
+
+    save(filename = "node.cpuprofile") {
+      const absoluteFile = Path.resolve(filename);
+      const json = JSONStringify(this.data);
+      FS.writeFileSync(absoluteFile, json);
+      print("Saved profile to " + absoluteFile);
+    }
+  }
+
+  class SourceSnippet {
+    constructor(location, delta, scriptSource) {
+      ObjectAssign(this, location);
+      this.scriptSource = scriptSource;
+      this.delta = delta;
+    }
+
+    [customInspectSymbol](depth, options) {
+      const { scriptId, lineNumber, columnNumber, delta, scriptSource } = this;
+      const start = MathMax(1, lineNumber - delta + 1);
+      const end = lineNumber + delta + 1;
+
+      const lines = StringPrototypeSplit(scriptSource, "\n");
+      return ArrayPrototypeJoin(
+        ArrayPrototypeMap(ArrayPrototypeSlice(lines, start - 1, end), (lineText, offset) => {
+          const i = start + offset;
+          const isCurrent = i === lineNumber + 1;
+
+          const markedLine = isCurrent ? markSourceColumn(lineText, columnNumber, options.colors) : lineText;
+
+          let isBreakpoint = false;
+          ArrayPrototypeForEach(knownBreakpoints, ({ location }) => {
+            if (!location) return;
+            if (scriptId === location.scriptId && i === location.lineNumber + 1) {
+              isBreakpoint = true;
+            }
+          });
+
+          let prefixChar = " ";
+          if (isCurrent) {
+            prefixChar = ">";
+          } else if (isBreakpoint) {
+            prefixChar = "*";
+          }
+          return `${leftPad(i, prefixChar, end)} ${markedLine}`;
+        }),
+        "\n",
+      );
+    }
+  }
+
+  async function getSourceSnippet(location, delta = 5) {
+    const { scriptId } = location;
+    const { scriptSource } = await Debugger.getScriptSource({ scriptId });
+    return new SourceSnippet(location, delta, scriptSource);
+  }
+
+  class CallFrame {
+    constructor(callFrame) {
+      ObjectAssign(this, callFrame);
+    }
+
+    loadScopes() {
+      return SafePromiseAllReturnArrayLike(
+        ArrayPrototypeFilter(this.scopeChain, scope => scope.type !== "global"),
+        async scope => {
+          const { objectId } = scope.object;
+          const { result } = await Runtime.getProperties({
+            objectId,
+            generatePreview: true,
+          });
+          return new ScopeSnapshot(scope, result);
+        },
+      );
+    }
+
+    list(delta = 5) {
+      return getSourceSnippet(this.location, delta);
+    }
+  }
+
+  class Backtrace extends Array {
+    [customInspectSymbol]() {
+      return ArrayPrototypeJoin(
+        ArrayPrototypeMap(this, (callFrame, idx) => {
+          const {
+            location: { scriptId, lineNumber, columnNumber },
+            functionName,
+          } = callFrame;
+          const name = functionName || "(anonymous)";
+
+          const script = knownScripts[scriptId];
+          const relativeUrl = (script && getRelativePath(script.url)) || "<unknown>";
+          const frameLocation = `${relativeUrl}:${lineNumber + 1}:${columnNumber}`;
+
+          return `#${idx} ${name} ${frameLocation}`;
+        }),
+        "\n",
+      );
+    }
+
+    static from(callFrames) {
+      return FunctionPrototypeCall(ArrayFrom, this, callFrames, callFrame =>
+        callFrame instanceof CallFrame ? callFrame : new CallFrame(callFrame),
+      );
+    }
+  }
+
+  function prepareControlCode(input) {
+    if (input === "\n") return lastCommand;
+    // Add parentheses: exec process.title => exec("process.title");
+    const match = RegExpPrototypeExec(/^\s*(?:exec|p)\s+([^\n]*)/, input);
+    input = match ? match[1] : input;
+
+    if (isObjectLiteral(input)) {
+      // Add parentheses to make sure `input` is parsed as an expression
+      input = `(${StringPrototypeTrim(input)})\n`;
+    }
+
+    if (match) {
+      lastCommand = `exec(${JSONStringify(input)})`;
+    } else {
+      lastCommand = input;
+    }
+    return lastCommand;
+  }
+
+  async function evalInCurrentContext(code) {
+    // Repl asked for scope variables
+    if (code === ".scope") {
+      if (!selectedFrame) {
+        throw $ERR_DEBUGGER_ERROR("Requires execution to be paused");
+      }
+      const scopes = await selectedFrame.loadScopes();
+      return ArrayPrototypeMap(scopes, scope => scope.completionGroup);
+    }
+
+    if (selectedFrame) {
+      return PromisePrototypeThen(
+        Debugger.evaluateOnCallFrame({
+          callFrameId: selectedFrame.callFrameId,
+          expression: code,
+          objectGroup: "node-inspect",
+          generatePreview: true,
+        }),
+        RemoteObject.fromEvalResult,
+      );
+    }
+    return PromisePrototypeThen(
+      Runtime.evaluate({
+        expression: code,
+        objectGroup: "node-inspect",
+        generatePreview: true,
+      }),
+      RemoteObject.fromEvalResult,
+    );
+  }
+
+  function controlEval(input, context, filename, callback) {
+    debuglog("eval:", input);
+    function returnToCallback(error, result) {
+      debuglog("end-eval:", input, error);
+      callback(error, result);
+    }
+
+    try {
+      const code = prepareControlCode(input);
+      const result = vm.runInContext(code, context, filename);
+
+      const then = result?.then;
+      if (typeof then === "function") {
+        FunctionPrototypeCall(then, result, result => returnToCallback(null, result), returnToCallback);
+      } else {
+        returnToCallback(null, result);
+      }
+    } catch (e) {
+      returnToCallback(e);
+    }
+  }
+
+  function debugEval(input, context, filename, callback) {
+    debuglog("eval:", input);
+    function returnToCallback(error, result) {
+      debuglog("end-eval:", input, error);
+      callback(error, result);
+    }
+
+    PromisePrototypeThen(evalInCurrentContext(input), result => returnToCallback(null, result), returnToCallback);
+  }
+
+  async function formatWatchers(verbose = false) {
+    if (!watchedExpressions.length) {
+      return "";
+    }
+
+    const inspectValue = expr =>
+      PromisePrototypeThen(evalInCurrentContext(expr), undefined, error => `<${error.message}>`);
+    const lastIndex = watchedExpressions.length - 1;
+
+    const values = await SafePromiseAllReturnArrayLike(watchedExpressions, inspectValue);
+    const lines = ArrayPrototypeMap(watchedExpressions, (expr, idx) => {
+      const prefix = `${leftPad(idx, " ", lastIndex)}: ${expr} =`;
+      const value = inspect(values[idx]);
+      if (!StringPrototypeIncludes(value, "\n")) {
+        return `${prefix} ${value}`;
+      }
+      return `${prefix}\n    ${StringPrototypeReplaceAll(value, "\n", "\n    ")}`;
+    });
+    const valueList = ArrayPrototypeJoin(lines, "\n");
+    return verbose ? `Watchers:\n${valueList}\n` : valueList;
+  }
+
+  function watchers(verbose = false) {
+    return PromisePrototypeThen(formatWatchers(verbose), print);
+  }
+
+  // List source code
+  function list(delta = 5) {
+    if (!selectedFrame) {
+      throw $ERR_DEBUGGER_ERROR("Requires execution to be paused");
+    }
+    return selectedFrame.list(delta).then(null, error => {
+      print("You can't list source code right now");
+      throw error;
+    });
+  }
+
+  function setContextLineNumber(delta = 2) {
+    if (!selectedFrame) {
+      throw $ERR_DEBUGGER_ERROR("Requires execution to be paused");
+    }
+    validateNumber(delta, "delta", 1);
+    contextLineNumber = delta;
+    print(`The contextLine has been changed to ${delta}.`);
+  }
+
+  function handleBreakpointResolved({ breakpointId, location }) {
+    const script = knownScripts[location.scriptId];
+    const scriptUrl = script?.url;
+    if (scriptUrl) {
+      ObjectAssign(location, { scriptUrl });
+    }
+    const isExisting = ArrayPrototypeSome(knownBreakpoints, bp => {
+      if (bp.breakpointId === breakpointId) {
+        ObjectAssign(bp, { location });
+        return true;
+      }
+      return false;
+    });
+    if (!isExisting) {
+      ArrayPrototypePush(knownBreakpoints, { breakpointId, location });
+    }
+  }
+
+  function listBreakpoints() {
+    if (!knownBreakpoints.length) {
+      print("No breakpoints yet");
+      return;
+    }
+
+    function formatLocation(location) {
+      if (!location) return "<unknown location>";
+      const script = knownScripts[location.scriptId];
+      const scriptUrl = script ? script.url : location.scriptUrl;
+      return `${getRelativePath(scriptUrl)}:${location.lineNumber + 1}`;
+    }
+    const breaklist = ArrayPrototypeJoin(
+      ArrayPrototypeMap(knownBreakpoints, (bp, idx) => `#${idx} ${formatLocation(bp.location)}`),
+      "\n",
+    );
+    print(breaklist);
+  }
+
+  function setBreakpoint(script, line, condition, silent) {
+    function registerBreakpoint({ breakpointId, actualLocation }) {
+      handleBreakpointResolved({ breakpointId, location: actualLocation });
+      if (actualLocation?.scriptId) {
+        if (!silent) return getSourceSnippet(actualLocation, 5);
+      } else {
+        print(`Warning: script '${script}' was not loaded yet.`);
+      }
+      return undefined;
+    }
+
+    // setBreakpoint(): set breakpoint at current location
+    if (script === undefined) {
+      return PromisePrototypeThen(
+        Debugger.setBreakpoint({ location: getCurrentLocation(), condition }),
+        registerBreakpoint,
+      );
+    }
+
+    // setBreakpoint(line): set breakpoint in current script at specific line
+    if (line === undefined && typeof script === "number") {
+      const location = {
+        scriptId: getCurrentLocation().scriptId,
+        lineNumber: script - 1,
+      };
+      return PromisePrototypeThen(Debugger.setBreakpoint({ location, condition }), registerBreakpoint);
+    }
+
+    validateString(script, "script");
+
+    // setBreakpoint('fn()'): Break when a function is called
+    if (StringPrototypeEndsWith(script, "()")) {
+      const debugExpr = `debug(${script.slice(0, -2)})`;
+      const debugCall = selectedFrame
+        ? Debugger.evaluateOnCallFrame({
+            callFrameId: selectedFrame.callFrameId,
+            expression: debugExpr,
+            includeCommandLineAPI: true,
+          })
+        : Runtime.evaluate({
+            expression: debugExpr,
+            includeCommandLineAPI: true,
+          });
+      return PromisePrototypeThen(debugCall, ({ result, wasThrown }) => {
+        if (wasThrown) return convertResultToError(result);
+        return undefined; // This breakpoint can't be removed the same way
+      });
+    }
+
+    // setBreakpoint('scriptname')
+    let scriptId = null;
+    let ambiguous = false;
+    if (knownScripts[script]) {
+      scriptId = script;
+    } else {
+      ArrayPrototypeForEach(ObjectKeys(knownScripts), id => {
+        const scriptUrl = knownScripts[id].url;
+        if (scriptUrl && StringPrototypeIncludes(scriptUrl, script)) {
+          if (scriptId !== null) {
+            ambiguous = true;
+          }
+          scriptId = id;
+        }
+      });
+    }
+
+    if (ambiguous) {
+      print("Script name is ambiguous");
+      return undefined;
+    }
+    if (line <= 0) {
+      print("Line should be a positive value");
+      return undefined;
+    }
+
+    if (scriptId !== null) {
+      const location = { scriptId, lineNumber: line - 1 };
+      return PromisePrototypeThen(Debugger.setBreakpoint({ location, condition }), registerBreakpoint);
+    }
+
+    const escapedPath = SideEffectFreeRegExpPrototypeSymbolReplace(/([/\\.?*()^${}|[\]])/g, script, "\\$1");
+    const urlRegex = `^(.*[\\/\\\\])?${escapedPath}$`;
+
+    return PromisePrototypeThen(
+      Debugger.setBreakpointByUrl({
+        urlRegex,
+        lineNumber: line - 1,
+        condition,
+      }),
+      bp => {
+        // TODO: handle bp.locations in case the regex matches existing files
+        if (!bp.location) {
+          // Fake it for now.
+          ObjectAssign(bp, {
+            actualLocation: {
+              scriptUrl: `.*/${script}$`,
+              lineNumber: line - 1,
+            },
+          });
+        }
+        return registerBreakpoint(bp);
+      },
+    );
+  }
+
+  function clearBreakpoint(url, line) {
+    const breakpoint = ArrayPrototypeFind(knownBreakpoints, ({ location }) => {
+      if (!location) return false;
+      const script = knownScripts[location.scriptId];
+      if (!script) return false;
+      return StringPrototypeIncludes(script.url, url) && location.lineNumber + 1 === line;
+    });
+    if (!breakpoint) {
+      print(`Could not find breakpoint at ${url}:${line}`);
+      return PromiseResolve();
+    }
+    return PromisePrototypeThen(Debugger.removeBreakpoint({ breakpointId: breakpoint.breakpointId }), () => {
+      const idx = ArrayPrototypeIndexOf(knownBreakpoints, breakpoint);
+      ArrayPrototypeSplice(knownBreakpoints, idx, 1);
+    });
+  }
+
+  function restoreBreakpoints() {
+    const lastBreakpoints = ArrayPrototypeSplice(knownBreakpoints, 0);
+    const newBreakpoints = ArrayPrototypeMap(
+      ArrayPrototypeFilter(lastBreakpoints, ({ location }) => !!location.scriptUrl),
+      ({ location }) => setBreakpoint(location.scriptUrl, location.lineNumber + 1),
+    );
+    if (!newBreakpoints.length) return PromiseResolve();
+    return PromisePrototypeThen(SafePromiseAllReturnVoid(newBreakpoints), () => {
+      print(`${newBreakpoints.length} breakpoints restored.`);
+    });
+  }
+
+  function setPauseOnExceptions(state) {
+    return PromisePrototypeThen(Debugger.setPauseOnExceptions({ state }), () => {
+      pauseOnExceptionState = state;
+    });
+  }
+
+  Debugger.on("paused", ({ callFrames, reason /* , hitBreakpoints */ }) => {
+    if (process.env.NODE_INSPECT_RESUME_ON_START === "1" && reason === "Break on start") {
+      debuglog("Paused on start, but NODE_INSPECT_RESUME_ON_START" + " environment variable is set to 1, resuming");
+      inspector.client.callMethod("Debugger.resume");
+      return;
+    }
+
+    // Save execution context's data
+    currentBacktrace = Backtrace.from(callFrames);
+    selectedFrame = currentBacktrace[0];
+    const { scriptId, lineNumber } = selectedFrame.location;
+
+    const breakType = reason === "other" ? "break" : reason;
+    const script = knownScripts[scriptId];
+    const scriptUrl = script ? getRelativePath(script.url) : "[unknown]";
+
+    const header = `${breakType} in ${scriptUrl}:${lineNumber + 1}`;
+
+    inspector.suspendReplWhile(() =>
+      PromisePrototypeThen(
+        SafePromiseAllReturnArrayLike([formatWatchers(true), selectedFrame.list(contextLineNumber)]),
+        ({ 0: watcherList, 1: context }) => {
+          const breakContext = watcherList ? `${watcherList}\n${inspect(context)}` : inspect(context);
+          print(`${header}\n${breakContext}`);
+        },
+      ),
+    );
+  });
+
+  function handleResumed() {
+    currentBacktrace = null;
+    selectedFrame = null;
+  }
+
+  Debugger.on("resumed", handleResumed);
+
+  Debugger.on("breakpointResolved", handleBreakpointResolved);
+
+  Debugger.on("scriptParsed", script => {
+    const { scriptId, url } = script;
+    if (url) {
+      knownScripts[scriptId] = { isNative: isNativeUrl(url), ...script };
+    }
+  });
+
+  Profiler.on("consoleProfileFinished", ({ profile }) => {
+    Profile.createAndRegister({ profile });
+    print("Captured new CPU profile.\n" + `Access it with profiles[${profiles.length - 1}]`);
+  });
+
+  function initializeContext(context) {
+    ArrayPrototypeForEach(inspector.domainNames, domain => {
+      ObjectDefineProperty(context, domain, {
+        __proto__: null,
+        value: inspector[domain],
+        enumerable: true,
+        configurable: true,
+        writeable: false,
+      });
+    });
+
+    copyOwnProperties(context, {
+      get help() {
+        return print(HELP);
+      },
+
+      get run() {
+        return inspector.run();
+      },
+
+      get kill() {
+        return inspector.killChild();
+      },
+
+      get restart() {
+        return inspector.run();
+      },
+
+      get cont() {
+        handleResumed();
+        return Debugger.resume();
+      },
+
+      get next() {
+        handleResumed();
+        return Debugger.stepOver();
+      },
+
+      get step() {
+        handleResumed();
+        return Debugger.stepInto();
+      },
+
+      get out() {
+        handleResumed();
+        return Debugger.stepOut();
+      },
+
+      get pause() {
+        return Debugger.pause();
+      },
+
+      get backtrace() {
+        return currentBacktrace;
+      },
+
+      get breakpoints() {
+        return listBreakpoints();
+      },
+
+      exec(expr) {
+        return evalInCurrentContext(expr);
+      },
+
+      get profile() {
+        return Profiler.start();
+      },
+
+      get profileEnd() {
+        return PromisePrototypeThen(Profiler.stop(), Profile.createAndRegister);
+      },
+
+      get profiles() {
+        return profiles;
+      },
+
+      takeHeapSnapshot(filename = "node.heapsnapshot") {
+        if (heapSnapshotPromise) {
+          print("Cannot take heap snapshot because another snapshot is in progress.");
+          return heapSnapshotPromise;
+        }
+        heapSnapshotPromise = new Promise((resolve, reject) => {
+          const absoluteFile = Path.resolve(filename);
+          const writer = FS.createWriteStream(absoluteFile);
+          let sizeWritten = 0;
+          function onProgress({ done, total, finished }) {
+            if (finished) {
+              print("Heap snapshot prepared.");
+            } else {
+              print(`Heap snapshot: ${done}/${total}`, false);
+            }
+          }
+
+          function onChunk({ chunk }) {
+            sizeWritten += chunk.length;
+            writer.write(chunk);
+            print(`Writing snapshot: ${sizeWritten}`, false);
+          }
+
+          function onResolve() {
+            writer.end(() => {
+              teardown();
+              print(`Wrote snapshot: ${absoluteFile}`);
+              heapSnapshotPromise = null;
+              resolve();
+            });
+          }
+
+          function onReject(error) {
+            teardown();
+            reject(error);
+          }
+
+          function teardown() {
+            HeapProfiler.removeListener("reportHeapSnapshotProgress", onProgress);
+            HeapProfiler.removeListener("addHeapSnapshotChunk", onChunk);
+          }
+
+          HeapProfiler.on("reportHeapSnapshotProgress", onProgress);
+          HeapProfiler.on("addHeapSnapshotChunk", onChunk);
+
+          print("Heap snapshot: 0/0", false);
+          PromisePrototypeThen(HeapProfiler.takeHeapSnapshot({ reportProgress: true }), onResolve, onReject);
+        });
+        return heapSnapshotPromise;
+      },
+
+      get watchers() {
+        return watchers();
+      },
+
+      watch(expr) {
+        validateString(expr, "expression");
+        ArrayPrototypePush(watchedExpressions, expr);
+      },
+
+      unwatch(expr) {
+        const index = ArrayPrototypeIndexOf(watchedExpressions, expr);
+
+        // Unwatch by expression
+        // or
+        // Unwatch by watcher number
+        ArrayPrototypeSplice(watchedExpressions, index !== -1 ? index : +expr, 1);
+      },
+
+      get repl() {
+        // Don't display any default messages
+        const listeners = ArrayPrototypeSlice(repl.listeners("SIGINT"));
+        repl.removeAllListeners("SIGINT");
+
+        const oldContext = repl.context;
+
+        exitDebugRepl = () => {
+          // Restore all listeners
+          process.nextTick(() => {
+            ArrayPrototypeForEach(listeners, listener => {
+              repl.on("SIGINT", listener);
+            });
+          });
+
+          // Exit debug repl
+          repl.evalFn = controlEval;
+
+          // Swap history
+          history.debug = repl.history;
+          repl.history = history.control;
+
+          repl.context = oldContext;
+          repl.setPrompt("debug> ");
+          repl.displayPrompt();
+
+          repl.removeListener("SIGINT", exitDebugRepl);
+          repl.removeListener("exit", exitDebugRepl);
+
+          exitDebugRepl = null;
+        };
+
+        // Exit debug repl on SIGINT
+        repl.on("SIGINT", exitDebugRepl);
+
+        // Exit debug repl on repl exit
+        repl.on("exit", exitDebugRepl);
+
+        // Set new
+        repl.evalFn = debugEval;
+        repl.context = {};
+
+        // Swap history
+        history.control = repl.history;
+        repl.history = history.debug;
+
+        repl.setPrompt("> ");
+
+        print("Press Ctrl+C to leave debug repl");
+        return repl.displayPrompt();
+      },
+
+      get version() {
+        return PromisePrototypeThen(
+          Runtime.evaluate({
+            expression: "process.versions.v8",
+            contextId: 1,
+            returnByValue: true,
+          }),
+          ({ result }) => {
+            print(result.value);
+          },
+        );
+      },
+
+      scripts: listScripts,
+
+      setBreakpoint,
+      clearBreakpoint,
+      setPauseOnExceptions,
+      get breakOnException() {
+        return setPauseOnExceptions("all");
+      },
+      get breakOnUncaught() {
+        return setPauseOnExceptions("uncaught");
+      },
+      get breakOnNone() {
+        return setPauseOnExceptions("none");
+      },
+
+      list,
+      setContextLineNumber,
+    });
+    aliasProperties(context, SHORTCUTS);
+  }
+
+  async function initAfterStart() {
+    await Runtime.enable();
+    await Profiler.enable();
+    await Profiler.setSamplingInterval({ interval: 100 });
+    await Debugger.enable();
+    await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
+    await Debugger.setBlackboxPatterns({ patterns: [] });
+    await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
+    await restoreBreakpoints();
+    return Runtime.runIfWaitingForDebugger();
+  }
+
+  return async function startRepl() {
+    inspector.client.on("close", () => {
+      resetOnStart();
+    });
+    inspector.client.on("ready", () => {
+      initAfterStart();
+    });
+
+    // Init once for the initial connection
+    await initAfterStart();
+
+    const replOptions = {
+      prompt: "debug> ",
+      input: inspector.stdin,
+      output: inspector.stdout,
+      // `evalFn`, not upstream's `eval`: see internal/debugger/repl.
+      evalFn: controlEval,
+      useGlobal: false,
+      ignoreUndefined: true,
+    };
+
+    repl = Repl.start(replOptions);
+    initializeContext(repl.context);
+    repl.on("reset", initializeContext);
+
+    repl.defineCommand("interrupt", () => {
+      // We want this for testing purposes where sending Ctrl+C can be tricky.
+      repl.emit("SIGINT");
+    });
+
+    return repl;
+  };
+}
+export default createRepl;
diff --git a/src/js/internal/debugger/primordials.ts b/src/js/internal/debugger/primordials.ts
new file mode 100644
index 00000000000..ffb3a2d3293
--- /dev/null
+++ b/src/js/internal/debugger/primordials.ts
@@ -0,0 +1,76 @@
+// Primordial-style helpers for the `node inspect` CLI port; not tamper-proof
+// (the CLI never evaluates user code), just keeps the port close to upstream.
+// https://github.com/nodejs/node/blob/main/lib/internal/per_context/primordials.js
+
+const SafePromiseAllReturnArrayLike = (values, mapFn?) => {
+  return Promise.all(mapFn ? Array.from(values, mapFn) : values);
+};
+
+export default {
+  // Plain global constructors that upstream pulls from primordials. They must
+  // be present here because the ported files destructure them — a missing key
+  // would shadow the real global with `undefined`.
+  Array,
+  Date,
+  Number,
+  Promise,
+  Proxy,
+  String,
+  Symbol,
+  // The real Array.from (not a wrapper): ported code calls it with an explicit
+  // `this` (e.g. FunctionPrototypeCall(ArrayFrom, Backtrace, ...)) to construct
+  // Array subclasses.
+  ArrayFrom: Array.from,
+  ArrayIsArray: Array.isArray,
+  ArrayPrototypeFilter: (arr, fn) => arr.filter(fn),
+  ArrayPrototypeFind: (arr, fn) => arr.find(fn),
+  ArrayPrototypeForEach: (arr, fn) => arr.forEach(fn),
+  ArrayPrototypeIncludes: (arr, value) => arr.includes(value),
+  ArrayPrototypeIndexOf: (arr, value) => arr.indexOf(value),
+  ArrayPrototypeJoin: (arr, sep) => arr.join(sep),
+  ArrayPrototypeMap: (arr, fn) => arr.map(fn),
+  ArrayPrototypePop: arr => arr.pop(),
+  ArrayPrototypePush: (arr, ...values) => arr.push(...values),
+  ArrayPrototypePushApply: (arr, values) => arr.push(...values),
+  ArrayPrototypeShift: arr => arr.shift(),
+  ArrayPrototypeSlice: (arr, start?, end?) => arr.slice(start, end),
+  ArrayPrototypeSome: (arr, fn) => arr.some(fn),
+  ArrayPrototypeSplice: (arr, start, deleteCount, ...items) => arr.splice(start, deleteCount, ...items),
+  ErrorCaptureStackTrace: Error.captureStackTrace,
+  FunctionPrototypeBind: (fn, thisArg, ...args) => fn.bind(thisArg, ...args),
+  FunctionPrototypeCall: (fn, thisArg, ...args) => fn.$call(thisArg, ...args),
+  JSONParse: JSON.parse,
+  JSONStringify: JSON.stringify,
+  MathMax: Math.max,
+  NumberIsNaN: Number.isNaN,
+  NumberParseInt: Number.parseInt,
+  ObjectAssign: Object.assign,
+  ObjectDefineProperty: Object.defineProperty,
+  ObjectEntries: Object.entries,
+  ObjectKeys: Object.keys,
+  ObjectValues: Object.values,
+  PromisePrototypeThen: (promise, onFulfilled, onRejected?) => promise.then(onFulfilled, onRejected),
+  PromiseResolve: value => Promise.resolve(value),
+  PromiseWithResolvers: () => Promise.withResolvers(),
+  ReflectGetOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
+  ReflectOwnKeys: Reflect.ownKeys,
+  RegExpPrototypeExec: (re, str) => re.exec(str),
+  RegExpPrototypeSymbolSplit: (re, str, limit?) => String(str).split(re, limit),
+  SafeMap: Map,
+  SafeSet: Set,
+  SafePromiseAllReturnArrayLike,
+  SafePromiseAllReturnVoid: async (values, mapFn?) => {
+    await SafePromiseAllReturnArrayLike(values, mapFn);
+  },
+  SideEffectFreeRegExpPrototypeSymbolReplace: (re, str, replacement) => str.replace(re, replacement),
+  StringFromCharCode: String.fromCharCode,
+  StringPrototypeEndsWith: (str, search, end?) => str.endsWith(search, end),
+  StringPrototypeIncludes: (str, search) => str.includes(search),
+  StringPrototypeRepeat: (str, count) => str.repeat(count),
+  StringPrototypeReplaceAll: (str, search, replacement) => str.replaceAll(search, replacement),
+  StringPrototypeSlice: (str, start?, end?) => str.slice(start, end),
+  StringPrototypeSplit: (str, sep, limit?) => str.split(sep, limit),
+  StringPrototypeStartsWith: (str, search, start?) => str.startsWith(search, start),
+  StringPrototypeToUpperCase: str => str.toUpperCase(),
+  StringPrototypeTrim: str => str.trim(),
+};
diff --git a/src/js/internal/debugger/repl.ts b/src/js/internal/debugger/repl.ts
new file mode 100644
index 00000000000..b46d562c4db
--- /dev/null
+++ b/src/js/internal/debugger/repl.ts
@@ -0,0 +1,168 @@
+// Minimal REPLServer subset for the `node inspect` CLI port (Bun lacks
+// node:repl); just what inspect_repl.js needs, line-by-line via readline.
+// https://github.com/nodejs/node/blob/main/lib/repl.js
+"use strict";
+
+const { EventEmitter } = require("node:events");
+const readline = require("node:readline");
+const util = require("node:util");
+const vm = require("node:vm");
+
+class ReplInterface extends EventEmitter {
+  input;
+  output;
+  context;
+  // Not named `eval`: JSC's builtin parser rejects that identifier, and the
+  // release build minifies `this["eval"]` down to `this.eval`.
+  evalFn;
+  history = [];
+  ignoreUndefined = false;
+  useColors = false;
+  commands = { __proto__: null };
+  closed = false;
+  #prompt = "> ";
+  #rl;
+
+  constructor(options) {
+    super();
+    this.input = options.input;
+    this.output = options.output;
+    this.#prompt = options.prompt ?? "> ";
+    this.evalFn = options.evalFn;
+    this.ignoreUndefined = !!options.ignoreUndefined;
+    this.useColors = options.useColors ?? !!options.output?.isTTY;
+    // useGlobal: false — evaluate control commands in a fresh vm context, like
+    // node's REPL does, so `cont`/`next`/… resolve to the getters installed by
+    // initializeContext() rather than this process's globals.
+    this.context = vm.createContext({});
+
+    this.defineCommand("exit", {
+      help: "Exit the REPL",
+      action: () => this.close(),
+    });
+
+    this.#rl = readline.createInterface({
+      input: this.input,
+      terminal: false,
+    });
+    this.#rl.on("line", line => this.#onLine(line));
+    this.#rl.on("close", () => {
+      if (!this.closed) {
+        this.closed = true;
+        this.emit("exit");
+      }
+    });
+    this.#rl.on("SIGINT", () => this.#onSigint());
+
+    this.displayPrompt();
+  }
+
+  defineCommand(keyword, cmd) {
+    this.commands[keyword] = typeof cmd === "function" ? { action: cmd } : cmd;
+  }
+
+  setPrompt(prompt) {
+    this.#prompt = prompt;
+  }
+
+  getPrompt() {
+    return this.#prompt;
+  }
+
+  displayPrompt(_preserveCursor?) {
+    if (this.closed) return;
+    this.output.write(this.#prompt);
+  }
+
+  pause() {
+    this.#rl.pause();
+  }
+
+  resume() {
+    this.#rl.resume();
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.#rl.close();
+    this.emit("exit");
+  }
+
+  listenerCountSigint() {
+    return this.listenerCount("SIGINT");
+  }
+
+  #onSigint() {
+    if (this.listenerCount("SIGINT") > 0) {
+      this.emit("SIGINT");
+    } else {
+      this.output.write("\n");
+      this.displayPrompt();
+    }
+  }
+
+  #onLine(line) {
+    if (this.closed) return;
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith(".") && !trimmed.startsWith("..") && trimmed !== ".") {
+      const match = /^\.([^\s]+)\s*(.*)$/.exec(trimmed);
+      const keyword = match?.[1];
+      const rest = match?.[2] ?? "";
+      const command = keyword !== undefined ? this.commands[keyword] : undefined;
+      if (command) {
+        // The action is responsible for re-displaying the prompt (matching
+        // node's REPL); printing another one here races the test harness's
+        // prompt detection.
+        command.action.$call(this, rest);
+      } else {
+        this.output.write(`Invalid REPL keyword\n`);
+        this.displayPrompt();
+      }
+      return;
+    }
+
+    // Match node's REPL, which hands the line to `eval` with its trailing
+    // newline — the debugger uses a bare "\n" to mean "repeat last command".
+    const evalFn = this.evalFn;
+    try {
+      evalFn.$call(this, `${line}\n`, this.context, "repl", (error, result) => {
+        this.#finishEval(error, result);
+      });
+    } catch (error) {
+      this.#finishEval(error, undefined);
+    }
+  }
+
+  #finishEval(error, result) {
+    if (this.closed) return;
+    if (error) {
+      this.output.write(`${this.#formatError(error)}\n`);
+    } else if (!(this.ignoreUndefined && result === undefined)) {
+      this.output.write(`${util.inspect(result, { colors: this.useColors })}\n`);
+    }
+    this.displayPrompt();
+  }
+
+  // Node's REPL renders internal errors as "Name [ERR_CODE]: message" (the
+  // code is baked into the error's stack there). Recreate that shape here so
+  // output matches what `node inspect` prints.
+  #formatError(error) {
+    if (!(error instanceof Error)) {
+      return `Uncaught ${util.inspect(error, { colors: this.useColors })}`;
+    }
+    const code = typeof error.code === "string" && error.code.startsWith("ERR_") ? ` [${error.code}]` : "";
+    const head = `${error.name}${code}: ${error.message}`;
+    const stack = typeof error.stack === "string" ? error.stack : "";
+    const newline = stack.indexOf("\n");
+    const frames = newline === -1 ? "" : stack.slice(newline);
+    return `Uncaught ${head}${frames}`;
+  }
+}
+
+function start(options) {
+  return new ReplInterface(options);
+}
+
+export default { start };
diff --git a/src/js/internal/inspector/cdp.ts b/src/js/internal/inspector/cdp.ts
index fee809737ff..552fbf8e14b 100644
--- a/src/js/internal/inspector/cdp.ts
+++ b/src/js/internal/inspector/cdp.ts
@@ -275,6 +275,124 @@ function ownSourceMappingURL(source: string): string {
   return source.slice(at + SOURCE_MAPPING_URL_COMMENT.length, end < 0 ? source.length : end).trim();
 }
 
+// ── RemoteObject / ObjectPreview ───────────────────────────────────────────
+// V8 reports NaN/±Infinity/-0/bigint via `unserializableValue`; JSC sends
+// `value: null` + `description`. https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#type-UnserializableValue
+const UNSERIALIZABLE_NUMBERS = new Set(["NaN", "Infinity", "-Infinity", "-0"]);
+
+// Commands whose reply carries `wasThrown`; a thrown reply is enriched with
+// the exception's stack before it is forwarded (see #replyEvaluateLike).
+const EVALUATE_LIKE_METHODS = new Set(["Runtime.evaluate", "Runtime.callFunctionOn", "Debugger.evaluateOnCallFrame"]);
+
+// JSC names a collection by its class alone and puts the element count in a
+// separate `size` field; V8 folds the count into the description and has no
+// such field.
+function collectionDescription(description: string | undefined, size: number | undefined): string | undefined {
+  if (description === undefined || size === undefined) return description;
+  return `${description}(${size})`;
+}
+
+// JSC gives every Error line/column/sourceURL own properties (plus the raw
+// originalLine/originalColumn pair) that V8 errors do not have; previews must
+// not show them. V8 lists stack before message.
+const JSC_ERROR_LOCATION_PROPS = new Set(["line", "column", "sourceURL", "originalLine", "originalColumn"]);
+
+function toV8ErrorPreviewProperties(properties: AnyObject[]): AnyObject[] {
+  const filtered = properties.filter(property => !JSC_ERROR_LOCATION_PROPS.$has(property?.name));
+  const stackAt = filtered.findIndex(property => property?.name === "stack");
+  if (stackAt > 0) {
+    const stack = filtered[stackAt];
+    filtered.splice(stackAt, 1);
+    filtered.unshift(stack);
+  }
+  return filtered;
+}
+
+function toCdpObjectPreview(preview: AnyObject | undefined, nested = false): AnyObject | undefined {
+  if (!preview) return preview;
+  const { lossless, size, properties, entries, valuePreview, description, ...rest } = preview;
+  const out: AnyObject = rest;
+  out.description = collectionDescription(description, size);
+  // JSC's `lossless` is the negation of V8's `overflow`. JSC sends `overflow`
+  // too, but only for some types, so derive it whenever `lossless` is present.
+  if (lossless !== undefined) out.overflow = !lossless;
+  if (properties) {
+    out.properties =
+      rest.subtype === "error"
+        ? toV8ErrorPreviewProperties(properties).map(toCdpPropertyPreview)
+        : properties.map(toCdpPropertyPreview);
+    // The JSC-only properties were what made the preview lossy.
+    if (rest.subtype === "error") out.overflow = false;
+  }
+  // V8 omits `entries` when empty (JSC sends []) and only on the top-level
+  // preview (nested Map/Set is elided to overflow); Node's REPL branches on
+  // the field's presence, so match V8.
+  if (entries && entries.length > 0) {
+    if (nested) {
+      out.overflow = true;
+    } else {
+      out.entries = entries.map(toCdpEntryPreview);
+    }
+  }
+  if (valuePreview) out.valuePreview = toCdpObjectPreview(valuePreview, nested);
+  return out;
+}
+
+function toCdpPropertyPreview(property: AnyObject): AnyObject {
+  const { valuePreview } = property;
+  if (!valuePreview) return property;
+  return { ...property, valuePreview: toCdpObjectPreview(valuePreview, true) };
+}
+
+function toCdpEntryPreview(entry: AnyObject): AnyObject {
+  const { key, value } = entry;
+  const out: AnyObject = { ...entry };
+  if (key) out.key = toCdpObjectPreview(key, true);
+  if (value) out.value = toCdpObjectPreview(value, true);
+  return out;
+}
+
+function toCdpRemoteObject(remote: AnyObject | undefined): AnyObject | undefined {
+  if (!remote || typeof remote !== "object") return remote;
+  const { size, preview, description, type, ...rest } = remote;
+  const out: AnyObject = rest;
+  if (type !== undefined) out.type = type;
+  if (description !== undefined) out.description = description;
+  const unserializable =
+    description !== undefined && (type === "bigint" || (type === "number" && UNSERIALIZABLE_NUMBERS.$has(description)));
+  if (unserializable) {
+    delete out.value;
+    out.unserializableValue = description;
+  } else if (size !== undefined) {
+    out.description = collectionDescription(description, size);
+  }
+  if (preview) out.preview = toCdpObjectPreview(preview);
+  return out;
+}
+
+function toCdpPropertyDescriptor(property: AnyObject): AnyObject {
+  const { value, get, set, symbol } = property;
+  const out: AnyObject = { configurable: false, enumerable: false, ...property };
+  if (value) out.value = toCdpRemoteObject(value);
+  if (get) out.get = toCdpRemoteObject(get);
+  if (set) out.set = toCdpRemoteObject(set);
+  if (symbol) out.symbol = toCdpRemoteObject(symbol);
+  return out;
+}
+
+// JSC and V8 word the same protocol failures differently. CDP clients match on
+// the message text, so translate the ones with a V8 counterpart.
+// https://github.com/nodejs/node/blob/v26.3.0/test/parallel/test-debugger-breakpoint-exists.js
+const BACKEND_ERROR_MESSAGES: Record<string, string> = {
+  __proto__: null,
+  "Breakpoint for given location already exists": "Breakpoint at specified location already exists.",
+} as any;
+
+function toCdpErrorMessage(message: string | undefined): string {
+  if (message === undefined) return "Unknown error";
+  return BACKEND_ERROR_MESSAGES[message] ?? message;
+}
+
 // Null-proto so a key not present as an own property does not fall through to
 // Object.prototype: the in-process Session runs this adapter on the user's
 // main thread, where Object.prototype may have been tampered with.
@@ -343,6 +461,13 @@ class InspectorCDPAdapter {
   #writeToBackend: (message: string) => void;
   #writeToClient: (message: string) => void;
   #nextExceptionId = 1;
+  // V8 reports the pause that ends a step command with reason "step"; JSC does
+  // not distinguish it from any other pause, so track the step here.
+  #steppingToNextPause = false;
+  // V8 labels the --inspect-brk pause "Break on start"; Bun's injected
+  // `debugger;` is indistinguishable to JSC, so latch the release of a waiting
+  // target and relabel the pause it triggers.
+  #breakOnStartPending = false;
   #pending = new Map<
     number,
     { clientId: number | string | null; method: string; onResult?: (result: AnyObject, error?: AnyObject) => void }
@@ -380,6 +505,11 @@ class InspectorCDPAdapter {
   #profilerTracking = false;
   #profilerStartTime = 0;
   #profilerStopClientIds: (number | string)[] = [];
+  // console.profile() starts JSC tracking with no client Profiler.start;
+  // V8 announces those as consoleProfileStarted/Finished instead of a
+  // Profiler.stop reply.
+  #consoleProfileActive = false;
+  #consoleProfileSeq = 0;
   // NodeRuntime domain state, per connection, mirroring Node's RuntimeAgent.
   #nodeRuntimeEnabled = false;
   #notifyWhenWaitingForDisconnect = false;
@@ -512,7 +642,7 @@ class InspectorCDPAdapter {
 
   #onEvaluateForAwaitPromise(id: number, method: string, params: AnyObject, result: AnyObject, error: AnyObject) {
     if (error) {
-      this.#replyErrorToClient(id, error.code ?? -32000, error.message ?? "Unknown error");
+      this.#replyErrorToClient(id, error.code ?? -32000, toCdpErrorMessage(error.message));
       return;
     }
     const remote = result.result;
@@ -533,15 +663,157 @@ class InspectorCDPAdapter {
       );
       return;
     }
-    // Primitive/thrown: nothing to await. A thrown non-primitive already has an objectId (step one
-    // forced returnByValue:false), which clients inspect via exceptionDetails — do not re-serialize.
-    this.#replyToClient(id, this.#translateResult(method, result));
+    // Primitive / thrown: nothing to await. Primitives already carry value
+    // regardless of returnByValue; a thrown non-primitive comes back as an
+    // objectId (the first step forced returnByValue:false), which
+    // DevTools/vscode-js-debug inspect via exceptionDetails, so we do not
+    // re-serialize it to honour the client's returnByValue.
+    this.#replyEvaluateLike(id, method, result);
+  }
+
+  // V8's exceptionDetails carry throw site + stackTrace + formatted stack;
+  // JSC reports only the bare exception. Recover from the error's own
+  // stack/line/column/sourceURL via one extra Runtime.getProperties roundtrip.
+  #replyEvaluateLike(clientId: number | string, method: string, jscResult: AnyObject): void {
+    const remote = jscResult.result;
+    const objectId = jscResult.wasThrown ? remote?.objectId : undefined;
+    if (objectId) {
+      this.#sendToBackend("Runtime.getProperties", { objectId, ownProperties: true }, null, method, (props, error) => {
+        const properties = error ? [] : (props.properties ?? []);
+        this.#replyToClient(clientId, this.#translateThrownResult(method, jscResult, properties));
+      });
+      return;
+    }
+    // An error VALUE with a preview: JSC caps preview properties at five, and
+    // an error's five JSC location properties crowd `stack` out entirely, so
+    // recover it from the object itself (V8 lists it first).
+    if (remote?.subtype === "error" && remote.preview && remote.objectId) {
+      this.#sendToBackend(
+        "Runtime.getProperties",
+        { objectId: remote.objectId, ownProperties: true },
+        null,
+        method,
+        (props, error) => {
+          const out = this.#translateResult(method, jscResult);
+          const preview = out.result?.preview;
+          if (!error && preview?.properties) {
+            let stack: unknown;
+            for (const property of props.properties ?? []) {
+              if (property?.name === "stack") stack = property.value?.value;
+            }
+            const hasStack = preview.properties.some((property: AnyObject) => property?.name === "stack");
+            if (typeof stack === "string" && !hasStack) {
+              preview.properties.unshift({ name: "stack", type: "string", value: stack });
+            }
+          }
+          this.#replyToClient(clientId, out);
+        },
+      );
+      return;
+    }
+    this.#replyToClient(clientId, this.#translateResult(method, jscResult));
+  }
+
+  #translateThrownResult(method: string, jscResult: AnyObject, properties: AnyObject[]): AnyObject {
+    const out = this.#translateResult(method, jscResult);
+    const details = out.exceptionDetails;
+    if (!details) return out;
+    let stack: string | undefined;
+    let line: number | undefined;
+    let column: number | undefined;
+    let generatedLine: number | undefined;
+    let generatedColumn: number | undefined;
+    let sourceURL: string | undefined;
+    for (const property of properties) {
+      const value = property?.value?.value;
+      switch (property?.name) {
+        case "stack":
+          if (typeof value === "string") stack = value;
+          break;
+        // Bun stores the raw JSC throw position in originalLine/originalColumn
+        // and the source-mapped one in line/column (all 1-based).
+        case "line":
+          if (typeof value === "number") line = value;
+          break;
+        case "column":
+          if (typeof value === "number") column = value;
+          break;
+        case "originalLine":
+          if (typeof value === "number") generatedLine = value;
+          break;
+        case "originalColumn":
+          if (typeof value === "number") generatedColumn = value;
+          break;
+        case "sourceURL":
+          if (typeof value === "string") sourceURL = value;
+          break;
+      }
+    }
+    // details.exception and out.result are the same object; V8 formats both
+    // with the message followed by the frames, which is exactly Bun's
+    // Error#stack. A tampered stack that dropped the message keeps it.
+    const remote = details.exception;
+    if (stack !== undefined && stack !== "") {
+      const description = typeof remote.description === "string" ? remote.description : "";
+      remote.description = stack.startsWith(description) ? stack : `${description}\n${stack}`;
+
+      const callFrames: AnyObject[] = [];
+      for (const frameLine of stack.split("\n")) {
+        const match = /^\s+at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/.exec(frameLine);
+        if (match === null) continue;
+        const frameUrl = match[2];
+        callFrames.push({
+          functionName: match[1] ?? "",
+          scriptId: this.#scriptIdsByUrl.get(frameUrl) ?? "",
+          url: frameUrl,
+          lineNumber: Number(match[3]) - 1,
+          columnNumber: Number(match[4]) - 1,
+        });
+      }
+      if (callFrames.length > 0) details.stackTrace = { callFrames };
+    }
+    // JSC is 1-based and records the callee position; V8/CDP is 0-based and
+    // reports the throwing statement's start. Approximate the latter via the
+    // source-map mapping at-or-before the generated position, walked to line start.
+    const scriptId = sourceURL !== undefined ? this.#scriptIdsByUrl.get(sourceURL) : undefined;
+    const statementStart =
+      scriptId !== undefined && typeof generatedLine === "number" && generatedLine > 0
+        ? this.#originalStatementStart(
+            scriptId,
+            generatedLine - 1,
+            typeof generatedColumn === "number" && generatedColumn > 0 ? generatedColumn - 1 : 0,
+          )
+        : undefined;
+    if (statementStart !== undefined) {
+      details.lineNumber = statementStart.lineNumber;
+      details.columnNumber = statementStart.columnNumber;
+      details.scriptId = scriptId;
+    } else if (typeof line === "number" && line > 0) {
+      details.lineNumber = line - 1;
+      details.columnNumber = typeof column === "number" && column > 0 ? column - 1 : 0;
+      if (scriptId !== undefined) details.scriptId = scriptId;
+    }
+    return out;
+  }
+
+  #originalStatementStart(scriptId: string, genLine: number, genColumn: number): OriginalPosition | undefined {
+    const map = this.#sourceMapFor(scriptId);
+    const lineMappings = map?.byGeneratedLine?.[genLine];
+    if (!lineMappings || lineMappings.columns.length === 0) return undefined;
+    const { columns, lineNumbers, columnNumbers } = lineMappings;
+    let at = 0;
+    for (let i = 0; i < columns.length; i++) {
+      if (columns[i] <= genColumn) at = i;
+    }
+    const lineNumber = lineNumbers[at];
+    while (at > 0 && lineNumbers[at - 1] === lineNumber) at--;
+    return { lineNumber, columnNumber: columnNumbers[at] };
   }
 
   #onProfilerStartReply(id: number, _result: AnyObject, error: AnyObject) {
     if (error) {
       this.#profilerTracking = false;
-      this.#replyErrorToClient(id, error.code ?? -32000, error.message ?? "Unknown error");
+      this.#replyErrorToClient(id, error.code ?? -32000, toCdpErrorMessage(error.message));
       return;
     }
     this.#replyToClient(id, {});
@@ -552,7 +824,7 @@ class InspectorCDPAdapter {
     if (error) {
       const at = this.#profilerStopClientIds.indexOf(id);
       if (at >= 0) this.#profilerStopClientIds.splice(at, 1);
-      this.#replyErrorToClient(id, error.code ?? -32000, error.message ?? "Unknown error");
+      this.#replyErrorToClient(id, error.code ?? -32000, toCdpErrorMessage(error.message));
     }
   }
 
@@ -577,7 +849,11 @@ class InspectorCDPAdapter {
   #onGlobalObjectForCallFunctionOn(id: number, method: string, params: AnyObject, result: AnyObject, error: AnyObject) {
     const globalObjectId = result.result?.objectId;
     if (error || !globalObjectId) {
-      this.#replyErrorToClient(id, error?.code ?? -32000, error?.message ?? "Failed to resolve global object");
+      this.#replyErrorToClient(
+        id,
+        error?.code ?? -32000,
+        error ? toCdpErrorMessage(error.message) : "Failed to resolve global object",
+      );
       return;
     }
     this.#forwardCallFunctionOn(id, method, params, globalObjectId);
@@ -594,7 +870,7 @@ class InspectorCDPAdapter {
     error: AnyObject,
   ) {
     if (error) {
-      this.#replyErrorToClient(id, error.code ?? -32000, error.message ?? "Unknown error");
+      this.#replyErrorToClient(id, error.code ?? -32000, toCdpErrorMessage(error.message));
       return;
     }
     const breakpointId = result.breakpointId;
@@ -657,6 +933,7 @@ class InspectorCDPAdapter {
     // A synchronous scriptParsed listener may have already decoded the map
     // (#sourceMapFor consumes mappings into map), so check both states.
     if (!script || (script.mappings === undefined && script.map === undefined)) return;
+    const resets: { clientBreakpointId: string; bp: AnyObject; generated: AnyObject }[] = [];
     for (const [clientBreakpointId, bp] of this.#preParseBreakpoints) {
       if (bp.resolved) continue;
       const { url: bpUrl, urlRegex: bpUrlRegex } = bp;
@@ -681,8 +958,16 @@ class InspectorCDPAdapter {
       if (generated.lineNumber === bp.lineNumber && (generated.columnNumber ?? 0) === (bp.columnNumber ?? 0)) {
         continue; // The map is an identity for this position.
       }
+      resets.push({ clientBreakpointId, bp, generated });
+    }
+    // Remove all before re-adding any: JSC merges pre-parse requests on an
+    // unmapped line to one pause location, so removing one after a re-add
+    // resolved to the same spot cleared the re-added one too.
+    for (const { bp } of resets) {
       bp.resetPending = true;
       this.#sendToBackend("Debugger.removeBreakpoint", { breakpointId: bp.jscId });
+    }
+    for (const { clientBreakpointId, bp, generated } of resets) {
       const options: AnyObject = {};
       const { condition } = bp;
       if (condition) options.condition = condition;
@@ -692,7 +977,7 @@ class InspectorCDPAdapter {
           lineNumber: generated.lineNumber,
           columnNumber: generated.columnNumber,
           options,
-          urlRegex: bpUrlRegex ?? breakpointUrlRegex(bpUrl!),
+          urlRegex: bp.urlRegex ?? breakpointUrlRegex(bp.url!),
         },
         null,
         "Debugger.setBreakpointByUrl",
@@ -763,7 +1048,11 @@ class InspectorCDPAdapter {
       }
       if (clientId === null || clientId === undefined) return;
       if (error) {
-        this.#replyErrorToClient(clientId, error.code ?? -32000, error.message ?? "Unknown error");
+        this.#replyErrorToClient(clientId, error.code ?? -32000, toCdpErrorMessage(error.message));
+        return;
+      }
+      if (EVALUATE_LIKE_METHODS.$has(pending.method)) {
+        this.#replyEvaluateLike(clientId, pending.method, parsed.result || {});
         return;
       }
       this.#replyToClient(clientId, this.#translateResult(pending.method, parsed.result || {}));
@@ -832,6 +1121,9 @@ class InspectorCDPAdapter {
         return;
 
       case "Runtime.runIfWaitingForDebugger":
+        // Only a target parked in wait-for-debugger state can produce the
+        // "Break on start" pause; --inspect (no -brk/-wait) never waits.
+        if (this.#isWaitingForDebugger()) this.#breakOnStartPending = true;
         // Inspector.initialized resolves Bun's wait-for-debugger state, which
         // unblocks inspector.open(port, host, true) on the inspected thread.
         this.#sendToBackend("Inspector.initialized");
@@ -939,13 +1231,18 @@ class InspectorCDPAdapter {
         this.#sendToBackend("Debugger.setPauseOnDebuggerStatements", { enabled: true }, id, method);
         return;
 
-      case "Debugger.disable":
-      case "Debugger.pause":
-      case "Debugger.resume":
       case "Debugger.stepInto":
       case "Debugger.stepOut":
       case "Debugger.stepOver":
+        this.#steppingToNextPause = true;
+        this.#sendToBackend(method, params, id, method);
+        return;
+
+      case "Debugger.disable":
+      case "Debugger.pause":
+      case "Debugger.resume":
       case "Debugger.setBreakpointsActive":
+        this.#steppingToNextPause = false;
         this.#sendToBackend(method, params, id, method);
         return;
 
@@ -1105,6 +1402,45 @@ class InspectorCDPAdapter {
         this.#sendToBackend("Heap.gc", undefined, id, method);
         return;
 
+      // V8 streams the snapshot as addHeapSnapshotChunk events, then answers
+      // the command. JSC's Heap.snapshot uses its own format, so build the
+      // V8-format snapshot on the inspected thread instead and chunk it here.
+      case "HeapProfiler.takeHeapSnapshot": {
+        const reportProgress = !!params.reportProgress;
+        this.#sendToBackend(
+          "Runtime.evaluate",
+          {
+            expression: 'Bun.generateHeapSnapshot("v8")',
+            returnByValue: true,
+            doNotPauseOnExceptionsAndMuteConsole: true,
+          },
+          null,
+          method,
+          (result, error) => {
+            const snapshot = !error && !result.wasThrown ? result.result?.value : undefined;
+            if (typeof snapshot !== "string") {
+              this.#replyErrorToClient(id, -32000, "Failed to take heap snapshot");
+              return;
+            }
+            if (reportProgress) {
+              this.#emitToClient("HeapProfiler.reportHeapSnapshotProgress", {
+                done: 1,
+                total: 1,
+                finished: true,
+              });
+            }
+            const chunkSize = 100 * 1024;
+            for (let offset = 0; offset < snapshot.length; offset += chunkSize) {
+              this.#emitToClient("HeapProfiler.addHeapSnapshotChunk", {
+                chunk: snapshot.slice(offset, offset + chunkSize),
+              });
+            }
+            this.#replyToClient(id, {});
+          },
+        );
+        return;
+      }
+
       // V8's CPU profiler maps onto JSC's ScriptProfiler: track with samples,
       // then reshape them into a V8 profile (#translateSamplingProfile).
       case "Profiler.start":
@@ -1211,31 +1547,46 @@ class InspectorCDPAdapter {
       case "Debugger.enable":
         return { debuggerId: "(bun)", ...result };
 
+      // Breakpoint replies carry resolved positions in generated coordinates;
+      // clients print them (the debugger REPL's `breakpoints` list), so they
+      // need the same original-position translation as pause locations.
+      case "Debugger.setBreakpoint": {
+        const out: AnyObject = { ...result };
+        if (out.actualLocation) out.actualLocation = this.#toOriginalLocation(out.actualLocation);
+        return out;
+      }
+
+      case "Debugger.setBreakpointByUrl": {
+        const out: AnyObject = { ...result };
+        if ($isJSArray(out.locations)) {
+          out.locations = out.locations.map((location: AnyObject) => this.#toOriginalLocation(location));
+        }
+        return out;
+      }
+
       case "Runtime.evaluate":
       case "Runtime.callFunctionOn":
       case "Debugger.evaluateOnCallFrame": {
-        const out: AnyObject = { result: result.result ?? { type: "undefined" } };
+        const remote = toCdpRemoteObject(result.result) ?? { type: "undefined" };
+        const out: AnyObject = { result: remote };
         if (result.wasThrown) {
           out.exceptionDetails = {
             exceptionId: this.#nextExceptionId++,
-            text: result.result?.description ?? "Uncaught",
+            // V8's text for a thrown evaluation is the fixed string
+            // "Uncaught"; the message lives in the exception's description.
+            text: "Uncaught",
             lineNumber: 0,
             columnNumber: 0,
-            exception: result.result,
+            exception: remote,
           };
         }
         return out;
       }
 
       case "Runtime.getProperties": {
-        const properties = (result.properties ?? []).map((property: AnyObject) => ({
-          configurable: false,
-          enumerable: false,
-          ...property,
-        }));
-        const out: AnyObject = { result: properties };
+        const out: AnyObject = { result: (result.properties ?? []).map(toCdpPropertyDescriptor) };
         const { internalProperties } = result;
-        if (internalProperties) out.internalProperties = internalProperties;
+        if (internalProperties) out.internalProperties = internalProperties.map(toCdpPropertyDescriptor);
         return out;
       }
 
@@ -1335,7 +1686,9 @@ class InspectorCDPAdapter {
           canBeRestarted: false,
         }));
         const { data, asyncStackTrace } = params;
-        const cdpParams: AnyObject = { callFrames, reason: "other", data };
+        const stepped = this.#steppingToNextPause;
+        this.#steppingToNextPause = false;
+        const cdpParams: AnyObject = { callFrames, reason: stepped ? "step" : "other", data };
         switch (params.reason) {
           case "exception":
             cdpParams.reason = "exception";
@@ -1344,9 +1697,20 @@ class InspectorCDPAdapter {
             cdpParams.reason = "assert";
             break;
           case "Breakpoint":
+            // A breakpoint reached mid-step is a breakpoint hit to V8, not a
+            // completed step.
+            cdpParams.reason = "other";
             if (data?.breakpointId) cdpParams.hitBreakpoints = [this.#toClientBreakpointId(data.breakpointId)];
             break;
         }
+        // The first pause after releasing a parked target is "Break on start";
+        // it wins over a breakpoint (V8 does too) but not over an exception,
+        // which means user code already ran.
+        const breakOnStart = this.#breakOnStartPending;
+        this.#breakOnStartPending = false;
+        if (breakOnStart && cdpParams.reason !== "exception" && cdpParams.reason !== "assert") {
+          cdpParams.reason = "Break on start";
+        }
         if (asyncStackTrace) cdpParams.asyncStackTrace = this.#translateStackTrace(asyncStackTrace);
         this.#emitToClient("Debugger.paused", cdpParams);
         return;
@@ -1377,6 +1741,16 @@ class InspectorCDPAdapter {
 
       case "ScriptProfiler.trackingStart":
         this.#profilerStartTime = params.timestamp ?? 0;
+        // Tracking that no client requested was started programmatically by
+        // console.profile(); V8 announces it. JSC does not report the call
+        // site, so the location is empty.
+        if (!this.#profilerTracking) {
+          this.#consoleProfileActive = true;
+          this.#emitToClient("Profiler.consoleProfileStarted", {
+            id: String(++this.#consoleProfileSeq),
+            location: { scriptId: "0", lineNumber: 0, columnNumber: 0 },
+          });
+        }
         return;
 
       case "ScriptProfiler.trackingComplete": {
@@ -1386,6 +1760,15 @@ class InspectorCDPAdapter {
           // ended. The issuing session already cleared #profilerTracking at
           // Profiler.stop and may have re-armed it with a pipelined start.
           this.#profilerTracking = false;
+          if (this.#consoleProfileActive) {
+            this.#consoleProfileActive = false;
+            this.#emitToClient("Profiler.consoleProfileFinished", {
+              id: String(this.#consoleProfileSeq),
+              location: { scriptId: "0", lineNumber: 0, columnNumber: 0 },
+              profile: this.#translateSamplingProfile(params),
+            });
+            this.#profilerStartTime = 0;
+          }
           return;
         }
         this.#replyToClient(clientId, { profile: this.#translateSamplingProfile(params) });
diff --git a/src/js/node/inspector.ts b/src/js/node/inspector.ts
index cce028f5f0d..637f439495e 100644
--- a/src/js/node/inspector.ts
+++ b/src/js/node/inspector.ts
@@ -49,11 +49,18 @@ const drainInProcessInspectorMessages = $newCppFunction(
 );
 const disconnectInProcessInspector = $newCppFunction("BunDebugger.cpp", "jsFunction_disconnectInProcessInspector", 0);
 const closeNodeInspector = $newCppFunction("BunDebugger.cpp", "jsFunction_closeNodeInspector", 0);
+const getNodeInspectorUrl = $newCppFunction("BunDebugger.cpp", "jsFunction_getNodeInspectorUrl", 0);
+// Emits one console message to attached inspector sessions only; see
+// `console` below.
+const inspectorConsoleCall = $newCppFunction("BunDebugger.cpp", "jsFunction_inspectorConsoleCall", 1);
 
 // Captured at load so console-hook stack capture survives user tampering with globalThis.Error.
 const ErrorObject = globalThis.Error;
 const errorCaptureStackTrace = ErrorObject.captureStackTrace;
 
+// Set only by open(): flags that the debugger thread owns a backend Sessions
+// must share (what #handleMethod's Debugger.* forwarding keys off). --inspect
+// sets no such backend, so url()/close()/waitForDebugger() use getNodeInspectorUrl().
 let activeInspectorUrl: string | undefined;
 
 // Same check as Node's internal/net.js isLoopback().
@@ -67,14 +74,21 @@ function isLoopbackHost(host: string) {
   );
 }
 
+// URL of the listening node-inspector server (from open() or --inspect).
+// Workers never have one: the main thread owns it and open() rejects there.
+function listeningInspectorUrl(): string | undefined {
+  if (!Bun.isMainThread) return undefined;
+  return getNodeInspectorUrl() ?? undefined;
+}
+
 function open(port?: number, host?: string, wait?: boolean) {
-  if (activeInspectorUrl !== undefined) {
-    throw $ERR_INSPECTOR_ALREADY_ACTIVATED();
-  }
   if (!Bun.isMainThread) {
     // Node supports per-worker inspectors; Bun does not yet.
     throw $ERR_WORKER_UNSUPPORTED_OPERATION("inspector.open() is not supported in workers");
   }
+  if (listeningInspectorUrl() !== undefined) {
+    throw $ERR_INSPECTOR_ALREADY_ACTIVATED();
+  }
 
   if (port !== undefined && port !== null) {
     if (typeof port !== "number" || !Number.isInteger(port) || port < 0 || port > 65535) {
@@ -141,7 +155,7 @@ function open(port?: number, host?: string, wait?: boolean) {
 }
 
 function close() {
-  if (activeInspectorUrl === undefined) {
+  if (listeningInspectorUrl() === undefined) {
     return;
   }
   // Blocks until the debugger thread has stopped the server, so the port is refused on return.
@@ -151,11 +165,11 @@ function close() {
 
 function url() {
   // https://nodejs.org/api/inspector.html#inspectorurl
-  return activeInspectorUrl;
+  return listeningInspectorUrl();
 }
 
 function waitForDebugger() {
-  if (activeInspectorUrl === undefined) {
+  if (listeningInspectorUrl() === undefined) {
     throw $ERR_INSPECTOR_NOT_ACTIVE();
   }
   waitForNodeInspectorConnection();
@@ -1016,7 +1030,6 @@ class Session extends EventEmitter {
   #adapter: any = undefined;
   #pendingResults: Map<number, (err: any, result?: any) => void> = new SafeMap();
   #nextCommandId = 1;
-  #dispatchingClientCommand = false;
 
   // Lazily route untranslated commands through the CDP<->JSC adapter; replies land in #pendingResults.
   #inProcessAdapter() {
@@ -1056,9 +1069,9 @@ class Session extends EventEmitter {
     }
   }
 
-  // Replies produced during post() are deferred until dispatch unwinds so a throwing callback isn't
-  // misread as command failure. Events deliver immediately — Debugger.paused nested in a dispatch
-  // must reach listeners before execution continues (#onClientMessage contains listener throws).
+  // Synchronous, replies included: in Node the reply reaches the callback
+  // before post() returns. #onClientMessage turns a throw into a warning.
+  // https://github.com/nodejs/node/blob/main/src/inspector_js_api.cc
   #deliverClientMessage(clientMessage: string) {
     let parsed;
     try {
@@ -1066,11 +1079,7 @@ class Session extends EventEmitter {
     } catch {
       return;
     }
-    if (this.#dispatchingClientCommand && parsed?.id !== undefined) {
-      queueMicrotask(this.#onClientMessage.bind(this, parsed));
-    } else {
-      this.#onClientMessage(parsed);
-    }
+    this.#onClientMessage(parsed);
   }
 
   // HeapProfiler.addHeapSnapshotChunk chunked delivery: https://chromedevtools.github.io/devtools-protocol/tot/HeapProfiler/#event-addHeapSnapshotChunk
@@ -1087,14 +1096,7 @@ class Session extends EventEmitter {
     const id = this.#nextCommandId++;
     this.#pendingResults.set(id, done);
     const message = JSON.stringify(params === undefined ? { id, method } : { id, method, params });
-    const wasDispatching = this.#dispatchingClientCommand;
-    this.#dispatchingClientCommand = true;
-    try {
-      adapter.handleClientMessage(message);
-    } finally {
-      // Restore, not clear: a re-entered post() must not flip the outer dispatch to sync delivery.
-      this.#dispatchingClientCommand = wasDispatching;
-    }
+    adapter.handleClientMessage(message);
   }
 
   connect() {
@@ -1160,8 +1162,8 @@ class Session extends EventEmitter {
     }
     if (callback !== undefined) validateFunction(callback, "callback");
 
+    // Node throws here even when a callback was given (verified on v26.3.0).
     if (!this.#connected) {
-      // Node throws synchronously regardless of callback: https://github.com/nodejs/node/blob/main/lib/inspector.js
       throw $ERR_INSPECTOR_NOT_CONNECTED();
     }
 
@@ -1179,7 +1181,13 @@ class Session extends EventEmitter {
     }
 
     if (callback) {
-      queueMicrotask(settleLocalPost.bind(undefined, callback, result));
+      // Same contract as a reply from the backend: synchronous, and a throw
+      // from the callback becomes a process warning rather than escaping.
+      try {
+        settleLocalPost(callback, result);
+      } catch (thrown) {
+        process.emitWarning(toWarning(thrown));
+      }
     }
     // Node's post() always returns undefined; protocol errors without a callback are unobservable.
   }
@@ -1419,6 +1427,34 @@ class Session extends EventEmitter {
       case "NodeWorker.detach":
         return {};
 
+      // Node's tracing-agent category list, same order (Bun emits a subset).
+      // https://github.com/nodejs/node/blob/v26.3.0/src/inspector/tracing_agent.cc#L181-L206
+      case "NodeTracing.getCategories":
+        return {
+          categories: [
+            "node",
+            "node.async_hooks",
+            "node.bootstrap",
+            "node.console",
+            "node.dns.native",
+            "node.environment",
+            "node.fs.async",
+            "node.fs.sync",
+            "node.fs_dir.async",
+            "node.fs_dir.sync",
+            "node.http",
+            "node.net.native",
+            "node.perf",
+            "node.perf.timerify",
+            "node.perf.usertiming",
+            "node.promises.rejections",
+            "node.threadpoolwork.async",
+            "node.threadpoolwork.sync",
+            "node.vm.script",
+            "v8",
+          ],
+        };
+
       case "NodeTracing.start": {
         if (!Bun.isMainThread) {
           return {
@@ -1461,8 +1497,67 @@ class Session extends EventEmitter {
   }
 }
 
+// Node's `inspector.console` = V8's inspector console: Runtime.consoleAPICalled
+// only, no stdio. Ids match Bun::InspectorConsoleMethod in BunDebugger.h.
+// https://github.com/nodejs/node/blob/main/lib/inspector.js
+const InspectorConsoleMethod = {
+  log: 0,
+  info: 1,
+  debug: 2,
+  warn: 3,
+  error: 4,
+  dir: 5,
+  dirxml: 6,
+  table: 7,
+  trace: 8,
+  clear: 9,
+  assert: 10,
+  group: 11,
+  groupCollapsed: 12,
+  groupEnd: 13,
+  count: 14,
+  countReset: 15,
+  profile: 16,
+  profileEnd: 17,
+  time: 18,
+  timeLog: 19,
+  timeEnd: 20,
+  timeStamp: 21,
+};
+
+function makeInspectorConsoleMethod(name: string) {
+  const id = InspectorConsoleMethod[name];
+  const method = function (...args: unknown[]) {
+    inspectorConsoleCall(id, ...args);
+  };
+  Object.defineProperty(method, "name", { __proto__: null, value: name, configurable: true });
+  return method;
+}
+
+// Same keys, in the same order, as Node v26.3.0's `inspector.console`.
 const console = {
-  ...globalThis.console,
+  debug: makeInspectorConsoleMethod("debug"),
+  error: makeInspectorConsoleMethod("error"),
+  info: makeInspectorConsoleMethod("info"),
+  log: makeInspectorConsoleMethod("log"),
+  warn: makeInspectorConsoleMethod("warn"),
+  dir: makeInspectorConsoleMethod("dir"),
+  dirxml: makeInspectorConsoleMethod("dirxml"),
+  table: makeInspectorConsoleMethod("table"),
+  trace: makeInspectorConsoleMethod("trace"),
+  group: makeInspectorConsoleMethod("group"),
+  groupCollapsed: makeInspectorConsoleMethod("groupCollapsed"),
+  groupEnd: makeInspectorConsoleMethod("groupEnd"),
+  clear: makeInspectorConsoleMethod("clear"),
+  count: makeInspectorConsoleMethod("count"),
+  countReset: makeInspectorConsoleMethod("countReset"),
+  assert: makeInspectorConsoleMethod("assert"),
+  profile: makeInspectorConsoleMethod("profile"),
+  profileEnd: makeInspectorConsoleMethod("profileEnd"),
+  time: makeInspectorConsoleMethod("time"),
+  timeLog: makeInspectorConsoleMethod("timeLog"),
+  timeEnd: makeInspectorConsoleMethod("timeEnd"),
+  timeStamp: makeInspectorConsoleMethod("timeStamp"),
   context: {
     console: globalThis.console,
   },
diff --git a/src/jsc/Debugger.rs b/src/jsc/Debugger.rs
index 6905f00a72d..a0689790b7d 100644
--- a/src/jsc/Debugger.rs
+++ b/src/jsc/Debugger.rs
@@ -240,11 +240,7 @@ impl Debugger {
         });
 
         bun_core::scoped_log!(debugger, "spin");
-        // `FUTEX_ATOMIC` starts at 0 and nothing ever stores `1` before this
-        // load, so this loop is a no-op on first call.
-        while FUTEX_ATOMIC.load(Ordering::Relaxed) > 0 {
-            bun_threading::Futex::wait_forever(&FUTEX_ATOMIC, 1);
-        }
+        Debugger::wait_for_thread_startup();
         if bun_core::Environment::ENABLE_LOGS {
             bun_core::scoped_log!(
                 debugger,
@@ -384,6 +380,15 @@ impl Debugger {
         }
     }
 
+    /// Block until the debugger thread finishes startup: `create()` arms the
+    /// futex before spawning, `start_js_debugger_thread` clears it on every
+    /// exit path. No-op once the thread already started.
+    pub fn wait_for_thread_startup() {
+        while FUTEX_ATOMIC.load(Ordering::Relaxed) > 0 {
+            bun_threading::Futex::wait_forever(&FUTEX_ATOMIC, 1);
+        }
+    }
+
     /// `Debugger.create(vm, global)` — first-time debugger setup: create the
     /// JSC inspector context, spawn the debugger VM thread, and arm the
     /// keep-alive on the parent loop.
@@ -413,6 +418,10 @@ impl Debugger {
 
         if !this_ref.has_started_debugger {
             this_ref.as_mut().has_started_debugger = true;
+            // Armed before spawn, cleared on every `start_js_debugger_thread`
+            // exit; `wait_for_thread_startup` blocks on it so `--inspect`
+            // prints its banner before script output, as Node does.
+            FUTEX_ATOMIC.store(1, Ordering::Relaxed);
             // `std::thread::spawn` requires `Send`; raw `*mut
             // VirtualMachine` is `!Send`. Wrap in a `Send` newtype — the
             // pointer is only ever dereferenced on the debugger thread under
@@ -787,6 +796,15 @@ pub fn debug_end() {
     }
 }
 
+/// `process.binding('inspector').isEnabled()`: whether this thread has an
+/// inspector agent that `process._debugEnd()` has not stopped.
+// HOST_EXPORT(Debugger__isEnabled, c)
+pub fn is_enabled() -> bool {
+    VirtualMachine::get()
+        .debugger_mut()
+        .is_some_and(|dbg| !dbg.debug_ended)
+}
+
 // HOST_EXPORT(Debugger__didConnect, c)
 pub fn did_connect() {
     let this = VirtualMachine::get().as_mut();
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index 55b69838d71..53343b4fb91 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -156,6 +156,9 @@ pub struct VirtualMachine {
     /// `main()`.
     main: bun_ptr::RawSlice<u8>,
     pub main_is_html_entrypoint: bool,
+    /// `bun inspect` / `node inspect`: load the internal debugger CLI module
+    /// instead of resolving `main` as a user entry point.
+    pub main_is_node_inspect: bool,
     pub main_resolved_path: bun_core::String,
     pub main_hash: u32,
     /// Set if code overrides Bun.main to a custom value.
@@ -1970,6 +1973,8 @@ unsafe extern "C" {
     // ABI-identical to a non-null `*mut`); remaining args are by-value scalars.
     // The returned cell pointer is GC-owned (caller checks before deref).
     safe fn Bun__loadHTMLEntryPoint(global: &JSGlobalObject) -> *mut JSInternalPromise;
+    // safe: same contract as `Bun__loadHTMLEntryPoint`.
+    safe fn Bun__loadNodeInspectEntryPoint(global: &JSGlobalObject) -> *mut JSInternalPromise;
     // safe: `ctx` is an opaque round-trip pointer C++ only forwards to `callback`
     // (never dereferenced as Rust data).
     safe fn JSC__VM__holdAPILock(
@@ -2339,7 +2344,7 @@ impl VirtualMachine {
             crate::cpp::Bun__preExecutionBootstrap(self.global());
         }
 
-        if !self.main_is_html_entrypoint {
+        if !self.main_is_html_entrypoint && !self.main_is_node_inspect {
             if let Some(hooks) = hooks {
                 let watch = self.is_watcher_enabled();
                 if !(hooks.generate_entry_point)(self, watch, entry_path) {
@@ -2389,7 +2394,16 @@ impl VirtualMachine {
             // Note: reshaped for borrowck — capture raw ptr before &self call.
             let global = self.global;
             let global_ref = self.global();
-            let promise = if !self.main_is_html_entrypoint {
+            let promise = if self.main_is_node_inspect {
+                let p: *mut JSInternalPromise = jsc::from_js_host_call_generic(global_ref, || {
+                    Bun__loadNodeInspectEntryPoint(global_ref)
+                })
+                .map_err(|_| crate::CrateError::JSError)?;
+                if p.is_null() {
+                    return Err(crate::CrateError::JSError);
+                }
+                p
+            } else if !self.main_is_html_entrypoint {
                 let name = bun_core::String::borrow_utf8(MAIN_FILE_NAME);
                 jsc::JSModuleLoader::load_and_evaluate_module_ptr(global, Some(&name))
                     .map(NonNull::as_ptr)
diff --git a/src/jsc/bindings/BunCPUProfiler.cpp b/src/jsc/bindings/BunCPUProfiler.cpp
index 978ab566049..c9630426354 100644
--- a/src/jsc/bindings/BunCPUProfiler.cpp
+++ b/src/jsc/bindings/BunCPUProfiler.cpp
@@ -360,11 +360,40 @@ void stopCPUProfiler(JSC::VM& vm, WTF::String* outJSON, WTF::String* outText)
         double startTime = s_profilingStartTime;
         double lastTime = s_profilingStartTime;
 
+        // V8 fills time outside JS with (idle) samples (Node drives them from
+        // the event-loop idle callback); JSC records nothing then, so infer
+        // one where the sample gap exceeds an extra sampling period.
+        int idleNodeId = 0;
+        auto appendIdleSampleBefore = [&](double sampleTime) {
+            double gap = sampleTime - lastTime;
+            if (gap <= 2.0 * s_samplingInterval)
+                return;
+            if (!idleNodeId) {
+                idleNodeId = nextNodeId++;
+                ProfileNode idleNode;
+                idleNode.id = idleNodeId;
+                idleNode.functionName = "(idle)"_s;
+                idleNode.url = ""_s;
+                idleNode.scriptId = 0;
+                idleNode.lineNumber = -1;
+                idleNode.columnNumber = -1;
+                idleNode.hitCount = 0;
+                nodes.append(WTF::move(idleNode));
+                nodes[0].children.append(idleNodeId);
+            }
+            nodes[idleNodeId - 1].hitCount++;
+            samples.append(idleNodeId);
+            // The sample that follows keeps one sampling period of its own.
+            timeDeltas.append(static_cast<long long>(gap - s_samplingInterval));
+            lastTime = sampleTime - s_samplingInterval;
+        };
+
         for (size_t idx : sortedIndices) {
             auto& stackTrace = stackTraces[idx];
+            double currentTime = stackTrace.timestamp.approximate<WTF::WallTime>().secondsSinceEpoch().value() * 1000000.0;
+            appendIdleSampleBefore(currentTime);
             if (stackTrace.frames.isEmpty()) {
                 samples.append(1);
-                double currentTime = stackTrace.timestamp.approximate<WTF::WallTime>().secondsSinceEpoch().value() * 1000000.0;
                 double delta = std::max(0.0, currentTime - lastTime);
                 timeDeltas.append(static_cast<long long>(delta));
                 lastTime = currentTime;
@@ -538,7 +567,6 @@ void stopCPUProfiler(JSC::VM& vm, WTF::String* outJSON, WTF::String* outText)
 
             samples.append(currentParentId);
 
-            double currentTime = stackTrace.timestamp.approximate<WTF::WallTime>().secondsSinceEpoch().value() * 1000000.0;
             double delta = std::max(0.0, currentTime - lastTime);
             timeDeltas.append(static_cast<long long>(delta));
             lastTime = currentTime;
diff --git a/src/jsc/bindings/BunDebugger.cpp b/src/jsc/bindings/BunDebugger.cpp
index 12ff3cd6d6b..b0cc0651b4e 100644
--- a/src/jsc/bindings/BunDebugger.cpp
+++ b/src/jsc/bindings/BunDebugger.cpp
@@ -15,6 +15,8 @@
 #include "debug-helpers.h"
 #include "BunInjectedScriptHost.h"
 #include <JavaScriptCore/JSGlobalObjectInspectorController.h>
+#include <JavaScriptCore/ConsoleClient.h>
+#include <JavaScriptCore/ScriptArguments.h>
 #include <wtf/JSONValues.h>
 
 #include "InspectorLifecycleAgent.h"
@@ -989,6 +991,8 @@ static NodeInspectorState& nodeInspectorState()
     return instance.get();
 }
 
+extern "C" void Bun__setProcessDebugPort(uint16_t port);
+
 // Called by internal/debugger.ts on the debugger thread once the node:inspector
 // server is listening (url, controlCallback) or failed to start ("", undefined, error).
 JSC_DECLARE_HOST_FUNCTION(jsFunctionReportNodeInspectorServerStarted);
@@ -1003,6 +1007,14 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionReportNodeInspectorServerStarted, (JSGlobalOb
     String error = callFrame->argument(2).isUndefined() ? String() : callFrame->argument(2).toWTFString(globalObject);
     RETURN_IF_EXCEPTION(scope, {});
 
+    // Node resolves process.debugPort to the bound port once the inspector
+    // server is listening; mirror that for the CLI-started server (the
+    // inspector.open() path assigns process.debugPort from JS instead).
+    if (!url.isEmpty()) {
+        if (auto port = WTF::URL(url).port())
+            Bun__setProcessDebugPort(*port);
+    }
+
     auto& state = nodeInspectorState();
     {
         Locker<Lock> locker(state.lock);
@@ -1140,6 +1152,23 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_waitForNodeInspectorConnection, (JSGlobalObj
     return JSValue::encode(jsUndefined());
 }
 
+// The listening node-inspector server's URL, or null when none is listening.
+// node:inspector cannot cache this: --inspect starts the server on the
+// debugger thread before the module is ever required.
+JSC_DEFINE_HOST_FUNCTION(jsFunction_getNodeInspectorUrl, (JSGlobalObject * globalObject, CallFrame*))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto& state = nodeInspectorState();
+    String url;
+    {
+        Locker<Lock> locker(state.lock);
+        if (!state.serverStarted || state.url.isEmpty())
+            return JSValue::encode(jsNull());
+        url = state.url.isolatedCopy();
+    }
+    return JSValue::encode(jsString(vm, url));
+}
+
 // Dispatches one JSC-protocol message from the in-process Session synchronously and returns
 // the reply + any events as an array of JSON strings. Connects the channel on first use.
 // https://github.com/nodejs/node/blob/main/lib/inspector.js
@@ -1260,6 +1289,142 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_disconnectInProcessInspector, (JSGlobalObjec
     return JSValue::encode(jsUndefined());
 }
 
+// node:inspector's `inspector.console`: inspector-only, no stdio. Call the
+// inspector controller's console client directly (Bun::ConsoleObject would
+// also write to the terminal). https://github.com/nodejs/node/blob/main/lib/inspector.js
+JSC_DEFINE_HOST_FUNCTION(jsFunction_inspectorConsoleCall, (JSGlobalObject * globalObject, CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    uint32_t rawMethod = callFrame->argument(0).toUInt32(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (rawMethod > kLastInspectorConsoleMethod) {
+        throwTypeError(globalObject, scope, "invalid inspector console method"_s);
+        return {};
+    }
+    auto method = static_cast<InspectorConsoleMethod>(rawMethod);
+
+    // Every argument is coerced before the console client is reached, because
+    // a `toString` can run user JS that disconnects the frontend.
+    String label;
+    size_t firstValueArgument = 1;
+    switch (method) {
+    case InspectorConsoleMethod::Count:
+    case InspectorConsoleMethod::CountReset:
+    case InspectorConsoleMethod::Time:
+    case InspectorConsoleMethod::TimeLog:
+    case InspectorConsoleMethod::TimeEnd:
+        // JSC's console spells the omitted label this way too.
+        label = callFrame->argument(1).isUndefined() ? "default"_s : callFrame->argument(1).toWTFString(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        firstValueArgument = 2;
+        break;
+    case InspectorConsoleMethod::Profile:
+    case InspectorConsoleMethod::ProfileEnd:
+        label = callFrame->argument(1).isUndefined() ? String() : callFrame->argument(1).toWTFString(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        firstValueArgument = 2;
+        break;
+    case InspectorConsoleMethod::Assert: {
+        bool condition = callFrame->argument(1).toBoolean(globalObject);
+        // console.assert only reports when the assertion failed.
+        if (condition)
+            return JSValue::encode(jsUndefined());
+        firstValueArgument = 2;
+        break;
+    }
+    default:
+        break;
+    }
+
+    if (!globalObject->inspectable())
+        return JSValue::encode(jsUndefined());
+    auto client = globalObject->inspectorController().consoleClient();
+    if (!client)
+        return JSValue::encode(jsUndefined());
+
+    Vector<JSC::Strong<JSC::Unknown>> values;
+    size_t argumentCount = callFrame->argumentCount();
+    if (argumentCount > firstValueArgument) {
+        values.reserveInitialCapacity(argumentCount - firstValueArgument);
+        for (size_t i = firstValueArgument; i < argumentCount; i++)
+            values.append(JSC::Strong<JSC::Unknown>(vm, callFrame->uncheckedArgument(i)));
+    }
+    Ref<Inspector::ScriptArguments> arguments = Inspector::ScriptArguments::create(globalObject, WTF::move(values));
+
+    switch (method) {
+    case InspectorConsoleMethod::Log:
+        client->logWithLevel(globalObject, WTF::move(arguments), MessageLevel::Log);
+        break;
+    case InspectorConsoleMethod::Info:
+        client->logWithLevel(globalObject, WTF::move(arguments), MessageLevel::Info);
+        break;
+    case InspectorConsoleMethod::Debug:
+        client->logWithLevel(globalObject, WTF::move(arguments), MessageLevel::Debug);
+        break;
+    case InspectorConsoleMethod::Warn:
+        client->logWithLevel(globalObject, WTF::move(arguments), MessageLevel::Warning);
+        break;
+    case InspectorConsoleMethod::Error:
+        client->logWithLevel(globalObject, WTF::move(arguments), MessageLevel::Error);
+        break;
+    case InspectorConsoleMethod::Dir:
+        client->dir(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::DirXML:
+        client->dirXML(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::Table:
+        client->table(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::Trace:
+        client->trace(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::Clear:
+        client->clear(globalObject);
+        break;
+    case InspectorConsoleMethod::Assert:
+        client->assertion(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::Group:
+        client->group(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::GroupCollapsed:
+        client->groupCollapsed(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::GroupEnd:
+        client->groupEnd(globalObject, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::Count:
+        client->count(globalObject, label);
+        break;
+    case InspectorConsoleMethod::CountReset:
+        client->countReset(globalObject, label);
+        break;
+    case InspectorConsoleMethod::Profile:
+        client->profile(globalObject, label);
+        break;
+    case InspectorConsoleMethod::ProfileEnd:
+        client->profileEnd(globalObject, label);
+        break;
+    case InspectorConsoleMethod::Time:
+        client->time(globalObject, label);
+        break;
+    case InspectorConsoleMethod::TimeLog:
+        client->timeLog(globalObject, label, WTF::move(arguments));
+        break;
+    case InspectorConsoleMethod::TimeEnd:
+        client->timeEnd(globalObject, label);
+        break;
+    case InspectorConsoleMethod::TimeStamp:
+        client->timeStamp(globalObject, WTF::move(arguments));
+        break;
+    }
+
+    return JSValue::encode(jsUndefined());
+}
+
 // Forwards a control message (close, breakpoint forwarded from the in-process
 // Session, ...) from the main thread to the node-inspector server running on
 // the debugger thread. Returns false when no server is active.
diff --git a/src/jsc/bindings/BunDebugger.h b/src/jsc/bindings/BunDebugger.h
index 57441092750..6828006c305 100644
--- a/src/jsc/bindings/BunDebugger.h
+++ b/src/jsc/bindings/BunDebugger.h
@@ -14,5 +14,36 @@ JSC_DECLARE_HOST_FUNCTION(jsFunction_closeNodeInspector);
 JSC_DECLARE_HOST_FUNCTION(jsFunction_dispatchInProcessInspectorMessage);
 JSC_DECLARE_HOST_FUNCTION(jsFunction_drainInProcessInspectorMessages);
 JSC_DECLARE_HOST_FUNCTION(jsFunction_disconnectInProcessInspector);
+JSC_DECLARE_HOST_FUNCTION(jsFunction_getNodeInspectorUrl);
+
+// The methods of node:inspector's `inspector.console`, mirrored by
+// InspectorConsoleMethod in src/js/node/inspector.ts. Keep both in sync.
+enum class InspectorConsoleMethod : uint32_t {
+    Log = 0,
+    Info,
+    Debug,
+    Warn,
+    Error,
+    Dir,
+    DirXML,
+    Table,
+    Trace,
+    Clear,
+    Assert,
+    Group,
+    GroupCollapsed,
+    GroupEnd,
+    Count,
+    CountReset,
+    Profile,
+    ProfileEnd,
+    Time,
+    TimeLog,
+    TimeEnd,
+    TimeStamp,
+};
+static constexpr uint32_t kLastInspectorConsoleMethod = static_cast<uint32_t>(InspectorConsoleMethod::TimeStamp);
+
+JSC_DECLARE_HOST_FUNCTION(jsFunction_inspectorConsoleCall);
 
 } // namespace Bun
diff --git a/src/jsc/bindings/BunProcess.cpp b/src/jsc/bindings/BunProcess.cpp
index 83c62f8016c..eb6bbca278d 100644
--- a/src/jsc/bindings/BunProcess.cpp
+++ b/src/jsc/bindings/BunProcess.cpp
@@ -3331,6 +3331,23 @@ inline JSValue processBindingConfig(Zig::GlobalObject* globalObject, JSC::VM& vm
     return config;
 }
 
+extern "C" bool Debugger__isEnabled();
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionInspectorIsEnabled, (JSGlobalObject*, CallFrame*))
+{
+    return JSValue::encode(jsBoolean(Debugger__isEnabled()));
+}
+
+// Only `isEnabled` is exposed: the rest of Node's internal inspector binding
+// is reachable as public `node:inspector` API, and a stub that answered for
+// methods Bun does not implement would be worse than the missing property.
+inline JSValue processBindingInspector(Zig::GlobalObject* globalObject, JSC::VM& vm)
+{
+    auto* binding = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
+    binding->putDirect(vm, JSC::Identifier::fromString(vm, "isEnabled"_s), JSC::JSFunction::create(vm, globalObject, 0, String("isEnabled"_s), jsFunctionInspectorIsEnabled, ImplementationVisibility::Public), 0);
+    return binding;
+}
+
 JSValue createCryptoX509Object(JSGlobalObject* globalObject)
 {
     auto& vm = JSC::getVM(globalObject);
@@ -3360,7 +3377,7 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionBinding, (JSGlobalObject * jsGlobalObje
     if (moduleName == "fs_event_wrap"_s) PROCESS_BINDING_NOT_IMPLEMENTED("fs_event_wrap");
     if (moduleName == "http_parser"_s) return JSValue::encode(globalObject->processBindingHTTPParser());
     if (moduleName == "icu"_s) PROCESS_BINDING_NOT_IMPLEMENTED("icu");
-    if (moduleName == "inspector"_s) PROCESS_BINDING_NOT_IMPLEMENTED("inspector");
+    if (moduleName == "inspector"_s) return JSValue::encode(processBindingInspector(globalObject, vm));
     if (moduleName == "js_stream"_s) PROCESS_BINDING_NOT_IMPLEMENTED("js_stream");
     if (moduleName == "natives"_s) return JSValue::encode(process->bindingNatives());
     if (moduleName == "os"_s) PROCESS_BINDING_NOT_IMPLEMENTED("os");
@@ -4190,6 +4207,14 @@ static JSValue constructFeatures(VM& vm, JSObject* processObject)
 
 static uint16_t debugPort = 9229;
 
+// The CLI inspector server binds on the debugger thread; once it is listening
+// it reports the resolved port here so process.debugPort reflects it, as in
+// Node. https://github.com/nodejs/node/blob/v26.3.0/lib/internal/process/pre_execution.js (updates via the inspector)
+extern "C" void Bun__setProcessDebugPort(uint16_t port)
+{
+    debugPort = port;
+}
+
 JSC_DEFINE_CUSTOM_GETTER(processDebugPort, (JSC::JSGlobalObject * globalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
 {
     return JSC::JSValue::encode(jsNumber(debugPort));
diff --git a/src/jsc/bindings/ErrorCode.ts b/src/jsc/bindings/ErrorCode.ts
index b36ab04d45c..2337f3af787 100644
--- a/src/jsc/bindings/ErrorCode.ts
+++ b/src/jsc/bindings/ErrorCode.ts
@@ -65,6 +65,8 @@ const errors: ErrorCodeMapping = [
   ["ERR_CRYPTO_UNKNOWN_CIPHER", Error],
   ["ERR_CRYPTO_UNKNOWN_DH_GROUP", Error],
   ["ERR_CRYPTO_UNSUPPORTED_OPERATION", Error],
+  ["ERR_DEBUGGER_ERROR", Error],
+  ["ERR_DEBUGGER_STARTUP_ERROR", Error],
   ["ERR_DIR_CLOSED", Error],
   ["ERR_DLOPEN_DISABLED", Error],
   ["ERR_DLOPEN_FAILED", Error],
diff --git a/src/jsc/bindings/HTMLEntryPoint.cpp b/src/jsc/bindings/HTMLEntryPoint.cpp
index 95d5d987b1b..4ab0fc2c7a5 100644
--- a/src/jsc/bindings/HTMLEntryPoint.cpp
+++ b/src/jsc/bindings/HTMLEntryPoint.cpp
@@ -30,7 +30,7 @@ extern "C" JSPromise* Bun__loadHTMLEntryPoint(Zig::GlobalObject* globalObject)
     }
 
     if (result.isUndefined()) {
-        return JSPromise::resolvedPromise(globalObject, result);
+        RELEASE_AND_RETURN(scope, JSPromise::resolvedPromise(globalObject, result));
     }
 
     JSPromise* promise = dynamicDowncast<JSC::JSPromise>(result);
diff --git a/src/jsc/bindings/NodeInspectEntryPoint.cpp b/src/jsc/bindings/NodeInspectEntryPoint.cpp
new file mode 100644
index 00000000000..385636d724f
--- /dev/null
+++ b/src/jsc/bindings/NodeInspectEntryPoint.cpp
@@ -0,0 +1,49 @@
+#include "root.h"
+
+#include "JavaScriptCore/CallData.h"
+#include <JavaScriptCore/ObjectConstructor.h>
+#include "InternalModuleRegistry.h"
+#include "ModuleLoader.h"
+#include "ZigGlobalObject.h"
+#include <JavaScriptCore/JSPromise.h>
+namespace Bun {
+using namespace JSC;
+
+// Entry point for `bun inspect` / `node inspect`: instead of loading a user
+// script, require the internal debugger CLI module and call its start().
+extern "C" JSPromise* Bun__loadNodeInspectEntryPoint(Zig::GlobalObject* globalObject)
+{
+    auto& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSValue inspectModule = globalObject->internalModuleRegistry()->requireId(globalObject, vm, InternalModuleRegistry::InternalDebuggerInspect);
+    if (scope.exception()) [[unlikely]] {
+        return JSPromise::rejectedPromiseWithCaughtException(globalObject, scope);
+    }
+
+    JSObject* inspectModuleObject = inspectModule.getObject();
+    if (!inspectModuleObject) [[unlikely]] {
+        BUN_PANIC("Failed to load node inspect entry point");
+    }
+
+    JSValue startFunction = inspectModuleObject->get(globalObject, Identifier::fromString(vm, "start"_s));
+    RETURN_IF_EXCEPTION(scope, JSPromise::rejectedPromiseWithCaughtException(globalObject, scope));
+
+    JSObject* startObject = startFunction.getObject();
+    if (!startObject) [[unlikely]] {
+        BUN_PANIC("Failed to load node inspect entry point");
+    }
+
+    MarkedArgumentBuffer args;
+    JSValue result = JSC::call(globalObject, startObject, args, "Failed to start node inspect"_s);
+    if (scope.exception()) [[unlikely]] {
+        return JSPromise::rejectedPromiseWithCaughtException(globalObject, scope);
+    }
+
+    if (JSPromise* promise = dynamicDowncast<JSC::JSPromise>(result)) {
+        return promise;
+    }
+    RELEASE_AND_RETURN(scope, JSPromise::resolvedPromise(globalObject, jsUndefined()));
+}
+
+}
diff --git a/src/options_types/context.rs b/src/options_types/context.rs
index 32068217f6f..71cd071d2b6 100644
--- a/src/options_types/context.rs
+++ b/src/options_types/context.rs
@@ -556,6 +556,9 @@ pub struct RuntimeOptions {
     pub cron_period: Box<[u8]>,
     pub cpu_prof: CpuProf,
     pub heap_prof: HeapProf,
+    /// `bun inspect` / `node inspect`: boot the internal debugger CLI instead
+    /// of resolving the first positional as an entry point.
+    pub node_inspect_cli: bool,
 }
 
 #[derive(Default)]
@@ -623,6 +626,7 @@ impl Default for RuntimeOptions {
             cron_period: Box::default(),
             cpu_prof: CpuProf::default(),
             heap_prof: HeapProf::default(),
+            node_inspect_cli: false,
         }
     }
 }
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index 6dec4f9c937..a1d9618f56f 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -185,6 +185,9 @@ const RUNTIME_PARAMS_: &[ParamType] = &[
     parse_param!(
         "--inspect-brk <STR>?              Activate Bun's debugger, set breakpoint on first line of code and wait"
     ),
+    parse_param!(
+        "--inspect-port <STR>              Set the [host:]port used by the debugger and reported by process.debugPort"
+    ),
     parse_param!(
         "--cpu-prof                        Start CPU profiler and write profile to disk on exit"
     ),
@@ -302,6 +305,10 @@ const RUNTIME_PARAMS_: &[ParamType] = &[
     parse_param!("--trace-exit"),
     parse_param!("--expose-internals"),
     parse_param!("--stack-trace-limit <STR>"),
+    // Rejected below with Node's DEP0062 message. Declared so `--debug=<port>`
+    // does not swallow the entrypoint before the rejection runs.
+    parse_param!("--debug <STR>?"),
+    parse_param!("--debug-brk <STR>?"),
 ];
 
 const AUTO_OR_RUN_PARAMS: &[ParamType] = &[
@@ -1159,6 +1166,16 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             Global::exit(1);
         }
 
+        // Node exits 9 on `--debug`/`--debug-brk` (DEP0062).
+        // https://github.com/nodejs/node/blob/v26.3.0/src/node_options.cc#L56-L60
+        if args.option(b"--debug").is_some() || args.option(b"--debug-brk").is_some() {
+            Output::err_generic(
+                "[DEP0062]: `node --debug` and `node --debug-brk` are invalid. Please use `node --inspect` and `node --inspect-brk` instead.",
+                (),
+            );
+            Global::exit(9);
+        }
+
         if let Some(inspect_flag) = args.option(b"--inspect") {
             ctx.runtime_options.debugger = if inspect_flag.is_empty() {
                 Debugger::Enable(Default::default())
@@ -1198,6 +1215,31 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             };
         }
 
+        unsafe extern "C" {
+            // Defined in BunProcess.cpp; backs process.debugPort.
+            fn Bun__setProcessDebugPort(port: u16);
+        }
+        // Node's --inspect-port=[host:]port: process.debugPort always, and the
+        // active `--inspect*` listener's port unless `--inspect=<port>` set
+        // one. https://github.com/nodejs/node/blob/main/src/node_options.cc
+        if let Some(inspect_port_flag) = args.option(b"--inspect-port") {
+            let port_bytes = match inspect_port_flag.iter().rposition(|&byte| byte == b':') {
+                Some(at) => &inspect_port_flag[at + 1..],
+                None => inspect_port_flag,
+            };
+            if let Ok(port) = core::str::from_utf8(port_bytes)
+                .unwrap_or("")
+                .parse::<u16>()
+            {
+                unsafe { Bun__setProcessDebugPort(port) };
+                if let Debugger::Enable(ref mut enable) = ctx.runtime_options.debugger {
+                    if enable.path_or_port.is_empty() {
+                        enable.path_or_port = Box::<[u8]>::from(inspect_port_flag);
+                    }
+                }
+            }
+        }
+
         let cpu_prof_flag = args.flag(b"--cpu-prof");
         let cpu_prof_md_flag = args.flag(b"--cpu-prof-md");
 
diff --git a/src/runtime/cli/mod.rs b/src/runtime/cli/mod.rs
index cebb8c8d6d4..b0b9a42dfed 100644
--- a/src/runtime/cli/mod.rs
+++ b/src/runtime/cli/mod.rs
@@ -1465,6 +1465,13 @@ pub mod command {
             }
         }
 
+        // `bun inspect [...]` launches the Node-compatible CLI debugger, like
+        // `node inspect`. Only the bare `bun inspect` form is special-cased;
+        // `bun run inspect` still resolves a package.json script of that name.
+        if tag == Tag::AutoCommand && ctx.positionals.first().is_some_and(|p| &**p == b"inspect") {
+            return run_command::RunCommand::exec_inspect(ctx);
+        }
+
         if !ctx.positionals.is_empty() {
             let cfg = run_command::ExecCfg {
                 bin_dirs_only: tag == Tag::AutoCommand,
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index fb001d360ae..c2a3d35be38 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -1079,6 +1079,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
         vm.main_is_html_entrypoint = loader
             .unwrap_or_else(|| vm.transpiler.options.loader(paths::extension(entry)))
             == Loader::Html;
+        vm.main_is_node_inspect = ctx.runtime_options.node_inspect_cli;
 
         // ── enter `Run::start` under the JSC API lock ──────────────────────
         // SAFETY: `RUN` is the process-global singleton;
@@ -2970,6 +2971,14 @@ impl RunCommand {
         Self::boot(ctx, entry, None)
     }
 
+    /// `bun inspect [...]` / `node inspect [...]` — the Node-compatible CLI
+    /// debugger. Boots the VM with `internal/debugger/inspect` as the entry
+    /// point instead of a user script.
+    pub(crate) fn exec_inspect(ctx: &mut ContextData) -> crate::Result<()> {
+        ctx.runtime_options.node_inspect_cli = true;
+        Self::boot(ctx, Box::from(&b"inspect"[..]), None)
+    }
+
     /// `node` argv0 emulation. Port of `execAsIfNode`.
     pub(crate) fn exec_as_if_node(ctx: &mut ContextData) -> crate::Result<()> {
         // SAFETY: single-threaded CLI startup; `PRETEND_TO_BE_NODE` is set in
@@ -3016,6 +3025,12 @@ impl RunCommand {
             Self::exec_as_if_node_missing_script();
         }
 
+        // `node inspect [...]` launches the CLI debugger rather than running a
+        // script named "inspect".
+        if &*ctx.positionals[0] == b"inspect" {
+            return Self::exec_inspect(ctx);
+        }
+
         // borrowck — `boot_and_handle_error` takes `&mut ctx`, so
         // dupe the positional out before the call.
         let filename: Box<[u8]> = ctx.positionals[0].clone();
diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs
index 1a5f86b7ec8..5aad1a95a84 100644
--- a/src/runtime/jsc_hooks.rs
+++ b/src/runtime/jsc_hooks.rs
@@ -883,6 +883,10 @@ unsafe fn ensure_debugger(vm: *mut VirtualMachine, block_until_connected: bool)
         bun_core::Output::err("Debugger", "{}", format_args!("create failed: {e:?}"));
         return;
     }
+    // Hold until the inspector server is up even without a connection wait:
+    // Node binds synchronously, so the banner precedes script output and
+    // process.debugPort is resolved before the first user statement.
+    bun_jsc::debugger::Debugger::wait_for_thread_startup();
     if block_until_connected {
         bun_jsc::debugger::Debugger::wait_for_debugger_if_necessary(vm);
     }
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index ad1d2c403f5..53baa647f1e 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -381,7 +381,10 @@ it("process.binding", () => {
   expect(() => process.binding("fs_event_wrap")).toThrow();
   expect(() => process.binding("http_parser")).not.toThrow();
   expect(() => process.binding("icu")).toThrow();
-  expect(() => process.binding("inspector")).toThrow();
+  // Only isEnabled() is implemented; test-inspector-enabled.js covers what it
+  // reports under --inspect and after process._debugEnd().
+  expect(() => process.binding("inspector")).not.toThrow();
+  expect(process.binding("inspector").isEnabled).toBeInstanceOf(Function);
   expect(() => process.binding("js_stream")).toThrow();
   expect(() => process.binding("natives")).not.toThrow();
   expect(() => process.binding("os")).toThrow();
diff --git a/test/js/node/test/common/debugger-probe.js b/test/js/node/test/common/debugger-probe.js
new file mode 100644
index 00000000000..c2ed825a260
--- /dev/null
+++ b/test/js/node/test/common/debugger-probe.js
@@ -0,0 +1,85 @@
+'use strict';
+
+const assert = require('assert');
+
+// Work around a pre-existing inspector issue: if the debuggee exits too quickly
+// the inspector can segfault while tearing down. For now normalize the segfault
+// back to the expected terminal event (e.g. "completed" or "miss")
+// until the upstream bug is fixed.
+// See https://github.com/nodejs/node/issues/62765
+// https://github.com/nodejs/node/issues/58245
+const probeTargetExitSignal = 'SIGSEGV';
+
+function isProbeSegvTeardown(result) {
+  if (result?.event !== 'error') { return false; }
+  const error = result.error;
+  if (error?.signal !== probeTargetExitSignal) { return false; }
+  return error.code === 'probe_target_exit' || error.code === 'probe_failure';
+}
+
+function findProbeSegvTeardownLine(output) {
+  const signalPrefix = `Target exited with signal ${probeTargetExitSignal}`;
+  if (output.startsWith(signalPrefix)) { return 0; }
+  const idx = output.indexOf(`\n${signalPrefix}`);
+  return idx === -1 ? -1 : idx + 1;
+}
+
+// Replace volatile fields in a probe report (stack frames, Node.js version,
+// scriptId, callFrames) with stable placeholders for deepStrictEqual.
+function normalizeProbeReport(value) {
+  if (typeof value === 'string') {
+    return value
+      .replace(/(?:\n[ \t]+at\s[^\n]*)+/g, '\n<stack>')
+      .replace(/\nNode\.js v[^\n]+/g, '\nNode.js <version>');
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeProbeReport);
+  }
+  if (value !== null && typeof value === 'object') {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      if (key === 'scriptId') {
+        result[key] = '<scriptId>';
+      } else if (key === 'callFrames') {
+        result[key] = '<callFrames>';
+      } else {
+        result[key] = normalizeProbeReport(value[key]);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+
+function assertProbeJson(output, expected) {
+  const normalized = typeof output === 'string' ? JSON.parse(output) : output;
+  const lastResult = normalized.results?.[normalized.results.length - 1];
+
+  if (isProbeSegvTeardown(lastResult)) {
+    // Log to facilitate debugging if this normalization is occurring.
+    console.log('Normalizing trailing SIGSEGV in JSON probe output');
+    normalized.results[normalized.results.length - 1] = expected.results.at(-1);
+  }
+
+  assert.deepStrictEqual(normalizeProbeReport(normalized), normalizeProbeReport(expected));
+}
+
+function assertProbeText(output, expected) {
+  const lineStart = findProbeSegvTeardownLine(output);
+  let normalized;
+  if (lineStart !== -1) {
+    // Log to facilitate debugging if this normalization is occurring.
+    console.log('Normalizing trailing SIGSEGV in text probe output');
+    const expectedLineStart = expected.lastIndexOf('\n');
+    const terminalLine = expectedLineStart === -1 ? expected : expected.slice(expectedLineStart + 1);
+    normalized = lineStart === 0 ? terminalLine : `${output.slice(0, lineStart - 1)}\n${terminalLine}`;
+  } else {
+    normalized = output;
+  }
+  assert.strictEqual(normalized, expected);
+}
+
+module.exports = {
+  assertProbeJson,
+  assertProbeText,
+};
diff --git a/test/js/node/test/common/inspector-helper.js b/test/js/node/test/common/inspector-helper.js
index 864538f245e..895e4c77972 100644
--- a/test/js/node/test/common/inspector-helper.js
+++ b/test/js/node/test/common/inspector-helper.js
@@ -6,7 +6,7 @@ const http = require('http');
 const fixtures = require('../common/fixtures');
 const { spawn } = require('child_process');
 const { URL, pathToFileURL } = require('url');
-const { EventEmitter } = require('events');
+const { EventEmitter, once } = require('events');
 
 const _MAINSCRIPT = fixtures.path('loop.js');
 const DEBUG = false;
@@ -544,6 +544,34 @@ function fires(promise, error, timeoutMs) {
   ]);
 }
 
+/**
+ * When waiting for inspector events, there might be no handles on the event
+ * loop, and leads to process exits.
+ *
+ * This function provides a utility to wait until a inspector event for a certain
+ * time.
+ * @returns {Promise}
+ */
+function waitUntil(session, eventName, timeout = 1000) {
+  const resolvers = Promise.withResolvers();
+  const timer = setTimeout(() => {
+    resolvers.reject(new Error(`Wait for inspector event ${eventName} timed out`));
+  }, timeout);
+
+  once(session, eventName)
+    .then((res) => {
+      resolvers.resolve(res);
+      clearTimeout(timer);
+    }, (error) => {
+      // This should never happen.
+      resolvers.reject(error);
+      clearTimeout(timer);
+    });
+
+  return resolvers.promise;
+}
+
 module.exports = {
   NodeInstance,
+  waitUntil,
 };
diff --git a/test/js/node/test/fixtures/debugger/probe-bound-never-hit.js b/test/js/node/test/fixtures/debugger/probe-bound-never-hit.js
new file mode 100644
index 00000000000..65277d09c8f
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-bound-never-hit.js
@@ -0,0 +1,10 @@
+'use strict';
+
+function neverCalled() {
+  console.log('unreachable');
+  console.log('also unreachable');
+  console.log('still unreachable');
+}
+
+console.log('reached');
+module.exports = neverCalled;  // Keep the function alive.
diff --git a/test/js/node/test/fixtures/debugger/probe-exits-during-probe.js b/test/js/node/test/fixtures/debugger/probe-exits-during-probe.js
new file mode 100644
index 00000000000..7bed0703f90
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-exits-during-probe.js
@@ -0,0 +1,8 @@
+'use strict';
+
+function exitDuringProbe() {
+  process.exit(0);
+}
+
+module.exports = { exitDuringProbe };
+globalThis.probeLine = 1;
diff --git a/test/js/node/test/fixtures/debugger/probe-indented.js b/test/js/node/test/fixtures/debugger/probe-indented.js
new file mode 100644
index 00000000000..3d05242a3ba
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-indented.js
@@ -0,0 +1,10 @@
+'use strict';
+
+function run() {
+  let x = 0;
+  // The first executable column is past column 1.
+  x = 42;
+  return x;
+}
+
+run();
diff --git a/test/js/node/test/fixtures/debugger/probe-late-entry.js b/test/js/node/test/fixtures/debugger/probe-late-entry.js
new file mode 100644
index 00000000000..2e8350bd7a2
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-late-entry.js
@@ -0,0 +1,7 @@
+'use strict';
+
+import('./probe-late-target.cjs').then(({ add }) => {
+  const result = add(3, 2);
+  const { multiply } = require('./probe-late-target.mjs');
+  console.log(multiply(result, 4));
+});
diff --git a/test/js/node/test/fixtures/debugger/probe-late-target.cjs b/test/js/node/test/fixtures/debugger/probe-late-target.cjs
new file mode 100644
index 00000000000..0e324b1a7da
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-late-target.cjs
@@ -0,0 +1,7 @@
+'use strict';
+
+exports.add = function(a, b) {
+  let value = a;
+  value += b;
+  return value;
+};
diff --git a/test/js/node/test/fixtures/debugger/probe-late-target.mjs b/test/js/node/test/fixtures/debugger/probe-late-target.mjs
new file mode 100644
index 00000000000..832a16e8fcb
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-late-target.mjs
@@ -0,0 +1,5 @@
+export function multiply(a, b) {
+  let value = a;
+  value *= b;
+  return value;
+}
diff --git a/test/js/node/test/fixtures/debugger/probe-miss.js b/test/js/node/test/fixtures/debugger/probe-miss.js
new file mode 100644
index 00000000000..1b647114a6e
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-miss.js
@@ -0,0 +1,5 @@
+'use strict';
+
+function neverCalled() {
+  console.log('unreachable');
+}
diff --git a/test/js/node/test/fixtures/debugger/probe-multi-a/utils.js b/test/js/node/test/fixtures/debugger/probe-multi-a/utils.js
new file mode 100644
index 00000000000..0e324b1a7da
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-multi-a/utils.js
@@ -0,0 +1,7 @@
+'use strict';
+
+exports.add = function(a, b) {
+  let value = a;
+  value += b;
+  return value;
+};
diff --git a/test/js/node/test/fixtures/debugger/probe-multi-b/utils.js b/test/js/node/test/fixtures/debugger/probe-multi-b/utils.js
new file mode 100644
index 00000000000..786ddaef1a7
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-multi-b/utils.js
@@ -0,0 +1,7 @@
+'use strict';
+
+exports.multiply = function(a, b) {
+  let value = a;
+  value *= b;
+  return value;
+};
diff --git a/test/js/node/test/fixtures/debugger/probe-multi-entry.js b/test/js/node/test/fixtures/debugger/probe-multi-entry.js
new file mode 100644
index 00000000000..3eef08774e9
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-multi-entry.js
@@ -0,0 +1,6 @@
+'use strict';
+
+const { add } = require('./probe-multi-a/utils');
+const { multiply } = require('./probe-multi-b/utils');
+
+multiply(add(1, 2), 3);
diff --git a/test/js/node/test/fixtures/debugger/probe-multi-statement.js b/test/js/node/test/fixtures/debugger/probe-multi-statement.js
new file mode 100644
index 00000000000..e014edbe111
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-multi-statement.js
@@ -0,0 +1,7 @@
+'use strict';
+
+const acc = [];
+function fill() {
+  acc.push(1); acc.push(2); acc.push(3);
+}
+fill();
diff --git a/test/js/node/test/fixtures/debugger/probe-throwing-getter.js b/test/js/node/test/fixtures/debugger/probe-throwing-getter.js
new file mode 100644
index 00000000000..906e464f98d
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-throwing-getter.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const holder = {
+  get throwingGetter() {
+    throw new Error('boom');
+  },
+};
+
+let probesDone = false;
+function markProbesDone() {
+  probesDone = true;
+}
+
+module.exports = { holder, markProbesDone };
+
+globalThis.probeLine1 = 1;
+globalThis.probeLine2 = 2;
+
+const interval = setInterval(() => {
+  if (probesDone) clearInterval(interval);
+}, 50);
diff --git a/test/js/node/test/fixtures/debugger/probe-timeout.js b/test/js/node/test/fixtures/debugger/probe-timeout.js
new file mode 100644
index 00000000000..8894305e3d9
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-timeout.js
@@ -0,0 +1,7 @@
+'use strict';
+
+function neverCalled() {
+  console.log('never');
+}
+
+setInterval(() => {}, 1000);
diff --git a/test/js/node/test/fixtures/debugger/probe-types.js b/test/js/node/test/fixtures/debugger/probe-types.js
new file mode 100644
index 00000000000..9ca45b69684
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe-types.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const stringValue = 'hello';
+const booleanValue = true;
+const undefinedValue = undefined;
+const nullValue = null;
+const nanValue = NaN;
+const bigintValue = 1n;
+const symbolValue = Symbol('tag');
+const functionValue = () => 1;
+const objectValue = { alpha: 1, beta: 'two' };
+const arrayValue = [1, 'two', 3];
+const errorValue = new Error('boom');
+errorValue.stack = 'Error: boom';
+
+function consume() {}
+consume();
diff --git a/test/js/node/test/fixtures/debugger/probe.js b/test/js/node/test/fixtures/debugger/probe.js
new file mode 100644
index 00000000000..a847c7af62f
--- /dev/null
+++ b/test/js/node/test/fixtures/debugger/probe.js
@@ -0,0 +1,12 @@
+'use strict';
+
+console.log('probe stdout');
+console.error('probe stderr');
+
+let total = 0;
+for (let index = 0; index < 2; index++) {
+  total += index + 40;
+}
+
+const finalValue = total;
+console.log(finalValue);
diff --git a/test/js/node/test/parallel/test-debugger-address.mjs b/test/js/node/test/parallel/test-debugger-address.mjs
new file mode 100644
index 00000000000..c159ff2094e
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-address.mjs
@@ -0,0 +1,71 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+import { spawn } from 'child_process';
+
+// NOTE(oyyd): We might want to import this regexp from "lib/_inspect.js"?
+const kDebuggerMsgReg = /Debugger listening on ws:\/\/\[?(.+?)\]?:(\d+)\//;
+
+function launchTarget(...args) {
+  const childProc = spawn(process.execPath, args);
+  return new Promise((resolve, reject) => {
+    const onExit = () => {
+      reject(new Error('Child process exits unexpectedly'));
+    };
+    childProc.on('exit', onExit);
+    childProc.stderr.setEncoding('utf8');
+    let data = '';
+    childProc.stderr.on('data', (chunk) => {
+      data += chunk;
+      const ret = kDebuggerMsgReg.exec(data);
+      childProc.removeListener('exit', onExit);
+      if (ret) {
+        resolve({
+          childProc,
+          host: ret[1],
+          port: ret[2],
+        });
+      }
+    });
+  });
+}
+
+{
+  const script = fixtures.path('debugger/alive.js');
+  let cli = null;
+  let target = null;
+
+  function cleanup(error) {
+    if (cli) {
+      cli.quit();
+      cli = null;
+    }
+    if (target) {
+      target.kill();
+      target = null;
+    }
+    assert.ifError(error);
+  }
+
+  try {
+    const { childProc, host, port } = await launchTarget('--inspect=0', script);
+    target = childProc;
+    cli = startCLI([`${host || '127.0.0.1'}:${port}`], [], {}, { randomPort: false });
+    await cli.waitForPrompt();
+    await cli.command('sb("alive.js", 3)');
+    await cli.waitFor(/break/);
+    await cli.waitForPrompt();
+    assert.match(
+      cli.output,
+      /> 3 {3}\+\+x;/,
+      'marks the 3rd line'
+    );
+  } finally {
+    cleanup();
+  }
+}
diff --git a/test/js/node/test/parallel/test-debugger-auto-resume.mjs b/test/js/node/test/parallel/test-debugger-auto-resume.mjs
new file mode 100644
index 00000000000..f8dbf3be583
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-auto-resume.mjs
@@ -0,0 +1,33 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+import { addLibraryPath } from '../common/shared-lib-util.js';
+
+import assert from 'assert';
+import { relative } from 'path';
+
+addLibraryPath(process.env);
+
+// Auto-resume on start if the environment variable is defined.
+{
+  const scriptFullPath = fixtures.path('debugger', 'break.js');
+  const script = relative(process.cwd(), scriptFullPath);
+
+  const env = {
+    ...process.env,
+  };
+  env.NODE_INSPECT_RESUME_ON_START = '1';
+
+  const cli = startCLI([script], [], { env });
+
+  await cli.waitForInitialBreak();
+  assert.deepStrictEqual(cli.breakInfo, {
+    filename: script,
+    line: 10,
+  });
+  const code = await cli.quit();
+  assert.strictEqual(code, 0);
+}
diff --git a/test/js/node/test/parallel/test-debugger-breakpoint-exists.js b/test/js/node/test/parallel/test-debugger-breakpoint-exists.js
new file mode 100644
index 00000000000..e2efa8182e4
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-breakpoint-exists.js
@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+// Test for "Breakpoint at specified location already exists" error.
+const script = fixtures.path('debugger', 'three-lines.js');
+const cli = startCLI([script]);
+
+(async () => {
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    await cli.command('setBreakpoint(1)');
+    await cli.command('setBreakpoint(1)');
+    await cli.waitFor(/Breakpoint at specified location already exists/);
+  } finally {
+    await cli.quit();
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-clear-breakpoints.js b/test/js/node/test/parallel/test-debugger-clear-breakpoints.js
new file mode 100644
index 00000000000..91349e105a1
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-clear-breakpoints.js
@@ -0,0 +1,53 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// clearBreakpoint
+{
+  const scriptFullPath = fixtures.path('debugger', 'break.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('sb("break.js", 3)'))
+    .then(() => cli.command('sb("break.js", 9)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      assert.ok(cli.output.includes(`#0 ${script}:3`));
+      assert.ok(cli.output.includes(`#1 ${script}:9`));
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 4)'))
+    .then(() => {
+      assert.match(cli.output, /Could not find breakpoint/);
+    })
+    .then(() => cli.command('clearBreakpoint("not-such-script.js", 3)'))
+    .then(() => {
+      assert.match(cli.output, /Could not find breakpoint/);
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 3)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      assert.ok(cli.output.includes(`#0 ${script}:9`));
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      assert.ok(
+        cli.output.includes(`break in ${script}:9`),
+        'hits the 2nd breakpoint because the 1st was cleared');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/js/node/test/parallel/test-debugger-exceptions.js b/test/js/node/test/parallel/test-debugger-exceptions.js
new file mode 100644
index 00000000000..27818612301
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-exceptions.js
@@ -0,0 +1,64 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// Break on (uncaught) exceptions.
+{
+  const scriptFullPath = fixtures.path('debugger', 'exceptions.js');
+  const script = path.relative(process.cwd(), scriptFullPath);
+  const cli = startCLI([script]);
+
+  (async () => {
+    try {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      await cli.waitForPrompt();
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
+
+      // Making sure it will die by default:
+      await cli.command('c');
+      await cli.waitFor(/disconnect/);
+
+      // Next run: With `breakOnException` it pauses in both places.
+      await cli.command('r');
+      await cli.waitFor(/ ok\n/);
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
+      await cli.command('breakOnException');
+      await cli.stepCommand('c');
+      assert.ok(cli.output.includes(`exception in ${script}:3`));
+      await cli.stepCommand('c');
+      assert.ok(cli.output.includes(`exception in ${script}:9`));
+
+      // Next run: With `breakOnUncaught` it only pauses on the 2nd exception.
+      await cli.command('breakOnUncaught');
+      await cli.command('r'); // Also, the setting survives the restart.
+      await cli.waitFor(/ ok\n/);
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
+      await cli.stepCommand('c');
+      assert.ok(cli.output.includes(`exception in ${script}:9`));
+
+      // Next run: Back to the initial state! It should die again.
+      await cli.command('breakOnNone');
+      await cli.command('r');
+      await cli.waitFor(/ ok\n/);
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      assert.deepStrictEqual(cli.breakInfo, { filename: script, line: 1 });
+      await cli.command('c');
+      await cli.waitFor(/disconnect/);
+    } finally {
+      cli.quit();
+    }
+  })().then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-debugger-exec-scope.mjs b/test/js/node/test/parallel/test-debugger-exec-scope.mjs
new file mode 100644
index 00000000000..661061f11e0
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-exec-scope.mjs
@@ -0,0 +1,23 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+
+const cli = startCLI([fixtures.path('debugger/backtrace.js')]);
+
+try {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  await cli.stepCommand('c');
+  await cli.command('exec .scope');
+  assert.match(cli.output, /'moduleScoped'/, 'displays closure from module body');
+  assert.match(cli.output, /'a'/, 'displays local / function arg');
+  assert.match(cli.output, /'l1'/, 'displays local scope');
+  assert.doesNotMatch(cli.output, /'encodeURIComponent'/, 'omits global scope');
+} finally {
+  await cli.quit();
+}
diff --git a/test/js/node/test/parallel/test-debugger-extract-function-name.mjs b/test/js/node/test/parallel/test-debugger-extract-function-name.mjs
new file mode 100644
index 00000000000..a7de32ad4e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-extract-function-name.mjs
@@ -0,0 +1,33 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+
+const cli = startCLI([fixtures.path('debugger', 'three-lines.js')]);
+
+try {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  await cli.command('exec a = function func() {}; a;');
+  assert.match(cli.output, /\[Function: func\]/);
+  await cli.command('exec a = function func () {}; a;');
+  assert.match(cli.output, /\[Function\]/);
+  await cli.command('exec a = function() {}; a;');
+  assert.match(cli.output, /\[Function: function\]/);
+  await cli.command('exec a = () => {}; a;');
+  assert.match(cli.output, /\[Function\]/);
+  await cli.command('exec a = function* func() {}; a;');
+  assert.match(cli.output, /\[GeneratorFunction: func\]/);
+  await cli.command('exec a = function *func() {}; a;');
+  assert.match(cli.output, /\[GeneratorFunction: \*func\]/);
+  await cli.command('exec a = function*func() {}; a;');
+  assert.match(cli.output, /\[GeneratorFunction: function\*func\]/);
+  await cli.command('exec a = function * func() {}; a;');
+  assert.match(cli.output, /\[GeneratorFunction\]/);
+} finally {
+  cli.quit();
+}
diff --git a/test/js/node/test/parallel/test-debugger-heap-profiler.js b/test/js/node/test/parallel/test-debugger-heap-profiler.js
new file mode 100644
index 00000000000..96c3ed0e1a5
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-heap-profiler.js
@@ -0,0 +1,38 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+const tmpdir = require('../common/tmpdir');
+
+tmpdir.refresh();
+
+const { readFileSync } = require('fs');
+
+const filename = tmpdir.resolve('node.heapsnapshot');
+
+// Heap profiler take snapshot.
+{
+  const opts = { cwd: tmpdir.path };
+  const cli = startCLI([fixtures.path('debugger/empty.js')], [], opts);
+
+  async function waitInitialBreak() {
+    try {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      await cli.command('takeHeapSnapshot()');
+      JSON.parse(readFileSync(filename, 'utf8'));
+      // Check that two simultaneous snapshots don't step all over each other.
+      // Refs: https://github.com/nodejs/node/issues/39555
+      await cli.command('takeHeapSnapshot(); takeHeapSnapshot()');
+      JSON.parse(readFileSync(filename, 'utf8'));
+    } finally {
+      await cli.quit();
+    }
+  }
+
+  // Check that the snapshot is valid JSON.
+  waitInitialBreak().then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-debugger-help.mjs b/test/js/node/test/parallel/test-debugger-help.mjs
new file mode 100644
index 00000000000..1fb710d6280
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-help.mjs
@@ -0,0 +1,19 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+
+const cli = startCLI([fixtures.path('debugger', 'empty.js')]);
+
+try {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  await cli.command('help');
+  assert.match(cli.output, /run, restart, r\s+/m);
+} finally {
+  cli.quit();
+}
diff --git a/test/js/node/test/parallel/test-debugger-inspect-help-forwarding.mjs b/test/js/node/test/parallel/test-debugger-inspect-help-forwarding.mjs
new file mode 100644
index 00000000000..796fcf36cc7
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-inspect-help-forwarding.mjs
@@ -0,0 +1,34 @@
+// Tests that --help / -h are forwarded to the debuggee when a script is
+// also passed, instead of being hijacked as the inspect help flag.
+
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+
+skipIfInspectorDisabled();
+
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+
+async function getEvaluatedArgv(flag) {
+  const script = fixtures.path('debugger', 'empty.js');
+  const cli = startCLI([script, flag]);
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    await cli.command('exec process.argv');
+    return cli.output;
+  } finally {
+    await cli.quit();
+  }
+}
+
+async function checkForwardedHelp(flag) {
+  const output = await getEvaluatedArgv(flag);
+  assert(output.includes(`'${flag}'`),
+         `expected debuggee process.argv to include "${flag}", got:\n${output}`);
+  assert.doesNotMatch(output, /Usage: .+ inspect/);
+}
+
+await checkForwardedHelp('--help');
+await checkForwardedHelp('-h');
diff --git a/test/js/node/test/parallel/test-debugger-inspect-help.js b/test/js/node/test/parallel/test-debugger-inspect-help.js
new file mode 100644
index 00000000000..3dfc1f79af7
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-inspect-help.js
@@ -0,0 +1,37 @@
+'use strict';
+
+// Tests that `node inspect` help text is printed when
+// `--help` / `-h` is passed and there is no script,
+// or when there are no additional arguments.
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const {
+  spawnSyncAndAssert,
+  spawnSyncAndExit,
+} = require('../common/child_process');
+
+const usageRegex = /^Usage: .+ inspect .*debugger\.html/ms;
+
+// --help / -h prints the usage to stdout and exits with code 0,
+// for both interactive and probe-mode invocations.
+const helpArgs = [
+  ['inspect', '--help'],
+  ['inspect', '-h'],
+  ['inspect', '--probe', '--help'],
+  ['inspect', '--probe', '-h'],
+];
+
+for (const args of helpArgs) {
+  spawnSyncAndAssert(process.execPath, args, {
+    stdout: usageRegex,
+  });
+}
+
+// `node inspect` with no args prints the usage to stderr and exits
+// with kInvalidCommandLineArgument (9).
+spawnSyncAndExit(process.execPath, ['inspect'], {
+  status: 9,
+  signal: null,
+  stderr: usageRegex,
+});
diff --git a/test/js/node/test/parallel/test-debugger-list.js b/test/js/node/test/parallel/test-debugger-list.js
new file mode 100644
index 00000000000..594874e140b
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-list.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+const cli = startCLI([fixtures.path('debugger/three-lines.js')]);
+
+(async () => {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  await cli.command('list(0)');
+  assert.match(cli.output, /> 1 let x = 1;/);
+  await cli.command('list(1)');
+  assert.match(cli.output, /> 1 let x = 1;\r?\n {2}2 x = x \+ 1;/);
+  await cli.command('list(10)');
+  assert.match(cli.output, /> 1 let x = 1;\r?\n {2}2 x = x \+ 1;\r?\n {2}3 module\.exports = x;\r?\n {2}4 /);
+  await cli.command('c');
+  await cli.waitFor(/disconnect/);
+  await cli.waitFor(/debug> $/);
+  await cli.command('list()');
+  await cli.waitFor(/ERR_DEBUGGER_ERROR/);
+  assert.match(cli.output, /Uncaught Error \[ERR_DEBUGGER_ERROR\]: Requires execution to be paused/);
+})()
+.finally(() => cli.quit())
+.then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-probe-activation.js b/test/js/node/test/parallel/test-debugger-probe-activation.js
new file mode 100644
index 00000000000..69eb1324ef8
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-activation.js
@@ -0,0 +1,38 @@
+// This tests that probe mode only activates when --probe is present,
+// so that other options can be used as user script arguments without
+// accidentally activating probe mode.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+const script = fixtures.path('debugger', 'three-lines.js');
+const cli = startCLI([
+  script,
+  '--json',
+  '--preview',
+  '--timeout=1',
+  '--expr',
+  'value',
+]);
+
+(async () => {
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    await cli.command('exec JSON.stringify(process.argv.slice(2))');
+    // Check that it's parsable as usual.
+    assert.match(
+      cli.output,
+      /\["--json","--preview","--timeout=1","--expr","value"\]/,
+    );
+  } finally {
+    const code = await cli.quit();
+    assert.strictEqual(code, 0);
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-probe-bound-never-hit.js b/test/js/node/test/parallel/test-debugger-probe-bound-never-hit.js
new file mode 100644
index 00000000000..2dc8b5a5e9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-bound-never-hit.js
@@ -0,0 +1,34 @@
+// Tests that probing an unreachable line produces a `miss` with no hit events.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-bound-never-hit.js:4',
+  '--expr', '1',
+  'probe-bound-never-hit.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: '1',
+        target: { suffix: 'probe-bound-never-hit.js', line: 4 },
+      }],
+      results: [{
+        event: 'miss',
+        pending: [0],
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-child-inspect-port-zero.js b/test/js/node/test/parallel/test-debugger-probe-child-inspect-port-zero.js
new file mode 100644
index 00000000000..468f7fdccba
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-child-inspect-port-zero.js
@@ -0,0 +1,42 @@
+// This tests child --inspect-port=0 pass-through in probe mode.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const probeUrl = fixtures.fileURL('debugger', 'probe.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe.js:12',
+  '--expr', 'finalValue',
+  '--',
+  '--inspect-port=0',
+  'probe.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: 'finalValue',
+        target: { suffix: 'probe.js', line: 12 },
+      }],
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location: { url: probeUrl, line: 12, column: 1 },
+        result: { type: 'number', value: 81, description: '81' },
+      }, {
+        event: 'completed',
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-explicit-column.js b/test/js/node/test/parallel/test-debugger-probe-explicit-column.js
new file mode 100644
index 00000000000..ac65b572a37
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-explicit-column.js
@@ -0,0 +1,72 @@
+// Tests that probes on the same line but different columns are hit separately.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixtureUrl = fixtures.fileURL('debugger', 'probe-multi-statement.js').href;
+
+// col 3:  acc === []
+// col 16: acc === [1]
+// col 29: acc === [1, 2]
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-multi-statement.js:5:3',
+  '--expr', 'acc.length',
+  '--probe', 'probe-multi-statement.js:5:16',
+  '--expr', 'acc.length',
+  '--probe', 'probe-multi-statement.js:5:29',
+  '--expr', 'acc.length',
+  'probe-multi-statement.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        {
+          expr: 'acc.length',
+          target: { suffix: 'probe-multi-statement.js', line: 5, column: 3 },
+        },
+        {
+          expr: 'acc.length',
+          target: { suffix: 'probe-multi-statement.js', line: 5, column: 16 },
+        },
+        {
+          expr: 'acc.length',
+          target: { suffix: 'probe-multi-statement.js', line: 5, column: 29 },
+        },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location: { url: fixtureUrl, line: 5, column: 3 },
+          result: { type: 'number', value: 0, description: '0' },
+        },
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 1,
+          location: { url: fixtureUrl, line: 5, column: 16 },
+          result: { type: 'number', value: 1, description: '1' },
+        },
+        {
+          probe: 2,
+          event: 'hit',
+          hit: 1,
+          location: { url: fixtureUrl, line: 5, column: 29 },
+          result: { type: 'number', value: 2, description: '2' },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-expression-throws.js b/test/js/node/test/parallel/test-debugger-probe-expression-throws.js
new file mode 100644
index 00000000000..a5447fe0a0f
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-expression-throws.js
@@ -0,0 +1,64 @@
+// This tests that a probe expression throwing an exception is recorded as
+// a per-hit error and does not fail the session.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-throwing-getter.js';
+const probes = [
+  { expr: 'holder.throwingGetter', target: { suffix: fixture, line: 16 } },
+  // This clears the interval so the process will exit naturally.
+  { expr: 'markProbesDone()', target: { suffix: fixture, line: 17 } },
+];
+const url = fixtures.fileURL('debugger', fixture).href;
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:16`, '--expr', probes[0].expr,
+  '--probe', `${fixture}:17`, '--expr', probes[1].expr,
+  fixture,
+], { cwd }, {
+  status: 0,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location: { url, line: 16, column: 1 },
+        error: {
+          message: 'Error: boom\n<stack>',
+          details: {
+            exception: {
+              exceptionId: 1,
+              text: 'Uncaught',
+              lineNumber: 4,
+              columnNumber: 4,
+              scriptId: '<scriptId>',
+              stackTrace: { callFrames: '<callFrames>' },
+              exception: { type: 'object', subtype: 'error', description: 'Error: boom\n<stack>' },
+            },
+          },
+        },
+      }, {
+        probe: 1,
+        event: 'hit',
+        hit: 1,
+        location: { url, line: 17, column: 1 },
+        result: { type: 'undefined' },
+      }, {
+        event: 'completed',
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-failure-process-exit.js b/test/js/node/test/parallel/test-debugger-probe-failure-process-exit.js
new file mode 100644
index 00000000000..1e14c8b2b81
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-failure-process-exit.js
@@ -0,0 +1,50 @@
+// This tests that a clean process.exit(0) from inside a probe expression
+// surfaces as probe_failure, not probe_target_exit.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const fixture = 'probe-exits-during-probe.js';
+const probes = [{ expr: 'exitDuringProbe()', target: { suffix: fixture, line: 8 } }];
+const location = { url: fixtures.fileURL('debugger', fixture).href, line: 8, column: 1 };
+
+spawnSyncAndExit(process.execPath, [
+  'inspect', '--json',
+  '--probe', `${fixture}:8`, '--expr', probes[0].expr,
+  fixture,
+], { cwd }, {
+  status: 1,
+  signal: null,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes,
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location,
+        error: { message: 'Probe evaluation did not complete' },
+      }, {
+        event: 'error',
+        pending: [],
+        error: {
+          code: 'probe_failure',
+          message:
+            'Target process exited during probe evaluation. ' +
+            'If the failure repeats, review the probe expression.',
+          probe: 0,
+          stderr: '',
+          details: { lastCdpMethod: 'Debugger.evaluateOnCallFrame' },
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-global-option-order.js b/test/js/node/test/parallel/test-debugger-probe-global-option-order.js
new file mode 100644
index 00000000000..33e9b688f2e
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-global-option-order.js
@@ -0,0 +1,40 @@
+// This tests that global probe options can appear after the first --probe.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const probeUrl = fixtures.fileURL('debugger', 'probe.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--probe', 'probe.js:12',
+  '--expr', 'finalValue',
+  '--json',
+  'probe.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: 'finalValue',
+        target: { suffix: 'probe.js', line: 12 },
+      }],
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        location: { url: probeUrl, line: 12, column: 1 },
+        result: { type: 'number', value: 81, description: '81' },
+      }, {
+        event: 'completed',
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-json-preview.js b/test/js/node/test/parallel/test-debugger-probe-json-preview.js
new file mode 100644
index 00000000000..acfd5bbbc78
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-json-preview.js
@@ -0,0 +1,104 @@
+// This tests debugger probe JSON preview opt-in for object-like values.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const probeArg = 'probe-types.js:17';
+const target = { suffix: 'probe-types.js', line: 17 };
+const location = { url: fixtures.fileURL('debugger', 'probe-types.js').href, line: 17, column: 1 };
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--preview',
+  '--probe', probeArg,
+  '--expr', 'objectValue',
+  '--probe', probeArg,
+  '--expr', 'arrayValue',
+  '--probe', probeArg,
+  '--expr', 'errorValue',
+  'probe-types.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'objectValue', target },
+        { expr: 'arrayValue', target },
+        { expr: 'errorValue', target },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            description: 'Object',
+            preview: {
+              type: 'object',
+              description: 'Object',
+              overflow: false,
+              properties: [
+                { name: 'alpha', type: 'number', value: '1' },
+                { name: 'beta', type: 'string', value: 'two' },
+              ],
+            },
+          },
+        },
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            subtype: 'array',
+            description: 'Array(3)',
+            preview: {
+              type: 'object',
+              subtype: 'array',
+              description: 'Array(3)',
+              overflow: false,
+              properties: [
+                { name: '0', type: 'number', value: '1' },
+                { name: '1', type: 'string', value: 'two' },
+                { name: '2', type: 'number', value: '3' },
+              ],
+            },
+          },
+        },
+        {
+          probe: 2,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            subtype: 'error',
+            description: 'Error: boom',
+            preview: {
+              type: 'object',
+              subtype: 'error',
+              description: 'Error: boom',
+              overflow: false,
+              properties: [
+                { name: 'stack', type: 'string', value: 'Error: boom' },
+                { name: 'message', type: 'string', value: 'boom' },
+              ],
+            },
+          },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-json-special-values.js b/test/js/node/test/parallel/test-debugger-probe-json-special-values.js
new file mode 100644
index 00000000000..e24ea5b3080
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-json-special-values.js
@@ -0,0 +1,156 @@
+// This tests debugger probe JSON output for stable special-cased values.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const probeArg = 'probe-types.js:17';
+const target = { suffix: 'probe-types.js', line: 17 };
+const location = { url: fixtures.fileURL('debugger', 'probe-types.js').href, line: 17, column: 1 };
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', probeArg,
+  '--expr', 'stringValue',
+  '--probe', probeArg,
+  '--expr', 'booleanValue',
+  '--probe', probeArg,
+  '--expr', 'undefinedValue',
+  '--probe', probeArg,
+  '--expr', 'nullValue',
+  '--probe', probeArg,
+  '--expr', 'nanValue',
+  '--probe', probeArg,
+  '--expr', 'bigintValue',
+  '--probe', probeArg,
+  '--expr', 'symbolValue',
+  '--probe', probeArg,
+  '--expr', 'functionValue',
+  '--probe', probeArg,
+  '--expr', 'objectValue',
+  '--probe', probeArg,
+  '--expr', 'arrayValue',
+  '--probe', probeArg,
+  '--expr', 'errorValue',
+  'probe-types.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'stringValue', target },
+        { expr: 'booleanValue', target },
+        { expr: 'undefinedValue', target },
+        { expr: 'nullValue', target },
+        { expr: 'nanValue', target },
+        { expr: 'bigintValue', target },
+        { expr: 'symbolValue', target },
+        { expr: 'functionValue', target },
+        { expr: 'objectValue', target },
+        { expr: 'arrayValue', target },
+        { expr: 'errorValue', target },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'string', value: 'hello' },
+        },
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'boolean', value: true },
+        },
+        {
+          probe: 2,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'undefined' },
+        },
+        {
+          probe: 3,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'object', subtype: 'null', value: null },
+        },
+        {
+          probe: 4,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'number', unserializableValue: 'NaN', description: 'NaN' },
+        },
+        {
+          probe: 5,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'bigint', unserializableValue: '1n', description: '1n' },
+        },
+        {
+          probe: 6,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: { type: 'symbol', description: 'Symbol(tag)' },
+        },
+        {
+          probe: 7,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'function',
+            description: '() => 1',
+          },
+        },
+        {
+          probe: 8,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            description: 'Object',
+          },
+        },
+        {
+          probe: 9,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            subtype: 'array',
+            description: 'Array(3)',
+          },
+        },
+        {
+          probe: 10,
+          event: 'hit',
+          hit: 1,
+          location,
+          result: {
+            type: 'object',
+            subtype: 'error',
+            description: 'Error: boom',
+          },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-json.js b/test/js/node/test/parallel/test-debugger-probe-json.js
new file mode 100644
index 00000000000..559392cc69d
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-json.js
@@ -0,0 +1,76 @@
+// This tests debugger probe JSON output for duplicate and multi-probe hits.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const probeUrl = fixtures.fileURL('debugger', 'probe.js').href;
+const locationAt8 = { url: probeUrl, line: 8, column: 3 };
+const locationAt12 = { url: probeUrl, line: 12, column: 1 };
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe.js:8',
+  '--expr', 'index',
+  '--probe', 'probe.js:8',
+  '--expr', 'total',
+  '--probe', 'probe.js:12',
+  '--expr', 'finalValue',
+  'probe.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'index', target: { suffix: 'probe.js', line: 8 } },
+        { expr: 'total', target: { suffix: 'probe.js', line: 8 } },
+        { expr: 'finalValue', target: { suffix: 'probe.js', line: 12 } },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location: locationAt8,
+          result: { type: 'number', value: 0, description: '0' },
+        },
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 1,
+          location: locationAt8,
+          result: { type: 'number', value: 0, description: '0' },
+        },
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 2,
+          location: locationAt8,
+          result: { type: 'number', value: 1, description: '1' },
+        },
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 2,
+          location: locationAt8,
+          result: { type: 'number', value: 40, description: '40' },
+        },
+        {
+          probe: 2,
+          event: 'hit',
+          hit: 1,
+          location: locationAt12,
+          result: { type: 'number', value: 81, description: '81' },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-late-resolution.js b/test/js/node/test/parallel/test-debugger-probe-late-resolution.js
new file mode 100644
index 00000000000..202019122c4
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-late-resolution.js
@@ -0,0 +1,52 @@
+// Tests that probing scripts loaded mid-session via require(esm) and import(cjs)
+// still resolves and hits correctly.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const esmUrl = fixtures.fileURL('debugger', 'probe-late-target.mjs').href;
+const cjsUrl = fixtures.fileURL('debugger', 'probe-late-target.cjs').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-late-target.mjs:3',
+  '--expr', 'value',
+  '--probe', 'probe-late-target.cjs:5',
+  '--expr', 'value',
+  'probe-late-entry.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'value', target: { suffix: 'probe-late-target.mjs', line: 3 } },
+        { expr: 'value', target: { suffix: 'probe-late-target.cjs', line: 5 } },
+      ],
+      results: [
+        {
+          probe: 1,
+          event: 'hit',
+          hit: 1,
+          location: { url: cjsUrl, line: 5, column: 3 },
+          result: { type: 'number', value: 3, description: '3' },
+        },
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location: { url: esmUrl, line: 3, column: 3 },
+          result: { type: 'number', value: 5, description: '5' },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-miss.js b/test/js/node/test/parallel/test-debugger-probe-miss.js
new file mode 100644
index 00000000000..4fd4824ed0c
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-miss.js
@@ -0,0 +1,33 @@
+// This tests that probe sessions report unresolved breakpoints as misses.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+const cwd = fixtures.path('debugger');
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-miss.js:99',
+  '--expr', '42',
+  'probe-miss.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: '42',
+        target: { suffix: 'probe-miss.js', line: 99 },
+      }],
+      results: [{
+        event: 'miss',
+        pending: [0],
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-missing-expr.js b/test/js/node/test/parallel/test-debugger-probe-missing-expr.js
new file mode 100644
index 00000000000..3011bc51f58
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-missing-expr.js
@@ -0,0 +1,21 @@
+// This tests that probe mode rejects a --probe without a matching --expr.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+const cwd = fixtures.path('debugger');
+
+spawnSyncAndExit(process.execPath, [
+  'inspect',
+  '--probe', 'probe.js:12',
+  'probe.js',
+], { cwd }, {
+  signal: null,
+  status: 9,
+  stderr: /Each --probe must be followed immediately by --expr/,
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-multi-location.js b/test/js/node/test/parallel/test-debugger-probe-multi-location.js
new file mode 100644
index 00000000000..15638f880ed
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-multi-location.js
@@ -0,0 +1,49 @@
+// Tests that when probing a suffix that resolves to two files,
+// both are probed and each hit is attributed to the right script.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const urlA = fixtures.fileURL('debugger', 'probe-multi-a', 'utils.js').href;
+const urlB = fixtures.fileURL('debugger', 'probe-multi-b', 'utils.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'utils.js:5',
+  '--expr', 'b',
+  'probe-multi-entry.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'b', target: { suffix: 'utils.js', line: 5 } },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location: { url: urlA, line: 5, column: 3 },
+          result: { type: 'number', value: 2, description: '2' },
+        },
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 2,
+          location: { url: urlB, line: 5, column: 3 },
+          result: { type: 'number', value: 3, description: '3' },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-narrow-suffix.js b/test/js/node/test/parallel/test-debugger-probe-narrow-suffix.js
new file mode 100644
index 00000000000..194ddfbdc5d
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-narrow-suffix.js
@@ -0,0 +1,40 @@
+// Tests that a path-qualified suffix narrows the match to a single script.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+
+const cwd = fixtures.path('debugger');
+const urlA = fixtures.fileURL('debugger', 'probe-multi-a', 'utils.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-multi-a/utils.js:5',
+  '--expr', 'b',
+  'probe-multi-entry.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [
+        { expr: 'b', target: { suffix: 'probe-multi-a/utils.js', line: 5 } },
+      ],
+      results: [
+        {
+          probe: 0,
+          event: 'hit',
+          hit: 1,
+          location: { url: urlA, line: 5, column: 3 },
+          result: { type: 'number', value: 2, description: '2' },
+        },
+        { event: 'completed' },
+      ],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-no-column-indent.js b/test/js/node/test/parallel/test-debugger-probe-no-column-indent.js
new file mode 100644
index 00000000000..351f1b89e79
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-no-column-indent.js
@@ -0,0 +1,43 @@
+// Tests probing an indented line without specifying a column should relocate
+// the breakpoint to the first executable column.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+const cwd = fixtures.path('debugger');
+const fixtureUrl = fixtures.fileURL('debugger', 'probe-indented.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--json',
+  '--probe', 'probe-indented.js:6',  // No `:col`
+  '--expr', 'x',
+  'probe-indented.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: 'x',
+        // No `:col` in `target`, reflecting the user spec.
+        target: { suffix: 'probe-indented.js', line: 6 },
+      }],
+      results: [{
+        probe: 0,
+        event: 'hit',
+        hit: 1,
+        // V8 should relocate the breakpoint to the first executable column (3).
+        location: { url: fixtureUrl, line: 6, column: 3 },
+        // Pauses *before* the assignment runs, so `x` still holds the value from line 4.
+        result: { type: 'number', value: 0, description: '0' },
+      }, {
+        event: 'completed',
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-requires-separator.js b/test/js/node/test/parallel/test-debugger-probe-requires-separator.js
new file mode 100644
index 00000000000..efc81fda4d6
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-requires-separator.js
@@ -0,0 +1,23 @@
+// This tests that child Node.js flags require -- in probe mode.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+const cwd = fixtures.path('debugger');
+
+spawnSyncAndExit(process.execPath, [
+  'inspect',
+  '--probe', 'probe.js:12',
+  '--expr', 'finalValue',
+  '--inspect-port=0',
+  'probe.js',
+], { cwd }, {
+  signal: null,
+  status: 9,
+  stderr: /Use -- before child Node\.js flags in probe mode/,
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-text-special-values.js b/test/js/node/test/parallel/test-debugger-probe-text-special-values.js
new file mode 100644
index 00000000000..ea62c45970a
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-text-special-values.js
@@ -0,0 +1,68 @@
+// This tests debugger probe text output for stable special-cased values.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeText } = require('../common/debugger-probe');
+const cwd = fixtures.path('debugger');
+const probeArg = 'probe-types.js:17';
+const hitText = `${fixtures.fileURL('debugger', 'probe-types.js').href}:17:1`;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--probe', probeArg,
+  '--expr', 'stringValue',
+  '--probe', probeArg,
+  '--expr', 'booleanValue',
+  '--probe', probeArg,
+  '--expr', 'undefinedValue',
+  '--probe', probeArg,
+  '--expr', 'nullValue',
+  '--probe', probeArg,
+  '--expr', 'nanValue',
+  '--probe', probeArg,
+  '--expr', 'bigintValue',
+  '--probe', probeArg,
+  '--expr', 'symbolValue',
+  '--probe', probeArg,
+  '--expr', 'functionValue',
+  '--probe', probeArg,
+  '--expr', 'objectValue',
+  '--probe', probeArg,
+  '--expr', 'arrayValue',
+  '--probe', probeArg,
+  '--expr', 'errorValue',
+  'probe-types.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeText(output, [
+      `Hit 1 at ${hitText}`,
+      '  stringValue = "hello"',
+      `Hit 1 at ${hitText}`,
+      '  booleanValue = true',
+      `Hit 1 at ${hitText}`,
+      '  undefinedValue = undefined',
+      `Hit 1 at ${hitText}`,
+      '  nullValue = null',
+      `Hit 1 at ${hitText}`,
+      '  nanValue = NaN',
+      `Hit 1 at ${hitText}`,
+      '  bigintValue = 1n',
+      `Hit 1 at ${hitText}`,
+      '  symbolValue = Symbol(tag)',
+      `Hit 1 at ${hitText}`,
+      '  functionValue = () => 1',
+      `Hit 1 at ${hitText}`,
+      '  objectValue = {alpha: 1, beta: "two"}',
+      `Hit 1 at ${hitText}`,
+      '  arrayValue = [1, "two", 3]',
+      `Hit 1 at ${hitText}`,
+      '  errorValue = Error: boom',
+      'Completed',
+    ].join('\n'));
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-text.js b/test/js/node/test/parallel/test-debugger-probe-text.js
new file mode 100644
index 00000000000..f6752741a22
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-text.js
@@ -0,0 +1,26 @@
+// This tests debugger probe text output for a single hit.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const { assertProbeText } = require('../common/debugger-probe');
+const cwd = fixtures.path('debugger');
+const probeUrl = fixtures.fileURL('debugger', 'probe.js').href;
+
+spawnSyncAndAssert(process.execPath, [
+  'inspect',
+  '--probe', 'probe.js:12',
+  '--expr', 'finalValue',
+  'probe.js',
+], { cwd }, {
+  stdout(output) {
+    assertProbeText(output,
+                    `Hit 1 at ${probeUrl}:12:1\n` +
+                    '  finalValue = 81\n' +
+                    'Completed');
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-probe-timeout.js b/test/js/node/test/parallel/test-debugger-probe-timeout.js
new file mode 100644
index 00000000000..de9309c3f60
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-probe-timeout.js
@@ -0,0 +1,41 @@
+// This tests probe session timeout behavior and teardown.
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+const { assertProbeJson } = require('../common/debugger-probe');
+const cwd = fixtures.path('debugger');
+
+const timeout = common.platformTimeout(1000);
+spawnSyncAndExit(process.execPath, [
+  'inspect',
+  '--json',
+  `--timeout=${timeout}`,
+  '--probe', 'probe-timeout.js:99',
+  '--expr', '1',
+  'probe-timeout.js',
+], { cwd }, {
+  signal: null,
+  status: 1,
+  stdout(output) {
+    assertProbeJson(output, {
+      v: 2,
+      probes: [{
+        expr: '1',
+        target: { suffix: 'probe-timeout.js', line: 99 },
+      }],
+      results: [{
+        event: 'timeout',
+        pending: [0],
+        error: {
+          code: 'probe_timeout',
+          message: `Timed out after ${timeout}ms waiting for probes: probe-timeout.js:99`,
+        },
+      }],
+    });
+  },
+  trim: true,
+});
diff --git a/test/js/node/test/parallel/test-debugger-profile.js b/test/js/node/test/parallel/test-debugger-profile.js
new file mode 100644
index 00000000000..31f57ee06da
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-profile.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Profiles.
+{
+  const cli = startCLI([fixtures.path('debugger/empty.js')], [], {
+    env: {
+      ...process.env,
+      // When this test is run with NODE_V8_COVERAGE, it clobbers the inspector
+      // output, so override to disable coverage for the child process.
+      NODE_V8_COVERAGE: undefined,
+    }
+  });
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  try {
+    (async () => {
+      await cli.waitForInitialBreak();
+      await cli.waitForPrompt();
+      await cli.command('exec console.profile()');
+      assert.match(cli.output, /undefined/);
+      await cli.command('exec console.profileEnd()');
+      await delay(250);
+      assert.match(cli.output, /undefined/);
+      assert.match(cli.output, /Captured new CPU profile\./);
+      await cli.quit();
+    })()
+        .then(common.mustCall());
+  } catch (error) {
+    return onFatal(error);
+  }
+
+}
diff --git a/test/js/node/test/parallel/test-debugger-random-port-with-inspect-port.js b/test/js/node/test/parallel/test-debugger-random-port-with-inspect-port.js
new file mode 100644
index 00000000000..a7e74c0dbae
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-random-port-with-inspect-port.js
@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Random port with --inspect-port=0.
+const script = fixtures.path('debugger', 'three-lines.js');
+
+const cli = startCLI(['--inspect-port=0', script], [], {}, { randomPort: false });
+
+(async () => {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  assert.match(cli.output, /debug>/, 'prints a prompt');
+  assert.match(
+    cli.output,
+    /< Debugger listening on /,
+    'forwards child output');
+  const code = await cli.quit();
+  assert.strictEqual(code, 0);
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-random-port.js b/test/js/node/test/parallel/test-debugger-random-port.js
new file mode 100644
index 00000000000..06f927b4db9
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-random-port.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Random port.
+{
+  const script = fixtures.path('debugger', 'three-lines.js');
+
+  const cli = startCLI([script]);
+
+  cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      assert.match(cli.output, /debug>/, 'prints a prompt');
+      assert.match(
+        cli.output,
+        /< Debugger listening on /,
+        'forwards child output');
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      assert.strictEqual(code, 0);
+    })
+    .then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-debugger-sb-before-load.js b/test/js/node/test/parallel/test-debugger-sb-before-load.js
new file mode 100644
index 00000000000..e2267156b74
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-sb-before-load.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const path = require('path');
+
+// Using sb before loading file.
+
+const scriptFullPath = fixtures.path('debugger', 'cjs', 'index.js');
+const script = path.relative(process.cwd(), scriptFullPath);
+
+const otherScriptFullPath = fixtures.path('debugger', 'cjs', 'other.js');
+const otherScript = path.relative(process.cwd(), otherScriptFullPath);
+
+const cli = startCLI([script]);
+
+(async () => {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  await cli.command('sb("other.js", 2)');
+  assert.match(cli.output, /not loaded yet/,
+               'warns that the script was not loaded yet');
+  await cli.stepCommand('cont');
+  assert.ok(cli.output.includes(`break in ${otherScript}:2`),
+            'found breakpoint in file that was not loaded yet');
+})()
+.then(common.mustCall())
+.finally(() => cli.quit());
diff --git a/test/js/node/test/parallel/test-debugger-unavailable-port.js b/test/js/node/test/parallel/test-debugger-unavailable-port.js
new file mode 100644
index 00000000000..4a43d643988
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-unavailable-port.js
@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+const { createServer } = require('net');
+
+// Launch w/ unavailable port.
+(async () => {
+  const blocker = createServer((socket) => socket.end());
+  const port = await new Promise((resolve, reject) => {
+    blocker.on('error', reject);
+    blocker.listen(0, '127.0.0.1', () => resolve(blocker.address().port));
+  });
+
+  try {
+    const script = fixtures.path('debugger', 'three-lines.js');
+    const cli = startCLI([`--port=${port}`, script], [], {}, { randomPort: false });
+    const code = await cli.quit();
+
+    assert.doesNotMatch(
+      cli.output,
+      /report this bug/,
+      'Omits message about reporting this as a bug');
+    assert.ok(
+      cli.output.includes(`waiting for 127.0.0.1:${port} to be free`),
+      'Tells the user that the port wasn\'t available');
+    assert.strictEqual(code, 1);
+  } finally {
+    blocker.close();
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-use-strict.js b/test/js/node/test/parallel/test-debugger-use-strict.js
new file mode 100644
index 00000000000..ae82a9fc823
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-use-strict.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Test for files that start with strict directive.
+{
+  const script = fixtures.path('debugger', 'use-strict.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitForInitialBreak()
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      const brk = cli.breakInfo;
+      assert.match(
+        `${brk.line}`,
+        /^(1|2)$/,
+        'pauses either on strict directive or first "real" line');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+}
diff --git a/test/js/node/test/parallel/test-debugger-watch-validation.js b/test/js/node/test/parallel/test-debugger-watch-validation.js
new file mode 100644
index 00000000000..46307c18d55
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-watch-validation.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+const cli = startCLI([fixtures.path('debugger/break.js')]);
+
+(async () => {
+  await cli.waitForInitialBreak();
+  await cli.command('watch()');
+  await cli.waitFor(/ERR_INVALID_ARG_TYPE/);
+  assert.match(cli.output, /TypeError \[ERR_INVALID_ARG_TYPE\]: The "expression" argument must be of type string\. Received undefined/);
+})()
+.finally(() => cli.quit())
+.then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-debugger-websocket-secret-mismatch.js b/test/js/node/test/parallel/test-debugger-websocket-secret-mismatch.js
new file mode 100644
index 00000000000..062a2dbd68b
--- /dev/null
+++ b/test/js/node/test/parallel/test-debugger-websocket-secret-mismatch.js
@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const childProcess = require('child_process');
+const http = require('http');
+
+let port;
+
+const server = http.createServer(common.mustCall((req, res) => {
+  if (req.url.startsWith('/json')) {
+    res.writeHead(200);
+    res.end(`[ {
+      "description": "",
+      "devtoolsFrontendUrl": "/devtools/inspector.html?ws=localhost:${port}/devtools/page/DAB7FB6187B554E10B0BD18821265734",
+      "cid": "DAB7FB6187B554E10B0BD18821265734",
+      "title": "Fhqwhgads",
+      "type": "page",
+      "url": "https://www.example.com/",
+      "webSocketDebuggerUrl": "ws://localhost:${port}/devtools/page/DAB7FB6187B554E10B0BD18821265734"
+    } ]`);
+  } else {
+    res.setHeader('Upgrade', 'websocket');
+    res.setHeader('Connection', 'Upgrade');
+    res.setHeader('Sec-WebSocket-Accept', 'fhqwhgads');
+    res.setHeader('Sec-WebSocket-Protocol', 'chat');
+    res.writeHead(101);
+    res.end();
+  }
+}, 2)).listen(0, common.mustCall(() => {
+  port = server.address().port;
+  const proc =
+    childProcess.spawn(process.execPath, ['inspect', `localhost:${port}`]);
+
+  let stdout = '';
+  proc.stdout.on('data', common.mustCallAtLeast((data) => {
+    stdout += data.toString();
+    assert.doesNotMatch(stdout, /\bok\b/);
+  }));
+
+  let stderr = '';
+  proc.stderr.on('data', (data) => {
+    stderr += data.toString();
+  });
+
+  proc.on('exit', common.mustCall((code, signal) => {
+    assert.match(stderr, /\bWebSocket secret mismatch\b/);
+    assert.notStrictEqual(code, 0);
+    assert.strictEqual(signal, null);
+    server.close();
+  }));
+}));
diff --git a/test/js/node/test/parallel/test-inspector-already-activated-cli.js b/test/js/node/test/parallel/test-inspector-already-activated-cli.js
new file mode 100644
index 00000000000..9de226cedca
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-already-activated-cli.js
@@ -0,0 +1,24 @@
+// Flags: --inspect=0
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+const assert = require('assert');
+const inspector = require('inspector');
+const wsUrl = inspector.url();
+assert(wsUrl.startsWith('ws://'));
+assert.throws(() => {
+  inspector.open(0, undefined, false);
+}, {
+  code: 'ERR_INSPECTOR_ALREADY_ACTIVATED'
+});
+assert.strictEqual(inspector.url(), wsUrl);
+inspector.close();
+assert.strictEqual(inspector.url(), undefined);
diff --git a/test/js/node/test/parallel/test-inspector-async-stack-traces-promise-then.js b/test/js/node/test/parallel/test-inspector-async-stack-traces-promise-then.js
new file mode 100644
index 00000000000..188f38b8ef4
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-async-stack-traces-promise-then.js
@@ -0,0 +1,74 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+common.skipIf32Bits();
+const { NodeInstance } = require('../common/inspector-helper');
+const assert = require('assert');
+
+const script = `runTest();
+function runTest() {
+  const p = Promise.resolve();
+  p.then(function break1() { // lineNumber 3
+    debugger;
+  });
+  p.then(function break2() { // lineNumber 6
+    debugger;
+  });
+}
+`;
+
+async function runTests() {
+  const instance = new NodeInstance(undefined, script);
+  const session = await instance.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send([
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 10 } },
+    { 'method': 'Debugger.setBlackboxPatterns',
+      'params': { 'patterns': [] } },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ]);
+  await session.send({ method: 'NodeRuntime.disable' });
+
+  await session.waitForBreakOnLine(0, '[eval]');
+  await session.send({ 'method': 'Debugger.resume' });
+
+  console.error('[test] Waiting for break1');
+  debuggerPausedAt(await session.waitForBreakOnLine(4, '[eval]'),
+                   'break1', 'runTest:3');
+
+  await session.send({ 'method': 'Debugger.resume' });
+
+  console.error('[test] Waiting for break2');
+  debuggerPausedAt(await session.waitForBreakOnLine(7, '[eval]'),
+                   'break2', 'runTest:6');
+
+  await session.runToCompletion();
+  assert.strictEqual((await instance.expectShutdown()).exitCode, 0);
+}
+
+function debuggerPausedAt(msg, functionName, previousTickLocation) {
+  assert(
+    !!msg.params.asyncStackTrace,
+    `${Object.keys(msg.params)} contains "asyncStackTrace" property`);
+
+  assert.strictEqual(msg.params.callFrames[0].functionName, functionName);
+  assert.strictEqual(msg.params.asyncStackTrace.description, 'Promise.then');
+
+  const frameLocations = msg.params.asyncStackTrace.callFrames.map(
+    (frame) => `${frame.functionName}:${frame.lineNumber}`);
+  assertArrayIncludes(frameLocations, previousTickLocation);
+}
+
+function assertArrayIncludes(actual, expected) {
+  const expectedString = JSON.stringify(expected);
+  const actualString = JSON.stringify(actual);
+  assert(
+    actual.includes(expected),
+    `Expected ${actualString} to contain ${expectedString}.`);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-break-e.js b/test/js/node/test/parallel/test-inspector-break-e.js
new file mode 100644
index 00000000000..ccbef313404
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-break-e.js
@@ -0,0 +1,24 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+async function runTests() {
+  const instance = new NodeInstance(undefined, 'console.log(10)');
+  const session = await instance.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send([
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ]);
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForBreakOnLine(0, '[eval]');
+  await session.runToCompletion();
+  assert.strictEqual((await instance.expectShutdown()).exitCode, 0);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-break-when-eval.js b/test/js/node/test/parallel/test-inspector-break-when-eval.js
new file mode 100644
index 00000000000..6fc76acd840
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-break-when-eval.js
@@ -0,0 +1,80 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+const fixtures = require('../common/fixtures');
+const { pathToFileURL } = require('url');
+
+// This needs to be an ES module file to ensure that internal modules are
+// loaded before pausing. See
+// https://bugs.chromium.org/p/chromium/issues/detail?id=1246905
+const script = fixtures.path('inspector-global-function.mjs');
+
+async function setupDebugger(session) {
+  console.log('[test]', 'Setting up a debugger');
+  const commands = [
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 0 } },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ];
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send(commands);
+  await session.send({ method: 'NodeRuntime.disable' });
+
+  await session.waitForNotification('Debugger.paused', 'Initial pause');
+
+  // NOTE(mmarchini): We wait for the second console.log to ensure we loaded
+  // every internal module before pausing. See
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=1246905
+  const waitForReady = session.waitForConsoleOutput('log', 'Ready!');
+  session.send({ 'method': 'Debugger.resume' });
+  await waitForReady;
+}
+
+async function breakOnLine(session) {
+  console.log('[test]', 'Breaking in the code');
+  const commands = [
+    { 'method': 'Debugger.setBreakpointByUrl',
+      'params': { 'lineNumber': 9,
+                  'url': pathToFileURL(script).toString(),
+                  'columnNumber': 0,
+                  'condition': '' } },
+    { 'method': 'Runtime.evaluate',
+      'params': { 'expression': 'sum()',
+                  'objectGroup': 'console',
+                  'includeCommandLineAPI': true,
+                  'silent': false,
+                  'contextId': 1,
+                  'returnByValue': false,
+                  'generatePreview': true,
+                  'userGesture': true,
+                  'awaitPromise': false } },
+  ];
+  session.send(commands);
+  await session.waitForBreakOnLine(9, pathToFileURL(script).toString());
+}
+
+async function stepOverConsoleStatement(session) {
+  console.log('[test]', 'Step over console statement and test output');
+  session.send({ 'method': 'Debugger.stepOver' });
+  await session.waitForConsoleOutput('log', [0, 3]);
+  await session.waitForNotification('Debugger.paused');
+}
+
+async function runTests() {
+  // NOTE(mmarchini): Use --inspect-brk to improve avoid indeterministic
+  // behavior.
+  const child = new NodeInstance(['--inspect-brk=0'], undefined, script);
+  const session = await child.connectInspectorSession();
+  await setupDebugger(session);
+  await breakOnLine(session);
+  await stepOverConsoleStatement(session);
+  await session.runToCompletion();
+  assert.strictEqual((await child.expectShutdown()).exitCode, 0);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-console.js b/test/js/node/test/parallel/test-inspector-console.js
new file mode 100644
index 00000000000..659eccc17a7
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-console.js
@@ -0,0 +1,40 @@
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const { NodeInstance } = require('../common/inspector-helper.js');
+const assert = require('assert');
+
+async function runTest() {
+  const script = 'require(\'inspector\').console.log(\'hello world\');';
+  const child = new NodeInstance('--inspect-brk=0', script, '');
+
+  let out = '';
+  child.on('stdout', (line) => out += line);
+
+  const session = await child.connectInspectorSession();
+
+  const commands = [
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ];
+
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send(commands);
+  await session.send({ method: 'NodeRuntime.disable' });
+
+  const msg = await session.waitForNotification('Runtime.consoleAPICalled');
+
+  assert.strictEqual(msg.params.type, 'log');
+  assert.deepStrictEqual(msg.params.args, [{
+    type: 'string',
+    value: 'hello world'
+  }]);
+  assert.strictEqual(out, '');
+
+  session.disconnect();
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-debug-brk-flag.js b/test/js/node/test/parallel/test-inspector-debug-brk-flag.js
new file mode 100644
index 00000000000..e417f54e93b
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-debug-brk-flag.js
@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+async function testBreakpointOnStart(session) {
+  const commands = [
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setPauseOnExceptions',
+      'params': { 'state': 'none' } },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 0 } },
+    { 'method': 'Profiler.enable' },
+    { 'method': 'Profiler.setSamplingInterval',
+      'params': { 'interval': 100 } },
+    { 'method': 'Debugger.setBlackboxPatterns',
+      'params': { 'patterns': [] } },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ];
+
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send(commands);
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForBreakOnLine(0, session.scriptURL());
+}
+
+async function runTests() {
+  const child = new NodeInstance(['--inspect-brk=0']);
+  const session = await child.connectInspectorSession();
+
+  await testBreakpointOnStart(session);
+  await session.runToCompletion();
+
+  assert.strictEqual((await child.expectShutdown()).exitCode, 55);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-debug-end.js b/test/js/node/test/parallel/test-inspector-debug-end.js
new file mode 100644
index 00000000000..328f15628e3
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-debug-end.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+async function testNoServerNoCrash() {
+  console.log('Test there\'s no crash stopping server that was not started');
+  const instance = new NodeInstance([],
+                                    `process._debugEnd();
+                                     process.exit(42);`);
+  assert.strictEqual((await instance.expectShutdown()).exitCode, 42);
+}
+
+async function testNoSessionNoCrash() {
+  console.log('Test there\'s no crash stopping server without connecting');
+  const instance = new NodeInstance('--inspect=0',
+                                    'process._debugEnd();process.exit(42);');
+  assert.strictEqual((await instance.expectShutdown()).exitCode, 42);
+}
+
+async function testSessionNoCrash() {
+  console.log('Test there\'s no crash stopping server after connecting');
+  const script = `process._debugEnd();
+                  process._debugProcess(process.pid);
+                  setTimeout(() => {
+                      console.log("Done");
+                      process.exit(42);
+                  });`;
+
+  const instance = new NodeInstance('--inspect-brk=0', script);
+  const session = await instance.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ 'method': 'Runtime.runIfWaitingForDebugger' });
+  await session.waitForServerDisconnect();
+  assert.strictEqual((await instance.expectShutdown()).exitCode, 42);
+}
+
+async function runTest() {
+  await testNoServerNoCrash();
+  await testNoSessionNoCrash();
+  await testSessionNoCrash();
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-emit-protocol-event-errors.js b/test/js/node/test/parallel/test-inspector-emit-protocol-event-errors.js
new file mode 100644
index 00000000000..1a76a491c21
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-emit-protocol-event-errors.js
@@ -0,0 +1,503 @@
+// Flags: --inspect=0 --experimental-network-inspection --experimental-storage-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const inspector = require('node:inspector/promises');
+const assert = require('node:assert');
+
+function omit(object, ...keys) {
+  const copy = { ...object };
+  for (const key of keys) {
+    delete copy[key];
+  }
+  return copy;
+}
+
+function networkRequest(overrides = {}) {
+  return {
+    requestId: 'request-id',
+    timestamp: 1000,
+    wallTime: 1000,
+    request: {
+      url: 'https://nodejs.org/en',
+      method: 'GET',
+      headers: {},
+    },
+    ...overrides,
+  };
+}
+
+function networkResponse(overrides = {}) {
+  return {
+    requestId: 'response-id',
+    timestamp: 1000,
+    type: 'Other',
+    response: {
+      url: 'https://nodejs.org/en',
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+    },
+    ...overrides,
+  };
+}
+
+function loadingFailed(overrides = {}) {
+  return {
+    requestId: 'loading-failed-id',
+    timestamp: 1000,
+    type: 'Document',
+    errorText: 'Failed to load resource',
+    ...overrides,
+  };
+}
+
+function loadingFinished(overrides = {}) {
+  return {
+    requestId: 'loading-finished-id',
+    timestamp: 1000,
+    ...overrides,
+  };
+}
+
+function webSocketCreated(overrides = {}) {
+  return {
+    requestId: 'websocket-created-id',
+    url: 'ws://example.com:8080',
+    ...overrides,
+  };
+}
+
+function webSocketClosed(overrides = {}) {
+  return {
+    requestId: 'websocket-closed-id',
+    timestamp: 1000,
+    ...overrides,
+  };
+}
+
+function webSocketResponse(overrides = {}) {
+  return {
+    requestId: 'websocket-response-id',
+    timestamp: 1000,
+    response: {
+      status: 101,
+      statusText: 'Switching Protocols',
+      headers: {},
+    },
+    ...overrides,
+  };
+}
+
+function storageId(overrides = {}) {
+  return {
+    securityOrigin: '',
+    isLocalStorage: true,
+    storageKey: 'node-inspector://default-dom-storage',
+    ...overrides,
+  };
+}
+
+function domStorageItemAdded(overrides = {}) {
+  return {
+    storageId: storageId(),
+    key: 'testKey',
+    newValue: 'testValue',
+    ...overrides,
+  };
+}
+
+function domStorageItemRemoved(overrides = {}) {
+  return {
+    storageId: storageId(),
+    key: 'testKey',
+    ...overrides,
+  };
+}
+
+function domStorageItemUpdated(overrides = {}) {
+  return {
+    storageId: storageId(),
+    key: 'testKey',
+    oldValue: 'oldValue',
+    newValue: 'newValue',
+    ...overrides,
+  };
+}
+
+function registerStorage(overrides = {}) {
+  return {
+    isLocalStorage: true,
+    storageMap: {},
+    ...overrides,
+  };
+}
+
+const NETWORK_ERROR_CASES = [
+  [
+    'requestWillBeSent',
+    omit(networkRequest(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'requestWillBeSent',
+    omit(networkRequest(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+  [
+    'requestWillBeSent',
+    omit(networkRequest(), 'wallTime'),
+    'Missing wallTime in event',
+  ],
+  [
+    'requestWillBeSent',
+    omit(networkRequest(), 'request'),
+    'Missing request in event',
+  ],
+  [
+    'requestWillBeSent',
+    networkRequest({ request: omit(networkRequest().request, 'url') }),
+    'Missing request.url in event',
+  ],
+  [
+    'requestWillBeSent',
+    networkRequest({ request: omit(networkRequest().request, 'method') }),
+    'Missing request.method in event',
+  ],
+  [
+    'requestWillBeSent',
+    networkRequest({ request: omit(networkRequest().request, 'headers') }),
+    'Missing request.headers in event',
+  ],
+
+  [
+    'responseReceived',
+    omit(networkResponse(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'responseReceived',
+    omit(networkResponse(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+  [
+    'responseReceived',
+    omit(networkResponse(), 'type'),
+    'Missing type in event',
+  ],
+  [
+    'responseReceived',
+    omit(networkResponse(), 'response'),
+    'Missing response in event',
+  ],
+  [
+    'responseReceived',
+    networkResponse({ response: omit(networkResponse().response, 'url') }),
+    'Missing response.url in event',
+  ],
+  [
+    'responseReceived',
+    networkResponse({ response: omit(networkResponse().response, 'status') }),
+    'Missing response.status in event',
+  ],
+  [
+    'responseReceived',
+    networkResponse({
+      response: omit(networkResponse().response, 'statusText'),
+    }),
+    'Missing response.statusText in event',
+  ],
+  [
+    'responseReceived',
+    networkResponse({ response: omit(networkResponse().response, 'headers') }),
+    'Missing response.headers in event',
+  ],
+  [
+    'responseReceived',
+    networkResponse({
+      response: { ...networkResponse().response, headers: { host: 1 } },
+    }),
+    'Invalid header value in event',
+  ],
+
+  [
+    'loadingFailed',
+    omit(loadingFailed(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'loadingFailed',
+    omit(loadingFailed(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+  ['loadingFailed', omit(loadingFailed(), 'type'), 'Missing type in event'],
+  [
+    'loadingFailed',
+    omit(loadingFailed(), 'errorText'),
+    'Missing errorText in event',
+  ],
+
+  [
+    'loadingFinished',
+    omit(loadingFinished(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'loadingFinished',
+    omit(loadingFinished(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+
+  [
+    'webSocketCreated',
+    omit(webSocketCreated(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  ['webSocketCreated', omit(webSocketCreated(), 'url'), 'Missing url in event'],
+
+  [
+    'webSocketClosed',
+    omit(webSocketClosed(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'webSocketClosed',
+    omit(webSocketClosed(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+
+  [
+    'webSocketHandshakeResponseReceived',
+    omit(webSocketResponse(), 'requestId'),
+    'Missing requestId in event',
+  ],
+  [
+    'webSocketHandshakeResponseReceived',
+    omit(webSocketResponse(), 'timestamp'),
+    'Missing timestamp in event',
+  ],
+  [
+    'webSocketHandshakeResponseReceived',
+    omit(webSocketResponse(), 'response'),
+    'Missing response in event',
+  ],
+  [
+    'webSocketHandshakeResponseReceived',
+    webSocketResponse({
+      response: omit(webSocketResponse().response, 'status'),
+    }),
+    'Missing response.status in event',
+  ],
+  [
+    'webSocketHandshakeResponseReceived',
+    webSocketResponse({
+      response: omit(webSocketResponse().response, 'statusText'),
+    }),
+    'Missing response.statusText in event',
+  ],
+  [
+    'webSocketHandshakeResponseReceived',
+    webSocketResponse({
+      response: omit(webSocketResponse().response, 'headers'),
+    }),
+    'Missing response.headers in event',
+  ],
+];
+
+const DOM_STORAGE_ERROR_CASES = [
+  [
+    'domStorageItemAdded',
+    omit(domStorageItemAdded(), 'storageId'),
+    'Missing storageId in event',
+  ],
+  [
+    'domStorageItemAdded',
+    domStorageItemAdded({ storageId: omit(storageId(), 'securityOrigin') }),
+    'Missing securityOrigin in storageId',
+  ],
+  [
+    'domStorageItemAdded',
+    domStorageItemAdded({ storageId: omit(storageId(), 'storageKey') }),
+    'Missing storageKey in storageId',
+  ],
+  [
+    'domStorageItemAdded',
+    omit(domStorageItemAdded(), 'key'),
+    'Missing key in event',
+  ],
+  [
+    'domStorageItemAdded',
+    omit(domStorageItemAdded(), 'newValue'),
+    'Missing newValue in event',
+  ],
+
+  [
+    'domStorageItemRemoved',
+    omit(domStorageItemRemoved(), 'storageId'),
+    'Missing storageId in event',
+  ],
+  [
+    'domStorageItemRemoved',
+    omit(domStorageItemRemoved(), 'key'),
+    'Missing key in event',
+  ],
+
+  [
+    'domStorageItemUpdated',
+    omit(domStorageItemUpdated(), 'storageId'),
+    'Missing storageId in event',
+  ],
+  [
+    'domStorageItemUpdated',
+    omit(domStorageItemUpdated(), 'key'),
+    'Missing key in event',
+  ],
+  [
+    'domStorageItemUpdated',
+    omit(domStorageItemUpdated(), 'oldValue'),
+    'Missing oldValue in event',
+  ],
+  [
+    'domStorageItemUpdated',
+    omit(domStorageItemUpdated(), 'newValue'),
+    'Missing newValue in event',
+  ],
+
+  ['domStorageItemsCleared', {}, 'Missing storageId in event'],
+
+  [
+    'registerStorage',
+    omit(registerStorage(), 'isLocalStorage'),
+    'Missing isLocalStorage in event',
+  ],
+  [
+    'registerStorage',
+    omit(registerStorage(), 'storageMap'),
+    'Missing storageMap in event',
+  ],
+  [
+    'registerStorage',
+    registerStorage({
+      storageMap: new Proxy(
+        {},
+        {
+          ownKeys() {
+            throw new Error('boom');
+          },
+        },
+      ),
+    }),
+    'Failed to get property names from storageMap',
+  ],
+  [
+    'registerStorage',
+    registerStorage({
+      storageMap: new Proxy(
+        { testKey: 'testValue' },
+        {
+          get(target, property, receiver) {
+            if (property === 'testKey') throw new Error('boom');
+            return Reflect.get(target, property, receiver);
+          },
+        },
+      ),
+    }),
+    'Failed to get value from storageMap',
+  ],
+];
+
+const DATA_SENT_REQUEST_ID = 'data-sent-id';
+const DATA_SENT_ERROR_CASES = [
+  [{ finished: false }, 'Missing requestId in event'],
+  [{ requestId: DATA_SENT_REQUEST_ID }, 'Missing timestamp in event'],
+  [
+    { requestId: DATA_SENT_REQUEST_ID, timestamp: 1000 },
+    'Missing dataLength in event',
+  ],
+  [
+    { requestId: DATA_SENT_REQUEST_ID, timestamp: 1000, dataLength: 1 },
+    'Missing data in event',
+  ],
+  [
+    {
+      requestId: DATA_SENT_REQUEST_ID,
+      timestamp: 1000,
+      dataLength: 1,
+      data: {},
+    },
+    'Expected data to be Uint8Array in event',
+  ],
+];
+
+const DATA_RECEIVED_ERROR_CASES = [
+  [{}, 'Missing requestId in event'],
+  [{ requestId: 'data-received-id' }, 'Missing timestamp in event'],
+  [
+    { requestId: 'data-received-id', timestamp: 1000 },
+    'Missing dataLength in event',
+  ],
+  [
+    { requestId: 'data-received-id', timestamp: 1000, dataLength: 1 },
+    'Missing encodedDataLength in event',
+  ],
+  [
+    {
+      requestId: 'data-received-id',
+      timestamp: 1000,
+      dataLength: 1,
+      encodedDataLength: 1,
+    },
+    'Missing data in event',
+  ],
+  [
+    {
+      requestId: 'data-received-id',
+      timestamp: 1000,
+      dataLength: 1,
+      encodedDataLength: 1,
+      data: {},
+    },
+    'Expected data to be Uint8Array in event',
+  ],
+];
+
+function assertEventErrors(domain, name, params, message) {
+  assert.throws(
+    () => inspector[domain][name](params),
+    {
+      message,
+    },
+    `Expected ${domain}.${name} to throw`,
+  );
+}
+
+function startRequest(requestId) {
+  inspector.Network.requestWillBeSent(networkRequest({ requestId }));
+}
+
+(async () => {
+  const session = new inspector.Session();
+  session.connect();
+
+  await session.post('Network.enable');
+  await session.post('DOMStorage.enable');
+
+  for (const [name, params, message] of NETWORK_ERROR_CASES) {
+    assertEventErrors('Network', name, params, message);
+  }
+
+  startRequest(DATA_SENT_REQUEST_ID);
+  for (const [params, message] of DATA_SENT_ERROR_CASES) {
+    assertEventErrors('Network', 'dataSent', params, message);
+  }
+
+  for (const [params, message] of DATA_RECEIVED_ERROR_CASES) {
+    assertEventErrors('Network', 'dataReceived', params, message);
+  }
+
+  for (const [name, params, message] of DOM_STORAGE_ERROR_CASES) {
+    assertEventErrors('DOMStorage', name, params, message);
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-emit-protocol-event.js b/test/js/node/test/parallel/test-inspector-emit-protocol-event.js
new file mode 100644
index 00000000000..567c92e3eeb
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-emit-protocol-event.js
@@ -0,0 +1,201 @@
+// Flags: --inspect=0 --experimental-network-inspection --experimental-storage-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const inspector = require('node:inspector/promises');
+const assert = require('node:assert');
+
+const EXPECTED_EVENTS = {
+  Network: [
+    {
+      name: 'requestWillBeSent',
+      params: {
+        requestId: 'request-id-1',
+        request: {
+          url: 'https://nodejs.org/en',
+          method: 'GET',
+          headers: {},
+        },
+        timestamp: 1000,
+        wallTime: 1000,
+      },
+      expected: {
+        requestId: 'request-id-1',
+        request: {
+          url: 'https://nodejs.org/en',
+          method: 'GET',
+          headers: {},
+          hasPostData: false,
+        },
+        timestamp: 1000,
+        wallTime: 1000,
+      }
+    },
+    {
+      name: 'responseReceived',
+      params: {
+        requestId: 'request-id-1',
+        timestamp: 1000,
+        type: 'Other',
+        response: {
+          url: 'https://nodejs.org/en',
+          status: 200,
+          statusText: '',
+          headers: { host: 'nodejs.org' },
+          mimeType: 'text/html',
+          charset: 'utf-8'
+        }
+      },
+      expected: {
+        requestId: 'request-id-1',
+        timestamp: 1000,
+        type: 'Other',
+        response: {
+          url: 'https://nodejs.org/en',
+          status: 200,
+          statusText: '',
+          headers: { host: 'nodejs.org' },
+          mimeType: 'text/html',
+          charset: 'utf-8'
+        }
+      }
+    },
+    {
+      name: 'dataReceived',
+      // Network.dataReceived is buffered until Network.streamResourceContent/Network.getResponseBody is invoked.
+      skip: true,
+    },
+    {
+      name: 'dataSent',
+      // Network.dataSent is buffered until Network.getRequestPostData is invoked.
+      skip: true,
+    },
+    {
+      name: 'loadingFinished',
+      params: {
+        requestId: 'request-id-1',
+        timestamp: 1000,
+      }
+    },
+    {
+      name: 'loadingFailed',
+      params: {
+        requestId: 'request-id-1',
+        timestamp: 1000,
+        type: 'Document',
+        errorText: 'Failed to load resource'
+      }
+    },
+    {
+      name: 'webSocketCreated',
+      params: {
+        requestId: 'websocket-id-1',
+        url: 'ws://example.com:8080',
+      }
+
+    },
+    {
+      name: 'webSocketHandshakeResponseReceived',
+      params: {
+        requestId: 'websocket-id-1',
+        response: {
+          status: 101,
+          statusText: 'Switching Protocols',
+          headers: {},
+        },
+        timestamp: 1000,
+      }
+    },
+    {
+      name: 'webSocketClosed',
+      params: {
+        requestId: 'websocket-id-1',
+        timestamp: 1000,
+
+      }
+    },
+  ],
+  DOMStorage: [
+    {
+      name: 'domStorageItemAdded',
+      params: {
+        storageId: {
+          securityOrigin: '',
+          isLocalStorage: true,
+          storageKey: 'node-inspector://default-dom-storage',
+        },
+        key: 'testKey',
+        newValue: 'testValue',
+      }
+    },
+    {
+      name: 'domStorageItemRemoved',
+      skip: true
+    },
+    {
+      name: 'domStorageItemUpdated',
+      skip: true
+    },
+    {
+      name: 'domStorageItemsCleared',
+      skip: true
+    },
+    {
+      name: 'registerStorage',
+      skip: true
+    },
+  ]
+};
+
+// Check that all domains and events are present in the inspector object.
+for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) {
+  if (!(domain in inspector)) {
+    assert.fail(`Expected domain ${domain} to be present in inspector`);
+  }
+  const actualEventNames = Object.keys(inspector[domain]).sort();
+  const expectedEventNames = events.map((event) => event.name).sort();
+  assert.deepStrictEqual(actualEventNames, expectedEventNames, `Expected ${domain} to have events ${expectedEventNames}, but got ${actualEventNames}`);
+}
+
+// Check that all events throw when called with a non-object argument.
+for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) {
+  for (const event of events) {
+    assert.throws(() => inspector[domain][event.name]('params'), {
+      name: 'TypeError',
+      code: 'ERR_INVALID_ARG_TYPE',
+      message: 'The "params" argument must be of type object. Received type string (\'params\')'
+    });
+  }
+}
+
+(async () => {
+  const session = new inspector.Session();
+  session.connect();
+
+  // Check that all events emit the expected parameters.
+  await session.post('Network.enable');
+  await session.post('DOMStorage.enable');
+  for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) {
+    for (const event of events) {
+      if (event.skip) {
+        continue;
+      }
+      session.on(`${domain}.${event.name}`, common.mustCall(({ params }) => {
+        if (event.name === 'requestWillBeSent' || event.name === 'webSocketCreated') {
+          // Initiator is automatically captured and contains caller info.
+          // No need to validate it.
+          delete params.initiator;
+        }
+        assert.deepStrictEqual(params, event.expected ?? event.params);
+      }));
+      inspector[domain][event.name](event.params);
+    }
+  }
+
+  // Check tht no events are emitted after disabling the domain.
+  await session.post('Network.disable');
+  session.on('Network.requestWillBeSent', common.mustNotCall());
+  inspector.Network.requestWillBeSent({});
+})().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-enabled.js b/test/js/node/test/parallel/test-inspector-enabled.js
new file mode 100644
index 00000000000..33140ba5074
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-enabled.js
@@ -0,0 +1,29 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const spawn = require('child_process').spawn;
+
+const script = `
+const assert = require('assert');
+const inspector = process.binding('inspector');
+
+assert(
+  !!inspector.isEnabled(),
+  'inspector.isEnabled() should be true when run with --inspect');
+
+process._debugEnd();
+
+assert(
+  !inspector.isEnabled(),
+  'inspector.isEnabled() should be false after _debugEnd()');
+`;
+
+const args = ['--inspect=0', '-e', script];
+const child = spawn(process.execPath, args, {
+  stdio: 'inherit',
+  env: { ...process.env, NODE_V8_COVERAGE: '' }
+});
+child.on('exit', (code, signal) => {
+  process.exit(code || signal);
+});
diff --git a/test/js/node/test/parallel/test-inspector-exception.js b/test/js/node/test/parallel/test-inspector-exception.js
new file mode 100644
index 00000000000..fdfc6bab298
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-exception.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+const { pathToFileURL } = require('url');
+
+const script = fixtures.path('throws_error.js');
+
+async function testBreakpointOnStart(session) {
+  console.log('[test]',
+              'Verifying debugger stops on start (--inspect-brk option)');
+  const commands = [
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setPauseOnExceptions',
+      'params': { 'state': 'none' } },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 0 } },
+    { 'method': 'Profiler.enable' },
+    { 'method': 'Profiler.setSamplingInterval',
+      'params': { 'interval': 100 } },
+    { 'method': 'Debugger.setBlackboxPatterns',
+      'params': { 'patterns': [] } },
+    { 'method': 'Runtime.runIfWaitingForDebugger' },
+  ];
+
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send(commands);
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForBreakOnLine(21, pathToFileURL(script).toString());
+}
+
+
+async function runTest() {
+  const child = new NodeInstance(undefined, undefined, script);
+  const session = await child.connectInspectorSession();
+  await testBreakpointOnStart(session);
+  await session.runToCompletion();
+  assert.strictEqual((await child.expectShutdown()).exitCode, 1);
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-heap-allocation-tracker.js b/test/js/node/test/parallel/test-inspector-heap-allocation-tracker.js
new file mode 100644
index 00000000000..4002d15b3c1
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-heap-allocation-tracker.js
@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const inspector = require('inspector');
+const stream = require('stream');
+const { Worker, workerData } = require('worker_threads');
+
+const session = new inspector.Session();
+session.connect();
+session.post('HeapProfiler.enable');
+session.post('HeapProfiler.startTrackingHeapObjects',
+             { trackAllocations: true });
+
+// Perform some silly heap allocations for the next 100 ms.
+const interval = setInterval(common.mustCallAtLeast(() => {
+  new stream.PassThrough().end('abc').on('data', common.mustCall());
+}), 1);
+
+setTimeout(common.mustCall(() => {
+  clearInterval(interval);
+
+  // Once the main test is done, we re-run it from inside a Worker thread
+  // and stop early, as that is a good way to make sure the timer handles
+  // internally created by the inspector are cleaned up properly.
+  if (workerData === 'stopEarly')
+    process.exit();
+
+  let data = '';
+  session.on('HeapProfiler.addHeapSnapshotChunk',
+             common.mustCallAtLeast((event) => {
+               data += event.params.chunk;
+             }));
+
+  // TODO(addaleax): Using `{ reportProgress: true }` crashes the process
+  // because the progress indication event would mean calling into JS while
+  // a heap snapshot is being taken, which is forbidden.
+  // What can we do about that?
+  session.post('HeapProfiler.stopTrackingHeapObjects');
+
+  assert(data.includes('PassThrough'), data);
+
+  new Worker(__filename, { workerData: 'stopEarly' });
+}), 100);
diff --git a/test/js/node/test/parallel/test-inspector-invalid-args.js b/test/js/node/test/parallel/test-inspector-invalid-args.js
new file mode 100644
index 00000000000..846a46a429f
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-invalid-args.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const execFile = require('child_process').execFile;
+
+const mainScript = fixtures.path('loop.js');
+const expected =
+  '`node --debug` and `node --debug-brk` are invalid. ' +
+  'Please use `node --inspect` and `node --inspect-brk` instead.';
+for (const invalidArg of ['--debug-brk', '--debug']) {
+  execFile(
+    process.execPath,
+    [invalidArg, mainScript],
+    common.mustCall((error, stdout, stderr) => {
+      assert.strictEqual(error.code, 9, `node ${invalidArg} should exit 9`);
+      assert.strictEqual(
+        stderr.includes(expected),
+        true,
+        `${stderr} should include '${expected}'`
+      );
+    })
+  );
+}
diff --git a/test/js/node/test/parallel/test-inspector-module.js b/test/js/node/test/parallel/test-inspector-module.js
new file mode 100644
index 00000000000..cdbbc69229d
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-module.js
@@ -0,0 +1,71 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { Session } = require('inspector');
+
+const session = new Session();
+
+assert.throws(
+  () => session.post('Runtime.evaluate', { expression: '2 + 2' }),
+  {
+    code: 'ERR_INSPECTOR_NOT_CONNECTED',
+    name: 'Error',
+    message: 'Session is not connected'
+  }
+);
+
+session.connect();
+session.post('Runtime.evaluate', { expression: '2 + 2' });
+
+[1, {}, [], true, Infinity, undefined].forEach((i) => {
+  assert.throws(
+    () => session.post(i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message:
+        'The "method" argument must be of type string.' +
+        common.invalidArgTypeHelper(i)
+    }
+  );
+});
+
+[1, true, Infinity].forEach((i) => {
+  assert.throws(
+    () => session.post('test', i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+      message:
+        'The "params" argument must be of type object.' +
+        common.invalidArgTypeHelper(i)
+    }
+  );
+});
+
+[1, 'a', {}, [], true, Infinity].forEach((i) => {
+  assert.throws(
+    () => session.post('test', {}, i),
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      name: 'TypeError',
+    }
+  );
+});
+
+assert.throws(
+  () => session.connect(),
+  {
+    code: 'ERR_INSPECTOR_ALREADY_CONNECTED',
+    name: 'Error',
+    message: 'The inspector session is already connected'
+  }
+);
+
+session.disconnect();
+// Calling disconnect twice should not throw.
+session.disconnect();
diff --git a/test/js/node/test/parallel/test-inspector-multisession-ws.js b/test/js/node/test/parallel/test-inspector-multisession-ws.js
new file mode 100644
index 00000000000..6a2b1951d27
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-multisession-ws.js
@@ -0,0 +1,85 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+// Sets up JS bindings session and runs till the "paused" event
+const script = `
+const { Session } = require('inspector');
+const session = new Session();
+let done = false;
+const interval = setInterval(() => {
+  if (done)
+    clearInterval(interval);
+}, 150);
+session.on('Debugger.paused', () => {
+  done = true;
+});
+session.connect();
+session.post('Debugger.enable');
+console.log('Ready');
+`;
+
+async function setupSession(node) {
+  const session = await node.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send([
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setPauseOnExceptions',
+      'params': { 'state': 'none' } },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 0 } },
+    { 'method': 'Profiler.enable' },
+    { 'method': 'Profiler.setSamplingInterval',
+      'params': { 'interval': 100 } },
+    { 'method': 'Debugger.setBlackboxPatterns',
+      'params': { 'patterns': [] } },
+  ]);
+
+  return session;
+}
+
+async function testSuspend(sessionA, sessionB) {
+  console.log('[test]', 'Breaking in code and verifying events are fired');
+  await Promise.all([
+    sessionA.waitForNotification('Debugger.paused', 'Initial sessionA paused'),
+    sessionB.waitForNotification('Debugger.paused', 'Initial sessionB paused'),
+  ]);
+  sessionA.send({ 'method': 'Debugger.resume' });
+
+  await sessionA.waitForNotification('Runtime.consoleAPICalled',
+                                     'Console output');
+  sessionA.send({ 'method': 'Debugger.pause' });
+  return Promise.all([
+    sessionA.waitForNotification('Debugger.paused', 'SessionA paused'),
+    sessionB.waitForNotification('Debugger.paused', 'SessionB paused'),
+  ]);
+}
+
+async function runTest() {
+  const child = new NodeInstance(undefined, script);
+
+  const [session1, session2] =
+      await Promise.all([setupSession(child), setupSession(child)]);
+  await Promise.all([
+    session1.send({ method: 'Runtime.runIfWaitingForDebugger' }),
+    session2.send({ method: 'Runtime.runIfWaitingForDebugger' }),
+  ]);
+  await Promise.all([
+    session1.send({ method: 'NodeRuntime.disable' }),
+    session2.send({ method: 'NodeRuntime.disable' }),
+  ]);
+  await testSuspend(session2, session1);
+  console.log('[test]', 'Should shut down after both sessions disconnect');
+
+  await session1.runToCompletion();
+  await session2.send({ 'method': 'Debugger.disable' });
+  await session2.disconnect();
+  return child.expectShutdown();
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-network-arbitrary-data.js b/test/js/node/test/parallel/test-inspector-network-arbitrary-data.js
new file mode 100644
index 00000000000..2df76010f53
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-network-arbitrary-data.js
@@ -0,0 +1,41 @@
+// Flags: --inspect=0 --experimental-network-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const inspector = require('node:inspector/promises');
+const { Network } = require('node:inspector');
+const test = require('node:test');
+const assert = require('node:assert');
+const { waitUntil } = require('../common/inspector-helper');
+
+const session = new inspector.Session();
+session.connect();
+
+test('should emit Network.requestWillBeSent with unicode', async () => {
+  await session.post('Network.enable');
+  const expectedValue = 'CJK 汉字 🍱 🧑‍🧑‍🧒‍🧒';
+
+  const requestWillBeSentFuture = waitUntil(session, 'Network.requestWillBeSent')
+    .then(([event]) => {
+      assert.strictEqual(event.params.request.url, expectedValue);
+      assert.strictEqual(event.params.request.method, expectedValue);
+      assert.strictEqual(event.params.request.headers.mKey, expectedValue);
+    });
+
+  Network.requestWillBeSent({
+    requestId: '1',
+    timestamp: 1,
+    wallTime: 1,
+    request: {
+      url: expectedValue,
+      method: expectedValue,
+      headers: {
+        mKey: expectedValue,
+      },
+    },
+  });
+
+  await requestWillBeSentFuture;
+});
diff --git a/test/js/node/test/parallel/test-inspector-network-data-received.js b/test/js/node/test/parallel/test-inspector-network-data-received.js
new file mode 100644
index 00000000000..6aa2f68b048
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-network-data-received.js
@@ -0,0 +1,192 @@
+// Flags: --inspect=0 --experimental-network-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const inspector = require('node:inspector/promises');
+const { Network } = require('node:inspector');
+const test = require('node:test');
+const assert = require('node:assert');
+const { waitUntil } = require('../common/inspector-helper');
+const { setTimeout } = require('node:timers/promises');
+
+// The complete payload string received by the network agent
+const payloadString = `Hello, world${'.'.repeat(4096)}`;
+
+const session = new inspector.Session();
+session.connect();
+session.post('Network.enable');
+
+async function triggerNetworkEvents(requestId, charset) {
+  const url = 'https://example.com';
+  Network.requestWillBeSent({
+    requestId,
+    timestamp: 1,
+    wallTime: 1,
+    request: {
+      url,
+      method: 'GET',
+      headers: {
+        mKey: 'mValue',
+      },
+    },
+  });
+  await setTimeout(1);
+
+  Network.responseReceived({
+    requestId,
+    timestamp: 2,
+    type: 'Fetch',
+    response: {
+      url,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        mKey: 'mValue',
+      },
+      charset,
+    },
+  });
+  await setTimeout(1);
+
+  const chunk1 = Buffer.from('Hello, ');
+  Network.dataReceived({
+    requestId,
+    timestamp: 3,
+    dataLength: chunk1.byteLength,
+    encodedDataLength: chunk1.byteLength,
+    data: chunk1,
+  });
+  await setTimeout(1);
+
+  const chunk2 = Buffer.from('world');
+  Network.dataReceived({
+    requestId,
+    timestamp: 4,
+    dataLength: chunk2.byteLength,
+    encodedDataLength: chunk2.byteLength,
+    data: chunk2,
+  });
+  await setTimeout(1);
+
+  // Test inspector binary conversions with large input
+  const chunk3 = Buffer.allocUnsafe(4096).fill('.');
+  Network.dataReceived({
+    requestId,
+    timestamp: 5,
+    dataLength: chunk3.byteLength,
+    encodedDataLength: chunk3.byteLength,
+    data: chunk3,
+  });
+  await setTimeout(1);
+
+  Network.loadingFinished({
+    requestId,
+    timestamp: 6,
+  });
+}
+
+function assertNetworkEvents(session, requestId) {
+  session.on('Network.requestWillBeSent', common.mustCall(({ params }) => {
+    assert.strictEqual(params.requestId, requestId);
+  }));
+  session.on('Network.responseReceived', common.mustCall(({ params }) => {
+    assert.strictEqual(params.requestId, requestId);
+  }));
+  const loadingFinishedFuture = waitUntil(session, 'Network.loadingFinished')
+    .then(async ([{ params }]) => {
+      assert.strictEqual(params.requestId, requestId);
+    });
+
+  return loadingFinishedFuture;
+}
+
+test('should stream Network.dataReceived with data chunks', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-1';
+  const chunks = [];
+  let totalDataLength = 0;
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+  const responseReceivedFuture = waitUntil(session, 'Network.responseReceived')
+    .then(async () => {
+      const { bufferedData } = await session.post('Network.streamResourceContent', {
+        requestId,
+      });
+      const data = Buffer.from(bufferedData, 'base64');
+      totalDataLength += data.byteLength;
+      chunks.push(data);
+    });
+  session.on('Network.dataReceived', common.mustCallAtLeast(({ params }) => {
+    assert.strictEqual(params.requestId, requestId);
+    totalDataLength += params.dataLength;
+    chunks.push(Buffer.from(params.data, 'base64'));
+  }));
+
+  await triggerNetworkEvents(requestId);
+  await responseReceivedFuture;
+  await loadingFinishedFuture;
+
+  const data = Buffer.concat(chunks);
+  assert.strictEqual(data.byteLength, totalDataLength, data);
+  assert.strictEqual(data.toString('utf8'), payloadString);
+});
+
+test('Network.streamResourceContent should send all buffered chunks', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-2';
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+  session.on('Network.dataReceived', common.mustNotCall());
+
+  await triggerNetworkEvents(requestId);
+  await loadingFinishedFuture;
+  const { bufferedData } = await session.post('Network.streamResourceContent', {
+    requestId,
+  });
+  assert.strictEqual(Buffer.from(bufferedData, 'base64').toString('utf8'), payloadString);
+});
+
+test('Network.streamResourceContent should reject if request id not found', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'unknown-request-id';
+  await assert.rejects(session.post('Network.streamResourceContent', {
+    requestId,
+  }), {
+    code: 'ERR_INSPECTOR_COMMAND',
+  });
+});
+
+test('Network.getResponseBody should send all buffered binary data', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-3';
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+  session.on('Network.dataReceived', common.mustNotCall());
+
+  await triggerNetworkEvents(requestId);
+  await loadingFinishedFuture;
+  const { body, base64Encoded } = await session.post('Network.getResponseBody', {
+    requestId,
+  });
+  assert.strictEqual(base64Encoded, true);
+  assert.strictEqual(body, Buffer.from(payloadString).toString('base64'));
+});
+
+test('Network.getResponseBody should send all buffered text data', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-4';
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+  session.on('Network.dataReceived', common.mustNotCall());
+
+  await triggerNetworkEvents(requestId, 'utf-8');
+  await loadingFinishedFuture;
+  const { body, base64Encoded } = await session.post('Network.getResponseBody', {
+    requestId,
+  });
+  assert.strictEqual(base64Encoded, false);
+  assert.strictEqual(body, payloadString);
+});
diff --git a/test/js/node/test/parallel/test-inspector-network-data-sent.js b/test/js/node/test/parallel/test-inspector-network-data-sent.js
new file mode 100644
index 00000000000..5c28c1935af
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-network-data-sent.js
@@ -0,0 +1,136 @@
+// Flags: --inspect=0 --experimental-network-inspection
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const inspector = require('node:inspector/promises');
+const { Network } = require('node:inspector');
+const test = require('node:test');
+const assert = require('node:assert');
+const { waitUntil } = require('../common/inspector-helper');
+const { setTimeout } = require('node:timers/promises');
+
+const session = new inspector.Session();
+session.connect();
+session.post('Network.enable');
+
+async function triggerNetworkEvents(requestId, requestCharset) {
+  const url = 'https://example.com';
+  Network.requestWillBeSent({
+    requestId,
+    timestamp: 1,
+    wallTime: 1,
+    request: {
+      url,
+      method: 'PUT',
+      headers: {
+        mKey: 'mValue',
+      },
+      hasPostData: true,
+    },
+    charset: requestCharset,
+  });
+  await setTimeout(1);
+
+  const chunk1 = Buffer.from('Hello, ');
+  Network.dataSent({
+    requestId,
+    timestamp: 2,
+    dataLength: chunk1.byteLength,
+    data: chunk1,
+  });
+  await setTimeout(1);
+
+  const chunk2 = Buffer.from('world');
+  Network.dataSent({
+    requestId,
+    timestamp: 3,
+    dataLength: chunk2.byteLength,
+    data: chunk2,
+  });
+  await setTimeout(1);
+
+  Network.dataSent({
+    requestId,
+    finished: true,
+  });
+  await setTimeout(1);
+
+  Network.responseReceived({
+    requestId,
+    timestamp: 4,
+    type: 'Fetch',
+    response: {
+      url,
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        mKey: 'mValue',
+      },
+    },
+  });
+  await setTimeout(1);
+
+  Network.loadingFinished({
+    requestId,
+    timestamp: 5,
+  });
+}
+
+function assertNetworkEvents(session, requestId) {
+  session.on('Network.requestWillBeSent', common.mustCall(({ params }) => {
+    assert.strictEqual(params.requestId, requestId);
+  }));
+  session.on('Network.responseReceived', common.mustCall(({ params }) => {
+    assert.strictEqual(params.requestId, requestId);
+  }));
+  const loadingFinishedFuture = waitUntil(session, 'Network.loadingFinished')
+    .then(async ([{ params }]) => {
+      assert.strictEqual(params.requestId, requestId);
+    });
+
+  return loadingFinishedFuture;
+}
+
+test('Network.getRequestPostData should send all buffered text data', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-1';
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+
+  await triggerNetworkEvents(requestId, 'utf-8');
+  await loadingFinishedFuture;
+
+  const { postData } = await session.post('Network.getRequestPostData', {
+    requestId,
+  });
+  assert.strictEqual(postData, 'Hello, world');
+});
+
+test('Network.getRequestPostData does not support binary data', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'my-req-id-2';
+  const loadingFinishedFuture = assertNetworkEvents(session, requestId);
+
+  await triggerNetworkEvents(requestId);
+  await loadingFinishedFuture;
+
+  await assert.rejects(session.post('Network.getRequestPostData', {
+    requestId,
+  }), {
+    code: 'ERR_INSPECTOR_COMMAND',
+  });
+});
+
+test('Network.getRequestPostData should reject if request id not found', async () => {
+  session.removeAllListeners();
+
+  const requestId = 'unknown-request-id';
+  await assert.rejects(session.post('Network.getRequestPostData', {
+    requestId,
+  }), {
+    code: 'ERR_INSPECTOR_COMMAND',
+  });
+});
diff --git a/test/js/node/test/parallel/test-inspector-port-zero.js b/test/js/node/test/parallel/test-inspector-port-zero.js
new file mode 100644
index 00000000000..d49a30cdcd8
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-port-zero.js
@@ -0,0 +1,55 @@
+'use strict';
+const { mustCall, skipIfInspectorDisabled, mustCallAtLeast } = require('../common');
+
+skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawn } = require('child_process');
+
+function test(arg, port = '') {
+  const args = [arg, '-p', 'process.debugPort'];
+  const proc = spawn(process.execPath, args);
+  proc.stdout.setEncoding('utf8');
+  proc.stderr.setEncoding('utf8');
+  let stdout = '';
+  let stderr = '';
+  proc.stdout.on('data', (data) => stdout += data);
+  proc.stderr.on('data', (data) => stderr += data);
+  proc.stdout.on('close', mustCall((hadErr) => assert(!hadErr)));
+  proc.stderr.on('close', mustCall((hadErr) => assert(!hadErr)));
+  proc.stderr.on('data', mustCallAtLeast(() => {
+    if (!stderr.includes('\n')) return;
+    assert.match(stderr, /Debugger listening on (.+)/);
+    port = new URL(RegExp.$1).port;
+    assert(+port > 0);
+  }, 0));
+  if (/inspect-brk/.test(arg)) {
+    proc.stderr.on('data', () => {
+      if (stderr.includes('\n') && !proc.killed) proc.kill();
+    });
+  } else {
+    let onclose = mustCall(() => {
+      onclose = mustCall(() => assert.strictEqual(port, stdout.trim()));
+    });
+    proc.stdout.on('close', () => onclose());
+    proc.stderr.on('close', () => onclose());
+    proc.on('exit', mustCall((exitCode, signal) => assert.strictEqual(
+      exitCode,
+      0,
+      `exitCode: ${exitCode}, signal: ${signal}`)));
+  }
+}
+
+test('--inspect=0');
+test('--inspect=127.0.0.1:0');
+test('--inspect=localhost:0');
+
+test('--inspect-brk=0');
+test('--inspect-brk=127.0.0.1:0');
+test('--inspect-brk=localhost:0');
+
+// In these cases, the inspector doesn't listen, so an ephemeral port is not
+// allocated and the expected value of `process.debugPort` is `0`.
+test('--inspect-port=0', '0');
+test('--inspect-port=127.0.0.1:0', '0');
+test('--inspect-port=localhost:0', '0');
diff --git a/test/js/node/test/parallel/test-inspector-stop-profile-after-done.js b/test/js/node/test/parallel/test-inspector-stop-profile-after-done.js
new file mode 100644
index 00000000000..8378496753a
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-stop-profile-after-done.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+async function runTests() {
+  const child = new NodeInstance(['--inspect-brk=0'],
+                                 `let c = 0;
+                                  const interval = setInterval(() => {
+                                   console.log(new Object());
+                                   if (c++ === 10)
+                                     clearInterval(interval);
+                                 }, ${common.platformTimeout(30)});`);
+  const session = await child.connectInspectorSession();
+
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send([
+    { method: 'Profiler.setSamplingInterval',
+      params: { interval: common.platformTimeout(300) } },
+    { method: 'Profiler.enable' }]);
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.send({ method: 'Profiler.start' });
+  while (await child.nextStderrString() !==
+         'Waiting for the debugger to disconnect...');
+  await session.send({ method: 'Profiler.stop' });
+  session.disconnect();
+  assert.strictEqual((await child.expectShutdown()).exitCode, 0);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-tracing-domain.js b/test/js/node/test/parallel/test-inspector-tracing-domain.js
new file mode 100644
index 00000000000..aa31d63a015
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-tracing-domain.js
@@ -0,0 +1,92 @@
+'use strict';
+
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  // https://github.com/nodejs/node/issues/22767
+  common.skip('This test only works on a main thread');
+}
+
+const assert = require('assert');
+const { Session } = require('inspector');
+
+const session = new Session();
+
+function post(message, data) {
+  return new Promise((resolve, reject) => {
+    session.post(message, data, (err, result) => {
+      if (err)
+        reject(new Error(JSON.stringify(err)));
+      else
+        resolve(result);
+    });
+  });
+}
+
+function generateTrace() {
+  return new Promise((resolve) => setTimeout(() => {
+    for (let i = 0; i < 1000000; i++) {
+      'test' + i; // eslint-disable-line no-unused-expressions
+    }
+    resolve();
+  }, 1));
+}
+
+async function test() {
+  // This interval ensures Node does not terminate till the test is finished.
+  // Inspector session does not keep the node process running (e.g. it does not
+  // have async handles on the main event loop). It is debatable whether this
+  // should be considered a bug, and there are no plans to fix it atm.
+  const interval = setInterval(() => {}, 5000);
+  session.connect();
+  let traceNotification = null;
+  let tracingComplete = false;
+  session.on('NodeTracing.dataCollected', (n) => traceNotification = n);
+  session.on('NodeTracing.tracingComplete', () => tracingComplete = true);
+  const { categories } = await post('NodeTracing.getCategories');
+  const expectedCategories = [
+    'node',
+    'node.async_hooks',
+    'node.bootstrap',
+    'node.console',
+    'node.dns.native',
+    'node.environment',
+    'node.fs.async',
+    'node.fs.sync',
+    'node.fs_dir.async',
+    'node.fs_dir.sync',
+    'node.http',
+    'node.net.native',
+    'node.perf',
+    'node.perf.timerify',
+    'node.perf.usertiming',
+    'node.promises.rejections',
+    'node.threadpoolwork.async',
+    'node.threadpoolwork.sync',
+    'node.vm.script',
+    'v8',
+  ].sort();
+  assert.ok(categories.length === expectedCategories.length);
+  categories.forEach((category, index) => {
+    const value = expectedCategories[index];
+    assert.ok(category === value, `${category} is out of order, expect ${value}`);
+  });
+
+  const traceConfig = { includedCategories: ['v8'] };
+  await post('NodeTracing.start', { traceConfig });
+
+  for (let i = 0; i < 5; i++)
+    await generateTrace();
+  JSON.stringify(await post('NodeTracing.stop', { traceConfig }));
+  session.disconnect();
+  assert(traceNotification.params.value.length > 0);
+  assert(tracingComplete);
+  clearInterval(interval);
+  console.log('Success');
+}
+
+test().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js b/test/js/node/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js
new file mode 100644
index 00000000000..6f54231882d
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js
@@ -0,0 +1,32 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+// Test that if there is a side effect in a getter invoked through the vm
+// global proxy, Runtime.evaluate recognizes that.
+
+const assert = require('assert');
+const inspector = require('inspector');
+const vm = require('vm');
+
+const session = new inspector.Session();
+session.connect();
+
+const context = vm.createContext({
+  get a() {
+    globalThis.foo = '1';
+    return 100;
+  }
+});
+
+session.post('Runtime.evaluate', {
+  expression: 'a',
+  throwOnSideEffect: true,
+  contextId: 2 // context's id
+}, common.mustSucceed((res) => {
+  const { exception } = res.exceptionDetails;
+  assert.strictEqual(exception.className, 'EvalError');
+  assert.match(exception.description, /Possible side-effect/);
+
+  assert(context);  // Keep 'context' alive and make linter happy.
+}));
diff --git a/test/js/node/test/parallel/test-inspector-vm-global-accessors-sideeffects.js b/test/js/node/test/parallel/test-inspector-vm-global-accessors-sideeffects.js
new file mode 100644
index 00000000000..b07ce182232
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-vm-global-accessors-sideeffects.js
@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+// Regression test for https://github.com/nodejs/node/issues/27518.
+
+const assert = require('assert');
+const inspector = require('inspector');
+const vm = require('vm');
+
+const session = new inspector.Session();
+session.connect();
+
+const context = vm.createContext({
+  a: 100
+});
+
+session.post('Runtime.evaluate', {
+  expression: 'a',
+  throwOnSideEffect: true,
+  contextId: 2 // context's id
+}, common.mustSucceed((res) => {
+  assert.deepStrictEqual(res, {
+    result: {
+      type: 'number',
+      value: context.a,
+      description: '100'
+    }
+  });
+}));
diff --git a/test/js/node/test/parallel/test-inspector-wait-for-connection.js b/test/js/node/test/parallel/test-inspector-wait-for-connection.js
new file mode 100644
index 00000000000..c28bebb1daa
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-wait-for-connection.js
@@ -0,0 +1,78 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+async function runTests() {
+  const child = new NodeInstance(['-e', `(${main.toString()})()`], '', '');
+  const session = await child.connectInspectorSession();
+  await session.send({ method: 'Runtime.enable' });
+  // Check that there is only one console message received.
+  await session.waitForConsoleOutput('log', 'before wait for debugger');
+  assert.ok(!session.unprocessedNotifications()
+                    .some((n) => n.method === 'Runtime.consoleAPICalled'));
+  // Check that inspector.url() is available between inspector.open() and
+  // inspector.waitForDebugger()
+  const { result: { value } } = await session.send({
+    method: 'Runtime.evaluate',
+    params: {
+      expression: 'process._ws',
+      includeCommandLineAPI: true
+    }
+  });
+  assert.ok(value.startsWith('ws://'));
+  await session.send({ method: 'NodeRuntime.enable' });
+  child.write('first');
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
+  await session.send({ method: 'NodeRuntime.disable' });
+  // Check that messages after first and before second waitForDebugger are
+  // received
+  await session.waitForConsoleOutput('log', 'after wait for debugger');
+  await session.waitForConsoleOutput('log', 'before second wait for debugger');
+  assert.ok(!session.unprocessedNotifications()
+                    .some((n) => n.method === 'Runtime.consoleAPICalled'));
+  const secondSession = await child.connectInspectorSession();
+  // Check that inspector.waitForDebugger can be resumed from another session
+  await session.send({ method: 'NodeRuntime.enable' });
+  child.write('second');
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForConsoleOutput('log', 'after second wait for debugger');
+  assert.ok(!session.unprocessedNotifications()
+                    .some((n) => n.method === 'Runtime.consoleAPICalled'));
+  secondSession.disconnect();
+  session.disconnect();
+
+  function main(prefix) {
+    const inspector = require('inspector');
+    inspector.open(0, undefined, false);
+    process._ws = inspector.url();
+    console.log('before wait for debugger');
+    process.stdin.once('data', (data) => {
+      if (data.toString() === 'first') {
+        inspector.waitForDebugger();
+        console.log('after wait for debugger');
+        console.log('before second wait for debugger');
+        process.stdin.once('data', (data) => {
+          if (data.toString() === 'second') {
+            inspector.waitForDebugger();
+            console.log('after second wait for debugger');
+            process.exit();
+          }
+        });
+      }
+    });
+  }
+
+  // Check that inspector.waitForDebugger throws if there is no active
+  // inspector
+  const re = /^Error \[ERR_INSPECTOR_NOT_ACTIVE\]: Inspector is not active$/;
+  assert.throws(() => require('inspector').waitForDebugger(), re);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-wait.mjs b/test/js/node/test/parallel/test-inspector-wait.mjs
new file mode 100644
index 00000000000..9bb28ed22b2
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-wait.mjs
@@ -0,0 +1,28 @@
+import * as common from '../common/index.mjs';
+
+common.skipIfInspectorDisabled();
+
+import assert from 'node:assert';
+import { NodeInstance } from '../common/inspector-helper.js';
+
+
+async function runTests() {
+  const child = new NodeInstance(['--inspect-wait=0'], 'console.log(0);');
+  const session = await child.connectInspectorSession();
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+
+  // The execution should be paused until the debugger is attached
+  while (await child.nextStderrString() !== 'Debugger attached.');
+
+  await session.send({ 'method': 'Runtime.runIfWaitingForDebugger' });
+
+  // Wait for the execution to finish
+  while (await child.nextStderrString() !== 'Waiting for the debugger to disconnect...');
+
+  await session.send({ method: 'NodeRuntime.disable' });
+  session.disconnect();
+  assert.strictEqual((await child.expectShutdown()).exitCode, 0);
+}
+
+runTests().then(common.mustCall());
diff --git a/test/js/node/test/parallel/test-inspector-waiting-for-disconnect.js b/test/js/node/test/parallel/test-inspector-waiting-for-disconnect.js
new file mode 100644
index 00000000000..7c4ca7ec7cd
--- /dev/null
+++ b/test/js/node/test/parallel/test-inspector-waiting-for-disconnect.js
@@ -0,0 +1,47 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+function mainContextDestroyed(notification) {
+  return notification.method === 'Runtime.executionContextDestroyed' &&
+      notification.params.executionContextId === 1;
+}
+
+async function runTest() {
+  const child = new NodeInstance(['--inspect-brk=0', '-e', 'process.exit(55)']);
+  const session = await child.connectInspectorSession();
+  const oldStyleSession = await child.connectInspectorSession();
+  await oldStyleSession.send([
+    { method: 'Runtime.enable' }]);
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send([
+    { method: 'Runtime.enable' },
+    { method: 'NodeRuntime.notifyWhenWaitingForDisconnect',
+      params: { enabled: true } },
+    { method: 'Runtime.runIfWaitingForDebugger' }]);
+  await session.send({ method: 'NodeRuntime.disable' });
+  await session.waitForNotification((notification) => {
+    return notification.method === 'NodeRuntime.waitingForDisconnect';
+  });
+  const receivedExecutionContextDestroyed =
+    session.unprocessedNotifications().some(mainContextDestroyed);
+  if (receivedExecutionContextDestroyed) {
+    assert.fail('When NodeRuntime enabled, ' +
+      'Runtime.executionContextDestroyed should not be sent');
+  }
+  const { result: { value } } = await session.send({
+    method: 'Runtime.evaluate', params: { expression: '42' }
+  });
+  assert.strictEqual(value, 42);
+  await session.disconnect();
+  await oldStyleSession.waitForNotification(mainContextDestroyed);
+  await oldStyleSession.disconnect();
+  assert.strictEqual((await child.expectShutdown()).exitCode, 55);
+}
+
+runTest().then(common.mustCall());
diff --git a/test/js/node/test/sequential/test-debugger-custom-port.js b/test/js/node/test/sequential/test-debugger-custom-port.js
new file mode 100644
index 00000000000..5ecb91c07fe
--- /dev/null
+++ b/test/js/node/test/sequential/test-debugger-custom-port.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const fixtures = require('../common/fixtures');
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Custom port.
+const script = fixtures.path('debugger', 'three-lines.js');
+
+const cli = startCLI([`--port=${common.PORT}`, script], [], {}, { randomPort: false });
+(async function() {
+  try {
+    await cli.waitForInitialBreak();
+    await cli.waitForPrompt();
+    assert.match(cli.output, /debug>/, 'prints a prompt');
+    assert.match(
+      cli.output,
+      new RegExp(`< Debugger listening on [^\n]*${common.PORT}`),
+      'forwards child output');
+  } finally {
+    const code = await cli.quit();
+    assert.strictEqual(code, 0);
+  }
+})().then(common.mustCall());
diff --git a/test/js/node/test/sequential/test-debugger-debug-brk.js b/test/js/node/test/sequential/test-debugger-debug-brk.js
new file mode 100644
index 00000000000..7a13572a06a
--- /dev/null
+++ b/test/js/node/test/sequential/test-debugger-debug-brk.js
@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+// This test ensures that the --debug-brk flag will exit the process
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const { spawnSync } = require('child_process');
+
+// File name here doesn't actually matter the process will exit on start.
+const script = fixtures.path('empty.js');
+
+function test(arg) {
+  const child = spawnSync(process.execPath, ['--inspect', arg, script]);
+  const stderr = child.stderr.toString();
+  assert(stderr.includes('DEP0062'));
+  assert.strictEqual(child.status, 9);
+}
+
+test('--debug-brk');
+test('--debug-brk=5959');
diff --git a/test/js/node/test/sequential/test-debugger-invalid-args.js b/test/js/node/test/sequential/test-debugger-invalid-args.js
new file mode 100644
index 00000000000..83a7e253a3f
--- /dev/null
+++ b/test/js/node/test/sequential/test-debugger-invalid-args.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../common');
+
+common.skipIfInspectorDisabled();
+
+const startCLI = require('../common/debugger');
+
+const assert = require('assert');
+
+// Launch CLI w/o args.
+(async () => {
+  const cli = startCLI([], [], {}, { randomPort: false });
+  const code = await cli.quit();
+  assert.strictEqual(code, 9);
+  assert.match(cli.output, /^Usage:/, 'Prints usage info');
+})().then(common.mustCall());
+
+// Launch w/ invalid host:port.
+(async () => {
+  const cli = startCLI([`localhost:${common.PORT}`], [], {}, { randomPort: false });
+  const code = await cli.quit();
+  assert.match(
+    cli.output,
+    /failed to connect/,
+    'Tells the user that the connection failed');
+  assert.strictEqual(code, 1);
+})().then(common.mustCall());
diff --git a/test/js/node/test/sequential/test-debugger-launch.mjs b/test/js/node/test/sequential/test-debugger-launch.mjs
new file mode 100644
index 00000000000..a810ca37f2f
--- /dev/null
+++ b/test/js/node/test/sequential/test-debugger-launch.mjs
@@ -0,0 +1,37 @@
+import { skipIfInspectorDisabled } from '../common/index.mjs';
+skipIfInspectorDisabled();
+
+// This must be in sequential because we check that the default port is 9229.
+import * as fixtures from '../common/fixtures.mjs';
+import startCLI from '../common/debugger.js';
+
+import assert from 'assert';
+
+const script = fixtures.path('debugger', 'three-lines.js');
+const cli = startCLI([script], [], {}, { randomPort: false });
+try {
+  await cli.waitForInitialBreak();
+  await cli.waitForPrompt();
+  assert.match(cli.output, /debug>/, 'prints a prompt');
+  assert.match(
+    cli.output,
+    /< Debugger listening on [^\n]*9229/,
+    'forwards child output'
+  );
+  await cli.command('["hello", "world"].join(" ")');
+  assert.match(cli.output, /hello world/, 'prints the result');
+  await cli.command('');
+  assert.match(
+    cli.output,
+    /hello world/,
+    'repeats the last command on <enter>'
+  );
+  await cli.command('version');
+  assert.ok(
+    cli.output.includes(process.versions.v8),
+    'version prints the v8 version'
+  );
+} finally {
+  const code = await cli.quit();
+  assert.strictEqual(code, 0);
+}