diff --git a/src/workerd/jsg/promise.h b/src/workerd/jsg/promise.h
index e00b4c651f5..9c20ba83383 100644
--- a/src/workerd/jsg/promise.h
+++ b/src/workerd/jsg/promise.h
@@ -25,7 +25,26 @@ namespace workerd::jsg {
 template <typename T, bool = isGcVisitable<T>()>
 struct OpaqueWrappable;
 
+// Type tag used to identify OpaqueWrappable<T> types without relying on RTTI/dynamic_cast.
+// We use a unique address per T as a type tag. Alternatively, in theory, we could use
+// an optimization of dynamic_cast where each of the specialized OpaqueWrappable<T> types
+// are marked final, which enables dynamic_cast to just compare vtable pointers. However,
+// there's a bug in LLVM (https://github.com/llvm/llvm-project/issues/71196) that causes
+// this optimization to fail when using thin-LTO, hidden visibility, and shared libraries
+// (which we use for some tests and benchmarks).
+template <typename T>
+struct OpaqueWrappableTypeTag final {
+  inline static const char storage = 0;
+  static const void* get() {
+    return &storage;
+  }
+};
+
 struct OpaqueWrappableBase: public Wrappable {
+  const void* const typeTag;
+
+  explicit OpaqueWrappableBase(const void* tag): typeTag(tag) {}
+
   kj::StringPtr jsgGetMemoryName() const override final {
     return "OpaqueWrappable"_kjc;
   }
@@ -35,10 +54,12 @@ struct OpaqueWrappableBase: public Wrappable {
 };
 
 template <typename T>
-struct OpaqueWrappable<T, false>: public OpaqueWrappableBase {
+struct OpaqueWrappable<T, false> final: public OpaqueWrappableBase {
   // Used to implement wrapOpaque().
 
-  OpaqueWrappable(T&& value): value(kj::mv(value)) {}
+  OpaqueWrappable(T&& value)
+      : OpaqueWrappableBase(OpaqueWrappableTypeTag<T>::get()),
+        value(kj::mv(value)) {}
 
   T value;
   bool movedAway = false;
@@ -49,10 +70,19 @@ struct OpaqueWrappable<T, false>: public OpaqueWrappableBase {
 };
 
 template <typename T>
-struct OpaqueWrappable<T, true>: public OpaqueWrappable<T, false> {
+struct OpaqueWrappable<T, true> final: public OpaqueWrappableBase {
   // When T is GC-visitable, make sure to implement visitation.
 
-  using OpaqueWrappable<T, false>::OpaqueWrappable;
+  OpaqueWrappable(T&& value)
+      : OpaqueWrappableBase(OpaqueWrappableTypeTag<T>::get()),
+        value(kj::mv(value)) {}
+
+  T value;
+  bool movedAway = false;
+
+  size_t jsgGetMemorySelfSize() const override final {
+    return sizeof(OpaqueWrappable);
+  }
 
   void jsgVisitForGc(GcVisitor& visitor) override {
     if (!this->movedAway) {
@@ -95,8 +125,9 @@ T unwrapOpaque(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Local<T>(), "can't opaque-wrap non-persistent handles");
 
   Wrappable& wrappable = KJ_ASSERT_NONNULL(Wrappable::tryUnwrapOpaque(isolate, handle));
-  OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-  KJ_ASSERT(holder != nullptr);
+  auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+  KJ_ASSERT(base->typeTag == OpaqueWrappableTypeTag<T>::get());
+  auto* holder = static_cast<OpaqueWrappable<T>*>(base);
   KJ_ASSERT(!holder->movedAway);
   holder->movedAway = true;
   return kj::mv(holder->value);
@@ -111,8 +142,9 @@ T& unwrapOpaqueRef(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Local<T>(), "can't opaque-wrap non-persistent handles");
 
   Wrappable& wrappable = KJ_ASSERT_NONNULL(Wrappable::tryUnwrapOpaque(isolate, handle));
-  OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-  KJ_ASSERT(holder != nullptr);
+  auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+  KJ_ASSERT(base->typeTag == OpaqueWrappableTypeTag<T>::get());
+  auto* holder = static_cast<OpaqueWrappable<T>*>(base);
   KJ_ASSERT(!holder->movedAway);
   return holder->value;
 }
@@ -126,8 +158,9 @@ void dropOpaque(v8::Isolate* isolate, v8::Local<v8::Value> handle) {
   static_assert(!isV8Ref<T>());
 
   KJ_IF_SOME(wrappable, Wrappable::tryUnwrapOpaque(isolate, handle)) {
-    OpaqueWrappable<T>* holder = dynamic_cast<OpaqueWrappable<T>*>(&wrappable);
-    if (holder != nullptr) {
+    auto* base = static_cast<OpaqueWrappableBase*>(&wrappable);
+    if (base->typeTag == OpaqueWrappableTypeTag<T>::get()) {
+      auto* holder = static_cast<OpaqueWrappable<T>*>(base);
       holder->movedAway = true;
       auto drop KJ_UNUSED = kj::mv(holder->value);
     }