diff --git a/deps/inspector_protocol/README.node b/deps/inspector_protocol/README.node
index af4618cd6160e5..f37ddb9e9280b6 100644
--- a/deps/inspector_protocol/README.node
+++ b/deps/inspector_protocol/README.node
@@ -2,7 +2,7 @@ Name: inspector protocol
 Short Name: inspector_protocol
 URL: https://chromium.googlesource.com/deps/inspector_protocol/
 Version: 0
-Revision: 69d69ddf3aa698b171886551a4a672c5af1ad902
+Revision: af7f5a8173fdbc29f0835ec94395932e328b2ea2
 License: BSD
 License File: LICENSE
 Security Critical: no
diff --git a/deps/inspector_protocol/crdtp/cbor.cc b/deps/inspector_protocol/crdtp/cbor.cc
index 801c1708022763..dc52549c55a6fe 100644
--- a/deps/inspector_protocol/crdtp/cbor.cc
+++ b/deps/inspector_protocol/crdtp/cbor.cc
@@ -833,7 +833,7 @@ void ParseUTF16String(CBORTokenizer* tokenizer, ParserHandler* out) {
   span<uint8_t> rep = tokenizer->GetString16WireRep();
   for (size_t ii = 0; ii < rep.size(); ii += 2)
     value.push_back((rep[ii + 1] << 8) | rep[ii]);
-  out->HandleString16(span<uint16_t>(value.data(), value.size()));
+  out->HandleString16(value);
   tokenizer->Next();
 }
 
