diff --git a/Editor/GameObjectPool/GameObjectPoolEditor.cs b/Editor/GameObjectPool/GameObjectPoolEditor.cs
index 64aa142..da79068 100644
--- a/Editor/GameObjectPool/GameObjectPoolEditor.cs
+++ b/Editor/GameObjectPool/GameObjectPoolEditor.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using UnityEditor;
 using UnityEngine;
@@ -7,49 +8,57 @@ namespace AlicizaX
     [CustomEditor(typeof(GameObjectPoolManager))]
     public sealed class GameObjectPoolEditor : UnityEditor.Editor
     {
-        private readonly Dictionary<string, bool> _foldoutState = new Dictionary<string, bool>();
+        private readonly Dictionary<string, bool> _foldoutState = new Dictionary<string, bool>(StringComparer.Ordinal);
 
         public override void OnInspectorGUI()
         {
             serializedObject.Update();
-
             DrawDefaultInspector();
             serializedObject.ApplyModifiedProperties();
 
-            var pool = (GameObjectPoolManager)target;
+            var poolManager = (GameObjectPoolManager)target;
             if (!Application.isPlaying)
             {
-                EditorGUILayout.HelpBox("Enter Play Mode to inspect runtime pool state.", MessageType.Info);
+                EditorGUILayout.HelpBox("Enter Play Mode to inspect the runtime pool.", MessageType.Info);
                 return;
             }
 
-            if (!pool.showDetailedInfo)
+            if (!poolManager.showDetailedInfo)
             {
                 return;
             }
 
             EditorGUILayout.Space();
-            DrawRuntimeState(pool);
+            DrawRuntimeState(poolManager);
         }
 
         public override bool RequiresConstantRepaint()
         {
-            var pool = target as GameObjectPoolManager;
-            return pool != null && Application.isPlaying && pool.showDetailedInfo;
+            var poolManager = target as GameObjectPoolManager;
+            return poolManager != null && Application.isPlaying && poolManager.showDetailedInfo;
         }
 
         private void DrawRuntimeState(GameObjectPoolManager poolManager)
         {
-            if (!poolManager.IsReady)
+            GameObjectPoolSummarySnapshot summary = poolManager.GetDebugSummary();
+            DrawSummary(summary);
+
+            if (summary.WaitingForBootstrap)
             {
-                EditorGUILayout.HelpBox("GameObjectPool is initializing.", MessageType.Info);
+                EditorGUILayout.HelpBox("Waiting for YooAssets bootstrap before pool catalog build.", MessageType.Info);
+                return;
+            }
+
+            if (!summary.IsReady)
+            {
+                EditorGUILayout.HelpBox("Pool manager is not ready.", MessageType.Warning);
                 return;
             }
 
             List<GameObjectPoolSnapshot> snapshots = poolManager.GetDebugSnapshots();
             if (snapshots.Count == 0)
             {
-                EditorGUILayout.HelpBox("No runtime pools have been created yet.", MessageType.Info);
+                EditorGUILayout.HelpBox("No pooled runtime instances exist yet.", MessageType.Info);
                 return;
             }
 
@@ -59,6 +68,22 @@ namespace AlicizaX
             }
         }
 
+        private static void DrawSummary(in GameObjectPoolSummarySnapshot summary)
+        {
+            EditorGUILayout.BeginVertical("box");
+            EditorGUILayout.LabelField("Runtime Summary", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField("Ready", summary.IsReady ? "Yes" : "No");
+            EditorGUILayout.LabelField("Waiting Bootstrap", summary.WaitingForBootstrap ? "Yes" : "No");
+            EditorGUILayout.LabelField("Pools", summary.PoolCount.ToString());
+            EditorGUILayout.LabelField("Loaded Prefabs", summary.LoadedPrefabCount.ToString());
+            EditorGUILayout.LabelField("Instances", summary.TotalInstanceCount.ToString());
+            EditorGUILayout.LabelField("Active", summary.ActiveInstanceCount.ToString());
+            EditorGUILayout.LabelField("Inactive", summary.InactiveInstanceCount.ToString());
+            EditorGUILayout.LabelField("Pending Maintenance", summary.PendingMaintenanceCount.ToString());
+            EditorGUILayout.EndVertical();
+            EditorGUILayout.Space();
+        }
+
         private void DrawSnapshot(GameObjectPoolSnapshot snapshot)
         {
             if (snapshot == null)
@@ -66,40 +91,49 @@ namespace AlicizaX
                 return;
             }
 
-            string key = $"{snapshot.group}|{snapshot.assetPath}";
-            if (!_foldoutState.ContainsKey(key))
+            string entryLabel = string.IsNullOrWhiteSpace(snapshot.entryName) ? snapshot.assetPath : snapshot.entryName;
+            string foldoutKey = string.Concat(entryLabel, "|", snapshot.assetPath);
+            if (!_foldoutState.ContainsKey(foldoutKey))
             {
-                _foldoutState[key] = false;
+                _foldoutState[foldoutKey] = false;
             }
 
-            EditorGUILayout.BeginVertical("box");
-            _foldoutState[key] = EditorGUILayout.Foldout(
-                _foldoutState[key],
-                $"{snapshot.group} | {snapshot.assetPath} ({snapshot.activeCount}/{snapshot.totalCount})",
-                true);
+            string foldoutLabel = string.Format(
+                "{0} [{1}/{2}] Hit:{3}/{4}",
+                entryLabel,
+                snapshot.activeCount,
+                snapshot.totalCount,
+                snapshot.hitCount,
+                snapshot.acquireCount);
 
-            if (_foldoutState[key])
+            EditorGUILayout.BeginVertical("box");
+            _foldoutState[foldoutKey] = EditorGUILayout.Foldout(_foldoutState[foldoutKey], foldoutLabel, true);
+            if (_foldoutState[foldoutKey])
             {
-                EditorGUILayout.LabelField("Entry", snapshot.entryName);
+                EditorGUILayout.LabelField("Rule", entryLabel);
+                EditorGUILayout.LabelField("Asset Path", snapshot.assetPath);
                 EditorGUILayout.LabelField("Loader", snapshot.loaderType.ToString());
-                EditorGUILayout.LabelField("Overflow Policy", snapshot.overflowPolicy.ToString());
-                EditorGUILayout.LabelField("Min Retained", snapshot.minRetained.ToString());
+                EditorGUILayout.LabelField("Retain Target", snapshot.retainTarget.ToString());
                 EditorGUILayout.LabelField("Soft Capacity", snapshot.softCapacity.ToString());
-                EditorGUILayout.LabelField("Hard Capacity", snapshot.hardCapacity.ToString());
+                EditorGUILayout.LabelField("Capacity", snapshot.hardCapacity.ToString());
+                EditorGUILayout.LabelField("Runtime Capacity", snapshot.runtimeHardCapacity.ToString());
                 EditorGUILayout.LabelField("Inactive", snapshot.inactiveCount.ToString());
                 EditorGUILayout.LabelField("Prefab Loaded", snapshot.prefabLoaded ? "Yes" : "No");
-                EditorGUILayout.LabelField("Prefab Idle", $"{snapshot.prefabIdleDuration:F1}s");
+                EditorGUILayout.LabelField("Prefab Cold", FormatSeconds(snapshot.prefabIdleDuration));
+                EditorGUILayout.LabelField("Wake Count", snapshot.prefabWakeCount.ToString());
+                EditorGUILayout.LabelField("Wake Gap", snapshot.prefabWakeGap < 0f ? "N/A" : FormatSeconds(snapshot.prefabWakeGap));
+                EditorGUILayout.LabelField("Unload Delay", snapshot.prefabUnloadDelay < 0f ? "N/A" : FormatSeconds(snapshot.prefabUnloadDelay));
+                EditorGUILayout.LabelField("Next Maintenance", snapshot.nextMaintenanceIn < 0f ? "None" : FormatSeconds(snapshot.nextMaintenanceIn));
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Acquire", snapshot.acquireCount.ToString());
                 EditorGUILayout.LabelField("Release", snapshot.releaseCount.ToString());
                 EditorGUILayout.LabelField("Hit", snapshot.hitCount.ToString());
                 EditorGUILayout.LabelField("Miss", snapshot.missCount.ToString());
                 EditorGUILayout.LabelField("Expand", snapshot.expandCount.ToString());
-                EditorGUILayout.LabelField("Exhausted", snapshot.exhaustedCount.ToString());
-                EditorGUILayout.LabelField("Auto Recycle", snapshot.autoRecycleCount.ToString());
                 EditorGUILayout.LabelField("Destroy", snapshot.destroyCount.ToString());
                 EditorGUILayout.LabelField("Peak Active", snapshot.peakActive.ToString());
-                EditorGUILayout.LabelField("Peak Total", snapshot.peakTotal.ToString());
+                EditorGUILayout.LabelField("Peak Active Short", snapshot.peakActiveShort.ToString());
+                EditorGUILayout.LabelField("Peak Active Long", snapshot.peakActiveLong.ToString());
 
                 if (snapshot.instances.Count > 0)
                 {
@@ -116,25 +150,31 @@ namespace AlicizaX
             EditorGUILayout.Space();
         }
 
-        private static void DrawInstance(GameObjectPoolInstanceSnapshot instance)
+        private static void DrawInstance(GameObjectPoolInstanceSnapshot snapshot)
         {
-            if (instance == null)
+            if (snapshot == null)
             {
                 return;
             }
 
             EditorGUILayout.BeginHorizontal("box");
             EditorGUILayout.BeginVertical();
-            EditorGUILayout.LabelField(instance.instanceName, EditorStyles.boldLabel);
-            EditorGUILayout.LabelField("State", instance.isActive ? "Active" : "Inactive");
-            EditorGUILayout.LabelField("Life", $"{instance.lifeDuration:F1}s");
-            if (!instance.isActive)
+            EditorGUILayout.LabelField(snapshot.instanceName, EditorStyles.boldLabel);
+            EditorGUILayout.LabelField("State", snapshot.isActive ? "Active" : "Inactive");
+            EditorGUILayout.LabelField("Life", FormatSeconds(snapshot.lifeDuration));
+            if (!snapshot.isActive)
             {
-                EditorGUILayout.LabelField("Idle", $"{instance.idleDuration:F1}s");
+                EditorGUILayout.LabelField("Idle", FormatSeconds(snapshot.idleDuration));
             }
+
             EditorGUILayout.EndVertical();
-            EditorGUILayout.ObjectField(instance.gameObject, typeof(GameObject), true, GUILayout.Width(120));
+            EditorGUILayout.ObjectField(snapshot.gameObject, typeof(GameObject), true, GUILayout.Width(140f));
             EditorGUILayout.EndHorizontal();
         }
+
+        private static string FormatSeconds(float seconds)
+        {
+            return seconds.ToString("F2") + "s";
+        }
     }
 }
diff --git a/Editor/GameObjectPool/PoolConfigEditorWindow.cs b/Editor/GameObjectPool/PoolConfigEditorWindow.cs
index c54df31..458f61a 100644
--- a/Editor/GameObjectPool/PoolConfigEditorWindow.cs
+++ b/Editor/GameObjectPool/PoolConfigEditorWindow.cs
@@ -3,6 +3,7 @@ using AlicizaX.Editor;
 using UnityEditor;
 using UnityEditor.Callbacks;
 using UnityEditor.UIElements;
+using UnityEditorInternal;
 using UnityEngine;
 using UnityEngine.UIElements;
 
@@ -12,37 +13,47 @@ namespace AlicizaX
     {
         private const float MinLeftWidth = 240f;
         private const float InitialLeftWidth = 300f;
-        private const int ListItemHeight = 46;
-        private const string WindowTitle = "Pool Config Editor";
+        private const int ListItemHeight = 24;
+        private const string WindowTitle = "对象池配置编辑器";
 
         private static readonly Color LeftPanelColor = new Color(0.22f, 0.22f, 0.22f, 1f);
         private static readonly Color RightPanelColor = new Color(0.16f, 0.16f, 0.16f, 1f);
+        private static readonly Color DescriptionColor = new Color(0.72f, 0.72f, 0.72f, 1f);
+        private static readonly List<string> MatchModeOptions = new List<string> { "精确匹配", "前缀匹配" };
+        private static readonly List<string> LoaderTypeOptions = new List<string> { "AssetBundle", "Resources" };
 
+        [SerializeField]
         private PoolConfigScriptableObject _asset;
+        [SerializeField]
+        private string _assetGuid;
         private SerializedObject _serializedObject;
         private SerializedProperty _entriesProperty;
         private readonly List<int> _entryIndices = new List<int>();
 
+        [SerializeField]
         private int _selectedIndex;
+        [SerializeField]
         private bool _hasUnsavedChanges;
+        [SerializeField]
+        private Vector2 _entryListScrollPosition;
 
         private ToolbarButton _saveButton;
         private Label _titleLabel;
         private VisualElement _leftPane;
-        private ListView _listView;
+        private IMGUIContainer _entryListContainer;
+        private ReorderableList _entryList;
         private ScrollView _detailScrollView;
         private Label _detailTitleLabel;
         private VisualElement _detailFieldsContainer;
         private VisualElement _emptyContainer;
 
-        [MenuItem("AlicizaX/GameObjectPool/Open PoolConfig Editor")]
-        public static void OpenWindow()
+        private static void OpenForAsset(PoolConfigScriptableObject asset)
         {
-            Open(Selection.activeObject as PoolConfigScriptableObject);
-        }
+            if (asset == null)
+            {
+                return;
+            }
 
-        public static void Open(PoolConfigScriptableObject asset)
-        {
             PoolConfigEditorWindow window = GetWindow<PoolConfigEditorWindow>(false, WindowTitle, true);
             window.minSize = new Vector2(920f, 560f);
             window.SetAsset(asset);
@@ -58,7 +69,7 @@ namespace AlicizaX
                 return false;
             }
 
-            Open(asset);
+            OpenForAsset(asset);
             return true;
         }
 
@@ -66,15 +77,8 @@ namespace AlicizaX
         {
             titleContent = new GUIContent(WindowTitle, EditorGUIUtility.IconContent("ScriptableObject Icon").image);
             BuildUi();
-
-            if (_asset == null && Selection.activeObject is PoolConfigScriptableObject selectedAsset)
-            {
-                SetAsset(selectedAsset);
-            }
-            else
-            {
-                RefreshUi();
-            }
+            RestoreWindowState();
+            RefreshUi();
         }
 
         private void OnEnable()
@@ -85,22 +89,8 @@ namespace AlicizaX
                 BuildUi();
             }
 
-            if (_asset == null && Selection.activeObject is PoolConfigScriptableObject selectedAsset)
-            {
-                SetAsset(selectedAsset);
-            }
-            else
-            {
-                RefreshUi();
-            }
-        }
-
-        private void OnSelectionChange()
-        {
-            if (Selection.activeObject is PoolConfigScriptableObject selectedAsset && selectedAsset != _asset)
-            {
-                SetAsset(selectedAsset);
-            }
+            RestoreWindowState();
+            RefreshUi();
         }
 
         private void BuildUi()
@@ -113,7 +103,7 @@ namespace AlicizaX
 
             _saveButton = new ToolbarButton(SaveAsset)
             {
-                tooltip = "Save PoolConfig"
+                tooltip = "保存当前 PoolConfig 配置"
             };
             _saveButton.Add(new Image
             {
@@ -161,63 +151,10 @@ namespace AlicizaX
 
         private void BuildLeftPane()
         {
-            _listView = new ListView
-            {
-                selectionType = SelectionType.Single,
-                virtualizationMethod = CollectionVirtualizationMethod.FixedHeight,
-                reorderable = false,
-                showBorder = false,
-                showAlternatingRowBackgrounds = AlternatingRowBackground.None,
-                style =
-                {
-                    flexGrow = 1f,
-                    marginBottom = 4f
-                },
-                fixedItemHeight = ListItemHeight
-            };
-
-            _listView.makeItem = MakeListItem;
-            _listView.bindItem = BindListItem;
-            _listView.selectionChanged += _ => OnListSelectionChanged();
-            _leftPane.Add(_listView);
-
-            VisualElement footer = new VisualElement();
-            footer.style.flexDirection = FlexDirection.Row;
-            footer.style.justifyContent = Justify.Center;
-            footer.style.alignItems = Align.Center;
-            footer.style.flexShrink = 0f;
-            footer.style.height = 28f;
-
-            Button addButton = new Button(AddEntry)
-            {
-                tooltip = "Add Item"
-            };
-            addButton.style.width = 24f;
-            addButton.style.height = 20f;
-            addButton.style.marginRight = 4f;
-            addButton.Add(new Image
-            {
-                image = EditorUtils.Styles.PlusIcon.image,
-                scaleMode = ScaleMode.ScaleToFit
-            });
-
-            Button removeButton = new Button(RemoveEntry)
-            {
-                tooltip = "Remove Item",
-                name = "remove-button"
-            };
-            removeButton.style.width = 24f;
-            removeButton.style.height = 20f;
-            removeButton.Add(new Image
-            {
-                image = EditorUtils.Styles.MinusIcon.image,
-                scaleMode = ScaleMode.ScaleToFit
-            });
-            removeButton.SetEnabled(false);
-
-            footer.Add(addButton);
-            footer.Add(removeButton);
-            _leftPane.Add(footer);
+            _entryListContainer = new IMGUIContainer(DrawEntryList);
+            _entryListContainer.style.flexGrow = 1f;
+            _entryListContainer.style.marginBottom = 4f;
+            _leftPane.Add(_entryListContainer);
         }
 
         private void BuildRightPane(VisualElement rightPane)
@@ -230,7 +167,7 @@ namespace AlicizaX
                     justifyContent = Justify.Center
                 }
             };
-            _emptyContainer.Add(new HelpBox("No entry selected.", HelpBoxMessageType.Info));
+            _emptyContainer.Add(new HelpBox("当前没有选中任何规则。", HelpBoxMessageType.Info));
 
             _detailScrollView = new ScrollView
             {
@@ -256,59 +193,53 @@ namespace AlicizaX
             rightPane.Add(_detailScrollView);
         }
 
-        private VisualElement MakeListItem()
-        {
-            VisualElement root = new VisualElement();
-            root.style.height = ListItemHeight;
-            root.style.flexDirection = FlexDirection.Column;
-            root.style.justifyContent = Justify.Center;
-            root.style.paddingLeft = 8f;
-            root.style.paddingRight = 8f;
-            root.style.paddingTop = 6f;
-            root.style.paddingBottom = 6f;
-            root.style.marginBottom = 2f;
-
-            Label primary = new Label { name = "primary" };
-            primary.style.unityTextAlign = TextAnchor.MiddleLeft;
-
-            Label secondary = new Label { name = "secondary" };
-            secondary.style.unityTextAlign = TextAnchor.MiddleLeft;
-            secondary.style.fontSize = 11f;
-            secondary.style.color = new Color(0.72f, 0.72f, 0.72f, 1f);
-
-            root.Add(primary);
-            root.Add(secondary);
-            return root;
-        }
-
-        private void BindListItem(VisualElement element, int index)
-        {
-            SerializedProperty entry = GetEntryAt(index);
-            element.Q<Label>("primary").text = GetPrimaryLabel(entry);
-            element.Q<Label>("secondary").text = GetSecondaryLabel(entry);
-        }
-
         private void SetAsset(PoolConfigScriptableObject asset)
         {
             _asset = asset;
+            _assetGuid = GetAssetGuid(asset);
             _selectedIndex = 0;
             _hasUnsavedChanges = false;
+            _entryListScrollPosition = Vector2.zero;
+            RebindAssetState();
+            RefreshUi();
+        }
+
+        private void RestoreWindowState()
+        {
+            if (_asset == null && !string.IsNullOrEmpty(_assetGuid))
+            {
+                string assetPath = AssetDatabase.GUIDToAssetPath(_assetGuid);
+                if (!string.IsNullOrEmpty(assetPath))
+                {
+                    _asset = AssetDatabase.LoadAssetAtPath<PoolConfigScriptableObject>(assetPath);
+                }
+            }
+            else if (_asset != null)
+            {
+                _assetGuid = GetAssetGuid(_asset);
+            }
+
+            RebindAssetState();
+        }
+
+        private void RebindAssetState()
+        {
+            _entryList = null;
 
             if (_asset == null)
             {
+                _assetGuid = string.Empty;
                 _serializedObject = null;
                 _entriesProperty = null;
-            }
-            else
-            {
-                _asset.Normalize();
-                _serializedObject = new SerializedObject(_asset);
-                _entriesProperty = _serializedObject.FindProperty("entries");
-                RebuildEntryIndices();
-                ClampSelection();
+                _entryIndices.Clear();
+                return;
             }
 
-            RefreshUi();
+            _asset.Normalize();
+            _serializedObject = new SerializedObject(_asset);
+            _entriesProperty = _serializedObject.FindProperty("entries");
+            RebuildEntryIndices();
+            ClampSelection();
         }
 
         private void RefreshUi()
@@ -324,24 +255,23 @@ namespace AlicizaX
             if (_asset == null || _serializedObject == null)
             {
                 _entryIndices.Clear();
-                _listView.itemsSource = _entryIndices;
-                _listView.Rebuild();
+                _entryList = null;
+                _entryListContainer?.MarkDirtyRepaint();
                 _emptyContainer.Clear();
-                _emptyContainer.Add(new HelpBox("Select or double-click a PoolConfig asset to edit it in this window.", HelpBoxMessageType.Info));
+                _emptyContainer.Add(new HelpBox("请选择或双击 PoolConfig 资源，然后在这个窗口里编辑对象池规则。", HelpBoxMessageType.Info));
                 _emptyContainer.style.display = DisplayStyle.Flex;
                 _detailScrollView.style.display = DisplayStyle.None;
-                UpdateRemoveButtonState();
                 return;
             }
 
             RebuildEntryIndices();
             ClampSelection();
+            EnsureEntryReorderableList();
+            SyncEntryListSelection();
+            _entryListContainer?.MarkDirtyRepaint();
 
-            _listView.itemsSource = _entryIndices;
-            _listView.Rebuild();
             if (_entryIndices.Count > 0)
             {
-                _listView.SetSelectionWithoutNotify(new[] { _selectedIndex });
                 _emptyContainer.style.display = DisplayStyle.None;
                 _detailScrollView.style.display = DisplayStyle.Flex;
                 RebuildDetailFields();
@@ -349,12 +279,10 @@ namespace AlicizaX
             else
             {
                 _emptyContainer.Clear();
-                _emptyContainer.Add(new HelpBox("No entry selected.", HelpBoxMessageType.Info));
+                _emptyContainer.Add(new HelpBox("当前没有可编辑的规则，请先新增一条对象池规则。", HelpBoxMessageType.Info));
                 _emptyContainer.style.display = DisplayStyle.Flex;
                 _detailScrollView.style.display = DisplayStyle.None;
             }
-
-            UpdateRemoveButtonState();
         }
 
         private void RebuildEntryIndices()
@@ -367,24 +295,121 @@ namespace AlicizaX
             }
         }
 
