diff --git a/Editor/Obfuz.Editor.asmdef b/Editor/Obfuz.Editor.asmdef
index a140070..910467f 100644
--- a/Editor/Obfuz.Editor.asmdef
+++ b/Editor/Obfuz.Editor.asmdef
@@ -2,8 +2,7 @@
     "name": "Obfuz",
     "rootNamespace": "",
     "references": [
-        "GUID:167b4b7f91c16bb4183f7298af665076",
-        "GUID:d6548fbf155e392419f0f6a6dcf078d9"
+        "GUID:167b4b7f91c16bb4183f7298af665076"
     ],
     "includePlatforms": [
         "Editor"
diff --git a/Editor/Rename/RenameRecordMap.cs b/Editor/Rename/RenameRecordMap.cs
index c5d5cd8..e3da935 100644
--- a/Editor/Rename/RenameRecordMap.cs
+++ b/Editor/Rename/RenameRecordMap.cs
@@ -2,6 +2,7 @@ using dnlib.DotNet;
 using Obfuz.Rename;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Xml;
 using System.Xml.Linq;
@@ -413,6 +414,22 @@ namespace Obfuz
                 }
                 root.AppendChild(assemblyNode);
             }
+            foreach (RenameMappingAssembly ass in _assemblies.Values)
+            {
+                if (_modRenames.Keys.Any(m => m.Assembly.Name == ass.oldAssName))
+                {
+                    continue;
+                }
+                var assemblyNode = doc.CreateElement("assembly");
+                assemblyNode.SetAttribute("name", ass.oldAssName);
+                assemblyNode.SetAttribute("newName", ass.status == RenameStatus.Renamed ? ass.newAssName : "");
+                assemblyNode.SetAttribute("status", ass.status.ToString());
+                foreach (var e in ass.types)
+                {
+                    WriteTypeMapping(assemblyNode, e.Key, e.Value);
+                }
+                root.AppendChild(assemblyNode);
+            }
             doc.Save(_mappingFile);
             Debug.Log($"Mapping file saved to {Path.GetFullPath(_mappingFile)}");
         }
@@ -447,6 +464,37 @@ namespace Obfuz
             }
         }
 
+
+
+        private void WriteTypeMapping(XmlElement assNode, string fullName, RenameMappingType type)
+        {
+            var typeNode = assNode.OwnerDocument.CreateElement("type");
+            typeNode.SetAttribute("fullName", fullName);
+            typeNode.SetAttribute("newFullName", type.status == RenameStatus.Renamed ? type.newFullName : "");
+            typeNode.SetAttribute("status", type.status.ToString());
+
+            foreach (var e in type.fields)
+            {
+                string signature = e.Key;
+                RenameMappingField field = e.Value;
+                WriteFieldMapping(typeNode, e.Key, e.Value);
+            }
+            foreach (var e in type.properties)
+            {
+                WritePropertyMapping(typeNode, e.Key, e.Value);
+            }
+            foreach (var e in type.events)
+            {
+                WriteEventMapping(typeNode, e.Key, e.Value);
+            }
+            foreach (var e in type.methods)
+            {
+                WriteMethodMapping(typeNode, e.Key, e.Value);
+            }
+
+            assNode.AppendChild(typeNode);
+        }
+
         private void WriteFieldMapping(XmlElement typeEle, FieldDef field)
         {
             if (!_fieldRenames.TryGetValue(field, out var record) || record.status == RenameStatus.NotRenamed)
@@ -460,6 +508,15 @@ namespace Obfuz
             typeEle.AppendChild(fieldNode);
         }
 
+        private void WriteFieldMapping(XmlElement typeEle, string signature, RenameMappingField field)
+        {
+            var fieldNode = typeEle.OwnerDocument.CreateElement("field");
+            fieldNode.SetAttribute("signature", signature);
+            fieldNode.SetAttribute("newName", field.newName);
+            //fieldNode.SetAttribute("status", record.status.ToString());
+            typeEle.AppendChild(fieldNode);
+        }
+
         private void WritePropertyMapping(XmlElement typeEle, PropertyDef property)
         {
             if (!_propertyRenames.TryGetValue(property, out var record) || record.status == RenameStatus.NotRenamed)
@@ -473,6 +530,15 @@ namespace Obfuz
             typeEle.AppendChild(propertyNode);
         }
 
+        private void WritePropertyMapping(XmlElement typeEle, string signature, RenameMappingProperty property)
+        {
+            var propertyNode = typeEle.OwnerDocument.CreateElement("property");
+            propertyNode.SetAttribute("signature", signature);
+            propertyNode.SetAttribute("newName", property.newName);
+            //propertyNode.SetAttribute("status", record.status.ToString());
+            typeEle.AppendChild(propertyNode);
+        }
+
         private void WriteEventMapping(XmlElement typeEle, EventDef eventDef)
         {
             if (!_eventRenames.TryGetValue(eventDef, out var record) || record.status == RenameStatus.NotRenamed)
@@ -485,6 +551,14 @@ namespace Obfuz
             typeEle.AppendChild(eventNode);
         }
 
