src: remove double encoding validation on fatal path

src/encoding_binding.cc

@@ -460,7 +460,13 @@ void BindingData::DecodeUTF8(const FunctionCallbackInfo<Value>& args) {
           env->isolate(), "The encoded data was not valid for encoding utf-8");
     }
 
-    // TODO(chalker): save on utf8 validity recheck in StringBytes::Encode()
+    Local<Value> ret;
+    // Data is already validated as UTF-8 above; skip redundant re-validation.
+    if (StringBytes::EncodeKnownValidUTF8(env->isolate(), data, length)
+            .ToLocal(&ret)) {
+      args.GetReturnValue().Set(ret);
+    }
+    return;
   }
 
   if (length == 0) return args.GetReturnValue().SetEmptyString();

src/string_bytes.cc

@@ -537,6 +537,36 @@ Maybe<size_t> StringBytes::Size(Isolate* isolate,
     }                                                                          \
   } while (0)
 
+// Converts known-valid UTF-8 (buflen >= 32) to a V8 string via the fast
+// UTF-16 path. Callers must ensure buflen is range-checked.
+static MaybeLocal<Value> EncodeKnownValidNonAsciiUTF8(Isolate* isolate,
+                                                      const char* buf,
+                                                      size_t buflen) {
+  size_t u16size = simdutf::utf16_length_from_utf8(buf, buflen);
+  if (u16size > static_cast<size_t>(v8::String::kMaxLength)) {
+    isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
+    return MaybeLocal<Value>();
+  }
+  return EncodeTwoByteString(
+      isolate, u16size, [buf, buflen, u16size](uint16_t* dst) {
+        size_t written = simdutf::convert_valid_utf8_to_utf16(
+            buf, buflen, reinterpret_cast<char16_t*>(dst));
+        CHECK_EQ(written, u16size);
+      });
+}
+
+MaybeLocal<Value> StringBytes::EncodeKnownValidUTF8(Isolate* isolate,
+                                                    const char* buf,
+                                                    size_t buflen) {
+  buflen = keep_buflen_in_range(buflen);
+  if (buflen >= 32) return EncodeKnownValidNonAsciiUTF8(isolate, buf, buflen);
+  Local<String> str;
+  if (!String::NewFromUtf8(isolate, buf, v8::NewStringType::kNormal, buflen)
+           .ToLocal(&str))
+    isolate->ThrowException(node::ERR_STRING_TOO_LONG(isolate));
+  return str;
+}
+
 MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
                                       const char* buf,
                                       size_t buflen,
@@ -586,17 +616,7 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
         // We know that we are non-ASCII (and are unlikely Latin1), use 2-byte
         // In the most likely case of valid UTF-8, we can use this fast impl
         // For very short input, it is slower, so we limit min size
-        size_t u16size = simdutf::utf16_length_from_utf8(buf, buflen);
-        if (u16size > static_cast<size_t>(v8::String::kMaxLength)) {
-          isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
-          return MaybeLocal<Value>();
-        }
-        return EncodeTwoByteString(
-            isolate, u16size, [buf, buflen, u16size](uint16_t* dst) {
-              size_t written = simdutf::convert_valid_utf8_to_utf16(
-                  buf, buflen, reinterpret_cast<char16_t*>(dst));
-              CHECK_EQ(written, u16size);
-            });
+        return EncodeKnownValidNonAsciiUTF8(isolate, buf, buflen);
       }
 
       val =

src/string_bytes.h

@@ -83,6 +83,12 @@ class StringBytes {
                                           size_t buflen,
                                           enum encoding encoding);
 
+  // Like Encode(..., UTF8) but skips UTF-8 validation. Caller must guarantee
+  // that buf contains valid UTF-8.
+  static v8::MaybeLocal<v8::Value> EncodeKnownValidUTF8(v8::Isolate* isolate,
+                                                        const char* buf,
+                                                        size_t buflen);
+
   // Warning: This reverses endianness on BE platforms, even though the
   // signature using uint16_t implies that it should not.
   // However, the brokenness is already public API and can't therefore