diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ddc0da0cb7..1a6cf82fdc 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -224,6 +224,7 @@ jobs:
           publishToSonatype
           closeAndReleaseStagingRepositories
           releaseSummary
+          --info
           --stacktrace
         env:
           GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
diff --git a/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts
index 458efe9c47..29aab3a9dd 100644
--- a/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts
+++ b/buildSrc/src/main/kotlin/mockito.javadoc-conventions.gradle.kts
@@ -15,6 +15,10 @@ tasks.named<Javadoc>("javadoc") {
     inputs.dir(javadocConfigDir)
     description = "Creates javadoc html for ${project.name}."
 
+    // Work-around as suggested in https://github.com/gradle/gradle/issues/19726
+    val sourceSetDirectories = sourceSets.main.get().java.sourceDirectories.joinToString(":")
+    val coreOptions = options as CoreJavadocOptions
+    coreOptions.addStringOption("-source-path", sourceSetDirectories)
     exclude("**/internal/**")
 
     // For more details on the format
diff --git a/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts b/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts
index 9e912f0347..5f896044fc 100644
--- a/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts
+++ b/buildSrc/src/main/kotlin/mockito.quality-spotless-conventions.gradle.kts
@@ -1,6 +1,8 @@
 import com.diffplug.gradle.spotless.SpotlessExtension
+import com.diffplug.spotless.FormatterFunc
 import com.google.googlejavaformat.java.Formatter
 import com.google.googlejavaformat.java.JavaFormatterOptions
+import java.io.Serializable
 
 plugins {
     id("com.diffplug.spotless")
@@ -13,16 +15,20 @@ configure<SpotlessExtension> {
     java {
         licenseHeaderFile(rootProject.file("config/spotless/spotless.header"))
 
-        // not using stock googleJavaFormat due to missing options like reorderModifiers
-        custom("google-java-format") {
-            val formatterOptions = JavaFormatterOptions.builder()
-                .style(JavaFormatterOptions.Style.AOSP)
-                .reorderModifiers(true)
-                .formatJavadoc(false)
-                .build()
-
-            Formatter(formatterOptions).formatSource(it)
-        }
+        // Not using stock googleJavaFormat due to missing options like reorderModifiers
+        // Also, using the Serializable interface to work around bug in spotless 7.0.0
+        // https://github.com/diffplug/spotless/issues/2387
+        custom("google-java-format", object : Serializable, FormatterFunc {
+            override fun apply(input: String): String {
+                val formatterOptions = JavaFormatterOptions.builder()
+                    .style(JavaFormatterOptions.Style.AOSP)
+                    .reorderModifiers(true)
+                    .formatJavadoc(false)
+                    .build()
+
+                return Formatter(formatterOptions).formatSource(input)
+            }
+        })
 
         toggleOffOn()
     }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index ff89f56a38..2e02e29680 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -10,14 +10,14 @@ gradleplugin-test-logger = "4.0.0"
 gradleplugin-animal-sniffer = "1.7.2"
 gradleplugin-aQute-bnd = "7.1.0"
 gradleplugin-errorprone = "4.1.0"
-gradleplugin-spotless = "6.25.0"
+gradleplugin-spotless = "7.0.2"
 
 gradleplugin-android = "7.4.2"
 
 [libraries]
 android-junit = { module = "androidx.test.ext:junit", version = "1.2.1" }
 android-runner = { module = "androidx.test:runner", version = "1.6.2" }
-assertj = { module = "org.assertj:assertj-core", version = "3.27.1" }
+assertj = { module = "org.assertj:assertj-core", version = "3.27.3" }
 autoservice = { module = "com.google.auto.service:auto-service", version = "1.1.1" }
 bnd-gradle = { module = "biz.aQute.bnd:biz.aQute.bnd.gradle", version.ref = "gradleplugin-aQute-bnd" }
 bytebuddy = { module = "net.bytebuddy:byte-buddy", version.ref = "bytebuddy" }
diff --git a/mockito-core/build.gradle.kts b/mockito-core/build.gradle.kts
index 3686d18538..0c15d91275 100644
--- a/mockito-core/build.gradle.kts
+++ b/mockito-core/build.gradle.kts
@@ -1,4 +1,9 @@
 import com.android.build.gradle.internal.tasks.factory.dependsOn
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.ClassWriter
+import org.objectweb.asm.ModuleVisitor
+import org.objectweb.asm.Opcodes
 
 plugins {
     id("mockito.library-conventions")
@@ -70,11 +75,40 @@ tasks {
 
         from(sourceSets.main.flatMap { it.java.classesDirectory }
             .map { it.file("org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class") })
-        into(generatedInlineResource.map { it.dir("org/mockito/internal/creation/bytebuddy/inject") })
+        into(generatedInlineResource.map { it.dir("org/mockito/internal/creation/bytebuddy") })
 
-        rename("(.+)\\.class", "$1.raw")
+        rename(".*", "inject-MockMethodDispatcher.raw")
     }
+
+    val removeInjectionPackageFromModuleInfo by registering(DefaultTask::class) {
+        dependsOn(compileJava)
+
+        doLast {
+            val moduleInfo = sourceSets.main.get().output.classesDirs.first().resolve("module-info.class")
+
+            val reader = ClassReader(moduleInfo.readBytes())
+            val writer = ClassWriter(reader, 0)
+            reader.accept(object : ClassVisitor(Opcodes.ASM9, writer) {
+                override fun visitModule(name: String?, access: Int, version: String?): ModuleVisitor {
+                    return object : ModuleVisitor(
+                        Opcodes.ASM9,
+                        super.visitModule(name, access, version)
+                    ) {
+                        override fun visitPackage(packaze: String) {
+                            if (packaze != "org/mockito/internal/creation/bytebuddy/inject") {
+                                super.visitPackage(packaze)
+                            }
+                        }
+                    }
+                }
+            }, 0)
+
+            moduleInfo.writeBytes(writer.toByteArray())
+        }
+    }
+
     classes.dependsOn(copyMockMethodDispatcher)
+    classes.dependsOn(removeInjectionPackageFromModuleInfo)
 
 
     jar {
@@ -112,8 +146,8 @@ tasks {
                 # Export rules for public and internal packages
                 # https://bnd.bndtools.org/heads/export_package.html
                 Export-Package: \
-                    org.mockito.internal.*;status=INTERNAL;mandatory:=status;version=${archiveVersion.get()}, \
-                    org.mockito.*;version=${archiveVersion.get()}
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.internal.*;status=INTERNAL;mandatory:=status;version=${archiveVersion.get()}, \
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.*;version=${archiveVersion.get()}
 
                 # General rules for package import
                 # https://bnd.bndtools.org/heads/import_package.html
@@ -132,15 +166,12 @@ tasks {
                     org.hamcrest;resolution:=optional, \
                     org.objenesis;version="[3.1,4.0)", \
                     org.opentest4j.*;resolution:=optional, \
-                    org.mockito.*
+                    !org.mockito.internal.creation.bytebuddy.inject,org.mockito.*
 
                 # Don't add the Private-Package header.
                 # See https://bnd.bndtools.org/instructions/removeheaders.html
                 -removeheaders: Private-Package
 
-                # Configures the automatic module name for Java 9+.
-                Automatic-Module-Name: org.mockito
-
                 # Don't add all the extra headers bnd normally adds.
                 # See https://bnd.bndtools.org/instructions/noextraheaders.html
                 -noextraheaders: true
diff --git a/mockito-core/src/main/java/module-info.java b/mockito-core/src/main/java/module-info.java
new file mode 100644
index 0000000000..6a76ff81b3
--- /dev/null
+++ b/mockito-core/src/main/java/module-info.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+module org.mockito {
+    requires java.instrument;
+    requires jdk.attach;
+    requires net.bytebuddy;
+    requires net.bytebuddy.agent;
+    requires static junit;
+    requires static org.hamcrest;
+    requires static org.opentest4j;
+    requires static jdk.unsupported;
+
+    exports org.mockito;
+    exports org.mockito.configuration;
+    exports org.mockito.creation.instance;
+    exports org.mockito.exceptions.base;
+    exports org.mockito.exceptions.misusing;
+    exports org.mockito.exceptions.verification;
+    exports org.mockito.exceptions.verification.junit;
+    exports org.mockito.exceptions.verification.opentest4j;
+    exports org.mockito.hamcrest;
+    exports org.mockito.invocation;
+    exports org.mockito.junit;
+    exports org.mockito.listeners;
+    exports org.mockito.mock;
+    exports org.mockito.plugins;
+    exports org.mockito.quality;
+    exports org.mockito.session;
+    exports org.mockito.stubbing;
+    exports org.mockito.verification;
+    exports org.mockito.internal.configuration to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.session to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.configuration.plugins to
+            org.mockito.junit.jupiter;
+    exports org.mockito.internal.util to
+            org.mockito.junit.jupiter;
+}
diff --git a/mockito-core/src/main/java/org/mockito/Mockito.java b/mockito-core/src/main/java/org/mockito/Mockito.java
index ba71195cd9..e69919d56f 100644
--- a/mockito-core/src/main/java/org/mockito/Mockito.java
+++ b/mockito-core/src/main/java/org/mockito/Mockito.java
@@ -175,6 +175,9 @@
  * to attach a Java agent to their own JVM</a>. As a result, the inline-mock-maker might not be able
  * to function without an explicit setup to enable instrumentation, and the JVM will always display a warning.
  *
+ * The following are examples about how to set up mockito-core as a Java agent, and it may be more appropriate to choose
+ * a different approach depending on your project constraints.
+ *
  * <p>
  * To explicitly attach Mockito during test execution, the library's jar file needs to be specified as <code>-javaagent</code>
  * as an argument to the executing JVM. To enable this in Gradle, the following example adds Mockito to all test
@@ -188,7 +191,7 @@
  * }
  * tasks {
  *     test {
- *         jvmArgs("-javaagent:${mockitoAgent.asPath}")
+ *         jvmArgs.add("-javaagent:${mockitoAgent.asPath}")
  *     }
  * }
  * </code></pre>
@@ -244,9 +247,18 @@
  * &lt;/plugin&gt;
  * </code></pre>
  *
+ * <blockquote>
+ * Note however, that <code>@{argLine}</code> needs to exist when surefire performs its
+ * <a href="https://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#argLine">late replacement</a> otherwise
+ * it will just use the value verbatim which will crash the VM,
+ * <code>The forked VM terminated without properly saying goodbye. VM crash or System.exit called.</code>, in this case,
+ * you may need to adapt your maven configuration, for example by adding an empty <code>&lt;argLine/&gt;</code> property
+ * to the POM file.
+ * </blockquote>
+ *
  * <p>
- * To enable support for dynamic attach, it is also possible to start a JVM with
- * <pre>-XX:+EnableDynamicAgentLoading</pre>. Do however note that, since this option is not standardized, any future
+ * Alternatively, to enable support for dynamic attach, it is also possible to start a JVM with
+ * <code>-XX:+EnableDynamicAgentLoading</code> flag. Do however note that, since this option is not standardized, any future
  * release of a JDK might prohibit this behaviour.
  *
  * <h3 id="1">1. <a class="meaningful_link" href="#verification" name="verification">Let's verify some behaviour!</a></h3>
diff --git a/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java b/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
index 7331abc6ae..2676fbce3e 100644
--- a/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
+++ b/mockito-core/src/main/java/org/mockito/internal/PremainAttachAccess.java
@@ -46,11 +46,11 @@ public static Instrumentation getInstrumentation() {
                             Class.forName("java.lang.management.ManagementFactory")
                                     .getMethod("getRuntimeMXBean")
                                     .invoke(null);
+
                     @SuppressWarnings("unchecked")
                     List<String> arguments =
                             (List<String>)
-                                    runtimeMXBean
-                                            .getClass()
+                                    Class.forName("java.lang.management.RuntimeMXBean")
                                             .getMethod("getInputArguments")
                                             .invoke(runtimeMXBean);
                     dynamicAgentLoading =
diff --git a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
index b042a84396..262f7e78b8 100644
--- a/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
+++ b/mockito-core/src/main/java/org/mockito/internal/configuration/plugins/PluginInitializer.java
@@ -5,6 +5,7 @@
 package org.mockito.internal.configuration.plugins;
 
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Enumeration;
@@ -48,6 +49,7 @@ public <T> T loadImpl(Class<T> service) {
                     classOrAlias = DefaultMockitoPlugins.getDefaultPluginClass(classOrAlias);
                 }
                 Class<?> pluginClass = loader.loadClass(classOrAlias);
+                addReads(pluginClass);
                 Object plugin = pluginClass.getDeclaredConstructor().newInstance();
                 return service.cast(plugin);
             }
@@ -80,6 +82,7 @@ public <T> List<T> loadImpls(Class<T> service) {
                     classOrAlias = DefaultMockitoPlugins.getDefaultPluginClass(classOrAlias);
                 }
                 Class<?> pluginClass = loader.loadClass(classOrAlias);
+                addReads(pluginClass);
                 Object plugin = pluginClass.getDeclaredConstructor().newInstance();
                 impls.add(service.cast(plugin));
             }
@@ -89,4 +92,17 @@ public <T> List<T> loadImpls(Class<T> service) {
                     "Failed to load " + service + " implementation declared in " + resources, e);
         }
     }
+
+    private static void addReads(Class<?> pluginClass) {
+        try {
+            Method getModule = Class.class.getMethod("getModule");
+            Method addReads =
+                    getModule.getReturnType().getMethod("addReads", getModule.getReturnType());
+            addReads.invoke(
+                    getModule.invoke(PluginInitializer.class), getModule.invoke(pluginClass));
+        } catch (NoSuchMethodException ignored) {
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
+    }
 }
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
index 973423f1a3..21237f981f 100644
--- a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
+++ b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
@@ -138,25 +138,29 @@ class InlineDelegateByteBuddyMockMaker
                 boot.deleteOnExit();
                 try (JarOutputStream outputStream =
                         new JarOutputStream(new FileOutputStream(boot))) {
-                    String source =
-                            "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher";
                     InputStream inputStream =
-                            InlineDelegateByteBuddyMockMaker.class
-                                    .getClassLoader()
-                                    .getResourceAsStream(source + ".raw");
+                            InlineDelegateByteBuddyMockMaker.class.getResourceAsStream(
+                                    "inject-MockMethodDispatcher.raw");
                     if (inputStream == null) {
                         throw new IllegalStateException(
                                 join(
                                         "The MockMethodDispatcher class file is not locatable: "
-                                                + source
-                                                + ".raw",
+                                                + "inject-MockMethodDispatcher.raw"
+                                                + " in context of "
+                                                + InlineDelegateByteBuddyMockMaker.class.getName(),
                                         "",
                                         "The class loader responsible for looking up the resource: "
                                                 + InlineDelegateByteBuddyMockMaker.class
-                                                        .getClassLoader()));
+                                                        .getClassLoader(),
+                                        "",
+                                        "The module responsible for looking up the resource: "
+                                                + InlineDelegateByteBuddyMockMaker.class
+                                                        .getModule()));
                     }
                     try (inputStream) {
-                        outputStream.putNextEntry(new JarEntry(source + ".class"));
+                        outputStream.putNextEntry(
+                                new JarEntry(
+                                        "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class"));
                         int length;
                         byte[] buffer = new byte[1024];
                         while ((length = inputStream.read(buffer)) != -1) {
@@ -168,11 +172,13 @@ class InlineDelegateByteBuddyMockMaker
                 try (JarFile jarfile = new JarFile(boot)) {
                     instrumentation.appendToBootstrapClassLoaderSearch(jarfile);
                 }
+                Class<?> dispatcher;
                 try {
-                    Class.forName(
-                            "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
-                            false,
-                            null);
+                    dispatcher =
+                            Class.forName(
+                                    "org.mockito.internal.creation.bytebuddy.inject.MockMethodDispatcher",
+                                    false,
+                                    null);
                 } catch (ClassNotFoundException cnfe) {
                     throw new IllegalStateException(
                             join(
@@ -181,6 +187,21 @@ class InlineDelegateByteBuddyMockMaker
                                     "It seems like your current VM does not support the instrumentation API correctly."),
                             cnfe);
                 }
+                try {
+                    InlineDelegateByteBuddyMockMaker.class
+                            .getModule()
+                            .addReads(dispatcher.getModule());
+                } catch (Exception e) {
+                    throw new IllegalStateException(
+                            join(
+                                    "Mockito failed to adjust the module graph to read the dispatcher module",
+                                    "",
+                                    "Dispatcher: "
+                                            + dispatcher
+                                            + " is loaded by "
+                                            + dispatcher.getClassLoader()),
+                            e);
+                }
             } catch (IOException ioe) {
                 throw new IllegalStateException(
                         join(
diff --git a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java b/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
deleted file mode 100644
index 5abed05fbe..0000000000
--- a/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/inject/package-info.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2007 Mockito contributors
- * This program is made available under the terms of the MIT License.
- */
-
-/**
- * Internal classes, not to be used by clients. Intended for injection into the bootstrap class loader.
- *
- * Subject to change at any time without notice.
- */
-package org.mockito.internal.creation.bytebuddy.inject;
diff --git a/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
index 93569efcf0..e01b1f1280 100644
--- a/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
+++ b/mockito-core/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
@@ -5,7 +5,8 @@
 package org.mockito.internal.util.reflection;
 
 import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.dynamic.loading.ByteArrayClassLoader;
+import net.bytebuddy.dynamic.loading.InjectionClassLoader;
 import net.bytebuddy.implementation.MethodCall;
 import org.mockito.exceptions.base.MockitoInitializationException;
 import org.mockito.internal.PremainAttachAccess;
@@ -52,6 +53,20 @@ class InstrumentationMemberAccessor implements MemberAccessor {
             // This way, we assure that classes within Mockito's module (which might be a shared,
             // unnamed module) do not face escalated privileges where tests might pass that would
             // otherwise fail without Mockito's opening.
+            InjectionClassLoader classLoader =
+                    new ByteArrayClassLoader(
+                            InstrumentationMemberAccessor.class.getClassLoader(),
+                            false,
+                            Collections.emptyMap());
+            instrumentation.redefineModule(
+                    Dispatcher.class.getModule(),
+                    Collections.emptySet(),
+                    Collections.singletonMap(
+                            Dispatcher.class.getPackageName(),
+                            Collections.singleton(classLoader.getUnnamedModule())),
+                    Collections.emptyMap(),
+                    Collections.emptySet(),
+                    Collections.emptyMap());
             dispatcher =
                     new ByteBuddy()
                             .subclass(Dispatcher.class)
@@ -78,12 +93,11 @@ class InstrumentationMemberAccessor implements MemberAccessor {
                                             .onArgument(0)
                                             .withArgument(1))
                             .make()
-                            .load(
-                                    InstrumentationMemberAccessor.class.getClassLoader(),
-                                    ClassLoadingStrategy.Default.WRAPPER)
+                            .load(classLoader, InjectionClassLoader.Strategy.INSTANCE)
                             .getLoaded()
                             .getConstructor()
                             .newInstance();
+            classLoader.seal();
             throwable = null;
         } catch (Throwable t) {
             instrumentation = null;
diff --git a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
index 36bf920552..19fc9ce581 100644
--- a/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
+++ b/mockito-core/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
@@ -528,13 +528,20 @@ protected static <T> MockCreationSettings<T> settingsFor(
     }
 
     @Test
-    public void testMockDispatcherIsRelocated() throws Exception {
+    public void testMockDispatcherIsRelocated() {
         assertThat(
                         InlineByteBuddyMockMaker.class
                                 .getClassLoader()
                                 .getResource(
-                                        "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.raw"))
+                                        "org/mockito/internal/creation/bytebuddy/inject-MockMethodDispatcher.raw"))
                 .isNotNull();
+
+        assertThat(
+                        InlineByteBuddyMockMaker.class
+                                .getClassLoader()
+                                .getResource(
+                                        "org/mockito/internal/creation/bytebuddy/inject/MockMethodDispatcher.class"))
+                .isNull();
     }
 
     private static final class FinalClass {
diff --git a/mockito-extensions/mockito-junit-jupiter/build.gradle.kts b/mockito-extensions/mockito-junit-jupiter/build.gradle.kts
index ddaeff2dc5..7f0dca43dd 100644
--- a/mockito-extensions/mockito-junit-jupiter/build.gradle.kts
+++ b/mockito-extensions/mockito-junit-jupiter/build.gradle.kts
@@ -53,9 +53,6 @@ tasks {
                 # See https://bnd.bndtools.org/instructions/removeheaders.html
                 -removeheaders: Private-Package
 
-                # Configures the automatic module name for Java 9+.
-                Automatic-Module-Name: org.mockito.junit.jupiter
-
                 # Don't add all the extra headers bnd normally adds.
                 # See https://bnd.bndtools.org/instructions/noextraheaders.html
                 -noextraheaders: true
diff --git a/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java b/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java
new file mode 100644
index 0000000000..1119e9a6c0
--- /dev/null
+++ b/mockito-extensions/mockito-junit-jupiter/src/main/java/module-info.java
@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+module org.mockito.junit.jupiter {
+    requires transitive org.mockito;
+    requires transitive org.junit.jupiter.api;
+
+    exports org.mockito.junit.jupiter;
+    exports org.mockito.junit.jupiter.resolver;
+}
diff --git a/mockito-integration-tests/module-named-tests/build.gradle.kts b/mockito-integration-tests/module-named-tests/build.gradle.kts
new file mode 100644
index 0000000000..68fc906460
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    id("java")
+    id("mockito.test-conventions")
+}
+
+description = "Test suite for Java 9 modules using a named declaration with Mockito"
+
+dependencies {
+    implementation(project(":mockito-core"))
+    testImplementation(libs.junit4)
+    testImplementation(libs.assertj)
+}
diff --git a/mockito-integration-tests/module-named-tests/src/test/java/module-info.java b/mockito-integration-tests/module-named-tests/src/test/java/module-info.java
new file mode 100644
index 0000000000..5f74e6c85a
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/src/test/java/module-info.java
@@ -0,0 +1,8 @@
+module org.mockito.test {
+    requires junit;
+    requires org.mockito;
+    requires org.assertj.core;
+
+    exports org.mockito.modulenamedtest to
+            junit;
+}
diff --git a/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java b/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java
new file mode 100644
index 0000000000..aa668bebda
--- /dev/null
+++ b/mockito-integration-tests/module-named-tests/src/test/java/org/mockito/modulenamedtest/ModuleUseTest.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.modulenamedtest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Test;
+
+public class ModuleUseTest {
+
+    @Test
+    public void can_mock_with_named_module() {
+        Foo foo = mock(Foo.class);
+        when(foo.value()).thenReturn("foo");
+        assertThat(foo.value()).isEqualTo("foo");
+    }
+
+    public static class Foo {
+
+        public String value() {
+            return null;
+        }
+    }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index ca8b0b74f6..62ab590cf3 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -13,7 +13,7 @@ dependencyResolutionManagement {
 }
 
 plugins {
-    id("com.gradle.develocity") version "3.19"
+    id("com.gradle.develocity") version "3.19.1"
     id("org.gradle.toolchains.foojay-resolver-convention") version "0.9.0"
 }
 
@@ -39,6 +39,7 @@ include(
     "mockito-integration-tests:junit-jupiter-extension-tests",
     "mockito-integration-tests:junit-jupiter-inline-mock-maker-extension-tests",
     "mockito-integration-tests:module-tests",
+    "mockito-integration-tests:module-named-tests",
     "mockito-integration-tests:memory-tests",
     "mockito-integration-tests:junit-jupiter-parallel-tests",
     "mockito-integration-tests:osgi-tests",