diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 5152cc8c4d5708..16787723c6e57e 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -70,6 +70,30 @@ if (isMainThread) {
 }
 ```
 
+## worker.moveMessagePortToContext(port, contextifiedSandbox)
+<!-- YAML
+added: REPLACEME
+-->
+
+* `port` {MessagePort} The message port which will be transferred.
+* `contextifiedSandbox` {Object} A [contextified][] object as returned by the
+  `vm.createContext()` method.
+
+* Returns: {MessagePort}
+
+Transfer a `MessagePort` to a different [`vm`][] Context. The original `port`
+object will be rendered unusable, and the returned `MessagePort` instance will
+take its place.
+
+The returned `MessagePort` will be an object in the target context, and will
+inherit from its global `Object` class. Objects passed to the
+[`port.onmessage()`][] listener will also be created in the target context
+and inherit from its global `Object` class.
+
+However, the created `MessagePort` will no longer inherit from
+[`EventEmitter`][], and only [`port.onmessage()`][] can be used to receive
+events using it.
+
 ## worker.parentPort
 <!-- YAML
 added: v10.5.0
@@ -583,6 +607,7 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`Worker`]: #worker_threads_class_worker
 [`cluster` module]: cluster.html
 [`port.on('message')`]: #worker_threads_event_message
+[`port.onmessage()`]: https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/onmessage
 [`port.postMessage()`]: #worker_threads_port_postmessage_value_transferlist
 [`process.abort()`]: process.html#process_process_abort
 [`process.chdir()`]: process.html#process_process_chdir_directory
@@ -600,6 +625,7 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`require('worker_threads').threadId`]: #worker_threads_worker_threadid
 [`require('worker_threads').workerData`]: #worker_threads_worker_workerdata
 [`trace_events`]: tracing.html
+[`vm`]: vm.html
 [`worker.on('message')`]: #worker_threads_event_message_1
 [`worker.postMessage()`]: #worker_threads_worker_postmessage_value_transferlist
 [`worker.terminate()`]: #worker_threads_worker_terminate_callback
@@ -610,4 +636,5 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [Web Workers]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
 [browser `MessagePort`]: https://developer.mozilla.org/en-US/docs/Web/API/MessagePort
 [child processes]: child_process.html
+[contextified]: vm.html#vm_what_does_it_mean_to_contextify_an_object
 [v8.serdes]: v8.html#v8_serialization_api
diff --git a/lib/internal/bootstrap/cache.js b/lib/internal/bootstrap/cache.js
index 3840d7ee255335..1b07fa5a81dba2 100644
--- a/lib/internal/bootstrap/cache.js
+++ b/lib/internal/bootstrap/cache.js
@@ -20,10 +20,12 @@ const cannotBeRequired = [
 
   'internal/test/binding',
 
-  'internal/bootstrap/context',
   'internal/bootstrap/primordials',
   'internal/bootstrap/loaders',
-  'internal/bootstrap/node'
+  'internal/bootstrap/node',
+
+  'internal/per_context/setup',
+  'internal/per_context/domexception',
 ];
 
 // Skip modules that cannot be required when they are not
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 0bd1a3f363469a..f8cddb3153ed20 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -214,8 +214,6 @@ if (!config.noBrowserGlobals) {
   defineOperation(global, 'setImmediate', timers.setImmediate);
 }
 
-setupDOMException();
-
 // process.allowedNodeEnvironmentFlags
 Object.defineProperty(process, 'allowedNodeEnvironmentFlags', {
   get() {
@@ -394,13 +392,6 @@ function createGlobalConsole(consoleFromVM) {
   return consoleFromNode;
 }
 
-function setupDOMException() {
-  // Registers the constructor with C++.
-  const DOMException = NativeModule.require('internal/domexception');
-  const { registerDOMException } = internalBinding('messaging');
-  registerDOMException(DOMException);
-}
-
 // https://heycam.github.io/webidl/#es-namespaces
 function exposeNamespace(target, name, namespaceObject) {
   Object.defineProperty(target, name, {
diff --git a/lib/internal/domexception.js b/lib/internal/per_context/domexception.js
similarity index 93%
rename from lib/internal/domexception.js
rename to lib/internal/per_context/domexception.js
index 9845919e498dae..795acf76c09303 100644
--- a/lib/internal/domexception.js
+++ b/lib/internal/per_context/domexception.js
@@ -1,6 +1,12 @@
 'use strict';
 
-const { ERR_INVALID_THIS } = require('internal/errors').codes;
+class ERR_INVALID_THIS extends TypeError {
+  constructor(type) {
+    super('Value of "this" must be of ' + type);
+  }
+
+  get code() { return 'ERR_INVALID_THIS'; }
+}
 
 const internalsMap = new WeakMap();
 
@@ -83,4 +89,4 @@ for (const [name, codeName, value] of [
   nameToCodeMap.set(name, value);
 }
 
-module.exports = DOMException;
+exports.DOMException = DOMException;
diff --git a/lib/internal/bootstrap/context.js b/lib/internal/per_context/setup.js
similarity index 100%
rename from lib/internal/bootstrap/context.js
rename to lib/internal/per_context/setup.js
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 387dc9df74efed..2f1352fdf910b8 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -8,6 +8,7 @@ const {
   MessagePort,
   MessageChannel,
   drainMessagePort,
+  moveMessagePortToContext,
   stopMessagePort
 } = internalBinding('messaging');
 const { threadId } = internalBinding('worker');
@@ -233,6 +234,7 @@ module.exports = {
   kIncrementsPortRef,
   kWaitingStreams,
   kStdioWantsMoreDataCallback,
+  moveMessagePortToContext,
   MessagePort,
   MessageChannel,
   setupPortReferencing,
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index 2fe1a872464d19..722e47caf1092f 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -8,13 +8,15 @@ const {
 
 const {
   MessagePort,
-  MessageChannel
+  MessageChannel,
+  moveMessagePortToContext,
 } = require('internal/worker/io');
 
 module.exports = {
   isMainThread,
   MessagePort,
   MessageChannel,
+  moveMessagePortToContext,
   threadId,
   Worker,
   parentPort: null,
diff --git a/node.gyp b/node.gyp
index 1c7484378fbf5c..0c6aee7f80445c 100644
--- a/node.gyp
+++ b/node.gyp
@@ -26,12 +26,13 @@
     'node_lib_target_name%': 'node_lib',
     'node_intermediate_lib_type%': 'static_library',
     'library_files': [
-      'lib/internal/bootstrap/context.js',
       'lib/internal/bootstrap/primordials.js',
       'lib/internal/bootstrap/cache.js',
       'lib/internal/bootstrap/loaders.js',
       'lib/internal/bootstrap/node.js',
       'lib/internal/bootstrap/pre_execution.js',
+      'lib/internal/per_context/setup.js',
+      'lib/internal/per_context/domexception.js',
       'lib/async_hooks.js',
       'lib/assert.js',
       'lib/buffer.js',
@@ -115,7 +116,6 @@
       'lib/internal/dgram.js',
       'lib/internal/dns/promises.js',
       'lib/internal/dns/utils.js',
-      'lib/internal/domexception.js',
       'lib/internal/dtrace.js',
       'lib/internal/encoding.js',
       'lib/internal/errors.js',
diff --git a/src/api/environment.cc b/src/api/environment.cc
index 9b8e4686852811..6e3c61fac16de5 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -15,6 +15,7 @@
 
 namespace node {
 using v8::Context;
+using v8::EscapableHandleScope;
 using v8::Function;
 using v8::HandleScope;
 using v8::Isolate;
@@ -22,7 +23,9 @@ using v8::Local;
 using v8::MaybeLocal;
 using v8::Message;
 using v8::MicrotasksPolicy;
+using v8::Object;
 using v8::ObjectTemplate;
+using v8::Private;
 using v8::String;
 using v8::Value;
 
@@ -279,6 +282,26 @@ void FreePlatform(MultiIsolatePlatform* platform) {
   delete platform;
 }
 
+MaybeLocal<Object> GetPerContextExports(Local<Context> context) {
+  Isolate* isolate = context->GetIsolate();
+  EscapableHandleScope handle_scope(isolate);
+
+  Local<Object> global = context->Global();
+  Local<Private> key = Private::ForApi(isolate,
+      FIXED_ONE_BYTE_STRING(isolate, "node:per_context_binding_exports"));
+
+  Local<Value> existing_value;
+  if (!global->GetPrivate(context, key).ToLocal(&existing_value))
+    return MaybeLocal<Object>();
+  if (existing_value->IsObject())
+    return handle_scope.Escape(existing_value.As<Object>());
+
+  Local<Object> exports = Object::New(isolate);
+  if (context->Global()->SetPrivate(context, key, exports).IsNothing())
+    return MaybeLocal<Object>();
+  return handle_scope.Escape(exports);
+}
+
 Local<Context> NewContext(Isolate* isolate,
                           Local<ObjectTemplate> object_template) {
   auto context = Context::New(isolate, nullptr, object_template);
@@ -289,25 +312,42 @@ Local<Context> NewContext(Isolate* isolate,
                            True(isolate));
 
   {
-    // Run lib/internal/bootstrap/context.js
+    // Run per-context JS files.
     Context::Scope context_scope(context);
-
-    std::vector<Local<String>> parameters = {
-        FIXED_ONE_BYTE_STRING(isolate, "global")};
-    Local<Value> arguments[] = {context->Global()};
-    MaybeLocal<Function> maybe_fn =
-        per_process::native_module_loader.LookupAndCompile(
-            context, "internal/bootstrap/context", &parameters, nullptr);
-    if (maybe_fn.IsEmpty()) {
-      return Local<Context>();
-    }
-    Local<Function> fn = maybe_fn.ToLocalChecked();
-    MaybeLocal<Value> result =
-        fn->Call(context, Undefined(isolate), arraysize(arguments), arguments);
-    // Execution failed during context creation.
-    // TODO(joyeecheung): deprecate this signature and return a MaybeLocal.
-    if (result.IsEmpty()) {
+    Local<Object> exports;
+    if (!GetPerContextExports(context).ToLocal(&exports))
       return Local<Context>();
+
+    Local<String> global_string = FIXED_ONE_BYTE_STRING(isolate, "global");
+    Local<String> exports_string = FIXED_ONE_BYTE_STRING(isolate, "exports");
+
+    static const char* context_files[] = {
+      "internal/per_context/setup",
+      "internal/per_context/domexception",
+      nullptr
+    };
+
+    for (const char** module = context_files; *module != nullptr; module++) {
+      std::vector<Local<String>> parameters = {
+        global_string,
+        exports_string
+      };
+      Local<Value> arguments[] = {context->Global(), exports};
+      MaybeLocal<Function> maybe_fn =
+          per_process::native_module_loader.LookupAndCompile(
+              context, *module, &parameters, nullptr);
+      if (maybe_fn.IsEmpty()) {
+        return Local<Context>();
+      }
+      Local<Function> fn = maybe_fn.ToLocalChecked();
+      MaybeLocal<Value> result =
+          fn->Call(context, Undefined(isolate),
+                   arraysize(arguments), arguments);
+      // Execution failed during context creation.
+      // TODO(joyeecheung): deprecate this signature and return a MaybeLocal.
+      if (result.IsEmpty()) {
+        return Local<Context>();
+      }
     }
   }
 
diff --git a/src/node_internals.h b/src/node_internals.h
index d2eadf510947db..bc6a36d9db4a21 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -296,6 +296,8 @@ void DefineZlibConstants(v8::Local<v8::Object> target);
 v8::MaybeLocal<v8::Value> RunBootstrapping(Environment* env);
 v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
                                          const char* main_script_id);
+v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
+
 namespace profiler {
 void StartCoverageCollection(Environment* env);
 }
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index e6e7f743de27ad..ace875a1d3122b 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -2,11 +2,13 @@
 
 #include "async_wrap-inl.h"
 #include "debug_utils.h"
+#include "node_contextify.h"
 #include "node_buffer.h"
 #include "node_errors.h"
 #include "node_process.h"
 #include "util.h"
 
+using node::contextify::ContextifyContext;
 using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferCreationMode;
@@ -177,19 +179,30 @@ uint32_t Message::AddWASMModule(WasmCompiledModule::TransferrableModule&& mod) {
 
 namespace {
 
-void ThrowDataCloneException(Environment* env, Local<String> message) {
+void ThrowDataCloneException(Local<Context> context, Local<String> message) {
+  Isolate* isolate = context->GetIsolate();
   Local<Value> argv[] = {
     message,
-    FIXED_ONE_BYTE_STRING(env->isolate(), "DataCloneError")
+    FIXED_ONE_BYTE_STRING(isolate, "DataCloneError")
   };
   Local<Value> exception;
-  Local<Function> domexception_ctor = env->domexception_function();
-  CHECK(!domexception_ctor.IsEmpty());
-  if (!domexception_ctor->NewInstance(env->context(), arraysize(argv), argv)
+
+  Local<Object> per_context_bindings;
+  Local<Value> domexception_ctor_val;
+  if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
+      !per_context_bindings->Get(context,
+                                FIXED_ONE_BYTE_STRING(isolate, "DOMException"))
+          .ToLocal(&domexception_ctor_val)) {
+    return;
+  }
+
+  CHECK(domexception_ctor_val->IsFunction());
+  Local<Function> domexception_ctor = domexception_ctor_val.As<Function>();
+  if (!domexception_ctor->NewInstance(context, arraysize(argv), argv)
           .ToLocal(&exception)) {
     return;
   }
-  env->isolate()->ThrowException(exception);
+  isolate->ThrowException(exception);
 }
 
 // This tells V8 how to serialize objects that it does not understand
@@ -201,7 +214,7 @@ class SerializerDelegate : public ValueSerializer::Delegate {
       : env_(env), context_(context), msg_(m) {}
 
   void ThrowDataCloneError(Local<String> message) override {
-    ThrowDataCloneException(env_, message);
+    ThrowDataCloneException(context_, message);
   }
 
   Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {
@@ -309,7 +322,7 @@ Maybe<bool> Message::Serialize(Environment* env,
         if (std::find(array_buffers.begin(), array_buffers.end(), ab) !=
             array_buffers.end()) {
           ThrowDataCloneException(
-              env,
+              context,
               FIXED_ONE_BYTE_STRING(
                   env->isolate(),
                   "Transfer list contains duplicate ArrayBuffer"));
@@ -326,7 +339,7 @@ Maybe<bool> Message::Serialize(Environment* env,
         // Check if the source MessagePort is being transferred.
         if (!source_port.IsEmpty() && entry == source_port) {
           ThrowDataCloneException(
-              env,
+              context,
               FIXED_ONE_BYTE_STRING(env->isolate(),
                                     "Transfer list contains source port"));
           return Nothing<bool>();
@@ -334,7 +347,7 @@ Maybe<bool> Message::Serialize(Environment* env,
         MessagePort* port = Unwrap<MessagePort>(entry.As<Object>());
         if (port == nullptr || port->IsDetached()) {
           ThrowDataCloneException(
-              env,
+              context,
               FIXED_ONE_BYTE_STRING(
                   env->isolate(),
                   "MessagePort in transfer list is already detached"));
@@ -343,7 +356,7 @@ Maybe<bool> Message::Serialize(Environment* env,
         if (std::find(delegate.ports_.begin(), delegate.ports_.end(), port) !=
             delegate.ports_.end()) {
           ThrowDataCloneException(
-              env,
+              context,
               FIXED_ONE_BYTE_STRING(
                   env->isolate(),
                   "Transfer list contains duplicate MessagePort"));
@@ -749,6 +762,35 @@ void MessagePort::Drain(const FunctionCallbackInfo<Value>& args) {
   port->OnMessage();
 }
 
+void MessagePort::MoveToContext(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  if (!args[0]->IsObject() ||
+      !env->message_port_constructor_template()->HasInstance(args[0])) {
+    return THROW_ERR_INVALID_ARG_TYPE(env,
+        "First argument needs to be a MessagePort instance");
+  }
+  MessagePort* port = Unwrap<MessagePort>(args[0].As<Object>());
+  CHECK_NOT_NULL(port);
+
+  Local<Value> context_arg = args[1];
+  ContextifyContext* context_wrapper;
+  if (!context_arg->IsObject() ||
+      (context_wrapper = ContextifyContext::ContextFromContextifiedSandbox(
+          env, context_arg.As<Object>())) == nullptr) {
+    return THROW_ERR_INVALID_ARG_TYPE(env, "Invalid context argument");
+  }
+
+  std::unique_ptr<MessagePortData> data;
+  if (!port->IsDetached())
+    data = port->Detach();
+
+  Context::Scope context_scope(context_wrapper->context());
+  MessagePort* target =
+      MessagePort::New(env, context_wrapper->context(), std::move(data));
+  if (target != nullptr)
+    args.GetReturnValue().Set(target->object());
+}
+
 void MessagePort::Entangle(MessagePort* a, MessagePort* b) {
   Entangle(a, b->data_.get());
 }
@@ -805,19 +847,12 @@ static void MessageChannel(const FunctionCallbackInfo<Value>& args) {
   MessagePort* port2 = MessagePort::New(env, context);
   MessagePort::Entangle(port1, port2);
 
-  args.This()->Set(env->context(), env->port1_string(), port1->object())
+  args.This()->Set(context, env->port1_string(), port1->object())
       .FromJust();
-  args.This()->Set(env->context(), env->port2_string(), port2->object())
+  args.This()->Set(context, env->port2_string(), port2->object())
       .FromJust();
 }
 
-static void RegisterDOMException(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK_EQ(args.Length(), 1);
-  CHECK(args[0]->IsFunction());
-  env->set_domexception_function(args[0].As<Function>());
-}
-
 static void InitMessaging(Local<Object> target,
                           Local<Value> unused,
                           Local<Context> context,
@@ -829,7 +864,7 @@ static void InitMessaging(Local<Object> target,
         FIXED_ONE_BYTE_STRING(env->isolate(), "MessageChannel");
     Local<FunctionTemplate> templ = env->NewFunctionTemplate(MessageChannel);
     templ->SetClassName(message_channel_string);
-    target->Set(env->context(),
+    target->Set(context,
                 message_channel_string,
                 templ->GetFunction(context).ToLocalChecked()).FromJust();
   }
@@ -839,12 +874,12 @@ static void InitMessaging(Local<Object> target,
               GetMessagePortConstructor(env, context).ToLocalChecked())
                   .FromJust();
 
-  env->SetMethod(target, "registerDOMException", RegisterDOMException);
-
   // These are not methods on the MessagePort prototype, because
   // the browser equivalents do not provide them.
   env->SetMethod(target, "stopMessagePort", MessagePort::Stop);
   env->SetMethod(target, "drainMessagePort", MessagePort::Drain);
+  env->SetMethod(target, "moveMessagePortToContext",
+                 MessagePort::MoveToContext);
 }
 
 }  // anonymous namespace
diff --git a/src/node_messaging.h b/src/node_messaging.h
index 282ad93468d95f..20b89c5bfe80c2 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -158,12 +158,17 @@ class MessagePort : public HandleWrap {
   // Stop processing messages on this port as a receiving end.
   void Stop();
 
+  /* constructor */
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  /* prototype methods */
   static void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+  /* static */
+  static void MoveToContext(const v8::FunctionCallbackInfo<v8::Value>& args);
+
   // Turns `a` and `b` into siblings, i.e. connects the sending side of one
   // to the receiving side of the other. This is not thread-safe.
   static void Entangle(MessagePort* a, MessagePort* b);
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index efae4725cf706d..e65098b92295bc 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -17,7 +17,6 @@ const expectedModules = new Set([
   'Internal Binding credentials',
   'Internal Binding fs',
   'Internal Binding inspector',
-  'Internal Binding messaging',
   'Internal Binding module_wrap',
   'Internal Binding native_module',
   'Internal Binding options',
@@ -38,7 +37,6 @@ const expectedModules = new Set([
   'NativeModule internal/console/constructor',
   'NativeModule internal/console/global',
   'NativeModule internal/constants',
-  'NativeModule internal/domexception',
   'NativeModule internal/encoding',
   'NativeModule internal/errors',
   'NativeModule internal/fixed_queue',
@@ -74,6 +72,7 @@ if (common.isMainThread) {
   expectedModules.add('NativeModule internal/process/stdio');
 } else {
   expectedModules.add('Internal Binding heap_utils');
+  expectedModules.add('Internal Binding messaging');
   expectedModules.add('Internal Binding serdes');
   expectedModules.add('Internal Binding stream_wrap');
   expectedModules.add('Internal Binding symbols');
diff --git a/test/parallel/test-worker-message-port-move.js b/test/parallel/test-worker-message-port-move.js
new file mode 100644
index 00000000000000..65082139776683
--- /dev/null
+++ b/test/parallel/test-worker-message-port-move.js
@@ -0,0 +1,69 @@
+/* global port */
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const {
+  MessagePort, MessageChannel, moveMessagePortToContext
+} = require('worker_threads');
+
+const context = vm.createContext();
+const { port1, port2 } = new MessageChannel();
+context.port = moveMessagePortToContext(port1, context);
+context.global = context;
+Object.assign(context, {
+  global: context,
+  assert,
+  MessagePort,
+  MessageChannel
+});
+
+vm.runInContext('(' + function() {
+  {
+    assert(port.postMessage instanceof Function);
+    assert(port.constructor instanceof Function);
+    for (let obj = port; obj !== null; obj = Object.getPrototypeOf(obj)) {
+      for (const key of Object.getOwnPropertyNames(obj)) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+          assert(obj[key] instanceof Object);
+        } else if (typeof obj[key] === 'function') {
+          assert(obj[key] instanceof Function);
+        }
+      }
+    }
+
+    assert(!(port instanceof MessagePort));
+    assert.strictEqual(port.onmessage, undefined);
+    port.onmessage = function({ data }) {
+      assert(data instanceof Object);
+      port.postMessage(data);
+    };
+    port.start();
+  }
+
+  {
+    let threw = false;
+    try {
+      port.postMessage(global);
+    } catch (e) {
+      assert.strictEqual(e.constructor.name, 'DOMException');
+      assert(e instanceof Object);
+      assert(e instanceof Error);
+      threw = true;
+    }
+    assert(threw);
+  }
+
+  {
+    const newDummyPort = new (port.constructor)();
+    assert(!(newDummyPort instanceof MessagePort));
+    assert(newDummyPort.close instanceof Function);
+    newDummyPort.close();
+  }
+} + ')()', context);
+
+port2.on('message', common.mustCall((msg) => {
+  assert(msg instanceof Object);
+  port2.close();
+}));
+port2.postMessage({});
diff --git a/test/wpt/test-url.js b/test/wpt/test-url.js
index 8734452940e84e..4b909988ddb5ee 100644
--- a/test/wpt/test-url.js
+++ b/test/wpt/test-url.js
@@ -3,6 +3,7 @@
 // Flags: --expose-internals
 
 require('../common');
+const assert = require('assert');
 const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('url');
@@ -10,9 +11,22 @@ const runner = new WPTRunner('url');
 // Copy global descriptors from the global object
 runner.copyGlobalsFromObject(global, ['URL', 'URLSearchParams']);
 // Needed by urlsearchparams-constructor.any.js
+let DOMException;
 runner.defineGlobal('DOMException', {
   get() {
-    return require('internal/domexception');
+    // A 'hack' to get the DOMException constructor since we don't have it
+    // on the global object.
+    if (DOMException === undefined) {
+      const port = new (require('worker_threads').MessagePort)();
+      const ab = new ArrayBuffer(1);
+      try {
+        port.postMessage(ab, [ab, ab]);
+      } catch (err) {
+        DOMException = err.constructor;
+      }
+      assert.strictEqual(DOMException.name, 'DOMException');
+    }
+    return DOMException;
   }
 });