diff --git a/doc/api/cli.md b/doc/api/cli.md
index 61a047e5ac159f..926b557944d720 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1014,6 +1014,18 @@ passing a second `parentURL` argument for contextual resolution.
 
 Previously gated the entire `import.meta.resolve` feature.
 
+### `--experimental-inspector-network-resource`
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+> Stability: 1.1 - Active Development
+
+Enables the Network.loadNetworkResource method in the Chrome DevTools Protocol (CDP) during debugging sessions.
+This feature allows DevTools to fetch additional resources directly through the inspector backend.
+
 ### `--experimental-loader=module`
 
 <!-- YAML
diff --git a/src/inspector/io_agent.cc b/src/inspector/io_agent.cc
new file mode 100644
index 00000000000000..a22bd68e8b54ee
--- /dev/null
+++ b/src/inspector/io_agent.cc
@@ -0,0 +1,50 @@
+#include "io_agent.h"
+#include "crdtp/dispatch.h"
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+void IoAgent::Wire(UberDispatcher* dispatcher) {
+  frontend_ = std::make_shared<IO::Frontend>(dispatcher->channel());
+  IO::Dispatcher::wire(dispatcher, this);
+}
+
+DispatchResponse IoAgent::read(const String& in_handle,
+                               Maybe<int> in_offset,
+                               Maybe<int> in_size,
+                               String* out_data,
+                               bool* out_eof) {
+  std::string txt = data_map_[in_handle];
+  int offset = 0;
+  if (in_offset.isJust()) {
+    offset = in_offset.fromJust();
+  } else if (offset_map_.find(in_handle) != offset_map_.end()) {
+    offset = offset_map_[in_handle];
+  }
+  int size = 1 << 20;
+  if (in_size.isJust()) {
+    size = in_size.fromJust();
+  }
+
+  if (static_cast<std::size_t>(offset) < txt.length()) {
+    std::string out_txt = txt.substr(offset, size);
+    out_data->assign(out_txt);
+  } else {
+    *out_eof = true;
+  }
+
+  offset_map_[in_handle] = offset + size;
+
+  return DispatchResponse::Success();
+}
+
+DispatchResponse IoAgent::close(const String& in_handle) {
+  offset_map_.erase(in_handle);
+  data_map_.erase(in_handle);
+  return DispatchResponse::Success();
+}
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
diff --git a/src/inspector/io_agent.h b/src/inspector/io_agent.h
new file mode 100644
index 00000000000000..e4baa2c299f326
--- /dev/null
+++ b/src/inspector/io_agent.h
@@ -0,0 +1,36 @@
+#ifndef SRC_INSPECTOR_IO_AGENT_H_
+#define SRC_INSPECTOR_IO_AGENT_H_
+
+#include <unordered_map>
+#include "node/inspector/protocol/IO.h"
+
+namespace node {
+
+namespace inspector {
+namespace protocol {
+
+class IoAgent : public IO::Backend {
+ public:
+  IoAgent() {}
+  void Wire(UberDispatcher* dispatcher);
+  DispatchResponse read(const String& in_handle,
+                        Maybe<int> in_offset,
+                        Maybe<int> in_size,
+                        String* out_data,
+                        bool* out_eof) override;
+  DispatchResponse close(const String& in_handle) override;
+
+  void setData(const std::string& key, const std::string value) {
+    data_map_[key] = value;
+  }
+
+ private:
+  std::shared_ptr<IO::Frontend> frontend_;
+  std::unordered_map<std::string, int> offset_map_;
+  std::unordered_map<std::string, std::string> data_map_;
+};
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_IO_AGENT_H_
diff --git a/src/inspector/network_agent.cc b/src/inspector/network_agent.cc
index 497260ecc93c5f..b7f3f31f5a2829 100644
--- a/src/inspector/network_agent.cc
+++ b/src/inspector/network_agent.cc
@@ -1,7 +1,13 @@
 #include "network_agent.h"
+#include <string>
+#include "env-inl.h"
 #include "inspector/protocol_helper.h"
 #include "network_inspector.h"
+#include "node_metadata.h"
 #include "util-inl.h"
+#include "uv.h"
+#include "uv/unix.h"
+#include "v8-context.h"
 #include "v8.h"
 
 namespace node {
@@ -177,8 +183,13 @@ std::unique_ptr<protocol::Network::Response> createResponseFromObject(
 }
 
 NetworkAgent::NetworkAgent(NetworkInspector* inspector,
-                           v8_inspector::V8Inspector* v8_inspector)
-    : inspector_(inspector), v8_inspector_(v8_inspector) {
+                           v8_inspector::V8Inspector* v8_inspector,
+                           Environment* env,
+                           std::shared_ptr<protocol::IoAgent> io_agent)
+    : inspector_(inspector),
+      v8_inspector_(v8_inspector),
+      env_(env),
+      io_agent_(io_agent) {
   event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent;
   event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived;
   event_notifier_map_["loadingFailed"] = &NetworkAgent::loadingFailed;
@@ -211,6 +222,148 @@ protocol::DispatchResponse NetworkAgent::disable() {
   return protocol::DispatchResponse::Success();
 }
 
+std::tuple<int, std::string, std::string> NetworkAgent::spawnFetchProcess(
+    std::string_view code, Environment* env, std::string_view url) {
+  std::string stdout_result;
+  std::string stderr_result;
+  uv_loop_t* loop = new uv_loop_t;
+  uv_loop_init(loop);
+  uv_process_t child;
+  uv_pipe_t stdout_pipe;
+  uv_pipe_init(loop, &stdout_pipe, 0);
+  uv_pipe_t stderr_pipe;
+  uv_pipe_init(loop, &stderr_pipe, 0);
+
+  uv_process_options_t uv_process_options;
+  std::string command =
+      env->exec_path() + " --eval \"" + code.data() + "\" -- " + url.data();
+
+  const char* file = env->exec_path().c_str();
+  char* args[] = {
+                  // shell_escape(env->exec_path()).c_str(),
+                  const_cast<char*>(file),
+                  const_cast<char*>("--eval"),
+                  reinterpret_cast<char*>(const_cast<char*>(code.data())),
+                  reinterpret_cast<char*>(const_cast<char*>(url.data())),
+                  nullptr};
+
+  uv_stdio_container_t stdio[3];
+  uv_process_options.file = file;
+  uv_process_options.args = args;
+  uv_process_options.flags = 0;
+  uv_process_options.stdio_count = 3;
+  uv_process_options.stdio = stdio;
+  uv_process_options.cwd = nullptr;
+  uv_process_options.env = nullptr;
+
+  uv_process_options.exit_cb =
+      [](uv_process_t* req, int64_t exit_status, int term_signal) {
+        uv_close(reinterpret_cast<uv_handle_t*>(req), nullptr);
+      };
+
+  stdio[0].flags = UV_INHERIT_FD;
+  stdio[0].data.fd = 0;
+  stdio[1].flags =
+      static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
+  stdio[1].data.stream = reinterpret_cast<uv_stream_t*>(&stdout_pipe);
+  stdio[2].flags =
+      static_cast<uv_stdio_flags>(UV_CREATE_PIPE | UV_WRITABLE_PIPE);
+  stdio[2].data.stream = reinterpret_cast<uv_stream_t*>(&stderr_pipe);
+
+  int r = uv_spawn(loop, &child, &uv_process_options);
+
+  if (r != 0) {
+    uv_loop_close(loop);
+    delete loop;
+    return {r, stdout_result, stderr_result};
+  }
+
+  auto alloc_cb =
+      [](uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+        buf->base = static_cast<char*>(malloc(suggested_size));
+        buf->len = suggested_size;
+      };
+
+  auto read_cb = [](uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
+    auto* response = static_cast<std::string*>(stream->data);
+    if (nread > 0) {
+      response->append(buf->base, nread);
+    } else if (nread < 0) {
+      if (!response->empty() && response->back() == '\n') {
+        response->pop_back();
+      }
+      uv_close(reinterpret_cast<uv_handle_t*>(stream), nullptr);
+    }
+    if (buf->base) free(buf->base);
+  };
+
+  stdout_pipe.data = &stdout_result;
+  uv_read_start(
+      reinterpret_cast<uv_stream_t*>(&stdout_pipe), alloc_cb, read_cb);
+
+  stderr_pipe.data = &stderr_result;
+  uv_read_start(
+      reinterpret_cast<uv_stream_t*>(&stderr_pipe), alloc_cb, read_cb);
+
+  uv_run(loop, UV_RUN_DEFAULT);
+
+  uv_walk(
+      loop,
+      [](uv_handle_t* handle, void*) {
+        if (!uv_is_closing(handle)) {
+          uv_close(handle, nullptr);
+        }
+      },
+      nullptr);
+
+  uv_run(loop, UV_RUN_DEFAULT);
+
+  uv_loop_close(loop);
+  delete loop;
+  return {r, stdout_result, stderr_result};
+}
+
+protocol::DispatchResponse NetworkAgent::loadNetworkResource(
+    const protocol::String& in_url,
+    std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult>*
+        out_resource) {
+  if (!env_->options()->experimental_inspector_network_resource) {
+    return protocol::DispatchResponse::MethodNotFound(
+        "Network.loadNetworkResource is not supported in this environment. "
+        "Please enable the experimental-inspector-network-resource option.");
+  }
+  DCHECK(io_agent_);
+
+  std::string code = R"(
+      fetch(process.argv[1], {signal: AbortSignal.timeout(2000) }).then(res => {
+        if (res.ok) {
+          res.text().then(console.log)
+        } else {
+          throw new Error('Network error: ' + res.status);
+        }
+      })
+    )";
+
+  auto [r, response, err] = spawnFetchProcess(code, env_, in_url);
+  if (r == 0 && err.empty()) {
+    std::string uuid = std::to_string(load_id_counter_);
+    load_id_counter_++;
+    io_agent_->setData(uuid, response);
+    auto result = protocol::Network::LoadNetworkResourcePageResult::create()
+                      .setSuccess(true)
+                      .setStream(uuid)
+                      .build();
+    out_resource->reset(result.release());
+  } else {
+    auto result = protocol::Network::LoadNetworkResourcePageResult::create()
+                      .setSuccess(false)
+                      .build();
+    out_resource->reset(result.release());
+  }
+
+  return protocol::DispatchResponse::Success();
+}
+
 void NetworkAgent::requestWillBeSent(v8::Local<v8::Context> context,
                                      v8::Local<v8::Object> params) {
   protocol::String request_id;
diff --git a/src/inspector/network_agent.h b/src/inspector/network_agent.h
index 459195ad6d31c2..eb12044faf5882 100644
--- a/src/inspector/network_agent.h
+++ b/src/inspector/network_agent.h
@@ -1,6 +1,8 @@
 #ifndef SRC_INSPECTOR_NETWORK_AGENT_H_
 #define SRC_INSPECTOR_NETWORK_AGENT_H_
 
+#include "env.h"
+#include "io_agent.h"
 #include "node/inspector/protocol/Network.h"
 
 #include <unordered_map>
@@ -13,7 +15,9 @@ class NetworkInspector;
 class NetworkAgent : public protocol::Network::Backend {
  public:
   explicit NetworkAgent(NetworkInspector* inspector,
-                        v8_inspector::V8Inspector* v8_inspector);
+                        v8_inspector::V8Inspector* v8_inspector,
+                        Environment* env,
+                        std::shared_ptr<protocol::IoAgent> io_agent);
 
   void Wire(protocol::UberDispatcher* dispatcher);
 
@@ -21,6 +25,11 @@ class NetworkAgent : public protocol::Network::Backend {
 
   protocol::DispatchResponse disable() override;
 
+  protocol::DispatchResponse loadNetworkResource(
+      const protocol::String& in_url,
+      std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult>*
+          out_resource) override;
+
   void emitNotification(v8::Local<v8::Context> context,
                         const protocol::String& event,
                         v8::Local<v8::Object> params);
@@ -38,12 +47,17 @@ class NetworkAgent : public protocol::Network::Backend {
                        v8::Local<v8::Object> params);
 
  private:
+  std::tuple<int, std::string, std::string> spawnFetchProcess(
+      std::string_view code, Environment* env, std::string_view url);
   NetworkInspector* inspector_;
   v8_inspector::V8Inspector* v8_inspector_;
   std::shared_ptr<protocol::Network::Frontend> frontend_;
+  Environment* env_;
   using EventNotifier = void (NetworkAgent::*)(v8::Local<v8::Context> context,
                                                v8::Local<v8::Object>);
   std::unordered_map<protocol::String, EventNotifier> event_notifier_map_;
+  std::shared_ptr<protocol::IoAgent> io_agent_;
+  int load_id_counter_ = 1;
 };
 
 }  // namespace inspector
diff --git a/src/inspector/network_inspector.cc b/src/inspector/network_inspector.cc
index e93db7bbe922f6..a1b20e402cb629 100644
--- a/src/inspector/network_inspector.cc
+++ b/src/inspector/network_inspector.cc
@@ -4,9 +4,11 @@ namespace node {
 namespace inspector {
 
 NetworkInspector::NetworkInspector(Environment* env,
-                                   v8_inspector::V8Inspector* v8_inspector)
+                                   v8_inspector::V8Inspector* v8_inspector,
+                                   std::shared_ptr<protocol::IoAgent> io_agent)
     : enabled_(false), env_(env) {
-  network_agent_ = std::make_unique<NetworkAgent>(this, v8_inspector);
+  network_agent_ =
+      std::make_unique<NetworkAgent>(this, v8_inspector, env, io_agent);
 }
 NetworkInspector::~NetworkInspector() {
   network_agent_.reset();
diff --git a/src/inspector/network_inspector.h b/src/inspector/network_inspector.h
index 4095a05394cd8a..a67689e9bbb6f9 100644
--- a/src/inspector/network_inspector.h
+++ b/src/inspector/network_inspector.h
@@ -11,8 +11,10 @@ namespace inspector {
 
 class NetworkInspector {
  public:
-  explicit NetworkInspector(Environment* env,
-                            v8_inspector::V8Inspector* v8_inspector);
+  explicit NetworkInspector(
+      Environment* env,
+      v8_inspector::V8Inspector* v8_inspector,
+      std::shared_ptr<protocol::IoAgent> io_agent = nullptr);
   ~NetworkInspector();
 
   void Wire(protocol::UberDispatcher* dispatcher);
diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi
index b789018e24f545..cfe80c70d1b9d0 100644
--- a/src/inspector/node_inspector.gypi
+++ b/src/inspector/node_inspector.gypi
@@ -34,6 +34,8 @@
       'src/inspector/network_agent.h',
       'src/inspector/worker_inspector.cc',
       'src/inspector/worker_inspector.h',
+      'src/inspector/io_agent.cc',
+      'src/inspector/io_agent.h',
     ],
     'node_inspector_generated_sources': [
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Forward.h',
@@ -47,6 +49,8 @@
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.h',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.cpp',
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h',
+      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/IO.h',
+      '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/IO.cpp',
     ],
     'node_protocol_files': [
       '<(protocol_tool_path)/lib/Forward_h.template',
diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
index 2fe6634ad7e278..3f56a9d265bdea 100644
--- a/src/inspector/node_protocol.pdl
+++ b/src/inspector/node_protocol.pdl
@@ -177,12 +177,25 @@ experimental domain Network
   # Request / response headers as keys / values of JSON object.
   type Headers extends object
 
+  type LoadNetworkResourcePageResult extends object
+    properties
+      boolean success
+      optional IO.StreamHandle stream
+
   # Disables network tracking, prevents network events from being sent to the client.
   command disable
 
   # Enables network tracking, network events will now be delivered to the client.
   command enable
 
+  # Fetches the resource and returns the content.
+  command loadNetworkResource
+    parameters
+      # URL of the resource to get content for.
+      string url
+    returns
+      LoadNetworkResourcePageResult resource
+
   # Fired when page is about to send HTTP request.
   event requestWillBeSent
     parameters
@@ -249,3 +262,25 @@ experimental domain NodeRuntime
   # This event is fired when the runtime is waiting for the debugger. For
   # example, when inspector.waitingForDebugger is called
   event waitingForDebugger
+
+domain IO
+  type StreamHandle extends string
+  # Read a chunk of the stream
+  command read
+    parameters
+      # Handle of the stream to read.
+      StreamHandle handle
+      # Seek to the specified offset before reading (if not specified, proceed with offset
+      # following the last read). Some types of streams may only support sequential reads.
+      optional integer offset
+      # Maximum number of bytes to read (left upon the agent discretion if not specified).
+      optional integer size
+    returns
+      # Data that were read.
+      string data
+      # Set if the end-of-file condition occurred while reading.
+      boolean eof
+  command close
+    parameters
+      # Handle of the stream to close.
+      StreamHandle handle
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index a68b19fd8a3930..5adb1b7f454d0d 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -2,6 +2,7 @@
 
 #include "crdtp/json.h"
 #include "env-inl.h"
+#include "inspector/io_agent.h"
 #include "inspector/main_thread_interface.h"
 #include "inspector/network_inspector.h"
 #include "inspector/node_json.h"
@@ -236,8 +237,12 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     }
     runtime_agent_ = std::make_unique<protocol::RuntimeAgent>();
     runtime_agent_->Wire(node_dispatcher_.get());
+    if (env->options()->experimental_inspector_network_resource) {
+      io_agent_ = std::make_unique<protocol::IoAgent>();
+      io_agent_->Wire(node_dispatcher_.get());
+    }
     network_inspector_ =
-        std::make_unique<NetworkInspector>(env, inspector.get());
+        std::make_unique<NetworkInspector>(env, inspector.get(), io_agent_);
     network_inspector_->Wire(node_dispatcher_.get());
   }
 
@@ -384,6 +389,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<protocol::TracingAgent> tracing_agent_;
   std::unique_ptr<protocol::WorkerAgent> worker_agent_;
   std::unique_ptr<NetworkInspector> network_inspector_;
+  std::shared_ptr<protocol::IoAgent> io_agent_;
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
   std::unique_ptr<UberDispatcher> node_dispatcher_;
diff --git a/src/node_options.cc b/src/node_options.cc
index c0a3384735c258..1413f465169f36 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -642,6 +642,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
   AddOption("--experimental-network-inspection",
             "experimental network inspection support",
             &EnvironmentOptions::experimental_network_inspection);
+  AddOption("--experimental-inspector-network-resource",
+            "experimental load network resources via the inspector",
+            &EnvironmentOptions::experimental_inspector_network_resource);
   AddOption(
       "--heap-prof",
       "Start the V8 heap profiler on start up, and write the heap profile "
diff --git a/src/node_options.h b/src/node_options.h
index 8c2025e849a856..dd7e43ecdf2d6f 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -173,6 +173,7 @@ class EnvironmentOptions : public Options {
   std::string cpu_prof_name;
   bool cpu_prof = false;
   bool experimental_network_inspection = false;
+  bool experimental_inspector_network_resource = false;
   std::string heap_prof_dir;
   std::string heap_prof_name;
   static const uint64_t kDefaultHeapProfInterval = 512 * 1024;
diff --git a/test/fixtures/inspector-network-resource/app.js b/test/fixtures/inspector-network-resource/app.js
new file mode 100644
index 00000000000000..360fcf153f748c
--- /dev/null
+++ b/test/fixtures/inspector-network-resource/app.js
@@ -0,0 +1,6 @@
+"use strict";
+function add(a, b) {
+    return a + b;
+}
+add(5, 3);
+//# sourceMappingURL=http://localhost:3000/app.js.map
diff --git a/test/fixtures/inspector-network-resource/app.js.map b/test/fixtures/inspector-network-resource/app.js.map
new file mode 100644
index 00000000000000..ca4bb9159baeaa
--- /dev/null
+++ b/test/fixtures/inspector-network-resource/app.js.map
@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "file": "app.js",
+  "sourceRoot": "",
+  "sources": [
+    "http://localhost:3000/app.ts"
+  ],
+  "names": [],
+  "mappings": ";AAAA,SAAS,GAAG,CAAC,CAAS,EAAE,CAAS;IAC/B,OAAO,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"
+}
diff --git a/test/fixtures/inspector-network-resource/app.ts b/test/fixtures/inspector-network-resource/app.ts
new file mode 100644
index 00000000000000..af0485d4954525
--- /dev/null
+++ b/test/fixtures/inspector-network-resource/app.ts
@@ -0,0 +1,5 @@
+function add(a: number, b: number): number {
+  return a + b;
+}
+
+add(5, 3);
diff --git a/test/parallel/test-inspector-load-network-resource.js b/test/parallel/test-inspector-load-network-resource.js
new file mode 100644
index 00000000000000..2f613774785aef
--- /dev/null
+++ b/test/parallel/test-inspector-load-network-resource.js
@@ -0,0 +1,200 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const http = require('node:http');
+const fs = require('node:fs');
+const { NodeInstance } = require('../common/inspector-helper');
+const assert = require('node:assert');
+
+common.skipIfInspectorDisabled();
+
+
+async function test(
+  {
+    serverCb,
+    assertLoadMapResult,
+    assertReadMapResult,
+    assertLoadTsResult,
+    assertReadTsResult,
+    readMap,
+    getMapUrl
+  }
+) {
+  const child = new NodeInstance(['--inspect-brk=0', '--experimental-inspector-network-resource'],
+                                 '',
+                                 fixtures.path('inspector-network-resource/app.js')
+  );
+
+  const server = http.createServer(serverCb);
+
+  server.listen(0);
+
+  const session = await child.connectInspectorSession();
+
+
+  await session.send({ method: 'NodeRuntime.enable' });
+  await session.waitForNotification('NodeRuntime.waitingForDebugger');
+  await session.send({ method: 'Runtime.enable' });
+  await session.send({ method: 'Debugger.enable' });
+  await session.send({ method: 'Runtime.runIfWaitingForDebugger' });
+  await session.waitForNotification((notification) => {
+    return notification.method === 'Debugger.scriptParsed' &&
+                notification.params.url.includes('app.js');
+  });
+
+  let result = await session.send({ method: 'Network.loadNetworkResource',
+                                    params: {
+                                      url: getMapUrl ?
+                                        getMapUrl(server) :
+                                        'http://localhost:' + server.address().port + '/app.js.map',
+                                    } });
+  let streamId = result.resource.stream || 'notExistsStreamId';
+
+  assertLoadMapResult(result);
+
+  result = await (readMap ?
+    readMap(session, streamId) :
+    session.send({ method: 'IO.read',
+                   params: {
+                     handle: streamId
+                   } }));
+
+  assertReadMapResult(result);
+
+  await session.send({ method: 'IO.close',
+                       params: {
+                         handle: streamId
+                       } });
+
+  result = await session.send({ method: 'Network.loadNetworkResource',
+                                params: {
+                                  url: 'http://localhost:' + server.address().port + '/app.ts'
+                                } });
+
+  streamId = result.resource.stream || 'notExistsStreamId';
+  assertLoadTsResult(result);
+  result = await session.send({ method: 'IO.read',
+                                params: {
+                                  handle: streamId
+                                } });
+  assertReadTsResult(result);
+  await session.send({ method: 'IO.close',
+                       params: {
+                         handle: streamId
+                       } });
+
+  server.close();
+  await session.waitForNotification('Debugger.paused');
+  await session.send({ method: 'Debugger.resume' });
+  await session.waitForDisconnect();
+}
+
+const mapText = fs.readFileSync(
+  fixtures.path('inspector-network-resource/app.js.map'), 'utf8'
+);
+
+const main = {
+  serverCb: (req, res) => {
+    const filename = req.url.split('/').pop();
+    const data = fs.readFileSync(fixtures.path('inspector-network-resource/' + filename));
+    res.writeHead(200, {
+      'Content-Type': 'application/javascript',
+      'Content-Length': data.length
+    });
+    res.end(data);
+  },
+  assertLoadMapResult: (result) => {
+    assert.ok(result.resource.success);
+    assert.ok(result.resource.stream);
+  },
+  assertReadMapResult: (result) => {
+    assert.ok(result.data);
+    assert.ok(result.data.length > 0);
+    assert.ok(result.data.includes(mapText));
+  },
+  assertLoadTsResult: (result) => {
+    assert.ok(result.resource.success);
+    assert.ok(result.resource.stream);
+  },
+  assertReadTsResult: (result) => {
+    assert.ok(result.data);
+    assert.ok(result.data.length > 0);
+    assert.ok(result.data.includes('function add(a: number, b: number): number {'));
+  }
+
+};
+
+const timeout = {
+  serverCb: (req, res) => {},
+  assertLoadMapResult: (result) => {
+    assert.strictEqual(result.resource.success, false);
+  },
+  assertReadMapResult: (result) => {
+    assert.strictEqual(result.data, '');
+  },
+  assertLoadTsResult: (result) => {
+    assert.strictEqual(result.resource.success, false);
+  },
+  assertReadTsResult: (result) => {
+    assert.strictEqual(result.data, '');
+  }
+};
+
+const smallChunkRead = {
+  ...main,
+  readMap: async (session, stream) => {
+    let result = await session.send({ method: 'IO.read', params: { handle: stream, size: 10 } });
+    assert.strictEqual(result.data.length, 10);
+    assert.strictEqual(result.data, mapText.slice(0, 10));
+    result = await session.send({ method: 'IO.read',
+                                  params: {
+                                    handle: stream,
+                                    size: 10,
+                                    offset: 10
+                                  } });
+    assert.strictEqual(result.data.length, 10);
+    assert.strictEqual(result.data, mapText.slice(10, 20));
+
+    result = await session.send({ method: 'IO.read',
+                                  params: {
+                                    handle: stream,
+                                    size: 10,
+                                    offset: 30
+                                  } });
+
+    assert.strictEqual(result.data.length, 10);
+    assert.strictEqual(result.data, mapText.slice(30, 40));
+
+    result = await session.send({ method: 'IO.read',
+                                  params: {
+                                    handle: stream,
+                                    size: 10,
+                                    offset: mapText.length - 10
+                                  } });
+
+    assert.strictEqual(result.data.length, 10);
+    assert.strictEqual(result.data, mapText.slice(mapText.length - 10));
+
+    result = await session.send({ method: 'IO.read',
+                                  params: {
+                                    handle: stream,
+                                    size: 10,
+                                  } });
+
+    assert.strictEqual(result.data.length, 0);
+    assert.strictEqual(result.eof, true);
+
+    return result;
+  },
+  assertReadMapResult: () => {}
+};
+
+const invalidUrl = {
+  ...timeout,
+  getMapUrl: () => 'invalid-url',
+};
+
+test(main).then(common.mustCall());
+test(timeout).then(common.mustCall());
+test(smallChunkRead).then(common.mustCall());
+test(invalidUrl).then(common.mustCall());