-        private void UpdateRemoveButtonState()
+        private void DrawEntryList()
         {
-            Button removeButton = _leftPane?.Q<Button>("remove-button");
-            removeButton?.SetEnabled(_entryIndices.Count > 0);
-        }
-
-        private void OnListSelectionChanged()
-        {
-            if (_listView.selectedIndex < 0 || _listView.selectedIndex >= _entryIndices.Count)
+            if (_asset == null || _serializedObject == null || _entriesProperty == null)
             {
                 return;
             }
 
-            _selectedIndex = _listView.selectedIndex;
-            UpdateRemoveButtonState();
+            EnsureEntryReorderableList();
+            SyncEntryListSelection();
+
+            _serializedObject.Update();
+            _entryListScrollPosition = EditorGUILayout.BeginScrollView(_entryListScrollPosition, GUILayout.ExpandHeight(true), GUILayout.ExpandWidth(true));
+            Rect listRect = GUILayoutUtility.GetRect(0f, _entryList.GetHeight(), GUILayout.ExpandWidth(true));
+            _entryList.DoList(listRect);
+            EditorGUILayout.EndScrollView();
+        }
+
+        private void EnsureEntryReorderableList()
+        {
+            if (_serializedObject == null || _entriesProperty == null)
+            {
+                _entryList = null;
+                return;
+            }
+
+            if (_entryList != null && _entryList.serializedProperty == _entriesProperty)
+            {
+                return;
+            }
+
+            _entryList = new ReorderableList(_serializedObject, _entriesProperty, true, true, true, true)
+            {
+                elementHeight = ListItemHeight + 6f
+            };
+
+            _entryList.drawHeaderCallback = rect =>
+            {
+                EditorGUI.LabelField(rect, Utility.Text.Format("对象池规则 ({0})", _entriesProperty.arraySize), EditorStyles.boldLabel);
+            };
+            _entryList.drawElementCallback = DrawEntryListElement;
+            _entryList.onSelectCallback = OnEntryListSelected;
+            _entryList.onAddCallback = OnEntryListAdd;
+            _entryList.onRemoveCallback = OnEntryListRemove;
+            _entryList.onReorderCallback = OnEntryListReordered;
+        }
+
+        private void DrawEntryListElement(Rect rect, int index, bool isActive, bool isFocused)
+        {
+            SerializedProperty entry = GetEntryAt(index);
+            if (entry == null)
+            {
+                return;
+            }
+
+            rect.y += 5f;
+
+            string primaryLabel = GetPrimaryLabel(entry);
+            string assetPath = entry.FindPropertyRelative("assetPath").stringValue;
+            string tooltip = string.IsNullOrWhiteSpace(assetPath) || string.Equals(primaryLabel, assetPath, System.StringComparison.Ordinal)
+                ? primaryLabel
+                : assetPath;
+
+            Rect primaryRect = new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight);
+            EditorGUI.LabelField(primaryRect, new GUIContent(primaryLabel, tooltip), EditorStyles.boldLabel);
+        }
+
+        private void OnEntryListSelected(ReorderableList list)
+        {
+            if (list.index < 0 || list.index >= _entryIndices.Count)
+            {
+                return;
+            }
+
+            _selectedIndex = list.index;
             RebuildDetailFields();
         }
 
+        private void OnEntryListAdd(ReorderableList list)
+        {
+            AddEntry();
+        }
+
+        private void OnEntryListRemove(ReorderableList list)
+        {
+            RemoveEntry();
+        }
+
+        private void OnEntryListReordered(ReorderableList list)
+        {
+            if (_asset == null || _serializedObject == null || _entriesProperty == null)
+            {
+                return;
+            }
+
+            RefreshEntryPriorities();
+            _serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            _asset.Normalize();
+            RebuildEntryIndices();
+            _selectedIndex = Mathf.Clamp(list.index, 0, _entryIndices.Count - 1);
+            _hasUnsavedChanges = true;
+            RefreshTitle();
+            RebuildDetailFields();
+            _entryListContainer?.MarkDirtyRepaint();
+        }
+
+        private void SyncEntryListSelection()
+        {
+            if (_entryList == null)
+            {
+                return;
+            }
+
+            _entryList.index = _entryIndices.Count == 0 ? -1 : _selectedIndex;
+        }
+
         private void RebuildDetailFields()
         {
             if (_asset == null || _serializedObject == null)
@@ -409,16 +434,124 @@ namespace AlicizaX
             bool enterChildren = true;
             while (iterator.NextVisible(enterChildren) && !SerializedProperty.EqualContents(iterator, end))
             {
-                PropertyField field = new PropertyField(iterator.Copy());
-                field.RegisterCallback<SerializedPropertyChangeEvent>(OnDetailPropertyChanged);
-                _detailFieldsContainer.Add(field);
+                SerializedProperty currentProperty = iterator.Copy();
+                if (!ShouldDisplayField(currentProperty.name))
+                {
+                    enterChildren = false;
+                    continue;
+                }
+
+                _detailFieldsContainer.Add(CreateDetailField(currentProperty));
                 enterChildren = false;
             }
 
             _detailFieldsContainer.Bind(_serializedObject);
         }
 
+        private VisualElement CreateDetailField(SerializedProperty property)
+        {
+            if (TryCreateLocalizedEnumField(property, out VisualElement enumFieldContainer))
+            {
+                return enumFieldContainer;
+            }
+
+            VisualElement container = new VisualElement();
+            container.style.flexDirection = FlexDirection.Column;
+            container.style.marginBottom = 4f;
+
+            string label = property.name == "group" ? "\u5206\u7ec4" : GetFieldLabel(property.name);
+            PropertyField field = new PropertyField(property, label);
+            if (IsReadOnlyField(property.name))
+            {
+                field.SetEnabled(false);
+            }
+
+            field.RegisterCallback<SerializedPropertyChangeEvent>(OnDetailPropertyChanged);
+            container.Add(field);
+
+            string description = property.name == "group"
+                ? "\u7528\u4e8e GameObjectPoolManager \u4e0b\u7684\u7a7a\u95f2\u8282\u70b9\u5f52\u7c7b\uff0c\u4e0d\u586b\u6216\u7a7a\u503c\u4f1a\u81ea\u52a8\u56de\u843d\u5230 DefaultGroup\u3002"
+                : GetFieldDescription(property.name);
+            if (!string.IsNullOrWhiteSpace(description))
+            {
+                Label descriptionLabel = new Label(description);
+                descriptionLabel.style.whiteSpace = WhiteSpace.Normal;
+                descriptionLabel.style.fontSize = 11f;
+                descriptionLabel.style.color = DescriptionColor;
+                descriptionLabel.style.marginLeft = 4f;
+                descriptionLabel.style.marginRight = 4f;
+                descriptionLabel.style.marginTop = -2f;
+                descriptionLabel.style.marginBottom = 6f;
+                container.Add(descriptionLabel);
+            }
+
+            return container;
+        }
+
+        private bool TryCreateLocalizedEnumField(SerializedProperty property, out VisualElement container)
+        {
+            List<string> options = GetEnumOptions(property.name);
+            if (options == null)
+            {
+                container = null;
+                return false;
+            }
+
+            container = new VisualElement();
+            container.style.flexDirection = FlexDirection.Column;
+            container.style.marginBottom = 4f;
+
+            int currentIndex = Mathf.Clamp(property.enumValueIndex, 0, options.Count - 1);
+            PopupField<string> popupField = new PopupField<string>(GetFieldLabel(property.name), options, currentIndex);
+            string propertyPath = property.propertyPath;
+            popupField.RegisterValueChangedCallback(_ =>
+            {
+                if (_serializedObject == null)
+                {
+                    return;
+                }
+
+                int selectedIndex = options.IndexOf(popupField.value);
+                if (selectedIndex < 0)
+                {
+                    return;
+                }
+
+                _serializedObject.Update();
+                SerializedProperty targetProperty = _serializedObject.FindProperty(propertyPath);
+                if (targetProperty == null || targetProperty.enumValueIndex == selectedIndex)
+                {
+                    return;
+                }
+
+                targetProperty.enumValueIndex = selectedIndex;
+                ApplyDetailPropertyChanges();
+            });
+            container.Add(popupField);
+
+            string description = GetFieldDescription(property.name);
+            if (!string.IsNullOrWhiteSpace(description))
+            {
+                Label descriptionLabel = new Label(description);
+                descriptionLabel.style.whiteSpace = WhiteSpace.Normal;
+                descriptionLabel.style.fontSize = 11f;
+                descriptionLabel.style.color = DescriptionColor;
+                descriptionLabel.style.marginLeft = 4f;
+                descriptionLabel.style.marginRight = 4f;
+                descriptionLabel.style.marginTop = -2f;
+                descriptionLabel.style.marginBottom = 6f;
+                container.Add(descriptionLabel);
+            }
+
+            return true;
+        }
+
         private void OnDetailPropertyChanged(SerializedPropertyChangeEvent evt)
+        {
+            ApplyDetailPropertyChanges();
+        }
+
+        private void ApplyDetailPropertyChanges()
         {
             if (_asset == null || _serializedObject == null)
             {
@@ -428,7 +561,7 @@ namespace AlicizaX
             _serializedObject.ApplyModifiedPropertiesWithoutUndo();
             _asset.Normalize();
             _hasUnsavedChanges = true;
-            _listView?.RefreshItems();
+            _entryListContainer?.MarkDirtyRepaint();
             RefreshTitle();
             _detailTitleLabel.text = GetPrimaryLabel(GetSelectedProperty());
         }
@@ -446,6 +579,7 @@ namespace AlicizaX
             _entriesProperty.InsertArrayElementAtIndex(index);
             SerializedProperty property = _entriesProperty.GetArrayElementAtIndex(index);
             InitializeNewEntry(property, index);
+            RefreshEntryPriorities();
 
             _serializedObject.ApplyModifiedPropertiesWithoutUndo();
             _asset.Normalize();
@@ -453,7 +587,6 @@ namespace AlicizaX
             _selectedIndex = index;
             _hasUnsavedChanges = true;
             RefreshUi();
-            _listView.SetSelectionWithoutNotify(new[] { _selectedIndex });
         }
 
         private void RemoveEntry()
@@ -465,6 +598,7 @@ namespace AlicizaX
 
             _serializedObject.Update();
             _entriesProperty.DeleteArrayElementAtIndex(_selectedIndex);
+            RefreshEntryPriorities();
             _serializedObject.ApplyModifiedPropertiesWithoutUndo();
             _asset.Normalize();
             RebuildEntryIndices();
@@ -476,38 +610,47 @@ namespace AlicizaX
 
             _hasUnsavedChanges = true;
             RefreshUi();
-            if (_entryIndices.Count > 0)
-            {
-                _listView.SetSelectionWithoutNotify(new[] { _selectedIndex });
-            }
         }
 
         private void InitializeNewEntry(SerializedProperty property, int index)
         {
-            property.FindPropertyRelative("entryName").stringValue = $"PoolEntry{index + 1}";
+            property.FindPropertyRelative("entryName").stringValue = Utility.Text.Format("对象池规则{0}", index + 1);
             property.FindPropertyRelative("group").stringValue = PoolEntry.DefaultGroup;
             property.FindPropertyRelative("assetPath").stringValue = string.Empty;
             property.FindPropertyRelative("matchMode").enumValueIndex = (int)PoolMatchMode.Exact;
             property.FindPropertyRelative("loaderType").enumValueIndex = (int)PoolResourceLoaderType.AssetBundle;
-            property.FindPropertyRelative("overflowPolicy").enumValueIndex = (int)PoolOverflowPolicy.FailFast;
-            property.FindPropertyRelative("trimPolicy").enumValueIndex = (int)PoolTrimPolicy.IdleOnly;
-            property.FindPropertyRelative("activationMode").enumValueIndex = (int)PoolActivationMode.SetActive;
-            property.FindPropertyRelative("resetMode").enumValueIndex = (int)PoolResetMode.PoolableCallbacks;
-            property.FindPropertyRelative("minRetained").intValue = 0;
+            property.FindPropertyRelative("category").enumValueIndex = (int)PoolCategory.Default;
             property.FindPropertyRelative("softCapacity").intValue = 8;
-            property.FindPropertyRelative("hardCapacity").intValue = 8;
-            property.FindPropertyRelative("idleTrimDelay").floatValue = 30f;
-            property.FindPropertyRelative("prefabUnloadDelay").floatValue = 60f;
-            property.FindPropertyRelative("autoRecycleDelay").floatValue = 0f;
-            property.FindPropertyRelative("trimBatchPerTick").intValue = 2;
-            property.FindPropertyRelative("warmupBatchPerFrame").intValue = 2;
-            property.FindPropertyRelative("warmupFrameBudgetMs").floatValue = 1f;
-            property.FindPropertyRelative("allowRuntimeExpand").boolValue = false;
-            property.FindPropertyRelative("keepPrefabResident").boolValue = false;
-            property.FindPropertyRelative("aggressiveTrimOnLowMemory").boolValue = false;
+            property.FindPropertyRelative("hardCapacity").intValue = 16;
             property.FindPropertyRelative("priority").intValue = index;
         }
 
+        private void RefreshEntryPriorities()
+        {
+            if (_entriesProperty == null)
+            {
+                return;
+            }
+
+            int count = _entriesProperty.arraySize;
+            for (int i = 0; i < count; i++)
+            {
+                SerializedProperty entry = _entriesProperty.GetArrayElementAtIndex(i);
+                entry.FindPropertyRelative("priority").intValue = count - i;
+            }
+        }
+
+        private static string GetAssetGuid(PoolConfigScriptableObject asset)
+        {
+            if (asset == null)
+            {
+                return string.Empty;
+            }
+
+            string assetPath = AssetDatabase.GetAssetPath(asset);
+            return string.IsNullOrEmpty(assetPath) ? string.Empty : AssetDatabase.AssetPathToGUID(assetPath);
+        }
+
         private void SaveAsset()
         {
             if (_asset == null || _serializedObject == null)
@@ -526,10 +669,10 @@ namespace AlicizaX
 
         private void RefreshTitle()
         {
-            string assetLabel = _asset == null ? "No PoolConfig Selected" : _asset.name;
+            string assetLabel = _asset == null ? "未选择 PoolConfig" : _asset.name;
             if (_hasUnsavedChanges)
             {
-                assetLabel += " *";
+                assetLabel = Utility.Text.Format("{0} *", assetLabel);
             }
 
             _titleLabel.text = assetLabel;
@@ -557,7 +700,7 @@ namespace AlicizaX
         {
             if (property == null)
             {
-                return "<Missing>";
+                return "<规则缺失>";
             }
 
             string entryName = property.FindPropertyRelative("entryName").stringValue;
@@ -567,19 +710,59 @@ namespace AlicizaX
                 return entryName;
             }
 
-            return string.IsNullOrWhiteSpace(assetPath) ? "<Unnamed Entry>" : assetPath;
+            return string.IsNullOrWhiteSpace(assetPath) ? "<未命名规则>" : assetPath;
         }
 
-        private string GetSecondaryLabel(SerializedProperty property)
+        private static List<string> GetEnumOptions(string propertyName)
         {
-            if (property == null)
+            return propertyName switch
             {
-                return string.Empty;
-            }
+                "matchMode" => MatchModeOptions,
+                "loaderType" => LoaderTypeOptions,
+                _ => null
+            };
+        }
 
-            string group = property.FindPropertyRelative("group").stringValue;
-            string assetPath = property.FindPropertyRelative("assetPath").stringValue;
-            return string.IsNullOrWhiteSpace(assetPath) ? group : $"{group} | {assetPath}";
+        private static bool ShouldDisplayField(string propertyName)
+        {
+            return propertyName != "category";
+        }
+
+        private static bool IsReadOnlyField(string propertyName)
+        {
+            return propertyName == "priority";
+        }
+
+        private static string GetFieldLabel(string propertyName)
+        {
+            return propertyName switch
+            {
+                "entryName" => "规则名称",
+                "group" => "分组",
+                "assetPath" => "资源路径",
+                "matchMode" => "匹配模式",
+                "loaderType" => "加载器类型",
+                "softCapacity" => "软容量",
+                "hardCapacity" => "容量",
+                "priority" => "优先级",
+                _ => propertyName
+            };
+        }
+
+        private static string GetFieldDescription(string propertyName)
+        {
+            return propertyName switch
+            {
+                "entryName" => "规则名称就是主定位信息。列表、调试和问题排查都直接看这个名字。",
+                "group" => "用于 GameObjectPoolManager 下的空闲节点归类。不填或空值会自动回落到 DefaultGroup。",
+                "assetPath" => "要匹配的资源路径。精确匹配填完整路径，前缀匹配可填写目录前缀。",
+                "matchMode" => "精确匹配只命中单一路径，前缀匹配适合同目录或同类资源共用规则。",
+                "loaderType" => "决定 Prefab 从哪个资源通道加载。AssetBundle 走包体资源，Resources 走内置目录。",
+                "softCapacity" => "超过该值后，维护阶段会优先回收空闲实例。",
+                "hardCapacity" => "基础容量。超过这个值会自动扩容并输出警告，后续维护回收会再收回到这个基准。",
+                "priority" => "由左侧拖拽顺序自动维护，越靠上优先级越高。",
+                _ => string.Empty
+            };
         }
 
         private void ClampSelection()
diff --git a/Editor/GameObjectPool/PoolConfigScriptableObjectEditor.cs b/Editor/GameObjectPool/PoolConfigScriptableObjectEditor.cs
index ce82b50..d413234 100644
--- a/Editor/GameObjectPool/PoolConfigScriptableObjectEditor.cs
+++ b/Editor/GameObjectPool/PoolConfigScriptableObjectEditor.cs
@@ -1,5 +1,4 @@
 using UnityEditor;
-using UnityEngine;
 
 namespace AlicizaX
 {
@@ -8,10 +7,7 @@ namespace AlicizaX
     {
         public override void OnInspectorGUI()
         {
-            if (GUILayout.Button("Open Editor", GUILayout.Width(160f), GUILayout.Height(28f)))
-            {
-                PoolConfigEditorWindow.Open((PoolConfigScriptableObject)target);
-            }
+            DrawDefaultInspector();
         }
     }
 }
diff --git a/Runtime/ABase/GameObjectPool/Components/PoolComponents.cs b/Runtime/ABase/GameObjectPool/Components/PoolComponents.cs
index ac611ee..4302065 100644
--- a/Runtime/ABase/GameObjectPool/Components/PoolComponents.cs
+++ b/Runtime/ABase/GameObjectPool/Components/PoolComponents.cs
@@ -1,22 +1,7 @@
-using System;
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace AlicizaX
 {
-    [DisallowMultipleComponent]
-    public sealed class PoolAutoRecycleAfterSeconds : MonoBehaviour, IPoolAutoRecycle
-    {
-        [Min(0f)]
-        public float delaySeconds = 1f;
-
-        public bool TryGetAutoRecycleDelay(out float delay)
-        {
-            delay = delaySeconds;
-            return delay > 0f;
-        }
-    }
-
     [DisallowMultipleComponent]
     public sealed class PoolAutoRecycleParticleStop : MonoBehaviour, IGameObjectPoolable
     {
@@ -76,168 +61,18 @@ namespace AlicizaX
         }
     }
 
