`MessageChannel` and `MessagePort` (#3860)

* copy and format

* copy

* copy

* cleanup

* some tests

* spellcheck

* add types

* don't lock getting contextId

* array buffer test

57 files changed, 3752 insertions, 247 deletions

diff --git a/packages/bun-types/globals.d.ts b/packages/bun-types/globals.d.ts
index ed22be080..bf374adfe 100644
--- a/packages/bun-types/globals.d.ts
+++ b/packages/bun-types/globals.d.ts
@@ -366,6 +366,152 @@ declare function structuredClone<T>(
   options?: StructuredSerializeOptions,
 ): T;
 
+/**
+ * This Channel Messaging API interface allows us to create a new message channel and send data through it via its two MessagePort properties.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel)
+ */
+interface MessageChannel {
+  /**
+   * Returns the first MessagePort object.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel/port1)
+   */
+  readonly port1: MessagePort;
+  /**
+   * Returns the second MessagePort object.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageChannel/port2)
+   */
+  readonly port2: MessagePort;
+}
+
+declare var MessageChannel: {
+  prototype: MessageChannel;
+  new (): MessageChannel;
+};
+
+/**
+ * A message received by a target object.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent)
+ */
+interface MessageEvent<T = any> extends Event {
+  /**
+   * Returns the data of the message.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/data)
+   */
+  readonly data: T;
+  /**
+   * Returns the last event ID string, for server-sent events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/lastEventId)
+   */
+  readonly lastEventId: string;
+  /**
+   * Returns the origin of the message, for server-sent events and cross-document messaging.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/origin)
+   */
+  readonly origin: string;
+  /**
+   * Returns the MessagePort array sent with the message, for cross-document messaging and channel messaging.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/ports)
+   */
+  readonly ports: ReadonlyArray<MessagePort>;
+  /**
+   * Returns the WindowProxy of the source window, for cross-document messaging, and the MessagePort being attached, in the connect event fired at SharedWorkerGlobalScope objects.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/source)
+   */
+  readonly source: MessageEventSource | null;
+  /**
+   * @deprecated
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/initMessageEvent)
+   */
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: MessageEventSource | null,
+    ports?: MessagePort[],
+  ): void;
+}
+
+declare var MessageEvent: {
+  prototype: MessageEvent;
+  new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
+};
+
+interface MessagePortEventMap {
+  message: MessageEvent;
+  messageerror: MessageEvent;
+}
+
+/**
+ * This Channel Messaging API interface represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort)
+ */
+interface MessagePort extends EventTarget {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/message_event) */
+  onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/messageerror_event) */
+  onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
+  /**
+   * Disconnects the port, so that it is no longer active.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/close)
+   */
+  close(): void;
+  /**
+   * Posts a message through the channel. Objects listed in transfer are transferred, not just cloned, meaning that they are no longer usable on the sending side.
+   *
+   * Throws a "DataCloneError" DOMException if transfer contains duplicate objects or port, or if message could not be cloned.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/postMessage)
+   */
+  postMessage(message: any, transfer: Transferable[]): void;
+  postMessage(message: any, options?: StructuredSerializeOptions): void;
+  /**
+   * Begins dispatching messages received on the port.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessagePort/start)
+   */
+  start(): void;
+  addEventListener<K extends keyof MessagePortEventMap>(
+    type: K,
+    listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions,
+  ): void;
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions,
+  ): void;
+  removeEventListener<K extends keyof MessagePortEventMap>(
+    type: K,
+    listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any,
+    options?: boolean | EventListenerOptions,
+  ): void;
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions,
+  ): void;
+}
+
+declare var MessagePort: {
+  prototype: MessagePort;
+  new (): MessagePort;
+};
+
 interface EncodeIntoResult {
   /**
    * The read Unicode code units of input.
diff --git a/src/bun.js/bindings/BunJSCModule.cpp b/src/bun.js/bindings/BunJSCModule.cpp
index a145f51c5..5e7a047ea 100644
--- a/src/bun.js/bindings/BunJSCModule.cpp
+++ b/src/bun.js/bindings/BunJSCModule.cpp
@@ -26,6 +26,7 @@
 #include "JavaScriptCore/VMTrapsInlines.h"
 #include "SerializedScriptValue.h"
 #include "ExceptionOr.h"
+#include "MessagePort.h"
 
 #if ENABLE(REMOTE_INSPECTOR)
 #include "JavaScriptCore/RemoteInspectorServer.h"
@@ -552,8 +553,8 @@ JSC_DEFINE_HOST_FUNCTION(functionSerialize, (JSGlobalObject * lexicalGlobalObjec
     }
 
     Vector<JSC::Strong<JSC::JSObject>> transferList;
-
-    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList));
+    Vector<RefPtr<MessagePort>> dummyPorts;
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList), dummyPorts);
 
     if (serialized.hasException()) {
         WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
diff --git a/src/bun.js/bindings/BunWorkerGlobalScope.cpp b/src/bun.js/bindings/BunWorkerGlobalScope.cpp
index 60b615e18..ef1f70fdf 100644
--- a/src/bun.js/bindings/BunWorkerGlobalScope.cpp
+++ b/src/bun.js/bindings/BunWorkerGlobalScope.cpp
@@ -1,10 +1,14 @@
 #include "config.h"
 
 #include "BunWorkerGlobalScope.h"
+#include "MessagePortChannelProviderImpl.h"
 
-namespace Bun {
-using namespace WebCore;
+namespace WebCore {
 
 WTF_MAKE_ISO_ALLOCATED_IMPL(GlobalScope);
 
+MessagePortChannelProvider& GlobalScope::messagePortChannelProvider()
+{
+    return *reinterpret_cast<MessagePortChannelProvider*>(&MessagePortChannelProviderImpl::singleton());
+}
 }
\ No newline at end of file
diff --git a/src/bun.js/bindings/BunWorkerGlobalScope.h b/src/bun.js/bindings/BunWorkerGlobalScope.h
index 767289716..fff50d6ec 100644
--- a/src/bun.js/bindings/BunWorkerGlobalScope.h
+++ b/src/bun.js/bindings/BunWorkerGlobalScope.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #include "root.h"
 
 #include "EventTarget.h"
@@ -7,8 +9,12 @@
 #include <wtf/HashSet.h>
 #include <wtf/Lock.h>
 
-namespace Bun {
-class GlobalScope final : public RefCounted<GlobalScope>, public EventTargetWithInlineData {
+namespace WebCore {
+
+class MessagePortChannelProvider;
+class MessagePortChannelProviderImpl;
+
+class GlobalScope : public RefCounted<GlobalScope>, public EventTargetWithInlineData {
     WTF_MAKE_ISO_ALLOCATED(GlobalScope);
 
 public:
@@ -33,6 +39,11 @@ public:
     void derefEventTarget() final { deref(); }
     void eventListenersDidChange() final {}
 
+    MessagePortChannelProvider& messagePortChannelProvider();
+
     ScriptExecutionContext* m_context;
+
+private:
+    MessagePortChannelProviderImpl* m_messagePortChannelProvider;
 };
 }
\ No newline at end of file
diff --git a/src/bun.js/bindings/ScriptExecutionContext.cpp b/src/bun.js/bindings/ScriptExecutionContext.cpp
index 47908b385..d9adbeb98 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.cpp
+++ b/src/bun.js/bindings/ScriptExecutionContext.cpp
@@ -1,6 +1,7 @@
 #include "root.h"
 #include "headers.h"
 #include "ScriptExecutionContext.h"
+#include "MessagePort.h"
 
 #include "webcore/WebSocket.h"
 #include "libusockets.h"
@@ -70,6 +71,23 @@ void ScriptExecutionContext::unrefEventLoop()
     Bun__eventLoop__incrementRefConcurrently(WebCore::clientData(vm())->bunVM, -1);
 }
 
+ScriptExecutionContext::~ScriptExecutionContext()
+{
+    checkConsistency();
+
+    {
+        Locker locker { allScriptExecutionContextsMapLock };
+        ASSERT_WITH_MESSAGE(!allScriptExecutionContextsMap().contains(m_identifier), "A ScriptExecutionContext subclass instance implementing postTask should have already removed itself from the map");
+    }
+
+    auto postMessageCompletionHandlers = WTFMove(m_processMessageWithMessagePortsSoonHandlers);
+    for (auto& completionHandler : postMessageCompletionHandlers)
+        completionHandler();
+
+    while (auto* destructionObserver = m_destructionObservers.takeAny())
+        destructionObserver->contextDestroyed();
+}
+
 bool ScriptExecutionContext::postTaskTo(ScriptExecutionContextIdentifier identifier, Function<void(ScriptExecutionContext&)>&& task)
 {
     Locker locker { allScriptExecutionContextsMapLock };
@@ -82,6 +100,125 @@ bool ScriptExecutionContext::postTaskTo(ScriptExecutionContextIdentifier identif
     return true;
 }
 
+void ScriptExecutionContext::didCreateDestructionObserver(ContextDestructionObserver& observer)
+{
+    ASSERT(!m_inScriptExecutionContextDestructor);
+    m_destructionObservers.add(&observer);
+}
+
+void ScriptExecutionContext::willDestroyDestructionObserver(ContextDestructionObserver& observer)
+{
+    m_destructionObservers.remove(&observer);
+}
+
+extern "C" void* Bun__getVM();
+
+bool ScriptExecutionContext::isContextThread()
+{
+    auto clientData = WebCore::clientData(vm());
+    return clientData->bunVM == Bun__getVM();
+}
+
+bool ScriptExecutionContext::ensureOnContextThread(ScriptExecutionContextIdentifier identifier, Function<void(ScriptExecutionContext&)>&& task)
+{
+    ScriptExecutionContext* context = nullptr;
+    {
+        Locker locker { allScriptExecutionContextsMapLock };
+        context = allScriptExecutionContextsMap().get(identifier);
+
+        if (!context)
+            return false;
+
+        if (!context->isContextThread()) {
+            context->postTaskConcurrently(WTFMove(task));
+            return true;
+        }
+    }
+
+    task(*context);
+    return true;
+}
+
+bool ScriptExecutionContext::ensureOnMainThread(Function<void(ScriptExecutionContext&)>&& task)
+{
+    Locker locker { allScriptExecutionContextsMapLock };
+    auto* context = allScriptExecutionContextsMap().get(1);
+
+    if (!context) {
+        return false;
+    }
+
+    context->postTaskConcurrently(WTFMove(task));
+    return true;
+}
+
+void ScriptExecutionContext::processMessageWithMessagePortsSoon(CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(isContextThread());
+    m_processMessageWithMessagePortsSoonHandlers.append(WTFMove(completionHandler));
+
+    if (m_willProcessMessageWithMessagePortsSoon) {
+        return;
+    }
+
+    m_willProcessMessageWithMessagePortsSoon = true;
+
+    postTask([](ScriptExecutionContext& context) {
+        context.dispatchMessagePortEvents();
+    });
+}
+
+void ScriptExecutionContext::dispatchMessagePortEvents()
+{
+    ASSERT(isContextThread());
+    checkConsistency();
+
+    ASSERT(m_willprocessMessageWithMessagePortsSoon);
+    m_willProcessMessageWithMessagePortsSoon = false;
+
+    auto completionHandlers = std::exchange(m_processMessageWithMessagePortsSoonHandlers, Vector<CompletionHandler<void()>> {});
+
+    // Make a frozen copy of the ports so we can iterate while new ones might be added or destroyed.
+    for (auto* messagePort : copyToVector(m_messagePorts)) {
+        // The port may be destroyed, and another one created at the same address,
+        // but this is harmless. The worst that can happen as a result is that
+        // dispatchMessages() will be called needlessly.
+        if (m_messagePorts.contains(messagePort) && messagePort->started())
+            messagePort->dispatchMessages();
+    }
+
+    for (auto& completionHandler : completionHandlers)
+        completionHandler();
+}
+
+void ScriptExecutionContext::checkConsistency() const
+{
+    for (auto* messagePort : m_messagePorts)
+        ASSERT(messagePort->scriptExecutionContext() == this);
+
+    for (auto* destructionObserver : m_destructionObservers)
+        ASSERT(destructionObserver->scriptExecutionContext() == this);
+
+    // for (auto* activeDOMObject : m_activeDOMObjects) {
+    //     ASSERT(activeDOMObject->scriptExecutionContext() == this);
+    //     activeDOMObject->assertSuspendIfNeededWasCalled();
+    // }
+}
+
+void ScriptExecutionContext::createdMessagePort(MessagePort& messagePort)
+{
+    ASSERT(isContextThread());
+
+    m_messagePorts.add(&messagePort);
+}
+
+void ScriptExecutionContext::destroyedMessagePort(MessagePort& messagePort)
+{
+    ASSERT(isContextThread());
+
+    m_messagePorts.remove(&messagePort);
+}
+
 us_socket_context_t* ScriptExecutionContext::webSocketContextNoSSL()
 {
     if (!m_client_websockets_ctx) {
diff --git a/src/bun.js/bindings/ScriptExecutionContext.h b/src/bun.js/bindings/ScriptExecutionContext.h
index b0e4e2096..23c44ab51 100644
--- a/src/bun.js/bindings/ScriptExecutionContext.h
+++ b/src/bun.js/bindings/ScriptExecutionContext.h
@@ -2,12 +2,14 @@
 
 #include "root.h"
 #include "ActiveDOMObject.h"
+#include "ContextDestructionObserver.h"
 #include <wtf/CrossThreadTask.h>
 #include <wtf/Function.h>
 #include <wtf/HashSet.h>
 #include <wtf/ObjectIdentifier.h>
 #include <wtf/WeakPtr.h>
 #include <wtf/text/WTFString.h>
+#include <wtf/CompletionHandler.h>
 #include "CachedScript.h"
 #include "wtf/URL.h"
 
@@ -27,6 +29,7 @@ struct us_loop_t;
 namespace WebCore {
 
 class WebSocket;
+class MessagePort;
 
 class ScriptExecutionContext;
 
@@ -89,6 +92,8 @@ public:
         addToContextsMap();
     }
 
+    ~ScriptExecutionContext();
+
     static ScriptExecutionContextIdentifier generateIdentifier();
 
     JSC::JSGlobalObject* jsGlobalObject()
@@ -117,7 +122,7 @@ public:
     bool isMainThread() const { return static_cast<unsigned>(m_identifier) == 1; }
     bool activeDOMObjectsAreSuspended() { return false; }
     bool activeDOMObjectsAreStopped() { return false; }
-    bool isContextThread() { return true; }
+    bool isContextThread();
     bool isDocument() { return false; }
     bool isWorkerGlobalScope() { return true; }
     bool isJSExecutionForbidden() { return false; }
@@ -140,7 +145,21 @@ public:
     bool unwrapCryptoKey(const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key) { return false; }
 #endif
 
-    static bool postTaskTo(ScriptExecutionContextIdentifier identifier, Function<void(ScriptExecutionContext&)>&& task);
+    WEBCORE_EXPORT static bool postTaskTo(ScriptExecutionContextIdentifier identifier, Function<void(ScriptExecutionContext&)>&& task);
+    WEBCORE_EXPORT static bool ensureOnContextThread(ScriptExecutionContextIdentifier, Function<void(ScriptExecutionContext&)>&& task);
+    WEBCORE_EXPORT static bool ensureOnMainThread(Function<void(ScriptExecutionContext&)>&& task);
+
+    WEBCORE_EXPORT JSC::JSGlobalObject* globalObject();
+
+    void didCreateDestructionObserver(ContextDestructionObserver&);
+    void willDestroyDestructionObserver(ContextDestructionObserver&);
+
+    void processMessageWithMessagePortsSoon(CompletionHandler<void()>&&);
+    void createdMessagePort(MessagePort&);
+    void destroyedMessagePort(MessagePort&);
+
+    void dispatchMessagePortEvents();
+    void checkConsistency() const;
 
     void regenerateIdentifier();
     void addToContextsMap();
@@ -196,6 +215,12 @@ private:
     WTF::URL m_url = WTF::URL();
     ScriptExecutionContextIdentifier m_identifier;
 
+    HashSet<MessagePort*> m_messagePorts;
+    HashSet<ContextDestructionObserver*> m_destructionObservers;
+    Vector<CompletionHandler<void()>> m_processMessageWithMessagePortsSoonHandlers;
+
+    bool m_willProcessMessageWithMessagePortsSoon { false };
+
     us_socket_context_t* webSocketContextSSL();
     us_socket_context_t* webSocketContextNoSSL();
     us_socket_context_t* connectedWebSocketKindClientSSL();
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index b7171b21c..1aefe476c 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -119,6 +119,9 @@
 #include "DOMIsoSubspaces.h"
 #include "BunWorkerGlobalScope.h"
 #include "JSWorker.h"
+#include "JSMessageChannel.h"
+#include "JSMessagePort.h"
+// #include "JSBroadcastChannel.h"
 
 #if ENABLE(REMOTE_INSPECTOR)
 #include "JavaScriptCore/RemoteInspectorServer.h"
@@ -718,6 +721,7 @@ GlobalObject::GlobalObject(JSC::VM& vm, JSC::Structure* structure)
     , m_scriptExecutionContext(new WebCore::ScriptExecutionContext(&vm, this))
     , globalEventScope(*new Bun::GlobalScope(m_scriptExecutionContext))
 {
+    // m_scriptExecutionContext = globalEventScope.m_context;
     mockModule = Bun::JSMockModule::create(this);
     globalEventScope.m_context = m_scriptExecutionContext;
 }
@@ -732,6 +736,7 @@ GlobalObject::GlobalObject(JSC::VM& vm, JSC::Structure* structure, WebCore::Scri
     , m_scriptExecutionContext(new WebCore::ScriptExecutionContext(&vm, this, contextId))
     , globalEventScope(*new Bun::GlobalScope(m_scriptExecutionContext))
 {
+    // m_scriptExecutionContext = globalEventScope.m_context;
     mockModule = Bun::JSMockModule::create(this);
     globalEventScope.m_context = m_scriptExecutionContext;
 }
@@ -931,6 +936,15 @@ WEBCORE_GENERATED_CONSTRUCTOR_SETTER(JSDOMFormData);
 WEBCORE_GENERATED_CONSTRUCTOR_GETTER(JSWorker);
 WEBCORE_GENERATED_CONSTRUCTOR_SETTER(JSWorker);
 
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(JSMessageChannel);
+WEBCORE_GENERATED_CONSTRUCTOR_SETTER(JSMessageChannel);
+
+WEBCORE_GENERATED_CONSTRUCTOR_GETTER(JSMessagePort);
+WEBCORE_GENERATED_CONSTRUCTOR_SETTER(JSMessagePort);
+
+// WEBCORE_GENERATED_CONSTRUCTOR_GETTER(JSBroadcastChannel);
+// WEBCORE_GENERATED_CONSTRUCTOR_SETTER(JSBroadcastChannel);
+
 JSC_DECLARE_CUSTOM_GETTER(JSEvent_getter);
 
 JSC_DEFINE_CUSTOM_GETTER(JSEvent_getter,
@@ -1285,13 +1299,14 @@ JSC_DEFINE_HOST_FUNCTION(functionStructuredClone,
         }
     }
 
-    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList));
+    Vector<RefPtr<MessagePort>> ports;
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList), ports);
     if (serialized.hasException()) {
         WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
         return JSValue::encode(jsUndefined());
     }
 
-    JSValue deserialized = serialized.releaseReturnValue()->deserialize(*globalObject, globalObject);
+    JSValue deserialized = serialized.releaseReturnValue()->deserialize(*globalObject, globalObject, ports);
 
     return JSValue::encode(deserialized);
 }
@@ -3665,26 +3680,28 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionPostMessage,
         }
     }
 
-    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList));
+    Vector<RefPtr<MessagePort>> ports;
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTFMove(transferList), ports);
     if (serialized.hasException()) {
         WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
         return JSValue::encode(jsUndefined());
     }
 
-    RefPtr<SerializedScriptValue> message = serialized.releaseReturnValue();
-    ScriptExecutionContext::postTaskTo(context->identifier(), [message = WTFMove(message), protectedThis = Ref { *worker }](ScriptExecutionContext& context) {
+    ExceptionOr<Vector<TransferredMessagePort>> disentangledPorts = MessagePort::disentanglePorts(WTFMove(ports));
+    if (disentangledPorts.hasException()) {
+        WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
+        return JSValue::encode(jsUndefined());
+    }
+
+    MessageWithMessagePorts messageWithMessagePorts { serialized.releaseReturnValue(), disentangledPorts.releaseReturnValue() };
+
+    ScriptExecutionContext::postTaskTo(context->identifier(), [message = messageWithMessagePorts, protectedThis = Ref { *worker }, ports](ScriptExecutionContext& context) mutable {
         Zig::GlobalObject* globalObject = jsCast<Zig::GlobalObject*>(context.jsGlobalObject());
-        bool didFail = false;
-        JSValue value = message->deserialize(*globalObject, globalObject, SerializationErrorMode::NonThrowing, &didFail);
 
-        if (didFail) {
-            protectedThis->dispatchEvent(MessageEvent::create(eventNames().messageerrorEvent, MessageEvent::Init {}, MessageEvent::IsTrusted::Yes));
-            return;
-        }
+        auto ports = MessagePort::entanglePorts(context, WTFMove(message.transferredPorts));
+        auto event = MessageEvent::create(*globalObject, message.message.releaseNonNull(), std::nullopt, WTFMove(ports));
 
-        WebCore::MessageEvent::Init init;
-        init.data = value;
-        protectedThis->dispatchEvent(MessageEvent::create(eventNames().messageEvent, WTFMove(init), MessageEvent::IsTrusted::Yes));
+        protectedThis->dispatchEvent(event.event);
     });
 
     return JSValue::encode(jsUndefined());
@@ -4227,6 +4244,9 @@ void GlobalObject::addBuiltinGlobals(JSC::VM& vm)
     PUT_WEBCORE_GENERATED_CONSTRUCTOR("Headers"_s, JSFetchHeaders);
     PUT_WEBCORE_GENERATED_CONSTRUCTOR("URLSearchParams"_s, JSURLSearchParams);
     PUT_WEBCORE_GENERATED_CONSTRUCTOR("Worker"_s, JSWorker);
+    PUT_WEBCORE_GENERATED_CONSTRUCTOR("MessageChannel"_s, JSMessageChannel);
+    PUT_WEBCORE_GENERATED_CONSTRUCTOR("MessagePort"_s, JSMessagePort);
+    // PUT_WEBCORE_GENERATED_CONSTRUCTOR("BroadcastChannel"_s, JSBroadcastChannel);
 
     putDirectCustomAccessor(vm, builtinNames.TransformStreamPublicName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_TransformStreamConstructor, nullptr), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::DontEnum)));
     putDirectCustomAccessor(vm, builtinNames.TransformStreamPrivateName(), CustomGetterSetter::create(vm, jsServiceWorkerGlobalScope_TransformStreamConstructor, nullptr), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::DontEnum)));
@@ -4619,6 +4639,9 @@ void GlobalObject::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     visitor.append(thisObject->m_JSURLSearchParamsSetterValue);
     visitor.append(thisObject->m_JSDOMFormDataSetterValue);
     visitor.append(thisObject->m_JSWorkerSetterValue);
+    visitor.append(thisObject->m_JSMessageChannelSetterValue);
+    visitor.append(thisObject->m_JSMessagePortSetterValue);
+    visitor.append(thisObject->m_JSBroadcastChannelSetterValue);
 
     thisObject->m_JSArrayBufferSinkClassStructure.visit(visitor);
     thisObject->m_JSBufferListClassStructure.visit(visitor);
diff --git a/src/bun.js/bindings/ZigGlobalObject.h b/src/bun.js/bindings/ZigGlobalObject.h
index e4364d248..9d04786d5 100644
--- a/src/bun.js/bindings/ZigGlobalObject.h
+++ b/src/bun.js/bindings/ZigGlobalObject.h
@@ -43,11 +43,8 @@ class DOMWrapperWorld;
 #include "BunPlugin.h"
 #include "JSMockFunction.h"
 
-namespace Bun {
-class GlobalScope;
-}
-
 namespace WebCore {
+class GlobalScope;
 class SubtleCrypto;
 class EventTarget;
 }
@@ -386,6 +383,9 @@ public:
     mutable WriteBarrier<Unknown> m_JSWebSocketSetterValue;
     mutable WriteBarrier<Unknown> m_JSDOMFormDataSetterValue;
     mutable WriteBarrier<Unknown> m_JSWorkerSetterValue;
+    mutable WriteBarrier<Unknown> m_JSMessageChannelSetterValue;
+    mutable WriteBarrier<Unknown> m_JSMessagePortSetterValue;
+    mutable WriteBarrier<Unknown> m_JSBroadcastChannelSetterValue;
     mutable WriteBarrier<Unknown> m_BunCommonJSModuleValue;
 
     mutable WriteBarrier<JSFunction> m_thenables[promiseFunctionsSize + 1];
diff --git a/src/bun.js/bindings/webcore/ContextDestructionObserver.cpp b/src/bun.js/bindings/webcore/ContextDestructionObserver.cpp
new file mode 100644
index 000000000..72e6a85c4
--- /dev/null
+++ b/src/bun.js/bindings/webcore/ContextDestructionObserver.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+#include "ContextDestructionObserver.h"
+
+#include "ScriptExecutionContext.h"
+
+namespace WebCore {
+
+ContextDestructionObserver::ContextDestructionObserver(ScriptExecutionContext* scriptExecutionContext)
+    : m_context(nullptr)
+{
+    observeContext(scriptExecutionContext);
+}
+
+ContextDestructionObserver::~ContextDestructionObserver()
+{
+    observeContext(nullptr);
+}
+
+void ContextDestructionObserver::observeContext(ScriptExecutionContext* scriptExecutionContext)
+{
+    if (m_context) {
+        ASSERT(m_context->isContextThread());
+        m_context->willDestroyDestructionObserver(*this);
+    }
+
+    m_context = scriptExecutionContext;
+
+    if (m_context) {
+        ASSERT(m_context->isContextThread());
+        m_context->didCreateDestructionObserver(*this);
+    }
+}
+
+void ContextDestructionObserver::contextDestroyed()
+{
+    m_context = nullptr;
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/ContextDestructionObserver.h b/src/bun.js/bindings/webcore/ContextDestructionObserver.h
index ccf20f301..7408b5f27 100644
--- a/src/bun.js/bindings/webcore/ContextDestructionObserver.h
+++ b/src/bun.js/bindings/webcore/ContextDestructionObserver.h
@@ -4,29 +4,23 @@
 
 #include "root.h"
 
-#include "ScriptExecutionContext.h"
-
 namespace WebCore {
 
-// TODO:
+class ScriptExecutionContext;
+
 class ContextDestructionObserver {
 
 public:
-    WEBCORE_EXPORT void contextDestroyed() {}
+    WEBCORE_EXPORT virtual void contextDestroyed();
 
     ScriptExecutionContext* scriptExecutionContext() const { return m_context; }
 
-    ContextDestructionObserver(ScriptExecutionContext* context)
-        : m_context(context)
-    {
-    }
-    ContextDestructionObserver(ContextDestructionObserver& context)
-        : m_context(context.m_context)
-    {
-    }
+protected:
+    WEBCORE_EXPORT ContextDestructionObserver(ScriptExecutionContext*);
+    WEBCORE_EXPORT virtual ~ContextDestructionObserver();
+    void observeContext(ScriptExecutionContext*);
 
 private:
-    int m_junk = 0;
     ScriptExecutionContext* m_context;
 };
 
diff --git a/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h b/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
index 740c6d9a9..391060426 100644
--- a/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
+++ b/src/bun.js/bindings/webcore/DOMClientIsoSubspaces.h
@@ -410,7 +410,7 @@ public:
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForAnimationEvent;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForAttr;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForBeforeUnloadEvent;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForBroadcastChannel;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForBroadcastChannel;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForCDATASection;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForCharacterData;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForClipboardEvent;
@@ -443,9 +443,9 @@ public:
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForIdleDeadline;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForInputEvent;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForKeyboardEvent;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMessageChannel;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMessageChannel;
     std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMessageEvent;
-    // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMessagePort;
+    std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMessagePort;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMouseEvent;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMutationEvent;
     // std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMutationObserver;
diff --git a/src/bun.js/bindings/webcore/DOMIsoSubspaces.h b/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
index 52be5872a..01f202a81 100644
--- a/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
+++ b/src/bun.js/bindings/webcore/DOMIsoSubspaces.h
@@ -401,7 +401,7 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForAnimationEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForAttr;
     // std::unique_ptr<IsoSubspace> m_subspaceForBeforeUnloadEvent;
-    // std::unique_ptr<IsoSubspace> m_subspaceForBroadcastChannel;
+    std::unique_ptr<IsoSubspace> m_subspaceForBroadcastChannel;
     // std::unique_ptr<IsoSubspace> m_subspaceForCDATASection;
     // std::unique_ptr<IsoSubspace> m_subspaceForCharacterData;
     // std::unique_ptr<IsoSubspace> m_subspaceForClipboardEvent;
@@ -409,7 +409,6 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForCompositionEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForCustomElementRegistry;
     std::unique_ptr<IsoSubspace> m_subspaceForCustomEvent;
-    // std::unique_ptr<IsoSubspace> m_subspaceForDOMException;
     // std::unique_ptr<IsoSubspace> m_subspaceForDOMImplementation;
     // std::unique_ptr<IsoSubspace> m_subspaceForDOMPoint;
     // std::unique_ptr<IsoSubspace> m_subspaceForDOMPointReadOnly;
@@ -436,9 +435,9 @@ public:
     // std::unique_ptr<IsoSubspace> m_subspaceForIdleDeadline;
     // std::unique_ptr<IsoSubspace> m_subspaceForInputEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForKeyboardEvent;
-    // std::unique_ptr<IsoSubspace> m_subspaceForMessageChannel;
+    std::unique_ptr<IsoSubspace> m_subspaceForMessageChannel;
     std::unique_ptr<IsoSubspace> m_subspaceForMessageEvent;
-    // std::unique_ptr<IsoSubspace> m_subspaceForMessagePort;
+    std::unique_ptr<IsoSubspace> m_subspaceForMessagePort;
     // std::unique_ptr<IsoSubspace> m_subspaceForMouseEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForMutationEvent;
     // std::unique_ptr<IsoSubspace> m_subspaceForMutationObserver;
diff --git a/src/bun.js/bindings/webcore/EventListenerMap.cpp b/src/bun.js/bindings/webcore/EventListenerMap.cpp
index 5014cfa00..540f498e0 100644
--- a/src/bun.js/bindings/webcore/EventListenerMap.cpp
+++ b/src/bun.js/bindings/webcore/EventListenerMap.cpp
@@ -41,7 +41,6 @@
 #include <wtf/StdLibExtras.h>
 #include <wtf/Vector.h>
 
-
 namespace WebCore {
 
 EventListenerMap::EventListenerMap() = default;
@@ -168,7 +167,7 @@ EventListenerVector* EventListenerMap::find(const AtomString& eventType)
 
 static void removeFirstListenerCreatedFromMarkup(EventListenerVector& listenerVector)
 {
-    bool foundListener = listenerVector.removeFirstMatching([] (const auto& registeredListener) {
+    bool foundListener = listenerVector.removeFirstMatching([](const auto& registeredListener) {
         if (JSEventListener::wasCreatedFromMarkup(registeredListener->callback())) {
             registeredListener->markAsRemoved();
             return true;
diff --git a/src/bun.js/bindings/webcore/EventListenerMap.h b/src/bun.js/bindings/webcore/EventListenerMap.h
index 572f999f9..690afd133 100644
--- a/src/bun.js/bindings/webcore/EventListenerMap.h
+++ b/src/bun.js/bindings/webcore/EventListenerMap.h
@@ -65,7 +65,7 @@ public:
 
     void removeFirstEventListenerCreatedFromMarkup(const AtomString& eventType);
     void copyEventListenersNotCreatedFromMarkupToTarget(EventTarget*);
-    
+
     template<typename Visitor> void visitJSEventListeners(Visitor&);
     Lock& lock() { return m_lock; }
 
diff --git a/src/bun.js/bindings/webcore/EventTargetFactory.cpp b/src/bun.js/bindings/webcore/EventTargetFactory.cpp
index 97e66977b..867d007be 100644
--- a/src/bun.js/bindings/webcore/EventTargetFactory.cpp
+++ b/src/bun.js/bindings/webcore/EventTargetFactory.cpp
@@ -117,8 +117,8 @@ JSC::JSValue toJS(JSC::JSGlobalObject* state, JSDOMGlobalObject* globalObject, E
         //     case MediaStreamTrackEventTargetInterfaceType:
         //         return toJS(state, globalObject, static_cast<MediaStreamTrack&>(impl));
         // #endif
-        //     case MessagePortEventTargetInterfaceType:
-        //         return toJS(state, globalObject, static_cast<MessagePort&>(impl));
+    case MessagePortEventTargetInterfaceType:
+        return toJS(state, globalObject, static_cast<MessagePort&>(impl));
         //     case NodeEventTargetInterfaceType:
         //         return toJS(state, globalObject, static_cast<Node&>(impl));
         // #if ENABLE(NOTIFICATIONS)
diff --git a/src/bun.js/bindings/webcore/EventTargetHeaders.h b/src/bun.js/bindings/webcore/EventTargetHeaders.h
index b36e49a66..89c1f2393 100644
--- a/src/bun.js/bindings/webcore/EventTargetHeaders.h
+++ b/src/bun.js/bindings/webcore/EventTargetHeaders.h
@@ -106,8 +106,8 @@
 // #include "JSMediaStreamTrack.h"
 // #include "MediaStreamTrack.h"
 // #endif
-// #include "MessagePort.h"
-// #include "JSMessagePort.h"
+#include "MessagePort.h"
+#include "JSMessagePort.h"
 // #include "JSNode.h"
 #include "Node.h"
 // #if ENABLE(NOTIFICATIONS)
diff --git a/src/bun.js/bindings/webcore/JSMessageChannel.cpp b/src/bun.js/bindings/webcore/JSMessageChannel.cpp
new file mode 100644
index 000000000..2082bd9a8
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessageChannel.cpp
@@ -0,0 +1,323 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+
+#if ENABLE(CHANNEL_MESSAGING)
+
+#include "JSMessageChannel.h"
+
+#include "ActiveDOMObject.h"
+#include "ExtendedDOMClientIsoSubspaces.h"
+#include "ExtendedDOMIsoSubspaces.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructor.h"
+#include "JSDOMConvertInterface.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObject.h"
+#include "JSDOMGlobalObjectInlines.h"
+#include "JSDOMWrapperCache.h"
+#include "JSMessagePort.h"
+#include "ScriptExecutionContext.h"
+#include "WebCoreJSClientData.h"
+#include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/HeapAnalyzer.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/SlotVisitorMacros.h>
+#include <JavaScriptCore/SubspaceInlines.h>
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+namespace WebCore {
+using namespace JSC;
+
+// Attributes
+
+static JSC_DECLARE_CUSTOM_GETTER(jsMessageChannelConstructor);
+static JSC_DECLARE_CUSTOM_GETTER(jsMessageChannel_port1);
+static JSC_DECLARE_CUSTOM_GETTER(jsMessageChannel_port2);
+
+class JSMessageChannelPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static JSMessageChannelPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSMessageChannelPrototype* ptr = new (NotNull, JSC::allocateCell<JSMessageChannelPrototype>(vm)) JSMessageChannelPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMessageChannelPrototype, Base);
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSMessageChannelPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+        : JSC::JSNonFinalObject(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMessageChannelPrototype, JSMessageChannelPrototype::Base);
+
+using JSMessageChannelDOMConstructor = JSDOMConstructor<JSMessageChannel>;
+
+template<> EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSMessageChannelDOMConstructor::construct(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
+{
+    VM& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* castedThis = jsCast<JSMessageChannelDOMConstructor*>(callFrame->jsCallee());
+    ASSERT(castedThis);
+    auto* context = castedThis->scriptExecutionContext();
+    if (UNLIKELY(!context))
+        return throwConstructorScriptExecutionContextUnavailableError(*lexicalGlobalObject, throwScope, "MessageChannel");
+    auto object = MessageChannel::create(*context);
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    static_assert(TypeOrExceptionOrUnderlyingType<decltype(object)>::isRef);
+    auto jsValue = toJSNewlyCreated<IDLInterface<MessageChannel>>(*lexicalGlobalObject, *castedThis->globalObject(), throwScope, WTFMove(object));
+    if constexpr (IsExceptionOr<decltype(object)>)
+        RETURN_IF_EXCEPTION(throwScope, {});
+    setSubclassStructureIfNeeded<MessageChannel>(lexicalGlobalObject, callFrame, asObject(jsValue));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    return JSValue::encode(jsValue);
+}
+JSC_ANNOTATE_HOST_FUNCTION(JSMessageChannelDOMConstructorConstruct, JSMessageChannelDOMConstructor::construct);
+
+template<> const ClassInfo JSMessageChannelDOMConstructor::s_info = { "MessageChannel"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessageChannelDOMConstructor) };
+
+template<> JSValue JSMessageChannelDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+    UNUSED_PARAM(vm);
+    return globalObject.functionPrototype();
+}
+
+template<> void JSMessageChannelDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "MessageChannel"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    putDirect(vm, vm.propertyNames->prototype, JSMessageChannel::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSMessageChannelPrototypeTableValues[] = {
+    { "constructor"_s, static_cast<unsigned>(PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsMessageChannelConstructor, 0 } },
+    { "port1"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsMessageChannel_port1, 0 } },
+    { "port2"_s, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsMessageChannel_port2, 0 } },
+};
+
+const ClassInfo JSMessageChannelPrototype::s_info = { "MessageChannel"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessageChannelPrototype) };
+
+void JSMessageChannelPrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSMessageChannel::info(), JSMessageChannelPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSMessageChannel::s_info = { "MessageChannel"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessageChannel) };
+
+JSMessageChannel::JSMessageChannel(Structure* structure, JSDOMGlobalObject& globalObject, Ref<MessageChannel>&& impl)
+    : JSDOMWrapper<MessageChannel>(structure, globalObject, WTFMove(impl))
+{
+}
+
+// static_assert(!std::is_base_of<ActiveDOMObject, MessageChannel>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
+
+JSObject* JSMessageChannel::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    auto* structure = JSMessageChannelPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype());
+    structure->setMayBePrototype(true);
+    return JSMessageChannelPrototype::create(vm, &globalObject, structure);
+}
+
+JSObject* JSMessageChannel::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return getDOMPrototype<JSMessageChannel>(vm, globalObject);
+}
+
+JSValue JSMessageChannel::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSMessageChannelDOMConstructor, DOMConstructorID::MessageChannel>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+void JSMessageChannel::destroy(JSC::JSCell* cell)
+{
+    JSMessageChannel* thisObject = static_cast<JSMessageChannel*>(cell);
+    thisObject->JSMessageChannel::~JSMessageChannel();
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessageChannelConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* prototype = jsDynamicCast<JSMessageChannelPrototype*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(JSMessageChannel::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
+}
+
+static inline JSValue jsMessageChannel_port1Getter(JSGlobalObject& lexicalGlobalObject, JSMessageChannel& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<MessagePort>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.port1())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessageChannel_port1, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessageChannel>::get<jsMessageChannel_port1Getter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline JSValue jsMessageChannel_port2Getter(JSGlobalObject& lexicalGlobalObject, JSMessageChannel& thisObject)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto& impl = thisObject.wrapped();
+    RELEASE_AND_RETURN(throwScope, (toJS<IDLInterface<MessagePort>>(lexicalGlobalObject, *thisObject.globalObject(), throwScope, impl.port2())));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessageChannel_port2, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessageChannel>::get<jsMessageChannel_port2Getter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+JSC::GCClient::IsoSubspace* JSMessageChannel::subspaceForImpl(JSC::VM& vm)
+{
+    return WebCore::subspaceForImpl<JSMessageChannel, UseCustomHeapCellType::No>(
+        vm,
+        [](auto& spaces) { return spaces.m_clientSubspaceForMessageChannel.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMessageChannel = std::forward<decltype(space)>(space); },
+        [](auto& spaces) { return spaces.m_subspaceForMessageChannel.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_subspaceForMessageChannel = std::forward<decltype(space)>(space); });
+}
+
+template<typename Visitor>
+void JSMessageChannel::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    auto* thisObject = jsCast<JSMessageChannel*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    thisObject->visitAdditionalChildren(visitor);
+}
+
+DEFINE_VISIT_CHILDREN(JSMessageChannel);
+
+template<typename Visitor>
+void JSMessageChannel::visitOutputConstraints(JSCell* cell, Visitor& visitor)
+{
+    auto* thisObject = jsCast<JSMessageChannel*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitOutputConstraints(thisObject, visitor);
+    thisObject->visitAdditionalChildren(visitor);
+}
+
+template void JSMessageChannel::visitOutputConstraints(JSCell*, AbstractSlotVisitor&);
+template void JSMessageChannel::visitOutputConstraints(JSCell*, SlotVisitor&);
+void JSMessageChannel::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSMessageChannel*>(cell);
+    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+    if (thisObject->scriptExecutionContext())
+        analyzer.setLabelForCell(cell, "url "_s + thisObject->scriptExecutionContext()->url().string());
+    Base::analyzeHeap(cell, analyzer);
+}
+
+bool JSMessageChannelOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason)
+{
+    UNUSED_PARAM(handle);
+    UNUSED_PARAM(visitor);
+    UNUSED_PARAM(reason);
+    return false;
+}
+
+void JSMessageChannelOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+    auto* jsMessageChannel = static_cast<JSMessageChannel*>(handle.slot()->asCell());
+    auto& world = *static_cast<DOMWrapperWorld*>(context);
+    uncacheWrapper(world, &jsMessageChannel->wrapped(), jsMessageChannel);
+}
+
+#if ENABLE(BINDING_INTEGRITY)
+#if PLATFORM(WIN)
+#pragma warning(disable : 4483)
+extern "C" {
+extern void (*const __identifier("??_7MessageChannel@WebCore@@6B@")[])();
+}
+#else
+extern "C" {
+extern void* _ZTVN7WebCore14MessageChannelE[];
+}
+#endif
+#endif
+
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<MessageChannel>&& impl)
+{
+
+    if constexpr (std::is_polymorphic_v<MessageChannel>) {
+#if ENABLE(BINDING_INTEGRITY)
+        const void* actualVTablePointer = getVTablePointer(impl.ptr());
+#if PLATFORM(WIN)
+        void* expectedVTablePointer = __identifier("??_7MessageChannel@WebCore@@6B@");
+#else
+        void* expectedVTablePointer = &_ZTVN7WebCore14MessageChannelE[2];
+#endif
+
+        // If you hit this assertion you either have a use after free bug, or
+        // MessageChannel has subclasses. If MessageChannel has subclasses that get passed
+        // to toJS() we currently require MessageChannel you to opt out of binding hardening
+        // by adding the SkipVTableValidation attribute to the interface IDL definition
+        RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
+#endif
+    }
+    return createWrapper<MessageChannel>(globalObject, WTFMove(impl));
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, MessageChannel& impl)
+{
+    return wrap(lexicalGlobalObject, globalObject, impl);
+}
+
+MessageChannel* JSMessageChannel::toWrapped(JSC::VM&, JSC::JSValue value)
+{
+    if (auto* wrapper = jsDynamicCast<JSMessageChannel*>(value))
+        return &wrapper->wrapped();
+    return nullptr;
+}
+
+}
+
+#endif // ENABLE(CHANNEL_MESSAGING)
diff --git a/src/bun.js/bindings/webcore/JSMessageChannel.h b/src/bun.js/bindings/webcore/JSMessageChannel.h
new file mode 100644
index 000000000..551be7459
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessageChannel.h
@@ -0,0 +1,102 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#if ENABLE(CHANNEL_MESSAGING)
+
+#include "JSDOMWrapper.h"
+#include "MessageChannel.h"
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+class JSMessageChannel : public JSDOMWrapper<MessageChannel> {
+public:
+    using Base = JSDOMWrapper<MessageChannel>;
+    static JSMessageChannel* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<MessageChannel>&& impl)
+    {
+        JSMessageChannel* ptr = new (NotNull, JSC::allocateCell<JSMessageChannel>(globalObject->vm())) JSMessageChannel(structure, *globalObject, WTFMove(impl));
+        ptr->finishCreation(globalObject->vm());
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+    static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+    static MessageChannel* toWrapped(JSC::VM&, JSC::JSValue);
+    static void destroy(JSC::JSCell*);
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return subspaceForImpl(vm);
+    }
+    static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+
+    template<typename Visitor> static void visitOutputConstraints(JSCell*, Visitor&);
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+
+protected:
+    JSMessageChannel(JSC::Structure*, JSDOMGlobalObject&, Ref<MessageChannel>&&);
+
+    DECLARE_DEFAULT_FINISH_CREATION;
+};
+
+class JSMessageChannelOwner final : public JSC::WeakHandleOwner {
+public:
+    bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor&, const char**) final;
+    void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, MessageChannel*)
+{
+    static NeverDestroyed<JSMessageChannelOwner> owner;
+    return &owner.get();
+}
+
+inline void* wrapperKey(MessageChannel* wrappableObject)
+{
+    return wrappableObject;
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject*, JSDOMGlobalObject*, MessageChannel&);
+inline JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, MessageChannel* impl) { return impl ? toJS(lexicalGlobalObject, globalObject, *impl) : JSC::jsNull(); }
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject*, Ref<MessageChannel>&&);
+inline JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, RefPtr<MessageChannel>&& impl) { return impl ? toJSNewlyCreated(lexicalGlobalObject, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
+
+template<> struct JSDOMWrapperConverterTraits<MessageChannel> {
+    using WrapperClass = JSMessageChannel;
+    using ToWrappedReturnType = MessageChannel*;
+};
+
+} // namespace WebCore
+
+#endif // ENABLE(CHANNEL_MESSAGING)
diff --git a/src/bun.js/bindings/webcore/JSMessageChannelCustom.cpp b/src/bun.js/bindings/webcore/JSMessageChannelCustom.cpp
new file mode 100644
index 000000000..75b074048
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessageChannelCustom.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2008-2021 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#if ENABLE(CHANNEL_MESSAGING)
+
+#include "DOMWrapperWorld.h"
+#include "JSMessageChannel.h"
+// #include "JSNodeCustom.h"
+#include "MessagePort.h"
+// #include "WebCoreOpaqueRootInlines.h"
+#include <JavaScriptCore/SlotVisitorInlines.h>
+
+namespace WebCore {
+
+template<typename Visitor>
+void JSMessageChannel::visitAdditionalChildren(Visitor& visitor)
+{
+    visitor.addOpaqueRoot(WTF::getPtr(wrapped().port1()));
+    visitor.addOpaqueRoot(WTF::getPtr(wrapped().port2()));
+    // addWebCoreOpaqueRoot(visitor, wrapped().port1());
+    // addWebCoreOpaqueRoot(visitor, wrapped().port2());
+}
+
+DEFINE_VISIT_ADDITIONAL_CHILDREN(JSMessageChannel);
+
+} // namespace WebCore
+
+#endif // ENABLE(CHANNEL_MESSAGING)
diff --git a/src/bun.js/bindings/webcore/JSMessageEvent.cpp b/src/bun.js/bindings/webcore/JSMessageEvent.cpp
index e797e3af2..f6090bd91 100644
--- a/src/bun.js/bindings/webcore/JSMessageEvent.cpp
+++ b/src/bun.js/bindings/webcore/JSMessageEvent.cpp
@@ -41,7 +41,7 @@
 #include "JSDOMGlobalObjectInlines.h"
 #include "JSDOMOperation.h"
 #include "JSDOMWrapperCache.h"
-// #include "JSMessagePort.h"
+#include "JSMessagePort.h"
 #include "JSServiceWorker.h"
 #include "JSWindowProxy.h"
 #include "ScriptExecutionContext.h"
@@ -143,18 +143,18 @@ template<> MessageEvent::Init convertDictionary<MessageEvent::Init>(JSGlobalObje
         RETURN_IF_EXCEPTION(throwScope, {});
     } else
         result.origin = emptyString();
-    // JSValue portsValue;
-    // if (isNullOrUndefined)
-    //     portsValue = jsUndefined();
-    // else {
-    //     portsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "ports"_s));
-    //     RETURN_IF_EXCEPTION(throwScope, { });
-    // }
-    // if (!portsValue.isUndefined()) {
-    //     result.ports = convert<IDLSequence<IDLInterface<MessagePort>>>(lexicalGlobalObject, portsValue);
-    //     RETURN_IF_EXCEPTION(throwScope, { });
-    // } else
-    //     result.ports = Converter<IDLSequence<IDLInterface<MessagePort>>>::ReturnType{ };
+    JSValue portsValue;
+    if (isNullOrUndefined)
+        portsValue = jsUndefined();
+    else {
+        portsValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "ports"_s));
+        RETURN_IF_EXCEPTION(throwScope, {});
+    }
+    if (!portsValue.isUndefined()) {
+        result.ports = convert<IDLSequence<IDLInterface<MessagePort>>>(lexicalGlobalObject, portsValue);
+        RETURN_IF_EXCEPTION(throwScope, {});
+    } else
+        result.ports = Converter<IDLSequence<IDLInterface<MessagePort>>>::ReturnType {};
     JSValue sourceValue;
     if (isNullOrUndefined)
         sourceValue = jsUndefined();
@@ -377,9 +377,7 @@ JSC_DEFINE_CUSTOM_GETTER(jsMessageEvent_data, (JSGlobalObject * lexicalGlobalObj
 static inline JSValue jsMessageEvent_portsGetter(JSGlobalObject& lexicalGlobalObject, JSMessageEvent& thisObject)
 {
     UNUSED_PARAM(lexicalGlobalObject);
-    // TODO:
-    return JSArray::create(lexicalGlobalObject.vm(), lexicalGlobalObject.arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous), 0);
-    // return thisObject.ports(lexicalGlobalObject);
+    return thisObject.ports(lexicalGlobalObject);
 }
 
 JSC_DEFINE_CUSTOM_GETTER(jsMessageEvent_ports, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
@@ -416,13 +414,12 @@ static inline JSC::EncodedJSValue jsMessageEventPrototypeFunction_initMessageEve
     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
     EnsureStillAliveScope argument6 = callFrame->argument(6);
     auto source = WebCore::MessageEventSource();
-    // RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
-    // EnsureStillAliveScope argument7 = callFrame->argument(7);
-    // auto messagePorts = JSArray::create(lexicalGlobalObject.vm(), lexicalGlobalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous), 0);
-    // auto messagePorts = Converter<IDLSequence<IDLInterface<MessagePort>>>::ReturnType {};
+    // auto source = argument6.value().isUndefined() ? std::nullopt : convert<IDLNullable<IDLUnion<IDLInterface<WindowProxy>, IDLInterface<MessagePort>, IDLInterface<ServiceWorker>>>>(*lexicalGlobalObject, argument6.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument7 = callFrame->argument(7);
+    auto messagePorts = argument7.value().isUndefined() ? Converter<IDLSequence<IDLInterface<MessagePort>>>::ReturnType {} : convert<IDLSequence<IDLInterface<MessagePort>>>(*lexicalGlobalObject, argument7.value());
     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
-    // RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.initMessageEvent(WTFMove(type), WTFMove(bubbles), WTFMove(cancelable), WTFMove(data), WTFMove(originArg), WTFMove(lastEventId), WTFMove(source), WTFMove(messagePorts)); })));
-    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.initMessageEvent(WTFMove(type), WTFMove(bubbles), WTFMove(cancelable), WTFMove(data), WTFMove(originArg), WTFMove(lastEventId), WTFMove(source)); })));
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.initMessageEvent(WTFMove(type), WTFMove(bubbles), WTFMove(cancelable), WTFMove(data), WTFMove(originArg), WTFMove(lastEventId), WTFMove(source), WTFMove(messagePorts)); })));
 }
 
 JSC_DEFINE_HOST_FUNCTION(jsMessageEventPrototypeFunction_initMessageEvent, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
@@ -474,7 +471,7 @@ void JSMessageEvent::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     auto* thisObject = jsCast<JSMessageEvent*>(cell);
     analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
     if (thisObject->scriptExecutionContext())
-        analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+        analyzer.setLabelForCell(cell, "url "_s + thisObject->scriptExecutionContext()->url().string());
     Base::analyzeHeap(cell, analyzer);
 }
 
diff --git a/src/bun.js/bindings/webcore/JSMessageEvent.h b/src/bun.js/bindings/webcore/JSMessageEvent.h
index 85424d9ec..8f48568f7 100644
--- a/src/bun.js/bindings/webcore/JSMessageEvent.h
+++ b/src/bun.js/bindings/webcore/JSMessageEvent.h
@@ -70,6 +70,7 @@ public:
     {
         return static_cast<MessageEvent&>(Base::wrapped());
     }
+
 protected:
     JSMessageEvent(JSC::Structure*, JSDOMGlobalObject&, Ref<MessageEvent>&&);
 
@@ -87,5 +88,4 @@ template<> struct JSDOMWrapperConverterTraits<MessageEvent> {
 };
 template<> MessageEvent::Init convertDictionary<MessageEvent::Init>(JSC::JSGlobalObject&, JSC::JSValue);
 
-
 } // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSMessageEventCustom.cpp b/src/bun.js/bindings/webcore/JSMessageEventCustom.cpp
index 66390f86b..772a1b3c4 100644
--- a/src/bun.js/bindings/webcore/JSMessageEventCustom.cpp
+++ b/src/bun.js/bindings/webcore/JSMessageEventCustom.cpp
@@ -45,26 +45,21 @@ namespace WebCore {
 
 JSC::JSValue JSMessageEvent::ports(JSC::JSGlobalObject& lexicalGlobalObject) const
 {
-    return JSC::jsUndefined();
+    auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject.vm());
+    return cachedPropertyValue(lexicalGlobalObject, *this, wrapped().cachedPorts(), [&] {
+        JSC::JSValue ports = toJS<IDLFrozenArray<IDLInterface<MessagePort>>>(lexicalGlobalObject, *globalObject(), throwScope, wrapped().ports());
+        return ports;
+    });
 }
-//     auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject.vm());
-//     return cachedPropertyValue(lexicalGlobalObject, *this, wrapped().cachedPorts(), [&] {
-//         JSC::JSValue ports = toJS<IDLFrozenArray<IDLInterface<MessagePort>>>(lexicalGlobalObject, *globalObject(), throwScope, wrapped().ports());
-//         return ports;
-//     });
-// }
 
 JSC::JSValue JSMessageEvent::data(JSC::JSGlobalObject& lexicalGlobalObject) const
 {
-    return cachedPropertyValue(lexicalGlobalObject, *this, wrapped().cachedData(), [this, &lexicalGlobalObject] {
+    auto throwScope = DECLARE_THROW_SCOPE(lexicalGlobalObject.vm());
+    return cachedPropertyValue(throwScope, lexicalGlobalObject, *this, wrapped().cachedData(), [this, &lexicalGlobalObject](JSC::ThrowScope&) {
         return WTF::switchOn(
-            wrapped().data(), [this](MessageEvent::JSValueTag) -> JSC::JSValue { return wrapped().jsData().getValue(JSC::jsNull()); },
-            // [this, &lexicalGlobalObject](const Ref<SerializedScriptValue>& data) {
-            // // FIXME: Is it best to handle errors by returning null rather than throwing an exception?
-            // return data->deserialize(lexicalGlobalObject, globalObject(), wrapped().ports(), SerializationErrorMode::NonThrowing); },
-            [&lexicalGlobalObject](const String& data) { return toJS<IDLDOMString>(lexicalGlobalObject, data); },
-            // [this, &lexicalGlobalObject](const Ref<Blob>& data) { return toJS<IDLInterface<Blob>>(lexicalGlobalObject, *globalObject(), data); },
-            [this, &lexicalGlobalObject](const Ref<ArrayBuffer>& data) { return toJS<IDLInterface<ArrayBuffer>>(lexicalGlobalObject, *globalObject(), data); });
+            wrapped().data(), [this](MessageEvent::JSValueTag) -> JSC::JSValue { return wrapped().jsData().getValue(JSC::jsNull()); }, [this, &lexicalGlobalObject](const Ref<SerializedScriptValue>& data) {
+            // FIXME: Is it best to handle errors by returning null rather than throwing an exception?
+            return data->deserialize(lexicalGlobalObject, globalObject(), wrapped().ports(), SerializationErrorMode::NonThrowing); }, [&lexicalGlobalObject](const String& data) { return toJS<IDLDOMString>(lexicalGlobalObject, data); }, [this, &lexicalGlobalObject](const Ref<ArrayBuffer>& data) { return toJS<IDLInterface<ArrayBuffer>>(lexicalGlobalObject, *globalObject(), data); });
     });
 }
 
diff --git a/src/bun.js/bindings/webcore/JSMessagePort.cpp b/src/bun.js/bindings/webcore/JSMessagePort.cpp
new file mode 100644
index 000000000..d957e32ce
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessagePort.cpp
@@ -0,0 +1,440 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSMessagePort.h"
+
+#include "ActiveDOMObject.h"
+#include "EventNames.h"
+#include "ExtendedDOMClientIsoSubspaces.h"
+#include "ExtendedDOMIsoSubspaces.h"
+#include "IDLTypes.h"
+#include "JSDOMAttribute.h"
+#include "JSDOMBinding.h"
+#include "JSDOMConstructorNotConstructable.h"
+#include "JSDOMConvertAny.h"
+#include "JSDOMConvertBase.h"
+#include "JSDOMConvertDictionary.h"
+#include "JSDOMConvertObject.h"
+#include "JSDOMConvertSequences.h"
+#include "JSDOMExceptionHandling.h"
+#include "JSDOMGlobalObjectInlines.h"
+#include "JSDOMOperation.h"
+#include "JSDOMWrapperCache.h"
+#include "JSEventListener.h"
+#include "JSStructuredSerializeOptions.h"
+#include "ScriptExecutionContext.h"
+#include "WebCoreJSClientData.h"
+// #include "WebCoreOpaqueRootInlines.h"
+#include <JavaScriptCore/HeapAnalyzer.h>
+#include <JavaScriptCore/IteratorOperations.h>
+#include <JavaScriptCore/JSArray.h>
+#include <JavaScriptCore/JSCInlines.h>
+#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/SlotVisitorMacros.h>
+#include <JavaScriptCore/SubspaceInlines.h>
+#include <wtf/GetPtr.h>
+#include <wtf/PointerPreparations.h>
+#include <wtf/URL.h>
+
+namespace WebCore {
+using namespace JSC;
+
+// Functions
+
+static JSC_DECLARE_HOST_FUNCTION(jsMessagePortPrototypeFunction_postMessage);
+static JSC_DECLARE_HOST_FUNCTION(jsMessagePortPrototypeFunction_start);
+static JSC_DECLARE_HOST_FUNCTION(jsMessagePortPrototypeFunction_close);
+
+// Attributes
+
+static JSC_DECLARE_CUSTOM_GETTER(jsMessagePortConstructor);
+static JSC_DECLARE_CUSTOM_GETTER(jsMessagePort_onmessage);
+static JSC_DECLARE_CUSTOM_SETTER(setJSMessagePort_onmessage);
+static JSC_DECLARE_CUSTOM_GETTER(jsMessagePort_onmessageerror);
+static JSC_DECLARE_CUSTOM_SETTER(setJSMessagePort_onmessageerror);
+
+class JSMessagePortPrototype final : public JSC::JSNonFinalObject {
+public:
+    using Base = JSC::JSNonFinalObject;
+    static JSMessagePortPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSMessagePortPrototype* ptr = new (NotNull, JSC::allocateCell<JSMessagePortPrototype>(vm)) JSMessagePortPrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    template<typename CellType, JSC::SubspaceAccess>
+    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMessagePortPrototype, Base);
+        return &vm.plainObjectSpace();
+    }
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSMessagePortPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
+        : JSC::JSNonFinalObject(vm, structure)
+    {
+    }
+
+    void finishCreation(JSC::VM&);
+};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMessagePortPrototype, JSMessagePortPrototype::Base);
+
+using JSMessagePortDOMConstructor = JSDOMConstructorNotConstructable<JSMessagePort>;
+
+template<> const ClassInfo JSMessagePortDOMConstructor::s_info = { "MessagePort"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessagePortDOMConstructor) };
+
+template<> JSValue JSMessagePortDOMConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
+{
+    return JSEventTarget::getConstructor(vm, &globalObject);
+}
+
+template<> void JSMessagePortDOMConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    JSString* nameString = jsNontrivialString(vm, "MessagePort"_s);
+    m_originalName.set(vm, this, nameString);
+    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
+    putDirect(vm, vm.propertyNames->prototype, JSMessagePort::prototype(vm, globalObject), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSMessagePortPrototypeTableValues[] = {
+    { "constructor"_s, static_cast<unsigned>(PropertyAttribute::DontEnum), NoIntrinsic, { HashTableValue::GetterSetterType, jsMessagePortConstructor, 0 } },
+    { "onmessage"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsMessagePort_onmessage, setJSMessagePort_onmessage } },
+    { "onmessageerror"_s, JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute, NoIntrinsic, { HashTableValue::GetterSetterType, jsMessagePort_onmessageerror, setJSMessagePort_onmessageerror } },
+    { "postMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsMessagePortPrototypeFunction_postMessage, 1 } },
+    { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsMessagePortPrototypeFunction_start, 0 } },
+    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, jsMessagePortPrototypeFunction_close, 0 } },
+};
+
+const ClassInfo JSMessagePortPrototype::s_info = { "MessagePort"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessagePortPrototype) };
+
+void JSMessagePortPrototype::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSMessagePort::info(), JSMessagePortPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+const ClassInfo JSMessagePort::s_info = { "MessagePort"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMessagePort) };
+
+JSMessagePort::JSMessagePort(Structure* structure, JSDOMGlobalObject& globalObject, Ref<MessagePort>&& impl)
+    : JSEventTarget(structure, globalObject, WTFMove(impl))
+{
+}
+
+// static_assert(std::is_base_of<ActiveDOMObject, MessagePort>::value, "Interface is marked as [ActiveDOMObject] but implementation class does not subclass ActiveDOMObject.");
+
+JSObject* JSMessagePort::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    auto* structure = JSMessagePortPrototype::createStructure(vm, &globalObject, JSEventTarget::prototype(vm, globalObject));
+    structure->setMayBePrototype(true);
+    return JSMessagePortPrototype::create(vm, &globalObject, structure);
+}
+
+JSObject* JSMessagePort::prototype(VM& vm, JSDOMGlobalObject& globalObject)
+{
+    return getDOMPrototype<JSMessagePort>(vm, globalObject);
+}
+
+JSValue JSMessagePort::getConstructor(VM& vm, const JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSMessagePortDOMConstructor, DOMConstructorID::MessagePort>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessagePortConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* prototype = jsDynamicCast<JSMessagePortPrototype*>(JSValue::decode(thisValue));
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(JSMessagePort::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
+}
+
+static inline JSValue jsMessagePort_onmessageGetter(JSGlobalObject& lexicalGlobalObject, JSMessagePort& thisObject)
+{
+    UNUSED_PARAM(lexicalGlobalObject);
+    return eventHandlerAttribute(thisObject.wrapped(), eventNames().messageEvent, worldForDOMObject(thisObject));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessagePort_onmessage, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessagePort>::get<jsMessagePort_onmessageGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline bool setJSMessagePort_onmessageSetter(JSGlobalObject& lexicalGlobalObject, JSMessagePort& thisObject, JSValue value)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    UNUSED_PARAM(vm);
+    setEventHandlerAttribute<JSEventListener>(thisObject.wrapped(), eventNames().messageEvent, value, thisObject);
+    vm.writeBarrier(&thisObject, value);
+    ensureStillAliveHere(value);
+
+    return true;
+}
+
+JSC_DEFINE_CUSTOM_SETTER(setJSMessagePort_onmessage, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessagePort>::set<setJSMessagePort_onmessageSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
+}
+
+static inline JSValue jsMessagePort_onmessageerrorGetter(JSGlobalObject& lexicalGlobalObject, JSMessagePort& thisObject)
+{
+    UNUSED_PARAM(lexicalGlobalObject);
+    return eventHandlerAttribute(thisObject.wrapped(), eventNames().messageerrorEvent, worldForDOMObject(thisObject));
+}
+
+JSC_DEFINE_CUSTOM_GETTER(jsMessagePort_onmessageerror, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessagePort>::get<jsMessagePort_onmessageerrorGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
+}
+
+static inline bool setJSMessagePort_onmessageerrorSetter(JSGlobalObject& lexicalGlobalObject, JSMessagePort& thisObject, JSValue value)
+{
+    auto& vm = JSC::getVM(&lexicalGlobalObject);
+    UNUSED_PARAM(vm);
+    setEventHandlerAttribute<JSEventListener>(thisObject.wrapped(), eventNames().messageerrorEvent, value, thisObject);
+    vm.writeBarrier(&thisObject, value);
+    ensureStillAliveHere(value);
+
+    return true;
+}
+
+JSC_DEFINE_CUSTOM_SETTER(setJSMessagePort_onmessageerror, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    return IDLAttribute<JSMessagePort>::set<setJSMessagePort_onmessageerrorSetter>(*lexicalGlobalObject, thisValue, encodedValue, attributeName);
+}
+
+static inline JSC::EncodedJSValue jsMessagePortPrototypeFunction_postMessage1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSMessagePort>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
+    auto message = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument1 = callFrame->uncheckedArgument(1);
+    auto transfer = convert<IDLSequence<IDLObject>>(*lexicalGlobalObject, argument1.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postMessage(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(message), WTFMove(transfer)); })));
+}
+
+static inline JSC::EncodedJSValue jsMessagePortPrototypeFunction_postMessage2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSMessagePort>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
+    auto message = convert<IDLAny>(*lexicalGlobalObject, argument0.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    EnsureStillAliveScope argument1 = callFrame->argument(1);
+    auto options = convert<IDLDictionary<StructuredSerializeOptions>>(*lexicalGlobalObject, argument1.value());
+    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.postMessage(*jsCast<JSDOMGlobalObject*>(lexicalGlobalObject), WTFMove(message), WTFMove(options)); })));
+}
+
+static inline JSC::EncodedJSValue jsMessagePortPrototypeFunction_postMessageOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSMessagePort>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    size_t argsCount = std::min<size_t>(2, callFrame->argumentCount());
+    if (argsCount == 1) {
+        RELEASE_AND_RETURN(throwScope, (jsMessagePortPrototypeFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
+    }
+    if (argsCount == 2) {
+        JSValue distinguishingArg = callFrame->uncheckedArgument(1);
+        if (distinguishingArg.isUndefined())
+            RELEASE_AND_RETURN(throwScope, (jsMessagePortPrototypeFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
+        if (distinguishingArg.isUndefinedOrNull())
+            RELEASE_AND_RETURN(throwScope, (jsMessagePortPrototypeFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
+        {
+            bool success = hasIteratorMethod(lexicalGlobalObject, distinguishingArg);
+            RETURN_IF_EXCEPTION(throwScope, {});
+            if (success)
+                RELEASE_AND_RETURN(throwScope, (jsMessagePortPrototypeFunction_postMessage1Body(lexicalGlobalObject, callFrame, castedThis)));
+        }
+        if (distinguishingArg.isObject())
+            RELEASE_AND_RETURN(throwScope, (jsMessagePortPrototypeFunction_postMessage2Body(lexicalGlobalObject, callFrame, castedThis)));
+    }
+    return argsCount < 1 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsMessagePortPrototypeFunction_postMessage, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSMessagePort>::call<jsMessagePortPrototypeFunction_postMessageOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "postMessage");
+}
+
+static inline JSC::EncodedJSValue jsMessagePortPrototypeFunction_startBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSMessagePort>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.start(); })));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsMessagePortPrototypeFunction_start, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSMessagePort>::call<jsMessagePortPrototypeFunction_startBody>(*lexicalGlobalObject, *callFrame, "start");
+}
+
+static inline JSC::EncodedJSValue jsMessagePortPrototypeFunction_closeBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSMessagePort>::ClassParameter castedThis)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    UNUSED_PARAM(throwScope);
+    UNUSED_PARAM(callFrame);
+    auto& impl = castedThis->wrapped();
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(toJS<IDLUndefined>(*lexicalGlobalObject, throwScope, [&]() -> decltype(auto) { return impl.close(); })));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsMessagePortPrototypeFunction_close, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    return IDLOperation<JSMessagePort>::call<jsMessagePortPrototypeFunction_closeBody>(*lexicalGlobalObject, *callFrame, "close");
+}
+
+JSC::GCClient::IsoSubspace* JSMessagePort::subspaceForImpl(JSC::VM& vm)
+{
+    return WebCore::subspaceForImpl<JSMessagePort, UseCustomHeapCellType::No>(
+        vm,
+        [](auto& spaces) { return spaces.m_clientSubspaceForMessagePort.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMessagePort = std::forward<decltype(space)>(space); },
+        [](auto& spaces) { return spaces.m_subspaceForMessagePort.get(); },
+        [](auto& spaces, auto&& space) { spaces.m_subspaceForMessagePort = std::forward<decltype(space)>(space); });
+}
+
+template<typename Visitor>
+void JSMessagePort::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    auto* thisObject = jsCast<JSMessagePort*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    thisObject->visitAdditionalChildren(visitor);
+}
+
+DEFINE_VISIT_CHILDREN(JSMessagePort);
+
+template<typename Visitor>
+void JSMessagePort::visitOutputConstraints(JSCell* cell, Visitor& visitor)
+{
+    auto* thisObject = jsCast<JSMessagePort*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitOutputConstraints(thisObject, visitor);
+    thisObject->visitAdditionalChildren(visitor);
+}
+
+template void JSMessagePort::visitOutputConstraints(JSCell*, AbstractSlotVisitor&);
+template void JSMessagePort::visitOutputConstraints(JSCell*, SlotVisitor&);
+void JSMessagePort::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSMessagePort*>(cell);
+    analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
+    if (thisObject->scriptExecutionContext())
+        analyzer.setLabelForCell(cell, "url "_s + thisObject->scriptExecutionContext()->url().string());
+    Base::analyzeHeap(cell, analyzer);
+}
+
+bool JSMessagePortOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason)
+{
+    auto* jsMessagePort = jsCast<JSMessagePort*>(handle.slot()->asCell());
+    auto& wrapped = jsMessagePort->wrapped();
+    if (wrapped.hasPendingActivity()) {
+        if (UNLIKELY(reason))
+            *reason = "ActiveDOMObject with pending activity";
+        return true;
+    }
+    MessagePort* owner = &jsMessagePort->wrapped();
+    if (UNLIKELY(reason))
+        *reason = "Reachable from MessagePort";
+
+    return visitor.containsOpaqueRoot(owner);
+}
+
+void JSMessagePortOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+    auto* jsMessagePort = static_cast<JSMessagePort*>(handle.slot()->asCell());
+    auto& world = *static_cast<DOMWrapperWorld*>(context);
+    uncacheWrapper(world, &jsMessagePort->wrapped(), jsMessagePort);
+}
+
+#if ENABLE(BINDING_INTEGRITY)
+#if PLATFORM(WIN)
+#pragma warning(disable : 4483)
+extern "C" {
+extern void (*const __identifier("??_7MessagePort@WebCore@@6B@")[])();
+}
+#else
+extern "C" {
+extern void* _ZTVN7WebCore11MessagePortE[];
+}
+#endif
+#endif
+
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<MessagePort>&& impl)
+{
+
+    if constexpr (std::is_polymorphic_v<MessagePort>) {
+#if ENABLE(BINDING_INTEGRITY)
+        const void* actualVTablePointer = getVTablePointer(impl.ptr());
+#if PLATFORM(WIN)
+        void* expectedVTablePointer = __identifier("??_7MessagePort@WebCore@@6B@");
+#else
+        void* expectedVTablePointer = &_ZTVN7WebCore11MessagePortE[2];
+#endif
+
+        // If you hit this assertion you either have a use after free bug, or
+        // MessagePort has subclasses. If MessagePort has subclasses that get passed
+        // to toJS() we currently require MessagePort you to opt out of binding hardening
+        // by adding the SkipVTableValidation attribute to the interface IDL definition
+        RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
+#endif
+    }
+    return createWrapper<MessagePort>(globalObject, WTFMove(impl));
+}
+
+JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, MessagePort& impl)
+{
+    return wrap(lexicalGlobalObject, globalObject, impl);
+}
+
+MessagePort* JSMessagePort::toWrapped(JSC::VM&, JSC::JSValue value)
+{
+    if (auto* wrapper = jsDynamicCast<JSMessagePort*>(value))
+        return &wrapper->wrapped();
+    return nullptr;
+}
+
+}
diff --git a/src/bun.js/bindings/webcore/JSMessagePort.h b/src/bun.js/bindings/webcore/JSMessagePort.h
new file mode 100644
index 000000000..44c928050
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessagePort.h
@@ -0,0 +1,103 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "JSDOMWrapper.h"
+#include "JSEventTarget.h"
+#include "MessagePort.h"
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+class WEBCORE_EXPORT JSMessagePort : public JSEventTarget {
+public:
+    using Base = JSEventTarget;
+    using DOMWrapped = MessagePort;
+    static JSMessagePort* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, Ref<MessagePort>&& impl)
+    {
+        JSMessagePort* ptr = new (NotNull, JSC::allocateCell<JSMessagePort>(globalObject->vm())) JSMessagePort(structure, *globalObject, WTFMove(impl));
+        ptr->finishCreation(globalObject->vm());
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSDOMGlobalObject&);
+    static JSC::JSObject* prototype(JSC::VM&, JSDOMGlobalObject&);
+    static MessagePort* toWrapped(JSC::VM&, JSC::JSValue);
+
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info(), JSC::NonArray);
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);
+    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+    {
+        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+            return nullptr;
+        return subspaceForImpl(vm);
+    }
+    static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
+    DECLARE_VISIT_CHILDREN;
+    template<typename Visitor> void visitAdditionalChildren(Visitor&);
+
+    template<typename Visitor> static void visitOutputConstraints(JSCell*, Visitor&);
+    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+    MessagePort& wrapped() const
+    {
+        return static_cast<MessagePort&>(Base::wrapped());
+    }
+
+protected:
+    JSMessagePort(JSC::Structure*, JSDOMGlobalObject&, Ref<MessagePort>&&);
+
+    DECLARE_DEFAULT_FINISH_CREATION;
+};
+
+class WEBCORE_EXPORT JSMessagePortOwner final : public JSC::WeakHandleOwner {
+public:
+    bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor&, const char**) final;
+    void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, MessagePort*)
+{
+    static NeverDestroyed<JSMessagePortOwner> owner;
+    return &owner.get();
+}
+
+inline void* wrapperKey(MessagePort* wrappableObject)
+{
+    return wrappableObject;
+}
+
+WEBCORE_EXPORT JSC::JSValue toJS(JSC::JSGlobalObject*, JSDOMGlobalObject*, MessagePort&);
+inline JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, MessagePort* impl) { return impl ? toJS(lexicalGlobalObject, globalObject, *impl) : JSC::jsNull(); }
+JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject*, Ref<MessagePort>&&);
+inline JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, RefPtr<MessagePort>&& impl) { return impl ? toJSNewlyCreated(lexicalGlobalObject, globalObject, impl.releaseNonNull()) : JSC::jsNull(); }
+
+template<> struct JSDOMWrapperConverterTraits<MessagePort> {
+    using WrapperClass = JSMessagePort;
+    using ToWrappedReturnType = MessagePort*;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSMessagePortCustom.cpp b/src/bun.js/bindings/webcore/JSMessagePortCustom.cpp
new file mode 100644
index 000000000..56031dd60
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSMessagePortCustom.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2008-2021 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2011 Google Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "JSMessagePort.h"
+// #include "WebCoreOpaqueRootInlines.h"
+
+namespace WebCore {
+using namespace JSC;
+
+template<typename Visitor>
+void JSMessagePort::visitAdditionalChildren(Visitor& visitor)
+{
+    // If we have a locally entangled port, we can directly mark it as reachable. Ports that are remotely entangled are marked in-use by markActiveObjectsForContext().
+    if (auto* port = wrapped().locallyEntangledPort()) {
+        visitor.addOpaqueRoot(port);
+        // addWebCoreOpaqueRoot(visitor, *port);
+    }
+}
+
+DEFINE_VISIT_ADDITIONAL_CHILDREN(JSMessagePort);
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.cpp b/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.cpp
new file mode 100644
index 000000000..4311426e6
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.cpp
@@ -0,0 +1,58 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSStructuredSerializeOptions.h"
+
+#include "JSDOMConvertObject.h"
+#include "JSDOMConvertSequences.h"
+#include <JavaScriptCore/JSArray.h>
+#include <JavaScriptCore/JSCInlines.h>
+
+namespace WebCore {
+using namespace JSC;
+
+template<> StructuredSerializeOptions convertDictionary<StructuredSerializeOptions>(JSGlobalObject& lexicalGlobalObject, JSValue value)
+{
+    VM& vm = JSC::getVM(&lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    bool isNullOrUndefined = value.isUndefinedOrNull();
+    auto* object = isNullOrUndefined ? nullptr : value.getObject();
+    if (UNLIKELY(!isNullOrUndefined && !object)) {
+        throwTypeError(&lexicalGlobalObject, throwScope);
+        return {};
+    }
+    StructuredSerializeOptions result;
+    JSValue transferValue;
+    if (isNullOrUndefined)
+        transferValue = jsUndefined();
+    else {
+        transferValue = object->get(&lexicalGlobalObject, Identifier::fromString(vm, "transfer"_s));
+        RETURN_IF_EXCEPTION(throwScope, {});
+    }
+    if (!transferValue.isUndefined()) {
+        result.transfer = convert<IDLSequence<IDLObject>>(lexicalGlobalObject, transferValue);
+        RETURN_IF_EXCEPTION(throwScope, {});
+    } else
+        result.transfer = Converter<IDLSequence<IDLObject>>::ReturnType {};
+    return result;
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.h b/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.h
new file mode 100644
index 000000000..8fc8fddd0
--- /dev/null
+++ b/src/bun.js/bindings/webcore/JSStructuredSerializeOptions.h
@@ -0,0 +1,30 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#pragma once
+
+#include "JSDOMConvertDictionary.h"
+#include "StructuredSerializeOptions.h"
+
+namespace WebCore {
+
+template<> StructuredSerializeOptions convertDictionary<StructuredSerializeOptions>(JSC::JSGlobalObject&, JSC::JSValue);
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/JSValueInWrappedObject.h b/src/bun.js/bindings/webcore/JSValueInWrappedObject.h
index d05fdb8fd..d11796912 100644
--- a/src/bun.js/bindings/webcore/JSValueInWrappedObject.h
+++ b/src/bun.js/bindings/webcore/JSValueInWrappedObject.h
@@ -61,6 +61,7 @@ private:
     JSC::Weak<JSC::JSCell> m_cell {};
 };
 
+JSC::JSValue cachedPropertyValue(JSC::ThrowScope&, JSC::JSGlobalObject&, const JSDOMObject& owner, JSValueInWrappedObject& cacheSlot, const Function<JSC::JSValue(JSC::ThrowScope&)>&);
 JSC::JSValue cachedPropertyValue(JSC::JSGlobalObject&, const JSDOMObject& owner, JSValueInWrappedObject& cacheSlot, const Function<JSC::JSValue()>&);
 
 inline JSValueInWrappedObject::JSValueInWrappedObject(JSC::JSValue value)
@@ -132,4 +133,17 @@ inline JSC::JSValue cachedPropertyValue(JSC::JSGlobalObject& lexicalGlobalObject
     return cachedValue.getValue();
 }
 
+inline JSC::JSValue cachedPropertyValue(JSC::ThrowScope& throwScope, JSC::JSGlobalObject& lexicalGlobalObject, const JSDOMObject& owner, JSValueInWrappedObject& cachedValue, const Function<JSC::JSValue(JSC::ThrowScope&)>& function)
+{
+    if (cachedValue && isWorldCompatible(lexicalGlobalObject, cachedValue.getValue()))
+        return cachedValue.getValue();
+
+    auto value = function(throwScope);
+    RETURN_IF_EXCEPTION(throwScope, {});
+
+    cachedValue.set(lexicalGlobalObject.vm(), &owner, cloneAcrossWorlds(lexicalGlobalObject, owner, value));
+    ASSERT(isWorldCompatible(lexicalGlobalObject, cachedValue.getValue()));
+    return cachedValue.getValue();
+}
+
 } // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessageChannel.cpp b/src/bun.js/bindings/webcore/MessageChannel.cpp
new file mode 100644
index 000000000..67407b9c0
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessageChannel.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+#include "MessageChannel.h"
+
+#include "MessagePort.h"
+#include "MessagePortChannelProvider.h"
+#include "ScriptExecutionContext.h"
+
+namespace WebCore {
+
+static std::pair<Ref<MessagePort>, Ref<MessagePort>> generateMessagePorts(ScriptExecutionContext& context)
+{
+    MessagePortIdentifier id1 = { ProcessIdent::identifier(), PortIdentifier::generate() };
+    MessagePortIdentifier id2 = { ProcessIdent::identifier(), PortIdentifier::generate() };
+
+    return { MessagePort::create(context, id1, id2), MessagePort::create(context, id2, id1) };
+}
+
+Ref<MessageChannel> MessageChannel::create(ScriptExecutionContext& context)
+{
+    return adoptRef(*new MessageChannel(context));
+}
+
+MessageChannel::MessageChannel(ScriptExecutionContext& context)
+    : m_ports(generateMessagePorts(context))
+{
+    if (!context.activeDOMObjectsAreStopped()) {
+        ASSERT(!port1().isDetached());
+        ASSERT(!port2().isDetached());
+        MessagePortChannelProvider::fromContext(context).createNewMessagePortChannel(port1().identifier(), port2().identifier());
+    } else {
+        ASSERT(port1().isDetached());
+        ASSERT(port2().isDetached());
+    }
+}
+
+MessageChannel::~MessageChannel() = default;
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessageChannel.h b/src/bun.js/bindings/webcore/MessageChannel.h
new file mode 100644
index 000000000..1cc936094
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessageChannel.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include <wtf/RefCounted.h>
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+
+class MessagePort;
+class ScriptExecutionContext;
+
+class MessageChannel : public RefCounted<MessageChannel> {
+public:
+    static Ref<MessageChannel> create(ScriptExecutionContext&);
+    ~MessageChannel();
+
+    MessagePort& port1() const { return m_ports.first; }
+    MessagePort& port2() const { return m_ports.second; }
+
+private:
+    explicit MessageChannel(ScriptExecutionContext&);
+
+    std::pair<Ref<MessagePort>, Ref<MessagePort>> m_ports;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessageEvent.cpp b/src/bun.js/bindings/webcore/MessageEvent.cpp
index b210f4cec..b5a96a4a2 100644
--- a/src/bun.js/bindings/webcore/MessageEvent.cpp
+++ b/src/bun.js/bindings/webcore/MessageEvent.cpp
@@ -30,7 +30,10 @@
 
 // #include "Blob.h"
 #include "EventNames.h"
+#include "JSDOMConvert.h"
+#include "JSMessageEvent.h"
 #include <JavaScriptCore/JSCInlines.h>
+
 // #include <wtf/IsoMallocInlines.h>
 
 namespace WebCore {
@@ -47,29 +50,29 @@ inline MessageEvent::MessageEvent(const AtomString& type, Init&& initializer, Is
     , m_origin(initializer.origin)
     , m_lastEventId(initializer.lastEventId)
     , m_source(WTFMove(initializer.source))
-    // , m_ports(WTFMove(initializer.ports))
+    , m_ports(WTFMove(initializer.ports))
     , m_jsData(initializer.data)
 {
 }
 
-inline MessageEvent::MessageEvent(const AtomString& type, DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source /*, Vector<RefPtr<MessagePort>>&& ports*/)
+inline MessageEvent::MessageEvent(const AtomString& type, DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports)
     : Event(type, CanBubble::No, IsCancelable::No)
     , m_data(WTFMove(data))
     , m_origin(origin)
     , m_lastEventId(lastEventId)
     , m_source(WTFMove(source))