@@ -1037,7 +1037,7 @@ void ParseCBOR(span<uint8_t> bytes, ParserHandler* out) {
 Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
                                    span<uint8_t> string8_value,
                                    std::vector<uint8_t>* cbor) {
-  span<uint8_t> bytes(cbor->data(), cbor->size());
+  span<uint8_t> bytes(*cbor);
   CBORTokenizer tokenizer(bytes);
   if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
     return tokenizer.Status();
diff --git a/deps/inspector_protocol/crdtp/cbor_test.cc b/deps/inspector_protocol/crdtp/cbor_test.cc
index 058cd787d6416b..2d3689e730047c 100644
--- a/deps/inspector_protocol/crdtp/cbor_test.cc
+++ b/deps/inspector_protocol/crdtp/cbor_test.cc
@@ -349,7 +349,7 @@ TEST(EncodeDecodeString16Test, RoundtripsHelloWorld) {
   std::array<uint16_t, 10> msg{
       {'H', 'e', 'l', 'l', 'o', ',', ' ', 0xd83c, 0xdf0e, '.'}};
   std::vector<uint8_t> encoded;
-  EncodeString16(span<uint16_t>(msg.data(), msg.size()), &encoded);
+  EncodeString16(msg, &encoded);
   // This will be encoded as BYTE_STRING of length 20, so the 20 is encoded in
   // the additional info part of the initial byte. Payload is two bytes for each
   // UTF16 character.
@@ -384,7 +384,7 @@ TEST(EncodeDecodeString16Test, Roundtrips500) {
   for (uint16_t ii = 0; ii < 250; ++ii)
     two_fifty.push_back(ii);
   std::vector<uint8_t> encoded;
-  EncodeString16(span<uint16_t>(two_fifty.data(), two_fifty.size()), &encoded);
+  EncodeString16(two_fifty, &encoded);
   EXPECT_EQ(3u + 250u * 2, encoded.size());
   // Now check the first three bytes:
   // Major type: 2 (BYTE_STRING)
@@ -501,7 +501,7 @@ TEST(EncodeFromLatin1Test, ConvertsToUTF8IfNeeded) {
 TEST(EncodeFromUTF16Test, ConvertsToUTF8IfEasy) {
   std::vector<uint16_t> ascii = {'e', 'a', 's', 'y'};
   std::vector<uint8_t> encoded;
-  EncodeFromUTF16(span<uint16_t>(ascii.data(), ascii.size()), &encoded);
+  EncodeFromUTF16(ascii, &encoded);
 
   CBORTokenizer tokenizer(SpanFrom(encoded));
   EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
@@ -518,7 +518,7 @@ TEST(EncodeFromUTF16Test, EncodesAsString16IfNeeded) {
   std::vector<uint16_t> msg = {'H', 'e', 'l',    'l',    'o',
                                ',', ' ', 0xd83c, 0xdf0e, '.'};
   std::vector<uint8_t> encoded;
-  EncodeFromUTF16(span<uint16_t>(msg.data(), msg.size()), &encoded);
+  EncodeFromUTF16(msg, &encoded);
 
   CBORTokenizer tokenizer(SpanFrom(encoded));
   EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
@@ -535,7 +535,7 @@ TEST(EncodeDecodeBinaryTest, RoundtripsHelloWorld) {
   std::vector<uint8_t> binary = {'H', 'e', 'l', 'l', 'o', ',', ' ',
                                  'w', 'o', 'r', 'l', 'd', '.'};
   std::vector<uint8_t> encoded;
-  EncodeBinary(span<uint8_t>(binary.data(), binary.size()), &encoded);
+  EncodeBinary(binary, &encoded);
   // So, on the wire we see that the binary blob travels unmodified.
   EXPECT_THAT(
       encoded,
@@ -699,7 +699,7 @@ TEST(JSONToCBOREncoderTest, SevenBitStrings) {
   Status status;
   std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
   std::vector<uint16_t> utf16 = {'f', 'o', 'o'};
-  encoder->HandleString16(span<uint16_t>(utf16.data(), utf16.size()));
+  encoder->HandleString16(utf16);
   EXPECT_THAT(status, StatusIsOk());
   // Here we assert that indeed, seven bit strings are represented as
   // bytes on the wire, "foo" is just "foo".
@@ -771,7 +771,7 @@ TEST(JsonCborRoundtrip, EncodingDecoding) {
   std::string decoded;
   std::unique_ptr<ParserHandler> json_encoder =
       json::NewJSONEncoder(&decoded, &status);
-  ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_encoder.get());
+  ParseCBOR(encoded, json_encoder.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ(json, decoded);
 }
@@ -791,7 +791,7 @@ TEST(JsonCborRoundtrip, MoreRoundtripExamples) {
     std::string decoded;
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&decoded, &status);
-    ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_writer.get());
+    ParseCBOR(encoded, json_writer.get());
     EXPECT_THAT(status, StatusIsOk());
     EXPECT_EQ(json, decoded);
   }
@@ -842,7 +842,7 @@ TEST(ParseCBORTest, ParseEmptyCBORMessage) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
+  ParseCBOR(in, json_writer.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{}", out);
 }
@@ -866,7 +866,7 @@ TEST(ParseCBORTest, ParseCBORHelloWorld) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out);
 }
@@ -887,7 +887,7 @@ TEST(ParseCBORTest, UTF8IsSupportedInKeys) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out);
 }
@@ -898,7 +898,7 @@ TEST(ParseCBORTest, NoInputError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
+  ParseCBOR(in, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0u));
   EXPECT_EQ("", out);
 }
@@ -914,7 +914,7 @@ TEST(ParseCBORTest, UnexpectedEofExpectedValueError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
                                bytes.size()));
   EXPECT_EQ("", out);
@@ -932,7 +932,7 @@ TEST(ParseCBORTest, UnexpectedEofInArrayError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status,
               StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, bytes.size()));
   EXPECT_EQ("", out);
@@ -947,7 +947,7 @@ TEST(ParseCBORTest, UnexpectedEofInMapError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_MAP, 7u));
   EXPECT_EQ("", out);
 }
@@ -963,7 +963,7 @@ TEST(ParseCBORTest, EnvelopeEncodingLegacy) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ(out, "{\"foo\":42}");
 }
@@ -980,7 +980,7 @@ TEST(ParseCBORTest, EnvelopeEncodingBySpec) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ(out, "{\"foo\":42}");
 }
@@ -991,7 +991,7 @@ TEST(ParseCBORTest, NoEmptyEnvelopesAllowed) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
                                bytes.size()));
   EXPECT_EQ("", out);