-    [DisallowMultipleComponent]
-    public sealed class PoolResetRigidbodyState : MonoBehaviour, IPoolResettablePhysics
-    {
-        [SerializeField] private bool includeChildren = true;
-        private Rigidbody[] _rigidbodies3D;
-        private Rigidbody2D[] _rigidbodies2D;
-
-        private void EnsureCache()
-        {
-            if (_rigidbodies3D == null)
-            {
-                _rigidbodies3D = includeChildren ? GetComponentsInChildren<Rigidbody>(true) : GetComponents<Rigidbody>();
-            }
-
-            if (_rigidbodies2D == null)
-            {
-                _rigidbodies2D = includeChildren ? GetComponentsInChildren<Rigidbody2D>(true) : GetComponents<Rigidbody2D>();
-            }
-        }
-
-        public void ResetPhysicsState()
-        {
-            EnsureCache();
-
-            for (int i = 0; i < _rigidbodies3D.Length; i++)
-            {
-                Rigidbody body = _rigidbodies3D[i];
-                if (body == null)
-                {
-                    continue;
-                }
-
-                body.velocity = Vector3.zero;
-                body.angularVelocity = Vector3.zero;
-                body.Sleep();
-            }
-
-            for (int i = 0; i < _rigidbodies2D.Length; i++)
-            {
-                Rigidbody2D body = _rigidbodies2D[i];
-                if (body == null)
-                {
-                    continue;
-                }
-
-                body.velocity = Vector2.zero;
-                body.angularVelocity = 0f;
-                body.Sleep();
-            }
-        }
-    }
-
-    [DisallowMultipleComponent]
-    public sealed class PoolResetParticleSystems : MonoBehaviour, IPoolResettableVisual
-    {
-        [SerializeField] private bool includeChildren = true;
-        private ParticleSystem[] _particleSystems;
-
-        private void EnsureCache()
-        {
-            if (_particleSystems == null)
-            {
-                _particleSystems = includeChildren
-                    ? GetComponentsInChildren<ParticleSystem>(true)
-                    : GetComponents<ParticleSystem>();
-            }
-        }
-
-        public void ResetVisualState()
-        {
-            EnsureCache();
-
-            for (int i = 0; i < _particleSystems.Length; i++)
-            {
-                ParticleSystem particle = _particleSystems[i];
-                if (particle == null)
-                {
-                    continue;
-                }
-
-                particle.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
-                particle.Clear(true);
-            }
-        }
-    }
-
-    [DisallowMultipleComponent]
-    public sealed class PoolResetTrailRenderers : MonoBehaviour, IPoolResettableVisual
-    {
-        [SerializeField] private bool includeChildren = true;
-        private TrailRenderer[] _trailRenderers;
-
-        private void EnsureCache()
-        {
-            if (_trailRenderers == null)
-            {
-                _trailRenderers = includeChildren
-                    ? GetComponentsInChildren<TrailRenderer>(true)
-                    : GetComponents<TrailRenderer>();
-            }
-        }
-
-        public void ResetVisualState()
-        {
-            EnsureCache();
-
-            for (int i = 0; i < _trailRenderers.Length; i++)
-            {
-                TrailRenderer trail = _trailRenderers[i];
-                if (trail == null)
-                {
-                    continue;
-                }
-
-                trail.Clear();
-            }
-        }
-    }
-
-    [DisallowMultipleComponent]
-    public sealed class PoolResetAnimatorState : MonoBehaviour, IPoolResettableAnimation
-    {
-        [SerializeField] private bool includeChildren = true;
-        private Animator[] _animators;
-
-        private void EnsureCache()
-        {
-            if (_animators == null)
-            {
-                _animators = includeChildren ? GetComponentsInChildren<Animator>(true) : GetComponents<Animator>();
-            }
-        }
-
-        public void ResetAnimationState()
-        {
-            EnsureCache();
-
-            for (int i = 0; i < _animators.Length; i++)
-            {
-                Animator animator = _animators[i];
-                if (animator == null || !animator.isActiveAndEnabled)
-                {
-                    continue;
-                }
-
-                animator.Rebind();
-                animator.Update(0f);
-            }
-        }
-    }
-
     [DisallowMultipleComponent]
     public sealed class PoolSleepableGameObjectGroup : MonoBehaviour, IPoolSleepable
     {
-        [SerializeField] private List<Behaviour> disableOnSleep = new List<Behaviour>();
-        [SerializeField] private List<Renderer> hideOnSleep = new List<Renderer>();
-        [SerializeField] private List<Collider> disableCollider3D = new List<Collider>();
-        [SerializeField] private List<Collider2D> disableCollider2D = new List<Collider2D>();
+        [SerializeField] private Behaviour[] disableOnSleep;
+        [SerializeField] private Renderer[] hideOnSleep;
+        [SerializeField] private Collider[] disableCollider3D;
+        [SerializeField] private Collider2D[] disableCollider2D;
 
         public void EnterSleep()
         {
-            for (int i = 0; i < disableOnSleep.Count; i++)
+            int disableCount = disableOnSleep == null ? 0 : disableOnSleep.Length;
+            for (int i = 0; i < disableCount; i++)
             {
                 if (disableOnSleep[i] != null)
                 {
@@ -245,7 +80,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < hideOnSleep.Count; i++)
+            int hideCount = hideOnSleep == null ? 0 : hideOnSleep.Length;
+            for (int i = 0; i < hideCount; i++)
             {
                 if (hideOnSleep[i] != null)
                 {
@@ -253,7 +89,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < disableCollider3D.Count; i++)
+            int collider3DCount = disableCollider3D == null ? 0 : disableCollider3D.Length;
+            for (int i = 0; i < collider3DCount; i++)
             {
                 if (disableCollider3D[i] != null)
                 {
@@ -261,7 +98,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < disableCollider2D.Count; i++)
+            int collider2DCount = disableCollider2D == null ? 0 : disableCollider2D.Length;
+            for (int i = 0; i < collider2DCount; i++)
             {
                 if (disableCollider2D[i] != null)
                 {
@@ -272,7 +110,8 @@ namespace AlicizaX
 
         public void ExitSleep(in PoolSpawnContext context)
         {
-            for (int i = 0; i < disableOnSleep.Count; i++)
+            int disableCount = disableOnSleep == null ? 0 : disableOnSleep.Length;
+            for (int i = 0; i < disableCount; i++)
             {
                 if (disableOnSleep[i] != null)
                 {
@@ -280,7 +119,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < hideOnSleep.Count; i++)
+            int hideCount = hideOnSleep == null ? 0 : hideOnSleep.Length;
+            for (int i = 0; i < hideCount; i++)
             {
                 if (hideOnSleep[i] != null)
                 {
@@ -288,7 +128,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < disableCollider3D.Count; i++)
+            int collider3DCount = disableCollider3D == null ? 0 : disableCollider3D.Length;
+            for (int i = 0; i < collider3DCount; i++)
             {
                 if (disableCollider3D[i] != null)
                 {
@@ -296,7 +137,8 @@ namespace AlicizaX
                 }
             }
 
-            for (int i = 0; i < disableCollider2D.Count; i++)
+            int collider2DCount = disableCollider2D == null ? 0 : disableCollider2D.Length;
+            for (int i = 0; i < collider2DCount; i++)
             {
                 if (disableCollider2D[i] != null)
                 {
diff --git a/Runtime/ABase/GameObjectPool/Data/PoolConfig.cs b/Runtime/ABase/GameObjectPool/Data/PoolConfig.cs
index 492e818..deb5295 100644
--- a/Runtime/ABase/GameObjectPool/Data/PoolConfig.cs
+++ b/Runtime/ABase/GameObjectPool/Data/PoolConfig.cs
@@ -1,5 +1,5 @@
 using System;
-using System.Collections.Generic;
+using AlicizaX.ObjectPool;
 using UnityEngine;
 
 namespace AlicizaX
@@ -16,84 +16,34 @@ namespace AlicizaX
         Prefix = 1
     }
 
-    public enum PoolOverflowPolicy
+    public enum PoolCategory
     {
-        FailFast = 0,
-        InstantiateOneShot = 1,
-        AutoExpand = 2,
-        RecycleOldestInactive = 3,
-        DropNewestRequest = 4
-    }
-
-    public enum PoolTrimPolicy
-    {
-        None = 0,
-        IdleOnly = 1,
-        IdleAndPriority = 2,
-        AggressiveOnLowMemory = 3
-    }
-
-    public enum PoolActivationMode
-    {
-        SetActive = 0,
-        SleepWake = 1,
-        Custom = 2
-    }
-
-    public enum PoolResetMode
-    {
-        TransformOnly = 0,
-        PoolableCallbacks = 1,
-        FullReset = 2,
-        Custom = 3
+        Default = 0,
+        Effect = 1,
+        Monster = 2,
+        Building = 3,
+        UI = 4,
+        Custom = 5
     }
 
     [Serializable]
     public sealed class PoolEntry
     {
-        public const string DefaultGroup = "Default";
-        public const string DefaultEntryName = "DefaultPool";
+        public const string DefaultGroup = "DefaultGroup";
+        public const string DefaultEntryName = "PoolRule";
 
         public string entryName = DefaultEntryName;
         public string group = DefaultGroup;
-        public string assetPath;
+        public string assetPath = string.Empty;
         public PoolMatchMode matchMode = PoolMatchMode.Exact;
         public PoolResourceLoaderType loaderType = PoolResourceLoaderType.AssetBundle;
-        public PoolOverflowPolicy overflowPolicy = PoolOverflowPolicy.FailFast;
-        public PoolTrimPolicy trimPolicy = PoolTrimPolicy.IdleOnly;
-        public PoolActivationMode activationMode = PoolActivationMode.SetActive;
-        public PoolResetMode resetMode = PoolResetMode.PoolableCallbacks;
-
-        [Min(0)]
-        public int minRetained = 0;
+        public PoolCategory category = PoolCategory.Default;
 
         [Min(1)]
         public int softCapacity = 8;
 
         [Min(1)]
-        public int hardCapacity = 8;
-
-        [Min(0f)]
-        public float idleTrimDelay = 30f;
-
-        [Min(0f)]
-        public float prefabUnloadDelay = 60f;
-
-        [Min(0f)]
-        public float autoRecycleDelay = 0f;
-
-        [Min(1)]
-        public int trimBatchPerTick = 2;
-
-        [Min(1)]
-        public int warmupBatchPerFrame = 2;
-
-        [Min(0f)]
-        public float warmupFrameBudgetMs = 1f;
-
-        public bool allowRuntimeExpand;
-        public bool keepPrefabResident;
-        public bool aggressiveTrimOnLowMemory;
+        public int hardCapacity = 16;
         public int priority;
 
         public void Normalize()
@@ -101,43 +51,26 @@ namespace AlicizaX
             entryName = string.IsNullOrWhiteSpace(entryName) ? DefaultEntryName : entryName.Trim();
             group = string.IsNullOrWhiteSpace(group) ? DefaultGroup : group.Trim();
             assetPath = NormalizeAssetPath(assetPath);
-            minRetained = Mathf.Max(0, minRetained);
             softCapacity = Mathf.Max(1, softCapacity);
             hardCapacity = Mathf.Max(softCapacity, hardCapacity);
-            minRetained = Mathf.Min(minRetained, hardCapacity);
-            idleTrimDelay = Mathf.Max(0f, idleTrimDelay);
-            prefabUnloadDelay = Mathf.Max(0f, prefabUnloadDelay);
-            autoRecycleDelay = Mathf.Max(0f, autoRecycleDelay);
-            trimBatchPerTick = Mathf.Max(1, trimBatchPerTick);
-            warmupBatchPerFrame = Mathf.Max(1, warmupBatchPerFrame);
-            warmupFrameBudgetMs = Mathf.Max(0f, warmupFrameBudgetMs);
         }
 
         public bool Matches(string requestedAssetPath, string requestedGroup = null)
         {
-            if (string.IsNullOrWhiteSpace(assetPath) || string.IsNullOrWhiteSpace(requestedAssetPath))
+            if (string.IsNullOrEmpty(assetPath) || string.IsNullOrEmpty(requestedAssetPath))
             {
                 return false;
             }
 
-            if (!string.IsNullOrWhiteSpace(requestedGroup) &&
+            if (!string.IsNullOrEmpty(requestedGroup) &&
                 !string.Equals(group, requestedGroup, StringComparison.Ordinal))
             {
                 return false;
             }
 
-            return matchMode switch
-            {
-                PoolMatchMode.Exact => string.Equals(requestedAssetPath, assetPath, StringComparison.Ordinal),
-                PoolMatchMode.Prefix => requestedAssetPath.StartsWith(assetPath, StringComparison.Ordinal),
-                _ => false
-            };
-        }
-
-        public string BuildResolvedPoolKey(string resolvedAssetPath)
-        {
-            string concretePath = NormalizeAssetPath(resolvedAssetPath);
-            return $"{group}|{(int)matchMode}|{assetPath}|{(int)loaderType}|{concretePath}|{entryName}";
+            return matchMode == PoolMatchMode.Exact
+                ? string.Equals(requestedAssetPath, assetPath, StringComparison.Ordinal)
+                : requestedAssetPath.StartsWith(assetPath, StringComparison.Ordinal);
         }
 
         public static int CompareByPriority(PoolEntry left, PoolEntry right)
@@ -169,8 +102,8 @@ namespace AlicizaX
                 return modeCompare;
             }
 
-            int leftLength = left.assetPath?.Length ?? 0;
-            int rightLength = right.assetPath?.Length ?? 0;
+            int leftLength = left.assetPath == null ? 0 : left.assetPath.Length;
+            int rightLength = right.assetPath == null ? 0 : right.assetPath.Length;
             int pathLengthCompare = rightLength.CompareTo(leftLength);
             if (pathLengthCompare != 0)
             {
@@ -191,81 +124,344 @@ namespace AlicizaX
         }
     }
 
-    [Serializable]
-    public sealed class ResolvedPoolConfig
+    internal struct PoolCompiledRule
     {
+        public int ruleIndex;
         public string entryName;
         public string group;
         public string assetPath;
         public PoolMatchMode matchMode;
         public PoolResourceLoaderType loaderType;
-        public PoolOverflowPolicy overflowPolicy;
-        public PoolTrimPolicy trimPolicy;
-        public PoolActivationMode activationMode;
-        public PoolResetMode resetMode;
-        public int minRetained;
+        public PoolCategory category;
         public int softCapacity;
         public int hardCapacity;
-        public float idleTrimDelay;
-        public float prefabUnloadDelay;
-        public float autoRecycleDelay;
-        public int trimBatchPerTick;
-        public int warmupBatchPerFrame;
-        public float warmupFrameBudgetMs;
-        public bool allowRuntimeExpand;
-        public bool keepPrefabResident;
-        public bool aggressiveTrimOnLowMemory;
         public int priority;
 
-        public string BuildResolvedPoolKey(string resolvedAssetPath)
-        {
-            string concretePath = PoolEntry.NormalizeAssetPath(resolvedAssetPath);
-            return $"{group}|{(int)matchMode}|{assetPath}|{(int)loaderType}|{concretePath}|{entryName}";
-        }
+        public bool IsPrefix => matchMode == PoolMatchMode.Prefix;
 
-        public static ResolvedPoolConfig From(PoolEntry entry)
+        public static PoolCompiledRule FromEntry(PoolEntry entry, int ruleIndex)
         {
-            if (entry == null)
-            {
-                throw new ArgumentNullException(nameof(entry));
-            }
-
-            return new ResolvedPoolConfig
+            return new PoolCompiledRule
             {
+                ruleIndex = ruleIndex,
                 entryName = entry.entryName,
                 group = entry.group,
                 assetPath = entry.assetPath,
                 matchMode = entry.matchMode,
                 loaderType = entry.loaderType,
-                overflowPolicy = entry.overflowPolicy,
-                trimPolicy = entry.trimPolicy,
-                activationMode = entry.activationMode,
-                resetMode = entry.resetMode,
-                minRetained = entry.minRetained,
+                category = entry.category,
                 softCapacity = entry.softCapacity,
                 hardCapacity = entry.hardCapacity,
-                idleTrimDelay = entry.idleTrimDelay,
-                prefabUnloadDelay = entry.prefabUnloadDelay,
-                autoRecycleDelay = entry.autoRecycleDelay,
-                trimBatchPerTick = entry.trimBatchPerTick,
-                warmupBatchPerFrame = entry.warmupBatchPerFrame,
-                warmupFrameBudgetMs = entry.warmupFrameBudgetMs,
-                allowRuntimeExpand = entry.allowRuntimeExpand,
-                keepPrefabResident = entry.keepPrefabResident,
-                aggressiveTrimOnLowMemory = entry.aggressiveTrimOnLowMemory,
                 priority = entry.priority
             };
         }
     }
 
-    [Serializable]
-    public sealed class PoolConfigCatalog
+    internal sealed class PoolCompiledCatalog
     {
-        public readonly List<PoolEntry> entries;
+        private readonly PoolCompiledRule[] _rules;
+        private StringOpenHashMap _groupIndexMap;
+        private PoolCompiledGroup[] _groups;
+        private StringOpenHashMap _globalExactMap;
+        private PoolPrefixTrie _globalPrefixTrie;
 
-        public PoolConfigCatalog(List<PoolEntry> entries)
+        private PoolCompiledCatalog(
+            PoolCompiledRule[] rules,
+            StringOpenHashMap groupIndexMap,
+            PoolCompiledGroup[] groups,
+            StringOpenHashMap globalExactMap,
+            PoolPrefixTrie globalPrefixTrie)
         {
-            this.entries = entries ?? throw new ArgumentNullException(nameof(entries));
+            _rules = rules;
+            _groupIndexMap = groupIndexMap;
+            _groups = groups;
+            _globalExactMap = globalExactMap;
+            _globalPrefixTrie = globalPrefixTrie;
+        }
+
+        public bool IsEmpty => _rules == null || _rules.Length == 0;
+
+        public int RuleCount => _rules == null ? 0 : _rules.Length;
+
+        public ref readonly PoolCompiledRule GetRule(int ruleIndex)
+        {
+            return ref _rules[ruleIndex];
+        }
+
+        public int Resolve(string assetPath, string group)
+        {
+            if (string.IsNullOrEmpty(assetPath) || _rules == null || _rules.Length == 0)
+            {
+                return -1;
+            }
+
+            if (!string.IsNullOrEmpty(group))
+            {
+                if (_groupIndexMap.TryGetValue(group, out int groupIndex))
+                {
+                    return _groups[groupIndex].Resolve(assetPath);
+                }
+
+                return -1;
+            }
+
+            if (_globalExactMap.TryGetValue(assetPath, out int exactRuleIndex))
+            {
+                return exactRuleIndex;
+            }
+
+            return _globalPrefixTrie.Resolve(assetPath);
+        }
+
+        public static PoolCompiledCatalog Empty()
+        {
+            return new PoolCompiledCatalog(
+                Array.Empty<PoolCompiledRule>(),
+                new StringOpenHashMap(8),
+                Array.Empty<PoolCompiledGroup>(),
+                new StringOpenHashMap(8),
+                new PoolPrefixTrie(0));
+        }
+
+        public static PoolCompiledCatalog Build(PoolEntry[] entries)
+        {
+            if (entries == null || entries.Length == 0)
+            {
+                return Empty();
+            }
+
+            int entryCount = entries.Length;
+            var groupIndexMap = new StringOpenHashMap(entryCount);
+            var groupNames = new string[entryCount];
+            var groupPrefixChars = new int[entryCount];
+            int groupCount = 0;
+            int globalPrefixChars = 0;
+
+            for (int i = 0; i < entryCount; i++)
+            {
+                PoolEntry entry = entries[i];
+                if (entry == null || string.IsNullOrEmpty(entry.assetPath))
+                {
+                    continue;
+                }
+
+                if (!groupIndexMap.TryGetValue(entry.group, out int groupIndex))
+                {
+                    groupIndex = groupCount;
+                    groupIndexMap.AddOrUpdate(entry.group, groupIndex);
+                    groupNames[groupCount] = entry.group;
+                    groupCount++;
+                }
+
+                if (entry.matchMode == PoolMatchMode.Prefix)
+                {
+                    int pathLength = entry.assetPath.Length;
+                    groupPrefixChars[groupIndex] += pathLength;
+                    globalPrefixChars += pathLength;
+                }
+            }
+
+            var groups = new PoolCompiledGroup[groupCount];
+            for (int i = 0; i < groupCount; i++)
+            {
+                groups[i] = new PoolCompiledGroup(groupNames[i], entryCount, groupPrefixChars[i]);
+            }
+
+            var rules = new PoolCompiledRule[entryCount];
+            var globalExactMap = new StringOpenHashMap(entryCount);
+            var globalPrefixTrie = new PoolPrefixTrie(globalPrefixChars);
+
+            for (int i = 0; i < entryCount; i++)
+            {
+                PoolEntry entry = entries[i];
+                if (entry == null || string.IsNullOrEmpty(entry.assetPath))
+                {
+                    continue;
+                }
+
+                PoolCompiledRule rule = PoolCompiledRule.FromEntry(entry, i);
+                rules[i] = rule;
+
+                groupIndexMap.TryGetValue(rule.group, out int groupIndex);
+                groups[groupIndex].Register(rule);
+
+                if (rule.matchMode == PoolMatchMode.Exact)
+                {
+                    if (!globalExactMap.TryGetValue(rule.assetPath, out _))
+                    {
+                        globalExactMap.AddOrUpdate(rule.assetPath, i);
+                    }
+                }
+                else
+                {
+                    globalPrefixTrie.Register(rule.assetPath, i);
+                }
+            }
+
+            return new PoolCompiledCatalog(rules, groupIndexMap, groups, globalExactMap, globalPrefixTrie);
+        }
+    }
+
+    internal sealed class PoolCompiledGroup
+    {
+        private readonly string _name;
+        private StringOpenHashMap _exactMap;
+        private PoolPrefixTrie _prefixTrie;
+
+        public PoolCompiledGroup(string name, int exactCapacity, int prefixChars)
+        {
+            _name = name;
+            _exactMap = new StringOpenHashMap(exactCapacity);
+            _prefixTrie = new PoolPrefixTrie(prefixChars);
+        }
+
+        public void Register(in PoolCompiledRule rule)
+        {
+            if (rule.matchMode == PoolMatchMode.Exact)
+            {
+                if (!_exactMap.TryGetValue(rule.assetPath, out _))
+                {
+                    _exactMap.AddOrUpdate(rule.assetPath, rule.ruleIndex);
+                }
+
+                return;
+            }
+
+            _prefixTrie.Register(rule.assetPath, rule.ruleIndex);
+        }
+
+        public int Resolve(string assetPath)
+        {
+            if (_exactMap.TryGetValue(assetPath, out int exactRuleIndex))
+            {
+                return exactRuleIndex;
+            }
+
+            return _prefixTrie.Resolve(assetPath);
+        }
+    }
+
+    internal sealed class PoolPrefixTrie
+    {
+        private struct Node
+        {
+            public char character;
+            public int firstChild;
+            public int nextSibling;
+            public int ruleIndex;
+        }
+
+        private Node[] _nodes;
+        private int _nodeCount;
+
+        public PoolPrefixTrie(int prefixCharCount)
+        {
+            int capacity = Mathf.Max(1, prefixCharCount + 1);
+            _nodes = new Node[capacity];
+            _nodes[0].firstChild = -1;
+            _nodes[0].nextSibling = -1;
+            _nodes[0].ruleIndex = -1;
+            _nodeCount = 1;
+        }
+
+        public void Register(string prefix, int ruleIndex)
+        {
+            if (string.IsNullOrEmpty(prefix))
+            {
+                return;
+            }
+
+            int nodeIndex = 0;
+            int length = prefix.Length;
+            for (int i = 0; i < length; i++)
+            {
+                nodeIndex = GetOrCreateChild(nodeIndex, prefix[i]);
+            }
+
+            if (_nodes[nodeIndex].ruleIndex < 0)
+            {
+                _nodes[nodeIndex].ruleIndex = ruleIndex;
+            }
+        }
+
+        public int Resolve(string value)
+        {
+            if (string.IsNullOrEmpty(value) || _nodes == null)
+            {
+                return -1;
+            }
+
+            int nodeIndex = 0;
+            int bestRuleIndex = -1;
+            int length = value.Length;
+            for (int i = 0; i < length; i++)
+            {
+                nodeIndex = FindChild(nodeIndex, value[i]);
+                if (nodeIndex < 0)
+                {
+                    break;
+                }
+
+                int matchedRuleIndex = _nodes[nodeIndex].ruleIndex;
+                if (matchedRuleIndex >= 0)
+                {
+                    bestRuleIndex = matchedRuleIndex;
+                }
+            }
+
+            return bestRuleIndex;
+        }
+
+        private int GetOrCreateChild(int nodeIndex, char character)
+        {
+            int childIndex = _nodes[nodeIndex].firstChild;
+            while (childIndex >= 0)
+            {
+                if (_nodes[childIndex].character == character)
+                {
+                    return childIndex;
+                }
+
+                childIndex = _nodes[childIndex].nextSibling;
+            }
+
+            EnsureCapacity(_nodeCount + 1);
+            int newNodeIndex = _nodeCount++;
+            _nodes[newNodeIndex].character = character;
+            _nodes[newNodeIndex].firstChild = -1;
+            _nodes[newNodeIndex].nextSibling = _nodes[nodeIndex].firstChild;
+            _nodes[newNodeIndex].ruleIndex = -1;
+            _nodes[nodeIndex].firstChild = newNodeIndex;
+            return newNodeIndex;
+        }
+
+        private int FindChild(int nodeIndex, char character)
+        {
+            int childIndex = _nodes[nodeIndex].firstChild;
+            while (childIndex >= 0)
+            {
+                if (_nodes[childIndex].character == character)
+                {
+                    return childIndex;
+                }
+
+                childIndex = _nodes[childIndex].nextSibling;
+            }
+
+            return -1;
+        }
+
+        private void EnsureCapacity(int required)
+        {
+            if (_nodes.Length >= required)
+            {
+                return;
+            }
+
+            int newCapacity = Mathf.Max(required, _nodes.Length << 1);
+            var newNodes = new Node[newCapacity];
+            Array.Copy(_nodes, 0, newNodes, 0, _nodeCount);
+            _nodes = newNodes;
         }
     }
 }
diff --git a/Runtime/ABase/GameObjectPool/Data/PoolConfigScriptableObject.cs b/Runtime/ABase/GameObjectPool/Data/PoolConfigScriptableObject.cs
index dde4a05..eed7519 100644
--- a/Runtime/ABase/GameObjectPool/Data/PoolConfigScriptableObject.cs
+++ b/Runtime/ABase/GameObjectPool/Data/PoolConfigScriptableObject.cs
@@ -1,31 +1,53 @@
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
 namespace AlicizaX
 {
     [CreateAssetMenu(fileName = "PoolConfig", menuName = "GameplaySystem/PoolConfig", order = 10)]
-    public class PoolConfigScriptableObject : ScriptableObject
+    public sealed class PoolConfigScriptableObject : ScriptableObject
     {
         public List<PoolEntry> entries = new List<PoolEntry>();
 
-        public PoolConfigCatalog BuildCatalog()
+        internal PoolCompiledCatalog BuildCatalog()
         {
             Normalize();
 
-            var normalizedEntries = new List<PoolEntry>(entries.Count);
+            if (entries == null || entries.Count == 0)
+            {
+                return PoolCompiledCatalog.Empty();
+            }
+
+            int validCount = 0;
             for (int i = 0; i < entries.Count; i++)
             {
                 PoolEntry entry = entries[i];
-                if (entry == null)
+                if (entry != null && !string.IsNullOrEmpty(entry.assetPath))
+                {
+                    validCount++;
+                }
+            }
+
+            if (validCount == 0)
+            {
+                return PoolCompiledCatalog.Empty();
+            }
+
+            var normalizedEntries = new PoolEntry[validCount];
+            int writeIndex = 0;
+            for (int i = 0; i < entries.Count; i++)
+            {
+                PoolEntry entry = entries[i];
+                if (entry == null || string.IsNullOrEmpty(entry.assetPath))
                 {
                     continue;
                 }
 
-                normalizedEntries.Add(entry);
+                normalizedEntries[writeIndex++] = entry;
             }
 
-            normalizedEntries.Sort(PoolEntry.CompareByPriority);
-            return new PoolConfigCatalog(normalizedEntries);
+            Array.Sort(normalizedEntries, PoolEntry.CompareByPriority);
+            return PoolCompiledCatalog.Build(normalizedEntries);
         }
 
         public void Normalize()
@@ -33,6 +55,7 @@ namespace AlicizaX
             if (entries == null)
             {
                 entries = new List<PoolEntry>();
+                return;
             }
 
             for (int i = 0; i < entries.Count; i++)
diff --git a/Runtime/ABase/GameObjectPool/GameObjectPoolManager.cs b/Runtime/ABase/GameObjectPool/GameObjectPoolManager.cs
index 88a535f..3da008a 100644
--- a/Runtime/ABase/GameObjectPool/GameObjectPoolManager.cs
+++ b/Runtime/ABase/GameObjectPool/GameObjectPoolManager.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
+using AlicizaX.ObjectPool;
 using AlicizaX.Resource.Runtime;
+using Cysharp.Text;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 
@@ -9,48 +11,59 @@ namespace AlicizaX
 {
     public sealed class GameObjectPoolManager : MonoServiceBehaviour<AppScope>
     {
-        private static readonly Comparison<GameObjectPoolSnapshot> SnapshotComparer = (left, right) =>
+        private enum BootstrapState : byte
         {
-            if (left == null && right == null) return 0;
-            if (left == null) return 1;
-            if (right == null) return -1;
-            int groupCompare = string.Compare(left.group, right.group, StringComparison.Ordinal);
-            return groupCompare != 0 ? groupCompare : string.Compare(left.assetPath, right.assetPath, StringComparison.Ordinal);
-        };
+            Waiting = 0,
+            Ready = 1
+        }
 
-        [Header("Cleanup Interval")] public float checkInterval = 5f;
-        [Header("Config Path")] public string poolConfigPath = "Assets/Bundles/Configs/PoolConfig";
-        [Header("Show Detailed Info")] public bool showDetailedInfo = true;
-        [SerializeField] internal Transform poolContainer;
+        private struct MaintenanceNode
+        {
+            public float dueTime;
+            public int poolIndex;
+        }
 
-        private const PoolResourceLoaderType DefaultDirectLoadResourceLoaderType = PoolResourceLoaderType.AssetBundle;
+        private static readonly Comparison<GameObjectPoolSnapshot> SnapshotComparer = CompareSnapshot;
+        private const PoolResourceLoaderType DefaultDirectLoader = PoolResourceLoaderType.AssetBundle;
 
-        private readonly Dictionary<string, RuntimePrefabPool> _poolsByKey = new Dictionary<string, RuntimePrefabPool>(StringComparer.Ordinal);
-        private readonly Dictionary<string, ResolvedPoolConfig> _resolvedConfigCache = new Dictionary<string, ResolvedPoolConfig>(StringComparer.Ordinal);
-        private readonly Dictionary<string, RuntimePrefabPool> _ownersByObject = new Dictionary<string, RuntimePrefabPool>(StringComparer.Ordinal);
-        private readonly Dictionary<PoolResourceLoaderType, IResourceLoader> _resourceLoaders = new Dictionary<PoolResourceLoaderType, IResourceLoader>();
-        private readonly List<PoolEntry> _entries = new List<PoolEntry>();
-        private readonly List<GameObjectPoolSnapshot> _debugSnapshots = new List<GameObjectPoolSnapshot>();
+        [Header("Config Path")]
+        public string poolConfigPath = "Assets/Bundles/Configs/PoolConfig";
 
+        [Header("Show Detailed Info")]
+        public bool showDetailedInfo = true;
+
+        [SerializeField]
+        internal Transform poolContainer;
+
+        private readonly IResourceLoader[] _resourceLoaders = new IResourceLoader[2];
+        private readonly List<GameObjectPoolSnapshot> _debugSnapshots = new List<GameObjectPoolSnapshot>(16);
+
+        private RuntimeGameObjectPool[] _pools = new RuntimeGameObjectPool[8];
+        private int _poolCount;
+        private PoolCompiledCatalog _catalog = PoolCompiledCatalog.Empty();
+        private StringOpenHashMap[] _rulePoolMaps = Array.Empty<StringOpenHashMap>();
+        private bool[] _rulePoolMapInitialized = Array.Empty<bool>();
+        private StringOpenHashMap _directLoadWarnedPaths = new StringOpenHashMap(8);
+        private StringOpenHashMap _groupRootMap = new StringOpenHashMap(8);
+        private Transform[] _groupRoots = new Transform[4];
+        private int _groupRootCount;
+        private BootstrapState _bootstrapState;
         private CancellationTokenSource _shutdownTokenSource;
-        private UniTask _initializeTask;
-        private bool _initializationCompleted;
-        private Exception _initializationException;
-        private bool _cleanupScheduled;
-        private float _nextCleanupTime = float.MaxValue;
-        private bool _isShuttingDown;
-        private bool _aggressiveCleanupRequested;
 
-        public bool IsReady => _initializationCompleted && _initializationException == null;
+        private MaintenanceNode[] _maintenanceHeap = new MaintenanceNode[8];
+        private int _maintenanceCount;
+
+        public bool IsReady => _bootstrapState == BootstrapState.Ready;
+        internal CancellationToken ShutdownToken => _shutdownTokenSource == null ? default : _shutdownTokenSource.Token;
 
         protected override void OnInitialize()
         {
             _shutdownTokenSource = new CancellationTokenSource();
             EnsureDefaultResourceLoaders();
             EnsurePoolContainer();
-            enabled = false;
             Application.lowMemory += OnLowMemory;
-            _initializeTask = InitializeAsync(_shutdownTokenSource.Token);
+            _bootstrapState = BootstrapState.Waiting;
+            enabled = true;
         }
 
         protected override void OnDestroyService()
@@ -69,42 +82,22 @@ namespace AlicizaX
             _shutdownTokenSource = null;
         }
 
-        private async UniTask InitializeAsync(CancellationToken cancellationToken)
-        {
-            try
-            {
-                await UniTask.WaitUntil(() => YooAsset.YooAssets.Initialized, cancellationToken: cancellationToken);
-                LoadConfigs();
-                _initializationCompleted = true;
-                ScheduleCleanup();
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                _initializationException = exception;
-                _initializationCompleted = true;
-                Log.Error($"GameObjectPool initialization failed: {exception}");
-            }
-        }
-
         private void Update()
         {
-            if (!IsReady || !_cleanupScheduled)
+            if (_bootstrapState == BootstrapState.Waiting)
             {
-                enabled = false;
+                TryBootstrap();
+            }
+
+            if (_bootstrapState != BootstrapState.Ready)
+            {
+                enabled = true;
                 return;
             }
 
-            if (Time.time < _nextCleanupTime)
-            {
-                return;
-            }
-
-            PerformCleanup(_aggressiveCleanupRequested);
-            _aggressiveCleanupRequested = false;
-            ScheduleCleanup();
+            float now = Time.time;
+            ProcessDueMaintenance(now);
+            enabled = _bootstrapState == BootstrapState.Waiting || _maintenanceCount > 0;
         }
 
         public void SetResourceLoader(IResourceLoader resourceLoader)
@@ -119,164 +112,26 @@ namespace AlicizaX
                 throw new ArgumentNullException(nameof(resourceLoader));
             }
 
-            _resourceLoaders[loaderType] = resourceLoader;
+            _resourceLoaders[(int)loaderType] = resourceLoader;
         }
 
-        public GameObject GetGameObject(string assetPath, Transform parent = null, object userData = null)
+        public GameObject GetGameObject(string assetPath, Transform parent = null)
         {
             EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = PoolSpawnContext.Create(normalized, null, parent, userData);
-            return GetGameObjectInternal(normalized, null, context);
-        }
-
-        public GameObject GetGameObject(string assetPath, in PoolSpawnContext context)
-        {
-            EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext resolvedContext = new PoolSpawnContext(
-                normalized,
-                context.Group,
-                context.Parent,
-                context.Position,
-                context.Rotation,
-                context.UserData,
-                context.OwnerId,
-                context.TeamId,
-                context.SpawnFrame == 0 ? (uint)Time.frameCount : context.SpawnFrame);
-            return GetGameObjectInternal(normalized, context.Group, resolvedContext);
-        }
-
-        public GameObject GetGameObject(
-            string assetPath,
-            Vector3 position,
-            Quaternion rotation,
-            Transform parent = null,
-            object userData = null)
-        {
-            EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = new PoolSpawnContext(
-                normalized,
-                null,
-                parent,
-                position,
-                rotation,
-                userData,
-                spawnFrame: (uint)Time.frameCount);
-            return GetGameObjectInternal(normalized, null, context);
-        }
-
-        public GameObject GetGameObjectByGroup(string group, string assetPath, Transform parent = null, object userData = null)
-        {
-            EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = PoolSpawnContext.Create(normalized, group, parent, userData);
-            return GetGameObjectInternal(normalized, group, context);
-        }
-
-        public GameObject GetGameObjectByGroup(string group, string assetPath, in PoolSpawnContext context)
-        {
-            EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext resolvedContext = new PoolSpawnContext(
-                normalized,
-                group,
-                context.Parent,
-                context.Position,
-                context.Rotation,
-                context.UserData,
-                context.OwnerId,
-                context.TeamId,
-                context.SpawnFrame == 0 ? (uint)Time.frameCount : context.SpawnFrame);
-            return GetGameObjectInternal(normalized, group, resolvedContext);
-        }
-
-        public GameObject GetGameObjectByGroup(
-            string group,
-            string assetPath,
-            Vector3 position,
-            Quaternion rotation,
-            Transform parent = null,
-            object userData = null)
-        {
-            EnsureReadyForSyncUse();
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = new PoolSpawnContext(
-                normalized,
-                group,
-                parent,
-                position,
-                rotation,
-                userData,
-                spawnFrame: (uint)Time.frameCount);
-            return GetGameObjectInternal(normalized, group, context);
+            string normalizedAssetPath = PoolEntry.NormalizeAssetPath(assetPath);
+            PoolSpawnContext context = PoolSpawnContext.Create(normalizedAssetPath, parent);
+            return GetGameObjectInternal(normalizedAssetPath, context);
         }
 
         public async UniTask<GameObject> GetGameObjectAsync(
             string assetPath,
             Transform parent = null,
-            object userData = null,
             CancellationToken cancellationToken = default)
         {
-            await EnsureInitializedAsync(cancellationToken);
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = PoolSpawnContext.Create(normalized, null, parent, userData);
-            return await GetGameObjectInternalAsync(normalized, null, context, cancellationToken);
-        }
-
-        public async UniTask<GameObject> GetGameObjectAsync(
-            string assetPath,
-            PoolSpawnContext context,
-            CancellationToken cancellationToken = default)
-        {
-            await EnsureInitializedAsync(cancellationToken);
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext resolvedContext = new PoolSpawnContext(
-                normalized,
-                context.Group,
-                context.Parent,
-                context.Position,
-                context.Rotation,
-                context.UserData,
-                context.OwnerId,
-                context.TeamId,
-                context.SpawnFrame == 0 ? (uint)Time.frameCount : context.SpawnFrame);
-            return await GetGameObjectInternalAsync(normalized, context.Group, resolvedContext, cancellationToken);
-        }
-
-        public async UniTask<GameObject> GetGameObjectAsyncByGroup(
-            string group,
-            string assetPath,
-            Transform parent = null,
-            object userData = null,
-            CancellationToken cancellationToken = default)
-        {
-            await EnsureInitializedAsync(cancellationToken);
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext context = PoolSpawnContext.Create(normalized, group, parent, userData);
-            return await GetGameObjectInternalAsync(normalized, group, context, cancellationToken);
-        }
-
-        public async UniTask<GameObject> GetGameObjectAsyncByGroup(
-            string group,
-            string assetPath,
-            PoolSpawnContext context,
-            CancellationToken cancellationToken = default)
-        {
-            await EnsureInitializedAsync(cancellationToken);
-            string normalized = PoolEntry.NormalizeAssetPath(assetPath);
-            PoolSpawnContext resolvedContext = new PoolSpawnContext(
-                normalized,
-                group,
-                context.Parent,
-                context.Position,
-                context.Rotation,
-                context.UserData,
-                context.OwnerId,
-                context.TeamId,
-                context.SpawnFrame == 0 ? (uint)Time.frameCount : context.SpawnFrame);
-            return await GetGameObjectInternalAsync(normalized, group, resolvedContext, cancellationToken);
+            await EnsureReadyAsync(cancellationToken);
+            string normalizedAssetPath = PoolEntry.NormalizeAssetPath(assetPath);
+            PoolSpawnContext context = PoolSpawnContext.Create(normalizedAssetPath, parent);
+            return await GetGameObjectInternalAsync(normalizedAssetPath, context, cancellationToken);
         }
 
         public void Release(GameObject gameObject)
@@ -286,140 +141,227 @@ namespace AlicizaX
                 return;
             }
 
-            string instanceKey = GetInstanceKey(gameObject);
-            if (_ownersByObject.TryGetValue(instanceKey, out RuntimePrefabPool pool))
+            if (gameObject.TryGetComponent(out GameObjectPoolHandle handle) && handle.TryRelease())
             {
-                pool.Release(gameObject);
                 return;
             }
 
-            Log.Warning($"Trying to release untracked GameObject '{gameObject.name}'. Destroying it.");
             Destroy(gameObject);
         }
 
         public async UniTask PreloadAsync(string assetPath, int count = 1, CancellationToken cancellationToken = default)
         {
-            await EnsureInitializedAsync(cancellationToken);
-            await PreloadInternalAsync(PoolEntry.NormalizeAssetPath(assetPath), null, count, cancellationToken);
-        }
-
-        public async UniTask PreloadAsyncByGroup(
-            string group,
-            string assetPath,
-            int count = 1,
-            CancellationToken cancellationToken = default)
-        {
-            await EnsureInitializedAsync(cancellationToken);
-            await PreloadInternalAsync(PoolEntry.NormalizeAssetPath(assetPath), group, count, cancellationToken);
+            await EnsureReadyAsync(cancellationToken);
+            await PreloadInternalAsync(PoolEntry.NormalizeAssetPath(assetPath), count, cancellationToken);
         }
 
         public void ForceCleanup()
         {
-            if (!IsReady)
+            if (_bootstrapState != BootstrapState.Ready)
             {
                 return;
             }
 
-            PerformCleanup(false);
-            ScheduleCleanup();
+            float now = Time.time;
+            for (int i = 0; i < _poolCount; i++)
+            {
+                RuntimeGameObjectPool pool = _pools[i];
+                if (pool != null)
+                {
+                    pool.ExecuteMaintenance(now, false);
+                }
+            }
         }
 
         public void ClearAllPools()
         {
-            _isShuttingDown = true;
-            foreach (RuntimePrefabPool pool in _poolsByKey.Values)
+            for (int i = 0; i < _poolCount; i++)
             {
+                RuntimeGameObjectPool pool = _pools[i];
+                if (pool == null)
+                {
+                    continue;
+                }
+
                 pool.Shutdown();
                 MemoryPool.Release(pool);
+                _pools[i] = null;
             }
 
-            _isShuttingDown = false;
-            _poolsByKey.Clear();
-            _ownersByObject.Clear();
-            _resolvedConfigCache.Clear();
-            _entries.Clear();
+            _poolCount = 0;
+            _maintenanceCount = 0;
+
+            for (int i = 0; i < _rulePoolMapInitialized.Length; i++)
+            {
+                if (_rulePoolMapInitialized[i])
+                {
+                    _rulePoolMaps[i].Clear();
+                }
+            }
+
+            ClearGroupRoots();
+            _directLoadWarnedPaths.Clear();
             ReleaseDebugSnapshots();
-            _cleanupScheduled = false;
-            _nextCleanupTime = float.MaxValue;
-            enabled = false;
+        }
+
+        public GameObjectPoolSummarySnapshot GetDebugSummary()
+        {
+            int loadedPrefabCount = 0;
+            int totalInstanceCount = 0;
+            int activeInstanceCount = 0;
+            int inactiveInstanceCount = 0;
+
+            for (int i = 0; i < _poolCount; i++)
+            {
+                RuntimeGameObjectPool pool = _pools[i];
+                if (pool == null)
+                {
+                    continue;
+                }
+
+                if (pool.IsPrefabLoaded)
+                {
+                    loadedPrefabCount++;
+                }
+
+                totalInstanceCount += pool.TotalCount;
+                activeInstanceCount += pool.ActiveCount;
+                inactiveInstanceCount += pool.InactiveCount;
+            }
+
+            return new GameObjectPoolSummarySnapshot(
+                _bootstrapState == BootstrapState.Ready,
+                _bootstrapState == BootstrapState.Waiting,
+                _poolCount,
+                loadedPrefabCount,
+                totalInstanceCount,
+                activeInstanceCount,
+                inactiveInstanceCount,
+                _maintenanceCount);
         }
 
         public List<GameObjectPoolSnapshot> GetDebugSnapshots()
         {
             ReleaseDebugSnapshots();
 
-            foreach (RuntimePrefabPool pool in _poolsByKey.Values)
+            for (int i = 0; i < _poolCount; i++)
             {
-                _debugSnapshots.Add(pool.CreateSnapshot());
+                RuntimeGameObjectPool pool = _pools[i];
+                if (pool != null)
+                {
+                    _debugSnapshots.Add(pool.CreateSnapshot());
+                }
             }
 
             _debugSnapshots.Sort(SnapshotComparer);
             return _debugSnapshots;
         }
 
-        internal void RegisterOwnedObject(GameObject gameObject, RuntimePrefabPool pool)
+        internal void ScheduleMaintenance(int poolIndex, float dueTime, ref int heapIndex)
         {
-            if (gameObject == null || pool == null)
+            if (dueTime >= float.MaxValue)
             {
+                RemoveMaintenance(ref heapIndex);
                 return;
             }
 
-            _ownersByObject[GetInstanceKey(gameObject)] = pool;
-            NotifyPoolStateChanged();
-        }
-
-        internal void UnregisterOwnedObject(GameObject gameObject)
-        {
-            if (gameObject == null || _isShuttingDown)
+            if (heapIndex >= 0)
             {
+                _maintenanceHeap[heapIndex].dueTime = dueTime;
+                _maintenanceHeap[heapIndex].poolIndex = poolIndex;
+                SiftMaintenanceUp(heapIndex);
+                SiftMaintenanceDown(heapIndex);
+                enabled = true;
                 return;
             }
 
-            _ownersByObject.Remove(GetInstanceKey(gameObject));
-            NotifyPoolStateChanged();
+            EnsureMaintenanceCapacity(_maintenanceCount + 1);
+            int insertIndex = _maintenanceCount++;
+            _maintenanceHeap[insertIndex].dueTime = dueTime;
+            _maintenanceHeap[insertIndex].poolIndex = poolIndex;
+            heapIndex = insertIndex;
+            _pools[poolIndex].SetMaintenanceHeapIndex(insertIndex);
+            SiftMaintenanceUp(insertIndex);
+            enabled = true;
         }
 
-        internal void NotifyPoolStateChanged()
+        internal void RemoveMaintenance(ref int heapIndex)
         {
-            if (!IsReady)
+            if (heapIndex < 0 || heapIndex >= _maintenanceCount)
             {
+                heapIndex = -1;
                 return;
             }
 
-            ScheduleCleanup();
+            RemoveMaintenanceAt(heapIndex);
+            heapIndex = -1;
         }
 
-        private GameObject GetGameObjectInternal(string assetPath, string group, PoolSpawnContext context)
+        private bool TryBootstrap()
         {
-            ResolvedPoolConfig config = ResolveConfig(assetPath, group);
-            if (config == null)
+            if (_bootstrapState == BootstrapState.Ready)
             {
-                return LoadUnpooled(assetPath, group, context.Parent);
+                return true;
             }
 
-            RuntimePrefabPool pool = GetOrCreatePool(config, assetPath);
-            return pool.Acquire(context);
+            if (!YooAsset.YooAssets.Initialized)
+            {
+                return false;
+            }
+
+            LoadCatalog();
+            _bootstrapState = BootstrapState.Ready;
+            enabled = _maintenanceCount > 0;
+            return true;
+        }
+
+        private void LoadCatalog()
+        {
+            IResourceService resourceService = AppServices.Require<IResourceService>();
+            PoolConfigScriptableObject configAsset = resourceService.LoadAsset<PoolConfigScriptableObject>(poolConfigPath);
+            _catalog = configAsset == null ? PoolCompiledCatalog.Empty() : configAsset.BuildCatalog();
+            if (configAsset != null)
+            {
+                resourceService.UnloadAsset(configAsset);
+            }
+
+            _rulePoolMaps = _catalog.RuleCount == 0 ? Array.Empty<StringOpenHashMap>() : new StringOpenHashMap[_catalog.RuleCount];
+            _rulePoolMapInitialized = _catalog.RuleCount == 0 ? Array.Empty<bool>() : new bool[_catalog.RuleCount];
+        }
+
+        private GameObject GetGameObjectInternal(string assetPath, in PoolSpawnContext context)
+        {
+            int ruleIndex = _catalog.Resolve(assetPath, null);
+            if (ruleIndex < 0)
+            {
+                WarnDirectLoadFallback(assetPath);
+                return LoadDirect(assetPath, context.Parent);
+            }
+
+            ref readonly PoolCompiledRule rule = ref _catalog.GetRule(ruleIndex);
+            RuntimeGameObjectPool pool = GetOrCreatePool(ruleIndex, assetPath);
+            return pool.Acquire(context.WithGroup(rule.group));
         }
 
         private async UniTask<GameObject> GetGameObjectInternalAsync(
             string assetPath,
-            string group,
             PoolSpawnContext context,
             CancellationToken cancellationToken)
         {
-            ResolvedPoolConfig config = ResolveConfig(assetPath, group);
-            if (config == null)
+            int ruleIndex = _catalog.Resolve(assetPath, null);
+            if (ruleIndex < 0)
             {
-                return await LoadUnpooledAsync(assetPath, group, context.Parent, cancellationToken);
+                WarnDirectLoadFallback(assetPath);
+                return await LoadDirectAsync(assetPath, context.Parent, cancellationToken);
             }
 
-            RuntimePrefabPool pool = GetOrCreatePool(config, assetPath);
-            return await pool.AcquireAsync(context, cancellationToken);
+            string ruleGroup = _catalog.GetRule(ruleIndex).group;
+            RuntimeGameObjectPool pool = GetOrCreatePool(ruleIndex, assetPath);
+            return await pool.AcquireAsync(context.WithGroup(ruleGroup), cancellationToken);
         }
 
         private async UniTask PreloadInternalAsync(
             string assetPath,
-            string group,
             int count,
             CancellationToken cancellationToken)
         {
@@ -428,97 +370,74 @@ namespace AlicizaX
                 return;
             }
 
-            ResolvedPoolConfig config = ResolveConfig(assetPath, group);
-            if (config == null)
+            int ruleIndex = _catalog.Resolve(assetPath, null);
+            if (ruleIndex < 0)
             {
-                Log.Warning($"Asset '{assetPath}' has no matching pool rule. Preload skipped.");
+                WarnDirectLoadFallback(assetPath);
                 return;
             }
 
-            RuntimePrefabPool pool = GetOrCreatePool(config, assetPath);
+            RuntimeGameObjectPool pool = GetOrCreatePool(ruleIndex, assetPath);
             await pool.WarmupAsync(count, cancellationToken);
         }
 
-        private RuntimePrefabPool GetOrCreatePool(ResolvedPoolConfig config, string assetPath)
+        private RuntimeGameObjectPool GetOrCreatePool(int ruleIndex, string assetPath)
         {
-            EnsurePoolContainer();
-
-            string poolKey = config.BuildResolvedPoolKey(assetPath);
-            if (_poolsByKey.TryGetValue(poolKey, out RuntimePrefabPool existingPool))
+            if (!_rulePoolMapInitialized[ruleIndex])
             {
-                return existingPool;
+                _rulePoolMaps[ruleIndex] = new StringOpenHashMap(4);
+                _rulePoolMapInitialized[ruleIndex] = true;
             }
 
-            var pool = MemoryPool.Acquire<RuntimePrefabPool>();
-            pool.Initialize(
-                config,
-                assetPath,
-                GetResourceLoader(config.loaderType),
-                this,
-                _shutdownTokenSource != null ? _shutdownTokenSource.Token : default);
+            if (_rulePoolMaps[ruleIndex].TryGetValue(assetPath, out int poolIndex))
+            {
+                return _pools[poolIndex];
+            }
 
-            _poolsByKey.Add(poolKey, pool);
-            ScheduleCleanup();
+            EnsurePoolCapacity(_poolCount + 1);
+            ref readonly PoolCompiledRule rule = ref _catalog.GetRule(ruleIndex);
+            var pool = MemoryPool.Acquire<RuntimeGameObjectPool>();
+            pool.Initialize(this, _poolCount, rule, assetPath, GetResourceLoader(rule.loaderType), GetOrCreateGroupRoot(rule.group));
+            _pools[_poolCount] = pool;
+            _rulePoolMaps[ruleIndex].AddOrUpdate(assetPath, _poolCount);
+            _poolCount++;
+            enabled = true;
             return pool;
         }
 
-        private void PerformCleanup(bool aggressive)
+        private GameObject LoadDirect(string assetPath, Transform parent)
         {
-            foreach (RuntimePrefabPool pool in _poolsByKey.Values)
-            {
-                pool.Trim(aggressive ? int.MaxValue : 0, aggressive);
-            }
+            IResourceLoader loader = GetResourceLoader(DefaultDirectLoader);
+            return loader.LoadGameObject(assetPath, parent);
         }
 
-        private void ScheduleCleanup()
+        private async UniTask<GameObject> LoadDirectAsync(string assetPath, Transform parent, CancellationToken cancellationToken)
         {
-            if (!IsReady)
-            {
-                _cleanupScheduled = false;
-                _nextCleanupTime = float.MaxValue;
-                enabled = false;
-                return;
-            }
-
-            float now = Time.time;
-            bool hasWork = false;
-            float nextDueTime = now + Mathf.Max(checkInterval, 0.1f);
-            foreach (RuntimePrefabPool pool in _poolsByKey.Values)
-            {
-                if (pool.NeedsTrim(now) || pool.NeedsPrefabUnload(now, false))
-                {
-                    hasWork = true;
-                    break;
-                }
-            }
-
-            _nextCleanupTime = hasWork ? nextDueTime : float.MaxValue;
-            _cleanupScheduled = hasWork;
-            enabled = hasWork;
+            IResourceLoader loader = GetResourceLoader(DefaultDirectLoader);
+            return await loader.LoadGameObjectAsync(assetPath, parent, cancellationToken);
         }
 
-        private void OnLowMemory()
+        private IResourceLoader GetResourceLoader(PoolResourceLoaderType loaderType)
         {
-            if (!IsReady)
+            IResourceLoader loader = _resourceLoaders[(int)loaderType];
+            if (loader == null)
             {
-                return;
+                throw new InvalidOperationException(ZString.Format("Resource loader not registered: {0}.", loaderType));
             }
 
-            _aggressiveCleanupRequested = true;
-            PerformCleanup(true);
-            ScheduleCleanup();
+            return loader;
         }
 
         private void EnsureDefaultResourceLoaders()
         {
-            if (!_resourceLoaders.ContainsKey(PoolResourceLoaderType.AssetBundle))
+            if (_resourceLoaders[(int)PoolResourceLoaderType.AssetBundle] == null)
             {
-                _resourceLoaders[PoolResourceLoaderType.AssetBundle] = new AssetBundleResourceLoader();
+                _resourceLoaders[(int)PoolResourceLoaderType.AssetBundle] = new AssetBundleResourceLoader();
             }
 
-            if (!_resourceLoaders.ContainsKey(PoolResourceLoaderType.Resources))
+            if (_resourceLoaders[(int)PoolResourceLoaderType.Resources] == null)
             {
-                _resourceLoaders[PoolResourceLoaderType.Resources] = new UnityResourcesLoader();
+                _resourceLoaders[(int)PoolResourceLoaderType.Resources] = new UnityResourcesLoader();
             }
         }
 
@@ -529,126 +448,227 @@ namespace AlicizaX
                 return;
             }
 
-            var container = new GameObject("GameObjectPoolContainer");
+            GameObject container = new GameObject("GameObjectPoolContainer");
             poolContainer = container.transform;
             poolContainer.SetParent(transform, false);
         }
 
-        private void LoadConfigs()
+        private Transform GetOrCreateGroupRoot(string group)
         {
-            _entries.Clear();
-            _resolvedConfigCache.Clear();
+            string groupName = string.IsNullOrWhiteSpace(group) ? PoolEntry.DefaultGroup : group.Trim();
+            if (_groupRootMap.TryGetValue(groupName, out int groupIndex))
+            {
+                Transform existingRoot = _groupRoots[groupIndex];
+                if (existingRoot != null)
+                {
+                    return existingRoot;
+                }
+            }
 
-            IResourceService resourceService = AppServices.Require<IResourceService>();
-            PoolConfigScriptableObject configAsset = resourceService.LoadAsset<PoolConfigScriptableObject>(poolConfigPath);
+            EnsureGroupRootCapacity(_groupRootCount + 1);
+            GameObject rootObject = new GameObject(ZString.Format("[{0}]", groupName));
+            Transform root = rootObject.transform;
+            root.SetParent(poolContainer, false);
+            rootObject.SetActive(true);
 
-            if (configAsset == null)
+            int newIndex = _groupRootCount++;
+            _groupRoots[newIndex] = root;
+            _groupRootMap.AddOrUpdate(groupName, newIndex);
+            return root;
+        }
+
+        private void EnsureGroupRootCapacity(int required)
+        {
+            if (_groupRoots.Length >= required)
             {
                 return;
             }
 
-            PoolConfigCatalog catalog = configAsset.BuildCatalog();
-            _entries.AddRange(catalog.entries);
-            resourceService.UnloadAsset(configAsset);
+            int newCapacity = Mathf.Max(required, _groupRoots.Length << 1);
+            var newRoots = new Transform[newCapacity];
+            Array.Copy(_groupRoots, 0, newRoots, 0, _groupRootCount);
+            _groupRoots = newRoots;
         }
 
-        private ResolvedPoolConfig ResolveConfig(string assetPath, string group)
+        private void ClearGroupRoots()
         {
-            if (string.IsNullOrWhiteSpace(assetPath))
+            for (int i = 0; i < _groupRootCount; i++)
             {
-                return null;
-            }
-
-            string cacheKey = string.IsNullOrWhiteSpace(group) ? assetPath : string.Concat(group, "|", assetPath);
-            if (_resolvedConfigCache.TryGetValue(cacheKey, out ResolvedPoolConfig cachedConfig))
-            {
-                return cachedConfig;
-            }
-
-            for (int i = 0; i < _entries.Count; i++)
-            {
-                PoolEntry entry = _entries[i];
-                if (!entry.Matches(assetPath, group))
+                Transform root = _groupRoots[i];
+                if (root != null)
                 {
-                    continue;
-                }
-
-                ResolvedPoolConfig resolved = ResolvedPoolConfig.From(entry);
-                _resolvedConfigCache[cacheKey] = resolved;
-                return resolved;
-            }
-
-            _resolvedConfigCache[cacheKey] = null;
-            return null;
-        }
-
-        private GameObject LoadUnpooled(string assetPath, string group, Transform parent)
-        {
-            IResourceLoader loader = GetDirectLoadResourceLoader(group);
-            return loader.LoadGameObject(assetPath, parent);
-        }
-
-        private async UniTask<GameObject> LoadUnpooledAsync(
-            string assetPath,
-            string group,
-            Transform parent,
-            CancellationToken cancellationToken)
-        {
-            IResourceLoader loader = GetDirectLoadResourceLoader(group);
-            return await loader.LoadGameObjectAsync(assetPath, parent, cancellationToken);
-        }
-
-        private IResourceLoader GetDirectLoadResourceLoader(string group)
-        {
-            if (!string.IsNullOrWhiteSpace(group))
-            {
-                for (int i = 0; i < _entries.Count; i++)
-                {
-                    PoolEntry entry = _entries[i];
-                    if (string.Equals(entry.group, group, StringComparison.Ordinal))
-                    {
-                        return GetResourceLoader(entry.loaderType);
-                    }
+                    Destroy(root.gameObject);
+                    _groupRoots[i] = null;
                 }
             }
 
-            return GetResourceLoader(DefaultDirectLoadResourceLoaderType);
+            _groupRootCount = 0;
+            _groupRootMap.Clear();
         }
 
-        private IResourceLoader GetResourceLoader(PoolResourceLoaderType loaderType)
+        private void WarnDirectLoadFallback(string assetPath)
         {
-            if (_resourceLoaders.TryGetValue(loaderType, out IResourceLoader loader) && loader != null)
+            if (_directLoadWarnedPaths.TryGetValue(assetPath, out _))
             {
-                return loader;
+                return;
             }
 
-            throw new InvalidOperationException($"Resource loader not registered: {loaderType}");
+            _directLoadWarnedPaths.AddOrUpdate(assetPath, 1);
+            Log.Warning(ZString.Format(
+                "[GameObjectPool] Asset not found in PoolConfig. Fallback to direct load and Release() will destroy it. Asset:{0}",
+                assetPath));
         }
 
         private void EnsureReadyForSyncUse()
         {
-            if (!_initializationCompleted)
+            if (!TryBootstrap())
             {
                 throw new InvalidOperationException(
-                    "GameObjectPool is still initializing. Use the async APIs or wait until initialization completes.");
-            }
-
-            if (_initializationException != null)
-            {
-                throw new InvalidOperationException("GameObjectPool initialization failed.", _initializationException);
+                    "GameObjectPool is waiting for resource bootstrap. Use async APIs or call after YooAssets initialization.");
             }
         }
 
-        private async UniTask EnsureInitializedAsync(CancellationToken cancellationToken)
+        private async UniTask EnsureReadyAsync(CancellationToken cancellationToken)
         {
-            await _initializeTask.AttachExternalCancellation(cancellationToken);
-
-            if (_initializationException != null)
+            while (!TryBootstrap())
             {
-                throw new InvalidOperationException("GameObjectPool initialization failed.", _initializationException);
+                cancellationToken.ThrowIfCancellationRequested();
+                await UniTask.Yield(PlayerLoopTiming.Update, cancellationToken);
             }
         }
 
+        private void OnLowMemory()
+        {
+            if (_bootstrapState != BootstrapState.Ready)
+            {
+                return;
+            }
+
+            float now = Time.time;
+            for (int i = 0; i < _poolCount; i++)
+            {
+                RuntimeGameObjectPool pool = _pools[i];
+                if (pool != null)
+                {
+                    pool.ExecuteMaintenance(now, true);
+                }
+            }
+        }
+
+        private void ProcessDueMaintenance(float now)
+        {
+            while (_maintenanceCount > 0)
+            {
+                MaintenanceNode node = _maintenanceHeap[0];
+                if (node.dueTime > now)
+                {
+                    return;
+                }
+
+                RemoveMaintenanceAt(0);
+                RuntimeGameObjectPool pool = _pools[node.poolIndex];
+                pool?.ExecuteMaintenance(now, false);
+            }
+        }
+
+        private void EnsurePoolCapacity(int required)
+        {
+            if (_pools.Length >= required)
+            {
+                return;
+            }
+
+            int newCapacity = Mathf.Max(required, _pools.Length << 1);
+            var newPools = new RuntimeGameObjectPool[newCapacity];
+            Array.Copy(_pools, 0, newPools, 0, _poolCount);
+            _pools = newPools;
+        }
+
+        private void EnsureMaintenanceCapacity(int required)
+        {
+            if (_maintenanceHeap.Length >= required)
+            {
+                return;
+            }
+
+            int newCapacity = Mathf.Max(required, _maintenanceHeap.Length << 1);
+            var newHeap = new MaintenanceNode[newCapacity];
+            Array.Copy(_maintenanceHeap, 0, newHeap, 0, _maintenanceCount);
+            _maintenanceHeap = newHeap;
+        }
+
+        private void RemoveMaintenanceAt(int heapIndex)
+        {
+            MaintenanceNode removed = _maintenanceHeap[heapIndex];
+            RuntimeGameObjectPool removedPool = _pools[removed.poolIndex];
+            removedPool?.SetMaintenanceHeapIndex(-1);
+
+            int lastIndex = _maintenanceCount - 1;
+            if (heapIndex != lastIndex)
+            {
+                MaintenanceNode moved = _maintenanceHeap[lastIndex];
+                _maintenanceHeap[heapIndex] = moved;
+                RuntimeGameObjectPool movedPool = _pools[moved.poolIndex];
+                movedPool?.SetMaintenanceHeapIndex(heapIndex);
+            }
+
+            _maintenanceHeap[lastIndex] = default;
+            _maintenanceCount = lastIndex;
+            if (heapIndex < _maintenanceCount)
+            {
+                SiftMaintenanceUp(heapIndex);
+                SiftMaintenanceDown(heapIndex);
+            }
+        }
+
+        private void SiftMaintenanceUp(int index)
+        {
+            while (index > 0)
+            {
+                int parent = (index - 1) >> 1;
+                if (_maintenanceHeap[parent].dueTime <= _maintenanceHeap[index].dueTime)
+                {
+                    break;
+                }
+
+                SwapMaintenance(parent, index);
+                index = parent;
+            }
+        }
+
+        private void SiftMaintenanceDown(int index)
+        {
+            while (true)
+            {
+                int left = (index << 1) + 1;
+                if (left >= _maintenanceCount)
+                {
+                    return;
+                }
+
+                int right = left + 1;
+                int smallest = right < _maintenanceCount && _maintenanceHeap[right].dueTime < _maintenanceHeap[left].dueTime
+                    ? right
+                    : left;
+                if (_maintenanceHeap[index].dueTime <= _maintenanceHeap[smallest].dueTime)
+                {
+                    return;
+                }
+
+                SwapMaintenance(index, smallest);
+                index = smallest;
+            }
+        }
+
+        private void SwapMaintenance(int left, int right)
+        {
+            MaintenanceNode temp = _maintenanceHeap[left];
+            _maintenanceHeap[left] = _maintenanceHeap[right];
+            _maintenanceHeap[right] = temp;
+            _pools[_maintenanceHeap[left].poolIndex]?.SetMaintenanceHeapIndex(left);
+            _pools[_maintenanceHeap[right].poolIndex]?.SetMaintenanceHeapIndex(right);
+        }
+
         private void ReleaseDebugSnapshots()
         {
             for (int i = 0; i < _debugSnapshots.Count; i++)
@@ -659,9 +679,30 @@ namespace AlicizaX
             _debugSnapshots.Clear();
         }
 
-        private static string GetInstanceKey(GameObject gameObject)
+        private static int CompareSnapshot(GameObjectPoolSnapshot left, GameObjectPoolSnapshot right)
         {
-            return gameObject.GetInstanceID().ToString();
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return 1;
+            }
+
+            if (right == null)
+            {
+                return -1;
+            }
+
+            int groupCompare = string.Compare(left.group, right.group, StringComparison.Ordinal);
+            if (groupCompare != 0)
+            {
+                return groupCompare;
+            }
+
+            return string.Compare(left.assetPath, right.assetPath, StringComparison.Ordinal);
         }
     }
 }