-// , m_ports(WTFMove(ports))
+    , m_ports(WTFMove(ports))
 {
 }
 
-Ref<MessageEvent> MessageEvent::create(const AtomString& type, DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source /*, Vector<RefPtr<MessagePort>>&& ports*/)
+Ref<MessageEvent> MessageEvent::create(const AtomString& type, DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports)
 {
-    return adoptRef(*new MessageEvent(type, WTFMove(data), origin, lastEventId, WTFMove(source) /*, /*WTFMove(ports)*/));
+    return adoptRef(*new MessageEvent(type, WTFMove(data), origin, lastEventId, WTFMove(source), WTFMove(ports)));
 }
 
-Ref<MessageEvent> MessageEvent::create(DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source /*, Vector<RefPtr<MessagePort>>&& ports*/)
+Ref<MessageEvent> MessageEvent::create(DataType&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports)
 {
-    return create(eventNames().messageEvent, WTFMove(data), origin, lastEventId, WTFMove(source) /*, /*WTFMove(ports)*/);
+    return create(eventNames().messageEvent, WTFMove(data), origin, lastEventId, WTFMove(source), WTFMove(ports));
 }
 
 Ref<MessageEvent> MessageEvent::createForBindings()
@@ -84,7 +87,32 @@ Ref<MessageEvent> MessageEvent::create(const AtomString& type, Init&& initialize
 
 MessageEvent::~MessageEvent() = default;
 
-void MessageEvent::initMessageEvent(const AtomString& type, bool canBubble, bool cancelable, JSValue data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source /*, Vector<RefPtr<MessagePort>>&& ports*/)
+auto MessageEvent::create(JSC::JSGlobalObject& globalObject, Ref<SerializedScriptValue>&& data, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports) -> MessageEventWithStrongData
+{
+    return create(globalObject, WTFMove(data), {}, {}, WTFMove(source), WTFMove(ports));
+}
+
+auto MessageEvent::create(JSC::JSGlobalObject& globalObject, Ref<SerializedScriptValue>&& data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports) -> MessageEventWithStrongData
+{
+    auto& vm = globalObject.vm();
+    // Locker<JSC::JSLock> locker(vm.apiLock());
+
+    bool didFail = false;
+
+    auto deserialized = data->deserialize(globalObject, &globalObject, ports, SerializationErrorMode::NonThrowing, &didFail);
+    JSC::Strong<JSC::Unknown> strongData(vm, deserialized);
+
+    auto& eventType = didFail ? eventNames().messageerrorEvent : eventNames().messageEvent;
+    auto event = adoptRef(*new MessageEvent(eventType, WTFMove(data), origin, lastEventId, WTFMove(source), WTFMove(ports)));
+    JSC::Strong<JSC::JSObject> strongWrapper(vm, JSC::jsCast<JSC::JSObject*>(toJS(&globalObject, JSC::jsCast<JSDOMGlobalObject*>(&globalObject), event.get())));
+    // Since we've already deserialized the SerializedScriptValue, cache the result so we don't have to deserialize
+    // again the next time JSMessageEvent::data() gets called by the main world.
+    event->cachedData().set(vm, strongWrapper.get(), deserialized);
+
+    return MessageEventWithStrongData { event, WTFMove(strongWrapper) };
+}
+
+void MessageEvent::initMessageEvent(const AtomString& type, bool canBubble, bool cancelable, JSValue data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& source, Vector<RefPtr<MessagePort>>&& ports)
 {
     if (isBeingDispatched())
         return;
@@ -102,7 +130,7 @@ void MessageEvent::initMessageEvent(const AtomString& type, bool canBubble, bool
     m_origin = origin;
     m_lastEventId = lastEventId;
     m_source = WTFMove(source);
-    // m_ports = WTFMove(ports);
+    m_ports = WTFMove(ports);
     m_cachedPorts.clear();
 }
 
@@ -116,7 +144,7 @@ size_t MessageEvent::memoryCost() const
     Locker { m_concurrentDataAccessLock };
     return WTF::switchOn(
         m_data, [](JSValueTag) -> size_t { return 0; },
-        // [](const Ref<SerializedScriptValue>& data) -> size_t { return data->memoryCost(); },
+        [](const Ref<SerializedScriptValue>& data) -> size_t { return data->memoryCost(); },
         [](const String& string) -> size_t { return string.sizeInBytes(); },
         // [](const Ref<Blob>& blob) -> size_t { return blob->size(); },
         [](const Ref<ArrayBuffer>& buffer) -> size_t { return buffer->byteLength(); });
diff --git a/src/bun.js/bindings/webcore/MessageEvent.h b/src/bun.js/bindings/webcore/MessageEvent.h
index 4089e2ca1..184aa63a1 100644
--- a/src/bun.js/bindings/webcore/MessageEvent.h
+++ b/src/bun.js/bindings/webcore/MessageEvent.h
@@ -29,17 +29,16 @@
 
 #include "Event.h"
 #include "JSValueInWrappedObject.h"
-// #include "MessagePort.h"
-// #include "SerializedScriptValue.h"
+#include "MessagePort.h"
+#include "SerializedScriptValue.h"
+#include "MessagePort.h"
+// #include "JSMessageEvent.h"
 // #include "ServiceWorker.h"
 // #include "WindowProxy.h"
 #include <variant>
 
 namespace WebCore {
 
-class MessagePort : public RefCounted<MessagePort> {
-};
-
 class MessageEventSource {
 };
 
@@ -50,9 +49,10 @@ public:
     struct JSValueTag {
     };
     // using DataType = std::variant<JSValueTag, Ref<SerializedScriptValue>, String, Ref<Blob>, Ref<ArrayBuffer>>;
-    using DataType = std::variant<JSValueTag, String, Ref<ArrayBuffer>>;
-    static Ref<MessageEvent> create(const AtomString& type, DataType&&, const String& origin = {}, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt /*, Vector<RefPtr<MessagePort>>&& = {}*/);
-    static Ref<MessageEvent> create(DataType&&, const String& origin = {}, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt /*, Vector<RefPtr<MessagePort>>&& = {}*/);
+    using DataType = std::variant<JSValueTag, Ref<SerializedScriptValue>, String, Ref<ArrayBuffer>>;
+    static Ref<MessageEvent> create(const AtomString& type, DataType&&, const String& origin = {}, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt, Vector<RefPtr<MessagePort>>&& = {});
+    static Ref<MessageEvent> create(DataType&&, const String& origin = {}, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt, Vector<RefPtr<MessagePort>>&& = {});
+
     static Ref<MessageEvent> createForBindings();
 
     struct Init : EventInit {
@@ -60,18 +60,27 @@ public:
         String origin;
         String lastEventId;
         std::optional<MessageEventSource> source;
-        // Vector<RefPtr<MessagePort>> ports;
+        Vector<RefPtr<MessagePort>> ports;
     };
     static Ref<MessageEvent> create(const AtomString& type, Init&&, IsTrusted = IsTrusted::No);
 
+    struct MessageEventWithStrongData {
+        Ref<MessageEvent> event;
+        JSC::Strong<JSC::JSObject> strongWrapper; // Keep the wrapper alive until the event is fired, since it is what keeps `data` alive.
+    };
+
+    static MessageEventWithStrongData create(JSC::JSGlobalObject&, Ref<SerializedScriptValue>&&, const String& origin = {}, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt, Vector<RefPtr<MessagePort>>&& = {});
+
+    static MessageEventWithStrongData create(JSC::JSGlobalObject&, Ref<SerializedScriptValue>&&, std::optional<MessageEventSource>&& = std::nullopt, Vector<RefPtr<MessagePort>>&& = {});
+
     virtual ~MessageEvent();
 
-    void initMessageEvent(const AtomString& type, bool canBubble, bool cancelable, JSC::JSValue data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&& /*, Vector<RefPtr<MessagePort>>&&*/);
+    void initMessageEvent(const AtomString& type, bool canBubble, bool cancelable, JSC::JSValue data, const String& origin, const String& lastEventId, std::optional<MessageEventSource>&&, Vector<RefPtr<MessagePort>>&&);
 
     const String& origin() const { return m_origin; }
     const String& lastEventId() const { return m_lastEventId; }
     const std::optional<MessageEventSource>& source() const { return m_source; }
-    // const Vector<RefPtr<MessagePort>>& ports() const { return m_ports; }
+    const Vector<RefPtr<MessagePort>>& ports() const { return m_ports; }
 
     const DataType& data() const { return m_data; }
 
@@ -84,7 +93,7 @@ public:
 private:
     MessageEvent();
     MessageEvent(const AtomString& type, Init&&, IsTrusted);
-    MessageEvent(const AtomString& type, DataType&&, const String& origin, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt /*, Vector<RefPtr<MessagePort>>&& = {}*/);
+    MessageEvent(const AtomString& type, DataType&&, const String& origin, const String& lastEventId = {}, std::optional<MessageEventSource>&& = std::nullopt, Vector<RefPtr<MessagePort>>&& = {});
 
     EventInterface eventInterface() const final;
 
@@ -92,7 +101,7 @@ private:
     String m_origin;
     String m_lastEventId;
     std::optional<MessageEventSource> m_source;
-    // Vector<RefPtr<MessagePort>> m_ports;
+    Vector<RefPtr<MessagePort>> m_ports;
 
     JSValueInWrappedObject m_jsData;
     JSValueInWrappedObject m_cachedData;
diff --git a/src/bun.js/bindings/webcore/MessagePort.cpp b/src/bun.js/bindings/webcore/MessagePort.cpp
new file mode 100644
index 000000000..956143c80
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePort.cpp
@@ -0,0 +1,419 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+#include "MessagePort.h"
+
+// #include "Document.h"
+#include "EventNames.h"
+// #include "Logging.h"
+#include "MessageEvent.h"
+#include "BunWorkerGlobalScope.h"
+#include "MessagePortChannelProvider.h"
+#include "MessageWithMessagePorts.h"
+#include "StructuredSerializeOptions.h"
+#include "WebCoreOpaqueRoot.h"
+// #include "WorkerGlobalScope.h"
+// #include "WorkerThread.h"
+#include "TaskSource.h"
+#include <wtf/CompletionHandler.h>
+#include <wtf/IsoMallocInlines.h>
+#include <wtf/Lock.h>
+#include <wtf/Scope.h>
+
+namespace WebCore {
+
+WTF_MAKE_ISO_ALLOCATED_IMPL(MessagePort);
+
+static Lock allMessagePortsLock;
+static HashMap<MessagePortIdentifier, MessagePort*>& allMessagePorts() WTF_REQUIRES_LOCK(allMessagePortsLock)
+{
+    static NeverDestroyed<HashMap<MessagePortIdentifier, MessagePort*>> map;
+    return map;
+}
+
+static HashMap<MessagePortIdentifier, ScriptExecutionContextIdentifier>& portToContextIdentifier() WTF_REQUIRES_LOCK(allMessagePortsLock)
+{
+    static NeverDestroyed<HashMap<MessagePortIdentifier, ScriptExecutionContextIdentifier>> map;
+    return map;
+}
+
+void MessagePort::ref() const
+{
+    ++m_refCount;
+}
+
+void MessagePort::deref() const
+{
+    // This custom deref() function ensures that as long as the lock to allMessagePortsLock is taken, no MessagePort will be destroyed.
+    // This allows notifyMessageAvailable to easily query the map and manipulate MessagePort instances.
+
+    if (!--m_refCount) {
+        Locker locker { allMessagePortsLock };
+
+        if (m_refCount)
+            return;
+
+        auto iterator = allMessagePorts().find(m_identifier);
+        if (iterator != allMessagePorts().end() && iterator->value == this) {
+            allMessagePorts().remove(iterator);
+            portToContextIdentifier().remove(m_identifier);
+        }
+
+        delete this;
+    }
+}
+
+bool MessagePort::hasPendingActivity() const
+{
+    return m_refCount > 0;
+}
+
+bool MessagePort::isMessagePortAliveForTesting(const MessagePortIdentifier& identifier)
+{
+    Locker locker { allMessagePortsLock };
+    return allMessagePorts().contains(identifier);
+}
+
+ScriptExecutionContextIdentifier MessagePort::contextIdForMessagePortId(MessagePortIdentifier messagePortId)
+{
+    Locker locker { allMessagePortsLock };
+    return portToContextIdentifier().get(messagePortId);
+}
+
+void MessagePort::notifyMessageAvailable(const MessagePortIdentifier& identifier)
+{
+    ASSERT(isMainThread());
+    ScriptExecutionContextIdentifier scriptExecutionContextIdentifier;
+    {
+        Locker locker { allMessagePortsLock };
+        scriptExecutionContextIdentifier = portToContextIdentifier().get(identifier);
+    }
+    if (!scriptExecutionContextIdentifier)
+        return;
+
+    ScriptExecutionContext::ensureOnContextThread(scriptExecutionContextIdentifier, [identifier](auto&) {
+        RefPtr<MessagePort> port;
+        {
+            Locker locker { allMessagePortsLock };
+            port = allMessagePorts().get(identifier);
+        }
+        if (port)
+            port->messageAvailable();
+    });
+}
+
+Ref<MessagePort> MessagePort::create(ScriptExecutionContext& scriptExecutionContext, const MessagePortIdentifier& local, const MessagePortIdentifier& remote)
+{
+    auto messagePort = adoptRef(*new MessagePort(scriptExecutionContext, local, remote));
+    // messagePort->suspendIfNeeded();
+    return messagePort;
+}
+
+MessagePort::MessagePort(ScriptExecutionContext& scriptExecutionContext, const MessagePortIdentifier& local, const MessagePortIdentifier& remote)
+    // : ActiveDOMObject(&scriptExecutionContext)
+    : ContextDestructionObserver(&scriptExecutionContext)
+    , m_identifier(local)
+    , m_remoteIdentifier(remote)
+{
+    LOG(MessagePorts, "Created MessagePort %s (%p) in process %" PRIu64, m_identifier.logString().utf8().data(), this, ProcessIdent::identifier().toUInt64());
+
+    Locker locker { allMessagePortsLock };
+    allMessagePorts().set(m_identifier, this);
+    portToContextIdentifier().set(m_identifier, scriptExecutionContext.identifier());
+
+    // Make sure the WeakPtrFactory gets initialized eagerly on the thread the MessagePort gets constructed on for thread-safety reasons.
+    initializeWeakPtrFactory();
+
+    scriptExecutionContext.createdMessagePort(*this);
+
+    // Don't need to call processMessageWithMessagePortsSoon() here, because the port will not be opened until start() is invoked.
+}
+
+MessagePort::~MessagePort()
+{
+    LOG(MessagePorts, "Destroyed MessagePort %s (%p) in process %" PRIu64, m_identifier.logString().utf8().data(), this, ProcessIdent::identifier().toUInt64());
+
+    ASSERT(allMessagePortsLock.isLocked());
+
+    if (m_entangled)
+        close();
+
+    if (auto contextId = portToContextIdentifier().get(m_identifier))
+        ScriptExecutionContext::getScriptExecutionContext(contextId)->destroyedMessagePort(*this);
+}
+
+void MessagePort::entangle()
+{
+    ScriptExecutionContext::ensureOnMainThread([identifier = m_identifier, remoteIdentifier = m_remoteIdentifier](ScriptExecutionContext& context) {
+        MessagePortChannelProvider::fromContext(context).entangleLocalPortInThisProcessToRemote(identifier, remoteIdentifier);
+    });
+}
+
+ExceptionOr<void> MessagePort::postMessage(JSC::JSGlobalObject& state, JSC::JSValue messageValue, StructuredSerializeOptions&& options)
+{
+    LOG(MessagePorts, "Attempting to post message to port %s (to be received by port %s)", m_identifier.logString().utf8().data(), m_remoteIdentifier.logString().utf8().data());
+
+    Vector<RefPtr<MessagePort>> ports;
+    auto messageData = SerializedScriptValue::create(state, messageValue, WTFMove(options.transfer), ports, SerializationForStorage::No, SerializationContext::WorkerPostMessage);
+    if (messageData.hasException())
+        return messageData.releaseException();
+
+    if (!isEntangled())
+        return {};
+    ASSERT(scriptExecutionContext());
+
+    Vector<TransferredMessagePort> transferredPorts;
+    // Make sure we aren't connected to any of the passed-in ports.
+    if (!ports.isEmpty()) {
+        for (auto& port : ports) {
+            if (port->identifier() == m_identifier || port->identifier() == m_remoteIdentifier)
+                return Exception { DataCloneError };
+        }
+
+        auto disentangleResult = MessagePort::disentanglePorts(WTFMove(ports));
+        if (disentangleResult.hasException())
+            return disentangleResult.releaseException();
+        transferredPorts = disentangleResult.releaseReturnValue();
+    }
+
+    MessageWithMessagePorts message { messageData.releaseReturnValue(), WTFMove(transferredPorts) };
+
+    LOG(MessagePorts, "Actually posting message to port %s (to be received by port %s)", m_identifier.logString().utf8().data(), m_remoteIdentifier.logString().utf8().data());
+
+    ScriptExecutionContextIdentifier contextId = contextIdForMessagePortId(m_remoteIdentifier);
+
+    MessagePortChannelProvider::fromContext(*ScriptExecutionContext::getScriptExecutionContext(contextId)).postMessageToRemote(WTFMove(message), m_remoteIdentifier);
+
+    return {};
+}
+
+TransferredMessagePort MessagePort::disentangle()
+{
+    ASSERT(m_entangled);
+    m_entangled = false;
+
+    auto& context = *scriptExecutionContext();
+    MessagePortChannelProvider::fromContext(context).messagePortDisentangled(m_identifier);
+
+    // We can't receive any messages or generate any events after this, so remove ourselves from the list of active ports.
+    context.destroyedMessagePort(*this);
+    // context.willDestroyActiveDOMObject(*this);
+    context.willDestroyDestructionObserver(*this);
+
+    observeContext(nullptr);
+
+    return { identifier(), remoteIdentifier() };
+}
+
+// Invoked to notify us that there are messages available for this port.
+// This code may be called from another thread, and so should not call any non-threadsafe APIs (i.e. should not call into the entangled channel or access mutable variables).
+void MessagePort::messageAvailable()
+{
+    // This MessagePort object might be disentangled because the port is being transferred,
+    // in which case we'll notify it that messages are available once a new end point is created.
+    auto* context = scriptExecutionContext();
+    if (!context || context->activeDOMObjectsAreSuspended())
+        return;
+
+    context->processMessageWithMessagePortsSoon([pendingActivity = Ref { *this }] {});
+}
+
+void MessagePort::start()
+{
+    // Do nothing if we've been cloned or closed.
+    if (!isEntangled())
+        return;
+
+    ASSERT(scriptExecutionContext());
+    if (m_started)
+        return;
+
+    m_started = true;
+    scriptExecutionContext()->processMessageWithMessagePortsSoon([pendingActivity = Ref { *this }] {});
+}
+
+void MessagePort::close()
+{
+    if (m_isDetached)
+        return;
+    m_isDetached = true;
+
+    ScriptExecutionContext::ensureOnMainThread([identifier = m_identifier, protectedThis = Ref { *this }](ScriptExecutionContext& context) {
+        MessagePortChannelProvider::singleton().messagePortClosed(identifier);
+    });
+
+    removeAllEventListeners();
+}
+
+void MessagePort::dispatchMessages()
+{
+    // Messages for contexts that are not fully active get dispatched too, but JSAbstractEventListener::handleEvent() doesn't call handlers for these.
+    // The HTML5 spec specifies that any messages sent to a document that is not fully active should be dropped, so this behavior is OK.
+    ASSERT(started());
+
+    auto* context = scriptExecutionContext();
+    if (!context || context->activeDOMObjectsAreSuspended() || !isEntangled())
+        return;
+
+    auto messagesTakenHandler = [this, protectedThis = Ref { *this }](Vector<MessageWithMessagePorts>&& messages, CompletionHandler<void()>&& completionCallback) mutable {
+        auto scopeExit = makeScopeExit(WTFMove(completionCallback));
+
+        LOG(MessagePorts, "MessagePort %s (%p) dispatching %zu messages", m_identifier.logString().utf8().data(), this, messages.size());
+
+        auto* context = scriptExecutionContext();
+        if (!context || !context->jsGlobalObject())
+            return;
+
+        ASSERT(context->isContextThread());
+
+        // bool contextIsWorker = is<WorkerGlobalScope>(*context);
+        for (auto& message : messages) {
+            // close() in Worker onmessage handler should prevent next message from dispatching.
+            // if (contextIsWorker && downcast<WorkerGlobalScope>(*context).isClosing())
+            //     return;
+
+            auto ports = MessagePort::entanglePorts(*context, WTFMove(message.transferredPorts));
+
+            // Per specification, each MessagePort object has a task source called the port message queue.
+            // queueTaskKeepingObjectAlive(context, *this, TaskSource::PostedMessageQueue, [this, event = WTFMove(event)] {
+            //     dispatchEvent(event.event);
+            // });
+
+            ScriptExecutionContext::postTaskTo(contextIdForMessagePortId(m_identifier), [protectedThis = Ref { *this }, ports = WTFMove(ports), message = WTFMove(message)](ScriptExecutionContext& context) mutable {
+                auto event = MessageEvent::create(*context.jsGlobalObject(), message.message.releaseNonNull(), {}, {}, {}, WTFMove(ports));
+                protectedThis->dispatchEvent(event.event);
+            });
+        }
+    };
+
+    MessagePortChannelProvider::fromContext(*context).takeAllMessagesForPort(m_identifier, WTFMove(messagesTakenHandler));
+}
+
+void MessagePort::dispatchEvent(Event& event)
+{
+    if (m_isDetached) {
+        return;
+    }
+
+    // auto* context = scriptExecutionContext();
+    // if (is<WebCore::GlobalScope>(*context) && downcast<WebCore::GlobalScope>(*context).isClosing())
+    //     return;
+
+    EventTarget::dispatchEvent(event);
+}
+
+// https://html.spec.whatwg.org/multipage/web-messaging.html#ports-and-garbage-collection
+// bool MessagePort::virtualHasPendingActivity() const
+// {
+//     // If the ScriptExecutionContext has been shut down on this object close()'ed, we can GC.
+//     auto* context = scriptExecutionContext();
+//     if (!context || m_isDetached)
+//         return false;
+
+//     // If this MessagePort has no message event handler then there is no point in keeping it alive.
+//     if (!m_hasMessageEventListener)
+//         return false;
+
+//     return m_entangled;
+// }
+
+MessagePort* MessagePort::locallyEntangledPort()
+{
+    // FIXME: As the header describes, this is an optional optimization.
+    // Even in the new async model we should be able to get it right.
+    return nullptr;
+}
+
+ExceptionOr<Vector<TransferredMessagePort>> MessagePort::disentanglePorts(Vector<RefPtr<MessagePort>>&& ports)
+{
+    if (ports.isEmpty())
+        return Vector<TransferredMessagePort> {};
+
+    // Walk the incoming array - if there are any duplicate ports, or null ports or cloned ports, throw an error (per section 8.3.3 of the HTML5 spec).
+    HashSet<MessagePort*> portSet;
+    for (auto& port : ports) {
+        if (!port || !port->m_entangled || !portSet.add(port.get()).isNewEntry)
+            return Exception { DataCloneError };
+    }
+
+    // Passed-in ports passed validity checks, so we can disentangle them.
+    return WTF::map(ports, [](auto& port) {
+        return port->disentangle();
+    });
+}
+
+Vector<RefPtr<MessagePort>> MessagePort::entanglePorts(ScriptExecutionContext& context, Vector<TransferredMessagePort>&& transferredPorts)
+{
+    LOG(MessagePorts, "Entangling %zu transferred ports to ScriptExecutionContext %s (%p)", transferredPorts.size(), context.url().string().utf8().data(), &context);
+
+    if (transferredPorts.isEmpty())
+        return {};
+
+    return WTF::map(transferredPorts, [&](auto& port) -> RefPtr<MessagePort> {
+        return MessagePort::entangle(context, WTFMove(port));
+    });
+}
+
+Ref<MessagePort> MessagePort::entangle(ScriptExecutionContext& context, TransferredMessagePort&& transferredPort)
+{
+    auto port = MessagePort::create(context, transferredPort.first, transferredPort.second);
+    port->entangle();
+    return port;
+}
+
+bool MessagePort::addEventListener(const AtomString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
+{
+    if (eventType == eventNames().messageEvent) {
+        if (listener->isAttribute())
+            start();
+        m_hasMessageEventListener = true;
+    }
+
+    return EventTarget::addEventListener(eventType, WTFMove(listener), options);
+}
+
+bool MessagePort::removeEventListener(const AtomString& eventType, EventListener& listener, const EventListenerOptions& options)
+{
+    auto result = EventTarget::removeEventListener(eventType, listener, options);
+
+    if (!hasEventListeners(eventNames().messageEvent))
+        m_hasMessageEventListener = false;
+
+    return result;
+}
+
+// const char* MessagePort::activeDOMObjectName() const
+// {
+//     return "MessagePort";
+// }
+
+WebCoreOpaqueRoot root(MessagePort* port)
+{
+    return WebCoreOpaqueRoot { port };
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePort.h b/src/bun.js/bindings/webcore/MessagePort.h
new file mode 100644
index 000000000..18f0ba212
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePort.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+#include "ActiveDOMObject.h"
+#include "EventTarget.h"
+#include "ExceptionOr.h"
+#include "MessagePortChannel.h"
+#include "MessagePortIdentifier.h"
+#include "MessageWithMessagePorts.h"
+#include <wtf/WeakPtr.h>
+
+namespace JSC {
+class CallFrame;
+class JSObject;
+class JSValue;
+}
+
+namespace WebCore {
+
+class LocalFrame;
+class WebCoreOpaqueRoot;
+
+struct StructuredSerializeOptions;
+
+class MessagePort final : /* public ActiveDOMObject, */ public ContextDestructionObserver, public EventTarget {
+    WTF_MAKE_NONCOPYABLE(MessagePort);
+    WTF_MAKE_ISO_ALLOCATED(MessagePort);
+
+public:
+    static Ref<MessagePort> create(ScriptExecutionContext&, const MessagePortIdentifier& local, const MessagePortIdentifier& remote);
+    virtual ~MessagePort();
+
+    ExceptionOr<void> postMessage(JSC::JSGlobalObject&, JSC::JSValue message, StructuredSerializeOptions&&);
+
+    void start();
+    void close();
+    void entangle();
+
+    // Returns nullptr if the passed-in vector is empty.
+    static ExceptionOr<Vector<TransferredMessagePort>> disentanglePorts(Vector<RefPtr<MessagePort>>&&);
+    static Vector<RefPtr<MessagePort>> entanglePorts(ScriptExecutionContext&, Vector<TransferredMessagePort>&&);
+
+    WEBCORE_EXPORT static bool isMessagePortAliveForTesting(const MessagePortIdentifier&);
+    WEBCORE_EXPORT static void notifyMessageAvailable(const MessagePortIdentifier&);
+
+    WEBCORE_EXPORT void messageAvailable();
+    bool started() const { return m_started; }
+    bool isDetached() const { return m_isDetached; }
+
+    void dispatchMessages();
+
+    // Returns null if there is no entangled port, or if the entangled port is run by a different thread.
+    // This is used solely to enable a GC optimization. Some platforms may not be able to determine ownership
+    // of the remote port (since it may live cross-process) - those platforms may always return null.
+    MessagePort* locallyEntangledPort();
+
+    const MessagePortIdentifier& identifier() const { return m_identifier; }
+    const MessagePortIdentifier& remoteIdentifier() const { return m_remoteIdentifier; }
+
+    WEBCORE_EXPORT void ref() const;
+    WEBCORE_EXPORT void deref() const;
+
+    // EventTarget.
+    EventTargetInterface eventTargetInterface() const final
+    {
+        return MessagePortEventTargetInterfaceType;
+    }
+    ScriptExecutionContext* scriptExecutionContext() const final { return ScriptExecutionContext::getScriptExecutionContext(contextIdForMessagePortId(m_identifier)); }
+    void refEventTarget() final { ref(); }
+    void derefEventTarget() final { deref(); }
+
+    void dispatchEvent(Event&) final;
+
+    TransferredMessagePort disentangle();
+    static Ref<MessagePort> entangle(ScriptExecutionContext&, TransferredMessagePort&&);
+
+    bool hasPendingActivity() const;
+
+    static ScriptExecutionContextIdentifier contextIdForMessagePortId(MessagePortIdentifier);
+
+private:
+    explicit MessagePort(ScriptExecutionContext&, const MessagePortIdentifier& local, const MessagePortIdentifier& remote);
+
+    bool addEventListener(const AtomString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) final;
+    bool removeEventListener(const AtomString& eventType, EventListener&, const EventListenerOptions&) final;
+
+    // ActiveDOMObject
+    // const char* activeDOMObjectName() const final;
+    // void contextDestroyed() final;
+    // void stop() final { close(); }
+    // bool virtualHasPendingActivity() const final;
+
+    EventTargetData* eventTargetData() final { return &m_eventTargetData; }
+    EventTargetData* eventTargetDataConcurrently() final { return &m_eventTargetData; }
+    EventTargetData& ensureEventTargetData() final { return m_eventTargetData; }
+
+    EventTargetData m_eventTargetData;
+
+    // A port starts out its life entangled, and remains entangled until it is detached or is cloned.
+    bool isEntangled() const { return !m_isDetached && m_entangled; }
+
+    bool m_started { false };
+    bool m_isDetached { false };
+    bool m_entangled { true };
+    bool m_hasMessageEventListener { false };
+
+    MessagePortIdentifier m_identifier;
+    MessagePortIdentifier m_remoteIdentifier;
+
+    mutable std::atomic<unsigned> m_refCount { 1 };
+};
+
+WebCoreOpaqueRoot root(MessagePort*);
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannel.cpp b/src/bun.js/bindings/webcore/MessagePortChannel.cpp
new file mode 100644
index 000000000..4e0f44524
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannel.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MessagePortChannel.h"
+
+// #include "Logging.h"
+#include "MessagePortChannelRegistry.h"
+#include <wtf/CompletionHandler.h>
+#include <wtf/MainThread.h>
+
+namespace WebCore {
+
+Ref<MessagePortChannel> MessagePortChannel::create(MessagePortChannelRegistry& registry, const MessagePortIdentifier& port1, const MessagePortIdentifier& port2)
+{
+    return adoptRef(*new MessagePortChannel(registry, port1, port2));
+}
+
+MessagePortChannel::MessagePortChannel(MessagePortChannelRegistry& registry, const MessagePortIdentifier& port1, const MessagePortIdentifier& port2)
+    : m_registry(registry)
+{
+    ASSERT(isMainThread());
+
+    relaxAdoptionRequirement();
+
+    m_ports[0] = port1;
+    m_processes[0] = port1.processIdentifier;
+    m_entangledToProcessProtectors[0] = this;
+    m_ports[1] = port2;
+    m_processes[1] = port2.processIdentifier;
+    m_entangledToProcessProtectors[1] = this;
+
+    m_registry.messagePortChannelCreated(*this);
+}
+
+MessagePortChannel::~MessagePortChannel()
+{
+    m_registry.messagePortChannelDestroyed(*this);
+}
+
+std::optional<ProcessIdentifier> MessagePortChannel::processForPort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+    ASSERT(port == m_ports[0] || port == m_ports[1]);
+    size_t i = port == m_ports[0] ? 0 : 1;
+    return m_processes[i];
+}
+
+bool MessagePortChannel::includesPort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    return m_ports[0] == port || m_ports[1] == port;
+}
+
+void MessagePortChannel::entanglePortWithProcess(const MessagePortIdentifier& port, ProcessIdentifier process)
+{
+    ASSERT(isMainThread());
+
+    ASSERT(port == m_ports[0] || port == m_ports[1]);
+    size_t i = port == m_ports[0] ? 0 : 1;
+
+    LOG(MessagePorts, "MessagePortChannel %s (%p) entangling port %s (that port has %zu messages available)", logString().utf8().data(), this, port.logString().utf8().data(), m_pendingMessages[i].size());
+
+    ASSERT(!m_processes[i] || *m_processes[i] == process);
+    m_processes[i] = process;
+    m_entangledToProcessProtectors[i] = this;
+    m_pendingMessagePortTransfers[i].remove(this);
+}
+
+void MessagePortChannel::disentanglePort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    LOG(MessagePorts, "MessagePortChannel %s (%p) disentangling port %s", logString().utf8().data(), this, port.logString().utf8().data());
+
+    ASSERT(port == m_ports[0] || port == m_ports[1]);
+    size_t i = port == m_ports[0] ? 0 : 1;
+
+    ASSERT(m_processes[i] || m_isClosed[i]);
+    m_processes[i] = std::nullopt;
+    m_pendingMessagePortTransfers[i].add(this);
+
+    // This set of steps is to guarantee that the lock is unlocked before the
+    // last ref to this object is released.
+    auto protectedThis = WTFMove(m_entangledToProcessProtectors[i]);
+}
+
+void MessagePortChannel::closePort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    ASSERT(port == m_ports[0] || port == m_ports[1]);
+    size_t i = port == m_ports[0] ? 0 : 1;
+
+    m_processes[i] = std::nullopt;
+    m_isClosed[i] = true;
+
+    // This set of steps is to guarantee that the lock is unlocked before the
+    // last ref to this object is released.
+    Ref protectedThis { *this };
+
+    m_pendingMessages[i].clear();
+    m_pendingMessagePortTransfers[i].clear();
+    m_pendingMessageProtectors[i] = nullptr;
+    m_entangledToProcessProtectors[i] = nullptr;
+}
+
+bool MessagePortChannel::postMessageToRemote(MessageWithMessagePorts&& message, const MessagePortIdentifier& remoteTarget)
+{
+    ASSERT(isMainThread());
+
+    ASSERT(remoteTarget == m_ports[0] || remoteTarget == m_ports[1]);
+    size_t i = remoteTarget == m_ports[0] ? 0 : 1;
+
+    m_pendingMessages[i].append(WTFMove(message));
+    LOG(MessagePorts, "MessagePortChannel %s (%p) now has %zu messages pending on port %s", logString().utf8().data(), this, m_pendingMessages[i].size(), remoteTarget.logString().utf8().data());
+
+    if (m_pendingMessages[i].size() == 1) {
+        m_pendingMessageProtectors[i] = this;
+        return true;
+    }
+
+    ASSERT(m_pendingMessageProtectors[i] == this);
+    return false;
+}
+
+void MessagePortChannel::takeAllMessagesForPort(const MessagePortIdentifier& port, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&& callback)
+{
+    ASSERT(isMainThread());
+
+    LOG(MessagePorts, "MessagePortChannel %p taking all messages for port %s", this, port.logString().utf8().data());
+
+    ASSERT(port == m_ports[0] || port == m_ports[1]);
+    size_t i = port == m_ports[0] ? 0 : 1;
+
+    if (m_pendingMessages[i].isEmpty()) {
+        callback({}, [] {});
+        return;
+    }
+
+    ASSERT(m_pendingMessageProtectors[i]);
+
+    Vector<MessageWithMessagePorts> result;
+    result.swap(m_pendingMessages[i]);
+
+    ++m_messageBatchesInFlight;
+
+    LOG(MessagePorts, "There are %zu messages to take for port %s. Taking them now, messages in flight is now %" PRIu64, result.size(), port.logString().utf8().data(), m_messageBatchesInFlight);
+
+    auto size = result.size();
+    callback(WTFMove(result), [size, this, port, protectedThis = WTFMove(m_pendingMessageProtectors[i])] {
+        UNUSED_PARAM(port);
+#if LOG_DISABLED
+        UNUSED_PARAM(size);
+#endif
+        --m_messageBatchesInFlight;
+        LOG(MessagePorts, "Message port channel %s was notified that a batch of %zu message port messages targeted for port %s just completed dispatch, in flight is now %" PRIu64, logString().utf8().data(), size, port.logString().utf8().data(), m_messageBatchesInFlight);
+    });
+}
+
+bool MessagePortChannel::hasAnyMessagesPendingOrInFlight() const
+{
+    ASSERT(isMainThread());
+    return m_messageBatchesInFlight || !m_pendingMessages[0].isEmpty() || !m_pendingMessages[1].isEmpty();
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannel.h b/src/bun.js/bindings/webcore/MessagePortChannel.h
new file mode 100644
index 000000000..787cc8f7a
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannel.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "MessagePortChannelProvider.h"
+#include "MessagePortIdentifier.h"
+#include "MessageWithMessagePorts.h"
+#include "ProcessIdentifier.h"
+#include <wtf/HashSet.h>
+#include <wtf/RefCounted.h>
+#include <wtf/text/WTFString.h>
+
+namespace WebCore {
+
+class MessagePortChannelRegistry;
+
+class MessagePortChannel : public RefCounted<MessagePortChannel> {
+public:
+    static Ref<MessagePortChannel> create(MessagePortChannelRegistry&, const MessagePortIdentifier& port1, const MessagePortIdentifier& port2);
+
+    ~MessagePortChannel();
+
+    const MessagePortIdentifier& port1() const { return m_ports[0]; }
+    const MessagePortIdentifier& port2() const { return m_ports[1]; }
+
+    WEBCORE_EXPORT std::optional<ProcessIdentifier> processForPort(const MessagePortIdentifier&);
+    bool includesPort(const MessagePortIdentifier&);
+    void entanglePortWithProcess(const MessagePortIdentifier&, ProcessIdentifier);
+    void disentanglePort(const MessagePortIdentifier&);
+    void closePort(const MessagePortIdentifier&);
+    bool postMessageToRemote(MessageWithMessagePorts&&, const MessagePortIdentifier& remoteTarget);
+
+    void takeAllMessagesForPort(const MessagePortIdentifier&, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&&);
+
+    WEBCORE_EXPORT bool hasAnyMessagesPendingOrInFlight() const;
+
+    uint64_t beingTransferredCount();
+
+#if !LOG_DISABLED
+    String logString() const
+    {
+        return makeString(m_ports[0].logString(), ":", m_ports[1].logString());
+    }
+#endif
+
+private:
+    MessagePortChannel(MessagePortChannelRegistry&, const MessagePortIdentifier& port1, const MessagePortIdentifier& port2);
+
+    MessagePortIdentifier m_ports[2];
+    bool m_isClosed[2] { false, false };
+    std::optional<ProcessIdentifier> m_processes[2];
+    RefPtr<MessagePortChannel> m_entangledToProcessProtectors[2];
+    Vector<MessageWithMessagePorts> m_pendingMessages[2];
+    HashSet<RefPtr<MessagePortChannel>> m_pendingMessagePortTransfers[2];
+    RefPtr<MessagePortChannel> m_pendingMessageProtectors[2];
+    uint64_t m_messageBatchesInFlight { 0 };
+
+    MessagePortChannelRegistry& m_registry;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelProvider.cpp b/src/bun.js/bindings/webcore/MessagePortChannelProvider.cpp
new file mode 100644
index 000000000..7675a2e75
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelProvider.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+// #include "MessagePortChannelProvider.h"
+
+// #include "Document.h"
+#include "MessagePortChannelProviderImpl.h"
+// #include "WorkerGlobalScope.h"
+// #include "WorkletGlobalScope.h"
+#include <wtf/MainThread.h>
+
+namespace WebCore {
+
+static MessagePortChannelProviderImpl* globalProvider;
+
+MessagePortChannelProvider& MessagePortChannelProvider::singleton()
+{
+    ASSERT(isMainThread());
+    static std::once_flag onceFlag;
+    std::call_once(onceFlag, [] {
+        if (!globalProvider)
+            globalProvider = new MessagePortChannelProviderImpl;
+    });
+
+    return *globalProvider;
+}
+
+// void MessagePortChannelProvider::setSharedProvider(MessagePortChannelProvider& provider)
+// {
+//     RELEASE_ASSERT(isMainThread());
+//     RELEASE_ASSERT(!globalProvider);
+//     globalProvider = &provider;
+// }
+
+MessagePortChannelProvider& MessagePortChannelProvider::fromContext(ScriptExecutionContext& context)
+{
+    // if (auto document = dynamicDowncast<Document>(context))
+    //     return document->messagePortChannelProvider();
+
+    // if (auto workletScope = dynamicDowncast<WorkletGlobalScope>(context))
+    //     return workletScope->messagePortChannelProvider();
+
+    return jsCast<Zig::GlobalObject*>(context.jsGlobalObject())->globalEventScope.messagePortChannelProvider();
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelProvider.h b/src/bun.js/bindings/webcore/MessagePortChannelProvider.h
new file mode 100644
index 000000000..2f9ab1787
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelProvider.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "ProcessIdentifier.h"
+#include "BunWorkerGlobalScope.h"
+#include <wtf/CompletionHandler.h>
+#include <wtf/Vector.h>
+
+namespace WebCore {
+
+class ScriptExecutionContext;
+struct MessagePortIdentifier;
+struct MessageWithMessagePorts;
+
+class MessagePortChannelProvider {
+public:
+    static MessagePortChannelProvider& fromContext(ScriptExecutionContext&);
+    static MessagePortChannelProvider& singleton();
+    // WEBCORE_EXPORT static void setSharedProvider(MessagePortChannelProvider&);
+
+    virtual ~MessagePortChannelProvider() {}
+
+    // Operations that WebProcesses perform
+    virtual void createNewMessagePortChannel(const MessagePortIdentifier& local, const MessagePortIdentifier& remote) = 0;
+    virtual void entangleLocalPortInThisProcessToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote) = 0;
+    virtual void messagePortDisentangled(const MessagePortIdentifier& local) = 0;
+    virtual void messagePortClosed(const MessagePortIdentifier& local) = 0;
+
+    virtual void takeAllMessagesForPort(const MessagePortIdentifier&, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&&) = 0;
+
+    virtual void postMessageToRemote(MessageWithMessagePorts&&, const MessagePortIdentifier& remoteTarget) = 0;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.cpp b/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.cpp
new file mode 100644
index 000000000..c33770dab
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MessagePortChannelProviderImpl.h"
+
+#include "MessagePort.h"
+#include <wtf/MainThread.h>
+#include <wtf/RunLoop.h>
+
+namespace WebCore {
+
+MessagePortChannelProviderImpl::MessagePortChannelProviderImpl()
+{
+}
+
+MessagePortChannelProviderImpl::~MessagePortChannelProviderImpl()
+{
+    ASSERT_NOT_REACHED();
+}
+
+void MessagePortChannelProviderImpl::createNewMessagePortChannel(const MessagePortIdentifier& local, const MessagePortIdentifier& remote)
+{
+    ScriptExecutionContext::ensureOnMainThread([registry = &m_registry, local, remote](ScriptExecutionContext& context) mutable {
+        registry->didCreateMessagePortChannel(local, remote);
+    });
+}
+
+void MessagePortChannelProviderImpl::entangleLocalPortInThisProcessToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote)
+{
+    ScriptExecutionContext::ensureOnMainThread([registry = &m_registry, local, remote](ScriptExecutionContext& context) mutable {
+        registry->didEntangleLocalToRemote(local, remote, ProcessIdent::identifier());
+    });
+}
+
+void MessagePortChannelProviderImpl::messagePortDisentangled(const MessagePortIdentifier& local)
+{
+    ScriptExecutionContext::ensureOnMainThread([registry = &m_registry, local](ScriptExecutionContext& context) mutable {
+        registry->didDisentangleMessagePort(local);
+    });
+}
+
+void MessagePortChannelProviderImpl::messagePortClosed(const MessagePortIdentifier& local)
+{
+    ScriptExecutionContext::ensureOnMainThread([registry = &m_registry, local](ScriptExecutionContext& context) mutable {
+        registry->didCloseMessagePort(local);
+    });
+}
+
+void MessagePortChannelProviderImpl::postMessageToRemote(MessageWithMessagePorts&& message, const MessagePortIdentifier& remoteTarget)
+{
+    ScriptExecutionContext::ensureOnMainThread([message = WTFMove(message), registry = &m_registry, remoteTarget](ScriptExecutionContext& context) mutable {
+        if (registry->didPostMessageToRemote(WTFMove(message), remoteTarget))
+            MessagePort::notifyMessageAvailable(remoteTarget);
+    });
+}
+
+void MessagePortChannelProviderImpl::takeAllMessagesForPort(const MessagePortIdentifier& port, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&& outerCallback)
+{
+    // It is the responsibility of outerCallback to get itself to the appropriate thread (e.g. WebWorker thread)
+    auto callback = [outerCallback = WTFMove(outerCallback)](Vector<MessageWithMessagePorts>&& messages, CompletionHandler<void()>&& messageDeliveryCallback) mutable {
+        ASSERT(isMainThread());
+        outerCallback(WTFMove(messages), WTFMove(messageDeliveryCallback));
+    };
+
+    ScriptExecutionContext::ensureOnMainThread([registry = &m_registry, port, callback = WTFMove(callback)](ScriptExecutionContext& context) mutable {
+        registry->takeAllMessagesForPort(port, WTFMove(callback));
+    });
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.h b/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.h
new file mode 100644
index 000000000..a6bcf79db
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelProviderImpl.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "MessagePortChannelProvider.h"
+#include "MessagePortChannelRegistry.h"
+
+namespace WebCore {
+
+class MessagePortChannelProviderImpl final : public MessagePortChannelProvider {
+public:
+    MessagePortChannelProviderImpl();
+    ~MessagePortChannelProviderImpl() final;
+
+private:
+    void createNewMessagePortChannel(const MessagePortIdentifier& local, const MessagePortIdentifier& remote) final;
+    void entangleLocalPortInThisProcessToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote) final;
+    void messagePortDisentangled(const MessagePortIdentifier& local) final;
+    void messagePortClosed(const MessagePortIdentifier& local) final;
+    void postMessageToRemote(MessageWithMessagePorts&&, const MessagePortIdentifier& remoteTarget) final;
+    void takeAllMessagesForPort(const MessagePortIdentifier&, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&&) final;
+
+    MessagePortChannelRegistry m_registry;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelRegistry.cpp b/src/bun.js/bindings/webcore/MessagePortChannelRegistry.cpp
new file mode 100644
index 000000000..7675e0eab
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelRegistry.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MessagePortChannelRegistry.h"
+
+// #include "Logging.h"
+#include <wtf/CompletionHandler.h>
+#include <wtf/MainThread.h>
+
+namespace WebCore {
+
+MessagePortChannelRegistry::MessagePortChannelRegistry() = default;
+
+MessagePortChannelRegistry::~MessagePortChannelRegistry()
+{
+    ASSERT(m_openChannels.isEmpty());
+}
+
+void MessagePortChannelRegistry::didCreateMessagePortChannel(const MessagePortIdentifier& port1, const MessagePortIdentifier& port2)
+{
+    LOG(MessagePorts, "Registry: Creating MessagePortChannel %p linking %s and %s", this, port1.logString().utf8().data(), port2.logString().utf8().data());
+    ASSERT(isMainThread());
+
+    MessagePortChannel::create(*this, port1, port2);
+}
+
+void MessagePortChannelRegistry::messagePortChannelCreated(MessagePortChannel& channel)
+{
+    ASSERT(isMainThread());
+
+    auto result = m_openChannels.ensure(channel.port1(), [channel = &channel] {
+        return channel;
+    });
+    ASSERT(result.isNewEntry);
+
+    result = m_openChannels.ensure(channel.port2(), [channel = &channel] {
+        return channel;
+    });
+    ASSERT(result.isNewEntry);
+}
+
+void MessagePortChannelRegistry::messagePortChannelDestroyed(MessagePortChannel& channel)
+{
+    ASSERT(isMainThread());
+
+    ASSERT(m_openChannels.get(channel.port1()) == &channel);
+    ASSERT(m_openChannels.get(channel.port2()) == &channel);
+
+    m_openChannels.remove(channel.port1());
+    m_openChannels.remove(channel.port2());
+
+    LOG(MessagePorts, "Registry: After removing channel %s there are %u channels left in the registry:", channel.logString().utf8().data(), m_openChannels.size());
+}
+
+void MessagePortChannelRegistry::didEntangleLocalToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote, ProcessIdentifier process)
+{
+    ASSERT(isMainThread());
+
+    // The channel might be gone if the remote side was closed.
+    auto* channel = m_openChannels.get(local);
+    if (!channel)
+        return;
+
+    ASSERT_UNUSED(remote, channel->includesPort(remote));
+
+    channel->entanglePortWithProcess(local, process);
+}
+
+void MessagePortChannelRegistry::didDisentangleMessagePort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    // The channel might be gone if the remote side was closed.
+    auto* channel = m_openChannels.get(port);
+    if (!channel)
+        return;
+
+    channel->disentanglePort(port);
+}
+
+void MessagePortChannelRegistry::didCloseMessagePort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    LOG(MessagePorts, "Registry: MessagePort %s closed in registry", port.logString().utf8().data());
+
+    auto* channel = m_openChannels.get(port);
+    if (!channel)
+        return;
+
+#ifndef NDEBUG
+    if (channel && channel->hasAnyMessagesPendingOrInFlight())
+        LOG(MessagePorts, "Registry: (Note) The channel closed for port %s had messages pending or in flight", port.logString().utf8().data());
+#endif
+
+    channel->closePort(port);
+
+    // FIXME: When making message ports be multi-process, this should probably push a notification
+    // to the remaining port to tell it this port closed.
+}
+
+bool MessagePortChannelRegistry::didPostMessageToRemote(MessageWithMessagePorts&& message, const MessagePortIdentifier& remoteTarget)
+{
+    ASSERT(isMainThread());
+
+    LOG(MessagePorts, "Registry: Posting message to MessagePort %s in registry", remoteTarget.logString().utf8().data());
+
+    // The channel might be gone if the remote side was closed.
+    auto* channel = m_openChannels.get(remoteTarget);
+    if (!channel) {
+        LOG(MessagePorts, "Registry: Could not find MessagePortChannel for port %s; It was probably closed. Message will be dropped.", remoteTarget.logString().utf8().data());
+        return false;
+    }
+
+    return channel->postMessageToRemote(WTFMove(message), remoteTarget);
+}
+
+void MessagePortChannelRegistry::takeAllMessagesForPort(const MessagePortIdentifier& port, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&& callback)
+{
+    ASSERT(isMainThread());
+
+    LOG(MessagePorts, "Registry: Taking all messages for MessagePort %s", port.logString().utf8().data());
+
+    // The channel might be gone if the remote side was closed.
+    auto* channel = m_openChannels.get(port);
+    if (!channel) {
+        callback({}, [] {});
+        return;
+    }
+
+    channel->takeAllMessagesForPort(port, WTFMove(callback));
+}
+
+MessagePortChannel* MessagePortChannelRegistry::existingChannelContainingPort(const MessagePortIdentifier& port)
+{
+    ASSERT(isMainThread());
+
+    return m_openChannels.get(port);
+}
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortChannelRegistry.h b/src/bun.js/bindings/webcore/MessagePortChannelRegistry.h
new file mode 100644
index 000000000..334fb5f9c
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortChannelRegistry.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "MessagePortChannel.h"
+#include "MessagePortChannelProvider.h"
+#include "MessagePortIdentifier.h"
+#include "ProcessIdentifier.h"
+#include <wtf/HashMap.h>
+
+namespace WebCore {
+
+class MessagePortChannelRegistry {
+public:
+    WEBCORE_EXPORT MessagePortChannelRegistry();
+
+    WEBCORE_EXPORT ~MessagePortChannelRegistry();
+
+    WEBCORE_EXPORT void didCreateMessagePortChannel(const MessagePortIdentifier& port1, const MessagePortIdentifier& port2);
+    WEBCORE_EXPORT void didEntangleLocalToRemote(const MessagePortIdentifier& local, const MessagePortIdentifier& remote, ProcessIdentifier);
+    WEBCORE_EXPORT void didDisentangleMessagePort(const MessagePortIdentifier& local);
+    WEBCORE_EXPORT void didCloseMessagePort(const MessagePortIdentifier& local);
+    WEBCORE_EXPORT bool didPostMessageToRemote(MessageWithMessagePorts&&, const MessagePortIdentifier& remoteTarget);
+    WEBCORE_EXPORT void takeAllMessagesForPort(const MessagePortIdentifier&, CompletionHandler<void(Vector<MessageWithMessagePorts>&&, CompletionHandler<void()>&&)>&&);
+
+    WEBCORE_EXPORT MessagePortChannel* existingChannelContainingPort(const MessagePortIdentifier&);
+
+    WEBCORE_EXPORT void messagePortChannelCreated(MessagePortChannel&);
+    WEBCORE_EXPORT void messagePortChannelDestroyed(MessagePortChannel&);
+
+private:
+    HashMap<MessagePortIdentifier, MessagePortChannel*> m_openChannels;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/MessagePortIdentifier.h b/src/bun.js/bindings/webcore/MessagePortIdentifier.h
new file mode 100644
index 000000000..eac8546de
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessagePortIdentifier.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "PortIdentifier.h"
+#include "ProcessIdentifier.h"
+#include <wtf/Hasher.h>
+#include <wtf/text/StringConcatenateNumbers.h>
+
+namespace WebCore {
+
+struct MessagePortIdentifier {
+    ProcessIdentifier processIdentifier;
+    PortIdentifier portIdentifier;
+
+#if !LOG_DISABLED
+    String logString() const;
+#endif
+};
+
+inline void add(Hasher& hasher, const MessagePortIdentifier& identifier)
+{
+    add(hasher, identifier.processIdentifier, identifier.portIdentifier);
+}
+
+inline bool operator==(const MessagePortIdentifier& a, const MessagePortIdentifier& b)
+{
+    return a.processIdentifier == b.processIdentifier && a.portIdentifier == b.portIdentifier;
+}
+
+#if !LOG_DISABLED
+
+inline String MessagePortIdentifier::logString() const
+{
+    return makeString(processIdentifier.toUInt64(), '-', portIdentifier.toUInt64());
+}
+
+#endif
+
+} // namespace WebCore
+
+namespace WTF {
+
+struct MessagePortIdentifierHash {
+    static unsigned hash(const WebCore::MessagePortIdentifier& key) { return computeHash(key); }
+    static bool equal(const WebCore::MessagePortIdentifier& a, const WebCore::MessagePortIdentifier& b) { return a == b; }
+    static const bool safeToCompareToEmptyOrDeleted = true;
+};
+
+template<> struct HashTraits<WebCore::MessagePortIdentifier> : GenericHashTraits<WebCore::MessagePortIdentifier> {
+    static WebCore::MessagePortIdentifier emptyValue() { return {}; }
+
+    static void constructDeletedValue(WebCore::MessagePortIdentifier& slot) { new (NotNull, &slot.processIdentifier) WebCore::ProcessIdentifier(WTF::HashTableDeletedValue); }
+
+    static bool isDeletedValue(const WebCore::MessagePortIdentifier& slot) { return slot.processIdentifier.isHashTableDeletedValue(); }
+};
+
+template<> struct DefaultHash<WebCore::MessagePortIdentifier> : MessagePortIdentifierHash {};
+
+} // namespace WTF
diff --git a/src/bun.js/bindings/webcore/MessageWithMessagePorts.h b/src/bun.js/bindings/webcore/MessageWithMessagePorts.h
new file mode 100644
index 000000000..a986bfb4c
--- /dev/null
+++ b/src/bun.js/bindings/webcore/MessageWithMessagePorts.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2018 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "SerializedScriptValue.h"
+#include "TransferredMessagePort.h"
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+
+struct MessageWithMessagePorts {
+    RefPtr<SerializedScriptValue> message;
+    Vector<TransferredMessagePort> transferredPorts;
+};
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/PortIdentifier.h b/src/bun.js/bindings/webcore/PortIdentifier.h
new file mode 100644
index 000000000..8b77e792e
--- /dev/null
+++ b/src/bun.js/bindings/webcore/PortIdentifier.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "ProcessIdentifier.h"
+
+namespace WebCore {
+
+enum PortIdentifierType {};
+using PortIdentifier = AtomicObjectIdentifier<PortIdentifierType>;
+
+}
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
index e80bc9493..9eeee155a 100644
--- a/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.cpp
@@ -54,7 +54,7 @@
 // #include "JSIDBSerializationGlobalObject.h"
 // #include "JSImageBitmap.h"
 // #include "JSImageData.h"
-// #include "JSMessagePort.h"
+#include "JSMessagePort.h"
 // #include "JSNavigator.h"
 // #include "JSRTCCertificate.h"
 // #include "JSRTCDataChannel.h"
@@ -715,7 +715,7 @@ public:
     //         return serializer.serialize(value);
     //     }
 
-    static SerializationReturnCode serialize(JSGlobalObject* lexicalGlobalObject, JSValue value, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
+    static SerializationReturnCode serialize(JSGlobalObject* lexicalGlobalObject, JSValue value, Vector<RefPtr<MessagePort>>& messagePorts, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
 #endif
@@ -733,7 +733,7 @@ public:
         Vector<uint8_t>& out, SerializationContext context, ArrayBufferContentsArray& sharedBuffers,
         SerializationForStorage forStorage)
     {
-        CloneSerializer serializer(lexicalGlobalObject, arrayBuffers,
+        CloneSerializer serializer(lexicalGlobalObject, messagePorts, arrayBuffers,
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
             offscreenCanvases,
 #endif
@@ -815,7 +815,7 @@ private:
     // #endif
     //     }
 
-    CloneSerializer(JSGlobalObject* lexicalGlobalObject, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
+    CloneSerializer(JSGlobalObject* lexicalGlobalObject, Vector<RefPtr<MessagePort>>& messagePorts, Vector<RefPtr<JSC::ArrayBuffer>>& arrayBuffers,
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         const Vector<RefPtr<OffscreenCanvas>>& offscreenCanvases,
 #endif
@@ -847,6 +847,7 @@ private:
         , m_forStorage(forStorage)
     {
         write(CurrentVersion);
+        fillTransferMap(messagePorts, m_transferredMessagePorts);
         fillTransferMap(arrayBuffers, m_transferredArrayBuffers);
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         fillTransferMap(offscreenCanvases, m_transferredOffscreenCanvases);
@@ -1501,17 +1502,17 @@ private:
                 write(String::fromLatin1(JSC::Yarr::flagsString(regExp->regExp()->flags()).data()));
                 return true;
             }
-            // if (obj->inherits<JSMessagePort>()) {
-            //     auto index = m_transferredMessagePorts.find(obj);
-            //     if (index != m_transferredMessagePorts.end()) {
-            //         write(MessagePortReferenceTag);
-            //         write(index->value);
-            //         return true;
-            //     }
-            //     // MessagePort object could not be found in transferred message ports
-            //     code = SerializationReturnCode::ValidationError;
-            //     return true;
-            // }
+            if (obj->inherits<JSMessagePort>()) {
+                auto index = m_transferredMessagePorts.find(obj);
+                if (index != m_transferredMessagePorts.end()) {
+                    write(MessagePortReferenceTag);
+                    write(index->value);
+                    return true;
+                }
+                // MessagePort object could not be found in transferred message ports
+                code = SerializationReturnCode::ValidationError;
+                return true;
+            }
             if (auto* arrayBuffer = toPossiblySharedArrayBuffer(vm, obj)) {
                 if (arrayBuffer->isDetached()) {
                     code = SerializationReturnCode::ValidationError;
@@ -1570,7 +1571,7 @@ private:
                 write(CryptoKeyTag);
                 Vector<uint8_t> serializedKey;
                 // Vector<URLKeepingBlobAlive> dummyBlobHandles;
-                // Vector<RefPtr<MessagePort>> dummyMessagePorts;
+                Vector<RefPtr<MessagePort>> dummyMessagePorts;
                 Vector<RefPtr<JSC::ArrayBuffer>> dummyArrayBuffers;
 #if ENABLE(WEB_CODECS)
                 Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>> dummyVideoChunks;
@@ -1597,7 +1598,7 @@ private:
                 //                     dummyMemoryHandles,
                 // #endif
                 //                     dummyBlobHandles, serializedKey, SerializationContext::Default, dummySharedBuffers, m_forStorage);
-                CloneSerializer rawKeySerializer(m_lexicalGlobalObject, dummyArrayBuffers,
+                CloneSerializer rawKeySerializer(m_lexicalGlobalObject, dummyMessagePorts, dummyArrayBuffers,
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
                     {},
 #endif
@@ -2518,7 +2519,7 @@ public:
     //         return deserializer.deserialize();
     //     }
 
-    static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject
+    static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         ,
         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
@@ -2541,7 +2542,7 @@ public:
     {
         if (!buffer.size())
             return std::make_pair(jsNull(), SerializationReturnCode::UnspecifiedError);
-        CloneDeserializer deserializer(lexicalGlobalObject, globalObject, arrayBufferContentsArray, std::span<uint8_t> { buffer.begin(), buffer.end() }, blobURLs, blobFilePaths, sharedBuffers
+        CloneDeserializer deserializer(lexicalGlobalObject, globalObject, messagePorts, arrayBufferContentsArray, std::span<uint8_t> { buffer.begin(), buffer.end() }, blobURLs, blobFilePaths, sharedBuffers
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
             ,
             WTFMove(detachedOffscreenCanvases)
@@ -2675,7 +2676,7 @@ private:
     //             m_version = 0xFFFFFFFF;
     //     }
 
-    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, ArrayBufferContentsArray* arrayBufferContents, const std::span<uint8_t>& buffer
+    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, const std::span<uint8_t>& buffer
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         ,
         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases = {}
@@ -2700,6 +2701,7 @@ private:
         , m_ptr(buffer.data())
         , m_end(buffer.data() + buffer.size())
         , m_version(0xFFFFFFFF)
+        , m_messagePorts(messagePorts)
         , m_arrayBufferContents(arrayBufferContents)
         , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
@@ -2781,7 +2783,7 @@ private:
     //             m_version = 0xFFFFFFFF;
     //     }
 
-    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, ArrayBufferContentsArray* arrayBufferContents, const std::span<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers
+    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, const std::span<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         ,
         Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
@@ -2806,6 +2808,7 @@ private:
         , m_ptr(buffer.data())
         , m_end(buffer.data() + buffer.size())
         , m_version(0xFFFFFFFF)
+        , m_messagePorts(messagePorts)
         , m_arrayBufferContents(arrayBufferContents)
         , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
         , m_blobURLs(blobURLs)
@@ -4391,15 +4394,15 @@ private:
             }
             return m_gcBuffer.at(index);
         }
-        // case MessagePortReferenceTag: {
-        //     uint32_t index;
-        //     bool indexSuccessfullyRead = read(index);
-        //     if (!indexSuccessfullyRead || index >= m_messagePorts.size()) {
-        //         fail();
-        //         return JSValue();
-        //     }
-        //     return getJSValue(m_messagePorts[index].get());
-        // }
+        case MessagePortReferenceTag: {
+            uint32_t index;
+            bool indexSuccessfullyRead = read(index);
+            if (!indexSuccessfullyRead || index >= m_messagePorts.size()) {
+                fail();
+                return JSValue();
+            }
+            return getJSValue(m_messagePorts[index].get());
+        }
 #if ENABLE(WEBASSEMBLY)
         case WasmModuleTag: {
             if (m_version >= 12) {
@@ -4554,7 +4557,7 @@ private:
             JSValue cryptoKey;
             // Vector<RefPtr<MessagePort>> dummyMessagePorts;
             // CloneDeserializer rawKeyDeserializer(m_lexicalGlobalObject, m_globalObject, dummyMessagePorts, nullptr, {}, serializedKey);
-            CloneDeserializer rawKeyDeserializer(m_lexicalGlobalObject, m_globalObject, nullptr, serializedKey);
+            CloneDeserializer rawKeyDeserializer(m_lexicalGlobalObject, m_globalObject, {}, nullptr, serializedKey);
             if (!rawKeyDeserializer.readCryptoKey(cryptoKey)) {
                 fail();
                 return JSValue();
@@ -4625,7 +4628,7 @@ private:
     const uint8_t* const m_end;
     unsigned m_version;
     Vector<CachedString> m_constantPool;
-    // const Vector<RefPtr<MessagePort>>& m_messagePorts;
+    const Vector<RefPtr<MessagePort>>& m_messagePorts;
     ArrayBufferContentsArray* m_arrayBufferContents;
     Vector<RefPtr<JSC::ArrayBuffer>> m_arrayBuffers;
     Vector<String> m_blobURLs;
@@ -5117,9 +5120,9 @@ static bool canDetachRTCDataChannels(const Vector<Ref<RTCDataChannel>>& channels
 
 RefPtr<SerializedScriptValue> SerializedScriptValue::create(JSC::JSGlobalObject& globalObject, JSC::JSValue value, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext serializationContext)
 {
-    // Vector<RefPtr<MessagePort>> dummyPorts;
-    // auto result = create(globalObject, value, {}, dummyPorts, forStorage, throwExceptions, serializationContext);
-    auto result = create(globalObject, value, {}, forStorage, throwExceptions, serializationContext);
+    Vector<RefPtr<MessagePort>> dummyPorts;
+    auto result = create(globalObject, value, {}, dummyPorts, forStorage, throwExceptions, serializationContext);
+    // auto result = create(globalObject, value, {}, forStorage, throwExceptions, serializationContext);
     if (result.hasException())
         return nullptr;
     return result.releaseReturnValue();
@@ -5130,13 +5133,13 @@ RefPtr<SerializedScriptValue> SerializedScriptValue::create(JSC::JSGlobalObject&
 //     return create(globalObject, value, WTFMove(transferList), messagePorts, forStorage, SerializationErrorMode::NonThrowing, serializationContext);
 // }
 
-ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& globalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, SerializationForStorage forStorage, SerializationContext serializationContext)
+ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& globalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, Vector<RefPtr<MessagePort>>& messagePorts, SerializationForStorage forStorage, SerializationContext serializationContext)
 {
-    return create(globalObject, value, WTFMove(transferList), forStorage, SerializationErrorMode::Throwing, serializationContext);
+    return create(globalObject, value, WTFMove(transferList), messagePorts, forStorage, SerializationErrorMode::Throwing, serializationContext);
 }
 
-// ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, Vector<RefPtr<MessagePort>>& messagePorts, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
-ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
+// ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
+ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalObject& lexicalGlobalObject, JSValue value, Vector<JSC::Strong<JSC::JSObject>>&& transferList, Vector<RefPtr<MessagePort>>& messagePorts, SerializationForStorage forStorage, SerializationErrorMode throwExceptions, SerializationContext context)
 {
     VM& vm = lexicalGlobalObject.vm();
     Vector<RefPtr<JSC::ArrayBuffer>> arrayBuffers;
@@ -5166,12 +5169,12 @@ ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalOb
             arrayBuffers.append(WTFMove(arrayBuffer));
             continue;
         }
-        // if (auto port = JSMessagePort::toWrapped(vm, transferable.get())) {
-        //     if (port->isDetached())
-        //         return Exception { DataCloneError, "MessagePort is detached"_s };
-        //     messagePorts.append(WTFMove(port));
-        //     continue;
-        // }
+        if (auto port = JSMessagePort::toWrapped(vm, transferable.get())) {
+            if (port->isDetached())
+                return Exception { DataCloneError, "MessagePort is detached"_s };
+            messagePorts.append(WTFMove(port));
+            continue;
+        }
 
         // if (auto imageBitmap = JSImageBitmap::toWrapped(vm, transferable.get())) {
         //     if (imageBitmap->isDetached())
@@ -5247,7 +5250,7 @@ ExceptionOr<Ref<SerializedScriptValue>> SerializedScriptValue::create(JSGlobalOb
     // #endif
     //         blobHandles, buffer, context, *sharedBuffers, forStorage);
 
-    auto code = CloneSerializer::serialize(&lexicalGlobalObject, value, arrayBuffers,
+    auto code = CloneSerializer::serialize(&lexicalGlobalObject, value, messagePorts, arrayBuffers,
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         offscreenCanvases,
 #endif
@@ -5408,7 +5411,7 @@ JSC::JSValue SerializedScriptValue::fromArrayBuffer(JSC::JSGlobalObject& domGlob
     auto size = std::min(arrayBuffer->byteLength(), maxByteLength);
     auto span = std::span<uint8_t> { data, size };
 
-    auto result = CloneDeserializer::deserialize(&domGlobal, globalObject, nullptr, span, blobURLs, blobFiles, nullptr
+    auto result = CloneDeserializer::deserialize(&domGlobal, globalObject, {}, nullptr, span, blobURLs, blobFiles, nullptr
 #if ENABLE(WEBASSEMBLY)
         ,
         nullptr, nullptr
@@ -5437,71 +5440,24 @@ JSC::JSValue SerializedScriptValue::fromArrayBuffer(JSC::JSGlobalObject& domGlob
 //     return deserialize(lexicalGlobalObject, globalObject, {}, throwExceptions, didFail);
 // }
 
-// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, SerializationErrorMode throwExceptions, bool* didFail)
-// {
-//     Vector<String> dummyBlobs;
-//     Vector<String> dummyPaths;
-//     return deserialize(lexicalGlobalObject, globalObject, messagePorts, dummyBlobs, dummyPaths, throwExceptions, didFail);
-// }
+JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, SerializationErrorMode throwExceptions, bool* didFail)
+{
+    Vector<String> dummyBlobs;
+    Vector<String> dummyPaths;
+    return deserialize(lexicalGlobalObject, globalObject, messagePorts, dummyBlobs, dummyPaths, throwExceptions, didFail);
+}
 
 JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, SerializationErrorMode throwExceptions, bool* didFail)
 {
     Vector<String> dummyBlobs;
     Vector<String> dummyPaths;
-    return deserialize(lexicalGlobalObject, globalObject, dummyBlobs, dummyPaths, throwExceptions, didFail);
+    Vector<RefPtr<MessagePort>> dummyPorts;
+    return deserialize(lexicalGlobalObject, globalObject, dummyPorts, dummyBlobs, dummyPaths, throwExceptions, didFail);
 }
 
-// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
-// {
-//     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
-// #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
-//                                                                                                                         ,
-//         WTFMove(m_detachedOffscreenCanvases)
-// #endif
-// #if ENABLE(WEB_RTC)
-//             ,
-//         WTFMove(m_detachedRTCDataChannels)
-// #endif
-//             ,
-//         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
-// #if ENABLE(WEBASSEMBLY)
-//                                                                                ,
-//         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
-// #endif
-// #if ENABLE(WEB_CODECS)
-//                                       ,
-//         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
-// #endif
-//     );
-//     if (didFail)
-//         *didFail = result.second != SerializationReturnCode::SuccessfullyCompleted;
-//     if (throwExceptions == SerializationErrorMode::Throwing)
-//         maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, result.second);
-//     return result.first ? result.first : jsNull();
-// }
-JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
+JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
 {
-    //     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
-    // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
-    //                                                                                                                         ,
-    //         WTFMove(m_detachedOffscreenCanvases)
-    // #endif
-    // #if ENABLE(WEB_RTC)
-    //             ,
-    //         WTFMove(m_detachedRTCDataChannels)
-    // #endif
-    //             ,
-    //         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
-    // #if ENABLE(WEBASSEMBLY)
-    //                                                                                ,
-    //         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
-    // #endif
-    // #if ENABLE(WEB_CODECS)
-    //                                       ,
-    //         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
-    // #endif
-    //     );
-    DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject
+    DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts
 #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
         ,
         WTFMove(m_detachedOffscreenCanvases)
@@ -5527,6 +5483,54 @@ JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject,
         maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, result.second);
     return result.first ? result.first : jsNull();
 }
+// JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions, bool* didFail)
+// {
+//     //     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
+//     // #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+//     //                                                                                                                         ,
+//     //         WTFMove(m_detachedOffscreenCanvases)
+//     // #endif
+//     // #if ENABLE(WEB_RTC)
+//     //             ,
+//     //         WTFMove(m_detachedRTCDataChannels)
+//     // #endif
+//     //             ,
+//     //         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
+//     // #if ENABLE(WEBASSEMBLY)
+//     //                                                                                ,
+//     //         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
+//     // #endif
+//     // #if ENABLE(WEB_CODECS)
+//     //                                       ,
+//     //         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
+//     // #endif
+//     //     );
+//     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject
+// #if ENABLE(OFFSCREEN_CANVAS_IN_WORKERS)
+//         ,
+//         WTFMove(m_detachedOffscreenCanvases)
+// #endif
+// #if ENABLE(WEB_RTC)
+//             ,
+//         WTFMove(m_detachedRTCDataChannels)
+// #endif
+//             ,
+//         m_arrayBufferContentsArray.get(), m_data, blobURLs, blobFilePaths, m_sharedBufferContentsArray.get()
+// #if ENABLE(WEBASSEMBLY)
+//                                                                                ,
+//         m_wasmModulesArray.get(), m_wasmMemoryHandlesArray.get()
+// #endif
+// #if ENABLE(WEB_CODECS)
+//                                       ,
+//         WTFMove(m_serializedVideoChunks), WTFMove(m_serializedVideoFrames)
+// #endif
+//     );
+//     if (didFail)
+//         *didFail = result.second != SerializationReturnCode::SuccessfullyCompleted;
+//     if (throwExceptions == SerializationErrorMode::Throwing)
+//         maybeThrowExceptionIfSerializationFailed(lexicalGlobalObject, result.second);
+//     return result.first ? result.first : jsNull();
+// }
 
 JSValueRef SerializedScriptValue::deserialize(JSContextRef destinationContext, JSValueRef* exception)
 {
diff --git a/src/bun.js/bindings/webcore/SerializedScriptValue.h b/src/bun.js/bindings/webcore/SerializedScriptValue.h
index 189945d52..5d5e93854 100644
--- a/src/bun.js/bindings/webcore/SerializedScriptValue.h
+++ b/src/bun.js/bindings/webcore/SerializedScriptValue.h
@@ -60,7 +60,7 @@ namespace WebCore {
 class DetachedOffscreenCanvas;
 #endif
 // class IDBValue;
-// class MessagePort;
+class MessagePort;
 // class ImageBitmapBacking;
 class CloneSerializer;
 class FragmentedSharedBuffer;
@@ -87,8 +87,8 @@ class SerializedScriptValue : public ThreadSafeRefCounted<SerializedScriptValue>
 public:
     static void writeBytesForBun(CloneSerializer*, const uint8_t*, uint32_t);
 
-    // WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, Vector<RefPtr<MessagePort>>&, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
-    WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
+    WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, Vector<RefPtr<MessagePort>>&, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
+    // WEBCORE_EXPORT static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, SerializationForStorage = SerializationForStorage::No, SerializationContext = SerializationContext::Default);
 
     WEBCORE_EXPORT static RefPtr<SerializedScriptValue> create(JSC::JSGlobalObject&, JSC::JSValue, SerializationForStorage = SerializationForStorage::No, SerializationErrorMode = SerializationErrorMode::Throwing, SerializationContext = SerializationContext::Default);
 
@@ -99,10 +99,10 @@ public:
     static Ref<SerializedScriptValue> nullValue();
 
     WEBCORE_EXPORT JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
-    // WEBCORE_EXPORT JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+    WEBCORE_EXPORT JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
 
-    // JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
-    JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+    JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<RefPtr<MessagePort>>&, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
+    // JSC::JSValue deserialize(JSC::JSGlobalObject&, JSC::JSGlobalObject*, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode = SerializationErrorMode::Throwing, bool* didFail = nullptr);
 
     static uint32_t wireFormatVersion();
 
@@ -146,7 +146,7 @@ private:
     //         Vector<RefPtr<WebCodecsEncodedVideoChunkStorage>>&& = {}, Vector<WebCodecsVideoFrameData>&& = {}
     // #endif
     //     );
-    static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, SerializationForStorage, SerializationErrorMode, SerializationContext);
+    static ExceptionOr<Ref<SerializedScriptValue>> create(JSC::JSGlobalObject&, JSC::JSValue, Vector<JSC::Strong<JSC::JSObject>>&& transfer, Vector<RefPtr<MessagePort>>&, SerializationForStorage, SerializationErrorMode, SerializationContext);
     WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&&, std::unique_ptr<ArrayBufferContentsArray>&& = nullptr
 #if ENABLE(WEB_RTC)
         ,
diff --git a/src/bun.js/bindings/webcore/TransferredMessagePort.h b/src/bun.js/bindings/webcore/TransferredMessagePort.h
new file mode 100644
index 000000000..19aa63746
--- /dev/null
+++ b/src/bun.js/bindings/webcore/TransferredMessagePort.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2018-2022 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "MessagePortIdentifier.h"
+
+namespace WebCore {
+
+// When a message port is transferred, it is represented by a pair of identifiers.
+// The first identifier is the port being transferred and the second is its remote port.
+using TransferredMessagePort = std::pair<MessagePortIdentifier, MessagePortIdentifier>;
+
+} // namespace WebCore
diff --git a/src/bun.js/bindings/webcore/Worker.cpp b/src/bun.js/bindings/webcore/Worker.cpp
index dfbc0e007..d9bd6f9b4 100644
--- a/src/bun.js/bindings/webcore/Worker.cpp
+++ b/src/bun.js/bindings/webcore/Worker.cpp
@@ -185,25 +185,25 @@ ExceptionOr<void> Worker::postMessage(JSC::JSGlobalObject& state, JSC::JSValue m
     if (m_wasTerminated)
         return Exception { InvalidStateError, "Worker has been terminated"_s };
 
-    auto message = SerializedScriptValue::create(state, messageValue, WTFMove(options.transfer), SerializationForStorage::No, SerializationContext::WorkerPostMessage);
-    if (message.hasException())
-        return message.releaseException();
+    Vector<RefPtr<MessagePort>> ports;
+    auto serialized = SerializedScriptValue::create(state, messageValue, WTFMove(options.transfer), ports);
+    if (serialized.hasException())
+        return serialized.releaseException();
+
+    ExceptionOr<Vector<TransferredMessagePort>> disentangledPorts = MessagePort::disentanglePorts(WTFMove(ports));
+    if (disentangledPorts.hasException()) {
+        return disentangledPorts.releaseException();
+    }
 
-    RefPtr<SerializedScriptValue> result = message.releaseReturnValue();
+    MessageWithMessagePorts messageWithMessagePorts { serialized.releaseReturnValue(), disentangledPorts.releaseReturnValue() };
 
-    this->postTaskToWorkerGlobalScope([message = WTFMove(result)](auto& context) {
+    this->postTaskToWorkerGlobalScope([message = messageWithMessagePorts](auto& context) mutable {
         Zig::GlobalObject* globalObject = jsCast<Zig::GlobalObject*>(context.jsGlobalObject());
-        bool didFail = false;
-        JSValue value = message->deserialize(*globalObject, globalObject, SerializationErrorMode::NonThrowing, &didFail);
 
-        if (didFail) {
-            globalObject->globalEventScope.dispatchEvent(MessageEvent::create(eventNames().messageerrorEvent, MessageEvent::Init {}, MessageEvent::IsTrusted::Yes));
-            return;
-        }
+        auto ports = MessagePort::entanglePorts(context, WTFMove(message.transferredPorts));
+        auto event = MessageEvent::create(*globalObject, message.message.releaseNonNull(), std::nullopt, WTFMove(ports));
 
-        WebCore::MessageEvent::Init init;
-        init.data = value;
-        globalObject->globalEventScope.dispatchEvent(MessageEvent::create(eventNames().messageEvent, WTFMove(init), MessageEvent::IsTrusted::Yes));
+        globalObject->globalEventScope.dispatchEvent(event.event);
     });
     return {};
 }
diff --git a/src/bun.js/bindings/webcore/Worker.h b/src/bun.js/bindings/webcore/Worker.h
index b0b8e0a2b..76607d8da 100644
--- a/src/bun.js/bindings/webcore/Worker.h
+++ b/src/bun.js/bindings/webcore/Worker.h
@@ -135,7 +135,6 @@ private:
     bool m_isClosing { false };
     const ScriptExecutionContextIdentifier m_clientIdentifier;
     void* impl_ { nullptr };
-    size_t m_pendingActivityCount { 0 };
 };
 
 } // namespace WebCore
diff --git a/src/bun.js/scripts/class-definitions.ts b/src/bun.js/scripts/class-definitions.ts
index 281cd62c5..d9c327f6b 100644
--- a/src/bun.js/scripts/class-definitions.ts
+++ b/src/bun.js/scripts/class-definitions.ts
@@ -41,7 +41,7 @@ export interface ClassDefinition {
 
   configurable?: boolean;
   enumerable?: boolean;
-  structuredClone?: boolean | { transferrable: boolean; tag: number };
+  structuredClone?: boolean | { transferable: boolean; tag: number };
 }
 
 export interface CustomField {
diff --git a/src/bun.js/scripts/generate-classes.ts b/src/bun.js/scripts/generate-classes.ts
index fb4419642..ec0021637 100644
--- a/src/bun.js/scripts/generate-classes.ts
+++ b/src/bun.js/scripts/generate-classes.ts
@@ -1249,7 +1249,7 @@ function generateZig(
   if (structuredClone) {
     exports.set("onStructuredCloneSerialize", symbolName(typeName, "onStructuredCloneSerialize"));
 
-    if (structuredClone === "transferrable") {
+    if (structuredClone === "transferable") {
       exports.set("onStructuredCloneTransfer", symbolName(typeName, "onStructuredCloneTransfer"));
     }
 
@@ -1306,8 +1306,8 @@ function generateZig(
       }
       `;
 
-      if (structuredClone === "transferrable") {
-        exports.set("structuredClone", symbolName(typeName, "onTransferrableStructuredClone"));
+      if (structuredClone === "transferable") {
+        exports.set("structuredClone", symbolName(typeName, "onTransferableStructuredClone"));
         output += `
         if (@TypeOf(${typeName}.onStructuredCloneTransfer) != (fn(*${typeName}, globalThis: *JSC.JSGlobalObject, ctx: *anyopaque, write: *const fn(*anyopaque, ptr: [*]const u8, len: usize) callconv(.C) void) callconv(.C) void)) {
           @compileLog("${typeName}.onStructuredCloneTransfer is not a structured clone transfer function");
diff --git a/src/bun.js/webcore/response.classes.ts b/src/bun.js/webcore/response.classes.ts
index f0d6e1451..abd29c654 100644
--- a/src/bun.js/webcore/response.classes.ts
+++ b/src/bun.js/webcore/response.classes.ts
@@ -125,7 +125,7 @@ export default [
     JSType: "0b11101110",
     klass: {},
     configurable: false,
-    structuredClone: { transferrable: false, tag: 254 },
+    structuredClone: { transferable: false, tag: 254 },
     proto: {
       text: { fn: "getText" },
       json: { fn: "getJSON" },
diff --git a/test/js/web/workers/create-port-worker.js b/test/js/web/workers/create-port-worker.js
new file mode 100644
index 000000000..6e8709de0
--- /dev/null
+++ b/test/js/web/workers/create-port-worker.js
@@ -0,0 +1,6 @@
+var channel = new MessageChannel();
+channel.port1.onmessage = e => {
+  channel.port1.postMessage("done!");
+};
+
+postMessage(channel.port2, { transfer: [channel.port2] });
diff --git a/test/js/web/workers/message-channel.test.ts b/test/js/web/workers/message-channel.test.ts
new file mode 100644
index 000000000..7d3e3cc25
--- /dev/null
+++ b/test/js/web/workers/message-channel.test.ts
@@ -0,0 +1,254 @@
+test("simple usage", done => {
+  var channel = new MessageChannel();
+  var port1 = channel.port1;
+  var port2 = channel.port2;
+
+  port2.onmessage = function (e) {
+    expect(e.data).toEqual("hello");
+    done();
+  };
+
+  port1.postMessage("hello");
+});
+
+test("transfer message port", done => {
+  var channel = new MessageChannel();
+  var anotherChannel = new MessageChannel();
+  var port1 = channel.port1;
+  var port2 = channel.port2;
+
+  port2.onmessage = function (e) {
+    expect(e.data).toEqual("hello");
+    expect(e.ports).toHaveLength(1);
+    expect(e.ports[0]).toBeInstanceOf(MessagePort);
+    done();
+  };
+
+  port1.postMessage("hello", [anotherChannel.port2]);
+});
+
+test("tranfer array buffer", done => {
+  var channel = new MessageChannel();
+  var port1 = channel.port1;
+  var port2 = channel.port2;
+
+  port2.onmessage = function (e) {
+    expect(e.data).toBeInstanceOf(ArrayBuffer);
+    expect(e.data.byteLength).toEqual(8);
+    done();
+  };
+
+  const buffer = new ArrayBuffer(8);
+
+  port1.postMessage(buffer, [buffer]);
+});
+
+test("non-transferable", () => {
+  var channel = new MessageChannel();
+  channel.port2.onmessage = function (e) {
+    // not reached
+    expect(1).toBe(2);
+  };
+  expect(() => {
+    channel.port1.postMessage("hello", [channel.port1]);
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("hello", [channel.port2]);
+  }).toThrow();
+});
+
+test("transfer message ports and post messages", done => {
+  var c1 = new MessageChannel();
+  var c2 = new MessageChannel();
+
+  c1.port1.onmessage = e => {
+    var port = e.ports[0];
+    expect(port).toBeInstanceOf(MessagePort);
+    expect(e.data).toEqual("hello from channel 1 port 2");
+    port.onmessage = e => {
+      expect(e.data).toEqual("hello from channel 1 port 2");
+      done();
+    };
+    port.postMessage("hello from channel 1 port 1", [c1.port1]);
+  };
+
+  c1.port2.onmessage = e => {
+    var port = e.ports[0];
+    expect(port).toBeInstanceOf(MessagePort);
+    expect(e.data).toEqual("hello from channel 2 port 1");
+    port.postMessage("hello from channel 1 port 2");
+  };
+
+  c2.port1.onmessage = e => {
+    var port = e.ports[0];
+    expect(port).toBeInstanceOf(MessagePort);
+    expect(e.data).toEqual("hello from channel 1 port 1");
+    port.postMessage("hello from channel 2 port 1", [c2.port1]);
+  };
+
+  c2.port2.onmessage = e => {
+    // should not be reached. onmessage defined in c1.port1 should be called instead
+    expect(1).toBe(2);
+  };
+
+  c1.port2.postMessage("hello from channel 1 port 2", [c2.port2]);
+});
+
+test("message channel created on main thread", done => {
+  var worker = new Worker(new URL("receive-port-worker.js", import.meta.url).href);
+  worker.onerror = e => {
+    expect(1).toBe(2);
+    done();
+  };
+  var channel = new MessageChannel();
+  channel.port1.onmessage = e => {
+    if (e.data === "done!") return done();
+    expect(e.data).toEqual("received port!");
+    channel.port1.postMessage("more message!");
+  };
+  worker.postMessage(channel.port2, { transfer: [channel.port2] });
+});
+
+test("message channel created on other thread", done => {
+  var worker = new Worker(new URL("create-port-worker.js", import.meta.url).href);
+  worker.onerror = e => {
+    expect(1).toBe(2);
+    done();
+  };
+  worker.onmessage = e => {
+    expect(e.data).toBeInstanceOf(MessagePort);
+    var port = e.data;
+    port.onmessage = e => {
+      expect(e.data).toEqual("done!");
+      done();
+    };
+    port.postMessage("hello from main thread");
+  };
+});
+
+test("many message channels", done => {
+  var channel = new MessageChannel();
+  var channel2 = new MessageChannel();
+  var channel3 = new MessageChannel();
+  var channel4 = new MessageChannel();
+
+  channel.port1.postMessage("noport");
+  channel.port1.postMessage("zero ports", []);
+  channel.port1.postMessage("two ports", [channel2.port1, channel2.port2]);
+
+  // Now test various failure cases
+  expect(() => {
+    channel.port1.postMessage("same port", [channel.port1]);
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("entangled port", [channel.port2]);
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("null port", [channel3.port1, null, channel3.port2]);
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("notAPort", [channel3.port1, {}, channel3.port2]);
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("duplicate port", [channel3.port1, channel3.port1]);
+  }).toThrow();
+
+  // Should be OK to send channel3.port1 (should not have been disentangled by the previous failed calls).
+  expect(() => {
+    channel.port1.postMessage("entangled ports", [channel3.port1, channel3.port2]);
+  }).not.toThrow();
+
+  expect(() => {
+    channel.port1.postMessage("notAnArray", "foo");
+  }).toThrow();
+  expect(() => {
+    channel.port1.postMessage("notASequence", [{ length: 3 }]);
+  }).toThrow();
+
+  // Should not crash (we should figure out that the array contains undefined
+  // entries).
+  var largePortArray = [];
+  largePortArray[1234567890] = channel4.port1;
+  expect(() => {
+    channel.port1.postMessage("largeSequence", largePortArray);
+  }).toThrow();
+
+  channel.port1.postMessage("done");
+
+  function testTransfers(done) {
+    var channel0 = new MessageChannel();
+
+    var c1 = new MessageChannel();
+    channel0.port1.postMessage({ id: "send-port", port: c1.port1 }, [c1.port1]);
+    var c2 = new MessageChannel();
+    channel0.port1.postMessage({ id: "send-port-twice", port0: c2.port1, port1: c2.port1 }, [c2.port1]);
+    var c3 = new MessageChannel();
+    channel0.port1.postMessage({ id: "send-two-ports", port0: c3.port1, port1: c3.port2 }, [c3.port1, c3.port2]);
+    var c4 = new MessageChannel();
+
+    // Sending host objects should throw
+    expect(() => {
+      channel0.port1.postMessage({ id: "host-object", hostObject: c3, port: c4.port1 }, [c4.port1]);
+    }).toThrow();
+
+    // Sending Function object should throw
+    expect(() => {
+      var f1 = function () {};
+      channel0.port1.postMessage({ id: "function-object", function: f1, port: c4.port1 }, [c4.port1]);
+    }).toThrow();
+
+    // Sending Error object should not throw
+    // expect(() => {
+    //   var err = new Error();
+    //   channel0.port1.postMessage({ id: "error-object", error: err, port: c4.port1 }, [c4.port1]);
+    // }).not.toThrow();
+
+    c4.port1.postMessage("Should succeed");
+    channel0.port1.postMessage({ id: "done" });
+
+    channel0.port2.onmessage = function (event) {
+      if (event.data.id == "send-port") {
+        expect(event.ports.length).toBeGreaterThan(0);
+        expect(event.ports[0]).toBe(event.data.port);
+      } else if (event.data.id == "error-object") {
+        expect(event.data.error).toBeInstanceOf(Error);
+      } else if (event.data.id == "send-port-twice") {
+        expect(event.ports).toBeDefined();
+        expect(event.ports.length).toBe(1);
+        expect(event.ports[0]).toBe(event.data.port0);
+        expect(event.ports[0]).toBe(event.data.port1);
+      } else if (event.data.id == "send-two-ports") {
+        expect(event.ports).toBeDefined();
+        expect(event.ports.length).toBe(2);
+        expect(event.ports[0]).toBe(event.data.port0);
+        expect(event.ports[1]).toBe(event.data.port1);
+      } else if (event.data.id == "done") {
+        done();
+      } else {
+        // should not be reached
+        expect(1).toBe(2);
+      }
+    };
+  }
+
+  channel.port2.onmessage = function (event) {
+    if (event.data == "noport") {
+      expect(event.ports).toBeDefined();
+      expect(event.ports.length).toBe(0);
+    } else if (event.data == "zero ports") {
+      expect(event.ports).toBeDefined();
+      expect(event.ports.length).toBe(0);
+    } else if (event.data == "two ports") {
+      expect(event.ports).toBeDefined();
+      expect(event.ports.length).toBe(2);
+    } else if (event.data == "entangled ports") {
+      expect(event.ports).toBeDefined();
+      expect(event.ports.length).toBe(2);
+    } else if (event.data == "done") {
+      testTransfers(done);
+    } else {
+      // should not be reached
+      expect(1).toBe(2);
+    }
+  };
+});
diff --git a/test/js/web/workers/receive-port-worker.js b/test/js/web/workers/receive-port-worker.js
new file mode 100644
index 000000000..871fc4405
--- /dev/null
+++ b/test/js/web/workers/receive-port-worker.js
@@ -0,0 +1,9 @@
+onmessage = e => {
+  if (e.data instanceof MessagePort) {
+    var port = e.data;
+    port.onmessage = e => {
+      port.postMessage("done!");
+    };
+    port.postMessage("received port!");
+  }
+};
diff --git a/test/js/web/workers/structured-clone.test.ts b/test/js/web/workers/structured-clone.test.ts
index 61a0c1320..bdc7fcfea 100644
--- a/test/js/web/workers/structured-clone.test.ts
+++ b/test/js/web/workers/structured-clone.test.ts
@@ -183,7 +183,7 @@ describe("structured clone", () => {
     });
   });
 
-  describe("transferrables", () => {
+  describe("transferables", () => {
     test("ArrayBuffer", () => {
       const buffer = Uint8Array.from([1]).buffer;
       const cloned = structuredClone(buffer, { transfer: [buffer] });