diff --git a/cmake/tools/SetupWebKit.cmake b/cmake/tools/SetupWebKit.cmake
index 5aee190f85..aa07c060ec 100644
--- a/cmake/tools/SetupWebKit.cmake
+++ b/cmake/tools/SetupWebKit.cmake
@@ -2,7 +2,7 @@ option(WEBKIT_VERSION "The version of WebKit to use")
 option(WEBKIT_LOCAL "If a local version of WebKit should be used instead of downloading")
 
 if(NOT WEBKIT_VERSION)
-  set(WEBKIT_VERSION 69fa2714ab5f917c2d15501ff8cfdccfaea78882)
+  set(WEBKIT_VERSION 6d0f3aac0b817cc01a846b3754b21271adedac12)
 endif()
 
 string(SUBSTRING ${WEBKIT_VERSION} 0 16 WEBKIT_VERSION_PREFIX)
diff --git a/src/bun.js/bindings/Base64Helpers.cpp b/src/bun.js/bindings/Base64Helpers.cpp
index d7996921d7..808a669584 100644
--- a/src/bun.js/bindings/Base64Helpers.cpp
+++ b/src/bun.js/bindings/Base64Helpers.cpp
@@ -18,7 +18,7 @@ ExceptionOr<String> atob(const String& encodedString)
     if (!encodedString.is8Bit()) {
         const auto span = encodedString.span16();
         size_t expected_length = simdutf::latin1_length_from_utf16(span.size());
-        std::span<LChar> ptr;
+        std::span<Latin1Character> ptr;
         WTF::String convertedString = WTF::String::tryCreateUninitialized(expected_length, ptr);
         if (convertedString.isNull()) [[unlikely]] {
             return WebCore::Exception { OutOfMemoryError };
@@ -34,7 +34,7 @@ ExceptionOr<String> atob(const String& encodedString)
 
     const auto span = encodedString.span8();
     size_t result_length = simdutf::maximal_binary_length_from_base64(reinterpret_cast<const char*>(span.data()), encodedString.length());
-    std::span<LChar> ptr;
+    std::span<Latin1Character> ptr;
     WTF::String outString = WTF::String::tryCreateUninitialized(result_length, ptr);
     if (outString.isNull()) [[unlikely]] {
         return WebCore::Exception { OutOfMemoryError };
diff --git a/src/bun.js/bindings/BunObject.cpp b/src/bun.js/bindings/BunObject.cpp
index 9d0fd7eea1..2eb6bd9df0 100644
--- a/src/bun.js/bindings/BunObject.cpp
+++ b/src/bun.js/bindings/BunObject.cpp
@@ -470,7 +470,7 @@ JSC_DEFINE_HOST_FUNCTION(functionBunSleep,
     return JSC::JSValue::encode(promise);
 }
 
-extern "C" JSC::EncodedJSValue Bun__escapeHTML8(JSGlobalObject* globalObject, JSC::EncodedJSValue input, const LChar* ptr, size_t length);
+extern "C" JSC::EncodedJSValue Bun__escapeHTML8(JSGlobalObject* globalObject, JSC::EncodedJSValue input, const Latin1Character* ptr, size_t length);
 extern "C" JSC::EncodedJSValue Bun__escapeHTML16(JSGlobalObject* globalObject, JSC::EncodedJSValue input, const char16_t* ptr, size_t length);
 
 JSC_DEFINE_HOST_FUNCTION(functionBunEscapeHTML, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame* callFrame))
diff --git a/src/bun.js/bindings/BunProcess.cpp b/src/bun.js/bindings/BunProcess.cpp
index 68d4992458..fff95e88d5 100644
--- a/src/bun.js/bindings/BunProcess.cpp
+++ b/src/bun.js/bindings/BunProcess.cpp
@@ -1821,7 +1821,7 @@ static JSValue constructReportObjectComplete(VM& vm, Zig::GlobalObject* globalOb
                 cwd[1] = '\0';
             }
 
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "cwd"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(cwd), strlen(cwd) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "cwd"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(cwd), strlen(cwd) })), 0);
             RETURN_IF_EXCEPTION(scope, {});
         }
 
@@ -1843,10 +1843,10 @@ static JSValue constructReportObjectComplete(VM& vm, Zig::GlobalObject* globalOb
                 memset(&buf, 0, sizeof(buf));
             }
 
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "osName"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(buf.sysname), strlen(buf.sysname) })), 0);
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "osRelease"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(buf.release), strlen(buf.release) })), 0);
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "osVersion"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(buf.version), strlen(buf.version) })), 0);
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "osMachine"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(buf.machine), strlen(buf.machine) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "osName"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(buf.sysname), strlen(buf.sysname) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "osRelease"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(buf.release), strlen(buf.release) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "osVersion"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(buf.version), strlen(buf.version) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "osMachine"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(buf.machine), strlen(buf.machine) })), 0);
         }
 
         // host
@@ -1857,7 +1857,7 @@ static JSValue constructReportObjectComplete(VM& vm, Zig::GlobalObject* globalOb
                 host[0] = '0';
             }
 
-            header->putDirect(vm, JSC::Identifier::fromString(vm, "host"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(host), strlen(host) })), 0);
+            header->putDirect(vm, JSC::Identifier::fromString(vm, "host"_s), JSC::jsString(vm, String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(host), strlen(host) })), 0);
         }
 
 #if OS(LINUX)
diff --git a/src/bun.js/bindings/BunString.cpp b/src/bun.js/bindings/BunString.cpp
index 490d727198..3fd23c573b 100644
--- a/src/bun.js/bindings/BunString.cpp
+++ b/src/bun.js/bindings/BunString.cpp
@@ -92,10 +92,10 @@ extern "C" [[ZIG_EXPORT(zero_is_throw)]] JSC::EncodedJSValue BunString__createUT
         return JSValue::encode(jsEmptyString(vm));
     }
     if (simdutf::validate_ascii(ptr, length)) {
-        return JSValue::encode(jsString(vm, WTF::String(std::span<const LChar>(reinterpret_cast<const LChar*>(ptr), length))));
+        return JSValue::encode(jsString(vm, WTF::String(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(ptr), length))));
     }
 
-    auto str = WTF::String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(ptr), length });
+    auto str = WTF::String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(ptr), length });
     EXCEPTION_ASSERT(str.isNull() == !!scope.exception());
     if (str.isNull()) [[unlikely]] {
         throwOutOfMemoryError(globalObject, scope);
@@ -369,7 +369,7 @@ extern "C" [[ZIG_EXPORT(nothrow)]] BunString BunString__fromUTF16Unitialized(siz
 extern "C" [[ZIG_EXPORT(nothrow)]] BunString BunString__fromLatin1Unitialized(size_t length)
 {
     ASSERT(length > 0);
-    std::span<LChar> ptr;
+    std::span<Latin1Character> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (!impl) [[unlikely]] {
         return { .tag = BunStringTag::Dead };
@@ -391,7 +391,7 @@ extern "C" BunString BunString__fromUTF8(const char* bytes, size_t length)
         return { BunStringTag::WTFStringImpl, { .wtf = impl.leakRef() } };
     }
 
-    auto str = WTF::String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const LChar*>(bytes), length });
+    auto str = WTF::String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const Latin1Character*>(bytes), length });
     if (str.isNull()) [[unlikely]] {
         return { .tag = BunStringTag::Dead };
     }