diff --git a/Runtime/ABase/GameObjectPool/RuntimePoolModels.cs b/Runtime/ABase/GameObjectPool/RuntimePoolModels.cs
index 84e20e2..06b7cad 100644
--- a/Runtime/ABase/GameObjectPool/RuntimePoolModels.cs
+++ b/Runtime/ABase/GameObjectPool/RuntimePoolModels.cs
@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Threading;
+using AlicizaX.ObjectPool;
+using Cysharp.Text;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 
@@ -11,49 +14,44 @@ namespace AlicizaX
         public readonly string AssetPath;
         public readonly string Group;
         public readonly Transform Parent;
-        public readonly Vector3 Position;
-        public readonly Quaternion Rotation;
-        public readonly object UserData;
-        public readonly int OwnerId;
-        public readonly int TeamId;
         public readonly uint SpawnFrame;
 
         public PoolSpawnContext(
             string assetPath,
             string group,
             Transform parent,
-            Vector3 position,
-            Quaternion rotation,
-            object userData = null,
-            int ownerId = 0,
-            int teamId = 0,
             uint spawnFrame = 0)
         {
             AssetPath = assetPath;
             Group = group;
             Parent = parent;
-            Position = position;
-            Rotation = rotation;
-            UserData = userData;
-            OwnerId = ownerId;
-            TeamId = teamId;
             SpawnFrame = spawnFrame;
         }
 
         public PoolSpawnContext WithParent(Transform parent)
         {
-            return new PoolSpawnContext(AssetPath, Group, parent, Position, Rotation, UserData, OwnerId, TeamId, SpawnFrame);
+            return new PoolSpawnContext(
+                AssetPath,
+                Group,
+                parent,
+                SpawnFrame);
         }
 