+        private void WriteEventMapping(XmlElement typeEle, string signature, RenameMappingEvent eventDef)
+        {
+            var eventNode = typeEle.OwnerDocument.CreateElement("event");
+            eventNode.SetAttribute("signature", signature);
+            eventNode.SetAttribute("newName", eventDef.newName);
+            typeEle.AppendChild(eventNode);
+        }
+
         private void WriteMethodMapping(XmlElement typeEle, MethodDef method)
         {
             if (!_methodRenames.TryGetValue(method, out var record) || record.status == RenameStatus.NotRenamed)
@@ -505,6 +579,19 @@ namespace Obfuz
             typeEle.AppendChild(methodNode);
         }
 
+        private void WriteMethodMapping(XmlElement typeEle, string signature, RenameMappingMethod method)
+        {
+            var methodNode = typeEle.OwnerDocument.CreateElement("method");
+            methodNode.SetAttribute("signature", signature);
+            methodNode.SetAttribute("newName", method.newName);
+            //methodNode.SetAttribute("status", record != null ? record.status.ToString() : RenameStatus.NotRenamed.ToString());
+            foreach (RenameMappingMethodParam param in method.parameters)
+            {
+                WriteMethodParamMapping(methodNode, param);
+            }
+            typeEle.AppendChild(methodNode);
+        }
+
         private void WriteMethodParamMapping(XmlElement methodEle, ParamDef param)
         {
             if (!_paramRenames.TryGetValue(param, out var record) || record.status == RenameStatus.NotRenamed)
@@ -518,6 +605,15 @@ namespace Obfuz
             methodEle.AppendChild(paramNode);
         }
 
+        private void WriteMethodParamMapping(XmlElement methodEle, RenameMappingMethodParam param)
+        {
+            var paramNode = methodEle.OwnerDocument.CreateElement("param");
+            paramNode.SetAttribute("index", param.index.ToString());
+            paramNode.SetAttribute("newName", param.newName);
+            //paramNode.SetAttribute("status", record.status.ToString());
+            methodEle.AppendChild(paramNode);
+        }
+
         public void AddRename(ModuleDefMD mod, string newName)
         {
             RenameRecord record = _modRenames[mod];
diff --git a/Editor/Rename/UnityRenamePolicy.cs b/Editor/Rename/UnityRenamePolicy.cs
index fad7d6d..5ae0ad9 100644
--- a/Editor/Rename/UnityRenamePolicy.cs
+++ b/Editor/Rename/UnityRenamePolicy.cs
@@ -59,6 +59,10 @@ namespace Obfuz.Rename
             {
                 return false;
             }
+            if (typeDef.FullName.StartsWith("UnitySourceGeneratedAssemblyMonoScriptTypes_"))
+            {
+                return false;
+            }
             return true;
         }
 
@@ -68,6 +72,10 @@ namespace Obfuz.Rename
             {
                 return !s_monoBehaviourEvents.Contains(methodDef.Name);
             }
+            if (methodDef.DeclaringType.FullName.StartsWith("UnitySourceGeneratedAssemblyMonoScriptTypes_"))
+            {
+                return false;
+            }
             return true;
         }
 
@@ -78,6 +86,10 @@ namespace Obfuz.Rename
             {
                 return !MetaUtil.IsSerializableField(fieldDef);
             }
+            if (fieldDef.DeclaringType.FullName.StartsWith("UnitySourceGeneratedAssemblyMonoScriptTypes_"))
+            {
+                return false;
+            }
             return true;
         }
     }
diff --git a/Editor/Settings/ObfuzSettings.cs b/Editor/Settings/ObfuzSettings.cs
index 5e90213..9ce3d4e 100644
--- a/Editor/Settings/ObfuzSettings.cs
+++ b/Editor/Settings/ObfuzSettings.cs
@@ -51,7 +51,9 @@ namespace Obfuz
         {
             string filePath = SettingsPath;
             var arr = InternalEditorUtility.LoadSerializedFileAndForget(filePath);
-            s_Instance = arr.Length > 0 ? arr[0] as ObfuzSettings : CreateInstance<ObfuzSettings>();
+            //Debug.Log($"typeof arr:{arr?.GetType()} arr[0]:{(arr != null && arr.Length > 0 ? arr[0].GetType(): null)}");
+
+            s_Instance = arr != null && arr.Length > 0 ? (ObfuzSettings)arr[0] : CreateInstance<ObfuzSettings>();
             return s_Instance;
         }
 
diff --git a/package.json b/package.json
index 3dd1a6f..23ed31b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.code-philosophy.obfuz",
-  "version": "7.9.0",
+  "version": "1.0.0-beta",
   "displayName": "Obfuz",
   "description": "Obfuz is a powerful code obfuscation tool designed specifically for Unity projects.",
   "category": "Editor",