@@ -402,7 +402,7 @@ extern "C" BunString BunString__fromUTF8(const char* bytes, size_t length)
 extern "C" [[ZIG_EXPORT(nothrow)]] BunString BunString__fromLatin1(const char* bytes, size_t length)
 {
     ASSERT(length > 0);
-    std::span<LChar> ptr;
+    std::span<Latin1Character> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(length, ptr);
     if (!impl) [[unlikely]] {
         return { .tag = BunStringTag::Dead };
@@ -417,7 +417,7 @@ extern "C" [[ZIG_EXPORT(nothrow)]] BunString BunString__fromUTF16ToLatin1(const
     ASSERT(length > 0);
     ASSERT_WITH_MESSAGE(simdutf::validate_utf16le(bytes, length), "This function only accepts ascii UTF16 strings");
     size_t outLength = simdutf::latin1_length_from_utf16(length);
-    std::span<LChar> ptr;
+    std::span<Latin1Character> ptr;
     auto impl = WTF::StringImpl::tryCreateUninitialized(outLength, ptr);
     if (!impl) [[unlikely]] {
         return { BunStringTag::Dead };
@@ -452,7 +452,7 @@ extern "C" [[ZIG_EXPORT(nothrow)]] BunString BunString__fromBytes(const char* by
 
 extern "C" BunString BunString__createStaticExternal(const char* bytes, size_t length, bool isLatin1)
 {
-    Ref<WTF::ExternalStringImpl> impl = isLatin1 ? WTF::ExternalStringImpl::createStatic({ reinterpret_cast<const LChar*>(bytes), length }) :
+    Ref<WTF::ExternalStringImpl> impl = isLatin1 ? WTF::ExternalStringImpl::createStatic({ reinterpret_cast<const Latin1Character*>(bytes), length }) :
 
                                                  WTF::ExternalStringImpl::createStatic({ reinterpret_cast<const char16_t*>(bytes), length });
 
@@ -461,7 +461,7 @@ extern "C" BunString BunString__createStaticExternal(const char* bytes, size_t l
 
 extern "C" BunString BunString__createExternal(const char* bytes, size_t length, bool isLatin1, void* ctx, void (*callback)(void* arg0, void* arg1, size_t arg2))
 {
-    Ref<WTF::ExternalStringImpl> impl = isLatin1 ? WTF::ExternalStringImpl::create({ reinterpret_cast<const LChar*>(bytes), length }, ctx, callback) :
+    Ref<WTF::ExternalStringImpl> impl = isLatin1 ? WTF::ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(bytes), length }, ctx, callback) :
 
                                                  WTF::ExternalStringImpl::create({ reinterpret_cast<const char16_t*>(bytes), length }, ctx, callback);
 
@@ -793,7 +793,7 @@ WTF::String BunString::transferToWTFString()
 }
 
 extern "C" BunString BunString__createExternalGloballyAllocatedLatin1(
-    const LChar* bytes,
+    const Latin1Character* bytes,
     size_t length)
 {
     ASSERT(length > 0);
diff --git a/src/bun.js/bindings/Cookie.cpp b/src/bun.js/bindings/Cookie.cpp
index 3a8ef1f4b3..5925069194 100644
--- a/src/bun.js/bindings/Cookie.cpp
+++ b/src/bun.js/bindings/Cookie.cpp
@@ -132,13 +132,13 @@ ExceptionOr<Ref<Cookie>> Cookie::parse(StringView cookieString)
             } else if (attributeName == "expires"_s && !hasMaxAge && !attributeValue.isEmpty()) {
                 if (!attributeValue.is8Bit()) [[unlikely]] {
                     auto asLatin1 = attributeValue.latin1();
-                    double parsed = WTF::parseDate({ reinterpret_cast<const LChar*>(asLatin1.data()), asLatin1.length() });
+                    double parsed = WTF::parseDate({ reinterpret_cast<const Latin1Character*>(asLatin1.data()), asLatin1.length() });
                     if (std::isfinite(parsed)) {
                         expires = static_cast<int64_t>(parsed);
                     }
                 } else {
                     auto nullTerminated = attributeValue.utf8();
-                    double parsed = WTF::parseDate(std::span<const LChar>(reinterpret_cast<const LChar*>(nullTerminated.data()), nullTerminated.length()));
+                    double parsed = WTF::parseDate(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(nullTerminated.data()), nullTerminated.length()));
                     if (std::isfinite(parsed)) {
                         expires = static_cast<int64_t>(parsed);
                     }
diff --git a/src/bun.js/bindings/EncodeURIComponent.cpp b/src/bun.js/bindings/EncodeURIComponent.cpp
index 2a2a2bca25..57cbe0a135 100644
--- a/src/bun.js/bindings/EncodeURIComponent.cpp
+++ b/src/bun.js/bindings/EncodeURIComponent.cpp
@@ -27,7 +27,7 @@ static WebCore::ExceptionOr<void> encode(VM& vm, const WTF::BitSet<256>& doNotEs
         if (character < doNotEscape.size() && doNotEscape.get(character)) {
             // 4-c-i. Let S be a String containing only the code unit C.
             // 4-c-ii. Let R be a new String value computed by concatenating the previous value of R and S.
-            builder.append(static_cast<LChar>(character));
+            builder.append(static_cast<Latin1Character>(character));
             continue;
         }
 
@@ -61,7 +61,7 @@ static WebCore::ExceptionOr<void> encode(VM& vm, const WTF::BitSet<256>& doNotEs
         }
 
         // 4-d-iv. Let Octets be the array of octets resulting by applying the UTF-8 transformation to V, and let L be the array size.
-        LChar utf8OctetsBuffer[U8_MAX_LENGTH];
+        Latin1Character utf8OctetsBuffer[U8_MAX_LENGTH];
         unsigned utf8Length = 0;
         // We can use U8_APPEND_UNSAFE here since codePoint is either
         // 1. non surrogate one, correct code point.
diff --git a/src/bun.js/bindings/ErrorCode.cpp b/src/bun.js/bindings/ErrorCode.cpp
index 9a1dea3f75..205df8c7bc 100644
--- a/src/bun.js/bindings/ErrorCode.cpp
+++ b/src/bun.js/bindings/ErrorCode.cpp
@@ -271,7 +271,7 @@ void JSValueToStringSafe(JSC::JSGlobalObject* globalObject, WTF::StringBuilder&
             if (str->contains('\'')) {
                 builder.append('"');
                 if (str->is8Bit()) {
-                    const auto span = str->span<LChar>();
+                    const auto span = str->span<Latin1Character>();
                     for (const auto c : span) {
                         if (c == '"') {
                             builder.append("\\\""_s);
@@ -420,7 +420,7 @@ void determineSpecificType(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WTF::
         if (needsEscape) [[unlikely]] {
             builder.append('"');
             if (view.is8Bit()) {
-                const auto span = view.span<LChar>();
+                const auto span = view.span<Latin1Character>();
                 for (const auto c : span) {
                     if (c == '"') {
                         builder.append("\\\""_s);
@@ -590,10 +590,10 @@ WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* gl
 
 WTF::String ERR_INVALID_ARG_TYPE(JSC::ThrowScope& scope, JSC::JSGlobalObject* globalObject, const ZigString* arg_name_string, const ZigString* expected_type_string, JSValue actual_value)
 {
-    auto arg_name = std::span<const LChar>(arg_name_string->ptr, arg_name_string->len);
+    auto arg_name = std::span<const Latin1Character>(arg_name_string->ptr, arg_name_string->len);
     ASSERT(WTF::charactersAreAllASCII(arg_name));
 
-    auto expected_type = std::span<const LChar>(expected_type_string->ptr, expected_type_string->len);
+    auto expected_type = std::span<const Latin1Character>(expected_type_string->ptr, expected_type_string->len);
     ASSERT(WTF::charactersAreAllASCII(expected_type));
 
     return ERR_INVALID_ARG_TYPE(scope, globalObject, arg_name, expected_type, actual_value);
diff --git a/src/bun.js/bindings/ErrorStackTrace.cpp b/src/bun.js/bindings/ErrorStackTrace.cpp
index b3935e107a..3ef56822a2 100644
--- a/src/bun.js/bindings/ErrorStackTrace.cpp
+++ b/src/bun.js/bindings/ErrorStackTrace.cpp
@@ -800,3 +800,8 @@ String functionName(JSC::VM& vm, JSC::JSGlobalObject* lexicalGlobalObject, const
     return functionName;
 }
 }
+
+extern "C" void Bun__errorInstance__finalize(void* bunErrorData)
+{
+    UNUSED_PARAM(bunErrorData);
+}
diff --git a/src/bun.js/bindings/JSBuffer.cpp b/src/bun.js/bindings/JSBuffer.cpp
index 34a11d5f53..9e10a88399 100644
--- a/src/bun.js/bindings/JSBuffer.cpp
+++ b/src/bun.js/bindings/JSBuffer.cpp
@@ -1753,7 +1753,7 @@ JSC::EncodedJSValue jsBufferToStringFromBytes(JSGlobalObject* lexicalGlobalObjec
         return JSC::JSValue::encode(buffer);
     }
     case BufferEncodingType::latin1: {
-        std::span<LChar> data;
+        std::span<Latin1Character> data;
         auto str = String::tryCreateUninitialized(bytes.size(), data);
         if (str.isNull()) [[unlikely]] {
             throwOutOfMemoryError(lexicalGlobalObject, scope);
@@ -1779,7 +1779,7 @@ JSC::EncodedJSValue jsBufferToStringFromBytes(JSGlobalObject* lexicalGlobalObjec
         return JSValue::encode(jsString(vm, WTFMove(str)));
     }
     case BufferEncodingType::ascii: {
-        std::span<LChar> data;
+        std::span<Latin1Character> data;
         auto str = String::tryCreateUninitialized(bytes.size(), data);
         if (str.isNull()) [[unlikely]] {
             throwOutOfMemoryError(lexicalGlobalObject, scope);
diff --git a/src/bun.js/bindings/JSType.zig b/src/bun.js/bindings/JSType.zig
index db69b5a145..305ce12034 100644
--- a/src/bun.js/bindings/JSType.zig
+++ b/src/bun.js/bindings/JSType.zig
@@ -484,13 +484,17 @@ pub const JSType = enum(u8) {
     /// ```
     JSPromise = 76,
 
+    /// Context object for Promise.all() operations.
+    /// Internal object used to track the state of Promise.all() resolution.
+    PromiseAllContext = 77,
+
     /// JavaScript Map object for key-value storage.
     /// ```js
     /// new Map()
     /// map.set(key, value)
     /// map.get(key)
     /// ```
-    Map = 77,
+    Map = 78,
 
     /// JavaScript Set object for unique value storage.
     /// ```js
@@ -498,34 +502,34 @@ pub const JSType = enum(u8) {
     /// set.add(value)
     /// set.has(value)
     /// ```
-    Set = 78,
+    Set = 79,
 
     /// WeakMap for weak key-value references.
     /// ```js
     /// new WeakMap()
     /// weakMap.set(object, value)
     /// ```
-    WeakMap = 79,
+    WeakMap = 80,
 
     /// WeakSet for weak value references.
     /// ```js
     /// new WeakSet()
     /// weakSet.add(object)
     /// ```
-    WeakSet = 80,
+    WeakSet = 81,
 
-    WebAssemblyModule = 81,
-    WebAssemblyInstance = 82,
-    WebAssemblyGCObject = 83,
+    WebAssemblyModule = 82,
+    WebAssemblyInstance = 83,
+    WebAssemblyGCObject = 84,
 
     /// Boxed String object.
     /// ```js
     /// new String("hello")
     /// ```
-    StringObject = 84,
+    StringObject = 85,
 
-    DerivedStringObject = 85,
-    InternalFieldTuple = 86,
+    DerivedStringObject = 86,
+    InternalFieldTuple = 87,
 
     MaxJS = 0b11111111,
     Event = 0b11101111,
@@ -569,6 +573,7 @@ pub const JSType = enum(u8) {
             .Map,
             .MapIterator,
             .JSPromise,
+            .PromiseAllContext,
             .Set,
             .SetIterator,
             .IteratorHelper,
diff --git a/src/bun.js/bindings/JSX509Certificate.cpp b/src/bun.js/bindings/JSX509Certificate.cpp
index 09278780f0..36058482cf 100644
--- a/src/bun.js/bindings/JSX509Certificate.cpp
+++ b/src/bun.js/bindings/JSX509Certificate.cpp
@@ -36,7 +36,7 @@ using namespace JSC;
 
 Ref<WTF::ExternalStringImpl> toExternalStringImpl(ncrypto::BIOPointer& bio, std::span<const char> span)
 {
-    return WTF::ExternalStringImpl::create({ reinterpret_cast<const LChar*>(span.data()), span.size() }, bio.release(), [](void* context, void* ptr, unsigned len) {
+    return WTF::ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(span.data()), span.size() }, bio.release(), [](void* context, void* ptr, unsigned len) {
         ncrypto::BIOPointer deleter = ncrypto::BIOPointer(static_cast<BIO*>(context));
     });
 }
@@ -49,7 +49,7 @@ WTF::String toWTFString(ncrypto::BIOPointer& bio)
     if (simdutf::validate_ascii(span.data(), span.size())) {
         return toExternalStringImpl(bio, span);
     }
-    return WTF::String::fromUTF8({ reinterpret_cast<const LChar*>(bptr->data), bptr->length });
+    return WTF::String::fromUTF8({ reinterpret_cast<const Latin1Character*>(bptr->data), bptr->length });
 }
 
 static JSC_DECLARE_HOST_FUNCTION(x509CertificateConstructorCall);
diff --git a/src/bun.js/bindings/JSX509CertificatePrototype.cpp b/src/bun.js/bindings/JSX509CertificatePrototype.cpp
index e7bd02bef8..8df864d95e 100644
--- a/src/bun.js/bindings/JSX509CertificatePrototype.cpp
+++ b/src/bun.js/bindings/JSX509CertificatePrototype.cpp
@@ -706,7 +706,7 @@ JSC_DEFINE_CUSTOM_GETTER(jsX509CertificateGetter_validToDate, (JSGlobalObject *
     Bun::UTF8View validToDateView = Bun::UTF8View(view);
     if (view->isEmpty())
         return JSValue::encode(jsUndefined());
-    std::span<const LChar> span = { reinterpret_cast<const LChar*>(validToDateView.span().data()), validToDateView.span().size() };
+    std::span<const Latin1Character> span = { reinterpret_cast<const Latin1Character*>(validToDateView.span().data()), validToDateView.span().size() };
     double date = WTF::parseDate(span);
     return JSValue::encode(JSC::DateInstance::create(vm, globalObject->dateStructure(), date));
 }
@@ -729,7 +729,7 @@ JSC_DEFINE_CUSTOM_GETTER(jsX509CertificateGetter_validFromDate, (JSGlobalObject
     Bun::UTF8View validFromDateView = Bun::UTF8View(view);
     if (view->isEmpty())
         return JSValue::encode(jsUndefined());
-    std::span<const LChar> span = { reinterpret_cast<const LChar*>(validFromDateView.span().data()), validFromDateView.span().size() };
+    std::span<const Latin1Character> span = { reinterpret_cast<const Latin1Character*>(validFromDateView.span().data()), validFromDateView.span().size() };
     double date = WTF::parseDate(span);
     return JSValue::encode(JSC::DateInstance::create(vm, globalObject->dateStructure(), date));
 }
diff --git a/src/bun.js/bindings/NodeHTTP.cpp b/src/bun.js/bindings/NodeHTTP.cpp
index 70c60c2e5e..daf35b9078 100644
--- a/src/bun.js/bindings/NodeHTTP.cpp
+++ b/src/bun.js/bindings/NodeHTTP.cpp
@@ -864,14 +864,14 @@ static void assignHeadersFromUWebSocketsForCall(uWS::HttpRequest* request, JSVal
     auto scope = DECLARE_THROW_SCOPE(vm);
     {
         std::string_view fullURLStdStr = request->getFullUrl();
-        String fullURL = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const LChar*>(fullURLStdStr.data()), fullURLStdStr.length() });
+        String fullURL = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const Latin1Character*>(fullURLStdStr.data()), fullURLStdStr.length() });
         args.append(jsString(vm, WTFMove(fullURL)));
     }
 
     // Get the method.
     if (methodString.isUndefinedOrNull()) [[unlikely]] {
         std::string_view methodView = request->getMethod();
-        WTF::String methodString = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const LChar*>(methodView.data()), methodView.length() });
+        WTF::String methodString = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const Latin1Character*>(methodView.data()), methodView.length() });
         args.append(jsString(vm, WTFMove(methodString)));
     } else {
         args.append(methodString);
@@ -892,8 +892,8 @@ static void assignHeadersFromUWebSocketsForCall(uWS::HttpRequest* request, JSVal
 
     for (auto it = request->begin(); it != request->end(); ++it) {
         auto pair = *it;
-        StringView nameView = StringView(std::span { reinterpret_cast<const LChar*>(pair.first.data()), pair.first.length() });
-        std::span<LChar> data;
+        StringView nameView = StringView(std::span { reinterpret_cast<const Latin1Character*>(pair.first.data()), pair.first.length() });
+        std::span<Latin1Character> data;
         auto value = String::createUninitialized(pair.second.length(), data);
         if (pair.second.length() > 0)
             memcpy(data.data(), pair.second.data(), pair.second.length());
@@ -964,7 +964,7 @@ static EncodedJSValue assignHeadersFromUWebSockets(uWS::HttpRequest* request, JS
 
     {
         std::string_view fullURLStdStr = request->getFullUrl();
-        String fullURL = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const LChar*>(fullURLStdStr.data()), fullURLStdStr.length() });
+        String fullURL = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const Latin1Character*>(fullURLStdStr.data()), fullURLStdStr.length() });
         PutPropertySlot slot(objectValue, false);
         objectValue->put(objectValue, globalObject, builtinNames.urlPublicName(), jsString(vm, WTFMove(fullURL)), slot);
         RETURN_IF_EXCEPTION(scope, {});
@@ -1052,7 +1052,7 @@ static EncodedJSValue assignHeadersFromUWebSockets(uWS::HttpRequest* request, JS
         }
 
         if (methodString.isNull()) {
-            methodString = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const LChar*>(methodView.data()), methodView.length() });
+            methodString = String::fromUTF8ReplacingInvalidSequences({ reinterpret_cast<const Latin1Character*>(methodView.data()), methodView.length() });
         }
         objectValue->put(objectValue, globalObject, builtinNames.methodPublicName(), jsString(vm, methodString), slot);
         RETURN_IF_EXCEPTION(scope, {});
@@ -1074,8 +1074,8 @@ static EncodedJSValue assignHeadersFromUWebSockets(uWS::HttpRequest* request, JS
 
     for (auto it = request->begin(); it != request->end(); ++it) {
         auto pair = *it;
-        StringView nameView = StringView(std::span { reinterpret_cast<const LChar*>(pair.first.data()), pair.first.length() });
-        std::span<LChar> data;
+        StringView nameView = StringView(std::span { reinterpret_cast<const Latin1Character*>(pair.first.data()), pair.first.length() });
+        std::span<Latin1Character> data;
         auto value = String::tryCreateUninitialized(pair.second.length(), data);
         if (value.isNull()) [[unlikely]] {
             throwOutOfMemoryError(globalObject, scope);
diff --git a/src/bun.js/bindings/StringBuilderBinding.cpp b/src/bun.js/bindings/StringBuilderBinding.cpp
index 108ece7191..121d69bf7d 100644
--- a/src/bun.js/bindings/StringBuilderBinding.cpp
+++ b/src/bun.js/bindings/StringBuilderBinding.cpp
@@ -15,7 +15,7 @@ extern "C" void StringBuilder__deinit(WTF::StringBuilder* builder)
     builder->~StringBuilder();
 }
 
-extern "C" void StringBuilder__appendLatin1(WTF::StringBuilder* builder, LChar const* ptr, size_t len)
+extern "C" void StringBuilder__appendLatin1(WTF::StringBuilder* builder, Latin1Character const* ptr, size_t len)
 {
     builder->append({ ptr, len });
 }
@@ -45,7 +45,7 @@ extern "C" void StringBuilder__appendString(WTF::StringBuilder* builder, BunStri
     str.appendToBuilder(*builder);
 }
 
-extern "C" void StringBuilder__appendLChar(WTF::StringBuilder* builder, LChar c)
+extern "C" void StringBuilder__appendLChar(WTF::StringBuilder* builder, Latin1Character c)
 {
     builder->append(c);
 }
diff --git a/src/bun.js/bindings/TextCodecASCIIFastPath.h b/src/bun.js/bindings/TextCodecASCIIFastPath.h
index 71c1ec586e..3fa7708be5 100644
--- a/src/bun.js/bindings/TextCodecASCIIFastPath.h
+++ b/src/bun.js/bindings/TextCodecASCIIFastPath.h
@@ -33,7 +33,7 @@ namespace PAL {
 
 template<size_t size> struct UCharByteFiller;
 template<> struct UCharByteFiller<4> {
-    static void copy(std::span<LChar> destination, std::span<const uint8_t> source)
+    static void copy(std::span<Latin1Character> destination, std::span<const uint8_t> source)
     {
         memcpySpan(destination, source.first(4));
     }
@@ -47,7 +47,7 @@ template<> struct UCharByteFiller<4> {
     }
 };
 template<> struct UCharByteFiller<8> {
-    static void copy(std::span<LChar> destination, std::span<const uint8_t> source)
+    static void copy(std::span<Latin1Character> destination, std::span<const uint8_t> source)
     {
         memcpySpan(destination, source.first(8));
     }
@@ -65,7 +65,7 @@ template<> struct UCharByteFiller<8> {
     }
 };
 
-inline void copyASCIIMachineWord(std::span<LChar> destination, std::span<const uint8_t> source)
+inline void copyASCIIMachineWord(std::span<Latin1Character> destination, std::span<const uint8_t> source)
 {
     UCharByteFiller<sizeof(WTF::MachineWord)>::copy(destination, source);
 }
diff --git a/src/bun.js/bindings/TextEncodingRegistry.cpp b/src/bun.js/bindings/TextEncodingRegistry.cpp
index d5ade059ea..cab9ba628f 100644
--- a/src/bun.js/bindings/TextEncodingRegistry.cpp
+++ b/src/bun.js/bindings/TextEncodingRegistry.cpp
@@ -55,7 +55,7 @@ constexpr size_t maxEncodingNameLength = 63;
 
 // Hash for all-ASCII strings that does case folding.
 struct TextEncodingNameHash {
-    static bool equal(std::span<const LChar> s1, std::span<const LChar> s2)
+    static bool equal(std::span<const Latin1Character> s1, std::span<const Latin1Character> s2)
     {
         if (s1.size() != s2.size())
             return false;
@@ -76,7 +76,7 @@ struct TextEncodingNameHash {
     // This algorithm is the one-at-a-time hash from:
     // http://burtleburtle.net/bob/hash/hashfaq.html
     // http://burtleburtle.net/bob/hash/doobs.html
-    static unsigned hash(std::span<const LChar> s)
+    static unsigned hash(std::span<const Latin1Character> s)
     {
         unsigned h = WTF::stringHashingStartValue;
         for (char c : s) {
@@ -99,12 +99,12 @@ struct TextEncodingNameHash {
 };
 
 struct HashTranslatorTextEncodingName {
-    static unsigned hash(std::span<const LChar> literal)
+    static unsigned hash(std::span<const Latin1Character> literal)
     {
         return TextEncodingNameHash::hash(literal);
     }
 
-    static bool equal(const ASCIILiteral& a, std::span<const LChar> b)
+    static bool equal(const ASCIILiteral& a, std::span<const Latin1Character> b)
     {
         return TextEncodingNameHash::equal(a.span8(), b);
     }
@@ -307,7 +307,7 @@ std::unique_ptr<TextCodec> newTextCodec(const TextEncoding& encoding)
     return result->value();
 }
 
-static ASCIILiteral atomCanonicalTextEncodingName(std::span<const LChar> name)
+static ASCIILiteral atomCanonicalTextEncodingName(std::span<const Latin1Character> name)
 {
     if (name.empty())
         return {};
@@ -333,7 +333,7 @@ static ASCIILiteral atomCanonicalTextEncodingName(std::span<const char16_t> char
     if (characters.size() > maxEncodingNameLength)
         return {};
 
-    std::array<LChar, maxEncodingNameLength> buffer;
+    std::array<Latin1Character, maxEncodingNameLength> buffer;
     for (size_t i = 0; i < characters.size(); ++i)
         buffer[i] = characters[i];
 
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index d786694411..21141e1935 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -778,8 +778,10 @@ static String computeErrorInfoToString(JSC::VM& vm, Vector<StackFrame>& stackTra
     return computeErrorInfoWithoutPrepareStackTrace(vm, globalObject, lexicalGlobalObject, stackTrace, line, column, sourceURL, nullptr);
 }
 
-static JSValue computeErrorInfoToJSValueWithoutSkipping(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance)
+static JSValue computeErrorInfoToJSValueWithoutSkipping(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance, void* bunErrorData)
 {
+    UNUSED_PARAM(bunErrorData);
+
     Zig::GlobalObject* globalObject = nullptr;
     JSC::JSGlobalObject* lexicalGlobalObject = nullptr;
     lexicalGlobalObject = errorInstance->globalObject();
@@ -821,13 +823,15 @@ static JSValue computeErrorInfoToJSValueWithoutSkipping(JSC::VM& vm, Vector<Stac
     return jsString(vm, result);
 }
 
-static JSValue computeErrorInfoToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance)
+static JSValue computeErrorInfoToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, OrdinalNumber& line, OrdinalNumber& column, String& sourceURL, JSObject* errorInstance, void* bunErrorData)
 {
-    return computeErrorInfoToJSValueWithoutSkipping(vm, stackTrace, line, column, sourceURL, errorInstance);
+    return computeErrorInfoToJSValueWithoutSkipping(vm, stackTrace, line, column, sourceURL, errorInstance, bunErrorData);
 }
 
-static String computeErrorInfoWrapperToString(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL)
+static String computeErrorInfoWrapperToString(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL, void* bunErrorData)
 {
+    UNUSED_PARAM(bunErrorData);
+
     OrdinalNumber line = OrdinalNumber::fromOneBasedInt(line_in);
     OrdinalNumber column = OrdinalNumber::fromOneBasedInt(column_in);
 
@@ -846,12 +850,12 @@ static String computeErrorInfoWrapperToString(JSC::VM& vm, Vector<StackFrame>& s
     return result;
 }
 
-static JSValue computeErrorInfoWrapperToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL, JSObject* errorInstance)
+static JSValue computeErrorInfoWrapperToJSValue(JSC::VM& vm, Vector<StackFrame>& stackTrace, unsigned int& line_in, unsigned int& column_in, String& sourceURL, JSObject* errorInstance, void* bunErrorData)
 {
     OrdinalNumber line = OrdinalNumber::fromOneBasedInt(line_in);
     OrdinalNumber column = OrdinalNumber::fromOneBasedInt(column_in);
 
-    JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorInstance);
+    JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorInstance, bunErrorData);
 
     line_in = line.oneBasedInt();
     column_in = column.oneBasedInt();
@@ -1615,7 +1619,7 @@ JSC_DEFINE_HOST_FUNCTION(functionBTOA,
     // That means even though this looks like the wrong thing to do,
     // we should be converting to latin1, not utf8.
     if (!encodedString.is8Bit()) {
-        std::span<LChar> ptr;
+        std::span<Latin1Character> ptr;
         unsigned length = encodedString.length();
         auto dest = WTF::String::tryCreateUninitialized(length, ptr);
         if (dest.isNull()) [[unlikely]] {
@@ -2641,7 +2645,7 @@ JSC_DEFINE_CUSTOM_GETTER(errorInstanceLazyStackCustomGetter, (JSGlobalObject * g
         return JSValue::encode(jsUndefined());
     }
 
-    JSValue result = computeErrorInfoToJSValue(vm, *stackTrace, line, column, sourceURL, errorObject);
+    JSValue result = computeErrorInfoToJSValue(vm, *stackTrace, line, column, sourceURL, errorObject, nullptr);
     stackTrace->clear();
     errorObject->setStackFrames(vm, {});
     RETURN_IF_EXCEPTION(scope, {});
@@ -2699,7 +2703,7 @@ JSC_DEFINE_HOST_FUNCTION(errorConstructorFuncCaptureStackTrace, (JSC::JSGlobalOb
         OrdinalNumber line;
         OrdinalNumber column;
         String sourceURL;
-        JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorObject);
+        JSValue result = computeErrorInfoToJSValue(vm, stackTrace, line, column, sourceURL, errorObject, nullptr);
         RETURN_IF_EXCEPTION(scope, {});
         errorObject->putDirect(vm, vm.propertyNames->stack, result, 0);
     }
diff --git a/src/bun.js/bindings/ZigSourceProvider.cpp b/src/bun.js/bindings/ZigSourceProvider.cpp
index 3ec0fcb9f6..021b567551 100644
--- a/src/bun.js/bindings/ZigSourceProvider.cpp
+++ b/src/bun.js/bindings/ZigSourceProvider.cpp
@@ -168,9 +168,9 @@ static JSC::VM& getVMForBytecodeCache()
     return *vmForBytecodeCache;
 }
 
-extern "C" bool generateCachedModuleByteCodeFromSourceCode(BunString* sourceProviderURL, const LChar* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
+extern "C" bool generateCachedModuleByteCodeFromSourceCode(BunString* sourceProviderURL, const Latin1Character* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
 {
-    std::span<const LChar> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
+    std::span<const Latin1Character> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
     JSC::SourceCode sourceCode = JSC::makeSource(WTF::String(sourceCodeSpan), toSourceOrigin(sourceProviderURL->toWTFString(), false), JSC::SourceTaintedOrigin::Untainted);
 
     JSC::VM& vm = getVMForBytecodeCache();
@@ -201,9 +201,9 @@ extern "C" bool generateCachedModuleByteCodeFromSourceCode(BunString* sourceProv
     return true;
 }
 
-extern "C" bool generateCachedCommonJSProgramByteCodeFromSourceCode(BunString* sourceProviderURL, const LChar* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
+extern "C" bool generateCachedCommonJSProgramByteCodeFromSourceCode(BunString* sourceProviderURL, const Latin1Character* inputSourceCode, size_t inputSourceCodeSize, const uint8_t** outputByteCode, size_t* outputByteCodeSize, JSC::CachedBytecode** cachedBytecodePtr)
 {
-    std::span<const LChar> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
+    std::span<const Latin1Character> sourceCodeSpan(inputSourceCode, inputSourceCodeSize);
 
     JSC::SourceCode sourceCode = JSC::makeSource(WTF::String(sourceCodeSpan), toSourceOrigin(sourceProviderURL->toWTFString(), false), JSC::SourceTaintedOrigin::Untainted);
     JSC::VM& vm = getVMForBytecodeCache();
diff --git a/src/bun.js/bindings/bindings.cpp b/src/bun.js/bindings/bindings.cpp
index e8c3dba9df..df1ddfe46e 100644
--- a/src/bun.js/bindings/bindings.cpp
+++ b/src/bun.js/bindings/bindings.cpp
@@ -1947,7 +1947,7 @@ WebCore::FetchHeaders* WebCore__FetchHeaders__createFromPicoHeaders_(const void*
 
             StringView nameView = StringView(std::span { reinterpret_cast<const char*>(header.name.ptr), header.name.len });
 
-            std::span<LChar> data;
+            std::span<Latin1Character> data;
             auto value = String::createUninitialized(header.value.len, data);
             memcpy(data.data(), header.value.ptr, header.value.len);
 
@@ -1980,8 +1980,8 @@ WebCore::FetchHeaders* WebCore__FetchHeaders__createFromUWS(void* arg1)
     HTTPHeaderMap map = HTTPHeaderMap();
 
     for (const auto& header : req) {
-        StringView nameView = StringView(std::span { reinterpret_cast<const LChar*>(header.first.data()), header.first.length() });
-        std::span<LChar> data;
+        StringView nameView = StringView(std::span { reinterpret_cast<const Latin1Character*>(header.first.data()), header.first.length() });
+        std::span<Latin1Character> data;
         auto value = String::createUninitialized(header.second.length(), data);
         if (header.second.length() > 0)
             memcpy(data.data(), header.second.data(), header.second.length());
@@ -3261,7 +3261,7 @@ JSC::EncodedJSValue ZigString__external(const ZigString* arg0, JSC::JSGlobalObje
     if (Zig::isTaggedUTF16Ptr(str.ptr)) {
         return JSC::JSValue::encode(JSC::jsString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const char16_t*>(Zig::untag(str.ptr)), str.len }, arg2, ArgFn3))));
     } else {
-        return JSC::JSValue::encode(JSC::jsString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const LChar*>(Zig::untag(str.ptr)), str.len }, arg2, ArgFn3))));
+        return JSC::JSValue::encode(JSC::jsString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(Zig::untag(str.ptr)), str.len }, arg2, ArgFn3))));
     }
 }
 
@@ -3273,7 +3273,7 @@ JSC::EncodedJSValue ZigString__toExternalValueWithCallback(const ZigString* arg0
     if (Zig::isTaggedUTF16Ptr(str.ptr)) {
         return JSC::JSValue::encode(JSC::jsOwnedString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const char16_t*>(Zig::untag(str.ptr)), str.len }, nullptr, ArgFn2))));
     } else {
-        return JSC::JSValue::encode(JSC::jsOwnedString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const LChar*>(Zig::untag(str.ptr)), str.len }, nullptr, ArgFn2))));
+        return JSC::JSValue::encode(JSC::jsOwnedString(arg1->vm(), WTF::String(ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(Zig::untag(str.ptr)), str.len }, nullptr, ArgFn2))));
     }
 }
 
@@ -6401,9 +6401,9 @@ extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNumber(JSC::JSGlobalObje
     return JSValue::encode(date);
 }
 
-extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNullTerminatedString(JSC::JSGlobalObject* globalObject, const LChar* nullTerminatedChars)
+extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNullTerminatedString(JSC::JSGlobalObject* globalObject, const Latin1Character* nullTerminatedChars)
 {
-    double dateSeconds = WTF::parseDate(std::span<const LChar>(nullTerminatedChars, strlen(reinterpret_cast<const char*>(nullTerminatedChars))));
+    double dateSeconds = WTF::parseDate(std::span<const Latin1Character>(nullTerminatedChars, strlen(reinterpret_cast<const char*>(nullTerminatedChars))));
     JSC::DateInstance* date = JSC::DateInstance::create(globalObject->vm(), globalObject->dateStructure(), dateSeconds);
 
     return JSValue::encode(date);
diff --git a/src/bun.js/bindings/decodeURIComponentSIMD.cpp b/src/bun.js/bindings/decodeURIComponentSIMD.cpp
index 3aedbfed3f..e434edeece 100644
--- a/src/bun.js/bindings/decodeURIComponentSIMD.cpp
+++ b/src/bun.js/bindings/decodeURIComponentSIMD.cpp
@@ -22,7 +22,7 @@ WTF::String decodeURIComponentSIMD(std::span<const uint8_t> input)
 {
     ASSERT_WITH_MESSAGE(simdutf::validate_ascii(reinterpret_cast<const char*>(input.data()), input.size()), "Input is not ASCII");
 
-    const std::span<const LChar> lchar = { reinterpret_cast<const LChar*>(input.data()), input.size() };
+    const std::span<const Latin1Character> lchar = { reinterpret_cast<const Latin1Character*>(input.data()), input.size() };
 
     // Fast path - check if there are any % characters at all
     const uint8_t* cursor = reinterpret_cast<const uint8_t*>(input.data());
@@ -53,7 +53,7 @@ WTF::String decodeURIComponentSIMD(std::span<const uint8_t> input)
 slow_path:
     StringBuilder result;
     result.reserveCapacity(input.size());
-    result.append(std::span<const LChar>(reinterpret_cast<const LChar*>(input.data()), cursor - input.data()));
+    result.append(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(input.data()), cursor - input.data()));
 
     while (cursor < end) {
         if (*cursor == '%') {
@@ -254,7 +254,7 @@ slow_path:
             }
 
             // Append everything up to lookAhead
-            result.append(std::span<const LChar>(reinterpret_cast<const LChar*>(cursor), lookAhead - cursor));
+            result.append(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(cursor), lookAhead - cursor));
             cursor = lookAhead;
 
             // Handle remaining bytes until next % or end
@@ -262,7 +262,7 @@ slow_path:
                 cursor++;
             }
             if (cursor > lookAhead) {
-                result.append(std::span<const LChar>(reinterpret_cast<const LChar*>(lookAhead), cursor - lookAhead));
+                result.append(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(lookAhead), cursor - lookAhead));
             }
         }
     }
@@ -283,7 +283,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionDecodeURIComponentSIMD, (JSC::JSGlobalObject
         if (!string.is8Bit()) {
             const auto span = string.span16();
             size_t expected_length = simdutf::latin1_length_from_utf16(span.size());
-            std::span<LChar> ptr;
+            std::span<Latin1Character> ptr;
             WTF::String convertedString = WTF::String::tryCreateUninitialized(expected_length, ptr);
             if (convertedString.isNull()) [[unlikely]] {
                 throwVMError(globalObject, scope, createOutOfMemoryError(globalObject));
diff --git a/src/bun.js/bindings/helpers.h b/src/bun.js/bindings/helpers.h
index ce1f0af703..1fc73077a9 100644
--- a/src/bun.js/bindings/helpers.h
+++ b/src/bun.js/bindings/helpers.h
@@ -173,11 +173,11 @@ static const WTF::String toStringCopy(ZigString str)
         memcpy(out.data(), untag(str.ptr), str.len * sizeof(char16_t));
         return WTF::String(WTFMove(impl));
     } else {
-        std::span<LChar> out;
+        std::span<Latin1Character> out;
         auto impl = WTF::StringImpl::tryCreateUninitialized(str.len, out);
         if (!impl) [[unlikely]]
             return WTF::String();
-        memcpy(out.data(), untag(str.ptr), str.len * sizeof(LChar));
+        memcpy(out.data(), untag(str.ptr), str.len * sizeof(Latin1Character));
         return WTF::String(WTFMove(impl));
     }
 }
diff --git a/src/bun.js/bindings/napi.cpp b/src/bun.js/bindings/napi.cpp
index 1c362e3884..75c49b966a 100644
--- a/src/bun.js/bindings/napi.cpp
+++ b/src/bun.js/bindings/napi.cpp
@@ -642,7 +642,7 @@ extern "C" napi_status napi_is_typedarray(napi_env env, napi_value value, bool*
 // because we can't guarantee the lifetime of it
 #define PROPERTY_NAME_FROM_UTF8(identifierName)                                                                            \
     size_t utf8Len = strlen(utf8Name);                                                                                     \
-    WTF::String&& nameString = WTF::charactersAreAllASCII(std::span { reinterpret_cast<const LChar*>(utf8Name), utf8Len }) \
+    WTF::String&& nameString = WTF::charactersAreAllASCII(std::span { reinterpret_cast<const Latin1Character*>(utf8Name), utf8Len }) \
         ? WTF::String(WTF::StringImpl::createWithoutCopying({ utf8Name, utf8Len }))                                        \
         : WTF::String::fromUTF8(utf8Name);                                                                                 \
     const JSC::PropertyName identifierName = JSC::Identifier::fromString(vm, nameString);
@@ -1411,7 +1411,7 @@ node_api_create_external_string_latin1(napi_env env,
     length = length == NAPI_AUTO_LENGTH ? strlen(str) : length;
     // WTF::ExternalStringImpl does not allow creating empty strings, so we have this limitation for now.
     NAPI_RETURN_EARLY_IF_FALSE(env, length > 0, napi_invalid_arg);
-    Ref<WTF::ExternalStringImpl> impl = WTF::ExternalStringImpl::create({ reinterpret_cast<const LChar*>(str), static_cast<unsigned int>(length) }, finalize_hint, [finalize_callback, env](void* hint, void* str, unsigned length) {
+    Ref<WTF::ExternalStringImpl> impl = WTF::ExternalStringImpl::create({ reinterpret_cast<const Latin1Character*>(str), static_cast<unsigned int>(length) }, finalize_hint, [finalize_callback, env](void* hint, void* str, unsigned length) {
         NAPI_LOG("latin1 string finalizer");
         env->doFinalizer(finalize_callback, str, hint);
     });
diff --git a/src/bun.js/bindings/ncrypto.cpp b/src/bun.js/bindings/ncrypto.cpp
index 869970e06c..446ee74a64 100644
--- a/src/bun.js/bindings/ncrypto.cpp
+++ b/src/bun.js/bindings/ncrypto.cpp
@@ -1345,7 +1345,7 @@ std::optional<WTF::String> X509View::getFingerprint(
 
     if (X509_digest(get(), method, md, &md_size)) {
         if (md_size == 0) return std::nullopt;
-        std::span<LChar> fingerprint;
+        std::span<Latin1Character> fingerprint;
         WTF::String fingerprintStr = WTF::String::createUninitialized((md_size * 3) - 1, fingerprint);
 
         {
diff --git a/src/bun.js/bindings/stripANSI.cpp b/src/bun.js/bindings/stripANSI.cpp
index da49414a4c..cbb3cf7b7f 100644
--- a/src/bun.js/bindings/stripANSI.cpp
+++ b/src/bun.js/bindings/stripANSI.cpp
@@ -251,7 +251,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionBunStripANSI, (JSC::JSGlobalObject * globalOb
 
     std::optional<WTF::String> result;
     if (view->is8Bit()) {
-        result = stripANSI<LChar>(view->span8());
+        result = stripANSI<Latin1Character>(view->span8());
     } else {
         result = stripANSI<UChar>(view->span16());
     }
diff --git a/src/bun.js/bindings/v8/V8String.cpp b/src/bun.js/bindings/v8/V8String.cpp
index eca567867c..8441d145bc 100644
--- a/src/bun.js/bindings/v8/V8String.cpp
+++ b/src/bun.js/bindings/v8/V8String.cpp
@@ -153,7 +153,7 @@ bool String::IsExternalOneByte() const
     return !impl->isNull() && impl->impl()->isExternal() && impl->is8Bit();
 }
 
-extern "C" size_t TextEncoder__encodeInto8(const LChar* stringPtr, size_t stringLen, void* ptr, size_t len);
+extern "C" size_t TextEncoder__encodeInto8(const Latin1Character* stringPtr, size_t stringLen, void* ptr, size_t len);
 extern "C" size_t TextEncoder__encodeInto16(const char16_t* stringPtr, size_t stringLen, void* ptr, size_t len);
 
 int String::WriteUtf8(Isolate* isolate, char* buffer, int length, int* nchars_ref, int options) const
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderField.cpp b/src/bun.js/bindings/webcore/HTTPHeaderField.cpp
index 26d5b080df..649e756fc0 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderField.cpp
+++ b/src/bun.js/bindings/webcore/HTTPHeaderField.cpp
@@ -32,14 +32,14 @@ namespace RFC7230 {
 
 bool isTokenCharacter(char16_t c)
 {
-    return c < 0x80 && isTokenCharacter(static_cast<LChar>(c));
+    return c < 0x80 && isTokenCharacter(static_cast<Latin1Character>(c));
 }
 bool isDelimiter(char16_t c)
 {
-    return c < 0x80 && isDelimiter(static_cast<LChar>(c));
+    return c < 0x80 && isDelimiter(static_cast<Latin1Character>(c));
 }
 
-bool isTokenCharacter(LChar c)
+bool isTokenCharacter(Latin1Character c)
 {
     return isASCIIAlpha(c) || isASCIIDigit(c)
         || c == '!' || c == '#' || c == '$'
@@ -49,7 +49,7 @@ bool isTokenCharacter(LChar c)
         || c == '`' || c == '|' || c == '~';
 }
 
-bool isDelimiter(LChar c)
+bool isDelimiter(Latin1Character c)
 {
     return c == '(' || c == ')' || c == ','
         || c == '/' || c == ':' || c == ';'
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderField.h b/src/bun.js/bindings/webcore/HTTPHeaderField.h
index 30f94fc67b..5acb00c8a2 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderField.h
+++ b/src/bun.js/bindings/webcore/HTTPHeaderField.h
@@ -75,8 +75,8 @@ std::optional<HTTPHeaderField> HTTPHeaderField::decode(Decoder& decoder)
 namespace RFC7230 {
 bool isTokenCharacter(char16_t);
 bool isWhitespace(char16_t);
-bool isTokenCharacter(LChar);
-bool isWhitespace(LChar);
+bool isTokenCharacter(Latin1Character);
+bool isWhitespace(Latin1Character);
 bool isCommentText(char16_t);
 bool isQuotedPairSecondOctet(char16_t);
 bool isDelimiter(char16_t);
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderMap.cpp b/src/bun.js/bindings/webcore/HTTPHeaderMap.cpp
index c520ab1312..3f1ad6fd32 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderMap.cpp
+++ b/src/bun.js/bindings/webcore/HTTPHeaderMap.cpp
@@ -145,7 +145,7 @@ void HTTPHeaderMap::setUncommonHeaderCloneName(const StringView name, const Stri
         return equalIgnoringASCIICase(header.key, name);
     });
     if (index == notFound) {
-        std::span<LChar> ptr;
+        std::span<Latin1Character> ptr;
         auto nameCopy = WTF::String::createUninitialized(name.length(), ptr);
         memcpy(ptr.data(), name.span8().data(), name.length());
         m_uncommonHeaders.append(UncommonHeader { nameCopy, value });
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderNames.cpp b/src/bun.js/bindings/webcore/HTTPHeaderNames.cpp
index 428d1a6fb4..19dc63c413 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderNames.cpp
+++ b/src/bun.js/bindings/webcore/HTTPHeaderNames.cpp
@@ -667,14 +667,14 @@ bool findHTTPHeaderName(const StringView stringView, HTTPHeaderName& headerName)
             return true;
         }
     } else {
-        LChar characters[maxHTTPHeaderNameLength];
+        Latin1Character characters[maxHTTPHeaderNameLength];
         const auto span = stringView.span16();
         for (unsigned i = 0; i < length; ++i) {
             char16_t character = span.data()[i];
             if (!isASCII(character))
                 return false;
 
-            characters[i] = static_cast<LChar>(character);
+            characters[i] = static_cast<Latin1Character>(character);
         }
 
         if (auto nameAndString = HTTPHeaderNamesHash::findHeaderNameImpl(reinterpret_cast<const char*>(characters), length)) {
@@ -692,7 +692,7 @@ StringView httpHeaderNameString(HTTPHeaderName headerName)
 
     const auto& name = headerNameStrings[static_cast<unsigned>(headerName)];
 
-    return StringView(std::span { reinterpret_cast<const LChar*>(name.name), static_cast<unsigned>(name.length) });
+    return StringView(std::span { reinterpret_cast<const Latin1Character*>(name.name), static_cast<unsigned>(name.length) });
 }
 
 } // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/HTTPHeaderNames.gperf b/src/bun.js/bindings/webcore/HTTPHeaderNames.gperf
index 2ef3d13308..48474edfcd 100644
--- a/src/bun.js/bindings/webcore/HTTPHeaderNames.gperf
+++ b/src/bun.js/bindings/webcore/HTTPHeaderNames.gperf
@@ -263,16 +263,16 @@ bool findHTTPHeaderName(StringView stringView, HTTPHeaderName& headerName)
             return true;
         }
     } else {
-        LChar characters[maxHTTPHeaderNameLength];
+        Latin1Character characters[maxHTTPHeaderNameLength];
         const auto span = stringView.span16();
         for (unsigned i = 0; i < length; ++i) {
             UChar character = span.data()[i];
             if (!isASCII(character))
                 return false;
-                
-            characters[i] = static_cast<LChar>(character);
+
+            characters[i] = static_cast<Latin1Character>(character);
         }
-        
+
         if (auto nameAndString = HTTPHeaderNamesHash::findHeaderNameImpl(reinterpret_cast<const char*>(characters), length)) {
             headerName = nameAndString->headerName;
             return true;
@@ -285,10 +285,10 @@ bool findHTTPHeaderName(StringView stringView, HTTPHeaderName& headerName)
 StringView httpHeaderNameString(HTTPHeaderName headerName)
 {
     ASSERT(static_cast<unsigned>(headerName) < numHTTPHeaderNames);
-    
+
     const auto& name = headerNameStrings[static_cast<unsigned>(headerName)];
-    
-    return StringView { reinterpret_cast<const LChar*>(name.name), static_cast<unsigned>(name.length) };
+
+    return StringView { reinterpret_cast<const Latin1Character*>(name.name), static_cast<unsigned>(name.length) };
 }
 
 } // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/HTTPParsers.cpp b/src/bun.js/bindings/webcore/HTTPParsers.cpp
index c973a531bb..19bd1c5868 100644
--- a/src/bun.js/bindings/webcore/HTTPParsers.cpp
+++ b/src/bun.js/bindings/webcore/HTTPParsers.cpp
@@ -128,11 +128,11 @@ bool isValidHTTPHeaderValue(const StringView& value)
     if (isTabOrSpace(c))
         return false;
     if (value.is8Bit()) {
-        const LChar* begin = value.span8().data();
-        const LChar* end = begin + value.length();
-        for (const LChar* p = begin; p != end; ++p) {
+        const Latin1Character* begin = value.span8().data();
+        const Latin1Character* end = begin + value.length();
+        for (const Latin1Character* p = begin; p != end; ++p) {
             if (*p <= 13) [[unlikely]] {
-                LChar c = *p;
+                Latin1Character c = *p;
                 if (c == 0x00 || c == 0x0A || c == 0x0D)
                     return false;
             }
@@ -201,8 +201,8 @@ bool isValidHTTPToken(const StringView& value)
         return false;
 
     if (value.is8Bit()) {
-        const LChar* characters = value.span8().data();
-        const LChar* end = characters + value.length();
+        const Latin1Character* characters = value.span8().data();
+        const Latin1Character* end = characters + value.length();
         while (characters < end) {
             if (!RFC7230::isTokenCharacter(*characters++))
                 return false;
@@ -338,7 +338,7 @@ static String trimInputSample(CharType* p, size_t length)
 std::optional<WallTime> parseHTTPDate(const String& value)
 {
     auto utf8Data = value.utf8();
-    double dateInMillisecondsSinceEpoch = parseDate({ reinterpret_cast<const LChar*>(utf8Data.data()), utf8Data.length() });
+    double dateInMillisecondsSinceEpoch = parseDate({ reinterpret_cast<const Latin1Character*>(utf8Data.data()), utf8Data.length() });
     if (!std::isfinite(dateInMillisecondsSinceEpoch))
         return std::nullopt;
     // This assumes system_clock epoch equals Unix epoch which is true for all implementations but unspecified.
diff --git a/src/bun.js/bindings/webcore/JSCookie.cpp b/src/bun.js/bindings/webcore/JSCookie.cpp
index b542632559..a53ff6336f 100644
--- a/src/bun.js/bindings/webcore/JSCookie.cpp
+++ b/src/bun.js/bindings/webcore/JSCookie.cpp
@@ -70,7 +70,7 @@ static int64_t getExpiresValue(JSGlobalObject* lexicalGlobalObject, JSC::ThrowSc
         auto expiresStr = convert<IDLUSVString>(*lexicalGlobalObject, expiresValue);
         RETURN_IF_EXCEPTION(throwScope, Cookie::emptyExpiresAtValue);
         auto nullTerminatedSpan = expiresStr.utf8();
-        if (auto parsed = WTF::parseDate(std::span<const LChar>(reinterpret_cast<const LChar*>(nullTerminatedSpan.data()), nullTerminatedSpan.length()))) {
+        if (auto parsed = WTF::parseDate(std::span<const Latin1Character>(reinterpret_cast<const Latin1Character*>(nullTerminatedSpan.data()), nullTerminatedSpan.length()))) {
             if (std::isnan(parsed)) {
                 throwVMError(lexicalGlobalObject, throwScope, createTypeError(lexicalGlobalObject, "Invalid cookie expiration date"_s));
                 return Cookie::emptyExpiresAtValue;
diff --git a/src/bun.js/bindings/webcore/JSMIMEParams.cpp b/src/bun.js/bindings/webcore/JSMIMEParams.cpp
index 93be29485e..d00418d49d 100644
--- a/src/bun.js/bindings/webcore/JSMIMEParams.cpp
+++ b/src/bun.js/bindings/webcore/JSMIMEParams.cpp
@@ -144,7 +144,7 @@ static String removeBackslashes(const StringView& view)
     if (view.is8Bit()) {
         auto span = view.span8();
         for (size_t i = 0; i < span.size(); ++i) {
-            LChar c = span[i];
+            Latin1Character c = span[i];
             if (c == '\\' && i + 1 < span.size()) {
                 builder.append(span[++i]);
             } else {
@@ -174,7 +174,7 @@ static void escapeQuoteOrBackslash(const StringView& view, StringBuilder& builde
 
     if (view.is8Bit()) {
         auto span = view.span8();
-        for (LChar c : span) {
+        for (Latin1Character c : span) {
             if (c == '"' || c == '\\') {
                 builder.append('\\');
             }
diff --git a/src/bun.js/bindings/webcore/JSMIMEType.cpp b/src/bun.js/bindings/webcore/JSMIMEType.cpp
index cb92824bd0..57edf53082 100644
--- a/src/bun.js/bindings/webcore/JSMIMEType.cpp
+++ b/src/bun.js/bindings/webcore/JSMIMEType.cpp
@@ -153,7 +153,7 @@ static String removeBackslashes(const StringView& view)
     if (view.is8Bit()) {
         auto span = view.span8();
         for (size_t i = 0; i < span.size(); ++i) {
-            LChar c = span[i];
+            Latin1Character c = span[i];
             if (c == '\\' && i + 1 < span.size()) {
                 builder.append(span[++i]);
             } else {
@@ -183,7 +183,7 @@ static String escapeQuoteOrBackslash(const StringView& view)
     StringBuilder builder;
     if (view.is8Bit()) {
         auto span = view.span8();
-        for (LChar c : span) {
+        for (Latin1Character c : span) {
             if (c == '"' || c == '\\') {
                 builder.append('\\');
             }
diff --git a/src/bun.js/bindings/webcore/JSTextEncoder.cpp b/src/bun.js/bindings/webcore/JSTextEncoder.cpp
index 4e61872dc9..0a1fcf212e 100644
--- a/src/bun.js/bindings/webcore/JSTextEncoder.cpp
+++ b/src/bun.js/bindings/webcore/JSTextEncoder.cpp
@@ -68,9 +68,9 @@ namespace WebCore {
 using namespace JSC;
 using namespace JSC::DOMJIT;
 
-extern "C" JSC::EncodedJSValue TextEncoder__encode8(JSC::JSGlobalObject* global, const LChar* stringPtr, size_t stringLen);
+extern "C" JSC::EncodedJSValue TextEncoder__encode8(JSC::JSGlobalObject* global, const Latin1Character* stringPtr, size_t stringLen);
 extern "C" JSC::EncodedJSValue TextEncoder__encode16(JSC::JSGlobalObject* global, const char16_t* stringPtr, size_t stringLen);
-extern "C" size_t TextEncoder__encodeInto8(const LChar* stringPtr, size_t stringLen, void* ptr, size_t len);
+extern "C" size_t TextEncoder__encodeInto8(const Latin1Character* stringPtr, size_t stringLen, void* ptr, size_t len);
 extern "C" size_t TextEncoder__encodeInto16(const char16_t* stringPtr, size_t stringLen, void* ptr, size_t len);
 extern "C" JSC::EncodedJSValue TextEncoder__encodeRopeString(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSString* str);
 
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
index 7cf7e2bd13..bc7a596710 100644
--- a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
@@ -3392,7 +3392,7 @@ private:
         if (is8Bit) {
             if ((end - ptr) < static_cast<int>(length))
                 return false;
-            str = Identifier::fromString(vm, { reinterpret_cast<const LChar*>(ptr), length });
+            str = Identifier::fromString(vm, { reinterpret_cast<const Latin1Character*>(ptr), length });
             ptr += length;
             return true;
         }
diff --git a/src/bun.js/bindings/wtf-bindings.cpp b/src/bun.js/bindings/wtf-bindings.cpp
index 7d9d6fb10d..2d48fc3cdc 100644
--- a/src/bun.js/bindings/wtf-bindings.cpp
+++ b/src/bun.js/bindings/wtf-bindings.cpp
@@ -170,7 +170,7 @@ extern "C" int Bun__ttySetMode(int fd, int mode)
 #endif
 }
 
-extern "C" double WTF__parseDouble(const LChar* string, size_t length, size_t* position)
+extern "C" double WTF__parseDouble(const Latin1Character* string, size_t length, size_t* position)
 {
     return WTF::parseDouble({ string, length }, *position);
 }
@@ -191,7 +191,7 @@ String base64URLEncodeToString(Vector<uint8_t> data)
     if (!encodedLength)
         return String();
 
-    std::span<LChar> ptr;
+    std::span<Latin1Character> ptr;
     auto result = String::createUninitialized(encodedLength, ptr);
 
     encodedLength = WTF__base64URLEncode(reinterpret_cast<const char*>(data.begin()), data.size(), reinterpret_cast<char*>(ptr.data()), encodedLength);
diff --git a/src/codegen/bundle-functions.ts b/src/codegen/bundle-functions.ts
index b379844324..8765cb5983 100644
--- a/src/codegen/bundle-functions.ts
+++ b/src/codegen/bundle-functions.ts
@@ -421,8 +421,8 @@ export async function bundleBuiltinFunctions({ requireTransformer }: BundleBuilt
     #include "BunBuiltinNames.h"
 
     namespace WebCore {
-        static const LChar combinedSourceCodeBuffer[${combinedSourceCodeLength + 1}] = { ${combinedSourceCodeChars}, 0 };
-        static const std::span<const LChar> internalCombinedSource = { combinedSourceCodeBuffer, ${combinedSourceCodeLength} };
+        static const Latin1Character combinedSourceCodeBuffer[${combinedSourceCodeLength + 1}] = { ${combinedSourceCodeChars}, 0 };
+        static const std::span<const Latin1Character> internalCombinedSource = { combinedSourceCodeBuffer, ${combinedSourceCodeLength} };
     `;
 
   for (const { basename, functions } of files) {