diff --git a/core/src/com/google/inject/internal/RealMapBinder.java b/core/src/com/google/inject/internal/RealMapBinder.java
index f12d15bd17..ad7a81f4c0 100644
--- a/core/src/com/google/inject/internal/RealMapBinder.java
+++ b/core/src/com/google/inject/internal/RealMapBinder.java
@@ -125,6 +125,17 @@ static <K, V> TypeLiteral<Map<K, Provider<V>>> mapOfProviderOf(
         TypeLiteral.get(Types.mapOf(keyType.getType(), Types.providerOf(valueType.getType())));
   }
 
+  // provider map <K, V> is safely a Map<K, jakarta.inject.Provider<V>>>
+  @SuppressWarnings("unchecked")
+  static <K, V> TypeLiteral<Map<K, jakarta.inject.Provider<V>>> mapOfJakartaProviderOf(
+      TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
+    return (TypeLiteral<Map<K, jakarta.inject.Provider<V>>>)
+        TypeLiteral.get(
+            Types.mapOf(
+                keyType.getType(),
+                newParameterizedType(jakarta.inject.Provider.class, valueType.getType())));
+  }
+
   // provider map <K, V> is safely a Map<K, javax.inject.Provider<V>>>
   @SuppressWarnings("unchecked")
   static <K, V> TypeLiteral<Map<K, javax.inject.Provider<V>>> mapOfJavaxProviderOf(
@@ -144,6 +155,15 @@ static <K, V> TypeLiteral<Map<K, Set<Provider<V>>>> mapOfSetOfProviderOf(
             Types.mapOf(keyType.getType(), Types.setOf(Types.providerOf(valueType.getType()))));
   }
 
+  @SuppressWarnings("unchecked") // a provider map <K, Set<V>> is safely a Map<K, Set<Provider<V>>>
+  static <K, V> TypeLiteral<Map<K, Set<jakarta.inject.Provider<V>>>> mapOfSetOfJakartaProviderOf(
+      TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
+    return (TypeLiteral<Map<K, Set<jakarta.inject.Provider<V>>>>)
+        TypeLiteral.get(
+            Types.mapOf(
+                keyType.getType(), Types.setOf(Types.jakartaProviderOf(valueType.getType()))));
+  }
+
   @SuppressWarnings("unchecked") // a provider map <K, Set<V>> is safely a Map<K, Set<Provider<V>>>
   static <K, V> TypeLiteral<Map<K, Set<javax.inject.Provider<V>>>> mapOfSetOfJavaxProviderOf(
       TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
@@ -162,6 +182,17 @@ static <K, V> TypeLiteral<Map<K, Collection<Provider<V>>>> mapOfCollectionOfProv
                 keyType.getType(), Types.collectionOf(Types.providerOf(valueType.getType()))));
   }
 
+  @SuppressWarnings("unchecked") // a provider map <K, Set<V>> is safely a Map<K, Set<Provider<V>>>
+  static <K, V>
+      TypeLiteral<Map<K, Collection<jakarta.inject.Provider<V>>>>
+          mapOfCollectionOfJakartaProviderOf(TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
+    return (TypeLiteral<Map<K, Collection<jakarta.inject.Provider<V>>>>)
+        TypeLiteral.get(
+            Types.mapOf(
+                keyType.getType(),
+                Types.collectionOf(Types.jakartaProviderOf(valueType.getType()))));
+  }
+
   @SuppressWarnings("unchecked") // a provider map <K, Set<V>> is safely a Map<K, Set<Provider<V>>>
   static <K, V>
       TypeLiteral<Map<K, Collection<javax.inject.Provider<V>>>> mapOfCollectionOfJavaxProviderOf(
@@ -184,6 +215,26 @@ static <K, V> TypeLiteral<Map.Entry<K, Provider<V>>> entryOfProviderOf(
                 Types.providerOf(valueType.getType())));
   }
 
+  @SuppressWarnings("unchecked") // a provider entry <K, V> is safely a Map.Entry<K, Provider<V>>
+  static <K, V> TypeLiteral<Map.Entry<K, Provider<V>>> entryOfJakartaProviderOf(
+      TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
+    return (TypeLiteral<Map.Entry<K, Provider<V>>>)
+        TypeLiteral.get(
+            newParameterizedTypeWithOwner(
+                Map.class,
+                Map.Entry.class,
+                keyType.getType(),
+                Types.jakartaProviderOf(valueType.getType())));
+  }
+
+  @SuppressWarnings("unchecked") // a provider entry <K, V> is safely a Map.Entry<K, Provider<V>>
+  static <K, V>
+      TypeLiteral<Set<Map.Entry<K, jakarta.inject.Provider<V>>>> setOfEntryOfJakartaProviderOf(
+          TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
+    return (TypeLiteral<Set<Map.Entry<K, jakarta.inject.Provider<V>>>>)
+        TypeLiteral.get(Types.setOf(entryOfJakartaProviderOf(keyType, valueType).getType()));
+  }
+
   @SuppressWarnings("unchecked") // a provider entry <K, V> is safely a Map.Entry<K, Provider<V>>
   static <K, V> TypeLiteral<Map.Entry<K, Provider<V>>> entryOfJavaxProviderOf(
       TypeLiteral<K> keyType, TypeLiteral<V> valueType) {
@@ -216,7 +267,6 @@ private static <T> Key<Provider<T>> getKeyOfProvider(Key<T> valueKey) {
   // instance.
   static <K, V> RealMapBinder<K, V> newRealMapBinder(
       Binder binder, TypeLiteral<K> keyType, Key<V> valueTypeAndAnnotation) {
-    binder = binder.skipSources(RealMapBinder.class);
     TypeLiteral<V> valueType = valueTypeAndAnnotation.getTypeLiteral();
     return newRealMapBinder(
         binder,
@@ -299,6 +349,14 @@ public void configure(Binder binder) {
         new RealProviderMapProvider<>(bindingSelection);
     binder.bind(bindingSelection.getProviderMapKey()).toProvider(providerMapProvider);
 
+    // The map this exposes is internally an ImmutableMap, so it's OK to massage
+    // the guice Provider to jakarta Provider in the value (since Guice provider
+    // implements jakarta Provider).
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    Provider<Map<K, jakarta.inject.Provider<V>>> jakartaProviderMapProvider =
+        (Provider) providerMapProvider;
+    binder.bind(bindingSelection.getJakartaProviderMapKey()).toProvider(jakartaProviderMapProvider);
+
     // The map this exposes is internally an ImmutableMap, so it's OK to massage
     // the guice Provider to javax Provider in the value (since Guice provider
     // implements javax Provider).
@@ -315,6 +373,13 @@ public void configure(Binder binder) {
     // Bind Map<K, ? extends V> to the provider w/o the extension support.
     binder.bind(bindingSelection.getMapOfKeyExtendsValueKey()).toProvider(mapProvider);
 
+    // The Map.Entries are all ProviderMapEntry instances which do not allow setValue, so it is
+    // safe to massage the return type like this
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    Key<Set<Map.Entry<K, jakarta.inject.Provider<V>>>> jakartaEntrySetProviderKey =
+        (Key) bindingSelection.getEntrySetBinder().getSetKey();
+    binder.bind(bindingSelection.getEntrySetJakartaProviderKey()).to(jakartaEntrySetProviderKey);
+
     // The Map.Entries are all ProviderMapEntry instances which do not allow setValue, so it is
     // safe to massage the return type like this
     @SuppressWarnings({"unchecked", "rawtypes"})
@@ -360,13 +425,18 @@ private enum InitializationState {
     private final Key<Map<K, V>> mapKey;
 
     // Lazily computed
+    private Key<Map<K, jakarta.inject.Provider<V>>> jakartaProviderMapKey;
     private Key<Map<K, javax.inject.Provider<V>>> javaxProviderMapKey;
     private Key<Map<K, Provider<V>>> providerMapKey;
     private Key<Map<K, Set<V>>> multimapKey;
     private Key<Map<K, Set<Provider<V>>>> providerSetMultimapKey;
+    private Key<Map<K, Set<jakarta.inject.Provider<V>>>> jakartaProviderSetMultimapKey;
     private Key<Map<K, Set<javax.inject.Provider<V>>>> javaxProviderSetMultimapKey;
     private Key<Map<K, Collection<Provider<V>>>> providerCollectionMultimapKey;
+    private Key<Map<K, Collection<jakarta.inject.Provider<V>>>>
+        jakartaProviderCollectionMultimapKey;
     private Key<Map<K, Collection<javax.inject.Provider<V>>>> javaxProviderCollectionMultimapKey;
+    private Key<Set<Map.Entry<K, jakarta.inject.Provider<V>>>> entrySetJakartaProviderKey;
     private Key<Set<Map.Entry<K, javax.inject.Provider<V>>>> entrySetJavaxProviderKey;
     private Key<Map<K, ? extends V>> mapOfKeyExtendsValueKey;
 
@@ -533,13 +603,17 @@ private boolean containsElement(Element element) {
 
       return key.equals(getMapKey())
           || key.equals(getProviderMapKey())
+          || key.equals(getJakartaProviderMapKey())
           || key.equals(getJavaxProviderMapKey())
           || key.equals(getMultimapKey())
           || key.equals(getProviderSetMultimapKey())
+          || key.equals(getJakartaProviderSetMultimapKey())
           || key.equals(getJavaxProviderSetMultimapKey())
           || key.equals(getProviderCollectionMultimapKey())
+          || key.equals(getJakartaProviderCollectionMultimapKey())
           || key.equals(getJavaxProviderCollectionMultimapKey())
           || key.equals(entrySetBinder.getSetKey())
+          || key.equals(getEntrySetJakartaProviderKey())
           || key.equals(getEntrySetJavaxProviderKey())
           || key.equals(getMapOfKeyExtendsValueKey())
           || matchesValueKey(key);
@@ -562,6 +636,14 @@ private Key<Map<K, Provider<V>>> getProviderMapKey() {
       return local;
     }
 
+    private Key<Map<K, jakarta.inject.Provider<V>>> getJakartaProviderMapKey() {
+      Key<Map<K, jakarta.inject.Provider<V>>> local = jakartaProviderMapKey;
+      if (local == null) {
+        local = jakartaProviderMapKey = mapKey.ofType(mapOfJakartaProviderOf(keyType, valueType));
+      }
+      return local;
+    }
+
     private Key<Map<K, javax.inject.Provider<V>>> getJavaxProviderMapKey() {
       Key<Map<K, javax.inject.Provider<V>>> local = javaxProviderMapKey;
       if (local == null) {
@@ -586,6 +668,16 @@ private Key<Map<K, Set<Provider<V>>>> getProviderSetMultimapKey() {
       return local;
     }
 
+    private Key<Map<K, Set<jakarta.inject.Provider<V>>>> getJakartaProviderSetMultimapKey() {
+      Key<Map<K, Set<jakarta.inject.Provider<V>>>> local = jakartaProviderSetMultimapKey;
+      if (local == null) {
+        local =
+            jakartaProviderSetMultimapKey =
+                mapKey.ofType(mapOfSetOfJakartaProviderOf(keyType, valueType));
+      }
+      return local;
+    }
+
     private Key<Map<K, Set<javax.inject.Provider<V>>>> getJavaxProviderSetMultimapKey() {
       Key<Map<K, Set<javax.inject.Provider<V>>>> local = javaxProviderSetMultimapKey;
       if (local == null) {
@@ -606,6 +698,18 @@ private Key<Map<K, Collection<Provider<V>>>> getProviderCollectionMultimapKey()
       return local;
     }
 
+    private Key<Map<K, Collection<jakarta.inject.Provider<V>>>>
+        getJakartaProviderCollectionMultimapKey() {
+      Key<Map<K, Collection<jakarta.inject.Provider<V>>>> local =
+          jakartaProviderCollectionMultimapKey;
+      if (local == null) {
+        local =
+            jakartaProviderCollectionMultimapKey =
+                mapKey.ofType(mapOfCollectionOfJakartaProviderOf(keyType, valueType));
+      }
+      return local;
+    }
+
     private Key<Map<K, Collection<javax.inject.Provider<V>>>>
         getJavaxProviderCollectionMultimapKey() {
       Key<Map<K, Collection<javax.inject.Provider<V>>>> local = javaxProviderCollectionMultimapKey;
@@ -617,6 +721,16 @@ private Key<Map<K, Collection<Provider<V>>>> getProviderCollectionMultimapKey()
       return local;
     }
 
+    private Key<Set<Map.Entry<K, jakarta.inject.Provider<V>>>> getEntrySetJakartaProviderKey() {
+      Key<Set<Map.Entry<K, jakarta.inject.Provider<V>>>> local = entrySetJakartaProviderKey;
+      if (local == null) {
+        local =
+            entrySetJakartaProviderKey =
+                mapKey.ofType(setOfEntryOfJakartaProviderOf(keyType, valueType));
+      }
+      return local;
+    }
+
     private Key<Set<Map.Entry<K, javax.inject.Provider<V>>>> getEntrySetJavaxProviderKey() {
       Key<Set<Map.Entry<K, javax.inject.Provider<V>>>> local = entrySetJavaxProviderKey;
       if (local == null) {
@@ -862,11 +976,14 @@ public Key<Map<K, V>> getMapKey() {
     @Override
     public Set<Key<?>> getAlternateMapKeys() {
       return ImmutableSet.of(
+          (Key<?>) bindingSelection.getJakartaProviderMapKey(),
           (Key<?>) bindingSelection.getJavaxProviderMapKey(),
           (Key<?>) bindingSelection.getProviderMapKey(),
           (Key<?>) bindingSelection.getProviderSetMultimapKey(),
+          (Key<?>) bindingSelection.getJakartaProviderSetMultimapKey(),
           (Key<?>) bindingSelection.getJavaxProviderSetMultimapKey(),
           (Key<?>) bindingSelection.getProviderCollectionMultimapKey(),
+          (Key<?>) bindingSelection.getJakartaProviderCollectionMultimapKey(),
           (Key<?>) bindingSelection.getJavaxProviderCollectionMultimapKey(),
           (Key<?>) bindingSelection.getMultimapKey(),
           (Key<?>) bindingSelection.getMapOfKeyExtendsValueKey());
@@ -1041,12 +1158,28 @@ public void configure(Binder binder) {
       Provider<Map<K, Set<javax.inject.Provider<V>>>> javaxProvider = (Provider) multimapProvider;
       binder.bind(bindingSelection.getJavaxProviderSetMultimapKey()).toProvider(javaxProvider);
 
+      // Provide links from a few different public keys to the providerMultimapKey.
+      // The collection this exposes is internally an ImmutableMap, so it's OK to massage
+      // the guice Provider to jakarta Provider in the value (since the guice Provider implements
+      // jakarta Provider).
+      @SuppressWarnings({"unchecked", "rawtypes"})
+      Provider<Map<K, Set<jakarta.inject.Provider<V>>>> jakartaProvider =
+          (Provider) multimapProvider;
+      binder.bind(bindingSelection.getJakartaProviderSetMultimapKey()).toProvider(jakartaProvider);
+
       @SuppressWarnings({"unchecked", "rawtypes"})
       Provider<Map<K, Collection<Provider<V>>>> collectionProvider = (Provider) multimapProvider;
       binder
           .bind(bindingSelection.getProviderCollectionMultimapKey())
           .toProvider(collectionProvider);
 
+      @SuppressWarnings({"unchecked", "rawtypes"})
+      Provider<Map<K, Collection<jakarta.inject.Provider<V>>>> collectionJakartaProvider =
+          (Provider) multimapProvider;
+      binder
+          .bind(bindingSelection.getJakartaProviderCollectionMultimapKey())
+          .toProvider(collectionJakartaProvider);
+
       @SuppressWarnings({"unchecked", "rawtypes"})
       Provider<Map<K, Collection<javax.inject.Provider<V>>>> collectionJavaxProvider =
           (Provider) multimapProvider;
diff --git a/core/src/com/google/inject/internal/RealMultibinder.java b/core/src/com/google/inject/internal/RealMultibinder.java
index 90781b3eac..e9981389ec 100644
--- a/core/src/com/google/inject/internal/RealMultibinder.java
+++ b/core/src/com/google/inject/internal/RealMultibinder.java
@@ -72,6 +72,15 @@ static <T> TypeLiteral<Collection<Provider<T>>> collectionOfProvidersOf(
     return (TypeLiteral<Collection<Provider<T>>>) TypeLiteral.get(type);
   }
 
+  @SuppressWarnings("unchecked")
+  static <T> TypeLiteral<Collection<jakarta.inject.Provider<T>>> collectionOfJakartaProvidersOf(
+      TypeLiteral<T> elementType) {
+    Type providerType =
+        Types.newParameterizedType(jakarta.inject.Provider.class, elementType.getType());
+    Type type = Types.collectionOf(providerType);
+    return (TypeLiteral<Collection<jakarta.inject.Provider<T>>>) TypeLiteral.get(type);
+  }
+
   @SuppressWarnings("unchecked")
   static <T> TypeLiteral<Collection<javax.inject.Provider<T>>> collectionOfJavaxProvidersOf(
       TypeLiteral<T> elementType) {
@@ -116,6 +125,14 @@ public void configure(Binder binder) {
         .bind(bindingSelection.getCollectionOfProvidersKey())
         .toProvider(collectionOfProvidersProvider);
 
+    // The collection this exposes is internally an ImmutableList, so it's OK to massage
+    // the guice Provider to jakarta Provider in the value (since the guice Provider implements
+    // jakarta Provider).
+    @SuppressWarnings("unchecked")
+    Provider<Collection<jakarta.inject.Provider<T>>> jakartaProvider =
+        (Provider) collectionOfProvidersProvider;
+    binder.bind(bindingSelection.getCollectionOfJakartaProvidersKey()).toProvider(jakartaProvider);
+
     // The collection this exposes is internally an ImmutableList, so it's OK to massage
     // the guice Provider to javax Provider in the value (since the guice Provider implements
     // javax Provider).
@@ -326,6 +343,7 @@ public Key<Set<T>> getSetKey() {
     public ImmutableSet<Key<?>> getAlternateSetKeys() {
       return ImmutableSet.of(
           (Key<?>) bindingSelection.getCollectionOfProvidersKey(),
+          (Key<?>) bindingSelection.getCollectionOfJakartaProvidersKey(),
           (Key<?>) bindingSelection.getCollectionOfJavaxProvidersKey(),
           (Key<?>) bindingSelection.getSetOfExtendsKey());
     }
@@ -390,6 +408,7 @@ private static final class BindingSelection<T> {
     // these are all lazily allocated
     private String setName;
     private Key<Collection<Provider<T>>> collectionOfProvidersKey;
+    private Key<Collection<jakarta.inject.Provider<T>>> collectionOfJakartaProvidersKey;
     private Key<Collection<javax.inject.Provider<T>>> collectionOfJavaxProvidersKey;
     private Key<Set<? extends T>> setOfExtendsKey;
     private Key<Boolean> permitDuplicatesKey;
@@ -507,6 +526,16 @@ Key<Collection<Provider<T>>> getCollectionOfProvidersKey() {
       return local;
     }
 
+    Key<Collection<jakarta.inject.Provider<T>>> getCollectionOfJakartaProvidersKey() {
+      Key<Collection<jakarta.inject.Provider<T>>> local = collectionOfJakartaProvidersKey;
+      if (local == null) {
+        local =
+            collectionOfJakartaProvidersKey =
+                setKey.ofType(collectionOfJakartaProvidersOf(elementType));
+      }
+      return local;
+    }
+
     Key<Collection<javax.inject.Provider<T>>> getCollectionOfJavaxProvidersKey() {
       Key<Collection<javax.inject.Provider<T>>> local = collectionOfJavaxProvidersKey;
       if (local == null) {
@@ -564,6 +593,7 @@ boolean containsElement(com.google.inject.spi.Element element) {
             || binding.getKey().equals(getPermitDuplicatesKey())
             || binding.getKey().equals(setKey)
             || binding.getKey().equals(collectionOfProvidersKey)
+            || binding.getKey().equals(collectionOfJakartaProvidersKey)
             || binding.getKey().equals(collectionOfJavaxProvidersKey)
             || binding.getKey().equals(setOfExtendsKey);
       } else {
diff --git a/core/src/com/google/inject/internal/RealOptionalBinder.java b/core/src/com/google/inject/internal/RealOptionalBinder.java
index c5af20a455..d94fd34f8f 100644
--- a/core/src/com/google/inject/internal/RealOptionalBinder.java
+++ b/core/src/com/google/inject/internal/RealOptionalBinder.java
@@ -91,6 +91,27 @@ static <T> TypeLiteral<java.util.Optional<javax.inject.Provider<T>>> javaOptiona
                 newParameterizedType(javax.inject.Provider.class, type.getType())));
   }
 
+  @SuppressWarnings("unchecked")
+  static <T> TypeLiteral<Optional<jakarta.inject.Provider<T>>> optionalOfJakartaProvider(
+      TypeLiteral<T> type) {
+    return (TypeLiteral<Optional<jakarta.inject.Provider<T>>>)
+        TypeLiteral.get(
+            Types.newParameterizedType(
+                Optional.class,
+                newParameterizedType(jakarta.inject.Provider.class, type.getType())));
+  }
+
+  @SuppressWarnings("unchecked")
+  static <T>
+      TypeLiteral<java.util.Optional<jakarta.inject.Provider<T>>> javaOptionalOfJakartaProvider(
+          TypeLiteral<T> type) {
+    return (TypeLiteral<java.util.Optional<jakarta.inject.Provider<T>>>)
+        TypeLiteral.get(
+            Types.newParameterizedType(
+                java.util.Optional.class,
+                newParameterizedType(jakarta.inject.Provider.class, type.getType())));
+  }
+
   @SuppressWarnings("unchecked")
   static <T> TypeLiteral<Optional<Provider<T>>> optionalOfProvider(TypeLiteral<T> type) {
     return (TypeLiteral<Optional<Provider<T>>>)
@@ -189,15 +210,16 @@ public void configure(Binder binder) {
     // Every OptionalBinder gets the following types bound
     // * {cgcb,ju}.Optional<Provider<T>>
     // * {cgcb,ju}.Optional<javax.inject.Provider<T>>
+    // * {cgcb,ju}.Optional<jakarta.inject.Provider<T>>
     // * {cgcb,ju}.Optional<T>
     // If setDefault() or setBinding() is called then also
     // * T is bound
 
-    // cgcb.Optional<Provider<T>>
+    // cgcb.Optional<c.g.i.Provider<T>>
     InternalProviderInstanceBindingImpl.Factory<Optional<Provider<T>>> optionalProviderFactory =
         new RealOptionalProviderProvider<>(bindingSelection);
     binder.bind(key.ofType(optionalOfProvider(typeLiteral))).toProvider(optionalProviderFactory);
-    // ju.Optional<Provider<T>>
+    // ju.Optional<c.g.i.Provider<T>>
     InternalProviderInstanceBindingImpl.Factory<java.util.Optional<Provider<T>>>
         javaOptionalProviderFactory = new JavaOptionalProviderProvider<>(bindingSelection);
     binder
@@ -207,7 +229,7 @@ public void configure(Binder binder) {
     // Provider is assignable to javax.inject.Provider and the provider that the factory contains
     // cannot be modified so we can use some rawtypes hackery to share the same implementation.
 
-    // cgcb.Optional<ji.Provider<T>>
+    // cgcb.Optional<javax.inject.Provider<T>>
     @SuppressWarnings("unchecked")
     InternalProviderInstanceBindingImpl.Factory<Optional<javax.inject.Provider<T>>>
         optionalJavaxProviderFactory =
@@ -215,7 +237,7 @@ public void configure(Binder binder) {
     binder
         .bind(key.ofType(optionalOfJavaxProvider(typeLiteral)))
         .toProvider(optionalJavaxProviderFactory);
-    // ju.Optional<ji.Provider<T>>
+    // ju.Optional<javax.inject.Provider<T>>
     @SuppressWarnings("unchecked")
     InternalProviderInstanceBindingImpl.Factory<java.util.Optional<javax.inject.Provider<T>>>
         javaOptionalJavaxProviderFactory =
@@ -224,6 +246,26 @@ public void configure(Binder binder) {
         .bind(key.ofType(javaOptionalOfJavaxProvider(typeLiteral)))
         .toProvider(javaOptionalJavaxProviderFactory);
 
+    // Provider is assignable to jakarta.inject.Provider and the provider that the factory contains
+    // cannot be modified so we can use some rawtypes hackery to share the same implementation.
+
+    // cgcb.Optional<jakarta.inject.Provider<T>>
+    @SuppressWarnings("unchecked")
+    InternalProviderInstanceBindingImpl.Factory<Optional<jakarta.inject.Provider<T>>>
+        optionalJakartaProviderFactory =
+            (InternalProviderInstanceBindingImpl.Factory) optionalProviderFactory;
+    binder
+        .bind(key.ofType(optionalOfJakartaProvider(typeLiteral)))
+        .toProvider(optionalJakartaProviderFactory);
+    // ju.Optional<jakarta.inject.Provider<T>>
+    @SuppressWarnings("unchecked")
+    InternalProviderInstanceBindingImpl.Factory<java.util.Optional<jakarta.inject.Provider<T>>>
+        javaOptionalJakartaProviderFactory =
+            (InternalProviderInstanceBindingImpl.Factory) javaOptionalProviderFactory;
+    binder
+        .bind(key.ofType(javaOptionalOfJakartaProvider(typeLiteral)))
+        .toProvider(javaOptionalJakartaProviderFactory);
+
     // cgcb.Optional<T>
     Key<Optional<T>> optionalKey = key.ofType(optionalOf(typeLiteral));
     binder
@@ -324,7 +366,8 @@ public Set<Key<?>> getAlternateKeys() {
       TypeLiteral<?> typeLiteral = key.getTypeLiteral();
       return ImmutableSet.of(
           (Key<?>) key.ofType(javaOptionalOfProvider(typeLiteral)),
-          (Key<?>) key.ofType(javaOptionalOfJavaxProvider(typeLiteral)));
+          (Key<?>) key.ofType(javaOptionalOfJavaxProvider(typeLiteral)),
+          (Key<?>) key.ofType(javaOptionalOfJakartaProvider(typeLiteral)));
     }
   }
 
@@ -496,7 +539,8 @@ public Set<Key<?>> getAlternateKeys() {
       TypeLiteral<?> typeLiteral = key.getTypeLiteral();
       return ImmutableSet.of(
           (Key<?>) key.ofType(optionalOfProvider(typeLiteral)),
-          (Key<?>) key.ofType(optionalOfJavaxProvider(typeLiteral)));
+          (Key<?>) key.ofType(optionalOfJavaxProvider(typeLiteral)),
+          (Key<?>) key.ofType(optionalOfJakartaProvider(typeLiteral)));
     }
 
     @Override
diff --git a/core/test/com/google/inject/internal/MapBinderTest.java b/core/test/com/google/inject/internal/MapBinderTest.java
index ffebc91fc6..3685ecc9b1 100644
--- a/core/test/com/google/inject/internal/MapBinderTest.java
+++ b/core/test/com/google/inject/internal/MapBinderTest.java
@@ -81,13 +81,17 @@
 import java.util.concurrent.atomic.AtomicReference;
 import junit.framework.TestCase;
 
-/** @author dpb@google.com (David P. Baker) */
+/**
+ * @author dpb@google.com (David P. Baker)
+ */
 public class MapBinderTest extends TestCase {
 
   private static final ImmutableSet<Key<?>> FRAMEWORK_KEYS =
       ImmutableSet.of(
           Key.get(java.util.logging.Logger.class), Key.get(Stage.class), Key.get(Injector.class));
 
+  final TypeLiteral<Map<String, jakarta.inject.Provider<String>>> mapOfStringJakartaProvider =
+      new TypeLiteral<Map<String, jakarta.inject.Provider<String>>>() {};
   final TypeLiteral<Map<String, javax.inject.Provider<String>>> mapOfStringJavaxProvider =
       new TypeLiteral<Map<String, javax.inject.Provider<String>>>() {};
   final TypeLiteral<Map<String, Provider<String>>> mapOfStringProvider =
@@ -134,24 +138,36 @@ protected void configure() {
                 Key.get(Types.mapOf(String.class, String.class)),
                 // Map<K, Provider<V>>
                 Key.get(Types.mapOf(String.class, Types.providerOf(String.class))),
+                // Map<K, jakarta.inject.Provider<V>>
+                Key.get(Types.mapOf(String.class, Types.jakartaProviderOf(String.class))),
                 // Map<K, javax.inject.Provider<V>>
                 Key.get(Types.mapOf(String.class, javaxProviderOf(String.class))),
                 // Map<K, Set<V>>
                 Key.get(Types.mapOf(String.class, Types.setOf(String.class))),
                 // Map<K, Set<Provider<V>>
                 Key.get(Types.mapOf(String.class, Types.setOf(Types.providerOf(String.class)))),
+                // Map<K, Set<jakarta.inject.Provider<V>>
+                Key.get(
+                    Types.mapOf(String.class, Types.setOf(Types.jakartaProviderOf(String.class)))),
                 // Map<K, Set<javax.inject.Provider<V>>
                 Key.get(
                     Types.mapOf(String.class, Types.setOf(Types.javaxProviderOf(String.class)))),
                 // Map<K, Collection<Provider<V>>
                 Key.get(
                     Types.mapOf(String.class, Types.collectionOf(Types.providerOf(String.class)))),
+                // Map<K, Collection<jakarta.inject.Provider<V>>
+                Key.get(
+                    Types.mapOf(
+                        String.class, Types.collectionOf(Types.jakartaProviderOf(String.class)))),
                 // Map<K, Collection<javax.inject.Provider<V>>
                 Key.get(
                     Types.mapOf(
                         String.class, Types.collectionOf(Types.javaxProviderOf(String.class)))),
                 // Set<Map.Entry<K, Provider<V>>>
                 Key.get(Types.setOf(mapEntryOf(String.class, Types.providerOf(String.class)))),
+                // Set<Map.Entry<K, jakarta.inject.Provider<V>>>
+                Key.get(
+                    Types.setOf(mapEntryOf(String.class, Types.jakartaProviderOf(String.class)))),
                 // Set<Map.Entry<K, javax.inject.Provider<V>>>
                 Key.get(Types.setOf(mapEntryOf(String.class, Types.javaxProviderOf(String.class)))),
                 // Collection<Provider<Map.Entry<K, Provider<V>>>>
@@ -159,6 +175,11 @@ protected void configure() {
                     collectionOf(
                         Types.providerOf(
                             mapEntryOf(String.class, Types.providerOf(String.class))))),
+                // Collection<jakarta.inject.Provider<Map.Entry<K, Provider<V>>>>
+                Key.get(
+                    collectionOf(
+                        Types.jakartaProviderOf(
+                            mapEntryOf(String.class, Types.providerOf(String.class))))),
                 // Collection<javax.inject.Provider<Map.Entry<K, Provider<V>>>>
                 Key.get(
                     collectionOf(
@@ -233,6 +254,7 @@ protected void configure() {
     // just make sure these succeed
     injector.getInstance(Key.get(mapOfStringProvider));
     injector.getInstance(Key.get(mapOfStringJavaxProvider));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider));
   }
 
   public void testMapBinderAggregationForAnnotationInstance() {
@@ -270,6 +292,7 @@ protected void configure() {
     // just make sure these succeed
     injector.getInstance(Key.get(mapOfStringProvider, Names.named("abc")));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, Names.named("abc")));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, Names.named("abc")));
   }
 
   public void testMapBinderAggregationForAnnotationType() {
@@ -306,6 +329,7 @@ protected void configure() {
     // just make sure these succeed
     injector.getInstance(Key.get(mapOfStringProvider, Abc.class));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, Abc.class));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, Abc.class));
   }
 
   public void testMapBinderWithMultipleAnnotationValueSets() {
@@ -358,8 +382,10 @@ protected void configure() {
     // just make sure these succeed
     injector.getInstance(Key.get(mapOfStringProvider, named("abc")));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, named("abc")));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, named("abc")));
     injector.getInstance(Key.get(mapOfStringProvider, named("de")));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, named("de")));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, named("de")));
   }
 
   public void testMapBinderWithMultipleAnnotationTypeSets() {
@@ -412,8 +438,10 @@ protected void configure() {
     // just make sure these succeed
     injector.getInstance(Key.get(mapOfStringProvider, Abc.class));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, Abc.class));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, Abc.class));
     injector.getInstance(Key.get(mapOfStringProvider, De.class));
     injector.getInstance(Key.get(mapOfStringJavaxProvider, De.class));
+    injector.getInstance(Key.get(mapOfStringJakartaProvider, De.class));
   }
 
   public void testMapBinderWithMultipleTypes() {
@@ -830,15 +858,16 @@ protected void configure() {
   }
 
   public void testMapBinderMapForbidsNullValues() {
-    Module m =
-        new AbstractModule() {
-          @Override
-          protected void configure() {
-            MapBinder.newMapBinder(binder(), String.class, String.class)
-                .addBinding("null")
-                .toProvider(Providers.<String>of(null));
-          }
-        };
+    class NullValueModule extends AbstractModule {
+      @Override
+      protected void configure() {
+        MapBinder.newMapBinder(binder(), String.class, String.class)
+            .addBinding("null")
+            .toProvider(Providers.<String>of(null));
+      }
+    }
+
+    Module m = new NullValueModule();
     Injector injector = Guice.createInjector(m);
 
     try {
@@ -848,7 +877,7 @@ protected void configure() {
       assertContains(
           expected.getMessage(),
           "Map injection failed due to null value for key \"null\", bound at:"
-              + " MapBinderTest$30.configure");
+              + " MapBinderTest$1NullValueModule.configure");
     }
   }
 
@@ -880,20 +909,20 @@ protected void configure() {
   }
 
   public void testSourceLinesInMapBindings() {
+    class SimpleBinding extends AbstractModule {
+      @Override
+      protected void configure() {
+        MapBinder.newMapBinder(binder(), String.class, Integer.class).addBinding("one");
+      }
+    }
     try {
-      Guice.createInjector(
-          new AbstractModule() {
-            @Override
-            protected void configure() {
-              MapBinder.newMapBinder(binder(), String.class, Integer.class).addBinding("one");
-            }
-          });
+      Guice.createInjector(new SimpleBinding());
       fail();
     } catch (CreationException expected) {
       assertContains(
           expected.getMessage(),
           "No implementation for Integer",
-          "1  : MapBinderTest$33.configure");
+          "1  : MapBinderTest$1SimpleBinding.configure");
     }
   }
 
@@ -1270,7 +1299,8 @@ public void configure() {
                 mb1.addBinding(1).toInstance(1);
                 mb2.addBinding(2).toInstance(2);
 
-                // This assures us that the two binders are equivalent, so we expect the instance added to
+                // This assures us that the two binders are equivalent, so we expect the instance
+                // added to
                 // each to have been added to one set.
                 assertEquals(mb1, mb2);
               }
diff --git a/core/test/com/google/inject/internal/MultibinderTest.java b/core/test/com/google/inject/internal/MultibinderTest.java
index 568ce9033a..eca7b2aab2 100644
--- a/core/test/com/google/inject/internal/MultibinderTest.java
+++ b/core/test/com/google/inject/internal/MultibinderTest.java
@@ -19,6 +19,7 @@
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.MoreCollectors.onlyElement;
 import static com.google.inject.Asserts.assertContains;
+import static com.google.inject.internal.RealMultibinder.collectionOfJakartaProvidersOf;
 import static com.google.inject.internal.RealMultibinder.collectionOfJavaxProvidersOf;
 import static com.google.inject.internal.SpiUtils.VisitType.BOTH;
 import static com.google.inject.internal.SpiUtils.VisitType.MODULE;
@@ -1417,6 +1418,10 @@ protected void configure() {
         injector.getInstance(Key.get(collectionOfProvidersOfStrings));
     assertEquals(expectedValues, collectValues(providers));
 
+    Collection<jakarta.inject.Provider<String>> jakartaProviders =
+        injector.getInstance(Key.get(collectionOfJakartaProvidersOf(stringType)));
+    assertEquals(expectedValues, collectValuesJakarta(jakartaProviders));
+
     Collection<javax.inject.Provider<String>> javaxProviders =
         injector.getInstance(Key.get(collectionOfJavaxProvidersOf(stringType)));
     assertEquals(expectedValues, collectValues(javaxProviders));
@@ -1444,6 +1449,10 @@ protected void configure() {
     Collection<String> values = collectValues(providers);
     assertEquals(expectedValues, values);
 
+    Collection<jakarta.inject.Provider<String>> jakartaProviders =
+        injector.getInstance(Key.get(collectionOfJakartaProvidersOf(stringType), ann));
+    assertEquals(expectedValues, collectValuesJakarta(jakartaProviders));
+
     Collection<javax.inject.Provider<String>> javaxProviders =
         injector.getInstance(Key.get(collectionOfJavaxProvidersOf(stringType), ann));
     assertEquals(expectedValues, collectValues(javaxProviders));
@@ -1610,6 +1619,15 @@ protected void configure() {
     }
   }
 
+  private <T> Collection<T> collectValuesJakarta(
+      Collection<? extends jakarta.inject.Provider<T>> providers) {
+    Collection<T> values = Lists.newArrayList();
+    for (jakarta.inject.Provider<T> provider : providers) {
+      values.add(provider.get());
+    }
+    return values;
+  }
+
   private <T> Collection<T> collectValues(
       Collection<? extends javax.inject.Provider<T>> providers) {
     Collection<T> values = Lists.newArrayList();
diff --git a/core/test/com/google/inject/internal/OptionalBinderTest.java b/core/test/com/google/inject/internal/OptionalBinderTest.java
index e752b22d48..14f166b9f8 100644
--- a/core/test/com/google/inject/internal/OptionalBinderTest.java
+++ b/core/test/com/google/inject/internal/OptionalBinderTest.java
@@ -82,6 +82,11 @@ public class OptionalBinderTest extends TestCase {
   final TypeLiteral<java.util.Optional<javax.inject.Provider<String>>>
       javaOptionalOfJavaxProviderString =
           new TypeLiteral<java.util.Optional<javax.inject.Provider<String>>>() {};
+  final TypeLiteral<Optional<jakarta.inject.Provider<String>>> optionalOfJakartaProviderString =
+      new TypeLiteral<Optional<jakarta.inject.Provider<String>>>() {};
+  final TypeLiteral<java.util.Optional<jakarta.inject.Provider<String>>>
+      javaOptionalOfJakartaProviderString =
+          new TypeLiteral<java.util.Optional<jakarta.inject.Provider<String>>>() {};
 
   final Key<Integer> intKey = Key.get(Integer.class);
   final TypeLiteral<Optional<Integer>> optionalOfInteger = new TypeLiteral<Optional<Integer>>() {};
@@ -96,6 +101,11 @@ public class OptionalBinderTest extends TestCase {
   final TypeLiteral<java.util.Optional<javax.inject.Provider<Integer>>>
       javaOptionalOfJavaxProviderInteger =
           new TypeLiteral<java.util.Optional<javax.inject.Provider<Integer>>>() {};
+  final TypeLiteral<Optional<jakarta.inject.Provider<Integer>>> optionalOfJakartaProviderInteger =
+      new TypeLiteral<Optional<jakarta.inject.Provider<Integer>>>() {};
+  final TypeLiteral<java.util.Optional<jakarta.inject.Provider<Integer>>>
+      javaOptionalOfJakartaProviderInteger =
+          new TypeLiteral<java.util.Optional<jakarta.inject.Provider<Integer>>>() {};
 
   final TypeLiteral<List<String>> listOfStrings = new TypeLiteral<List<String>>() {};
 
@@ -178,6 +188,10 @@ protected void configure() {
         injector.getInstance(Key.get(optionalOfJavaxProviderString));
     assertFalse(optionalJxP.isPresent());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertFalse(optionalJkP.isPresent());
+
     assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, null, null, null);
 
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfString)));
@@ -189,6 +203,10 @@ protected void configure() {
     optionalJxP =
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertFalse(optionalJxP.isPresent());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertFalse(optionalJkP.isPresent());
   }
 
   public void testUsesUserBoundValue() throws Exception {
@@ -218,6 +236,10 @@ String provideString() {
         injector.getInstance(Key.get(optionalOfJavaxProviderString));
     assertEquals("foo", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertEquals("foo", optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey, setOf(module), VisitType.BOTH, 0, null, null, providerInstance("foo"));
 
@@ -230,6 +252,10 @@ String provideString() {
     optionalJxP =
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertEquals("foo", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertEquals("foo", optionalJkP.get().get());
   }
 
   public void testUsesUserBoundValueNullProvidersMakeAbsent() throws Exception {
@@ -259,6 +285,10 @@ String provideString() {
         injector.getInstance(Key.get(optionalOfJavaxProviderString));
     assertEquals(null, optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertEquals(null, optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey, setOf(module), VisitType.BOTH, 0, null, null, providerInstance(null));
 
@@ -271,6 +301,10 @@ String provideString() {
     optionalJxP =
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertEquals(null, optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertEquals(null, optionalJkP.get().get());
   }
 
   private static class JitBinding {
@@ -371,6 +405,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
+
     assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, instance("a"), null, null);
 
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfString)));
@@ -385,6 +424,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
   }
 
   public void testSetBinding() throws Exception {
@@ -411,6 +455,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
+
     assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, null, instance("a"), null);
 
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfString)));
@@ -425,6 +474,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
   }
 
   public void testSetBindingOverridesDefault() throws Exception {
@@ -454,6 +508,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey, setOf(module), VisitType.BOTH, 0, instance("a"), instance("b"), null);
 
@@ -469,6 +528,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
   }
 
   public void testSpreadAcrossModules() throws Exception {
@@ -510,6 +574,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey,
         setOf(module1, module2, module3),
@@ -531,6 +600,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
   }
 
   public void testExactSameBindingCollapses_defaults() throws Exception {
@@ -562,6 +636,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
+
     assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, instance("a"), null, null);
 
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfString)));
@@ -576,6 +655,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
   }
 
   public void testExactSameBindingCollapses_actual() throws Exception {
@@ -607,6 +691,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
+
     assertOptionalVisitor(stringKey, setOf(module), VisitType.BOTH, 0, null, instance("a"), null);
 
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfString)));
@@ -621,6 +710,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertEquals("a", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("a", optionalJkP.get().get());
   }
 
   public void testDifferentBindingsFail_defaults() {
@@ -732,6 +826,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString, Names.named("foo")));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
+
     assertOptionalVisitor(
         Key.get(String.class, Names.named("foo")),
         setOf(module1, module2, module3),
@@ -758,6 +857,12 @@ protected void configure() {
             injector.getInstance(Key.get(javaOptionalOfJavaxProviderString, Names.named("foo"))));
     assertTrue(optionalJxP.isPresent());
     assertEquals("b", optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(
+            injector.getInstance(Key.get(javaOptionalOfJakartaProviderString, Names.named("foo"))));
+    assertTrue(optionalJkP.isPresent());
+    assertEquals("b", optionalJkP.get().get());
   }
 
   public void testMultipleDifferentOptionals() {
@@ -810,6 +915,8 @@ int provideInt() {
         injector.getInstance(Key.get(optionalOfProviderInteger));
     Optional<javax.inject.Provider<Integer>> optionalJxP =
         injector.getInstance(Key.get(optionalOfJavaxProviderInteger));
+    Optional<jakarta.inject.Provider<Integer>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderInteger));
 
     assertEquals(1, injector.getInstance(Integer.class).intValue());
     assertEquals(2, injector.getInstance(Integer.class).intValue());
@@ -828,21 +935,29 @@ int provideInt() {
     assertEquals(7, optionalJxP.get().get().intValue());
     assertEquals(8, optionalJxP.get().get().intValue());
 
+    assertEquals(9, optionalJkP.get().get().intValue());
+    assertEquals(10, optionalJkP.get().get().intValue());
+
     // and same rules with java.util.Optional
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfInteger)));
-    assertEquals(9, optional.get().intValue());
-    assertEquals(9, optional.get().intValue());
+    assertEquals(11, optional.get().intValue());
+    assertEquals(11, optional.get().intValue());
     optional = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfInteger)));
