diff --git a/Documentation/docs-mobile/messages/index.md b/Documentation/docs-mobile/messages/index.md
index b9e3a345395..239ae6489bb 100644
--- a/Documentation/docs-mobile/messages/index.md
+++ b/Documentation/docs-mobile/messages/index.md
@@ -221,8 +221,6 @@ Either change the value in the AndroidManifest.xml to match the $(SupportedOSPla
 + [XA4250](xa4250.md): Manifest-referenced type '{type}' was not found in any scanned assembly. It may be a framework type.
 + [XA4252](xa4252.md): Insecure HTTP Maven repository URL '{url}' is not allowed. Use an HTTPS URL, or set AllowInsecureHttp="true" metadata on the item to override this check.
 + [XA4253](xa4253.md): Generated Java callable wrapper code changed: '{path}'
-+ [XA4254](xa4254.md): Trimmable type map Java source input directory '{input}' and output directory '{output}' must be different.
-+ [XA4255](xa4255.md): Generated trimmable type map Java source '{path}' was not found.
 + XA4300: Native library '{library}' will not be bundled because it has an unsupported ABI.
 + [XA4301](xa4301.md): Apk already contains the item `xxx`.
 + [XA4302](xa4302.md): Unhandled exception merging \`AndroidManifest.xml\`: {ex}
diff --git a/Documentation/docs-mobile/messages/xa4254.md b/Documentation/docs-mobile/messages/xa4254.md
deleted file mode 100644
index 6997cf235b1..00000000000
--- a/Documentation/docs-mobile/messages/xa4254.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: .NET for Android error XA4254
-description: XA4254 error code
-ms.date: 05/20/2026
-f1_keywords:
-  - "XA4254"
----
-
-# .NET for Android error XA4254
-
-## Example message
-
-```text
-error XA4254: Trimmable type map Java source input directory 'obj/Release/net11.0-android/typemap/java' and output directory 'obj/Release/net11.0-android/typemap/java' must be different.
-```
-
-## Issue
-
-The trimmable type map build tried to clean the Java source output directory, but the configured input and output directories resolved to the same path.
-
-Cleaning the output directory in this configuration would delete the input Java sources before they can be copied.
-
-## Solution
-
-This error indicates an internal build configuration problem. File an issue at <https://github.com/dotnet/android/issues> and include the full build log.
diff --git a/Documentation/docs-mobile/messages/xa4255.md b/Documentation/docs-mobile/messages/xa4255.md
deleted file mode 100644
index 633df761ecb..00000000000
--- a/Documentation/docs-mobile/messages/xa4255.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: .NET for Android error XA4255
-description: XA4255 error code
-ms.date: 05/20/2026
-f1_keywords:
-  - "XA4255"
----
-
-# .NET for Android error XA4255
-
-## Example message
-
-```text
-error XA4255: Generated trimmable type map Java source 'obj/Release/net11.0-android/typemap/java/my/app/MainActivity.java' was not found.
-```
-
-## Issue
-
-The post-trim trimmable type map scan expected to copy a generated Java source file from the pre-trim Java source directory, but the file was missing.
-
-This can happen if intermediate build outputs are stale or if the generated Java source list no longer matches the files on disk.
-
-## Solution
-
-Delete the project's `obj` and `bin` directories, then rebuild.
-
-If the error persists after a clean rebuild, file an issue at <https://github.com/dotnet/android/issues> and include the full build log.
diff --git a/external/Java.Interop b/external/Java.Interop
index 70493645c7d..8d544738ad2 160000
--- a/external/Java.Interop
+++ b/external/Java.Interop
@@ -1 +1 @@
-Subproject commit 70493645c7d95648010a4cef948234a28744c03f
+Subproject commit 8d544738ad294b4faf13d189eeeb02f0313e00b3
diff --git a/external/xamarin-android-tools b/external/xamarin-android-tools
index 132f7903534..716b7ded6ff 160000
--- a/external/xamarin-android-tools
+++ b/external/xamarin-android-tools
@@ -1 +1 @@
-Subproject commit 132f790353413dcaef231e720e255364a310b3bd
+Subproject commit 716b7ded6ff6820e34ed6db8dadf5644b4e78204
diff --git a/src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs b/src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs
index 5891149578f..b920167dd23 100644
--- a/src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs
+++ b/src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs
@@ -61,7 +61,7 @@ static NativeAotRuntimeOptions CreateJreVM (NativeAotRuntimeOptions builder)
 			builder.TypeManager     ??= CreateDefaultTypeManager ();
 #endif  // NET
 
-			builder.ValueManager            ??= new JavaMarshalValueManager ();
+			builder.ValueManager            ??= Android.Runtime.JNIEnvInit.CreateValueManager ();
 			builder.ObjectReferenceManager  ??= new Android.Runtime.AndroidObjectReferenceManager ();
 
 			if (builder.InvocationPointer != IntPtr.Zero || builder.EnvironmentPointer != IntPtr.Zero)
@@ -81,7 +81,7 @@ static JniRuntime.JniTypeManager CreateDefaultTypeManager ()
 				return new TrimmableTypeMapTypeManager ();
 			}
 
-			return new ManagedTypeManager ();
+			throw new NotImplementedException ();
 		}
 
 		public override string? GetCurrentManagedThreadName ()
diff --git a/src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml b/src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml
index 124edd61d93..29e7d7503ae 100644
--- a/src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml
+++ b/src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml
@@ -27,6 +27,7 @@
 		<type fullname="Android.Runtime.RaiseThrowableEventArgs" />
 		<type fullname="Android.Runtime.RegisterAttribute" />
 		<type fullname="Android.Runtime.TypeManager" />
+		<type fullname="Microsoft.Android.Runtime.ManagedTypeMapping" preserve="all" />
 		<!--
 		<type fullname="Android.Runtime.XmlResourceParserReader" />
 		<type fullname="Android.Runtime.XmlPullParserReader" />
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/DeterministicHashBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/DeterministicHashBuilder.cs
new file mode 100644
index 00000000000..ebe9549851b
--- /dev/null
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/DeterministicHashBuilder.cs
@@ -0,0 +1,96 @@
+using System;
+using System.Buffers;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Microsoft.Android.Sdk.TrimmableTypeMap;
+
+sealed class DeterministicHashBuilder : IDisposable
+{
+	readonly HashAlgorithm hash = SHA256.Create ();
+	readonly byte [] intBuffer = new byte [4];
+	readonly byte [] byteBuffer = new byte [1];
+	bool finished;
+
+	public void AddString (string value)
+	{
+		var bytes = Encoding.UTF8.GetBytes (value);
+		AddInt32 (bytes.Length);
+		AddBytes (bytes);
+	}
+
+	public void AddVersion (Version version)
+	{
+		AddInt32 (version.Major);
+		AddInt32 (version.Minor);
+		AddInt32 (version.Build);
+		AddInt32 (version.Revision);
+	}
+
+	public void AddInt32 (int value)
+	{
+		intBuffer [0] = (byte) value;
+		intBuffer [1] = (byte) (value >> 8);
+		intBuffer [2] = (byte) (value >> 16);
+		intBuffer [3] = (byte) (value >> 24);
+		AddBytes (intBuffer);
+	}
+
+	public void AddByte (byte value)
+	{
+		byteBuffer [0] = value;
+		AddBytes (byteBuffer);
+	}
+
+	public void AddBytes (byte [] bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.Length != 0) {
+			hash.TransformBlock (bytes, 0, bytes.Length, null, 0);
+		}
+	}
+
+	public void AddBytes (ReadOnlySpan<byte> bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.IsEmpty) {
+			return;
+		}
+
+		var buffer = ArrayPool<byte>.Shared.Rent (Math.Min (bytes.Length, 4096));
+		try {
+			while (!bytes.IsEmpty) {
+				var count = Math.Min (bytes.Length, buffer.Length);
+				bytes.Slice (0, count).CopyTo (buffer);
+				hash.TransformBlock (buffer, 0, count, null, 0);
+				bytes = bytes.Slice (count);
+			}
+		} finally {
+			ArrayPool<byte>.Shared.Return (buffer);
+		}
+	}
+
+	public byte [] ToHash ()
+	{
+		if (!finished) {
+			hash.TransformFinalBlock ([], 0, 0);
+			finished = true;
+		}
+		if (hash.Hash is not null) {
+			return hash.Hash;
+		}
+		throw new InvalidOperationException ("SHA256 did not produce a hash.");
+	}
+
+	void EnsureNotFinished ()
+	{
+		if (finished) {
+			throw new InvalidOperationException ("Cannot add data after finalizing the hash.");
+		}
+	}
+
+	public void Dispose ()
+	{
+		hash.Dispose ();
+	}
+}
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs
index 93f8ce5c5fc..81e1708713f 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/MetadataHelper.cs
@@ -1,6 +1,5 @@
 using System;
-using System.Security.Cryptography;
-using System.Text;
+using System.Collections.Generic;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
@@ -12,12 +11,12 @@ static class MetadataHelper
 	/// </summary>
 	public static Guid DeterministicMvid (string moduleName, ReadOnlySpan<byte> contentBytes = default)
 	{
-		using var sha = SHA256.Create ();
-		byte [] nameBytes = Encoding.UTF8.GetBytes (moduleName);
-		byte [] input = new byte [nameBytes.Length + contentBytes.Length];
-		nameBytes.CopyTo (input, 0);
-		contentBytes.CopyTo (input.AsSpan (nameBytes.Length));
-		byte [] hash = sha.ComputeHash (input);
+		using var hashBuilder = new DeterministicHashBuilder ();
+		hashBuilder.AddString (moduleName);
+		if (!contentBytes.IsEmpty) {
+			hashBuilder.AddBytes (contentBytes);
+		}
+		byte [] hash = hashBuilder.ToHash ();
 		byte [] guidBytes = new byte [16];
 		Array.Copy (hash, guidBytes, 16);
 		return new Guid (guidBytes);
@@ -28,26 +27,44 @@ public static Guid DeterministicMvid (string moduleName, ReadOnlySpan<byte> cont
 	/// </summary>
 	public static byte [] ComputeContentFingerprint (TypeMapAssemblyData data)
 	{
-		using var sha = SHA256.Create ();
-		using var stream = new System.IO.MemoryStream ();
-		using var writer = new System.IO.BinaryWriter (stream, Encoding.UTF8);
+		using var hash = new DeterministicHashBuilder ();
 		foreach (var entry in data.Entries) {
-			writer.Write (entry.JniName);
-			writer.Write (entry.ProxyTypeReference);
-			writer.Write (entry.TargetTypeReference ?? "");
+			hash.AddString (entry.JniName);
+			hash.AddString (entry.ProxyTypeReference);
+			hash.AddString (entry.TargetTypeReference ?? "");
 		}
 		foreach (var proxy in data.ProxyTypes) {
-			writer.Write (proxy.TypeName);
-			writer.Write (proxy.TargetType.ManagedTypeName);
-			writer.Write (proxy.TargetType.AssemblyName);
-			writer.Write ((byte)(proxy.ActivationCtor?.Style ?? 0));
-			writer.Write ((byte)(proxy.InvokerActivationCtorStyle ?? 0));
+			hash.AddString (proxy.TypeName);
+			hash.AddString (proxy.TargetType.ManagedTypeName);
+			hash.AddString (proxy.TargetType.AssemblyName);
+			hash.AddByte ((byte)(proxy.ActivationCtor?.Style ?? 0));
+			hash.AddByte ((byte)(proxy.InvokerActivationCtorStyle ?? 0));
+		}
+		foreach (var proxy in data.ArrayProxyTypes) {
+			hash.AddString (proxy.TypeName);
+			hash.AddString (proxy.JniName);
+			hash.AddString (proxy.ElementType.ManagedTypeName);
+			hash.AddString (proxy.ElementType.AssemblyName);
+			hash.AddInt32 (proxy.Rank);
+			hash.AddString (proxy.Primitive?.ConcreteArrayType.ManagedTypeName ?? "");
+			hash.AddString (proxy.Primitive?.ConcreteArrayType.AssemblyName ?? "");
 		}
 		foreach (var assoc in data.Associations) {
-			writer.Write (assoc.SourceTypeReference);
-			writer.Write (assoc.AliasProxyTypeReference);
+			hash.AddString (assoc.SourceTypeReference);
+			hash.AddString (assoc.AliasProxyTypeReference);
+		}
+		return hash.ToHash ();
+	}
+
+	public static byte [] ComputeRootContentFingerprint (Version systemRuntimeVersion, IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, int maxArrayRank)
+	{
+		using var hash = new DeterministicHashBuilder ();
+		hash.AddVersion (systemRuntimeVersion);
+		hash.AddByte (useSharedTypemapUniverse ? (byte) 1 : (byte) 0);
+		hash.AddInt32 (maxArrayRank);
+		foreach (var name in perAssemblyTypeMapNames) {
+			hash.AddString (name);
 		}
-		writer.Flush ();
-		return sha.ComputeHash (stream.ToArray ());
+		return hash.ToHash ();
 	}
 }
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs
index a90f0d7dbeb..6da408c557a 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs
@@ -40,6 +40,11 @@ sealed class TypeMapAssemblyData
 	/// </summary>
 	public List<AliasHolderData> AliasHolders { get; } = new ();
 
+	/// <summary>
+	/// Array proxy types to emit — one per JNI element name and rank.
+	/// </summary>
+	public List<ArrayProxyData> ArrayProxyTypes { get; } = new ();
+
 	/// <summary>
 	/// Maximum array rank for which the generator emits per-rank <c>__ArrayMapRank{N}</c>
 	/// sentinel TypeDefs and <c>TypeMap</c> entries. 0 disables.
@@ -91,6 +96,32 @@ sealed record TypeMapAttributeData
 	public int? AnchorRank { get; init; }
 }
 
+/// <summary>
+/// A generated array proxy type used by per-rank array TypeMap entries.
+/// </summary>
+sealed record ArrayProxyData
+{
+	public required string TypeName { get; init; }
+
+	public string Namespace { get; init; } = "_TypeMap.ArrayProxies";
+
+	public required string JniName { get; init; }
+
+	public required TypeRefData ElementType { get; init; }
+
+	public required int Rank { get; init; }
+
+	public PrimitiveArrayProxyData? Primitive { get; init; }
+}
+
+/// <summary>
+/// Additional primitive array metadata for <see cref="ArrayProxyData"/>.
+/// </summary>
+sealed record PrimitiveArrayProxyData
+{
+	public required TypeRefData ConcreteArrayType { get; init; }
+}
+
 /// <summary>
 /// A proxy type to generate in the TypeMap assembly (subclass of JavaPeerProxy).
 /// </summary>
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
index 4671394e936..5be2dc94369 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs
@@ -16,6 +16,17 @@ static class ModelBuilder
 {
 	const string ProxyTypeSuffix = "_Proxy";
 
+	static readonly PrimitiveArrayProxyInfo [] PrimitiveArrayProxies = [
+		new ("Z", "Boolean", "System.Boolean", "Java.Interop.JavaBooleanArray"),
+		new ("B", "SByte", "System.SByte", "Java.Interop.JavaSByteArray"),
+		new ("C", "Char", "System.Char", "Java.Interop.JavaCharArray"),
+		new ("S", "Int16", "System.Int16", "Java.Interop.JavaInt16Array"),
+		new ("I", "Int32", "System.Int32", "Java.Interop.JavaInt32Array"),
+		new ("J", "Int64", "System.Int64", "Java.Interop.JavaInt64Array"),
+		new ("F", "Single", "System.Single", "Java.Interop.JavaSingleArray"),
+		new ("D", "Double", "System.Double", "Java.Interop.JavaDoubleArray"),
+	];
+
 	static readonly HashSet<string> EssentialRuntimeTypes = new (StringComparer.Ordinal) {
 		"java/lang/Object",
 		"java/lang/Class",
@@ -99,6 +110,10 @@ public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, stri
 			}
 		}
 
+		if (maxArrayRank > 0 && peers.Any (p => string.Equals (p.AssemblyName, "Java.Interop", StringComparison.Ordinal))) {
+			EmitPrimitiveArrayEntries (model, maxArrayRank);
+		}
+
 		BuildNativeRegistrations (model);
 
 		// Compute IgnoresAccessChecksTo from cross-assembly references
@@ -253,13 +268,26 @@ static void AddIfCrossAssembly (SortedSet<string> set, string? asmName, string o
 	static string ManagedTypeNameToProxyTypeName (string managedTypeName)
 	{
 		var builder = new StringBuilder (managedTypeName.Length + ProxyTypeSuffix.Length);
+		AppendSafeManagedTypeName (builder, managedTypeName);
+		builder.Append (ProxyTypeSuffix);
+		return builder.ToString ();
+	}
+
+	static string ManagedTypeNameToArrayProxyTypeName (string managedTypeName, int rank)
+	{
+		var builder = new StringBuilder (managedTypeName.Length + 20);
+		AppendSafeManagedTypeName (builder, managedTypeName);
+		builder.Append ("_ArrayProxy");
+		builder.Append (rank);
+		return builder.ToString ();
+	}
+
+	static void AppendSafeManagedTypeName (StringBuilder builder, string managedTypeName)
+	{
 		for (int i = 0; i < managedTypeName.Length; i++) {
 			char c = managedTypeName [i];
 			builder.Append (c == '.' || c == '+' || c == '`' ? '_' : c);
 		}
-
-		builder.Append (ProxyTypeSuffix);
-		return builder.ToString ();
 	}
 
 	static JavaPeerProxyData BuildProxyType (JavaPeerInfo peer, string jniName, HashSet<string> usedProxyNames, bool isAcw)
@@ -502,17 +530,84 @@ static TypeMapAttributeData BuildEntry (JavaPeerInfo peer, JavaPeerProxyData? pr
 	static string AssemblyQualify (string typeName, string assemblyName)
 		=> $"{typeName}, {assemblyName}";
 
+	static string AddArrayRank (string typeReference, int rank)
+	{
+		if (rank == 0) {
+			return typeReference;
+		}
+
+		int assemblySeparator = typeReference.LastIndexOf (", ", StringComparison.Ordinal);
+		if (assemblySeparator < 0) {
+			throw new InvalidOperationException ($"Assembly-qualified type reference '{typeReference}' does not contain an assembly name.");
+		}
+
+		return typeReference.Substring (0, assemblySeparator) + Brackets (rank) + typeReference.Substring (assemblySeparator);
+	}
+
+	static string MakeGenericTypeReference (string openTypeName, string openTypeAssembly, string argumentTypeReference)
+		=> $"{openTypeName}[[{argumentTypeReference}]], {openTypeAssembly}";
+
+	static string MakeNestedJavaObjectArrayTypeReference (string elementTypeReference, int rank)
+	{
+		var result = elementTypeReference;
+		for (int i = 0; i < rank; i++) {
+			result = MakeGenericTypeReference ("Java.Interop.JavaObjectArray`1", "Java.Interop", result);
+		}
+		return result;
+	}
+
+	static IReadOnlyList<string> GetArrayTypeReferences (ArrayProxyData proxy)
+	{
+		var elementType = AssemblyQualify (proxy.ElementType.ManagedTypeName, proxy.ElementType.AssemblyName);
+		if (proxy.Primitive is null) {
+			var rankOneTypes = new [] {
+				MakeGenericTypeReference ("Java.Interop.JavaObjectArray`1", "Java.Interop", elementType),
+				MakeGenericTypeReference ("Java.Interop.JavaArray`1", "Java.Interop", elementType),
+				AddArrayRank (elementType, 1),
+			};
+			return ExpandRankOneTypes (rankOneTypes, proxy.Rank);
+		}
+
+		var rankOnePrimitiveTypes = new [] {
+			AddArrayRank (elementType, 1),
+			MakeGenericTypeReference ("Java.Interop.JavaArray`1", "Java.Interop", elementType),
+			MakeGenericTypeReference ("Java.Interop.JavaPrimitiveArray`1", "Java.Interop", elementType),
+			AssemblyQualify (proxy.Primitive.ConcreteArrayType.ManagedTypeName, proxy.Primitive.ConcreteArrayType.AssemblyName),
+		};
+		return ExpandRankOneTypes (rankOnePrimitiveTypes, proxy.Rank);
+	}
+
+	static IReadOnlyList<string> ExpandRankOneTypes (IReadOnlyList<string> rankOneTypes, int rank)
+	{
+		if (rank == 1) {
+			return rankOneTypes;
+		}
+
+		var result = new List<string> (rankOneTypes.Count * 2);
+		foreach (var type in rankOneTypes) {
+			result.Add (MakeNestedJavaObjectArrayTypeReference (type, rank - 1));
+			result.Add (AddArrayRank (type, rank - 1));
+		}
+		return result;
+	}
+
+	static void AddArrayProxyAssociations (TypeMapAssemblyData model, ArrayProxyData proxy, string proxyReference)
+	{
+		foreach (var typeReference in GetArrayTypeReferences (proxy)) {
+			model.Associations.Add (new TypeMapAssociationData {
+				SourceTypeReference = typeReference,
+				AliasProxyTypeReference = proxyReference,
+			});
+		}
+	}
+
 	/// <summary>
 	/// Emits per-rank array TypeMap entries for one peer, anchored to the per-assembly
 	/// <c>__ArrayMapRank{N}</c> sentinels. Keys are bare element JNI names (rank is encoded
-	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics, primitive JNI
-	/// keyword keys (handled by the legacy primitive-array path), and alias groups.
+	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics and alias groups.
 	/// </summary>
 	static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<JavaPeerInfo> peersForName, int maxArrayRank)
 	{
-		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
-			return;
-		}
 		if (peersForName.Count != 1) {
 			return;
 		}
@@ -524,15 +619,62 @@ static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<Ja
 		if (peer.IsGenericDefinition) {
 			return;
 		}
+		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
+			return;
+		}
 
 		for (int rank = 1; rank <= maxArrayRank; rank++) {
-			string arrayTypeRef = AssemblyQualify (peer.ManagedTypeName + Brackets (rank), peer.AssemblyName);
+			var proxy = new ArrayProxyData {
+				TypeName = ManagedTypeNameToArrayProxyTypeName (peer.ManagedTypeName, rank),
+				JniName = jniName,
+				ElementType = new TypeRefData {
+					ManagedTypeName = peer.ManagedTypeName,
+					AssemblyName = peer.AssemblyName,
+				},
+				Rank = rank,
+			};
+			model.ArrayProxyTypes.Add (proxy);
+
+			var proxyReference = AssemblyQualify ($"{proxy.Namespace}.{proxy.TypeName}", model.AssemblyName);
 			model.Entries.Add (new TypeMapAttributeData {
 				JniName = jniName,
-				ProxyTypeReference = arrayTypeRef,
-				TargetTypeReference = arrayTypeRef,
+				ProxyTypeReference = proxyReference,
+				TargetTypeReference = proxyReference,
 				AnchorRank = rank,
 			});
+			AddArrayProxyAssociations (model, proxy, proxyReference);
+		}
+	}
+
+	static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRank)
+	{
+		foreach (var primitive in PrimitiveArrayProxies) {
+			for (int rank = 1; rank <= maxArrayRank; rank++) {
+				var proxy = new ArrayProxyData {
+					TypeName = $"Primitive_{primitive.Name}_ArrayProxy{rank}",
+					JniName = primitive.JniName,
+					ElementType = new TypeRefData {
+						ManagedTypeName = primitive.ManagedTypeName,
+						AssemblyName = "System.Runtime",
+					},
+					Rank = rank,
+					Primitive = new PrimitiveArrayProxyData {
+						ConcreteArrayType = new TypeRefData {
+							ManagedTypeName = primitive.ConcreteArrayTypeName,
+							AssemblyName = "Java.Interop",
+						},
+					},
+				};
+				model.ArrayProxyTypes.Add (proxy);
+				var proxyReference = AssemblyQualify ($"{proxy.Namespace}.{proxy.TypeName}", model.AssemblyName);
+				model.Entries.Add (new TypeMapAttributeData {
+					JniName = primitive.JniName,
+					ProxyTypeReference = proxyReference,
+					TargetTypeReference = proxyReference,
+					AnchorRank = rank,
+				});
+				AddArrayProxyAssociations (model, proxy, proxyReference);
+			}
 		}
 	}
 
@@ -555,4 +697,10 @@ static string BuildBrackets (int rank)
 	static bool IsJniPrimitiveKeyword (char c)
 		=> c == 'Z' || c == 'B' || c == 'C' || c == 'S' || c == 'I'
 			|| c == 'J' || c == 'F' || c == 'D' || c == 'V';
+
+	readonly record struct PrimitiveArrayProxyInfo (
+		string JniName,
+		string Name,
+		string ManagedTypeName,
+		string ConcreteArrayTypeName);
 }
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs
index 57e57b7a835..70f37c65682 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs
@@ -5,6 +5,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
+using System.Security.Cryptography;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
@@ -106,12 +107,31 @@ public void WritePE (Stream stream)
 			new PEHeaderBuilder (imageCharacteristics: Characteristics.Dll),
 			new MetadataRootBuilder (Metadata),
 			ILBuilder,
-			mappedFieldData: _mappedFieldData.Count > 0 ? _mappedFieldData : null);
+			mappedFieldData: _mappedFieldData.Count > 0 ? _mappedFieldData : null,
+			deterministicIdProvider: CreateDeterministicContentId);
 		var peBlob = new BlobBuilder ();
 		peBuilder.Serialize (peBlob);
 		peBlob.WriteContentTo (stream);
 	}
 
+	static BlobContentId CreateDeterministicContentId (IEnumerable<Blob> blobs)
+	{
+		using var sha = SHA256.Create ();
+		foreach (var blob in blobs) {
+			var bytes = blob.GetBytes ();
+			if (bytes.Array is null) {
+				continue;
+			}
+			sha.TransformBlock (bytes.Array, bytes.Offset, bytes.Count, null, 0);
+		}
+		sha.TransformFinalBlock ([], 0, 0);
+		var hash = sha.Hash;
+		if (hash is null) {
+			throw new InvalidOperationException ("SHA256 did not produce a hash.");
+		}
+		return BlobContentId.FromHash (hash);
+	}
+
 	/// <summary>
 	/// Adds (or retrieves from cache) an assembly reference.
 	/// </summary>
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
index b54c2f535ec..33ee23cf36c 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
@@ -93,7 +93,7 @@ public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSha
 		moduleName ??= assemblyName + ".dll";
 
 		var pe = new PEAssemblyBuilder (_systemRuntimeVersion);
-		pe.EmitPreamble (assemblyName, moduleName);
+		pe.EmitPreamble (assemblyName, moduleName, MetadataHelper.ComputeRootContentFingerprint (_systemRuntimeVersion, perAssemblyTypeMapNames, useSharedTypemapUniverse, maxArrayRank));
 
 		EntityHandle anchorTypeHandle;
 		if (useSharedTypemapUniverse) {
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs
index 8ab18800ea5..610139d01f9 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs
@@ -80,6 +80,7 @@ sealed class TypeMapAssemblyEmitter
 
 	TypeReferenceHandle _javaPeerProxyRef;
 	TypeReferenceHandle _javaPeerProxyNonGenericRef;
+	TypeReferenceHandle _javaArrayProxyRef;
 	TypeReferenceHandle _iJavaPeerableRef;
 	TypeReferenceHandle _jniHandleOwnershipRef;
 	TypeReferenceHandle _jniObjectReferenceRef;
@@ -88,6 +89,9 @@ sealed class TypeMapAssemblyEmitter
 	TypeReferenceHandle _iAndroidCallableWrapperRef;
 	TypeReferenceHandle _jniEnvRef;
 	TypeReferenceHandle _javaLangObjectRef;
+	TypeReferenceHandle _javaObjectArrayOpenRef;
+	TypeReferenceHandle _javaArrayOpenRef;
+	TypeReferenceHandle _javaPrimitiveArrayOpenRef;
 	TypeReferenceHandle _systemTypeRef;
 	TypeReferenceHandle _systemArrayRef;
 	TypeReferenceHandle _runtimeTypeHandleRef;
@@ -115,6 +119,7 @@ sealed class TypeMapAssemblyEmitter
 	BlobHandle _ucoAttrBlobHandle;
 	MemberReferenceHandle _typeMapAttrCtorRef2Arg;
 	MemberReferenceHandle _typeMapAttrCtorRef3Arg;
+	MemberReferenceHandle _javaArrayProxyCtorRef;
 	MemberReferenceHandle _typeMapAssociationAttrCtorRef;
 
 	// RegisterNatives with JniNativeMethod
@@ -145,7 +150,8 @@ sealed class TypeMapAssemblyEmitter
 	// aren't emitted.
 	EntityHandle [] _rankAnchorHandles = [];
 
-	// Per-anchor TypeMap<TGroup>(string, Type, Type) ctor refs, lazily built.
+	// Per-anchor TypeMap<TGroup> ctor refs, lazily built.
+	readonly Dictionary<EntityHandle, MemberReferenceHandle> _typeMapAttr2ArgCtorRefByAnchor = new ();
 	readonly Dictionary<EntityHandle, MemberReferenceHandle> _typeMapAttr3ArgCtorRefByAnchor = new ();
 
 	// Cached open TypeMapAttribute`1 ref shared across closed TypeSpecs.
@@ -214,6 +220,10 @@ void EmitCore (TypeMapAssemblyData model, bool useSharedTypemapUniverse)
 			EmitAliasHolderType (holder);
 		}
 
+		foreach (var arrayProxy in model.ArrayProxyTypes) {
+			EmitArrayProxyType (arrayProxy);
+		}
+
 		foreach (var entry in model.Entries) {
 			EmitTypeMapAttribute (entry);
 		}
@@ -278,6 +288,8 @@ void EmitTypeReferences ()
 			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaPeerProxy`1"));
 		_javaPeerProxyNonGenericRef = metadata.AddTypeReference (_pe.MonoAndroidRef,
 			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaPeerProxy"));
+		_javaArrayProxyRef = metadata.AddTypeReference (_pe.MonoAndroidRef,
+			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaArrayProxy"));
 		_iJavaPeerableRef = metadata.AddTypeReference (_javaInteropRef,
 			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("IJavaPeerable"));
 		_jniHandleOwnershipRef = metadata.AddTypeReference (_pe.MonoAndroidRef,
@@ -286,6 +298,12 @@ void EmitTypeReferences ()
 			metadata.GetOrAddString ("Android.Runtime"), metadata.GetOrAddString ("JNIEnv"));
 		_javaLangObjectRef = metadata.AddTypeReference (_pe.MonoAndroidRef,
 			metadata.GetOrAddString ("Java.Lang"), metadata.GetOrAddString ("Object"));
+		_javaObjectArrayOpenRef = metadata.AddTypeReference (_javaInteropRef,
+			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaObjectArray`1"));
+		_javaArrayOpenRef = metadata.AddTypeReference (_javaInteropRef,
+			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaArray`1"));
+		_javaPrimitiveArrayOpenRef = metadata.AddTypeReference (_javaInteropRef,
+			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JavaPrimitiveArray`1"));
 		_jniObjectReferenceRef = metadata.AddTypeReference (_javaInteropRef,
 			metadata.GetOrAddString ("Java.Interop"), metadata.GetOrAddString ("JniObjectReference"));
 		_jniObjectReferenceTypeRef = metadata.AddTypeReference (_javaInteropRef,
@@ -385,6 +403,9 @@ void EmitMemberReferences ()
 				rt => rt.Type ().Type (_systemTypeRef, false),
 				p => p.AddParameter ().Type ().Type (_runtimeTypeHandleRef, true)));
 
+		_javaArrayProxyCtorRef = _pe.AddMemberRef (_javaArrayProxyRef, ".ctor",
+			sig => sig.MethodSignature (isInstanceMethod: true).Parameters (0, rt => rt.Void (), p => { }));
+
 		_getUninitializedObjectRef = _pe.AddMemberRef (_runtimeHelpersRef, "GetUninitializedObject",
 			sig => sig.MethodSignature ().Parameters (1,
 				rt => rt.Type ().Object (),
@@ -556,26 +577,39 @@ void EmitTypeMapAttributeCtorRef ()
 			metadata.GetOrAddString ("System.Runtime.InteropServices"),
 			metadata.GetOrAddString ("TypeMapAttribute`1"));
 
-		var closedAttrTypeSpec = _pe.MakeGenericTypeSpec (_typeMapAttrOpenRef, _anchorTypeHandle);
+		// 2-arg: TypeMap(string jniName, Type proxyType) — unconditional.
+		_typeMapAttrCtorRef2Arg = AddTypeMapAttr2ArgCtorRef (_anchorTypeHandle);
+		_typeMapAttr2ArgCtorRefByAnchor [_anchorTypeHandle] = _typeMapAttrCtorRef2Arg;
+
+		// 3-arg: TypeMap(string jniName, Type proxyType, Type targetType) — trimmable.
+		// Cache by anchor so rank-anchored entries can build their own closed ctor on demand.
+		_typeMapAttrCtorRef3Arg = AddTypeMapAttr3ArgCtorRef (_anchorTypeHandle);
+		_typeMapAttr3ArgCtorRefByAnchor [_anchorTypeHandle] = _typeMapAttrCtorRef3Arg;
+	}
+
+	/// <summary>Cached 2-arg <c>TypeMap&lt;TGroup&gt;</c> ctor ref for the given anchor, built on first use.</summary>
+	MemberReferenceHandle GetOrAddTypeMapAttr2ArgCtorRef (EntityHandle anchor)
+	{
+		if (_typeMapAttr2ArgCtorRefByAnchor.TryGetValue (anchor, out var cached)) {
+			return cached;
+		}
+		var ctorRef = AddTypeMapAttr2ArgCtorRef (anchor);
+		_typeMapAttr2ArgCtorRefByAnchor [anchor] = ctorRef;
+		return ctorRef;
+	}
 
-		// 2-arg: TypeMap(string jniName, Type proxyType) — unconditional. Default anchor only;
-		// rank-anchored entries are always conditional (3-arg) so no per-rank 2-arg ctor is
-		// needed today.
-		_typeMapAttrCtorRef2Arg = _pe.AddMemberRef (closedAttrTypeSpec, ".ctor",
+	MemberReferenceHandle AddTypeMapAttr2ArgCtorRef (EntityHandle anchor)
+	{
+		var closedAttrTypeSpec = _pe.MakeGenericTypeSpec (_typeMapAttrOpenRef, anchor);
+		return _pe.AddMemberRef (closedAttrTypeSpec, ".ctor",
 			sig => sig.MethodSignature (isInstanceMethod: true).Parameters (2,
 				rt => rt.Void (),
 				p => {
 					p.AddParameter ().Type ().String ();
 					p.AddParameter ().Type ().Type (_systemTypeRef, false);
 				}));
-
-		// 3-arg: TypeMap(string jniName, Type proxyType, Type targetType) — trimmable.
-		// Cache by anchor so rank-anchored entries can build their own closed ctor on demand.
-		_typeMapAttrCtorRef3Arg = AddTypeMapAttr3ArgCtorRef (_anchorTypeHandle);
-		_typeMapAttr3ArgCtorRefByAnchor [_anchorTypeHandle] = _typeMapAttrCtorRef3Arg;
 	}
 
-	/// <summary>Cached 3-arg <c>TypeMap&lt;TGroup&gt;</c> ctor ref for the given anchor, built on first use.</summary>
 	MemberReferenceHandle GetOrAddTypeMapAttr3ArgCtorRef (EntityHandle anchor)
 	{
 		if (_typeMapAttr3ArgCtorRefByAnchor.TryGetValue (anchor, out var cached)) {
@@ -775,6 +809,69 @@ void EmitAliasHolderType (AliasHolderData holder)
 		EmitJavaPeerAliasesAttribute (typeDefHandle, holder.AliasKeys);
 	}
 
+	void EmitArrayProxyType (ArrayProxyData proxy)
+	{
+		var metadata = _pe.Metadata;
+		var typeDefHandle = metadata.AddTypeDefinition (
+			TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Class,
+			metadata.GetOrAddString (proxy.Namespace),
+			metadata.GetOrAddString (proxy.TypeName),
+			_javaArrayProxyRef,
+			MetadataTokens.FieldDefinitionHandle (metadata.GetRowCount (TableIndex.Field) + 1),
+			MetadataTokens.MethodDefinitionHandle (metadata.GetRowCount (TableIndex.MethodDef) + 1));
+
+		var selfAttrCtorDef = _pe.EmitBody (".ctor",
+			MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName,
+			sig => sig.MethodSignature (isInstanceMethod: true).Parameters (0, rt => rt.Void (), p => { }),
+			encoder => {
+				encoder.OpCode (ILOpCode.Ldarg_0);
+				encoder.Call (_javaArrayProxyCtorRef, parameterCount: 0, isInstance: true);
+				encoder.Return ();
+			});
+
+		metadata.AddCustomAttribute (typeDefHandle, selfAttrCtorDef, _pe.BuildAttributeBlob (b => { }));
+
+		EmitArrayProxyGetArrayTypes (proxy);
+		EmitArrayProxyCreateManagedArray (proxy);
+	}
+
+	void EmitArrayProxyGetArrayTypes (ArrayProxyData proxy)
+	{
+		var arrayTypes = GetArrayProxyTypes (proxy);
+		_pe.EmitBody ("GetArrayTypes",
+			MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig,
+			sig => sig.MethodSignature (isInstanceMethod: true).Parameters (0,
+				rt => rt.Type ().SZArray ().Type (_systemTypeRef, false),
+				p => { }),
+			encoder => {
+				encoder.LoadConstantI4 (arrayTypes.Count);
+				encoder.NewArray (_systemTypeRef);
+				for (int i = 0; i < arrayTypes.Count; i++) {
+					encoder.OpCode (ILOpCode.Dup);
+					encoder.LoadConstantI4 (i);
+					encoder.LoadToken (ResolveRuntimeTypeSpec (arrayTypes [i]));
+					encoder.Call (_getTypeFromHandleRef, parameterCount: 1, returnsValue: true);
+					encoder.OpCode (ILOpCode.Stelem_ref);
+				}
+				encoder.Return (returnsValue: true);
+			});
+	}
+
+	void EmitArrayProxyCreateManagedArray (ArrayProxyData proxy)
+	{
+		var elementType = AddSzArrayRank (new NamedRuntimeTypeSpec (proxy.ElementType), proxy.Rank - 1);
+		_pe.EmitBody ("CreateManagedArray",
+			MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig,
+			sig => sig.MethodSignature (isInstanceMethod: true).Parameters (1,
+				rt => rt.Type ().Type (_systemArrayRef, false),
+				p => p.AddParameter ().Type ().Int32 ()),
+			encoder => {
+				encoder.LoadArgument (1);
+				encoder.NewArray (ResolveRuntimeTypeSpec (elementType));
+				encoder.Return (returnsValue: true);
+			});
+	}
+
 	void EmitJavaPeerAliasesAttributeCtorRef ()
 	{
 		// JavaPeerAliasesAttribute(params string[] aliases) — in Mono.Android, Java.Interop namespace
@@ -1476,6 +1573,105 @@ void EmitManagedConstructorArgument (TrackedInstructionEncoder encoder, TypeRefD
 		encoder.CastClass (managedTypeHandle);
 	}
 
+	IReadOnlyList<RuntimeTypeSpec> GetArrayProxyTypes (ArrayProxyData proxy)
+	{
+		var elementType = new NamedRuntimeTypeSpec (proxy.ElementType);
+		if (proxy.Primitive is null) {
+			var rankOneObjectTypes = new RuntimeTypeSpec [] {
+				new GenericRuntimeTypeSpec (_javaObjectArrayOpenRef, elementType),
+				new GenericRuntimeTypeSpec (_javaArrayOpenRef, elementType),
+				AddSzArrayRank (elementType, 1),
+			};
+			return ExpandRankOneTypes (rankOneObjectTypes, proxy.Rank);
+		}
+
+		var rankOneTypes = new RuntimeTypeSpec [] {
+			AddSzArrayRank (elementType, 1),
+			new GenericRuntimeTypeSpec (_javaArrayOpenRef, elementType),
+			new GenericRuntimeTypeSpec (_javaPrimitiveArrayOpenRef, elementType),
+			new NamedRuntimeTypeSpec (proxy.Primitive.ConcreteArrayType),
+		};
+
+		if (proxy.Rank == 1) {
+			return rankOneTypes;
+		}
+
+		return ExpandRankOneTypes (rankOneTypes, proxy.Rank);
+	}
+
+	IReadOnlyList<RuntimeTypeSpec> ExpandRankOneTypes (IReadOnlyList<RuntimeTypeSpec> rankOneTypes, int rank)
+	{
+		if (rank == 1) {
+			return rankOneTypes;
+		}
+
+		var result = new List<RuntimeTypeSpec> (rankOneTypes.Count * 2);
+		foreach (var type in rankOneTypes) {
+			result.Add (MakeNestedJavaObjectArrayType (type, rank - 1));
+			result.Add (AddSzArrayRank (type, rank - 1));
+		}
+		return result;
+	}
+
+	static RuntimeTypeSpec AddSzArrayRank (RuntimeTypeSpec elementType, int rank)
+	{
+		var result = elementType;
+		for (int i = 0; i < rank; i++) {
+			result = new SzArrayRuntimeTypeSpec (result);
+		}
+		return result;
+	}
+
+	RuntimeTypeSpec MakeNestedJavaObjectArrayType (RuntimeTypeSpec elementType, int rank)
+	{
+		var result = elementType;
+		for (int i = 0; i < rank; i++) {
+			result = new GenericRuntimeTypeSpec (_javaObjectArrayOpenRef, result);
+		}
+		return result;
+	}
+
+	EntityHandle ResolveRuntimeTypeSpec (RuntimeTypeSpec type)
+	{
+		if (type is NamedRuntimeTypeSpec namedType) {
+			return _pe.ResolveTypeRef (namedType.Type);
+		}
+
+		var blob = new BlobBuilder (64);
+		EncodeRuntimeTypeSpec (blob, type);
+		return _pe.Metadata.AddTypeSpecification (_pe.Metadata.GetOrAddBlob (blob));
+	}
+
+	void EncodeRuntimeTypeSpec (BlobBuilder blob, RuntimeTypeSpec type)
+	{
+		switch (type) {
+		case NamedRuntimeTypeSpec namedType:
+			WriteManagedTypeSignature (blob, namedType.Type.ManagedTypeName, namedType.Type.AssemblyName);
+			break;
+		case SzArrayRuntimeTypeSpec arrayType:
+			blob.WriteByte (0x1D); // ELEMENT_TYPE_SZARRAY
+			EncodeRuntimeTypeSpec (blob, arrayType.ElementType);
+			break;
+		case GenericRuntimeTypeSpec genericType:
+			blob.WriteByte (0x15); // ELEMENT_TYPE_GENERICINST
+			blob.WriteByte (0x12); // ELEMENT_TYPE_CLASS
+			blob.WriteCompressedInteger (CodedIndex.TypeDefOrRefOrSpec (genericType.OpenType));
+			blob.WriteCompressedInteger (1); // generic arity = 1
+			EncodeRuntimeTypeSpec (blob, genericType.Argument);
+			break;
+		default:
+			throw new InvalidOperationException ($"Unsupported runtime type spec '{type.GetType ()}'.");
+		}
+	}
+
+	abstract record RuntimeTypeSpec;
+
+	sealed record NamedRuntimeTypeSpec (TypeRefData Type) : RuntimeTypeSpec;
+
+	sealed record SzArrayRuntimeTypeSpec (RuntimeTypeSpec ElementType) : RuntimeTypeSpec;
+
+	sealed record GenericRuntimeTypeSpec (EntityHandle OpenType, RuntimeTypeSpec Argument) : RuntimeTypeSpec;
+
 	EntityHandle ResolveManagedTypeHandle (string managedType, string defaultAssemblyName)
 	{
 		if (TryGetSzArrayElementType (managedType, out var elementType)) {
@@ -1729,17 +1925,15 @@ void EmitTypeMapAttribute (TypeMapAttributeData entry)
 	{
 		MemberReferenceHandle ctorRef;
 		if (entry.AnchorRank is int rank) {
-			if (entry.IsUnconditional) {
-				throw new InvalidOperationException (
-					$"Rank-anchored TypeMap entries must be conditional (3-arg). Entry '{entry.JniName}' rank={rank}.");
-			}
 			int anchorIndex = rank - 1;
 			if ((uint)anchorIndex >= (uint)_rankAnchorHandles.Length) {
 				throw new InvalidOperationException (
 					$"No rank-{rank} anchor available for entry '{entry.JniName}'. " +
 					$"Ensure TypeMapAssemblyData.MaxArrayRank was >= {rank} before emit.");
 			}
-			ctorRef = GetOrAddTypeMapAttr3ArgCtorRef (_rankAnchorHandles [anchorIndex]);
+			ctorRef = entry.IsUnconditional
+				? GetOrAddTypeMapAttr2ArgCtorRef (_rankAnchorHandles [anchorIndex])
+				: GetOrAddTypeMapAttr3ArgCtorRef (_rankAnchorHandles [anchorIndex]);
 		} else {
 			ctorRef = entry.IsUnconditional ? _typeMapAttrCtorRef2Arg : _typeMapAttrCtorRef3Arg;
 		}
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
index 08316ff1787..fa92522e530 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
@@ -210,13 +210,16 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A
 
 			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);
-			// }
+			// Framework/runtime assemblies contain internal [JniAddNativeMethodRegistration]
+			// users such as Java.Interop.JavaProxyObject and Java.Interop.ManagedPeer.
+			// The diagnostic is for user assemblies because the trimmable runtime either
+			// has generated replacements for framework registration or intentionally
+			// disables unsupported runtime paths.
+			if (!frameworkAssemblyNames.Contains (index.AssemblyName) &&
+			    index.MayUseJniAddNativeMethodRegistrationAttribute &&
+			    HasJniAddNativeMethodRegistrationAttribute (typeDef, index)) {
+				logger?.LogJniAddNativeMethodRegistrationAttributeError (fullName);
+			}
 
 			// Determine the JNI name and whether this is a known Java peer.
 			// Priority:
@@ -413,12 +416,6 @@ 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/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ScannerHashingHelper.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ScannerHashingHelper.cs
index fe3aa9aaed0..9132d036a0f 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ScannerHashingHelper.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/ScannerHashingHelper.cs
@@ -26,15 +26,12 @@ internal static string ToLegacyCrc64 (string ns, string assemblyName)
 
 	internal static string ToCrc64 (string ns, string assemblyName)
 	{
-		const int stackallocThresholdBytes = 256;
 		int byteCount = GetNamespaceAssemblyUtf8ByteCount (ns, assemblyName);
-		Span<byte> utf8Buffer = byteCount <= stackallocThresholdBytes
-			? stackalloc byte [stackallocThresholdBytes]
-			: new byte [byteCount];
+		byte[] utf8Buffer = new byte [byteCount];
 
-		int bytesWritten = GetNamespaceAssemblyUtf8Bytes (ns, assemblyName, utf8Buffer.Slice (0, byteCount));
-		Span<byte> hash = stackalloc byte [8];
-		System.IO.Hashing.Crc64.Hash (utf8Buffer.Slice (0, bytesWritten), hash);
+		int bytesWritten = GetNamespaceAssemblyUtf8Bytes (ns, assemblyName, utf8Buffer);
+		// Avoid Span overloads here: their assembly identity differs between netstandard and netCore System.IO.Hashing assets.
+		byte[] hash = System.IO.Hashing.Crc64.Hash (utf8Buffer);
 		ulong hashValue = BinaryPrimitives.ReadUInt64LittleEndian (hash);
 		BinaryPrimitives.WriteUInt64LittleEndian (hash, hashValue ^ (ulong) bytesWritten);
 		return ToHexString (hash);
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
index 95d0446b205..e5c2a37be5a 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
@@ -34,8 +34,7 @@ public TrimmableTypeMapResult Execute (
 		ManifestConfig? manifestConfig = null,
 		XDocument? manifestTemplate = null,
 		string? packageNamingPolicy = null,
-		int maxArrayRank = 0,
-		bool generateTypeMapAssemblies = true)
+		int maxArrayRank = 0)
 	{
 		_ = assemblies ?? throw new ArgumentNullException (nameof (assemblies));
 		_ = systemRuntimeVersion ?? throw new ArgumentNullException (nameof (systemRuntimeVersion));
@@ -55,9 +54,7 @@ public TrimmableTypeMapResult Execute (
 		PropagateDeferredRegistrationToBaseClasses (allPeers);
 		PropagateCannotRegisterToDescendants (allPeers);
 
-		var generatedAssemblies = generateTypeMapAssemblies
-			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank)
-			: [];
+		var generatedAssemblies = GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank);
 		var jcwPeers = allPeers.Where (ShouldGenerateJcw).ToList ();
 		logger.LogGeneratingJcwFilesInfo (jcwPeers.Count, allPeers.Count);
 		var generatedJavaSources = GenerateJcwJavaSources (jcwPeers);
diff --git a/src/Mono.Android/Android.Graphics/Color.cs b/src/Mono.Android/Android.Graphics/Color.cs
index 1f4bde8455c..bcc1002b3ac 100644
--- a/src/Mono.Android/Android.Graphics/Color.cs
+++ b/src/Mono.Android/Android.Graphics/Color.cs
@@ -434,7 +434,6 @@ public static void RGBToHSV (int red, int green, int blue, float[] hsv)
 
 	public class ColorValueMarshaler : JniValueMarshaler<Color>
 	{
-		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 		const string ExpressionRequiresUnreferencedCode = "System.Linq.Expression usage may trim away required code.";
 
 		public override Type MarshalType {
@@ -444,7 +443,6 @@ public override Type MarshalType {
 		public override Color CreateGenericValue (
 				ref JniObjectReference reference,
 				JniObjectReferenceOptions options,
-				[DynamicallyAccessedMembers (Constructors)]
 				Type targetType)
 		{
 			throw new NotImplementedException ();
diff --git a/src/Mono.Android/Android.Runtime/AndroidRuntime.cs b/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
index dd0d94a73a9..cb05c9da9b1 100644
--- a/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
+++ b/src/Mono.Android/Android.Runtime/AndroidRuntime.cs
@@ -58,6 +58,10 @@ public override string GetCurrentManagedThreadStackTrace (int skipFrames, bool f
 			if (!reference.IsValid)
 				return null;
 			var peeked      = JniEnvironment.Runtime.ValueManager.PeekPeer (reference);
+			if (peeked is JavaProxyThrowable proxyThrowable) {
+				JniObjectReference.Dispose (ref reference, options);
+				return proxyThrowable.InnerException;
+			}
 			var peekedExc   = peeked as Exception;
 			if (peekedExc == null) {
 				var throwable = Java.Lang.Object.GetObject<Java.Lang.Throwable> (reference.Handle, JniHandleOwnership.DoNotTransfer);
@@ -310,14 +314,12 @@ public override void DeleteWeakGlobalReference (ref JniObjectReference value)
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	[RequiresDynamicCode ("This type manager is reflection-backed and is not compatible with Native AOT.")]
+	[RequiresUnreferencedCode ("This type manager is reflection-backed and is not trimming-compatible.")]
 	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)
 		{
@@ -334,8 +336,6 @@ 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);
@@ -352,21 +352,22 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 			if (j != null) {
 				return GetReplacementTypeCore (j) ?? j;
 			}
-			return base.GetSimpleReference (type);
+			// Intentionally don't call base.GetSimpleReference(type): Android's
+			// non-trimmable runtime uses the generated/registered typemap, not
+			// Java.Interop's JniTypeSignatureAttribute fallback.
+			return null;
 		}
 
 		protected override IEnumerable<string> GetSimpleReferences (Type type)
 		{
 			string? j = JNIEnv.TypemapManagedToJava (type);
-			j   = GetReplacementTypeCore (j) ?? j;
+			j	   = GetReplacementTypeCore (j) ?? j;
 
 			if (j != null) {
-				yield return j;
-				yield break;
-			}
-			foreach (var r in base.GetSimpleReferences (type)) {
-				yield return r;
+				return [j];
 			}
+			// Keep this in sync with GetSimpleReference(): no base fallback.
+			return [];
 		}
 
 		protected override IReadOnlyList<string>? GetStaticMethodFallbackTypesCore (string jniSimpleReference)
@@ -374,7 +375,7 @@ protected override IEnumerable<string> GetSimpleReferences (Type type)
 			return JniRemappingLookup.GetStaticMethodFallbackTypes (jniSimpleReference, useReplacementTypes: true);
 		}
 
-		protected override string? GetReplacementTypeCore (string jniSimpleReference)
+		protected override string? GetReplacementTypeCore (string? jniSimpleReference)
 		{
 			return JniRemappingLookup.GetReplacementType (jniSimpleReference);
 		}
@@ -384,10 +385,7 @@ protected override IEnumerable<string> GetSimpleReferences (Type type)
 			return JniRemappingLookup.GetReplacementMethodInfo (jniSourceType, jniMethodName, jniMethodSignature);
 		}
 
-		[return: DynamicallyAccessedMembers (Constructors)]
-		protected override Type? GetInvokerTypeCore (
-			[DynamicallyAccessedMembers (Constructors)]
-			Type type)
+		protected override Type? GetInvokerTypeCore (Type type)
 		{
 			if (type.IsInterface || type.IsAbstract) {
 				return JavaObjectExtensions.GetInvokerType (type)
@@ -402,8 +400,6 @@ protected override IEnumerable<string> GetSimpleReferences (Type type)
 		static MethodInfo? dynamic_callback_gen;
 
 		// See ExportAttribute.cs
-		[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Mono.Android.Export.dll is preserved when [Export] is used via [DynamicDependency].")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2075", Justification = "Mono.Android.Export.dll is preserved when [Export] is used via [DynamicDependency].")]
 		static Delegate CreateDynamicCallback (MethodInfo method)
 		{
 			if (dynamic_callback_gen == null) {
@@ -498,20 +494,10 @@ static bool CallRegisterMethodByIndex (JniNativeMethodRegistrationArguments argu
 		}
 
 		[Obsolete ("Use RegisterNativeMembers(JniType, Type, ReadOnlySpan<char>) instead.")]
-		public override void RegisterNativeMembers (
-				JniType nativeClass,
-				[DynamicallyAccessedMembers (MethodsAndPrivateNested)]
-				Type type,
-				string? methods) =>
+		public override void RegisterNativeMembers (JniType nativeClass, Type type, string? methods) =>
 			RegisterNativeMembers (nativeClass, type, methods.AsSpan ());
 
-		[UnconditionalSuppressMessage ("Trimming", "IL2057", Justification = "Type.GetType() can never statically know the string value parsed from parameter 'methods'.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2067", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2072", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-		public override void RegisterNativeMembers (
-				JniType nativeClass,
-				[DynamicallyAccessedMembers (MethodsAndPrivateNested)] Type type,
-				ReadOnlySpan<char> methods)
+		public override void RegisterNativeMembers (JniType nativeClass, Type type, ReadOnlySpan<char> methods)
 		{
 			try {
 				if (methods.IsEmpty) {
@@ -595,15 +581,6 @@ public override void RegisterNativeMembers (
 			} catch (Exception e) {
 				JniEnvironment.Runtime.RaisePendingException (e);
 			}
-
-			bool ShouldRegisterDynamically (string callbackTypeName, string callbackString, string typeName, string callbackName)
-			{
-				if (String.Compare (typeName, callbackTypeName, StringComparison.Ordinal) != 0) {
-					return false;
-				}
-
-				return String.Compare (callbackName, callbackString, StringComparison.Ordinal) == 0;
-			}
 		}
 
 		static int CountMethods (ReadOnlySpan<char> methodsSpan)
@@ -640,7 +617,8 @@ static void SplitMethodLine (
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	[RequiresDynamicCode ("This value manager is reflection-backed and is not compatible with Native AOT.")]
+	[RequiresUnreferencedCode ("This value manager is reflection-backed and is not trimming-compatible.")]
 	class AndroidValueManager : JniRuntime.ReflectionJniValueManager {
 
 		Dictionary<IntPtr, IdentityHashTargets>         instances       = new Dictionary<IntPtr, IdentityHashTargets> ();
@@ -850,11 +828,7 @@ internal void RemovePeer (IJavaPeerable value, IntPtr hash)
 			return null;
 		}
 
-		public override void ActivatePeer (
-			JniObjectReference reference,
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type,
-			ConstructorInfo cinfo,
-			object?[]? argumentValues)
+		public override void ActivatePeer (JniObjectReference reference, Type type, ConstructorInfo cinfo, object?[]? argumentValues)
 		{
 			Java.Interop.TypeManager.Activate (reference.Handle, cinfo, argumentValues);
 		}
diff --git a/src/Mono.Android/Android.Runtime/IJavaObjectValueMarshaler.cs b/src/Mono.Android/Android.Runtime/IJavaObjectValueMarshaler.cs
index 79230b9d2eb..443b4e5890b 100644
--- a/src/Mono.Android/Android.Runtime/IJavaObjectValueMarshaler.cs
+++ b/src/Mono.Android/Android.Runtime/IJavaObjectValueMarshaler.cs
@@ -9,8 +9,6 @@
 namespace Android.Runtime
 {
 	sealed class IJavaObjectValueMarshaler : JniValueMarshaler<IJavaObject> {
-
-		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
 		const string ExpressionRequiresUnreferencedCode = "System.Linq.Expression usage may trim away required code.";
 
 		internal    static  IJavaObjectValueMarshaler              Instance    = new IJavaObjectValueMarshaler ();
@@ -18,7 +16,6 @@ sealed class IJavaObjectValueMarshaler : JniValueMarshaler<IJavaObject> {
 		public override IJavaObject CreateGenericValue (
 				ref JniObjectReference reference,
 				JniObjectReferenceOptions options,
-				[DynamicallyAccessedMembers (Constructors)]
 				Type? targetType)
 		{
 			throw new NotImplementedException ();
@@ -49,6 +46,8 @@ public override Expression CreateReturnValueFromManagedExpression (JniValueMarsh
 		[RequiresUnreferencedCode (ExpressionRequiresUnreferencedCode)]
 		public override Expression CreateParameterToManagedExpression (JniValueMarshalerContext context, ParameterExpression sourceValue, ParameterAttributes synchronize, Type? targetType)
 		{
+			ArgumentNullException.ThrowIfNull (targetType);
+
 			var r   = Expression.Variable (targetType, sourceValue.Name + "_val");
 			context.LocalVariables.Add (r);
 			context.CreationStatements.Add (
diff --git a/src/Mono.Android/Android.Runtime/JNIEnv.cs b/src/Mono.Android/Android.Runtime/JNIEnv.cs
index ebfc81cc39b..433d1a0d53e 100644
--- a/src/Mono.Android/Android.Runtime/JNIEnv.cs
+++ b/src/Mono.Android/Android.Runtime/JNIEnv.cs
@@ -27,20 +27,22 @@ public static partial class JNIEnv {
 		static Array ArrayCreateInstance (Type elementType, int length)
 		{
 			if (RuntimeFeature.TrimmableTypeMap) {
-				if (System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported) {
+				if (RuntimeFeature.IsCoreClrRuntime) {
 					// CoreCLR runtime type loader can construct any T[] dynamically.
 					// IsDynamicCodeSupported is a [FeatureGuard] so this branch is
 					// dead-coded under PublishAot.
 					return Array.CreateInstance (elementType, length);
 				}
 
-				// NativeAOT: resolve via per-rank typemap + Array.CreateInstanceFromArrayType.
-				if (TrimmableTypeMap.Instance.TryGetArrayType (elementType, out var arrayType)) {
-					return Array.CreateInstanceFromArrayType (arrayType, length);
+				if (RuntimeFeature.IsNativeAotRuntime) {
+					// NativeAOT: resolve via per-rank typemap + generated array proxy.
+					if (TrimmableTypeMap.Instance.TryGetArrayProxy (elementType, additionalRank: 1, out var arrayProxy)) {
+						return arrayProxy.CreateManagedArray (length);
+					}
 				}
 
 				throw new NotSupportedException (
-					$"No TrimmableTypeMap array entry for element type '{elementType}'. " +
+					$"No TrimmableTypeMap array proxy entry for element type '{elementType}'. " +
 					$"Array lookups use the element type within the per-rank __ArrayMapRank{GetArrayRank (elementType)} typemap group; " +
 					$"ensure the mapping is emitted for that rank (for example by increasing _AndroidTrimmableTypeMapMaxArrayRank) or report an issue.");
 			}
@@ -64,13 +66,6 @@ static int GetArrayRank (Type elementType)
 			return rank;
 		}
 
-		static Type MakeArrayType (Type type) =>
-			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-			// IL3050 disabled in source: if someone uses NativeAOT, they will get the warning.
-			#pragma warning disable IL3050
-			type.MakeArrayType ();
-			#pragma warning restore IL3050
-
 		internal static IntPtr IdentityHash (IntPtr v)
 		{
 			return JniEnvironment.References.GetIdentityHashCode (new JniObjectReference (v));
@@ -309,10 +304,7 @@ public static IntPtr FindClass (System.Type type)
 				}
 				sig = sig.AddArrayRank (rank);
 
-				JniObjectReference local_ref = JniEnvironment.Types.FindClass (sig.Name);
-				IntPtr global_ref = local_ref.NewGlobalRef ().Handle;
-				JniObjectReference.Dispose (ref local_ref);
-				return global_ref;
+				return FindClass (sig.Name);
 			} catch (Java.Lang.Throwable e) {
 				if (!((e is Java.Lang.NoClassDefFoundError) || (e is Java.Lang.ClassNotFoundException)))
 					throw;
@@ -577,9 +569,9 @@ public static unsafe IntPtr NewString (char[]? text, int length)
 				return JniEnvironment.Strings.NewString (s, length).Handle;
 		}
 
-		static void AssertCompatibleArrayTypes (Type sourceType, IntPtr destArray)
+		static void AssertCompatibleArrayTypes (Type srcElementType, IntPtr destArray)
 		{
-			IntPtr grefSource = FindClass (sourceType);
+			IntPtr grefSource = FindArrayClassByElementType (srcElementType);
 			IntPtr lrefDest   = GetObjectClass (destArray);
 			try {
 				if (!IsAssignableFrom (grefSource, lrefDest)) {
@@ -592,9 +584,9 @@ static void AssertCompatibleArrayTypes (Type sourceType, IntPtr destArray)
 			}
 		}
 
-		static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destType)
+		static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destElementType)
 		{
-			IntPtr grefDest   = FindClass (destType);
+			IntPtr grefDest   = FindArrayClassByElementType (destElementType);
 			IntPtr lrefSource = GetObjectClass (sourceArray);
 			try {
 				if (!IsAssignableFrom (lrefSource, grefDest)) {
@@ -607,12 +599,19 @@ static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destType)
 			}
 		}
 
+		static IntPtr FindArrayClassByElementType (Type elementType)
+		{
+			int rank = JavaNativeTypeManager.GetArrayInfo (elementType, out elementType) + 1;
+			var typeSignature = JniRuntime.CurrentRuntime.TypeManager.GetTypeSignature (elementType).AddArrayRank (rank);
+			return FindClass (typeSignature.Name);
+		}
+
 		public static void CopyArray (IntPtr src, bool[] dest)
 		{
 			if (dest == null)
 				throw new ArgumentNullException ("dest");
 
-			AssertCompatibleArrayTypes (src, typeof (bool[]));
+			AssertCompatibleArrayTypes (src, destElementType: typeof (bool));
 
 			_GetBooleanArrayRegion (src, 0, dest.Length, dest);
 		}
@@ -804,7 +803,7 @@ public static void CopyArray (IntPtr src, Array dest, Type? elementType = null)
 				throw new ArgumentNullException ("dest");
 
 			if (elementType != null && elementType.IsValueType)
-				AssertCompatibleArrayTypes (src, MakeArrayType (elementType));
+				AssertCompatibleArrayTypes (src, destElementType: elementType);
 
 			if (elementType != null && elementType.IsArray) {
 				for (int i = 0; i < dest.Length; ++i) {
@@ -840,7 +839,7 @@ public static void CopyArray<T> (IntPtr src, T[] dest)
 				throw new ArgumentNullException ("dest");
 
 			if (typeof (T).IsValueType)
-				AssertCompatibleArrayTypes (src, typeof (T[]));
+				AssertCompatibleArrayTypes (src, destElementType: typeof (T));
 
 			if (typeof (T).IsArray) {
 				CopyArray (src, dest, typeof (T));
@@ -858,7 +857,7 @@ public static unsafe void CopyArray (bool[] src, IntPtr dest)
 			if (src == null)
 				throw new ArgumentNullException ("src");
 
-			AssertCompatibleArrayTypes (typeof (bool[]), dest);
+			AssertCompatibleArrayTypes (srcElementType: typeof (bool), dest);
 
 			fixed (bool* p = src)
 				JniEnvironment.Arrays.SetBooleanArrayRegion (new JniObjectReference (dest), 0, src.Length, p);
@@ -947,7 +946,7 @@ public static void CopyArray (Array source, Type elementType, IntPtr dest)
 				throw new ArgumentNullException ("elementType");
 
 			if (elementType.IsValueType)
-				AssertCompatibleArrayTypes (MakeArrayType (elementType), dest);
+				AssertCompatibleArrayTypes (srcElementType: elementType, dest);
 
 			Action<Array, IntPtr> converter = GetConverter (CopyManagedToNativeArray, elementType, dest);
 
@@ -1072,7 +1071,7 @@ public static void CopyArray<T> (T[] src, IntPtr dest)
 				return null;
 
 			if (element_type != null && element_type.IsValueType)
-				AssertCompatibleArrayTypes (array_ptr, MakeArrayType (element_type));
+				AssertCompatibleArrayTypes (array_ptr, destElementType: element_type);
 
 			int cnt = _GetArrayLength (array_ptr);
 
@@ -1119,7 +1118,7 @@ static int _GetArrayLength (IntPtr array_ptr)
 				return null;
 
 			if (typeof (T).IsValueType)
-				AssertCompatibleArrayTypes (array_ptr, typeof (T[]));
+				AssertCompatibleArrayTypes (array_ptr, destElementType: typeof (T));
 
 			int cnt = _GetArrayLength (array_ptr);
 			T[] ret = new T [cnt];
diff --git a/src/Mono.Android/Android.Runtime/JNIEnvInit.cs b/src/Mono.Android/Android.Runtime/JNIEnvInit.cs
index c2e7ea913ca..22390df92d1 100644
--- a/src/Mono.Android/Android.Runtime/JNIEnvInit.cs
+++ b/src/Mono.Android/Android.Runtime/JNIEnvInit.cs
@@ -174,28 +174,62 @@ internal static JniRuntime.JniTypeManager CreateTypeManager (JnienvInitializeArg
 				return new TrimmableTypeMapTypeManager ();
 			}
 
-			if (RuntimeFeature.IsNativeAotRuntime || RuntimeFeature.ManagedTypeMap) {
-				return new ManagedTypeManager ();
+			if (RuntimeFeature.IsNativeAotRuntime) {
+				throw new NotSupportedException ($"{nameof (RuntimeFeature.IsNativeAotRuntime)} requires {nameof (RuntimeFeature.TrimmableTypeMap)}.");
+			}
+
+			if (RuntimeFeature.IsMonoRuntime) {
+				return CreateAndroidTypeManagerWithSuppressedWarnings (args);
+			}
+
+			if (RuntimeFeature.IsCoreClrRuntime) {
+				return CreateAndroidTypeManagerWithSuppressedWarnings (args);
 			}
 
-			return new AndroidTypeManager (args.jniAddNativeMethodRegistrationAttributePresent != 0);
+			throw new NotSupportedException ("Internal error: unknown runtime not supported");
+
+			[UnconditionalSuppressMessage ("Trimming", "IL2026",
+				Justification = "We choose to ignore the trimming warnings for CoreCLR and Mono " +
+								"when using AndroidTypeManager because even though we use unconstrained reflection " +
+								"we expect the types to be preserved by custom trimmer steps and we don't expect " +
+								"the trimmer (ILLink) to remove any metadata need at runtime.")]
+			AndroidTypeManager CreateAndroidTypeManagerWithSuppressedWarnings (JnienvInitializeArgs args) =>
+				new AndroidTypeManager (args.jniAddNativeMethodRegistrationAttributePresent != 0);
 		}
 
 		internal static JniRuntime.JniValueManager CreateValueManager ()
 		{
-			if (RuntimeFeature.IsMonoRuntime) {
-				return new AndroidValueManager ();
+			if (RuntimeFeature.TrimmableTypeMap) {
+				return new TrimmableTypeMapValueManager ();
 			}
 
-			if (RuntimeFeature.IsCoreClrRuntime) {
-				return new JavaMarshalValueManager ();
+			if (RuntimeFeature.IsNativeAotRuntime) {
+				throw new NotSupportedException ($"Native AOT builds require using {nameof (RuntimeFeature.TrimmableTypeMap)}.");
 			}
 
-			if (RuntimeFeature.IsNativeAotRuntime) {
-				return new JavaMarshalValueManager ();
+			if (RuntimeFeature.IsMonoRuntime) {
+				return CreateAndroidValueManagerWithSuppressedWarnings ();
+			}
+
+			if (RuntimeFeature.IsCoreClrRuntime) {
+				return CreateCoreClrValueManagerWithSuppressedWarnings ();
 			}
 
 			throw new NotSupportedException ("Internal error: unknown runtime not supported");
+
+			[UnconditionalSuppressMessage ("Trimming", "IL2026",
+				Justification = "We choose to ignore the trimming warnings for Mono when using AndroidValueManager " +
+								"because even though we use unconstrained reflection " +
+								"we expect the types to be preserved by custom trimmer steps and we don't expect " +
+								"the trimmer (ILLink) to remove any metadata need at runtime.")]
+			JniRuntime.JniValueManager CreateAndroidValueManagerWithSuppressedWarnings () => new AndroidValueManager ();
+
+			[UnconditionalSuppressMessage ("Trimming", "IL2026",
+				Justification = "We choose to ignore the trimming warnings for CoreCLR when using CoreClrJavaMarshalValueManager " +
+								"because even though we use unconstrained reflection " +
+								"we expect the types to be preserved by custom trimmer steps and we don't expect " +
+								"the trimmer (ILLink) to remove any metadata need at runtime.")]
+			JniRuntime.JniValueManager CreateCoreClrValueManagerWithSuppressedWarnings () => new CoreClrJavaMarshalValueManager ();
 		}
 
 		static void InitializeCommonState (JnienvInitializeArgs args)
diff --git a/src/Mono.Android/Android.Runtime/JNINativeWrapper.cs b/src/Mono.Android/Android.Runtime/JNINativeWrapper.cs
index 10e38fcb236..84d7de20f76 100644
--- a/src/Mono.Android/Android.Runtime/JNINativeWrapper.cs
+++ b/src/Mono.Android/Android.Runtime/JNINativeWrapper.cs
@@ -26,6 +26,7 @@ static void get_runtime_types ()
 				AndroidEnvironment.FailFast ("Cannot find AndroidRuntimeInternal.WaitForBridgeProcessing");
 		}
 
+		[RequiresDynamicCode ("This method uses System.Reflection.Emit to create a delegate at runtime.")]
 		public static Delegate CreateDelegate (Delegate dlg)
 		{
 			if (dlg == null)
diff --git a/src/Mono.Android/Android.Runtime/JavaProxyThrowable.cs b/src/Mono.Android/Android.Runtime/JavaProxyThrowable.cs
index a8b48686157..630d23b9677 100644
--- a/src/Mono.Android/Android.Runtime/JavaProxyThrowable.cs
+++ b/src/Mono.Android/Android.Runtime/JavaProxyThrowable.cs
@@ -10,7 +10,6 @@
 namespace Android.Runtime {
 
 	sealed class JavaProxyThrowable : Java.Lang.Error {
-
 		public  readonly Exception InnerException;
 
 		JavaProxyThrowable (string message, Exception innerException)
diff --git a/src/Mono.Android/ApiCompatLinesToAdd.txt b/src/Mono.Android/ApiCompatLinesToAdd.txt
new file mode 100644
index 00000000000..b69aa045665
--- /dev/null
+++ b/src/Mono.Android/ApiCompatLinesToAdd.txt
@@ -0,0 +1,2 @@
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'Java.Interop.ExportAttribute' in the contract but not the implementation.
+Total Issues: 1
diff --git a/src/Mono.Android/Java.Interop/JavaConvert.cs b/src/Mono.Android/Java.Interop/JavaConvert.cs
index ba46b155c00..c1055fbffb3 100644
--- a/src/Mono.Android/Java.Interop/JavaConvert.cs
+++ b/src/Mono.Android/Java.Interop/JavaConvert.cs
@@ -12,44 +12,100 @@ namespace Java.Interop {
 
 	static class JavaConvert {
 		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+		// Mirrors JniObjectReference.DisposeSource; JniObjectReferenceOptions only exposes it through CopyAndDispose.
+		const JniObjectReferenceOptions DisposeSource = (JniObjectReferenceOptions)(1 << 1);
 
-		static Dictionary<Type, Func<IntPtr, JniHandleOwnership, object>> JniHandleConverters = new Dictionary<Type, Func<IntPtr, JniHandleOwnership, object>>() {
+		static Dictionary<Type, Func<IntPtr, JniHandleOwnership, object?>> JniHandleConverters = new Dictionary<Type, Func<IntPtr, JniHandleOwnership, object?>>() {
 			{ typeof (bool), (handle, transfer) => {
 				using (var value = new Java.Lang.Boolean (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.BooleanValue ();
 			} },
+			{ typeof (bool?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Boolean (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.BooleanValue ();
+			} },
 			{ typeof (byte), (handle, transfer) => {
 				using (var value = new Java.Lang.Byte (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return (byte) value.ByteValue ();
 			} },
+			{ typeof (byte?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Byte (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return (byte) value.ByteValue ();
+			} },
 			{ typeof (sbyte), (handle, transfer) => {
 				using (var value = new Java.Lang.Byte (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.ByteValue ();
 			} },
+			{ typeof (sbyte?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Byte (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.ByteValue ();
+			} },
 			{ typeof (char), (handle, transfer) => {
 				using (var value = new Java.Lang.Character (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.CharValue ();
 			} },
+			{ typeof (char?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Character (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.CharValue ();
+			} },
 			{ typeof (short), (handle, transfer) => {
 				using (var value = new Java.Lang.Short (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.ShortValue ();
 			} },
+			{ typeof (short?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Short (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.ShortValue ();
+			} },
 			{ typeof (int), (handle, transfer) => {
 				using (var value = new Java.Lang.Integer (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.IntValue ();
 			} },
+			{ typeof (int?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Integer (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.IntValue ();
+			} },
 			{ typeof (long), (handle, transfer) => {
 				using (var value = new Java.Lang.Long (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.LongValue ();
 			} },
+			{ typeof (long?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Long (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.LongValue ();
+			} },
 			{ typeof (float), (handle, transfer) => {
 				using (var value = new Java.Lang.Float (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.FloatValue ();
 			} },
+			{ typeof (float?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Float (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.FloatValue ();
+			} },
 			{ typeof (double), (handle, transfer) => {
 				using (var value = new Java.Lang.Double (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.DoubleValue ();
 			} },
+			{ typeof (double?), (handle, transfer) => {
+				if (handle == IntPtr.Zero)
+					return null;
+				using (var value = new Java.Lang.Double (handle, transfer | JniHandleOwnership.DoNotRegister))
+					return value.DoubleValue ();
+			} },
 			{ typeof (string), (handle, transfer) => {
 				using (var value = new Java.Lang.String (handle, transfer | JniHandleOwnership.DoNotRegister))
 					return value.ToString ();
@@ -58,21 +114,6 @@ static class JavaConvert {
 
 		static Func<IntPtr, JniHandleOwnership, object?>? GetJniHandleConverter (Type? target)
 		{
-			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-			// Might cause an issue in the future for NativeAOT
-			[UnconditionalSuppressMessage ("Trimming", "IL2055", Justification = "We don't think the IDictionary, IList, or ICollection code paths occur if JavaDictionary<,>, JavaList<>, and JavaCollection<> do not exist.")]
-			[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)]
-			static Type MakeGenericType (
-					[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)]
-					Type type,
-					params Type [] typeArguments
-			) =>
-				// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-				// IL3050 disabled in source: if someone uses NativeAOT, they will get the warning.
-				#pragma warning disable IL3050
-				type.MakeGenericType (typeArguments);
-				#pragma warning restore IL3050
-
 			if (target == null)
 				return null;
 
@@ -81,28 +122,31 @@ params Type [] typeArguments
 			if (target.IsArray)
 				return (h, t) => JNIEnv.GetArray (h, t, target.GetElementType ());
 
-			if (RuntimeFeature.TrimmableTypeMap) {
-				var factoryConverter = TryGetFactoryBasedConverter (target);
-				if (factoryConverter != null)
-					return factoryConverter;
+			if (target.IsGenericType && !target.IsGenericTypeDefinition) {
+				if (RuntimeFeature.TrimmableTypeMap) {
+					var factoryConverter = TryGetFactoryBasedConverter (target);
+					if (factoryConverter != null)
+						return factoryConverter;
+				} else if (RuntimeFeature.IsMonoRuntime || RuntimeFeature.IsCoreClrRuntime) {
+					if (target.GetGenericTypeDefinition() == typeof (IDictionary<,>)) {
+						Type t = typeof (JavaDictionary<,>).MakeGenericType (target.GetGenericArguments ());
+						return GetJniHandleConverterForType (t);
+					}
+					if (typeof (IDictionary).IsAssignableFrom (target))
+						return (h, t) => JavaDictionary.FromJniHandle (h, t);
+					if (target.GetGenericTypeDefinition() == typeof (IList<>)) {
+						Type t = typeof (JavaList<>).MakeGenericType (target.GetGenericArguments ());
+						return GetJniHandleConverterForType (t);
+					}
+					if (typeof (IList).IsAssignableFrom (target))
+						return (h, t) => JavaList.FromJniHandle (h, t);
+					if (target.GetGenericTypeDefinition() == typeof (ICollection<>)) {
+						Type t = typeof (JavaCollection<>).MakeGenericType (target.GetGenericArguments ());
+						return GetJniHandleConverterForType (t);
+					}
+				}
 			}
 
-			if (target.IsGenericType && target.GetGenericTypeDefinition() == typeof (IDictionary<,>)) {
-				Type t = MakeGenericType (typeof (JavaDictionary<,>), target.GetGenericArguments ());
-				return GetJniHandleConverterForType (t);
-			}
-			if (typeof (IDictionary).IsAssignableFrom (target))
-				return (h, t) => JavaDictionary.FromJniHandle (h, t);
-			if (target.IsGenericType && target.GetGenericTypeDefinition() == typeof (IList<>)) {
-				Type t = MakeGenericType (typeof (JavaList<>), target.GetGenericArguments ());
-				return GetJniHandleConverterForType (t);
-			}
-			if (typeof (IList).IsAssignableFrom (target))
-				return (h, t) => JavaList.FromJniHandle (h, t);
-			if (target.IsGenericType && target.GetGenericTypeDefinition() == typeof (ICollection<>)) {
-				Type t = MakeGenericType (typeof (JavaCollection<>), target.GetGenericArguments ());
-				return GetJniHandleConverterForType (t);
-			}
 			if (typeof (ICollection).IsAssignableFrom (target))
 				return (h, t) => JavaCollection.FromJniHandle (h, t);
 
@@ -115,9 +159,6 @@ params Type [] typeArguments
 		/// </summary>
 		static Func<IntPtr, JniHandleOwnership, object?>? TryGetFactoryBasedConverter (Type target)
 		{
-			if (!target.IsGenericType)
-				return null;
-
 			var genericDef = target.GetGenericTypeDefinition ();
 			var typeArgs = target.GetGenericArguments ();
 
@@ -141,18 +182,14 @@ params Type [] typeArguments
 			}
 
 			return null;
-		}
 
-		static JavaPeerContainerFactory? TryGetContainerFactory (Type elementType)
-		{
-			if (!typeof (IJavaPeerable).IsAssignableFrom (elementType))
-				return null;
+			static JavaPeerContainerFactory? TryGetContainerFactory (Type elementType)
+			{
+				if (!typeof (IJavaPeerable).IsAssignableFrom (elementType))
+					return null;
 
-			if (RuntimeFeature.TrimmableTypeMap) {
 				return TrimmableTypeMap.Instance?.GetContainerFactory (elementType);
 			}
-
-			return null;
 		}
 
 		static Func<IntPtr, JniHandleOwnership, object> GetJniHandleConverterForType ([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] Type t)
@@ -295,6 +332,31 @@ public static T? FromJniHandle<
 			return (T?) Convert.ChangeType (v, typeof (T), CultureInfo.InvariantCulture);
 		}
 
+		internal static object? FromObjectReference (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type? targetType = null)
+		{
+			JniHandleOwnership transfer;
+			if ((options & DisposeSource) != DisposeSource) {
+				transfer = JniHandleOwnership.DoNotTransfer;
+			} else {
+				transfer = reference.Type switch {
+					JniObjectReferenceType.Local => JniHandleOwnership.TransferLocalRef,
+					JniObjectReferenceType.Global => JniHandleOwnership.TransferGlobalRef,
+					_ => JniHandleOwnership.DoNotTransfer,
+				};
+			}
+
+			var value = FromJniHandle (reference.Handle, transfer, targetType);
+			if (transfer != JniHandleOwnership.DoNotTransfer) {
+				reference = default;
+			}
+
+			return value;
+		}
+
 		public static object? FromJniHandle (
 				IntPtr handle,
 				JniHandleOwnership transfer,
@@ -559,6 +621,32 @@ internal static IntPtr ToLocalJniHandle (object? value)
 			return converter (value);
 		}
 
+		internal static bool TryConvertKnownValueToLocalJniHandle (object? value, out IntPtr handle)
+		{
+			if (value == null) {
+				handle = IntPtr.Zero;
+				return true;
+			}
+			if (value is IJavaObject v) {
+				handle = JNIEnv.ToLocalJniHandle (v);
+				return true;
+			}
+
+			Type sourceType = value.GetType ();
+			Func<object, IntPtr>? converter;
+			if (LocalJniHandleConverters.TryGetValue (sourceType, out converter)) {
+				handle = converter (value);
+				return true;
+			}
+			if (sourceType.IsArray) {
+				handle = LocalJniHandleConverters [typeof (Array)] (value);
+				return true;
+			}
+
+			handle = IntPtr.Zero;
+			return false;
+		}
+
 		public static TReturn WithLocalJniHandle<TValue, TReturn>(TValue value, Func<IntPtr, TReturn> action)
 		{
 			IntPtr lref = ToLocalJniHandle (value);
diff --git a/src/Mono.Android/Java.Interop/JavaObjectExtensions.cs b/src/Mono.Android/Java.Interop/JavaObjectExtensions.cs
index a3e817facb9..d434dc9350a 100644
--- a/src/Mono.Android/Java.Interop/JavaObjectExtensions.cs
+++ b/src/Mono.Android/Java.Interop/JavaObjectExtensions.cs
@@ -108,42 +108,24 @@ internal static TResult? _JavaCast<
 		// typeof(Foo) -> FooInvoker
 		// typeof(Foo<>) -> FooInvoker`1
 		[return: DynamicallyAccessedMembers (Constructors)]
+		[RequiresDynamicCode ("Invoker lookup can construct generic invoker types.")]
+		[RequiresUnreferencedCode ("Invoker lookup uses reflection over preserved Java peer types.")]
 		internal static Type? GetInvokerType (Type type)
 		{
-			const string InvokerTypes = "*Invoker types are preserved by the MarkJavaObjects linker step.";
-
-			[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = InvokerTypes)]
-			[UnconditionalSuppressMessage ("Trimming", "IL2055", Justification = InvokerTypes)]
-			[UnconditionalSuppressMessage ("Trimming", "IL2073", Justification = InvokerTypes)]
-			[return: DynamicallyAccessedMembers (Constructors)]
-			static Type? AssemblyGetType (Assembly assembly, string typeName) =>
-				assembly.GetType (typeName);
-
-			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-			// IL3050 disabled in source: if someone uses NativeAOT, they will get the warning.
-			[UnconditionalSuppressMessage ("Trimming", "IL2055", Justification = InvokerTypes)]
-			[UnconditionalSuppressMessage ("Trimming", "IL2068", Justification = InvokerTypes)]
-			[return: DynamicallyAccessedMembers (Constructors)]
-			static Type MakeGenericType (Type type, params Type [] typeArguments) =>
-				#pragma warning disable IL3050
-				type.MakeGenericType (typeArguments);
-				#pragma warning restore IL3050
-
 			const string suffix = "Invoker";
 			
 			Type[] arguments = type.GetGenericArguments ();
 			if (arguments.Length == 0)
-				return AssemblyGetType (type.Assembly, type + suffix);
+				return type.Assembly.GetType (type + suffix);
 			Type definition = type.GetGenericTypeDefinition ();
 			int bt = definition.FullName!.IndexOf ("`", StringComparison.Ordinal);
 			if (bt == -1)
 				throw new NotSupportedException ("Generic type doesn't follow generic type naming convention! " + type.FullName);
-			Type? suffixDefinition = AssemblyGetType (
-					definition.Assembly,
+			Type? suffixDefinition = definition.Assembly.GetType (
 					definition.FullName.Substring (0, bt) + suffix + definition.FullName.Substring (bt));
 			if (suffixDefinition == null)
 				return null;
-			return MakeGenericType (suffixDefinition, arguments);
+			return suffixDefinition.MakeGenericType (arguments);
 		}
 	}
 }
diff --git a/src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs b/src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs
index 04995ea206c..d621b6554e3 100644
--- a/src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs
+++ b/src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs
@@ -2,9 +2,7 @@
 
 using System;
 using System.Collections;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
 using Android.Runtime;
 
 namespace Java.Interop
@@ -15,6 +13,8 @@ namespace Java.Interop
 	/// </summary>
 	public abstract class JavaPeerContainerFactory
 	{
+		private protected const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
 		/// <summary>
 		/// Creates a typed <c>JavaList&lt;T&gt;</c> from a JNI handle.
 		/// </summary>
@@ -36,36 +36,19 @@ public abstract class JavaPeerContainerFactory
 		/// Visitor callback invoked by the value factory's <see cref="CreateDictionary"/>.
 		/// Override in <see cref="JavaPeerContainerFactory{T}"/> to provide both type parameters.
 		/// </summary>
-		internal virtual IDictionary? CreateDictionaryWithValueFactory<TValue> (
+		internal virtual IDictionary? CreateDictionaryWithValueFactory<[DynamicallyAccessedMembers (Constructors)] TValue> (
 			JavaPeerContainerFactory<TValue> valueFactory, IntPtr handle, JniHandleOwnership transfer)
 			where TValue : class, IJavaPeerable
 			=> null;
-
-		/// <summary>
-		/// Creates a <see cref="JavaPeerContainerFactory{T}"/> singleton for the specified type.
-		/// </summary>
-		public static JavaPeerContainerFactory Create<
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-			T
-		> () where T : class, IJavaPeerable
-			=> JavaPeerContainerFactory<T>.Instance;
 	}
 
 	/// <summary>
 	/// Typed container factory. All creation uses direct <c>new</c> expressions — fully AOT-safe.
 	/// </summary>
 	/// <typeparam name="T">The Java peer element type.</typeparam>
-	public sealed class JavaPeerContainerFactory<
-	 	// TODO (https://github.com/dotnet/android/issues/10794): Remove this DAM annotation — it preserves too much reflection metadata on all types in the typemap.
-		[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-		T
-	> : JavaPeerContainerFactory
+	public sealed class JavaPeerContainerFactory<[DynamicallyAccessedMembers (Constructors)] T> : JavaPeerContainerFactory
 		where T : class, IJavaPeerable
 	{
-		internal static readonly JavaPeerContainerFactory<T> Instance = new ();
-
-		JavaPeerContainerFactory () { }
-
 		internal override IList CreateList (IntPtr handle, JniHandleOwnership transfer)
 			=> new Android.Runtime.JavaList<T> (handle, transfer);
 
@@ -75,10 +58,8 @@ internal override ICollection CreateCollection (IntPtr handle, JniHandleOwnershi
 		internal override IDictionary? CreateDictionary (JavaPeerContainerFactory keyFactory, IntPtr handle, JniHandleOwnership transfer)
 			=> keyFactory.CreateDictionaryWithValueFactory (this, handle, transfer);
 
-		#pragma warning disable IL2091 // DynamicallyAccessedMembers on base method type parameter cannot be repeated on override in C#
-		internal override IDictionary? CreateDictionaryWithValueFactory<TValue> (
+		internal override IDictionary? CreateDictionaryWithValueFactory<[DynamicallyAccessedMembers (Constructors)] TValue> (
 			JavaPeerContainerFactory<TValue> valueFactory, IntPtr handle, JniHandleOwnership transfer)
 			=> new Android.Runtime.JavaDictionary<T, TValue> (handle, transfer);
-		#pragma warning restore IL2091
 	}
 }
diff --git a/src/Mono.Android/Java.Interop/JavaPeerProxy.cs b/src/Mono.Android/Java.Interop/JavaPeerProxy.cs
index fec5337d347..949a7a03148 100644
--- a/src/Mono.Android/Java.Interop/JavaPeerProxy.cs
+++ b/src/Mono.Android/Java.Interop/JavaPeerProxy.cs
@@ -42,14 +42,13 @@ public sealed class JavaPeerAliasesAttribute : Attribute
 	[AttributeUsage (AttributeTargets.Class | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
 	public abstract class JavaPeerProxy : Attribute
 	{
-		protected JavaPeerProxy (
-			string jniName,
-			Type targetType,
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-			Type? invokerType)
+		private protected JavaPeerProxy (string jniName, Type targetType, Type? invokerType)
 		{
-			JniName = jniName ?? throw new ArgumentNullException (nameof (jniName));
-			TargetType = targetType ?? throw new ArgumentNullException (nameof (targetType));
+			ArgumentNullException.ThrowIfNull (jniName);
+			ArgumentNullException.ThrowIfNull (targetType);
+
+			JniName = jniName;
+			TargetType = targetType;
 			InvokerType = invokerType;
 		}
 
@@ -76,7 +75,6 @@ protected JavaPeerProxy (
 		/// Gets the invoker type for interfaces and abstract classes.
 		/// Returns null for concrete types that can be directly instantiated.
 		/// </summary>
-		[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
 		public Type? InvokerType { get; }
 
 		/// <summary>
@@ -141,20 +139,25 @@ static bool IsActivationPeer (IJavaPeerable peer)
 	/// </summary>
 	/// <typeparam name="T">The target .NET peer type this proxy represents.</typeparam>
 	[AttributeUsage (AttributeTargets.Class | AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
-	public abstract class JavaPeerProxy<
-		// TODO (https://github.com/dotnet/android/issues/10794): Remove this DAM annotation
-		[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-		T
-	> : JavaPeerProxy where T : class, IJavaPeerable
+	public abstract class JavaPeerProxy<[DynamicallyAccessedMembers (Constructors)] T>
+		: JavaPeerProxy where T : class, IJavaPeerable
 	{
-		protected JavaPeerProxy (
-			string jniName,
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-			Type? invokerType) : base (jniName, typeof (T), invokerType)
+		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
+		protected JavaPeerProxy (string jniName, Type? invokerType)
+			: base (jniName, typeof (T), invokerType)
 		{
 		}
 
-		public override JavaPeerContainerFactory GetContainerFactory ()
-			=> JavaPeerContainerFactory<T>.Instance;
+		public override JavaPeerContainerFactory? GetContainerFactory ()
+			=> new JavaPeerContainerFactory<T> ();
+	}
+
+	[AttributeUsage (AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+	public abstract class JavaArrayProxy : Attribute
+	{
+		public abstract Type[] GetArrayTypes ();
+
+		public abstract Array CreateManagedArray (int length);
 	}
 }
diff --git a/src/Mono.Android/Java.Interop/TypeManager.cs b/src/Mono.Android/Java.Interop/TypeManager.cs
index b00ea6056b0..f856818e09f 100644
--- a/src/Mono.Android/Java.Interop/TypeManager.cs
+++ b/src/Mono.Android/Java.Interop/TypeManager.cs
@@ -292,13 +292,15 @@ static Type monovm_typemap_java_to_managed (string java_type_name)
 			return null;
 		}
 
+		[RequiresDynamicCode ("Legacy type manager peer creation can construct generic invoker types.")]
+		[RequiresUnreferencedCode ("Legacy type manager peer creation uses reflection over preserved Java peer types.")]
 		internal static IJavaPeerable? CreateInstance (IntPtr handle, JniHandleOwnership transfer)
 		{
 			return CreateInstance (handle, transfer, null);
 		}
 
-		[UnconditionalSuppressMessage ("Trimming", "IL2067", Justification = "TypeManager.CreateProxy() does not statically know the value of the 'type' local variable.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2072", Justification = "TypeManager.CreateProxy() does not statically know the value of the 'type' local variable.")]
+		[RequiresDynamicCode ("Legacy type manager peer creation can construct generic invoker types.")]
+		[RequiresUnreferencedCode ("Legacy type manager peer creation uses reflection over preserved Java peer types.")]
 		internal static IJavaPeerable? CreateInstance (IntPtr handle, JniHandleOwnership transfer, Type? targetType)
 		{
 			Type? type = null;
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/AggregateTypeMap.cs b/src/Mono.Android/Microsoft.Android.Runtime/AggregateTypeMap.cs
index 0374570f12a..1d5f66d86a6 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/AggregateTypeMap.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/AggregateTypeMap.cs
@@ -42,15 +42,15 @@ public bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? pr
 		return false;
 	}
 
-	public bool TryGetArrayType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? arrayType)
+	public bool TryGetArrayProxyType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? proxyType)
 	{
 		foreach (var universe in _universes) {
-			if (universe.TryGetArrayType (jniName, rankIndex, out arrayType)) {
+			if (universe.TryGetArrayProxyType (jniName, rankIndex, out proxyType)) {
 				return true;
 			}
 		}
 
-		arrayType = null;
+		proxyType = null;
 		return false;
 	}
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs
deleted file mode 100644
index 1ead336ccb6..00000000000
--- a/src/Mono.Android/Microsoft.Android.Runtime/AndroidReflectionJniValueManager.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-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/CoreClrJavaMarshalValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/CoreClrJavaMarshalValueManager.cs
new file mode 100644
index 00000000000..5a2ba0bc385
--- /dev/null
+++ b/src/Mono.Android/Microsoft.Android.Runtime/CoreClrJavaMarshalValueManager.cs
@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Android.Runtime;
+using Java.Interop;
+
+namespace Microsoft.Android.Runtime;
+
+[RequiresDynamicCode ("This value manager is reflection-backed and is not compatible with Native AOT.")]
+[RequiresUnreferencedCode ("This value manager is reflection-backed and is not trimming-compatible.")]
+sealed class CoreClrJavaMarshalValueManager : JniRuntime.ReflectionJniValueManager
+{
+	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+	const BindingFlags ActivationConstructorBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+
+	static readonly Type[] JIConstructorSignature  = [typeof (JniObjectReference).MakeByRefType (), typeof (JniObjectReferenceOptions)];
+	static readonly Type[] XAConstructorSignature  = [typeof (IntPtr), typeof (JniHandleOwnership)];
+
+	readonly JavaMarshalRegisteredPeers registeredPeers = new ();
+
+	protected override void Dispose (bool disposing)
+	{
+		registeredPeers.Dispose ();
+		base.Dispose (disposing);
+	}
+
+	public override void WaitForGCBridgeProcessing ()
+	{
+		// Intentionally empty. The Mono runtime's own implementation acknowledges this
+		// pattern is fundamentally flawed (see FIXME in sgen-bridge.c): a thread that
+		// passes the check can still race with bridge processing that starts immediately
+		// after. The wait cannot prevent the race, only reduce its window. On CoreCLR,
+		// JNI wrapper threads hold their own handle copies via JniObjectReference, so
+		// they are not affected by the bridge swapping control_block handles.
+	}
+
+	public override void CollectPeers ()
+	{
+		registeredPeers.CollectPeers ();
+	}
+
+	public override void AddPeer (IJavaPeerable value)
+	{
+		registeredPeers.AddPeer (value);
+	}
+
+	public override IJavaPeerable? PeekPeer (JniObjectReference reference)
+	{
+		return registeredPeers.PeekPeer (reference);
+	}
+
+	public override void RemovePeer (IJavaPeerable value)
+	{
+		registeredPeers.RemovePeer (value);
+	}
+
+	public override void FinalizePeer (IJavaPeerable value)
+	{
+		registeredPeers.FinalizePeer (value);
+	}
+
+	public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
+	{
+		return registeredPeers.GetSurfacedPeers ();
+	}
+
+	public override IJavaPeerable? CreatePeer (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions transfer,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type? targetType)
+	{
+		EnsureNotDisposed ();
+
+		if (!reference.IsValid) {
+			return null;
+		}
+
+		targetType = JavaMarshalValueManagerHelper.ResolvePeerType (targetType) ?? typeof (global::Java.Interop.JavaObject);
+
+		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));
+		}
+
+		if (JavaMarshalValueManagerHelper.IsIncompatibleCast (targetSig.SimpleReference, ref reference, targetType)) {
+			return null;
+		}
+
+		var refClass = JniEnvironment.Types.GetObjectClass (reference);
+		try {
+			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;
+		} finally {
+			JniObjectReference.Dispose (ref refClass);
+		}
+	}
+
+	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);
+
+		Type? GetTypeAssignableTo (JniTypeSignature sig, Type targetType)
+		{
+			foreach (var t in Runtime.TypeManager.GetTypes (sig)) {
+				if (targetType.IsAssignableFrom (t)) {
+					return t;
+				}
+			}
+			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;
+	}
+
+	bool TryConstructPeer (
+			IJavaPeerable self,
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			[DynamicallyAccessedMembers (Constructors)]
+			Type type)
+	{
+		var c = type.GetConstructor (ActivationConstructorBindingFlags, null, XAConstructorSignature, null);
+		if (c != null) {
+			var args = new object[] {
+				reference.Handle,
+				JniHandleOwnership.DoNotTransfer,
+			};
+			c.Invoke (self, args);
+			JniObjectReference.Dispose (ref reference, options);
+			return true;
+		}
+
+		c = type.GetConstructor (ActivationConstructorBindingFlags, null, JIConstructorSignature, null);
+		if (c != null) {
+			var args = new object[] {
+				reference,
+				options,
+			};
+			c.Invoke (self, args);
+			reference = (JniObjectReference) args [0];
+			return true;
+		}
+
+		return false;
+	}
+
+	protected override bool TryUnboxPeerObject (IJavaPeerable value, [NotNullWhen (true)] out object? result)
+	{
+		var proxy = value as JavaProxyThrowable;
+		if (proxy != null) {
+			result = proxy.InnerException;
+			return true;
+		}
+		return base.TryUnboxPeerObject (value, out result);
+	}
+}
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/ITypeMap.cs b/src/Mono.Android/Microsoft.Android.Runtime/ITypeMap.cs
index 8aa230d273f..7e3ae4946dd 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/ITypeMap.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/ITypeMap.cs
@@ -26,7 +26,7 @@ interface ITypeMap
 	bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? proxyType);
 
 	/// <summary>
-	/// Resolves a JNI leaf name and 0-based array rank index to a managed array type.
+	/// Resolves a JNI leaf name and 0-based array rank index to a generated array proxy type.
 	/// </summary>
-	bool TryGetArrayType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? arrayType);
+	bool TryGetArrayProxyType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? proxyType);
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalRegisteredPeers.cs
similarity index 60%
rename from src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs
rename to src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalRegisteredPeers.cs
index cfc32a7900a..229dd090a9f 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalRegisteredPeers.cs
@@ -1,97 +1,82 @@
-// Originally from: https://github.com/dotnet/java-interop/blob/9b1d8781e8e322849d05efac32119c913b21c192/src/Java.Runtime.Environment/Java.Interop/ManagedValueManager.cs
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Java;
-using System.Threading;
 using Android.Runtime;
 using Java.Interop;
 
 namespace Microsoft.Android.Runtime;
 
-class JavaMarshalValueManager : AndroidReflectionJniValueManager
+// Originally from: https://github.com/dotnet/java-interop/blob/9b1d8781e8e322849d05efac32119c913b21c192/src/Java.Runtime.Environment/Java.Interop/ManagedValueManager.cs
+sealed class JavaMarshalRegisteredPeers : IDisposable
 {
-	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
-
 	readonly Dictionary<int, List<ReferenceTrackingHandle>> RegisteredInstances = new ();
 	readonly ConcurrentQueue<IntPtr> CollectedContexts = new ();
 
 	bool disposed;
 
-	public unsafe JavaMarshalValueManager ()
+	public JavaMarshalRegisteredPeers ()
 	{
-		var javaMarshalValueManagerHandle = new GCHandle<JavaMarshalValueManager> (this);
-		var mark_cross_references_ftn = RuntimeNativeMethods.clr_initialize_gc_bridge (
-			GCHandle<JavaMarshalValueManager>.ToIntPtr (javaMarshalValueManagerHandle), &BridgeProcessingStarted, &BridgeProcessingFinished);
-		JavaMarshal.Initialize (mark_cross_references_ftn);
+		unsafe {
+			var registeredPeersHandle = new GCHandle<JavaMarshalRegisteredPeers> (this);
+			var mark_cross_references_ftn = RuntimeNativeMethods.clr_initialize_gc_bridge (
+				GCHandle<JavaMarshalRegisteredPeers>.ToIntPtr (registeredPeersHandle), &BridgeProcessingStarted, &BridgeProcessingFinished);
+			JavaMarshal.Initialize (mark_cross_references_ftn);
+		}
 	}
 
-	protected override void Dispose (bool disposing)
+	public void Dispose ()
 	{
 		disposed = true;
-		base.Dispose (disposing);
 	}
 
 	void ThrowIfDisposed ()
 	{
 		if (disposed)
-			throw new ObjectDisposedException (nameof (JavaMarshalValueManager));
+			throw new ObjectDisposedException (nameof (JavaMarshalRegisteredPeers));
 	}
 
-	public override void WaitForGCBridgeProcessing ()
-	{
-		// Intentionally empty. The Mono runtime's own implementation acknowledges this
-		// pattern is fundamentally flawed (see FIXME in sgen-bridge.c): a thread that
-		// passes the check can still race with bridge processing that starts immediately
-		// after. The wait cannot prevent the race, only reduce its window. On CoreCLR,
-		// JNI wrapper threads hold their own handle copies via JniObjectReference, so
-		// they are not affected by the bridge swapping control_block handles.
-	}
-
-	public unsafe override void CollectPeers ()
+	public void CollectPeers ()
 	{
 		ThrowIfDisposed ();
 
-		while (CollectedContexts.TryDequeue (out IntPtr contextPtr)) {
-			Debug.Assert (contextPtr != IntPtr.Zero, "CollectedContexts should not contain null pointers.");
-			HandleContext* context = (HandleContext*)contextPtr;
-			
-			lock (RegisteredInstances) {
-				Remove (context);
-			}
+		unsafe {
+			while (CollectedContexts.TryDequeue (out IntPtr contextPtr)) {
+				Debug.Assert (contextPtr != IntPtr.Zero, "CollectedContexts should not contain null pointers.");
+				HandleContext* context = (HandleContext*)contextPtr;
 
-			HandleContext.Free (ref context);
-		}
+				lock (RegisteredInstances) {
+					Remove (context);
+				}
 
-		void Remove (HandleContext* context)
-		{
-			int key = context->PeerIdentityHashCode;
-			if (!RegisteredInstances.TryGetValue (key, out List<ReferenceTrackingHandle>? peers))
-				return;
+				HandleContext.Free (ref context);
+			}
 
-			for (int i = peers.Count - 1; i >= 0; i--) {
-				var peer = peers [i];
-				if (peer.BelongsToContext (context)) {
-					peers.RemoveAt (i);
+			void Remove (HandleContext* context)
+			{
+				int key = context->PeerIdentityHashCode;
+				if (!RegisteredInstances.TryGetValue (key, out List<ReferenceTrackingHandle>? peers))
+					return;
+
+				for (int i = peers.Count - 1; i >= 0; i--) {
+					var peer = peers [i];
+					if (peer.BelongsToContext (context)) {
+						peers.RemoveAt (i);
+					}
 				}
-			}
 
-			if (peers.Count == 0) {
-				RegisteredInstances.Remove (key);
+				if (peers.Count == 0) {
+					RegisteredInstances.Remove (key);
+				}
 			}
 		}
 	}
 
-	public override void AddPeer (IJavaPeerable value)
+	public void AddPeer (IJavaPeerable value)
 	{
 		ThrowIfDisposed ();
 
@@ -137,7 +122,7 @@ public override void AddPeer (IJavaPeerable value)
 
 	void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepValue)
 	{
-		Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
+		JniEnvironment.Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
 				"Warning: Not registering PeerReference={0} IdentityHashCode=0x{1} Instance={2} Instance.Type={3} Java.Type={4}; " +
 				"keeping previously registered PeerReference={5} Instance={6} Instance.Type={7} Java.Type={8}.",
 				ignoreValue.PeerReference.ToString (),
@@ -151,14 +136,14 @@ void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepVal
 				JniEnvironment.Types.GetJniTypeNameFromInstance (keepValue.PeerReference));
 	}
 
-	public override IJavaPeerable? PeekPeer (JniObjectReference reference)
+	public IJavaPeerable? PeekPeer (JniObjectReference reference)
 	{
 		ThrowIfDisposed ();
 
 		if (!reference.IsValid)
 			return null;
 
-		int key = GetJniIdentityHashCode (reference);
+		int key = JniEnvironment.References.GetIdentityHashCode (reference);
 
 		lock (RegisteredInstances) {
 			if (!RegisteredInstances.TryGetValue (key, out List<ReferenceTrackingHandle>? peers))
@@ -178,7 +163,7 @@ void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepVal
 		return null;
 	}
 
-	public override void RemovePeer (IJavaPeerable value)
+	public void RemovePeer (IJavaPeerable value)
 	{
 		ThrowIfDisposed ();
 
@@ -195,7 +180,7 @@ public override void RemovePeer (IJavaPeerable value)
 
 			for (int i = peers.Count - 1; i >= 0; i--) {
 				ReferenceTrackingHandle peer = peers [i];
-				IJavaPeerable target = peer.Target;
+				IJavaPeerable? target = peer.Target;
 				if (ReferenceEquals (value, target)) {
 					peers.RemoveAt (i);
 					peer.Dispose ();
@@ -207,10 +192,10 @@ public override void RemovePeer (IJavaPeerable value)
 		}
 	}
 
-	public override void FinalizePeer (IJavaPeerable value)
+	public void FinalizePeer (IJavaPeerable value)
 	{
 		var h = value.PeerReference;
-		var o = Runtime.ObjectReferenceManager;
+		var o = JniEnvironment.Runtime.ObjectReferenceManager;
 		// MUST NOT use SafeHandle.ReferenceType: local refs are tied to a JniEnvironment
 		// and the JniEnvironment's corresponding thread; it's a thread-local value.
 		// Accessing SafeHandle.ReferenceType won't kill anything (so far...), but
@@ -242,15 +227,7 @@ public override void FinalizePeer (IJavaPeerable value)
 		value.Finalized ();
 	}
 
-	public override void ActivatePeer (JniObjectReference reference, [DynamicallyAccessedMembers (Constructors)] Type type, ConstructorInfo cinfo, object?[]? argumentValues)
-	{
-		if (RuntimeFeature.TrimmableTypeMap)
-			throw new PlatformNotSupportedException ("Activating Java peers is not supported when TrimmableTypeMap is enabled.");
-
-		base.ActivatePeer (reference, type, cinfo, argumentValues);
-	}
-
-	public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
+	public List<JniSurfacedPeerInfo> GetSurfacedPeers ()
 	{
 		ThrowIfDisposed ();
 
@@ -272,7 +249,7 @@ public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
 
 	unsafe struct ReferenceTrackingHandle : IDisposable
 	{
-		WeakReference<IJavaPeerable> _weakReference;
+		WeakReference<IJavaPeerable?> _weakReference;
 		HandleContext* _context;
 
 		public bool BelongsToContext (HandleContext* context)
@@ -281,7 +258,7 @@ public bool BelongsToContext (HandleContext* context)
 		public ReferenceTrackingHandle (IJavaPeerable peer)
 		{
 			_context = HandleContext.Alloc (peer);
-			_weakReference = new WeakReference<IJavaPeerable> (peer);
+			_weakReference = new (peer);
 		}
 
 		public IJavaPeerable? Target
@@ -423,13 +400,13 @@ static unsafe void BridgeProcessingStarted (MarkCrossReferencesArgs* mcr)
 	}
 
 	[UnmanagedCallersOnly]
-	static unsafe void BridgeProcessingFinished (IntPtr javaMarshalValueManagerHandle, MarkCrossReferencesArgs* mcr)
+	static unsafe void BridgeProcessingFinished (IntPtr registeredPeersHandle, MarkCrossReferencesArgs* mcr)
 	{
 		if (mcr == null) {
 			throw new ArgumentNullException (nameof (mcr), "MarkCrossReferencesArgs should never be null.");
 		}
 
-		JavaMarshalValueManager instance = GCHandle<JavaMarshalValueManager>.FromIntPtr (javaMarshalValueManagerHandle).Target;
+		JavaMarshalRegisteredPeers instance = GCHandle<JavaMarshalRegisteredPeers>.FromIntPtr (registeredPeersHandle).Target;
 
 		ReadOnlySpan<GCHandle> handlesToFree = instance.ProcessCollectedContexts (mcr);
 
@@ -484,146 +461,4 @@ void ProcessContext (HandleContext* context)
 		return CollectionsMarshal.AsSpan (handlesToFree);
 	}
 
-	const BindingFlags ActivationConstructorBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-
-	static  readonly    Type[]  XAConstructorSignature  = new Type [] { typeof (IntPtr), typeof (JniHandleOwnership) };
-
-	public override IJavaPeerable? CreatePeer (
-			ref JniObjectReference reference,
-			JniObjectReferenceOptions transfer,
-			[DynamicallyAccessedMembers (Constructors)]
-			Type? targetType)
-	{
-		ThrowIfDisposed ();
-
-		if (!reference.IsValid) {
-			return null;
-		}
-
-		if (RuntimeFeature.TrimmableTypeMap) {
-			try {
-				// Mirror legacy GetPeerType: callers commonly request universal
-				// interfaces / boxes (IJavaPeerable, object, Exception) — map these
-				// to a concrete peer type so the proxy lookup can succeed.
-				var resolvedTargetType = ResolvePeerType (targetType);
-
-				var typeMap = TrimmableTypeMap.Instance;
-				var peer = typeMap.CreateInstance (reference.Handle, resolvedTargetType);
-				if (peer is not null) {
-					return peer;
-				}
-
-				// Disambiguate the failure — match the contract of the base
-				// JniRuntime.JniValueManager.CreatePeer so JavaCast / JavaAs
-				// surface the right exception (or null) to callers:
-				//
-				//  (a) target type has no Java mapping at all → ArgumentException
-				//  (b) Java instance is not assignable to the target's Java class
-				//      → return null (JavaAs returns null; JavaCast wraps to
-				//      InvalidCastException via its `??` clause)
-				//  (c) classes are compatible but no proxy / activation failed
-				//      → NotSupportedException (genuine generator gap)
-				if (resolvedTargetType is not null &&
-						IsIncompatibleCast (typeMap, ref reference, resolvedTargetType)) {
-					return null;
-				}
-
-				var targetName = resolvedTargetType?.AssemblyQualifiedName ?? "<null>";
-				var javaType = JniEnvironment.Types.GetJniTypeNameFromInstance (reference);
-
-				throw new NotSupportedException (
-					$"No generated {nameof (JavaPeerProxy)} was found for Java type '{javaType}' " +
-					$"with targetType '{targetName}' while {nameof (RuntimeFeature.TrimmableTypeMap)} is enabled. " +
-					$"This indicates a missing trimmable typemap proxy or association and should be fixed in the generator.");
-			} finally {
-				JniObjectReference.Dispose (ref reference, transfer);
-			}
-		}
-
-		return base.CreatePeer (ref reference, transfer, targetType);
-	}
-
-	[return: DynamicallyAccessedMembers (Constructors)]
-	static Type? ResolvePeerType ([DynamicallyAccessedMembers (Constructors)] Type? type)
-	{
-		if (type is null) {
-			return null;
-		}
-		if (type == typeof (object) || type == typeof (IJavaPeerable)) {
-			return typeof (global::Java.Interop.JavaObject);
-		}
-		if (type == typeof (Exception)) {
-			return typeof (JavaException);
-		}
-		return type;
-	}
-
-	/// <summary>
-	/// Returns true when <paramref name="targetType"/>'s Java class is not assignable from
-	/// <paramref name="reference"/>. Throws when <paramref name="targetType"/> has no usable mapping.
-	/// </summary>
-	static bool IsIncompatibleCast (
-			TrimmableTypeMap typeMap,
-			ref JniObjectReference reference,
-			Type targetType)
-	{
-		if (!typeMap.TryGetJniNameForManagedType (targetType, out var targetJniName)) {
-			throw new ArgumentException (
-				$"Could not determine Java type corresponding to '{targetType.AssemblyQualifiedName}'.",
-				nameof (targetType));
-		}
-
-		var instanceClass = JniEnvironment.Types.GetObjectClass (reference);
-		JniObjectReference targetClass = default;
-		try {
-			try {
-				targetClass = JniEnvironment.Types.FindClass (targetJniName);
-			} catch (Java.Lang.ClassNotFoundException e) {
-				throw new ArgumentException (
-					$"Could not find Java class '{targetJniName}'.",
-					nameof (targetType), e);
-			}
-
-			if (!JniEnvironment.Types.IsAssignableFrom (instanceClass, targetClass)) {
-				// Bad cast: callers translate null to the expected result.
-				return true;
-			}
-		} finally {
-			JniObjectReference.Dispose (ref instanceClass);
-			JniObjectReference.Dispose (ref targetClass);
-		}
-
-		// Compatible classes mean a proxy/activation gap.
-		return false;
-	}
-
-	protected override bool TryConstructPeer (
-			IJavaPeerable self,
-			ref JniObjectReference reference,
-			JniObjectReferenceOptions options,
-			[DynamicallyAccessedMembers (Constructors)]
-			Type type)
-	{
-		var c = type.GetConstructor (ActivationConstructorBindingFlags, null, XAConstructorSignature, null);
-		if (c != null) {
-			var args = new object[] {
-				reference.Handle,
-				JniHandleOwnership.DoNotTransfer,
-			};
-			c.Invoke (self, args);
-			JniObjectReference.Dispose (ref reference, options);
-			return true;
-		}
-		return base.TryConstructPeer (self, ref reference, options, type);
-	}
-
-	protected override bool TryUnboxPeerObject (IJavaPeerable value, [NotNullWhen (true)] out object? result)
-	{
-		var proxy = value as JavaProxyThrowable;
-		if (proxy != null) {
-			result = proxy.InnerException;
-			return true;
-		}
-		return base.TryUnboxPeerObject (value, out result);
-	}
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManagerHelper.cs b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManagerHelper.cs
new file mode 100644
index 00000000000..26f4d3bf627
--- /dev/null
+++ b/src/Mono.Android/Microsoft.Android.Runtime/JavaMarshalValueManagerHelper.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Android.Runtime;
+using Java.Interop;
+
+namespace Microsoft.Android.Runtime;
+
+static class JavaMarshalValueManagerHelper
+{
+	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
+	[return: DynamicallyAccessedMembers (Constructors)]
+	public static Type? ResolvePeerType ([DynamicallyAccessedMembers (Constructors)] Type? type)
+	{
+		if (type is null) {
+			return null;
+		}
+		if (type == typeof (object) || type == typeof (IJavaPeerable)) {
+			return typeof (global::Java.Interop.JavaObject);
+		}
+		if (type == typeof (Exception)) {
+			return typeof (JavaException);
+		}
+		return type;
+	}
+
+	/// <summary>
+	/// Returns true when <paramref name="targetType"/>'s Java class is not assignable from
+	/// <paramref name="reference"/>. Throws when <paramref name="targetType"/> has no usable mapping.
+	/// </summary>
+	public static bool IsIncompatibleCast (
+		string targetJniName,
+		ref JniObjectReference reference,
+		Type targetType)
+	{
+		var instanceClass = JniEnvironment.Types.GetObjectClass (reference);
+		JniObjectReference targetClass = default;
+		try {
+			targetClass = JniEnvironment.Types.FindClass (targetJniName);
+
+			if (!JniEnvironment.Types.IsAssignableFrom (instanceClass, targetClass)) {
+				// Match the legacy cast diagnostic when assembly logging is enabled.
+				if (Logger.LogAssembly) {
+					var targetSig = JniRuntime.CurrentRuntime.TypeManager.GetTypeSignature (targetType);
+					var message = $"Handle 0x{reference.Handle:x} is of type '{JNIEnv.GetClassNameFromInstance (reference.Handle)}' which is not assignable to '{targetSig.SimpleReference}'";
+					Logger.Log (LogLevel.Debug, "monodroid-assembly", message);
+				}
+
+				if (RuntimeFeature.IsAssignableFromCheck) {
+					return true;
+				}
+			}
+		} catch (Java.Lang.ClassNotFoundException e) {
+			throw new ArgumentException (
+				$"Could not find Java class '{targetJniName}'.",
+				nameof (targetType), e);
+		} finally {
+			JniObjectReference.Dispose (ref instanceClass);
+			JniObjectReference.Dispose (ref targetClass);
+		}
+
+		// Compatible classes mean a proxy/activation gap.
+		return false;
+	}
+}
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
index aaee4516788..458b76ba371 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/ManagedTypeManager.cs
@@ -7,69 +7,37 @@
 
 namespace Microsoft.Android.Runtime;
 
-[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
-class ManagedTypeManager : JniRuntime.ReflectionJniTypeManager {
+[RequiresUnreferencedCode ("The 'Invoker' types are preserved by the MarkJavaObjects trimmer step.")]
+[RequiresDynamicCode ("The 'Invoker' types are preserved by the MarkJavaObjects trimmer step.")]
+class ManagedTypeManager : JniRuntime.JniTypeManager {
 
 	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 ()
 	{
 	}
 
-	[return: DynamicallyAccessedMembers (Constructors)]
-	protected override Type? GetInvokerTypeCore (
-			[DynamicallyAccessedMembers (Constructors)]
-			Type type)
+	protected override Type? GetInvokerTypeCore (Type type)
 	{
 		const string suffix = "Invoker";
 
-		// https://github.com/xamarin/xamarin-android/blob/5472eec991cc075e4b0c09cd98a2331fb93aa0f3/src/Microsoft.Android.Sdk.ILLink/MarkJavaObjects.cs#L176-L186
-		const string assemblyGetTypeMessage = "'Invoker' types are preserved by the MarkJavaObjects trimmer step.";
-		const string makeGenericTypeMessage = "Generic 'Invoker' types are preserved by the MarkJavaObjects trimmer step.";
-
-		[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = assemblyGetTypeMessage)]
-		[UnconditionalSuppressMessage ("Trimming", "IL2073", Justification = assemblyGetTypeMessage)]
-		[return: DynamicallyAccessedMembers (Constructors)]
-		static Type? AssemblyGetType (Assembly assembly, string typeName) =>
-			assembly.GetType (typeName);
-
-		[UnconditionalSuppressMessage ("Trimming", "IL2055", Justification = makeGenericTypeMessage)]
-		[return: DynamicallyAccessedMembers (Constructors)]
-		static Type MakeGenericType (
-				[DynamicallyAccessedMembers (Constructors)]
-				Type type,
-				Type [] arguments) =>
-			// FIXME: https://github.com/dotnet/java-interop/issues/1192
-			#pragma warning disable IL3050
-			type.MakeGenericType (arguments);
-			#pragma warning restore IL3050
-
 		Type[] arguments = type.GetGenericArguments ();
 		if (arguments.Length == 0)
-			return AssemblyGetType (type.Assembly, type + suffix) ?? base.GetInvokerTypeCore (type);
+			return type.Assembly.GetType (type + suffix) ?? base.GetInvokerTypeCore (type);
 		Type definition = type.GetGenericTypeDefinition ();
 		int bt = definition.FullName!.IndexOf ("`", StringComparison.Ordinal);
 		if (bt == -1)
 			throw new NotSupportedException ("Generic type doesn't follow generic type naming convention! " + type.FullName);
-		Type? suffixDefinition = AssemblyGetType (definition.Assembly,
+		Type? suffixDefinition = definition.Assembly.GetType (
 				definition.FullName.Substring (0, bt) + suffix + definition.FullName.Substring (bt));
 		if (suffixDefinition == null)
 			return base.GetInvokerTypeCore (type);
-		return MakeGenericType (suffixDefinition, arguments);
+		return suffixDefinition.MakeGenericType (arguments);
 	}
 
-	// NOTE: suppressions below also in `src/Mono.Android/Android.Runtime/AndroidRuntime.cs`
-	[UnconditionalSuppressMessage ("Trimming", "IL2057", Justification = "Type.GetType() can never statically know the string value parsed from parameter 'methods'.")]
-	[UnconditionalSuppressMessage ("Trimming", "IL2067", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-	[UnconditionalSuppressMessage ("Trimming", "IL2072", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-	public override void RegisterNativeMembers (
-			JniType nativeClass,
-			[DynamicallyAccessedMembers (MethodsAndPrivateNested)]
-			Type type,
-			ReadOnlySpan<char> methods)
+	public override void RegisterNativeMembers (JniType nativeClass, Type type, ReadOnlySpan<char> methods)
 	{
 		if (methods.IsEmpty) {
 			base.RegisterNativeMembers (nativeClass, type, methods);
@@ -143,18 +111,6 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2068", Justification = "Temporary suppression until ManagedTypeMapping type entries carry DAM annotations.")]
-	[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/PrimitiveArrayInfo.cs b/src/Mono.Android/Microsoft.Android.Runtime/PrimitiveArrayInfo.cs
new file mode 100644
index 00000000000..098c769b77a
--- /dev/null
+++ b/src/Mono.Android/Microsoft.Android.Runtime/PrimitiveArrayInfo.cs
@@ -0,0 +1,224 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Java.Interop;
+
+namespace Microsoft.Android.Runtime;
+
+static class PrimitiveArrayInfo
+{
+	delegate TArray PrimitiveArrayFactory<TArray> (ref JniObjectReference reference, JniObjectReferenceOptions options);
+
+	abstract class Handler
+	{
+		public abstract bool TryGetArrayTypes (Type elementType, [NotNullWhen (true)] out Type[]? arrayTypes);
+
+		public abstract bool TryGetTypeSignature (Type type, out JniTypeSignature signature);
+
+		public abstract bool TryCreateWrapper (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			Type targetType,
+			[NotNullWhen (true)] out object? value);
+
+		public abstract bool TryCreateObjectReference (object value, out JniObjectReference reference);
+	}
+
+	sealed class Handler<T, TArray> : Handler
+		where T : struct
+		where TArray : JavaArray<T>
+	{
+		readonly string jniSimpleReference;
+		readonly PrimitiveArrayFactory<TArray> createFromReference;
+		readonly Func<IList<T>, TArray> createCopy;
+
+		public Handler (string jniSimpleReference, PrimitiveArrayFactory<TArray> createFromReference, Func<IList<T>, TArray> createCopy)
+		{
+			this.jniSimpleReference = jniSimpleReference;
+			this.createFromReference = createFromReference;
+			this.createCopy = createCopy;
+		}
+
+		public override bool TryGetArrayTypes (Type elementType, [NotNullWhen (true)] out Type[]? arrayTypes)
+		{
+			if (typeof (T) != elementType) {
+				arrayTypes = null;
+				return false;
+			}
+
+			arrayTypes = [typeof (T[]), typeof (JavaArray<T>), typeof (JavaPrimitiveArray<T>), typeof (TArray)];
+			return true;
+		}
+
+		public override bool TryGetTypeSignature (Type type, out JniTypeSignature signature)
+		{
+			if (IsArrayType (type)) {
+				signature = new JniTypeSignature (jniSimpleReference, arrayRank: 1, keyword: true);
+				return true;
+			}
+
+			signature = default;
+			return false;
+		}
+
+		public override bool TryCreateWrapper (
+			ref JniObjectReference reference,
+			JniObjectReferenceOptions options,
+			Type targetType,
+			[NotNullWhen (true)] out object? value)
+		{
+			if (!IsTargetType (targetType)) {
+				value = null;
+				return false;
+			}
+
+			var array = createFromReference (ref reference, options);
+			if (targetType == typeof (T[]) || IsCompatibleListType (targetType)) {
+				try {
+					value = array.ToArray ();
+					return true;
+				} finally {
+					array.Dispose ();
+				}
+			}
+
+			value = array;
+			return true;
+		}
+
+		public override bool TryCreateObjectReference (object value, out JniObjectReference reference)
+		{
+			if (value is TArray array) {
+				reference = array.PeerReference.IsValid
+					? array.PeerReference.NewLocalRef ()
+					: new JniObjectReference ();
+				return true;
+			}
+
+			if (value is not IList<T> list) {
+				reference = new JniObjectReference ();
+				return false;
+			}
+
+			var marshaledArray = createCopy (list);
+			try {
+				reference = marshaledArray.PeerReference.IsValid
+					? marshaledArray.PeerReference.NewLocalRef ()
+					: new JniObjectReference ();
+				return true;
+			} finally {
+				marshaledArray.Dispose ();
+			}
+		}
+
+		bool IsTargetType (Type targetType)
+		{
+			return IsArrayType (targetType) ||
+				IsCompatibleListType (targetType);
+		}
+
+		static bool IsArrayType (Type targetType)
+		{
+			return targetType == typeof (JavaArray<T>) ||
+				targetType == typeof (JavaPrimitiveArray<T>) ||
+				targetType == typeof (TArray) ||
+				targetType == typeof (T[]);
+		}
+
+		static bool IsCompatibleListType (Type targetType)
+		{
+			return targetType.IsGenericType &&
+				targetType.GetGenericTypeDefinition () == typeof (IList<>) &&
+				targetType.IsAssignableFrom (typeof (IList<T>));
+		}
+	}
+
+	static readonly Handler[] Handlers = [
+		new Handler<bool, JavaBooleanArray> (
+			"Z",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaBooleanArray (ref h, o),
+			list => new JavaBooleanArray (list)),
+		new Handler<sbyte, JavaSByteArray> (
+			"B",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSByteArray (ref h, o),
+			list => new JavaSByteArray (list)),
+		new Handler<char, JavaCharArray> (
+			"C",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaCharArray (ref h, o),
+			list => new JavaCharArray (list)),
+		new Handler<short, JavaInt16Array> (
+			"S",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt16Array (ref h, o),
+			list => new JavaInt16Array (list)),
+		new Handler<int, JavaInt32Array> (
+			"I",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt32Array (ref h, o),
+			list => new JavaInt32Array (list)),
+		new Handler<long, JavaInt64Array> (
+			"J",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt64Array (ref h, o),
+			list => new JavaInt64Array (list)),
+		new Handler<float, JavaSingleArray> (
+			"F",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSingleArray (ref h, o),
+			list => new JavaSingleArray (list)),
+		new Handler<double, JavaDoubleArray> (
+			"D",
+			(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaDoubleArray (ref h, o),
+			list => new JavaDoubleArray (list)),
+	];
+
+	public static bool TryGetArrayTypes (Type elementType, [NotNullWhen (true)] out Type[]? arrayTypes)
+	{
+		foreach (var handler in Handlers) {
+			if (handler.TryGetArrayTypes (elementType, out arrayTypes)) {
+				return true;
+			}
+		}
+
+		arrayTypes = null;
+		return false;
+	}
+
+	public static bool TryGetTypeSignature (Type type, out JniTypeSignature signature)
+	{
+		foreach (var handler in Handlers) {
+			if (handler.TryGetTypeSignature (type, out signature)) {
+				return true;
+			}
+		}
+
+		signature = default;
+		return false;
+	}
+
+	public static bool TryCreateWrapper (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options,
+		Type targetType,
+		[NotNullWhen (true)] out object? value)
+	{
+		foreach (var handler in Handlers) {
+			if (handler.TryCreateWrapper (ref reference, options, targetType, out value)) {
+				return true;
+			}
+		}
+
+		value = null;
+		return false;
+	}
+
+	public static bool TryCreateObjectReference (object value, out JniObjectReference reference)
+	{
+		foreach (var handler in Handlers) {
+			if (handler.TryCreateObjectReference (value, out reference)) {
+				return true;
+			}
+		}
+
+		reference = new JniObjectReference ();
+		return false;
+	}
+}
\ No newline at end of file
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/RuntimeFeature.cs b/src/Mono.Android/Microsoft.Android.Runtime/RuntimeFeature.cs
index 5d20f9e5ac4..11d8bd2c835 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/RuntimeFeature.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/RuntimeFeature.cs
@@ -18,14 +18,20 @@ static class RuntimeFeature
 	const string StartupHookProviderSwitch = "System.StartupHookProvider.IsSupported";
 
 	[FeatureSwitchDefinition ($"{FeatureSwitchPrefix}{nameof (ManagedTypeMap)}")]
+	[FeatureGuard (typeof (RequiresDynamicCodeAttribute))]
+	[FeatureGuard (typeof (RequiresUnreferencedCodeAttribute))]
 	internal static bool ManagedTypeMap { get; } =
 		AppContext.TryGetSwitch ($"{FeatureSwitchPrefix}{nameof (ManagedTypeMap)}", out bool isEnabled) ? isEnabled : ManagedTypeMapEnabledByDefault;
 
 	[FeatureSwitchDefinition ($"{FeatureSwitchPrefix}{nameof (IsMonoRuntime)}")]
+	[FeatureGuard (typeof (RequiresDynamicCodeAttribute))]
+	[FeatureGuard (typeof (RequiresUnreferencedCodeAttribute))]
 	internal static bool IsMonoRuntime { get; } =
 		AppContext.TryGetSwitch ($"{FeatureSwitchPrefix}{nameof (IsMonoRuntime)}", out bool isEnabled) ? isEnabled : IsMonoRuntimeEnabledByDefault;
 		
 	[FeatureSwitchDefinition ($"{FeatureSwitchPrefix}{nameof (IsCoreClrRuntime)}")]
+	[FeatureGuard (typeof (RequiresDynamicCodeAttribute))]
+	[FeatureGuard (typeof (RequiresUnreferencedCodeAttribute))]
 	internal static bool IsCoreClrRuntime { get; } =
 		AppContext.TryGetSwitch ($"{FeatureSwitchPrefix}{nameof (IsCoreClrRuntime)}", out bool isEnabled) ? isEnabled : IsCoreClrRuntimeEnabledByDefault;
 
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs
deleted file mode 100644
index 0546f43d378..00000000000
--- a/src/Mono.Android/Microsoft.Android.Runtime/SimpleValueManager.cs
+++ /dev/null
@@ -1,259 +0,0 @@
-// Originally from: https://github.com/dotnet/java-interop/blob/9b1d8781e8e322849d05efac32119c913b21c192/src/Java.Runtime.Environment/Java.Interop/ManagedValueManager.cs
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-using Android.Runtime;
-using Java.Interop;
-
-namespace Microsoft.Android.Runtime;
-
-class SimpleValueManager : AndroidReflectionJniValueManager
-{
-	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
-
-	Dictionary<int, List<IJavaPeerable>>?   RegisteredInstances = new Dictionary<int, List<IJavaPeerable>>();
-
-	internal SimpleValueManager ()
-	{
-	}
-
-	public override void WaitForGCBridgeProcessing ()
-	{
-	}
-
-	public override void CollectPeers ()
-	{
-		if (RegisteredInstances == null)
-			throw new ObjectDisposedException (nameof (SimpleValueManager));
-
-		var peers = new List<IJavaPeerable> ();
-
-		lock (RegisteredInstances) {
-			foreach (var ps in RegisteredInstances.Values) {
-				foreach (var p in ps) {
-					peers.Add (p);
-				}
-			}
-			RegisteredInstances.Clear ();
-		}
-		List<Exception>? exceptions = null;
-		foreach (var peer in peers) {
-			try {
-				peer.Dispose ();
-			}
-			catch (Exception e) {
-				exceptions = exceptions ?? new List<Exception> ();
-				exceptions.Add (e);
-			}
-		}
-		if (exceptions != null)
-			throw new AggregateException ("Exceptions while collecting peers.", exceptions);
-	}
-
-	public override void AddPeer (IJavaPeerable value)
-	{
-		if (RegisteredInstances == null)
-			throw new ObjectDisposedException (nameof (SimpleValueManager));
-
-		var r = value.PeerReference;
-		if (!r.IsValid)
-			throw new ObjectDisposedException (value.GetType ().FullName);
-
-		if (r.Type != JniObjectReferenceType.Global) {
-			value.SetPeerReference (r.NewGlobalRef ());
-			JniObjectReference.Dispose (ref r, JniObjectReferenceOptions.CopyAndDispose);
-		}
-		int key = value.JniIdentityHashCode;
-		lock (RegisteredInstances) {
-			List<IJavaPeerable>? peers;
-			if (!RegisteredInstances.TryGetValue (key, out peers)) {
-				peers = new List<IJavaPeerable> () {
-					value,
-				};
-				RegisteredInstances.Add (key, peers);
-				return;
-			}
-
-			for (int i = peers.Count - 1; i >= 0; i--) {
-				var p   = peers [i];
-				if (!JniEnvironment.Types.IsSameObject (p.PeerReference, value.PeerReference))
-					continue;
-				if (Replaceable (p)) {
-					peers [i] = value;
-				} else {
-					WarnNotReplacing (key, value, p);
-				}
-				return;
-			}
-			peers.Add (value);
-		}
-	}
-
-	static bool Replaceable (IJavaPeerable peer)
-	{
-		if (peer == null)
-			return true;
-		return peer.JniManagedPeerState.HasFlag (JniManagedPeerStates.Replaceable);
-	}
-
-	void WarnNotReplacing (int key, IJavaPeerable ignoreValue, IJavaPeerable keepValue)
-	{
-		Runtime.ObjectReferenceManager.WriteGlobalReferenceLine (
-				"Warning: Not registering PeerReference={0} IdentityHashCode=0x{1} Instance={2} Instance.Type={3} Java.Type={4}; " +
-				"keeping previously registered PeerReference={5} Instance={6} Instance.Type={7} Java.Type={8}.",
-				ignoreValue.PeerReference.ToString (),
-				key.ToString ("x", CultureInfo.InvariantCulture),
-				RuntimeHelpers.GetHashCode (ignoreValue).ToString ("x", CultureInfo.InvariantCulture),
-				ignoreValue.GetType ().FullName,
-				JniEnvironment.Types.GetJniTypeNameFromInstance (ignoreValue.PeerReference),
-				keepValue.PeerReference.ToString (),
-				RuntimeHelpers.GetHashCode (keepValue).ToString ("x", CultureInfo.InvariantCulture),
-				keepValue.GetType ().FullName,
-				JniEnvironment.Types.GetJniTypeNameFromInstance (keepValue.PeerReference));
-	}
-
-	public override IJavaPeerable? PeekPeer (JniObjectReference reference)
-	{
-		if (RegisteredInstances == null)
-			throw new ObjectDisposedException (nameof (SimpleValueManager));
-
-		if (!reference.IsValid)
-			return null;
-
-		int key = GetJniIdentityHashCode (reference);
-
-		lock (RegisteredInstances) {
-			List<IJavaPeerable>? peers;
-			if (!RegisteredInstances.TryGetValue (key, out peers))
-				return null;
-
-			for (int i = peers.Count - 1; i >= 0; i--) {
-				var p = peers [i];
-				if (JniEnvironment.Types.IsSameObject (reference, p.PeerReference))
-					return p;
-			}
-			if (peers.Count == 0)
-				RegisteredInstances.Remove (key);
-		}
-		return null;
-	}
-
-	public override void RemovePeer (IJavaPeerable value)
-	{
-		if (RegisteredInstances == null)
-			throw new ObjectDisposedException (nameof (SimpleValueManager));
-
-		if (value == null)
-			throw new ArgumentNullException (nameof (value));
-
-		int key = value.JniIdentityHashCode;
-		lock (RegisteredInstances) {
-			List<IJavaPeerable>? peers;
-			if (!RegisteredInstances.TryGetValue (key, out peers))
-				return;
-
-			for (int i = peers.Count - 1; i >= 0; i--) {
-				var p   = peers [i];
-				if (object.ReferenceEquals (value, p)) {
-					peers.RemoveAt (i);
-				}
-			}
-			if (peers.Count == 0)
-				RegisteredInstances.Remove (key);
-		}
-	}
-
-	public override void FinalizePeer (IJavaPeerable value)
-	{
-		var h = value.PeerReference;
-		var o = Runtime.ObjectReferenceManager;
-		// MUST NOT use SafeHandle.ReferenceType: local refs are tied to a JniEnvironment
-		// and the JniEnvironment's corresponding thread; it's a thread-local value.
-		// Accessing SafeHandle.ReferenceType won't kill anything (so far...), but
-		// instead it always returns JniReferenceType.Invalid.
-		if (!h.IsValid || h.Type == JniObjectReferenceType.Local) {
-			if (o.LogGlobalReferenceMessages) {
-				o.WriteGlobalReferenceLine ("Finalizing PeerReference={0} IdentityHashCode=0x{1} Instance=0x{2} Instance.Type={3}",
-						h.ToString (),
-						value.JniIdentityHashCode.ToString ("x", CultureInfo.InvariantCulture),
-						RuntimeHelpers.GetHashCode (value).ToString ("x", CultureInfo.InvariantCulture),
-						value.GetType ().ToString ());
-			}
-			RemovePeer (value);
-			value.SetPeerReference (new JniObjectReference ());
-			value.Finalized ();
-			return;
-		}
-
-		RemovePeer (value);
-		if (o.LogGlobalReferenceMessages) {
-			o.WriteGlobalReferenceLine ("Finalizing PeerReference={0} IdentityHashCode=0x{1} Instance=0x{2} Instance.Type={3}",
-					h.ToString (),
-					value.JniIdentityHashCode.ToString ("x", CultureInfo.InvariantCulture),
-					RuntimeHelpers.GetHashCode (value).ToString ("x", CultureInfo.InvariantCulture),
-					value.GetType ().ToString ());
-		}
-		value.SetPeerReference (new JniObjectReference ());
-		JniObjectReference.Dispose (ref h);
-		value.Finalized ();
-	}
-
-	public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
-	{
-		if (RegisteredInstances == null)
-			throw new ObjectDisposedException (nameof (SimpleValueManager));
-
-		lock (RegisteredInstances) {
-			var peers = new List<JniSurfacedPeerInfo> (RegisteredInstances.Count);
-			foreach (var e in RegisteredInstances) {
-				foreach (var p in e.Value) {
-					peers.Add (new JniSurfacedPeerInfo (e.Key, new WeakReference<IJavaPeerable> (p)));
-				}
-			}
-			return peers;
-		}
-	}
-
-	const   BindingFlags    ActivationConstructorBindingFlags   = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
-
-	static  readonly    Type[]  XAConstructorSignature  = new Type [] { typeof (IntPtr), typeof (JniHandleOwnership) };
-
-	protected override bool TryConstructPeer (
-			IJavaPeerable self,
-			ref JniObjectReference reference,
-			JniObjectReferenceOptions options,
-			[DynamicallyAccessedMembers (Constructors)]
-			Type type)
-	{
-		var c = type.GetConstructor (ActivationConstructorBindingFlags, null, XAConstructorSignature, null);
-		if (c != null) {
-			var args = new object[] {
-				reference.Handle,
-				JniHandleOwnership.DoNotTransfer,
-			};
-			c.Invoke (self, args);
-			JniObjectReference.Dispose (ref reference, options);
-			return true;
-		}
-		return base.TryConstructPeer (self, ref reference, options, type);
-	}
-
-	protected override bool TryUnboxPeerObject (IJavaPeerable value, [NotNullWhen (true)]out object? result)
-	{
-		var proxy = value as JavaProxyThrowable;
-		if (proxy != null) {
-			result  = proxy.InnerException;
-			return true;
-		}
-		return base.TryUnboxPeerObject (value, out result);
-	}
-}
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/SingleUniverseTypeMap.cs b/src/Mono.Android/Microsoft.Android.Runtime/SingleUniverseTypeMap.cs
index a6afdba2bab..7291e00555e 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/SingleUniverseTypeMap.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/SingleUniverseTypeMap.cs
@@ -102,17 +102,17 @@ public bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? pr
 		return false;
 	}
 
-	public bool TryGetArrayType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? arrayType)
+	public bool TryGetArrayProxyType (string jniName, int rankIndex, [NotNullWhen (true)] out Type? proxyType)
 	{
 		foreach (var arrayMapsByRank in _arrayMapsByUniverseAndRank) {
 			if ((uint)rankIndex < (uint)arrayMapsByRank.Length &&
 					arrayMapsByRank [rankIndex] is { } dict &&
-					dict.TryGetValue (jniName, out arrayType)) {
+					dict.TryGetValue (jniName, out proxyType)) {
 				return true;
 			}
 		}
 
-		arrayType = null;
+		proxyType = null;
 		return false;
 	}
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs
index 915daa0e248..afbd3ed45fd 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs
@@ -21,6 +21,7 @@ public class TrimmableTypeMap
 {
 	static readonly Lock s_initLock = new ();
 	static readonly JavaPeerProxy s_noPeerSentinel = new MissingJavaPeerProxy ();
+	static readonly JavaArrayProxy s_noArrayProxySentinel = new MissingJavaArrayProxy ();
 	static TrimmableTypeMap? s_instance;
 	static bool s_nativeMethodsRegistered;
 	static JniMethodInfo? s_classGetInterfacesMethod;
@@ -31,6 +32,7 @@ public class TrimmableTypeMap
 
 	readonly ITypeMap _typeMap;
 	readonly ConcurrentDictionary<Type, JavaPeerProxy> _proxyCache = new ();
+	readonly ConcurrentDictionary<Type, JavaArrayProxy> _arrayProxyCache = new ();
 	readonly ConcurrentDictionary<string, JavaPeerProxy[]> _jniProxyCache = new (StringComparer.Ordinal);
 	readonly ConcurrentDictionary<(string ClassName, Type TargetType), JavaPeerProxy> _interfaceProxyCache = new ();
 
@@ -370,7 +372,7 @@ static JniMethodInfo GetClassGetInterfacesMethod ()
 					// FindClass throws for managed types whose Java peer class is
 					// not present in the APK (e.g. test types annotated with
 					// [JniTypeSignature("__missing__")]). Treat as "no match" so
-					// JavaMarshalValueManager.CreatePeer can surface the correct
+					// TrimmableTypeMapValueManager.CreatePeer can surface the correct
 					// ArgumentException instead of leaking ClassNotFoundException.
 					return null;
 				}
@@ -384,9 +386,9 @@ static JniMethodInfo GetClassGetInterfacesMethod ()
 	}
 
 	internal IJavaPeerable? CreateInstance (
-			IntPtr handle,
-			[DynamicallyAccessedMembers (Constructors)]
-			Type? targetType = null)
+		IntPtr handle,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType = null)
 	{
 		var proxy = GetProxyForJavaObject (handle, targetType);
 
@@ -494,7 +496,6 @@ internal static bool TargetTypeMatches (Type targetType, Type proxyTargetType)
 	/// <summary>
 	/// Gets the invoker type for an interface or abstract class from the proxy attribute.
 	/// </summary>
-	[return: DynamicallyAccessedMembers (Constructors)]
 	internal Type? GetInvokerType (Type type)
 	{
 		return GetProxyForManagedType (type)?.InvokerType;
@@ -509,63 +510,23 @@ internal static bool TargetTypeMatches (Type targetType, Type proxyTargetType)
 		return GetProxyForManagedType (type)?.GetContainerFactory ();
 	}
 
-	/// <summary>AOT-safe lookup of the closed managed array type for the given element type.</summary>
-	internal bool TryGetArrayType (Type elementType, [NotNullWhen (true)] out Type? arrayType)
+	/// <summary>Lookup of the generated array proxy after adding array rank to the given element type.</summary>
+	internal bool TryGetArrayProxy (Type elementType, int additionalRank, [NotNullWhen (true)] out JavaArrayProxy? arrayProxy)
 	{
-		arrayType = null;
-
-		// Walk array nesting to the leaf; rankIndex = depth = (rank - 1).
-		// Reject multi-dim arrays (byte[,]) — JNI only supports szarrays.
-		var leaf = elementType;
-		int rankIndex = 0;
-		while (leaf.IsArray) {
-			if (!leaf.IsSZArray) {
-				return false;
-			}
-			var next = leaf.GetElementType ();
-			if (next is null) {
-				return false;
+		var signature = JniRuntime.CurrentRuntime.TypeManager.GetTypeSignature (elementType);
+		signature = signature.AddArrayRank (additionalRank);
+		var elementJniName = signature.SimpleReference ?? throw new InvalidOperationException ();
+
+		if (_typeMap.TryGetArrayProxyType (elementJniName, signature.ArrayRank - 1, out var proxyType)) {
+			var proxy = _arrayProxyCache.GetOrAdd (proxyType, static type =>
+				type.GetCustomAttribute<JavaArrayProxy> (inherit: false) ?? s_noArrayProxySentinel);
+			if (!ReferenceEquals (proxy, s_noArrayProxySentinel)) {
+				arrayProxy = proxy;
+				return true;
 			}
-			leaf = next;
-			rankIndex++;
-		}
-
-		bool isPrimitiveLeaf = leaf.IsPrimitive;
-		string? leafJniName = isPrimitiveLeaf
-			? TryGetPrimitiveJniName (leaf, out var p) ? p : null
-			: TryGetJniNameForManagedType (leaf, out var jni) ? jni : null;
-
-		if (leafJniName is not null && _typeMap.TryGetArrayType (leafJniName, rankIndex, out arrayType)) {
-			return true;
-		}
-
-		if (isPrimitiveLeaf) {
-			arrayType = MakePrimitiveArrayType (elementType);
-			return true;
 		}
 
-		return false;
-	}
-
-	static Type MakePrimitiveArrayType (Type elementType)
-	{
-#pragma warning disable IL3050 // Primitive array types are runtime intrinsic; no generated generic code is needed.
-		return elementType.MakeArrayType ();
-#pragma warning restore IL3050
-	}
-
-	/// <summary>JNI single-letter encoding for primitive element types.</summary>
-	static bool TryGetPrimitiveJniName (Type primitive, [NotNullWhen (true)] out string? jni)
-	{
-		if (primitive == typeof (bool))   { jni = "Z"; return true; }
-		if (primitive == typeof (byte))   { jni = "B"; return true; }
-		if (primitive == typeof (char))   { jni = "C"; return true; }
-		if (primitive == typeof (short))  { jni = "S"; return true; }
-		if (primitive == typeof (int))    { jni = "I"; return true; }
-		if (primitive == typeof (long))   { jni = "J"; return true; }
-		if (primitive == typeof (float))  { jni = "F"; return true; }
-		if (primitive == typeof (double)) { jni = "D"; return true; }
-		jni = null;
+		arrayProxy = null;
 		return false;
 	}
 
@@ -612,4 +573,11 @@ public MissingJavaPeerProxy () : base ("<missing>", typeof (Java.Lang.Object), n
 		public override IJavaPeerable? CreateInstance (IntPtr handle, JniHandleOwnership transfer) => null;
 	}
 
+	sealed class MissingJavaArrayProxy : JavaArrayProxy
+	{
+		public override Type[] GetArrayTypes () => [];
+
+		public override Array CreateManagedArray (int length) => throw new NotSupportedException ();
+	}
+
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
index c2514055757..d56e6438274 100644
--- a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
+++ b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapTypeManager.cs
@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Reflection;
 using Java.Interop;
 
 namespace Microsoft.Android.Runtime;
@@ -14,128 +13,328 @@ namespace Microsoft.Android.Runtime;
 /// Type manager for the trimmable typemap path. Delegates type lookups
 /// to <see cref="TrimmableTypeMap"/>.
 /// </summary>
-[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
-class TrimmableTypeMapTypeManager : JniRuntime.ReflectionJniTypeManager
+class TrimmableTypeMapTypeManager : JniRuntime.JniTypeManager
 {
-	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 ();
+	readonly ConcurrentDictionary<Type, JniTypeSignature> _typeSignatureCache = new ();
 
-	protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpleReference)
+	// This type manager has 2 core APIs: GetTypeSignatureCore for managed-to-Java lookups, and GetTypeForSimpleReference for Java-to-managed lookups.
+	// The rest of the APIs are unsupported and will throw if called, as they are not needed internally anywhere.
+
+	public override IEnumerable<Type> GetTypes (JniTypeSignature typeSignature)
 	{
-		foreach (var t in base.GetTypesForSimpleReference (jniSimpleReference)) {
-			yield return t;
+		if (typeSignature.SimpleReference is null) {
+			return [];
 		}
 
-		if (TrimmableTypeMap.Instance.TryGetTargetTypes (jniSimpleReference, out var types)) {
-			foreach (var type in types) {
-				yield return type;
+		var simpleReference = typeSignature.SimpleReference ?? throw new InvalidOperationException ("Should not be reached");
+		var simpleTypes = GetTypesForSimpleReference (simpleReference);
+
+		if (typeSignature.ArrayRank == 0) {
+			return simpleTypes;
+		}
+
+		return GetFlattenedArrayTypes (typeSignature, simpleTypes);
+
+		// Multiple managed types can map to a single JNI type and a single managed type can map to multiple array types.
+		IEnumerable<Type> GetFlattenedArrayTypes (JniTypeSignature typeSignature, IEnumerable<Type> elementTypes)
+		{
+			Debug.Assert (typeSignature.ArrayRank > 0, "Should not be reached");
+
+			foreach (var elementType in elementTypes) {
+				foreach (var arrayType in GetArrayTypes (typeSignature, elementType)) {
+					yield return arrayType;
+				}
+			}
+		}
+
+		// A single managed type can map to multiple array types, e.g., JavaArray<T>, JavaPrimitiveArray<T>, and T[].
+		static IEnumerable<Type> GetArrayTypes (JniTypeSignature typeSignature, Type elementType)
+		{
+			Debug.Assert (elementType != typeof (void), "Cannot create an array of void");
+
+			// We only pre-generate the array types proxy map for Native AOT because we can't manipulate types at runtime.
+			// For CoreCLR, we take advantage of the dynamic runtime and we save app size by not pre-generating the array types proxy map.
+			if (RuntimeFeature.IsNativeAotRuntime) {
+				if (TrimmableTypeMap.Instance.TryGetArrayProxy (elementType, typeSignature.ArrayRank, out var arrayProxy)) {
+					return arrayProxy.GetArrayTypes ();
+				}
+
+				return [];
+			}
+			
+			if (RuntimeFeature.IsCoreClrRuntime) {
+				if (IsKeyword (typeSignature)) {
+					return GetPrimitiveArrayTypes (elementType, typeSignature.ArrayRank);
+				}
+
+				return MakeArrayTypes (elementType, typeSignature.ArrayRank);
+			}
+			
+			throw new NotSupportedException ("Unsupporte runtime.");
+
+			static bool IsKeyword (JniTypeSignature typeSignature)
+			{
+				// typeSignature.IsKeyword is not public so we're using this workaround
+				var keywordTypeSignature = new JniTypeSignature (typeSignature.SimpleReference, typeSignature.ArrayRank, keyword: true);
+				return typeSignature.Equals (keywordTypeSignature);
+			}
+
+			[RequiresDynamicCode ("This API uses reflection to create generic types at runtime, which is not supported in AOT scenarios.")]
+			[RequiresUnreferencedCode ("This API uses reflection to create array types at runtime, which is not supported in trimming scenarios.")]
+			static IEnumerable<Type> GetPrimitiveArrayTypes (Type elementType, int rank)
+			{
+				Debug.Assert (elementType != typeof (void), "Cannot create an array of void");
+				Debug.Assert (rank > 0, "At least one array rank is expected");
+
+				if (!PrimitiveArrayInfo.TryGetArrayTypes (elementType, out var types)) {
+					throw new InvalidOperationException ($"Cannot create an array of type '{elementType.FullName}'");
+				}
+
+				foreach (var type in types) {
+					if (rank == 1) {
+						yield return type;
+					} else {
+						foreach (var arrayType in MakeArrayTypes (type, rank - 1)) {
+							yield return arrayType;
+						}
+					}
+				}
+			}
+
+			[RequiresDynamicCode ("This API uses reflection to create generic types at runtime, which is not supported in AOT scenarios.")]
+			[RequiresUnreferencedCode ("This API uses reflection to create array types at runtime, which is not supported in trimming scenarios.")]
+			static IEnumerable<Type> MakeArrayTypes (Type elementType, int rank)
+			{
+				Debug.Assert (rank > 0, "At least one array rank is expected");
+
+				var javaObjectArrayType = elementType;
+				for (int i = 0; i < rank; i++) {
+					javaObjectArrayType = typeof (JavaObjectArray<>).MakeGenericType (javaObjectArrayType);
+				}
+
+				var arrayType = elementType;
+				for (int i = 0; i < rank; i++) {
+					arrayType = arrayType.MakeArrayType ();
+				}
+
+				return [javaObjectArrayType, arrayType];
 			}
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2063", Justification = "Temporary suppression until trimmable typemap type entries carry DAM annotations.")]
-	[return: DynamicallyAccessedMembers (MethodsConstructors)]
-	protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
+	protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpleReference)
 	{
-		var type = base.GetTypeForSimpleReference (jniSimpleReference);
-		if (type != null) {
-			return type;
+		var builtInType = GetBuiltInTypeForSimpleReference (jniSimpleReference);
+		if (builtInType is not null) {
+			yield return builtInType;
 		}
 
 		if (TrimmableTypeMap.Instance.TryGetTargetTypes (jniSimpleReference, out var types)) {
-			return types [0];
+			foreach (var type in types) {
+				yield return type;
+			}
+		}
+
+		/// <summary>
+		/// Lookup of the JNI type signature for a built-in reference type, e.g., string, bool?, int?, etc.
+		/// </summary>
+		/// <param name="jniSimpleReference"></param>
+		/// <returns></returns>
+		static Type? GetBuiltInTypeForSimpleReference (string jniSimpleReference)
+		{
+			return jniSimpleReference switch {
+				"java/lang/String"     => typeof (string),
+				"V"                    => typeof (void),
+				"Z"                    => typeof (bool),
+				"java/lang/Boolean"    => typeof (bool?),
+				"B"                    => typeof (sbyte),
+				"java/lang/Byte"       => typeof (sbyte?),
+				"C"                    => typeof (char),
+				"java/lang/Character"  => typeof (char?),
+				"S"                    => typeof (short),
+				"java/lang/Short"      => typeof (short?),
+				"I"                    => typeof (int),
+				"java/lang/Integer"    => typeof (int?),
+				"J"                    => typeof (long),
+				"java/lang/Long"       => typeof (long?),
+				"F"                    => typeof (float),
+				"java/lang/Float"      => typeof (float?),
+				"D"                    => typeof (double),
+				"java/lang/Double"     => typeof (double?),
+				_                      => null,
+			};
 		}
-		return null;
 	}
 
-	protected override string? GetSimpleReference (Type type)
+	protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
 	{
-		var simpleReference = _simpleReferenceCache.GetOrAdd (type, GetSimpleReferenceUncached);
-		return simpleReference == NoSimpleReference ? null : simpleReference;
+		var types = GetTypesForSimpleReference (jniSimpleReference);
+		using var enumerator = types.GetEnumerator ();
+		return enumerator.MoveNext () ? enumerator.Current : null;
 	}
 
-	string GetSimpleReferenceUncached (Type type)
+	protected override JniTypeSignature GetTypeSignatureCore (Type type)
 	{
-		if (TrimmableTypeMap.Instance.TryGetJniNameForManagedType (type, out var jniName)) {
-			return jniName;
-		}
+		return _typeSignatureCache.GetOrAdd (type, GetTypeSignatureUncached);
 
-		foreach (var r in base.GetSimpleReferences (type)) {
-			return r;
-		}
+		static JniTypeSignature GetTypeSignatureUncached (Type type)
+		{
+			type = GetUnderlyingType (type, out int rank);
 
-		// Walk the base type chain for managed-only subclasses (e.g., JavaProxyThrowable
-		// extends Java.Lang.Error but has no [Register] attribute itself).
-		for (var baseType = type.BaseType; baseType is not null; baseType = baseType.BaseType) {
-			if (TrimmableTypeMap.Instance.TryGetJniNameForManagedType (baseType, out var baseJniName)) {
-				return baseJniName;
+			if (TryGetBuiltInTypeSignature (type, out var signature)) {
+				return signature.AddArrayRank (rank);
 			}
-		}
 
-		return NoSimpleReference;
-	}
+			if (type.IsGenericType) {
+				var genericDefinition = type.GetGenericTypeDefinition ();
+				if (genericDefinition == typeof (JavaArray<>)
+					|| genericDefinition == typeof (JavaObjectArray<>)
+					|| genericDefinition == typeof (JavaPrimitiveArray<>)) {
+					var elementSignature = GetTypeSignatureUncached (type.GenericTypeArguments [0]);
+					return elementSignature.AddArrayRank (rank + 1);
+				}
+			}
 
-	protected override IEnumerable<string> GetSimpleReferences (Type type)
-	{
-		if (TrimmableTypeMap.Instance.TryGetJniNameForManagedType (type, out var jniName)) {
-			yield return jniName;
-			yield break;
-		}
+			// Walk the base type chain for managed-only subclasses (e.g., JavaProxyThrowable
+			// extends Java.Lang.Error but has no [Register] attribute itself).
+			Type? currentType = type;
 
-		foreach (var r in base.GetSimpleReferences (type)) {
-			yield return r;
-		}
+			while (currentType is not null) {
+				if (TrimmableTypeMap.Instance.TryGetJniNameForManagedType (currentType, out var jniName)) {
+					return new (jniName, rank, keyword: false);
+				}
+
+				currentType = currentType.BaseType;
+			}
+
+			return default;
+
+			static Type GetUnderlyingType (Type type, out int rank)
+			{
+				rank = 0;
+				var originalType = type;
+				while (type.IsArray) {
+					if (type.GetArrayRank () > 1)
+						throw new ArgumentException ($"Multidimensional array '{originalType.FullName}' is not supported.", nameof (type));
+					rank++;
+					type = type.GetElementType () ?? throw new InvalidOperationException ("Array type has no element type.");
+				}
+
+				if (type.IsEnum)
+					type = Enum.GetUnderlyingType (type);
+
+				return type;
+			}
+
+			static bool TryGetBuiltInTypeSignature (Type type, out JniTypeSignature signature)
+			{
+				// Keep the hybrid Type.GetTypeCode + explicit nullable checks. Nullable.GetUnderlyingType ()
+				// allocates a Type[] via GetGenericArguments (), and this path is otherwise allocation-free.
+				if (GetPrimitiveTypeJniName (type) is string primitiveJniTypeName) {
+					signature = new JniTypeSignature (primitiveJniTypeName, keyword: true);
+					return true;
+				}
+
+				if (type == typeof (void)) {
+					signature = new JniTypeSignature ("V", keyword: true);
+					return true;
+				}
+
+				if (TryGetBuiltInReferenceJniName (type, out var jniName)) {
+					signature = new JniTypeSignature (jniName);
+					return true;
+				}
+
+				if (PrimitiveArrayInfo.TryGetTypeSignature (type, out signature)) {
+					return true;
+				}
+
+				signature = default;
+				return false;
+
+				static string? GetPrimitiveTypeJniName (Type type)
+				{
+					return Type.GetTypeCode (type) switch {
+						TypeCode.Boolean => "Z",
+						TypeCode.Byte => "B",
+						TypeCode.SByte => "B",
+						TypeCode.Char => "C",
+						TypeCode.Int16 => "S",
+						TypeCode.UInt16 => "S",
+						TypeCode.Int32 => "I",
+						TypeCode.UInt32 => "I",
+						TypeCode.Int64 => "J",
+						TypeCode.UInt64 => "J",
+						TypeCode.Single => "F",
+						TypeCode.Double => "D",
+						_ => null,
+					};
+				}
+
+				/// <summary>
+				/// Lookup of the JNI type signature for a built-in reference type, e.g., string, bool?, int?, etc.
+				/// </summary>
+				static bool TryGetBuiltInReferenceJniName (Type type, [NotNullWhen (true)] out string? jni)
+				{
+					if (type == typeof (string))  { jni = "java/lang/String"; return true; }
+					if (type == typeof (bool?))   { jni = "java/lang/Boolean"; return true; }
+					if (type == typeof (sbyte?))  { jni = "java/lang/Byte"; return true; }
+					if (type == typeof (char?))   { jni = "java/lang/Character"; return true; }
+					if (type == typeof (short?))  { jni = "java/lang/Short"; return true; }
+					if (type == typeof (int?))    { jni = "java/lang/Integer"; return true; }
+					if (type == typeof (long?))   { jni = "java/lang/Long"; return true; }
+					if (type == typeof (float?))  { jni = "java/lang/Float"; return true; }
+					if (type == typeof (double?)) { jni = "java/lang/Double"; return true; }
+					jni = null;
+					return false;
+				}
 
-		// Walk the base type chain for managed-only subclasses (e.g., JavaProxyThrowable
-		// extends Java.Lang.Error but has no [Register] attribute itself).
-		for (var baseType = type.BaseType; baseType is not null; baseType = baseType.BaseType) {
-			if (TrimmableTypeMap.Instance.TryGetJniNameForManagedType (baseType, out var baseJniName)) {
-				yield return baseJniName;
-				yield break;
 			}
 		}
 	}
 
-	[return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-	protected override Type? GetInvokerTypeCore (
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
-			Type type)
+	protected override IEnumerable<JniTypeSignature> GetTypeSignaturesCore (Type type)
 	{
-		var invokerType = TrimmableTypeMap.Instance.GetInvokerType (type);
-		if (invokerType != null) {
-			return invokerType;
-		}
-
-		return base.GetInvokerTypeCore (type);
+		var signature = GetTypeSignatureCore (type);
+		return signature.IsValid ? [signature] : [];
 	}
 
+	// Remapping APIs for InTune support
+
 	protected override IReadOnlyList<string>? GetStaticMethodFallbackTypesCore (string jniSimpleReference)
-	{
-		return JniRemappingLookup.GetStaticMethodFallbackTypes (jniSimpleReference, useReplacementTypes: true);
-	}
+		=> JniRemappingLookup.GetStaticMethodFallbackTypes (jniSimpleReference, useReplacementTypes: true);
 
 	protected override string? GetReplacementTypeCore (string jniSimpleReference)
-	{
-		return JniRemappingLookup.GetReplacementType (jniSimpleReference);
-	}
+		=> JniRemappingLookup.GetReplacementType (jniSimpleReference);
 
 	protected override JniRuntime.ReplacementMethodInfo? GetReplacementMethodInfoCore (string jniSourceType, string jniMethodName, string jniMethodSignature)
-	{
-		return JniRemappingLookup.GetReplacementMethodInfo (jniSourceType, jniMethodName, jniMethodSignature);
-	}
+		=> JniRemappingLookup.GetReplacementMethodInfo (jniSourceType, jniMethodName, jniMethodSignature);
 
-	public override void RegisterNativeMembers (
-			JniType nativeClass,
-			[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
-			Type type,
-			ReadOnlySpan<char> methods)
-	{
-		throw new UnreachableException (
+	// The rest of the APIs are unsupported - they are not needed internally anywhere anyway
+
+	protected override Type? GetInvokerTypeCore (Type type)
+		=> throw new UnreachableException (
+			$"{nameof (GetInvokerTypeCore)} should not be called in the trimmable typemap path. " +
+			$"Invoker types should use generated {nameof (JavaPeerProxy)} instances.");
+
+	protected override string? GetSimpleReference (Type type)
+		=> throw new UnreachableException (
+			$"{nameof (GetSimpleReference)} should not be called in the trimmable typemap path. " +
+			$"Simple reference lookup should use {nameof (GetTypeSignatureCore)} to get the full type signature, including simple reference.");
+
+	protected override IEnumerable<string> GetSimpleReferences (Type type)
+		=> throw new UnreachableException (
+			$"{nameof (GetSimpleReferences)} should not be called in the trimmable typemap path. " +
+			$"Simple reference lookup should use {nameof (GetTypeSignatureCore)} to get the full type signature, including simple reference.");
+
+	public override void RegisterNativeMembers (JniType nativeClass, Type type, ReadOnlySpan<char> methods)
+		=> throw new UnreachableException (
+			$"RegisterNativeMembers should not be called in the trimmable typemap path. " +
+			$"Native methods for '{type.FullName}' should be registered by JCW static initializer blocks.");
+
+	[Obsolete ("Use RegisterNativeMembers(JniType, Type, ReadOnlySpan<char>)")]
+	public override void RegisterNativeMembers (JniType nativeClass, Type type, string? methods)
+		=> throw new UnreachableException (
 			$"RegisterNativeMembers should not be called in the trimmable typemap path. " +
 			$"Native methods for '{type.FullName}' should be registered by JCW static initializer blocks.");
-	}
 }
diff --git a/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapValueManager.cs b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapValueManager.cs
new file mode 100644
index 00000000000..8ac512885e0
--- /dev/null
+++ b/src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMapValueManager.cs
@@ -0,0 +1,334 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Android.Runtime;
+using Java.Interop;
+
+namespace Microsoft.Android.Runtime;
+
+sealed partial class TrimmableTypeMapValueManager : JniRuntime.JniValueManager
+{
+	const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+	const JniObjectReferenceOptions DoNotRegisterTarget = (JniObjectReferenceOptions)(1 << 2);
+
+	readonly JavaMarshalRegisteredPeers registeredPeers = new ();
+
+	protected override void Dispose (bool disposing)
+	{
+		registeredPeers.Dispose ();
+		base.Dispose (disposing);
+	}
+
+	public override void WaitForGCBridgeProcessing ()
+	{
+		// Intentionally empty. The Mono runtime's own implementation acknowledges this
+		// pattern is fundamentally flawed (see FIXME in sgen-bridge.c): a thread that
+		// passes the check can still race with bridge processing that starts immediately
+		// after. The wait cannot prevent the race, only reduce its window. On CoreCLR,
+		// JNI wrapper threads hold their own handle copies via JniObjectReference, so
+		// they are not affected by the bridge swapping control_block handles.
+	}
+
+	public override void CollectPeers ()
+	{
+		registeredPeers.CollectPeers ();
+	}
+
+	public override void AddPeer (IJavaPeerable value)
+	{
+		registeredPeers.AddPeer (value);
+	}
+
+	public override IJavaPeerable? PeekPeer (JniObjectReference reference)
+	{
+		return registeredPeers.PeekPeer (reference);
+	}
+
+	public override void RemovePeer (IJavaPeerable value)
+	{
+		registeredPeers.RemovePeer (value);
+	}
+
+	public override void FinalizePeer (IJavaPeerable value)
+	{
+		registeredPeers.FinalizePeer (value);
+	}
+
+	public override List<JniSurfacedPeerInfo> GetSurfacedPeers ()
+	{
+		return registeredPeers.GetSurfacedPeers ();
+	}
+
+	public override void ActivatePeer (JniObjectReference reference, Type type, ConstructorInfo cinfo, object?[]? argumentValues)
+	{
+		throw new PlatformNotSupportedException ("Activating Java peers through the value manager is not supported when TrimmableTypeMap is enabled.");
+	}
+
+	protected override void ConstructPeerCore (
+		IJavaPeerable peer,
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options)
+	{
+		if (peer == null)
+			throw new ArgumentNullException (nameof (peer));
+
+		var newRef = peer.PeerReference;
+		if (newRef.IsValid) {
+			JniObjectReference.Dispose (ref reference, options);
+
+			// Instance was already added, don't add again
+			if (peer.JniManagedPeerState.HasFlag (JniManagedPeerStates.Activatable)) {
+				return;
+			}
+			var orig = newRef;
+			newRef = orig.NewGlobalRef ();
+			JniObjectReference.Dispose (ref orig);
+		} else if (options == JniObjectReferenceOptions.None) {
+			// `reference` is likely *InvalidJniObjectReference, and can't be touched
+			return;
+		} else if (!reference.IsValid) {
+			throw new ArgumentException ("JNI Object Reference is invalid.", nameof (reference));
+		} else {
+			newRef = reference;
+
+			if ((options & JniObjectReferenceOptions.Copy) == JniObjectReferenceOptions.Copy) {
+				newRef = reference.NewGlobalRef ();
+			}
+
+			JniObjectReference.Dispose (ref reference, options);
+		}
+
+		peer.SetPeerReference (newRef);
+		peer.SetJniIdentityHashCode (JniEnvironment.References.GetIdentityHashCode (newRef));
+
+		var o = Runtime.ObjectReferenceManager;
+		if (o.LogGlobalReferenceMessages) {
+			o.WriteGlobalReferenceLine ("Created PeerReference={0} IdentityHashCode=0x{1} Instance=0x{2} Instance.Type={3}, Java.Type={4}",
+					newRef.ToString (),
+					peer.JniIdentityHashCode.ToString ("x", CultureInfo.InvariantCulture),
+					RuntimeHelpers.GetHashCode (peer).ToString ("x", CultureInfo.InvariantCulture),
+					peer.GetType ().FullName,
+					JniEnvironment.Types.GetJniTypeNameFromInstance (newRef));
+		}
+
+		if ((options & DoNotRegisterTarget) != DoNotRegisterTarget) {
+			AddPeer (peer);
+		}
+	}
+
+	public override IJavaPeerable? CreatePeer (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions transfer,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType)
+	{
+		EnsureNotDisposed ();
+
+		if (!reference.IsValid) {
+			return null;
+		}
+
+		try {
+			// Mirror legacy GetPeerType: callers commonly request universal
+			// interfaces / boxes (IJavaPeerable, object, Exception) — map these
+			// to a concrete peer type so the proxy lookup can succeed.
+			var resolvedTargetType = JavaMarshalValueManagerHelper.ResolvePeerType (targetType);
+			var peer = TrimmableTypeMap.Instance.CreateInstance (reference.Handle, resolvedTargetType);
+			if (peer is not null) {
+				return peer;
+			}
+
+			// Disambiguate the failure — match the contract of the base
+			// JniRuntime.JniValueManager.CreatePeer so JavaCast / JavaAs
+			// surface the right exception (or null) to callers:
+			//
+			//  (a) target type has no Java mapping at all → ArgumentException
+			//  (b) Java instance is not assignable to the target's Java class
+			//      → return null (JavaAs returns null; JavaCast wraps to
+			//      InvalidCastException via its `??` clause)
+			//  (c) classes are compatible but no proxy / activation failed
+			//      → NotSupportedException (genuine generator gap)
+			if (targetType is not null && resolvedTargetType is not null) {
+				if (!TrimmableTypeMap.Instance.TryGetJniNameForManagedType (resolvedTargetType, out var targetJniName)) {
+					throw new ArgumentException (
+						$"Could not determine Java type corresponding to '{targetType.AssemblyQualifiedName}'.",
+						nameof (targetType));
+				}
+
+				if (JavaMarshalValueManagerHelper.IsIncompatibleCast (targetJniName, ref reference, resolvedTargetType)) {
+					return null;
+				}
+			}
+
+			var targetName = resolvedTargetType?.AssemblyQualifiedName ?? "<null>";
+			var javaType = JniEnvironment.Types.GetJniTypeNameFromInstance (reference);
+
+			throw new NotSupportedException (
+				$"No generated {nameof (JavaPeerProxy)} was found for Java type '{javaType}' " +
+				$"with targetType '{targetName}' while {nameof (RuntimeFeature.TrimmableTypeMap)} is enabled. " +
+				$"This indicates a missing trimmable typemap proxy or association and should be fixed in the generator.");
+		} finally {
+			JniObjectReference.Dispose (ref reference, transfer);
+		}
+	}
+
+	[return: MaybeNull]
+	protected override T CreateValueCore<[DynamicallyAccessedMembers (Constructors)] T> (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType = null)
+	{
+		return GetValueCore<T> (ref reference, options, targetType);
+	}
+
+	protected override object? CreateValueCore (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType = null)
+	{
+		return GetValueCore (ref reference, options, targetType);
+	}
+
+	[return: MaybeNull]
+	protected override T GetValueCore<[DynamicallyAccessedMembers (Constructors)] T> (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType = null)
+	{
+		EnsureNotDisposed ();
+		if (!reference.IsValid) {
+			return default;
+		}
+
+		if (targetType != null && !typeof (T).IsAssignableFrom (targetType)) {
+			throw new ArgumentException (
+				string.Format (CultureInfo.InvariantCulture, "Requested runtime '{0}' value of '{1}' is not compatible with requested compile-time type T of '{2}'.",
+					nameof (targetType),
+					targetType,
+					typeof (T)),
+				nameof (targetType));
+		}
+
+		var value = GetValueCore (ref reference, options, targetType ?? typeof (T));
+		if (value is null) {
+			return default;
+		}
+		return (T) value;
+	}
+
+	protected override object? GetValueCore (
+		ref JniObjectReference reference,
+		JniObjectReferenceOptions options,
+		[DynamicallyAccessedMembers (Constructors)]
+		Type? targetType = null)
+	{
+		EnsureNotDisposed ();
+		if (!reference.IsValid) {
+			return null;
+		}
+
+		var existing = PeekValue (reference);
+		if (existing != null && (targetType == null || targetType.IsAssignableFrom (existing.GetType ()))) {
+			JniObjectReference.Dispose (ref reference, options);
+			return existing;
+		}
+
+		if (targetType != null && PrimitiveArrayInfo.TryCreateWrapper (ref reference, options, targetType, out var arrayWrapper)) {
+			return arrayWrapper;
+		}
+
+		if (targetType != null && typeof (IJavaPeerable).IsAssignableFrom (targetType)) {
+			return CreatePeer (ref reference, options, targetType);
+		}
+
+		return JavaConvert.FromObjectReference (ref reference, options, targetType);
+	}
+
+	protected override bool TryUnboxPeerObject (IJavaPeerable value, [NotNullWhen (true)] out object? result)
+	{
+		if (value is TrimmableJavaProxyObject proxy) {
+			result = proxy.Value;
+			return true;
+		}
+
+		return base.TryUnboxPeerObject (value, out result);
+	}
+
+	protected override JniObjectReference CreateLocalObjectReferenceArgumentCore (Type type, object? value)
+	{
+		if (value == null) {
+			return new JniObjectReference ();
+		}
+
+		if (PrimitiveArrayInfo.TryCreateObjectReference (value, out var primitiveArrayReference)) {
+			return primitiveArrayReference;
+		}
+
+		if (value is IJavaPeerable peerable) {
+			return peerable.PeerReference.IsValid
+				? peerable.PeerReference.NewLocalRef ()
+				: new JniObjectReference ();
+		}
+
+		if (JavaConvert.TryConvertKnownValueToLocalJniHandle (value, out var handle)) {
+			return handle == IntPtr.Zero
+				? new JniObjectReference ()
+				: new JniObjectReference (handle, JniObjectReferenceType.Local);
+		}
+
+		var proxy = TrimmableJavaProxyObject.GetProxy (value);
+		return proxy.PeerReference.NewLocalRef ();
+	}
+
+	protected override JniValueMarshaler GetValueMarshalerCore (Type type)
+		=> throw new NotSupportedException ($"{nameof (GetValueMarshalerCore)} should not be called in the trimmable typemap path.");
+
+	protected override JniValueMarshaler<T> GetValueMarshalerCore<T> ()
+		=> throw new NotSupportedException ($"{nameof (GetValueMarshalerCore)} should not be called in the trimmable typemap path.");
+
+	[Register ("net/dot/jni/internal/TrimmableJavaProxyObject")]
+	private sealed class TrimmableJavaProxyObject : Java.Lang.Object, IEquatable<TrimmableJavaProxyObject>
+	{
+		static readonly ConditionalWeakTable<object, TrimmableJavaProxyObject> CachedValues = new ();
+
+		private TrimmableJavaProxyObject (object value) => Value = value;
+
+		// This class is not meant to be instantiated from the Java side, so make the parameterless constructor
+		// private to prevent the generator from generating the default Java ctor.
+		private TrimmableJavaProxyObject () => throw new UnreachableException ();
+
+		public object Value { get; }
+
+		public static TrimmableJavaProxyObject GetProxy (object value)
+		{
+			ArgumentNullException.ThrowIfNull (value);
+
+			lock (CachedValues) {
+				return CachedValues.GetOrAdd (value, static (value) => new TrimmableJavaProxyObject (value));
+			}
+		}
+
+		public bool Equals (TrimmableJavaProxyObject? other) => Equals (Value, other?.Value);
+
+		[Register ("hashCode", "()I", "GetGetHashCodeHandler")]
+		public override int GetHashCode () => Value.GetHashCode ();
+
+		[Register ("equals", "(Ljava/lang/Object;)Z", "GetEquals_Ljava_lang_Object_Handler")]
+		public override bool Equals (Java.Lang.Object? obj)
+		{
+			var reference = obj?.PeerReference ?? new JniObjectReference ();
+			var value = JniEnvironment.Runtime.ValueManager.GetValue (ref reference, JniObjectReferenceOptions.Copy);
+			return Equals (Value, value);
+		}
+
+		[Register ("toString", "()Ljava/lang/String;", "GetToStringHandler")]
+		public override string ToString () => Value.ToString () ?? "";
+	}
+}
diff --git a/src/Mono.Android/Mono.Android.csproj b/src/Mono.Android/Mono.Android.csproj
index f8013325628..ad89f747c00 100644
--- a/src/Mono.Android/Mono.Android.csproj
+++ b/src/Mono.Android/Mono.Android.csproj
@@ -363,15 +363,17 @@
     <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" />
+    <Compile Include="Microsoft.Android.Runtime\CoreClrJavaMarshalValueManager.cs" />
+    <Compile Include="Microsoft.Android.Runtime\JavaMarshalRegisteredPeers.cs" />
+    <Compile Include="Microsoft.Android.Runtime\JavaMarshalValueManagerHelper.cs" />
+    <Compile Include="Microsoft.Android.Runtime\PrimitiveArrayInfo.cs" />
     <Compile Include="Microsoft.Android.Runtime\RuntimeFeature.cs" />
-    <Compile Include="Microsoft.Android.Runtime\SimpleValueManager.cs" />
     <Compile Include="Microsoft.Android.Runtime\SingleUniverseTypeMap.cs" />
     <Compile Include="Microsoft.Android.Runtime\TrimmableTypeMap.cs" />
     <Compile Include="Microsoft.Android.Runtime\TrimmableTypeMapTypeManager.cs" />
+    <Compile Include="Microsoft.Android.Runtime\TrimmableTypeMapValueManager.cs" />
     <Compile Include="Org.Apache.Http.Impl.Conn\DefaultClientConnection.cs" />
     <Compile Include="Org.Apache.Http.Impl.Cookie\BasicClientCookie.cs" />
     <Compile Include="System.Drawing/PointConverter.cs" />
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
index e145c311485..53f153a8720 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.NativeAOT.targets
@@ -17,7 +17,7 @@ This file contains the NativeAOT-specific MSBuild logic for .NET for Android.
     <_AndroidRuntimePackRuntime>NativeAOT</_AndroidRuntimePackRuntime>
     <_AndroidUseWorkloadNativeLinker Condition=" '$(_AndroidUseWorkloadNativeLinker)' == '' ">true</_AndroidUseWorkloadNativeLinker>
     <_AndroidJcwCodegenTarget Condition=" '$(_AndroidJcwCodegenTarget)' == '' ">JavaInterop1</_AndroidJcwCodegenTarget>
-    <_AndroidTypeMapImplementation Condition=" '$(_AndroidTypeMapImplementation)' == '' ">managed</_AndroidTypeMapImplementation>
+    <_AndroidTypeMapImplementation Condition=" '$(_AndroidTypeMapImplementation)' == '' ">trimmable</_AndroidTypeMapImplementation>
     <!-- .NET SDK gives: error NETSDK1191: A runtime identifier for the property 'PublishAot' couldn't be inferred. Specify a rid explicitly. -->
     <AllowPublishAotWithoutRuntimeIdentifier Condition=" '$(AllowPublishAotWithoutRuntimeIdentifier)' == '' ">true</AllowPublishAotWithoutRuntimeIdentifier>
     <!-- NativeAOT's targets currently gives an error about cross-compilation -->
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index b21afc1b6e4..a76819a61a1 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -48,45 +48,6 @@
         OutputFile="$(_ProguardProjectConfiguration)" />
   </Target>
 
-  <Target Name="_GeneratePostTrimTrimmableTypeMapJavaSources"
-      Condition=" '$(_AndroidTypeMapImplementation)' == 'trimmable' and '$(PublishTrimmed)' == 'true' and '$(_ComputeFilesToPublishForRuntimeIdentifiers)' != 'true' "
-      AfterTargets="_ResolveAssemblies"
-      BeforeTargets="_GenerateJavaStubs;_CompileJava;_CompileToDalvik"
-      Inputs="@(ResolvedFileToPublish)"
-      Outputs="$(_PostTrimTrimmableTypeMapJavaStamp)">
-    <ItemGroup>
-      <_PostTrimTrimmableTypeMapInputAssemblies Include="@(ResolvedFileToPublish)"
-          Condition=" '%(Extension)' == '.dll' and ('%(RuntimeIdentifier)' == '' or '$(_PostTrimTypeMapFirstRuntimeIdentifier)' == '' or '%(RuntimeIdentifier)' == '$(_PostTrimTypeMapFirstRuntimeIdentifier)') " />
-    </ItemGroup>
-
-    <GenerateTrimmableTypeMap
-        ResolvedAssemblies="@(_PostTrimTrimmableTypeMapInputAssemblies)"
-        FrameworkAssemblyNames="@(ResolvedFrameworkAssemblies->'%(Filename)')"
-        OutputDirectory="$(_TypeMapOutputDirectory)"
-        JavaSourceOutputDirectory="$(_PostTrimTypeMapJavaOutputDirectory)"
-        JavaSourceInputDirectory="$(_TypeMapJavaOutputDirectory)"
-        TargetFrameworkVersion="$(TargetFrameworkVersion)"
-        PackageNamingPolicy="$(_TrimmableTypeMapPackageNamingPolicy)"
-        MaxArrayRank="$(_AndroidTrimmableTypeMapMaxArrayRank)"
-        GenerateTypeMapAssemblies="false"
-        CleanJavaSourceOutputDirectory="true"
-        AcwMapOutputFile="$(IntermediateOutputPath)acw-map.txt"
-        ApplicationRegistrationOutputFile="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java">
-      <Output TaskParameter="GeneratedJavaFiles" ItemName="_PostTrimGeneratedJavaFiles" />
-    </GenerateTrimmableTypeMap>
-
-    <MakeDir Directories="$([System.IO.Path]::GetDirectoryName('$(_PostTrimTrimmableTypeMapJavaStamp)'))" />
-    <Touch Files="$(_PostTrimTrimmableTypeMapJavaStamp)" AlwaysCreate="true" />
-
-    <ItemGroup>
-      <FileWrites Include="@(_PostTrimGeneratedJavaFiles)" />
-      <FileWrites Include="$(IntermediateOutputPath)acw-map.txt" />
-      <FileWrites Include="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java" />
-      <FileWrites Include="$(_PostTrimTrimmableTypeMapJavaStamp)" />
-      <_PostTrimTrimmableTypeMapInputAssemblies Remove="@(_PostTrimTrimmableTypeMapInputAssemblies)" />
-      <_PostTrimGeneratedJavaFiles Remove="@(_PostTrimGeneratedJavaFiles)" />
-    </ItemGroup>
-  </Target>
   <!-- Add linked TypeMap DLLs to the normal publish assembly pipeline.  The SDK R2R
        target only compiles ResolvedFileToPublish items with PostprocessAssembly=true. -->
   <Target Name="_AddTrimmableTypeMapToResolvedFileToPublish"
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 0a3ff223f63..e5032a3b9b9 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,16 +24,7 @@
     <_TypeMapOutputDirectory>$(_TypeMapBaseOutputDir)typemap/</_TypeMapOutputDirectory>
     <_TypeMapJavaOutputDirectory>$(_TypeMapBaseOutputDir)typemap/java</_TypeMapJavaOutputDirectory>
     <_TypeMapAssembliesListFile>$(_TypeMapOutputDirectory)typemap-assemblies.txt</_TypeMapAssembliesListFile>
-    <_PostTrimTypeMapJavaBaseOutputDir Condition=" '$(_OuterIntermediateOutputPath)' != '' ">$(IntermediateOutputPath)</_PostTrimTypeMapJavaBaseOutputDir>
-    <_PostTrimTypeMapJavaBaseOutputDir Condition=" '$(_PostTrimTypeMapJavaBaseOutputDir)' == '' ">$(_TypeMapBaseOutputDir)</_PostTrimTypeMapJavaBaseOutputDir>
-    <_PostTrimTypeMapJavaOutputDirectory>$(_PostTrimTypeMapJavaBaseOutputDir)typemap/linked-java</_PostTrimTypeMapJavaOutputDirectory>
-    <_PostTrimTypeMapFirstRuntimeIdentifier Condition=" '$(RuntimeIdentifiers)' != '' ">$([System.String]::Copy('$(RuntimeIdentifiers)').Split(';')[0])</_PostTrimTypeMapFirstRuntimeIdentifier>
-    <_PostTrimTypeMapFirstRuntimeIdentifier Condition=" '$(_PostTrimTypeMapFirstRuntimeIdentifier)' == '' ">$(RuntimeIdentifier)</_PostTrimTypeMapFirstRuntimeIdentifier>
-    <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
-    <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' ">$(_TypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
-    <_PostTrimTrimmableTypeMapJavaStamp>$(_PostTrimTypeMapJavaBaseOutputDir)stamp/_GeneratePostTrimTrimmableTypeMapJavaSources.stamp</_PostTrimTrimmableTypeMapJavaStamp>
-    <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTrimmableTypeMapJavaStamp)</_TrimmableJavaSourceStamp>
-    <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' ">$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll</_TrimmableJavaSourceStamp>
+    <_TrimmableTypeMapOutputStamp>$(_TypeMapOutputDirectory)_GenerateTrimmableTypeMap.stamp</_TrimmableTypeMapOutputStamp>
     <!-- Max array rank for __ArrayMapRank{N} sentinel emission. Defaults to 3 when
          dynamic code is unavailable, so array creation uses the typemap path;
          defaults to 0 otherwise, where dynamic code can use Array.CreateInstance directly. -->
@@ -48,6 +39,8 @@
   <ItemGroup>
     <RuntimeHostConfigurationOption Include="Microsoft.Android.Runtime.RuntimeFeature.TrimmableTypeMap"
         Value="true" Trim="true" />
+    <RuntimeHostConfigurationOption Include="Java.Interop.RuntimeFeature.ManagedPeerNativeRegistration"
+        Value="false" Trim="true" />
     <RuntimeHostConfigurationOption Include="System.Runtime.InteropServices.TypeMappingEntryAssembly"
         Value="$(_TypeMapAssemblyName)" />
     <!-- [Export] metadata is still needed at compile time, but the legacy runtime helper
@@ -86,7 +79,7 @@
       Condition=" '$(_AndroidTypeMapImplementation)' == 'trimmable' and '@(ReferencePath->Count())' != '0' and '$(_OuterIntermediateOutputPath)' == '' "
       AfterTargets="CoreCompile"
       Inputs="@(ReferencePath);$(IntermediateOutputPath)$(TargetFileName);$(_AndroidManifestAbs);$(_AndroidBuildPropertiesCache)"
-      Outputs="$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll;$(_TypeMapAssembliesListFile)">
+      Outputs="$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll;$(_TypeMapAssembliesListFile);$(_TrimmableTypeMapOutputStamp)">
 
     <ItemGroup>
       <_TypeMapInputAssemblies Include="@(ReferencePath)" />
@@ -125,13 +118,25 @@
         ApplicationRegistrationOutputFile="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java">
       <Output TaskParameter="GeneratedAssemblies" ItemName="_GeneratedTypeMapAssemblies" />
       <Output TaskParameter="GeneratedJavaFiles" ItemName="_GeneratedJavaFiles" />
+      <Output TaskParameter="DeletedJavaFiles" ItemName="_DeletedJavaFiles" />
       <Output TaskParameter="AdditionalProviderSources" ItemName="_AdditionalProviderSources" />
     </GenerateTrimmableTypeMap>
 
     <ItemGroup>
+      <_DeletedCopiedJavaFiles Remove="@(_DeletedCopiedJavaFiles)" />
+      <_DeletedCopiedJavaFiles Include="@(_DeletedJavaFiles->'$(IntermediateOutputPath)android/src/%(RelativePath)')" />
+    </ItemGroup>
+    <Delete Files="@(_DeletedCopiedJavaFiles)" />
+    <Delete Files="$(_AndroidCompileJavaStampFile)" Condition=" '@(_DeletedCopiedJavaFiles->Count())' != '0' " />
+    <Touch Files="@(_GeneratedTypeMapAssemblies);$(_TypeMapAssembliesListFile);$(_TrimmableTypeMapOutputStamp)" AlwaysCreate="true" />
+
+    <ItemGroup>
+      <FileWrites Remove="@(_DeletedJavaFiles)" />
+      <FileWrites Remove="@(_DeletedCopiedJavaFiles)" />
       <FileWrites Include="@(_GeneratedTypeMapAssemblies)" />
       <FileWrites Include="@(_GeneratedJavaFiles)" />
       <FileWrites Include="$(_TypeMapAssembliesListFile)" />
+      <FileWrites Include="$(_TrimmableTypeMapOutputStamp)" />
       <FileWrites Include="$(_TypeMapBaseOutputDir)AndroidManifest.xml" />
       <FileWrites Include="$(IntermediateOutputPath)acw-map.txt" />
       <FileWrites Include="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java" />
@@ -184,6 +189,7 @@
       <FileWrites Include="@(_TypeMapJavaFilesForFileWrites)" />
       <FileWrites Include="@(_TypeMapJavaFilesForFileWrites->'$(IntermediateOutputPath)android/src/%(RecursiveDir)%(Filename)%(Extension)')" />
       <FileWrites Include="$(_TypeMapAssembliesListFile)" />
+      <FileWrites Include="$(_TrimmableTypeMapOutputStamp)" Condition="Exists('$(_TrimmableTypeMapOutputStamp)')" />
       <FileWrites Include="$(_TypeMapBaseOutputDir)AndroidManifest.xml" Condition="Exists('$(_TypeMapBaseOutputDir)AndroidManifest.xml')" />
       <FileWrites Include="$(IntermediateOutputPath)AndroidManifest.xml" Condition="Exists('$(IntermediateOutputPath)AndroidManifest.xml')" />
       <FileWrites Include="$(IntermediateOutputPath)acw-map.txt" Condition="Exists('$(IntermediateOutputPath)acw-map.txt')" />
@@ -249,21 +255,26 @@
     so this target only handles JCW file copying, manifest, assembly store setup, and native config.
     We keep the name _GenerateJavaStubs because BuildOrder.targets references it.
 
-    Inputs uses the TypeMap DLL as a focused sentinel — _GenerateTrimmableTypeMap regenerates
-    the DLL whenever any of its own inputs (assemblies, manifest, etc.) change, so the DLL
-    timestamp is a reliable proxy for "something changed that requires re-copying".
+    Inputs uses the TypeMap output stamp as a focused sentinel — _GenerateTrimmableTypeMap
+    touches it whenever any of its own inputs (assemblies, manifest, etc.) change. Generated
+    Java files are also inputs so modified sources are copied even if the typemap stamp is stable.
+    The Copy task below then updates android/src only for Java sources whose content changed.
     We keep _GetGenerateJavaStubsInputs in DependsOnTargets so that downstream targets
     (_GetGeneratePackageManagerJavaInputs) can still read @(_GenerateJavaStubsInputs).
   -->
-  <Target Name="_GenerateJavaStubs"
-      DependsOnTargets="_SetLatestTargetFrameworkVersion;_PrepareAssemblies;_GetGenerateJavaStubsInputs;_DefineBuildTargetAbis;_PrepareNativeAssemblySources"
-      Inputs="$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll;@(_EnvironmentFiles)"
-      Outputs="$(_AndroidStampDirectory)_GenerateJavaStubs.stamp">
-
+  <Target Name="_CollectTrimmableTypeMapJavaFiles"
+      Condition=" '$(_AndroidTypeMapImplementation)' == 'trimmable' ">
     <ItemGroup>
-      <_TypeMapJavaFiles Include="$(_TypeMapJavaStubsSourceDirectory)/**/*.java" />
+      <_TypeMapJavaFiles Remove="@(_TypeMapJavaFiles)" />
+      <_TypeMapJavaFiles Include="$(_TypeMapJavaOutputDirectory)/**/*.java" />
     </ItemGroup>
-    <Copy SourceFiles="@(_TypeMapJavaFiles)" DestinationFolder="$(IntermediateOutputPath)android/src/%(RecursiveDir)" />
+  </Target>
+
+  <Target Name="_GenerateJavaStubs"
+      DependsOnTargets="_SetLatestTargetFrameworkVersion;_PrepareAssemblies;_GetGenerateJavaStubsInputs;_DefineBuildTargetAbis;_PrepareNativeAssemblySources;_CollectTrimmableTypeMapJavaFiles"
+      Inputs="$(_TrimmableTypeMapOutputStamp);@(_TypeMapJavaFiles);@(_EnvironmentFiles)"
+      Outputs="$(_AndroidStampDirectory)_GenerateJavaStubs.stamp">
+    <Copy SourceFiles="@(_TypeMapJavaFiles)" DestinationFolder="$(IntermediateOutputPath)android/src/%(RecursiveDir)" SkipUnchangedFiles="true" />
 
     <ItemGroup>
       <FileWrites Include="@(_TypeMapJavaFiles->'$(IntermediateOutputPath)android/src/%(RecursiveDir)%(Filename)%(Extension)')" />
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
index 42e59329019..64bde1a7cb8 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
@@ -1587,24 +1587,6 @@ public static string XA4251 {
             }
         }
 
-        /// <summary>
-        ///   Looks up a localized string similar to Trimmable type map Java source input directory &apos;{0}&apos; and output directory &apos;{1}&apos; must be different..
-        /// </summary>
-        public static string XA4254 {
-            get {
-                return ResourceManager.GetString("XA4254", resourceCulture);
-            }
-        }
-
-        /// <summary>
-        ///   Looks up a localized string similar to Generated trimmable type map Java source &apos;{0}&apos; was not found..
-        /// </summary>
-        public static string XA4255 {
-            get {
-                return ResourceManager.GetString("XA4255", resourceCulture);
-            }
-        }
-
         /// <summary>
         ///   Looks up a localized string similar to Native library &apos;{0}&apos; will not be bundled because it has an unsupported ABI. Move this file to a directory with a valid Android ABI name such as &apos;libs/armeabi-v7a/&apos;..
         /// </summary>
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
index f41614e9e2a..278abcf70b7 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
@@ -1155,17 +1155,6 @@ To use a custom JDK path for a command line build, set the 'JavaSdkDirectory' MS
     <value>Generated Java callable wrapper code changed: '{0}'</value>
     <comment>{0} - The path to the generated Java callable wrapper file</comment>
   </data>
-  <data name="XA4254" xml:space="preserve">
-    <value>Trimmable type map Java source input directory '{0}' and output directory '{1}' must be different.</value>
-    <comment>The following are literal names and should not be translated: Trimmable type map, Java.
-{0} - Full path to the Java source input directory
-{1} - Full path to the Java source output directory</comment>
-  </data>
-  <data name="XA4255" xml:space="preserve">
-    <value>Generated trimmable type map Java source '{0}' was not found.</value>
-    <comment>The following are literal names and should not be translated: trimmable type map, Java.
-{0} - Full path to the generated Java source file</comment>
-  </data>
   <data name="XA0142" xml:space="preserve">
     <value>Command '{0}' failed.\n{1}</value>
     <comment>'{0}' is a failed command name (potentially with path) followed by all the arguments passed to it. {1} is the combined output on the standard error and standard output streams.</comment>
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index 9a03ef4ff21..8c39a2021bd 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -10,6 +10,7 @@
 using Microsoft.Android.Sdk.TrimmableTypeMap;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using Xamarin.Android.Tools;
 
 namespace Xamarin.Android.Tasks;
 
@@ -57,7 +58,6 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	public string OutputDirectory { get; set; } = "";
 	[Required]
 	public string JavaSourceOutputDirectory { get; set; } = "";
-	public string? JavaSourceInputDirectory { get; set; }
 	[Required]
 	public string TargetFrameworkVersion { get; set; } = "";
 
@@ -93,14 +93,14 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	public string? ManifestPlaceholders { get; set; }
 	public string? CheckedBuild { get; set; }
 	public string? ApplicationJavaClass { get; set; }
-	public bool GenerateTypeMapAssemblies { get; set; } = true;
-	public bool CleanJavaSourceOutputDirectory { get; set; }
 
 	[Output]
 	public ITaskItem [] GeneratedAssemblies { get; set; } = [];
 	[Output]
 	public ITaskItem [] GeneratedJavaFiles { get; set; } = [];
 	[Output]
+	public ITaskItem [] DeletedJavaFiles { get; set; } = [];
+	[Output]
 	public string[]? AdditionalProviderSources { get; set; }
 
 	public override bool RunTask ()
@@ -119,19 +119,8 @@ public override bool RunTask ()
 		foreach (var assemblyName in FrameworkAssemblyNames) {
 			frameworkAssemblyNames.Add (assemblyName);
 		}
-		if (CleanJavaSourceOutputDirectory && !JavaSourceInputDirectory.IsNullOrEmpty ()) {
-			var inputDirectory = Path.GetFullPath (JavaSourceInputDirectory);
-			var outputDirectory = Path.GetFullPath (JavaSourceOutputDirectory);
-			if (string.Equals (inputDirectory, outputDirectory, StringComparison.OrdinalIgnoreCase)) {
-				Log.LogCodedError ("XA4254", Properties.Resources.XA4254, inputDirectory, outputDirectory);
-				return false;
-			}
-		}
 
 		Directory.CreateDirectory (OutputDirectory);
-		if (CleanJavaSourceOutputDirectory && Directory.Exists (JavaSourceOutputDirectory)) {
-			Directory.Delete (JavaSourceOutputDirectory, recursive: true);
-		}
 		Directory.CreateDirectory (JavaSourceOutputDirectory);
 
 		var peReaders = new List<PEReader> ();
@@ -182,16 +171,12 @@ public override bool RunTask ()
 				manifestConfig: manifestConfig,
 				manifestTemplate: manifestTemplate,
 				packageNamingPolicy: PackageNamingPolicy,
-				maxArrayRank: MaxArrayRank,
-				generateTypeMapAssemblies: GenerateTypeMapAssemblies);
+				maxArrayRank: MaxArrayRank);
 
-			if (GenerateTypeMapAssemblies) {
-				GeneratedAssemblies = WriteAssembliesToDisk (result.GeneratedAssemblies, assemblyInputs.Select (i => i.Path).ToList ());
-				WriteGeneratedAssembliesListFile (GeneratedAssemblies);
-			}
-			GeneratedJavaFiles = JavaSourceInputDirectory.IsNullOrEmpty ()
-				? WriteJavaSourcesToDisk (result.GeneratedJavaSources)
-				: CopyJavaSourcesFromInputDirectory (result.GeneratedJavaSources);
+			GeneratedAssemblies = WriteAssembliesToDisk (result.GeneratedAssemblies);
+			WriteGeneratedAssembliesListFile (GeneratedAssemblies);
+			GeneratedJavaFiles = WriteJavaSourcesToDisk (result.GeneratedJavaSources);
+			DeletedJavaFiles = DeleteStaleJavaSources (GeneratedJavaFiles);
 
 			// Write manifest to disk if generated
 			if (result.Manifest is not null && !MergedAndroidManifestOutput.IsNullOrEmpty ()) {
@@ -266,40 +251,9 @@ void WriteGeneratedAssembliesListFile (IReadOnlyList<ITaskItem> assemblies)
 		Files.CopyIfStringChanged (text, GeneratedAssembliesListFile);
 	}
 
-	ITaskItem [] CopyJavaSourcesFromInputDirectory (IReadOnlyList<GeneratedJavaSource> javaSources)
-	{
-		var items = new List<ITaskItem> ();
-		foreach (var source in javaSources) {
-			string inputPath = Path.Combine (JavaSourceInputDirectory ?? "", source.RelativePath);
-			if (!File.Exists (inputPath)) {
-				Log.LogCodedError ("XA4255", Properties.Resources.XA4255, inputPath);
-				continue;
-			}
-
-			string outputPath = Path.Combine (JavaSourceOutputDirectory, source.RelativePath);
-			string? dir = Path.GetDirectoryName (outputPath);
-			if (!string.IsNullOrEmpty (dir)) {
-				Directory.CreateDirectory (dir);
-			}
-			using (var stream = File.OpenRead (inputPath)) {
-				Files.CopyIfStreamChanged (stream, outputPath);
-			}
-			items.Add (new TaskItem (outputPath));
-		}
-		return items.ToArray ();
-	}
-
-	ITaskItem [] WriteAssembliesToDisk (IReadOnlyList<GeneratedAssembly> assemblies, IReadOnlyList<string> assemblyPaths)
+	ITaskItem [] WriteAssembliesToDisk (IReadOnlyList<GeneratedAssembly> assemblies)
 	{
-		// Build a map from assembly name -> source path for timestamp comparison
-		var sourcePathByName = new Dictionary<string, string> (StringComparer.Ordinal);
-		foreach (var path in assemblyPaths) {
-			var name = Path.GetFileNameWithoutExtension (path);
-			sourcePathByName [name] = path;
-		}
-
 		var items = new List<ITaskItem> ();
-		bool anyRegenerated = false;
 
 		foreach (var assembly in assemblies) {
 			if (assembly.Name == "_Microsoft.Android.TypeMaps") {
@@ -307,50 +261,23 @@ ITaskItem [] WriteAssembliesToDisk (IReadOnlyList<GeneratedAssembly> assemblies,
 			}
 
 			string outputPath = Path.Combine (OutputDirectory, assembly.Name + ".dll");
-			// Extract the original assembly name from the typemap name (e.g., "_Foo.TypeMap" -> "Foo")
-			string originalName = assembly.Name;
-			if (originalName.StartsWith ("_", StringComparison.Ordinal) && originalName.EndsWith (".TypeMap", StringComparison.Ordinal)) {
-				originalName = originalName.Substring (1, originalName.Length - ".TypeMap".Length - 1);
-			}
-
-			if (IsUpToDate (outputPath, originalName, sourcePathByName)) {
-				Log.LogDebugMessage ($"  {assembly.Name}: up to date, skipping");
-			} else {
-				Files.CopyIfStreamChanged (assembly.Content, outputPath);
-				anyRegenerated = true;
-				Log.LogDebugMessage ($"  {assembly.Name}: written");
-			}
+			var changed = Files.CopyIfStreamChanged (assembly.Content, outputPath);
+			Log.LogDebugMessage ($"  {assembly.Name}: {(changed ? "written" : "unchanged")}");
 
 			items.Add (new TaskItem (outputPath));
 		}
 
-		// Root assembly — regenerate if any per-assembly typemap changed
 		var rootAssembly = assemblies.FirstOrDefault (a => a.Name == "_Microsoft.Android.TypeMaps");
 		if (rootAssembly is not null) {
 			string rootOutputPath = Path.Combine (OutputDirectory, rootAssembly.Name + ".dll");
-			if (anyRegenerated || !File.Exists (rootOutputPath)) {
-				Files.CopyIfStreamChanged (rootAssembly.Content, rootOutputPath);
-				Log.LogDebugMessage ($"  Root: written");
-			} else {
-				Log.LogDebugMessage ($"  Root: up to date, skipping");
-			}
+			var changed = Files.CopyIfStreamChanged (rootAssembly.Content, rootOutputPath);
+			Log.LogDebugMessage ($"  Root: {(changed ? "written" : "unchanged")}");
 			items.Add (new TaskItem (rootOutputPath));
 		}
 
 		return items.ToArray ();
 	}
 
-	static bool IsUpToDate (string outputPath, string assemblyName, Dictionary<string, string> sourcePathByName)
-	{
-		if (!File.Exists (outputPath)) {
-			return false;
-		}
-		if (!sourcePathByName.TryGetValue (assemblyName, out var sourcePath)) {
-			return false;
-		}
-		return File.GetLastWriteTimeUtc (outputPath) >= File.GetLastWriteTimeUtc (sourcePath);
-	}
-
 	ITaskItem [] WriteJavaSourcesToDisk (IReadOnlyList<GeneratedJavaSource> javaSources)
 	{
 		var items = new List<ITaskItem> ();
@@ -370,6 +297,30 @@ ITaskItem [] WriteJavaSourcesToDisk (IReadOnlyList<GeneratedJavaSource> javaSour
 		return items.ToArray ();
 	}
 
+	ITaskItem [] DeleteStaleJavaSources (IReadOnlyCollection<ITaskItem> generatedJavaFiles)
+	{
+		var expectedFiles = new HashSet<string> (
+			generatedJavaFiles.Select (i => Path.GetFullPath (i.ItemSpec)),
+			Path.DirectorySeparatorChar == '\\' ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
+		var deleted = new List<ITaskItem> ();
+
+		foreach (var path in Directory.EnumerateFiles (JavaSourceOutputDirectory, "*.java", SearchOption.AllDirectories)) {
+			var fullPath = Path.GetFullPath (path);
+			if (expectedFiles.Contains (fullPath)) {
+				continue;
+			}
+
+			File.Delete (fullPath);
+			Log.LogDebugMessage ($"Deleted stale generated Java source '{fullPath}'.");
+
+			var item = new TaskItem (fullPath);
+			item.SetMetadata ("RelativePath", PathUtil.GetRelativePath (JavaSourceOutputDirectory, fullPath));
+			deleted.Add (item);
+		}
+
+		return deleted.ToArray ();
+	}
+
 	static Version ParseTargetFrameworkVersion (string tfv)
 	{
 		if (tfv.Length > 0 && (tfv [0] == 'v' || tfv [0] == 'V')) {
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs
index 0bce8de3328..d5d63d2078f 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs
@@ -1794,20 +1794,7 @@ public void XA4310 ([Values ("apk", "aab")] string packageFormat, [Values (Andro
 				StringAssertEx.Contains ("error XA4310", builder.LastBuildOutput, "Error should be XA4310");
 				StringAssertEx.Contains ("`DoesNotExist`", builder.LastBuildOutput, "Error should include the name of the nonexistent file");
 
-				if (runtime != AndroidRuntime.NativeAOT) {
-					builder.AssertHasNoWarnings ();
-					return;
-				}
-
-				// NativeAOT currently (Nov 2025) produces the following warning
-				//  warning IL3053: Assembly 'Mono.Android' produced AOT analysis warnings.
-				string expectedWarning = "warning IL3053:";
-				Assert.IsNotNull (
-					builder.LastBuildOutput
-					  .SkipWhile (x => !x.StartsWith ("Build FAILED.", StringComparison.Ordinal))
-					  .FirstOrDefault (x => x.Contains (expectedWarning)),
-					$"Build output should contain '{expectedWarning}'."
-				);
+				builder.AssertHasNoWarnings ();
 			}
 		}
 
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 6d92d889def..41106f7741e 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
@@ -402,28 +402,7 @@ public void BuildHasNoWarnings (bool isRelease, bool multidex, string packageFor
 			proj.SetProperty ("TrimmerSingleWarn", "false");
 			using (var b = CreateApkBuilder ()) {
 				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");
-
-				if (runtime == AndroidRuntime.NativeAOT) {
-					// 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 = 10;
-
-					Assert.IsTrue (
-						StringAssertEx.ContainsText (
-							b.LastBuildOutput,
-							$" {numberOfExpectedWarnings} Warning(s)"
-						),
-						$"{b.BuildLogFile} should have exactly {numberOfExpectedWarnings} MSBuild warnings for NativeAOT."
-					);
-
-					const string expectedWarningIL3050 = "ILC : AOT analysis warning IL3050:";
-					var warnings = b.LastBuildOutput.SkipWhile (x => !x.StartsWith ("Build succeeded.", StringComparison.Ordinal)).Where (x => x.Contains (expectedWarningIL3050, StringComparison.Ordinal));
-					Assert.IsTrue (warnings.Count () == numberOfExpectedWarnings, $"Expected {numberOfExpectedWarnings} 'IL3050' warnings, found {warnings.Count ()}");
-				} else {
-					b.AssertHasNoWarnings ();
-				}
+				b.AssertHasNoWarnings ();
 				Assert.IsFalse (StringAssertEx.ContainsText (b.LastBuildOutput, "Warning: end of file not at end of a line"),
 					"Should not get a warning from the <CompileNativeAssembly/> task.");
 				var lockFile = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath, ".__lock");
@@ -437,22 +416,13 @@ static IEnumerable<object[]> Get_BuildHasTrimmerWarningsData ()
 
 			foreach (AndroidRuntime runtime in new[] { AndroidRuntime.CoreCLR, AndroidRuntime.NativeAOT }) {
 				AddTestData (runtime, "", new string [0], false);
-
-				if (runtime == AndroidRuntime.NativeAOT) {
-					AddTestData (runtime, "", new [] { "IL2055", "IL3050" }, true, 2);
-				} else {
-					AddTestData (runtime, "", new string [0], true);
-				}
-				AddTestData (runtime, "SuppressTrimAnalysisWarnings=false", new string [] { "IL2055" }, true, 2);
-				AddTestData (runtime, "TrimMode=full", new string [] { "IL2055" }, false, 1);
-				AddTestData (runtime, "TrimMode=full", new string [] { "IL2055" }, true, 2);
-				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, "", new string [0], true);
+				AddTestData (runtime, "SuppressTrimAnalysisWarnings=false", new [] { "IL2055" }, true);
+				AddTestData (runtime, "SuppressTrimAnalysisWarnings=false", new string [0], true);
+				AddTestData (runtime, "TrimMode=full", new string [0], false);
+				AddTestData (runtime, "TrimMode=full", new string [0], true);
+				AddTestData (runtime, "IsAotCompatible=true", new string [0], false);
+				AddTestData (runtime, "IsAotCompatible=true", new string [0], true);
 			}
 
 			return ret;
@@ -491,9 +461,11 @@ public void BuildHasTrimmerWarnings (AndroidRuntime runtime, string properties,
 				proj.ItemGroupList.Add (ignoreIlcWarnings);
 			}
 			proj.SetRuntimeIdentifier ("arm64-v8a");
-			proj.MainActivity = proj.DefaultMainActivity
-				.Replace ("//${FIELDS}", "Type type = typeof (List<>);")
-				.Replace ("//${AFTER_ONCREATE}", "Console.WriteLine (type.MakeGenericType (typeof (object)));");
+			if (codes.Length != 0) {
+				proj.MainActivity = proj.DefaultMainActivity
+					.Replace ("//${FIELDS}", "Type type = typeof (List<>);")
+					.Replace ("//${AFTER_ONCREATE}", "Console.WriteLine (type.MakeGenericType (typeof (object)));");
+			}
 			proj.SetProperty ("TrimmerSingleWarn", "false");
 
 			if (!string.IsNullOrEmpty (properties)) {
@@ -511,8 +483,9 @@ public void BuildHasTrimmerWarnings (AndroidRuntime runtime, string properties,
 			if (codes.Length == 0) {
 				b.AssertHasNoWarnings ();
 			} else {
-				totalWarnings ??= codes.Length;
-				Assert.True (StringAssertEx.ContainsText (b.LastBuildOutput, $"{totalWarnings} Warning(s)"), $"Should receive {totalWarnings} warnings");
+				if (totalWarnings.HasValue) {
+					Assert.True (StringAssertEx.ContainsText (b.LastBuildOutput, $"{totalWarnings} Warning(s)"), $"Should receive {totalWarnings} warnings");
+				}
 				foreach (var code in codes) {
 					Assert.True (StringAssertEx.ContainsText (b.LastBuildOutput, code), $"Should receive {code} warning");
 				}
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/GenerateTrimmableTypeMapTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/GenerateTrimmableTypeMapTests.cs
index 7a6f121832d..5a76c868702 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/GenerateTrimmableTypeMapTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/GenerateTrimmableTypeMapTests.cs
@@ -2,8 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Microsoft.Android.Sdk.TrimmableTypeMap;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using Mono.Cecil;
 using NUnit.Framework;
 using Xamarin.Android.Tasks;
 using Xamarin.ProjectTools;
@@ -77,6 +79,46 @@ public void Execute_WithMonoAndroid_ProducesOutputs ()
 			}
 		}
 
+		[Test]
+		public void Execute_SameInputs_ProducesByteStableAssemblies ()
+		{
+			var path = Path.Combine ("temp", TestName);
+			var firstOutputDir = Path.Combine (Root, path, "first", "typemap");
+			var firstJavaDir = Path.Combine (Root, path, "first", "java");
+			var secondOutputDir = Path.Combine (Root, path, "second", "typemap");
+			var secondJavaDir = Path.Combine (Root, path, "second", "java");
+
+			var monoAndroidItem = FindMonoAndroidDll ();
+			if (monoAndroidItem is null) {
+				Assert.Ignore ("Mono.Android.dll not found; skipping.");
+				return;
+			}
+
+			var assemblies = new [] { monoAndroidItem };
+			var task1 = CreateTask (assemblies, firstOutputDir, firstJavaDir);
+			Assert.IsTrue (task1.Execute (), "First run should succeed.");
+			var task2 = CreateTask (assemblies, secondOutputDir, secondJavaDir);
+			Assert.IsTrue (task2.Execute (), "Second run should succeed.");
+
+			var firstAssemblies = ReadGeneratedAssemblyBytes (task1.GeneratedAssemblies);
+			var secondAssemblies = ReadGeneratedAssemblyBytes (task2.GeneratedAssemblies);
+
+			CollectionAssert.AreEquivalent (firstAssemblies.Keys, secondAssemblies.Keys, "Generated assembly set should be stable.");
+			foreach (var name in firstAssemblies.Keys) {
+				CollectionAssert.AreEqual (firstAssemblies [name], secondAssemblies [name], $"{name} should be byte-stable for identical inputs.");
+			}
+		}
+
+		[Test]
+		public void RootTypeMapAssembly_SystemRuntimeVersion_ChangesMvid ()
+		{
+			var first = GenerateRootTypeMapAssembly (new Version (11, 0));
+			var second = GenerateRootTypeMapAssembly (new Version (11, 1));
+
+			Assert.AreNotEqual (ReadMvid (first), ReadMvid (second),
+				"Root typemap assembly MVID should change when emitted System.Runtime references change.");
+		}
+
 		[Test]
 		public void Execute_SecondRun_OutputsAreUpToDate ()
 		{
@@ -110,6 +152,34 @@ public void Execute_SecondRun_OutputsAreUpToDate ()
 				"Typemap assembly should NOT be rewritten when content hasn't changed.");
 		}
 
+		[Test]
+		public void Execute_MaxArrayRankChange_RewritesGeneratedAssemblies ()
+		{
+			var path = Path.Combine ("temp", TestName);
+			var outputDir = Path.Combine (Root, path, "typemap");
+			var javaDir = Path.Combine (Root, path, "java");
+
+			var monoAndroidItem = FindMonoAndroidDll ();
+			if (monoAndroidItem is null) {
+				Assert.Ignore ("Mono.Android.dll not found; skipping.");
+				return;
+			}
+
+			var assemblies = new [] { monoAndroidItem };
+
+			var task1 = CreateTask (assemblies, outputDir, javaDir);
+			task1.MaxArrayRank = 0;
+			Assert.IsTrue (task1.Execute (), "First run should succeed.");
+			Assert.IsFalse (GeneratedAssembliesContainType (task1.GeneratedAssemblies, "__ArrayMapRank1"),
+				"MaxArrayRank=0 should not emit array-rank sentinel types.");
+
+			var task2 = CreateTask (assemblies, outputDir, javaDir);
+			task2.MaxArrayRank = 1;
+			Assert.IsTrue (task2.Execute (), "Second run should succeed.");
+			Assert.IsTrue (GeneratedAssembliesContainType (task2.GeneratedAssemblies, "__ArrayMapRank1"),
+				"Changing MaxArrayRank should rewrite generated typemap assemblies even when source assemblies did not change.");
+		}
+
 		[Test]
 		public void Execute_WritesGeneratedAssembliesListFile ()
 		{
@@ -139,6 +209,32 @@ public void Execute_WritesGeneratedAssembliesListFile ()
 			CollectionAssert.DoesNotContain (listedAssemblies, staleAssembly);
 		}
 
+		[Test]
+		public void Execute_DeletesStaleGeneratedJavaSources ()
+		{
+			var path = Path.Combine ("temp", TestName);
+			var outputDir = Path.Combine (Root, path, "typemap");
+			var javaDir = Path.Combine (Root, path, "java");
+			var staleJavaFile = Path.Combine (javaDir, "stale", "Old.java");
+			var staleJavaDirectory = Path.GetDirectoryName (staleJavaFile);
+
+			if (staleJavaDirectory is null) {
+				throw new InvalidOperationException ("Could not determine stale Java directory.");
+			}
+			Directory.CreateDirectory (staleJavaDirectory);
+			File.WriteAllText (staleJavaFile, "class Old {}");
+
+			var task = CreateTask ([], outputDir, javaDir);
+
+			Assert.IsTrue (task.Execute (), "Task should succeed.");
+			FileAssert.DoesNotExist (staleJavaFile);
+
+			var deletedFile = task.DeletedJavaFiles.SingleOrDefault ();
+			Assert.IsNotNull (deletedFile);
+			Assert.AreEqual (staleJavaFile, deletedFile.ItemSpec);
+			Assert.AreEqual (Path.Combine ("stale", "Old.java"), deletedFile.GetMetadata ("RelativePath"));
+		}
+
 		[Test]
 		public void Execute_GeneratesFrameworkJcws ()
 		{
@@ -308,5 +404,39 @@ GenerateTrimmableTypeMap CreateTask (ITaskItem [] assemblies, string outputDir,
 			item.SetMetadata ("HasMonoAndroidReference", "True");
 			return item;
 		}
+
+		static bool GeneratedAssembliesContainType (IEnumerable<ITaskItem> assemblies, string typeName)
+		{
+			foreach (var assemblyPath in assemblies.Select (a => a.ItemSpec)) {
+				using var assembly = AssemblyDefinition.ReadAssembly (assemblyPath);
+				if (assembly.Modules.SelectMany (m => m.Types).Any (t => t.Name == typeName)) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		static Dictionary<string, byte []> ReadGeneratedAssemblyBytes (IEnumerable<ITaskItem> assemblies)
+		{
+			return assemblies.ToDictionary (
+				a => Path.GetFileName (a.ItemSpec),
+				a => File.ReadAllBytes (a.ItemSpec),
+				StringComparer.Ordinal);
+		}
+
+		static byte [] GenerateRootTypeMapAssembly (Version systemRuntimeVersion)
+		{
+			using var stream = new MemoryStream ();
+			var generator = new RootTypeMapAssemblyGenerator (systemRuntimeVersion);
+			generator.Generate (new [] { "_Mono.Android.TypeMap" }, useSharedTypemapUniverse: false, stream, maxArrayRank: 3);
+			return stream.ToArray ();
+		}
+
+		static Guid ReadMvid (byte [] assemblyBytes)
+		{
+			using var stream = new MemoryStream (assemblyBytes);
+			using var assembly = AssemblyDefinition.ReadAssembly (stream);
+			return assembly.MainModule.Mvid;
+		}
 	}
 }
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 0315b20bf34..0c2bd2d81d8 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -17,6 +17,52 @@ namespace Xamarin.Android.Build.Tests {
 	[Category ("Node-2")]
 	public class TrimmableTypeMapBuildTests : BaseTest {
 
+		[Test]
+		public void NativeAot_DefaultsToTrimmableTypeMap ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.NativeAOT, release: true)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
+			proj.SetRuntime (AndroidRuntime.NativeAOT);
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.RunTarget (proj, "_CreatePropertiesCache"), "Property cache target should have succeeded.");
+
+			var buildProps = builder.Output.GetIntermediaryPath ("build.props");
+			FileAssert.Exists (buildProps);
+			StringAssert.Contains (
+				"_androidtypemapimplementation=trimmable",
+				File.ReadAllText (buildProps),
+				"NativeAOT should default to trimmable typemaps.");
+		}
+
+		[Test]
+		public void NativeAot_NonTrimmableTypeMap_FailsValidation ([Values ("managed", "llvm-ir")] string typemapImplementation)
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.NativeAOT, release: true)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
+			proj.SetRuntime (AndroidRuntime.NativeAOT);
+			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
+
+			using var builder = CreateApkBuilder ();
+			builder.ThrowOnBuildFailure = false;
+
+			Assert.IsFalse (builder.RunTarget (proj, "_ValidateAndroidTypeMapImplementation"),
+				"NativeAOT with a non-trimmable typemap should fail validation.");
+			Assert.IsTrue (
+				StringAssertEx.ContainsText (builder.LastBuildOutput, "NativeAOT requires _AndroidTypeMapImplementation=trimmable."),
+				$"{builder.BuildLogFile} should contain the NativeAOT trimmable typemap validation error.");
+		}
+
 		[Test]
 		public void Build_WithTrimmableTypeMap_Succeeds ([Values] bool isRelease, [Values (AndroidRuntime.CoreCLR, AndroidRuntime.NativeAOT)] AndroidRuntime runtime)
 		{
@@ -67,6 +113,126 @@ public void Build_WithTrimmableTypeMap_IncrementalBuild ([Values] bool isRelease
 			}
 		}
 
+		[Test]
+		public void GenerateJavaStubsTarget_WithTrimmableTypeMap_DoesNotCleanIntermediateAndroidDirectory ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: false)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject ();
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Build (proj), "First build should have succeeded.");
+
+			var androidDir = builder.Output.GetIntermediaryPath ("android");
+			DirectoryAssert.Exists (androidDir, "First build should have populated the intermediate android directory.");
+			var sentinel = Path.Combine (androidDir, "no-clean-sentinel.txt");
+			File.WriteAllText (sentinel, "do not clean");
+
+			var cleanStamp = builder.Output.GetIntermediaryPath (Path.Combine ("stamp", "_CleanIntermediateIfNeeded.stamp"));
+			if (File.Exists (cleanStamp)) {
+				File.Delete (cleanStamp);
+			}
+
+			var typeMapStamp = builder.Output.GetIntermediaryPath (Path.Combine ("typemap", "_GenerateTrimmableTypeMap.stamp"));
+			var javaStubsStamp = builder.Output.GetIntermediaryPath (Path.Combine ("stamp", "_GenerateJavaStubs.stamp"));
+			FileAssert.Exists (typeMapStamp);
+			FileAssert.Exists (javaStubsStamp);
+			var stampTime = DateTime.UtcNow;
+			File.SetLastWriteTimeUtc (typeMapStamp, stampTime);
+			File.SetLastWriteTimeUtc (javaStubsStamp, stampTime.AddSeconds (-5));
+
+			Assert.IsTrue (builder.RunTarget (proj, "_GenerateJavaStubs", doNotCleanupOnUpdate: true),
+				"_GenerateJavaStubs target should have succeeded.");
+			builder.Output.AssertTargetIsNotSkipped ("_GenerateJavaStubs");
+			FileAssert.Exists (sentinel, "_GenerateJavaStubs should not run _CleanIntermediateIfNeeded when invoked outside a full Build/DeployToDevice graph.");
+		}
+
+		[Test]
+		public void Build_WithTrimmableTypeMap_DeletesStaleGeneratedJavaSourcesAndCopies ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: false)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject ();
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Build (proj), "First build should have succeeded.");
+
+			var staleRelativePath = Path.Combine ("crc64stale", "Old.java");
+			var staleClassPath = Path.Combine ("crc64stale", "Old.class");
+			var staleGeneratedJava = builder.Output.GetIntermediaryPath (Path.Combine ("typemap", "java", staleRelativePath));
+			var staleCopiedJava = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src", staleRelativePath));
+			var staleCompiledClass = builder.Output.GetIntermediaryPath (Path.Combine ("android", "bin", "classes", staleClassPath));
+			var staleGeneratedJavaDirectory = Path.GetDirectoryName (staleGeneratedJava);
+			var staleCopiedJavaDirectory = Path.GetDirectoryName (staleCopiedJava);
+			var staleCompiledClassDirectory = Path.GetDirectoryName (staleCompiledClass);
+			if (staleGeneratedJavaDirectory is null || staleCopiedJavaDirectory is null || staleCompiledClassDirectory is null) {
+				throw new InvalidOperationException ("Could not determine stale Java output directories.");
+			}
+			Directory.CreateDirectory (staleGeneratedJavaDirectory);
+			Directory.CreateDirectory (staleCopiedJavaDirectory);
+			Directory.CreateDirectory (staleCompiledClassDirectory);
+			File.WriteAllText (staleGeneratedJava, "package crc64stale; public class Old {}");
+			File.WriteAllText (staleCopiedJava, "package crc64stale; public class Old {}");
+			File.WriteAllBytes (staleCompiledClass, []);
+
+			proj.MainActivity += Environment.NewLine + "// Force trimmable typemap regeneration.";
+			proj.Touch ("MainActivity.cs");
+			Assert.IsTrue (builder.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "Second build should have succeeded.");
+			builder.Output.AssertTargetIsNotSkipped ("_GenerateTrimmableTypeMap");
+			builder.Output.AssertTargetIsNotSkipped ("_CompileJava");
+
+			FileAssert.DoesNotExist (staleGeneratedJava, "Regenerated trimmable typemap should delete stale Java sources.");
+			FileAssert.DoesNotExist (staleCopiedJava, "Regenerated trimmable typemap should delete stale android/src Java copies.");
+			FileAssert.DoesNotExist (staleCompiledClass, "Deleting stale copied Java sources should force Java recompilation and remove stale class outputs.");
+		}
+
+		[Test]
+		public void Build_WithTrimmableTypeMap_CopiesUpdatedGeneratedJavaSources ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: false)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject ();
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Build (proj), "First build should have succeeded.");
+
+			var generatedJavaDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("typemap", "java"));
+			var generatedJavaFiles = Directory.GetFiles (generatedJavaDirectory, "*.java", SearchOption.AllDirectories);
+			Assert.IsNotEmpty (generatedJavaFiles, "Test setup should have generated trimmable typemap Java sources.");
+
+			var generatedJava = generatedJavaFiles [0];
+			var relativePath = Path.GetRelativePath (generatedJavaDirectory, generatedJava);
+			var copiedJava = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src", relativePath));
+			var typeMapStamp = builder.Output.GetIntermediaryPath (Path.Combine ("typemap", "_GenerateTrimmableTypeMap.stamp"));
+			var javaStubsStamp = builder.Output.GetIntermediaryPath (Path.Combine ("stamp", "_GenerateJavaStubs.stamp"));
+			FileAssert.Exists (copiedJava, "First build should have copied generated Java sources to android/src.");
+			FileAssert.Exists (typeMapStamp, "First build should have written the trimmable typemap output stamp.");
+			FileAssert.Exists (javaStubsStamp, "First build should have written the Java stubs output stamp.");
+
+			var updatedJava = File.ReadAllText (generatedJava) + "\n// Force generated Java copy regression.\n";
+			File.WriteAllText (generatedJava, updatedJava);
+			var stampTime = DateTime.UtcNow;
+			File.SetLastWriteTimeUtc (typeMapStamp, stampTime);
+			File.SetLastWriteTimeUtc (javaStubsStamp, stampTime.AddSeconds (-5));
+
+			Assert.IsTrue (builder.Build (proj, doNotCleanupOnUpdate: true), "Second build should have succeeded.");
+			builder.Output.AssertTargetIsNotSkipped ("_GenerateJavaStubs");
+			builder.Output.AssertTargetIsNotSkipped ("_CompileJava");
+			Assert.AreEqual (updatedJava, File.ReadAllText (copiedJava), "Updated generated Java sources should be copied to android/src even when typemap assemblies do not change.");
+		}
+
 		[Test]
 		public void Build_WithTrimmableTypeMap_ArrayRankChangeRegeneratesTypeMap ()
 		{
@@ -316,11 +482,6 @@ public void ReleaseCoreClrTrimmableTypeMap_SingleRuntimeIdentifier_PackagesLinke
 			var typeMapDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "typemap"));
 			var linkedAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "linked"));
 			var readyToRunAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "R2R"));
-			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "android", "src"));
-			var dexFile = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "android", "bin", "classes.dex"));
-			var acwMapPath = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "acw-map.txt"));
-			var proguardPrimaryPath = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "proguard", "proguard_project_primary.cfg"));
-
 			DirectoryAssert.Exists (typeMapDirectory, "trimmable build should generate typemap assemblies.");
 			DirectoryAssert.Exists (linkedAssemblyDirectory, "Release trimmable build should run ILLink.");
 
@@ -361,8 +522,6 @@ public void ReleaseCoreClrTrimmableTypeMap_SingleRuntimeIdentifier_PackagesLinke
 					expectedHash.SequenceEqual (packagedHash),
 					$"{apkPath} should package post-link typemap assembly {pair.Key} from {pair.Value}, not the generated pre-link copy.");
 			}
-
-			AssertPostTrimR8InputsExcludeDeadFrameworkImplementor (dexFile, javaSourceDirectory, acwMapPath, proguardPrimaryPath);
 		}
 
 		[Test]
@@ -650,35 +809,6 @@ ISet<string> ReadPackagedManagedAssemblyNames (string apkPath, AndroidTargetArch
 				.ToHashSet (StringComparer.Ordinal);
 		}
 
-		void AssertPostTrimR8InputsExcludeDeadFrameworkImplementor (string dexFile, string javaSourceDirectory, string acwMapPath, string proguardPrimaryPath)
-		{
-			const string deadManagedType = "Android.Animation.Animator+IAnimatorListenerImplementor";
-			const string deadJavaName = "Lmono/android/animation/Animator_AnimatorListenerImplementor;";
-			const string deadJavaDotName = "mono.android.animation.Animator_AnimatorListenerImplementor";
-
-			Assert.IsTrue (
-				Directory.EnumerateFiles (javaSourceDirectory, "MainActivity.java", SearchOption.AllDirectories).Any (),
-				"Post-trim Java source generation should keep the app activity JCW.");
-			FileAssert.DoesNotExist (
-				Path.Combine (javaSourceDirectory, "mono", "android", "animation", "Animator_AnimatorListenerImplementor.java"),
-				"Post-trim Java source generation should not copy framework listener implementors removed by ILLink.");
-
-			FileAssert.Exists (acwMapPath, "Post-trim scan should rewrite acw-map.txt for R8.");
-			var acwMap = File.ReadAllText (acwMapPath);
-			Assert.IsFalse (acwMap.Contains (deadManagedType, StringComparison.Ordinal), $"{acwMapPath} should be based on linked assemblies.");
-			Assert.IsFalse (acwMap.Contains (deadJavaDotName, StringComparison.Ordinal), $"{acwMapPath} should not keep removed framework listener implementors.");
-
-			FileAssert.Exists (proguardPrimaryPath, "R8 should generate a primary proguard configuration from the post-trim acw-map.");
-			Assert.IsFalse (
-				File.ReadAllText (proguardPrimaryPath).Contains (deadJavaDotName, StringComparison.Ordinal),
-				$"{proguardPrimaryPath} should not keep removed framework listener implementors.");
-
-			FileAssert.Exists (dexFile, "R8 should produce classes.dex.");
-			Assert.IsFalse (
-				DexUtils.ContainsClass (deadJavaName, dexFile, AndroidSdkPath),
-				$"{dexFile} should not contain the removed framework listener implementor.");
-		}
-
 		string FindOutputFile (ProjectBuilder builder, XamarinAndroidApplicationProject proj, string fileName)
 		{
 			var outputDirectory = Path.Combine (Root, builder.ProjectDirectory, proj.OutputPath);
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
index 7a7af12254a..3cbdc4d9663 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/XASdkTests.cs
@@ -329,8 +329,7 @@ public void DotNetPublish ([Values] bool isRelease, [ValueSource (nameof(Get_Dot
 				if (runtime != AndroidRuntime.NativeAOT) {
 					dotnet.AssertHasNoWarnings ();
 				} else {
-					// NativeAOT currently issues 1 warning
-					dotnet.AssertHasSomeWarnings (1);
+					dotnet.AssertHasNoWarnings ();
 				}
 			}
 
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 588ab6f17a5..99c24688174 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
@@ -11,31 +11,34 @@
       "Size": 18224
     },
     "lib/arm64-v8a/lib_Java.Interop.dll.so": {
-      "Size": 92568
+      "Size": 93856
     },
     "lib/arm64-v8a/lib_Mono.Android.dll.so": {
-      "Size": 119168
+      "Size": 119984
     },
     "lib/arm64-v8a/lib_Mono.Android.Runtime.dll.so": {
-      "Size": 26872
+      "Size": 26912
     },
     "lib/arm64-v8a/lib_System.Console.dll.so": {
       "Size": 24360
     },
+    "lib/arm64-v8a/lib_System.IO.Hashing.dll.so": {
+      "Size": 24280
+    },
     "lib/arm64-v8a/lib_System.Linq.dll.so": {
       "Size": 25552
     },
     "lib/arm64-v8a/lib_System.Private.CoreLib.dll.so": {
-      "Size": 704944
+      "Size": 705536
     },
     "lib/arm64-v8a/lib_System.Runtime.dll.so": {
-      "Size": 20224
+      "Size": 20232
     },
     "lib/arm64-v8a/lib_System.Runtime.InteropServices.dll.so": {
       "Size": 19760
     },
     "lib/arm64-v8a/lib_UnnamedProject.dll.so": {
-      "Size": 20096
+      "Size": 19976
     },
     "lib/arm64-v8a/libarc.bin.so": {
       "Size": 19296
@@ -44,7 +47,7 @@
       "Size": 36416
     },
     "lib/arm64-v8a/libmonodroid.so": {
-      "Size": 1387064
+      "Size": 1387008
     },
     "lib/arm64-v8a/libmonosgen-2.0.so": {
       "Size": 3111632
@@ -62,7 +65,7 @@
       "Size": 162000
     },
     "lib/arm64-v8a/libxamarin-app.so": {
-      "Size": 19680
+      "Size": 19824
     },
     "res/drawable-hdpi-v4/icon.png": {
       "Size": 2178
@@ -89,5 +92,5 @@
       "Size": 1904
     }
   },
-  "PackageSize": 3320142
+  "PackageSize": 3328422
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.NativeAOT.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.NativeAOT.apkdesc
index 79351723c31..ac323054b31 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.NativeAOT.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64SimpleDotNet.NativeAOT.apkdesc
@@ -8,7 +8,7 @@
       "Size": 22016
     },
     "lib/arm64-v8a/libUnnamedProject.so": {
-      "Size": 5999448
+      "Size": 5207328
     },
     "res/drawable-hdpi-v4/icon.png": {
       "Size": 2178
@@ -35,5 +35,5 @@
       "Size": 1904
     }
   },
-  "PackageSize": 2474779
+  "PackageSize": 2159387
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.MonoVM.apkdesc b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.MonoVM.apkdesc
index f0d9684ace8..9ab91e039fd 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.MonoVM.apkdesc
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Resources/Base/BuildReleaseArm64XFormsDotNet.MonoVM.apkdesc
@@ -35,13 +35,13 @@
       "Size": 25360
     },
     "lib/arm64-v8a/lib_Java.Interop.dll.so": {
-      "Size": 101872
+      "Size": 103352
     },
     "lib/arm64-v8a/lib_Mono.Android.dll.so": {
-      "Size": 545344
+      "Size": 561072
     },
     "lib/arm64-v8a/lib_Mono.Android.Runtime.dll.so": {
-      "Size": 26864
+      "Size": 26912
     },
     "lib/arm64-v8a/lib_mscorlib.dll.so": {
       "Size": 21400
@@ -94,6 +94,9 @@
     "lib/arm64-v8a/lib_System.IO.Compression.dll.so": {
       "Size": 34680
     },
+    "lib/arm64-v8a/lib_System.IO.Hashing.dll.so": {
+      "Size": 24280
+    },
     "lib/arm64-v8a/lib_System.IO.IsolatedStorage.dll.so": {
       "Size": 28240
     },
@@ -116,7 +119,7 @@
       "Size": 26976
     },
     "lib/arm64-v8a/lib_System.Private.CoreLib.dll.so": {
-      "Size": 1003920
+      "Size": 1002512
     },
     "lib/arm64-v8a/lib_System.Private.DataContractSerialization.dll.so": {
       "Size": 217808
@@ -131,7 +134,7 @@
       "Size": 35472
     },
     "lib/arm64-v8a/lib_System.Runtime.dll.so": {
-      "Size": 20352
+      "Size": 20376
     },
     "lib/arm64-v8a/lib_System.Runtime.InteropServices.dll.so": {
       "Size": 19752
@@ -257,7 +260,7 @@
       "Size": 168080
     },
     "lib/arm64-v8a/libxamarin-app.so": {
-      "Size": 350464
+      "Size": 350608
     },
     "META-INF/androidx.activity_activity.version": {
       "Size": 6
@@ -2435,5 +2438,5 @@
       "Size": 794696
     }
   },
-  "PackageSize": 11032423
+  "PackageSize": 11052991
 }
\ No newline at end of file
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
index ea3cf49c141..6d7b5a13940 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
@@ -2932,6 +2932,8 @@ because xbuild doesn't support framework reference assemblies.
       BeforeTargets="_CheckForInvalidConfigurationAndPlatform">
     <Error Condition=" '$(_AndroidTypeMapImplementation)' != '' and '$(_AndroidTypeMapImplementation)' != 'llvm-ir' and '$(_AndroidTypeMapImplementation)' != 'managed' and '$(_AndroidTypeMapImplementation)' != 'trimmable' "
            Text="Invalid value for _AndroidTypeMapImplementation: '$(_AndroidTypeMapImplementation)'. Valid values are: llvm-ir, managed, trimmable." />
+    <Error Condition=" '$(_AndroidRuntime)' == 'NativeAOT' and '$(_AndroidTypeMapImplementation)' != 'trimmable' "
+           Text="NativeAOT requires _AndroidTypeMapImplementation=trimmable." />
   </Target>
 
   <Target Name="_LinkAssemblies"
diff --git a/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportAttribute.cs b/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportAttribute.cs
index 1761bf4466e..8c5efd9cf32 100644
--- a/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportAttribute.cs
+++ b/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportAttribute.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Java.Interop {
 
@@ -7,20 +6,15 @@ namespace Java.Interop {
 	[AttributeUsage (AttributeTargets.Method | AttributeTargets.Constructor, 
 			AllowMultiple=false, 
 			Inherited=false)]
-#if !NETSTANDARD2_0
-	[RequiresUnreferencedCode ("[ExportAttribute] uses dynamic features.")]
-#endif
 #if !JCW_ONLY_TYPE_NAMES
 	public
 #endif  // !JCW_ONLY_TYPE_NAMES
 	partial class ExportAttribute : Attribute {
 
-		[DynamicDependency (DynamicallyAccessedMemberTypes.All, "Java.Interop.DynamicCallbackCodeGenerator", "Mono.Android.Export")]
 		public ExportAttribute ()
 		{
 		}
 		
-		[DynamicDependency (DynamicallyAccessedMemberTypes.All, "Java.Interop.DynamicCallbackCodeGenerator", "Mono.Android.Export")]
 		public ExportAttribute (string name)
 		{
 			Name = name;
diff --git a/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs b/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs
index 888636f60f0..c7db9433b8d 100644
--- a/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs
+++ b/src/Xamarin.Android.NamingCustomAttributes/Java.Interop/ExportFieldAttribute.cs
@@ -21,5 +21,3 @@ public ExportFieldAttribute (string name)
 		public string                 Name                    {get; set;}
 	}
 }
-
-
diff --git a/src/java-runtime/java-runtime.targets b/src/java-runtime/java-runtime.targets
index 82c10e29090..d4a6c69f4e5 100644
--- a/src/java-runtime/java-runtime.targets
+++ b/src/java-runtime/java-runtime.targets
@@ -14,7 +14,7 @@
     <OutputDex>$(OutputPath)java_runtime_trimmable.dex</OutputDex>
     <IntermediateRuntimeOutputPath>$(IntermediateOutputPath)release-trimmable</IntermediateRuntimeOutputPath>
     <IntermediateRuntimeClassesTxt>$(IntermediateOutputPath)release-trimmable.txt</IntermediateRuntimeClassesTxt>
-    <RemoveItems>java\mono\android\debug-net6\BuildConfig.java;java\mono\android\debug\BuildConfig.java;java\mono\android\release\BuildConfig.java;java\mono\android\MonoPackageManager.java;$(JavaInteropSourceDirectory)\src\Java.Interop\java\net\dot\jni\internal\JavaProxyObject.java;$(JavaInteropSourceDirectory)\src\Java.Interop\java\net\dot\jni\internal\JavaProxyThrowable.java</RemoveItems>
+    <RemoveItems>java\mono\android\debug-net6\BuildConfig.java;java\mono\android\debug\BuildConfig.java;java\mono\android\release\BuildConfig.java;java\mono\android\MonoPackageManager.java;$(JavaInteropSourceDirectory)\src\Java.Interop\java\net\dot\jni\ManagedPeer.java;$(JavaInteropSourceDirectory)\src\Java.Interop\java\net\dot\jni\internal\JavaProxyObject.java;$(JavaInteropSourceDirectory)\src\Java.Interop\java\net\dot\jni\internal\JavaProxyThrowable.java</RemoveItems>
     <AddItems>java-trimmable\net\dot\jni\internal\JavaProxyObject.java;java-trimmable\net\dot\jni\internal\JavaProxyThrowable.java</AddItems>
   </_RuntimeOutput>
   <_RuntimeOutput Include="$(OutputPath)java_runtime_fastdev.jar">
diff --git a/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs b/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
index dc3e1a83644..e81a04b0cd6 100644
--- a/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
+++ b/tests/MSBuildDeviceIntegration/Tests/InstallAndRunTests.cs
@@ -89,8 +89,8 @@ public void DotNetRun (bool isRelease, string typemapImplementation, AndroidRunt
 				Assert.Ignore ("dotnet run --no-build breaks marshal methods (both managed and llvm-ir) on MonoVM");
 			}
 
-			if (runtime == AndroidRuntime.NativeAOT && typemapImplementation == "llvm-ir") {
-				Assert.Ignore ("NativeAOT doesn't work with LLVM-IR typemaps");
+			if (runtime == AndroidRuntime.NativeAOT && typemapImplementation != "trimmable") {
+				Assert.Ignore ("NativeAOT requires trimmable typemaps.");
 			}
 
 			var proj = new XamarinAndroidApplicationProject (packageName: PackageUtils.MakePackageName (runtime)) {
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
index 0a19aa073ac..2d6a16b6d28 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
@@ -975,7 +975,8 @@ public void Build_EmitArrayEntries_HonoursMaxArrayRank ()
 			Assert.Equal (5, model5.MaxArrayRank);
 			var rank5Entries = model5.Entries.Where (e => e.AnchorRank is not null).ToList ();
 			Assert.Equal (5, rank5Entries.Count);
-			Assert.Equal ("Foo.Bar[][][][][], App", rank5Entries.Single (e => e.AnchorRank == 5).TargetTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy5, TestTypeMap", rank5Entries.Single (e => e.AnchorRank == 5).ProxyTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy5, TestTypeMap", rank5Entries.Single (e => e.AnchorRank == 5).TargetTypeReference);
 
 			var model1 = BuildModelWithArrays (new [] { peer }, maxArrayRank: 1);
 			Assert.Equal (1, model1.MaxArrayRank);
@@ -1008,29 +1009,61 @@ public void Build_EmitArrayEntries_KeyIsElementJniName ()
 		}
 
 		[Fact]
-		public void Build_EmitArrayEntries_TrimTargetIsClosedArrayType ()
+		public void Build_EmitArrayEntries_MapToGeneratedArrayProxy ()
 		{
-			// 3rd ctor arg = the closed array type itself, so ILC's per-shape conditional
-			// drops the entry when the array shape is never constructed.
 			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
 			var model = BuildModelWithArrays (new [] { peer });
 
 			var rank1 = model.Entries.Single (e => e.AnchorRank == 1);
-			Assert.Equal ("Foo.Bar[], App",     rank1.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[], App",     rank1.TargetTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, TestTypeMap", rank1.ProxyTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, TestTypeMap", rank1.TargetTypeReference);
 			var rank2 = model.Entries.Single (e => e.AnchorRank == 2);
-			Assert.Equal ("Foo.Bar[][], App",   rank2.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[][], App",   rank2.TargetTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy2, TestTypeMap", rank2.ProxyTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy2, TestTypeMap", rank2.TargetTypeReference);
 			var rank3 = model.Entries.Single (e => e.AnchorRank == 3);
-			Assert.Equal ("Foo.Bar[][][], App", rank3.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[][][], App", rank3.TargetTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy3, TestTypeMap", rank3.ProxyTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy3, TestTypeMap", rank3.TargetTypeReference);
+
+			Assert.Equal (3, model.ArrayProxyTypes.Count);
+			Assert.Equal ("Foo_Bar_ArrayProxy1", model.ArrayProxyTypes [0].TypeName);
+			Assert.Equal ("Foo_Bar_ArrayProxy2", model.ArrayProxyTypes [1].TypeName);
+			Assert.Equal ("Foo_Bar_ArrayProxy3", model.ArrayProxyTypes [2].TypeName);
+		}
+
+		[Fact]
+		public void Build_EmitArrayEntries_AssociationsMatchGetArrayTypes ()
+		{
+			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
+			var model = BuildModelWithArrays (new [] { peer });
+
+			var rank1Proxy = "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, TestTypeMap";
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaObjectArray`1[[Foo.Bar, App]], Java.Interop" &&
+				a.AliasProxyTypeReference == rank1Proxy);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaArray`1[[Foo.Bar, App]], Java.Interop" &&
+				a.AliasProxyTypeReference == rank1Proxy);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Foo.Bar[], App" &&
+				a.AliasProxyTypeReference == rank1Proxy);
+
+			var rank2Proxy = "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy2, TestTypeMap";
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaObjectArray`1[[Java.Interop.JavaObjectArray`1[[Foo.Bar, App]], Java.Interop]], Java.Interop" &&
+				a.AliasProxyTypeReference == rank2Proxy);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaArray`1[[Foo.Bar, App]][], Java.Interop" &&
+				a.AliasProxyTypeReference == rank2Proxy);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Foo.Bar[][], App" &&
+				a.AliasProxyTypeReference == rank2Proxy);
 		}
 
 		[Fact]
 		public void Build_EmitArrayEntries_AllConditional ()
 		{
 			// 2-arg unconditional makes no sense for arrays — the trim conditioning on the
-			// array shape is the whole point.
+			// generated array proxy is the whole point.
 			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
 			var model = BuildModelWithArrays (new [] { peer });
 
@@ -1107,6 +1140,35 @@ public void Build_EmitArrayEntries_PrimitiveJniKeyword_Skipped (string jniKeywor
 			Assert.DoesNotContain (model.Entries, e => e.AnchorRank is not null);
 		}
 
+		[Fact]
+		public void Build_EmitArrayEntries_PrimitiveEntries_SynthesizedForJavaInteropAssembly ()
+		{
+			var peer = MakeMcwPeer ("java/lang/Object", "Java.Lang.Object", "Java.Interop");
+			var model = BuildModelWithArrays (new [] { peer });
+
+			var primitiveEntries = model.Entries
+				.Where (e => e.JniName.Length == 1 && e.AnchorRank is not null)
+				.ToList ();
+			Assert.Equal (24, primitiveEntries.Count); // 8 primitive keywords × 3 ranks
+
+			var sbyteRank1 = primitiveEntries.Single (e => e.JniName == "B" && e.AnchorRank == 1);
+			Assert.Equal ("_TypeMap.ArrayProxies.Primitive_SByte_ArrayProxy1, TestTypeMap", sbyteRank1.ProxyTypeReference);
+			Assert.Equal ("_TypeMap.ArrayProxies.Primitive_SByte_ArrayProxy1, TestTypeMap", sbyteRank1.TargetTypeReference);
+			Assert.False (sbyteRank1.IsUnconditional);
+
+			var sbyteRank2 = primitiveEntries.Single (e => e.JniName == "B" && e.AnchorRank == 2);
+			Assert.Equal ("_TypeMap.ArrayProxies.Primitive_SByte_ArrayProxy2, TestTypeMap", sbyteRank2.TargetTypeReference);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaArray`1[[System.SByte, System.Runtime]], Java.Interop" &&
+				a.AliasProxyTypeReference == sbyteRank1.ProxyTypeReference);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaPrimitiveArray`1[[System.SByte, System.Runtime]], Java.Interop" &&
+				a.AliasProxyTypeReference == sbyteRank1.ProxyTypeReference);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaSByteArray, Java.Interop" &&
+				a.AliasProxyTypeReference == sbyteRank1.ProxyTypeReference);
+		}
+
 		[Fact]
 		public void Build_EmitArrayEntries_MultiplePeers_GetIndependentTrios ()
 		{
@@ -1197,10 +1259,24 @@ public void FullPipeline_ArrayEntries_AttributeBlobsRoundTrip ()
 			EmitAndVerify (model, "ArrBlobs", (pe, reader) => {
 				var attrs = ReadAllTypeMapAttributeBlobs (reader);
 
-				// Three array entries should round-trip with the same JNI key + array trim targets.
-				Assert.Contains (attrs, a => a.jniName == "foo/Bar" && a.targetRef == "Foo.Bar[], App");
-				Assert.Contains (attrs, a => a.jniName == "foo/Bar" && a.targetRef == "Foo.Bar[][], App");
-				Assert.Contains (attrs, a => a.jniName == "foo/Bar" && a.targetRef == "Foo.Bar[][][], App");
+				// Three array entries should round-trip with the same JNI key + generated array proxy refs.
+				Assert.Contains (attrs, a => a.jniName == "foo/Bar" &&
+					a.proxyRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, ArrBlobs" &&
+					a.targetRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, ArrBlobs");
+				Assert.Contains (attrs, a => a.jniName == "foo/Bar" &&
+					a.proxyRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy2, ArrBlobs" &&
+					a.targetRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy2, ArrBlobs");
+				Assert.Contains (attrs, a => a.jniName == "foo/Bar" &&
+					a.proxyRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy3, ArrBlobs" &&
+					a.targetRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy3, ArrBlobs");
+
+				var assocAttrs = ReadAllTypeMapAssociationAttributeBlobs (reader);
+				Assert.Contains (assocAttrs, a =>
+					a.sourceRef == "Java.Interop.JavaArray`1[[Foo.Bar, App]], Java.Interop" &&
+					a.proxyRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, ArrBlobs");
+				Assert.Contains (assocAttrs, a =>
+					a.sourceRef == "Java.Interop.JavaObjectArray`1[[Foo.Bar, App]], Java.Interop" &&
+					a.proxyRef == "_TypeMap.ArrayProxies.Foo_Bar_ArrayProxy1, ArrBlobs");
 			});
 		}
 	}
@@ -1279,6 +1355,35 @@ static void EmitAndVerify (TypeMapAssemblyData model, string assemblyName, Actio
 		return result;
 	}
 
+	static List<(string? sourceRef, string? proxyRef)> ReadAllTypeMapAssociationAttributeBlobs (MetadataReader reader)
+	{
+		var result = new List<(string?, string?)> ();
+		var asmAttrs = reader.GetCustomAttributes (EntityHandle.AssemblyDefinition);
+		foreach (var attrHandle in asmAttrs) {
+			var attr = reader.GetCustomAttribute (attrHandle);
+			if (attr.Constructor.Kind != HandleKind.MemberReference)
+				continue;
+
+			var ctor = reader.GetMemberReference ((MemberReferenceHandle) attr.Constructor);
+			if (ctor.Parent.Kind != HandleKind.TypeSpecification)
+				continue;
+
+			var parent = reader.GetTypeSpecification ((TypeSpecificationHandle) ctor.Parent);
+			var parentName = parent.DecodeSignature (SignatureTypeProvider.Instance, genericContext: null);
+			if (!parentName.StartsWith ("System.Runtime.InteropServices.TypeMapAssociationAttribute`1", StringComparison.Ordinal)) {
+				continue;
+			}
+
+			var blobReader = reader.GetBlobReader (attr.Value);
+			ushort prolog = blobReader.ReadUInt16 ();
+			if (prolog != 1)
+				continue;
+
+			result.Add ((blobReader.ReadSerializedString (), blobReader.ReadSerializedString ()));
+		}
+		return result;
+	}
+
 	public class UcoMethods
 	{
 		[Fact]
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
index 00c8be4e5bb..c2a087a68c9 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/JavaPeerScannerTests.cs
@@ -60,6 +60,38 @@ 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_ReportsXA4251 ()
+	{
+		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"));
+	}
+
+	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/Mono.Android-Tests/Java.Interop/TrimmableTypeMapRuntimeCoverageTests.cs b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapRuntimeCoverageTests.cs
index bfd4175bab4..0da6502bce5 100644
--- a/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapRuntimeCoverageTests.cs
+++ b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapRuntimeCoverageTests.cs
@@ -171,6 +171,25 @@ public void NonGenericCollection_CopyTo_ObjectArray_PreservesNullElement ()
 			}
 		}
 
+		[Test]
+		public void NativeObjectArray_GetArray_UsesRankOneTypeMapEntry ()
+		{
+			AssumeTrimmableTypeMapEnabled ();
+
+			using var first = new View (Android.App.Application.Context);
+			using var second = new View (Android.App.Application.Context);
+			var handle = JNIEnv.NewArray (new [] { first, second });
+
+			try {
+				var values = JNIEnv.GetArray<View> (handle);
+				Assert.AreEqual (2, values.Length);
+				Assert.IsTrue (JNIEnv.IsSameObject (first.Handle, values [0].Handle));
+				Assert.IsTrue (JNIEnv.IsSameObject (second.Handle, values [1].Handle));
+			} finally {
+				JNIEnv.DeleteLocalRef (handle);
+			}
+		}
+
 		[Test]
 		public void NonGenericCollection_CopyTo_StringArray_ConvertsJavaString ()
 		{
diff --git a/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs
index 3ccae0da3ad..e6dbd323ca2 100644
--- a/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs
+++ b/tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/TrimmableTypeMapTypeManagerTests.cs
@@ -179,22 +179,6 @@ public void RegisteredPeer_CanCreateGenericHolder ()
 			Assert.AreEqual (42, holder.Value);
 		}
 
-		[Test]
-		public void JavaProxyObject_ValueMarshalerUsesProxyType ()
-		{
-			AssumeTrimmableTypeMapEnabled ();
-
-			var value = new object ();
-			var marshaler = JniEnvironment.Runtime.ValueManager.GetValueMarshaler (typeof (object));
-			var state = marshaler.CreateObjectReferenceArgumentState (value);
-
-			try {
-				Assert.AreEqual ("net/dot/jni/internal/JavaProxyObject", JNIEnv.GetClassNameFromInstance (state.ReferenceValue.Handle));
-			} finally {
-				marshaler.DestroyArgumentState (value, ref state);
-			}
-		}
-
 		[Test]
 		public void JavaProxyObject_CanBeUsedInObjectArray ()
 		{
@@ -207,66 +191,83 @@ public void JavaProxyObject_CanBeUsedInObjectArray ()
 		}
 
 		[Test]
+		[Category ("TrimmableTypeMapUnsupported")] // TODO: https://github.com/dotnet/android/issues/11703
 		public void JavaProxyObject_ObjectMethodsUseJavaIdentitySemantics ()
 		{
 			AssumeTrimmableTypeMapEnabled ();
 
 			var value = new object ();
 			var other = new object ();
-			var marshaler = JniEnvironment.Runtime.ValueManager.GetValueMarshaler (typeof (object));
-			var state = marshaler.CreateObjectReferenceArgumentState (value);
-			var otherState = marshaler.CreateObjectReferenceArgumentState (other);
+			using var values = new JavaObjectArray<object> (2);
+			values [0] = value;
+			values [1] = other;
 
+			var localProxy = JniEnvironment.Arrays.GetObjectArrayElement (values.PeerReference, 0);
+			var localOtherProxy = JniEnvironment.Arrays.GetObjectArrayElement (values.PeerReference, 1);
 			try {
-				var localProxy = state.ReferenceValue.NewLocalRef ();
-				var localOtherProxy = otherState.ReferenceValue.NewLocalRef ();
-
+				IntPtr proxyClass = JNIEnv.GetObjectClass (localProxy.Handle);
 				try {
-					IntPtr proxyClass = JNIEnv.GetObjectClass (localProxy.Handle);
+					IntPtr equals = JNIEnv.GetMethodID (proxyClass, "equals", "(Ljava/lang/Object;)Z");
+					IntPtr hashCode = JNIEnv.GetMethodID (proxyClass, "hashCode", "()I");
+					IntPtr toString = JNIEnv.GetMethodID (proxyClass, "toString", "()Ljava/lang/String;");
+					var systemClass = JniEnvironment.Types.FindClass ("java/lang/System");
+
 					try {
-						IntPtr equals = JNIEnv.GetMethodID (proxyClass, "equals", "(Ljava/lang/Object;)Z");
-						IntPtr hashCode = JNIEnv.GetMethodID (proxyClass, "hashCode", "()I");
-						IntPtr toString = JNIEnv.GetMethodID (proxyClass, "toString", "()Ljava/lang/String;");
-						var systemClass = JniEnvironment.Types.FindClass ("java/lang/System");
-
-						try {
-							IntPtr identityHashCode = JNIEnv.GetStaticMethodID (systemClass.Handle, "identityHashCode", "(Ljava/lang/Object;)I");
-
-							Assert.IsTrue (JNIEnv.CallBooleanMethod (localProxy.Handle, equals, new JValue (localProxy.Handle)));
-							Assert.IsFalse (JNIEnv.CallBooleanMethod (localProxy.Handle, equals, new JValue (localOtherProxy.Handle)));
-							Assert.AreEqual (
-								JNIEnv.CallStaticIntMethod (systemClass.Handle, identityHashCode, new JValue (localProxy.Handle)),
-								JNIEnv.CallIntMethod (localProxy.Handle, hashCode));
-							var proxyString = JNIEnv.GetString (JNIEnv.CallObjectMethod (localProxy.Handle, toString), JniHandleOwnership.TransferLocalRef);
-							Assert.IsTrue (
-								proxyString.StartsWith ("net.dot.jni.internal.JavaProxyObject@", StringComparison.Ordinal),
-								proxyString);
-						} finally {
-							JniObjectReference.Dispose (ref systemClass);
-						}
+						IntPtr identityHashCode = JNIEnv.GetStaticMethodID (systemClass.Handle, "identityHashCode", "(Ljava/lang/Object;)I");
+
+						Assert.AreEqual ("net/dot/jni/internal/JavaProxyObject", JNIEnv.GetClassNameFromInstance (localProxy.Handle));
+						Assert.IsTrue (JNIEnv.CallBooleanMethod (localProxy.Handle, equals, new JValue (localProxy.Handle)));
+						Assert.IsFalse (JNIEnv.CallBooleanMethod (localProxy.Handle, equals, new JValue (localOtherProxy.Handle)));
+						Assert.AreEqual (
+							JNIEnv.CallStaticIntMethod (systemClass.Handle, identityHashCode, new JValue (localProxy.Handle)),
+							JNIEnv.CallIntMethod (localProxy.Handle, hashCode));
+						var proxyString = JNIEnv.GetString (JNIEnv.CallObjectMethod (localProxy.Handle, toString), JniHandleOwnership.TransferLocalRef);
+						Assert.IsTrue (
+							proxyString.StartsWith ("net.dot.jni.internal.JavaProxyObject@", StringComparison.Ordinal),
+							proxyString);
 					} finally {
-						JNIEnv.DeleteLocalRef (proxyClass);
+						JniObjectReference.Dispose (ref systemClass);
 					}
 				} finally {
-					JniObjectReference.Dispose (ref localProxy);
-					JniObjectReference.Dispose (ref localOtherProxy);
+					JNIEnv.DeleteLocalRef (proxyClass);
 				}
 			} finally {
-				marshaler.DestroyArgumentState (other, ref otherState);
-				marshaler.DestroyArgumentState (value, ref state);
+				JniObjectReference.Dispose (ref localProxy);
+				JniObjectReference.Dispose (ref localOtherProxy);
 			}
 		}
 
 		[Test]
-		public void TryGetArrayType_PrimitiveLeaf_DoesNotRequireRankMapEntry ()
+		public void TryGetArrayProxy_ObjectLeaf_ReturnsAllRankTypes ()
+		{
+			AssumeTrimmableTypeMapEnabled ();
+
+			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayProxy (typeof (Java.Lang.Object), additionalRank: 1, out var objectArrayProxy));
+			CollectionAssert.Contains (objectArrayProxy.GetArrayTypes (), typeof (JavaObjectArray<Java.Lang.Object>));
+			CollectionAssert.Contains (objectArrayProxy.GetArrayTypes (), typeof (Java.Interop.JavaArray<Java.Lang.Object>));
+			CollectionAssert.Contains (objectArrayProxy.GetArrayTypes (), typeof (Java.Lang.Object[]));
+
+			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayProxy (typeof (Java.Lang.Object), additionalRank: 2, out var jaggedObjectArrayProxy));
+			CollectionAssert.Contains (jaggedObjectArrayProxy.GetArrayTypes (), typeof (JavaObjectArray<JavaObjectArray<Java.Lang.Object>>));
+			CollectionAssert.Contains (jaggedObjectArrayProxy.GetArrayTypes (), typeof (Java.Interop.JavaArray<Java.Lang.Object>[]));
+			CollectionAssert.Contains (jaggedObjectArrayProxy.GetArrayTypes (), typeof (Java.Lang.Object[][]));
+		}
+
+		[Test]
+		public void TryGetArrayProxy_PrimitiveLeaf_ReturnsAllRankTypes ()
 		{
 			AssumeTrimmableTypeMapEnabled ();
 
-			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayType (typeof (byte), out var byteArrayType));
-			Assert.AreEqual (typeof (byte[]), byteArrayType);
+			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayProxy (typeof (sbyte), additionalRank: 1, out var byteArrayProxy));
+			CollectionAssert.Contains (byteArrayProxy.GetArrayTypes (), typeof (sbyte[]));
+			CollectionAssert.Contains (byteArrayProxy.GetArrayTypes (), typeof (Java.Interop.JavaArray<sbyte>));
+			CollectionAssert.Contains (byteArrayProxy.GetArrayTypes (), typeof (JavaPrimitiveArray<sbyte>));
+			CollectionAssert.Contains (byteArrayProxy.GetArrayTypes (), typeof (JavaSByteArray));
 
-			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayType (typeof (byte[]), out var jaggedByteArrayType));
-			Assert.AreEqual (typeof (byte[][]), jaggedByteArrayType);
+			Assert.IsTrue (TrimmableTypeMap.Instance.TryGetArrayProxy (typeof (sbyte), additionalRank: 2, out var jaggedByteArrayProxy));
+			CollectionAssert.Contains (jaggedByteArrayProxy.GetArrayTypes (), typeof (sbyte[][]));
+			CollectionAssert.Contains (jaggedByteArrayProxy.GetArrayTypes (), typeof (JavaObjectArray<Java.Interop.JavaArray<sbyte>>));
+			CollectionAssert.Contains (jaggedByteArrayProxy.GetArrayTypes (), typeof (JavaObjectArray<JavaSByteArray>));
 		}
 
 		static ConcurrentDictionary<Type, JavaPeerProxy> GetProxyCache (TrimmableTypeMap instance)
diff --git a/tests/Mono.Android-Tests/Mono.Android-Tests/Xamarin.Android.RuntimeTests/TestInstrumentation.cs b/tests/Mono.Android-Tests/Mono.Android-Tests/Xamarin.Android.RuntimeTests/TestInstrumentation.cs
index da97716db5d..2f76e15dca3 100644
--- a/tests/Mono.Android-Tests/Mono.Android-Tests/Xamarin.Android.RuntimeTests/TestInstrumentation.cs
+++ b/tests/Mono.Android-Tests/Mono.Android-Tests/Xamarin.Android.RuntimeTests/TestInstrumentation.cs
@@ -30,6 +30,7 @@ protected override IEnumerable<string>? ExcludedCategories {
 				if (Microsoft.Android.Runtime.RuntimeFeature.TrimmableTypeMap) {
 					categories.Add ("NativeTypeMap");
 					categories.Add ("Export");
+					categories.Add ("TrimmableTypeMapUnsupported");
 				}
 
 				// Build-time flags flow in via runtimeconfig.json properties
@@ -66,35 +67,13 @@ protected override IEnumerable<string>? IncludedCategories {
 				var value = AppContext.GetData ("IncludeCategories") as string;
 				if (string.IsNullOrEmpty (value))
 					return null;
-				return value!.Split (new [] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
+				return value.Split (new [] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
 			}
 		}
 
 		static bool HasAppContextSwitch (string key)
 			=> AppContext.TryGetSwitch (key, out var value) && value;
 
-		protected override IEnumerable<string>? ExcludedTestNames {
-			get {
-				if (!Microsoft.Android.Runtime.RuntimeFeature.TrimmableTypeMap)
-					return null;
-
-				// Tests from the external Java.Interop-Tests assembly that fail under the
-				// trimmable typemap. These cannot use [Category] because we don't control
-				// that assembly — they must be excluded by name here.
-				return new [] {
-					// Known limitation: [JniAddNativeMethodRegistrationAttribute] is not
-					// supported by design under the trimmable typemap. This Java.Interop-Tests
-					// fixture uses that attribute to register native callbacks on a hand-written
-					// Java peer (an obsolete code path whose primary consumer, jnimarshalmethod-gen,
-					// was removed in dotnet/java-interop#1405). The trimmable typemap generator
-					// emits XA4251 when it encounters the attribute and instructs users to either
-					// avoid it or switch off the trimmable typemap.
-					// See https://github.com/dotnet/android/issues/11170.
-					"Java.InteropTests.InvokeVirtualFromConstructorTests",
-				};
-			}
-		}
-
 		public override void OnCreate (Bundle? arguments)
 		{
 			Java.Lang.JavaSystem.LoadLibrary ("reuse-threads");
diff --git a/tests/api-compatibility/acceptable-breakages-vReference-net11.0.txt b/tests/api-compatibility/acceptable-breakages-vReference-net11.0.txt
index 0feba3a1457..e6771e2a22e 100644
--- a/tests/api-compatibility/acceptable-breakages-vReference-net11.0.txt
+++ b/tests/api-compatibility/acceptable-breakages-vReference-net11.0.txt
@@ -1,5 +1,4 @@
 Compat issues with assembly Mono.Android:
-CannotChangeAttribute : Attribute 'System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute' on parameter 'targetType' on member 'Android.Graphics.ColorValueMarshaler.CreateGenericValue(Java.Interop.JniObjectReference, Java.Interop.JniObjectReferenceOptions, System.Type)' changed from '[DynamicallyAccessedMembersAttribute(8199)]' in the contract to '[DynamicallyAccessedMembersAttribute(7)]' in the implementation.
 CannotChangeAttribute : Attribute 'Android.Runtime.RequiresPermissionAttribute' on 'Android.Accounts.AccountManager.RemoveAccount(Android.Accounts.Account, Android.App.Activity, Android.Accounts.IAccountManagerCallback, Android.OS.Handler)' changed from '[RequiresPermissionAttribute("android.permission.MANAGE_ACCOUNTS")]' in the contract to '[RequiresPermissionAttribute("android.permission.REMOVE_ACCOUNTS")]' in the implementation.
 CannotRemoveAttribute : Attribute 'Android.Runtime.RequiresPermissionAttribute' exists on 'Android.Bluetooth.BluetoothDevice.CreateInsecureL2capChannel(System.Int32)' in the contract but not the implementation.
 CannotRemoveAttribute : Attribute 'Android.Runtime.RequiresPermissionAttribute' exists on 'Android.Bluetooth.BluetoothDevice.CreateInsecureRfcommSocketToServiceRecord(Java.Util.UUID)' in the contract but not the implementation.
@@ -48,3 +47,4 @@ MembersMustExist : Member 'public void Android.Telecom.CallControl.RequestVideoS
 TypesMustExist : Type 'Android.Text.IInputType' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'Xamarin.Android.Net.AndroidClientHandler' does not exist in the implementation but it does exist in the contract.
 CannotRemoveBaseTypeOrInterface : Type 'Android.Views.InputMethods.EditorInfo' does not implement interface 'Android.Text.IInputType' in the implementation but it does in the contract.
+CannotRemoveAttribute : Attribute 'System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute' exists on 'Java.Interop.ExportAttribute' in the contract but not the implementation.
\ No newline at end of file
diff --git a/tests/api-compatibility/api-compat-exclude-attributes.txt b/tests/api-compatibility/api-compat-exclude-attributes.txt
index bb1d43bbe88..0ca120ff8dd 100644
--- a/tests/api-compatibility/api-compat-exclude-attributes.txt
+++ b/tests/api-compatibility/api-compat-exclude-attributes.txt
@@ -16,3 +16,4 @@ T:System.Runtime.CompilerServices.IteratorStateMachineAttribute
 T:System.Runtime.CompilerServices.NullableAttribute
 T:System.Runtime.CompilerServices.NullableContextAttribute
 T:System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute
+T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute