Add a comment

1 files changed, 431 insertions, 377 deletions

diff --git a/src/bun.js/bindings/ZigGeneratedClasses.h b/src/bun.js/bindings/ZigGeneratedClasses.h
index aee32a315..05c919eeb 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses.h
@@ -10,27 +10,28 @@ namespace Zig {
 
 #include "JSDOMWrapper.h"
 #include <wtf/NeverDestroyed.h>
+#include "BunPlugin.h";
 
 namespace WebCore {
 using namespace Zig;
 using namespace JSC;
 
-class JSTCPSocket final : public JSC::JSDestructibleObject {
+class JSBlob final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSTCPSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSBlob* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSTCPSocket, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSBlob, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocket = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTCPSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocket = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForBlob.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlob = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForBlob.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForBlob = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -40,9 +41,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSTCPSocket();
+    ~JSBlob();
 
     void* wrapped() const { return m_ctx; }
 
@@ -52,69 +53,35 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTCPSocket, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBlob, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSTCPSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSBlob(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSTCPSocket>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
-
-    JSC::Weak<JSTCPSocket> m_weakThis;
-
-    static bool hasPendingActivity(void* ctx);
-
-    class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSTCPSocket*>(handle.slot()->asCell());
-            if (JSTCPSocket::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
-                    *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
-    };
-
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
 };
 
-class JSTLSSocket final : public JSC::JSDestructibleObject {
+class JSCryptoHasher final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSTLSSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSCryptoHasher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSTLSSocket, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSCryptoHasher, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocket = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTLSSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocket = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasher.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasher = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForCryptoHasher.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasher = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -124,9 +91,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSTLSSocket();
+    ~JSCryptoHasher();
 
     void* wrapped() const { return m_ctx; }
 
@@ -136,81 +103,54 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTLSSocket, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCryptoHasher, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSTLSSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSCryptoHasher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSTLSSocket>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
 
-    JSC::Weak<JSTLSSocket> m_weakThis;
-
-    static bool hasPendingActivity(void* ctx);
-
-    class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSTLSSocket*>(handle.slot()->asCell());
-            if (JSTLSSocket::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
-                    *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
-    };
-
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
     DECLARE_VISIT_CHILDREN;
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithms;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithm;
 };
 
-class JSListener final : public JSC::JSDestructibleObject {
+class JSDirent final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSListener* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSDirent* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSListener, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSDirent, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForListener.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListener = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForListener.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForListener = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForDirent.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirent = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForDirent.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForDirent = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
     {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSListener();
+    ~JSDirent();
 
     void* wrapped() const { return m_ctx; }
 
@@ -220,11 +160,11 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSListener, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDirent, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSListener(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSDirent(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
@@ -236,26 +176,25 @@ public:
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_unix;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
 };
 
-class JSSubprocess final : public JSC::JSDestructibleObject {
+class JSExpect final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSubprocess* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSExpect* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSubprocess, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSExpect, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSubprocess.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSubprocess = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSubprocess.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSubprocess = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForExpect.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpect = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForExpect.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpect = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -265,9 +204,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSubprocess();
+    ~JSExpect();
 
     void* wrapped() const { return m_ctx; }
 
@@ -277,70 +216,42 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSubprocess, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpect, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSubprocess(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSExpect(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSSubprocess>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
 
-    JSC::Weak<JSSubprocess> m_weakThis;
-
-    static bool hasPendingActivity(void* ctx);
-
-    class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSSubprocess*>(handle.slot()->asCell());
-            if (JSSubprocess::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
-                    *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
-    };
-
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
     DECLARE_VISIT_CHILDREN;
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stderr;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stdin;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stdout;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_capturedValue;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_resultValue;
 };
 
-class JSSHA1 final : public JSC::JSDestructibleObject {
+class JSFileSystemRouter final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA1* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSFileSystemRouter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA1, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSFileSystemRouter, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA1.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA1.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouter.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouter = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForFileSystemRouter.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouter = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -352,7 +263,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSHA1();
+    ~JSFileSystemRouter();
 
     void* wrapped() const { return m_ctx; }
 
@@ -362,35 +273,43 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA1, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFileSystemRouter, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA1(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSFileSystemRouter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_origin;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_routes;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_style;
 };
 
-class JSMD5 final : public JSC::JSDestructibleObject {
+class JSListener final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSMD5* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSListener* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSMD5, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSListener, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMD5.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMD5.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForListener.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListener = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForListener.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForListener = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -400,9 +319,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    ;
 
-    ~JSMD5();
+    ~JSListener();
 
     void* wrapped() const { return m_ctx; }
 
@@ -412,17 +331,24 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD5, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSListener, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSMD5(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSListener(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_unix;
 };
 
 class JSMD4 final : public JSC::JSDestructibleObject {
@@ -475,22 +401,22 @@ public:
     void finishCreation(JSC::VM&);
 };
 
-class JSSHA224 final : public JSC::JSDestructibleObject {
+class JSMD5 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA224* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSMD5* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA224, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSMD5, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA224.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA224.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForMD5.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForMD5.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -502,7 +428,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSHA224();
+    ~JSMD5();
 
     void* wrapped() const { return m_ctx; }
 
@@ -512,11 +438,11 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA224, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD5, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA224(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSMD5(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
@@ -525,22 +451,22 @@ public:
     void finishCreation(JSC::VM&);
 };
 
-class JSSHA512 final : public JSC::JSDestructibleObject {
+class JSMatchedRoute final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA512* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSMatchedRoute* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSMatchedRoute, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForMatchedRoute.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMatchedRoute = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForMatchedRoute.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForMatchedRoute = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -550,9 +476,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    ;
 
-    ~JSSHA512();
+    ~JSMatchedRoute();
 
     void* wrapped() const { return m_ctx; }
 
@@ -562,47 +488,59 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMatchedRoute, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA512(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSMatchedRoute(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_filePath;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_params;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_pathname;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_query;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_scriptSrc;
 };
 
-class JSSHA384 final : public JSC::JSDestructibleObject {
+class JSNodeJSFS final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA384* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSNodeJSFS* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA384, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSNodeJSFS, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA384.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA384.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFS.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFS = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForNodeJSFS.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFS = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
     {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSHA384();
+    ~JSNodeJSFS();
 
     void* wrapped() const { return m_ctx; }
 
@@ -612,11 +550,11 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA384, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSNodeJSFS, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA384(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSNodeJSFS(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
@@ -625,22 +563,22 @@ public:
     void finishCreation(JSC::VM&);
 };
 
-class JSSHA256 final : public JSC::JSDestructibleObject {
+class JSRequest final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSRequest* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA256, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSRequest, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForRequest.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequest = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForRequest.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForRequest = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -652,7 +590,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSHA256();
+    ~JSRequest();
 
     void* wrapped() const { return m_ctx; }
 
@@ -662,35 +600,43 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA256, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSRequest, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSRequest(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
 };
 
-class JSSHA512_256 final : public JSC::JSDestructibleObject {
+class JSResponse final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSSHA512_256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSResponse* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512_256, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSResponse, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256 = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512_256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256 = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForResponse.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponse = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForResponse.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForResponse = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -702,7 +648,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSSHA512_256();
+    ~JSResponse();
 
     void* wrapped() const { return m_ctx; }
 
@@ -712,35 +658,44 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512_256, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResponse, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSSHA512_256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSResponse(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_statusText;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
 };
 
-class JSCryptoHasher final : public JSC::JSDestructibleObject {
+class JSSHA1 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSCryptoHasher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSHA1* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSCryptoHasher, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSHA1, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasher = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForCryptoHasher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasher = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA1.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA1.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -752,7 +707,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSCryptoHasher();
+    ~JSSHA1();
 
     void* wrapped() const { return m_ctx; }
 
@@ -762,42 +717,35 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCryptoHasher, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA1, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSCryptoHasher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSHA1(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithms;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithm;
 };
 
-class JSServerWebSocket final : public JSC::JSDestructibleObject {
+class JSSHA224 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSServerWebSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSHA224* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSServerWebSocket, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSHA224, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocket = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForServerWebSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocket = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA224.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA224.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -809,7 +757,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSServerWebSocket();
+    ~JSSHA224();
 
     void* wrapped() const { return m_ctx; }
 
@@ -819,42 +767,35 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSServerWebSocket, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA224, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSServerWebSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSHA224(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
 };
 
-class JSFileSystemRouter final : public JSC::JSDestructibleObject {
+class JSSHA256 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSFileSystemRouter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSHA256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSFileSystemRouter, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSHA256, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouter = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFileSystemRouter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouter = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA256.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA256.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -866,7 +807,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSFileSystemRouter();
+    ~JSSHA256();
 
     void* wrapped() const { return m_ctx; }
 
@@ -876,43 +817,35 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFileSystemRouter, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA256, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSFileSystemRouter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSHA256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_origin;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_routes;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_style;
 };
 
-class JSMatchedRoute final : public JSC::JSDestructibleObject {
+class JSSHA384 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSMatchedRoute* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSHA384* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSMatchedRoute, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSHA384, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMatchedRoute.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMatchedRoute = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMatchedRoute.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMatchedRoute = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA384.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA384.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -922,9 +855,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSMatchedRoute();
+    ~JSSHA384();
 
     void* wrapped() const { return m_ctx; }
 
@@ -934,47 +867,35 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMatchedRoute, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA384, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSMatchedRoute(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSHA384(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_filePath;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_params;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_pathname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_query;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_scriptSrc;
 };
 
-class JSExpect final : public JSC::JSDestructibleObject {
+class JSSHA512 final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSExpect* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSHA512* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSExpect, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSHA512, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpect.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpect = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpect.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpect = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA512.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512 = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -986,7 +907,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSExpect();
+    ~JSSHA512();
 
     void* wrapped() const { return m_ctx; }
 
@@ -996,42 +917,85 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpect, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSExpect(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSHA512(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+};
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+class JSSHA512_256 final : public JSC::JSDestructibleObject {
+public:
+    using Base = JSC::JSDestructibleObject;
+    static JSSHA512_256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_capturedValue;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_resultValue;
+    DECLARE_EXPORT_INFO;
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return WebCore::subspaceForImpl<JSSHA512_256, WebCore::UseCustomHeapCellType::No>(
+            vm,
+            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256 = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSHA512_256.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256 = WTFMove(space); });
+    }
+
+    static void destroy(JSC::JSCell*);
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+    }
+
+    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+
+    ~JSSHA512_256();
+
+    void* wrapped() const { return m_ctx; }
+
+    void detach()
+    {
+        m_ctx = nullptr;
+    }
+
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512_256, m_ctx); }
+
+    void* m_ctx { nullptr };
+
+    JSSHA512_256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+        : Base(vm, structure)
+    {
+        m_ctx = sinkPtr;
+    }
+
+    void finishCreation(JSC::VM&);
 };
 
-class JSTextDecoder final : public JSC::JSDestructibleObject {
+class JSServerWebSocket final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSTextDecoder* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSServerWebSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSTextDecoder, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSServerWebSocket, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoder.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoder = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTextDecoder.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoder = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocket = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForServerWebSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocket = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -1043,7 +1007,7 @@ public:
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSTextDecoder();
+    ~JSServerWebSocket();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1053,11 +1017,11 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextDecoder, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSServerWebSocket, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSTextDecoder(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSServerWebSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
@@ -1069,25 +1033,26 @@ public:
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_encoding;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
 };
 
-class JSRequest final : public JSC::JSDestructibleObject {
+class JSSubprocess final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSRequest* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSSubprocess* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSRequest, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSSubprocess, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForRequest.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequest = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForRequest.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForRequest = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForSubprocess.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSubprocess = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForSubprocess.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForSubprocess = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -1097,9 +1062,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    ;
 
-    ~JSRequest();
+    ~JSSubprocess();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1109,43 +1074,70 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSRequest, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSubprocess, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSRequest(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSSubprocess(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
+        m_weakThis = JSC::Weak<JSSubprocess>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
 
+    JSC::Weak<JSSubprocess> m_weakThis;
+
+    static bool hasPendingActivity(void* ctx);
+
+    class Owner final : public JSC::WeakHandleOwner {
+    public:
+        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+        {
+            auto* controller = JSC::jsCast<JSSubprocess*>(handle.slot()->asCell());
+            if (JSSubprocess::hasPendingActivity(controller->wrapped())) {
+                if (UNLIKELY(reason))
+                    *reason = "has pending activity";
+                return true;
+            }
+
+            return visitor.containsOpaqueRoot(context);
+        }
+        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+    };
+
+    static JSC::WeakHandleOwner* getOwner()
+    {
+        static NeverDestroyed<Owner> m_owner;
+        return &m_owner.get();
+    }
+
     DECLARE_VISIT_CHILDREN;
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_stderr;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_stdin;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_stdout;
 };
 
-class JSResponse final : public JSC::JSDestructibleObject {
+class JSTCPSocket final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSResponse* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSTCPSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSResponse, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSTCPSocket, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForResponse.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponse = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForResponse.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForResponse = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocket = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForTCPSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocket = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -1155,9 +1147,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    ;
 
-    ~JSResponse();
+    ~JSTCPSocket();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1167,44 +1159,69 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResponse, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTCPSocket, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSResponse(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSTCPSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
+        m_weakThis = JSC::Weak<JSTCPSocket>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
 
+    JSC::Weak<JSTCPSocket> m_weakThis;
+
+    static bool hasPendingActivity(void* ctx);
+
+    class Owner final : public JSC::WeakHandleOwner {
+    public:
+        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+        {
+            auto* controller = JSC::jsCast<JSTCPSocket*>(handle.slot()->asCell());
+            if (JSTCPSocket::hasPendingActivity(controller->wrapped())) {
+                if (UNLIKELY(reason))
+                    *reason = "has pending activity";
+                return true;
+            }
+
+            return visitor.containsOpaqueRoot(context);
+        }
+        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+    };
+
+    static JSC::WeakHandleOwner* getOwner()
+    {
+        static NeverDestroyed<Owner> m_owner;
+        return &m_owner.get();
+    }
+
     DECLARE_VISIT_CHILDREN;
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_statusText;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
 };
 
-class JSBlob final : public JSC::JSDestructibleObject {
+class JSTLSSocket final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSBlob* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSTLSSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSBlob, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSTLSSocket, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBlob.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlob = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBlob.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBlob = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocket = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForTLSSocket.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocket = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
@@ -1214,9 +1231,9 @@ public:
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    ;
 
-    ~JSBlob();
+    ~JSTLSSocket();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1226,47 +1243,81 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBlob, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTLSSocket, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSBlob(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSTLSSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
+        m_weakThis = JSC::Weak<JSTLSSocket>(this, getOwner());
     }
 
     void finishCreation(JSC::VM&);
+
+    JSC::Weak<JSTLSSocket> m_weakThis;
+
+    static bool hasPendingActivity(void* ctx);
+
+    class Owner final : public JSC::WeakHandleOwner {
+    public:
+        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+        {
+            auto* controller = JSC::jsCast<JSTLSSocket*>(handle.slot()->asCell());
+            if (JSTLSSocket::hasPendingActivity(controller->wrapped())) {
+                if (UNLIKELY(reason))
+                    *reason = "has pending activity";
+                return true;
+            }
+
+            return visitor.containsOpaqueRoot(context);
+        }
+        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+    };
+
+    static JSC::WeakHandleOwner* getOwner()
+    {
+        static NeverDestroyed<Owner> m_owner;
+        return &m_owner.get();
+    }
+
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
 };
 
-class JSDirent final : public JSC::JSDestructibleObject {
+class JSTextDecoder final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSDirent* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSTextDecoder* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSDirent, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSTextDecoder, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDirent.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirent = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDirent.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDirent = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoder.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoder = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForTextDecoder.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoder = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
     {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSDirent();
+    ~JSTextDecoder();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1276,11 +1327,11 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDirent, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextDecoder, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSDirent(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSTextDecoder(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
@@ -1292,37 +1343,37 @@ public:
     template<typename Visitor> void visitAdditionalChildren(Visitor&);
     DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_encoding;
 };
 
-class JSNodeJSFS final : public JSC::JSDestructibleObject {
+class JSTranspiler final : public JSC::JSDestructibleObject {
 public:
     using Base = JSC::JSDestructibleObject;
-    static JSNodeJSFS* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    static JSTranspiler* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
 
     DECLARE_EXPORT_INFO;
     template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
     {
         if constexpr (mode == JSC::SubspaceAccess::Concurrently)
             return nullptr;
-        return WebCore::subspaceForImpl<JSNodeJSFS, WebCore::UseCustomHeapCellType::No>(
+        return WebCore::subspaceForImpl<JSTranspiler, WebCore::UseCustomHeapCellType::No>(
             vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFS.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFS = WTFMove(space); },
-            [](auto& spaces) { return spaces.m_subspaceForNodeJSFS.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFS = WTFMove(space); });
+            [](auto& spaces) { return spaces.m_clientSubspaceForTranspiler.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTranspiler = WTFMove(space); },
+            [](auto& spaces) { return spaces.m_subspaceForTranspiler.get(); },
+            [](auto& spaces, auto&& space) { spaces.m_subspaceForTranspiler = WTFMove(space); });
     }
 
     static void destroy(JSC::JSCell*);
     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
     {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
     }
 
     static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
     static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
 
-    ~JSNodeJSFS();
+    ~JSTranspiler();
 
     void* wrapped() const { return m_ctx; }
 
@@ -1332,17 +1383,20 @@ public:
     }
 
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSNodeJSFS, m_ctx); }
+    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTranspiler, m_ctx); }
 
     void* m_ctx { nullptr };
 
-    JSNodeJSFS(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+    JSTranspiler(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
         : Base(vm, structure)
     {
         m_ctx = sinkPtr;
     }
 
     void finishCreation(JSC::VM&);
+
+    WTF::Vector<std::unique_ptr<BunPlugin::OnLoad>> onLoadPlugins;
+    WTF::Vector<std::unique_ptr<BunPlugin::OnResolve>> onResolvePlugins;
 };
 
 }