-    assertEquals(10, optional.get().intValue());
+    assertEquals(12, optional.get().intValue());
 
     optionalP = Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfProviderInteger)));
-    assertEquals(11, optionalP.get().get().intValue());
-    assertEquals(12, optionalP.get().get().intValue());
+    assertEquals(13, optionalP.get().get().intValue());
+    assertEquals(14, optionalP.get().get().intValue());
 
     optionalJxP =
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderInteger)));
-    assertEquals(13, optionalJxP.get().get().intValue());
-    assertEquals(14, optionalJxP.get().get().intValue());
+    assertEquals(15, optionalJxP.get().get().intValue());
+    assertEquals(16, optionalJxP.get().get().intValue());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderInteger)));
+    assertEquals(17, optionalJkP.get().get().intValue());
+    assertEquals(18, optionalJkP.get().get().intValue());
   }
 
   public void testLinkedToNullProvidersMakeAbsentValuesAndPresentProviders_default()
@@ -871,6 +986,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertNull(optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey,
         setOf(module),
@@ -891,6 +1011,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertNull(optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
   }
 
   public void testLinkedToNullProvidersMakeAbsentValuesAndPresentProviders_actual()
@@ -919,6 +1044,11 @@ protected void configure() {
     assertTrue(optionalJxP.isPresent());
     assertNull(optionalJxP.get().get());
 
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
+
     assertOptionalVisitor(
         stringKey,
         setOf(module),
@@ -939,6 +1069,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertNull(optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
   }
 
   // TODO(sameb): Maybe change this?
@@ -966,7 +1101,12 @@ protected void configure() {
     Optional<javax.inject.Provider<String>> optionalJxP =
         injector.getInstance(Key.get(optionalOfJavaxProviderString));
     assertTrue(optionalJxP.isPresent());
-    assertNull(optionalP.get().get());
+    assertNull(optionalJxP.get().get());
+
+    Optional<jakarta.inject.Provider<String>> optionalJkP =
+        injector.getInstance(Key.get(optionalOfJakartaProviderString));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
 
     assertOptionalVisitor(
         stringKey,
@@ -988,6 +1128,11 @@ protected void configure() {
         Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJavaxProviderString)));
     assertTrue(optionalJxP.isPresent());
     assertNull(optionalJxP.get().get());
+
+    optionalJkP =
+        Optional.fromJavaUtil(injector.getInstance(Key.get(javaOptionalOfJakartaProviderString)));
+    assertTrue(optionalJkP.isPresent());
+    assertNull(optionalJkP.get().get());
   }
 
   public void testSourceLinesInException() {
diff --git a/core/test/com/google/inject/internal/SpiUtils.java b/core/test/com/google/inject/internal/SpiUtils.java
index 95cebb49b9..784e884e31 100644
--- a/core/test/com/google/inject/internal/SpiUtils.java
+++ b/core/test/com/google/inject/internal/SpiUtils.java
@@ -17,15 +17,20 @@
 package com.google.inject.internal;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.google.inject.internal.RealMapBinder.entryOfJakartaProviderOf;
 import static com.google.inject.internal.RealMapBinder.entryOfJavaxProviderOf;
 import static com.google.inject.internal.RealMapBinder.entryOfProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOf;
+import static com.google.inject.internal.RealMapBinder.mapOfCollectionOfJakartaProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfCollectionOfJavaxProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfCollectionOfProviderOf;
+import static com.google.inject.internal.RealMapBinder.mapOfJakartaProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfJavaxProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfProviderOf;
+import static com.google.inject.internal.RealMapBinder.mapOfSetOfJakartaProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfSetOfJavaxProviderOf;
 import static com.google.inject.internal.RealMapBinder.mapOfSetOfProviderOf;
+import static com.google.inject.internal.RealMultibinder.collectionOfJakartaProvidersOf;
 import static com.google.inject.internal.RealMultibinder.collectionOfJavaxProvidersOf;
 import static com.google.inject.internal.RealMultibinder.collectionOfProvidersOf;
 import static com.google.inject.internal.RealMultibinder.setOf;
@@ -182,19 +187,27 @@ private static <T> void mapInjectorTest(
       fail("Found all entries of: " + mapResults + ", but more were left over: " + entries);
     }
 
+    Key<?> mapOfJakartaProvider = mapKey.ofType(mapOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(keyType, valueType));
     Key<?> mapOfSetOfProvider = mapKey.ofType(mapOfSetOfProviderOf(keyType, valueType));
+    Key<?> mapOfSetOfJakartaProvider =
+        mapKey.ofType(mapOfSetOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfSetOfJavaxProvider = mapKey.ofType(mapOfSetOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfCollectionOfProvider =
         mapKey.ofType(mapOfCollectionOfProviderOf(keyType, valueType));
+    Key<?> mapOfCollectionOfJakartaProvider =
+        mapKey.ofType(mapOfCollectionOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfCollectionOfJavaxProvider =
         mapKey.ofType(mapOfCollectionOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfSet = mapKey.ofType(mapOf(keyType, setOf(valueType)));
     Key<?> setOfEntry = mapKey.ofType(setOf(entryOfProviderOf(keyType, valueType)));
+    Key<?> setOfJakartaEntry = mapKey.ofType(setOf(entryOfJakartaProviderOf(keyType, valueType)));
     Key<?> setOfJavaxEntry = mapKey.ofType(setOf(entryOfJavaxProviderOf(keyType, valueType)));
     Key<?> collectionOfProvidersOfEntryOfProvider =
         mapKey.ofType(collectionOfProvidersOf(entryOfProviderOf(keyType, valueType)));
+    Key<?> collectionOfJakartaProvidersOfEntryOfProvider =
+        mapKey.ofType(collectionOfJakartaProvidersOf(entryOfProviderOf(keyType, valueType)));
     Key<?> collectionOfJavaxProvidersOfEntryOfProvider =
         mapKey.ofType(collectionOfJavaxProvidersOf(entryOfProviderOf(keyType, valueType)));
     Key<?> setOfExtendsOfEntryOfProvider =
@@ -204,26 +217,34 @@ private static <T> void mapInjectorTest(
 
     assertEquals(
         ImmutableSet.of(
+            mapOfJakartaProvider,
             mapOfJavaxProvider,
             mapOfProvider,
             mapOfSetOfProvider,
+            mapOfSetOfJakartaProvider,
             mapOfSetOfJavaxProvider,
             mapOfCollectionOfProvider,
+            mapOfCollectionOfJakartaProvider,
             mapOfCollectionOfJavaxProvider,
             mapOfSet,
             mapOfKeyExtendsValueKey),
         mapbinder.getAlternateMapKeys());
 
     boolean entrySetMatch = false;
+    boolean jakartaEntrySetMatch = false;
     boolean javaxEntrySetMatch = false;
+    boolean mapJakartaProviderMatch = false;
     boolean mapJavaxProviderMatch = false;
     boolean mapProviderMatch = false;
     boolean mapSetMatch = false;
     boolean mapSetProviderMatch = false;
+    boolean mapSetJakartaProviderMatch = false;
     boolean mapSetJavaxProviderMatch = false;
     boolean mapCollectionProviderMatch = false;
+    boolean mapCollectionJakartaProviderMatch = false;
     boolean mapCollectionJavaxProviderMatch = false;
     boolean collectionOfProvidersOfEntryOfProviderMatch = false;
+    boolean collectionOfJakartaProvidersOfEntryOfProviderMatch = false;
     boolean collectionOfJavaxProvidersOfEntryOfProviderMatch = false;
     boolean setOfExtendsOfEntryOfProviderMatch = false;
     boolean mapOfKeyExtendsValueKeyMatch = false;
@@ -245,6 +266,9 @@ private static <T> void mapInjectorTest(
       } else if (b.getKey().equals(mapOfProvider)) {
         assertTrue(contains);
         mapProviderMatch = true;
+      } else if (b.getKey().equals(mapOfJakartaProvider)) {
+        assertTrue(contains);
+        mapJakartaProviderMatch = true;
       } else if (b.getKey().equals(mapOfJavaxProvider)) {
         assertTrue(contains);
         mapJavaxProviderMatch = true;
@@ -254,12 +278,18 @@ private static <T> void mapInjectorTest(
       } else if (b.getKey().equals(mapOfSetOfProvider)) {
         assertTrue(contains);
         mapSetProviderMatch = true;
+      } else if (b.getKey().equals(mapOfSetOfJakartaProvider)) {
+        assertTrue(contains);
+        mapSetJakartaProviderMatch = true;
       } else if (b.getKey().equals(mapOfSetOfJavaxProvider)) {
         assertTrue(contains);
         mapSetJavaxProviderMatch = true;
       } else if (b.getKey().equals(mapOfCollectionOfProvider)) {
         assertTrue(contains);
         mapCollectionProviderMatch = true;
+      } else if (b.getKey().equals(mapOfCollectionOfJakartaProvider)) {
+        assertTrue(contains);
+        mapCollectionJakartaProviderMatch = true;
       } else if (b.getKey().equals(mapOfCollectionOfJavaxProvider)) {
         assertTrue(contains);
         mapCollectionJavaxProviderMatch = true;
@@ -269,12 +299,18 @@ private static <T> void mapInjectorTest(
         // Validate that this binding is also a MultibinderBinding.
         assertThat(((Binding<T>) b).acceptTargetVisitor(visitor))
             .isInstanceOf(MultibinderBinding.class);
+      } else if (b.getKey().equals(setOfJakartaEntry)) {
+        assertTrue(contains);
+        jakartaEntrySetMatch = true;
       } else if (b.getKey().equals(setOfJavaxEntry)) {
         assertTrue(contains);
         javaxEntrySetMatch = true;
       } else if (b.getKey().equals(collectionOfProvidersOfEntryOfProvider)) {
         assertTrue(contains);
         collectionOfProvidersOfEntryOfProviderMatch = true;
+      } else if (b.getKey().equals(collectionOfJakartaProvidersOfEntryOfProvider)) {
+        assertTrue(contains);
+        collectionOfJakartaProvidersOfEntryOfProviderMatch = true;
       } else if (b.getKey().equals(collectionOfJavaxProvidersOfEntryOfProvider)) {
         assertTrue(contains);
         collectionOfJavaxProvidersOfEntryOfProviderMatch = true;
@@ -313,16 +349,21 @@ private static <T> void mapInjectorTest(
         expectedSize,
         sizeOfOther);
     assertTrue(entrySetMatch);
+    assertTrue(jakartaEntrySetMatch);
     assertTrue(javaxEntrySetMatch);
     assertTrue(mapProviderMatch);
+    assertTrue(mapJakartaProviderMatch);
     assertTrue(mapJavaxProviderMatch);
     assertTrue(collectionOfProvidersOfEntryOfProviderMatch);
+    assertTrue(collectionOfJakartaProvidersOfEntryOfProviderMatch);
     assertTrue(collectionOfJavaxProvidersOfEntryOfProviderMatch);
     assertTrue(setOfExtendsOfEntryOfProviderMatch);
     assertTrue(mapOfKeyExtendsValueKeyMatch);
     assertEquals(allowDuplicates, mapSetMatch);
     assertEquals(allowDuplicates, mapSetProviderMatch);
+    assertEquals(allowDuplicates, mapSetJakartaProviderMatch);
     assertEquals(allowDuplicates, mapSetJavaxProviderMatch);
+    assertEquals(allowDuplicates, mapCollectionJakartaProviderMatch);
     assertEquals(allowDuplicates, mapCollectionJavaxProviderMatch);
     assertEquals(allowDuplicates, mapCollectionProviderMatch);
     assertEquals(
@@ -389,18 +430,26 @@ private static <T> void mapModuleTest(
     assertEquals(valueType, mapbinder.getValueTypeLiteral());
 
     Key<?> mapOfProvider = mapKey.ofType(mapOfProviderOf(keyType, valueType));
+    Key<?> mapOfJakartaProvider = mapKey.ofType(mapOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfJavaxProvider = mapKey.ofType(mapOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfSetOfProvider = mapKey.ofType(mapOfSetOfProviderOf(keyType, valueType));
+    Key<?> mapOfSetOfJakartaProvider =
+        mapKey.ofType(mapOfSetOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfSetOfJavaxProvider = mapKey.ofType(mapOfSetOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfCollectionOfProvider =
         mapKey.ofType(mapOfCollectionOfProviderOf(keyType, valueType));
+    Key<?> mapOfCollectionOfJakartaProvider =
+        mapKey.ofType(mapOfCollectionOfJakartaProviderOf(keyType, valueType));
     Key<?> mapOfCollectionOfJavaxProvider =
         mapKey.ofType(mapOfCollectionOfJavaxProviderOf(keyType, valueType));
     Key<?> mapOfSet = mapKey.ofType(mapOf(keyType, setOf(valueType)));
     Key<?> setOfEntry = mapKey.ofType(setOf(entryOfProviderOf(keyType, valueType)));
+    Key<?> setOfJakartaEntry = mapKey.ofType(setOf(entryOfJakartaProviderOf(keyType, valueType)));
     Key<?> setOfJavaxEntry = mapKey.ofType(setOf(entryOfJavaxProviderOf(keyType, valueType)));
     Key<?> collectionOfProvidersOfEntryOfProvider =
         mapKey.ofType(collectionOfProvidersOf(entryOfProviderOf(keyType, valueType)));
+    Key<?> collectionOfJakartaProvidersOfEntryOfProvider =
+        mapKey.ofType(collectionOfJakartaProvidersOf(entryOfProviderOf(keyType, valueType)));
     Key<?> collectionOfJavaxProvidersOfEntryOfProvider =
         mapKey.ofType(collectionOfJavaxProvidersOf(entryOfProviderOf(keyType, valueType)));
     Key<?> setOfExtendsOfEntryOfProvider =
@@ -411,25 +460,33 @@ private static <T> void mapModuleTest(
     assertEquals(
         ImmutableSet.of(
             mapOfProvider,
+            mapOfJakartaProvider,
             mapOfJavaxProvider,
             mapOfSetOfProvider,
+            mapOfSetOfJakartaProvider,
             mapOfSetOfJavaxProvider,
             mapOfCollectionOfProvider,
+            mapOfCollectionOfJakartaProvider,
             mapOfCollectionOfJavaxProvider,
             mapOfSet,
             mapOfKeyExtendsValueKey),
         mapbinder.getAlternateMapKeys());
 
     boolean entrySetMatch = false;
+    boolean entrySetJakartaMatch = false;
     boolean entrySetJavaxMatch = false;
     boolean mapProviderMatch = false;
+    boolean mapJakartaProviderMatch = false;
     boolean mapJavaxProviderMatch = false;
     boolean mapSetMatch = false;
     boolean mapSetProviderMatch = false;
+    boolean mapSetJakartaProviderMatch = false;
     boolean mapSetJavaxProviderMatch = false;
     boolean mapCollectionProviderMatch = false;
+    boolean mapCollectionJakartaProviderMatch = false;
     boolean mapCollectionJavaxProviderMatch = false;
     boolean collectionOfProvidersOfEntryOfProviderMatch = false;
+    boolean collectionOfJakartaProvidersOfEntryOfProviderMatch = false;
     boolean collectionOfJavaxProvidersOfEntryOfProviderMatch = false;
     boolean setOfExtendsOfEntryOfProviderMatch = false;
     boolean mapOfKeyExtendsValueKeyMatch = false;
@@ -483,6 +540,10 @@ private static <T> void mapModuleTest(
           matched = true;
           assertTrue(contains);
           mapProviderMatch = true;
+        } else if (key.equals(mapOfJakartaProvider)) {
+          matched = true;
+          assertTrue(contains);
+          mapJakartaProviderMatch = true;
         } else if (key.equals(mapOfJavaxProvider)) {
           matched = true;
           assertTrue(contains);
@@ -495,6 +556,10 @@ private static <T> void mapModuleTest(
           matched = true;
           assertTrue(contains);
           mapSetProviderMatch = true;
+        } else if (key.equals(mapOfSetOfJakartaProvider)) {
+          matched = true;
+          assertTrue(contains);
+          mapSetJakartaProviderMatch = true;
         } else if (key.equals(mapOfSetOfJavaxProvider)) {
           matched = true;
           assertTrue(contains);
@@ -503,6 +568,10 @@ private static <T> void mapModuleTest(
           matched = true;
           assertTrue(contains);
           mapCollectionProviderMatch = true;
+        } else if (key.equals(mapOfCollectionOfJakartaProvider)) {
+          matched = true;
+          assertTrue(contains);
+          mapCollectionJakartaProviderMatch = true;
         } else if (key.equals(mapOfCollectionOfJavaxProvider)) {
           matched = true;
           assertTrue(contains);
@@ -515,6 +584,10 @@ private static <T> void mapModuleTest(
           if (b != null) {
             assertTrue(b.acceptTargetVisitor(visitor) instanceof MultibinderBinding);
           }
+        } else if (key.equals(setOfJakartaEntry)) {
+          matched = true;
+          assertTrue(contains);
+          entrySetJakartaMatch = true;
         } else if (key.equals(setOfJavaxEntry)) {
           matched = true;
           assertTrue(contains);
@@ -523,6 +596,10 @@ private static <T> void mapModuleTest(
           matched = true;
           assertTrue(contains);
           collectionOfProvidersOfEntryOfProviderMatch = true;
+        } else if (key.equals(collectionOfJakartaProvidersOfEntryOfProvider)) {
+          matched = true;
+          assertTrue(contains);
+          collectionOfJakartaProvidersOfEntryOfProviderMatch = true;
         } else if (key.equals(collectionOfJavaxProvidersOfEntryOfProvider)) {
           matched = true;
           assertTrue(contains);
@@ -555,17 +632,22 @@ private static <T> void mapModuleTest(
         otherMatchesSize);
 
     assertTrue(entrySetMatch);
+    assertTrue(entrySetJakartaMatch);
     assertTrue(entrySetJavaxMatch);
     assertTrue(mapProviderMatch);
+    assertTrue(mapJakartaProviderMatch);
     assertTrue(mapJavaxProviderMatch);
     assertTrue(collectionOfProvidersOfEntryOfProviderMatch);
+    assertTrue(collectionOfJakartaProvidersOfEntryOfProviderMatch);
     assertTrue(collectionOfJavaxProvidersOfEntryOfProviderMatch);
     assertTrue(setOfExtendsOfEntryOfProviderMatch);
     assertTrue(mapOfKeyExtendsValueKeyMatch);
     assertEquals(allowDuplicates, mapSetMatch);
     assertEquals(allowDuplicates, mapSetProviderMatch);
+    assertEquals(allowDuplicates, mapSetJakartaProviderMatch);
     assertEquals(allowDuplicates, mapSetJavaxProviderMatch);
     assertEquals(allowDuplicates, mapCollectionProviderMatch);
+    assertEquals(allowDuplicates, mapCollectionJakartaProviderMatch);
     assertEquals(allowDuplicates, mapCollectionJavaxProviderMatch);
     assertEquals(
         "other MapBindings found: " + otherMapBindings,
@@ -620,6 +702,8 @@ private static <T> void setInjectorTest(
       int otherMultibindings,
       BindResult<T>... results) {
     Key<?> collectionOfProvidersKey = setKey.ofType(collectionOfProvidersOf(elementType));
+    Key<?> collectionOfJakartaProvidersKey =
+        setKey.ofType(collectionOfJakartaProvidersOf(elementType));
     Key<?> collectionOfJavaxProvidersKey = setKey.ofType(collectionOfJavaxProvidersOf(elementType));
     Key<?> setOfExtendsKey = setKey.ofType(setOfExtendsOf(elementType));
     Injector injector = Guice.createInjector(modules);
@@ -632,7 +716,11 @@ private static <T> void setInjectorTest(
     assertEquals(elementType, multibinder.getElementTypeLiteral());
     assertEquals(allowDuplicates, multibinder.permitsDuplicates());
     assertEquals(
-        ImmutableSet.of(collectionOfProvidersKey, collectionOfJavaxProvidersKey, setOfExtendsKey),
+        ImmutableSet.of(
+            collectionOfProvidersKey,
+            collectionOfJakartaProvidersKey,
+            collectionOfJavaxProvidersKey,
+            setOfExtendsKey),
         multibinder.getAlternateSetKeys());
     List<Binding<?>> elements = Lists.newArrayList(multibinder.getElements());
     List<BindResult<?>> bindResults = Lists.newArrayList(results);
@@ -670,6 +758,7 @@ private static <T> void setInjectorTest(
     List<Object> otherMultibinders = Lists.newArrayList();
     List<Binding<?>> otherContains = Lists.newArrayList();
     boolean collectionOfProvidersMatch = false;
+    boolean collectionOfJakartaProvidersMatch = false;
     boolean collectionOfJavaxProvidersMatch = false;
     boolean setOfExtendsKeyMatch = false;
     for (Binding<?> b : injector.getAllBindings().values()) {
@@ -687,6 +776,9 @@ private static <T> void setInjectorTest(
       } else if (key.equals(collectionOfProvidersKey)) {
         assertTrue(contains);
         collectionOfProvidersMatch = true;
+      } else if (key.equals(collectionOfJakartaProvidersKey)) {
+        assertTrue(contains);
+        collectionOfJakartaProvidersMatch = true;
       } else if (key.equals(collectionOfJavaxProvidersKey)) {
         assertTrue(contains);
         collectionOfJavaxProvidersMatch = true;
@@ -701,6 +793,7 @@ private static <T> void setInjectorTest(
     }
 
     assertTrue(collectionOfProvidersMatch);
+    assertTrue(collectionOfJakartaProvidersMatch);
     assertTrue(collectionOfJavaxProvidersMatch);
     assertTrue(setOfExtendsKeyMatch);
 
@@ -724,6 +817,8 @@ private static <T> void setModuleTest(
       int otherMultibindings,
       BindResult<?>... results) {
     Key<?> collectionOfProvidersKey = setKey.ofType(collectionOfProvidersOf(elementType));
+    Key<?> collectionOfJakartaProvidersKey =
+        setKey.ofType(collectionOfJakartaProvidersOf(elementType));
     Key<?> collectionOfJavaxProvidersKey = setKey.ofType(collectionOfJavaxProvidersOf(elementType));
     Key<?> setOfExtendsKey = setKey.ofType(setOfExtendsOf(elementType));
     List<BindResult<?>> bindResults = Lists.newArrayList(results);
@@ -741,7 +836,11 @@ private static <T> void setModuleTest(
     assertEquals(setKey, multibinder.getSetKey());
     assertEquals(elementType, multibinder.getElementTypeLiteral());
     assertEquals(
-        ImmutableSet.of(collectionOfProvidersKey, collectionOfJavaxProvidersKey, setOfExtendsKey),
+        ImmutableSet.of(
+            collectionOfProvidersKey,
+            collectionOfJakartaProvidersKey,
+            collectionOfJavaxProvidersKey,
+            setOfExtendsKey),
         multibinder.getAlternateSetKeys());
     List<Object> otherMultibinders = Lists.newArrayList();
     Set<Element> otherContains = new HashSet<>();
@@ -750,6 +849,7 @@ private static <T> void setModuleTest(
     Set<IndexedBinding> setOfIndexed = Sets.newHashSet();
     Indexer indexer = new Indexer(null);
     boolean collectionOfProvidersMatch = false;
+    boolean collectionOfJakartaProvidersMatch = false;
     boolean collectionOfJavaxProvidersMatch = false;
     boolean setOfExtendsMatch = false;
     for (Element element : elements) {
@@ -781,6 +881,10 @@ private static <T> void setModuleTest(
         assertTrue(contains);
         assertFalse(matched);
         collectionOfProvidersMatch = true;
+      } else if (collectionOfJakartaProvidersKey.equals(key)) {
+        assertTrue(contains);
+        assertFalse(matched);
+        collectionOfJakartaProvidersMatch = true;
       } else if (collectionOfJavaxProvidersKey.equals(key)) {
         assertTrue(contains);
         assertFalse(matched);
@@ -811,6 +915,7 @@ private static <T> void setModuleTest(
         otherMultibindings,
         otherMultibinders.size());
     assertTrue(collectionOfProvidersMatch);
+    assertTrue(collectionOfJakartaProvidersMatch);
     assertTrue(collectionOfJavaxProvidersMatch);
     assertTrue(setOfExtendsMatch);
 
@@ -953,15 +1058,20 @@ private static <T> void optionalInjectorTest(
         keyType.ofType(RealOptionalBinder.optionalOfJavaxProvider(keyType.getTypeLiteral()));
     Key<?> javaOptionalJavaxProviderKey =
         keyType.ofType(RealOptionalBinder.javaOptionalOfJavaxProvider(keyType.getTypeLiteral()));
+    Key<Optional<jakarta.inject.Provider<T>>> optionalJakartaProviderKey =
+        keyType.ofType(RealOptionalBinder.optionalOfJakartaProvider(keyType.getTypeLiteral()));
+    Key<?> javaOptionalJakartaProviderKey =
+        keyType.ofType(RealOptionalBinder.javaOptionalOfJakartaProvider(keyType.getTypeLiteral()));
     Key<Optional<Provider<T>>> optionalProviderKey =
         keyType.ofType(RealOptionalBinder.optionalOfProvider(keyType.getTypeLiteral()));
     Key<?> javaOptionalProviderKey =
         keyType.ofType(RealOptionalBinder.javaOptionalOfProvider(keyType.getTypeLiteral()));
     assertEquals(
-        ImmutableSet.of(optionalJavaxProviderKey, optionalProviderKey),
+        ImmutableSet.of(optionalJavaxProviderKey, optionalJakartaProviderKey, optionalProviderKey),
         optionalBinder.getAlternateKeys());
     assertEquals(
-        ImmutableSet.of(javaOptionalJavaxProviderKey, javaOptionalProviderKey),
+        ImmutableSet.of(
+            javaOptionalJavaxProviderKey, javaOptionalJakartaProviderKey, javaOptionalProviderKey),
         javaOptionalBinder.getAlternateKeys());
 
     boolean keyMatch = false;
@@ -969,6 +1079,8 @@ private static <T> void optionalInjectorTest(
     boolean javaOptionalKeyMatch = false;
     boolean optionalJavaxProviderKeyMatch = false;
     boolean javaOptionalJavaxProviderKeyMatch = false;
+    boolean optionalJakartaProviderKeyMatch = false;
+    boolean javaOptionalJakartaProviderKeyMatch = false;
     boolean optionalProviderKeyMatch = false;
     boolean javaOptionalProviderKeyMatch = false;
     boolean defaultMatch = false;
@@ -1008,6 +1120,12 @@ private static <T> void optionalInjectorTest(
       } else if (b.getKey().equals(javaOptionalJavaxProviderKey)) {
         assertTrue(contains);
         javaOptionalJavaxProviderKeyMatch = true;
+      } else if (b.getKey().equals(optionalJakartaProviderKey)) {
+        assertTrue(contains);
+        optionalJakartaProviderKeyMatch = true;
+      } else if (b.getKey().equals(javaOptionalJakartaProviderKey)) {
+        assertTrue(contains);
+        javaOptionalJakartaProviderKeyMatch = true;
       } else if (b.getKey().equals(optionalProviderKey)) {
         assertTrue(contains);
         optionalProviderKeyMatch = true;
@@ -1030,9 +1148,11 @@ private static <T> void optionalInjectorTest(
     assertEquals(expectedDefault != null || expectedActual != null, keyMatch);
     assertTrue(optionalKeyMatch);
     assertTrue(optionalJavaxProviderKeyMatch);
+    assertTrue(optionalJakartaProviderKeyMatch);
     assertTrue(optionalProviderKeyMatch);
     assertTrue(javaOptionalKeyMatch);
     assertTrue(javaOptionalJavaxProviderKeyMatch);
+    assertTrue(javaOptionalJakartaProviderKeyMatch);
     assertTrue(javaOptionalProviderKeyMatch);
     assertEquals(expectedDefault != null, defaultMatch);
     assertEquals(expectedActual != null, actualMatch);
@@ -1093,6 +1213,10 @@ private static <T> void optionalModuleTest(
         keyType.ofType(RealOptionalBinder.optionalOfJavaxProvider(keyType.getTypeLiteral()));
     Key<?> javaOptionalJavaxProviderKey =
         keyType.ofType(RealOptionalBinder.javaOptionalOfJavaxProvider(keyType.getTypeLiteral()));
+    Key<Optional<jakarta.inject.Provider<T>>> optionalJakartaProviderKey =
+        keyType.ofType(RealOptionalBinder.optionalOfJakartaProvider(keyType.getTypeLiteral()));
+    Key<?> javaOptionalJakartaProviderKey =
+        keyType.ofType(RealOptionalBinder.javaOptionalOfJakartaProvider(keyType.getTypeLiteral()));
     Key<Optional<Provider<T>>> optionalProviderKey =
         keyType.ofType(RealOptionalBinder.optionalOfProvider(keyType.getTypeLiteral()));
     Key<?> javaOptionalProviderKey =
@@ -1102,6 +1226,8 @@ private static <T> void optionalModuleTest(
     boolean javaOptionalKeyMatch = false;
     boolean optionalJavaxProviderKeyMatch = false;
     boolean javaOptionalJavaxProviderKeyMatch = false;
+    boolean optionalJakartaProviderKeyMatch = false;
+    boolean javaOptionalJakartaProviderKeyMatch = false;
     boolean optionalProviderKeyMatch = false;
     boolean javaOptionalProviderKeyMatch = false;
     boolean defaultMatch = false;
@@ -1154,6 +1280,12 @@ private static <T> void optionalModuleTest(
       } else if (key != null && key.equals(javaOptionalJavaxProviderKey)) {
         assertTrue(contains);
         javaOptionalJavaxProviderKeyMatch = true;
+      } else if (key != null && key.equals(optionalJakartaProviderKey)) {
+        assertTrue(contains);
+        optionalJakartaProviderKeyMatch = true;
+      } else if (key != null && key.equals(javaOptionalJakartaProviderKey)) {
+        assertTrue(contains);
+        javaOptionalJakartaProviderKeyMatch = true;
       } else if (key != null && key.equals(optionalProviderKey)) {
         assertTrue(contains);
         optionalProviderKeyMatch = true;
@@ -1182,9 +1314,11 @@ private static <T> void optionalModuleTest(
     assertEquals(expectedDefault != null || expectedActual != null, keyMatch);
     assertTrue(optionalKeyMatch);
     assertTrue(optionalJavaxProviderKeyMatch);
+    assertTrue(optionalJakartaProviderKeyMatch);
     assertTrue(optionalProviderKeyMatch);
     assertTrue(javaOptionalKeyMatch);
     assertTrue(javaOptionalJavaxProviderKeyMatch);
+    assertTrue(javaOptionalJakartaProviderKeyMatch);
     assertTrue(javaOptionalProviderKeyMatch);
     assertEquals(expectedDefault != null, defaultMatch);
     assertEquals(expectedActual != null, actualMatch);