diff --git a/external/Java.Interop b/external/Java.Interop
index b881d21f51c..cfca8ad36ba 160000
--- a/external/Java.Interop
+++ b/external/Java.Interop
@@ -1 +1 @@
-Subproject commit b881d21f51cbac6e175de1b2f6c254fe3846aa1d
+Subproject commit cfca8ad36ba046f47d64bb8a60fe49e4f4723403
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
index 08b7b6c66bc..08316ff1787 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
@@ -208,18 +208,15 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A
 				continue;
 			}
 
-			// [JniAddNativeMethodRegistrationAttribute] is not supported by the trimmable typemap
-			// by design (see XA4251). Detect the attribute *before* any per-type filters below
-			// (array type, no JNI name, etc.) so the diagnostic fires uniformly regardless of
-			// whether the type would otherwise have ended up in the typemap.
-			//
-			// Skip the per-method walk entirely for the overwhelmingly common case where
-			// the assembly doesn't even reference the attribute type — the per-assembly
-			// flag was computed cheaply in AssemblyIndex.Build.
-			if (index.MayUseJniAddNativeMethodRegistrationAttribute &&
-			    HasJniAddNativeMethodRegistrationAttribute (typeDef, index)) {
-				logger?.LogJniAddNativeMethodRegistrationAttributeError (MetadataTypeNameResolver.GetFullName (typeDef, index.Reader));
-			}
+			var fullName = MetadataTypeNameResolver.GetFullName (typeDef, index.Reader);
+
+			// Temporarily allow [JniAddNativeMethodRegistrationAttribute] while we investigate
+			// which scenarios fail later in the trimmable typemap pipeline.
+			// if (index.MayUseJniAddNativeMethodRegistrationAttribute &&
+			//     !IsBuiltInJniAddNativeMethodRegistrationType (fullName, index) &&
+			//     HasJniAddNativeMethodRegistrationAttribute (typeDef, index)) {
+			// 	logger?.LogJniAddNativeMethodRegistrationAttributeError (fullName);
+			// }
 
 			// Determine the JNI name and whether this is a known Java peer.
 			// Priority:
@@ -261,8 +258,6 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A
 				}
 			}
 
-			var fullName = MetadataTypeNameResolver.GetFullName (typeDef, index.Reader);
-
 			var isInterface = (typeDef.Attributes & TypeAttributes.Interface) != 0;
 			var isAbstract = (typeDef.Attributes & TypeAttributes.Abstract) != 0;
 			var isGenericDefinition = typeDef.GetGenericParameters ().Count > 0;
@@ -418,6 +413,12 @@ static bool HasJniAddNativeMethodRegistrationAttribute (TypeDefinition typeDef,
 		return false;
 	}
 
+	static bool IsBuiltInJniAddNativeMethodRegistrationType (string fullName, AssemblyIndex index)
+	{
+		return string.Equals (index.AssemblyName, "Java.Interop", StringComparison.Ordinal) &&
+			string.Equals (fullName, "Java.Interop.JavaProxyObject", StringComparison.Ordinal);
+	}
+
 	/// <summary>
 	/// For each virtual override method on <paramref name="typeDef"/> that wasn't already
 	/// collected (no direct [Register]), walks up the base type hierarchy to find a
diff --git a/src/Mono.Android/Android.Runtime/AndroidRuntime.cs b/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
index 918b8377b54..dd0d94a73a9 100644
--- a/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
+++ b/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
@@ -310,12 +310,14 @@ public override void DeleteWeakGlobalReference (ref JniObjectReference value)
 		}
 	}
 
-	class AndroidTypeManager : JniRuntime.JniTypeManager {
+	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	class AndroidTypeManager : JniRuntime.ReflectionJniTypeManager {
 		bool jniAddNativeMethodRegistrationAttributePresent;
 
 		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 		const DynamicallyAccessedMemberTypes Methods = DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods;
 		const DynamicallyAccessedMemberTypes MethodsAndPrivateNested = Methods | DynamicallyAccessedMemberTypes.NonPublicNestedTypes;
+		const DynamicallyAccessedMemberTypes MethodsConstructors = MethodsAndPrivateNested | Constructors;
 
 		public AndroidTypeManager (bool jniAddNativeMethodRegistrationAttributePresent)
 		{
@@ -332,13 +334,25 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 				yield return t;
 		}
 
+		[UnconditionalSuppressMessage ("Trimming", "IL2073", Justification = "Temporary suppression until legacy typemap entries carry DAM annotations.")]
+		[return: DynamicallyAccessedMembers (MethodsConstructors)]
+		protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
+		{
+			var type = base.GetTypeForSimpleReference (jniSimpleReference);
+			if (type != null) {
+				return type;
+			}
+
+			return Java.Interop.TypeManager.GetJavaToManagedType (jniSimpleReference);
+		}
+
 		protected override string? GetSimpleReference (Type type)
 		{
 			string? j = JNIEnv.TypemapManagedToJava (type);
 			if (j != null) {
 				return GetReplacementTypeCore (j) ?? j;
 			}
-			return null;
+			return base.GetSimpleReference (type);
 		}
 
 		protected override IEnumerable<string> GetSimpleReferences (Type type)
@@ -347,9 +361,12 @@ protected override IEnumerable<string> GetSimpleReferences (Type type)
 			j   = GetReplacementTypeCore (j) ?? j;
 
 			if (j != null) {
-				return new[]{j};
+				yield return j;
+				yield break;
+			}
+			foreach (var r in base.GetSimpleReferences (type)) {
+				yield return r;
 			}
-			return Array.Empty<string> ();
 		}
 
 		protected override IReadOnlyList<string>? GetStaticMethodFallbackTypesCore (string jniSimpleReference)
@@ -623,7 +640,8 @@ static void SplitMethodLine (
 		}
 	}
 
-	class AndroidValueManager : JniRuntime.JniValueManager {
+	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	class AndroidValueManager : JniRuntime.ReflectionJniValueManager {
 
 		Dictionary<IntPtr, IdentityHashTargets>         instances       = new Dictionary<IntPtr, IdentityHashTargets> ();
 
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs
new file mode 100644
index 00000000000..1ead336ccb6
--- /dev/null
+++ b/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Java.Interop;
+
+namespace Microsoft.Android.Runtime;
+
+[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+abstract class AndroidReflectionJniValueManager : JniRuntime.ReflectionJniValueManager
+{
+	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
+	public override IJavaPeerable? CreatePeer (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions transfer,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type? targetType)
+	{
+		EnsureNotDisposed ();
+
+		if (!reference.IsValid) {
+			return null;
+		}
+
+		targetType = targetType ?? typeof (global::Java.Interop.JavaObject);
+		targetType = GetPeerType (targetType);
+
+		if (!typeof (IJavaPeerable).IsAssignableFrom (targetType)) {
+			throw new ArgumentException ($"targetType `{targetType.AssemblyQualifiedName}` must implement IJavaPeerable!", nameof (targetType));
+		}
+
+		var targetSig = Runtime.TypeManager.GetTypeSignature (targetType);
+		if (!targetSig.IsValid || targetSig.SimpleReference == null) {
+			throw new ArgumentException ($"Could not determine Java type corresponding to `{targetType.AssemblyQualifiedName}`.", nameof (targetType));
+		}
+
+		var refClass = JniEnvironment.Types.GetObjectClass (reference);
+		JniObjectReference targetClass;
+		try {
+			targetClass = JniEnvironment.Types.FindClass (targetSig.SimpleReference);
+		} catch (Exception e) {
+			JniObjectReference.Dispose (ref refClass);
+			throw new ArgumentException ($"Could not find Java class `{targetSig.SimpleReference}`.",
+					nameof (targetType),
+					e);
+		}
+
+		if (!JniEnvironment.Types.IsAssignableFrom (refClass, targetClass)) {
+			JniObjectReference.Dispose (ref refClass);
+			JniObjectReference.Dispose (ref targetClass);
+			return null;
+		}
+
+		JniObjectReference.Dispose (ref targetClass);
+
+		var peer = CreatePeerInstance (ref refClass, targetType, ref reference, transfer);
+		if (peer == null) {
+			throw new NotSupportedException (string.Format (CultureInfo.InvariantCulture, "Could not find an appropriate constructable wrapper type for Java type '{0}', targetType='{1}'.",
+					JniEnvironment.Types.GetJniTypeNameFromInstance (reference), targetType));
+		}
+		peer.SetJniManagedPeerState (peer.JniManagedPeerState | JniManagedPeerStates.Replaceable);
+		return peer;
+	}
+
+	[return: DynamicallyAccessedMembers (Constructors)]
+	static Type GetPeerType ([DynamicallyAccessedMembers (Constructors)] Type type)
+	{
+		if (type == typeof (object)) {
+			return typeof (global::Java.Interop.JavaObject);
+		}
+		if (type == typeof (IJavaPeerable)) {
+			return typeof (global::Java.Interop.JavaObject);
+		}
+		if (type == typeof (Exception)) {
+			return typeof (JavaException);
+		}
+		return type;
+	}
+
+	IJavaPeerable? CreatePeerInstance (
+			ref JniObjectReference klass,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type targetType,
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions transfer)
+	{
+		var jniTypeName = JniEnvironment.Types.GetJniTypeNameFromClass (klass);
+
+		while (jniTypeName != null) {
+			JniTypeSignature sig;
+			if (!JniTypeSignature.TryParse (jniTypeName, out sig)) {
+				return null;
+			}
+
+			Type? type = GetTypeAssignableTo (sig, targetType);
+			if (type != null) {
+				var peer = TryCreatePeerInstance (ref reference, transfer, type);
+
+				if (peer != null) {
+					JniObjectReference.Dispose (ref klass);
+					return peer;
+				}
+			}
+
+			var super = JniEnvironment.Types.GetSuperclass (klass);
+			jniTypeName = super.IsValid
+				? JniEnvironment.Types.GetJniTypeNameFromClass (super)
+				: null;
+
+			JniObjectReference.Dispose (ref klass, JniObjectReferenceOptions.CopyAndDispose);
+			klass = super;
+		}
+		JniObjectReference.Dispose (ref klass, JniObjectReferenceOptions.CopyAndDispose);
+
+		return TryCreatePeerInstance (ref reference, transfer, targetType);
+
+		[return: DynamicallyAccessedMembers (Constructors)]
+		Type? GetTypeAssignableTo (JniTypeSignature sig, Type targetType)
+		{
+			foreach (var t in Runtime.TypeManager.GetReflectionConstructibleTypes (sig)) {
+				if (targetType.IsAssignableFrom (t.Type)) {
+					return t.Type;
+				}
+			}
+			return null;
+		}
+	}
+
+	IJavaPeerable? TryCreatePeerInstance (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type type)
+	{
+		type = Runtime.TypeManager.GetInvokerType (type) ?? type;
+
+		var self = (IJavaPeerable) RuntimeHelpers.GetUninitializedObject (type);
+		self.SetJniManagedPeerState (JniManagedPeerStates.Replaceable | JniManagedPeerStates.Activatable);
+
+		var constructed = false;
+		try {
+			constructed = TryConstructPeer (self, ref reference, options, type);
+		} finally {
+			if (!constructed) {
+				GC.SuppressFinalize (self);
+				self = null;
+			}
+		}
+		return self;
+	}
+
+	static readonly Type ByRefJniObjectReference = typeof (JniObjectReference).MakeByRefType ();
+	static readonly Type[] JIConstructorSignature = new Type [] { ByRefJniObjectReference, typeof (JniObjectReferenceOptions) };
+
+	protected virtual bool TryConstructPeer (
+			IJavaPeerable self,
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type type)
+	{
+		var c = type.GetConstructor (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, JIConstructorSignature, null);
+		if (c != null) {
+			var args = new object[] {
+				reference,
+				options,
+			};
+			c.Invoke (self, args);
+			reference = (JniObjectReference) args [0];
+			return true;
+		}
+		return false;
+	}
+}
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs
index 458ad77202a..cfc32a7900a 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs
@@ -18,7 +18,7 @@
 
 namespace Microsoft.Android.Runtime;
 
-class JavaMarshalValueManager : JniRuntime.JniValueManager
+class JavaMarshalValueManager : AndroidReflectionJniValueManager
 {
 	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
index 454bab0e1bb..bf38800a807 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
@@ -7,11 +7,13 @@
 
 namespace Microsoft.Android.Runtime;
 
-class ManagedTypeManager : JniRuntime.JniTypeManager {
+[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+class ManagedTypeManager : JniRuntime.ReflectionJniTypeManager {
 
 	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 	internal const DynamicallyAccessedMemberTypes Methods = DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods;
 	internal const DynamicallyAccessedMemberTypes MethodsAndPrivateNested = Methods | DynamicallyAccessedMemberTypes.NonPublicNestedTypes;
+	internal const DynamicallyAccessedMemberTypes MethodsConstructors = MethodsAndPrivateNested | Constructors;
 
 	public ManagedTypeManager ()
 	{
@@ -141,6 +143,17 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 		}
 	}
 
+	[return: DynamicallyAccessedMembers (MethodsConstructors)]
+	protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
+	{
+		var type = base.GetTypeForSimpleReference (jniSimpleReference);
+		if (type != null) {
+			return type;
+		}
+
+		return ManagedTypeMapping.TryGetType (jniSimpleReference, out var target) ? target : null;
+	}
+
 	protected override IEnumerable<string> GetSimpleReferences (Type type)
 	{
 		foreach (var r in base.GetSimpleReferences (type)) {
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs
index bcccf6d6fd1..0546f43d378 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs
@@ -16,7 +16,7 @@
 
 namespace Microsoft.Android.Runtime;
 
-class SimpleValueManager : JniRuntime.JniValueManager
+class SimpleValueManager : AndroidReflectionJniValueManager
 {
 	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
index dea8cb2dcb8..c2514055757 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
@@ -14,9 +14,14 @@ namespace Microsoft.Android.Runtime;
 /// Type manager for the trimmable typemap path. Delegates type lookups
 /// to <see cref="TrimmableTypeMap"/>.
 /// </summary>
-class TrimmableTypeMapTypeManager : JniRuntime.JniTypeManager
+[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+class TrimmableTypeMapTypeManager : JniRuntime.ReflectionJniTypeManager
 {
 	const string NoSimpleReference = "\0";
+	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+	const DynamicallyAccessedMemberTypes Methods = DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods;
+	const DynamicallyAccessedMemberTypes MethodsAndPrivateNested = Methods | DynamicallyAccessedMemberTypes.NonPublicNestedTypes;
+	const DynamicallyAccessedMemberTypes MethodsConstructors = MethodsAndPrivateNested | Constructors;
 	readonly ConcurrentDictionary<Type, string> _simpleReferenceCache = new ();
 
 	protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpleReference)
@@ -32,6 +37,21 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 		}
 	}
 
+	[UnconditionalSuppressMessage ("Trimming", "IL2063", Justification = "Temporary suppression until trimmable typemap type entries carry DAM annotations.")]
+	[return: DynamicallyAccessedMembers (MethodsConstructors)]
+	protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
+	{
+		var type = base.GetTypeForSimpleReference (jniSimpleReference);
+		if (type != null) {
+			return type;
+		}
+
+		if (TrimmableTypeMap.Instance.TryGetTargetTypes (jniSimpleReference, out var types)) {
+			return types [0];
+		}
+		return null;
+	}
+
 	protected override string? GetSimpleReference (Type type)
 	{
 		var simpleReference = _simpleReferenceCache.GetOrAdd (type, GetSimpleReferenceUncached);
diff --git a/src/Mono.Android/Mono.Android.csproj b/src/Mono.Android/Mono.Android.csproj
index 611ef7edf07..f8013325628 100644
--- a/src/Mono.Android/Mono.Android.csproj
+++ b/src/Mono.Android/Mono.Android.csproj
@@ -10,7 +10,7 @@
     <RootNamespace>Android</RootNamespace>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\..\product.snk</AssemblyOriginatorKeyFile>
-    <NoWarn>0618;0809;0108;0114;0465;8609;8610;8614;8617;8613;8764;8765;8766;8767;RS0041</NoWarn>
+    <NoWarn>0618;0809;0108;0114;0465;8609;8610;8614;8617;8613;8764;8765;8766;8767;RS0041;IL3050</NoWarn>
     <WarningsAsErrors>$(WarningsAsErrors);CS2002</WarningsAsErrors>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);JAVA_INTEROP</DefineConstants>
@@ -363,6 +363,7 @@
     <Compile Include="Microsoft.Android.Runtime\AggregateTypeMap.cs" />
     <Compile Include="Microsoft.Android.Runtime\ITypeMap.cs" />
     <Compile Include="Microsoft.Android.Runtime\JniRemappingLookup.cs" />
+    <Compile Include="Microsoft.Android.Runtime\AndroidReflectionJniValueManager.cs" />
     <Compile Include="Microsoft.Android.Runtime\ManagedTypeManager.cs" />
     <Compile Include="Microsoft.Android.Runtime\ManagedTypeMapping.cs" />
     <Compile Include="Microsoft.Android.Runtime\JavaMarshalValueManager.cs" />
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index e98c23cf5e6..2811ab5f6da 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -24,10 +24,12 @@
     <_TypeMapOutputDirectory>$(_TypeMapBaseOutputDir)typemap/</_TypeMapOutputDirectory>
     <_TypeMapJavaOutputDirectory>$(_TypeMapBaseOutputDir)typemap/java</_TypeMapJavaOutputDirectory>
     <_TypeMapAssembliesListFile>$(_TypeMapOutputDirectory)typemap-assemblies.txt</_TypeMapAssembliesListFile>
-    <_PostTrimTypeMapJavaOutputDirectory>$(_TypeMapBaseOutputDir)typemap/linked-java</_PostTrimTypeMapJavaOutputDirectory>
+    <_PostTrimTypeMapJavaBaseOutputDir Condition=" '$(_OuterIntermediateOutputPath)' != '' ">$(IntermediateOutputPath)</_PostTrimTypeMapJavaBaseOutputDir>
+    <_PostTrimTypeMapJavaBaseOutputDir Condition=" '$(_PostTrimTypeMapJavaBaseOutputDir)' == '' ">$(_TypeMapBaseOutputDir)</_PostTrimTypeMapJavaBaseOutputDir>
+    <_PostTrimTypeMapJavaOutputDirectory>$(_PostTrimTypeMapJavaBaseOutputDir)typemap/linked-java</_PostTrimTypeMapJavaOutputDirectory>
     <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
     <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' ">$(_TypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
-    <_PostTrimTrimmableTypeMapJavaStamp>$(_TypeMapBaseOutputDir)stamp/_GeneratePostTrimTrimmableTypeMapJavaSources.stamp</_PostTrimTrimmableTypeMapJavaStamp>
+    <_PostTrimTrimmableTypeMapJavaStamp>$(_PostTrimTypeMapJavaBaseOutputDir)stamp/_GeneratePostTrimTrimmableTypeMapJavaSources.stamp</_PostTrimTrimmableTypeMapJavaStamp>
     <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTrimmableTypeMapJavaStamp)</_TrimmableJavaSourceStamp>
     <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' ">$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll</_TrimmableJavaSourceStamp>
     <!-- Max array rank for __ArrayMapRank{N} sentinel emission. Defaults to 3 when
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest2.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest2.cs
index 05a317d6669..b04c6f08155 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest2.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest2.cs
@@ -462,11 +462,11 @@ public void BuildHasNoWarnings (bool isRelease, bool multidex, string packageFor
 				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");
 
 				if (runtime == AndroidRuntime.NativeAOT) {
-					// NativeAOT currently (Nov 2025) produces 6 `ILC : AOT analysis warning IL3050` warnings for various
+					// NativeAOT currently (Nov 2025) produces 10 `ILC : AOT analysis warning IL3050` warnings for various
 					// bits of code. Even though this test expects no warnings and the above likely make the app not work
 					// correctly at run time, it is still worth running this test under NativeAOT to test for the absence
 					// of other warnings.
-					int numberOfExpectedWarnings = 6;
+					int numberOfExpectedWarnings = 10;
 
 					Assert.IsTrue (
 						StringAssertEx.ContainsText (
@@ -501,15 +501,15 @@ static IEnumerable<object[]> Get_BuildHasTrimmerWarningsData ()
 				} else {
 					AddTestData (runtime, "", new string [0], true);
 				}
-				AddTestData (runtime, "SuppressTrimAnalysisWarnings=false", new string [] { "IL2055" }, true, 2);
+				AddTestData (runtime, "SuppressTrimAnalysisWarnings=false", new string [] { "IL2055" }, true, 3);
 				AddTestData (runtime, "TrimMode=full", new string [] { "IL2055" }, false, 1);
-				AddTestData (runtime, "TrimMode=full", new string [] { "IL2055" }, true, 2);
+				AddTestData (runtime, "TrimMode=full", new string [] { "IL2055" }, true, runtime == AndroidRuntime.NativeAOT ? 2 : 3);
 				AddTestData (runtime, "IsAotCompatible=true", new string [] { "IL2055", "IL3050" }, false);
 
 				if (runtime == AndroidRuntime.NativeAOT) {
 					AddTestData (runtime, "IsAotCompatible=true", new string [] { "IL2055", "IL3050" }, true, 2);
 				} else {
-					AddTestData (runtime, "IsAotCompatible=true", new string [] { "IL2055", "IL3050" }, true, 3);
+					AddTestData (runtime, "IsAotCompatible=true", new string [] { "IL2055", "IL3050" }, true, 4);
 				}
 			}
 
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/ManifestTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/ManifestTest.cs
index c11651105d0..050030a15b4 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/ManifestTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/ManifestTest.cs
@@ -1340,7 +1340,8 @@ public void SupportedOSPlatformVersion (string minSdkVersion, bool removeUsesSdk
 			} else {
 				if (runtime == AndroidRuntime.NativeAOT) {
 					// 2 of: warning IL3053: Assembly 'Mono.Android' produced AOT analysis warnings.
-					StringAssertEx.Contains ("2 Warning(s)", builder.LastBuildOutput, "NativeAOT should produce two IL3053 warnings");
+					// 2 of: warning IL2104: Assembly 'Mono.Android' produced trim warnings.
+					StringAssertEx.Contains ("4 Warning(s)", builder.LastBuildOutput, "NativeAOT should produce four warnings");
 				} else {
 					builder.AssertHasNoWarnings ();
 				}
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
index ea19d25ad0f..d954457fc7f 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/PackagingTest.cs
@@ -569,7 +569,7 @@ public void CheckSignApk ([Values] bool useApkSigner, [Values] bool perAbiApk, [
 				if (runtime != AndroidRuntime.NativeAOT) {
 					b.AssertHasNoWarnings ();
 				} else {
-					StringAssertEx.Contains ("2 Warning(s)", b.LastBuildOutput, "NativeAOT should produce two IL3053 warnings");
+					StringAssertEx.Contains ("4 Warning(s)", b.LastBuildOutput, "NativeAOT should produce four warnings");
 				}
 
 				//Make sure the APKs are signed
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.MonoVM.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.MonoVM.apkdesc
index 42c7d46617e..92fc486e9ea 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.MonoVM.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.MonoVM.apkdesc
@@ -8,34 +8,34 @@
       "Size": 22384
     },
     "lib/arm64-v8a/lib__Microsoft.Android.Resource.Designer.dll.so": {
-      "Size": 18232
+      "Size": 18224
     },
     "lib/arm64-v8a/lib_Java.Interop.dll.so": {
-      "Size": 87720
+      "Size": 92560
     },
     "lib/arm64-v8a/lib_Mono.Android.dll.so": {
-      "Size": 118392
+      "Size": 119200
     },
     "lib/arm64-v8a/lib_Mono.Android.Runtime.dll.so": {
-      "Size": 26848
+      "Size": 26864
     },
     "lib/arm64-v8a/lib_System.Console.dll.so": {
       "Size": 24360
     },
     "lib/arm64-v8a/lib_System.Linq.dll.so": {
-      "Size": 25432
+      "Size": 25552
     },
     "lib/arm64-v8a/lib_System.Private.CoreLib.dll.so": {
-      "Size": 638568
+      "Size": 704944
     },
     "lib/arm64-v8a/lib_System.Runtime.dll.so": {
       "Size": 20224
     },
     "lib/arm64-v8a/lib_System.Runtime.InteropServices.dll.so": {
-      "Size": 19752
+      "Size": 19760
     },
     "lib/arm64-v8a/lib_UnnamedProject.dll.so": {
-      "Size": 19968
+      "Size": 19976
     },
     "lib/arm64-v8a/libarc.bin.so": {
       "Size": 19296
@@ -44,10 +44,10 @@
       "Size": 36416
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 1385800
+      "Size": 1387008
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
-      "Size": 3111840
+      "Size": 3111632
     },
     "lib/arm64-v8a/libSystem.Globalization.Native.so": {
       "Size": 72344
@@ -62,7 +62,7 @@
       "Size": 162000
     },
     "lib/arm64-v8a/libxamarin-app.so": {
-      "Size": 19832
+      "Size": 19680
     },
     "res/drawable-hdpi-v4/icon.png": {
       "Size": 2178
@@ -89,5 +89,5 @@
       "Size": 1904
     }
   },
-  "PackageSize": 3254606
+  "PackageSize": 3320142
 }
\ No newline at end of file
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
index 6139ea8ee6a..b3eba523be1 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
@@ -74,17 +74,6 @@ public void Execute_WithTestFixtures_ProducesOutputs ()
 		Assert.Contains (result.GeneratedAssemblies, a => a.Name == "_TestFixtures.TypeMap");
 	}
 
-	[Fact]
-	public void Execute_WithJniAddNativeMethodRegistrationAttribute_ReportsXA4251 ()
-	{
-		// TestFixtures.HandWrittenNativeRegistrationPeer carries [JniAddNativeMethodRegistrationAttribute].
-		// The trimmable typemap does not support that attribute by design — the orchestrator must
-		// emit XA4251 so MSBuild fails the build via HasLoggedErrors.
-		using var peReader = CreateTestFixturePEReader ();
-		CreateGenerator ().Execute (new List<(string, PEReader)> { ("TestFixtures", peReader) }, new Version (11, 0), new HashSet<string> ());
-		Assert.Contains (logMessages, m => m.Contains ("XA4251") && m.Contains ("HandWrittenNativeRegistrationPeer"));
-	}
-
 	[Fact]
 	public void Execute_CollectsDeferredRegistrationTypes_ForAllApplicationAndInstrumentationSubtypes ()
 	{
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
index 6d32900bdb7..00c8be4e5bb 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
@@ -60,42 +60,6 @@ public void Scan_MarksFrameworkAssemblyPeers ()
 		Assert.All (peers, p => Assert.False (p.GenerateArrayEntries, $"{p.ManagedTypeName} should not emit array entries unless referenced from a non-framework assembly."));
 	}
 
-	[Fact]
-	public void Scan_JniAddNativeMethodRegistrationAttribute_LogsError ()
-	{
-		// The trimmable typemap refuses to support [JniAddNativeMethodRegistrationAttribute]
-		// by design (XA4251). The scanner reports each offending type via the logger.
-		var errors = new List<string> ();
-		var logger = new RecordingLogger (errors);
-
-		using var scanner = new JavaPeerScanner (logger: logger);
-		using var peReader = new PEReader (File.OpenRead (TestFixtureAssemblyPath));
-		var reader = peReader.GetMetadataReader ();
-		var assemblyName = reader.GetString (reader.GetAssemblyDefinition ().Name);
-		_ = scanner.Scan (new List<(string, PEReader)> { (assemblyName, peReader) });
-
-		Assert.Contains (errors, e => e.Contains ("HandWrittenNativeRegistrationPeer"));
-		Assert.Contains (errors, e => e.Contains ("NonPeerNativeRegistration"));
-		Assert.DoesNotContain (errors, e => e.Contains ("OtherNamespaceNativeRegistration"));
-		Assert.DoesNotContain (errors, e => e.Contains ("MyHelper"));
-	}
-
-	sealed class RecordingLogger (List<string> errors) : ITrimmableTypeMapLogger
-	{
-		public void LogNoJavaPeerTypesFound () { }
-		public void LogJavaPeerScanInfo (int assemblyCount, int peerCount) { }
-		public void LogGeneratingJcwFilesInfo (int jcwPeerCount, int totalPeerCount) { }
-		public void LogDeferredRegistrationTypesInfo (int typeCount) { }
-		public void LogGeneratedTypeMapAssemblyInfo (string assemblyName, int typeCount) { }
-		public void LogGeneratedRootTypeMapInfo (int assemblyReferenceCount) { }
-		public void LogGeneratedTypeMapAssembliesInfo (int assemblyCount) { }
-		public void LogGeneratedJcwFilesInfo (int sourceCount) { }
-		public void LogRootingManifestReferencedTypeInfo (string javaTypeName, string managedTypeName) { }
-		public void LogManifestReferencedTypeNotFoundWarning (string javaTypeName) { }
-		public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeName) =>
-			errors.Add ($"XA4251: {managedTypeName}");
-	}
-
 	[Fact]
 	public void Scan_TypeMetadata_IsCorrect ()
 	{
diff --git a/tests/Mono.Android-Tests/Java.Interop-Tests/Java.Interop-Tests.NET.csproj b/tests/Mono.Android-Tests/Java.Interop-Tests/Java.Interop-Tests.NET.csproj
index 14d29d76d54..79ccfecab84 100644
--- a/tests/Mono.Android-Tests/Java.Interop-Tests/Java.Interop-Tests.NET.csproj
+++ b/tests/Mono.Android-Tests/Java.Interop-Tests/Java.Interop-Tests.NET.csproj
@@ -50,13 +50,6 @@
     <Compile Remove="$(JavaInteropTestDirectory)Java.Interop\JniRuntime.JniValueManagerTests.cs" />
   </ItemGroup>
 
-  <ItemGroup>
-    <!-- Compile the GenericMarshaler helper against the Android platform Java.Interop instead of referencing the external project, which depends on standalone Java.Interop. -->
-    <Compile Include="$(JavaInteropSourceDirectory)\src\Java.Interop.GenericMarshaler\Java.Interop.GenericMarshaler\JniPeerInstanceMethodsExtensions.cs">
-      <Link>Java.Interop.GenericMarshaler\JniPeerInstanceMethodsExtensions.cs</Link>
-    </Compile>
-  </ItemGroup>
-
   <!-- Import Microsoft.NET.Sdk targets before our targets so we can override build/clean behavior -->
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
   <Import Project="Java.Interop-Tests.targets" />