-        public static PoolSpawnContext Create(string assetPath, string group, Transform parent, object userData = null)
+        public PoolSpawnContext WithGroup(string group)
+        {
+            return new PoolSpawnContext(
+                AssetPath,
+                group,
+                Parent,
+                SpawnFrame);
+        }
+
+        public static PoolSpawnContext Create(string assetPath, Transform parent)
         {
             return new PoolSpawnContext(
                 assetPath,
-                group,
+                null,
                 parent,
-                Vector3.zero,
-                Quaternion.identity,
-                userData,
                 spawnFrame: (uint)Time.frameCount);
         }
     }
@@ -66,39 +64,129 @@ namespace AlicizaX
         void OnPoolDestroy();
     }
 
-    public interface IPoolAutoRecycle
-    {
-        bool TryGetAutoRecycleDelay(out float delaySeconds);
-    }
-
-    public interface IPoolResettablePhysics
-    {
-        void ResetPhysicsState();
-    }
-
-    public interface IPoolResettableVisual
-    {
-        void ResetVisualState();
-    }
-
-    public interface IPoolResettableAnimation
-    {
-        void ResetAnimationState();
-    }
-
     public interface IPoolSleepable
     {
         void EnterSleep();
         void ExitSleep(in PoolSpawnContext context);
     }
 
-    public enum RuntimePooledObjectState
+    internal readonly struct PoolRecycleRuntimeContext
     {
-        Uninitialized = 0,
-        Inactive = 1,
-        Active = 2,
-        Releasing = 3,
-        Destroying = 4
+        public readonly string Group;
+        public readonly string AssetPath;
+        public readonly PoolCategory Category;
+        public readonly int ActiveCount;
+        public readonly int InactiveCount;
+        public readonly int TotalCount;
+        public readonly int MinRetained;
+        public readonly int SoftCapacity;
+        public readonly int HardCapacity;
+        public readonly int ShortPeakRetainPercent;
+        public readonly int LongPeakRetainPercent;
+        public readonly int ShortPeakDecayFrames;
+        public readonly int LongPeakDecayFrames;
+        public readonly int TrimMultiplier;
+        public readonly bool RetainAllInactive;
+        public readonly int PeakActiveShort;
+        public readonly int PeakActiveLong;
+        public readonly int IdleFrames;
+        public readonly int HotFrames;
+        public readonly float OldestIdleSeconds;
+        public readonly bool LowMemory;
+
+        public PoolRecycleRuntimeContext(
+            string group,
+            string assetPath,
+            PoolCategory category,
+            int activeCount,
+            int inactiveCount,
+            int totalCount,
+            int minRetained,
+            int softCapacity,
+            int hardCapacity,
+            int shortPeakRetainPercent,
+            int longPeakRetainPercent,
+            int shortPeakDecayFrames,
+            int longPeakDecayFrames,
+            int trimMultiplier,
+            bool retainAllInactive,
+            int peakActiveShort,
+            int peakActiveLong,
+            int idleFrames,
+            int hotFrames,
+            float oldestIdleSeconds,
+            bool lowMemory)
+        {
+            Group = group;
+            AssetPath = assetPath;
+            Category = category;
+            ActiveCount = activeCount;
+            InactiveCount = inactiveCount;
+            TotalCount = totalCount;
+            MinRetained = minRetained;
+            SoftCapacity = softCapacity;
+            HardCapacity = hardCapacity;
+            ShortPeakRetainPercent = shortPeakRetainPercent;
+            LongPeakRetainPercent = longPeakRetainPercent;
+            ShortPeakDecayFrames = shortPeakDecayFrames;
+            LongPeakDecayFrames = longPeakDecayFrames;
+            TrimMultiplier = trimMultiplier;
+            RetainAllInactive = retainAllInactive;
+            PeakActiveShort = peakActiveShort;
+            PeakActiveLong = peakActiveLong;
+            IdleFrames = idleFrames;
+            HotFrames = hotFrames;
+            OldestIdleSeconds = oldestIdleSeconds;
+            LowMemory = lowMemory;
+        }
+    }
+
+    internal readonly struct PoolRecyclePlan
+    {
+        public readonly int RetainTarget;
+        public readonly int TrimBudget;
+        public readonly bool ForceTrim;
+        public readonly bool ForcePrefabUnload;
+
+        public PoolRecyclePlan(int retainTarget, int trimBudget, bool forceTrim, bool forcePrefabUnload)
+        {
+            RetainTarget = retainTarget;
+            TrimBudget = trimBudget;
+            ForceTrim = forceTrim;
+            ForcePrefabUnload = forcePrefabUnload;
+        }
+    }
+
+    public readonly struct GameObjectPoolSummarySnapshot
+    {
+        public readonly bool IsReady;
+        public readonly bool WaitingForBootstrap;
+        public readonly int PoolCount;
+        public readonly int LoadedPrefabCount;
+        public readonly int TotalInstanceCount;
+        public readonly int ActiveInstanceCount;
+        public readonly int InactiveInstanceCount;
+        public readonly int PendingMaintenanceCount;
+
+        public GameObjectPoolSummarySnapshot(
+            bool isReady,
+            bool waitingForBootstrap,
+            int poolCount,
+            int loadedPrefabCount,
+            int totalInstanceCount,
+            int activeInstanceCount,
+            int inactiveInstanceCount,
+            int pendingMaintenanceCount)
+        {
+            IsReady = isReady;
+            WaitingForBootstrap = waitingForBootstrap;
+            PoolCount = poolCount;
+            LoadedPrefabCount = loadedPrefabCount;
+            TotalInstanceCount = totalInstanceCount;
+            ActiveInstanceCount = activeInstanceCount;
+            InactiveInstanceCount = inactiveInstanceCount;
+            PendingMaintenanceCount = pendingMaintenanceCount;
+        }
     }
 
     [Serializable]
@@ -126,26 +214,38 @@ namespace AlicizaX
         public string entryName;
         public string group;
         public string assetPath;
+        public PoolCategory category;
         public PoolResourceLoaderType loaderType;
-        public PoolOverflowPolicy overflowPolicy;
         public int minRetained;
+        public int retainTarget;
         public int softCapacity;
         public int hardCapacity;
+        public int runtimeHardCapacity;
+        public int trimPerTick;
+        public int shortPeakRetainPercent;
+        public int longPeakRetainPercent;
+        public int shortPeakDecayFrames;
+        public int longPeakDecayFrames;
+        public int trimMultiplier;
+        public bool retainAllInactive;
         public int totalCount;
         public int activeCount;
         public int inactiveCount;
         public bool prefabLoaded;
         public float prefabIdleDuration;
+        public int prefabWakeCount;
+        public float prefabWakeGap;
+        public float prefabUnloadDelay;
+        public float nextMaintenanceIn;
         public int acquireCount;
         public int releaseCount;
         public int hitCount;
         public int missCount;
         public int expandCount;
-        public int exhaustedCount;
-        public int autoRecycleCount;
         public int destroyCount;
         public int peakActive;
-        public int peakTotal;
+        public int peakActiveShort;
+        public int peakActiveLong;
         public List<GameObjectPoolInstanceSnapshot> instances = new List<GameObjectPoolInstanceSnapshot>();
 
         public void Clear()
@@ -153,26 +253,38 @@ namespace AlicizaX
             entryName = null;
             group = null;
             assetPath = null;
+            category = default;
             loaderType = default;
-            overflowPolicy = default;
             minRetained = 0;
+            retainTarget = 0;
             softCapacity = 0;
             hardCapacity = 0;
+            runtimeHardCapacity = 0;
+            trimPerTick = 0;
+            shortPeakRetainPercent = 0;
+            longPeakRetainPercent = 0;
+            shortPeakDecayFrames = 0;
+            longPeakDecayFrames = 0;
+            trimMultiplier = 0;
+            retainAllInactive = false;
             totalCount = 0;
             activeCount = 0;
             inactiveCount = 0;
             prefabLoaded = false;
             prefabIdleDuration = 0f;
+            prefabWakeCount = 0;
+            prefabWakeGap = 0f;
+            prefabUnloadDelay = 0f;
+            nextMaintenanceIn = 0f;
             acquireCount = 0;
             releaseCount = 0;
             hitCount = 0;
             missCount = 0;
             expandCount = 0;
-            exhaustedCount = 0;
-            autoRecycleCount = 0;
             destroyCount = 0;
             peakActive = 0;
-            peakTotal = 0;
+            peakActiveShort = 0;
+            peakActiveLong = 0;
 
             for (int i = 0; i < instances.Count; i++)
             {
@@ -184,932 +296,945 @@ namespace AlicizaX
     }
 
     [DisallowMultipleComponent]
