Current draft standard explicitly states that placement new[] can have a space overhead:
 This overhead may be applied in all array new-expressions, including those referencing the library function

template <class T> constexpr bool Predicate(const T& value) { return value > 0; }

template <class T> constexpr auto F(const T& value) { return sizeof(T); }

template <class T, class... Ts>
constexpr auto foo1(const T& t, const Ts& ...ts) {
   if (Predicate(t)) return F(t);
   if constexpr (sizeof...(ts) > 0) {
       return foo1(ts...);
   }
   // UB here
}

static_assert(foo1(-1, -1.0f, 10, true) == sizeof(int));

template <class... Ts>
constexpr auto foo2(const Ts& ...ts) {
   std::optional<decltype(F(0))> result;

   auto l = [&](const auto& t) {
       if (!result && Predicate(t))
           result = F(t);
   };
   (l(ts), ...);
   
   return result.value();
}

static_assert(foo2(-1, -1.0f, 10, true) == sizeof(int));

template <class... Ts>
constexpr auto foo3(const Ts& ...ts) {
   const void* arg = nullptr;
   std::size_t(*visitor)(const void*) = nullptr;

   ((arg = &ts, visitor = [](const void* arg) { return F(*static_cast<const Ts*>(arg)); }, Predicate(ts)) || ...);

   return visitor(arg);…