@@ -1021,7 +1021,7 @@ TEST(ParseCBORTest, OnlyMapsAndArraysSupportedInsideEnvelopes) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
                                error_pos));
   EXPECT_EQ("", out);
@@ -1038,7 +1038,7 @@ TEST(ParseCBORTest, InvalidMapKeyError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_MAP_KEY, 7u));
   EXPECT_EQ("", out);
 }
@@ -1068,7 +1068,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     Status status;
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    ParseCBOR(bytes, json_writer.get());
     EXPECT_THAT(status, StatusIsOk());
     EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out);
   }
@@ -1078,7 +1078,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     Status status;
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    ParseCBOR(bytes, json_writer.get());
     EXPECT_THAT(status, StatusIsOk());
   }
 
@@ -1097,7 +1097,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     Status status;
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    ParseCBOR(bytes, json_writer.get());
     EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
                                  opening_segment_size * 301));
   }
@@ -1107,7 +1107,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     Status status;
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    ParseCBOR(bytes, json_writer.get());
     EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
                                  opening_segment_size * 301));
   }
@@ -1126,7 +1126,7 @@ TEST(ParseCBORTest, UnsupportedValueError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_UNSUPPORTED_VALUE, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1148,7 +1148,7 @@ TEST(ParseCBORTest, InvalidString16Error) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING16, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1167,7 +1167,7 @@ TEST(ParseCBORTest, InvalidString8Error) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING8, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1188,7 +1188,7 @@ TEST(ParseCBORTest, InvalidBinaryError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_BINARY, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1208,7 +1208,7 @@ TEST(ParseCBORTest, InvalidDoubleError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_DOUBLE, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1228,7 +1228,7 @@ TEST(ParseCBORTest, InvalidSignedError) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_INT32, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1250,7 +1250,7 @@ TEST(ParseCBORTest, TrailingJunk) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_TRAILING_JUNK, error_pos));
   EXPECT_EQ("", out);
 }
@@ -1272,7 +1272,7 @@ TEST(ParseCBORTest, EnvelopeContentsLengthMismatch) {
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  ParseCBOR(bytes, json_writer.get());
   EXPECT_THAT(status, StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
                                bytes.size()));
   EXPECT_EQ("", out);
diff --git a/deps/inspector_protocol/crdtp/json.cc b/deps/inspector_protocol/crdtp/json.cc
index 479f9ba51875ab..bc3b8a6d9093c7 100644
--- a/deps/inspector_protocol/crdtp/json.cc
+++ b/deps/inspector_protocol/crdtp/json.cc
@@ -149,23 +149,31 @@ class JSONEncoder : public ParserHandler {
     Emit('"');
     for (const uint16_t ch : chars) {
       if (ch == '"') {
-        Emit('\\'); Emit('"');
+        Emit('\\');
+        Emit('"');
       } else if (ch == '\\') {
-        Emit('\\'); Emit('\\');
+        Emit('\\');
+        Emit('\\');
       } else if (ch >= 32 && ch <= 127) {
         Emit(ch);
       } else if (ch == '\n') {
-        Emit('\\'); Emit('n');
+        Emit('\\');
+        Emit('n');
       } else if (ch == '\r') {
-        Emit('\\'); Emit('r');
+        Emit('\\');
+        Emit('r');
       } else if (ch == '\t') {
-        Emit('\\'); Emit('t');
+        Emit('\\');
+        Emit('t');
       } else if (ch == '\b') {
-        Emit('\\'); Emit('b');
+        Emit('\\');
+        Emit('b');
       } else if (ch == '\f') {
-        Emit('\\'); Emit('f');
+        Emit('\\');
+        Emit('f');
       } else {
-        Emit('\\'); Emit('u');
+        Emit('\\');
+        Emit('u');
         PrintHex(ch, out_);
       }
     }
@@ -177,26 +185,42 @@ class JSONEncoder : public ParserHandler {
       return;
     state_.top().StartElement(out_);
     Emit('"');
+    // Fast path for input strings that can be emitted as-is.
+    if (std::all_of(chars.begin(), chars.end(), [](uint8_t c) {
+          return c != '"' && c != '\\' && c >= 32 && c <= 127;
+        })) {
+      Emit(chars);
+      Emit('"');
+      return;
+    }
     for (size_t ii = 0; ii < chars.size(); ++ii) {
       uint8_t c = chars[ii];
       if (c == '"') {
-        Emit('\\'); Emit('"');
+        Emit('\\');
+        Emit('"');
       } else if (c == '\\') {
-        Emit('\\'); Emit('\\');
+        Emit('\\');
+        Emit('\\');
       } else if (c >= 32 && c <= 127) {
         Emit(c);
       } else if (c == '\n') {
-        Emit('\\'); Emit('n');
+        Emit('\\');
+        Emit('n');
       } else if (c == '\r') {
-        Emit('\\'); Emit('r');
+        Emit('\\');
+        Emit('r');
       } else if (c == '\t') {
-        Emit('\\'); Emit('t');
+        Emit('\\');
+        Emit('t');
       } else if (c == '\b') {
-        Emit('\\'); Emit('b');
+        Emit('\\');
+        Emit('b');
       } else if (c == '\f') {
-        Emit('\\'); Emit('f');
+        Emit('\\');
+        Emit('f');
       } else if (c < 32) {
-        Emit('\\'); Emit('u');
+        Emit('\\');
+        Emit('u');
         PrintHex(static_cast<uint16_t>(c), out_);
       } else {
         // Inspect the leading byte to figure out how long the utf8
@@ -330,10 +354,11 @@ class JSONEncoder : public ParserHandler {
     if (!status_->ok())
       return;
     state_.top().StartElement(out_);
-    if (value)
+    if (value) {
       Emit("true");
-    else
+    } else {
       Emit("false");
+    }
   }
 
   void HandleNull() override {
@@ -351,13 +376,16 @@ class JSONEncoder : public ParserHandler {
 
  private:
   inline void Emit(char c) { out_->push_back(c); }
-  template<size_t N>
+  template <size_t N>
   inline void Emit(const char (&str)[N]) {
     out_->insert(out_->end(), str, str + N - 1);
   }
   inline void Emit(const std::string& str) {
     out_->insert(out_->end(), str.begin(), str.end());
   }
+  inline void Emit(const span<uint8_t>& bytes) {
+    out_->insert(out_->end(), bytes.begin(), bytes.end());
+  }
 
   C* out_;
   Status* status_;
@@ -882,7 +910,7 @@ class JsonParser {
           HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
           return;
         }
-        handler_->HandleString16(span<uint16_t>(value.data(), value.size()));
+        handler_->HandleString16(value);
         break;
       }
       case ArrayBegin: {
@@ -929,7 +957,7 @@ class JsonParser {
             HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
             return;
           }
-          handler_->HandleString16(span<uint16_t>(key.data(), key.size()));
+          handler_->HandleString16(key);
           start = token_end;
 
           token = ParseToken(start, end, &token_start, &token_end);
diff --git a/deps/inspector_protocol/crdtp/json_test.cc b/deps/inspector_protocol/crdtp/json_test.cc
index 08f65e48a20147..13566ac8b92f61 100644
--- a/deps/inspector_protocol/crdtp/json_test.cc
+++ b/deps/inspector_protocol/crdtp/json_test.cc
@@ -90,7 +90,7 @@ TEST(JsonEncoder, EscapesLoneHighSurrogates) {
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
-  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  writer->HandleString16(chars);
   EXPECT_EQ("\"a\\ud800b\\udadac\\udbffd\"", out);
 }
 
@@ -103,7 +103,7 @@ TEST(JsonEncoder, EscapesLoneLowSurrogates) {
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
-  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  writer->HandleString16(chars);
   EXPECT_EQ("\"a\\udc00b\\udedec\\udfffd\"", out);
 }
 
@@ -114,7 +114,7 @@ TEST(JsonEncoder, EscapesFFFF) {
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
-  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  writer->HandleString16(chars);
   EXPECT_EQ("\"abc\\uffffd\"", out);
 }
 
@@ -123,7 +123,7 @@ TEST(JsonEncoder, Passes0x7FString8) {
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
-  writer->HandleString8(span<uint8_t>(chars.data(), chars.size()));
+  writer->HandleString8(chars);
   EXPECT_EQ(
       "\"a\x7f"
       "b\"",
@@ -135,7 +135,7 @@ TEST(JsonEncoder, Passes0x7FString16) {
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
-  writer->HandleString16(span<uint16_t>(chars16.data(), chars16.size()));
+  writer->HandleString16(chars16);
   EXPECT_EQ(
       "\"a\x7f"
       "b\"",
@@ -737,8 +737,7 @@ TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
       '"', ':', '[', '1',    ',',    '2', ',', '3', ']', '}'};
   std::vector<uint8_t> cbor;
   {
-    Status status =
-        ConvertJSONToCBOR(span<uint16_t>(json16.data(), json16.size()), &cbor);
+    Status status = ConvertJSONToCBOR(json16, &cbor);
     EXPECT_THAT(status, StatusIsOk());
   }
   TypeParam roundtrip_json;
diff --git a/deps/inspector_protocol/crdtp/protocol_core.cc b/deps/inspector_protocol/crdtp/protocol_core.cc
index 69773593ded162..dc483ac5ad0896 100644
--- a/deps/inspector_protocol/crdtp/protocol_core.cc
+++ b/deps/inspector_protocol/crdtp/protocol_core.cc
@@ -12,7 +12,7 @@ namespace crdtp {
 
 DeserializerState::DeserializerState(std::vector<uint8_t> bytes)
     : storage_(new std::vector<uint8_t>(std::move(bytes))),
-      tokenizer_(span<uint8_t>(storage_->data(), storage_->size())) {}
+      tokenizer_(*storage_) {}
 
 DeserializerState::DeserializerState(Storage storage, span<uint8_t> span)
     : storage_(std::move(storage)), tokenizer_(span) {}
diff --git a/deps/inspector_protocol/crdtp/protocol_core.h b/deps/inspector_protocol/crdtp/protocol_core.h
index f8283367773a42..b111746253aaf3 100644
--- a/deps/inspector_protocol/crdtp/protocol_core.h
+++ b/deps/inspector_protocol/crdtp/protocol_core.h
@@ -219,8 +219,7 @@ struct CRDTP_EXPORT ProtocolTypeTraits<DeferredMessage> {
 
 template <typename T>
 struct ProtocolTypeTraits<std::optional<T>> {
-  static bool Deserialize(DeserializerState* state,
-                          std::optional<T>* value) {
+  static bool Deserialize(DeserializerState* state, std::optional<T>* value) {
     T res;
     if (!ProtocolTypeTraits<T>::Deserialize(state, &res))
       return false;
@@ -341,9 +340,7 @@ template <typename T, typename F>
 bool ConvertProtocolValue(const F& from, T* to) {
   std::vector<uint8_t> bytes;
   ProtocolTypeTraits<F>::Serialize(from, &bytes);
-  auto deserializer =
-      DeferredMessage::FromSpan(span<uint8_t>(bytes.data(), bytes.size()))
-          ->MakeDeserializer();
+  auto deserializer = DeferredMessage::FromSpan(bytes)->MakeDeserializer();
   return ProtocolTypeTraits<T>::Deserialize(&deserializer, to);
 }
 
diff --git a/deps/inspector_protocol/crdtp/span.h b/deps/inspector_protocol/crdtp/span.h
index c2b5b02d9a1832..40471f20aa88a2 100644
--- a/deps/inspector_protocol/crdtp/span.h
+++ b/deps/inspector_protocol/crdtp/span.h
@@ -7,49 +7,17 @@
 
 #include <cstdint>
 #include <cstring>
-#include <type_traits>
+#include <span>
 #include <string>
+#include <type_traits>
 
 #include "export.h"
 
 namespace crdtp {
-// =============================================================================
-// span - sequence of bytes
-// =============================================================================
 
-// This template is similar to std::span, which will be included in C++20.
+// crdtp::span is a std::span which always holds const elements.
 template <typename T>
-class span {
- public:
-  using index_type = size_t;
-
-  constexpr span() : data_(nullptr), size_(0) {}
-  constexpr span(const T* data, index_type size) : data_(data), size_(size) {}
-
-  constexpr const T* data() const { return data_; }
-
-  constexpr const T* begin() const { return data_; }
-  constexpr const T* end() const { return data_ + size_; }
-
-  constexpr const T& operator[](index_type idx) const { return data_[idx]; }
-
-  constexpr span<T> subspan(index_type offset, index_type count) const {
-    return span(data_ + offset, count);
-  }
-
-  constexpr span<T> subspan(index_type offset) const {
-    return span(data_ + offset, size_ - offset);
-  }
-
-  constexpr bool empty() const { return size_ == 0; }
-
-  constexpr index_type size() const { return size_; }
-  constexpr index_type size_bytes() const { return size_ * sizeof(T); }
-
- private:
-  const T* data_;
-  index_type size_;
-};
+using span = std::span<const T>;
 
 template <size_t N>
 constexpr span<char> MakeSpan(const char (&str)[N]) {
diff --git a/deps/inspector_protocol/crdtp/span_test.cc b/deps/inspector_protocol/crdtp/span_test.cc
index e562f4ea6feed9..2845a3b889fcc3 100644
--- a/deps/inspector_protocol/crdtp/span_test.cc
+++ b/deps/inspector_protocol/crdtp/span_test.cc
@@ -85,6 +85,12 @@ TEST(SpanFromTest, FromVectorUint8AndUint16) {
   EXPECT_EQ(bar.size(), bar_span.size());
 }
 
+TEST(SpanFromTest, FromVectorImplicit) {
+  std::vector<uint8_t> foo = {'f', 'o', 'o'};
+  span<uint8_t> foo_span(foo);
+  EXPECT_EQ(foo.size(), foo_span.size());
+}
+
 TEST(SpanComparisons, ByteWiseLexicographicalOrder) {
   // Compare the empty span.
   EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>()));
diff --git a/deps/inspector_protocol/lib/Values_cpp.template b/deps/inspector_protocol/lib/Values_cpp.template
index 0c409295d52ae3..abeee79e5c3a05 100644
--- a/deps/inspector_protocol/lib/Values_cpp.template
+++ b/deps/inspector_protocol/lib/Values_cpp.template
@@ -300,7 +300,7 @@ namespace {
 //   transcodes to UTF8 if needed.
 void EncodeString(const String& s, std::vector<uint8_t>* out) {
   if (StringUtil::CharacterCount(s) == 0) {
-    cbor::EncodeString8(span<uint8_t>(nullptr, 0), out);  // Empty string.
+    cbor::EncodeString8(span<uint8_t>(), out);  // Empty string.
   } else if (StringUtil::CharactersLatin1(s)) {
     cbor::EncodeFromLatin1(span<uint8_t>(StringUtil::CharactersLatin1(s),
 		                         StringUtil::CharacterCount(s)),
diff --git a/deps/inspector_protocol/pdl.py b/deps/inspector_protocol/pdl.py
index 6b448c07443c7e..20f505ea81e34e 100644
--- a/deps/inspector_protocol/pdl.py
+++ b/deps/inspector_protocol/pdl.py
@@ -86,6 +86,18 @@ def parse(data, file_name, map_binary_to_string=False):
       protocol['domains'].append(domain)
       continue
 
+    match = re.compile(
+        r'^include (.*)').match(line)
+    if match:
+      included_filename = match.group(1)
+      if path.isabs(included_filename):
+        raise Exception("Only relative paths are supported in include's")
+      resolved_path = path.normpath(path.join(path.dirname(file_name), included_filename))
+      with open(resolved_path, 'r') as file:
+        included_data = parse(file.read(), resolved_path, map_binary_to_string)
+        protocol['domains'].extend(included_data['domains'])
+      continue
+
     match = re.compile(r'^  depends on ([^\s]+)').match(line)
     if match:
       if 'dependencies' not in domain: