diff --git a/build-tools/create-packs/Microsoft.Android.Sdk.TrimmableTypeMap.targets b/build-tools/create-packs/Microsoft.Android.Sdk.TrimmableTypeMap.targets
new file mode 100644
index 00000000000..2571729ab8b
--- /dev/null
+++ b/build-tools/create-packs/Microsoft.Android.Sdk.TrimmableTypeMap.targets
@@ -0,0 +1,105 @@
+<!--
+  Pre-generates the trimmable type map for Mono.Android at SDK build time (issue #10792).
+
+  App builds otherwise rescan the ~8000 Mono.Android types on every (Debug) build. Instead we
+  scan Mono.Android once here and ship the resulting _Mono.Android.TypeMap.dll (and, later, the
+  Java Callable Wrapper jar) in the SDK pack. The typemap always anchors on Java.Lang.Object
+  (ForceSharedTypemapUniverse=true) so a single artifact serves both app-build universe modes:
+  merged (Release) and aggregate (Debug). The root _Microsoft.Android.TypeMaps assembly is NOT
+  generated here (GenerateRootAssembly=false) — the app build emits it and references this
+  pre-generated typemap under Java.Lang.Object.
+-->
+<Project>
+
+  <UsingTask TaskName="Xamarin.Android.Tasks.GenerateTrimmableTypeMap" AssemblyFile="$(MicrosoftAndroidSdkOutDir)Xamarin.Android.Build.Tasks.dll" />
+
+  <PropertyGroup>
+    <_PreBuiltTypeMapPackSubDir>data\prebuilt-typemap</_PreBuiltTypeMapPackSubDir>
+    <_PreBuiltTypeMapOutputDir>$(MicrosoftAndroidSdkPackDir)$(_PreBuiltTypeMapPackSubDir)\</_PreBuiltTypeMapOutputDir>
+    <!-- Intermediate (not packaged): generated JCW .java and compiled .class files. -->
+    <_PreBuiltTypeMapIntDir>$([MSBuild]::NormalizeDirectory('$(MSBuildProjectDirectory)', 'obj', 'prebuilt-typemap'))</_PreBuiltTypeMapIntDir>
+    <_PreBuiltTypeMapJavaDir>$(_PreBuiltTypeMapIntDir)java\</_PreBuiltTypeMapJavaDir>
+    <_PreBuiltTypeMapAssembly>$(_PreBuiltTypeMapOutputDir)_Mono.Android.TypeMap.dll</_PreBuiltTypeMapAssembly>
+    <_PreBuiltTypeMapJavaInteropAssembly>$(_PreBuiltTypeMapOutputDir)_Java.Interop.TypeMap.dll</_PreBuiltTypeMapJavaInteropAssembly>
+    <_PreBuiltTypeMapAcwMap>$(_PreBuiltTypeMapOutputDir)mono.android-acw-map.txt</_PreBuiltTypeMapAcwMap>
+    <!--
+      Array-map rank baked into the pre-generated framework typemaps. This MUST match the app
+      build's effective MaxArrayRank when it consumes these artifacts, otherwise array entries land
+      in different universes (main vs __ArrayMapRank{N}) and the runtime throws BadImageFormatException.
+      The app-build value comes from _AndroidTrimmableTypeMapMaxArrayRank (see
+      Microsoft.Android.Sdk.TypeMap.Trimmable.targets), whose NativeAOT default is 3; pre-generation
+      only runs for that shape, so we hardcode the same value here.
+    -->
+    <_PreBuiltTypeMapMaxArrayRank>3</_PreBuiltTypeMapMaxArrayRank>
+  </PropertyGroup>
+
+  <Target Name="_GeneratePreBuiltMonoAndroidTypeMap"
+      BeforeTargets="ConfigureLocalWorkload;_GenerateXASdkContent"
+      Inputs="$(_MonoAndroidNETDefaultOutDir)Mono.Android.dll;$(_MonoAndroidNETDefaultOutDir)Java.Interop.dll;$(MicrosoftAndroidSdkOutDir)Xamarin.Android.Build.Tasks.dll"
+      Outputs="$(_PreBuiltTypeMapAssembly);$(_PreBuiltTypeMapJavaInteropAssembly)">
+    <ItemGroup>
+      <!-- Scan Mono.Android and Java.Interop TOGETHER so their cross-assembly aliases (e.g.
+           java/lang/Object mapped by both Java.Lang.Object and Java.Interop.JavaObject) are
+           coordinated into a single primary + aliases, instead of colliding as duplicate keys in
+           the merged Java.Lang.Object universe at runtime. -->
+      <_PreBuiltTypeMapInput Include="$(_MonoAndroidNETDefaultOutDir)Mono.Android.dll" />
+      <_PreBuiltTypeMapInput Include="$(_MonoAndroidNETDefaultOutDir)Java.Interop.dll" />
+      <!-- Reference-only framework assemblies needed to resolve base types.
+           These are NOT scanned for peers; only @(_PreBuiltTypeMapInput) is. -->
+      <_PreBuiltTypeMapFramework Include="$(_MonoAndroidNETDefaultOutDir)*.dll"
+          Exclude="@(_PreBuiltTypeMapInput)" />
+    </ItemGroup>
+    <MakeDir Directories="$(_PreBuiltTypeMapOutputDir);$(_PreBuiltTypeMapJavaDir)" />
+    <GenerateTrimmableTypeMap
+        ResolvedAssemblies="@(_PreBuiltTypeMapInput)"
+        ResolvedFrameworkAssemblies="@(_PreBuiltTypeMapFramework)"
+        FrameworkAssemblyNames="@(_PreBuiltTypeMapFramework->'%(Filename)')"
+        OutputDirectory="$(_PreBuiltTypeMapOutputDir)"
+        JavaSourceOutputDirectory="$(_PreBuiltTypeMapJavaDir)"
+        AcwMapOutputFile="$(_PreBuiltTypeMapAcwMap)"
+        TargetFrameworkVersion="v$(DotNetTargetFrameworkVersion)"
+        ForceSharedTypemapUniverse="true"
+        MaxArrayRank="$(_PreBuiltTypeMapMaxArrayRank)"
+        GenerateRootAssembly="false" />
+  </Target>
+
+  <PropertyGroup>
+    <_PreBuiltTypeMapJcwJar>$(_PreBuiltTypeMapOutputDir)mono.android-typemaps.jar</_PreBuiltTypeMapJcwJar>
+    <_PreBuiltTypeMapJcwClassesDir>$(_PreBuiltTypeMapIntDir)jcw-classes\</_PreBuiltTypeMapJcwClassesDir>
+    <_PreBuiltTypeMapJcwSourceList>$(_PreBuiltTypeMapIntDir)jcw-sources.txt</_PreBuiltTypeMapJcwSourceList>
+    <_PreBuiltTypeMapAndroidJar>$(AndroidSdkDirectory)\platforms\android-$(AndroidPlatformId)\android.jar</_PreBuiltTypeMapAndroidJar>
+    <_PreBuiltTypeMapMonoAndroidJar>$(_MonoAndroidNETDefaultOutDir)mono.android.jar</_PreBuiltTypeMapMonoAndroidJar>
+    <_PreBuiltTypeMapRuntimeJar>$(MicrosoftAndroidSdkOutDir)java_runtime.jar</_PreBuiltTypeMapRuntimeJar>
+  </PropertyGroup>
+
+  <!-- Compile the pre-generated Java Callable Wrappers into a jar shipped in the pack. The app
+       build adds this jar to its dex inputs instead of re-generating and re-compiling the
+       Mono.Android JCWs. Classpath mirrors build-tools/scripts/JavaCallableWrappers.targets:
+       android.jar + mono.android.jar + java_runtime.jar. -->
+  <Target Name="_CompilePreBuiltMonoAndroidTypeMapJcwJar"
+      BeforeTargets="ConfigureLocalWorkload;_GenerateXASdkContent"
+      DependsOnTargets="_GeneratePreBuiltMonoAndroidTypeMap"
+      Inputs="$(_PreBuiltTypeMapAssembly)"
+      Outputs="$(_PreBuiltTypeMapJcwJar)">
+    <ItemGroup>
+      <_PreBuiltTypeMapJavaFile Include="$(_PreBuiltTypeMapJavaDir)**\*.java" />
+    </ItemGroup>
+    <RemoveDir Directories="$(_PreBuiltTypeMapJcwClassesDir)" />
+    <MakeDir Directories="$(_PreBuiltTypeMapJcwClassesDir)" />
+    <WriteLinesToFile File="$(_PreBuiltTypeMapJcwSourceList)" Lines="@(_PreBuiltTypeMapJavaFile)" Overwrite="true" />
+    <Exec Command="&quot;$(JavaCPath)&quot; -source $(JavacSourceVersion) -target $(JavacTargetVersion) -nowarn -d &quot;$(_PreBuiltTypeMapJcwClassesDir.TrimEnd('\'))&quot; -classpath &quot;$(_PreBuiltTypeMapAndroidJar)&quot;$(PathSeparator)&quot;$(_PreBuiltTypeMapMonoAndroidJar)&quot;$(PathSeparator)&quot;$(_PreBuiltTypeMapRuntimeJar)&quot; @&quot;$(_PreBuiltTypeMapJcwSourceList)&quot;" />
+    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(_PreBuiltTypeMapJcwJar)&quot; -C &quot;$(_PreBuiltTypeMapJcwClassesDir.TrimEnd('\'))&quot; ." />
+  </Target>
+
+  <Target Name="_AddPreBuiltMonoAndroidTypeMapToPackage"
+      BeforeTargets="_GenerateXASdkContent"
+      DependsOnTargets="_GeneratePreBuiltMonoAndroidTypeMap;_CompilePreBuiltMonoAndroidTypeMapJcwJar">
+    <ItemGroup>
+      <_PreBuiltTypeMapAllAssemblies Include="$(_PreBuiltTypeMapOutputDir)*.TypeMap.dll" />
+      <FilesToPackage Include="@(_PreBuiltTypeMapAllAssemblies)" TargetPath="$(_PreBuiltTypeMapPackSubDir)" />
+      <FilesToPackage Include="$(_PreBuiltTypeMapJcwJar)" TargetPath="$(_PreBuiltTypeMapPackSubDir)" />
+      <FilesToPackage Include="$(_PreBuiltTypeMapAcwMap)" TargetPath="$(_PreBuiltTypeMapPackSubDir)" />
+    </ItemGroup>
+  </Target>
+
+</Project>
diff --git a/build-tools/create-packs/Microsoft.Android.Sdk.proj b/build-tools/create-packs/Microsoft.Android.Sdk.proj
index de28a81047f..71b45305b7b 100644
--- a/build-tools/create-packs/Microsoft.Android.Sdk.proj
+++ b/build-tools/create-packs/Microsoft.Android.Sdk.proj
@@ -12,6 +12,8 @@ core workload SDK packs imported by WorkloadManifest.targets.
   <Sdk Name="Microsoft.DotNet.SharedFramework.Sdk" Version="$(MicrosoftDotNetBuildTasksFeedPackageVersionNet10)" />
   <UsingTask AssemblyFile="$(BootstrapTasksAssembly)" TaskName="Xamarin.Android.Tools.BootstrapTasks.GenerateUnixFilePermissions" TaskFactory="TaskHostFactory" Runtime="NET" />
 
+  <Import Project="Microsoft.Android.Sdk.TrimmableTypeMap.targets" />
+
   <PropertyGroup>
     <!-- Use stable TFM since CI only has the stable .NET SDK installed -->
     <TargetFramework>$(DotNetStableTargetFramework)</TargetFramework>
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/AssemblyInput.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/AssemblyInput.cs
index d742d120d8c..c924746abf6 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/AssemblyInput.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/AssemblyInput.cs
@@ -2,4 +2,9 @@
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
-public readonly record struct AssemblyInput (string Name, string Path, PEReader Reader);
+/// <param name="ScanForPeers">
+/// When true (default) the assembly is scanned and its Java peers are emitted into a typemap.
+/// When false the assembly is only indexed for base-type resolution (e.g. Mono.Android on the app
+/// build, whose typemap is pre-generated at SDK build time, issue #10792) and no peers are emitted.
+/// </param>
+public readonly record struct AssemblyInput (string Name, string Path, PEReader Reader, bool ScanForPeers = true);
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
index de295c8d4a9..643f563f0b4 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/RootTypeMapAssemblyGenerator.cs
@@ -80,7 +80,16 @@ public RootTypeMapAssemblyGenerator (Version systemRuntimeVersion)
 	/// sentinels. Must match the value passed to the per-assembly generators. 0 means
 	/// no array sentinels were emitted; the loader passes <c>null</c> for array maps.
 	/// </param>
-	public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, Stream stream, string? assemblyName = null, string? moduleName = null, int maxArrayRank = 0)
+	/// <param name="sharedFrameworkTypeMapNames">
+	/// Names of pre-generated framework per-assembly typemaps (e.g. <c>_Mono.Android.TypeMap</c>,
+	/// produced at SDK build time, issue #10792) that always use <c>Java.Lang.Object</c> as their
+	/// universe anchor regardless of <paramref name="useSharedTypemapUniverse"/>. They are emitted as
+	/// <c>[assembly: TypeMapAssemblyTarget&lt;Java.Lang.Object&gt;("name")]</c> so the runtime loads
+	/// them into the <c>Java.Lang.Object</c> universe: in shared mode they merge into the single
+	/// app universe; in aggregate mode the loader adds the <c>Java.Lang.Object</c> universe alongside
+	/// the app's per-assembly universes.
+	/// </param>
+	public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, Stream stream, string? assemblyName = null, string? moduleName = null, int maxArrayRank = 0, IReadOnlyList<string>? sharedFrameworkTypeMapNames = null)
 	{
 		if (perAssemblyTypeMapNames is null) {
 			throw new ArgumentNullException (nameof (perAssemblyTypeMapNames));
@@ -125,6 +134,19 @@ public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSha
 		}
 		EmitArrayAssemblyTargetAttributes (pe, perAssemblyTypeMapNames, maxArrayRank);
 
+		// Pre-generated framework typemaps (e.g. _Mono.Android.TypeMap) always live in the
+		// Java.Lang.Object universe, so reference them under that anchor regardless of mode.
+		bool hasSharedFrameworkUniverse = sharedFrameworkTypeMapNames is { Count: > 0 };
+		if (hasSharedFrameworkUniverse) {
+			var javaLangObjectHandle = pe.Metadata.AddTypeReference (pe.MonoAndroidRef,
+				pe.Metadata.GetOrAddString ("Java.Lang"),
+				pe.Metadata.GetOrAddString ("Object"));
+			EmitSharedUniverseAssemblyTargetAttributes (pe, javaLangObjectHandle, sharedFrameworkTypeMapNames!);
+			// The pre-generated framework typemaps also emit __ArrayMapRank{N} array universes; the
+			// app-build root must reference those so framework array types resolve at runtime.
+			EmitArrayAssemblyTargetAttributes (pe, sharedFrameworkTypeMapNames!, maxArrayRank);
+		}
+
 		// Emit [assembly: IgnoresAccessChecksTo("...")] so TypeMapLoader.Initialize() can access
 		// internal types (TrimmableTypeMap and friends in Mono.Android, and private anchors
 		// in each per-assembly typemap DLL when aggregate universes or array maps are used).
@@ -135,7 +157,7 @@ public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSha
 		pe.EmitIgnoresAccessChecksToAttribute (accessTargets);
 
 		// Emit TypeMapLoader class with Initialize() method
-		EmitTypeMapLoader (pe, anchorTypeHandle, perAssemblyTypeMapNames, useSharedTypemapUniverse, maxArrayRank, assemblyName);
+		EmitTypeMapLoader (pe, anchorTypeHandle, perAssemblyTypeMapNames, useSharedTypemapUniverse, maxArrayRank, assemblyName, hasSharedFrameworkUniverse);
 
 		pe.WritePE (stream);
 	}
@@ -201,7 +223,7 @@ static void EmitAssemblyTargetAttribute (PEAssemblyBuilder pe, MemberReferenceHa
 		pe.Metadata.AddCustomAttribute (EntityHandle.AssemblyDefinition, ctorRef, blobHandle);
 	}
 
-	static void EmitTypeMapLoader (PEAssemblyBuilder pe, EntityHandle anchorTypeHandle, IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, int maxArrayRank, string assemblyName)
+	static void EmitTypeMapLoader (PEAssemblyBuilder pe, EntityHandle anchorTypeHandle, IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, int maxArrayRank, string assemblyName, bool hasSharedFrameworkUniverse = false)
 	{
 		var metadata = pe.Metadata;
 
@@ -240,6 +262,9 @@ static void EmitTypeMapLoader (PEAssemblyBuilder pe, EntityHandle anchorTypeHand
 		var externalDictArrayTypeSpec = MakeIReadOnlyDictArrayTypeSpec (pe, iReadOnlyDictOpenRef, systemTypeRef, keyIsString: true);
 
 		if (useSharedTypemapUniverse) {
+			// Single Java.Lang.Object universe. Pre-generated framework typemaps (if any) also
+			// anchor on Java.Lang.Object, so GetOrCreateExternalTypeMapping<Java.Lang.Object>()
+			// already merges them in via their TypeMapAssemblyTarget attributes — no extra universe.
 			if (maxArrayRank > 0) {
 				var initializeRef = AddInitializeSingleWithArraysRef (pe, trimmableTypeMapRef, iReadOnlyDictOpenRef, systemTypeRef);
 				EmitInitializeWithSingleTypeMap (pe, anchorTypeHandle, getExternalMemberRef, getProxyMemberRef,
@@ -251,13 +276,21 @@ static void EmitTypeMapLoader (PEAssemblyBuilder pe, EntityHandle anchorTypeHand
 		} else {
 			var proxyDictTypeSpec = MakeIReadOnlyDictTypeSpec (pe, iReadOnlyDictOpenRef, systemTypeRef, keyIsString: false);
 			if (maxArrayRank > 0) {
+				if (hasSharedFrameworkUniverse) {
+					// Debug + array maps (NativeAOT) combined with a pre-generated shared framework
+					// universe is not yet wired: the array-map aggregation is built per-assembly and
+					// would need an extra Java.Lang.Object array-map slot. Tracked by
+					// https://github.com/dotnet/android/issues/12128. The app build avoids reaching
+					// here by falling back to scanning the framework assemblies for this combination.
+					throw new NotSupportedException ("Pre-generated framework typemaps are not yet supported together with aggregate array maps (maxArrayRank > 0). See https://github.com/dotnet/android/issues/12128.");
+				}
 				var initializeRef = AddInitializeAggregateWithArraysRef (pe, trimmableTypeMapRef, iReadOnlyDictOpenRef, systemTypeRef);
 				EmitInitializeWithAggregateTypeMap (pe, perAssemblyTypeMapNames, getExternalMemberRef, getProxyMemberRef,
 					initializeRef, externalDictTypeSpec, proxyDictTypeSpec, externalDictArrayTypeSpec, iReadOnlyDictOpenRef, systemTypeRef, maxArrayRank, assemblyName);
 			} else {
 				var initializeRef = AddInitializeAggregateNoArraysRef (pe, trimmableTypeMapRef, iReadOnlyDictOpenRef, systemTypeRef);
 				EmitInitializeWithAggregateTypeMapNoArrays (pe, perAssemblyTypeMapNames, getExternalMemberRef, getProxyMemberRef,
-					initializeRef, externalDictTypeSpec, proxyDictTypeSpec, iReadOnlyDictOpenRef, systemTypeRef, assemblyName);
+					initializeRef, externalDictTypeSpec, proxyDictTypeSpec, iReadOnlyDictOpenRef, systemTypeRef, assemblyName, hasSharedFrameworkUniverse);
 			}
 		}
 	}
@@ -348,18 +381,30 @@ static void EmitInitializeWithAggregateTypeMapNoArrays (PEAssemblyBuilder pe,
 		MemberReferenceHandle initializeRef,
 		TypeSpecificationHandle externalDictTypeSpec, TypeSpecificationHandle proxyDictTypeSpec,
 		TypeReferenceHandle iReadOnlyDictOpenRef, TypeReferenceHandle systemTypeRef,
-		string assemblyName)
+		string assemblyName,
+		bool hasSharedFrameworkUniverse = false)
 	{
-		var count = perAssemblyTypeMapNames.Count;
+		// When a pre-generated framework typemap is present (e.g. _Mono.Android.TypeMap), it lives in
+		// the Java.Lang.Object universe. Emit it as universe [0] (via
+		// GetOrCreate*TypeMapping<Java.Lang.Object>()), followed by the app's per-assembly universes.
+		var count = perAssemblyTypeMapNames.Count + (hasSharedFrameworkUniverse ? 1 : 0);
 
 		var getExternalSpecs = new EntityHandle [count];
 		var getProxySpecs = new EntityHandle [count];
-		for (int i = 0; i < count; i++) {
+		int offset = 0;
+		if (hasSharedFrameworkUniverse) {
+			var javaLangObjectRef = pe.Metadata.AddTypeReference (pe.MonoAndroidRef,
+				pe.Metadata.GetOrAddString ("Java.Lang"), pe.Metadata.GetOrAddString ("Object"));
+			getExternalSpecs [0] = MakeGenericMethodSpec (pe, getExternalMemberRef, javaLangObjectRef);
+			getProxySpecs [0] = MakeGenericMethodSpec (pe, getProxyMemberRef, javaLangObjectRef);
+			offset = 1;
+		}
+		for (int i = 0; i < perAssemblyTypeMapNames.Count; i++) {
 			var asmRef = pe.FindOrAddAssemblyRef (perAssemblyTypeMapNames [i]);
 			var perAsmAnchorRef = pe.Metadata.AddTypeReference (asmRef,
 				default, pe.Metadata.GetOrAddString ("__TypeMapAnchor"));
-			getExternalSpecs [i] = MakeGenericMethodSpec (pe, getExternalMemberRef, perAsmAnchorRef);
-			getProxySpecs [i] = MakeGenericMethodSpec (pe, getProxyMemberRef, perAsmAnchorRef);
+			getExternalSpecs [offset + i] = MakeGenericMethodSpec (pe, getExternalMemberRef, perAsmAnchorRef);
+			getProxySpecs [offset + i] = MakeGenericMethodSpec (pe, getProxyMemberRef, perAsmAnchorRef);
 		}
 
 		pe.EmitBody ("Initialize",
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
index f239f509f54..e88c234e2b4 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs
@@ -173,9 +173,15 @@ public List<JavaPeerInfo> Scan (IReadOnlyList<(string Name, PEReader Reader)> as
 
 	public List<JavaPeerInfo> Scan (IEnumerable<AssemblyInput> assemblies)
 	{
+		// Reference-only assemblies (ScanForPeers == false) are indexed so base-type resolution
+		// works, but are not scanned for peer emission (their typemap is pre-generated elsewhere).
+		var referenceOnlyAssemblyNames = new HashSet<string> (StringComparer.Ordinal);
 		foreach (var assembly in assemblies) {
 			var index = AssemblyIndex.Create (assembly.Reader, assembly.Name, assembly.Path);
 			assemblyCache [index.AssemblyName] = index;
+			if (!assembly.ScanForPeers) {
+				referenceOnlyAssemblyNames.Add (index.AssemblyName);
+			}
 		}
 
 		// Key by (managedTypeName, assemblyName) to avoid collisions when two assemblies
@@ -183,6 +189,9 @@ public List<JavaPeerInfo> Scan (IEnumerable<AssemblyInput> assemblies)
 		// Java.Interop and Mono.Android).
 		var resultsByQualifiedName = new Dictionary<(string ManagedName, string AssemblyName), JavaPeerInfo> ();
 		foreach (var index in assemblyCache.Values) {
+			if (referenceOnlyAssemblyNames.Contains (index.AssemblyName)) {
+				continue;
+			}
 			ScanAssembly (index, resultsByQualifiedName);
 		}
 		ForceUnconditionalCrossReferences (resultsByQualifiedName, assemblyCache);
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
index fee0811ebc4..ae0b917d0a6 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
@@ -35,7 +35,9 @@ public TrimmableTypeMapResult Execute (
 		XDocument? manifestTemplate = null,
 		string? packageNamingPolicy = null,
 		int maxArrayRank = 0,
-		bool generateTypeMapAssemblies = true)
+		bool generateTypeMapAssemblies = true,
+		bool generateRootAssembly = true,
+		IReadOnlyList<string>? sharedFrameworkTypeMapNames = null)
 	{
 		_ = assemblies ?? throw new ArgumentNullException (nameof (assemblies));
 		_ = systemRuntimeVersion ?? throw new ArgumentNullException (nameof (systemRuntimeVersion));
@@ -56,7 +58,7 @@ public TrimmableTypeMapResult Execute (
 		PropagateCannotRegisterToDescendants (allPeers);
 
 		var generatedAssemblies = generateTypeMapAssemblies
-			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank)
+			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank, generateRootAssembly, sharedFrameworkTypeMapNames)
 			: [];
 		var jcwPeers = allPeers.Where (ShouldGenerateJcw).ToList ();
 		logger.LogGeneratingJcwFilesInfo (jcwPeers.Count, allPeers.Count);
@@ -179,7 +181,9 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (
 		List<JavaPeerInfo> allPeers,
 		Version systemRuntimeVersion,
 		bool useSharedTypemapUniverse,
-		int maxArrayRank)
+		int maxArrayRank,
+		bool generateRootAssembly = true,
+		IReadOnlyList<string>? sharedFrameworkTypeMapNames = null)
 	{
 		List<(string AssemblyName, List<JavaPeerInfo> Peers)> peersByAssembly;
 
@@ -213,12 +217,20 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (
 			generatedAssemblies.Add (new GeneratedAssembly (typeMapAssemblyName, stream));
 			logger.LogGeneratedTypeMapAssemblyInfo (typeMapAssemblyName, peers.Count);
 		}
-		var rootStream = new MemoryStream ();
-		var rootGenerator = new RootTypeMapAssemblyGenerator (systemRuntimeVersion);
-		rootGenerator.Generate (perAssemblyNames, useSharedTypemapUniverse, rootStream, maxArrayRank: maxArrayRank);
-		rootStream.Position = 0;
-		generatedAssemblies.Add (new GeneratedAssembly ("_Microsoft.Android.TypeMaps", rootStream));
-		logger.LogGeneratedRootTypeMapInfo (perAssemblyNames.Count);
+		// The root assembly (_Microsoft.Android.TypeMaps) carries the
+		// [assembly: TypeMapAssemblyTarget<T>] attributes and TypeMapLoader.Initialize() that
+		// bind the per-assembly typemaps into universes at runtime. When pre-generating a
+		// framework typemap (e.g. Mono.Android) at SDK build time, the root is intentionally
+		// skipped: it is emitted by the app build, which references the pre-generated per-assembly
+		// typemap alongside the app's own.
+		if (generateRootAssembly) {
+			var rootStream = new MemoryStream ();
+			var rootGenerator = new RootTypeMapAssemblyGenerator (systemRuntimeVersion);
+			rootGenerator.Generate (perAssemblyNames, useSharedTypemapUniverse, rootStream, maxArrayRank: maxArrayRank, sharedFrameworkTypeMapNames: sharedFrameworkTypeMapNames);
+			rootStream.Position = 0;
+			generatedAssemblies.Add (new GeneratedAssembly ("_Microsoft.Android.TypeMaps", rootStream));
+			logger.LogGeneratedRootTypeMapInfo (perAssemblyNames.Count);
+		}
 		logger.LogGeneratedTypeMapAssembliesInfo (generatedAssemblies.Count);
 		return generatedAssemblies;
 	}
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.NativeAOT.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.NativeAOT.targets
index 2d1201e2cfc..808cdb7b588 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.NativeAOT.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.NativeAOT.targets
@@ -197,14 +197,40 @@
     </ItemGroup>
   </Target>
 
+  <!-- When the pre-generated Mono.Android typemap is used, Mono.Android is excluded from the app
+       scan so its ACW entries are missing from acw-map.txt. Build a SEPARATE merged map (app map +
+       pre-built mono.android-acw-map.txt) for the keep-rule generator, so R8 keeps the pre-built
+       JCWs instead of shrinking them out of classes.dex. Regenerated wholesale (Overwrite="true")
+       from both inputs each time they change — never appended in place — so it is deterministic and
+       leaves the app's acw-map.txt untouched. -->
+  <Target Name="_MergePreGeneratedMonoAndroidAcwMapForKeepRules"
+      Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' and '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
+      Inputs="$(IntermediateOutputPath)acw-map.txt;$(_PreGeneratedMonoAndroidTypeMapAcwMap)"
+      Outputs="$(_TrimmableTypeMapKeepRulesAcwMapFile)">
+    <ReadLinesFromFile File="$(IntermediateOutputPath)acw-map.txt">
+      <Output TaskParameter="Lines" ItemName="_MergedKeepRulesAcwMapLines" />
+    </ReadLinesFromFile>
+    <ReadLinesFromFile File="$(_PreGeneratedMonoAndroidTypeMapAcwMap)" Condition=" Exists('$(_PreGeneratedMonoAndroidTypeMapAcwMap)') ">
+      <Output TaskParameter="Lines" ItemName="_MergedKeepRulesAcwMapLines" />
+    </ReadLinesFromFile>
+    <WriteLinesToFile
+        File="$(_TrimmableTypeMapKeepRulesAcwMapFile)"
+        Lines="@(_MergedKeepRulesAcwMapLines)"
+        Overwrite="true"
+        WriteOnlyWhenDifferent="true" />
+    <ItemGroup>
+      <FileWrites Include="$(_TrimmableTypeMapKeepRulesAcwMapFile)" />
+    </ItemGroup>
+  </Target>
+
   <Target Name="_GenerateTrimmableTypeMapProguardConfiguration"
-      DependsOnTargets="_WriteTrimmableNativeAotProguardConfigurationInputs;_CollectTrimmableNativeAotDgmlFiles"
+      DependsOnTargets="_WriteTrimmableNativeAotProguardConfigurationInputs;_CollectTrimmableNativeAotDgmlFiles;_MergePreGeneratedMonoAndroidAcwMapForKeepRules"
       Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
-      Inputs="$(_TrimmableNativeAotProguardConfigurationInputsStamp);@(_TrimmableNativeAotDgmlFiles);$(IntermediateOutputPath)acw-map.txt"
+      Inputs="$(_TrimmableNativeAotProguardConfigurationInputsStamp);@(_TrimmableNativeAotDgmlFiles);$(_TrimmableTypeMapKeepRulesAcwMapFile)"
       Outputs="$(_ProguardProjectConfiguration)">
     <GenerateNativeAotProguardConfiguration
         NativeAotDgmlFiles="@(_TrimmableNativeAotDgmlFiles)"
-        AcwMapFile="$(IntermediateOutputPath)acw-map.txt"
+        AcwMapFile="$(_TrimmableTypeMapKeepRulesAcwMapFile)"
         TrimJavaCallableWrappers="$(_AndroidTrimmableTypemapTrimJavaCode)"
         OutputFile="$(_ProguardProjectConfiguration)" />
     <ItemGroup>
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 b66b2e0208d..46169402a2e 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
@@ -61,6 +61,32 @@
     </IncrementalCleanDependsOn>
   </PropertyGroup>
 
+  <!-- Pre-generated Mono.Android typemap shipped in the SDK pack (issue #10792). When present,
+       the app build skips scanning Mono.Android (its ~8000 types) and instead references the
+       pre-built _Mono.Android.TypeMap.dll (Java.Lang.Object universe) + dexes the pre-compiled
+       JCW jar. Opt out with $(_AndroidUsePreGeneratedMonoAndroidTypeMap)=false. -->
+  <PropertyGroup>
+    <_PreGeneratedTypeMapDir>$([MSBuild]::NormalizeDirectory('$(MSBuildThisFileDirectory)..\data\prebuilt-typemap'))</_PreGeneratedTypeMapDir>
+    <_PreGeneratedMonoAndroidTypeMapAssembly>$(_PreGeneratedTypeMapDir)_Mono.Android.TypeMap.dll</_PreGeneratedMonoAndroidTypeMapAssembly>
+    <_PreGeneratedMonoAndroidTypeMapJar>$(_PreGeneratedTypeMapDir)mono.android-typemaps.jar</_PreGeneratedMonoAndroidTypeMapJar>
+    <_PreGeneratedMonoAndroidTypeMapAcwMap>$(_PreGeneratedTypeMapDir)mono.android-acw-map.txt</_PreGeneratedMonoAndroidTypeMapAcwMap>
+    <_AndroidUsePreGeneratedMonoAndroidTypeMap Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == '' and Exists('$(_PreGeneratedMonoAndroidTypeMapAssembly)') ">true</_AndroidUsePreGeneratedMonoAndroidTypeMap>
+    <_AndroidUsePreGeneratedMonoAndroidTypeMap Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == '' ">false</_AndroidUsePreGeneratedMonoAndroidTypeMap>
+    <!-- Debug + array maps (aggregate universe with maxArrayRank > 0, i.e. Debug NativeAOT) is not
+         yet supported for pre-generated framework typemaps; fall back to scanning normally so the
+         build still succeeds (without the pre-generation speedup) instead of failing. Tracked by
+         https://github.com/dotnet/android/issues/12128. -->
+    <_AndroidUsePreGeneratedMonoAndroidTypeMap Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' and '$(AndroidIncludeDebugSymbols)' == 'true' and '$(_AndroidTrimmableTypeMapMaxArrayRank)' != '0' ">false</_AndroidUsePreGeneratedMonoAndroidTypeMap>
+    <!-- ACW map fed to the R8/proguard keep-rule generation. Normally this is the app's own
+         acw-map.txt. When the pre-generated Mono.Android typemap is used, Mono.Android is excluded
+         from the app scan, so its ACW entries are absent from acw-map.txt; the keep rules must
+         instead read a merge of the app map and the pre-built mono.android-acw-map.txt. We write
+         that merge to a SEPARATE file (rather than appending to acw-map.txt) so the app's acw-map.txt
+         stays byte-stable across builds and its own incremental checks keep working. -->
+    <_TrimmableTypeMapKeepRulesAcwMapFile>$(IntermediateOutputPath)acw-map.txt</_TrimmableTypeMapKeepRulesAcwMapFile>
+    <_TrimmableTypeMapKeepRulesAcwMapFile Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' ">$(IntermediateOutputPath)acw-map.prebuilt-merged.txt</_TrimmableTypeMapKeepRulesAcwMapFile>
+  </PropertyGroup>
+
   <ItemGroup>
     <RuntimeHostConfigurationOption Include="Microsoft.Android.Runtime.RuntimeFeature.TrimmableTypeMap"
         Value="true" Trim="true" />
@@ -127,12 +153,23 @@
       <!-- Library (.aar) manifests to merge into the app manifest. Only on the legacy manifest
            merger path; manifestmerger.jar merges these downstream in the _ManifestMerger target. -->
       <_MergedManifestDocuments Condition=" '$(AndroidManifestMerger)' == 'legacy' " Include="@(ExtractedManifestDocuments)" />
+
+      <!-- When a pre-generated framework typemap set is shipped, index Mono.Android and Java.Interop
+           for resolution but don't rescan them: pass them as pre-generated assemblies so the generated
+           root references the shipped _Mono.Android.TypeMap / _Java.Interop.TypeMap under
+           Java.Lang.Object instead. Both are pre-generated together so their cross-assembly aliases
+           (e.g. java/lang/Object) are coordinated rather than colliding in the merged universe. -->
+      <_PreGeneratedTypeMapAssemblyInput Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' "
+          Include="@(_TypeMapInputAssemblies)" KeepDuplicates="false" />
+      <_PreGeneratedTypeMapAssemblyInput Remove="@(_PreGeneratedTypeMapAssemblyInput)"
+          Condition=" '%(Filename)' != 'Mono.Android' and '%(Filename)' != 'Java.Interop' " />
     </ItemGroup>
 
     <GenerateTrimmableTypeMap
         ResolvedAssemblies="@(_TypeMapInputAssemblies)"
         ResolvedFrameworkAssemblies="@(_TypeMapFrameworkAssemblies)"
         FrameworkAssemblyNames="@(_TypeMapFrameworkAssemblies->'%(Filename)')"
+        PreGeneratedTypeMapAssemblies="@(_PreGeneratedTypeMapAssemblyInput)"
         OutputDirectory="$(_TypeMapOutputDirectory)"
         JavaSourceOutputDirectory="$(_TypeMapJavaOutputDirectory)"
         TargetFrameworkVersion="$(TargetFrameworkVersion)"
@@ -211,8 +248,19 @@
     <ReadLinesFromFile File="$(_TypeMapAssembliesListFile)">
       <Output TaskParameter="Lines" ItemName="_GeneratedTypeMapAssembliesFromList" />
     </ReadLinesFromFile>
+    <!-- Include the pre-generated framework typemaps (Mono.Android + Java.Interop) so they are
+         linked/published and loadable at runtime (the generated root references them via
+         TypeMapAssemblyTarget<Java.Lang.Object>). -->
+    <ItemGroup Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' ">
+      <_GeneratedTypeMapAssembliesFromList Include="$(_PreGeneratedTypeMapDir)*.TypeMap.dll" />
+    </ItemGroup>
   </Target>
 
+  <!-- Dex the pre-compiled Mono.Android JCW jar instead of regenerating/compiling those JCWs. -->
+  <ItemGroup Condition=" '$(_AndroidUsePreGeneratedMonoAndroidTypeMap)' == 'true' ">
+    <AndroidJavaLibrary Include="$(_PreGeneratedMonoAndroidTypeMapJar)" />
+  </ItemGroup>
+
   <!--
     The TypeMap generator has dynamic outputs: the set of generated assemblies
     and Java files comes from scanning references.  FileWrites entries in the
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index b1dcd144167..119721eb4e9 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -113,6 +113,24 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	public string? CheckedBuild { get; set; }
 	public string? ApplicationJavaClass { get; set; }
 	public bool GenerateTypeMapAssemblies { get; set; } = true;
+
+	// When false, the per-assembly typemap DLLs (and JCWs) are emitted but the root
+	// _Microsoft.Android.TypeMaps assembly is not. Used for SDK-build-time pre-generation of
+	// framework typemaps (e.g. Mono.Android, issue #10792); the app build emits the root, which
+	// references the pre-generated per-assembly typemaps alongside the app's own.
+	public bool GenerateRootAssembly { get; set; } = true;
+
+	// When true, forces the shared (Java.Lang.Object) typemap universe regardless of Debug.
+	// Set for SDK-build-time pre-generation of framework typemaps (issue #10792) so they always
+	// anchor on Java.Lang.Object and can be consumed by both app-build universe modes.
+	public bool ForceSharedTypemapUniverse { get; set; }
+
+	// Framework assemblies whose typemap is pre-generated at SDK build time (issue #10792), e.g.
+	// Mono.Android. On the app build these are indexed for base-type resolution but NOT scanned for
+	// peers; instead their pre-generated per-assembly typemap (_<Name>.TypeMap) is referenced by the
+	// generated root assembly under the Java.Lang.Object universe.
+	public ITaskItem [] PreGeneratedTypeMapAssemblies { get; set; } = [];
+
 	public bool CleanJavaSourceOutputDirectory { get; set; }
 
 	[Output]
@@ -130,11 +148,21 @@ public override bool RunTask ()
 		var frameworkAssemblyPaths = new HashSet<string> (
 			ResolvedFrameworkAssemblies.Select (i => Path.GetFullPath (i.ItemSpec)),
 			StringComparer.OrdinalIgnoreCase);
+		// Assemblies whose typemap is pre-generated: index them for resolution but don't scan for
+		// peers, and reference their pre-generated _<Name>.TypeMap from the root under Java.Lang.Object.
+		var preGeneratedAssemblyPaths = new HashSet<string> (
+			PreGeneratedTypeMapAssemblies.Select (i => Path.GetFullPath (i.ItemSpec)),
+			StringComparer.OrdinalIgnoreCase);
+		var sharedFrameworkTypeMapNames = PreGeneratedTypeMapAssemblies
+			.Select (i => $"_{Path.GetFileNameWithoutExtension (i.ItemSpec)}.TypeMap")
+			.Distinct (StringComparer.Ordinal)
+			.ToList ();
 		var assemblyInputs = ResolvedAssemblies
 			.GroupBy (i => Path.GetFullPath (i.ItemSpec), StringComparer.OrdinalIgnoreCase)
 			.Select (g => (
 				Path: g.Key,
-				IsFrameworkAssembly: frameworkAssemblyPaths.Contains (g.Key) || g.Any (IsFrameworkAssemblyItem)))
+				IsFrameworkAssembly: frameworkAssemblyPaths.Contains (g.Key) || g.Any (IsFrameworkAssemblyItem),
+				ScanForPeers: !preGeneratedAssemblyPaths.Contains (g.Key)))
 			.ToList ();
 		var frameworkAssemblyNames = new HashSet<string> (DefaultFrameworkAssemblyNames, StringComparer.OrdinalIgnoreCase);
 		foreach (var assemblyName in FrameworkAssemblyNames) {
@@ -169,12 +197,12 @@ public override bool RunTask ()
 		var assemblies = new List<AssemblyInput> ();
 		TrimmableTypeMapResult? result = null;
 		try {
-			foreach (var (path, isFrameworkAssembly) in assemblyInputs) {
+			foreach (var (path, isFrameworkAssembly, scanForPeers) in assemblyInputs) {
 				var peReader = new PEReader (File.OpenRead (path));
 				peReaders.Add (peReader);
 				var mdReader = peReader.GetMetadataReader ();
 				var assemblyName = mdReader.GetString (mdReader.GetAssemblyDefinition ().Name);
-				assemblies.Add (new AssemblyInput (assemblyName, path, peReader));
+				assemblies.Add (new AssemblyInput (assemblyName, path, peReader, scanForPeers));
 				if (isFrameworkAssembly) {
 					frameworkAssemblyNames.Add (assemblyName);
 				}
@@ -210,12 +238,14 @@ public override bool RunTask ()
 				assemblies,
 				systemRuntimeVersion,
 				frameworkAssemblyNames,
-				useSharedTypemapUniverse: !Debug,
+				useSharedTypemapUniverse: ForceSharedTypemapUniverse || !Debug,
 				manifestConfig: manifestConfig,
 				manifestTemplate: manifestTemplate,
 				packageNamingPolicy: PackageNamingPolicy,
 				maxArrayRank: MaxArrayRank,
-				generateTypeMapAssemblies: GenerateTypeMapAssemblies);
+				generateTypeMapAssemblies: GenerateTypeMapAssemblies,
+				generateRootAssembly: GenerateRootAssembly,
+				sharedFrameworkTypeMapNames: sharedFrameworkTypeMapNames);
 
 			if (GenerateTypeMapAssemblies) {
 				GeneratedAssemblies = WriteAssembliesToDisk (result.GeneratedAssemblies, assemblyInputs.Select (i => i.Path).ToList ());
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/RootTypeMapAssemblyGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/RootTypeMapAssemblyGeneratorTests.cs
index 2ad242d096a..b0eda710196 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/RootTypeMapAssemblyGeneratorTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/RootTypeMapAssemblyGeneratorTests.cs
@@ -12,11 +12,11 @@ namespace Microsoft.Android.Sdk.TrimmableTypeMap.Tests;
 public class RootTypeMapAssemblyGeneratorTests : FixtureTestBase
 {
 
-	static MemoryStream GenerateRootAssembly (IReadOnlyList<string> perAssemblyNames, bool useSharedTypemapUniverse = false, string? assemblyName = null, int maxArrayRank = 0)
+	static MemoryStream GenerateRootAssembly (IReadOnlyList<string> perAssemblyNames, bool useSharedTypemapUniverse = false, string? assemblyName = null, int maxArrayRank = 0, IReadOnlyList<string>? sharedFrameworkTypeMapNames = null)
 	{
 		var stream = new MemoryStream ();
 		var generator = new RootTypeMapAssemblyGenerator (new Version (11, 0, 0, 0));
-		generator.Generate (perAssemblyNames, useSharedTypemapUniverse, stream, assemblyName, maxArrayRank: maxArrayRank);
+		generator.Generate (perAssemblyNames, useSharedTypemapUniverse, stream, assemblyName, maxArrayRank: maxArrayRank, sharedFrameworkTypeMapNames: sharedFrameworkTypeMapNames);
 		stream.Position = 0;
 		return stream;
 	}
@@ -180,6 +180,58 @@ public void Generate_MergedMode_TargetAttributesUseSharedAnchor ()
 		}, targetAttributes);
 	}
 
+	// Issue #10792: a pre-generated framework typemap (e.g. _Mono.Android.TypeMap, built at SDK
+	// build time) always uses Java.Lang.Object as its universe anchor. The root must reference it
+	// under that anchor (resolution scope "Mono.Android") regardless of the app's universe mode.
+
+	[Fact]
+	public void Generate_MergedMode_SharedFrameworkTypeMap_ReferencedUnderJavaLangObject ()
+	{
+		using var stream = GenerateRootAssembly (
+			[ "_App.TypeMap" ],
+			useSharedTypemapUniverse: true,
+			sharedFrameworkTypeMapNames: [ "_Mono.Android.TypeMap" ]);
+		using var pe = new PEReader (stream);
+		var reader = pe.GetMetadataReader ();
+
+		var targetAttributes = GetTypeMapAssemblyTargetAttributeTargets (reader);
+
+		// Both the app typemap (shared mode) and the framework typemap anchor on Java.Lang.Object.
+		Assert.Contains (("_App.TypeMap", "Mono.Android"), targetAttributes);
+		Assert.Contains (("_Mono.Android.TypeMap", "Mono.Android"), targetAttributes);
+	}
+
+	[Fact]
+	public void Generate_AggregateMode_SharedFrameworkTypeMap_AppUsesOwnAnchorFrameworkUsesJavaLangObject ()
+	{
+		using var stream = GenerateRootAssembly (
+			[ "_App.TypeMap" ],
+			useSharedTypemapUniverse: false,
+			sharedFrameworkTypeMapNames: [ "_Mono.Android.TypeMap" ]);
+		using var pe = new PEReader (stream);
+		var reader = pe.GetMetadataReader ();
+
+		var targetAttributes = GetTypeMapAssemblyTargetAttributeTargets (reader);
+
+		// App typemap keeps its own per-assembly __TypeMapAnchor universe; the pre-generated
+		// framework typemap is referenced under Java.Lang.Object (scope "Mono.Android").
+		Assert.Contains (("_App.TypeMap", "_App.TypeMap"), targetAttributes);
+		Assert.Contains (("_Mono.Android.TypeMap", "Mono.Android"), targetAttributes);
+	}
+
+	[Theory]
+	[InlineData (true)]
+	[InlineData (false)]
+	public void Generate_WithSharedFrameworkTypeMap_ProducesValidPE (bool useSharedTypemapUniverse)
+	{
+		using var stream = GenerateRootAssembly (
+			[ "_App.TypeMap" ],
+			useSharedTypemapUniverse,
+			sharedFrameworkTypeMapNames: [ "_Mono.Android.TypeMap" ]);
+		using var pe = new PEReader (stream);
+		Assert.True (pe.HasMetadata);
+	}
+
 	[Theory]
 	[InlineData (true)]
 	[InlineData (false)]
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
index fb9829ca648..424b05cda09 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs
@@ -89,6 +89,42 @@ public void Execute_WithTestFixtures_ProducesOutputs ()
 		Assert.Contains (result.GeneratedAssemblies, a => a.Name == "_TestFixtures.TypeMap");
 	}
 
+	[Fact]
+	public void Execute_WithGenerateRootAssemblyFalse_EmitsPerAssemblyTypeMapButNoRoot ()
+	{
+		// SDK-time pre-generation (issue #10792) emits only the per-assembly typemap (and JCWs)
+		// for a framework assembly; the root _Microsoft.Android.TypeMaps is emitted by the app
+		// build, which references the pre-generated per-assembly typemap alongside its own.
+		using var peReader = CreateTestFixturePEReader ();
+		var result = CreateGenerator ().Execute (
+			[Input ("TestFixtures", peReader)],
+			new Version (11, 0),
+			new HashSet<string> (),
+			generateRootAssembly: false);
+
+		Assert.Contains (result.GeneratedAssemblies, a => a.Name == "_TestFixtures.TypeMap");
+		Assert.DoesNotContain (result.GeneratedAssemblies, a => a.Name == "_Microsoft.Android.TypeMaps");
+		// JCWs are still produced so they can be pre-compiled into a jar shipped in the SDK pack.
+		Assert.NotEmpty (result.GeneratedJavaSources);
+	}
+
+	[Fact]
+	public void Execute_ReferenceOnlyAssembly_EmitsNoPeers ()
+	{
+		// A reference-only assembly (ScanForPeers: false) is indexed for base-type resolution but
+		// its peers are not emitted — used on the app build for Mono.Android, whose typemap is
+		// pre-generated at SDK build time (issue #10792).
+		using var peReader = CreateTestFixturePEReader ();
+		var result = CreateGenerator ().Execute (
+			[new AssemblyInput ("TestFixtures", "", peReader, ScanForPeers: false)],
+			new Version (11, 0),
+			new HashSet<string> ());
+
+		Assert.Empty (result.GeneratedAssemblies);
+		Assert.Empty (result.GeneratedJavaSources);
+		Assert.DoesNotContain (result.GeneratedAssemblies, a => a.Name == "_TestFixtures.TypeMap");
+	}
+
 	[Fact]
 	public void Execute_CollectsDeferredRegistrationTypes_ForAllApplicationAndInstrumentationSubtypes ()
 	{