-    public sealed class PooledGameObjectMarker : MonoBehaviour
+    public sealed class GameObjectPoolHandle : MonoBehaviour
     {
-        private RuntimePrefabPool _owner;
-        private RuntimePooledInstance _instance;
+        private RuntimeGameObjectPool _owner;
+        private int _slotIndex = -1;
+        private uint _generation;
 
-        internal void Bind(RuntimePrefabPool owner, RuntimePooledInstance instance)
+        internal int SlotIndex => _slotIndex;
+        internal uint Generation => _generation;
+
+        internal void Bind(RuntimeGameObjectPool owner, int slotIndex, uint generation)
         {
             _owner = owner;
-            _instance = instance;
+            _slotIndex = slotIndex;
+            _generation = generation;
         }
 
-        public void Detach()
+        internal void Detach()
         {
             _owner = null;
-            _instance = null;
+            _slotIndex = -1;
+            _generation = 0;
+        }
+
+        internal bool TryRelease()
+        {
+            return _owner != null && _owner.ReleaseFromHandle(this);
         }
 
         private void OnDestroy()
         {
-            if (_owner != null && _instance != null)
+            if (_owner != null)
             {
-                _owner.NotifyInstanceDestroyed(_instance);
+                _owner.NotifyHandleDestroyed(_slotIndex, _generation);
             }
         }
     }
 
