diff --git a/system/include/emscripten/bind.h b/system/include/emscripten/bind.h
index 9bceabd53481e..a787a92fdd4f2 100644
--- a/system/include/emscripten/bind.h
+++ b/system/include/emscripten/bind.h
@@ -283,181 +283,6 @@ struct InitFunc {
 
 } // end namespace internal
 
-////////////////////////////////////////////////////////////////////////////////
-// POLICIES
-////////////////////////////////////////////////////////////////////////////////
-
-template<int Index>
-struct arg {
-    static constexpr int index = Index + 1;
-};
-
-struct ret_val {
-    static constexpr int index = 0;
-};
-
-/*
-template<typename Slot>
-struct allow_raw_pointer {
-    template<typename InputType, int Index>
-    struct Transform {
-        typedef typename std::conditional<
-            Index == Slot::index,
-            internal::AllowedRawPointer<typename std::remove_pointer<InputType>::type>,
-            InputType
-        >::type type;
-    };
-};
-*/
-
-// allow all raw pointers
-struct allow_raw_pointers {
-    template<typename InputType, int Index>
-    struct Transform {
-        // Use decay to handle references to pointers e.g.(T*&)->(T*).
-        typedef typename std::decay<InputType>::type DecayedType;
-        typedef typename std::conditional<
-            std::is_pointer<DecayedType>::value,
-            internal::AllowedRawPointer<typename std::remove_pointer<DecayedType>::type>,
-            InputType
-        >::type type;
-    };
-};
-
-// this is temporary until arg policies are reworked
-template<typename Slot>
-struct allow_raw_pointer : public allow_raw_pointers {
-};
-
-struct async {
-    template<typename InputType, int Index>
-    struct Transform {
-        typedef InputType type;
-    };
-};
-
-struct pure_virtual {
-    template<typename InputType, int Index>
-    struct Transform {
-        typedef InputType type;
-    };
-};
-
-template<typename Slot>
-struct nonnull {
-    static_assert(std::is_same<Slot, ret_val>::value, "Only nonnull return values are currently supported.");
-    template<typename InputType, int Index>
-    struct Transform {
-        typedef InputType type;
-    };
-};
-
-namespace return_value_policy {
-
-struct take_ownership : public allow_raw_pointers {};
-struct reference : public allow_raw_pointers {};
-
-} // end namespace return_value_policy
-
-namespace internal {
-
-#if __cplusplus >= 201703L
-template <typename... Args> using conjunction = std::conjunction<Args...>;
-template <typename... Args> using disjunction = std::disjunction<Args...>;
-#else
-// Helper available in C++14.
-template <bool _Test, class _T1, class _T2>
-using conditional_t = typename std::conditional<_Test, _T1, _T2>::type;
-
-template<class...> struct conjunction : std::true_type {};
-template<class B1> struct conjunction<B1> : B1 {};
-template<class B1, class... Bn>
-struct conjunction<B1, Bn...>
-    : conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
-
-template<class...> struct disjunction : std::false_type {};
-template<class B1> struct disjunction<B1> : B1 {};
-template<class B1, class... Bn>
-struct disjunction<B1, Bn...>
-    : conditional_t<bool(B1::value), disjunction<Bn...>, B1> {};
-#endif
-
-template<typename... Policies>
-struct isPolicy;
-
-template<typename... Rest>
-struct isPolicy<return_value_policy::take_ownership, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename... Rest>
-struct isPolicy<return_value_policy::reference, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename... Rest>
-struct isPolicy<emscripten::async, Rest...> {
-    static constexpr bool value = true;
-};
-
-template <typename T, typename... Rest>
-struct isPolicy<emscripten::allow_raw_pointer<T>, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename... Rest>
-struct isPolicy<allow_raw_pointers, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename... Rest>
-struct isPolicy<emscripten::pure_virtual, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename T, typename... Rest>
-struct isPolicy<emscripten::nonnull<T>, Rest...> {
-    static constexpr bool value = true;
-};
-
-template<typename T, typename... Rest>
-struct isPolicy<T, Rest...> {
-    static constexpr bool value = isPolicy<Rest...>::value;
-};
-
-template<>
-struct isPolicy<> {
-    static constexpr bool value = false;
-};
-
-template<typename ReturnType, typename... Rest>
-struct GetReturnValuePolicy {
-    using tag = rvp::default_tag;
-};
-
-template<typename ReturnType, typename... Rest>
-struct GetReturnValuePolicy<ReturnType, return_value_policy::take_ownership, Rest...> {
-    using tag = rvp::take_ownership;
-};
-
-template<typename ReturnType, typename... Rest>
-struct GetReturnValuePolicy<ReturnType, return_value_policy::reference, Rest...> {
-    using tag = rvp::reference;
-};
-
-template<typename ReturnType, typename T, typename... Rest>
-struct GetReturnValuePolicy<ReturnType, T, Rest...> {
-    using tag = GetReturnValuePolicy<ReturnType, Rest...>::tag;
-};
-
-template<typename... Policies>
-using isAsync = disjunction<std::is_same<async, Policies>...>;
-
-template<typename... Policies>
-using isNonnullReturn = disjunction<std::is_same<nonnull<ret_val>, Policies>...>;
-
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // select_overload and select_const
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/system/include/emscripten/val.h b/system/include/emscripten/val.h
index a57c11a944bc5..32c1c4c214f4d 100644
--- a/system/include/emscripten/val.h
+++ b/system/include/emscripten/val.h
@@ -345,7 +345,7 @@ class EMBIND_VISIBILITY_DEFAULT val {
   explicit val(T&& value, Policies...) {
     using namespace internal;
 
-    new (this) val(internalCall<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, val>(nullptr, nullptr, std::forward<T>(value)));
+    new (this) val(internalCallWithPolicy<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, val>(nullptr, nullptr, std::forward<T>(value)));
   }
 
   val() : val(EM_VAL(internal::_EMVAL_UNDEFINED)) {}
@@ -492,28 +492,28 @@ class EMBIND_VISIBILITY_DEFAULT val {
   val new_(Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::CONSTRUCTOR, WithPolicies<>, val>(as_handle(), nullptr, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::CONSTRUCTOR, val>(as_handle(), nullptr, std::forward<Args>(args)...);
   }
 
   template<typename... Args>
   val operator()(Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::FUNCTION, WithPolicies<>, val>(as_handle(), nullptr, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::FUNCTION, val>(as_handle(), nullptr, std::forward<Args>(args)...);
   }
 
   template<typename ReturnValue, typename... Args>
   ReturnValue call(const char* name, Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::METHOD, WithPolicies<>, ReturnValue>(as_handle(), name, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::METHOD, ReturnValue>(as_handle(), name, std::forward<Args>(args)...);
   }
 
   template<typename T, typename ...Policies>
   T as(Policies...) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, T>(as_handle(), nullptr, *this);
+    return internalCallWithPolicy<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, T>(as_handle(), nullptr, *this);
   }
 
 // Prefer calling val::typeOf() over val::typeof(), since this form works in both C++11 and GNU++11 build modes. "typeof" is a reserved word in GNU++11 extensions.
@@ -573,8 +573,27 @@ class EMBIND_VISIBILITY_DEFAULT val {
   template<typename WrapperType>
   friend val internal::wrapped_extend(const std::string& , const val& );
 
-  template<internal::EM_INVOKER_KIND Kind, typename Policy, typename Ret, typename... Args>
+  template<internal::EM_INVOKER_KIND Kind, typename Ret, typename... Args>
   static Ret internalCall(EM_VAL handle, const char *methodName, Args&&... args) {
+    using namespace internal;
+#if __cplusplus >= 201703L
+    using Policy = WithPolicies<FilterTypes<isPolicy, Args...>>;
+    auto filteredArgs = Filter<isNotPolicy>(args...);
+    return std::apply(
+        [&](auto&&... filteredArgs) {
+          return internalCallWithPolicy<Kind, Policy, Ret>(handle, methodName, std::forward<decltype(filteredArgs)>(filteredArgs)...);
+        },
+        filteredArgs
+    );
+#else
+    // When std::apply is not available allow pointers by default. std::apply
+    // could be polyfilled, but it requires a lot of code.
+    return internalCallWithPolicy<Kind, WithPolicies<allow_raw_pointers>, Ret>(handle, methodName, std::forward<decltype(args)>(args)...);
+#endif
+  }
+
+  template<internal::EM_INVOKER_KIND Kind, typename Policy, typename Ret, typename... Args>
+  static Ret internalCallWithPolicy(EM_VAL handle, const char *methodName, Args&&... args) {
     static_assert(!std::is_lvalue_reference<Ret>::value,
                   "Cannot create a lvalue reference out of a JS value.");
 
diff --git a/system/include/emscripten/wire.h b/system/include/emscripten/wire.h
index 33cf72eafbbbe..aa993e806a5f1 100644
--- a/system/include/emscripten/wire.h
+++ b/system/include/emscripten/wire.h
@@ -265,6 +265,9 @@ struct WithPolicies {
     };
 };
 
+template<typename... Policies>
+struct WithPolicies<std::tuple<Policies...>> : WithPolicies<Policies...> {};
+
 // BindingType<T>
 
 // The second typename is an unused stub so it's possible to
@@ -492,6 +495,214 @@ struct BindingType<memory_view<ElementType>> {
     }
 };
 
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// POLICIES
+////////////////////////////////////////////////////////////////////////////////
+
+template<int Index>
+struct arg {
+    static constexpr int index = Index + 1;
+};
+
+struct ret_val {
+    static constexpr int index = 0;
+};
+
+/*
+template<typename Slot>
+struct allow_raw_pointer {
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef typename std::conditional<
+            Index == Slot::index,
+            internal::AllowedRawPointer<typename std::remove_pointer<InputType>::type>,
+            InputType
+        >::type type;
+    };
+};
+*/
+
+// allow all raw pointers
+struct allow_raw_pointers {
+    template<typename InputType, int Index>
+    struct Transform {
+        // Use decay to handle references to pointers e.g.(T*&)->(T*).
+        typedef typename std::decay<InputType>::type DecayedType;
+        typedef typename std::conditional<
+            std::is_pointer<DecayedType>::value,
+            internal::AllowedRawPointer<typename std::remove_pointer<DecayedType>::type>,
+            InputType
+        >::type type;
+    };
+};
+
+// this is temporary until arg policies are reworked
+template<typename Slot>
+struct allow_raw_pointer : public allow_raw_pointers {
+};
+
+struct async {
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef InputType type;
+    };
+};
+
+struct pure_virtual {
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef InputType type;
+    };
+};
+
+template<typename Slot>
+struct nonnull {
+    static_assert(std::is_same<Slot, ret_val>::value, "Only nonnull return values are currently supported.");
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef InputType type;
+    };
+};
+
+namespace return_value_policy {
+
+struct take_ownership : public allow_raw_pointers {};
+struct reference : public allow_raw_pointers {};
+
+} // end namespace return_value_policy
+
+namespace internal {
+
+#if __cplusplus >= 201703L
+template <typename... Args> using conjunction = std::conjunction<Args...>;
+template <typename... Args> using disjunction = std::disjunction<Args...>;
+#else
+// Helper available in C++14.
+template <bool _Test, class _T1, class _T2>
+using conditional_t = typename std::conditional<_Test, _T1, _T2>::type;
+
+template<class...> struct conjunction : std::true_type {};
+template<class B1> struct conjunction<B1> : B1 {};
+template<class B1, class... Bn>
+struct conjunction<B1, Bn...>
+    : conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
+
+template<class...> struct disjunction : std::false_type {};
+template<class B1> struct disjunction<B1> : B1 {};
+template<class B1, class... Bn>
+struct disjunction<B1, Bn...>
+    : conditional_t<bool(B1::value), disjunction<Bn...>, B1> {};
+#endif
+
+template<typename... Policies>
+struct isPolicy;
+
+template<typename... Rest>
+struct isPolicy<return_value_policy::take_ownership, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename... Rest>
+struct isPolicy<return_value_policy::reference, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename... Rest>
+struct isPolicy<emscripten::async, Rest...> {
+    static constexpr bool value = true;
+};
+
+template <typename T, typename... Rest>
+struct isPolicy<emscripten::allow_raw_pointer<T>, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename... Rest>
+struct isPolicy<allow_raw_pointers, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename... Rest>
+struct isPolicy<emscripten::pure_virtual, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename T, typename... Rest>
+struct isPolicy<emscripten::nonnull<T>, Rest...> {
+    static constexpr bool value = true;
+};
+
+template<typename T, typename... Rest>
+struct isPolicy<T, Rest...> {
+    static constexpr bool value = isPolicy<Rest...>::value;
+};
+
+template<>
+struct isPolicy<> {
+    static constexpr bool value = false;
+};
+
+template<typename T>
+struct isNotPolicy {
+    static constexpr bool value = !isPolicy<T>::value;
+};
+
+template<typename ReturnType, typename... Rest>
+struct GetReturnValuePolicy {
+    using tag = rvp::default_tag;
+};
+
+template<typename ReturnType, typename... Rest>
+struct GetReturnValuePolicy<ReturnType, return_value_policy::take_ownership, Rest...> {
+    using tag = rvp::take_ownership;
+};
+
+template<typename ReturnType, typename... Rest>
+struct GetReturnValuePolicy<ReturnType, return_value_policy::reference, Rest...> {
+    using tag = rvp::reference;
+};
+
+template<typename ReturnType, typename T, typename... Rest>
+struct GetReturnValuePolicy<ReturnType, T, Rest...> {
+    using tag = GetReturnValuePolicy<ReturnType, Rest...>::tag;
+};
+
+template<typename... Policies>
+using isAsync = disjunction<std::is_same<async, Policies>...>;
+
+template<typename... Policies>
+using isNonnullReturn = disjunction<std::is_same<nonnull<ret_val>, Policies>...>;
+
+// Build a tuple type that contains all the types where the predicate is true.
+// e.g. FilterTypes<std::is_integral, int, char, float> would return std::tuple<int, char>.
+template <template <class> class Predicate, class... T>
+using FilterTypes = decltype(std::tuple_cat(
+        std::declval<
+            typename std::conditional<
+                Predicate<T>::value,
+                std::tuple<T>,
+                std::tuple<>
+            >::type
+        >()...
+    ));
+
+#if __cplusplus >= 201402L
+// Build a tuple that contains all the args where the predicate is true.
+template<template <class> class Predicate, typename... Args>
+auto Filter(Args&&... args) {
+    return std::tuple_cat(
+        std::get<Predicate<typename std::decay_t<Args>>::value ? 0 : 1>(
+            std::make_tuple(
+                [](auto&& arg) { return std::forward_as_tuple(std::forward<decltype(arg)>(arg)); },
+                [](auto&&) { return std::tuple<>(); }
+            )
+        )(std::forward<Args>(args))...
+    );
+}
+#endif
+
 } // namespace internal
 
 } // namespace emscripten
diff --git a/test/embind/test_embind_no_raw_pointers_val_call.cpp b/test/embind/test_embind_no_raw_pointers_val_call.cpp
new file mode 100644
index 0000000000000..d7d6a91324c3b
--- /dev/null
+++ b/test/embind/test_embind_no_raw_pointers_val_call.cpp
@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global().call<void>("test", x);
+}
diff --git a/test/embind/test_embind_no_raw_pointers_val_invoke.cpp b/test/embind/test_embind_no_raw_pointers_val_invoke.cpp
new file mode 100644
index 0000000000000..7fe6809c9a682
--- /dev/null
+++ b/test/embind/test_embind_no_raw_pointers_val_invoke.cpp
@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global()("test", x);
+}
diff --git a/test/embind/test_embind_no_raw_pointers_val_new.cpp b/test/embind/test_embind_no_raw_pointers_val_new.cpp
new file mode 100644
index 0000000000000..7bd434a1612f2
--- /dev/null
+++ b/test/embind/test_embind_no_raw_pointers_val_new.cpp
@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global().new_(x);
+}
diff --git a/test/embind/test_val.cpp b/test/embind/test_val.cpp
index f64ce66870de7..82d4e44f62fd0 100644
--- a/test/embind/test_val.cpp
+++ b/test/embind/test_val.cpp
@@ -41,6 +41,7 @@ EMSCRIPTEN_BINDINGS(test_bindings) {
 
 int main() {
   printf("start\n");
+  Dummy *dummy;
 
   test("val array()");
   val::global().set("a", val::array());
@@ -408,6 +409,14 @@ int main() {
   ensure_js("a instanceof A");
   ensure_js("a.arg1 == 2");
   ensure_js("a.arg2 == 'b'");
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  val::global().set("a", val::global("A").new_(dummy, val("b"), allow_raw_pointers()));
+  ensure_js("a instanceof A");
+  ensure_js("a.arg1 instanceof Module.Dummy");
+  ensure_js("a.arg2 == 'b'");
+  delete dummy;
+#endif
 
   test("template<typename T> val operator[](const T& key)");
   EM_ASM(
@@ -457,6 +466,11 @@ int main() {
   );
   ensure(val::global("f1")(val(2),val("3")).as<int>() == 2);
   ensure(val::global("f2")(val(2),val("3")).as<string>() == "3");
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  ensure(val::global("f1")(dummy, 42, allow_raw_pointers()).as<Dummy*>(allow_raw_pointers()) == dummy);
+  delete dummy;
+#endif
 
   test("template<typename ReturnValue, typename... Args> ReturnValue call(const char* name, Args&&... args)");
   EM_ASM(
@@ -473,6 +487,18 @@ int main() {
     c = new C;
   );
   ensure(val::global("c").call<int>("method", val(2)) == 2);
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  EM_ASM(
+    globalThis.C = function() {
+      this.method = function(arg) { this.obj = arg; };
+    };
+    c = new C;
+  );
+  val::global("c").call<void>("method", dummy, allow_raw_pointers());
+  ensure_js("c.obj instanceof Module.Dummy");
+  delete dummy;
+#endif
 
   test("template<typename T, typename ...Policies> T as(Policies...)");
   EM_ASM(
@@ -677,7 +703,7 @@ int main() {
   ensure_js("a == '😃 = \U0001F603 is :-D'");
 
   test("val set() with policy");
-  Dummy *dummy = new Dummy();
+  dummy = new Dummy();
   val::global().set("a", dummy, allow_raw_pointers());
   ensure_js("a instanceof Module.Dummy");
   val::global().set("a", val::null());
diff --git a/test/test_other.py b/test/test_other.py
index 141f15e08423e..1becf098678ba 100644
--- a/test/test_other.py
+++ b/test/test_other.py
@@ -3332,6 +3332,9 @@ def test_embind_closure_no_dynamic_execution(self):
     'val_1': ['embind/test_embind_no_raw_pointers_val_1.cpp'],
     'val_2': ['embind/test_embind_no_raw_pointers_val_2.cpp'],
     'val_3': ['embind/test_embind_no_raw_pointers_val_3.cpp'],
+    'val_invoke': ['embind/test_embind_no_raw_pointers_val_invoke.cpp'],
+    'val_call': ['embind/test_embind_no_raw_pointers_val_call.cpp'],
+    'val_new': ['embind/test_embind_no_raw_pointers_val_new.cpp'],
   })
   def test_embind_no_raw_pointers(self, filename):
     stderr = self.expect_fail([EMCC, '-lembind', test_file(filename)])