diff --git a/java/androidmk.go b/java/androidmk.go
index a52d439..e1b4efd 100644
--- a/java/androidmk.go
+++ b/java/androidmk.go
@@ -211,7 +211,7 @@
 	return []android.AndroidMkEntries{android.AndroidMkEntries{
 		Class:        "JAVA_LIBRARIES",
 		OverrideName: prebuilt.BaseModuleName(),
-		OutputFile:   android.OptionalPathForPath(prebuilt.combinedImplementationFile),
+		OutputFile:   android.OptionalPathForPath(prebuilt.combinedClasspathFile),
 		Include:      "$(BUILD_SYSTEM)/soong_java_prebuilt.mk",
 		ExtraEntries: []android.AndroidMkExtraEntriesFunc{
 			func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
@@ -219,8 +219,8 @@
 				if prebuilt.dexJarFile.IsSet() {
 					entries.SetPath("LOCAL_SOONG_DEX_JAR", prebuilt.dexJarFile.Path())
 				}
-				entries.SetPath("LOCAL_SOONG_HEADER_JAR", prebuilt.combinedHeaderFile)
-				entries.SetPath("LOCAL_SOONG_CLASSES_JAR", prebuilt.combinedImplementationFile)
+				entries.SetPath("LOCAL_SOONG_HEADER_JAR", prebuilt.combinedClasspathFile)
+				entries.SetPath("LOCAL_SOONG_CLASSES_JAR", prebuilt.combinedClasspathFile)
 				entries.SetString("LOCAL_SDK_VERSION", prebuilt.sdkVersion.String())
 				entries.SetString("LOCAL_MODULE_STEM", prebuilt.Stem())
 				// TODO(b/289117800): LOCAL_ACONFIG_FILES for prebuilts
diff --git a/java/java.go b/java/java.go
index 7bf9fac..ad10cbd 100644
--- a/java/java.go
+++ b/java/java.go
@@ -21,7 +21,6 @@
 import (
 	"fmt"
 	"path/filepath"
-	"slices"
 	"sort"
 	"strings"
 
@@ -2338,9 +2337,6 @@
 	// List of shared java libs that this module has dependencies to
 	Libs []string
 
-	// List of static java libs that this module has dependencies to
-	Static_libs []string
-
 	// List of files to remove from the jar file(s)
 	Exclude_files []string
 
@@ -2393,10 +2389,9 @@
 	dexJarFileErr     error
 	dexJarInstallFile android.Path
 
-	combinedImplementationFile android.Path
-	combinedHeaderFile         android.Path
-	classLoaderContexts        dexpreopt.ClassLoaderContextMap
-	exportAidlIncludeDirs      android.Paths
+	combinedClasspathFile android.Path
+	classLoaderContexts   dexpreopt.ClassLoaderContextMap
+	exportAidlIncludeDirs android.Paths
 
 	hideApexVariantFromMake bool
 
@@ -2480,7 +2475,6 @@
 
 func (j *Import) DepsMutator(ctx android.BottomUpMutatorContext) {
 	ctx.AddVariationDependencies(nil, libTag, j.properties.Libs...)
-	ctx.AddVariationDependencies(nil, staticLibTag, j.properties.Static_libs...)
 
 	if ctx.Device() && Bool(j.dexProperties.Compile_dex) {
 		sdkDeps(ctx, android.SdkContext(j), j.dexer)
@@ -2510,13 +2504,23 @@
 func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 	j.commonBuildActions(ctx)
 
+	jars := android.PathsForModuleSrc(ctx, j.properties.Jars)
+
+	jarName := j.Stem() + ".jar"
+	outputFile := android.PathForModuleOut(ctx, "combined", jarName)
+	TransformJarsToJar(ctx, outputFile, "for prebuilts", jars, android.OptionalPath{},
+		false, j.properties.Exclude_files, j.properties.Exclude_dirs)
+	if Bool(j.properties.Jetifier) {
+		inputFile := outputFile
+		outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
+		TransformJetifier(ctx, outputFile, inputFile)
+	}
+	j.combinedClasspathFile = outputFile
 	j.classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
 
 	var flags javaBuilderFlags
 
 	j.collectTransitiveHeaderJars(ctx)
-	var staticJars android.Paths
-	var staticHeaderJars android.Paths
 	ctx.VisitDirectDeps(func(module android.Module) {
 		tag := ctx.OtherModuleDependencyTag(module)
 		if dep, ok := android.OtherModuleProvider(ctx, module, JavaInfoProvider); ok {
@@ -2526,8 +2530,6 @@
 				flags.dexClasspath = append(flags.dexClasspath, dep.HeaderJars...)
 			case staticLibTag:
 				flags.classpath = append(flags.classpath, dep.HeaderJars...)
-				staticJars = append(staticJars, dep.ImplementationAndResourcesJars...)
-				staticHeaderJars = append(staticHeaderJars, dep.HeaderJars...)
 			case bootClasspathTag:
 				flags.bootClasspath = append(flags.bootClasspath, dep.HeaderJars...)
 			}
@@ -2541,46 +2543,6 @@
 		addCLCFromDep(ctx, module, j.classLoaderContexts)
 	})
 
-	jars := android.PathsForModuleSrc(ctx, j.properties.Jars)
-	jarName := j.Stem() + ".jar"
-
-	// Always pass the input jars to TransformJarsToJar, even if there is only a single jar, we need the output
-	// file of the module to be named jarName.
-	outputFile := android.PathForModuleOut(ctx, "combined", jarName)
-	implementationJars := append(slices.Clone(jars), staticJars...)
-	TransformJarsToJar(ctx, outputFile, "combine prebuilt implementation jars", implementationJars, android.OptionalPath{},
-		false, j.properties.Exclude_files, j.properties.Exclude_dirs)
-
-	// If no dependencies have separate header jars then there is no need to create a separate
-	// header jar for this module.
-	reuseImplementationJarAsHeaderJar := slices.Equal(staticJars, staticHeaderJars)
-
-	var headerOutputFile android.WritablePath
-	if reuseImplementationJarAsHeaderJar {
-		headerOutputFile = outputFile
-	} else {
-		headerJars := append(slices.Clone(jars), staticHeaderJars...)
-		headerOutputFile = android.PathForModuleOut(ctx, "turbine-combined", jarName)
-		TransformJarsToJar(ctx, headerOutputFile, "combine prebuilt header jars", headerJars, android.OptionalPath{},
-			false, j.properties.Exclude_files, j.properties.Exclude_dirs)
-	}
-
-	if Bool(j.properties.Jetifier) {
-		inputFile := outputFile
-		outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
-		TransformJetifier(ctx, outputFile, inputFile)
-
-		if !reuseImplementationJarAsHeaderJar {
-			headerInputFile := headerOutputFile
-			headerOutputFile = android.PathForModuleOut(ctx, "jetifier-headers", jarName)
-			TransformJetifier(ctx, headerOutputFile, headerInputFile)
-		} else {
-			headerOutputFile = outputFile
-		}
-	}
-	j.combinedHeaderFile = headerOutputFile
-	j.combinedImplementationFile = outputFile
-
 	j.maybeInstall(ctx, jarName, outputFile)
 
 	j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.properties.Aidl.Export_include_dirs)
@@ -2664,11 +2626,11 @@
 	}
 
 	android.SetProvider(ctx, JavaInfoProvider, JavaInfo{
-		HeaderJars:                     android.PathsIfNonNil(j.combinedHeaderFile),
+		HeaderJars:                     android.PathsIfNonNil(j.combinedClasspathFile),
 		TransitiveLibsHeaderJars:       j.transitiveLibsHeaderJars,
 		TransitiveStaticLibsHeaderJars: j.transitiveStaticLibsHeaderJars,
-		ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedImplementationFile),
-		ImplementationJars:             android.PathsIfNonNil(j.combinedImplementationFile),
+		ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedClasspathFile),
+		ImplementationJars:             android.PathsIfNonNil(j.combinedClasspathFile),
 		AidlIncludeDirs:                j.exportAidlIncludeDirs,
 		StubsLinkType:                  j.stubsLinkType,
 		// TODO(b/289117800): LOCAL_ACONFIG_FILES for prebuilts
@@ -2696,7 +2658,7 @@
 func (j *Import) OutputFiles(tag string) (android.Paths, error) {
 	switch tag {
 	case "", ".jar":
-		return android.Paths{j.combinedImplementationFile}, nil
+		return android.Paths{j.combinedClasspathFile}, nil
 	default:
 		return nil, fmt.Errorf("unsupported module reference tag %q", tag)
 	}
@@ -2705,11 +2667,17 @@
 var _ android.OutputFileProducer = (*Import)(nil)
 
 func (j *Import) HeaderJars() android.Paths {
-	return android.PathsIfNonNil(j.combinedHeaderFile)
+	if j.combinedClasspathFile == nil {
+		return nil
+	}
+	return android.Paths{j.combinedClasspathFile}
 }
 
 func (j *Import) ImplementationAndResourcesJars() android.Paths {
-	return android.PathsIfNonNil(j.combinedImplementationFile)
+	if j.combinedClasspathFile == nil {
+		return nil
+	}
+	return android.Paths{j.combinedClasspathFile}
 }
 
 func (j *Import) DexJarBuildPath(ctx android.ModuleErrorfContext) OptionalDexJarPath {
diff --git a/java/java_test.go b/java/java_test.go
index 2676aa5..194f9d9 100644
--- a/java/java_test.go
+++ b/java/java_test.go
@@ -588,11 +588,10 @@
 	javac := fooModule.Rule("javac")
 	combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
 	barModule := ctx.ModuleForTests("bar", "android_common")
-	barJar := barModule.Output("combined/bar.jar").Output
+	barJar := barModule.Rule("combineJar").Output
 	bazModule := ctx.ModuleForTests("baz", "android_common")
 	bazJar := bazModule.Rule("combineJar").Output
-	sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").
-		Output("combined/sdklib.stubs.jar").Output
+	sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").Rule("combineJar").Output
 
 	fooLibrary := fooModule.Module().(*Library)
 	assertDeepEquals(t, "foo unique sources incorrect",
@@ -1036,7 +1035,7 @@
 	}
 }
 
-func TestJavaLibraryOutputFiles(t *testing.T) {
+func TestJavaLibrary(t *testing.T) {
 	testJavaWithFS(t, "", map[string][]byte{
 		"libcore/Android.bp": []byte(`
 				java_library {
@@ -1053,7 +1052,7 @@
 	})
 }
 
-func TestJavaImportOutputFiles(t *testing.T) {
+func TestJavaImport(t *testing.T) {
 	testJavaWithFS(t, "", map[string][]byte{
 		"libcore/Android.bp": []byte(`
 				java_import {
@@ -1069,85 +1068,6 @@
 	})
 }
 
-func TestJavaImport(t *testing.T) {
-	bp := `
-		java_library {
-			name: "source_library",
-			srcs: ["source.java"],
-		}
-
-		java_import {
-			name: "import_with_no_deps",
-			jars: ["no_deps.jar"],
-		}
-
-		java_import {
-			name: "import_with_source_deps",
-			jars: ["source_deps.jar"],
-			static_libs: ["source_library"],
-		}
-
-		java_import {
-			name: "import_with_import_deps",
-			jars: ["import_deps.jar"],
-			static_libs: ["import_with_no_deps"],
-		}
-	`
-	ctx := android.GroupFixturePreparers(
-		PrepareForTestWithJavaDefaultModules,
-	).RunTestWithBp(t, bp)
-
-	source := ctx.ModuleForTests("source_library", "android_common")
-	sourceJar := source.Output("javac/source_library.jar")
-	sourceHeaderJar := source.Output("turbine-combined/source_library.jar")
-	sourceJavaInfo, _ := android.SingletonModuleProvider(ctx, source.Module(), JavaInfoProvider)
-
-	// The source library produces separate implementation and header jars
-	android.AssertPathsRelativeToTopEquals(t, "source library implementation jar",
-		[]string{sourceJar.Output.String()}, sourceJavaInfo.ImplementationAndResourcesJars)
-	android.AssertPathsRelativeToTopEquals(t, "source library header jar",
-		[]string{sourceHeaderJar.Output.String()}, sourceJavaInfo.HeaderJars)
-
-	importWithNoDeps := ctx.ModuleForTests("import_with_no_deps", "android_common")
-	importWithNoDepsJar := importWithNoDeps.Output("combined/import_with_no_deps.jar")
-	importWithNoDepsJavaInfo, _ := android.SingletonModuleProvider(ctx, importWithNoDeps.Module(), JavaInfoProvider)
-
-	// An import with no deps produces a single jar used as both the header and implementation jar.
-	android.AssertPathsRelativeToTopEquals(t, "import with no deps implementation jar",
-		[]string{importWithNoDepsJar.Output.String()}, importWithNoDepsJavaInfo.ImplementationAndResourcesJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with no deps header jar",
-		[]string{importWithNoDepsJar.Output.String()}, importWithNoDepsJavaInfo.HeaderJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with no deps combined inputs",
-		[]string{"no_deps.jar"}, importWithNoDepsJar.Inputs)
-
-	importWithSourceDeps := ctx.ModuleForTests("import_with_source_deps", "android_common")
-	importWithSourceDepsJar := importWithSourceDeps.Output("combined/import_with_source_deps.jar")
-	importWithSourceDepsHeaderJar := importWithSourceDeps.Output("turbine-combined/import_with_source_deps.jar")
-	importWithSourceDepsJavaInfo, _ := android.SingletonModuleProvider(ctx, importWithSourceDeps.Module(), JavaInfoProvider)
-
-	// An import with source deps produces separate header and implementation jars.
-	android.AssertPathsRelativeToTopEquals(t, "import with source deps implementation jar",
-		[]string{importWithSourceDepsJar.Output.String()}, importWithSourceDepsJavaInfo.ImplementationAndResourcesJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with source deps header jar",
-		[]string{importWithSourceDepsHeaderJar.Output.String()}, importWithSourceDepsJavaInfo.HeaderJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with source deps combined implementation jar inputs",
-		[]string{"source_deps.jar", sourceJar.Output.String()}, importWithSourceDepsJar.Inputs)
-	android.AssertPathsRelativeToTopEquals(t, "import with source deps combined header jar inputs",
-		[]string{"source_deps.jar", sourceHeaderJar.Output.String()}, importWithSourceDepsHeaderJar.Inputs)
-
-	importWithImportDeps := ctx.ModuleForTests("import_with_import_deps", "android_common")
-	importWithImportDepsJar := importWithImportDeps.Output("combined/import_with_import_deps.jar")
-	importWithImportDepsJavaInfo, _ := android.SingletonModuleProvider(ctx, importWithImportDeps.Module(), JavaInfoProvider)
-
-	// An import with only import deps produces a single jar used as both the header and implementation jar.
-	android.AssertPathsRelativeToTopEquals(t, "import with import deps implementation jar",
-		[]string{importWithImportDepsJar.Output.String()}, importWithImportDepsJavaInfo.ImplementationAndResourcesJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with import deps header jar",
-		[]string{importWithImportDepsJar.Output.String()}, importWithImportDepsJavaInfo.HeaderJars)
-	android.AssertPathsRelativeToTopEquals(t, "import with import deps combined implementation jar inputs",
-		[]string{"import_deps.jar", importWithNoDepsJar.Output.String()}, importWithImportDepsJar.Inputs)
-}
-
 var compilerFlagsTestCases = []struct {
 	in  string
 	out bool