-    [DisallowMultipleComponent]
-    public sealed class PooledAutoRecycle : MonoBehaviour
+    internal sealed class RuntimeGameObjectPool : IMemory
     {
+        private enum SlotState : byte
+        {
+            Free = 0,
+            Inactive = 1,
+            Active = 2
+        }
+
+        private struct Slot
+        {
+            public GameObject instance;
+            public Transform transform;
+            public GameObjectPoolHandle handle;
+            public IGameObjectPoolable[] poolables;
+            public float spawnTime;
+            public float lastReleaseTime;
+            public int prevInactive;
+            public int nextInactive;
+            public uint generation;
+            public SlotState state;
+        }
+
+        private const int PageBits = 7;
+        private const int PageSize = 1 << PageBits;
+        private const int PageMask = PageSize - 1;
+        private const byte PageAllocated = 1;
+        private const byte PageInFreeStack = 2;
+        private const byte PageInEmptyStack = 4;
+        private const int InitialPageCapacity = 4;
+        private const int WarmupCreateBatch = 8;
+        private const float WarmupFrameBudgetSeconds = 0.001f;
+        private const float IdleTrimDelaySeconds = 15f;
+        private const float PrefabUnloadDelayColdSeconds = 15f;
+        private const float PrefabUnloadDelaySparseSeconds = 30f;
+        private const float PrefabUnloadDelayHotSeconds = 90f;
+        private const float PrefabSparseWakeGapSeconds = 20f;
+        private const int PrefabLowWakeCountThreshold = 2;
+        private const int PrefabWarmWakeCountThreshold = 6;
+        private const int PeakRetainPercentShort = 120;
+        private const int PeakRetainPercentLong = 100;
+        private const int PeakDecayFramesShort = 180;
+        private const int PeakDecayFramesLong = 900;
+        private const int TrimBudgetCap = 16;
+        private static readonly Comparison<GameObjectPoolInstanceSnapshot> InstanceComparer = CompareInstanceSnapshot;
+
         private GameObjectPoolManager _manager;
-        private CancellationTokenSource _cts;
-
-        public void Schedule(GameObjectPoolManager manager, float delaySeconds)
-        {
-            Cancel();
-
-            if (manager == null || delaySeconds <= 0f)
-            {
-                return;
-            }
-
-            _manager = manager;
-            _cts = new CancellationTokenSource();
-            AutoReleaseAsync(delaySeconds, _cts.Token).Forget();
-        }
-
-        public void Cancel()
-        {
-            if (_cts == null)
-            {
-                return;
-            }
-
-            _cts.Cancel();
-            _cts.Dispose();
-            _cts = null;
-        }
-
-        private async UniTaskVoid AutoReleaseAsync(float delaySeconds, CancellationToken cancellationToken)
-        {
-            try
-            {
-                await UniTask.Delay(TimeSpan.FromSeconds(delaySeconds), cancellationToken: cancellationToken);
-                if (_manager != null && this != null && gameObject != null)
-                {
-                    _manager.Release(gameObject);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-        }
-
-        private void OnDestroy()
-        {
-            Cancel();
-            _manager = null;
-        }
-    }
-
-    internal sealed class RuntimePoolLifecycleCache : IMemory
-    {
-        public IGameObjectPoolable[] poolables;
-        public IPoolSleepable[] sleepables;
-        public IPoolResettablePhysics[] physicsResetters;
-        public IPoolResettableVisual[] visualResetters;
-        public IPoolResettableAnimation[] animationResetters;
-        public IPoolAutoRecycle[] autoRecyclers;
-
-        public void Clear()
-        {
-            poolables = null;
-            sleepables = null;
-            physicsResetters = null;
-            visualResetters = null;
-            animationResetters = null;
-            autoRecyclers = null;
-        }
-    }
-
-    internal sealed class RuntimePooledInstance : IMemory
-    {
-        public GameObject GameObject { get; private set; }
-        public PooledGameObjectMarker Marker { get; private set; }
-        public PooledAutoRecycle AutoRecycle { get; private set; }
-        public RuntimePoolLifecycleCache Lifecycle { get; private set; }
-        public LinkedListNode<RuntimePooledInstance> InactiveNode { get; set; }
-        public RuntimePooledObjectState State { get; set; }
-        public float LastReleaseTime { get; set; }
-        public float SpawnTime { get; set; }
-
-        public void Initialize(
-            GameObject gameObject,
-            PooledGameObjectMarker marker,
-            PooledAutoRecycle autoRecycle,
-            RuntimePoolLifecycleCache lifecycle)
-        {
-            GameObject = gameObject;
-            Marker = marker;
-            AutoRecycle = autoRecycle;
-            Lifecycle = lifecycle;
-            State = RuntimePooledObjectState.Inactive;
-            SpawnTime = Time.time;
-            LastReleaseTime = Time.time;
-        }
-
-        public void Clear()
-        {
-            GameObject = null;
-            Marker = null;
-            AutoRecycle = null;
-            Lifecycle = null;
-            InactiveNode = null;
-            State = RuntimePooledObjectState.Uninitialized;
-            LastReleaseTime = 0f;
-            SpawnTime = 0f;
-        }
-    }
-
-    internal sealed class RuntimePrefabPool : IMemory
-    {
-        private static readonly Comparison<GameObjectPoolInstanceSnapshot> InstanceSnapshotComparer = (left, right) =>
-        {
-            if (left == null && right == null) return 0;
-            if (left == null) return 1;
-            if (right == null) return -1;
-            if (left.isActive != right.isActive) return left.isActive ? -1 : 1;
-            return string.Compare(left.instanceName, right.instanceName, StringComparison.Ordinal);
-        };
-
-        private ResolvedPoolConfig _config;
-        private string _assetPath;
         private IResourceLoader _loader;
-        private GameObjectPoolManager _service;
-        private CancellationToken _shutdownToken;
-        private Dictionary<GameObject, RuntimePooledInstance> _instancesByObject;
-        private LinkedList<RuntimePooledInstance> _inactiveInstances;
-        private List<RuntimePooledInstance> _destroyBuffer;
+        private PoolCompiledRule _rule;
+        private int _poolIndex;
+        private string _assetPath;
         private Transform _root;
         private GameObject _prefab;
-        private UniTaskCompletionSource<GameObject> _prefabLoadSource;
-        private int _activeCount;
+        private UniTask<GameObject> _prefabLoadTask;
+        private bool _prefabLoading;
+        private bool _isShuttingDown;
         private float _lastPrefabTouchTime;
+        private float _lastWakeTime;
+        private float _previousWakeTime;
+        private float _nextMaintenanceAt;
+        private int _maintenanceHeapIndex;
+        private Slot[][] _pages;
+        private int[][] _pageFreeStacks;
+        private int[] _pageAliveCounts;
+        private int[] _pageFreeTops;
+        private byte[] _pageFlags;
+        private int _pageCount;
+        private int[] _freePageStack;
+        private int _freePageTop;
+        private int[] _emptyPageStack;
+        private int _emptyPageTop;
+        private int _inactiveHead;
+        private int _inactiveTail;
+        private int _activeCount;
+        private int _inactiveCount;
+        private int _totalCount;
         private int _runtimeHardCapacity;
+        private int _retainTarget;
         private int _acquireCount;
         private int _releaseCount;
         private int _hitCount;
         private int _missCount;
         private int _expandCount;
-        private int _exhaustedCount;
-        private int _autoRecycleCount;
         private int _destroyCount;
         private int _peakActive;
-        private int _peakTotal;
+        private int _peakActiveShort;
+        private int _peakActiveLong;
+        private int _acquireSinceMaintain;
+        private int _releaseSinceMaintain;
+        private int _wakeCountSincePrefabLoad;
+        private int _idleFrames;
+        private int _hotFrames;
+        private uint _generationCounter;
 
-        public RuntimePrefabPool()
-        {
-            _instancesByObject = new Dictionary<GameObject, RuntimePooledInstance>();
-            _inactiveInstances = new LinkedList<RuntimePooledInstance>();
-            _destroyBuffer = new List<RuntimePooledInstance>();
-        }
+        public int TotalCount => _totalCount;
+        public int ActiveCount => _activeCount;
+        public int InactiveCount => _inactiveCount;
+        public bool IsPrefabLoaded => _prefab != null;
+        public float NextMaintenanceAt => _nextMaintenanceAt;
+        public bool HasMaintenance => _maintenanceHeapIndex >= 0;
+        public float PrefabIdleDuration => _prefab == null ? 0f : Mathf.Max(0f, Time.time - GetPrefabReferenceTime());
 
         public void Initialize(
-            ResolvedPoolConfig config,
+            GameObjectPoolManager manager,
+            int poolIndex,
+            in PoolCompiledRule rule,
             string assetPath,
             IResourceLoader loader,
-            GameObjectPoolManager service,
-            CancellationToken shutdownToken)
+            Transform inactiveRoot)
         {
-            _config = config ?? throw new ArgumentNullException(nameof(config));
-            _assetPath = assetPath ?? throw new ArgumentNullException(nameof(assetPath));
-            _loader = loader ?? throw new ArgumentNullException(nameof(loader));
-            _service = service ?? throw new ArgumentNullException(nameof(service));
-            _shutdownToken = shutdownToken;
-            _lastPrefabTouchTime = Time.time;
-            _runtimeHardCapacity = config.hardCapacity;
+            _manager = manager;
+            _poolIndex = poolIndex;
+            _rule = rule;
+            _assetPath = assetPath;
+            _loader = loader;
+            _root = inactiveRoot;
+            _runtimeHardCapacity = rule.hardCapacity;
+            _retainTarget = GetMinimumRetained();
+            _lastPrefabTouchTime = -1f;
+            _lastWakeTime = -1f;
+            _previousWakeTime = -1f;
+            _nextMaintenanceAt = float.MaxValue;
+            _maintenanceHeapIndex = -1;
+            _inactiveHead = -1;
+            _inactiveTail = -1;
+            _pages = SlotArrayPool<Slot[]>.Rent(InitialPageCapacity);
+            _pageFreeStacks = SlotArrayPool<int[]>.Rent(InitialPageCapacity);
+            _pageAliveCounts = SlotArrayPool<int>.Rent(InitialPageCapacity);
+            _pageFreeTops = SlotArrayPool<int>.Rent(InitialPageCapacity);
+            _pageFlags = SlotArrayPool<byte>.Rent(InitialPageCapacity);
+            _freePageStack = SlotArrayPool<int>.Rent(InitialPageCapacity);
+            _emptyPageStack = SlotArrayPool<int>.Rent(InitialPageCapacity);
+            Array.Clear(_pages, 0, InitialPageCapacity);
+            Array.Clear(_pageFreeStacks, 0, InitialPageCapacity);
+            Array.Clear(_pageAliveCounts, 0, InitialPageCapacity);
+            Array.Clear(_pageFreeTops, 0, InitialPageCapacity);
+            Array.Clear(_pageFlags, 0, InitialPageCapacity);
+            Array.Clear(_freePageStack, 0, InitialPageCapacity);
+            Array.Clear(_emptyPageStack, 0, InitialPageCapacity);
 
-            _instancesByObject.Clear();
-            _inactiveInstances.Clear();
-            _destroyBuffer.Clear();
-            _prefab = null;
-            _prefabLoadSource = null;
-            _activeCount = 0;
-            _acquireCount = 0;
-            _releaseCount = 0;
-            _hitCount = 0;
-            _missCount = 0;
-            _expandCount = 0;
-            _exhaustedCount = 0;
-            _autoRecycleCount = 0;
-            _destroyCount = 0;
-            _peakActive = 0;
-            _peakTotal = 0;
-
-            GameObject rootObject = new GameObject($"Pool_{SanitizeName(config.group)}_{SanitizeName(assetPath)}");
-            _root = rootObject.transform;
-            _root.SetParent(service.poolContainer, false);
-            rootObject.SetActive(false);
+            ScheduleMaintenance(float.MaxValue);
         }
 
-        public string AssetPath => _assetPath;
-        public ResolvedPoolConfig Config => _config;
-        public int TotalCount => _instancesByObject.Count;
-        public int ActiveCount => _activeCount;
-        public int InactiveCount => _inactiveInstances.Count;
-        public bool IsPrefabLoaded => _prefab != null;
-        public float PrefabIdleDuration => _prefab == null ? 0f : Mathf.Max(0f, Time.time - _lastPrefabTouchTime);
-
         public GameObject Acquire(in PoolSpawnContext context)
         {
-            EnsurePrefabLoaded();
+            if (!EnsurePrefabLoaded())
+            {
+                throw new InvalidOperationException(ZString.Format(
+                    "Pool prefab '{0}' is loading asynchronously. Use async acquire for this path.",
+                    _assetPath));
+            }
+
             return AcquirePrepared(context);
         }
 
         public async UniTask<GameObject> AcquireAsync(PoolSpawnContext context, CancellationToken cancellationToken)
         {
-            await EnsurePrefabLoadedAsync(cancellationToken);
+            bool prefabLoaded = await EnsurePrefabLoadedAsync(cancellationToken);
+            if (!prefabLoaded)
+            {
+                return null;
+            }
+
             return AcquirePrepared(context);
         }
 
-        public async UniTask WarmupAsync(int targetCount, CancellationToken cancellationToken)
+        public async UniTask WarmupAsync(int count, CancellationToken cancellationToken)
         {
-            if (targetCount <= 0)
+            int warmCount = Mathf.Max(0, count);
+            if (warmCount <= 0)
             {
                 return;
             }
 
-            await EnsurePrefabLoadedAsync(cancellationToken);
-
-            int desiredInactiveCount = Mathf.Clamp(targetCount, 0, _runtimeHardCapacity);
-            if (desiredInactiveCount <= _inactiveInstances.Count)
+            if (_inactiveCount >= warmCount)
             {
                 return;
             }
 
-            int desiredTotalCount = Mathf.Min(_runtimeHardCapacity, _activeCount + desiredInactiveCount);
-            if (desiredTotalCount <= _instancesByObject.Count)
+            bool prefabLoaded = await EnsurePrefabLoadedAsync(cancellationToken);
+            if (!prefabLoaded)
             {
                 return;
             }
 
-            float frameBudgetSeconds = _config.warmupFrameBudgetMs * 0.001f;
+            EnsureRuntimeHardCapacity(warmCount, "Warmup");
+
+            float frameBudget = WarmupFrameBudgetSeconds;
             int createdThisFrame = 0;
-            float frameStartTime = Time.realtimeSinceStartup;
+            float frameStart = Time.realtimeSinceStartup;
 
-            while (_instancesByObject.Count < desiredTotalCount)
+            while (_inactiveCount < warmCount)
             {
-                RuntimePooledInstance instance = CreateInstance();
-                ParkInactive(instance);
+                EnsureRuntimeHardCapacity(_totalCount + 1, "Warmup");
+                int slotIndex = CreateTrackedInstance();
+                ParkInactive(slotIndex, true);
                 createdThisFrame++;
 
-                bool budgetReachedByCount = createdThisFrame >= _config.warmupBatchPerFrame;
-                bool budgetReachedByTime = frameBudgetSeconds > 0f &&
-                                          Time.realtimeSinceStartup - frameStartTime >= frameBudgetSeconds;
-
+                bool budgetReachedByCount = createdThisFrame >= WarmupCreateBatch;
+                bool budgetReachedByTime = frameBudget > 0f && Time.realtimeSinceStartup - frameStart >= frameBudget;
                 if (budgetReachedByCount || budgetReachedByTime)
                 {
                     createdThisFrame = 0;
-                    frameStartTime = Time.realtimeSinceStartup;
+                    frameStart = Time.realtimeSinceStartup;
                     await UniTask.Yield(PlayerLoopTiming.Update, cancellationToken);
                 }
             }
+
+            RefreshMaintenance(false);
         }
 
-        public bool Release(GameObject gameObject)
+        public bool ReleaseFromHandle(GameObjectPoolHandle handle)
         {
-            if (gameObject == null || !_instancesByObject.TryGetValue(gameObject, out RuntimePooledInstance instance))
+            if (handle == null)
             {
                 return false;
             }
 
-            if (instance.State != RuntimePooledObjectState.Active)
+            int slotIndex = handle.SlotIndex;
+            if (!IsValidIndex(slotIndex))
             {
-                return true;
+                return false;
             }
 
-            _releaseCount++;
-            InternalReleaseInstance(instance, true);
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            if (slot.handle != handle || slot.generation != handle.Generation || slot.state != SlotState.Active)
+            {
+                return false;
+            }
+
+            ReleaseTrackedInstance(slotIndex);
             return true;
         }
 
-        public void NotifyInstanceDestroyed(RuntimePooledInstance instance)
+        public void NotifyHandleDestroyed(int slotIndex, uint generation)
         {
-            if (instance == null)
+            if (_isShuttingDown || !IsValidIndex(slotIndex))
             {
                 return;
             }
 
-            RemoveInstance(instance, false);
-            ReleaseLifecycleCache(instance.Lifecycle);
-            MemoryPool.Release(instance);
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            if (slot.generation != generation)
+            {
+                return;
+            }
+
+            RemoveSlot(slotIndex, false);
         }
 
-        public void Trim(int maxDestroyCount, bool aggressive)
+        public void SetMaintenanceHeapIndex(int heapIndex)
         {
-            if (_config.trimPolicy == PoolTrimPolicy.None)
+            _maintenanceHeapIndex = heapIndex;
+        }
+
+        public void ExecuteMaintenance(float now, bool lowMemory)
+        {
+            UpdateRetentionMetrics();
+
+            PoolRecyclePlan plan = BuildRecyclePlan(now, lowMemory);
+            _retainTarget = Mathf.Clamp(plan.RetainTarget, GetMinimumRetained(), _runtimeHardCapacity);
+
+            int destroyBudget = Mathf.Max(1, plan.TrimBudget);
+            while (_inactiveHead >= 0 && destroyBudget > 0 && ShouldTrimHead(now, plan))
             {
-                return;
-            }
-
-            if (maxDestroyCount <= 0)
-            {
-                maxDestroyCount = _config.trimBatchPerTick;
-            }
-
-            int destroyBudget = Mathf.Max(1, maxDestroyCount);
-            float now = Time.time;
-            int remainingRetained = Mathf.Max(_config.minRetained, 0);
-
-            while (destroyBudget > 0 && _inactiveInstances.First != null)
-            {
-                if (_instancesByObject.Count <= remainingRetained)
-                {
-                    break;
-                }
-
-                RuntimePooledInstance candidate = _inactiveInstances.First.Value;
-                bool expired = _config.idleTrimDelay > 0f && now - candidate.LastReleaseTime >= _config.idleTrimDelay;
-                bool overSoftCapacity = _instancesByObject.Count > _config.softCapacity;
-                bool canAggressiveTrim = aggressive && _config.aggressiveTrimOnLowMemory;
-
-                if (!expired && !overSoftCapacity && !canAggressiveTrim)
-                {
-                    break;
-                }
-
-                DestroyInstance(candidate);
+                DestroyTrackedInstance(_inactiveHead, true);
                 destroyBudget--;
             }
 
-            if (!CanKeepPrefabLoaded(now, aggressive))
+            RestoreRuntimeHardCapacity();
+
+            if (_prefab != null && ShouldUnloadPrefab(now, plan))
+            {
+                _loader.UnloadAsset(_prefab);
+                _prefab = null;
+                _prefabLoading = false;
+            }
+
+            RefreshMaintenance(false);
+        }
+
+        public void Shutdown()
+        {
+            _isShuttingDown = true;
+            _manager.RemoveMaintenance(ref _maintenanceHeapIndex);
+
+            for (int page = 0; page < _pageCount; page++)
+            {
+                Slot[] pageSlots = _pages[page];
+                if (pageSlots == null)
+                {
+                    continue;
+                }
+
+                for (int offset = 0; offset < PageSize; offset++)
+                {
+                    int slotIndex = MakeIndex(page, offset);
+                    ref Slot slot = ref pageSlots[offset];
+                    if (slot.state == SlotState.Free && slot.instance == null)
+                    {
+                        continue;
+                    }
+
+                    InvokeOnPoolDestroy(ref slot);
+                    if (slot.handle != null)
+                    {
+                        slot.handle.Detach();
+                    }
+
+                    if (slot.instance != null)
+                    {
+                        GameObject.Destroy(slot.instance);
+                    }
+
+                    ClearSlot(ref slot);
+                    slot.state = SlotState.Free;
+                    slot.prevInactive = -1;
+                    slot.nextInactive = -1;
+                    _totalCount--;
+                    _destroyCount++;
+                }
+            }
+
+            _inactiveHead = -1;
+            _inactiveTail = -1;
+            _activeCount = 0;
+            _inactiveCount = 0;
+            _totalCount = 0;
+
+            if (_prefab != null)
             {
                 _loader.UnloadAsset(_prefab);
                 _prefab = null;
             }
         }
 
-        public bool NeedsTrim(float now)
-        {
-            if (_inactiveInstances.First == null)
-            {
-                return false;
-            }
-
-            if (_instancesByObject.Count > _config.softCapacity)
-            {
-                return true;
-            }
-
-            if (_config.idleTrimDelay <= 0f)
-            {
-                return false;
-            }
-
-            return now - _inactiveInstances.First.Value.LastReleaseTime >= _config.idleTrimDelay;
-        }
-
-        public bool NeedsPrefabUnload(float now, bool aggressive)
-        {
-            return !CanKeepPrefabLoaded(now, aggressive);
-        }
-
         public GameObjectPoolSnapshot CreateSnapshot()
         {
+            float now = Time.time;
             var snapshot = MemoryPool.Acquire<GameObjectPoolSnapshot>();
-            snapshot.entryName = _config.entryName;
-            snapshot.group = _config.group;
+            snapshot.entryName = _rule.entryName;
+            snapshot.group = _rule.group;
             snapshot.assetPath = _assetPath;
-            snapshot.loaderType = _config.loaderType;
-            snapshot.overflowPolicy = _config.overflowPolicy;
-            snapshot.minRetained = _config.minRetained;
-            snapshot.softCapacity = _config.softCapacity;
-            snapshot.hardCapacity = _runtimeHardCapacity;
-            snapshot.totalCount = _instancesByObject.Count;
+            snapshot.category = _rule.category;
+            snapshot.loaderType = _rule.loaderType;
+            snapshot.minRetained = GetMinimumRetained();
+            snapshot.retainTarget = _retainTarget;
+            snapshot.softCapacity = _rule.softCapacity;
+            snapshot.hardCapacity = _rule.hardCapacity;
+            snapshot.runtimeHardCapacity = _runtimeHardCapacity;
+            snapshot.trimPerTick = GetTrimBudgetBase();
+            snapshot.shortPeakRetainPercent = PeakRetainPercentShort;
+            snapshot.longPeakRetainPercent = PeakRetainPercentLong;
+            snapshot.shortPeakDecayFrames = PeakDecayFramesShort;
+            snapshot.longPeakDecayFrames = PeakDecayFramesLong;
+            snapshot.trimMultiplier = 1;
+            snapshot.retainAllInactive = false;
+            snapshot.totalCount = _totalCount;
             snapshot.activeCount = _activeCount;
-            snapshot.inactiveCount = _inactiveInstances.Count;
+            snapshot.inactiveCount = _inactiveCount;
             snapshot.prefabLoaded = _prefab != null;
             snapshot.prefabIdleDuration = PrefabIdleDuration;
+            snapshot.prefabWakeCount = _prefab == null ? 0 : _wakeCountSincePrefabLoad;
+            snapshot.prefabWakeGap = _prefab == null ? -1f : GetLastWakeGapDuration();
+            snapshot.prefabUnloadDelay = _prefab == null ? -1f : GetPrefabUnloadDelaySeconds();
+            snapshot.nextMaintenanceIn = _nextMaintenanceAt >= float.MaxValue
+                ? -1f
+                : Mathf.Max(0f, _nextMaintenanceAt - now);
             snapshot.acquireCount = _acquireCount;
             snapshot.releaseCount = _releaseCount;
             snapshot.hitCount = _hitCount;
             snapshot.missCount = _missCount;
             snapshot.expandCount = _expandCount;
-            snapshot.exhaustedCount = _exhaustedCount;
-            snapshot.autoRecycleCount = _autoRecycleCount;
             snapshot.destroyCount = _destroyCount;
             snapshot.peakActive = _peakActive;
-            snapshot.peakTotal = _peakTotal;
+            snapshot.peakActiveShort = _peakActiveShort;
+            snapshot.peakActiveLong = _peakActiveLong;
 
-            foreach (RuntimePooledInstance instance in _instancesByObject.Values)
+            for (int page = 0; page < _pageCount; page++)
             {
-                var instanceSnapshot = MemoryPool.Acquire<GameObjectPoolInstanceSnapshot>();
-                instanceSnapshot.instanceName = instance.GameObject != null ? instance.GameObject.name : "<destroyed>";
-                instanceSnapshot.isActive = instance.State == RuntimePooledObjectState.Active;
-                instanceSnapshot.idleDuration = instance.State == RuntimePooledObjectState.Active
-                    ? 0f
-                    : Mathf.Max(0f, Time.time - instance.LastReleaseTime);
-                instanceSnapshot.lifeDuration = Mathf.Max(0f, Time.time - instance.SpawnTime);
-                instanceSnapshot.gameObject = instance.GameObject;
-                snapshot.instances.Add(instanceSnapshot);
+                Slot[] pageSlots = _pages[page];
+                if (pageSlots == null)
+                {
+                    continue;
+                }
+
+                for (int offset = 0; offset < PageSize; offset++)
+                {
+                    ref Slot slot = ref pageSlots[offset];
+                    if (slot.state == SlotState.Free && slot.instance == null)
+                    {
+                        continue;
+                    }
+
+                    var instanceSnapshot = MemoryPool.Acquire<GameObjectPoolInstanceSnapshot>();
+                    instanceSnapshot.instanceName = slot.instance == null ? "<destroyed>" : slot.instance.name;
+                    instanceSnapshot.isActive = slot.state == SlotState.Active;
+                    instanceSnapshot.idleDuration = slot.state == SlotState.Active
+                        ? 0f
+                        : Mathf.Max(0f, now - slot.lastReleaseTime);
+                    instanceSnapshot.lifeDuration = Mathf.Max(0f, now - slot.spawnTime);
+                    instanceSnapshot.gameObject = slot.instance;
+                    snapshot.instances.Add(instanceSnapshot);
+                }
             }
 
-            snapshot.instances.Sort(InstanceSnapshotComparer);
+            snapshot.instances.Sort(InstanceComparer);
             return snapshot;
         }
 
-        public void Shutdown()
+        public void Clear()
         {
-            _destroyBuffer.AddRange(_instancesByObject.Values);
-            for (int i = 0; i < _destroyBuffer.Count; i++)
-            {
-                DestroyInstance(_destroyBuffer[i]);
-            }
-
-            _destroyBuffer.Clear();
-            _inactiveInstances.Clear();
-            _instancesByObject.Clear();
-            _activeCount = 0;
-
-            if (_prefab != null)
-            {
-                _loader.UnloadAsset(_prefab);
-                _prefab = null;
-            }
-
-            if (_root != null)
-            {
-                GameObject.Destroy(_root.gameObject);
-            }
-
+            ReturnAllPages();
+            ReturnStorageArrays();
+            _manager = null;
+            _loader = null;
+            _rule = default;
+            _poolIndex = 0;
+            _assetPath = null;
             _root = null;
-        }
-
-        private void EnsurePrefabLoaded()
-        {
-            if (_prefab != null)
-            {
-                TouchPrefab();
-                return;
-            }
-
-            if (_prefabLoadSource != null)
-            {
-                throw new InvalidOperationException(
-                    $"Pool asset '{_assetPath}' is being loaded asynchronously. Use the async acquire API.");
-            }
-
-            _prefab = _loader.LoadPrefab(_assetPath);
-            if (_prefab == null)
-            {
-                throw new InvalidOperationException($"Failed to load pooled prefab '{_assetPath}'.");
-            }
-
-            TouchPrefab();
-        }
-
-        private async UniTask EnsurePrefabLoadedAsync(CancellationToken cancellationToken)
-        {
-            if (_prefab != null)
-            {
-                TouchPrefab();
-                return;
-            }
-
-            if (_prefabLoadSource != null)
-            {
-                await _prefabLoadSource.Task.AttachExternalCancellation(cancellationToken);
-                return;
-            }
-
-            _prefabLoadSource = new UniTaskCompletionSource<GameObject>();
-
-            try
-            {
-                GameObject prefab = await _loader.LoadPrefabAsync(_assetPath, _shutdownToken);
-                if (prefab == null)
-                {
-                    throw new InvalidOperationException($"Failed to load pooled prefab '{_assetPath}'.");
-                }
-
-                _prefab = prefab;
-                TouchPrefab();
-                _prefabLoadSource.TrySetResult(prefab);
-            }
-            catch (Exception exception)
-            {
-                _prefabLoadSource.TrySetException(exception);
-                throw;
-            }
-            finally
-            {
-                _prefabLoadSource = null;
-            }
+            _prefab = null;
+            _prefabLoadTask = default;
+            _prefabLoading = false;
+            _isShuttingDown = false;
+            _lastPrefabTouchTime = -1f;
+            _lastWakeTime = -1f;
+            _previousWakeTime = -1f;
+            _nextMaintenanceAt = float.MaxValue;
+            _maintenanceHeapIndex = -1;
+            _inactiveHead = -1;
+            _inactiveTail = -1;
+            _activeCount = 0;
+            _inactiveCount = 0;
+            _totalCount = 0;
+            _runtimeHardCapacity = 0;
+            _retainTarget = 0;
+            _acquireCount = 0;
+            _releaseCount = 0;
+            _hitCount = 0;
+            _missCount = 0;
+            _expandCount = 0;
+            _destroyCount = 0;
+            _peakActive = 0;
+            _peakActiveShort = 0;
+            _peakActiveLong = 0;
+            _acquireSinceMaintain = 0;
+            _releaseSinceMaintain = 0;
+            _wakeCountSincePrefabLoad = 0;
+            _idleFrames = 0;
+            _hotFrames = 0;
+            _generationCounter = 0;
         }
 
         private GameObject AcquirePrepared(in PoolSpawnContext context)
         {
             _acquireCount++;
-            RuntimePooledInstance instance = null;
+            _acquireSinceMaintain++;
 
-            if (_inactiveInstances.Last != null)
+            int slotIndex;
+            if (_inactiveTail >= 0)
             {
-                instance = _inactiveInstances.Last.Value;
-                RemoveInactiveNode(instance);
+                slotIndex = _inactiveTail;
+                RemoveFromInactive(slotIndex);
                 _hitCount++;
             }
             else
             {
                 _missCount++;
-                instance = AcquireOnMiss();
+                slotIndex = AcquireOnMiss();
             }
 
-            if (instance == null)
+            ActivateTrackedInstance(slotIndex, context);
+            if (_activeCount > _peakActive)
             {
-                _exhaustedCount++;
-                return null;
+                _peakActive = _activeCount;
             }
 
-            ActivateInstance(instance, context);
-            return instance.GameObject;
+            if (_activeCount > _peakActiveShort)
+            {
+                _peakActiveShort = _activeCount;
+            }
+
+            if (_activeCount > _peakActiveLong)
+            {
+                _peakActiveLong = _activeCount;
+            }
+
+            RefreshMaintenance(false);
+            return GetSlotRef(slotIndex).instance;
         }
 
-        private RuntimePooledInstance AcquireOnMiss()
+        private int AcquireOnMiss()
         {
-            if (_instancesByObject.Count < _runtimeHardCapacity)
-            {
-                return CreateInstance();
-            }
-
-            switch (_config.overflowPolicy)
-            {
-                case PoolOverflowPolicy.AutoExpand:
-                    if (_config.allowRuntimeExpand)
-                    {
-                        _runtimeHardCapacity++;
-                        _expandCount++;
-                        return CreateInstance();
-                    }
-
-                    return null;
-
-                case PoolOverflowPolicy.RecycleOldestInactive:
-                    if (_inactiveInstances.First != null)
-                    {
-                        RuntimePooledInstance oldest = _inactiveInstances.First.Value;
-                        RemoveInactiveNode(oldest);
-                        return oldest;
-                    }
-
-                    return null;
-
-                case PoolOverflowPolicy.InstantiateOneShot:
-                    return CreateInstance();
-
-                case PoolOverflowPolicy.DropNewestRequest:
-                case PoolOverflowPolicy.FailFast:
-                default:
-                    return null;
-            }
+            EnsureRuntimeHardCapacity(_totalCount + 1, "Acquire");
+            return CreateTrackedInstance();
         }
 
-        private void ActivateInstance(RuntimePooledInstance instance, in PoolSpawnContext context)
+        private void ActivateTrackedInstance(int slotIndex, in PoolSpawnContext context)
         {
-            instance.State = RuntimePooledObjectState.Active;
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            slot.state = SlotState.Active;
             _activeCount++;
-            _peakActive = Mathf.Max(_peakActive, _activeCount);
-            _peakTotal = Mathf.Max(_peakTotal, _instancesByObject.Count);
-            TouchPrefab();
+            RecordWake();
 
-            GameObject gameObject = instance.GameObject;
-            Transform transform = gameObject.transform;
-            transform.SetParent(context.Parent != null ? context.Parent : null, false);
-            if (context.Position != Vector3.zero || context.Rotation != Quaternion.identity)
+            Transform transform = slot.transform;
+            transform.SetParent(context.Parent, false);
+            if (!slot.instance.activeSelf)
             {
-                transform.SetPositionAndRotation(context.Position, context.Rotation);
+                slot.instance.SetActive(true);
             }
 
-            ApplyGetLifecycle(instance, context);
-            if (_config.activationMode == PoolActivationMode.SetActive)
-            {
-                gameObject.SetActive(true);
-            }
+            InvokeOnPoolGet(ref slot, context);
         }
 
-        private RuntimePooledInstance CreateInstance()
+        private void ReleaseTrackedInstance(int slotIndex)
         {
-            GameObject gameObject = GameObject.Instantiate(_prefab);
-            gameObject.name = $"{_prefab.name}(Pool)";
-            gameObject.SetActive(false);
-            gameObject.transform.SetParent(_root, false);
-
-            PooledGameObjectMarker marker = gameObject.GetComponent<PooledGameObjectMarker>();
-            if (marker == null)
-            {
-                marker = gameObject.AddComponent<PooledGameObjectMarker>();
-            }
-
-            PooledAutoRecycle autoRecycle = gameObject.GetComponent<PooledAutoRecycle>();
-            if (autoRecycle == null)
-            {
-                autoRecycle = gameObject.AddComponent<PooledAutoRecycle>();
-            }
-
-            RuntimePoolLifecycleCache lifecycle = BuildLifecycleCache(gameObject);
-
-            var instance = MemoryPool.Acquire<RuntimePooledInstance>();
-            instance.Initialize(gameObject, marker, autoRecycle, lifecycle);
-            marker.Bind(this, instance);
-            _instancesByObject.Add(gameObject, instance);
-            _service.RegisterOwnedObject(gameObject, this);
-            InvokeOnPoolCreate(lifecycle);
-            TouchPrefab();
-            _peakTotal = Mathf.Max(_peakTotal, _instancesByObject.Count);
-            return instance;
-        }
-
-        private void ParkInactive(RuntimePooledInstance instance)
-        {
-            if (instance == null)
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            if (slot.state != SlotState.Active)
             {
                 return;
             }
 
-            instance.State = RuntimePooledObjectState.Inactive;
-            instance.LastReleaseTime = Time.time;
-
-            Transform transform = instance.GameObject.transform;
-            transform.SetParent(_root, false);
-            transform.localPosition = Vector3.zero;
-            transform.localRotation = Quaternion.identity;
-            transform.localScale = Vector3.one;
-            instance.GameObject.SetActive(false);
-            instance.InactiveNode = _inactiveInstances.AddLast(instance);
-            _service.NotifyPoolStateChanged();
-        }
-
-        private void InternalReleaseInstance(RuntimePooledInstance instance, bool notifyStateChanged)
-        {
-            if (instance == null || instance.GameObject == null)
-            {
-                return;
-            }
-
-            if (instance.State != RuntimePooledObjectState.Active)
-            {
-                return;
-            }
-
-            instance.State = RuntimePooledObjectState.Releasing;
-            instance.AutoRecycle?.Cancel();
-            ApplyReleaseLifecycle(instance);
-            if (_config.activationMode == PoolActivationMode.SetActive)
-            {
-                instance.GameObject.SetActive(false);
-            }
-
+            _releaseCount++;
+            _releaseSinceMaintain++;
             _activeCount = Mathf.Max(0, _activeCount - 1);
-            ParkInactive(instance);
+            InvokeOnPoolRelease(ref slot);
+            if (slot.instance.activeSelf)
+            {
+                slot.instance.SetActive(false);
+            }
+
+            ParkInactive(slotIndex, false);
+            RefreshMaintenance(false);
+        }
+
+        private void ParkInactive(int slotIndex, bool newInstance)
+        {
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            slot.state = SlotState.Inactive;
+            slot.lastReleaseTime = Time.time;
+            slot.transform.SetParent(_root, false);
+
+            AddToInactiveTail(slotIndex);
+        }
+
+        private int CreateTrackedInstance()
+        {
+            int slotIndex = AllocSlot();
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            slot.generation = ++_generationCounter;
+            slot.state = SlotState.Inactive;
+            slot.spawnTime = Time.time;
+            slot.lastReleaseTime = Time.time;
+            slot.prevInactive = -1;
+            slot.nextInactive = -1;
+            slot.instance = GameObject.Instantiate(_prefab);
+            slot.transform = slot.instance.transform;
+            slot.instance.name = ZString.Format("{0}[Pool]", _prefab.name);
+            slot.transform.SetParent(_root, false);
+            if (slot.instance.activeSelf)
+            {
+                slot.instance.SetActive(false);
+            }
+
+            GameObjectPoolHandle handle = slot.instance.GetComponent<GameObjectPoolHandle>();
+            if (handle == null)
+            {
+                handle = slot.instance.AddComponent<GameObjectPoolHandle>();
+            }
+
+            handle.Bind(this, slotIndex, slot.generation);
+            slot.handle = handle;
+            BuildLifecycleCache(slot.instance, ref slot);
+            InvokeOnPoolCreate(ref slot);
+            _totalCount++;
             TouchPrefab();
-
-            if (notifyStateChanged)
-            {
-                _service.NotifyPoolStateChanged();
-            }
+            return slotIndex;
         }
 
-        private void DestroyInstance(RuntimePooledInstance instance)
+        private void DestroyTrackedInstance(int slotIndex, bool countDestroy)
         {
-            if (instance == null)
-            {
-                return;
-            }
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            RemoveFromInactive(slotIndex);
 
-            instance.State = RuntimePooledObjectState.Destroying;
-            RemoveInstance(instance, true);
-
-            if (instance.GameObject != null)
-            {
-                InvokeOnPoolDestroy(instance.Lifecycle);
-                instance.AutoRecycle?.Cancel();
-                instance.Marker?.Detach();
-                GameObject.Destroy(instance.GameObject);
-            }
-
-            ReleaseLifecycleCache(instance.Lifecycle);
-            MemoryPool.Release(instance);
-        }
-
-        private void RemoveInstance(RuntimePooledInstance instance, bool countDestroy)
-        {
-            GameObject gameObject = instance?.GameObject;
-            if (gameObject == null)
-            {
-                return;
-            }
-
-            RemoveInactiveNode(instance);
-
-            if (instance.State == RuntimePooledObjectState.Active)
+            if (slot.state == SlotState.Active)
             {
                 _activeCount = Mathf.Max(0, _activeCount - 1);
             }
 
-            _instancesByObject.Remove(gameObject);
-            _service.UnregisterOwnedObject(gameObject);
+            InvokeOnPoolDestroy(ref slot);
+            if (slot.handle != null)
+            {
+                slot.handle.Detach();
+            }
+
+            if (slot.instance != null)
+            {
+                GameObject.Destroy(slot.instance);
+            }
+
+            ClearSlot(ref slot);
+            slot.state = SlotState.Free;
+            slot.prevInactive = -1;
+            slot.nextInactive = -1;
+            FreeSlot(slotIndex);
+            _totalCount = Mathf.Max(0, _totalCount - 1);
+            if (countDestroy)
+            {
+                _destroyCount++;
+            }
+        }
+
+        private void RemoveSlot(int slotIndex, bool countDestroy)
+        {
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            RemoveFromInactive(slotIndex);
+
+            if (slot.state == SlotState.Active)
+            {
+                _activeCount = Mathf.Max(0, _activeCount - 1);
+            }
+
+            ClearSlot(ref slot);
+            slot.state = SlotState.Free;
+            slot.prevInactive = -1;
+            slot.nextInactive = -1;
+            FreeSlot(slotIndex);
+            _totalCount = Mathf.Max(0, _totalCount - 1);
             if (countDestroy)
             {
                 _destroyCount++;
             }
 
-            TouchPrefab();
-            _service.NotifyPoolStateChanged();
+            RestoreRuntimeHardCapacity();
+            RefreshMaintenance(false);
         }
 
-        private void RemoveInactiveNode(RuntimePooledInstance instance)
+        private void RefreshMaintenance(bool lowMemory)
         {
-            if (instance?.InactiveNode == null)
-            {
-                return;
-            }
-
-            _inactiveInstances.Remove(instance.InactiveNode);
-            instance.InactiveNode = null;
+            float dueTime = ComputeNextMaintenanceAt(Time.time, lowMemory);
+            ScheduleMaintenance(dueTime);
         }
 
-        private void ApplyGetLifecycle(RuntimePooledInstance instance, in PoolSpawnContext context)
+        private void ScheduleMaintenance(float dueTime)
         {
-            if (instance.Lifecycle == null)
+            _nextMaintenanceAt = dueTime;
+            _manager.ScheduleMaintenance(_poolIndex, dueTime, ref _maintenanceHeapIndex);
+        }
+
+        private float ComputeNextMaintenanceAt(float now, bool lowMemory)
+        {
+            if (lowMemory && _inactiveHead >= 0)
             {
-                return;
+                return now;
             }
 
-            if (_config.activationMode == PoolActivationMode.SleepWake && instance.Lifecycle.sleepables != null)
+            float nextDueTime = float.MaxValue;
+            if (_inactiveHead >= 0)
             {
-                for (int i = 0; i < instance.Lifecycle.sleepables.Length; i++)
+                if (_totalCount > _rule.softCapacity)
                 {
-                    instance.Lifecycle.sleepables[i]?.ExitSleep(context);
+                    return now;
+                }
+
+                ref Slot headSlot = ref GetSlotRef(_inactiveHead);
+                nextDueTime = headSlot.lastReleaseTime + IdleTrimDelaySeconds;
+            }
+
+            if (_prefab != null && _totalCount == 0)
+            {
+                float unloadDue = GetPrefabUnloadDueTime();
+                if (unloadDue < nextDueTime)
+                {
+                    nextDueTime = unloadDue;
                 }
             }
 
-            if (instance.Lifecycle.poolables != null)
-            {
-                for (int i = 0; i < instance.Lifecycle.poolables.Length; i++)
-                {
-                    instance.Lifecycle.poolables[i]?.OnPoolGet(context);
-                }
-            }
-
-            ScheduleAutoRecycle(instance);
+            return nextDueTime;
         }
 
-        private void ApplyReleaseLifecycle(RuntimePooledInstance instance)
+        private PoolRecyclePlan BuildRecyclePlan(float now, bool lowMemory)
         {
-            if (instance.Lifecycle == null)
-            {
-                return;
-            }
+            float oldestIdle = _inactiveHead >= 0
+                ? Mathf.Max(0f, now - GetSlotRef(_inactiveHead).lastReleaseTime)
+                : 0f;
 
-            if (_config.resetMode == PoolResetMode.FullReset || _config.resetMode == PoolResetMode.PoolableCallbacks)
-            {
-                if (instance.Lifecycle.physicsResetters != null)
-                {
-                    for (int i = 0; i < instance.Lifecycle.physicsResetters.Length; i++)
-                    {
-                        instance.Lifecycle.physicsResetters[i]?.ResetPhysicsState();
-                    }
-                }
+            var context = new PoolRecycleRuntimeContext(
+                _rule.group,
+                _assetPath,
+                _rule.category,
+                _activeCount,
+                _inactiveCount,
+                _totalCount,
+                GetMinimumRetained(),
+                _rule.softCapacity,
+                _runtimeHardCapacity,
+                PeakRetainPercentShort,
+                PeakRetainPercentLong,
+                PeakDecayFramesShort,
+                PeakDecayFramesLong,
+                1,
+                false,
+                _peakActiveShort,
+                _peakActiveLong,
+                _idleFrames,
+                _hotFrames,
+                oldestIdle,
+                lowMemory);
 
-                if (instance.Lifecycle.visualResetters != null)
-                {
-                    for (int i = 0; i < instance.Lifecycle.visualResetters.Length; i++)
-                    {
-                        instance.Lifecycle.visualResetters[i]?.ResetVisualState();
-                    }
-                }
-
-                if (instance.Lifecycle.animationResetters != null)
-                {
-                    for (int i = 0; i < instance.Lifecycle.animationResetters.Length; i++)
-                    {
-                        instance.Lifecycle.animationResetters[i]?.ResetAnimationState();
-                    }
-                }
-            }
-
-            if (instance.Lifecycle.poolables != null)
-            {
-                for (int i = 0; i < instance.Lifecycle.poolables.Length; i++)
-                {
-                    instance.Lifecycle.poolables[i]?.OnPoolRelease();
-                }
-            }
-
-            if (_config.activationMode == PoolActivationMode.SleepWake && instance.Lifecycle.sleepables != null)
-            {
-                for (int i = 0; i < instance.Lifecycle.sleepables.Length; i++)
-                {
-                    instance.Lifecycle.sleepables[i]?.EnterSleep();
-                }
-            }
+            return BuildDefaultRecyclePlan(in context);
         }
 
-        private void InvokeOnPoolCreate(RuntimePoolLifecycleCache lifecycle)
+        private PoolRecyclePlan BuildDefaultRecyclePlan(in PoolRecycleRuntimeContext context)
         {
-            if (lifecycle?.poolables == null)
+            if (_idleFrames >= context.ShortPeakDecayFrames && _peakActiveShort > 0)
             {
-                return;
+                _peakActiveShort -= Mathf.Max(1, _peakActiveShort >> 4);
             }
 
-            for (int i = 0; i < lifecycle.poolables.Length; i++)
+            if (_idleFrames >= context.LongPeakDecayFrames && _peakActiveLong > 0)
             {
-                lifecycle.poolables[i]?.OnPoolCreate();
+                _peakActiveLong -= Mathf.Max(1, _peakActiveLong >> 6);
             }
+
+            int shortRetain = (_peakActiveShort * context.ShortPeakRetainPercent + 99) / 100;
+            int longRetain = (_peakActiveLong * context.LongPeakRetainPercent + 99) / 100;
+            int retainTarget = Mathf.Max(context.MinRetained, Mathf.Max(shortRetain, longRetain));
+            retainTarget = Mathf.Min(retainTarget, context.SoftCapacity);
+            if (context.RetainAllInactive)
+            {
+                retainTarget = Mathf.Max(retainTarget, context.InactiveCount);
+            }
+
+            if (context.LowMemory)
+            {
+                retainTarget = context.MinRetained;
+            }
+
+            int trimBudget = GetTrimBudgetBase();
+            bool forceTrim = context.LowMemory;
+            bool forceUnload = context.LowMemory;
+            return new PoolRecyclePlan(retainTarget, trimBudget, forceTrim, forceUnload);
         }
 
-        private void InvokeOnPoolDestroy(RuntimePoolLifecycleCache lifecycle)
+        private bool ShouldTrimHead(float now, in PoolRecyclePlan plan)
         {
-            if (lifecycle?.poolables == null)
-            {
-                return;
-            }
-
-            for (int i = 0; i < lifecycle.poolables.Length; i++)
-            {
-                lifecycle.poolables[i]?.OnPoolDestroy();
-            }
-        }
-
-        private void ScheduleAutoRecycle(RuntimePooledInstance instance)
-        {
-            if (instance?.AutoRecycle == null)
-            {
-                return;
-            }
-
-            float delay = _config.autoRecycleDelay;
-            if (delay <= 0f && instance.Lifecycle?.autoRecyclers != null)
-            {
-                for (int i = 0; i < instance.Lifecycle.autoRecyclers.Length; i++)
-                {
-                    if (instance.Lifecycle.autoRecyclers[i] != null &&
-                        instance.Lifecycle.autoRecyclers[i].TryGetAutoRecycleDelay(out delay) &&
-                        delay > 0f)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            if (delay > 0f)
-            {
-                _autoRecycleCount++;
-                instance.AutoRecycle.Schedule(_service, delay);
-            }
-        }
-
-        private RuntimePoolLifecycleCache BuildLifecycleCache(GameObject gameObject)
-        {
-            var cache = MemoryPool.Acquire<RuntimePoolLifecycleCache>();
-            cache.poolables = gameObject.GetComponentsInChildren<IGameObjectPoolable>(true);
-            cache.sleepables = gameObject.GetComponentsInChildren<IPoolSleepable>(true);
-            cache.physicsResetters = gameObject.GetComponentsInChildren<IPoolResettablePhysics>(true);
-            cache.visualResetters = gameObject.GetComponentsInChildren<IPoolResettableVisual>(true);
-            cache.animationResetters = gameObject.GetComponentsInChildren<IPoolResettableAnimation>(true);
-            cache.autoRecyclers = gameObject.GetComponentsInChildren<IPoolAutoRecycle>(true);
-            return cache;
-        }
-
-        private void ReleaseLifecycleCache(RuntimePoolLifecycleCache lifecycle)
-        {
-            if (lifecycle == null)
-            {
-                return;
-            }
-
-            MemoryPool.Release(lifecycle);
-        }
-
-        private bool CanKeepPrefabLoaded(float now, bool aggressive)
-        {
-            if (_prefab == null)
-            {
-                return true;
-            }
-
-            if (_config.keepPrefabResident)
-            {
-                return true;
-            }
-
-            if (_instancesByObject.Count > 0)
-            {
-                return true;
-            }
-
-            if (_config.prefabUnloadDelay <= 0f)
+            if (_inactiveHead < 0)
             {
                 return false;
             }
 
-            if (aggressive && _config.aggressiveTrimOnLowMemory)
+            if (_totalCount <= plan.RetainTarget)
             {
                 return false;
             }
 
-            return now - _lastPrefabTouchTime < _config.prefabUnloadDelay;
+            if (plan.ForceTrim)
+            {
+                return true;
+            }
+
+            if (_totalCount > _rule.softCapacity)
+            {
+                return true;
+            }
+
+            ref Slot headSlot = ref GetSlotRef(_inactiveHead);
+            return _inactiveCount > plan.RetainTarget && now - headSlot.lastReleaseTime >= IdleTrimDelaySeconds;
+        }
+
+        private bool ShouldUnloadPrefab(float now, in PoolRecyclePlan plan)
+        {
+            if (_prefab == null || _totalCount > 0)
+            {
+                return false;
+            }
+
+            if (plan.ForcePrefabUnload)
+            {
+                return true;
+            }
+
+            return now >= GetPrefabUnloadDueTime();
+        }
+
+        private void UpdateRetentionMetrics()
+        {
+            bool hot = _acquireSinceMaintain > 0 || _releaseSinceMaintain > 0 || _activeCount > 0;
+            if (hot)
+            {
+                _hotFrames++;
+                _idleFrames = 0;
+            }
+            else
+            {
+                _idleFrames++;
+                _hotFrames = 0;
+            }
+
+            _acquireSinceMaintain = 0;
+            _releaseSinceMaintain = 0;
+        }
+
+        private void RestoreRuntimeHardCapacity()
+        {
+            _runtimeHardCapacity = Mathf.Max(_rule.hardCapacity, _totalCount);
+        }
+
+        private int GetMinimumRetained()
+        {
+            return 0;
+        }
+
+        private int GetTrimBudgetBase()
+        {
+            return Mathf.Clamp(_rule.softCapacity >> 2, 1, TrimBudgetCap);
+        }
+
+        private void EnsureRuntimeHardCapacity(int requiredCapacity, string reason)
+        {
+            if (requiredCapacity <= _runtimeHardCapacity)
+            {
+                return;
+            }
+
+            int previousRuntimeHardCapacity = _runtimeHardCapacity;
+            int expandedBy = requiredCapacity - previousRuntimeHardCapacity;
+            _runtimeHardCapacity = requiredCapacity;
+            _expandCount += expandedBy;
+            Log.Warning(ZString.Format(
+                "[GameObjectPool] Pool expanded ({0}). Rule:{1}, Asset:{2}, ConfigHard:{3}, RuntimeHard:{4}->{5}, ExpandCount:{6}",
+                reason,
+                _rule.entryName,
+                _assetPath,
+                _rule.hardCapacity,
+                previousRuntimeHardCapacity,
+                _runtimeHardCapacity,
+                _expandCount));
+        }
+
+        private bool EnsurePrefabLoaded()
+        {
+            if (_prefab != null)
+            {
+                TouchPrefab();
+                return true;
+            }
+
+            if (_prefabLoading)
+            {
+                return false;
+            }
+
+            _prefab = _loader.LoadPrefab(_assetPath);
+            _prefabLoading = false;
+            if (_prefab != null)
+            {
+                ResetPrefabUsageWindow();
+            }
+
+            return _prefab != null;
+        }
+
+        private async UniTask<bool> EnsurePrefabLoadedAsync(CancellationToken cancellationToken)
+        {
+            if (_prefab != null)
+            {
+                TouchPrefab();
+                return true;
+            }
+
+            if (_prefabLoading)
+            {
+                GameObject loadedPrefab = await _prefabLoadTask.AttachExternalCancellation(cancellationToken);
+                bool firstCompletion = _prefab == null;
+                _prefab = loadedPrefab;
+                _prefabLoading = false;
+                if (_prefab != null)
+                {
+                    if (firstCompletion)
+                    {
+                        ResetPrefabUsageWindow();
+                    }
+                    else
+                    {
+                        TouchPrefab();
+                    }
+                }
+
+                return _prefab != null;
+            }
+
+            _prefabLoading = true;
+            _prefabLoadTask = _loader.LoadPrefabAsync(_assetPath, _manager.ShutdownToken);
+            _prefab = await _prefabLoadTask.AttachExternalCancellation(cancellationToken);
+            _prefabLoading = false;
+            if (_prefab != null)
+            {
+                ResetPrefabUsageWindow();
+            }
+
+            return _prefab != null;
         }
 
         private void TouchPrefab()
@@ -1117,39 +1242,549 @@ namespace AlicizaX
             _lastPrefabTouchTime = Time.time;
         }
 
-        public void Clear()
+        private void ResetPrefabUsageWindow()
         {
-            _config = null;
-            _assetPath = null;
-            _loader = null;
-            _service = null;
-            _shutdownToken = default;
-            _instancesByObject.Clear();
-            _inactiveInstances.Clear();
-            _destroyBuffer.Clear();
-            _root = null;
-            _prefab = null;
-            _prefabLoadSource = null;
-            _activeCount = 0;
-            _lastPrefabTouchTime = 0f;
-            _runtimeHardCapacity = 0;
-            _acquireCount = 0;
-            _releaseCount = 0;
-            _hitCount = 0;
-            _missCount = 0;
-            _expandCount = 0;
-            _exhaustedCount = 0;
-            _autoRecycleCount = 0;
-            _destroyCount = 0;
-            _peakActive = 0;
-            _peakTotal = 0;
+            _lastPrefabTouchTime = Time.time;
+            _lastWakeTime = -1f;
+            _previousWakeTime = -1f;
+            _wakeCountSincePrefabLoad = 0;
         }
 
-        private static string SanitizeName(string value)
+        private void RecordWake()
         {
-            return string.IsNullOrWhiteSpace(value)
-                ? "Unnamed"
-                : value.Replace('/', '_').Replace('\\', '_').Replace(':', '_');
+            float now = Time.time;
+            _previousWakeTime = _lastWakeTime;
+            _lastWakeTime = now;
+            _wakeCountSincePrefabLoad++;
+            _lastPrefabTouchTime = now;
+        }
+
+        private float GetPrefabReferenceTime()
+        {
+            return _lastWakeTime >= 0f ? _lastWakeTime : _lastPrefabTouchTime;
+        }
+
+        private float GetLastWakeGapDuration()
+        {
+            if (_lastWakeTime < 0f || _previousWakeTime < 0f)
+            {
+                return -1f;
+            }
+
+            return Mathf.Max(0f, _lastWakeTime - _previousWakeTime);
+        }
+
+        // Empty pools unload faster after sparse wake patterns, and stay loaded longer after bursty use.
+        private float GetPrefabUnloadDelaySeconds()
+        {
+            if (_wakeCountSincePrefabLoad <= 0)
+            {
+                return PrefabUnloadDelayColdSeconds;
+            }
+
+            float lastWakeGap = GetLastWakeGapDuration();
+            bool sparseWakeGap = lastWakeGap < 0f || lastWakeGap >= PrefabSparseWakeGapSeconds;
+            if (_wakeCountSincePrefabLoad <= PrefabLowWakeCountThreshold)
+            {
+                return sparseWakeGap
+                    ? PrefabUnloadDelayColdSeconds
+                    : PrefabUnloadDelaySparseSeconds;
+            }
+
+            if (_wakeCountSincePrefabLoad <= PrefabWarmWakeCountThreshold && sparseWakeGap)
+            {
+                return PrefabUnloadDelaySparseSeconds;
+            }
+
+            return PrefabUnloadDelayHotSeconds;
+        }
+
+        private float GetPrefabUnloadDueTime()
+        {
+            if (_prefab == null || _totalCount > 0)
+            {
+                return float.MaxValue;
+            }
+
+            return GetPrefabReferenceTime() + GetPrefabUnloadDelaySeconds();
+        }
+
+        private static void BuildLifecycleCache(GameObject gameObject, ref Slot slot)
+        {
+            MonoBehaviour[] behaviours = gameObject.GetComponentsInChildren<MonoBehaviour>(true);
+            int poolableCount = 0;
+
+            for (int i = 0; i < behaviours.Length; i++)
+            {
+                MonoBehaviour behaviour = behaviours[i];
+                if (behaviour == null)
+                {
+                    continue;
+                }
+
+                if (behaviour is IGameObjectPoolable)
+                {
+                    poolableCount++;
+                }
+            }
+
+            slot.poolables = poolableCount == 0 ? null : new IGameObjectPoolable[poolableCount];
+
+            int poolableIndex = 0;
+
+            for (int i = 0; i < behaviours.Length; i++)
+            {
+                MonoBehaviour behaviour = behaviours[i];
+                if (behaviour == null)
+                {
+                    continue;
+                }
+
+                if (behaviour is IGameObjectPoolable poolable)
+                {
+                    slot.poolables[poolableIndex++] = poolable;
+                }
+            }
+        }
+
+        private void InvokeOnPoolCreate(ref Slot slot)
+        {
+            if (slot.poolables == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < slot.poolables.Length; i++)
+            {
+                slot.poolables[i]?.OnPoolCreate();
+            }
+        }
+
+        private void InvokeOnPoolGet(ref Slot slot, in PoolSpawnContext context)
+        {
+            if (slot.poolables == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < slot.poolables.Length; i++)
+            {
+                slot.poolables[i]?.OnPoolGet(context);
+            }
+        }
+
+        private void InvokeOnPoolRelease(ref Slot slot)
+        {
+            if (slot.poolables == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < slot.poolables.Length; i++)
+            {
+                slot.poolables[i]?.OnPoolRelease();
+            }
+        }
+
+        private void InvokeOnPoolDestroy(ref Slot slot)
+        {
+            if (slot.poolables == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < slot.poolables.Length; i++)
+            {
+                slot.poolables[i]?.OnPoolDestroy();
+            }
+        }
+
+        private static void ClearSlot(ref Slot slot)
+        {
+            slot.instance = null;
+            slot.transform = null;
+            slot.handle = null;
+            slot.poolables = null;
+            slot.spawnTime = 0f;
+            slot.lastReleaseTime = 0f;
+            slot.generation++;
+        }
+
+        private void AddToInactiveTail(int slotIndex)
+        {
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            if (_inactiveTail == slotIndex || slot.prevInactive >= 0 || slot.nextInactive >= 0)
+            {
+                return;
+            }
+
+            slot.prevInactive = _inactiveTail;
+            slot.nextInactive = -1;
+            if (_inactiveTail >= 0)
+            {
+                GetSlotRef(_inactiveTail).nextInactive = slotIndex;
+            }
+            else
+            {
+                _inactiveHead = slotIndex;
+            }
+
+            _inactiveTail = slotIndex;
+            _inactiveCount++;
+        }
+
+        private void RemoveFromInactive(int slotIndex)
+        {
+            if (!IsValidIndex(slotIndex))
+            {
+                return;
+            }
+
+            ref Slot slot = ref GetSlotRef(slotIndex);
+            if (_inactiveHead != slotIndex && slot.prevInactive < 0 && slot.nextInactive < 0)
+            {
+                return;
+            }
+
+            int prev = slot.prevInactive;
+            int next = slot.nextInactive;
+            if (prev >= 0)
+            {
+                GetSlotRef(prev).nextInactive = next;
+            }
+            else
+            {
+                _inactiveHead = next;
+            }
+
+            if (next >= 0)
+            {
+                GetSlotRef(next).prevInactive = prev;
+            }
+            else
+            {
+                _inactiveTail = prev;
+            }
+
+            slot.prevInactive = -1;
+            slot.nextInactive = -1;
+            _inactiveCount = Mathf.Max(0, _inactiveCount - 1);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int MakeIndex(int page, int offset)
+        {
+            return (page << PageBits) | offset;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int PageOf(int index)
+        {
+            return index >> PageBits;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int OffsetOf(int index)
+        {
+            return index & PageMask;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private ref Slot GetSlotRef(int index)
+        {
+            return ref _pages[PageOf(index)][OffsetOf(index)];
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private bool IsValidIndex(int index)
+        {
+            if (index < 0)
+            {
+                return false;
+            }
+
+            int page = PageOf(index);
+            return page < _pageCount && _pages[page] != null;
+        }
+
+        private int AllocSlot()
+        {
+            if (_freePageTop <= 0)
+            {
+                AllocatePage();
+            }
+
+            int page = _freePageStack[_freePageTop - 1];
+            int offset = _pageFreeStacks[page][--_pageFreeTops[page]];
+            if (_pageFreeTops[page] <= 0)
+            {
+                RemoveFreePage(page);
+            }
+
+            _pageAliveCounts[page]++;
+            return MakeIndex(page, offset);
+        }
+
+        private void FreeSlot(int index)
+        {
+            int page = PageOf(index);
+            int offset = OffsetOf(index);
+            _pageFreeStacks[page][_pageFreeTops[page]++] = offset;
+            _pageAliveCounts[page]--;
+
+            if (_pageFreeTops[page] == 1)
+            {
+                AddFreePage(page);
+            }
+
+            if (_pageAliveCounts[page] == 0)
+            {
+                AddEmptyPage(page);
+                ReleaseEmptyPages(1);
+            }
+        }
+
+        private void AllocatePage()
+        {
+            int page = GetReusablePageIndex();
+            _pages[page] = SlotArrayPool<Slot>.Rent(PageSize);
+            _pageFreeStacks[page] = SlotArrayPool<int>.Rent(PageSize);
+            Array.Clear(_pages[page], 0, PageSize);
+            for (int i = 0; i < PageSize; i++)
+            {
+                _pageFreeStacks[page][i] = PageSize - 1 - i;
+                _pages[page][i].prevInactive = -1;
+                _pages[page][i].nextInactive = -1;
+            }
+
+            _pageFreeTops[page] = PageSize;
+            _pageAliveCounts[page] = 0;
+            _pageFlags[page] = PageAllocated;
+            AddFreePage(page);
+        }
+
+        private int GetReusablePageIndex()
+        {
+            if (_emptyPageTop > 0)
+            {
+                int page = _emptyPageStack[--_emptyPageTop];
+                _pageFlags[page] = (byte)(_pageFlags[page] & ~PageInEmptyStack);
+                return page;
+            }
+
+            if (_pageCount >= _pages.Length)
+            {
+                ExpandPageStorage(_pages.Length << 1);
+            }
+
+            return _pageCount++;
+        }
+
+        private void ExpandPageStorage(int required)
+        {
+            int newCapacity = Mathf.Max(required, _pages.Length << 1);
+            Slot[][] newPages = SlotArrayPool<Slot[]>.Rent(newCapacity);
+            int[][] newPageFreeStacks = SlotArrayPool<int[]>.Rent(newCapacity);
+            int[] newPageAliveCounts = SlotArrayPool<int>.Rent(newCapacity);
+            int[] newPageFreeTops = SlotArrayPool<int>.Rent(newCapacity);
+            byte[] newPageFlags = SlotArrayPool<byte>.Rent(newCapacity);
+            int[] newFreePageStack = SlotArrayPool<int>.Rent(newCapacity);
+            int[] newEmptyPageStack = SlotArrayPool<int>.Rent(newCapacity);
+
+            Array.Clear(newPages, 0, newCapacity);
+            Array.Clear(newPageFreeStacks, 0, newCapacity);
+            Array.Clear(newPageAliveCounts, 0, newCapacity);
+            Array.Clear(newPageFreeTops, 0, newCapacity);
+            Array.Clear(newPageFlags, 0, newCapacity);
+            Array.Clear(newFreePageStack, 0, newCapacity);
+            Array.Clear(newEmptyPageStack, 0, newCapacity);
+
+            Array.Copy(_pages, 0, newPages, 0, _pageCount);
+            Array.Copy(_pageFreeStacks, 0, newPageFreeStacks, 0, _pageCount);
+            Array.Copy(_pageAliveCounts, 0, newPageAliveCounts, 0, _pageCount);
+            Array.Copy(_pageFreeTops, 0, newPageFreeTops, 0, _pageCount);
+            Array.Copy(_pageFlags, 0, newPageFlags, 0, _pageCount);
+            Array.Copy(_freePageStack, 0, newFreePageStack, 0, _freePageTop);
+            Array.Copy(_emptyPageStack, 0, newEmptyPageStack, 0, _emptyPageTop);
+
+            SlotArrayPool<Slot[]>.Return(_pages, true);
+            SlotArrayPool<int[]>.Return(_pageFreeStacks, true);
+            SlotArrayPool<int>.Return(_pageAliveCounts, true);
+            SlotArrayPool<int>.Return(_pageFreeTops, true);
+            SlotArrayPool<byte>.Return(_pageFlags, true);
+            SlotArrayPool<int>.Return(_freePageStack, true);
+            SlotArrayPool<int>.Return(_emptyPageStack, true);
+
+            _pages = newPages;
+            _pageFreeStacks = newPageFreeStacks;
+            _pageAliveCounts = newPageAliveCounts;
+            _pageFreeTops = newPageFreeTops;
+            _pageFlags = newPageFlags;
+            _freePageStack = newFreePageStack;
+            _emptyPageStack = newEmptyPageStack;
+        }
+
+        private void AddFreePage(int page)
+        {
+            if ((_pageFlags[page] & PageInFreeStack) != 0)
+            {
+                return;
+            }
+
+            _pageFlags[page] = (byte)(_pageFlags[page] | PageInFreeStack);
+            _freePageStack[_freePageTop++] = page;
+        }
+
+        private void RemoveFreePage(int page)
+        {
+            if ((_pageFlags[page] & PageInFreeStack) == 0)
+            {
+                return;
+            }
+
+            _pageFlags[page] = (byte)(_pageFlags[page] & ~PageInFreeStack);
+            for (int i = 0; i < _freePageTop; i++)
+            {
+                if (_freePageStack[i] != page)
+                {
+                    continue;
+                }
+
+                _freePageTop--;
+                _freePageStack[i] = _freePageStack[_freePageTop];
+                _freePageStack[_freePageTop] = 0;
+                return;
+            }
+        }
+
+        private void AddEmptyPage(int page)
+        {
+            if ((_pageFlags[page] & PageInEmptyStack) != 0)
+            {
+                return;
+            }
+
+            _pageFlags[page] = (byte)(_pageFlags[page] | PageInEmptyStack);
+            _emptyPageStack[_emptyPageTop++] = page;
+        }
+
+        private void ReleaseEmptyPages(int budget)
+        {
+            while (budget > 0 && _emptyPageTop > 0)
+            {
+                int page = _emptyPageStack[--_emptyPageTop];
+                _pageFlags[page] = (byte)(_pageFlags[page] & ~PageInEmptyStack);
+                if (_pages[page] == null || _pageAliveCounts[page] != 0)
+                {
+                    continue;
+                }
+
+                SlotArrayPool<Slot>.Return(_pages[page], true);
+                SlotArrayPool<int>.Return(_pageFreeStacks[page], true);
+                _pages[page] = null;
+                _pageFreeStacks[page] = null;
+                _pageFreeTops[page] = 0;
+                _pageAliveCounts[page] = 0;
+                _pageFlags[page] = 0;
+                budget--;
+            }
+        }
+
+        private void ReturnAllPages()
+        {
+            if (_pages == null)
+            {
+                return;
+            }
+
+            for (int page = 0; page < _pageCount; page++)
+            {
+                if (_pages[page] != null)
+                {
+                    SlotArrayPool<Slot>.Return(_pages[page], true);
+                    _pages[page] = null;
+                }
+
+                if (_pageFreeStacks[page] != null)
+                {
+                    SlotArrayPool<int>.Return(_pageFreeStacks[page], true);
+                    _pageFreeStacks[page] = null;
+                }
+            }
+        }
+
+        private void ReturnStorageArrays()
+        {
+            if (_pages != null)
+            {
+                SlotArrayPool<Slot[]>.Return(_pages, true);
+                _pages = null;
+            }
+
+            if (_pageFreeStacks != null)
+            {
+                SlotArrayPool<int[]>.Return(_pageFreeStacks, true);
+                _pageFreeStacks = null;
+            }
+
+            if (_pageAliveCounts != null)
+            {
+                SlotArrayPool<int>.Return(_pageAliveCounts, true);
+                _pageAliveCounts = null;
+            }
+
+            if (_pageFreeTops != null)
+            {
+                SlotArrayPool<int>.Return(_pageFreeTops, true);
+                _pageFreeTops = null;
+            }
+
+            if (_pageFlags != null)
+            {
+                SlotArrayPool<byte>.Return(_pageFlags, true);
+                _pageFlags = null;
+            }
+
+            if (_freePageStack != null)
+            {
+                SlotArrayPool<int>.Return(_freePageStack, true);
+                _freePageStack = null;
+            }
+
+            if (_emptyPageStack != null)
+            {
+                SlotArrayPool<int>.Return(_emptyPageStack, true);
+                _emptyPageStack = null;
+            }
+
+            _pageCount = 0;
+            _freePageTop = 0;
+            _emptyPageTop = 0;
+        }
+
+        private static int CompareInstanceSnapshot(GameObjectPoolInstanceSnapshot left, GameObjectPoolInstanceSnapshot right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return 1;
+            }
+
+            if (right == null)
+            {
+                return -1;
+            }
+
+            if (left.isActive != right.isActive)
+            {
+                return left.isActive ? -1 : 1;
+            }
+
+            return string.Compare(left.instanceName, right.instanceName, StringComparison.Ordinal);
         }
     }
 }