diff --git a/.gitignore b/.gitignore
index 1660e0b..29b263a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -74,10 +74,10 @@ mono_crash.*
 *.unitypackage.meta
 *.app
 
-# Windows Git matches the macOS bundle pattern case-insensitively. Keep the
-# namespace-suffixed Unity package in source control.
-!Assets/Modules/ShrinkDataSaver.Integration.App/
-!Assets/Modules/ShrinkDataSaver.Integration.App/**
+# Windows Git matches the macOS bundle pattern case-insensitively. Keep all
+# namespace-suffixed Unity Integration.App packages in source control.
+!Assets/Modules/*.Integration.App/
+!Assets/Modules/*.Integration.App/**
 
 # Crashlytics generated file
 crashlytics-build.properties
diff --git a/Assets/Demos/Demo2/Runtime/Demo2AppIntegration.cs b/Assets/Demos/Demo2/Runtime/Demo2AppIntegration.cs
index 3f81fb4..9ee96a0 100644
--- a/Assets/Demos/Demo2/Runtime/Demo2AppIntegration.cs
+++ b/Assets/Demos/Demo2/Runtime/Demo2AppIntegration.cs
@@ -56,8 +56,19 @@ namespace Demo2.Runtime
             ShrinkAppLoaderBootstrapper.DefaultComposition = host =>
             {
                 previous?.Invoke(host);
-                if (host.ModuleIds.Contains("demo2.rule-factory")) host.OverrideModuleComponent("demo2.rule-factory", static () => new Demo2AppComponent());
+                RegisterOrReplace(host, "demo2.rule-factory", static () => new Demo2AppComponent());
             };
         }
+
+        private static void RegisterOrReplace(
+            ShrinkAppLoaderHost host,
+            string moduleId,
+            System.Func<IShrinkComponent> componentFactory)
+        {
+            if (host.ModuleIds.Contains(moduleId, System.StringComparer.OrdinalIgnoreCase))
+                host.OverrideModuleComponent(moduleId, componentFactory);
+            else
+                host.AddModuleComponent(moduleId, componentFactory);
+        }
     }
 }
diff --git a/Assets/Demos/Demo2/Tests/PlayMode/Demo2.PlayMode.Tests.asmdef b/Assets/Demos/Demo2/Tests/PlayMode/Demo2.PlayMode.Tests.asmdef
index d9ba45d..05e7eac 100644
--- a/Assets/Demos/Demo2/Tests/PlayMode/Demo2.PlayMode.Tests.asmdef
+++ b/Assets/Demos/Demo2/Tests/PlayMode/Demo2.PlayMode.Tests.asmdef
@@ -5,6 +5,8 @@
     "Demo2.Domain",
     "Demo2.ECS",
     "Demo2.Runtime",
+    "ShrinkApp.Core.Runtime",
+    "ShrinkContext.AppAdapter.Runtime",
     "Unity.Entities",
     "Unity.Collections"
   ],
diff --git a/Assets/Demos/Demo2/Tests/PlayMode/Demo2PlayModeTests.cs b/Assets/Demos/Demo2/Tests/PlayMode/Demo2PlayModeTests.cs
index 54a5ec5..6ba974f 100644
--- a/Assets/Demos/Demo2/Tests/PlayMode/Demo2PlayModeTests.cs
+++ b/Assets/Demos/Demo2/Tests/PlayMode/Demo2PlayModeTests.cs
@@ -6,6 +6,7 @@ using Demo2.Domain;
 using Demo2.ECS;
 using Demo2.Runtime;
 using NUnit.Framework;
+using ShrinkContext.AppAdapter;
 using Unity.Entities;
 using UnityEngine;
 using UnityEngine.SceneManagement;
@@ -23,6 +24,16 @@ namespace Demo2.Tests
             yield return null;
             var controller = Object.FindObjectOfType<Demo2DemoController>();
             Assert.That(controller, Is.Not.Null);
+            for (var frame = 0; frame < 30 &&
+                 (ShrinkAppLoaderBootstrapper.Instance == null || !ShrinkAppLoaderBootstrapper.Instance.Host.IsRunning);
+                 frame++)
+                yield return null;
+            var appHost = ShrinkAppLoaderBootstrapper.Instance;
+            Assert.That(appHost, Is.Not.Null);
+            Assert.That(appHost!.Host.IsRunning, Is.True);
+            Assert.That(appHost.Host.ActiveModuleIds, Does.Contain("demo2.rule-factory"));
+            Assert.That(appHost.Host.Services.TryGet<Demo2GameService>(out var appService), Is.True);
+            Assert.That(appService, Is.Not.Null);
             var document = controller!.GetComponentInChildren<UIDocument>();
             Assert.That(document, Is.Not.Null);
             var solo = document!.rootVisualElement.Q<Button>("solo-button");
diff --git a/Assets/Demos/ReplacedPerson/Runtime/ReplacedPersonAppIntegration.cs b/Assets/Demos/ReplacedPerson/Runtime/ReplacedPersonAppIntegration.cs
index 6b3b287..269e245 100644
--- a/Assets/Demos/ReplacedPerson/Runtime/ReplacedPersonAppIntegration.cs
+++ b/Assets/Demos/ReplacedPerson/Runtime/ReplacedPersonAppIntegration.cs
@@ -67,9 +67,19 @@ namespace ReplacedPerson.Runtime
             ShrinkAppLoaderBootstrapper.DefaultComposition = host =>
             {
                 previous?.Invoke(host);
-                if (host.ModuleIds.Contains("demo.replaced-person"))
-                    host.OverrideModuleComponent("demo.replaced-person", static () => new ReplacedPersonAppComponent());
+                RegisterOrReplace(host, "demo.replaced-person", static () => new ReplacedPersonAppComponent());
             };
         }
+
+        private static void RegisterOrReplace(
+            ShrinkAppLoaderHost host,
+            string moduleId,
+            Func<IShrinkComponent> componentFactory)
+        {
+            if (host.ModuleIds.Contains(moduleId, StringComparer.OrdinalIgnoreCase))
+                host.OverrideModuleComponent(moduleId, componentFactory);
+            else
+                host.AddModuleComponent(moduleId, componentFactory);
+        }
     }
 }
diff --git a/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPerson.PlayMode.Tests.asmdef b/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPerson.PlayMode.Tests.asmdef
index 1d55060..6434c01 100644
--- a/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPerson.PlayMode.Tests.asmdef
+++ b/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPerson.PlayMode.Tests.asmdef
@@ -1,7 +1,7 @@
 {
   "name": "ReplacedPerson.PlayMode.Tests",
   "rootNamespace": "ReplacedPerson.Tests",
-  "references": ["ReplacedPerson.Core", "ReplacedPerson.Runtime", "UnityEngine.UI", "Unity.TextMeshPro"],
+  "references": ["ReplacedPerson.Core", "ReplacedPerson.Runtime", "ShrinkApp.Core.Runtime", "ShrinkContext.AppAdapter.Runtime", "UnityEngine.UI", "Unity.TextMeshPro"],
   "optionalUnityReferences": ["TestAssemblies"],
   "includePlatforms": [],
   "excludePlatforms": [],
diff --git a/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPersonSceneTests.cs b/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPersonSceneTests.cs
index 95633c5..bac71a3 100644
--- a/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPersonSceneTests.cs
+++ b/Assets/Demos/ReplacedPerson/Tests/PlayMode/ReplacedPersonSceneTests.cs
@@ -4,6 +4,7 @@ using System.Collections;
 using System.Linq;
 using NUnit.Framework;
 using ReplacedPerson.Runtime;
+using ShrinkContext.AppAdapter;
 using TMPro;
 using UnityEngine;
 using UnityEngine.EventSystems;
@@ -22,6 +23,16 @@ namespace ReplacedPerson.Tests
             yield return null;
             var root = GameObject.Find("ReplacedPersonDemo");
             Assert.That(root, Is.Not.Null);
+            for (var frame = 0; frame < 30 &&
+                 (ShrinkAppLoaderBootstrapper.Instance == null || !ShrinkAppLoaderBootstrapper.Instance.Host.IsRunning);
+                 frame++)
+                yield return null;
+            var appHost = ShrinkAppLoaderBootstrapper.Instance;
+            Assert.That(appHost, Is.Not.Null);
+            Assert.That(appHost!.Host.IsRunning, Is.True);
+            Assert.That(appHost.Host.ActiveModuleIds, Does.Contain("demo.replaced-person"));
+            Assert.That(appHost.Host.Services.TryGet<ReplacedPersonGameService>(out var appService), Is.True);
+            Assert.That(appService, Is.Not.Null);
             var camera = Camera.main;
             Assert.That(camera, Is.Not.Null);
             Assert.That(camera!.enabled, Is.True);
diff --git a/Assets/Modules/ShrinkApp.Core/package.json b/Assets/Modules/ShrinkApp.Core/package.json
index 1b8bb53..d020fed 100644
--- a/Assets/Modules/ShrinkApp.Core/package.json
+++ b/Assets/Modules/ShrinkApp.Core/package.json
@@ -5,7 +5,8 @@
   "description": "Shrink 系列统一宿主层，提供模块安装器、服务容器与统一启动流程。",
   "unity": "2022.3",
   "dependencies": {
-    "com.cneicy.shrink-eventbus": "1.1.5",
+    "com.cneicy.shrink-eventbus": "1.3.0",
+    "com.cneicy.shrink-shared-codegen": "0.1.0",
     "com.cysharp.unitask": "2.5.10"
   },
   "keywords": [
diff --git a/Assets/Modules/ShrinkApp.Starter.Basic/Runtime/ShrinkAppBasicContextComposition.cs b/Assets/Modules/ShrinkApp.Starter.Basic/Runtime/ShrinkAppBasicContextComposition.cs
index 53409b5..10fc3f2 100644
--- a/Assets/Modules/ShrinkApp.Starter.Basic/Runtime/ShrinkAppBasicContextComposition.cs
+++ b/Assets/Modules/ShrinkApp.Starter.Basic/Runtime/ShrinkAppBasicContextComposition.cs
@@ -1,6 +1,7 @@
 #nullable enable
 
 using System.Collections.Generic;
+using System.Linq;
 using ShrinkCommand.Integration.App;
 using ShrinkCommand.Integration;
 using ShrinkContext.AppAdapter;
@@ -42,9 +43,9 @@ namespace ShrinkApp.Starter.Basic
             if (host == null)
                 throw new System.ArgumentNullException(nameof(host));
 
-            host.OverrideModuleComponent("shrink.network", static () => new ShrinkNetworkAppComponent());
-            host.OverrideModuleComponent("shrink.command", static () => new ShrinkCommandAppComponent());
-            host.OverrideModuleComponent("shrink.datasaver", static () => new ShrinkDataSaverAppComponent());
+            RegisterOrReplace(host, "shrink.network", static () => new ShrinkNetworkAppComponent());
+            RegisterOrReplace(host, "shrink.command", static () => new ShrinkCommandAppComponent());
+            RegisterOrReplace(host, "shrink.datasaver", static () => new ShrinkDataSaverAppComponent());
             host.AddModuleComponent("shrink.integration.command-network",
                 static () => new ShrinkCommandNetworkIntegrationComponent());
             host.AddModuleComponent("shrink.integration.command-eventbus",
@@ -55,6 +56,17 @@ namespace ShrinkApp.Starter.Basic
                 static () => new ShrinkNetworkEventBusComponent());
         }
 
+        private static void RegisterOrReplace(
+            ShrinkAppLoaderHost host,
+            string moduleId,
+            System.Func<ShrinkContext.IShrinkComponent> componentFactory)
+        {
+            if (host.ModuleIds.Any(id => string.Equals(id, moduleId, System.StringComparison.OrdinalIgnoreCase)))
+                host.OverrideModuleComponent(moduleId, componentFactory);
+            else
+                host.AddModuleComponent(moduleId, componentFactory);
+        }
+
         public static ShrinkAppCompositionDocument CreateDefaultDocument()
         {
             var entries = new List<ShrinkAppCompositionEntry>(DefaultModuleIdValues.Length);
diff --git a/Assets/Modules/ShrinkApp.Starter.Basic/package.json b/Assets/Modules/ShrinkApp.Starter.Basic/package.json
index 064f117..e078f81 100644
--- a/Assets/Modules/ShrinkApp.Starter.Basic/package.json
+++ b/Assets/Modules/ShrinkApp.Starter.Basic/package.json
@@ -5,7 +5,7 @@
   "description": "ShrinkApp 最小起盘 Starter，提供向导、入口场景和 DataSaver 示例。",
   "unity": "2022.3",
   "dependencies": {
-    "com.cneicy.shrink-app-core": "0.1.0",
+    "com.cneicy.shrink-app-core": "0.1.1",
     "com.cneicy.shrink-context-core": "0.1.0",
     "com.cneicy.shrink-context-app-adapter": "0.1.0",
     "com.cneicy.shrink-command": "0.2.0",
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md b/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md
new file mode 100644
index 0000000..d7c0103
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md
@@ -0,0 +1,11 @@
+# Changelog
+
+本文件记录 `ShrinkCommand.Integration.App` 的包内变更。
+
+## [0.1.0] - 2026-05-18
+
+### Added
+
+- 新增 `ShrinkCommand` 与 `ShrinkApp.Core` 的桥接包。
+- 新增 `ShrinkCommandAppInstaller`，把默认命令服务挂入宿主服务容器。
+- 新增 `ShrinkCommandAppService` 作为宿主侧命令门面。
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md.meta b/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md.meta
new file mode 100644
index 0000000..dede82c
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1754b3bc0377768409187131b594bda6
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/README.md b/Assets/Modules/ShrinkCommand.Integration.App/README.md
new file mode 100644
index 0000000..1f32796
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/README.md
@@ -0,0 +1,23 @@
+# ShrinkCommand.Integration.App
+
+`ShrinkCommand.Integration.App` 是 `ShrinkCommand` 与 `ShrinkApp.Core` 的桥接层。它的职责很简单：把默认命令服务挂进 `ShrinkApp` 的服务容器里，让项目在进入统一宿主模式后，仍能用熟悉的命令系统，而不需要到处手动拿 `ShrinkCommandRuntime.Default`。
+
+## 当前能力
+
+- 提供原生 `ShrinkCommandAppComponent`，发布 `shrink.service.command`
+- 把 `ShrinkCommandRuntime.Default` 包装为 `ShrinkCommandAppService`
+- ContextLoader 下由 Starter 组合根装配，服务门面随组件停用可逆注销
+- `ShrinkCommandAppInstaller` 仅保留给 ClassicHost 兼容路径，已标记过时
+
+## 使用示例
+
+```csharp
+var command = ShrinkApp.ShrinkApp.Services.GetRequired<ShrinkCommand.Integration.App.ShrinkCommandAppService>();
+var result = await command.ExecuteAsync(source, "help");
+```
+
+## 说明
+
+- 本包不改变 `ShrinkCommand` 的原有 API。
+- 静态命令的默认注册仍由 `ShrinkCommandRuntime.Default` 完成。
+- 运行时实例命令仍然走 `RegisterCommands(object target)`。
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/README.md.meta b/Assets/Modules/ShrinkCommand.Integration.App/README.md.meta
new file mode 100644
index 0000000..b6d83a5
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: da6f74ed70ed86e48bc9309983a690b9
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime.meta b/Assets/Modules/ShrinkCommand.Integration.App/Runtime.meta
new file mode 100644
index 0000000..27fbc44
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 79640806d61572d44b10ae9bbb0ace79
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef
new file mode 100644
index 0000000..7ddce94
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef
@@ -0,0 +1,18 @@
+{
+  "name": "ShrinkCommand.Integration.App",
+  "rootNamespace": "ShrinkCommand.Integration.App",
+  "references": [
+    "ShrinkCommand.Runtime",
+    "ShrinkApp.Core.Runtime",
+    "ShrinkContext.Core.Runtime",
+        "UniTask"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef.meta b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef.meta
new file mode 100644
index 0000000..a5c227c
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommand.Integration.App.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e5805c0a2f81e6f47818b1dac7d15e6c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs
new file mode 100644
index 0000000..1f8c414
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs
@@ -0,0 +1,49 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using ShrinkApp;
+using ShrinkContext;
+using ShrinkCommand;
+
+namespace ShrinkCommand.Integration.App
+{
+    /// <summary>
+    /// ShrinkCommand 的原生 Cordis 组件（阶段 3）：
+    /// 提供 <c>shrink.service.command</c> 余效应键（默认命令服务），依赖者按键注入；
+    /// 与经典 ShrinkCommandAppInstaller（ModuleId "shrink.command"）二选一使用（同键供给冲突保护）。
+    /// </summary>
+    public sealed class ShrinkCommandAppComponent : IShrinkComponent
+    {
+        public const string ServiceKey = "shrink.service.command";
+        public const string ModuleKey = "app.module.shrink.command";
+
+        private static readonly string[] ProvideKeys = { ModuleKey, ServiceKey };
+
+        public string Name => "shrink.command";
+
+        public IReadOnlyList<string> Inject => Array.Empty<string>();
+
+        public IReadOnlyList<string> Provide => ProvideKeys;
+
+        public UniTask ApplyAsync(ShrinkCtx ctx, object? config)
+        {
+            var service = ShrinkCommandRuntime.Default;
+            ctx.Set(ServiceKey, service);
+            ctx.Set(ModuleKey, Name);
+
+            if (config is ShrinkAppServices appServices)
+            {
+                var facade = new ShrinkCommandAppService(service);
+                appServices.Register(facade);
+                ctx.EffectInverse(() =>
+                {
+                    appServices.TryUnregister(facade);
+                    return UniTask.CompletedTask;
+                });
+            }
+
+            return UniTask.CompletedTask;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs.meta b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs.meta
new file mode 100644
index 0000000..4b584f9
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppComponent.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 507e23e02986281488456a63dc8ffdbe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs
new file mode 100644
index 0000000..5a6a066
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs
@@ -0,0 +1,48 @@
+#nullable enable
+
+using System;
+using Cysharp.Threading.Tasks;
+using ShrinkApp;
+
+namespace ShrinkCommand.Integration.App
+{
+    [ShrinkAppModuleInstaller]
+    [Obsolete("ClassicHost compatibility only. ContextLoader projects should use ShrinkCommandAppComponent from a composition root.")]
+    public sealed class ShrinkCommandAppInstaller : IShrinkAppModuleInstaller
+    {
+        public string ModuleId => "shrink.command";
+        public int Order => -1500;
+        public System.Collections.Generic.IReadOnlyList<string> DependsOn => Array.Empty<string>();
+
+        public void RegisterServices(ShrinkAppContext context)
+        {
+            context.Services.Register(new ShrinkCommandAppService(ShrinkCommandRuntime.Default));
+        }
+
+        public UniTask InitializeAsync(ShrinkAppContext context)
+        {
+            return UniTask.CompletedTask;
+        }
+    }
+
+    public sealed class ShrinkCommandAppService
+    {
+        public ShrinkCommandAppService(ShrinkCommandService service)
+        {
+            Service = service ?? throw new ArgumentNullException(nameof(service));
+        }
+
+        public ShrinkCommandService Service { get; }
+
+        public UniTask<ShrinkCommandExecutionResult> ExecuteAsync(
+            IShrinkCommandSource source,
+            string rawInput,
+            System.Threading.CancellationToken cancellationToken = default)
+            => Service.ExecuteAsync(source, rawInput, cancellationToken);
+
+        public string BuildHelp(IShrinkCommandSource? source, string? prefix = null)
+            => Service.BuildHelp(source, prefix);
+
+        public System.Collections.Generic.IReadOnlyList<ShrinkCommandDescriptor> Commands => Service.Commands;
+    }
+}
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs.meta b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs.meta
new file mode 100644
index 0000000..d696176
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/Runtime/ShrinkCommandAppInstaller.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a71473a2ecd04c3459903841fee6da7d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/package.json b/Assets/Modules/ShrinkCommand.Integration.App/package.json
new file mode 100644
index 0000000..449eb20
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "com.cneicy.shrink-command-integration-app",
+  "version": "0.1.0",
+  "displayName": "ShrinkCommand - App Integration",
+  "description": "ShrinkCommand 与 ShrinkApp 的桥接层，把默认命令服务纳入统一宿主服务容器。",
+  "unity": "2022.3",
+  "dependencies": {
+    "com.cneicy.shrink-command": "0.2.0",
+    "com.cneicy.shrink-app-core": "0.1.1",
+    "com.cysharp.unitask": "2.5.10",
+    "com.cneicy.shrink-context-core": "0.1.0"
+  },
+  "keywords": [
+    "command",
+    "integration",
+    "app",
+    "console"
+  ],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkCommand.Integration.App/package.json.meta b/Assets/Modules/ShrinkCommand.Integration.App/package.json.meta
new file mode 100644
index 0000000..15a121b
--- /dev/null
+++ b/Assets/Modules/ShrinkCommand.Integration.App/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 126abcc047b44714593c2f94aa587c75
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkCommand.Integration.EventBus/package.json b/Assets/Modules/ShrinkCommand.Integration.EventBus/package.json
index 492daff..dbf9433 100644
--- a/Assets/Modules/ShrinkCommand.Integration.EventBus/package.json
+++ b/Assets/Modules/ShrinkCommand.Integration.EventBus/package.json
@@ -5,9 +5,9 @@
   "description": "ShrinkCommand 与 ShrinkEventBus 的桥接层，支持事件请求执行命令，以及命令执行生命周期事件发布。",
   "unity": "2022.3",
   "dependencies": {
-    "com.cneicy.shrink-command": "0.1.0",
+    "com.cneicy.shrink-command": "0.2.0",
     "com.cneicy.shrink-context-core": "0.1.0",
-    "com.cneicy.shrink-eventbus": "1.1.5"
+    "com.cneicy.shrink-eventbus": "1.3.0"
   },
   "keywords": ["command", "eventbus", "integration", "bridge"],
   "author": {
diff --git a/Assets/Modules/ShrinkCommand.Integration.Network/package.json b/Assets/Modules/ShrinkCommand.Integration.Network/package.json
index 4467920..f364b65 100644
--- a/Assets/Modules/ShrinkCommand.Integration.Network/package.json
+++ b/Assets/Modules/ShrinkCommand.Integration.Network/package.json
@@ -5,8 +5,8 @@
   "description": "ShrinkCommand 与 ShrinkNetwork 的桥接层，允许远程会话通过 RPC 执行命令。",
   "unity": "2022.3",
   "dependencies": {
-    "com.cneicy.shrink-command": "0.1.0",
-    "com.cneicy.shrink-network": "0.1.0",
+    "com.cneicy.shrink-command": "0.2.0",
+    "com.cneicy.shrink-network": "0.2.0",
     "com.cneicy.shrink-context-core": "0.1.0"
   },
   "keywords": [
@@ -19,4 +19,4 @@
     "name": "cneicy",
     "url": "https://github.com/cneicy"
   }
-}
\ No newline at end of file
+}
diff --git a/Assets/Modules/ShrinkCommand/package.json b/Assets/Modules/ShrinkCommand/package.json
index 2388305..67e39fa 100644
--- a/Assets/Modules/ShrinkCommand/package.json
+++ b/Assets/Modules/ShrinkCommand/package.json
@@ -5,6 +5,7 @@
   "description": "独立于网络层的 Unity 命令系统，提供路径式命令、权限、帮助输出与属性式注册。",
   "unity": "2022.3",
   "dependencies": {
+    "com.cneicy.shrink-shared-codegen": "0.1.0",
     "com.cysharp.unitask": "2.5.10"
   },
   "keywords": [
diff --git a/Assets/Modules/ShrinkContext.AppAdapter/README.md b/Assets/Modules/ShrinkContext.AppAdapter/README.md
index 94d42cb..3a7df8b 100644
--- a/Assets/Modules/ShrinkContext.AppAdapter/README.md
+++ b/Assets/Modules/ShrinkContext.AppAdapter/README.md
@@ -1,6 +1,6 @@
 # ShrinkContext.AppAdapter
 
-ShrinkApp ↔ ShrinkContext 的桥接层：把现有 `IShrinkAppModuleInstaller` 生态接入 Cordis 时空可组合性范式（阶段 2 过渡产物，方案见仓库根 `CORDIS_MIGRATION.md`）。
+ShrinkApp ↔ ShrinkContext 的桥接层：提供当前默认的 ContextLoader 宿主、声明式组合 Profile、诊断工具，并保留 `IShrinkAppModuleInstaller` 兼容适配。当前架构与边界见仓库根 `DESIGN.md`。
 
 ## 组成
 
@@ -62,11 +62,11 @@ Profile 的 JSON 结构如下：
 | 依赖缺失 | 排序期抛错 | 安装器保持 Waiting，依赖出现自动激活 |
 | 重复 ModuleId | 宿主级异常 | 构造期抛错（一致）；运行期替换退化为供给冲突失败 |
 | 运行中禁用模块 | 不支持（需重启） | `SetModuleDisabledAsync` 增量协调，重启用会重新执行安装器初始化 |
-| `ShrinkApp.IsRunning` | Host 驱动 | 以 `ShrinkAppLoaderHost.IsRunning` 为准（静态 IsRunning 为 false，过渡期已知差异） |
+| `ShrinkApp.IsRunning` | Host 驱动 | LoaderHost 通过 `SetExternalHostRunning` 同步静态门面状态 |
 
 ## 已知边界
 
-- `ShrinkAppServices` 无注销能力：安装器停用不撤回已注册服务（重新启用会重跑 RegisterServices，同键覆盖）。
+- `ShrinkAppServices.TryUnregister(instance)` 支持按实例撤回服务；原生 Context 组件已使用该路径。旧 installer 包装器仍取决于安装器自身是否提供完整逆操作。
 - config/isolate 变化走条目重建；intercept metadata 可原位更新而不改变 fiber generation。
 - 运行中不支持重新应用整份 Profile；资产修改在下一次宿主启动生效，运行中模块开关仍使用 `SetModuleDisabledAsync`。
 - Editor 基准的毫秒数和 GC 管理堆差值只用于同机前后对比；自动测试只断言索引候选规模和事务恢复结果。
diff --git a/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppInstallerComponent.cs b/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppInstallerComponent.cs
index 074a826..1229f84 100644
--- a/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppInstallerComponent.cs
+++ b/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppInstallerComponent.cs
@@ -14,8 +14,8 @@ namespace ShrinkContext.AppAdapter
     /// - provide 发布模块键 <c>app.module.&lt;ModuleId&gt;</c>（安装器 Active 后对依赖者可见）；
     /// - apply 依次执行 RegisterServices + InitializeAsync，config 必须传入 <see cref="ShrinkAppServices"/>。
     ///
-    /// 已知边界（后续阶段补齐）：ShrinkAppServices 尚无注销能力，
-    /// 安装器卸载时不会移除已注册的服务；重新激活会重复执行 RegisterServices（同键覆盖）。
+    /// 兼容安装器只负责执行既有 RegisterServices + InitializeAsync。需要停用时撤回服务的模块应使用
+    /// 原生 Context 组件，并通过 ShrinkAppServices.TryUnregister(instance) 登记对应逆操作。
     /// </summary>
     public sealed class ShrinkAppInstallerComponent : IShrinkComponent
     {
diff --git a/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppLoaderBootstrapper.cs b/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppLoaderBootstrapper.cs
index d52e39f..c053b18 100644
--- a/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppLoaderBootstrapper.cs
+++ b/Assets/Modules/ShrinkContext.AppAdapter/Runtime/ShrinkAppLoaderBootstrapper.cs
@@ -17,7 +17,7 @@ namespace ShrinkContext.AppAdapter
 
         /// <summary>
         /// Starter/组合包在 SubsystemRegistration 阶段设置的默认装配表。
-        /// AppAdapter 保持不依赖具体业务模块，组合根负责把原生组件挂到已发现的模块 id。
+        /// AppAdapter 保持不依赖具体业务模块，组合根负责注册原生组件；若兼容 installer 已被发现则覆盖同 id。
         /// </summary>
         public static System.Action<ShrinkAppLoaderHost>? DefaultComposition { get; set; }
 
diff --git a/Assets/Modules/ShrinkContext.AppAdapter/package.json b/Assets/Modules/ShrinkContext.AppAdapter/package.json
index cb6d160..6b64231 100644
--- a/Assets/Modules/ShrinkContext.AppAdapter/package.json
+++ b/Assets/Modules/ShrinkContext.AppAdapter/package.json
@@ -6,7 +6,7 @@
   "unity": "2022.3",
   "dependencies": {
     "com.cneicy.shrink-context-core": "0.1.0",
-    "com.cneicy.shrink-app-core": "0.1.0",
+    "com.cneicy.shrink-app-core": "0.1.1",
     "com.cysharp.unitask": "2.5.10"
   },
   "keywords": [
@@ -20,4 +20,4 @@
     "name": "cneicy",
     "url": "https://github.com/cneicy"
   }
-}
\ No newline at end of file
+}
diff --git a/Assets/Modules/ShrinkContext.Core/README.md b/Assets/Modules/ShrinkContext.Core/README.md
index cb7efa6..023e2a4 100644
--- a/Assets/Modules/ShrinkContext.Core/README.md
+++ b/Assets/Modules/ShrinkContext.Core/README.md
@@ -1,6 +1,6 @@
 # ShrinkContext.Core
 
-《Cordis: A Programming Paradigm for Spatiotemporal Composability》核心机制的 Unity/C# 实现（改造方案与当前边界见仓库根 `CORDIS_MIGRATION.md`）。
+《Cordis: A Programming Paradigm for Spatiotemporal Composability》核心机制的 Unity/C# 实现。当前架构与边界见仓库根 `DESIGN.md`；已完成的迁移过程归档于 `Docs/Archive/CORDIS_MIGRATION.completed.md`。
 
 ## 定位
 
@@ -61,7 +61,7 @@
 - 强类型版本键是新增契约，现有字符串键不会在阶段 5 被一次性重写。
 - Core 保持不依赖具体配置资产；`ShrinkContext.AppAdapter` 提供 ScriptableObject/JSON 组合、Editor 诊断窗和可重复容量基准。
 - 主线程宿主与 Unity PlayerLoop 调度仍由上层应用负责。
-- 跨进程/独立服务器上下文
+- 当前上下文只协调单进程内组件；跨进程/独立服务器使用 Network 合同，不共享 fiber 或事务。
 
 ## 约定
 
diff --git a/Assets/Modules/ShrinkDataSaver b/Assets/Modules/ShrinkDataSaver
deleted file mode 160000
index 524a1fd..0000000
--- a/Assets/Modules/ShrinkDataSaver
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 524a1fd11ec752913b4a361a5ec1918d6a2ad362
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.App/package.json b/Assets/Modules/ShrinkDataSaver.Integration.App/package.json
index 8d86a37..28b7857 100644
--- a/Assets/Modules/ShrinkDataSaver.Integration.App/package.json
+++ b/Assets/Modules/ShrinkDataSaver.Integration.App/package.json
@@ -6,7 +6,7 @@
   "unity": "2022.3",
   "dependencies": {
     "com.cneicy.shrink-datasaver": "2.2.0",
-    "com.cneicy.shrink-app-core": "0.1.0",
+    "com.cneicy.shrink-app-core": "0.1.1",
     "com.cysharp.unitask": "2.5.10",
     "com.cneicy.shrink-context-core": "0.1.0"
   },
@@ -20,4 +20,4 @@
     "name": "cneicy",
     "url": "https://github.com/cneicy"
   }
-}
\ No newline at end of file
+}
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus b/Assets/Modules/ShrinkDataSaver.Integration.EventBus
deleted file mode 160000
index 6dbee4a..0000000
--- a/Assets/Modules/ShrinkDataSaver.Integration.EventBus
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 6dbee4a992944ac264e5cb47998844c5d1d986d5
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md
new file mode 100644
index 0000000..3296e96
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md
@@ -0,0 +1,15 @@
+# Changelog
+
+本文件记录 `ShrinkDataSaver.Integration.EventBus` 这个独立 UPM 包的变更。
+
+## [2.1.0] - 2026-05-18
+
+### Changed
+
+- 与 `ShrinkDataSaverRuntime` / `ShrinkApp` 接管初始化链路兼容，保留零配置桥接方式不变。
+
+## [2.0.1] - 2026-04-06
+
+### Changed
+
+- 添加了变更日志。
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md.meta
new file mode 100644
index 0000000..b09bf6a
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 916d7f3a5759d4941823219888267177
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs
new file mode 100644
index 0000000..98dbfb4
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs
@@ -0,0 +1,107 @@
+#nullable enable
+
+using ShrinkEventBus;
+using UnityEngine;
+
+namespace ShrinkDataSaver.Integration
+{
+    /// <summary>
+    /// DataSaver 原生事件到 EventBus 的显式桥接器。
+    /// 生命周期由 ShrinkDataSaverEventBusComponent 管理，不再因程序集存在而全局自动接入。
+    /// </summary>
+    public static class DataSaverEventBusBridge
+    {
+        private static bool _registered;
+
+        public static bool IsRegistered => _registered;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void ResetStaticState()
+        {
+            Unregister();
+            _registered = false;
+        }
+
+        public static void Register()
+        {
+            if (_registered)
+                return;
+
+            ShrinkSettings.OnChanged += HandleSettingsChanged;
+            ShrinkSave.OnSaveStarted += HandleSaveStarted;
+            ShrinkSave.OnSaveCompleted += HandleSaveCompleted;
+            ShrinkSave.OnSaveFailed += HandleSaveFailed;
+            ShrinkSave.OnLoadStarted += HandleLoadStarted;
+            ShrinkSave.OnLoadCompleted += HandleLoadCompleted;
+            ShrinkSave.OnLoadFailed += HandleLoadFailed;
+            ShrinkSave.OnMigrationCompleted += HandleMigrationCompleted;
+            ShrinkSave.OnDeleteCompleted += HandleSlotDeleted;
+            _registered = true;
+        }
+
+        public static void Unregister()
+        {
+            ShrinkSettings.OnChanged -= HandleSettingsChanged;
+            ShrinkSave.OnSaveStarted -= HandleSaveStarted;
+            ShrinkSave.OnSaveCompleted -= HandleSaveCompleted;
+            ShrinkSave.OnSaveFailed -= HandleSaveFailed;
+            ShrinkSave.OnLoadStarted -= HandleLoadStarted;
+            ShrinkSave.OnLoadCompleted -= HandleLoadCompleted;
+            ShrinkSave.OnLoadFailed -= HandleLoadFailed;
+            ShrinkSave.OnMigrationCompleted -= HandleMigrationCompleted;
+            ShrinkSave.OnDeleteCompleted -= HandleSlotDeleted;
+            _registered = false;
+        }
+
+        private static void HandleSettingsChanged(string key, object value) =>
+            EventBus.TriggerEvent(new SettingsChangedEvent { Key = key, Value = value });
+
+        private static void HandleSaveStarted(SaveStartedEventArgs args) =>
+            EventBus.TriggerEvent(new SaveStartedEvent { SlotIndex = args.SlotIndex, Timestamp = args.Timestamp });
+
+        private static void HandleSaveCompleted(SaveCompletedEventArgs args) =>
+            EventBus.TriggerEvent(new SaveCompletedEvent
+            {
+                SlotIndex = args.SlotIndex,
+                ModuleNames = args.ModuleNames,
+                Timestamp = args.Timestamp
+            });
+
+        private static void HandleSaveFailed(SaveFailedEventArgs args) =>
+            EventBus.TriggerEvent(new SaveFailedEvent
+            {
+                SlotIndex = args.SlotIndex,
+                ErrorMessage = args.ErrorMessage
+            });
+
+        private static void HandleLoadStarted(LoadStartedEventArgs args) =>
+            EventBus.TriggerEvent(new LoadStartedEvent { SlotIndex = args.SlotIndex, Timestamp = args.Timestamp });
+
+        private static void HandleLoadCompleted(LoadCompletedEventArgs args) =>
+            EventBus.TriggerEvent(new LoadCompletedEvent
+            {
+                SlotIndex = args.SlotIndex,
+                ModuleNames = args.ModuleNames,
+                Version = args.Version,
+                Timestamp = args.Timestamp
+            });
+
+        private static void HandleLoadFailed(LoadFailedEventArgs args) =>
+            EventBus.TriggerEvent(new LoadFailedEvent
+            {
+                SlotIndex = args.SlotIndex,
+                ErrorMessage = args.ErrorMessage
+            });
+
+        private static void HandleMigrationCompleted(MigrationCompletedEventArgs args) =>
+            EventBus.TriggerEvent(new MigrationCompletedEvent
+            {
+                SlotIndex = args.SlotIndex,
+                FromVersion = args.FromVersion,
+                ToVersion = args.ToVersion
+            });
+
+        private static void HandleSlotDeleted(SlotDeletedEventArgs args) =>
+            EventBus.TriggerEvent(new SlotDeletedEvent { SlotIndex = args.SlotIndex });
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs.meta
new file mode 100644
index 0000000..1d621a1
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d41cba0389b740dc80169c21db9eb259
+timeCreated: 1773053776
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs
new file mode 100644
index 0000000..ba521bd
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs
@@ -0,0 +1,63 @@
+using System;
+using ShrinkEventBus;
+
+namespace ShrinkDataSaver.Integration
+{
+    public class SettingsChangedEvent : EventBase
+    {
+        public string Key { get; internal set; }
+        public object Value { get; internal set; }
+        public T Get<T>() => (T)Convert.ChangeType(Value, typeof(T));
+    }
+
+    public class SaveStartedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public long Timestamp { get; internal set; }
+    }
+
+    public class SaveCompletedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public string[] ModuleNames { get; internal set; }
+        public long Timestamp { get; internal set; }
+    }
+
+    public class SaveFailedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public string ErrorMessage { get; internal set; }
+    }
+
+    public class LoadStartedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public long Timestamp { get; internal set; }
+    }
+
+    public class LoadCompletedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public string[] ModuleNames { get; internal set; }
+        public int Version { get; internal set; }
+        public long Timestamp { get; internal set; }
+    }
+
+    public class LoadFailedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public string ErrorMessage { get; internal set; }
+    }
+
+    public class MigrationCompletedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+        public int FromVersion { get; internal set; }
+        public int ToVersion { get; internal set; }
+    }
+
+    public class SlotDeletedEvent : EventBase
+    {
+        public int SlotIndex { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs.meta
new file mode 100644
index 0000000..aee6b96
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 154ed134a6cb40c4be44560f08362a2a
+timeCreated: 1773053752
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md
new file mode 100644
index 0000000..e4151b6
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md
@@ -0,0 +1,155 @@
+# ShrinkDataSaver.Integration.EventBus
+
+[ShrinkDataSaver](https://github.com/cneicy/ShrinkDataSaver) 与 [ShrinkEventBus](https://github.com/cneicy/ShrinkEventBus) 的桥接层。
+
+ContextLoader 下由 `ShrinkDataSaverEventBusComponent` 注入 `shrink.service.datasaver` 后接桥，依赖撤回时拆桥；独立使用时调用 `DataSaverEventBusBridge.Register()` / `Unregister()`。仅安装程序集不会再产生全局副作用。
+
+## ✨ 特性概览
+
+| 特性 | 说明 |
+|------|------|
+| 🌉 **可逆桥接** | 由 Cordis 组件或显式 API 管理注册与注销 |
+| 📡 **完整事件覆盖** | 9 种事件类型，覆盖设置变更 + 存档保存/加载/删除/迁移全生命周期 |
+| 🔒 **类型安全** | 所有事件继承 `EventBase`，支持 `[EventBusSubscriber]` 自动注册 |
+| 📦 **丰富载荷** | 事件携带 SlotIndex、ModuleNames、Version、Timestamp、ErrorMessage 等完整数据 |
+
+## 📦 依赖
+
+- [ShrinkDataSaver](https://github.com/cneicy/ShrinkDataSaver) `2.0.0+`
+- [ShrinkEventBus](https://github.com/cneicy/ShrinkEventBus) `1.0.0+`
+
+## ⚙️ 安装
+
+在项目的 `Packages/manifest.json` 中添加：
+
+```json
+{
+  "dependencies": {
+    "com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask",
+    "com.cneicy.shrink-datasaver": "https://github.com/cneicy/ShrinkDataSaver.git",
+    "com.cneicy.shrink-datasaver-integration-eventbus": "https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus.git"
+  }
+}
+```
+
+或通过 Package Manager → `+` → `Add package from git URL` 输入：
+
+```
+https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus.git
+```
+
+## 📡 事件类型
+
+| 事件类 | 对应原生事件 | 载荷字段 |
+|--------|-------------|----------|
+| `SettingsChangedEvent` | `ShrinkSettings.OnChanged` | Key, Value |
+| `SaveStartedEvent` | `ShrinkSave.OnSaveStarted` | SlotIndex, Timestamp |
+| `SaveCompletedEvent` | `ShrinkSave.OnSaveCompleted` | SlotIndex, ModuleNames[], Timestamp |
+| `SaveFailedEvent` | `ShrinkSave.OnSaveFailed` | SlotIndex, ErrorMessage |
+| `LoadStartedEvent` | `ShrinkSave.OnLoadStarted` | SlotIndex, Timestamp |
+| `LoadCompletedEvent` | `ShrinkSave.OnLoadCompleted` | SlotIndex, ModuleNames[], Version, Timestamp |
+| `LoadFailedEvent` | `ShrinkSave.OnLoadFailed` | SlotIndex, ErrorMessage |
+| `MigrationCompletedEvent` | `ShrinkSave.OnMigrationCompleted` | SlotIndex, FromVersion, ToVersion |
+| `SlotDeletedEvent` | `ShrinkSave.OnDeleteCompleted` | SlotIndex |
+
+## 🚀 使用示例
+
+### 使用 `[EventBusSubscriber]` 自动注册（推荐）
+
+```csharp
+[EventBusSubscriber]
+public class SaveUIManager : MonoBehaviour
+{
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnSaveCompleted(SaveCompletedEvent e)
+    {
+        Debug.Log($"槽位 {e.SlotIndex} 保存成功，模块: {string.Join(", ", e.ModuleNames)}");
+        ShowSaveIndicator();
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnLoadCompleted(LoadCompletedEvent e)
+    {
+        Debug.Log($"槽位 {e.SlotIndex} 加载完成 (v{e.Version})");
+        TransitionToGame();
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnSaveFailed(SaveFailedEvent e)
+    {
+        ShowErrorDialog($"保存失败: {e.ErrorMessage}");
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnLoadFailed(LoadFailedEvent e)
+    {
+        ShowErrorDialog($"加载失败: {e.ErrorMessage}");
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnMigration(MigrationCompletedEvent e)
+    {
+        Debug.Log($"存档已从 v{e.FromVersion} 迁移到 v{e.ToVersion}");
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnSettingsChanged(SettingsChangedEvent e)
+    {
+        if (e.Key == "MasterVolume")
+            ApplyVolume(e.Get<float>());
+    }
+}
+```
+
+### 手动注册
+
+```csharp
+public class AnalyticsTracker : IDisposable
+{
+    public AnalyticsTracker()
+    {
+        EventBus.RegisterEvent<SaveCompletedEvent>(OnSave, EventPriority.LOWEST);
+        EventBus.RegisterEvent<LoadCompletedEvent>(OnLoad, EventPriority.LOWEST);
+    }
+
+    private void OnSave(SaveCompletedEvent e)
+        => Analytics.Track("save", new { slot = e.SlotIndex, modules = e.ModuleNames.Length });
+
+    private void OnLoad(LoadCompletedEvent e)
+        => Analytics.Track("load", new { slot = e.SlotIndex, version = e.Version });
+
+    public void Dispose()
+        => EventBus.UnregisterAllEventsForObject(this);
+}
+```
+
+## 🏗️ 架构
+
+```
+ShrinkDataSaver.Integration.EventBus/
+├── DataSaverEvents.cs           9 个 EventBase 子类（事件定义）
+├── DataSaverEventBusBridge.cs   显式、可注销的静态桥接器
+├── ShrinkDataSaverEventBusComponent.cs  按服务键管理桥生命周期
+└── ShrinkDataSaver.Integration.EventBus.asmdef
+```
+
+**桥接原理：**
+
+```
+ShrinkDataSaver 原生事件 (Action<XxxEventArgs>)
+  └─ ShrinkDataSaverEventBusComponent / 显式 Register
+       └─ EventBus.TriggerEvent(new XxxEvent { ... })
+            └─ ShrinkEventBus 分发到所有订阅者
+```
+
+桥接器是单向的：DataSaver → EventBus。业务代码只需订阅 EventBus 事件，无需直接引用 ShrinkDataSaver 的原生事件。
+
+## ⚠️ 注意事项
+
+- **生命周期**：ContextLoader 组合根负责接桥；Standalone 必须在 DataSaver 初始化后显式 `Register()`，并在退出时 `Unregister()`。
+- **不影响原生事件**：桥接是附加行为，ShrinkDataSaver 的原生 C# 事件仍然正常触发，两种订阅方式可并存。
+- **SettingsChangedEvent.Get\<T\>()**：提供泛型辅助方法获取强类型值，内部使用 `Convert.ChangeType`。
+
+## 📄 License
+
+[MIT](LICENSE)
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md.meta
new file mode 100644
index 0000000..920e933
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d6a7cdf0e3e46ae418fd90acc11d6d48
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef
new file mode 100644
index 0000000..029f7ef
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef
@@ -0,0 +1,19 @@
+{
+  "name": "ShrinkDataSaver.Integration.EventBus",
+  "rootNamespace": "ShrinkDataSaver.Integration",
+  "references": [
+    "ShrinkDataSaver.Runtime",
+    "ShrinkContext.Core.Runtime",
+    "UniTask",
+    "ShrinkEventBus.Runtime"
+  ],
+  "optionalUnityReferences": [],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef.meta
new file mode 100644
index 0000000..498d1d4
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d3277e39d0a8439db56bfb6774183165
+timeCreated: 1773053684
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs
new file mode 100644
index 0000000..6d6b573
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs
@@ -0,0 +1,35 @@
+#nullable enable
+
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using ShrinkContext;
+
+namespace ShrinkDataSaver.Integration
+{
+    /// <summary>注入 DataSaver 服务键并把其原生事件显式接到 EventBus。</summary>
+    public sealed class ShrinkDataSaverEventBusComponent : IShrinkComponent
+    {
+        public const string DataSaverServiceKey = "shrink.service.datasaver";
+        public const string ProvideKey = "shrink.integration.datasaver-eventbus";
+
+        private static readonly string[] InjectKeys = { DataSaverServiceKey };
+        private static readonly string[] ProvideKeys = { ProvideKey };
+
+        public string Name => "shrink.integration.datasaver-eventbus";
+        public IReadOnlyList<string> Inject => InjectKeys;
+        public IReadOnlyList<string> Provide => ProvideKeys;
+
+        public UniTask ApplyAsync(ShrinkCtx ctx, object? config)
+        {
+            _ = ctx.Get<object>(DataSaverServiceKey);
+            DataSaverEventBusBridge.Register();
+            ctx.EffectInverse(() =>
+            {
+                DataSaverEventBusBridge.Unregister();
+                return UniTask.CompletedTask;
+            });
+            ctx.Set(ProvideKey, Name);
+            return UniTask.CompletedTask;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs.meta
new file mode 100644
index 0000000..6da8e30
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaverEventBusComponent.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ee66c2e8bc4958946b7c0849b11545ba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json
new file mode 100644
index 0000000..55d7977
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "com.cneicy.shrink-datasaver-integration-eventbus",
+  "version": "2.1.0",
+  "displayName": "ShrinkDataSaver - EventBus Integration",
+  "description": "ShrinkDataSaver 与 ShrinkEventBus 的桥接层，自动将存档/设置事件映射到事件总线。",
+  "unity": "2022.3",
+  "documentationUrl": "https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus",
+  "changelogUrl": "https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus/blob/main/CHANGELOG.md",
+  "licensesUrl": "https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus/blob/main/LICENSE",
+  "dependencies": {
+    "com.cneicy.shrink-datasaver": "2.2.0",
+    "com.cneicy.shrink-context-core": "0.1.0",
+    "com.cysharp.unitask": "2.5.10",
+    "com.cneicy.shrink-eventbus": "1.3.0"
+  },
+  "keywords": ["save", "eventbus", "integration", "bridge"],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json.meta b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json.meta
new file mode 100644
index 0000000..803aeed
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3d8e28bc2bab56447aab597955ca683b
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/CHANGELOG.md b/Assets/Modules/ShrinkDataSaver/CHANGELOG.md
new file mode 100644
index 0000000..2e77c71
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/CHANGELOG.md
@@ -0,0 +1,35 @@
+# Changelog
+
+本文件记录 `ShrinkDataSaver` 在当前工作区中的包内变更。
+
+## [2.2.0] - 2026-05-18
+
+### Added
+
+- 新增 `ShrinkDataSaverRuntime`，把真实初始化入口与 autosave 生命周期驱动下沉到运行时层。
+
+### Changed
+
+- `ShrinkDataSaverBootstrap` 现主要承担旧项目兼容入口职责；实际初始化改为委托给 `ShrinkDataSaverRuntime`。
+- 该调整为 `ShrinkApp` 等统一宿主接管初始化顺序铺路，同时保留旧项目直接挂 bootstrap 的使用方式。
+
+## [2.1.0] - 2026-05-15
+
+### Added
+
+- `ShrinkSave.GetRecentSlotIndex()` 与 `ShrinkSave.GetRecommendedContinueSlotAsync()`，用于把“最近游玩槽位 / 继续游戏”能力下沉到包内。
+- 包内测试补充了主文件损坏时的备份回退、最近槽位回退、以及本地存储双副本轮换验证。
+
+### Changed
+
+- `LocalStorageProvider` 升级为异步文件流读写，并在提交时使用主文件原子替换。
+- 本地存储新增 `.bak1` / `.bak2` 双副本轮换备份。
+- `ShrinkSave` 与 `ShrinkSettings` 在主文件损坏或缺失时，会自动从备份恢复并修复主文件。
+- `ShrinkSave.DeleteSlotAsync(...)` 现在会同时清理主文件、备份文件和临时文件，并在删除最近游玩槽位后自动回退记录。
+
+## [2.0.1] - 2026-04-07
+
+### Changed
+
+- 数据查看器编辑器入口迁移到 `ShrinkSDK/存档/数据查看器`。
+- README 同步更新新的菜单路径，统一到 `ShrinkSDK` 顶栏下。
diff --git a/Assets/Modules/ShrinkDataSaver/CHANGELOG.md.meta b/Assets/Modules/ShrinkDataSaver/CHANGELOG.md.meta
new file mode 100644
index 0000000..fc80cf2
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 78b8bd668657cd546a75bf4ae7cb3b8f
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Editor.meta b/Assets/Modules/ShrinkDataSaver/Editor.meta
new file mode 100644
index 0000000..d75e917
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Editor.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9e02de79ba4c4595bc36097d194fdf52
+timeCreated: 1773047471
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef
new file mode 100644
index 0000000..49bacf9
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef
@@ -0,0 +1,15 @@
+{
+  "name": "ShrinkDataSaver.Editor",
+  "rootNamespace": "ShrinkDataSaver.Editor",
+  "references": [
+    "ShrinkDataSaver.Runtime",
+    "UniTask"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": false
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef.meta b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef.meta
new file mode 100644
index 0000000..e590b96
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 78cf16cc0efe432a939df0e90a4cdb14
+timeCreated: 1773047512
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs
new file mode 100644
index 0000000..451f53c
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs
@@ -0,0 +1,378 @@
+#if UNITY_EDITOR
+using System;
+using System.IO;
+using System.Linq;
+using Cysharp.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace ShrinkDataSaver.Editor
+{
+    public class ShrinkDataSaverEditorWindow : EditorWindow
+    {
+        private int _selectedTab;
+        private readonly string[] _tabs = { "设置", "存档槽", "工具" };
+        private Vector2 _settingsScroll;
+        private Vector2 _slotsScroll;
+
+        private string _setKey = "";
+        private string _setValue = "";
+        private int _setType; // 0=string, 1=int, 2=float, 3=bool
+        private readonly string[] _typeNames = { "字符串", "整数", "浮点数", "布尔值" };
+
+        private int _saveSlot;
+        private string _slotName = "新存档";
+        private bool _encrypt;
+        private string _encryptKey = "";
+        private SaveMeta[] _metaCache;
+
+        [MenuItem("ShrinkSDK/存档/数据查看器")]
+        public static void ShowWindow()
+        {
+            var w = GetWindow<ShrinkDataSaverEditorWindow>("ShrinkDataSaver");
+            w.minSize = new Vector2(460, 500);
+        }
+
+        private void OnGUI()
+        {
+            DrawHeader();
+            _selectedTab = GUILayout.Toolbar(_selectedTab, _tabs, EditorStyles.toolbarButton);
+            EditorGUILayout.Space(4);
+
+            switch (_selectedTab)
+            {
+                case 0: DrawSettingsTab(); break;
+                case 1: DrawSaveSlotsTab(); break;
+                case 2: DrawToolsTab(); break;
+            }
+        }
+
+        private void OnInspectorUpdate() => Repaint();
+
+
+        private void DrawHeader()
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+            GUILayout.Label("ShrinkDataSaver", EditorStyles.boldLabel);
+            GUILayout.FlexibleSpace();
+
+            var color = GUI.color;
+            GUI.color = Application.isPlaying ? Color.green : Color.gray;
+            GUILayout.Label(Application.isPlaying ? "● 运行中" : "○ 未运行", EditorStyles.miniLabel);
+            GUI.color = color;
+            EditorGUILayout.EndHorizontal();
+        }
+
+
+        private void DrawSettingsTab()
+        {
+            if (!Application.isPlaying)
+            {
+                EditorGUILayout.HelpBox("设置查看器仅在运行模式下可用。", MessageType.Info);
+                DrawSettingsFilePath();
+                return;
+            }
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("重新加载", EditorStyles.miniButton))
+                ShrinkSettings.LoadAsync().Forget();
+            if (GUILayout.Button("立即保存", EditorStyles.miniButton))
+                ShrinkSettings.SaveAsync().Forget();
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Space(6);
+
+            var allSettings = ShrinkSettings.GetAllRaw();
+            EditorGUILayout.LabelField($"当前设置项（{allSettings.Count} 项）", EditorStyles.boldLabel);
+
+            if (allSettings.Count == 0)
+            {
+                EditorGUILayout.HelpBox("暂无设置项。", MessageType.None);
+            }
+            else
+            {
+                _settingsScroll = EditorGUILayout.BeginScrollView(_settingsScroll, GUILayout.MaxHeight(240));
+                string keyToRemove = null;
+
+                foreach (var kvp in allSettings.OrderBy(k => k.Key))
+                {
+                    EditorGUILayout.BeginHorizontal("box");
+                    EditorGUILayout.LabelField(kvp.Key, EditorStyles.boldLabel, GUILayout.Width(140));
+
+                    var valueStr = FormatJToken(kvp.Value);
+                    EditorGUILayout.LabelField(valueStr, EditorStyles.wordWrappedMiniLabel);
+
+                    var prevColor = GUI.backgroundColor;
+                    GUI.backgroundColor = new Color(1f, 0.6f, 0.6f);
+                    if (GUILayout.Button("删除", EditorStyles.miniButton, GUILayout.Width(40)))
+                        keyToRemove = kvp.Key;
+                    GUI.backgroundColor = prevColor;
+
+                    EditorGUILayout.EndHorizontal();
+                }
+
+                EditorGUILayout.EndScrollView();
+
+                if (keyToRemove != null)
+                    ShrinkSettings.Remove(keyToRemove);
+            }
+
+            EditorGUILayout.Space(8);
+
+            EditorGUILayout.LabelField("新增 / 修改", EditorStyles.boldLabel);
+            _setKey = EditorGUILayout.TextField("键", _setKey);
+            _setType = EditorGUILayout.Popup("类型", _setType, _typeNames);
+            _setValue = EditorGUILayout.TextField("值", _setValue);
+
+            EditorGUI.BeginDisabledGroup(string.IsNullOrWhiteSpace(_setKey));
+            if (GUILayout.Button("设置", EditorStyles.miniButton))
+                SetTypedValue(_setKey, _setValue, _setType);
+            EditorGUI.EndDisabledGroup();
+        }
+
+        private static void SetTypedValue(string key, string value, int type)
+        {
+            switch (type)
+            {
+                case 0: // string
+                    ShrinkSettings.Set(key, value);
+                    break;
+                case 1: // int
+                    if (int.TryParse(value, out var intVal))
+                        ShrinkSettings.Set(key, intVal);
+                    else
+                        Debug.LogWarning($"[ShrinkDataSaver] 无法将 \"{value}\" 解析为整数。");
+                    break;
+                case 2: // float
+                    if (float.TryParse(value, out var floatVal))
+                        ShrinkSettings.Set(key, floatVal);
+                    else
+                        Debug.LogWarning($"[ShrinkDataSaver] 无法将 \"{value}\" 解析为浮点数。");
+                    break;
+                case 3: // bool
+                    if (bool.TryParse(value, out var boolVal))
+                        ShrinkSettings.Set(key, boolVal);
+                    else
+                        ShrinkSettings.Set(key, value is "1" or "true" or "True");
+                    break;
+            }
+        }
+
+        private static string FormatJToken(JToken token)
+        {
+            if (token == null) return "null";
+            return token.Type switch
+            {
+                JTokenType.String => $"\"{token}\"",
+                JTokenType.Boolean => token.Value<bool>() ? "true" : "false",
+                JTokenType.Array or JTokenType.Object => token.ToString(Newtonsoft.Json.Formatting.None),
+                _ => token.ToString()
+            };
+        }
+
+        private void DrawSettingsFilePath()
+        {
+            var cfg = ShrinkDataSaverSettings.Instance;
+            var root = string.IsNullOrEmpty(cfg.customSavePath)
+                ? Application.persistentDataPath
+                : cfg.customSavePath;
+            EditorGUILayout.LabelField("设置文件路径：", Path.Combine(root, cfg.settingsFileName),
+                EditorStyles.wordWrappedMiniLabel);
+
+            if (GUILayout.Button("打开目录", EditorStyles.miniButton))
+                EditorUtility.RevealInFinder(root);
+        }
+
+
+        private void DrawSaveSlotsTab()
+        {
+            if (!Application.isPlaying)
+            {
+                EditorGUILayout.HelpBox("存档操作仅在运行模式下可用。", MessageType.Info);
+                DrawSavesFolderPath();
+                return;
+            }
+
+            EditorGUILayout.LabelField("快速操作", EditorStyles.boldLabel);
+
+            _saveSlot = EditorGUILayout.IntField("槽位索引", _saveSlot);
+            _slotName = EditorGUILayout.TextField("存档名称", _slotName);
+            _encrypt = EditorGUILayout.Toggle("加密", _encrypt);
+            if (_encrypt)
+                _encryptKey = EditorGUILayout.TextField("密钥", _encryptKey);
+
+            EditorGUILayout.BeginHorizontal();
+
+            if (GUILayout.Button("保存", EditorStyles.miniButton))
+            {
+                ShrinkSave.SaveSlotAsync(_saveSlot, new SaveOptions
+                {
+                    SlotName = _slotName,
+                    Encrypt = _encrypt,
+                    EncryptionKey = _encryptKey
+                }).Forget();
+                RefreshMetaDelayed().Forget();
+            }
+
+            if (GUILayout.Button("加载", EditorStyles.miniButton))
+            {
+                ShrinkSave.LoadSlotAsync(_saveSlot, _encrypt ? _encryptKey : null).Forget();
+            }
+
+            if (GUILayout.Button("删除", EditorStyles.miniButton))
+            {
+                if (EditorUtility.DisplayDialog("删除存档",
+                        $"确认删除槽位 {_saveSlot}？", "删除", "取消"))
+                {
+                    ShrinkSave.DeleteSlotAsync(_saveSlot).Forget();
+                    RefreshMetaDelayed().Forget();
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Space(8);
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("所有存档", EditorStyles.boldLabel);
+            if (GUILayout.Button("刷新", EditorStyles.miniButton, GUILayout.Width(50)))
+                RefreshMeta().Forget();
+            EditorGUILayout.EndHorizontal();
+
+            if (_metaCache == null)
+            {
+                EditorGUILayout.HelpBox("点击「刷新」加载存档列表。", MessageType.None);
+            }
+            else if (_metaCache.Length == 0)
+            {
+                EditorGUILayout.HelpBox("暂无存档。", MessageType.None);
+            }
+            else
+            {
+                DrawMetaList();
+            }
+        }
+
+        private async UniTask RefreshMeta()
+        {
+            _metaCache = await ShrinkSave.GetAllMetaAsync();
+            Repaint();
+        }
+
+        private async UniTaskVoid RefreshMetaDelayed()
+        {
+            await UniTask.Delay(300);
+            await RefreshMeta();
+        }
+
+        private void DrawMetaList()
+        {
+            _slotsScroll = EditorGUILayout.BeginScrollView(_slotsScroll, GUILayout.MaxHeight(360));
+
+            foreach (var meta in _metaCache)
+            {
+                EditorGUILayout.BeginVertical("box");
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField($"槽位 {meta.SlotIndex}  —  {meta.SlotName}", EditorStyles.boldLabel);
+                GUILayout.FlexibleSpace();
+
+                if (GUILayout.Button("加载", EditorStyles.miniButton, GUILayout.Width(40)))
+                {
+                    var key = meta.IsEncrypted ? _encryptKey : null;
+                    ShrinkSave.LoadSlotAsync(meta.SlotIndex, key).Forget();
+                }
+
+                var prevColor = GUI.backgroundColor;
+                GUI.backgroundColor = new Color(1f, 0.6f, 0.6f);
+                if (GUILayout.Button("删除", EditorStyles.miniButton, GUILayout.Width(40)))
+                {
+                    if (EditorUtility.DisplayDialog("删除存档",
+                            $"确认删除槽位 {meta.SlotIndex}（{meta.SlotName}）？", "删除", "取消"))
+                    {
+                        ShrinkSave.DeleteSlotAsync(meta.SlotIndex).Forget();
+                        RefreshMetaDelayed().Forget();
+                    }
+                }
+
+                GUI.backgroundColor = prevColor;
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.LabelField("最后修改", meta.LastModifiedTime.ToString("yyyy-MM-dd HH:mm:ss"));
+                EditorGUILayout.LabelField("游戏时长", TimeSpan.FromSeconds(meta.PlaytimeSeconds).ToString(@"hh\:mm\:ss"));
+                EditorGUILayout.LabelField("存档版本", meta.SaveVersion.ToString());
+                EditorGUILayout.LabelField("已加密", meta.IsEncrypted ? "是" : "否");
+                EditorGUILayout.LabelField("截图", meta.ScreenshotBase64 != null ? "有" : "无");
+
+                EditorGUILayout.EndVertical();
+                EditorGUILayout.Space(2);
+            }
+
+            EditorGUILayout.EndScrollView();
+        }
+
+        private void DrawSavesFolderPath()
+        {
+            var cfg = ShrinkDataSaverSettings.Instance;
+            var root = string.IsNullOrEmpty(cfg.customSavePath)
+                ? Application.persistentDataPath
+                : cfg.customSavePath;
+            var saves = Path.Combine(root, "saves");
+
+            EditorGUILayout.LabelField("存档目录：", saves, EditorStyles.wordWrappedMiniLabel);
+            if (GUILayout.Button("打开目录", EditorStyles.miniButton))
+                EditorUtility.RevealInFinder(saves);
+        }
+
+
+        private void DrawToolsTab()
+        {
+            EditorGUILayout.LabelField("实用工具", EditorStyles.boldLabel);
+
+            if (GUILayout.Button("打开持久化数据目录"))
+                EditorUtility.RevealInFinder(Application.persistentDataPath);
+
+            EditorGUILayout.Space(8);
+            EditorGUILayout.LabelField("配置资源", EditorStyles.boldLabel);
+            var settings = ShrinkDataSaverSettings.Instance;
+            if (settings)
+            {
+                EditorGUILayout.ObjectField("资源文件", settings, typeof(ShrinkDataSaverSettings), false);
+            }
+            else
+            {
+                EditorGUILayout.HelpBox(
+                    "未找到 ShrinkDataSaverSettings 资源文件。\n" +
+                    "请通过菜单 Assets → Create → ShrinkDataSaver → Settings 创建。",
+                    MessageType.Warning);
+            }
+
+            EditorGUILayout.Space(8);
+            EditorGUILayout.LabelField("危险操作", EditorStyles.boldLabel);
+
+            GUI.backgroundColor = new Color(1f, 0.4f, 0.4f);
+            if (GUILayout.Button("删除所有存档文件"))
+            {
+                var cfg = ShrinkDataSaverSettings.Instance;
+                var root = string.IsNullOrEmpty(cfg?.customSavePath)
+                    ? Application.persistentDataPath
+                    : cfg.customSavePath;
+                var saves = Path.Combine(root, "saves");
+
+                if (EditorUtility.DisplayDialog("删除所有存档",
+                        $"将删除以下目录中的所有内容：\n{saves}\n\n此操作不可撤销！",
+                        "全部删除", "取消"))
+                {
+                    if (Directory.Exists(saves))
+                        Directory.Delete(saves, true);
+                    _metaCache = null;
+                    Debug.Log("[ShrinkDataSaver] 所有存档文件已删除。");
+                }
+            }
+
+            GUI.backgroundColor = Color.white;
+        }
+    }
+}
+#endif
diff --git a/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs.meta b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs.meta
new file mode 100644
index 0000000..efc6ef2
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0c285b35e7094111b6ea986ea5af391e
+timeCreated: 1773047478
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/README.md b/Assets/Modules/ShrinkDataSaver/README.md
new file mode 100644
index 0000000..8cea6e6
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/README.md
@@ -0,0 +1,538 @@
+# ShrinkDataSaver
+
+一个为 Unity C# 项目设计的模块化存档与设置管理系统。支持多存档槽、链式版本迁移、可选 AES-256 加密、关键模块保护、跨模块只读查询，以及完整的事件驱动架构。
+
+## ✨ 特性概览
+
+| 特性 | 说明 |
+|------|------|
+| 💾 **模块化存档** | 按模块拆分存档数据，注册即用，读写隔离 |
+| 🔢 **多存档槽** | 槽位数量可配置，支持元数据轻量查询 |
+| 🔄 **链式版本迁移** | 注册迁移规则后自动链式执行，失败时整体回滚 |
+| 🔒 **可选加密** | AES-256-CBC + PBKDF2-SHA256，随机 Salt/IV，密钥由使用者管理 |
+| ⚡ **事件驱动** | 8 种原生事件，覆盖保存/加载/删除/迁移的完整生命周期 |
+| 🔍 **跨模块查询** | `QueryModule<T>` 只读查询其他模块的运行时数据 |
+| 🛡️ **关键模块保护** | `CriticalModule` 标记的模块序列化失败将中止整个保存操作 |
+| ⏱️ **自动保存** | 按模块配置的最小间隔自动触发保存 |
+| ⚙️ **Settings 系统** | 独立于存档的键值对设置，防抖写入，本地持久化 |
+| 🧷 **最近游玩槽位** | 自动记录最近一次成功进入的槽位，可用于“继续游戏” |
+| 🛠️ **双副本备份** | 主文件原子替换，自动保留 `.bak1` / `.bak2` 双副本轮换 |
+| ☁️ **云存档兼容** | 每槽单文件 `.sav`，模块级 `EnableCloudSync` 开关 |
+| 🔗 **EventBus 集成** | 可选接入 ShrinkEventBus，所有事件自动桥接到事件总线 |
+| 🖥️ **Editor 工具** | 中文可视化调试窗口，实时查看/操作设置与存档 |
+
+## 📦 依赖
+
+- Unity 2022.3+
+- [UniTask](https://github.com/Cysharp/UniTask) `2.x`
+- [Newtonsoft.Json](https://docs.unity3d.com/Packages/com.unity.nuget.newtonsoft-json@3.2/manual/index.html)（`com.unity.nuget.newtonsoft-json`）
+
+## ⚙️ 安装
+
+在项目的 `Packages/manifest.json` 中添加：
+
+```json
+{
+  "dependencies": {
+    "com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask",
+    "com.cneicy.shrink-datasaver": "https://github.com/cneicy/ShrinkDataSaver.git"
+  }
+}
+```
+
+或通过 Package Manager → `+` → `Add package from git URL` 输入：
+
+```
+https://github.com/cneicy/ShrinkDataSaver.git
+```
+
+## 🚀 快速上手
+
+### 第一步：创建配置资产
+
+菜单 `Assets` → `Create` → `ShrinkDataSaver` → `Settings`。
+
+配置文件可放置在项目**任意目录**下，编辑器会通过 `AssetDatabase` 自动搜索。也可放在 `Resources/` 下供运行时加载，或在 Bootstrap 组件上手动指定。
+
+> ⚠️ 未找到配置文件时，控制台会输出警告并使用默认配置。
+
+### 第二步：放置 Bootstrap
+
+在首场景中创建 GameObject，挂载 `ShrinkDataSaverBootstrap` 组件：
+
+- **Settings Override**：可选，手动拖入配置资产（留空则自动查找）
+- **Current Save Version**：当前存档版本号（从 `1` 开始）
+
+Bootstrap 会自动 `DontDestroyOnLoad`，并在应用退出 / 移动端切后台时自动写入 Settings。
+
+从当前版本开始，真正的初始化逻辑已下沉到 `ShrinkDataSaverRuntime`。这意味着：
+
+- 旧项目继续挂 `ShrinkDataSaverBootstrap` 也能正常工作
+- 如果项目接入了 `ShrinkApp`，则可由宿主统一调用 `ShrinkDataSaverRuntime.Initialize(...)`
+- 宿主已接管时，旧 bootstrap 会自动幂等退出，不重复初始化
+
+### 第三步：注册存档模块
+
+```csharp
+// 方式 A：Lambda（轻量）
+ShrinkSave.RegisterModule(
+    key: "inventory",
+    serialize:   () => inventoryManager.GetData(),
+    deserialize: data => inventoryManager.LoadData(data)
+);
+
+// 方式 B：Lambda + 模块配置
+ShrinkSave.RegisterModule(
+    key: "quests",
+    serialize:   () => questSystem.GetData(),
+    deserialize: data => questSystem.LoadData(data),
+    config: new ModuleConfig
+    {
+        EnableCloudSync = true,
+        AutoSaveIntervalSeconds = 60f,   // 每 60 秒自动保存
+        CriticalModule = true            // 序列化失败将中止保存
+    }
+);
+
+// 方式 C：接口（结构化）
+public class InventoryModule : ISaveModule<InventoryData>
+{
+    public string Key => "inventory";
+    public InventoryData Serialize() => inventoryManager.GetData();
+    public void Deserialize(InventoryData data) => inventoryManager.LoadData(data);
+}
+ShrinkSave.RegisterModule(new InventoryModule());
+```
+
+### 第四步：保存与加载
+
+```csharp
+// 保存
+await ShrinkSave.SaveSlotAsync(0, new SaveOptions
+{
+    SlotName = "第一周目",
+    CaptureScreenshot = true
+});
+
+// 加载
+await ShrinkSave.LoadSlotAsync(0);
+
+// 删除
+await ShrinkSave.DeleteSlotAsync(0);
+```
+
+---
+
+## 📖 核心概念
+
+### 事件系统
+
+系统在关键操作时触发原生 C# 事件，所有事件携带完整载荷数据：
+
+| 事件 | 触发时机 | 载荷 |
+|------|----------|------|
+| `OnSaveStarted` | 开始保存前 | SlotIndex, Timestamp |
+| `OnSaveCompleted` | 保存成功后 | SlotIndex, ModuleNames[], Timestamp |
+| `OnSaveFailed` | 保存失败时 | SlotIndex, ErrorMessage |
+| `OnLoadStarted` | 开始加载前 | SlotIndex, Timestamp |
+| `OnLoadCompleted` | 加载成功后 | SlotIndex, ModuleNames[], Version, Timestamp |
+| `OnLoadFailed` | 加载失败时 | SlotIndex, ErrorMessage |
+| `OnMigrationCompleted` | 版本迁移完成后 | SlotIndex, FromVersion, ToVersion |
+| `OnDeleteCompleted` | 删除存档后 | SlotIndex |
+
+```csharp
+ShrinkSave.OnSaveCompleted += args =>
+    Debug.Log($"槽位 {args.SlotIndex} 保存成功，模块: {string.Join(", ", args.ModuleNames)}");
+
+ShrinkSave.OnLoadFailed += args =>
+    ShowErrorDialog($"加载失败: {args.ErrorMessage}");
+
+ShrinkSave.OnMigrationCompleted += args =>
+    Debug.Log($"存档从 v{args.FromVersion} 迁移到 v{args.ToVersion}");
+```
+
+### 模块配置
+
+注册模块时可传入 `ModuleConfig` 控制行为：
+
+```csharp
+var config = new ModuleConfig
+{
+    EnableCloudSync = false,          // 不参与云存档（如本地设置）
+    AutoSaveIntervalSeconds = 30f,    // 自动保存间隔（0 = 禁用）
+    CriticalModule = true             // 序列化失败中止整个保存
+};
+ShrinkSave.RegisterModule("settings", () => data, d => data = d, config);
+```
+
+- **EnableCloudSync**：标记该模块是否参与云同步（供业务层查询）
+- **AutoSaveIntervalSeconds**：Bootstrap 会取所有模块中最小的非零间隔，定时自动保存到当前已加载的槽位
+- **CriticalModule**：标记为关键模块后，序列化异常会触发 `OnSaveFailed` 并中止保存；非关键模块异常仅跳过该模块
+
+### 跨模块只读查询
+
+模块间需要共享数据时，通过存档管理器提供的只读接口查询，避免直接耦合：
+
+```csharp
+// 查询其他模块的当前运行时数据（序列化快照）
+var playerStats = ShrinkSave.QueryModule<PlayerStatsData>("playerStats");
+if (playerStats != null)
+    Debug.Log($"玩家等级: {playerStats.Level}");
+
+// 检查已加载存档中某模块是否包含特定键
+bool hasCoins = ShrinkSave.HasKey("inventory", "coins");
+
+// 检查模块是否已注册
+bool registered = ShrinkSave.HasModule("quests");
+```
+
+### 最近游玩槽位
+
+包内会在 `LoadSlotAsync(...)` 成功后自动记录最近一次成功进入的槽位，并在删除该槽位时自动回退到其他有效槽位：
+
+```csharp
+int recentSlot = ShrinkSave.GetRecentSlotIndex();
+
+int continueSlot = await ShrinkSave.GetRecommendedContinueSlotAsync();
+if (continueSlot >= 0)
+{
+    await ShrinkSave.LoadSlotAsync(continueSlot);
+}
+```
+
+### 版本迁移
+
+每次存档结构变化时，注册迁移规则。**必须在 `LoadSlotAsync` 调用之前注册。**
+
+```csharp
+// 注册迁移（在游戏初始化时）
+MigrationChain.Register(fromVersion: 1, toVersion: 2, data =>
+{
+    // data 是整个存档的 JObject，包含所有模块
+    if (data["inventory"] is JObject inv)
+    {
+        inv["gold"] = inv["coins"];
+        inv.Remove("coins");
+    }
+    return data;
+});
+
+MigrationChain.Register(fromVersion: 2, toVersion: 3, data =>
+{
+    if (data["quests"] is JObject q)
+        q["dailyQuestReset"] = 0;
+    return data;
+});
+
+// 同步更新 Bootstrap 上的 Current Save Version = 3
+ShrinkSave.SetCurrentSaveVersion(3);
+```
+
+加载时自动检测版本差异，链式执行所有中间迁移（v1 → v2 → v3）。**迁移失败时自动回滚到迁移前的数据，不会丢失原始存档。**
+
+### Settings 系统
+
+独立于存档的键值对设置，本地持久化，不参与云存档：
+
+```csharp
+// 读写
+ShrinkSettings.Set("MasterVolume", 0.8f);
+ShrinkSettings.Set("Language", "zh-CN");
+float volume = ShrinkSettings.Get("MasterVolume", defaultValue: 1f);
+bool exists  = ShrinkSettings.Has("MasterVolume");
+ShrinkSettings.Remove("MasterVolume");
+
+// 查看所有设置
+var all = ShrinkSettings.GetAllRaw(); // IReadOnlyDictionary<string, JToken>
+
+// 监听变更
+ShrinkSettings.OnChanged += (key, value) => Debug.Log($"{key} = {value}");
+ShrinkSettings.Watch<float>("MasterVolume", vol => ApplyVolume(vol));
+```
+
+变更时立刻触发回调，写入磁盘有防抖延迟（默认 300ms），防止高频调用产生大量 IO。
+
+### 加密
+
+可选加密，默认关闭。使用 AES-256-CBC + PBKDF2-SHA256（10000 次迭代），每次加密随机生成 Salt 和 IV：
+
+```csharp
+// 加密保存
+await ShrinkSave.SaveSlotAsync(0, new SaveOptions
+{
+    Encrypt = true,
+    EncryptionKey = "your-secret-key"
+});
+
+// 解密加载（需传入相同密钥）
+await ShrinkSave.LoadSlotAsync(0, decryptionKey: "your-secret-key");
+
+// 通过元数据判断是否加密
+var meta = await ShrinkSave.GetMetaAsync(0);
+if (meta.IsEncrypted)
+    ShowPasswordPrompt();
+```
+
+---
+
+## 🔗 ShrinkEventBus 集成
+
+> 详细文档见 [ShrinkDataSaver.Integration.EventBus](https://github.com/cneicy/ShrinkDataSaver.Integration.EventBus)
+
+项目中同时包含 `ShrinkDataSaver.Integration.EventBus` 时，桥接器会在游戏启动时自动初始化，将所有原生事件映射到 EventBus：
+
+```csharp
+[EventBusSubscriber]
+public class SaveUIManager : MonoBehaviour
+{
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnSaveCompleted(SaveCompletedEvent e)
+    {
+        ShowSaveIndicator(e.SlotIndex, e.ModuleNames);
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnLoadFailed(LoadFailedEvent e)
+    {
+        ShowErrorDialog(e.ErrorMessage);
+    }
+
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnSettingsChanged(SettingsChangedEvent e)
+    {
+        if (e.Key == "MasterVolume")
+            ApplyVolume(e.Get<float>());
+    }
+}
+```
+
+**EventBus 事件类型完整列表：**
+
+`SettingsChangedEvent` · `SaveStartedEvent` · `SaveCompletedEvent` · `SaveFailedEvent` · `LoadStartedEvent` · `LoadCompletedEvent` · `LoadFailedEvent` · `MigrationCompletedEvent` · `SlotDeletedEvent`
+
+---
+
+## 🖥️ Editor 调试工具
+
+菜单 `ShrinkSDK` → `存档` → `数据查看器`
+
+| 标签页 | 功能 |
+|--------|------|
+| **设置** | 运行时查看所有设置项（键、值、类型），支持新增/修改/删除，一键保存/加载 |
+| **存档槽** | 查看所有槽位元数据，每个槽位可直接加载/删除，支持加密参数 |
+| **工具** | 打开持久化数据目录，定位配置资源文件，一键删除所有存档 |
+
+---
+
+## ☁️ Steam Auto-Cloud 配置
+
+每个逻辑存档槽默认包含一个主文件和最多两个轮换备份文件：`.sav`、`.sav.bak1`、`.sav.bak2`。
+
+在 Steamworks 后台（App Admin → Steam Cloud）配置同步路径：
+
+| 字段 | 值 |
+|------|-----|
+| Root Path | `{userdata}` |
+| Subdirectory | 指向 `persistentDataPath` 的相对路径 |
+| File Pattern | `saves/*.sav*` |
+
+通过 `ModuleConfig.EnableCloudSync = false` 可将特定模块（如本地设置）排除在云同步之外，供业务层在合并逻辑中过滤。
+
+---
+
+## 🔧 API 参考
+
+### ShrinkSave（静态门面）
+
+#### 模块注册
+
+```csharp
+ShrinkSave.RegisterModule(ISaveModule module, ModuleConfig config = null)
+ShrinkSave.RegisterModule<T>(string key, Func<T> serialize, Action<T> deserialize, ModuleConfig config = null)
+ShrinkSave.UnregisterModule(string key)
+ShrinkSave.HasModule(string moduleName)                         → bool
+ShrinkSave.GetModuleConfig(string key)                          → ModuleConfig
+ShrinkSave.GetRegisteredModuleNames()                           → IReadOnlyCollection<string>
+```
+
+#### 存档操作
+
+```csharp
+ShrinkSave.SaveSlotAsync(int slotIndex, SaveOptions, CancellationToken)   → UniTask
+ShrinkSave.LoadSlotAsync(int slotIndex, string decryptionKey, ct)         → UniTask
+ShrinkSave.DeleteSlotAsync(int slotIndex, CancellationToken)              → UniTask
+ShrinkSave.SlotExistsAsync(int slotIndex, CancellationToken)              → UniTask<bool>
+ShrinkSave.LoadedSlot                                                     → int (-1 = 未加载)
+```
+
+#### 元数据查询
+
+```csharp
+ShrinkSave.GetAllMetaAsync(CancellationToken)       → UniTask<SaveMeta[]>
+ShrinkSave.GetMetaAsync(int slotIndex, ct)           → UniTask<SaveMeta>
+ShrinkSave.GetRecentSlotIndex()                      → int
+ShrinkSave.GetRecommendedContinueSlotAsync(ct)       → UniTask<int>
+```
+
+#### 跨模块查询
+
+```csharp
+ShrinkSave.QueryModule<T>(string moduleName)         → T
+ShrinkSave.HasKey(string moduleName, string key)      → bool
+```
+
+#### 版本
+
+```csharp
+ShrinkSave.SetCurrentSaveVersion(int version)
+ShrinkSave.GetMinAutoSaveInterval()                   → float
+MigrationChain.Register(int from, int to, Func<JObject, JObject>)
+```
+
+#### 事件
+
+```csharp
+ShrinkSave.OnSaveStarted         += Action<SaveStartedEventArgs>
+ShrinkSave.OnSaveCompleted       += Action<SaveCompletedEventArgs>
+ShrinkSave.OnSaveFailed          += Action<SaveFailedEventArgs>
+ShrinkSave.OnLoadStarted         += Action<LoadStartedEventArgs>
+ShrinkSave.OnLoadCompleted       += Action<LoadCompletedEventArgs>
+ShrinkSave.OnLoadFailed          += Action<LoadFailedEventArgs>
+ShrinkSave.OnMigrationCompleted  += Action<MigrationCompletedEventArgs>
+ShrinkSave.OnDeleteCompleted     += Action<SlotDeletedEventArgs>
+```
+
+### ShrinkSettings（静态门面）
+
+```csharp
+ShrinkSettings.Set<T>(string key, T value)
+ShrinkSettings.Get<T>(string key, T defaultValue = default)    → T
+ShrinkSettings.Has(string key)                                 → bool
+ShrinkSettings.Remove(string key)
+ShrinkSettings.GetAllRaw()                                     → IReadOnlyDictionary<string, JToken>
+ShrinkSettings.Watch<T>(string key, Action<T> callback)
+ShrinkSettings.Unwatch(string key, Action<object> callback)
+ShrinkSettings.SaveAsync(CancellationToken)                    → UniTask
+ShrinkSettings.LoadAsync(CancellationToken)                    → UniTask
+ShrinkSettings.OnChanged                                       += Action<string, object>
+```
+
+---
+
+## 🏗️ 架构说明
+
+```
+ShrinkDataSaver/
+├── Runtime/
+│   ├── ShrinkSave                  存档系统静态门面（保存/加载/删除/事件/查询）
+│   ├── ShrinkSettings              设置系统静态门面（键值对/防抖写入/监听）
+│   ├── ShrinkDataSaverBootstrap    兼容旧入口的初始化组件
+│   ├── ShrinkDataSaverRuntime      可重入运行时初始化入口 + 生命周期驱动
+│   ├── ShrinkDataSaverSettings     ScriptableObject 全局配置（支持任意目录）
+│   ├── SaveTypes                   核心类型（SaveMeta/ISaveModule/ModuleConfig/EventArgs）
+│   ├── MigrationChain              版本迁移链（注册/链式执行/回滚）
+│   ├── DataSerializer              JSON 序列化（Newtonsoft.Json）
+│   ├── SaveEncryptor               AES-256-CBC 加密/解密
+│   ├── IStorageProvider            存储后端接口
+│   └── LocalStorageProvider        本地文件系统实现（异步读写 + 原子替换 + 双副本轮换）
+│
+├── Editor/
+│   └── ShrinkDataSaverEditorWindow 中文可视化调试窗口
+│
+└── Tests/
+    ├── MockStorageProvider          内存模拟存储
+    └── *Tests.cs                    NUnit 单元测试（69 个用例）
+
+ShrinkDataSaver.Integration.EventBus/     （可选）
+├── DataSaverEvents                 9 个 EventBus 事件类
+└── DataSaverEventBusBridge         自动桥接（RuntimeInitializeOnLoadMethod）
+```
+
+**保存流程：**
+
+```
+SaveSlotAsync(slotIndex, options)
+  ├─ ValidateSlotIndex
+  ├─ OnSaveStarted ← 事件
+  ├─ 序列化所有模块
+  │   ├─ CriticalModule 失败 → OnSaveFailed ← 事件，中止
+  │   └─ 普通模块失败 → LogError，跳过继续
+  ├─ 加密（可选）
+  ├─ 写入存储
+  └─ OnSaveCompleted ← 事件（含 ModuleNames[]）
+```
+
+**加载流程：**
+
+```
+LoadSlotAsync(slotIndex, decryptionKey)
+  ├─ OnLoadStarted ← 事件
+  ├─ 读取存储 → 解密（可选）
+  ├─ 版本迁移（如需）
+  │   ├─ DeepClone 备份
+  │   ├─ 链式执行迁移
+  │   ├─ 失败 → 回滚到备份
+  │   └─ OnMigrationCompleted ← 事件
+  ├─ 反序列化到各模块
+  ├─ 缓存模块数据（供 QueryModule/HasKey）
+  └─ OnLoadCompleted ← 事件（含 ModuleNames[], Version）
+```
+
+---
+
+## ✅ 最佳实践
+
+**设置模块标记 `EnableCloudSync = false`**
+
+```csharp
+// ✅ 本地设置不上传云端，避免跨设备覆盖
+ShrinkSave.RegisterModule("settings", () => localPrefs, d => localPrefs = d,
+    new ModuleConfig { EnableCloudSync = false });
+```
+
+**关键模块标记 `CriticalModule = true`**
+
+```csharp
+// ✅ 玩家核心数据序列化失败时中止保存，防止存档损坏
+ShrinkSave.RegisterModule("playerStats", () => stats, d => stats = d,
+    new ModuleConfig { CriticalModule = true });
+```
+
+**迁移注册必须在加载之前**
+
+```csharp
+// ✅ 游戏启动时立即注册所有迁移
+MigrationChain.Register(1, 2, MigrateV1ToV2);
+MigrationChain.Register(2, 3, MigrateV2ToV3);
+ShrinkSave.SetCurrentSaveVersion(3);
+// 之后才能调用 LoadSlotAsync
+```
+
+**加密存档先查询元数据**
+
+```csharp
+// ✅ 通过 Meta 判断是否需要密钥，避免盲目加载
+var meta = await ShrinkSave.GetMetaAsync(slotIndex);
+string key = meta?.IsEncrypted == true ? AskPlayerForPassword() : null;
+await ShrinkSave.LoadSlotAsync(slotIndex, key);
+```
+
+---
+
+## ⚠️ 注意事项
+
+- **模块注册顺序无关**：`SaveSlotAsync` 序列化所有已注册模块，`LoadSlotAsync` 分发到对应模块，缺失的模块会跳过但不会导致加载失败。
+- **宿主接管兼容**：如果项目接入了 `ShrinkApp`，推荐通过 `ShrinkDataSaver.Integration.App` 让宿主统一初始化，而不是继续依赖场景 bootstrap。
+- **写入原子性**：`LocalStorageProvider` 先异步写入 `.tmp` 临时文件，再通过原子替换提交主文件，并自动轮换 `.bak1` / `.bak2` 两份备份。
+- **读取恢复**：`ShrinkSave` 与 `ShrinkSettings` 读取主文件失败时，会自动回退到 `.bak1`、`.bak2`，并在成功后修复主文件。
+- **Settings 防抖**：`Set()` 调用后不立刻写磁盘，在 300ms（可配置）内连续调用只触发一次写入。退出时强制跳过防抖直接写入。
+- **加密密钥管理**：框架不存储密钥。密钥丢失则对应存档无法解密，建议在 UI 层给玩家明确提示。
+- **截图与 Steam Cloud**：截图压缩为 JPG 并限制最大宽度（默认 256px），仍需注意模块数据体积。Steam Cloud 默认单文件限制 1MB。
+- **配置文件查找顺序**：`Resources.Load` → 编辑器 `AssetDatabase` 全局搜索 → 创建默认实例并输出控制台警告。
+- **自动保存**：仅在有槽位已加载（`LoadedSlot >= 0`）且存在 `AutoSaveIntervalSeconds > 0` 的模块时生效。
+
+---
+
+## 📄 License
+
+[MIT](LICENSE)
diff --git a/Assets/Modules/ShrinkDataSaver/README.md.meta b/Assets/Modules/ShrinkDataSaver/README.md.meta
new file mode 100644
index 0000000..fb1bd4e
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/README.md.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a0a2b66f2bb84ff1bfe75303700753dd
+timeCreated: 1773048087
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime.meta b/Assets/Modules/ShrinkDataSaver/Runtime.meta
new file mode 100644
index 0000000..a6cb741
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4927a1e86fef478f9ab5e203485c50ce
+timeCreated: 1773046045
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs b/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs
new file mode 100644
index 0000000..035b952
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("ShrinkDataSaver.Tests")]
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs.meta
new file mode 100644
index 0000000..4935ef5
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/AssemblyInfo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e21adcea9de62441b55c09908f22530
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs b/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs
new file mode 100644
index 0000000..f5d124b
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs
@@ -0,0 +1,28 @@
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace ShrinkDataSaver
+{
+    public static class DataSerializer
+    {
+        private static readonly JsonSerializerSettings Settings = new()
+        {
+            NullValueHandling    = NullValueHandling.Ignore,
+            DefaultValueHandling = DefaultValueHandling.Include,
+            Formatting           = Formatting.None
+        };
+
+        public static byte[] Serialize<T>(T obj)
+            => Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj, Settings));
+
+        public static T Deserialize<T>(byte[] data)
+            => JsonConvert.DeserializeObject<T>(Encoding.UTF8.GetString(data), Settings);
+
+        public static JObject ToJObject(byte[] data)
+            => JObject.Parse(Encoding.UTF8.GetString(data));
+
+        public static byte[] FromJObject(JObject obj)
+            => Encoding.UTF8.GetBytes(obj.ToString(Formatting.None));
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs.meta
new file mode 100644
index 0000000..7d9a8e5
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 19531b42fff04fd9b2fde3cfb450881e
+timeCreated: 1773046107
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs b/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs
new file mode 100644
index 0000000..8a03f16
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs
@@ -0,0 +1,14 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkDataSaver
+{
+    public interface IStorageProvider
+    {
+        UniTask WriteAsync(string path, byte[] data, CancellationToken ct = default);
+        UniTask<byte[]> ReadAsync(string path, CancellationToken ct = default);
+        UniTask<bool> ExistsAsync(string path, CancellationToken ct = default);
+        UniTask DeleteAsync(string path, CancellationToken ct = default);
+        UniTask<string[]> ListAsync(string prefix = "", CancellationToken ct = default);
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs.meta
new file mode 100644
index 0000000..04db3d8
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0ea76ef6ec0a455aabd1fe2346be4ddf
+timeCreated: 1773046056
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs b/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs
new file mode 100644
index 0000000..c1d9c67
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    public class LocalStorageProvider : IStorageProvider
+    {
+        private const string BackupPrimarySuffix = ".bak1";
+        private const string BackupSecondarySuffix = ".bak2";
+        private const string TempWriteSuffix = ".tmp";
+
+        private static readonly ConcurrentDictionary<string, SemaphoreSlim> PathLocks =
+            new(StringComparer.OrdinalIgnoreCase);
+
+        private readonly string _rootPath;
+
+        public LocalStorageProvider(string rootPath = null)
+        {
+            _rootPath = rootPath ?? Application.persistentDataPath;
+        }
+
+        private string Resolve(string path) =>
+            Path.IsPathRooted(path) ? path : Path.Combine(_rootPath, path);
+
+        public async UniTask WriteAsync(string path, byte[] data, CancellationToken ct = default)
+        {
+            var fullPath = Resolve(path);
+            var dir = Path.GetDirectoryName(fullPath);
+            if (!string.IsNullOrEmpty(dir))
+            {
+                await UniTask.RunOnThreadPool(() => Directory.CreateDirectory(dir), cancellationToken: ct);
+            }
+
+            var tempPath = fullPath + TempWriteSuffix;
+            var backupPath = fullPath + BackupPrimarySuffix;
+            var secondaryBackupPath = fullPath + BackupSecondarySuffix;
+            var pathLock = GetPathLock(fullPath);
+
+            await pathLock.WaitAsync(ct);
+            try
+            {
+                await WriteFileBytesAsync(tempPath, data, ct);
+                await UniTask.RunOnThreadPool(() =>
+                {
+                    if (File.Exists(fullPath))
+                    {
+                        if (File.Exists(secondaryBackupPath))
+                        {
+                            File.Delete(secondaryBackupPath);
+                        }
+
+                        if (File.Exists(backupPath))
+                        {
+                            File.Move(backupPath, secondaryBackupPath);
+                        }
+
+                        File.Replace(tempPath, fullPath, backupPath, true);
+                    }
+                    else
+                    {
+                        File.Move(tempPath, fullPath);
+                    }
+                }, cancellationToken: ct);
+            }
+            catch
+            {
+                await UniTask.RunOnThreadPool(() =>
+                {
+                    if (File.Exists(tempPath))
+                    {
+                        File.Delete(tempPath);
+                    }
+                }, cancellationToken: CancellationToken.None);
+                throw;
+            }
+            finally
+            {
+                pathLock.Release();
+            }
+        }
+
+        public async UniTask<byte[]> ReadAsync(string path, CancellationToken ct = default)
+        {
+            var fullPath = Resolve(path);
+            var pathLock = GetPathLock(fullPath);
+            await pathLock.WaitAsync(ct);
+            try
+            {
+                if (!File.Exists(fullPath))
+                {
+                    throw new FileNotFoundException($"ShrinkDataSaver: file not found: {fullPath}");
+                }
+
+                return await ReadFileBytesAsync(fullPath, ct);
+            }
+            finally
+            {
+                pathLock.Release();
+            }
+        }
+
+        public UniTask<bool> ExistsAsync(string path, CancellationToken ct = default) =>
+            UniTask.RunOnThreadPool(() => File.Exists(Resolve(path)), cancellationToken: ct);
+
+        public async UniTask DeleteAsync(string path, CancellationToken ct = default)
+        {
+            var fullPath = Resolve(path);
+            var pathLock = GetPathLock(fullPath);
+            await pathLock.WaitAsync(ct);
+            try
+            {
+                await UniTask.RunOnThreadPool(() =>
+                {
+                    if (File.Exists(fullPath))
+                    {
+                        File.Delete(fullPath);
+                    }
+                }, cancellationToken: ct);
+            }
+            finally
+            {
+                pathLock.Release();
+            }
+        }
+
+        public async UniTask<string[]> ListAsync(string prefix = "", CancellationToken ct = default)
+        {
+            return await UniTask.RunOnThreadPool(() =>
+            {
+                var dir = string.IsNullOrEmpty(prefix) ? _rootPath : Path.Combine(_rootPath, prefix);
+                if (!Directory.Exists(dir))
+                {
+                    return Array.Empty<string>();
+                }
+
+                return Directory.GetFiles(dir)
+                    .Select(f => Path.GetRelativePath(_rootPath, f))
+                    .ToArray();
+            }, cancellationToken: ct);
+        }
+
+        private static SemaphoreSlim GetPathLock(string fullPath)
+        {
+            return PathLocks.GetOrAdd(fullPath, _ => new SemaphoreSlim(1, 1));
+        }
+
+        private static async UniTask WriteFileBytesAsync(string fullPath, byte[] data, CancellationToken ct)
+        {
+            await using var stream = new FileStream(
+                fullPath,
+                FileMode.Create,
+                FileAccess.Write,
+                FileShare.None,
+                4096,
+                FileOptions.Asynchronous);
+            await stream.WriteAsync(data, 0, data.Length, ct);
+            stream.Flush(true);
+        }
+
+        private static async UniTask<byte[]> ReadFileBytesAsync(string fullPath, CancellationToken ct)
+        {
+            await using var stream = new FileStream(
+                fullPath,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.Read,
+                4096,
+                FileOptions.Asynchronous | FileOptions.SequentialScan);
+
+            var length = stream.Length;
+            if (length > int.MaxValue)
+            {
+                throw new IOException($"ShrinkDataSaver: file too large to read into memory: {fullPath}");
+            }
+
+            var buffer = new byte[length];
+            var offset = 0;
+            while (offset < buffer.Length)
+            {
+                var read = await stream.ReadAsync(buffer, offset, buffer.Length - offset, ct);
+                if (read <= 0)
+                {
+                    throw new EndOfStreamException($"ShrinkDataSaver: unexpected EOF while reading {fullPath}");
+                }
+
+                offset += read;
+            }
+
+            return buffer;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs.meta
new file mode 100644
index 0000000..e2f0bc8
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: dde6d5dd1c3f47db9453a3d0122d39d4
+timeCreated: 1773046075
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs b/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs
new file mode 100644
index 0000000..dbc0ecb
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    public static class MigrationChain
+    {
+        private static readonly SortedDictionary<int, Migration> Migrations = new();
+
+        private struct Migration
+        {
+            public int ToVersion;
+            public Func<JObject, JObject> Migrate;
+        }
+
+        public static void Register(int fromVersion, int toVersion, Func<JObject, JObject> migrate)
+        {
+            if (fromVersion >= toVersion)
+                throw new ArgumentException(
+                    $"[ShrinkDataSaver] fromVersion({fromVersion}) 必须小于 toVersion({toVersion})");
+
+            Migrations[fromVersion] = new Migration { ToVersion = toVersion, Migrate = migrate };
+        }
+
+        internal static (JObject data, int finalVersion) Apply(JObject data, int currentVersion, int targetVersion)
+        {
+            var version = currentVersion;
+            var backup = (JObject)data.DeepClone();
+
+            while (version < targetVersion)
+            {
+                if (!Migrations.TryGetValue(version, out var migration))
+                {
+                    Debug.LogWarning($"[ShrinkDataSaver] 未找到 v{version} → v{version + 1} 的迁移逻辑，数据可能不完整。");
+                    break;
+                }
+
+                try
+                {
+                    var fromV = version;
+                    data = migration.Migrate(data) ?? data;
+                    version = migration.ToVersion;
+                    Debug.Log($"[ShrinkDataSaver] 存档已迁移 v{fromV} → v{version}");
+                }
+                catch (Exception e)
+                {
+                    Debug.LogError(
+                        $"[ShrinkDataSaver] 迁移 v{version} → v{migration.ToVersion} 失败: {e.Message}，已回滚至 v{currentVersion}");
+                    return (backup, currentVersion);
+                }
+            }
+
+            return (data, version);
+        }
+
+        internal static void Clear() => Migrations.Clear();
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs.meta
new file mode 100644
index 0000000..9fd1852
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 56cc513596cc4b30b82412e080e8b716
+timeCreated: 1773047408
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs b/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs
new file mode 100644
index 0000000..164215a
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs
@@ -0,0 +1,86 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace ShrinkDataSaver
+{
+    public static class SaveEncryptor
+    {
+        private const int KeySize = 256;
+        private const int BlockSize = 128;
+        private const int IvBytes = 16;
+        private const int SaltBytes = 16;
+        private const int Iterations = 10000;
+
+        public static byte[] Encrypt(byte[] data, string password)
+        {
+            if (data == null) throw new ArgumentNullException(nameof(data));
+            if (string.IsNullOrEmpty(password)) throw new ArgumentException("Password must not be empty.");
+
+            var salt = GenerateRandom(SaltBytes);
+            var iv = GenerateRandom(IvBytes);
+            var key = DeriveKey(password, salt);
+
+            using var aes = CreateAes(key, iv);
+            using var encryptor = aes.CreateEncryptor();
+            var cipher = encryptor.TransformFinalBlock(data, 0, data.Length);
+
+            var result = new byte[SaltBytes + IvBytes + cipher.Length];
+            Buffer.BlockCopy(salt, 0, result, 0, SaltBytes);
+            Buffer.BlockCopy(iv, 0, result, SaltBytes, IvBytes);
+            Buffer.BlockCopy(cipher, 0, result, SaltBytes + IvBytes, cipher.Length);
+            return result;
+        }
+
+        public static byte[] Decrypt(byte[] data, string password)
+        {
+            if (data == null) throw new ArgumentNullException(nameof(data));
+            if (string.IsNullOrEmpty(password)) throw new ArgumentException("Password must not be empty.");
+            if (data.Length < SaltBytes + IvBytes)
+                throw new ArgumentException("Data is too short to be valid encrypted content.");
+
+            var salt = new byte[SaltBytes];
+            var iv = new byte[IvBytes];
+            var cipher = new byte[data.Length - SaltBytes - IvBytes];
+
+            Buffer.BlockCopy(data, 0, salt, 0, SaltBytes);
+            Buffer.BlockCopy(data, SaltBytes, iv, 0, IvBytes);
+            Buffer.BlockCopy(data, SaltBytes + IvBytes, cipher, 0, cipher.Length);
+
+            var key = DeriveKey(password, salt);
+
+            using var aes = CreateAes(key, iv);
+            using var decryptor = aes.CreateDecryptor();
+            return decryptor.TransformFinalBlock(cipher, 0, cipher.Length);
+        }
+
+
+        private static byte[] DeriveKey(string password, byte[] salt)
+        {
+            using var deriveBytes = new Rfc2898DeriveBytes(
+                Encoding.UTF8.GetBytes(password), salt, Iterations, HashAlgorithmName.SHA256);
+            return deriveBytes.GetBytes(KeySize / 8);
+        }
+
+        private static Aes CreateAes(byte[] key, byte[] iv)
+        {
+            var aes = Aes.Create();
+            aes.KeySize = KeySize;
+            aes.BlockSize = BlockSize;
+            aes.Mode = CipherMode.CBC;
+            aes.Padding = PaddingMode.PKCS7;
+            aes.Key = key;
+            aes.IV = iv;
+            return aes;
+        }
+
+        private static byte[] GenerateRandom(int length)
+        {
+            var bytes = new byte[length];
+            using var rng = RandomNumberGenerator.Create();
+            rng.GetBytes(bytes);
+            return bytes;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs.meta
new file mode 100644
index 0000000..142ae83
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 751846b93860451e8864bf71f593d4ff
+timeCreated: 1773046087
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs b/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs
new file mode 100644
index 0000000..3b4c42e
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace ShrinkDataSaver
+{
+    [Serializable]
+    public class SaveMeta
+    {
+        public int SlotIndex { get; set; }
+        public string SlotName { get; set; } = "New Save";
+        public int SaveVersion { get; set; } = 1;
+        public long LastModified { get; set; }
+        public float PlaytimeSeconds { get; set; }
+        public string ScreenshotBase64 { get; set; }
+        public bool IsEncrypted { get; set; }
+
+        [JsonIgnore]
+        public DateTime LastModifiedTime => DateTimeOffset.FromUnixTimeSeconds(LastModified).LocalDateTime;
+    }
+
+    [Serializable]
+    internal class SavePacket
+    {
+        public SaveMeta Meta { get; set; }
+        public Dictionary<string, JToken> Modules { get; set; } = new();
+        public string EncryptedModules { get; set; }
+    }
+
+
+    public interface ISaveModule
+    {
+        string Key { get; }
+        object SerializeRaw();
+        void DeserializeRaw(JToken data);
+    }
+
+    public interface ISaveModule<T> : ISaveModule
+    {
+        T Serialize();
+        void Deserialize(T data);
+        object ISaveModule.SerializeRaw() => Serialize();
+        void ISaveModule.DeserializeRaw(JToken data) => Deserialize(data.ToObject<T>());
+    }
+
+    internal class LambdaSaveModule<T> : ISaveModule<T>
+    {
+        public string Key { get; }
+        private readonly Func<T> _serialize;
+        private readonly Action<T> _deserialize;
+
+        public LambdaSaveModule(string key, Func<T> serialize, Action<T> deserialize)
+        {
+            Key = key; _serialize = serialize; _deserialize = deserialize;
+        }
+        public T Serialize() => _serialize();
+        public void Deserialize(T data) => _deserialize(data);
+    }
+
+
+    public class SaveOptions
+    {
+        public string SlotName = "New Save";
+        public bool CaptureScreenshot = false;
+        public UnityEngine.Texture2D Screenshot = null;
+        public bool Encrypt = false;
+        public string EncryptionKey = null;
+    }
+
+
+    public class ModuleConfig
+    {
+        /// <summary>是否参与云存档同步（设置模块应设为 false）</summary>
+        public bool EnableCloudSync { get; set; } = true;
+
+        /// <summary>自动保存间隔（秒），0 表示不自动保存</summary>
+        public float AutoSaveIntervalSeconds { get; set; } = 0f;
+
+        /// <summary>是否为关键模块（关键模块序列化失败将中止整个保存操作）</summary>
+        public bool CriticalModule { get; set; } = false;
+    }
+
+
+    public class SaveStartedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public long Timestamp { get; set; }
+    }
+
+    public class SaveCompletedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public string[] ModuleNames { get; set; }
+        public long Timestamp { get; set; }
+    }
+
+    public class SaveFailedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public string ErrorMessage { get; set; }
+    }
+
+    public class LoadStartedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public long Timestamp { get; set; }
+    }
+
+    public class LoadCompletedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public string[] ModuleNames { get; set; }
+        public int Version { get; set; }
+        public long Timestamp { get; set; }
+    }
+
+    public class LoadFailedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public string ErrorMessage { get; set; }
+    }
+
+    public class MigrationCompletedEventArgs
+    {
+        public int SlotIndex { get; set; }
+        public int FromVersion { get; set; }
+        public int ToVersion { get; set; }
+    }
+
+    public class SlotDeletedEventArgs
+    {
+        public int SlotIndex { get; set; }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs.meta
new file mode 100644
index 0000000..fc3d389
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7cb5188d2a984a1b8f6a701789b8d0f1
+timeCreated: 1773047394
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef
new file mode 100644
index 0000000..27597bb
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef
@@ -0,0 +1,17 @@
+{
+  "name": "ShrinkDataSaver.Runtime",
+  "rootNamespace": "ShrinkDataSaver",
+  "references": [
+    "UniTask",
+    "Newtonsoft.Json"
+  ],
+  "optionalUnityReferences": [],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef.meta
new file mode 100644
index 0000000..83b9712
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5b60ff3063fc45e39b61d1df0c2a6339
+timeCreated: 1773047537
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs
new file mode 100644
index 0000000..c1f2fe0
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs
@@ -0,0 +1,44 @@
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    /// <summary>
+    /// 兼容旧用法：仍可把该组件挂到首场景中，
+    /// 但真正初始化已下沉到 ShrinkDataSaverRuntime，便于宿主层统一接管。
+    /// </summary>
+    [DefaultExecutionOrder(-2000)]
+    public class ShrinkDataSaverBootstrap : MonoBehaviour
+    {
+        [Header("Override (留空使用 ScriptableObject 设置)")] [SerializeField]
+        private ShrinkDataSaverSettings settingsOverride;
+
+        [Header("Save Version")] [SerializeField]
+        private int currentSaveVersion = 1;
+
+        private static bool _initialized;
+
+        private void Awake()
+        {
+            if (ShrinkDataSaverRuntime.IsInitialized)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            if (_initialized)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            _initialized = true;
+            DontDestroyOnLoad(gameObject);
+            ShrinkDataSaverRuntime.Initialize(new ShrinkDataSaverRuntimeConfig
+            {
+                SettingsOverride = settingsOverride,
+                CurrentSaveVersion = currentSaveVersion,
+                DontDestroyOnLoadDriver = true
+            });
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs.meta
new file mode 100644
index 0000000..bc70980
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 30e24d3823c349c99bd78fa0992be0e7
+timeCreated: 1773047454
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs
new file mode 100644
index 0000000..aaa8cbb
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs
@@ -0,0 +1,98 @@
+#nullable enable
+
+using System.IO;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    public sealed class ShrinkDataSaverRuntimeConfig
+    {
+        public ShrinkDataSaverSettings? SettingsOverride { get; set; }
+        public int CurrentSaveVersion { get; set; } = 1;
+        public bool DontDestroyOnLoadDriver { get; set; } = true;
+    }
+
+    public static class ShrinkDataSaverRuntime
+    {
+        public static bool IsInitialized { get; private set; }
+
+        public static void Initialize(ShrinkDataSaverRuntimeConfig? config = null)
+        {
+            if (IsInitialized)
+                return;
+
+            config ??= new ShrinkDataSaverRuntimeConfig();
+            var cfg = config.SettingsOverride ?? ShrinkDataSaverSettings.Instance;
+
+            if (config.SettingsOverride)
+                ShrinkDataSaverSettings.Instance = config.SettingsOverride;
+
+            if (cfg == null)
+                throw new System.InvalidOperationException("ShrinkDataSaverSettings instance is not available.");
+            var rootPath = string.IsNullOrEmpty(cfg.customSavePath)
+                ? Application.persistentDataPath
+                : cfg.customSavePath;
+
+            var savesDir = Path.Combine(rootPath, "saves");
+            var settingsPath = Path.Combine(rootPath, cfg.settingsFileName);
+            var storage = new LocalStorageProvider(rootPath);
+
+            ShrinkSettings.Initialize(storage, settingsPath);
+            ShrinkSave.Initialize(storage, savesDir, cfg.saveFileExtension, config.CurrentSaveVersion);
+            ShrinkSettings.LoadAsync().Forget();
+            ShrinkDataSaverLifecycleDriver.EnsureCreated(config.DontDestroyOnLoadDriver);
+            IsInitialized = true;
+
+            Debug.Log($"[ShrinkDataSaver] Runtime initialized. Root: {rootPath}");
+        }
+
+        internal static void ResetForTesting()
+        {
+            IsInitialized = false;
+        }
+    }
+
+    [DefaultExecutionOrder(-1999)]
+    internal sealed class ShrinkDataSaverLifecycleDriver : MonoBehaviour
+    {
+        private static ShrinkDataSaverLifecycleDriver? _instance;
+        private float _autoSaveTimer;
+
+        public static void EnsureCreated(bool dontDestroyOnLoad)
+        {
+            if (_instance != null)
+                return;
+
+            var go = new GameObject("ShrinkDataSaverRuntimeDriver");
+            _instance = go.AddComponent<ShrinkDataSaverLifecycleDriver>();
+            if (dontDestroyOnLoad)
+                DontDestroyOnLoad(go);
+        }
+
+        private void Update()
+        {
+            var interval = ShrinkSave.GetMinAutoSaveInterval();
+            if (interval <= 0f || ShrinkSave.LoadedSlot < 0)
+                return;
+
+            _autoSaveTimer += Time.unscaledDeltaTime;
+            if (_autoSaveTimer < interval)
+                return;
+
+            _autoSaveTimer = 0f;
+            ShrinkSave.SaveSlotAsync(ShrinkSave.LoadedSlot).Forget();
+        }
+
+        private async void OnApplicationQuit()
+        {
+            await ShrinkSettings.SaveAsync();
+        }
+
+        private async void OnApplicationPause(bool paused)
+        {
+            if (paused)
+                await ShrinkSettings.SaveAsync();
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs.meta
new file mode 100644
index 0000000..818a9e8
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverRuntime.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9b14a9eecf6eb746b24241eac07c939
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs
new file mode 100644
index 0000000..1e1cb44
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs
@@ -0,0 +1,61 @@
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    [CreateAssetMenu(fileName = "ShrinkDataSaverSettings", menuName = "ShrinkDataSaver/Settings")]
+    public class ShrinkDataSaverSettings : ScriptableObject
+    {
+        private static ShrinkDataSaverSettings _instance;
+
+        public static ShrinkDataSaverSettings Instance
+        {
+            get
+            {
+                if (_instance) return _instance;
+
+                _instance = Resources.Load<ShrinkDataSaverSettings>("ShrinkDataSaverSettings");
+
+#if UNITY_EDITOR
+                if (!_instance)
+                {
+                    var guids = UnityEditor.AssetDatabase.FindAssets("t:ShrinkDataSaverSettings");
+                    if (guids.Length > 0)
+                    {
+                        var path = UnityEditor.AssetDatabase.GUIDToAssetPath(guids[0]);
+                        _instance = UnityEditor.AssetDatabase.LoadAssetAtPath<ShrinkDataSaverSettings>(path);
+                    }
+                }
+#endif
+
+                if (!_instance)
+                {
+                    _instance = CreateInstance<ShrinkDataSaverSettings>();
+                    Debug.LogWarning(
+                        "[ShrinkDataSaver] 未找到 ShrinkDataSaverSettings 配置文件！当前使用默认配置。\n" +
+                        "请通过菜单 Assets → Create → ShrinkDataSaver → Settings 创建配置文件，\n" +
+                        "可放置在项目任意目录下（编辑器会自动搜索），或在 ShrinkDataSaverBootstrap 组件上手动指定。");
+                }
+
+                return _instance;
+            }
+            internal set => _instance = value;
+        }
+
+        [Header("Storage")]
+        public string customSavePath = "";
+
+        [Header("Settings File")]
+        public string settingsFileName = "settings.json";
+        public bool syncSettingsToCloud; //todo
+
+        [Header("Save Slots")]
+        public int maxSlots;
+        public string saveFileExtension = ".sav";
+
+        [Header("Screenshot")]
+        public int screenshotMaxWidth = 256;
+
+        [Header("Settings Debounce")]
+        public float settingsWriteDebounceSeconds = 0.3f;
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs.meta
new file mode 100644
index 0000000..11b10c0
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5df22787ec2544b9abbb40cf28536c7e
+timeCreated: 1773047342
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs
new file mode 100644
index 0000000..ecda16b
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs
@@ -0,0 +1,673 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    public static class ShrinkSave
+    {
+        private const string BackupPrimarySuffix = ".bak1";
+        private const string BackupSecondarySuffix = ".bak2";
+        private const string TempWriteSuffix = ".tmp";
+        private const string RecentSlotIndexSettingKey = "ShrinkDataSaver.RecentSlotIndex";
+
+        private static IStorageProvider _storage;
+        private static string _savesDir;
+        private static string _fileExt;
+        private static int _currentSaveVersion = 1;
+
+        private static readonly Dictionary<string, ISaveModule> _modules = new();
+        private static readonly Dictionary<string, ModuleConfig> _moduleConfigs = new();
+
+        private static int _loadedSlot = -1;
+        private static float _sessionStart;
+        private static float _storedPlaytime;
+
+        private static Dictionary<string, JToken> _loadedModuleData;
+
+        public static event Action<SaveStartedEventArgs> OnSaveStarted;
+        public static event Action<SaveCompletedEventArgs> OnSaveCompleted;
+        public static event Action<SaveFailedEventArgs> OnSaveFailed;
+        public static event Action<LoadStartedEventArgs> OnLoadStarted;
+        public static event Action<LoadCompletedEventArgs> OnLoadCompleted;
+        public static event Action<LoadFailedEventArgs> OnLoadFailed;
+        public static event Action<MigrationCompletedEventArgs> OnMigrationCompleted;
+        public static event Action<SlotDeletedEventArgs> OnDeleteCompleted;
+
+        public static int LoadedSlot => _loadedSlot;
+
+        public static int GetRecentSlotIndex() => ShrinkSettings.Get(RecentSlotIndexSettingKey, -1);
+
+        internal static void Initialize(IStorageProvider storage, string savesDir, string fileExt, int saveVersion)
+        {
+            _storage = storage;
+            _savesDir = savesDir;
+            _fileExt = fileExt;
+            _currentSaveVersion = saveVersion;
+        }
+
+        public static void SetCurrentSaveVersion(int version) => _currentSaveVersion = version;
+
+        public static void RegisterModule(ISaveModule module, ModuleConfig config = null)
+        {
+            _modules[module.Key] = module;
+            _moduleConfigs[module.Key] = config ?? new ModuleConfig();
+        }
+
+        public static void RegisterModule<T>(string key, Func<T> serialize, Action<T> deserialize, ModuleConfig config = null)
+        {
+            _modules[key] = new LambdaSaveModule<T>(key, serialize, deserialize);
+            _moduleConfigs[key] = config ?? new ModuleConfig();
+        }
+
+        public static void UnregisterModule(string key)
+        {
+            _modules.Remove(key);
+            _moduleConfigs.Remove(key);
+        }
+
+        public static ModuleConfig GetModuleConfig(string key)
+            => _moduleConfigs.TryGetValue(key, out var cfg) ? cfg : null;
+
+        public static IReadOnlyCollection<string> GetRegisteredModuleNames() => _modules.Keys;
+
+        public static T QueryModule<T>(string moduleName)
+        {
+            if (!_modules.TryGetValue(moduleName, out var module))
+            {
+                return default;
+            }
+
+            try
+            {
+                var raw = module.SerializeRaw();
+                if (raw is T typed)
+                {
+                    return typed;
+                }
+
+                return JToken.FromObject(raw).ToObject<T>();
+            }
+            catch
+            {
+                return default;
+            }
+        }
+
+        public static bool HasKey(string moduleName, string key)
+        {
+            if (_loadedModuleData == null)
+            {
+                return false;
+            }
+
+            if (!_loadedModuleData.TryGetValue(moduleName, out var token))
+            {
+                return false;
+            }
+
+            return token is JObject obj && obj.ContainsKey(key);
+        }
+
+        public static bool HasModule(string moduleName) => _modules.ContainsKey(moduleName);
+
+        public static async UniTask<SaveMeta[]> GetAllMetaAsync(CancellationToken ct = default)
+        {
+            var results = new List<SaveMeta>();
+            var files = await _storage.ListAsync(_savesDir, ct);
+            var discoveredSlots = new HashSet<int>();
+
+            foreach (var file in files)
+            {
+                if (TryExtractSlotIndex(file, out var slotIndex))
+                {
+                    discoveredSlots.Add(slotIndex);
+                }
+            }
+
+            foreach (var slotIndex in discoveredSlots)
+            {
+                try
+                {
+                    var readResult = await ReadPacketWithFallbackAsync(slotIndex, ct);
+                    if (readResult.packet?.Meta != null)
+                    {
+                        results.Add(readResult.packet.Meta);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[ShrinkDataSaver] 读取元数据失败 slot_{slotIndex}: {e.Message}");
+                }
+            }
+
+            results.Sort((a, b) => a.SlotIndex.CompareTo(b.SlotIndex));
+            return results.ToArray();
+        }
+
+        public async static UniTask<bool> SlotExistsAsync(int slotIndex, CancellationToken ct = default)
+            => await _storage.ExistsAsync(SlotPath(slotIndex), ct);
+
+        public static async UniTask<SaveMeta> GetMetaAsync(int slotIndex, CancellationToken ct = default)
+        {
+            try
+            {
+                var readResult = await ReadPacketWithFallbackAsync(slotIndex, ct);
+                return readResult.packet?.Meta;
+            }
+            catch (FileNotFoundException)
+            {
+                return null;
+            }
+        }
+
+        public static async UniTask<int> GetRecommendedContinueSlotAsync(CancellationToken ct = default)
+        {
+            var metas = await GetAllMetaAsync(ct);
+            var resolvedSlot = ResolveRecommendedContinueSlotIndex(GetRecentSlotIndex(), metas);
+            if (resolvedSlot != GetRecentSlotIndex())
+            {
+                await PersistRecentSlotIndexAsync(resolvedSlot, ct);
+            }
+
+            return resolvedSlot;
+        }
+
+        public static async UniTask SaveSlotAsync(int slotIndex, SaveOptions options = null, CancellationToken ct = default)
+        {
+            options ??= new SaveOptions();
+            ValidateSlotIndex(slotIndex);
+
+            var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+            OnSaveStarted?.Invoke(new SaveStartedEventArgs { SlotIndex = slotIndex, Timestamp = timestamp });
+
+            try
+            {
+                var packet = new SavePacket
+                {
+                    Meta = new SaveMeta
+                    {
+                        SlotIndex = slotIndex,
+                        SlotName = options.SlotName,
+                        SaveVersion = _currentSaveVersion,
+                        LastModified = timestamp,
+                        PlaytimeSeconds = GetCurrentPlaytime(),
+                        IsEncrypted = options.Encrypt
+                    }
+                };
+
+                if (options.Screenshot || options.CaptureScreenshot)
+                {
+                    packet.Meta.ScreenshotBase64 = await CaptureScreenshotAsync(options, ct);
+                }
+
+                var modulesDict = new Dictionary<string, JToken>();
+                var moduleNames = new List<string>();
+
+                foreach (var module in _modules.Values)
+                {
+                    try
+                    {
+                        modulesDict[module.Key] = JToken.FromObject(module.SerializeRaw());
+                        moduleNames.Add(module.Key);
+                    }
+                    catch (Exception e)
+                    {
+                        var isCritical = _moduleConfigs.TryGetValue(module.Key, out var cfg) && cfg.CriticalModule;
+                        if (isCritical)
+                        {
+                            throw new InvalidOperationException($"关键模块 '{module.Key}' 序列化失败: {e.Message}", e);
+                        }
+
+                        Debug.LogError($"[ShrinkDataSaver] 模块 '{module.Key}' 序列化失败（已跳过）: {e.Message}");
+                    }
+                }
+
+                if (options.Encrypt)
+                {
+                    if (string.IsNullOrEmpty(options.EncryptionKey))
+                    {
+                        throw new ArgumentException("EncryptionKey missing.");
+                    }
+
+                    var modulesBytes = DataSerializer.Serialize(modulesDict);
+                    var encryptedBytes = SaveEncryptor.Encrypt(modulesBytes, options.EncryptionKey);
+                    packet.EncryptedModules = Convert.ToBase64String(encryptedBytes);
+                }
+                else
+                {
+                    packet.Modules = modulesDict;
+                }
+
+                var finalBytes = DataSerializer.Serialize(packet);
+                await _storage.WriteAsync(SlotPath(slotIndex), finalBytes, ct);
+
+                OnSaveCompleted?.Invoke(new SaveCompletedEventArgs
+                {
+                    SlotIndex = slotIndex,
+                    ModuleNames = moduleNames.ToArray(),
+                    Timestamp = timestamp
+                });
+                Debug.Log($"[ShrinkDataSaver] 槽位 {slotIndex} 已保存。({moduleNames.Count} 个模块)");
+            }
+            catch (Exception e)
+            {
+                OnSaveFailed?.Invoke(new SaveFailedEventArgs
+                {
+                    SlotIndex = slotIndex,
+                    ErrorMessage = e.Message
+                });
+                throw;
+            }
+        }
+
+        public static async UniTask LoadSlotAsync(int slotIndex, string decryptionKey = null, CancellationToken ct = default)
+        {
+            var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+            OnLoadStarted?.Invoke(new LoadStartedEventArgs { SlotIndex = slotIndex, Timestamp = timestamp });
+
+            try
+            {
+                var loadResult = await ReadLoadResultWithFallbackAsync(slotIndex, decryptionKey, ct);
+                var packet = loadResult.packet;
+                var loadedModules = loadResult.loadedModules;
+
+                _loadedModuleData = new Dictionary<string, JToken>(loadedModules);
+
+                var moduleNames = new List<string>();
+                foreach (var module in _modules.Values)
+                {
+                    if (!loadedModules.TryGetValue(module.Key, out var token))
+                    {
+                        continue;
+                    }
+
+                    try
+                    {
+                        module.DeserializeRaw(token);
+                        moduleNames.Add(module.Key);
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.LogError($"[ShrinkDataSaver] 反序列化模块 '{module.Key}' 失败: {e.Message}");
+                    }
+                }
+
+                _loadedSlot = slotIndex;
+                _storedPlaytime = packet.Meta.PlaytimeSeconds;
+                _sessionStart = Time.realtimeSinceStartup;
+                await PersistRecentSlotIndexAsync(slotIndex, ct);
+
+                OnLoadCompleted?.Invoke(new LoadCompletedEventArgs
+                {
+                    SlotIndex = slotIndex,
+                    ModuleNames = moduleNames.ToArray(),
+                    Version = packet.Meta.SaveVersion,
+                    Timestamp = timestamp
+                });
+                Debug.Log($"[ShrinkDataSaver] 槽位 {slotIndex} 已加载。(v{packet.Meta.SaveVersion}, {moduleNames.Count} 个模块)");
+            }
+            catch (Exception e)
+            {
+                OnLoadFailed?.Invoke(new LoadFailedEventArgs
+                {
+                    SlotIndex = slotIndex,
+                    ErrorMessage = e.Message
+                });
+                throw;
+            }
+        }
+
+        public static async UniTask DeleteSlotAsync(int slotIndex, CancellationToken ct = default)
+        {
+            foreach (var candidatePath in EnumerateAllSlotPaths(slotIndex))
+            {
+                await _storage.DeleteAsync(candidatePath, ct);
+            }
+
+            if (_loadedSlot == slotIndex)
+            {
+                _loadedSlot = -1;
+                _storedPlaytime = 0f;
+                _loadedModuleData = null;
+            }
+
+            if (GetRecentSlotIndex() == slotIndex)
+            {
+                var metas = await GetAllMetaAsync(ct);
+                var fallbackSlot = ResolveRecommendedContinueSlotIndex(-1, metas);
+                await PersistRecentSlotIndexAsync(fallbackSlot, ct);
+            }
+
+            OnDeleteCompleted?.Invoke(new SlotDeletedEventArgs { SlotIndex = slotIndex });
+            Debug.Log($"[ShrinkDataSaver] 槽位 {slotIndex} 已删除。");
+        }
+
+        public static float GetMinAutoSaveInterval()
+        {
+            var min = float.MaxValue;
+            var hasAny = false;
+            foreach (var cfg in _moduleConfigs.Values)
+            {
+                if (cfg.AutoSaveIntervalSeconds > 0f)
+                {
+                    min = Mathf.Min(min, cfg.AutoSaveIntervalSeconds);
+                    hasAny = true;
+                }
+            }
+
+            return hasAny ? min : 0f;
+        }
+
+        internal static void ResetForTesting()
+        {
+            _modules.Clear();
+            _moduleConfigs.Clear();
+            _loadedSlot = -1;
+            _sessionStart = 0f;
+            _storedPlaytime = 0f;
+            _loadedModuleData = null;
+            OnSaveStarted = null;
+            OnSaveCompleted = null;
+            OnSaveFailed = null;
+            OnLoadStarted = null;
+            OnLoadCompleted = null;
+            OnLoadFailed = null;
+            OnMigrationCompleted = null;
+            OnDeleteCompleted = null;
+        }
+
+        private static string SlotPath(int slotIndex) => Path.Combine(_savesDir, $"slot_{slotIndex}{_fileExt}");
+
+        private static IEnumerable<string> EnumerateAllSlotPaths(int slotIndex)
+        {
+            var primaryPath = SlotPath(slotIndex);
+            yield return primaryPath;
+            yield return primaryPath + BackupPrimarySuffix;
+            yield return primaryPath + BackupSecondarySuffix;
+            yield return primaryPath + TempWriteSuffix;
+        }
+
+        private static IEnumerable<string> EnumerateReadCandidatePaths(string primaryPath)
+        {
+            yield return primaryPath;
+            yield return primaryPath + BackupPrimarySuffix;
+            yield return primaryPath + BackupSecondarySuffix;
+        }
+
+        private static void ValidateSlotIndex(int slotIndex)
+        {
+            if (slotIndex < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(slotIndex), "槽位索引不能为负数。");
+            }
+
+            var max = ShrinkDataSaverSettings.Instance.maxSlots;
+            if (max > 0 && slotIndex >= max)
+            {
+                throw new ArgumentOutOfRangeException(nameof(slotIndex), $"超出最大槽位数 ({max})。");
+            }
+        }
+
+        private static bool TryExtractSlotIndex(string path, out int slotIndex)
+        {
+            slotIndex = -1;
+
+            var fileName = Path.GetFileName(path);
+            if (string.IsNullOrWhiteSpace(fileName) || fileName.EndsWith(TempWriteSuffix, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            var normalizedName = fileName;
+            if (normalizedName.EndsWith(BackupSecondarySuffix, StringComparison.OrdinalIgnoreCase))
+            {
+                normalizedName = normalizedName[..^BackupSecondarySuffix.Length];
+            }
+            else if (normalizedName.EndsWith(BackupPrimarySuffix, StringComparison.OrdinalIgnoreCase))
+            {
+                normalizedName = normalizedName[..^BackupPrimarySuffix.Length];
+            }
+
+            if (!normalizedName.StartsWith("slot_", StringComparison.OrdinalIgnoreCase) ||
+                !normalizedName.EndsWith(_fileExt, StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            var indexText = normalizedName.Substring(5, normalizedName.Length - 5 - _fileExt.Length);
+            return int.TryParse(indexText, out slotIndex);
+        }
+
+        private static async UniTask PersistRecentSlotIndexAsync(int slotIndex, CancellationToken ct)
+        {
+            if (GetRecentSlotIndex() == slotIndex)
+            {
+                return;
+            }
+
+            ShrinkSettings.Set(RecentSlotIndexSettingKey, slotIndex);
+            await ShrinkSettings.SaveAsync(ct);
+        }
+
+        private static int ResolveRecommendedContinueSlotIndex(int rememberedSlotIndex, IReadOnlyList<SaveMeta> metas)
+        {
+            if (metas == null || metas.Count == 0)
+            {
+                return -1;
+            }
+
+            if (rememberedSlotIndex >= 0 && ContainsSlot(metas, rememberedSlotIndex))
+            {
+                return rememberedSlotIndex;
+            }
+
+            return PickMostRecentSlot(metas);
+        }
+
+        private static bool ContainsSlot(IReadOnlyList<SaveMeta> metas, int slotIndex)
+        {
+            for (var i = 0; i < metas.Count; i++)
+            {
+                if (metas[i] != null && metas[i].SlotIndex == slotIndex)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static int PickMostRecentSlot(IReadOnlyList<SaveMeta> metas)
+        {
+            SaveMeta best = null;
+            for (var i = 0; i < metas.Count; i++)
+            {
+                var meta = metas[i];
+                if (meta == null)
+                {
+                    continue;
+                }
+
+                if (best == null ||
+                    meta.LastModified > best.LastModified ||
+                    (meta.LastModified == best.LastModified && meta.SlotIndex < best.SlotIndex))
+                {
+                    best = meta;
+                }
+            }
+
+            return best?.SlotIndex ?? -1;
+        }
+
+        private static async UniTask<(SavePacket packet, byte[] rawBytes, string sourcePath)> ReadPacketWithFallbackAsync(
+            int slotIndex,
+            CancellationToken ct)
+        {
+            var primaryPath = SlotPath(slotIndex);
+            Exception lastError = null;
+
+            foreach (var candidatePath in EnumerateReadCandidatePaths(primaryPath))
+            {
+                if (!await _storage.ExistsAsync(candidatePath, ct))
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var bytes = await _storage.ReadAsync(candidatePath, ct);
+                    var packet = DataSerializer.Deserialize<SavePacket>(bytes);
+                    if (packet?.Meta == null)
+                    {
+                        throw new InvalidDataException($"槽位 {slotIndex} 的存档包缺少 Meta。");
+                    }
+
+                    if (!string.Equals(candidatePath, primaryPath, StringComparison.Ordinal))
+                    {
+                        Debug.LogWarning($"[ShrinkDataSaver] 槽位 {slotIndex} 主文件损坏或缺失，已从备份恢复：{candidatePath}");
+                        await _storage.WriteAsync(primaryPath, bytes, ct);
+                    }
+
+                    return (packet, bytes, candidatePath);
+                }
+                catch (Exception ex)
+                {
+                    lastError = ex;
+                    Debug.LogWarning($"[ShrinkDataSaver] 读取槽位副本失败：{candidatePath} / {ex.Message}");
+                }
+            }
+
+            if (lastError != null)
+            {
+                throw new InvalidDataException($"槽位 {slotIndex} 的主文件及备份均不可读取。", lastError);
+            }
+
+            throw new FileNotFoundException($"槽位 {slotIndex} 不存在。");
+        }
+
+        private static async UniTask<(SavePacket packet, Dictionary<string, JToken> loadedModules)> ReadLoadResultWithFallbackAsync(
+            int slotIndex,
+            string decryptionKey,
+            CancellationToken ct)
+        {
+            var primaryPath = SlotPath(slotIndex);
+            Exception lastError = null;
+
+            foreach (var candidatePath in EnumerateReadCandidatePaths(primaryPath))
+            {
+                if (!await _storage.ExistsAsync(candidatePath, ct))
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var bytes = await _storage.ReadAsync(candidatePath, ct);
+                    var packet = DataSerializer.Deserialize<SavePacket>(bytes);
+                    if (packet?.Meta == null)
+                    {
+                        throw new InvalidDataException($"反序列化槽位 {slotIndex} 失败。");
+                    }
+
+                    Dictionary<string, JToken> loadedModules;
+                    if (packet.Meta.IsEncrypted)
+                    {
+                        if (string.IsNullOrEmpty(decryptionKey))
+                        {
+                            throw new ArgumentException("需要解密密钥。");
+                        }
+
+                        var encryptedBytes = Convert.FromBase64String(packet.EncryptedModules);
+                        var decryptedBytes = SaveEncryptor.Decrypt(encryptedBytes, decryptionKey);
+                        loadedModules = DataSerializer.Deserialize<Dictionary<string, JToken>>(decryptedBytes);
+                    }
+                    else
+                    {
+                        loadedModules = packet.Modules ?? new Dictionary<string, JToken>();
+                    }
+
+                    if (packet.Meta.SaveVersion < _currentSaveVersion)
+                    {
+                        var fromVersion = packet.Meta.SaveVersion;
+                        var modulesObj = JObject.FromObject(loadedModules);
+                        (modulesObj, packet.Meta.SaveVersion) = MigrationChain.Apply(modulesObj, fromVersion, _currentSaveVersion);
+                        loadedModules = new Dictionary<string, JToken>();
+                        foreach (var key in modulesObj.Properties())
+                        {
+                            loadedModules[key.Name] = modulesObj[key.Name];
+                        }
+
+                        OnMigrationCompleted?.Invoke(new MigrationCompletedEventArgs
+                        {
+                            SlotIndex = slotIndex,
+                            FromVersion = fromVersion,
+                            ToVersion = packet.Meta.SaveVersion
+                        });
+                    }
+
+                    if (!string.Equals(candidatePath, primaryPath, StringComparison.Ordinal))
+                    {
+                        Debug.LogWarning($"[ShrinkDataSaver] 槽位 {slotIndex} 主文件损坏或缺失，已从备份恢复：{candidatePath}");
+                        await _storage.WriteAsync(primaryPath, bytes, ct);
+                    }
+
+                    return (packet, loadedModules);
+                }
+                catch (Exception ex)
+                {
+                    lastError = ex;
+                    Debug.LogWarning($"[ShrinkDataSaver] 加载槽位副本失败：{candidatePath} / {ex.Message}");
+                }
+            }
+
+            if (lastError != null)
+            {
+                throw new InvalidDataException($"槽位 {slotIndex} 的主文件及备份均不可加载。", lastError);
+            }
+
+            throw new FileNotFoundException($"槽位 {slotIndex} 不存在。");
+        }
+
+        private static float GetCurrentPlaytime() => _loadedSlot < 0 ? 0f : _storedPlaytime + (Time.realtimeSinceStartup - _sessionStart);
+
+        private static async UniTask<string> CaptureScreenshotAsync(SaveOptions options, CancellationToken ct)
+        {
+            var tex = options.Screenshot;
+            if (!tex && options.CaptureScreenshot)
+            {
+                await UniTask.Yield(PlayerLoopTiming.PostLateUpdate, ct);
+                tex = ScreenCapture.CaptureScreenshotAsTexture();
+            }
+
+            if (!tex)
+            {
+                return null;
+            }
+
+            var settings = ShrinkDataSaverSettings.Instance;
+            var maxW = settings.screenshotMaxWidth;
+            if (tex.width > maxW)
+            {
+                var scale = (float)maxW / tex.width;
+                var resized = new Texture2D(maxW, Mathf.RoundToInt(tex.height * scale));
+                for (var y = 0; y < resized.height; y++)
+                {
+                    for (var x = 0; x < resized.width; x++)
+                    {
+                        resized.SetPixel(x, y, tex.GetPixelBilinear((float)x / resized.width, (float)y / resized.height));
+                    }
+                }
+
+                resized.Apply();
+                tex = resized;
+            }
+
+            return Convert.ToBase64String(tex.EncodeToJPG(75));
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs.meta
new file mode 100644
index 0000000..ec0105b
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d41b28112039451ca4fca14c901a91a9
+timeCreated: 1773047436
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs
new file mode 100644
index 0000000..6bcb650
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs
@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace ShrinkDataSaver
+{
+    [Serializable]
+    internal class SettingsData
+    {
+        public Dictionary<string, JToken> Values = new();
+    }
+
+    public static class ShrinkSettings
+    {
+        private const string BackupPrimarySuffix = ".bak1";
+        private const string BackupSecondarySuffix = ".bak2";
+
+        private static SettingsData _data = new();
+        private static IStorageProvider _storage;
+        private static string _filePath;
+
+        private static CancellationTokenSource _debounceCts;
+        private static readonly Dictionary<string, List<Action<object>>> _watchers = new();
+
+        public static event Action<string, object> OnChanged;
+
+        internal static void Initialize(IStorageProvider storage, string filePath)
+        {
+            _storage = storage; _filePath = filePath;
+        }
+
+        public static void Set<T>(string key, T value)
+        {
+            _data.Values[key] = JToken.FromObject(value);
+            FireChanged(key, value);
+            ScheduleWrite().Forget();
+        }
+
+        public static T Get<T>(string key, T defaultValue = default)
+        {
+            if (_data.Values.TryGetValue(key, out var token))
+            {
+                try { return token.ToObject<T>(); } catch { /* ignore */ }
+            }
+            return defaultValue;
+        }
+
+        public static bool Has(string key) => _data.Values.ContainsKey(key);
+
+        public static IReadOnlyDictionary<string, JToken> GetAllRaw() => _data.Values;
+
+        public static void Remove(string key)
+        {
+            if (_data.Values.Remove(key))
+            {
+                FireChanged(key, null);
+                ScheduleWrite().Forget();
+            }
+        }
+
+        public static void Watch<T>(string key, Action<T> callback)
+        {
+            if (!_watchers.ContainsKey(key)) _watchers[key] = new List<Action<object>>();
+            _watchers[key].Add(raw => callback((T)Convert.ChangeType(raw, typeof(T))));
+        }
+
+        public static void Unwatch(string key, Action<object> callback)
+        {
+            if (_watchers.TryGetValue(key, out var list)) list.Remove(callback);
+        }
+
+        public static async UniTask SaveAsync(CancellationToken ct = default)
+        {
+            _debounceCts?.Cancel();
+            if (_storage == null || string.IsNullOrWhiteSpace(_filePath))
+            {
+                // 未初始化（独立宿主/单测环境）时跳过持久化，与 LoadAsync 的守卫保持一致
+                return;
+            }
+
+            var bytes = DataSerializer.Serialize(_data);
+            await _storage.WriteAsync(_filePath, bytes, ct);
+        }
+
+        public static async UniTask LoadAsync(CancellationToken ct = default)
+        {
+            if (_storage == null || string.IsNullOrWhiteSpace(_filePath))
+            {
+                _data = new SettingsData();
+                return;
+            }
+
+            var loadedData = await TryLoadWithFallbackAsync(ct);
+            _data = loadedData ?? new SettingsData();
+        }
+
+        internal static void ResetForTesting()
+        {
+            _data = new SettingsData();
+            _debounceCts?.Cancel();
+            _debounceCts = null;
+            _watchers.Clear();
+            OnChanged = null;
+        }
+
+        private static void FireChanged(string key, object value)
+        {
+            OnChanged?.Invoke(key, value);
+
+            if (_watchers.TryGetValue(key, out var list))
+                foreach (var cb in list)
+                    try { cb(value); } catch (Exception e) { Debug.LogException(e); }
+        }
+
+        private static async UniTaskVoid ScheduleWrite()
+        {
+            _debounceCts?.Cancel();
+            _debounceCts = new CancellationTokenSource();
+            var token = _debounceCts.Token;
+
+            try
+            {
+                var delay = (int)(ShrinkDataSaverSettings.Instance.settingsWriteDebounceSeconds * 1000);
+                await UniTask.Delay(delay, cancellationToken: token);
+                await SaveAsync(token);
+            }
+            catch (OperationCanceledException) { }
+            catch (Exception e) { Debug.LogException(e); }
+        }
+
+        private static async UniTask<SettingsData> TryLoadWithFallbackAsync(CancellationToken ct)
+        {
+            var primaryPath = _filePath;
+            Exception lastError = null;
+
+            foreach (var candidatePath in EnumerateCandidatePaths(primaryPath))
+            {
+                if (!await _storage.ExistsAsync(candidatePath, ct))
+                {
+                    continue;
+                }
+
+                try
+                {
+                    var bytes = await _storage.ReadAsync(candidatePath, ct);
+                    var loaded = DataSerializer.Deserialize<SettingsData>(bytes) ?? new SettingsData();
+                    if (!string.Equals(candidatePath, primaryPath, StringComparison.Ordinal))
+                    {
+                        Debug.LogWarning($"[ShrinkDataSaver] Settings 主文件损坏或缺失，已从备份恢复：{candidatePath}");
+                        await _storage.WriteAsync(primaryPath, bytes, ct);
+                    }
+
+                    return loaded;
+                }
+                catch (Exception ex)
+                {
+                    lastError = ex;
+                    Debug.LogWarning($"[ShrinkDataSaver] 读取 Settings 副本失败：{candidatePath} / {ex.Message}");
+                }
+            }
+
+            if (lastError != null)
+            {
+                Debug.LogWarning("[ShrinkDataSaver] 所有 Settings 副本均不可用，已回退为空设置。");
+            }
+
+            return new SettingsData();
+        }
+
+        private static IEnumerable<string> EnumerateCandidatePaths(string primaryPath)
+        {
+            yield return primaryPath;
+            yield return primaryPath + BackupPrimarySuffix;
+            yield return primaryPath + BackupSecondarySuffix;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs.meta b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs.meta
new file mode 100644
index 0000000..6f8fa76
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ffdd053c674640a9987f34ddd93080d8
+timeCreated: 1773047370
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Tests.meta b/Assets/Modules/ShrinkDataSaver/Tests.meta
new file mode 100644
index 0000000..be34e9d
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3ce4b0a2f2d4f304aa1f93b4ceccbf92
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs
new file mode 100644
index 0000000..a738459
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs
@@ -0,0 +1,81 @@
+using System;
+using NUnit.Framework;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class DataSerializerTests
+    {
+        [Serializable]
+        private class SimpleData
+        {
+            public string Name = "test";
+            public int Score = 42;
+        }
+
+        [Serializable]
+        private class NestedData
+        {
+            public string Id = "root";
+            public SimpleData Child = new();
+            public int[] Numbers = { 1, 2, 3 };
+        }
+
+        [Test]
+        public void Serialize_Deserialize_SimpleObject()
+        {
+            var original = new SimpleData { Name = "Alice", Score = 100 };
+            var bytes = DataSerializer.Serialize(original);
+            var restored = DataSerializer.Deserialize<SimpleData>(bytes);
+
+            Assert.AreEqual("Alice", restored.Name);
+            Assert.AreEqual(100, restored.Score);
+        }
+
+        [Test]
+        public void Serialize_Deserialize_NestedObject()
+        {
+            var original = new NestedData
+            {
+                Id = "parent",
+                Child = new SimpleData { Name = "child", Score = 99 },
+                Numbers = new[] { 10, 20, 30 }
+            };
+
+            var bytes = DataSerializer.Serialize(original);
+            var restored = DataSerializer.Deserialize<NestedData>(bytes);
+
+            Assert.AreEqual("parent", restored.Id);
+            Assert.AreEqual("child", restored.Child.Name);
+            Assert.AreEqual(99, restored.Child.Score);
+            Assert.AreEqual(new[] { 10, 20, 30 }, restored.Numbers);
+        }
+
+        [Test]
+        public void ToJObject_FromJObject_RoundTrip()
+        {
+            var original = new SimpleData { Name = "Bob", Score = 77 };
+            var bytes = DataSerializer.Serialize(original);
+            var jObj = DataSerializer.ToJObject(bytes);
+
+            Assert.AreEqual("Bob", jObj["Name"].ToString());
+            Assert.AreEqual(77, (int)jObj["Score"]);
+
+            var bytesBack = DataSerializer.FromJObject(jObj);
+            var restored = DataSerializer.Deserialize<SimpleData>(bytesBack);
+            Assert.AreEqual("Bob", restored.Name);
+            Assert.AreEqual(77, restored.Score);
+        }
+
+        [Test]
+        public void Serialize_NullFields_Ignored()
+        {
+            var data = new SimpleData { Name = null, Score = 5 };
+            var bytes = DataSerializer.Serialize(data);
+            var json = System.Text.Encoding.UTF8.GetString(bytes);
+
+            Assert.IsFalse(json.Contains("Name"));
+            Assert.IsTrue(json.Contains("Score"));
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs.meta
new file mode 100644
index 0000000..d8aec64
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 818cff0034bbd7d4aa0c64c46fc28343
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs
new file mode 100644
index 0000000..7955684
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs
@@ -0,0 +1,125 @@
+using System;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class MigrationChainTests
+    {
+        [SetUp]
+        public void SetUp() => MigrationChain.Clear();
+
+        [TearDown]
+        public void TearDown() => MigrationChain.Clear();
+
+        [Test]
+        public void Register_ValidVersions_Succeeds()
+        {
+            Assert.DoesNotThrow(() =>
+                MigrationChain.Register(1, 2, data => data));
+        }
+
+        [Test]
+        public void Register_InvalidRange_Throws()
+        {
+            Assert.Throws<ArgumentException>(() =>
+                MigrationChain.Register(2, 1, data => data));
+
+            Assert.Throws<ArgumentException>(() =>
+                MigrationChain.Register(1, 1, data => data));
+        }
+
+        [Test]
+        public void Apply_SingleMigration()
+        {
+            MigrationChain.Register(1, 2, data =>
+            {
+                data["newField"] = "added";
+                return data;
+            });
+
+            var input = new JObject { ["existing"] = "value" };
+            var (result, version) = MigrationChain.Apply(input, 1, 2);
+
+            Assert.AreEqual(2, version);
+            Assert.AreEqual("value", result["existing"].ToString());
+            Assert.AreEqual("added", result["newField"].ToString());
+        }
+
+        [Test]
+        public void Apply_ChainMigration_1To3()
+        {
+            MigrationChain.Register(1, 2, data =>
+            {
+                data["coins"] = data["gold"];
+                data.Remove("gold");
+                return data;
+            });
+
+            MigrationChain.Register(2, 3, data =>
+            {
+                data["version3Field"] = 42;
+                return data;
+            });
+
+            var input = new JObject { ["gold"] = 100 };
+            var (result, version) = MigrationChain.Apply(input, 1, 3);
+
+            Assert.AreEqual(3, version);
+            Assert.AreEqual(100, result["coins"].Value<int>());
+            Assert.IsFalse(result.ContainsKey("gold"));
+            Assert.AreEqual(42, result["version3Field"].Value<int>());
+        }
+
+        [Test]
+        public void Apply_MissingStep_StopsEarly()
+        {
+            MigrationChain.Register(1, 2, data => data);
+            // 缺少 2→3 的迁移
+
+            var input = new JObject { ["data"] = "test" };
+            var (result, version) = MigrationChain.Apply(input, 1, 3);
+
+            // 应该停在 v2，因为没有 2→3 的迁移
+            Assert.AreEqual(2, version);
+        }
+
+        [Test]
+        public void Apply_FailedMigration_Rollback()
+        {
+            MigrationChain.Register(1, 2, data =>
+            {
+                data["step1"] = "done";
+                return data;
+            });
+
+            MigrationChain.Register(2, 3, data =>
+            {
+                throw new Exception("Migration failed!");
+            });
+
+            var input = new JObject { ["original"] = "data" };
+            LogAssert.Expect(LogType.Error, "[ShrinkDataSaver] 迁移 v2 → v3 失败: Migration failed!，已回滚至 v1");
+            var (result, version) = MigrationChain.Apply(input, 1, 3);
+
+            // 应该回滚到 v1 的备份数据
+            Assert.AreEqual(1, version);
+            Assert.AreEqual("data", result["original"].ToString());
+            // 回滚意味着 step1 的修改不会存在
+            Assert.IsFalse(result.ContainsKey("step1"));
+        }
+
+        [Test]
+        public void Apply_NoMigrationNeeded_ReturnsSameData()
+        {
+            var input = new JObject { ["data"] = "unchanged" };
+            var (result, version) = MigrationChain.Apply(input, 3, 3);
+
+            Assert.AreEqual(3, version);
+            Assert.AreEqual("unchanged", result["data"].ToString());
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs.meta
new file mode 100644
index 0000000..0dc66a9
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dba29246ec289aa4d9798abaef89a7bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs b/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs
new file mode 100644
index 0000000..eca4f72
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs
@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkDataSaver.Tests
+{
+    /// <summary>
+    /// 内存模拟存储，用于单元测试，无需文件 I/O。
+    /// </summary>
+    public class MockStorageProvider : IStorageProvider
+    {
+        private readonly Dictionary<string, byte[]> _store = new();
+
+        public UniTask WriteAsync(string path, byte[] data, CancellationToken ct = default)
+        {
+            _store[NormalizePath(path)] = data;
+            return UniTask.CompletedTask;
+        }
+
+        public UniTask<byte[]> ReadAsync(string path, CancellationToken ct = default)
+        {
+            var key = NormalizePath(path);
+            if (!_store.TryGetValue(key, out var data))
+                throw new FileNotFoundException($"MockStorage: {key}");
+            return UniTask.FromResult(data);
+        }
+
+        public UniTask<bool> ExistsAsync(string path, CancellationToken ct = default)
+            => UniTask.FromResult(_store.ContainsKey(NormalizePath(path)));
+
+        public UniTask DeleteAsync(string path, CancellationToken ct = default)
+        {
+            _store.Remove(NormalizePath(path));
+            return UniTask.CompletedTask;
+        }
+
+        public UniTask<string[]> ListAsync(string prefix = "", CancellationToken ct = default)
+        {
+            var norm = NormalizePath(prefix);
+            var results = _store.Keys
+                .Where(k => string.IsNullOrEmpty(norm) || k.StartsWith(norm))
+                .ToArray();
+            return UniTask.FromResult(results);
+        }
+
+        public void Clear() => _store.Clear();
+        public int Count => _store.Count;
+
+        private static string NormalizePath(string path)
+            => path.Replace('\\', '/');
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs.meta
new file mode 100644
index 0000000..0cc9a91
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b20797d49fc7bfc47a22c7be5bbd6cf2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs
new file mode 100644
index 0000000..7c8fa99
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+using NUnit.Framework;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class SaveEncryptorTests
+    {
+        [Test]
+        public void Encrypt_Decrypt_RoundTrip()
+        {
+            var original = Encoding.UTF8.GetBytes("Hello, ShrinkDataSaver!");
+            var password = "TestPassword123";
+
+            var encrypted = SaveEncryptor.Encrypt(original, password);
+            var decrypted = SaveEncryptor.Decrypt(encrypted, password);
+
+            Assert.AreEqual(original, decrypted);
+        }
+
+        [Test]
+        public void Encrypt_Decrypt_LargeData()
+        {
+            var original = new byte[10000];
+            new System.Random(42).NextBytes(original);
+            var password = "LargeDataKey";
+
+            var encrypted = SaveEncryptor.Encrypt(original, password);
+            var decrypted = SaveEncryptor.Decrypt(encrypted, password);
+
+            Assert.AreEqual(original, decrypted);
+        }
+
+        [Test]
+        public void Decrypt_WrongPassword_Throws()
+        {
+            var original = Encoding.UTF8.GetBytes("secret data");
+            var encrypted = SaveEncryptor.Encrypt(original, "correct");
+
+            Assert.Throws<CryptographicException>(() =>
+                SaveEncryptor.Decrypt(encrypted, "wrong"));
+        }
+
+        [Test]
+        public void Encrypt_ProducesDifferentOutput_EachTime()
+        {
+            var data = Encoding.UTF8.GetBytes("same data");
+            var enc1 = SaveEncryptor.Encrypt(data, "key");
+            var enc2 = SaveEncryptor.Encrypt(data, "key");
+
+            // 因为随机 salt/IV，两次加密结果不同
+            Assert.AreNotEqual(enc1, enc2);
+
+            // 但两次都能正确解密
+            Assert.AreEqual(data, SaveEncryptor.Decrypt(enc1, "key"));
+            Assert.AreEqual(data, SaveEncryptor.Decrypt(enc2, "key"));
+        }
+
+        [Test]
+        public void Encrypt_NullData_Throws()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+                SaveEncryptor.Encrypt(null, "key"));
+        }
+
+        [Test]
+        public void Encrypt_EmptyPassword_Throws()
+        {
+            Assert.Throws<ArgumentException>(() =>
+                SaveEncryptor.Encrypt(new byte[] { 1, 2, 3 }, ""));
+        }
+
+        [Test]
+        public void Decrypt_NullData_Throws()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+                SaveEncryptor.Decrypt(null, "key"));
+        }
+
+        [Test]
+        public void Decrypt_DataTooShort_Throws()
+        {
+            Assert.Throws<ArgumentException>(() =>
+                SaveEncryptor.Decrypt(new byte[] { 1, 2, 3 }, "key"));
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs.meta
new file mode 100644
index 0000000..a326d5b
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e5040f6e0d2203349aea6b1d2c85a46d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs
new file mode 100644
index 0000000..ef0427c
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs
@@ -0,0 +1,134 @@
+using System;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class SaveTypesTests
+    {
+        // ── SaveMeta ──
+
+        [Test]
+        public void SaveMeta_LastModifiedTime_ConvertsCorrectly()
+        {
+            var meta = new SaveMeta
+            {
+                LastModified = 1700000000 // 2023-11-14 22:13:20 UTC
+            };
+
+            var dt = meta.LastModifiedTime;
+            Assert.AreEqual(2023, dt.Year);
+            Assert.AreEqual(11, dt.Month);
+        }
+
+        [Test]
+        public void SaveMeta_Defaults()
+        {
+            var meta = new SaveMeta();
+            Assert.AreEqual("New Save", meta.SlotName);
+            Assert.AreEqual(1, meta.SaveVersion);
+            Assert.IsFalse(meta.IsEncrypted);
+            Assert.IsNull(meta.ScreenshotBase64);
+        }
+
+        // ── ModuleConfig ──
+
+        [Test]
+        public void ModuleConfig_Defaults()
+        {
+            var cfg = new ModuleConfig();
+            Assert.IsTrue(cfg.EnableCloudSync);
+            Assert.AreEqual(0f, cfg.AutoSaveIntervalSeconds);
+            Assert.IsFalse(cfg.CriticalModule);
+        }
+
+        // ── SaveOptions ──
+
+        [Test]
+        public void SaveOptions_Defaults()
+        {
+            var opt = new SaveOptions();
+            Assert.AreEqual("New Save", opt.SlotName);
+            Assert.IsFalse(opt.CaptureScreenshot);
+            Assert.IsNull(opt.Screenshot);
+            Assert.IsFalse(opt.Encrypt);
+            Assert.IsNull(opt.EncryptionKey);
+        }
+
+        // ── LambdaSaveModule ──
+
+        [Test]
+        public void LambdaSaveModule_Serialize_CallsFactory()
+        {
+            var data = new TestData { Value = 42 };
+            var module = new LambdaSaveModule<TestData>("test", () => data, d => { });
+
+            Assert.AreEqual("test", module.Key);
+            var result = module.Serialize();
+            Assert.AreEqual(42, result.Value);
+        }
+
+        [Test]
+        public void LambdaSaveModule_Deserialize_CallsConsumer()
+        {
+            TestData received = null;
+            var module = new LambdaSaveModule<TestData>("test", () => null, d => received = d);
+
+            ((ISaveModule)module).DeserializeRaw(JToken.FromObject(new TestData { Value = 99 }));
+            Assert.IsNotNull(received);
+            Assert.AreEqual(99, received.Value);
+        }
+
+        // ── 事件参数 ──
+
+        [Test]
+        public void SaveCompletedEventArgs_Fields()
+        {
+            var args = new SaveCompletedEventArgs
+            {
+                SlotIndex = 2,
+                ModuleNames = new[] { "inventory", "quests" },
+                Timestamp = 1234567890
+            };
+
+            Assert.AreEqual(2, args.SlotIndex);
+            Assert.AreEqual(2, args.ModuleNames.Length);
+            Assert.AreEqual(1234567890, args.Timestamp);
+        }
+
+        [Test]
+        public void LoadCompletedEventArgs_Fields()
+        {
+            var args = new LoadCompletedEventArgs
+            {
+                SlotIndex = 1,
+                ModuleNames = new[] { "player" },
+                Version = 3,
+                Timestamp = 9999
+            };
+
+            Assert.AreEqual(1, args.SlotIndex);
+            Assert.AreEqual(3, args.Version);
+        }
+
+        [Test]
+        public void MigrationCompletedEventArgs_Fields()
+        {
+            var args = new MigrationCompletedEventArgs
+            {
+                SlotIndex = 0, FromVersion = 1, ToVersion = 3
+            };
+
+            Assert.AreEqual(1, args.FromVersion);
+            Assert.AreEqual(3, args.ToVersion);
+        }
+
+        [Serializable]
+        public class TestData
+        {
+            public int Value;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs.meta
new file mode 100644
index 0000000..70a87e4
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c4fec6ba5af68dd46ae44776da037c69
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef
new file mode 100644
index 0000000..5fe79e4
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef
@@ -0,0 +1,25 @@
+{
+    "name": "ShrinkDataSaver.Tests",
+    "rootNamespace": "ShrinkDataSaver.Tests",
+    "references": [
+        "ShrinkDataSaver.Runtime",
+        "UniTask",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Newtonsoft.Json.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef.meta b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef.meta
new file mode 100644
index 0000000..b35451b
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ea4bb7f0bb4396d4e9454b19f4630613
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs
new file mode 100644
index 0000000..f2650d0
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs
@@ -0,0 +1,629 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Cysharp.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Object = UnityEngine.Object;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class ShrinkSaveTests
+    {
+        private MockStorageProvider _storage;
+        private ShrinkDataSaverSettings _settings;
+
+        [Serializable]
+        private class PlayerData
+        {
+            public string Name = "TestPlayer";
+            public int Level = 1;
+            public int Coins = 100;
+        }
+
+        private PlayerData _playerData;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _storage = new MockStorageProvider();
+            _settings = ScriptableObject.CreateInstance<ShrinkDataSaverSettings>();
+            _settings.maxSlots = 10;
+            ShrinkDataSaverSettings.Instance = _settings;
+
+            ShrinkSave.ResetForTesting();
+            MigrationChain.Clear();
+            ShrinkSave.Initialize(_storage, "saves", ".sav", 1);
+
+            _playerData = new PlayerData();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            ShrinkSave.ResetForTesting();
+            MigrationChain.Clear();
+            if (_settings != null) Object.DestroyImmediate(_settings);
+        }
+
+        // ── 模块注册 ──
+
+        [Test]
+        public void RegisterModule_Lambda()
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            Assert.IsTrue(ShrinkSave.HasModule("player"));
+        }
+
+        [Test]
+        public void RegisterModule_WithConfig()
+        {
+            var config = new ModuleConfig
+            {
+                EnableCloudSync = false,
+                AutoSaveIntervalSeconds = 30f,
+                CriticalModule = true
+            };
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d, config);
+
+            var restored = ShrinkSave.GetModuleConfig("player");
+            Assert.IsFalse(restored.EnableCloudSync);
+            Assert.AreEqual(30f, restored.AutoSaveIntervalSeconds);
+            Assert.IsTrue(restored.CriticalModule);
+        }
+
+        [Test]
+        public void UnregisterModule_RemovesModuleAndConfig()
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d,
+                new ModuleConfig { CriticalModule = true });
+
+            ShrinkSave.UnregisterModule("player");
+            Assert.IsFalse(ShrinkSave.HasModule("player"));
+            Assert.IsNull(ShrinkSave.GetModuleConfig("player"));
+        }
+
+        [Test]
+        public void GetModuleConfig_NonExistent_ReturnsNull()
+        {
+            Assert.IsNull(ShrinkSave.GetModuleConfig("ghost"));
+        }
+
+        [Test]
+        public void HasModule_ReturnsFalse_WhenNotRegistered()
+        {
+            Assert.IsFalse(ShrinkSave.HasModule("nonexistent"));
+        }
+
+        [Test]
+        public void GetRegisteredModuleNames_ReturnsAll()
+        {
+            ShrinkSave.RegisterModule("a", () => 1, _ => { });
+            ShrinkSave.RegisterModule("b", () => 2, _ => { });
+
+            var names = ShrinkSave.GetRegisteredModuleNames();
+            Assert.AreEqual(2, names.Count);
+            Assert.IsTrue(names.Contains("a"));
+            Assert.IsTrue(names.Contains("b"));
+        }
+
+        // ── 保存 / 加载 / 删除 ──
+
+        [UnityTest]
+        public IEnumerator SaveSlotAsync_ThenExists() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "TestSave" });
+
+            Assert.IsTrue(await ShrinkSave.SlotExistsAsync(0));
+        });
+
+        [UnityTest]
+        public IEnumerator SaveLoad_RoundTrip_DataIntegrity() => UniTask.ToCoroutine(async () =>
+        {
+            _playerData = new PlayerData { Name = "Alice", Level = 10, Coins = 500 };
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "TestSave" });
+
+            // 清除内存数据
+            _playerData = new PlayerData();
+            Assert.AreEqual("TestPlayer", _playerData.Name);
+
+            // 重新加载
+            await ShrinkSave.LoadSlotAsync(0);
+            Assert.AreEqual("Alice", _playerData.Name);
+            Assert.AreEqual(10, _playerData.Level);
+            Assert.AreEqual(500, _playerData.Coins);
+        });
+
+        [UnityTest]
+        public IEnumerator SaveLoad_Encrypted_RoundTrip() => UniTask.ToCoroutine(async () =>
+        {
+            _playerData = new PlayerData { Name = "Encrypted", Level = 99, Coins = 9999 };
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions
+            {
+                SlotName = "Encrypted Save",
+                Encrypt = true,
+                EncryptionKey = "secret123"
+            });
+
+            _playerData = new PlayerData();
+            await ShrinkSave.LoadSlotAsync(0, "secret123");
+
+            Assert.AreEqual("Encrypted", _playerData.Name);
+            Assert.AreEqual(99, _playerData.Level);
+        });
+
+        [UnityTest]
+        public IEnumerator DeleteSlotAsync_RemovesSlot() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+
+            Assert.IsTrue(await ShrinkSave.SlotExistsAsync(0));
+
+            await ShrinkSave.DeleteSlotAsync(0);
+            Assert.IsFalse(await ShrinkSave.SlotExistsAsync(0));
+        });
+
+        [UnityTest]
+        public IEnumerator LoadSlotAsync_NonExistent_ThrowsAndFiresLoadFailed() => UniTask.ToCoroutine(async () =>
+        {
+            LoadFailedEventArgs failArgs = null;
+            ShrinkSave.OnLoadFailed += args => failArgs = args;
+
+            try
+            {
+                await ShrinkSave.LoadSlotAsync(99);
+                Assert.Fail("Should have thrown");
+            }
+            catch (System.IO.FileNotFoundException) { }
+
+            Assert.IsNotNull(failArgs);
+            Assert.AreEqual(99, failArgs.SlotIndex);
+            Assert.IsTrue(failArgs.ErrorMessage.Contains("99"));
+        });
+
+        [UnityTest]
+        public IEnumerator SaveSlotAsync_NegativeIndex_Throws() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            try
+            {
+                await ShrinkSave.SaveSlotAsync(-1);
+                Assert.Fail("Should have thrown");
+            }
+            catch (ArgumentOutOfRangeException) { }
+        });
+
+        [UnityTest]
+        public IEnumerator SaveSlotAsync_ExceedsMaxSlots_Throws() => UniTask.ToCoroutine(async () =>
+        {
+            _settings.maxSlots = 3;
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            try
+            {
+                await ShrinkSave.SaveSlotAsync(5);
+                Assert.Fail("Should have thrown");
+            }
+            catch (ArgumentOutOfRangeException) { }
+        });
+
+        // ── 事件 ──
+
+        [UnityTest]
+        public IEnumerator Events_SaveStarted_FiredBeforeSave() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+
+            SaveStartedEventArgs startArgs = null;
+            ShrinkSave.OnSaveStarted += args => startArgs = args;
+
+            await ShrinkSave.SaveSlotAsync(0);
+
+            Assert.IsNotNull(startArgs);
+            Assert.AreEqual(0, startArgs.SlotIndex);
+            Assert.IsTrue(startArgs.Timestamp > 0);
+        });
+
+        [UnityTest]
+        public IEnumerator Events_SaveCompleted_ContainsModuleNames() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            ShrinkSave.RegisterModule("settings", () => new { volume = 1f }, _ => { });
+
+            SaveCompletedEventArgs completedArgs = null;
+            ShrinkSave.OnSaveCompleted += args => completedArgs = args;
+
+            await ShrinkSave.SaveSlotAsync(0);
+
+            Assert.IsNotNull(completedArgs);
+            Assert.AreEqual(0, completedArgs.SlotIndex);
+            Assert.AreEqual(2, completedArgs.ModuleNames.Length);
+            Assert.IsTrue(completedArgs.Timestamp > 0);
+        });
+
+        [UnityTest]
+        public IEnumerator Events_LoadCompleted_ContainsVersionAndModules() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+
+            LoadCompletedEventArgs loadArgs = null;
+            ShrinkSave.OnLoadCompleted += args => loadArgs = args;
+
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.IsNotNull(loadArgs);
+            Assert.AreEqual(0, loadArgs.SlotIndex);
+            Assert.AreEqual(1, loadArgs.Version);
+            Assert.IsTrue(loadArgs.ModuleNames.Length > 0);
+        });
+
+        [UnityTest]
+        public IEnumerator Events_LoadStarted_Fired() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+
+            LoadStartedEventArgs startArgs = null;
+            ShrinkSave.OnLoadStarted += args => startArgs = args;
+
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.IsNotNull(startArgs);
+            Assert.AreEqual(0, startArgs.SlotIndex);
+        });
+
+        [UnityTest]
+        public IEnumerator Events_DeleteCompleted_Fired() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+
+            SlotDeletedEventArgs deleteArgs = null;
+            ShrinkSave.OnDeleteCompleted += args => deleteArgs = args;
+
+            await ShrinkSave.DeleteSlotAsync(0);
+
+            Assert.IsNotNull(deleteArgs);
+            Assert.AreEqual(0, deleteArgs.SlotIndex);
+        });
+
+        // ── 关键模块 ──
+
+        [UnityTest]
+        public IEnumerator CriticalModule_FailedSerialize_AbortsSave() => UniTask.ToCoroutine(async () =>
+        {
+            // 注册一个会抛异常的关键模块
+            ShrinkSave.RegisterModule<object>("broken",
+                () => throw new Exception("boom"),
+                _ => { },
+                new ModuleConfig { CriticalModule = true });
+
+            SaveFailedEventArgs failArgs = null;
+            ShrinkSave.OnSaveFailed += args => failArgs = args;
+
+            try
+            {
+                await ShrinkSave.SaveSlotAsync(0);
+                Assert.Fail("Should have thrown");
+            }
+            catch (InvalidOperationException) { }
+
+            Assert.IsNotNull(failArgs);
+            Assert.IsTrue(failArgs.ErrorMessage.Contains("broken"));
+        });
+
+        [UnityTest]
+        public IEnumerator NonCriticalModule_FailedSerialize_ContinuesSave() => UniTask.ToCoroutine(async () =>
+        {
+            // 正常模块
+            ShrinkSave.RegisterModule("good", () => _playerData, d => _playerData = d);
+            // 会失败的非关键模块
+            ShrinkSave.RegisterModule<object>("bad",
+                () => throw new Exception("oops"),
+                _ => { },
+                new ModuleConfig { CriticalModule = false });
+
+            SaveCompletedEventArgs completedArgs = null;
+            ShrinkSave.OnSaveCompleted += args => completedArgs = args;
+
+            LogAssert.Expect(LogType.Error, "[ShrinkDataSaver] 模块 'bad' 序列化失败（已跳过）: oops");
+            await ShrinkSave.SaveSlotAsync(0);
+
+            // 保存应该成功（跳过了失败的非关键模块）
+            Assert.IsNotNull(completedArgs);
+            Assert.IsTrue(await ShrinkSave.SlotExistsAsync(0));
+        });
+
+        // ── 版本迁移事件 ──
+
+        [UnityTest]
+        public IEnumerator MigrationCompleted_FiredOnVersionMismatch() => UniTask.ToCoroutine(async () =>
+        {
+            // 以 v1 保存
+            ShrinkSave.SetCurrentSaveVersion(1);
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+
+            // 设置迁移并升级到 v2
+            MigrationChain.Register(1, 2, data =>
+            {
+                data["migrated"] = true;
+                return data;
+            });
+            ShrinkSave.SetCurrentSaveVersion(2);
+
+            MigrationCompletedEventArgs migArgs = null;
+            ShrinkSave.OnMigrationCompleted += args => migArgs = args;
+
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.IsNotNull(migArgs);
+            Assert.AreEqual(0, migArgs.SlotIndex);
+            Assert.AreEqual(1, migArgs.FromVersion);
+            Assert.AreEqual(2, migArgs.ToVersion);
+        });
+
+        // ── 跨模块查询 ──
+
+        [Test]
+        public void QueryModule_ReturnsCurrentData()
+        {
+            _playerData = new PlayerData { Name = "Query", Level = 5, Coins = 200 };
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+
+            var result = ShrinkSave.QueryModule<PlayerData>("player");
+            Assert.IsNotNull(result);
+            Assert.AreEqual("Query", result.Name);
+            Assert.AreEqual(5, result.Level);
+        }
+
+        [Test]
+        public void QueryModule_NonExistentModule_ReturnsDefault()
+        {
+            var result = ShrinkSave.QueryModule<PlayerData>("ghost");
+            Assert.IsNull(result);
+        }
+
+        [UnityTest]
+        public IEnumerator HasKey_AfterLoad_ChecksModuleData() => UniTask.ToCoroutine(async () =>
+        {
+            _playerData = new PlayerData { Name = "KeyTest", Level = 1, Coins = 0 };
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.IsTrue(ShrinkSave.HasKey("player", "Name"));
+            Assert.IsTrue(ShrinkSave.HasKey("player", "Level"));
+            Assert.IsFalse(ShrinkSave.HasKey("player", "NonExistentField"));
+            Assert.IsFalse(ShrinkSave.HasKey("ghost_module", "Name"));
+        });
+
+        [Test]
+        public void HasKey_BeforeLoad_ReturnsFalse()
+        {
+            Assert.IsFalse(ShrinkSave.HasKey("player", "Name"));
+        }
+
+        // ── 自动保存间隔 ──
+
+        [Test]
+        public void GetMinAutoSaveInterval_NoModules_ReturnsZero()
+        {
+            Assert.AreEqual(0f, ShrinkSave.GetMinAutoSaveInterval());
+        }
+
+        [Test]
+        public void GetMinAutoSaveInterval_ReturnsMinimum()
+        {
+            ShrinkSave.RegisterModule("a", () => 1, _ => { },
+                new ModuleConfig { AutoSaveIntervalSeconds = 60f });
+            ShrinkSave.RegisterModule("b", () => 2, _ => { },
+                new ModuleConfig { AutoSaveIntervalSeconds = 30f });
+            ShrinkSave.RegisterModule("c", () => 3, _ => { },
+                new ModuleConfig { AutoSaveIntervalSeconds = 0f }); // 不参与
+
+            Assert.AreEqual(30f, ShrinkSave.GetMinAutoSaveInterval());
+        }
+
+        // ── 元数据 ──
+
+        [UnityTest]
+        public IEnumerator GetMetaAsync_ReturnsMeta() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "MetaTest" });
+
+            var meta = await ShrinkSave.GetMetaAsync(0);
+            Assert.IsNotNull(meta);
+            Assert.AreEqual(0, meta.SlotIndex);
+            Assert.AreEqual("MetaTest", meta.SlotName);
+            Assert.AreEqual(1, meta.SaveVersion);
+            Assert.IsFalse(meta.IsEncrypted);
+        });
+
+        [UnityTest]
+        public IEnumerator GetMetaAsync_NonExistent_ReturnsNull() => UniTask.ToCoroutine(async () =>
+        {
+            var meta = await ShrinkSave.GetMetaAsync(99);
+            Assert.IsNull(meta);
+        });
+
+        [UnityTest]
+        public IEnumerator GetAllMetaAsync_ReturnsAllSlots() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "Slot0" });
+            await ShrinkSave.SaveSlotAsync(1, new SaveOptions { SlotName = "Slot1" });
+
+            var allMeta = await ShrinkSave.GetAllMetaAsync();
+            Assert.AreEqual(2, allMeta.Length);
+            Assert.AreEqual(0, allMeta[0].SlotIndex);
+            Assert.AreEqual(1, allMeta[1].SlotIndex);
+        });
+
+        // ── LoadedSlot ──
+
+        [Test]
+        public void LoadedSlot_InitiallyNegative()
+        {
+            Assert.AreEqual(-1, ShrinkSave.LoadedSlot);
+        }
+
+        [UnityTest]
+        public IEnumerator LoadedSlot_UpdatedAfterLoad() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.AreEqual(0, ShrinkSave.LoadedSlot);
+        });
+
+        [UnityTest]
+        public IEnumerator LoadedSlot_ResetAfterDelete() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(0);
+            await ShrinkSave.LoadSlotAsync(0);
+            Assert.AreEqual(0, ShrinkSave.LoadedSlot);
+
+            await ShrinkSave.DeleteSlotAsync(0);
+            Assert.AreEqual(-1, ShrinkSave.LoadedSlot);
+        });
+
+        // ── 多模块 ──
+
+        [UnityTest]
+        public IEnumerator MultipleModules_SaveLoad_AllRestored() => UniTask.ToCoroutine(async () =>
+        {
+            var inventory = new int[] { 1, 2, 3 };
+            var questFlag = new bool[] { true, false, true };
+            int[] loadedInv = null;
+            bool[] loadedQuest = null;
+
+            ShrinkSave.RegisterModule("inventory", () => inventory, d => loadedInv = d);
+            ShrinkSave.RegisterModule("quests", () => questFlag, d => loadedQuest = d);
+
+            await ShrinkSave.SaveSlotAsync(0);
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.AreEqual(new[] { 1, 2, 3 }, loadedInv);
+            Assert.AreEqual(new[] { true, false, true }, loadedQuest);
+        });
+
+        [UnityTest]
+        public IEnumerator LoadSlotAsync_FallsBackToBackup_WhenPrimaryCorrupted() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            _playerData = new PlayerData { Name = "BackupPlayer", Level = 7, Coins = 321 };
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "BackupSlot" });
+
+            var backupBytes = await _storage.ReadAsync("saves/slot_0.sav");
+            await _storage.WriteAsync("saves/slot_0.sav.bak1", backupBytes);
+            await _storage.WriteAsync("saves/slot_0.sav", DataSerializer.Serialize(new { broken = true }));
+
+            _playerData = new PlayerData();
+            await ShrinkSave.LoadSlotAsync(0);
+
+            Assert.AreEqual("BackupPlayer", _playerData.Name);
+
+            var repairedPrimary = await _storage.ReadAsync("saves/slot_0.sav");
+            CollectionAssert.AreEqual(backupBytes, repairedPrimary);
+        });
+
+        [UnityTest]
+        public IEnumerator GetAllMetaAsync_UsesBackupOnlySlot_WhenPrimaryMissing() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+            await ShrinkSave.SaveSlotAsync(2, new SaveOptions { SlotName = "BackupOnly" });
+
+            var backupBytes = await _storage.ReadAsync("saves/slot_2.sav");
+            await _storage.WriteAsync("saves/slot_2.sav.bak1", backupBytes);
+            await _storage.DeleteAsync("saves/slot_2.sav");
+
+            var metas = await ShrinkSave.GetAllMetaAsync();
+
+            Assert.AreEqual(1, metas.Length);
+            Assert.AreEqual(2, metas[0].SlotIndex);
+            Assert.AreEqual("BackupOnly", metas[0].SlotName);
+            Assert.IsTrue(await _storage.ExistsAsync("saves/slot_2.sav"));
+        });
+
+        [UnityTest]
+        public IEnumerator GetRecommendedContinueSlotAsync_PrefersRecentAndSelfHeals() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSave.RegisterModule("player", () => _playerData, d => _playerData = d);
+
+            _playerData = new PlayerData { Name = "Slot0", Level = 1, Coins = 10 };
+            await ShrinkSave.SaveSlotAsync(0, new SaveOptions { SlotName = "Slot0" });
+
+            _playerData = new PlayerData { Name = "Slot3", Level = 3, Coins = 30 };
+            await ShrinkSave.SaveSlotAsync(3, new SaveOptions { SlotName = "Slot3" });
+
+            await ShrinkSettings.LoadAsync();
+            ShrinkSettings.Set("ShrinkDataSaver.RecentSlotIndex", 3);
+            await ShrinkSettings.SaveAsync();
+
+            var preferred = await ShrinkSave.GetRecommendedContinueSlotAsync();
+            Assert.AreEqual(3, preferred);
+
+            await ShrinkSave.DeleteSlotAsync(3);
+            preferred = await ShrinkSave.GetRecommendedContinueSlotAsync();
+            Assert.AreEqual(0, preferred);
+            Assert.AreEqual(0, ShrinkSave.GetRecentSlotIndex());
+        });
+    }
+
+    [TestFixture]
+    public class LocalStorageProviderTests
+    {
+        private string _rootPath;
+        private LocalStorageProvider _provider;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _rootPath = Path.Combine(Path.GetTempPath(), $"ShrinkDataSaverTests_{Guid.NewGuid():N}");
+            Directory.CreateDirectory(_rootPath);
+            _provider = new LocalStorageProvider(_rootPath);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (Directory.Exists(_rootPath))
+            {
+                Directory.Delete(_rootPath, true);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator WriteAsync_RotatesTwoBackupsAtomically() => UniTask.ToCoroutine(async () =>
+        {
+            var relativePath = "saves/sample.sav";
+
+            await _provider.WriteAsync(relativePath, DataSerializer.Serialize(new { version = 1 }));
+            await _provider.WriteAsync(relativePath, DataSerializer.Serialize(new { version = 2 }));
+            await _provider.WriteAsync(relativePath, DataSerializer.Serialize(new { version = 3 }));
+
+            var primary = DataSerializer.Deserialize<JObject>(await _provider.ReadAsync(relativePath));
+            var backup1 = DataSerializer.Deserialize<JObject>(await _provider.ReadAsync(relativePath + ".bak1"));
+            var backup2 = DataSerializer.Deserialize<JObject>(await _provider.ReadAsync(relativePath + ".bak2"));
+
+            Assert.AreEqual(3, primary["version"]?.Value<int>());
+            Assert.AreEqual(2, backup1["version"]?.Value<int>());
+            Assert.AreEqual(1, backup2["version"]?.Value<int>());
+        });
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs.meta
new file mode 100644
index 0000000..ea503e5
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2cf2ecb1a4173846bbcfb49d584d8bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs
new file mode 100644
index 0000000..a2de758
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs
@@ -0,0 +1,212 @@
+using System.Collections;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ShrinkDataSaver.Tests
+{
+    [TestFixture]
+    public class ShrinkSettingsTests
+    {
+        private MockStorageProvider _storage;
+        private ShrinkDataSaverSettings _settings;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _storage = new MockStorageProvider();
+            _settings = ScriptableObject.CreateInstance<ShrinkDataSaverSettings>();
+            ShrinkDataSaverSettings.Instance = _settings;
+            ShrinkSettings.ResetForTesting();
+            ShrinkSettings.Initialize(_storage, "settings.json");
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            ShrinkSettings.ResetForTesting();
+            if (_settings != null) Object.DestroyImmediate(_settings);
+        }
+
+        // ── Get / Set ──
+
+        [Test]
+        public void Set_Get_String()
+        {
+            ShrinkSettings.Set("name", "Alice");
+            Assert.AreEqual("Alice", ShrinkSettings.Get<string>("name"));
+        }
+
+        [Test]
+        public void Set_Get_Int()
+        {
+            ShrinkSettings.Set("score", 42);
+            Assert.AreEqual(42, ShrinkSettings.Get<int>("score"));
+        }
+
+        [Test]
+        public void Set_Get_Float()
+        {
+            ShrinkSettings.Set("volume", 0.75f);
+            Assert.AreEqual(0.75f, ShrinkSettings.Get<float>("volume"), 0.001f);
+        }
+
+        [Test]
+        public void Set_Get_Bool()
+        {
+            ShrinkSettings.Set("muted", true);
+            Assert.IsTrue(ShrinkSettings.Get<bool>("muted"));
+        }
+
+        [Test]
+        public void Set_Get_ComplexObject()
+        {
+            var data = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };
+            ShrinkSettings.Set("map", data);
+            var restored = ShrinkSettings.Get<Dictionary<string, int>>("map");
+
+            Assert.AreEqual(1, restored["a"]);
+            Assert.AreEqual(2, restored["b"]);
+        }
+
+        [Test]
+        public void Get_NonExistentKey_ReturnsDefault()
+        {
+            Assert.AreEqual(0, ShrinkSettings.Get<int>("missing"));
+            Assert.IsNull(ShrinkSettings.Get<string>("missing"));
+            Assert.AreEqual(99, ShrinkSettings.Get("missing", 99));
+        }
+
+        // ── Has / Remove ──
+
+        [Test]
+        public void Has_ExistingKey_ReturnsTrue()
+        {
+            ShrinkSettings.Set("key", "value");
+            Assert.IsTrue(ShrinkSettings.Has("key"));
+        }
+
+        [Test]
+        public void Has_NonExistentKey_ReturnsFalse()
+        {
+            Assert.IsFalse(ShrinkSettings.Has("ghost"));
+        }
+
+        [Test]
+        public void Remove_ExistingKey()
+        {
+            ShrinkSettings.Set("temp", 123);
+            Assert.IsTrue(ShrinkSettings.Has("temp"));
+
+            ShrinkSettings.Remove("temp");
+            Assert.IsFalse(ShrinkSettings.Has("temp"));
+        }
+
+        [Test]
+        public void Remove_NonExistentKey_NoError()
+        {
+            Assert.DoesNotThrow(() => ShrinkSettings.Remove("ghost"));
+        }
+
+        // ── GetAllRaw ──
+
+        [Test]
+        public void GetAllRaw_ReturnsAllSettings()
+        {
+            ShrinkSettings.Set("a", 1);
+            ShrinkSettings.Set("b", "two");
+            ShrinkSettings.Set("c", true);
+
+            var all = ShrinkSettings.GetAllRaw();
+            Assert.AreEqual(3, all.Count);
+            Assert.IsTrue(all.ContainsKey("a"));
+            Assert.IsTrue(all.ContainsKey("b"));
+            Assert.IsTrue(all.ContainsKey("c"));
+        }
+
+        // ── 事件 ──
+
+        [Test]
+        public void OnChanged_FiredOnSet()
+        {
+            string receivedKey = null;
+            object receivedValue = null;
+            ShrinkSettings.OnChanged += (k, v) => { receivedKey = k; receivedValue = v; };
+
+            ShrinkSettings.Set("volume", 0.5f);
+
+            Assert.AreEqual("volume", receivedKey);
+        }
+
+        [Test]
+        public void OnChanged_FiredOnRemove()
+        {
+            ShrinkSettings.Set("temp", "data");
+
+            string removedKey = null;
+            ShrinkSettings.OnChanged += (k, v) => { removedKey = k; };
+
+            ShrinkSettings.Remove("temp");
+            Assert.AreEqual("temp", removedKey);
+        }
+
+        // ── 持久化 ──
+
+        [UnityTest]
+        public IEnumerator SaveAsync_LoadAsync_RoundTrip() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSettings.Set("persist_str", "hello");
+            ShrinkSettings.Set("persist_int", 42);
+            await ShrinkSettings.SaveAsync();
+
+            // 重置内存数据后重新加载
+            ShrinkSettings.ResetForTesting();
+            ShrinkSettings.Initialize(_storage, "settings.json");
+
+            await ShrinkSettings.LoadAsync();
+
+            Assert.AreEqual("hello", ShrinkSettings.Get<string>("persist_str"));
+            Assert.AreEqual(42, ShrinkSettings.Get<int>("persist_int"));
+        });
+
+        [UnityTest]
+        public IEnumerator LoadAsync_EmptyStorage_GivesCleanState() => UniTask.ToCoroutine(async () =>
+        {
+            await ShrinkSettings.LoadAsync();
+            Assert.AreEqual(0, ShrinkSettings.GetAllRaw().Count);
+        });
+
+        [UnityTest]
+        public IEnumerator LoadAsync_FallsBackToBackup_WhenPrimaryCorrupted() => UniTask.ToCoroutine(async () =>
+        {
+            ShrinkSettings.Set("lang", "zh_cn");
+            await ShrinkSettings.SaveAsync();
+
+            var backupBytes = await _storage.ReadAsync("settings.json");
+            await _storage.WriteAsync("settings.json.bak1", backupBytes);
+            // 用无法解析的字节模拟主文件损坏：结构合法但字段不符的 JSON 无法与“合法空设置”区分
+            await _storage.WriteAsync("settings.json", System.Text.Encoding.UTF8.GetBytes("{ \"lang\": \"zh_cn\" , broken"));
+
+            ShrinkSettings.ResetForTesting();
+            ShrinkSettings.Initialize(_storage, "settings.json");
+
+            await ShrinkSettings.LoadAsync();
+
+            Assert.AreEqual("zh_cn", ShrinkSettings.Get<string>("lang"));
+            var repairedPrimary = await _storage.ReadAsync("settings.json");
+            CollectionAssert.AreEqual(backupBytes, repairedPrimary);
+        });
+
+        // ── Overwrite ──
+
+        [Test]
+        public void Set_OverwriteExistingKey()
+        {
+            ShrinkSettings.Set("key", "first");
+            ShrinkSettings.Set("key", "second");
+            Assert.AreEqual("second", ShrinkSettings.Get<string>("key"));
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs.meta b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs.meta
new file mode 100644
index 0000000..5cd8af3
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40ae83c4b82a9c24dbd209f7a03f08e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkDataSaver/package.json b/Assets/Modules/ShrinkDataSaver/package.json
new file mode 100644
index 0000000..dbab8e5
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "com.cneicy.shrink-datasaver",
+  "version": "2.2.0",
+  "displayName": "ShrinkDataSaver",
+  "description": "模块化 Unity 存档与设置管理系统，支持多槽位、链式版本迁移、AES-256 加密、关键模块保护、跨模块查询与事件驱动架构。",
+  "unity": "2022.3",
+  "documentationUrl": "https://github.com/cneicy/ShrinkDataSaver",
+  "changelogUrl": "https://github.com/cneicy/ShrinkDataSaver/blob/main/CHANGELOG.md",
+  "licensesUrl": "https://github.com/cneicy/ShrinkDataSaver/blob/main/LICENSE",
+  "dependencies": {
+    "com.unity.nuget.newtonsoft-json": "3.2.1",
+    "com.cysharp.unitask": "2.5.0",
+    "com.unity.modules.imageconversion": "1.0.0",
+    "com.unity.modules.screencapture": "1.0.0"
+  },
+  "keywords": ["save", "load", "data", "settings", "serialization", "encryption", "migration"],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkDataSaver/package.json.meta b/Assets/Modules/ShrinkDataSaver/package.json.meta
new file mode 100644
index 0000000..93d116e
--- /dev/null
+++ b/Assets/Modules/ShrinkDataSaver/package.json.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: eaff7d7dedd446b88dfdbe10d7bf3187
+timeCreated: 1774092581
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus b/Assets/Modules/ShrinkEventBus
deleted file mode 160000
index 8acccdc..0000000
--- a/Assets/Modules/ShrinkEventBus
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 8acccdcc4b1f0c51fc864e1d37d82d51f586348e
diff --git a/Assets/Modules/ShrinkEventBus/.gitignore b/Assets/Modules/ShrinkEventBus/.gitignore
new file mode 100644
index 0000000..9eb70ce
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/.gitignore
@@ -0,0 +1,99 @@
+# This .gitignore file should be placed at the root of your Unity project directory
+#
+# Get latest from https://github.com/github/gitignore/blob/main/Unity.gitignore
+#
+.utmp/
+/[Ll]ibrary/
+/[Tt]emp/
+/[Oo]bj/
+/[Bb]uild/
+/[Bb]uilds/
+/[Ll]ogs/
+/[Uu]ser[Ss]ettings/
+*.log
+
+# By default unity supports Blender asset imports, *.blend1 blender files do not need to be commited to version control.
+*.blend1
+*.blend1.meta
+
+# MemoryCaptures can get excessive in size.
+# They also could contain extremely sensitive data
+/[Mm]emoryCaptures/
+
+# Recordings can get excessive in size
+/[Rr]ecordings/
+
+# Uncomment this line if you wish to ignore the asset store tools plugin
+# /[Aa]ssets/AssetStoreTools*
+
+# Autogenerated Jetbrains Rider plugin
+/[Aa]ssets/Plugins/Editor/JetBrains*
+# Jetbrains Rider personal-layer settings
+*.DotSettings.user
+
+# Visual Studio cache directory
+.vs/
+
+# Gradle cache directory
+.gradle/
+
+# Autogenerated VS/MD/Consulo solution and project files
+ExportedObj/
+.consulo/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+*.pdb
+*.mdb
+*.opendb
+*.VC.db
+
+# Unity3D generated meta files
+*.pidb.meta
+*.pdb.meta
+*.mdb.meta
+
+# Unity3D generated file on crash reports
+sysinfo.txt
+
+# Mono auto generated files
+mono_crash.*
+
+# Builds
+*.apk
+*.aab
+*.unitypackage
+*.unitypackage.meta
+*.app
+
+# Crashlytics generated file
+crashlytics-build.properties
+
+# TestRunner generated files
+InitTestScene*.unity*
+
+# Addressables default ignores, before user customizations
+/ServerData
+/[Aa]ssets/StreamingAssets/aa*
+/[Aa]ssets/AddressableAssetsData/link.xml*
+/[Aa]ssets/Addressables_Temp*
+# By default, Addressables content builds will generate addressables_content_state.bin
+# files in platform-specific subfolders, for example:
+# /Assets/AddressableAssetsData/OSX/addressables_content_state.bin
+/[Aa]ssets/AddressableAssetsData/*/*.bin*
+
+# Visual Scripting auto-generated files
+/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Flow/UnitOptions.db
+/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Flow/UnitOptions.db.meta
+/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Core/Property Providers
+/[Aa]ssets/Unity.VisualScripting.Generated/VisualScripting.Core/Property Providers.meta
+
+# Auto-generated scenes by play mode tests
+/[Aa]ssets/[Ii]nit[Tt]est[Ss]cene*.unity*
diff --git a/Assets/Modules/ShrinkEventBus/Benchmark.txt b/Assets/Modules/ShrinkEventBus/Benchmark.txt
new file mode 100644
index 0000000..fb2a369
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Benchmark.txt
@@ -0,0 +1,83 @@
+╔══════════════════════════════════════════════════╗
+║         ShrinkEventBus Benchmark Report          ║
+║ iter= 1000000 mass= 10000 reg= 5000 scan=1000 ║
+╚══════════════════════════════════════════════════╝
+  基准对象：独立实例 bus（AllowPerPhaseDispatch 已开启）
+  采集于 1.3.0（EventBase 瘦身后；Unity 2022.3.62f3, Editor Play Mode）
+
+  ▶ TriggerEvent × 无订阅者（基线）
+      总耗时 :    111.466 ms
+      单次   :     0.1115 μs/op
+      吞吐量 :    8971378 ops/s
+
+  ▶ TriggerEvent × 单订阅者同步
+      总耗时 :    163.073 ms
+      单次   :     0.1631 μs/op
+      吞吐量 :    6132242 ops/s
+
+  ▶ TriggerEvent × 父事件监听子事件
+      总耗时 :    171.424 ms
+      单次   :     0.1714 μs/op
+      吞吐量 :    5833479 ops/s
+
+  ▶ TriggerEvent × 30 订阅者同步
+      总耗时 :     38.639 ms
+      单次   :     3.8639 μs/op
+      吞吐量 :     258805 ops/s
+
+  ▶ TriggerEvent(Phase=HIGH) × 3 phase 监听
+      总耗时 :    164.197 ms
+      单次   :     0.1642 μs/op
+      吞吐量 :    6090238 ops/s
+
+  ▶ TriggerEventAsync × 单订阅者异步
+      总耗时 :      0.856 ms
+      单次   :     0.8557 μs/op
+      吞吐量 :    1168634 ops/s
+
+  ▶ RegisterEvent(delegate)
+      总耗时 :     14.418 ms
+      单次   :     2.8836 μs/op
+      吞吐量 :     346791 ops/s
+
+  ▶ UnregisterEvent(delegate)
+      总耗时 :      3.427 ms
+      单次   :     0.6853 μs/op
+      吞吐量 :    1459130 ops/s
+
+  ▶ Register/Unregister(instance scan)
+      总耗时 :     13.097 ms
+      单次   :    13.0971 μs/op
+      吞吐量 :      76353 ops/s
+
+  ▶ Register/Unregister(static type scan)
+      总耗时 :      9.337 ms
+      单次   :     9.3374 μs/op
+      吞吐量 :     107096 ops/s
+
+  ▶ Register/Unregister(MethodInfo)
+      总耗时 :      6.513 ms
+      单次   :     6.5134 μs/op
+      吞吐量 :     153530 ops/s
+
+  ▶ TriggerEvent × new()      [GC Gen0=  1]
+      总耗时 :    266.536 ms
+      单次   :     0.2665 μs/op
+      吞吐量 :    3751843 ops/s
+
+  ▶ TriggerEvent × Pool.Get() [GC Gen0=  0]
+      总耗时 :    242.015 ms
+      单次   :     0.2420 μs/op
+      吞吐量 :    4131982 ops/s
+
+  ▶ TriggerEvent × 已取消事件跳过（10 订阅者）
+      总耗时 :     52.777 ms
+      单次   :     0.5278 μs/op
+      吞吐量 :    1894776 ops/s
+
+══════════════════════════════════════════════════
+  全部测试完成
+
+  对比 1.1.x 旧样本：new() 路径 7684ms / GC Gen0=6457 → 266ms / GC Gen0=1
+  （EventBase 不再每实例分配内置 ListenerList，new() 路径 GC 基本归零，
+   对象池从“高频必需”降级为可选优化。）
diff --git a/Assets/Modules/ShrinkEventBus/Benchmark.txt.meta b/Assets/Modules/ShrinkEventBus/Benchmark.txt.meta
new file mode 100644
index 0000000..ee8b618
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Benchmark.txt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 87ccd659dba774447b9d6941761b8300
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/CHANGELOG.md b/Assets/Modules/ShrinkEventBus/CHANGELOG.md
new file mode 100644
index 0000000..179bd90
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CHANGELOG.md
@@ -0,0 +1,58 @@
+# Changelog
+
+本文件记录 `ShrinkEventBus` 在当前工作区中的包内变更。
+
+## [1.3.0] - 2026-06-12
+
+### Breaking
+
+- 移除 `EventBase.GetListenerList()`。事件对象不再内置 `ListenerList`，改为持有派发时的快照数组；调试请使用 `GetSubscribers()`（现在返回拷贝）。
+- 数字优先级 `0` 现在映射到 `NORMAL`（原为 `LOW`），与枚举重载的默认值保持一致。
+- 所有 int 数字优先级重载（`RegisterEvent` / `SubscribeEvent`）不再提供默认值 `0`，必须显式传入数字——消除与枚举重载之间的重载二义性。不带优先级的调用现在唯一解析到枚举重载（`NORMAL`）。
+
+### Fixed
+
+- 织入前会检查类型自身及基类链上是否存在实例 `[EventSubscribe]` 方法，没有的类型不再织入，避免在 `Awake` 中抛出注册异常。
+- `AutoRegister`（含 Mod 框架反射路径）遇到没有任何匹配 `[EventSubscribe]` 方法的类型时，改为输出警告并跳过，不再抛异常；显式 `Register()` 仍保持严格抛错。
+- `ListenerList` 父子链脏标记传播与快照重建之间的竞态：同一总线内所有监听列表（含父子链）现共用一把锁。
+- `RegisterCore` 的 check-then-act 竞态（并发下同一实例可能被注册两次）。
+- `EventPool.Release` 的双重归还竞态；对象池增加容量上限（128），超出直接丢弃。
+- 父子事件同 phase 内的 handler 顺序：现在按数字优先级跨父子稳定归并（平局时子类型 handler 在前），数字优先级不再只在单层内生效。
+
+### Changed
+
+- 派发热路径重构：事件对象的监听者快照从“逐个带锁二分插入内置 ListenerList”改为一次数组引用赋值；`EventId` 改为懒生成；事件元数据缓存改用 `ConcurrentDictionary`。每个事件实例的构造分配显著减少。
+- 删除死代码 `EventCache<T>`（README 此前描述的“泛型静态缓存热路径”自实例化总线改造后已不存在）。
+- 恢复模块内 `CodeGen/` 作为可选本地织入管线：命中 `ShrinkShared.CodeGen` 覆盖范围的程序集继续由共享管线优先处理，其余只引用 `ShrinkEventBus.Runtime` 的程序集改由本地 `EventBusILPostProcessor` 兜底，避免 `[EventBusSubscriber]` 自动注册失效。
+- `GetEventSubscribers` / `GetAllSubscribersSnapshot` / `EventBase.GetSubscribers` 返回内部快照的拷贝，外部修改不再影响派发顺序。
+- `SetPhase` / `IsCanceled` / `Result` 的校验异常现在携带具体错误消息。
+- ILPP 的诊断列表与程序集解析器改为调用内局部状态，消除共享实例并发隐患。
+
+## [1.2.0] - 2026-05-18
+
+### Changed
+
+- `MonoBehaviour` 自动注册/反注册的 IL 织入已并入共享 `ShrinkShared.CodeGen` 管线；当前工作区同时保留 `ShrinkEventBus` 本地 `CodeGen/` 作为可选兜底，以兼容纯 `ShrinkEventBus.Runtime` 引用程序集。
+- 保留现有 `[EventBusSubscriber]` 用法与自动生命周期行为，不要求业务层改写订阅代码。
+
+## [1.1.6] - 2026-05-04
+
+### Changed
+
+- 运行时总线升级为“默认静态门面 + 可实例化 `IShrinkEventBus`/Builder”双层结构，支持异常策略、事件类型校验、按 phase 分发。
+- 手动注册能力从纯 delegate 扩展为 `object / Type / MethodInfo` 三类入口，并在注册阶段严格校验签名、静态/实例模式和事件参数类型。
+- `ListenerList` 改为按 phase 分桶 + 快照缓存模型，并支持父事件监听子事件。
+- 事件查看器不再反射私有字典，改走公开快照接口。
+- `EventBusBenchmark` 扩展为覆盖实例 bus、扫描注册、继承监听、phase 分发、对象池与取消事件跳过等关键场景。
+
+## [1.1.5] - 2026-04-07
+
+### Changed
+
+- 修正 `PrepareForDispatch()`，现在只重置派发期状态，不再误清业务载荷。
+- 修正同步 `TriggerEvent(...)` 遇到异步 handler 时的行为，改为向异步处理器分发脱离原对象的事件快照，避免直接复用原事件对象。
+- `OnEventTriggered` 与编辑器追踪钩子改为在派发完成后触发，同时覆盖无监听者事件。
+- `ShrinkNetworkEventBusBridge` 的异步转发改为先克隆事件，降低桥接层状态污染风险。
+- 事件查看器的实时日志改为快照模型，支持关键词过滤、按“有监听者 / 无监听者”筛选、同类事件折叠聚合显示。
+- 编辑器菜单迁移到 `ShrinkSDK/事件总线/事件查看器`。
+- README 同步更新新的调试入口与同步/异步派发语义说明。
diff --git a/Assets/Modules/ShrinkEventBus/CHANGELOG.md.meta b/Assets/Modules/ShrinkEventBus/CHANGELOG.md.meta
new file mode 100644
index 0000000..1467115
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9b2928da4a2426743bd762f5ebb9c232
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen.meta b/Assets/Modules/ShrinkEventBus/CodeGen.meta
new file mode 100644
index 0000000..f041337
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c2bfff1573c10da47ae73a47b8841279
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor.meta b/Assets/Modules/ShrinkEventBus/CodeGen/Editor.meta
new file mode 100644
index 0000000..cada1a3
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c297548ebc9165f448111a35488d368e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs
new file mode 100644
index 0000000..7881503
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs
@@ -0,0 +1,375 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Mono.Cecil;
+using Mono.Cecil.Cil;
+using Mono.Cecil.Rocks;
+using Mono.Cecil.Pdb;
+using Unity.CompilationPipeline.Common.Diagnostics;
+using Unity.CompilationPipeline.Common.ILPostProcessing;
+
+namespace ShrinkEventBus.CodeGen
+{
+    public sealed class EventBusILPostProcessor : ILPostProcessor
+    {
+        private const string RuntimeAssemblyName = "ShrinkEventBus.Runtime";
+        private static readonly string[] SharedCoverageAssemblyNames =
+        {
+            "ShrinkCommand.Runtime",
+            "ShrinkNetwork.Runtime",
+            "ShrinkApp.Core.Runtime"
+        };
+
+        public override ILPostProcessor GetInstance() => this;
+
+        public override bool WillProcess(ICompiledAssembly compiledAssembly)
+        {
+            if (!ReferencesAssembly(compiledAssembly, RuntimeAssemblyName))
+                return false;
+
+            if (ShouldDeferToSharedCodeGen(compiledAssembly))
+                return false;
+
+            return true;
+        }
+
+        public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
+        {
+            var diagnostics = new List<DiagnosticMessage>();
+            if (!WillProcess(compiledAssembly))
+                return new ILPostProcessResult(compiledAssembly.InMemoryAssembly, diagnostics);
+
+            var assemblyDefinition = AssemblyDefinitionFor(compiledAssembly);
+            var module = assemblyDefinition.MainModule;
+
+            try
+            {
+                var subscriberType = FindType(module, "ShrinkEventBus.EventBusSubscriberAttribute", RuntimeAssemblyName);
+                var subscribeAttributeType = FindType(module, "ShrinkEventBus.EventSubscribeAttribute", RuntimeAssemblyName);
+                var eventBusType = FindType(module, "ShrinkEventBus.EventBus", RuntimeAssemblyName);
+                var staticRegistryCtor = FindTypeArrayConstructor(
+                    module,
+                    "ShrinkEventBus.EventBusStaticRegistryAttribute",
+                    RuntimeAssemblyName);
+                if (subscriberType == null || subscribeAttributeType == null || eventBusType == null)
+                    return GetResult(assemblyDefinition, diagnostics);
+
+                var eventBusTypeDef = eventBusType.Resolve();
+                var autoRegisterMethod = eventBusTypeDef?.Methods.FirstOrDefault(method =>
+                    method.Name == "AutoRegister" &&
+                    method.IsStatic &&
+                    method.Parameters.Count == 1);
+                var unregisterMethod = eventBusTypeDef?.Methods.FirstOrDefault(method =>
+                    method.Name == "UnregisterInstance" &&
+                    method.IsStatic &&
+                    method.Parameters.Count == 1);
+                if (autoRegisterMethod == null || unregisterMethod == null)
+                    return GetResult(assemblyDefinition, diagnostics);
+
+                var autoRegisterMethodRef = module.ImportReference(autoRegisterMethod);
+                var unregisterMethodRef = module.ImportReference(unregisterMethod);
+
+                var subscriberTypes = module.Types
+                    .Where(type => HasAttribute(type, subscriberType))
+                    .Where(InheritsFromMonoBehaviour)
+                    .Where(type => HasInstanceSubscribeMethod(type, subscribeAttributeType))
+                    .ToArray();
+
+                foreach (var type in subscriberTypes)
+                {
+                    InjectAutoRegister(type, module, autoRegisterMethodRef);
+                    InjectAutoUnregister(type, module, unregisterMethodRef);
+                }
+
+                if (staticRegistryCtor != null)
+                {
+                    var staticSubscriberTypes = module.Types
+                        .Where(type => HasAttribute(type, subscriberType))
+                        .Where(type => type.Methods.Any(method =>
+                            method.IsStatic && HasAttribute(method, subscribeAttributeType)))
+                        .Select(type => module.ImportReference(type))
+                        .ToArray();
+                    if (staticSubscriberTypes.Length > 0)
+                        AddAssemblyTypeArrayAttribute(module, staticRegistryCtor, staticSubscriberTypes);
+                }
+            }
+            catch (Exception ex)
+            {
+                diagnostics.Add(new DiagnosticMessage
+                {
+                    DiagnosticType = DiagnosticType.Error,
+                    MessageData = $"[ShrinkEventBus.CodeGen] {ex.Message}"
+                });
+            }
+
+            return GetResult(assemblyDefinition, diagnostics);
+        }
+
+        private static bool ShouldDeferToSharedCodeGen(ICompiledAssembly compiledAssembly)
+        {
+            if (!IsSharedCodeGenAvailable())
+                return false;
+
+            return SharedCoverageAssemblyNames.Any(name => ReferencesAssembly(compiledAssembly, name));
+        }
+
+        private static bool IsSharedCodeGenAvailable()
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (string.Equals(assembly.GetName().Name, "Unity.ShrinkShared.CodeGen", StringComparison.Ordinal))
+                    return true;
+            }
+
+            return Type.GetType("ShrinkShared.CodeGen.ShrinkRegistryILPostProcessor, Unity.ShrinkShared.CodeGen", false) != null;
+        }
+
+        private static bool ReferencesAssembly(ICompiledAssembly compiledAssembly, string assemblyName)
+        {
+            return compiledAssembly.References.Any(reference =>
+                string.Equals(Path.GetFileNameWithoutExtension(reference), assemblyName, StringComparison.Ordinal));
+        }
+
+        private static bool HasAttribute(ICustomAttributeProvider provider, TypeReference expectedAttributeType)
+        {
+            return provider.CustomAttributes.Any(attribute => attribute.AttributeType.FullName == expectedAttributeType.FullName);
+        }
+
+        private static bool HasInstanceSubscribeMethod(TypeDefinition type, TypeReference subscribeAttributeType)
+        {
+            var current = type;
+            while (current != null && current.Name != "MonoBehaviour")
+            {
+                if (current.Methods.Any(method => !method.IsStatic && HasAttribute(method, subscribeAttributeType)))
+                    return true;
+
+                var baseTypeRef = current.BaseType;
+                if (baseTypeRef == null)
+                    return false;
+
+                TypeDefinition? resolvedBase;
+                try
+                {
+                    resolvedBase = baseTypeRef.Resolve();
+                }
+                catch
+                {
+                    return true;
+                }
+
+                if (resolvedBase == null)
+                    return true;
+
+                current = resolvedBase;
+            }
+
+            return false;
+        }
+
+        private static bool InheritsFromMonoBehaviour(TypeDefinition type)
+        {
+            var current = type.BaseType;
+            while (current != null)
+            {
+                if (current.Name == "MonoBehaviour")
+                    return true;
+
+                try
+                {
+                    current = current.Resolve()?.BaseType;
+                }
+                catch
+                {
+                    break;
+                }
+            }
+
+            return false;
+        }
+
+        private static void InjectAutoRegister(TypeDefinition type, ModuleDefinition module, MethodReference autoRegisterMethodRef)
+        {
+            var awake = type.Methods.FirstOrDefault(method => method.Name == "Awake" && !method.IsStatic);
+            if (awake == null)
+            {
+                var baseAwakeRef = FindBaseMethodReference(type, "Awake", module);
+                if (baseAwakeRef != null)
+                {
+                    awake = new MethodDefinition("Awake",
+                        MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual,
+                        module.TypeSystem.Void);
+                    var il = awake.Body.GetILProcessor();
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Call, baseAwakeRef);
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Call, autoRegisterMethodRef);
+                    il.Emit(OpCodes.Ret);
+                    type.Methods.Add(awake);
+                    return;
+                }
+
+                awake = new MethodDefinition("Awake",
+                    MethodAttributes.Private | MethodAttributes.HideBySig,
+                    module.TypeSystem.Void);
+                var retIl = awake.Body.GetILProcessor();
+                retIl.Emit(OpCodes.Ret);
+                type.Methods.Add(awake);
+            }
+
+            var processor = awake.Body.GetILProcessor();
+            var instructions = new List<Instruction>
+            {
+                processor.Create(OpCodes.Ldarg_0),
+                processor.Create(OpCodes.Call, autoRegisterMethodRef),
+                processor.Create(OpCodes.Nop)
+            };
+            instructions.Reverse();
+            instructions.ForEach(instruction => processor.Body.Instructions.Insert(0, instruction));
+        }
+
+        private static void InjectAutoUnregister(TypeDefinition type, ModuleDefinition module, MethodReference unregisterMethodRef)
+        {
+            var onDestroy = type.Methods.FirstOrDefault(method => method.Name == "OnDestroy" && !method.IsStatic);
+            if (onDestroy == null)
+            {
+                var baseOnDestroyRef = FindBaseMethodReference(type, "OnDestroy", module);
+                if (baseOnDestroyRef != null)
+                {
+                    onDestroy = new MethodDefinition("OnDestroy",
+                        MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.Virtual,
+                        module.TypeSystem.Void);
+                    var il = onDestroy.Body.GetILProcessor();
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Call, unregisterMethodRef);
+                    il.Emit(OpCodes.Ldarg_0);
+                    il.Emit(OpCodes.Call, baseOnDestroyRef);
+                    il.Emit(OpCodes.Ret);
+                    type.Methods.Add(onDestroy);
+                    return;
+                }
+
+                onDestroy = new MethodDefinition("OnDestroy",
+                    MethodAttributes.Private | MethodAttributes.HideBySig,
+                    module.TypeSystem.Void);
+                var retIl = onDestroy.Body.GetILProcessor();
+                retIl.Emit(OpCodes.Ret);
+                type.Methods.Add(onDestroy);
+            }
+
+            var processor = onDestroy.Body.GetILProcessor();
+            var instructions = new List<Instruction>
+            {
+                processor.Create(OpCodes.Ldarg_0),
+                processor.Create(OpCodes.Call, unregisterMethodRef),
+                processor.Create(OpCodes.Nop)
+            };
+            instructions.Reverse();
+            instructions.ForEach(instruction => processor.Body.Instructions.Insert(0, instruction));
+        }
+
+        private static MethodReference? FindBaseMethodReference(TypeDefinition type, string methodName, ModuleDefinition module)
+        {
+            try
+            {
+                var baseTypeRef = type.BaseType;
+                while (baseTypeRef != null)
+                {
+                    var baseTypeDef = baseTypeRef.Resolve();
+                    if (baseTypeDef == null)
+                        break;
+
+                    var method = baseTypeDef.Methods.FirstOrDefault(candidate =>
+                        candidate.Name == methodName && !candidate.IsStatic && candidate.IsVirtual);
+                    if (method != null)
+                    {
+                        if (baseTypeRef is GenericInstanceType genericInstance)
+                        {
+                            var methodRef = new MethodReference(
+                                method.Name,
+                                module.ImportReference(method.ReturnType),
+                                module.ImportReference(genericInstance))
+                            {
+                                HasThis = method.HasThis,
+                                ExplicitThis = method.ExplicitThis,
+                                CallingConvention = method.CallingConvention
+                            };
+                            return methodRef;
+                        }
+
+                        return module.ImportReference(method);
+                    }
+
+                    baseTypeRef = baseTypeDef.BaseType;
+                }
+            }
+            catch
+            {
+            }
+
+            return null;
+        }
+
+        private static TypeReference? FindType(ModuleDefinition module, string fullName, string assemblyName)
+        {
+            var resolved = Type.GetType($"{fullName}, {assemblyName}", false);
+            return resolved == null ? null : module.ImportReference(resolved);
+        }
+
+        private static MethodReference? FindTypeArrayConstructor(ModuleDefinition module, string fullName, string assemblyName)
+        {
+            var typeRef = FindType(module, fullName, assemblyName);
+            var typeDef = typeRef?.Resolve();
+            var ctor = typeDef?.Methods.FirstOrDefault(method =>
+                method.IsConstructor &&
+                method.Parameters.Count == 1 &&
+                method.Parameters[0].ParameterType.IsArray &&
+                method.Parameters[0].ParameterType.GetElementType().FullName == module.ImportReference(typeof(Type)).FullName);
+            return ctor == null ? null : module.ImportReference(ctor);
+        }
+
+        private static void AddAssemblyTypeArrayAttribute(ModuleDefinition module, MethodReference ctor, TypeReference[] types)
+        {
+            var attribute = new CustomAttribute(ctor);
+            var typeTypeRef = module.ImportReference(typeof(Type));
+            attribute.ConstructorArguments.Add(new CustomAttributeArgument(
+                module.ImportReference(typeof(Type[])),
+                types.Select(type => new CustomAttributeArgument(typeTypeRef, type)).ToArray()));
+            module.Assembly.CustomAttributes.Add(attribute);
+        }
+
+        private static AssemblyDefinition AssemblyDefinitionFor(ICompiledAssembly compiledAssembly)
+        {
+            var assemblyResolver = new PostProcessorAssemblyResolver(compiledAssembly);
+            var readerParameters = new ReaderParameters
+            {
+                SymbolStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PdbData.ToArray()),
+                SymbolReaderProvider = new PdbReaderProvider(),
+                AssemblyResolver = assemblyResolver,
+                ReflectionImporterProvider = new PostProcessorReflectionImporterProvider(),
+                ReadingMode = ReadingMode.Immediate
+            };
+
+            var assemblyDefinition = AssemblyDefinition.ReadAssembly(
+                new MemoryStream(compiledAssembly.InMemoryAssembly.PeData.ToArray()),
+                readerParameters);
+            assemblyResolver.AddAssemblyDefinitionBeingOperatedOn(assemblyDefinition);
+            return assemblyDefinition;
+        }
+
+        private static ILPostProcessResult GetResult(AssemblyDefinition assemblyDefinition, List<DiagnosticMessage> diagnostics)
+        {
+            var pe = new MemoryStream();
+            var pdb = new MemoryStream();
+            assemblyDefinition.Write(pe, new WriterParameters
+            {
+                SymbolWriterProvider = new PdbWriterProvider(),
+                SymbolStream = pdb,
+                WriteSymbols = true
+            });
+            return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), diagnostics);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs.meta b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs.meta
new file mode 100644
index 0000000..6f56fd9
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f611b284dae01a46bc990b87b8bca90
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs
new file mode 100644
index 0000000..38c7606
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs
@@ -0,0 +1,107 @@
+#nullable enable
+
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using Mono.Cecil;
+using Unity.CompilationPipeline.Common.ILPostProcessing;
+
+namespace ShrinkEventBus.CodeGen
+{
+    internal sealed class PostProcessorAssemblyResolver : IAssemblyResolver
+    {
+        private readonly string[] _references;
+        private readonly Dictionary<string, AssemblyDefinition> _cache = new();
+        private AssemblyDefinition? _self;
+
+        public PostProcessorAssemblyResolver(ICompiledAssembly compiledAssembly)
+        {
+            _references = compiledAssembly.References;
+        }
+
+        public void AddAssemblyDefinitionBeingOperatedOn(AssemblyDefinition assemblyDefinition)
+        {
+            _self = assemblyDefinition;
+        }
+
+        public AssemblyDefinition? Resolve(AssemblyNameReference name)
+        {
+            return Resolve(name, new ReaderParameters(ReadingMode.Deferred));
+        }
+
+        public AssemblyDefinition? Resolve(AssemblyNameReference name, ReaderParameters parameters)
+        {
+            lock (_cache)
+            {
+                if (name.Name == _self?.Name.Name)
+                    return _self;
+
+                var path = FindPath(name);
+                if (path == null)
+                    return null;
+
+                var key = $"{path}{File.GetLastWriteTime(path)}";
+                if (_cache.TryGetValue(key, out var cached))
+                    return cached;
+
+                parameters.AssemblyResolver = this;
+                var ms = ReadFileWithRetry(path);
+
+                var pdbPath = Path.ChangeExtension(path, ".pdb");
+                if (File.Exists(pdbPath))
+                    parameters.SymbolStream = ReadFileWithRetry(pdbPath);
+
+                var assembly = AssemblyDefinition.ReadAssembly(ms, parameters);
+                _cache[key] = assembly;
+                return assembly;
+            }
+        }
+
+        private string? FindPath(AssemblyNameReference name)
+        {
+            foreach (var reference in _references)
+            {
+                if (Path.GetFileNameWithoutExtension(reference) == name.Name)
+                    return reference;
+            }
+
+            var dirs = new HashSet<string>();
+            foreach (var reference in _references)
+            {
+                var dir = Path.GetDirectoryName(reference);
+                if (dir != null)
+                    dirs.Add(dir);
+            }
+
+            foreach (var dir in dirs)
+            {
+                var candidate = Path.Combine(dir, $"{name.Name}.dll");
+                if (File.Exists(candidate))
+                    return candidate;
+            }
+
+            return null;
+        }
+
+        private static MemoryStream ReadFileWithRetry(string path, int retries = 5)
+        {
+            for (var i = 0; i < retries; i++)
+            {
+                try
+                {
+                    return new MemoryStream(File.ReadAllBytes(path));
+                }
+                catch (IOException) when (i < retries - 1)
+                {
+                    Thread.Sleep(100);
+                }
+            }
+
+            throw new IOException($"[ShrinkEventBus.CodeGen] 无法读取文件: {path}");
+        }
+
+        public void Dispose()
+        {
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs.meta b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs.meta
new file mode 100644
index 0000000..5aedb8f
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aeea50f82bab4ee2833c671d801c95e3
+timeCreated: 1772908894
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs
new file mode 100644
index 0000000..957a46d
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs
@@ -0,0 +1,37 @@
+#nullable enable
+
+using System.Linq;
+using System.Reflection;
+using Mono.Cecil;
+
+namespace ShrinkEventBus.CodeGen
+{
+    internal sealed class PostProcessorReflectionImporter : DefaultReflectionImporter
+    {
+        private const string CoreLibName = "System.Private.CoreLib";
+        private readonly AssemblyNameReference? _corlib;
+
+        public PostProcessorReflectionImporter(ModuleDefinition module)
+            : base(module)
+        {
+            _corlib = module.AssemblyReferences.FirstOrDefault(
+                assembly => assembly.Name is "mscorlib" or "netstandard");
+        }
+
+        public override AssemblyNameReference ImportReference(AssemblyName reference)
+        {
+            if (_corlib != null && reference.Name == CoreLibName)
+                return _corlib;
+
+            return base.ImportReference(reference);
+        }
+    }
+
+    internal sealed class PostProcessorReflectionImporterProvider : IReflectionImporterProvider
+    {
+        public IReflectionImporter GetReflectionImporter(ModuleDefinition module)
+        {
+            return new PostProcessorReflectionImporter(module);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs.meta b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs.meta
new file mode 100644
index 0000000..70b8deb
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0a6c2401798b42f0bbcde72796d2fa9c
+timeCreated: 1772908906
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef
new file mode 100644
index 0000000..ffe61e9
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef
@@ -0,0 +1,23 @@
+{
+    "name": "Unity.ShrinkEventBus.CodeGen",
+    "rootNamespace": "ShrinkEventBus.CodeGen",
+    "references": [
+        "ShrinkEventBus.Runtime"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "Mono.Cecil.dll",
+        "Mono.Cecil.Mdb.dll",
+        "Mono.Cecil.Pdb.dll",
+        "Mono.Cecil.Rocks.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef.meta b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef.meta
new file mode 100644
index 0000000..7fd1430
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 91161d4c2ae3ae74c9184ba33d9aa52e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Editor.meta b/Assets/Modules/ShrinkEventBus/Editor.meta
new file mode 100644
index 0000000..454aa37
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Editor.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8bf98940dc144bd2bffd55ce21295bbd
+timeCreated: 1772878399
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs b/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs
new file mode 100644
index 0000000..ea0d260
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs
@@ -0,0 +1,793 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace ShrinkEventBus.Editor
+{
+    public class EventBusViewerWindow : EditorWindow
+    {
+        private enum LiveLogFilterMode
+        {
+            All,
+            HasListeners,
+            NoListeners
+        }
+
+        private sealed class HandlerDisplayData
+        {
+            public object TargetInstance { get; set; }
+            public MonoBehaviour PingTarget { get; set; }
+            public string TargetName { get; set; }
+            public string MethodName { get; set; }
+            public object Priority { get; set; }
+            public string ExecType { get; set; }
+            public bool IsStaticHandler { get; set; }
+        }
+
+        private sealed class EventLogRecord
+        {
+            public DateTime Timestamp { get; set; }
+            public string TimestampText { get; set; }
+            public string EventName { get; set; }
+            public string SenderInfo { get; set; }
+            public bool HasListeners { get; set; }
+            public bool IsCancelable { get; set; }
+            public bool IsCanceled { get; set; }
+            public string Result { get; set; }
+            public string Phase { get; set; }
+            public List<string> Parameters { get; set; }
+            public List<HandlerDisplayData> Handlers { get; set; }
+            public string MatchText { get; set; }
+        }
+
+        private sealed class EventLogGroup
+        {
+            public string EventName { get; set; }
+            public List<EventLogRecord> Records { get; } = new();
+            public EventLogRecord LatestRecord => Records[0];
+        }
+
+        private ScrollView _subscribersScrollView;
+        private ScrollView _liveTrackerScrollView;
+        private VisualElement _subscribersTab;
+        private VisualElement _liveTrackerTab;
+        private Label _instanceCountLabel;
+        private Label _liveLogStatsLabel;
+        private string _searchString = "";
+        private string _liveLogSearchString = "";
+        private LiveLogFilterMode _liveLogFilterMode = LiveLogFilterMode.All;
+        private bool _collapseSameEventType = true;
+        private const int MaxLogCount = 100;
+        private const double LiveTrackerRefreshIntervalSeconds = 0.1d;
+        private readonly List<EventLogRecord> _logRecords = new();
+        private bool _isLiveTrackerDirty;
+        private double _nextLiveTrackerRefreshTime;
+
+        [MenuItem("ShrinkSDK/事件总线/事件查看器")]
+        public static void ShowWindow()
+        {
+            var window = GetWindow<EventBusViewerWindow>("EventBus 控制台");
+            window.minSize = new Vector2(500, 600);
+            window.Show();
+        }
+
+        private void OnEnable()
+        {
+            EventBus.OnEventTriggeredForEditor += RecordEventLog;
+            EditorApplication.update += OnEditorUpdate;
+        }
+
+        private void OnDisable()
+        {
+            EventBus.OnEventTriggeredForEditor -= RecordEventLog;
+            EditorApplication.update -= OnEditorUpdate;
+        }
+
+        private void CreateGUI()
+        {
+            var root = rootVisualElement;
+            root.style.flexDirection = FlexDirection.Column;
+            root.Add(CreateHeader());
+            root.Add(CreateTabBar());
+
+            var contentContainer = new VisualElement { style = { flexGrow = 1 } };
+            _subscribersTab = CreateSubscribersTab();
+            _liveTrackerTab = CreateLiveTrackerTab();
+            _subscribersTab.style.display = DisplayStyle.Flex;
+            _liveTrackerTab.style.display = DisplayStyle.None;
+
+            contentContainer.Add(_subscribersTab);
+            contentContainer.Add(_liveTrackerTab);
+            root.Add(contentContainer);
+
+            RefreshSubscribersView();
+
+            root.schedule.Execute(() =>
+            {
+                _instanceCountLabel.text = Application.isPlaying
+                    ? $"活跃实例数: {EventBus.GetRegisteredInstanceCount()}"
+                    : "游戏未运行";
+            }).Every(500);
+        }
+
+        private VisualElement CreateHeader()
+        {
+            var header = new VisualElement
+            {
+                style =
+                {
+                    paddingTop = 10, paddingBottom = 10, paddingLeft = 10, paddingRight = 10,
+                    backgroundColor = new StyleColor(new Color(0.15f, 0.15f, 0.15f, 1f)), borderBottomWidth = 1,
+                    borderBottomColor = new StyleColor(Color.black)
+                }
+            };
+            header.Add(new Label("Shrink Event Bus 控制台")
+                { style = { fontSize = 16, unityFontStyleAndWeight = FontStyle.Bold } });
+            var debugToggle = new Toggle("启用 Debug 调试记录 (追踪实时事件)")
+                { value = EventBus.EnableDebugRecord, style = { marginTop = 5 } };
+            debugToggle.RegisterValueChangedCallback(evt => EventBus.EnableDebugRecord = evt.newValue);
+            header.Add(debugToggle);
+            var infoRow = new VisualElement
+                { style = { flexDirection = FlexDirection.Row, marginTop = 5, justifyContent = Justify.SpaceBetween } };
+            _instanceCountLabel = new Label("活跃实例数: 0") { style = { color = new StyleColor(Color.cyan) } };
+            infoRow.Add(_instanceCountLabel);
+            header.Add(infoRow);
+            return header;
+        }
+
+        private VisualElement CreateTabBar()
+        {
+            var toolbar = new Toolbar();
+            toolbar.Add(new ToolbarButton(() => SwitchTab(0))
+                { text = "订阅者全览", style = { flexGrow = 1, unityTextAlign = TextAnchor.MiddleCenter } });
+            toolbar.Add(new ToolbarButton(() => SwitchTab(1))
+                { text = "实时触发日志", style = { flexGrow = 1, unityTextAlign = TextAnchor.MiddleCenter } });
+            return toolbar;
+        }
+
+        private VisualElement CreateSubscribersTab()
+        {
+            var container = new VisualElement { style = { flexGrow = 1 } };
+            var toolbar = new Toolbar();
+            var searchField = new ToolbarSearchField { style = { flexGrow = 1 } };
+            searchField.RegisterValueChangedCallback(evt =>
+            {
+                _searchString = evt.newValue;
+                RefreshSubscribersView();
+            });
+            toolbar.Add(searchField);
+            toolbar.Add(new ToolbarButton(RefreshSubscribersView) { text = "刷新视图" });
+            container.Add(toolbar);
+            _subscribersScrollView = new ScrollView
+                { style = { flexGrow = 1, paddingLeft = 5, paddingRight = 5, paddingTop = 5 } };
+            container.Add(_subscribersScrollView);
+            return container;
+        }
+
+        private VisualElement CreateLiveTrackerTab()
+        {
+            var container = new VisualElement { style = { flexGrow = 1 } };
+            var toolbar = new Toolbar();
+            var searchField = new ToolbarSearchField { style = { flexGrow = 1 } };
+            searchField.RegisterValueChangedCallback(evt =>
+            {
+                _liveLogSearchString = evt.newValue ?? string.Empty;
+                RequestLiveTrackerRefresh(true);
+            });
+            toolbar.Add(searchField);
+
+            var filterMenu = new ToolbarMenu { text = "全部事件" };
+            filterMenu.menu.AppendAction("全部事件", _ =>
+            {
+                _liveLogFilterMode = LiveLogFilterMode.All;
+                filterMenu.text = "全部事件";
+                RequestLiveTrackerRefresh(true);
+            });
+            filterMenu.menu.AppendAction("仅有监听者", _ =>
+            {
+                _liveLogFilterMode = LiveLogFilterMode.HasListeners;
+                filterMenu.text = "仅有监听者";
+                RequestLiveTrackerRefresh(true);
+            });
+            filterMenu.menu.AppendAction("仅无监听者", _ =>
+            {
+                _liveLogFilterMode = LiveLogFilterMode.NoListeners;
+                filterMenu.text = "仅无监听者";
+                RequestLiveTrackerRefresh(true);
+            });
+            toolbar.Add(filterMenu);
+
+            var collapseToggle = new ToolbarToggle
+            {
+                text = "折叠同类事件",
+                value = _collapseSameEventType
+            };
+            collapseToggle.RegisterValueChangedCallback(evt =>
+            {
+                _collapseSameEventType = evt.newValue;
+                RequestLiveTrackerRefresh(true);
+            });
+            toolbar.Add(collapseToggle);
+            toolbar.Add(new ToolbarButton(ClearLogs) { text = "清空日志" });
+            container.Add(toolbar);
+
+            _liveLogStatsLabel = new Label
+            {
+                style =
+                {
+                    marginLeft = 8,
+                    marginRight = 8,
+                    marginTop = 4,
+                    marginBottom = 4,
+                    color = new StyleColor(Color.gray)
+                }
+            };
+            container.Add(_liveLogStatsLabel);
+
+            _liveTrackerScrollView = new ScrollView { style = { flexGrow = 1, paddingLeft = 5, paddingRight = 5 } };
+            container.Add(_liveTrackerScrollView);
+            RequestLiveTrackerRefresh(true);
+            return container;
+        }
+
+        private void SwitchTab(int index)
+        {
+            _subscribersTab.style.display = index == 0 ? DisplayStyle.Flex : DisplayStyle.None;
+            _liveTrackerTab.style.display = index == 1 ? DisplayStyle.Flex : DisplayStyle.None;
+            if (index == 0)
+            {
+                RefreshSubscribersView();
+                return;
+            }
+            RequestLiveTrackerRefresh(true);
+        }
+
+        private void OnEditorUpdate()
+        {
+            if (!_isLiveTrackerDirty) return;
+            if (_liveTrackerTab == null || _liveTrackerTab.style.display != DisplayStyle.Flex) return;
+            if (EditorApplication.timeSinceStartup < _nextLiveTrackerRefreshTime) return;
+            RefreshLiveTrackerView();
+        }
+
+        private void RequestLiveTrackerRefresh(bool immediate = false)
+        {
+            _isLiveTrackerDirty = true;
+            if (immediate)
+            {
+                _nextLiveTrackerRefreshTime = EditorApplication.timeSinceStartup;
+                if (_liveTrackerTab != null && _liveTrackerTab.style.display == DisplayStyle.Flex)
+                    RefreshLiveTrackerView();
+            }
+        }
+
+        private void RefreshSubscribersView()
+        {
+            _subscribersScrollView.Clear();
+            if (!Application.isPlaying)
+            {
+                _subscribersScrollView.Add(new HelpBox("请先运行游戏，系统初始化后即可查看内存中的事件树。", HelpBoxMessageType.Info));
+                return;
+            }
+
+            var snapshots = EventBus.GetAllSubscribersSnapshot();
+            foreach (var entry in snapshots)
+            {
+                var eventType = entry.Key;
+                if (!string.IsNullOrEmpty(_searchString) &&
+                    !eventType.Name.ToLower().Contains(_searchString.ToLower())) continue;
+
+                var handlers = entry.Value;
+
+                var foldout = new Foldout
+                {
+                    text = $"{eventType.Name}  (挂载数: {handlers.Length})",
+                    style =
+                    {
+                        backgroundColor = new StyleColor(new Color(0.2f, 0.2f, 0.2f, 0.5f)),
+                        marginTop = 2,
+                        paddingBottom = 2,
+                        borderBottomWidth = 1,
+                        borderBottomColor = new StyleColor(new Color(0.1f, 0.1f, 0.1f))
+                    }
+                };
+
+                foreach (var h in handlers) foldout.Add(CreateHandlerRow(h));
+                _subscribersScrollView.Add(foldout);
+            }
+        }
+
+        private void RecordEventLog(EventBase evt, string eventName, string senderInfo, EventHandlerInfo[] handlers)
+        {
+            if (!EventBus.EnableDebugRecord) return;
+            _logRecords.Add(CreateEventLogRecord(evt, eventName, senderInfo, handlers));
+            if (_logRecords.Count > MaxLogCount)
+                _logRecords.RemoveAt(0);
+            RequestLiveTrackerRefresh();
+        }
+
+        private EventLogRecord CreateEventLogRecord(EventBase evt, string eventName, string senderInfo,
+            EventHandlerInfo[] handlers)
+        {
+            var timestamp = DateTime.Now;
+            var hasListeners = handlers.Length > 0;
+            var paramsList = DumpEventParams(evt);
+            var handlerRows = new List<HandlerDisplayData>(handlers.Length);
+            foreach (var handler in handlers)
+                handlerRows.Add(ExtractHandlerDisplayData(handler));
+
+            var isCancelable = (GetMemberValue(evt, "IsCancelable") as bool?) ?? false;
+            var isCanceled = (GetMemberValue(evt, "IsCanceled") as bool?) ?? false;
+            var resultStr = GetMemberValue(evt, "Result")?.ToString() ?? "DEFAULT";
+            var phaseStr = GetMemberValue(evt, "Phase")?.ToString() ?? "NORMAL";
+
+            return new EventLogRecord
+            {
+                Timestamp = timestamp,
+                TimestampText = timestamp.ToString("HH:mm:ss.fff"),
+                EventName = eventName,
+                SenderInfo = senderInfo,
+                HasListeners = hasListeners,
+                IsCancelable = isCancelable,
+                IsCanceled = isCanceled,
+                Result = resultStr,
+                Phase = phaseStr,
+                Parameters = paramsList,
+                Handlers = handlerRows,
+                MatchText = BuildLogMatchText(eventName, senderInfo, paramsList)
+            };
+        }
+
+        private string BuildLogMatchText(string eventName, string senderInfo, List<string> paramsList)
+        {
+            if (paramsList.Count == 0)
+                return $"{eventName}\n{senderInfo}";
+            return $"{eventName}\n{senderInfo}\n{string.Join("\n", paramsList)}";
+        }
+
+        private void RefreshLiveTrackerView()
+        {
+            if (_liveTrackerScrollView == null) return;
+            _isLiveTrackerDirty = false;
+            _nextLiveTrackerRefreshTime = EditorApplication.timeSinceStartup + LiveTrackerRefreshIntervalSeconds;
+
+            _liveTrackerScrollView.Clear();
+
+            var filteredRecords = new List<EventLogRecord>(_logRecords.Count);
+            for (var i = _logRecords.Count - 1; i >= 0; i--)
+            {
+                var record = _logRecords[i];
+                if (MatchesLiveLogFilter(record))
+                    filteredRecords.Add(record);
+            }
+
+            if (_liveLogStatsLabel != null)
+            {
+                _liveLogStatsLabel.text = _collapseSameEventType
+                    ? $"显示 {filteredRecords.Count} / {_logRecords.Count} 条，按事件类型折叠"
+                    : $"显示 {filteredRecords.Count} / {_logRecords.Count} 条";
+            }
+
+            if (filteredRecords.Count == 0)
+            {
+                _liveTrackerScrollView.Add(new HelpBox("当前没有符合条件的实时事件日志。", HelpBoxMessageType.Info));
+                return;
+            }
+
+            if (_collapseSameEventType)
+            {
+                foreach (var group in BuildCollapsedGroups(filteredRecords))
+                    _liveTrackerScrollView.Add(CreateCollapsedGroupElement(group));
+                return;
+            }
+
+            foreach (var record in filteredRecords)
+                _liveTrackerScrollView.Add(CreateLogEntryElement(record));
+        }
+
+        private bool MatchesLiveLogFilter(EventLogRecord record)
+        {
+            switch (_liveLogFilterMode)
+            {
+                case LiveLogFilterMode.HasListeners:
+                    if (!record.HasListeners) return false;
+                    break;
+                case LiveLogFilterMode.NoListeners:
+                    if (record.HasListeners) return false;
+                    break;
+            }
+
+            if (string.IsNullOrWhiteSpace(_liveLogSearchString))
+                return true;
+
+            return record.MatchText.IndexOf(_liveLogSearchString.Trim(), StringComparison.OrdinalIgnoreCase) >= 0;
+        }
+
+        private List<EventLogGroup> BuildCollapsedGroups(List<EventLogRecord> records)
+        {
+            var groups = new List<EventLogGroup>();
+            var groupMap = new Dictionary<string, EventLogGroup>(StringComparer.Ordinal);
+
+            foreach (var record in records)
+            {
+                if (!groupMap.TryGetValue(record.EventName, out var group))
+                {
+                    group = new EventLogGroup { EventName = record.EventName };
+                    groupMap[record.EventName] = group;
+                    groups.Add(group);
+                }
+
+                group.Records.Add(record);
+            }
+
+            return groups;
+        }
+
+        private VisualElement CreateCollapsedGroupElement(EventLogGroup group)
+        {
+            var latest = group.LatestRecord;
+            var foldout = new Foldout
+            {
+                text = $"{group.EventName} × {group.Records.Count}  最近: {latest.TimestampText}",
+                value = group.Records.Count == 1,
+                style =
+                {
+                    backgroundColor = new StyleColor(new Color(0.2f, 0.2f, 0.2f, 0.4f)),
+                    marginTop = 2,
+                    paddingBottom = 2,
+                    borderBottomWidth = 1,
+                    borderBottomColor = new StyleColor(new Color(0.1f, 0.1f, 0.1f))
+                }
+            };
+
+            var summary = new Label(
+                $"最近来源: {latest.SenderInfo} | 监听者: {(latest.HasListeners ? latest.Handlers.Count : 0)} | 已取消: {(latest.IsCanceled ? "是" : "否")}")
+            {
+                style =
+                {
+                    marginLeft = 18,
+                    marginBottom = 4,
+                    color = new StyleColor(Color.gray)
+                }
+            };
+            foldout.Add(summary);
+            if (foldout.value)
+                PopulateCollapsedGroupDetails(foldout, group, 1);
+            foldout.RegisterValueChangedCallback(evt =>
+            {
+                if (evt.newValue)
+                {
+                    PopulateCollapsedGroupDetails(foldout, group, 1);
+                    return;
+                }
+                ClearFoldoutChildren(foldout, 1);
+            });
+
+            return foldout;
+        }
+
+        private void PopulateCollapsedGroupDetails(Foldout foldout, EventLogGroup group, int keepChildCount)
+        {
+            if (foldout.childCount > keepChildCount) return;
+            foreach (var record in group.Records)
+            {
+                var row = CreateLogEntryElement(record);
+                row.style.marginLeft = 12;
+                foldout.Add(row);
+            }
+        }
+
+        private void ClearFoldoutChildren(Foldout foldout, int keepChildCount)
+        {
+            while (foldout.childCount > keepChildCount)
+                foldout.RemoveAt(foldout.childCount - 1);
+        }
+
+        private VisualElement CreateLogEntryElement(EventLogRecord record)
+        {
+            var logEntry = new VisualElement
+            {
+                style =
+                {
+                    flexDirection = FlexDirection.Column,
+                    paddingBottom = 4,
+                    paddingTop = 4,
+                    borderBottomWidth = 1,
+                    borderBottomColor = new StyleColor(new Color(0.15f, 0.15f, 0.15f))
+                }
+            };
+
+            var headerRow = new VisualElement
+                { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } };
+            headerRow.Add(new Label(record.TimestampText)
+                { style = { width = 80, color = new StyleColor(Color.gray) } });
+            headerRow.Add(new Label(record.EventName)
+            {
+                style = { color = new StyleColor(new Color(1f, 0.84f, 0f)), unityFontStyleAndWeight = FontStyle.Bold }
+            });
+
+            var senderClassName = GetSenderClassName(record.SenderInfo);
+            var senderLabel = new Label($" [由 {record.SenderInfo} 触发]")
+            {
+                style =
+                {
+                    color = new StyleColor(new Color(0.5f, 0.8f, 1f)),
+                    marginLeft = 5,
+                    unityFontStyleAndWeight = FontStyle.Italic
+                }
+            };
+
+            if (senderClassName != "未知来源" && senderClassName != "EventBus" && senderClassName != "Unknown")
+            {
+                senderLabel.RegisterCallback<MouseEnterEvent>(_ =>
+                    senderLabel.style.color = new StyleColor(Color.cyan));
+                senderLabel.RegisterCallback<MouseLeaveEvent>(_ =>
+                    senderLabel.style.color = new StyleColor(new Color(0.5f, 0.8f, 1f)));
+                senderLabel.RegisterCallback<ClickEvent>(_ => OpenScriptByClassName(senderClassName));
+            }
+
+            headerRow.Add(senderLabel);
+            logEntry.Add(headerRow);
+
+            var statusRow = new VisualElement
+                { style = { flexDirection = FlexDirection.Row, marginLeft = 80, marginTop = 2 } };
+            statusRow.Add(new Label($"可取消: {(record.IsCancelable ? "是" : "否")}")
+                { style = { color = new StyleColor(Color.gray), marginRight = 15 } });
+
+            var canceledLabel = new Label($"已取消: {(record.IsCanceled ? "是" : "否")}")
+                { style = { marginRight = 15 } };
+            canceledLabel.style.color =
+                record.IsCanceled ? new StyleColor(new Color(1f, 0.3f, 0.3f)) : new StyleColor(Color.gray);
+            statusRow.Add(canceledLabel);
+
+            statusRow.Add(new Label($"Result: {record.Result}")
+                { style = { color = new StyleColor(new Color(0.8f, 0.6f, 0.8f)), marginRight = 15 } });
+            statusRow.Add(new Label($"最后阶段: {record.Phase}")
+                { style = { color = new StyleColor(new Color(0.6f, 0.8f, 1f)) } });
+            logEntry.Add(statusRow);
+
+            var paramsContainer = new VisualElement
+                { style = { flexDirection = FlexDirection.Column, marginLeft = 80, marginTop = 2, marginBottom = 2 } };
+            if (record.Parameters.Count == 0)
+            {
+                paramsContainer.Add(new Label("参数: { 无 }")
+                    { style = { color = new StyleColor(new Color(0.5f, 0.5f, 0.5f)) } });
+            }
+            else
+            {
+                paramsContainer.Add(
+                    new Label("携带参数:") { style = { color = new StyleColor(new Color(0.6f, 0.8f, 1f)) } });
+                foreach (var pStr in record.Parameters)
+                    paramsContainer.Add(new Label($"  • {pStr}")
+                        { style = { color = new StyleColor(new Color(0.6f, 0.9f, 0.6f)), marginLeft = 10 } });
+            }
+
+            logEntry.Add(paramsContainer);
+
+            if (record.HasListeners)
+            {
+                foreach (var handler in record.Handlers)
+                    logEntry.Add(CreateHandlerRow(handler, 80));
+            }
+            else
+            {
+                var noHandlerRow = new VisualElement
+                    { style = { flexDirection = FlexDirection.Row, marginLeft = 80, marginTop = 2 } };
+                noHandlerRow.Add(new Label("(无监听者响应)") { style = { color = new StyleColor(Color.gray) } });
+                logEntry.Add(noHandlerRow);
+            }
+
+            return logEntry;
+        }
+
+        private string GetSenderClassName(string senderInfo)
+        {
+            if (string.IsNullOrWhiteSpace(senderInfo))
+                return "未知来源";
+            return senderInfo.Contains(".") ? senderInfo.Split('.')[0] : senderInfo;
+        }
+
+        private VisualElement CreateHandlerRow(object h)
+        {
+            return CreateHandlerRow(ExtractHandlerDisplayData(h), 40);
+        }
+
+        private VisualElement CreateHandlerRow(HandlerDisplayData handlerData, float marginLeft)
+        {
+            var targetInstance = handlerData.TargetInstance;
+            var targetName = handlerData.TargetName;
+            var methodName = handlerData.MethodName;
+            var priority = handlerData.Priority;
+            var execType = handlerData.ExecType;
+
+            var row = new VisualElement
+            {
+                style =
+                {
+                    flexDirection = FlexDirection.Row, marginTop = 2, marginBottom = 2, marginLeft = marginLeft,
+                    alignItems = Align.Center
+                }
+            };
+
+            row.Add(new Label($"[{priority}]") { style = { width = 75, color = new StyleColor(Color.gray) } });
+            row.Add(new Label($"[{execType}]")
+                { style = { width = 50, color = new StyleColor(new Color(0.8f, 0.6f, 0.2f)) } });
+
+            var linkLabel = new Label($"{targetName}.{methodName}()")
+                { style = { color = new StyleColor(new Color(0.3f, 0.6f, 1f)) } };
+            linkLabel.RegisterCallback<MouseEnterEvent>(e => linkLabel.style.color = new StyleColor(Color.cyan));
+            linkLabel.RegisterCallback<MouseLeaveEvent>(e =>
+                linkLabel.style.color = new StyleColor(new Color(0.3f, 0.6f, 1f)));
+            linkLabel.RegisterCallback<ClickEvent>(e => OpenScriptByClassName(targetName));
+            linkLabel.style.flexGrow = 1;
+            row.Add(linkLabel);
+
+            if (handlerData.PingTarget)
+            {
+                var pingBtn = new Button(() =>
+                {
+                    EditorGUIUtility.PingObject(handlerData.PingTarget.gameObject);
+                    Selection.activeGameObject = handlerData.PingTarget.gameObject;
+                }) { text = "Ping", style = { width = 50, height = 18 } };
+                row.Add(pingBtn);
+            }
+            else if (handlerData.IsStaticHandler && methodName != "未知方法")
+                row.Add(new Label("(静态)")
+                {
+                    style = { width = 50, color = new StyleColor(Color.gray), unityTextAlign = TextAnchor.MiddleRight }
+                });
+            else
+                row.Add(new Label("(无对象)")
+                {
+                    style = { width = 50, color = new StyleColor(Color.gray), unityTextAlign = TextAnchor.MiddleRight }
+                });
+
+            return row;
+        }
+
+        private HandlerDisplayData ExtractHandlerDisplayData(object handlerObj)
+        {
+            var priority = GetMemberValue(handlerObj, "Priority") ?? "NORMAL";
+            var debugInfo = GetMemberValue(handlerObj, "DebugInfo") as string ?? "未知方法";
+
+            var execType = "Sync";
+            if (debugInfo.Contains("(UniTask)") || debugInfo.Contains("Async")) execType = "Async";
+            else if (debugInfo.Contains("(Task->UniTask)") || debugInfo.Contains("(Task)")) execType = "Task";
+
+            object targetInstance = null;
+            var targetName = "未知类";
+            var methodName = debugInfo;
+
+            var handlerDelegate = GetMemberValue(handlerObj, "Handler") as Delegate;
+            if (handlerDelegate != null)
+            {
+                targetInstance = handlerDelegate.Target;
+                var methodInfo = handlerDelegate.Method;
+
+                if (targetInstance != null && targetInstance.GetType().Name.Contains("Wrapper"))
+                {
+                    var realDelegate = GetMemberValue(targetInstance, "_originalAction") as Delegate;
+                    if (realDelegate != null)
+                    {
+                        targetInstance = realDelegate.Target;
+                        methodInfo = realDelegate.Method;
+                    }
+                }
+
+                if (methodInfo != null)
+                {
+                    var rawClassName = methodInfo.DeclaringType?.Name ?? "未知类";
+                    if (rawClassName.Contains("<>c")) rawClassName = "匿名闭包类";
+                    targetName = rawClassName;
+                    methodName = methodInfo.Name;
+                }
+            }
+
+            return new HandlerDisplayData
+            {
+                TargetInstance = targetInstance,
+                PingTarget = targetInstance as MonoBehaviour,
+                TargetName = targetName,
+                MethodName = methodName,
+                Priority = priority,
+                ExecType = execType,
+                IsStaticHandler = targetInstance == null
+            };
+        }
+
+        private List<string> DumpEventParams(EventBase evt)
+        {
+            var values = new List<string>();
+            if (evt == null) return values;
+
+            var currentType = evt.GetType();
+
+            while (currentType != null && currentType != typeof(EventBase) && currentType != typeof(object))
+            {
+                var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
+                            BindingFlags.DeclaredOnly;
+
+                foreach (var f in currentType.GetFields(flags))
+                {
+                    if (f.Name.Contains("<") || f.Name.Contains(">")) continue;
+                    if (f.Name is "CurrentHandler" or "Phase") continue;
+                    values.Add($"{f.Name} = {FormatValue(f.GetValue(evt))}");
+                }
+
+                foreach (var p in currentType.GetProperties(flags))
+                {
+                    if (p.Name is "CurrentHandler" or "Phase" or "IsCanceled" or "IsCancelable" or "Result") continue;
+                    if (!p.CanRead || p.GetIndexParameters().Length > 0) continue;
+                    try
+                    {
+                        values.Add($"{p.Name} = {FormatValue(p.GetValue(evt))}");
+                    }
+                    catch
+                    {
+                        // ignored
+                    }
+                }
+
+                currentType = currentType.BaseType;
+            }
+
+            return values;
+        }
+
+        private string FormatValue(object val)
+        {
+            if (val == null) return "null";
+            if (val is UnityEngine.Object uObj) return uObj ? uObj.name : "null(已销毁)";
+            if (val is string s) return $"\"{s}\"";
+            if (val is Array arr) return $"[数组 Length:{arr.Length}]";
+            return val.ToString();
+        }
+
+        private object GetMemberValue(object obj, string memberName)
+        {
+            if (obj == null) return null;
+            var type = obj.GetType();
+            var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+
+            var prop = type.GetProperty(memberName, flags);
+            if (prop != null) return prop.GetValue(obj);
+
+            var field = type.GetField(memberName, flags);
+            if (field != null) return field.GetValue(obj);
+
+            return null;
+        }
+
+        private void ClearLogs()
+        {
+            _logRecords.Clear();
+            RequestLiveTrackerRefresh(true);
+        }
+
+        private void OpenScriptByClassName(string className)
+        {
+            if (className == "匿名闭包类") return;
+            var guids = AssetDatabase.FindAssets($"{className} t:MonoScript");
+            foreach (var guid in guids)
+            {
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+                if (path.EndsWith($"{className}.cs"))
+                {
+                    var script = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
+                    if (script)
+                    {
+                        AssetDatabase.OpenAsset(script);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+#endif
diff --git a/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs.meta b/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs.meta
new file mode 100644
index 0000000..7fd9a77
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 16e1b18e2a2748e494f2ba648b4697a8
+timeCreated: 1772878417
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef b/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef
new file mode 100644
index 0000000..044b09e
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef
@@ -0,0 +1,13 @@
+{
+    "name": "ShrinkEventBus.Editor",
+    "rootNamespace": "ShrinkEventBus.Editor",
+    "references": [
+        "ShrinkEventBus.Runtime",
+        "UniTask"
+    ],
+    "includePlatforms": ["Editor"],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "autoReferenced": false
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef.meta b/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef.meta
new file mode 100644
index 0000000..ac5f960
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f0a89bdb25764f1f8a8e4dcc915abe39
+timeCreated: 1772900825
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/LICENSE b/Assets/Modules/ShrinkEventBus/LICENSE
new file mode 100644
index 0000000..b526bfd
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eicy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Assets/Modules/ShrinkEventBus/LICENSE.meta b/Assets/Modules/ShrinkEventBus/LICENSE.meta
new file mode 100644
index 0000000..d7574dc
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/LICENSE.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a726eae075081a24785e6f3f4a4efe6d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/README.md b/Assets/Modules/ShrinkEventBus/README.md
new file mode 100644
index 0000000..e51dc7b
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/README.md
@@ -0,0 +1,629 @@
+# ShrinkEventBus
+
+一个为 Unity C# 项目设计的高性能、类型安全事件总线系统。支持优先级调度、编译期自动注册、同步/异步混合处理，以及完整的 MonoBehaviour 生命周期管理。
+
+## ✨ 特性概览
+
+| 特性 | 说明 |
+|------|------|
+| 🔒 **类型安全** | 基于泛型的强类型事件，编译期检查，无装箱开销 |
+| ⚡ **高性能热路径** | 注册期预编译 invoker（无反射调用、无装箱），派发走缓存快照数组，监听者快照零拷贝挂接 |
+| 🤖 **零侵入自动注册** | 标记 `[EventBusSubscriber]` 即可，ILPostProcessor 编译期自动织入注册与反注册逻辑，动态创建的对象也无需手写任何代码 |
+| 🧾 **静态订阅清单** | 静态 `[EventBusSubscriber]` 现可通过编译期注册表收口，避免默认总线启动时全域扫描所有类型 |
+| 🎯 **双重优先级** | 支持枚举优先级与数字优先级组合，精确控制执行顺序 |
+| 🔄 **同步 & 异步** | 统一支持 `Action`（同步）与 `UniTask`（异步）两种 handler 形式 |
+| 🧵 **线程安全** | 注册/注销操作全程加锁保护 |
+| 📦 **对象池** | 内置 `EventPool<T>`，高频事件零 GC |
+| 🔍 **调试友好** | Editor 事件查看器实时追踪订阅者与触发日志 |
+| 🧩 **可实例化总线** | 除默认静态 `EventBus` 外，也可以用 Builder 创建独立 bus，并按需要配置异常策略、事件类型约束、分 phase 分发 |
+| 🌳 **父事件监听** | 监听父事件类型时，子事件触发也会命中父事件监听器，便于做 Pre/Post 家族事件和统一监控 |
+
+## 👓 Benchmark
+
+[Benchmark结果](Benchmark.txt)
+
+运行时仓库里自带 `EventBusBenchmark` 组件，当前会分别覆盖这些场景：
+
+- 无订阅者 / 单订阅者 / 多订阅者同步触发
+- 父事件监听子事件
+- 按 `EventPriority` 分 phase 分发
+- 单订阅者异步触发
+- 手工 delegate 注册 / 注销
+- `object / Type / MethodInfo` 扫描注册 / 注销
+- `EventPool<T>` 与 `new`
+- 已取消事件跳过
+
+如果你在评估这次 `IShrinkEventBus`、继承监听和严格注册带来的成本变化，优先看这个组件的输出，而不是只看 `Benchmark.txt` 里的旧样本。
+
+## 📦 依赖
+
+- Unity 2022.3+
+- [UniTask](https://github.com/Cysharp/UniTask) `2.x`
+
+## ⚙️ 安装
+
+在项目的 `Packages/manifest.json` 中添加：
+
+```json
+{
+  "dependencies": {
+    "com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask",
+    "com.cneicy.shrink-eventbus": "https://github.com/cneicy/ShrinkEventBus.git"
+  }
+}
+```
+
+或通过 Package Manager → `+` → `Add package from git URL` 输入：
+
+```
+https://github.com/cneicy/ShrinkEventBus.git
+```
+
+> ⚠️ **自动织入依赖说明**：当前工作区同时支持两层织入。若当前程序集命中共享管线 `ShrinkShared.CodeGen` 的覆盖范围（例如同时引用 `ShrinkCommand.Runtime` / `ShrinkNetwork.Runtime` / `ShrinkApp.Core.Runtime`），则优先由共享管线处理；其余只引用 `ShrinkEventBus.Runtime` 的程序集由模块内 `CodeGen/` 本地 ILPostProcessor 兜底。独立安装本包但未带上 `CodeGen/` 或共享管线时，没有编译期织入，请改用手动接入：MonoBehaviour 在 `Awake`/`OnDestroy` 中调用 `EventBus.AutoRegister(this)` / `EventBus.UnregisterInstance(this)`，或使用 `SubscribeEvent` 句柄。
+
+## 🚀 快速上手
+
+### 第一步：定义事件
+
+所有事件必须继承 `EventBase`，通过 Attribute 声明附加能力：
+
+```csharp
+// 普通事件
+public class PlayerDiedEvent : EventBase
+{
+    public int PlayerId { get; set; }
+    public string Cause { get; set; }
+}
+
+// 可取消事件
+[Cancelable]
+public class PlayerMoveEvent : EventBase
+{
+    public Vector3 OldPosition { get; set; }
+    public Vector3 NewPosition { get; set; }
+}
+
+// 有返回结果的事件
+[HasResult]
+public class ItemPickupEvent : EventBase
+{
+    public string ItemId { get; set; }
+    public GameObject Picker { get; set; }
+}
+```
+
+### 第二步：订阅事件
+
+在 MonoBehaviour 上标记 `[EventBusSubscriber]`，用 `[EventSubscribe]` 标记处理方法。
+
+**无论是场景初始时存在的对象，还是运行时动态 `Instantiate` 的对象，都会在 `Awake` 时自动完成注册，销毁时自动清理，无需手写任何注册代码。**
+
+```csharp
+[EventBusSubscriber]
+public class UIManager : MonoBehaviour
+{
+    // 同步处理
+    [EventSubscribe(EventPriority.NORMAL)]
+    private void OnPlayerDied(PlayerDiedEvent evt)
+    {
+        ShowDeathScreen(evt.PlayerId);
+    }
+
+    // 异步处理（UniTask）
+    [EventSubscribe(EventPriority.HIGH)]
+    private async UniTask OnItemPickup(ItemPickupEvent evt)
+    {
+        await PlayPickupAnimation(evt.ItemId);
+    }
+}
+```
+
+### 第三步：触发事件
+
+```csharp
+// 同步触发
+EventBus.TriggerEvent(new PlayerDiedEvent { PlayerId = 1, Cause = "Fall" });
+
+// 异步触发（顺序等待每个 handler）
+await EventBus.TriggerEventAsync(new PlayerMoveEvent
+{
+    OldPosition = transform.position,
+    NewPosition = targetPos
+});
+
+// 使用对象池（高频场景推荐）
+using var evt = EventPool<PlayerDiedEvent>.Get();
+evt.PlayerId = 1;
+EventBus.TriggerEvent(evt);
+// using 块结束时自动归还到池中
+```
+
+## 🖼️ 追踪图形化
+
+菜单栏 → `ShrinkSDK` → `事件总线` → `事件查看器`
+
+![订阅者全览](img1.png)
+
+![实时触发日志](img2.png)
+
+实时触发日志页现已支持关键词过滤、按“有监听者 / 无监听者”筛选，以及“折叠同类事件”聚合查看，适合排查高频事件刷屏场景。
+
+---
+
+## 📖 核心概念
+
+### 自动注册机制
+
+ShrinkEventBus 通过 **ILPostProcessor** 在编译期自动处理完整的生命周期管理。当 Unity 编译代码时，所有标记了 `[EventBusSubscriber]` 且自身或基类链上存在实例 `[EventSubscribe]` 方法的 MonoBehaviour 子类会被自动识别，并在其 `Awake` 和 `OnDestroy` 方法中分别织入注册与反注册逻辑（没有任何实例订阅方法的类型会被跳过，不织入也不报错）。
+
+当前织入策略如下：
+
+- 命中共享管线 `ShrinkShared.CodeGen` 覆盖范围的程序集，优先由共享管线处理。
+- 其余只引用 `ShrinkEventBus.Runtime` 的程序集，由模块内 `CodeGen/Editor/EventBusILPostProcessor.cs` 本地处理。
+- 因此 ShrinkSDK 工作区内的统一 CodeGen 与独立 `ShrinkEventBus` 业务程序集可以同时兼容，且不会双重织入。
+
+织入规则如下：
+
+- 类**自身已有** `Awake`/`OnDestroy`：在方法头部插入，用户自己负责 `base` 调用
+- 类**没有**，但**基类有虚方法**：生成 `protected override` 并自动调用 `base` 方法，`Awake` 顺序为 `base.Awake() → AutoRegister`，`OnDestroy` 顺序为 `UnregisterInstance → base.OnDestroy()`
+- 类**没有**，基类**也没有**：生成私有方法并插入
+
+这意味着：
+
+- 场景初始加载的对象 → `Awake` 执行时自动注册
+- 运行时 `Instantiate` 的对象 → `Awake` 执行时自动注册
+- GameObject 销毁时 → `OnDestroy` 执行时自动反注册，无内存泄漏
+
+**整个过程对业务代码完全透明，类里不需要写任何注册相关的代码。**
+
+### 实例化总线与 Builder
+
+默认情况下，项目继续使用全局静态门面 `EventBus`。如果你需要更清晰的模块边界，也可以创建独立 bus：
+
+```csharp
+var gameplayBus = EventBus.CreateBus(builder => builder
+    .AllowPerPhaseDispatch()
+    .SetExceptionHandlingMode(ShrinkEventExceptionHandlingMode.LogAndThrow));
+
+gameplayBus.Register(new GameplaySubscribers());
+gameplayBus.TriggerEvent(new PlayerDiedEvent { PlayerId = 1, Cause = "Fall" });
+```
+
+当前 Builder 支持的重点配置：
+
+- `SetExceptionHandlingMode(...)`
+- `SetExceptionHandler(...)`
+- `AllowPerPhaseDispatch()`
+- `CheckTypesOnDispatch()`
+- `MarkerInterface<TMarker>()`
+- `ClassChecker(...)`
+- `StartShutdown()`
+
+如果你只是想继续沿用旧习惯，直接用静态 `EventBus` 即可；它内部就是一个默认的 `IShrinkEventBus` 实例。
+
+### 手动注册的新边界
+
+除了 `AutoRegister(this)` / `[EventBusSubscriber]` 这条 Unity 友好的自动接入路径，现在也支持更显式的手动注册：
+
+```csharp
+// 扫描实例上的 [EventSubscribe] 方法
+EventBus.Register(mySubscriberInstance);
+
+// 扫描某个类型上的 static [EventSubscribe] 方法
+EventBus.Register(typeof(GlobalEventHooks));
+
+// 只注册某一个 static [EventSubscribe] 方法
+EventBus.Register(typeof(GlobalEventHooks).GetMethod("OnPlayerDied",
+    BindingFlags.Static | BindingFlags.NonPublic));
+```
+
+和旧版本相比，手动注册现在会更严格：
+
+- 方法必须带 `[EventSubscribe]`
+- 只能有一个参数
+- 参数必须继承 `EventBase`
+- 返回值只能是 `void` 或 `UniTask`
+- 实例注册只接受实例方法，类型/方法注册只接受静态方法
+
+这样做的目的是把“为什么没触发”尽量提前到注册阶段暴露，而不是静默吞掉。
+
+### 优先级系统
+
+`EventPriority` 枚举定义了六个优先级档位，数值越小越先执行：
+
+```
+HIGHEST(0) → HIGH(1) → NORMAL(2) → LOW(3) → LOWEST(4) → MONITOR(5)
+```
+
+同一优先级档位内，可用数字优先级进一步细排（数字越大越先执行）：
+
+```csharp
+// 枚举优先级
+[EventSubscribe(EventPriority.HIGH)]
+private void Handler(SomeEvent evt) { }
+
+// 数字优先级（自动映射到枚举档位；手动注册时必须显式传入数字）
+EventBus.RegisterEvent<SomeEvent>(Handler, priority: 75); // 映射为 HIGH
+
+// 手动注册时混合使用
+EventBus.RegisterEvent<SomeEvent>(Handler, EventPriority.HIGH, receiveCanceled: false);
+```
+
+数字到枚举的映射规则：
+
+| 数字范围 | 枚举档位 |
+|---------|---------|
+| ≥ 100 | HIGHEST |
+| ≥ 50 | HIGH |
+| ≥ 0 | NORMAL |
+| ≥ -50 | LOW |
+| < -50 | LOWEST |
+
+> 1.3.0 起：数字 `0` 映射到 `NORMAL`（与枚举重载默认值一致）；int 重载不再提供默认值，不带优先级的 `RegisterEvent(handler)` 调用唯一解析到枚举重载（NORMAL）。
+
+**推荐的优先级分工：**
+
+```
+HIGHEST  — 权限校验、合法性检查
+HIGH     — 核心业务逻辑、数值计算
+NORMAL   — 默认行为、状态变更
+LOW      — UI 更新、音效、特效
+LOWEST   — 收尾清理
+MONITOR  — 日志、统计、监控（通常配合 receiveCanceled: true）
+```
+
+如果你创建的 bus 开启了 `AllowPerPhaseDispatch()`，也可以只分发某一个 phase：
+
+```csharp
+gameplayBus.TriggerEvent(EventPriority.HIGH, evt);
+await gameplayBus.TriggerEventAsync(EventPriority.MONITOR, evt);
+```
+
+这个模式主要适合做框架级流水线控制；普通业务仍推荐直接走完整分发。
+
+### 父事件监听
+
+现在监听父事件时，子事件触发也会命中父事件监听器：
+
+```csharp
+public class DamageEvent : EventBase
+{
+    public int Value { get; set; }
+}
+
+public sealed class CriticalDamageEvent : DamageEvent
+{
+    public bool IsCritical { get; set; }
+}
+
+EventBus.RegisterEvent<DamageEvent>(OnAnyDamage, EventPriority.MONITOR, receiveCanceled: true);
+EventBus.TriggerEvent(new CriticalDamageEvent { Value = 42, IsCritical = true });
+```
+
+这很适合做统一日志、统一权限检查、事件族级别的监控和桥接。
+
+### 事件取消与结果
+
+```csharp
+// 取消事件（需标记 [Cancelable]）
+[EventSubscribe(EventPriority.HIGHEST)]
+private void ValidateMove(PlayerMoveEvent evt)
+{
+    if (!IsValidPosition(evt.NewPosition))
+        evt.SetCanceled(true); // 后续未设置 receiveCanceled: true 的 handler 将跳过
+}
+
+// 监控处理器可以接收已取消的事件
+[EventSubscribe(EventPriority.MONITOR, receiveCanceled: true)]
+private void LogMove(PlayerMoveEvent evt)
+{
+    Debug.Log($"移动 {(evt.IsCanceled ? "被取消" : "成功")}");
+}
+
+// 触发方检查取消状态
+var moveEvent = new PlayerMoveEvent { ... };
+await EventBus.TriggerEventAsync(moveEvent);
+if (!moveEvent.IsCanceled)
+    transform.position = moveEvent.NewPosition;
+```
+
+```csharp
+// 设置结果（需标记 [HasResult]）
+[EventSubscribe(EventPriority.HIGH)]
+private void CheckPermission(ItemPickupEvent evt)
+{
+    evt.SetResult(player.HasSpace ? EventResult.ALLOW : EventResult.DENY);
+}
+
+// 触发方读取结果
+var pickupEvent = new ItemPickupEvent { ... };
+EventBus.TriggerEvent(pickupEvent);
+bool success = pickupEvent.Result switch
+{
+    EventResult.ALLOW   => true,
+    EventResult.DENY    => false,
+    EventResult.DEFAULT => DefaultPickupLogic()
+};
+```
+
+### 注册方式对比
+
+| 方式 | 适用场景 | 自动反注册 |
+|------|---------|-----------|
+| `[EventBusSubscriber]` + `[EventSubscribe]` | MonoBehaviour（推荐） | ✅ ILP 织入 OnDestroy，随 GameObject 销毁自动清理 |
+| `EventBus.SubscribeEvent(...)` 手动订阅 | 非 MonoBehaviour 类、Lambda | ✅ `Dispose()` 即可精准清理 |
+| `EventBus.RegisterEvent(...)` 手动注册 | 兼容旧代码 | ❌ 需手动调用 `UnregisterEvent` |
+| `EventBus.AutoRegister(this)` | 特殊场景下手动触发 | ❌ 需手动调用 `UnregisterInstance` |
+
+**手动注册示例（非 MonoBehaviour）：**
+
+```csharp
+public class InventorySystem : IDisposable
+{
+    private readonly IShrinkEventSubscription _itemPickupSubscription;
+
+    public InventorySystem()
+    {
+        _itemPickupSubscription = EventBus.SubscribeEvent<ItemPickupEvent>(OnItemPickup, EventPriority.NORMAL);
+    }
+
+    private void OnItemPickup(ItemPickupEvent evt) { /* ... */ }
+
+    public void Dispose()
+    {
+        _itemPickupSubscription.Dispose();
+    }
+}
+```
+
+---
+
+## 🔧 API 参考
+
+### EventBus（静态门面）
+
+#### 注册 / 注销
+
+```csharp
+// 同步 handler
+EventBus.RegisterEvent<TEvent>(Action<TEvent> handler, EventPriority priority, bool receiveCanceled);
+EventBus.RegisterEvent<TEvent>(Action<TEvent> handler, int priority);
+EventBus.SubscribeEvent<TEvent>(Action<TEvent> handler, EventPriority priority, bool receiveCanceled);
+EventBus.SubscribeEvent<TEvent>(Action<TEvent> handler, int priority);
+
+// 异步 handler（UniTask）
+EventBus.RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, EventPriority priority, bool receiveCanceled);
+EventBus.SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler, EventPriority priority, bool receiveCanceled);
+
+// 注销
+EventBus.UnregisterEvent<TEvent>(Action<TEvent> handler);
+EventBus.UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler);
+EventBus.UnregisterAllEventsForObject(object target);  // 注销某实例的全部 handler
+EventBus.ClearAllSubscribersForEvent<TEvent>();         // 清空某事件的全部订阅者
+EventBus.UnregisterAllEvents();                         // 全部清空（谨慎使用）
+```
+
+#### 触发
+
+```csharp
+// 同步触发：只同步等待 sync handler；async handler 会基于事件快照 fire-and-forget
+bool handled = EventBus.TriggerEvent<TEvent>(TEvent eventArgs);
+
+// 异步触发：顺序 await 每个 handler
+bool handled = await EventBus.TriggerEventAsync<TEvent>(TEvent eventArgs);
+```
+
+> ⚠️ `TriggerEvent` 中遇到 async handler 时，不会等待其完成，而是对当前事件做一份快照后异步执行。如果你需要让 async handler 参与最终状态（如 `IsCanceled` / `Result` / 后续字段改写），请使用 `TriggerEventAsync`。
+
+#### 查询
+
+```csharp
+EventBus.IsInstanceRegistered(object target);
+EventBus.GetRegisteredInstanceCount();
+EventBus.GetRegisteredEventTypeCount();
+EventBus.GetEventSubscribers<TEvent>();   // 返回 EventHandlerInfo[]
+EventBus.GetListenerList<TEvent>();       // 无订阅者时返回 null
+EventBus.GetActiveSubscriptionsSnapshot();// 返回 IDisposable 订阅快照
+```
+
+### EventPool\<T\>
+
+```csharp
+// 从池中取出（自动重置状态）
+var evt = EventPool<MyEvent>.Get();
+
+// 手动归还
+EventPool<MyEvent>.Release(evt);
+
+// 推荐：配合 using 自动归还
+using var evt = EventPool<MyEvent>.Get();
+EventBus.TriggerEvent(evt);
+// 作用域结束时调用 Dispose() → 自动归还
+```
+
+> ⚠️ 归还后不要再访问 `evt` 的属性，对象已被重置并放回池中。
+
+### EventBase 关键成员
+
+```csharp
+evt.EventId          // Guid，每次派发唯一（懒生成，首次访问时分配）
+evt.EventTime        // 事件创建时间（UTC）
+evt.IsCancelable     // 是否支持取消（由 [Cancelable] 决定）
+evt.HasResult        // 是否支持结果（由 [HasResult] 决定）
+evt.IsCanceled       // 是否已被取消
+evt.Result           // 当前结果（EventResult 枚举）
+evt.Phase            // 当前执行到的优先级阶段
+evt.CurrentHandler   // 当前正在执行的 handler 信息
+evt.GetSubscribers() // 获取本次派发的 handler 快照拷贝（调试用）
+```
+
+---
+
+## 🏗️ 架构说明
+
+```
+ShrinkEventBus
+├── Runtime/
+│   ├── EventBus                 静态门面，内部是一个默认 IShrinkEventBus 实例
+│   ├── ShrinkEventBusInstance   总线实现：注册、派发、异常策略、phase 分发
+│   ├── ShrinkEventBusBuilder    实例总线的构建与配置入口
+│   ├── ListenerList             按 phase 分桶的有序 handler 列表，带快照缓存与父链合并
+│   ├── EventHandlerInfo         单个 handler 的元信息（优先级、预编译 invoker、调试信息）
+│   ├── EventBase                所有事件的基类，携带生命周期状态与派发快照
+│   ├── EventPool<T>             对象池，高频事件减少 GC
+│   ├── EventCloneUtility        同步路径上 async handler 的事件快照克隆
+│   ├── EventBusRegHelper        反射扫描 & handler 注册逻辑
+│   └── EventAutoRegHelper       运行时初始化，确保 IsInitialized 状态正确
+│
+├── Editor/
+│   └── EventBusViewerWindow     事件查看器，实时显示订阅者与触发日志
+│
+└── （织入）ShrinkShared.CodeGen / CodeGen  共享 ILPostProcessor 优先，本地 ILPostProcessor 兜底
+                                          向 [EventBusSubscriber] 类注入 Awake（AutoRegister）
+                                          与 OnDestroy（UnregisterInstance）
+```
+
+**热路径（`TriggerEvent`）工作流：**
+
+```
+TriggerEvent(evt)
+  └─ 取该事件类型的 ListenerList     // 总线级字典 + 共享锁，每类型常数开销
+       └─ GetHandlers()              // 返回缓存快照数组（脏时才重建），无拷贝
+            ├─ 快照数组引用挂到事件对象上（一次赋值，供 GetSubscribers 调试）
+            └─ 遍历 handlers[]
+                 ├─ 跳过已取消 & 不接收取消的 handler
+                 ├─ Action<T> → 经预编译 invoker 直接调用
+                 └─ Func<T, UniTask> → 克隆事件快照后 .Forget()（同步路径）
+```
+
+**自动注册完整流程：**
+
+```
+【编译期】若当前程序集命中 ShrinkShared.CodeGen 覆盖范围，则由共享 ILPostProcessor 扫描；
+         否则由 CodeGen/EventBusILPostProcessor.cs 本地扫描
+  └─ 找到标记了 [EventBusSubscriber] 且存在实例 [EventSubscribe] 方法的 MonoBehaviour 子类
+       ├─ 在 Awake 头部织入 EventBus.AutoRegister(this)
+       └─ 在 OnDestroy 头部织入 EventBus.UnregisterInstance(this)
+            （类无对应方法时自动生成，有虚基类方法时自动调用 base）
+  ※ 只引用 ShrinkEventBus.Runtime 的纯业务程序集目前不在织入范围内，需手动 AutoRegister
+
+【运行时 - 默认静态总线启动】
+  └─ 读取编译期静态订阅清单，注册 static [EventSubscribe] 方法
+
+【运行时 - 动态创建】Instantiate(prefab)
+  └─ Unity 调用新对象的 Awake（已含织入代码）→ 自动注册
+
+【运行时 - 销毁】GameObject.Destroy
+  └─ OnDestroy（已含织入代码）→ UnregisterInstance → 自动反注册
+```
+
+---
+
+## ✅ 最佳实践
+
+**事件设计：尽量让属性只读**
+
+```csharp
+// ✅ 推荐：构造时传入，防止 handler 间意外修改输入数据
+public class OrderPlacedEvent : EventBase
+{
+    public string OrderId { get; }
+    public decimal Amount { get; }
+    public OrderPlacedEvent(string orderId, decimal amount)
+    {
+        OrderId = orderId;
+        Amount = amount;
+    }
+}
+
+// ❌ 避免：公开可写属性，handler 间耦合风险高
+public class BadEvent : EventBase
+{
+    public object Payload { get; set; }
+}
+```
+
+**高频事件一定要用对象池**
+
+```csharp
+// ✅ 每帧触发的伤害/移动事件
+using var dmgEvt = EventPool<DamageEvent>.Get();
+dmgEvt.Value = damage;
+EventBus.TriggerEvent(dmgEvt);
+
+// ❌ 每帧 new，会产生大量 GC
+EventBus.TriggerEvent(new DamageEvent { Value = damage });
+```
+
+**非 MonoBehaviour 类一定要手动清理**
+
+```csharp
+public void Dispose()
+{
+    EventBus.UnregisterAllEventsForObject(this);
+}
+```
+
+**异步 handler 中谨慎触发新事件**
+
+在 `TriggerEventAsync` 的 handler 内部再次 `await TriggerEventAsync`，链条过深时调用栈难以追踪，建议把二次触发拆到外部或改用消息队列。
+
+---
+
+## ⚠️ 注意事项
+
+- **`TriggerEvent` 不等待异步 handler**：同步路径中的 UniTask handler 会基于事件快照异步执行，执行结果和异常不会传回调用方，对原事件对象的改动也不会回写。需要等待并拿到最终状态时请使用 `TriggerEventAsync`。
+- **同步路径中的 async 快照是浅拷贝**：事件对象本身会复制一份，但如果载荷里挂着可变引用类型（如 `List<>`、`Dictionary<>`、自定义引用对象），内部成员仍然是共享引用。高风险数据建议改成不可变载荷，或统一走 `TriggerEventAsync`。
+- **EventPool 归还后不要再使用**：`Release` 后对象会立即 `ResetInternal()`，继续访问属性将得到默认值。
+- **不要在 handler 内直接注册/注销 handler**：可能影响当前正在遍历的 handler 快照，会产生语义上的不确定性。
+- **静态 handler 永远不会自动注销**：静态方法注册后持续存活直到显式调用 `UnregisterEvent`，不要在静态 handler 里持有场景对象引用。
+- **`[EventBusSubscriber]` 仅对 MonoBehaviour 生效自动注册**：非 MonoBehaviour 类标记该 Attribute 无任何效果，请使用手动注册。
+- **标了 `[EventBusSubscriber]` 但没有实例 `[EventSubscribe]` 方法的类**：编译期不会织入；若通过 `AutoRegister` 手动接入，会输出警告并跳过（不抛异常）。显式 `Register()` 对此仍严格抛错。
+- **int 数字优先级重载必须显式传值**：1.3.0 起 int 重载不再有默认值；数字 `0` 映射 `NORMAL`。
+- **ILPostProcessor 织入发生在编译期**：修改代码后需要重新编译才能使注入生效，热重载场景下请注意这一点。
+- **继承泛型基类（如 `Singleton<T>`）时无需额外处理**：ILP 会正确识别泛型基类中的虚方法并生成 `protected override`，自动调用 `base.Awake()` 和 `base.OnDestroy()`。
+
+---
+
+## 🐛 常见问题排查
+
+**事件没有被任何 handler 接收**
+
+1. 检查订阅类是否有 `[EventBusSubscriber]`
+2. 检查方法是否有 `[EventSubscribe]`，且签名为 `void/UniTask Method(TEvent evt)`
+3. 确认代码在标记 `[EventBusSubscriber]` 后重新编译过（ILPostProcessor 需要编译期运行）
+4. 确认没有在 `Awake` 之前就触发事件
+
+```csharp
+// 调试：主动检查注册状态
+Debug.Log(EventBus.IsInstanceRegistered(this));
+Debug.Log($"订阅者数量: {EventBus.GetEventSubscribers<MyEvent>().Length}");
+```
+
+**怀疑内存泄漏**
+
+```csharp
+// 检查是否有 handler 持有意外引用
+var handlers = EventBus.GetEventSubscribers<MyEvent>();
+foreach (var h in handlers)
+    Debug.Log($"{h.DisplayDeclaringType.Name}.{h.DisplayMethodName} | target: {h.Target}");
+```
+
+**Editor 下想追踪事件流**
+
+打开事件查看器：菜单栏 → `ShrinkSDK` → `事件总线` → `事件查看器`
+
+也可以通过代码追踪：
+
+```csharp
+EventBus.EnableDebugRecord = true;
+EventBus.TriggerEvent(evt);
+foreach (var h in evt.GetSubscribers())
+    Debug.Log($"[{h.Priority}] {h.DisplayDeclaringType.Name}.{h.DisplayMethodName}");
+```
+
+---
+
+## 📄 License
+
+[MIT](LICENSE)
diff --git a/Assets/Modules/ShrinkEventBus/README.md.meta b/Assets/Modules/ShrinkEventBus/README.md.meta
new file mode 100644
index 0000000..c272807
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/README.md.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e08e301c95a34847a1071cd96bba1eeb
+timeCreated: 1772900157
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime.meta b/Assets/Modules/ShrinkEventBus/Runtime.meta
new file mode 100644
index 0000000..26d1953
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c410edd1d6b644b498d39ff5e1fbc98b
+timeCreated: 1772900792
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs b/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs
new file mode 100644
index 0000000..e8ffa9c
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("ShrinkNetwork.Integration.EventBus")]
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs.meta
new file mode 100644
index 0000000..58597f6
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/AssemblyInfo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 43e85f78c24f1d94ba7d06a4fa37e937
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs b/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs
new file mode 100644
index 0000000..81890b6
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs
@@ -0,0 +1,42 @@
+using System;
+
+namespace ShrinkEventBus
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class CancelableAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public class HasResultAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public class EventBusSubscriberAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
+    public class EventSubscribeAttribute : Attribute
+    {
+        public EventPriority Priority { get; set; }
+        public bool ReceiveCanceled { get; set; }
+        public int NumericPriority { get; set; }
+
+        public EventSubscribeAttribute()
+        {
+            Priority = EventPriority.NORMAL;
+            ReceiveCanceled = false;
+            NumericPriority = 0;
+        }
+
+        public EventSubscribeAttribute(EventPriority priority, bool receiveCanceled = false)
+        {
+            Priority = priority;
+            ReceiveCanceled = receiveCanceled;
+            NumericPriority = 0;
+        }
+
+        public EventSubscribeAttribute(int priority)
+        {
+            NumericPriority = priority;
+            Priority = PriorityHelper.ConvertToEventPriority(priority);
+            ReceiveCanceled = false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs.meta
new file mode 100644
index 0000000..f811159
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/Attributes.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9bb9d82b04a04f3085b9e68ab4f1ba60
+timeCreated: 1760098802
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs
new file mode 100644
index 0000000..592a832
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs
@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace ShrinkEventBus
+{
+    public static class EventAutoRegHelper
+    {
+        private static readonly object InitLock = new();
+        public static bool IsInitialized { get; private set; }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+        private static void InitializeAfterSceneLoad()
+        {
+            EnsureInitialized();
+        }
+
+        public static void EnsureInitialized()
+        {
+            if (IsInitialized) return;
+            lock (InitLock)
+            {
+                if (IsInitialized) return;
+                IsInitialized = true;
+            }
+        }
+
+        public static void Cleanup()
+        {
+            lock (InitLock)
+            {
+                IsInitialized = false;
+            }
+
+            EventBus.UnregisterAllEvents();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs.meta
new file mode 100644
index 0000000..0f2b7fc
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f4d79f65274145cab7614950a64a92f5
+timeCreated: 1760099405
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs
new file mode 100644
index 0000000..a05528e
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs
@@ -0,0 +1,146 @@
+#nullable enable
+using System;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Runtime.Serialization;
+
+namespace ShrinkEventBus
+{
+    public abstract class EventBase : IDisposable
+    {
+        private sealed class EventMetadata
+        {
+            public bool IsCancelable;
+            public bool HasResult;
+        }
+
+        private static readonly ConcurrentDictionary<Type, EventMetadata> MetadataCache = new();
+
+        private EventHandlerInfo[]? _dispatchSnapshot;
+        private Guid? _eventId;
+        private bool _isCanceled;
+        private EventResult _result = EventResult.DEFAULT;
+
+        [IgnoreDataMember]
+        public EventHandlerInfo? CurrentHandler { get; internal set; }
+
+        [IgnoreDataMember]
+        public DateTime EventTime { get; private set; } = DateTime.UtcNow;
+
+        [IgnoreDataMember]
+        public Guid EventId => _eventId ??= Guid.NewGuid();
+
+        [IgnoreDataMember]
+        public bool IsCancelable { get; }
+
+        [IgnoreDataMember]
+        public bool HasResult { get; }
+
+        [IgnoreDataMember]
+        public EventPriority? Phase { get; private set; }
+
+        internal bool IsInPool { get; set; }
+        internal Action<EventBase>? ReleaseAction { get; set; }
+
+        protected EventBase()
+        {
+            var metadata = GetOrCreateMetadata(GetType());
+            IsCancelable = metadata.IsCancelable;
+            HasResult = metadata.HasResult;
+            Setup();
+        }
+
+        protected virtual void Setup() { }
+
+        protected virtual void OnReset() { }
+
+        internal void ResetInternal()
+        {
+            _isCanceled = false;
+            _result = EventResult.DEFAULT;
+            CurrentHandler = null;
+            Phase = null;
+            EventTime = DateTime.UtcNow;
+            _eventId = null;
+            _dispatchSnapshot = null;
+            OnReset();
+        }
+
+        internal void PrepareForDispatch()
+        {
+            CurrentHandler = null;
+            Phase = null;
+            EventTime = DateTime.UtcNow;
+            _eventId = null;
+            _dispatchSnapshot = null;
+        }
+
+        internal void SetListenerSnapshot(EventHandlerInfo[]? handlers)
+        {
+            _dispatchSnapshot = handlers is { Length: > 0 } ? handlers : null;
+        }
+
+        [IgnoreDataMember]
+        public bool IsCanceled
+        {
+            get => _isCanceled;
+            set
+            {
+                if (!IsCancelable)
+                    throw new UnsupportedOperationException(
+                        $"Event {GetType().Name} is not cancelable. Mark it with [Cancelable] to allow cancellation.");
+                _isCanceled = value;
+            }
+        }
+
+        [IgnoreDataMember]
+        public EventResult Result
+        {
+            get => _result;
+            set
+            {
+                if (!HasResult)
+                    throw new InvalidOperationException(
+                        $"Event {GetType().Name} does not support results. Mark it with [HasResult] to allow setting a result.");
+                _result = value;
+            }
+        }
+
+        internal void SetPhase(EventPriority value)
+        {
+            if (Phase == value) return;
+            if (Phase != null && Phase.Value.CompareTo(value) > 0)
+                throw new ArgumentException(
+                    $"Event phase cannot move backwards from {Phase.Value} to {value}.", nameof(value));
+            Phase = value;
+        }
+
+        public void SetCanceled(bool canceled) => IsCanceled = canceled;
+        public void SetResult(EventResult result) => Result = result;
+
+        public EventHandlerInfo[] GetSubscribers()
+        {
+            var snapshot = _dispatchSnapshot;
+            if (snapshot == null || snapshot.Length == 0)
+                return Array.Empty<EventHandlerInfo>();
+
+            var copy = new EventHandlerInfo[snapshot.Length];
+            Array.Copy(snapshot, copy, snapshot.Length);
+            return copy;
+        }
+
+        public void Dispose()
+        {
+            ReleaseAction?.Invoke(this);
+        }
+
+        private static EventMetadata GetOrCreateMetadata(Type eventType)
+        {
+            return MetadataCache.GetOrAdd(eventType, static type => new EventMetadata
+            {
+                IsCancelable = type.GetCustomAttribute<CancelableAttribute>() != null,
+                HasResult = type.GetCustomAttribute<HasResultAttribute>() != null
+            });
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs.meta
new file mode 100644
index 0000000..26c8a83
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0b978c5174cf44d893a41950e7a504e3
+timeCreated: 1760098714
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs
new file mode 100644
index 0000000..a32a172
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs
@@ -0,0 +1,129 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkEventBus
+{
+    public static class EventBus
+    {
+        private static readonly IShrinkEventBus DefaultBus = CreateDefaultBus();
+
+        public static IShrinkEventBus Default => DefaultBus;
+
+        public static event Action<EventBase, Type> OnEventTriggered
+        {
+            add => DefaultBus.OnEventTriggered += value;
+            remove => DefaultBus.OnEventTriggered -= value;
+        }
+
+#if UNITY_EDITOR
+        public static bool EnableDebugRecord
+        {
+            get => DefaultBus.EnableDebugRecord;
+            set => DefaultBus.EnableDebugRecord = value;
+        }
+
+        public static event Action<EventBase, string, string, EventHandlerInfo[]> OnEventTriggeredForEditor
+        {
+            add => DefaultBus.OnEventTriggeredForEditor += value;
+            remove => DefaultBus.OnEventTriggeredForEditor -= value;
+        }
+#endif
+
+        public static ShrinkEventBusBuilder Builder() => new();
+
+        public static IShrinkEventBus CreateBus(Action<ShrinkEventBusBuilder>? configure = null)
+        {
+            var builder = new ShrinkEventBusBuilder();
+            configure?.Invoke(builder);
+            return builder.Build();
+        }
+
+        public static void Start() => DefaultBus.Start();
+        public static void AutoRegister(object target) => DefaultBus.AutoRegister(target);
+        public static void Register(object target) => DefaultBus.Register(target);
+        public static void Unregister(object target) => DefaultBus.Unregister(target);
+
+        public static void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
+            where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority);
+
+        public static void RegisterEvent<TEvent>(Action<TEvent> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
+            where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority, receiveCanceled);
+
+        public static void RegisterEvent<TEvent>(Action<TEvent> handler, int priority)
+            where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority);
+
+        public static void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
+            where TEvent : EventBase => DefaultBus.RegisterEvent(handler, priority, receiveCanceled);
+
+        public static IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
+            where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority, receiveCanceled);
+
+        public static IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler, int priority)
+            where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority);
+
+        public static IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false)
+            where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority, receiveCanceled);
+
+        public static IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
+            where TEvent : EventBase => DefaultBus.SubscribeEvent(handler, priority);
+
+        public static void UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler) where TEvent : EventBase =>
+            DefaultBus.UnregisterEvent(handler);
+
+        public static void UnregisterEvent<TEvent>(Action<TEvent> handler) where TEvent : EventBase =>
+            DefaultBus.UnregisterEvent(handler);
+
+        public static void ClearAllSubscribersForEvent<TEvent>() where TEvent : EventBase =>
+            DefaultBus.ClearAllSubscribersForEvent<TEvent>();
+
+        public static void UnregisterAllEventsForObject(object targetObject) =>
+            DefaultBus.UnregisterAllEventsForObject(targetObject);
+
+        public static void UnregisterInstance(object targetObject) => DefaultBus.Unregister(targetObject);
+        public static void UnregisterAllEvents() => DefaultBus.UnregisterAllEvents();
+
+        public static UniTask<bool> TriggerEventAsync<TEvent>(TEvent eventArgs) where TEvent : EventBase =>
+            DefaultBus.TriggerEventAsync(eventArgs);
+
+        public static UniTask<bool> TriggerEventAsync<TEvent>(EventPriority phase, TEvent eventArgs)
+            where TEvent : EventBase => DefaultBus.TriggerEventAsync(phase, eventArgs);
+
+        public static bool TriggerEvent<TEvent>(TEvent eventArgs) where TEvent : EventBase =>
+            DefaultBus.TriggerEvent(eventArgs);
+
+        public static bool TriggerEvent<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase =>
+            DefaultBus.TriggerEvent(phase, eventArgs);
+
+        public static EventHandlerInfo[] GetEventSubscribers<TEvent>() where TEvent : EventBase =>
+            DefaultBus.GetEventSubscribers<TEvent>();
+
+        public static ListenerList GetListenerList<TEvent>() where TEvent : EventBase =>
+            DefaultBus.GetListenerList<TEvent>();
+
+        public static IReadOnlyDictionary<Type, EventHandlerInfo[]> GetAllSubscribersSnapshot() =>
+            DefaultBus.GetAllSubscribersSnapshot();
+
+        public static IReadOnlyList<ShrinkEventSubscriptionSnapshot> GetActiveSubscriptionsSnapshot() =>
+            DefaultBus.GetActiveSubscriptionsSnapshot();
+
+        public static bool IsInstanceRegistered(object target) => DefaultBus.IsInstanceRegistered(target);
+        public static int GetRegisteredInstanceCount() => DefaultBus.GetRegisteredInstanceCount();
+        public static int GetRegisteredEventTypeCount() => DefaultBus.GetRegisteredEventTypeCount();
+
+        private static IShrinkEventBus CreateDefaultBus()
+        {
+            var bus = (ShrinkEventBusInstance)new ShrinkEventBusBuilder()
+                .SetExceptionHandlingMode(ShrinkEventExceptionHandlingMode.LogAndContinue)
+                .AllowPerPhaseDispatch()
+                .Build();
+            EventBusRegHelper.RegStaticEventHandler(bus);
+            return bus;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs.meta
new file mode 100644
index 0000000..6312bb8
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b995a65fd1324255a5ade1ae1f0adf32
+timeCreated: 1760099076
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs
new file mode 100644
index 0000000..bc5c98e
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs
@@ -0,0 +1,519 @@
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using System.Text;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using Debug = UnityEngine.Debug;
+
+namespace ShrinkEventBus.Runtime
+{
+    /// <summary>
+    /// ShrinkEventBus 性能测试。
+    /// 挂在任意 GameObject 上，运行后在 Console 查看结果。
+    /// 在进行测试时不要打开事件查看器的大量实时追踪。
+    /// </summary>
+    public sealed class EventBusBenchmark : MonoBehaviour
+    {
+        [Header("同步触发测试")] public int iterations = 1_000_000;
+
+        [Header("大批量订阅者测试")] public int subscriberCount = 30;
+        public int massIterations = 10_000;
+
+        [Header("异步触发测试")] public int asyncIterations = 1_000;
+
+        [Header("注册 / 注销测试")] public int registerIterations = 5_000;
+        public int scannedRegisterIterations = 1_000;
+
+        [Header("取消事件测试")] public int cancelIterations = 100_000;
+
+        public class BenchmarkEvent : EventBase
+        {
+            public int Value { get; set; }
+        }
+
+        public sealed class DerivedBenchmarkEvent : BenchmarkEvent
+        {
+            public bool IsDerived { get; set; }
+        }
+
+        [Cancelable]
+        public class CancelableBenchmarkEvent : EventBase
+        {
+            public int Value { get; set; }
+        }
+
+        private sealed class BenchmarkInstanceSubscriber
+        {
+            public int Recorded;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnBenchmark(BenchmarkEvent evt)
+            {
+                Recorded = evt.Value;
+            }
+        }
+
+        private static class BenchmarkStaticSubscriber
+        {
+            public static int Recorded;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private static void OnBenchmark(BenchmarkEvent evt)
+            {
+                Recorded = evt.Value;
+            }
+        }
+
+        private static class BenchmarkMethodSubscriber
+        {
+            public static int Recorded;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private static void OnBenchmark(BenchmarkEvent evt)
+            {
+                Recorded = evt.Value;
+            }
+        }
+
+        private sealed class PhaseSubscriber
+        {
+            public int Sum;
+
+            [EventSubscribe(EventPriority.HIGH)]
+            private void OnHigh(BenchmarkEvent evt)
+            {
+                Sum += evt.Value + 1;
+            }
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnNormal(BenchmarkEvent evt)
+            {
+                Sum += evt.Value + 10;
+            }
+
+            [EventSubscribe(EventPriority.LOW)]
+            private void OnLow(BenchmarkEvent evt)
+            {
+                Sum += evt.Value + 100;
+            }
+        }
+
+        private readonly StringBuilder _report = new();
+
+        private void Start()
+        {
+            RunAllBenchmarks().Forget();
+        }
+
+        private async UniTaskVoid RunAllBenchmarks()
+        {
+            _report.Clear();
+            _report.AppendLine("╔══════════════════════════════════════════════════╗");
+            _report.AppendLine("║         ShrinkEventBus Benchmark Report          ║");
+            _report.AppendLine(
+                $"║ iter={iterations,8} mass={massIterations,6} reg={registerIterations,5} scan={scannedRegisterIterations,4} ║");
+            _report.AppendLine("╚══════════════════════════════════════════════════╝");
+            _report.AppendLine("  基准对象：独立实例 bus（AllowPerPhaseDispatch 已开启）");
+
+            Log("开始：无订阅者触发");
+            Bench_TriggerEvent_NoSubscriber();
+            await UniTask.Yield();
+
+            Log("开始：单订阅者同步触发");
+            Bench_TriggerEvent_SingleSubscriber();
+            await UniTask.Yield();
+
+            Log("开始：父事件监听子事件");
+            Bench_TriggerEvent_InheritedSubscriber();
+            await UniTask.Yield();
+
+            Log($"开始：{subscriberCount} 订阅者同步触发");
+            Bench_TriggerEvent_MassSubscribers();
+            await UniTask.Yield();
+
+            Log("开始：按 phase 分发");
+            Bench_TriggerEvent_PerPhase();
+            await UniTask.Yield();
+
+            Log("开始：异步触发");
+            await Bench_TriggerEventAsync();
+            await UniTask.Yield();
+
+            Log("开始：手工 delegate 注册/注销");
+            Bench_RegisterUnregister_ManualDelegate();
+            await UniTask.Yield();
+
+            Log("开始：实例扫描注册/注销");
+            Bench_RegisterUnregister_InstanceScan();
+            await UniTask.Yield();
+
+            Log("开始：静态类型扫描注册/注销");
+            Bench_RegisterUnregister_StaticScan();
+            await UniTask.Yield();
+
+            Log("开始：MethodInfo 注册/注销");
+            Bench_RegisterUnregister_MethodScan();
+            await UniTask.Yield();
+
+            Log("开始：EventPool vs new");
+            Bench_EventPool_vs_New();
+            await UniTask.Yield();
+
+            Log("开始：已取消事件跳过");
+            Bench_CanceledEvent_Skip();
+
+            _report.AppendLine("\n══════════════════════════════════════════════════");
+            _report.AppendLine("  全部测试完成");
+            Debug.Log(_report.ToString());
+        }
+
+        private void Bench_TriggerEvent_NoSubscriber()
+        {
+            var bus = CreateBenchmarkBus();
+            var evt = new BenchmarkEvent { Value = 1 };
+
+            Warmup(() => bus.TriggerEvent(evt), 500);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+                bus.TriggerEvent(evt);
+            sw.Stop();
+
+            Record("TriggerEvent × 无订阅者（基线）", sw.Elapsed.TotalMilliseconds, iterations);
+            Log("完成：无订阅者触发");
+        }
+
+        private void Bench_TriggerEvent_SingleSubscriber()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+
+            void Handler(BenchmarkEvent evt)
+            {
+                dummy = evt.Value;
+            }
+
+            bus.RegisterEvent<BenchmarkEvent>(Handler, EventPriority.NORMAL);
+
+            var evt = new BenchmarkEvent { Value = 1 };
+            Warmup(() => bus.TriggerEvent(evt), 500);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+                bus.TriggerEvent(evt);
+            sw.Stop();
+
+            Record("TriggerEvent × 单订阅者同步", sw.Elapsed.TotalMilliseconds, iterations);
+            Log("完成：单订阅者同步触发");
+
+            bus.UnregisterEvent<BenchmarkEvent>(Handler);
+            GC.KeepAlive(dummy);
+        }
+
+        private void Bench_TriggerEvent_InheritedSubscriber()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+
+            void Handler(BenchmarkEvent evt)
+            {
+                dummy = evt.Value;
+            }
+
+            bus.RegisterEvent<BenchmarkEvent>(Handler, EventPriority.NORMAL);
+
+            var evt = new DerivedBenchmarkEvent { Value = 1, IsDerived = true };
+            Warmup(() => bus.TriggerEvent(evt), 500);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+                bus.TriggerEvent(evt);
+            sw.Stop();
+
+            Record("TriggerEvent × 父事件监听子事件", sw.Elapsed.TotalMilliseconds, iterations);
+            Log("完成：父事件监听子事件");
+
+            bus.UnregisterEvent<BenchmarkEvent>(Handler);
+            GC.KeepAlive(dummy);
+        }
+
+        private void Bench_TriggerEvent_MassSubscribers()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+            var handlers = new Action<BenchmarkEvent>[subscriberCount];
+            for (var i = 0; i < subscriberCount; i++)
+            {
+                var captured = i;
+                handlers[i] = evt => { dummy = captured + evt.Value; };
+                bus.RegisterEvent<BenchmarkEvent>(handlers[i], EventPriority.NORMAL);
+            }
+
+            var evt = new BenchmarkEvent { Value = 1 };
+            Warmup(() => bus.TriggerEvent(evt), 100);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < massIterations; i++)
+                bus.TriggerEvent(evt);
+            sw.Stop();
+
+            Record($"TriggerEvent × {subscriberCount} 订阅者同步", sw.Elapsed.TotalMilliseconds, massIterations);
+            Log($"完成：{subscriberCount} 订阅者同步触发");
+
+            foreach (var handler in handlers)
+                bus.UnregisterEvent<BenchmarkEvent>(handler);
+
+            GC.KeepAlive(dummy);
+        }
+
+        private void Bench_TriggerEvent_PerPhase()
+        {
+            var bus = CreateBenchmarkBus();
+            var subscriber = new PhaseSubscriber();
+            bus.Register(subscriber);
+
+            var evt = new BenchmarkEvent { Value = 1 };
+            Warmup(() => bus.TriggerEvent(EventPriority.HIGH, evt), 500);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+                bus.TriggerEvent(EventPriority.HIGH, evt);
+            sw.Stop();
+
+            Record("TriggerEvent(Phase=HIGH) × 3 phase 监听", sw.Elapsed.TotalMilliseconds, iterations);
+            Log("完成：按 phase 分发");
+
+            bus.Unregister(subscriber);
+            GC.KeepAlive(subscriber.Sum);
+        }
+
+        private async UniTask Bench_TriggerEventAsync()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+
+            async UniTask Handler(BenchmarkEvent evt)
+            {
+                dummy = evt.Value;
+                await UniTask.CompletedTask;
+            }
+
+            bus.RegisterEvent<BenchmarkEvent>(Handler, EventPriority.NORMAL);
+
+            var evt = new BenchmarkEvent { Value = 1 };
+            await WarmupAsync(() => bus.TriggerEventAsync(evt), 10);
+
+            const int perFrame = 10;
+            var totalMs = 0.0;
+            var ran = 0;
+
+            while (ran < asyncIterations)
+            {
+                await UniTask.Yield();
+                var count = Math.Min(perFrame, asyncIterations - ran);
+                var sw = Stopwatch.StartNew();
+                for (var i = 0; i < count; i++)
+                    await bus.TriggerEventAsync(evt);
+                sw.Stop();
+                totalMs += sw.Elapsed.TotalMilliseconds;
+                ran += count;
+            }
+
+            Record("TriggerEventAsync × 单订阅者异步", totalMs, asyncIterations);
+            Log("完成：异步触发");
+
+            bus.UnregisterEvent<BenchmarkEvent>(Handler);
+            GC.KeepAlive(dummy);
+        }
+
+        private void Bench_RegisterUnregister_ManualDelegate()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+            var handlers = new Action<BenchmarkEvent>[registerIterations];
+            for (var i = 0; i < registerIterations; i++)
+            {
+                var captured = i;
+                handlers[i] = evt => { dummy = captured; };
+            }
+
+            var swReg = Stopwatch.StartNew();
+            for (var i = 0; i < registerIterations; i++)
+                bus.RegisterEvent<BenchmarkEvent>(handlers[i], EventPriority.NORMAL);
+            swReg.Stop();
+            Record("RegisterEvent(delegate)", swReg.Elapsed.TotalMilliseconds, registerIterations);
+
+            var swUnreg = Stopwatch.StartNew();
+            for (var i = 0; i < registerIterations; i++)
+                bus.UnregisterEvent<BenchmarkEvent>(handlers[i]);
+            swUnreg.Stop();
+            Record("UnregisterEvent(delegate)", swUnreg.Elapsed.TotalMilliseconds, registerIterations);
+            Log("完成：手工 delegate 注册/注销");
+
+            GC.KeepAlive(dummy);
+        }
+
+        private void Bench_RegisterUnregister_InstanceScan()
+        {
+            var bus = CreateBenchmarkBus();
+            var subscribers = new BenchmarkInstanceSubscriber[scannedRegisterIterations];
+            for (var i = 0; i < subscribers.Length; i++)
+                subscribers[i] = new BenchmarkInstanceSubscriber();
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < subscribers.Length; i++)
+            {
+                var subscriber = subscribers[i];
+                bus.Register(subscriber);
+                bus.Unregister(subscriber);
+            }
+
+            sw.Stop();
+            Record("Register/Unregister(instance scan)", sw.Elapsed.TotalMilliseconds, subscribers.Length);
+            Log("完成：实例扫描注册/注销");
+        }
+
+        private void Bench_RegisterUnregister_StaticScan()
+        {
+            var bus = CreateBenchmarkBus();
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < scannedRegisterIterations; i++)
+            {
+                bus.Register(typeof(BenchmarkStaticSubscriber));
+                bus.Unregister(typeof(BenchmarkStaticSubscriber));
+            }
+
+            sw.Stop();
+            Record("Register/Unregister(static type scan)", sw.Elapsed.TotalMilliseconds, scannedRegisterIterations);
+            Log("完成：静态类型扫描注册/注销");
+        }
+
+        private void Bench_RegisterUnregister_MethodScan()
+        {
+            var bus = CreateBenchmarkBus();
+            var method = typeof(BenchmarkMethodSubscriber).GetMethod("OnBenchmark",
+                BindingFlags.Static | BindingFlags.NonPublic);
+            if (method == null)
+                throw new MissingMethodException(typeof(BenchmarkMethodSubscriber).FullName, "OnBenchmark");
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < scannedRegisterIterations; i++)
+            {
+                bus.Register(method);
+                bus.Unregister(method);
+            }
+
+            sw.Stop();
+            Record("Register/Unregister(MethodInfo)", sw.Elapsed.TotalMilliseconds, scannedRegisterIterations);
+            Log("完成：MethodInfo 注册/注销");
+        }
+
+        private void Bench_EventPool_vs_New()
+        {
+            var bus = CreateBenchmarkBus();
+
+            void Handler(BenchmarkEvent evt)
+            {
+            }
+
+            bus.RegisterEvent<BenchmarkEvent>(Handler, EventPriority.NORMAL);
+
+            for (var i = 0; i < 64; i++)
+                EventPool<BenchmarkEvent>.Release(EventPool<BenchmarkEvent>.Get());
+
+            GC.Collect();
+            var gcBefore = GC.CollectionCount(0);
+            var swNew = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+            {
+                var evt = new BenchmarkEvent { Value = i };
+                bus.TriggerEvent(evt);
+            }
+
+            swNew.Stop();
+            var gcNew = GC.CollectionCount(0) - gcBefore;
+            Record($"TriggerEvent × new()      [GC Gen0={gcNew,3}]", swNew.Elapsed.TotalMilliseconds, iterations);
+
+            GC.Collect();
+            gcBefore = GC.CollectionCount(0);
+            var swPool = Stopwatch.StartNew();
+            for (var i = 0; i < iterations; i++)
+            {
+                using var evt = EventPool<BenchmarkEvent>.Get();
+                evt.Value = i;
+                bus.TriggerEvent(evt);
+            }
+
+            swPool.Stop();
+            var gcPool = GC.CollectionCount(0) - gcBefore;
+            Record($"TriggerEvent × Pool.Get() [GC Gen0={gcPool,3}]", swPool.Elapsed.TotalMilliseconds, iterations);
+            Log("完成：EventPool vs new");
+
+            bus.UnregisterEvent<BenchmarkEvent>(Handler);
+        }
+
+        private void Bench_CanceledEvent_Skip()
+        {
+            var bus = CreateBenchmarkBus();
+            var dummy = 0;
+            var handlers = new Action<CancelableBenchmarkEvent>[10];
+            for (var i = 0; i < handlers.Length; i++)
+            {
+                handlers[i] = evt => { dummy = evt.Value; };
+                bus.RegisterEvent<CancelableBenchmarkEvent>(handlers[i], EventPriority.NORMAL);
+            }
+
+            var evt = new CancelableBenchmarkEvent { Value = 1 };
+            evt.SetCanceled(true);
+
+            Warmup(() => bus.TriggerEvent(evt), 500);
+
+            var sw = Stopwatch.StartNew();
+            for (var i = 0; i < cancelIterations; i++)
+                bus.TriggerEvent(evt);
+            sw.Stop();
+
+            Record("TriggerEvent × 已取消事件跳过（10 订阅者）", sw.Elapsed.TotalMilliseconds, cancelIterations);
+            Log("完成：已取消事件跳过");
+
+            foreach (var handler in handlers)
+                bus.UnregisterEvent<CancelableBenchmarkEvent>(handler);
+
+            GC.KeepAlive(dummy);
+        }
+
+        private static IShrinkEventBus CreateBenchmarkBus()
+        {
+            return EventBus.CreateBus(builder => builder.AllowPerPhaseDispatch());
+        }
+
+        private static void Warmup(Action action, int count)
+        {
+            for (var i = 0; i < count; i++)
+                action();
+        }
+
+        private static async UniTask WarmupAsync(Func<UniTask<bool>> action, int count)
+        {
+            for (var i = 0; i < count; i++)
+                await action();
+        }
+
+        private static void Log(string msg)
+        {
+            Debug.Log($"[Benchmark] {msg}");
+        }
+
+        private void Record(string label, double totalMs, int count)
+        {
+            var perOp = totalMs / count * 1000.0;
+            var throughput = totalMs <= 0.0001 ? 0 : count / (totalMs / 1000.0);
+            _report.AppendLine($"\n  ▶ {label}");
+            _report.AppendLine($"      总耗时 : {totalMs,10:F3} ms");
+            _report.AppendLine($"      单次   : {perOp,10:F4} μs/op");
+            _report.AppendLine($"      吞吐量 : {throughput,10:F0} ops/s");
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs.meta
new file mode 100644
index 0000000..d8996d9
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusBenchmark.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9619a4dc431b4b2c8268c32a9e56f72f
+timeCreated: 1772913062
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs
new file mode 100644
index 0000000..9883a9a
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs
@@ -0,0 +1,53 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ShrinkEventBus
+{
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+    public sealed class EventBusStaticRegistryAttribute : Attribute
+    {
+        public EventBusStaticRegistryAttribute(params Type[] subscriberTypes)
+        {
+            SubscriberTypes = subscriberTypes ?? Array.Empty<Type>();
+        }
+
+        public Type[] SubscriberTypes { get; }
+    }
+
+    internal static class EventBusGeneratedRegistry
+    {
+        public static IReadOnlyList<Type> GetStaticSubscriberTypes()
+        {
+            var types = new List<Type>();
+            var seen = new HashSet<Type>();
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                object[] attributes;
+                try
+                {
+                    attributes = assembly.GetCustomAttributes(typeof(EventBusStaticRegistryAttribute), false);
+                }
+                catch
+                {
+                    continue;
+                }
+
+                foreach (var attribute in attributes.OfType<EventBusStaticRegistryAttribute>())
+                {
+                    foreach (var subscriberType in attribute.SubscriberTypes ?? Array.Empty<Type>())
+                    {
+                        if (subscriberType == null || !seen.Add(subscriberType))
+                            continue;
+
+                        types.Add(subscriberType);
+                    }
+                }
+            }
+
+            return types;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs.meta
new file mode 100644
index 0000000..f6c67f8
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusGeneratedRegistry.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 04809187aa0ce3b43a4df12b048a1c98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs
new file mode 100644
index 0000000..df2d6b6
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs
@@ -0,0 +1,193 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace ShrinkEventBus
+{
+    internal static class EventBusRegHelper
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void RegStaticEventHandler(ShrinkEventBusInstance bus)
+        {
+            if (bus == null)
+                throw new ArgumentNullException(nameof(bus));
+
+            RegisterStaticSubscriberTypes(bus, EventBusGeneratedRegistry.GetStaticSubscriberTypes());
+        }
+
+        public static void RegisterStaticSubscriberTypes(ShrinkEventBusInstance bus, IEnumerable<Type> subscriberTypes)
+        {
+            if (bus == null)
+                throw new ArgumentNullException(nameof(bus));
+            if (subscriberTypes == null)
+                throw new ArgumentNullException(nameof(subscriberTypes));
+
+            foreach (var type in subscriberTypes)
+            {
+                try
+                {
+                    if (type == null || type.GetCustomAttributes(typeof(EventBusSubscriberAttribute), false).Length == 0)
+                        continue;
+
+                    RegisterTarget(bus, type, requireSubscriberAttribute: true, lenientWhenNoMethods: true);
+                }
+                catch (Exception ex)
+                {
+                    _ = ex;
+#if UNITY_EDITOR
+                    Debug.LogWarning($"[EventBus] Static registration failed for {type?.FullName}: {ex.Message}");
+#endif
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void RegisterTarget(ShrinkEventBusInstance bus, object target, bool requireSubscriberAttribute,
+            bool lenientWhenNoMethods = false)
+        {
+            if (bus == null)
+                throw new ArgumentNullException(nameof(bus));
+            if (target == null)
+                throw new ArgumentNullException(nameof(target));
+
+            switch (target)
+            {
+                case MethodInfo method:
+                    RegisterMethod(bus, null, method, requireSubscriberAttribute: false, isStaticRegistration: true);
+                    return;
+                case Type staticType:
+                    RegisterDeclaredMethods(bus, null, staticType, requireSubscriberAttribute,
+                        isStaticRegistration: true, lenientWhenNoMethods);
+                    return;
+                default:
+                    RegisterDeclaredMethods(bus, target, target.GetType(), requireSubscriberAttribute,
+                        isStaticRegistration: false, lenientWhenNoMethods);
+                    return;
+            }
+        }
+
+        private static void RegisterDeclaredMethods(ShrinkEventBusInstance bus, object? target, Type type,
+            bool requireSubscriberAttribute, bool isStaticRegistration, bool lenientWhenNoMethods)
+        {
+            if (requireSubscriberAttribute &&
+                type.GetCustomAttributes(typeof(EventBusSubscriberAttribute), false).Length == 0)
+            {
+                throw new InvalidOperationException(
+                    $"Type {type.FullName} must declare [EventBusSubscriber] before it can be auto-registered.");
+            }
+
+            var flags = (isStaticRegistration ? BindingFlags.Static : BindingFlags.Instance) |
+                        BindingFlags.Public | BindingFlags.NonPublic;
+            var methods = type.GetMethods(flags);
+            var foundMethods = 0;
+            foreach (var method in methods)
+            {
+                var hasSubscribeAttribute = method.GetCustomAttributes(typeof(EventSubscribeAttribute), false).Length > 0;
+                if (!hasSubscribeAttribute)
+                    continue;
+
+                if (method.IsStatic != isStaticRegistration)
+                {
+                    var expected = isStaticRegistration ? "static" : "instance";
+                    throw new InvalidOperationException(
+                        $"Method {method} is annotated with [EventSubscribe] but does not match the expected {expected} registration mode.");
+                }
+
+                RegisterMethod(bus, target, method, requireSubscriberAttribute: false, isStaticRegistration);
+                foundMethods++;
+            }
+
+            if (foundMethods == 0)
+            {
+                var message =
+                    $"Type {type.FullName} has no [EventSubscribe] methods for {(isStaticRegistration ? "static" : "instance")} registration.";
+                if (lenientWhenNoMethods)
+                {
+                    Debug.LogWarning($"[EventBus] {message} Auto-registration skipped.");
+                    return;
+                }
+
+                throw new InvalidOperationException(message);
+            }
+        }
+
+        private static void RegisterMethod(ShrinkEventBusInstance bus, object? target, MethodInfo method,
+            bool requireSubscriberAttribute, bool isStaticRegistration)
+        {
+            if (method == null)
+                throw new ArgumentNullException(nameof(method));
+
+            if (!method.IsDefined(typeof(EventSubscribeAttribute), false))
+                throw new InvalidOperationException($"Method {method} is not annotated with [EventSubscribe].");
+
+            if (method.IsStatic != isStaticRegistration)
+            {
+                var expected = isStaticRegistration ? "static" : "instance";
+                throw new InvalidOperationException(
+                    $"Method {method} is annotated with [EventSubscribe] but does not match the expected {expected} registration mode.");
+            }
+
+            if (requireSubscriberAttribute && method.DeclaringType != null &&
+                method.DeclaringType.GetCustomAttributes(typeof(EventBusSubscriberAttribute), false).Length == 0)
+            {
+                throw new InvalidOperationException(
+                    $"Type {method.DeclaringType.FullName} must declare [EventBusSubscriber] before it can be auto-registered.");
+            }
+
+            var subscribeAttr = (EventSubscribeAttribute)method.GetCustomAttributes(typeof(EventSubscribeAttribute), false)[0];
+            var parameters = method.GetParameters();
+            if (parameters.Length != 1)
+            {
+                throw new InvalidOperationException(
+                    $"Method {method} has [EventSubscribe] but declares {parameters.Length} parameters. Event handlers must declare exactly one EventBase parameter.");
+            }
+
+            var parameterType = parameters[0].ParameterType;
+            if (!typeof(EventBase).IsAssignableFrom(parameterType))
+            {
+                throw new InvalidOperationException(
+                    $"Method {method} has [EventSubscribe] but parameter {parameterType.FullName} does not inherit from EventBase.");
+            }
+
+            ProcessMethodRegistration(bus, target, method, subscribeAttr, parameterType);
+        }
+
+        private static void ProcessMethodRegistration(ShrinkEventBusInstance bus, object? target, MethodInfo method,
+            EventSubscribeAttribute subscribeAttr, Type parameterType)
+        {
+            string scope = target == null ? "Static" : "Instance";
+            string typeName = target == null ? method.DeclaringType?.Name ?? "Unknown" : target.GetType().Name;
+
+            if (method.ReturnType == typeof(UniTask))
+            {
+                var funcType = typeof(Func<,>).MakeGenericType(parameterType, typeof(UniTask));
+                var handlerDelegate = target == null
+                    ? Delegate.CreateDelegate(funcType, method)
+                    : Delegate.CreateDelegate(funcType, target, method);
+                bus.RegisterEventInternal(parameterType, handlerDelegate, subscribeAttr.Priority,
+                    subscribeAttr.NumericPriority, subscribeAttr.ReceiveCanceled,
+                    $"{scope} {typeName}.{method.Name} (UniTask)", method);
+                return;
+            }
+
+            if (method.ReturnType == typeof(void))
+            {
+                var actionType = typeof(Action<>).MakeGenericType(parameterType);
+                var actionDelegate = target == null
+                    ? Delegate.CreateDelegate(actionType, method)
+                    : Delegate.CreateDelegate(actionType, target, method);
+                bus.RegisterEventInternal(parameterType, actionDelegate, subscribeAttr.Priority,
+                    subscribeAttr.NumericPriority, subscribeAttr.ReceiveCanceled,
+                    $"{scope} {typeName}.{method.Name} (Sync)", method);
+                return;
+            }
+
+            throw new InvalidOperationException(
+                $"Method {method} has [EventSubscribe] but return type {method.ReturnType.FullName} is unsupported. Use void or UniTask.");
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs.meta
new file mode 100644
index 0000000..05ebd35
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a237a407a3a42394eba27bc8e4dbdce2
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs
new file mode 100644
index 0000000..96aaac4
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace ShrinkEventBus
+{
+    internal static class EventCloneUtility
+    {
+        private static readonly object CacheLock = new();
+        private static readonly Dictionary<Type, FieldInfo[]> FieldCache = new();
+
+        public static TEvent CloneForDetachedDispatch<TEvent>(TEvent source) where TEvent : EventBase
+        {
+            if (source == null)
+                throw new ArgumentNullException(nameof(source));
+
+            if (Activator.CreateInstance(source.GetType()) is not TEvent clone)
+                throw new InvalidOperationException(
+                    $"Cannot clone event type {source.GetType().FullName}. A public parameterless constructor is required.");
+
+            // 先固化 EventId，让克隆与原事件共享同一个派发标识
+            _ = source.EventId;
+            CopyFields(source, clone);
+            clone.ReleaseAction = null;
+            clone.IsInPool = false;
+            return clone;
+        }
+
+        private static void CopyFields(EventBase source, EventBase target)
+        {
+            var fields = GetCopyableFields(source.GetType());
+            for (var i = 0; i < fields.Length; i++)
+                fields[i].SetValue(target, fields[i].GetValue(source));
+        }
+
+        private static FieldInfo[] GetCopyableFields(Type type)
+        {
+            lock (CacheLock)
+            {
+                if (FieldCache.TryGetValue(type, out var cached))
+                    return cached;
+
+                var fields = new List<FieldInfo>();
+                var currentType = type;
+                while (currentType != null && currentType != typeof(object))
+                {
+                    var declaredFields = currentType.GetFields(BindingFlags.Instance | BindingFlags.Public |
+                                                               BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
+                    for (var i = 0; i < declaredFields.Length; i++)
+                    {
+                        var field = declaredFields[i];
+                        if (field.IsStatic)
+                            continue;
+                        if (ShouldSkipField(field))
+                            continue;
+
+                        fields.Add(field);
+                    }
+
+                    currentType = currentType.BaseType;
+                }
+
+                cached = fields.ToArray();
+                FieldCache[type] = cached;
+                return cached;
+            }
+        }
+
+        private static bool ShouldSkipField(FieldInfo field)
+        {
+            return field.Name is "<ReleaseAction>k__BackingField"
+                or "<IsInPool>k__BackingField";
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs.meta
new file mode 100644
index 0000000..489c6b8
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventCloneUtility.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 876564c111495b2489870b29ab75da5e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs
new file mode 100644
index 0000000..30cf122
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Reflection;
+using Cysharp.Threading.Tasks;
+#pragma warning disable CS8632 // 只能在 "#nullable" 注释上下文内的代码中使用可为 null 的引用类型的注释。
+
+
+namespace ShrinkEventBus
+{
+    public interface IMethodWrapper
+    {
+        MethodInfo OriginalMethod { get; }
+    }
+
+    public class EventHandlerInfo
+    {
+        public long SubscriptionId { get; }
+        public Delegate Handler { get; }
+        internal Action<EventBase>? SyncInvoker { get; }
+        internal Func<EventBase, UniTask>? AsyncInvoker { get; }
+        public EventPriority Priority { get; }
+        public int NumericPriority { get; }
+        public bool ReceiveCanceled { get; }
+        public object? Target { get; }
+        public MethodInfo Method { get; }
+        public string DebugInfo { get; }
+        public Type DeclaringType { get; }
+        public string MethodName { get; }
+        public MethodInfo? OriginalMethod { get; }
+        public string OriginalMethodName { get; }
+        public Type? OriginalDeclaringType { get; }
+        public DateTime RegisteredAtUtc { get; }
+
+        private EventHandlerInfo(long subscriptionId, Delegate handler, Action<EventBase>? syncInvoker,
+            Func<EventBase, UniTask>? asyncInvoker,
+            EventPriority priority, int numericPriority, bool receiveCanceled, string debugInfo = "",
+            MethodInfo? originalMethod = null)
+        {
+            SubscriptionId = subscriptionId;
+            Handler = handler;
+            SyncInvoker = syncInvoker;
+            AsyncInvoker = asyncInvoker;
+            Priority = priority;
+            NumericPriority = numericPriority;
+            ReceiveCanceled = receiveCanceled;
+            Target = handler.Target;
+            Method = handler.Method;
+            DebugInfo = debugInfo;
+            DeclaringType = Method.DeclaringType ?? typeof(object);
+            MethodName = Method.Name;
+
+            OriginalMethod = ExtractOriginalMethodFromWrapper(handler) ?? originalMethod;
+
+            if (OriginalMethod != null)
+            {
+                OriginalMethodName = OriginalMethod.Name;
+                OriginalDeclaringType = OriginalMethod.DeclaringType;
+            }
+            else
+            {
+                OriginalMethodName = MethodName;
+                OriginalDeclaringType = DeclaringType;
+            }
+
+            RegisteredAtUtc = DateTime.UtcNow;
+        }
+
+        private static MethodInfo? ExtractOriginalMethodFromWrapper(Delegate handler)
+        {
+            if (handler.Target is IMethodWrapper wrapper)
+            {
+                return wrapper.OriginalMethod;
+            }
+
+            return null;
+        }
+
+        public string DisplayMethodName => OriginalMethodName;
+        public Type DisplayDeclaringType => OriginalDeclaringType ?? DeclaringType;
+
+        public bool MatchesMethod(MethodInfo method)
+        {
+            return method != null && (ReferenceEquals(Method, method) || ReferenceEquals(OriginalMethod, method));
+        }
+
+        public bool MatchesDeclaringType(Type declaringType)
+        {
+            return declaringType != null &&
+                   (DeclaringType == declaringType || OriginalDeclaringType == declaringType);
+        }
+
+        public static EventHandlerInfo Create(long subscriptionId, Delegate handler, Type eventType,
+            EventPriority priority, int numericPriority, bool receiveCanceled, string debugInfo = "",
+            MethodInfo? originalMethod = null)
+        {
+            if (handler == null)
+                throw new System.ArgumentNullException(nameof(handler));
+            if (eventType == null)
+                throw new System.ArgumentNullException(nameof(eventType));
+
+            Action<EventBase>? syncInvoker = null;
+            Func<EventBase, UniTask>? asyncInvoker = null;
+            if (handler.Method.ReturnType == typeof(void))
+                syncInvoker = CreateSyncInvoker(eventType, handler);
+            else if (handler.Method.ReturnType == typeof(UniTask))
+                asyncInvoker = CreateAsyncInvoker(eventType, handler);
+            else
+                throw new System.ArgumentException(
+                    $"Unsupported event handler return type {handler.Method.ReturnType.FullName} for {handler.Method}.");
+
+            return new EventHandlerInfo(subscriptionId, handler, syncInvoker, asyncInvoker, priority, numericPriority,
+                receiveCanceled, debugInfo, originalMethod);
+        }
+
+        private static Action<EventBase> CreateSyncInvoker(Type eventType, Delegate handler)
+        {
+            var factory = typeof(EventHandlerInfo).GetMethod(nameof(CreateSyncInvokerGeneric),
+                BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(eventType);
+            return (Action<EventBase>)factory.Invoke(null, new object[] { handler })!;
+        }
+
+        private static Func<EventBase, UniTask> CreateAsyncInvoker(Type eventType, Delegate handler)
+        {
+            var factory = typeof(EventHandlerInfo).GetMethod(nameof(CreateAsyncInvokerGeneric),
+                BindingFlags.NonPublic | BindingFlags.Static)!.MakeGenericMethod(eventType);
+            return (Func<EventBase, UniTask>)factory.Invoke(null, new object[] { handler })!;
+        }
+
+        private static Action<EventBase> CreateSyncInvokerGeneric<TEvent>(Delegate handler) where TEvent : EventBase
+        {
+            var typedHandler = (Action<TEvent>)handler;
+            return eventArgs => typedHandler((TEvent)eventArgs);
+        }
+
+        private static Func<EventBase, UniTask> CreateAsyncInvokerGeneric<TEvent>(Delegate handler)
+            where TEvent : EventBase
+        {
+            var typedHandler = (Func<TEvent, UniTask>)handler;
+            return eventArgs => typedHandler((TEvent)eventArgs);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs.meta
new file mode 100644
index 0000000..463d79f
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 19972a32cbf54c7f94d6214fde5635c2
+timeCreated: 1760098840
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs
new file mode 100644
index 0000000..fab4bb1
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+
+namespace ShrinkEventBus
+{
+    public static class EventPool<T> where T : EventBase, new()
+    {
+        private const int MaxPoolSize = 128;
+
+        private static readonly Stack<T> Pool = new(32);
+        private static readonly object Lock = new();
+        private static readonly Action<EventBase> CachedReleaseAction = e => Release((T)e);
+
+        public static T Get()
+        {
+            lock (Lock)
+            {
+                if (Pool.Count > 0)
+                {
+                    var evt = Pool.Pop();
+                    evt.IsInPool = false;
+                    return evt;
+                }
+            }
+
+            var newEvt = new T();
+            newEvt.ReleaseAction = CachedReleaseAction;
+            return newEvt;
+        }
+
+        public static void Release(T evt)
+        {
+            if (evt == null)
+                return;
+
+            lock (Lock)
+            {
+                if (evt.IsInPool || Pool.Count >= MaxPoolSize)
+                    return;
+
+                evt.ResetInternal();
+                evt.IsInPool = true;
+                Pool.Push(evt);
+            }
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs.meta
new file mode 100644
index 0000000..d0aecaf
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c59d817792dd40f08ffed2f1a8d65cb8
+timeCreated: 1772891540
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs
new file mode 100644
index 0000000..852c5e7
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs
@@ -0,0 +1,27 @@
+namespace ShrinkEventBus
+{
+    public enum EventPriority
+    {
+        HIGHEST = 0,
+        HIGH = 1,
+        NORMAL = 2,
+        LOW = 3,
+        LOWEST = 4,
+        MONITOR = 5
+    }
+
+    internal static class PriorityHelper
+    {
+        public static EventPriority ConvertToEventPriority(int numericPriority)
+        {
+            return numericPriority switch
+            {
+                >= 100 => EventPriority.HIGHEST,
+                >= 50 => EventPriority.HIGH,
+                >= 0 => EventPriority.NORMAL,
+                >= -50 => EventPriority.LOW,
+                _ => EventPriority.LOWEST
+            };
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs.meta
new file mode 100644
index 0000000..c7fdea4
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventPriority.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c77c5178c66948f29a7c87c9ae203004
+timeCreated: 1760098774
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs b/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs
new file mode 100644
index 0000000..777d021
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs
@@ -0,0 +1,9 @@
+namespace ShrinkEventBus
+{
+    public enum EventResult
+    {
+        DEFAULT,
+        ALLOW,
+        DENY
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs.meta
new file mode 100644
index 0000000..b18a52d
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/EventResult.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d5213a68ce8f433a98f272904a5d7bd2
+timeCreated: 1760098791
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs b/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs
new file mode 100644
index 0000000..a652fdf
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs
@@ -0,0 +1,20 @@
+using System;
+
+namespace ShrinkEventBus
+{
+    public class UnsupportedOperationException : InvalidOperationException
+    {
+        public UnsupportedOperationException() : base()
+        {
+        }
+
+        public UnsupportedOperationException(string message) : base(message)
+        {
+        }
+
+        public UnsupportedOperationException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs.meta
new file mode 100644
index 0000000..a3f533d
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/Exceptions.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 893fdc450e7a4a8e8e1b675f0ce084a7
+timeCreated: 1760098825
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs b/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs
new file mode 100644
index 0000000..06bbb6e
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Cysharp.Threading.Tasks;
+
+namespace ShrinkEventBus
+{
+    public interface IShrinkEventSubscription : IDisposable
+    {
+        long SubscriptionId { get; }
+        bool IsDisposed { get; }
+    }
+
+    public readonly struct ShrinkEventSubscriptionSnapshot
+    {
+        public ShrinkEventSubscriptionSnapshot(long subscriptionId, Type eventType, EventPriority priority,
+            int numericPriority, bool receiveCanceled, object target, string targetTypeName, string methodName,
+            string debugInfo, DateTime registeredAtUtc)
+        {
+            SubscriptionId = subscriptionId;
+            EventType = eventType ?? throw new ArgumentNullException(nameof(eventType));
+            Priority = priority;
+            NumericPriority = numericPriority;
+            ReceiveCanceled = receiveCanceled;
+            Target = target;
+            TargetTypeName = targetTypeName ?? string.Empty;
+            MethodName = methodName ?? string.Empty;
+            DebugInfo = debugInfo ?? string.Empty;
+            RegisteredAtUtc = registeredAtUtc;
+        }
+
+        public long SubscriptionId { get; }
+        public Type EventType { get; }
+        public EventPriority Priority { get; }
+        public int NumericPriority { get; }
+        public bool ReceiveCanceled { get; }
+        public object Target { get; }
+        public string TargetTypeName { get; }
+        public string MethodName { get; }
+        public string DebugInfo { get; }
+        public DateTime RegisteredAtUtc { get; }
+        public bool IsStaticHandler => Target == null;
+    }
+
+    public interface IShrinkEventBus
+    {
+        event Action<EventBase, Type> OnEventTriggered;
+
+#if UNITY_EDITOR
+        event Action<EventBase, string, string, EventHandlerInfo[]> OnEventTriggeredForEditor;
+        bool EnableDebugRecord { get; set; }
+#endif
+
+        bool IsStarted { get; }
+
+        void Start();
+        void AutoRegister(object target);
+        void Register(object target);
+        void Unregister(object target);
+
+        void RegisterEvent<TEvent>(Action<TEvent> handler, EventPriority priority = EventPriority.NORMAL,
+            bool receiveCanceled = false) where TEvent : EventBase;
+        void RegisterEvent<TEvent>(Action<TEvent> handler, int priority) where TEvent : EventBase;
+        void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, EventPriority priority = EventPriority.NORMAL,
+            bool receiveCanceled = false) where TEvent : EventBase;
+        void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, int priority) where TEvent : EventBase;
+        IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase;
+        IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler, int priority)
+            where TEvent : EventBase;
+        IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase;
+        IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
+            where TEvent : EventBase;
+
+        void UnregisterEvent<TEvent>(Action<TEvent> handler) where TEvent : EventBase;
+        void UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler) where TEvent : EventBase;
+        void ClearAllSubscribersForEvent<TEvent>() where TEvent : EventBase;
+        void UnregisterAllEventsForObject(object targetObject);
+        void UnregisterAllEvents();
+
+        bool TriggerEvent<TEvent>(TEvent eventArgs) where TEvent : EventBase;
+        bool TriggerEvent<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase;
+        UniTask<bool> TriggerEventAsync<TEvent>(TEvent eventArgs) where TEvent : EventBase;
+        UniTask<bool> TriggerEventAsync<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase;
+
+        EventHandlerInfo[] GetEventSubscribers<TEvent>() where TEvent : EventBase;
+        ListenerList GetListenerList<TEvent>() where TEvent : EventBase;
+        IReadOnlyDictionary<Type, EventHandlerInfo[]> GetAllSubscribersSnapshot();
+        IReadOnlyList<ShrinkEventSubscriptionSnapshot> GetActiveSubscriptionsSnapshot();
+
+        bool IsInstanceRegistered(object target);
+        int GetRegisteredInstanceCount();
+        int GetRegisteredEventTypeCount();
+    }
+
+    public interface IShrinkEventExceptionHandler
+    {
+        void HandleException(IShrinkEventBus bus, EventBase eventArgs, EventHandlerInfo[] listeners, int index,
+            Exception exception);
+    }
+
+    public enum ShrinkEventExceptionHandlingMode
+    {
+        LogAndContinue,
+        Throw,
+        LogAndThrow
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs.meta
new file mode 100644
index 0000000..a95c735
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/IShrinkEventBus.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cb69f308f5c727542ac602709b02c628
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs b/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs
new file mode 100644
index 0000000..c214786
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs
@@ -0,0 +1,262 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+
+namespace ShrinkEventBus
+{
+    public class ListenerList
+    {
+        private static readonly EventPriority[] Priorities = (EventPriority[])Enum.GetValues(typeof(EventPriority));
+
+        private readonly object _lock;
+        private readonly List<EventHandlerInfo>[] _priorityBuckets;
+        private readonly ListenerList? _parent;
+        private List<ListenerList>? _children;
+        private EventHandlerInfo[] _snapshot = Array.Empty<EventHandlerInfo>();
+        private readonly EventHandlerInfo[]?[] _phaseSnapshots = new EventHandlerInfo[Priorities.Length][];
+        private bool _dirty;
+
+        public ListenerList(ListenerList? parent = null) : this(parent, null)
+        {
+        }
+
+        // 同一条父子链必须共用一把锁，否则脏标记传播与快照重建会产生竞态
+        internal ListenerList(ListenerList? parent, object? sharedLock)
+        {
+            _lock = sharedLock ?? parent?._lock ?? new object();
+            _priorityBuckets = new List<EventHandlerInfo>[Priorities.Length];
+            for (var i = 0; i < _priorityBuckets.Length; i++)
+                _priorityBuckets[i] = new List<EventHandlerInfo>();
+
+            _parent = parent;
+            _parent?.AddChild(this);
+            _dirty = true;
+        }
+
+        public int LocalCount
+        {
+            get
+            {
+                lock (_lock)
+                {
+                    var count = 0;
+                    foreach (var list in _priorityBuckets)
+                        count += list.Count;
+                    return count;
+                }
+            }
+        }
+
+        public int Count => GetHandlers().Length;
+
+        public void Add(EventHandlerInfo info)
+        {
+            if (info == null)
+                throw new ArgumentNullException(nameof(info));
+
+            lock (_lock)
+            {
+                var list = _priorityBuckets[(int)info.Priority];
+                var index = BinarySearchInsertIndex(list, info.NumericPriority);
+                list.Insert(index, info);
+                MarkDirty();
+            }
+        }
+
+        public bool Remove(Delegate handler)
+        {
+            if (handler == null)
+                return false;
+
+            lock (_lock)
+            {
+                foreach (var list in _priorityBuckets)
+                {
+                    for (var i = 0; i < list.Count; i++)
+                    {
+                        if (!list[i].Handler.Equals(handler))
+                            continue;
+
+                        list.RemoveAt(i);
+                        MarkDirty();
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        public int RemoveWhere(Predicate<EventHandlerInfo> predicate)
+        {
+            if (predicate == null)
+                return 0;
+
+            lock (_lock)
+            {
+                var removedCount = 0;
+                foreach (var list in _priorityBuckets)
+                {
+                    for (var i = list.Count - 1; i >= 0; i--)
+                    {
+                        if (!predicate(list[i]))
+                            continue;
+
+                        list.RemoveAt(i);
+                        removedCount++;
+                    }
+                }
+
+                if (removedCount > 0)
+                    MarkDirty();
+
+                return removedCount;
+            }
+        }
+
+        public void RemoveTarget(object target)
+        {
+            if (target == null)
+                return;
+
+            lock (_lock)
+            {
+                var removed = false;
+                foreach (var list in _priorityBuckets)
+                {
+                    for (var i = list.Count - 1; i >= 0; i--)
+                    {
+                        if (!ReferenceEquals(list[i].Target, target))
+                            continue;
+
+                        list.RemoveAt(i);
+                        removed = true;
+                    }
+                }
+
+                if (removed)
+                    MarkDirty();
+            }
+        }
+
+        public EventHandlerInfo[] GetHandlers()
+        {
+            lock (_lock)
+            {
+                if (_dirty)
+                    RebuildSnapshot();
+
+                return _snapshot;
+            }
+        }
+
+        public EventHandlerInfo[] GetHandlers(EventPriority priority)
+        {
+            lock (_lock)
+            {
+                if (_dirty)
+                    RebuildSnapshot();
+
+                return _phaseSnapshots[(int)priority] ?? Array.Empty<EventHandlerInfo>();
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_lock)
+            {
+                foreach (var list in _priorityBuckets)
+                    list.Clear();
+                MarkDirty();
+            }
+        }
+
+        private void AddChild(ListenerList child)
+        {
+            if (child == null)
+                return;
+
+            lock (_lock)
+            {
+                _children ??= new List<ListenerList>(2);
+                _children.Add(child);
+            }
+        }
+
+        private void MarkDirty()
+        {
+            _dirty = true;
+            _snapshot = Array.Empty<EventHandlerInfo>();
+            Array.Clear(_phaseSnapshots, 0, _phaseSnapshots.Length);
+
+            if (_children == null)
+                return;
+
+            for (var i = 0; i < _children.Count; i++)
+                _children[i].MarkDirty();
+        }
+
+        private void RebuildSnapshot()
+        {
+            var merged = new List<EventHandlerInfo>();
+
+            for (var i = 0; i < Priorities.Length; i++)
+            {
+                var parentHandlers = _parent != null
+                    ? _parent.GetHandlers(Priorities[i])
+                    : Array.Empty<EventHandlerInfo>();
+
+                var phaseSnapshot = MergeByNumericPriority(_priorityBuckets[i], parentHandlers);
+                _phaseSnapshots[i] = phaseSnapshot;
+                merged.AddRange(phaseSnapshot);
+            }
+
+            _snapshot = merged.ToArray();
+            _dirty = false;
+        }
+
+        // 两侧均已按 NumericPriority 降序排列；平局时本类型 handler 在前
+        private static EventHandlerInfo[] MergeByNumericPriority(List<EventHandlerInfo> own,
+            EventHandlerInfo[] parentHandlers)
+        {
+            if (parentHandlers.Length == 0)
+                return own.ToArray();
+            if (own.Count == 0)
+                return parentHandlers;
+
+            var result = new EventHandlerInfo[own.Count + parentHandlers.Length];
+            int i = 0, j = 0, k = 0;
+            while (i < own.Count && j < parentHandlers.Length)
+            {
+                result[k++] = parentHandlers[j].NumericPriority > own[i].NumericPriority
+                    ? parentHandlers[j++]
+                    : own[i++];
+            }
+
+            while (i < own.Count)
+                result[k++] = own[i++];
+            while (j < parentHandlers.Length)
+                result[k++] = parentHandlers[j++];
+
+            return result;
+        }
+
+        private static int BinarySearchInsertIndex(List<EventHandlerInfo> list, int numericPriority)
+        {
+            var lo = 0;
+            var hi = list.Count;
+
+            while (lo < hi)
+            {
+                var mid = (lo + hi) >> 1;
+                var cmp = numericPriority.CompareTo(list[mid].NumericPriority);
+                if (cmp > 0)
+                    hi = mid;
+                else
+                    lo = mid + 1;
+            }
+
+            return lo;
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs.meta
new file mode 100644
index 0000000..9a41846
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 864eb3e7bf8f443c86472995e408c580
+timeCreated: 1760098877
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef
new file mode 100644
index 0000000..9b2a8d4
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef
@@ -0,0 +1,12 @@
+{
+    "name": "ShrinkEventBus.Runtime",
+    "rootNamespace": "ShrinkEventBus",
+    "references": [
+        "UniTask"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "autoReferenced": true
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef.meta b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef.meta
new file mode 100644
index 0000000..b34cc54
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f9a7e109b2ecd4946ba9202d2288af15
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs
new file mode 100644
index 0000000..09f1cc3
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs
@@ -0,0 +1,76 @@
+#nullable enable
+using System;
+
+namespace ShrinkEventBus
+{
+    public sealed class ShrinkEventBusBuilder
+    {
+        internal IShrinkEventExceptionHandler? ExceptionHandler { get; private set; }
+        internal ShrinkEventExceptionHandlingMode ExceptionHandlingMode { get; private set; } =
+            ShrinkEventExceptionHandlingMode.LogAndContinue;
+        internal Action<Type>? EventClassChecker { get; private set; }
+        internal bool StartShutdownEnabled { get; private set; }
+        internal bool CheckTypesOnDispatchEnabled { get; private set; }
+        internal bool AllowPerPhaseDispatchEnabled { get; private set; }
+
+        public ShrinkEventBusBuilder SetExceptionHandler(IShrinkEventExceptionHandler handler)
+        {
+            ExceptionHandler = handler ?? throw new ArgumentNullException(nameof(handler));
+            return this;
+        }
+
+        public ShrinkEventBusBuilder SetExceptionHandlingMode(ShrinkEventExceptionHandlingMode mode)
+        {
+            ExceptionHandlingMode = mode;
+            return this;
+        }
+
+        public ShrinkEventBusBuilder StartShutdown()
+        {
+            StartShutdownEnabled = true;
+            return this;
+        }
+
+        public ShrinkEventBusBuilder CheckTypesOnDispatch()
+        {
+            CheckTypesOnDispatchEnabled = true;
+            return this;
+        }
+
+        public ShrinkEventBusBuilder AllowPerPhaseDispatch()
+        {
+            AllowPerPhaseDispatchEnabled = true;
+            return this;
+        }
+
+        public ShrinkEventBusBuilder ClassChecker(Action<Type> checker)
+        {
+            if (checker == null)
+                throw new ArgumentNullException(nameof(checker));
+
+            EventClassChecker = EventClassChecker == null
+                ? checker
+                : EventClassChecker + checker;
+            return this;
+        }
+
+        public ShrinkEventBusBuilder MarkerInterface<TMarker>() where TMarker : class
+        {
+            var markerType = typeof(TMarker);
+            if (!markerType.IsInterface)
+                throw new InvalidOperationException($"Marker type {markerType.FullName} must be an interface.");
+
+            return ClassChecker(eventType =>
+            {
+                if (!markerType.IsAssignableFrom(eventType))
+                    throw new ArgumentException(
+                        $"This bus only accepts events assignable to {markerType.FullName}, but got {eventType.FullName}.");
+            });
+        }
+
+        public IShrinkEventBus Build()
+        {
+            return new ShrinkEventBusInstance(this);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs.meta
new file mode 100644
index 0000000..97c4091
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aad8b06ecb53b8a4998fd9944673e537
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs
new file mode 100644
index 0000000..4816766
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs
@@ -0,0 +1,718 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace ShrinkEventBus
+{
+    internal sealed class ShrinkEventBusInstance : IShrinkEventBus
+    {
+        private sealed class EventSubscription : IShrinkEventSubscription
+        {
+            private readonly ShrinkEventBusInstance _owner;
+            private bool _disposed;
+
+            public EventSubscription(ShrinkEventBusInstance owner, long subscriptionId)
+            {
+                _owner = owner ?? throw new ArgumentNullException(nameof(owner));
+                SubscriptionId = subscriptionId;
+            }
+
+            public long SubscriptionId { get; }
+            public bool IsDisposed => _disposed;
+
+            public void Dispose()
+            {
+                if (_disposed)
+                    return;
+
+                _disposed = true;
+                _owner.UnregisterSubscription(SubscriptionId);
+            }
+        }
+
+        private readonly Dictionary<Type, ListenerList> _eventHandlers = new();
+        private readonly HashSet<object> _registeredTargets = new();
+        private readonly object _listenerLock = new();
+        private readonly object _registrationLock = new();
+        private long _nextSubscriptionId;
+        private readonly IShrinkEventExceptionHandler? _exceptionHandler;
+        private readonly ShrinkEventExceptionHandlingMode _exceptionHandlingMode;
+        private readonly Action<Type>? _eventClassChecker;
+        private readonly bool _checkTypesOnDispatch;
+        private readonly bool _allowPerPhaseDispatch;
+
+        public event Action<EventBase, Type>? OnEventTriggered;
+
+#if UNITY_EDITOR
+        public bool EnableDebugRecord { get; set; }
+        public event Action<EventBase, string, string, EventHandlerInfo[]>? OnEventTriggeredForEditor;
+#endif
+
+        public bool IsStarted { get; private set; }
+
+        public ShrinkEventBusInstance(ShrinkEventBusBuilder builder)
+        {
+            if (builder == null)
+                throw new ArgumentNullException(nameof(builder));
+
+            _exceptionHandler = builder.ExceptionHandler;
+            _exceptionHandlingMode = builder.ExceptionHandlingMode;
+            _eventClassChecker = builder.EventClassChecker;
+            _checkTypesOnDispatch = builder.CheckTypesOnDispatchEnabled;
+            _allowPerPhaseDispatch = builder.AllowPerPhaseDispatchEnabled;
+            IsStarted = !builder.StartShutdownEnabled;
+        }
+
+        public void Start()
+        {
+            IsStarted = true;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AutoRegister(object target)
+        {
+            RegisterCore(target, requireSubscriberAttribute: true, lenientWhenNoMethods: true);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Register(object target)
+        {
+            RegisterCore(target, requireSubscriberAttribute: false, lenientWhenNoMethods: false);
+        }
+
+        public void Unregister(object target)
+        {
+            if (target == null)
+                return;
+
+            lock (_registrationLock)
+            {
+                _registeredTargets.Remove(target);
+            }
+
+            switch (target)
+            {
+                case Delegate handler:
+                    RemoveHandlers(info => Equals(info.Handler, handler));
+                    return;
+                case MethodInfo method:
+                    RemoveHandlers(info => info.MatchesMethod(method));
+                    return;
+                case Type declaringType:
+                    RemoveHandlers(info => info.Target == null && info.MatchesDeclaringType(declaringType));
+                    return;
+                default:
+                    UnregisterAllEventsForObject(target);
+                    return;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
+            where TEvent : EventBase
+        {
+            var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
+            RegisterEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
+                $"Manual Async Handler (Priority: {priority})");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void RegisterEvent<TEvent>(Action<TEvent> handler, EventPriority priority = EventPriority.NORMAL,
+            bool receiveCanceled = false) where TEvent : EventBase
+        {
+            RegisterEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
+                $"Manual Sync Handler (Priority: {priority})", handler.Method);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void RegisterEvent<TEvent>(Action<TEvent> handler, int priority) where TEvent : EventBase
+        {
+            var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
+            RegisterEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
+                $"Manual Sync Handler (Priority: {priority})", handler.Method);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void RegisterEvent<TEvent>(Func<TEvent, UniTask> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase
+        {
+            RegisterEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
+                $"Manual Async Handler (Priority: {priority})");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase
+        {
+            return SubscribeEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
+                $"Manual Sync Subscription (Priority: {priority})", handler.Method);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IShrinkEventSubscription SubscribeEvent<TEvent>(Action<TEvent> handler, int priority)
+            where TEvent : EventBase
+        {
+            var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
+            return SubscribeEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
+                $"Manual Sync Subscription (Priority: {priority})", handler.Method);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler,
+            EventPriority priority = EventPriority.NORMAL, bool receiveCanceled = false) where TEvent : EventBase
+        {
+            return SubscribeEventInternal(typeof(TEvent), handler, priority, 0, receiveCanceled,
+                $"Manual Async Subscription (Priority: {priority})");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public IShrinkEventSubscription SubscribeEvent<TEvent>(Func<TEvent, UniTask> handler, int priority)
+            where TEvent : EventBase
+        {
+            var eventPriority = PriorityHelper.ConvertToEventPriority(priority);
+            return SubscribeEventInternal(typeof(TEvent), handler, eventPriority, priority, false,
+                $"Manual Async Subscription (Priority: {priority})");
+        }
+
+        internal void RegisterEventInternal(Type eventType, Delegate handler, EventPriority priority,
+            int numericPriority, bool receiveCanceled, string debugInfo = "", MethodInfo? originalMethod = null)
+        {
+            if (eventType == null)
+                throw new ArgumentNullException(nameof(eventType));
+            if (handler == null)
+                throw new ArgumentNullException(nameof(handler));
+
+            ValidateEventType(eventType, "register");
+            var handlerInfo = EventHandlerInfo.Create(GetNextSubscriptionId(), handler, eventType, priority,
+                numericPriority, receiveCanceled,
+                debugInfo, originalMethod);
+
+            lock (_listenerLock)
+            {
+                GetOrCreateListenerList(eventType).Add(handlerInfo);
+            }
+        }
+
+        private IShrinkEventSubscription SubscribeEventInternal(Type eventType, Delegate handler, EventPriority priority,
+            int numericPriority, bool receiveCanceled, string debugInfo = "", MethodInfo? originalMethod = null)
+        {
+            if (eventType == null)
+                throw new ArgumentNullException(nameof(eventType));
+            if (handler == null)
+                throw new ArgumentNullException(nameof(handler));
+
+            ValidateEventType(eventType, "subscribe");
+            var subscriptionId = GetNextSubscriptionId();
+            var handlerInfo = EventHandlerInfo.Create(subscriptionId, handler, eventType, priority, numericPriority,
+                receiveCanceled, debugInfo, originalMethod);
+
+            lock (_listenerLock)
+            {
+                GetOrCreateListenerList(eventType).Add(handlerInfo);
+            }
+
+            return new EventSubscription(this, subscriptionId);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnregisterEvent<TEvent>(Func<TEvent, UniTask> handler) where TEvent : EventBase
+        {
+            if (handler == null)
+                return;
+
+            var collection = TryGetListenerList(typeof(TEvent));
+            collection?.Remove(handler);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnregisterEvent<TEvent>(Action<TEvent> handler) where TEvent : EventBase
+        {
+            if (handler == null)
+                return;
+
+            var collection = TryGetListenerList(typeof(TEvent));
+            collection?.Remove(handler);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearAllSubscribersForEvent<TEvent>() where TEvent : EventBase
+        {
+            var collection = TryGetListenerList(typeof(TEvent));
+            collection?.Clear();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnregisterAllEventsForObject(object targetObject)
+        {
+            if (targetObject is null)
+                return;
+
+            // Keep the registration -> listener lock order used by RegisterCore.
+            // Removing only handlers is not enough: the target must be allowed to
+            // register again after a component-style teardown and reinitialization.
+            lock (_registrationLock)
+            {
+                _registeredTargets.Remove(targetObject);
+
+                lock (_listenerLock)
+                {
+                    foreach (var kvp in _eventHandlers)
+                        kvp.Value.RemoveTarget(targetObject);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnregisterAllEvents()
+        {
+            // Match RegisterCore/UnregisterAllEventsForObject so teardown cannot
+            // deadlock with a concurrent registration.
+            lock (_registrationLock)
+            {
+                lock (_listenerLock)
+                {
+                    foreach (var kvp in _eventHandlers)
+                        kvp.Value.Clear();
+                }
+
+                _registeredTargets.Clear();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public UniTask<bool> TriggerEventAsync<TEvent>(TEvent eventArgs) where TEvent : EventBase
+        {
+            return TriggerEventAsyncInternal(eventArgs, null);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public UniTask<bool> TriggerEventAsync<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase
+        {
+            EnsurePerPhaseDispatchAllowed();
+            return TriggerEventAsyncInternal(eventArgs, phase);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TriggerEvent<TEvent>(TEvent eventArgs) where TEvent : EventBase
+        {
+            return TriggerEventInternal(eventArgs, null);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TriggerEvent<TEvent>(EventPriority phase, TEvent eventArgs) where TEvent : EventBase
+        {
+            EnsurePerPhaseDispatchAllowed();
+            return TriggerEventInternal(eventArgs, phase);
+        }
+
+        private async UniTask<bool> TriggerEventAsyncInternal(EventBase eventArgs, EventPriority? phase)
+        {
+            if (!TryPrepareDispatch(eventArgs, phase, out var eventType, out var handlers))
+                return false;
+
+            var wasHandled = false;
+            for (var i = 0; i < handlers.Length; i++)
+            {
+                var handlerInfo = handlers[i];
+                if (!TryPrepareHandler(eventArgs, handlerInfo))
+                    continue;
+
+                try
+                {
+                    if (handlerInfo.SyncInvoker != null)
+                    {
+                        handlerInfo.SyncInvoker(eventArgs);
+                        wasHandled = true;
+                    }
+                    else if (handlerInfo.AsyncInvoker != null)
+                    {
+                        await handlerInfo.AsyncInvoker(eventArgs);
+                        wasHandled = true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (HandleListenerException(eventArgs, handlers, i, ex))
+                        throw;
+                }
+            }
+
+            eventArgs.CurrentHandler = null;
+            CompleteEventDispatch(eventArgs, eventType, handlers);
+            return wasHandled;
+        }
+
+        private bool TriggerEventInternal(EventBase eventArgs, EventPriority? phase)
+        {
+            if (!TryPrepareDispatch(eventArgs, phase, out var eventType, out var handlers))
+                return false;
+
+            var wasHandled = false;
+            for (var i = 0; i < handlers.Length; i++)
+            {
+                var handlerInfo = handlers[i];
+                if (!TryPrepareHandler(eventArgs, handlerInfo))
+                    continue;
+
+                try
+                {
+                    if (handlerInfo.SyncInvoker != null)
+                    {
+                        handlerInfo.SyncInvoker(eventArgs);
+                        wasHandled = true;
+                    }
+                    else if (handlerInfo.AsyncInvoker != null)
+                    {
+                        var detachedEvent = EventCloneUtility.CloneForDetachedDispatch(eventArgs);
+                        FireAndForgetSafe(() => handlerInfo.AsyncInvoker(detachedEvent),
+                            $"{handlerInfo.DisplayDeclaringType.Name}.{handlerInfo.DisplayMethodName}");
+                        wasHandled = true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    if (HandleListenerException(eventArgs, handlers, i, ex))
+                        throw;
+                }
+            }
+
+            eventArgs.CurrentHandler = null;
+            CompleteEventDispatch(eventArgs, eventType, handlers);
+            return wasHandled;
+        }
+
+        private bool TryPrepareDispatch(EventBase eventArgs, EventPriority? phase, out Type eventType,
+            out EventHandlerInfo[] handlers)
+        {
+            if (eventArgs == null)
+                throw new ArgumentNullException(nameof(eventArgs));
+
+            if (!IsStarted)
+            {
+                eventType = eventArgs.GetType();
+                handlers = Array.Empty<EventHandlerInfo>();
+                return false;
+            }
+
+            eventType = eventArgs.GetType();
+            ValidateDispatchEventType(eventType);
+            eventArgs.PrepareForDispatch();
+
+            lock (_listenerLock)
+            {
+                var listenerList = GetOrCreateListenerList(eventType);
+                handlers = phase.HasValue ? listenerList.GetHandlers(phase.Value) : listenerList.GetHandlers();
+            }
+
+            eventArgs.SetListenerSnapshot(handlers);
+            return true;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryPrepareHandler(EventBase eventArgs, EventHandlerInfo handlerInfo)
+        {
+            eventArgs.CurrentHandler = handlerInfo;
+            eventArgs.SetPhase(handlerInfo.Priority);
+            if (eventArgs.IsCancelable && eventArgs.IsCanceled && !handlerInfo.ReceiveCanceled)
+                return false;
+            return true;
+        }
+
+        private bool HandleListenerException(EventBase eventArgs, EventHandlerInfo[] handlers, int index, Exception exception)
+        {
+            _exceptionHandler?.HandleException(this, eventArgs, handlers, index, exception);
+
+            switch (_exceptionHandlingMode)
+            {
+                case ShrinkEventExceptionHandlingMode.Throw:
+                    return true;
+                case ShrinkEventExceptionHandlingMode.LogAndThrow:
+                    LogHandlerException(exception);
+                    return true;
+                default:
+                    LogHandlerException(exception);
+                    return false;
+            }
+        }
+
+        private static void LogHandlerException(Exception exception)
+        {
+            Debug.LogException(exception);
+            Debug.LogError($"[EventBus] Handler exception: {exception.Message}");
+        }
+
+        private static void FireAndForgetSafe(Func<UniTask> action, string handlerName)
+        {
+            action().Forget(e =>
+            {
+                Debug.LogException(e);
+                Debug.LogError($"[EventBus] Async Handler {handlerName} threw exception: {e.Message}");
+            });
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void CompleteEventDispatch(EventBase eventArgs, Type eventType, EventHandlerInfo[] handlers)
+        {
+            OnEventTriggered?.Invoke(eventArgs, eventType);
+
+#if UNITY_EDITOR
+            var editorTraceHandler = OnEventTriggeredForEditor;
+            if (!EnableDebugRecord || editorTraceHandler == null)
+                return;
+
+            editorTraceHandler.Invoke(eventArgs, eventType.Name, GetSenderInfo(), handlers);
+#endif
+        }
+
+#if UNITY_EDITOR
+        private static string GetSenderInfo()
+        {
+            var senderInfo = "Unknown";
+            try
+            {
+                var trace = new System.Diagnostics.StackTrace(0, false);
+                for (var i = 0; i < trace.FrameCount; i++)
+                {
+                    var method = trace.GetFrame(i)?.GetMethod();
+                    var declaringType = method?.DeclaringType;
+                    if (declaringType == null)
+                        continue;
+
+                    if (declaringType == typeof(EventBus) || declaringType.DeclaringType == typeof(EventBus))
+                        continue;
+
+                    if (declaringType == typeof(ShrinkEventBusInstance) ||
+                        declaringType.DeclaringType == typeof(ShrinkEventBusInstance))
+                        continue;
+
+                    var ns = declaringType.Namespace ?? string.Empty;
+                    if (ns.StartsWith("System") || ns.StartsWith("Cysharp") || ns.StartsWith("UnityEngine"))
+                        continue;
+
+                    var className = declaringType.Name;
+                    var methodName = method!.Name;
+                    if (declaringType.DeclaringType != null && className.StartsWith("<") && className.Contains(">"))
+                    {
+                        className = declaringType.DeclaringType.Name;
+                        var startIndex = declaringType.Name.IndexOf('<') + 1;
+                        var endIndex = declaringType.Name.IndexOf('>');
+                        if (startIndex > 0 && endIndex > startIndex)
+                            methodName = declaringType.Name.Substring(startIndex, endIndex - startIndex);
+                    }
+
+                    return $"{className}.{methodName}()";
+                }
+            }
+            catch
+            {
+            }
+
+            return senderInfo;
+        }
+#endif
+
+        public EventHandlerInfo[] GetEventSubscribers<TEvent>() where TEvent : EventBase
+        {
+            var listenerList = TryGetListenerList(typeof(TEvent));
+            var handlers = listenerList?.GetHandlers();
+            if (handlers == null || handlers.Length == 0)
+                return Array.Empty<EventHandlerInfo>();
+
+            return (EventHandlerInfo[])handlers.Clone();
+        }
+
+        public ListenerList GetListenerList<TEvent>() where TEvent : EventBase
+        {
+            lock (_listenerLock)
+            {
+                return GetOrCreateListenerList(typeof(TEvent));
+            }
+        }
+
+        public IReadOnlyDictionary<Type, EventHandlerInfo[]> GetAllSubscribersSnapshot()
+        {
+            lock (_listenerLock)
+            {
+                var snapshot = new Dictionary<Type, EventHandlerInfo[]>(_eventHandlers.Count);
+                foreach (var kvp in _eventHandlers)
+                {
+                    var handlers = kvp.Value.GetHandlers();
+                    if (handlers.Length == 0)
+                        continue;
+
+                    snapshot[kvp.Key] = (EventHandlerInfo[])handlers.Clone();
+                }
+
+                return snapshot;
+            }
+        }
+
+        public IReadOnlyList<ShrinkEventSubscriptionSnapshot> GetActiveSubscriptionsSnapshot()
+        {
+            lock (_listenerLock)
+            {
+                var snapshot = new List<ShrinkEventSubscriptionSnapshot>();
+                foreach (var entry in _eventHandlers)
+                {
+                    var eventType = entry.Key;
+                    var handlers = entry.Value.GetHandlers();
+                    for (var i = 0; i < handlers.Length; i++)
+                    {
+                        var handler = handlers[i];
+                        snapshot.Add(new ShrinkEventSubscriptionSnapshot(
+                            handler.SubscriptionId,
+                            eventType,
+                            handler.Priority,
+                            handler.NumericPriority,
+                            handler.ReceiveCanceled,
+                            handler.Target,
+                            handler.DisplayDeclaringType.FullName ?? handler.DisplayDeclaringType.Name,
+                            handler.DisplayMethodName,
+                            handler.DebugInfo,
+                            handler.RegisteredAtUtc));
+                    }
+                }
+
+                return snapshot;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool IsInstanceRegistered(object target)
+        {
+            if (target == null)
+                return false;
+
+            lock (_registrationLock)
+            {
+                return _registeredTargets.Contains(target);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetRegisteredInstanceCount()
+        {
+            lock (_registrationLock)
+            {
+                return _registeredTargets.Count;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetRegisteredEventTypeCount()
+        {
+            lock (_listenerLock)
+            {
+                var count = 0;
+                foreach (var listenerList in _eventHandlers.Values)
+                {
+                    if (listenerList.LocalCount > 0)
+                        count++;
+                }
+
+                return count;
+            }
+        }
+
+        private void RegisterCore(object target, bool requireSubscriberAttribute, bool lenientWhenNoMethods)
+        {
+            if (target == null)
+                throw new ArgumentNullException(nameof(target));
+
+            lock (_registrationLock)
+            {
+                if (_registeredTargets.Contains(target))
+                    return;
+
+                EventBusRegHelper.RegisterTarget(this, target, requireSubscriberAttribute, lenientWhenNoMethods);
+                _registeredTargets.Add(target);
+            }
+        }
+
+        private void RemoveHandlers(Predicate<EventHandlerInfo> predicate)
+        {
+            lock (_listenerLock)
+            {
+                foreach (var listenerList in _eventHandlers.Values)
+                    listenerList.RemoveWhere(predicate);
+            }
+        }
+
+        private void UnregisterSubscription(long subscriptionId)
+        {
+            RemoveHandlers(info => info.SubscriptionId == subscriptionId);
+        }
+
+        private long GetNextSubscriptionId() => Interlocked.Increment(ref _nextSubscriptionId);
+
+        private ListenerList GetOrCreateListenerList(Type eventType)
+        {
+            if (_eventHandlers.TryGetValue(eventType, out var existing))
+                return existing;
+
+            ListenerList? parent = null;
+            var parentType = GetParentEventType(eventType);
+            if (parentType != null)
+                parent = GetOrCreateListenerList(parentType);
+
+            var created = new ListenerList(parent, _listenerLock);
+            _eventHandlers[eventType] = created;
+            return created;
+        }
+
+        private ListenerList? TryGetListenerList(Type eventType)
+        {
+            if (eventType == null)
+                return null;
+
+            lock (_listenerLock)
+            {
+                return _eventHandlers.TryGetValue(eventType, out var listenerList) ? listenerList : null;
+            }
+        }
+
+        private void ValidateEventType(Type eventType, string action)
+        {
+            if (!typeof(EventBase).IsAssignableFrom(eventType))
+                throw new ArgumentException(
+                    $"Cannot {action} listener for {eventType.FullName}: type must inherit from EventBase.");
+
+            _eventClassChecker?.Invoke(eventType);
+        }
+
+        private void ValidateDispatchEventType(Type eventType)
+        {
+            if (!typeof(EventBase).IsAssignableFrom(eventType))
+                throw new ArgumentException($"Cannot dispatch event type {eventType.FullName}: not an EventBase.");
+
+            if (_checkTypesOnDispatch)
+                _eventClassChecker?.Invoke(eventType);
+        }
+
+        private static Type? GetParentEventType(Type eventType)
+        {
+            var current = eventType.BaseType;
+            while (current != null && current != typeof(object))
+            {
+                if (typeof(EventBase).IsAssignableFrom(current))
+                    return current;
+
+                current = current.BaseType;
+            }
+
+            return null;
+        }
+
+        private void EnsurePerPhaseDispatchAllowed()
+        {
+            if (!_allowPerPhaseDispatch)
+                throw new InvalidOperationException(
+                    "Per-phase event dispatch is disabled for this bus. Enable it via ShrinkEventBusBuilder.AllowPerPhaseDispatch().");
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs.meta b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs.meta
new file mode 100644
index 0000000..0a5ddaf
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBusInstance.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 92c1c7cd96e37c8458600728c7c0c57f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests.meta b/Assets/Modules/ShrinkEventBus/Tests.meta
new file mode 100644
index 0000000..1615325
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6f28409a6ba08444cbdbfc5eb37b1809
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs b/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs
new file mode 100644
index 0000000..b3c5984
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs
@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+
+namespace ShrinkEventBus.Tests
+{
+    [TestFixture]
+    public sealed class EventBusDispatchTests
+    {
+        private class PlainEvent : EventBase
+        {
+        }
+
+        private sealed class DerivedPlainEvent : PlainEvent
+        {
+        }
+
+        [Cancelable]
+        private sealed class CancelableEvent : EventBase
+        {
+        }
+
+        [HasResult]
+        private sealed class ResultEvent : EventBase
+        {
+        }
+
+        [Test]
+        public void TriggerEvent_ReturnsFalseWithoutSubscribers_TrueWhenHandled()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.IsFalse(bus.TriggerEvent(new PlainEvent()));
+
+            bus.RegisterEvent<PlainEvent>(_ => { }, EventPriority.NORMAL);
+            Assert.IsTrue(bus.TriggerEvent(new PlainEvent()));
+        }
+
+        [Test]
+        public void CanceledEvent_SkipsHandlersUnlessReceiveCanceled()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            bus.RegisterEvent<CancelableEvent>(evt =>
+            {
+                order.Add("canceler");
+                evt.SetCanceled(true);
+            }, EventPriority.HIGHEST);
+            bus.RegisterEvent<CancelableEvent>(_ => order.Add("skipped"), EventPriority.NORMAL);
+            bus.RegisterEvent<CancelableEvent>(evt => order.Add($"monitor:{evt.IsCanceled}"),
+                EventPriority.MONITOR, receiveCanceled: true);
+
+            var evt = new CancelableEvent();
+            bus.TriggerEvent(evt);
+
+            Assert.IsTrue(evt.IsCanceled);
+            CollectionAssert.AreEqual(new[] { "canceler", "monitor:True" }, order);
+        }
+
+        [Test]
+        public void SetCanceled_OnNonCancelableEvent_ThrowsWithMessage()
+        {
+            var evt = new PlainEvent();
+
+            var ex = Assert.Throws<UnsupportedOperationException>(() => evt.SetCanceled(true));
+            Assert.IsFalse(string.IsNullOrWhiteSpace(ex.Message));
+        }
+
+        [Test]
+        public void SetResult_OnEventWithoutResult_ThrowsWithMessage()
+        {
+            var evt = new PlainEvent();
+
+            var ex = Assert.Throws<InvalidOperationException>(() => evt.SetResult(EventResult.ALLOW));
+            Assert.IsFalse(string.IsNullOrWhiteSpace(ex.Message));
+        }
+
+        [Test]
+        public void SetResult_OnResultEvent_PersistsResult()
+        {
+            var bus = EventBus.CreateBus();
+            bus.RegisterEvent<ResultEvent>(evt => evt.SetResult(EventResult.DENY), EventPriority.HIGH);
+
+            var evt = new ResultEvent();
+            bus.TriggerEvent(evt);
+
+            Assert.AreEqual(EventResult.DENY, evt.Result);
+        }
+
+        [Test]
+        public void ParentSubscriber_ReceivesDerivedEvent()
+        {
+            var bus = EventBus.CreateBus();
+            var hits = 0;
+            bus.RegisterEvent<PlainEvent>(_ => hits++, EventPriority.NORMAL);
+
+            bus.TriggerEvent(new DerivedPlainEvent());
+
+            Assert.AreEqual(1, hits);
+        }
+
+        [Test]
+        public void ParentSubscriber_RegisteredAfterChildWasTriggered_StillReceivesChild()
+        {
+            var bus = EventBus.CreateBus();
+
+            // 先触发子事件，让子类型的监听列表先于父监听器创建（覆盖脏传播路径）
+            bus.TriggerEvent(new DerivedPlainEvent());
+
+            var hits = 0;
+            bus.RegisterEvent<PlainEvent>(_ => hits++, EventPriority.NORMAL);
+            bus.TriggerEvent(new DerivedPlainEvent());
+
+            Assert.AreEqual(1, hits);
+        }
+
+        [Test]
+        public void PerPhaseDispatch_OnlyRunsRequestedPhase()
+        {
+            var bus = EventBus.CreateBus(builder => builder.AllowPerPhaseDispatch());
+            var order = new List<string>();
+
+            bus.RegisterEvent<PlainEvent>(_ => order.Add("high"), EventPriority.HIGH);
+            bus.RegisterEvent<PlainEvent>(_ => order.Add("normal"), EventPriority.NORMAL);
+
+            bus.TriggerEvent(EventPriority.HIGH, new PlainEvent());
+
+            CollectionAssert.AreEqual(new[] { "high" }, order);
+        }
+
+        [Test]
+        public void PerPhaseDispatch_ThrowsWhenNotEnabled()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.Throws<InvalidOperationException>(() => bus.TriggerEvent(EventPriority.HIGH, new PlainEvent()));
+        }
+
+        [Test]
+        public void TriggerEventAsync_RunsHandlersSequentiallyByPriority()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            async UniTask AsyncHandler(PlainEvent evt)
+            {
+                order.Add("async-high");
+                await UniTask.CompletedTask;
+            }
+
+            bus.RegisterEvent<PlainEvent>(AsyncHandler, EventPriority.HIGH, receiveCanceled: false);
+            bus.RegisterEvent<PlainEvent>(_ => order.Add("sync-normal"), EventPriority.NORMAL);
+
+            var handled = bus.TriggerEventAsync(new PlainEvent()).GetAwaiter().GetResult();
+
+            Assert.IsTrue(handled);
+            CollectionAssert.AreEqual(new[] { "async-high", "sync-normal" }, order);
+        }
+
+        [Test]
+        public void TriggerEventAsync_AsyncHandlerCancellation_SkipsLaterHandlers()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            async UniTask CancelingHandler(CancelableEvent evt)
+            {
+                evt.SetCanceled(true);
+                order.Add("async-canceler");
+                await UniTask.CompletedTask;
+            }
+
+            bus.RegisterEvent<CancelableEvent>(CancelingHandler, EventPriority.HIGHEST, receiveCanceled: false);
+            bus.RegisterEvent<CancelableEvent>(_ => order.Add("skipped"), EventPriority.NORMAL);
+
+            bus.TriggerEventAsync(new CancelableEvent()).GetAwaiter().GetResult();
+
+            CollectionAssert.AreEqual(new[] { "async-canceler" }, order);
+        }
+
+        [Test]
+        public void GetSubscribers_ReturnsDefensiveCopyOfDispatchSnapshot()
+        {
+            var bus = EventBus.CreateBus();
+            bus.RegisterEvent<PlainEvent>(_ => { }, EventPriority.NORMAL);
+
+            var evt = new PlainEvent();
+            bus.TriggerEvent(evt);
+
+            var first = evt.GetSubscribers();
+            Assert.AreEqual(1, first.Length);
+
+            first[0] = null;
+            var second = evt.GetSubscribers();
+            Assert.IsNotNull(second[0]);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs.meta b/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs.meta
new file mode 100644
index 0000000..909457b
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusDispatchTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 11b7dddad0d215b47a7249e74a574105
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs b/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs
new file mode 100644
index 0000000..262b7f1
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs
@@ -0,0 +1,120 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace ShrinkEventBus.Tests
+{
+    [TestFixture]
+    public sealed class EventBusPriorityTests
+    {
+        private class BaseEvent : EventBase
+        {
+        }
+
+        private sealed class DerivedEvent : BaseEvent
+        {
+        }
+
+        [Test]
+        public void EnumPriority_ExecutesPhasesInOrder()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("LOW"), EventPriority.LOW);
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("MONITOR"), EventPriority.MONITOR);
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("HIGHEST"), EventPriority.HIGHEST);
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("NORMAL"), EventPriority.NORMAL);
+
+            bus.TriggerEvent(new BaseEvent());
+
+            CollectionAssert.AreEqual(new[] { "HIGHEST", "NORMAL", "LOW", "MONITOR" }, order);
+        }
+
+        [Test]
+        public void NumericPriority_HigherNumberRunsFirstWithinPhase()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            // 5 与 10 都映射到 NORMAL 档
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("p5"), 5);
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("p10"), 10);
+
+            bus.TriggerEvent(new BaseEvent());
+
+            CollectionAssert.AreEqual(new[] { "p10", "p5" }, order);
+        }
+
+        [Test]
+        public void NumericPriority_TieKeepsRegistrationOrder()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("first"), 0);
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("second"), 0);
+
+            bus.TriggerEvent(new BaseEvent());
+
+            CollectionAssert.AreEqual(new[] { "first", "second" }, order);
+        }
+
+        [Test]
+        public void NumericPriorityZero_MapsToNormalPhase()
+        {
+            var bus = EventBus.CreateBus();
+            bus.RegisterEvent<BaseEvent>(_ => { }, 0);
+
+            var subscribers = bus.GetEventSubscribers<BaseEvent>();
+
+            Assert.AreEqual(1, subscribers.Length);
+            Assert.AreEqual(EventPriority.NORMAL, subscribers[0].Priority);
+        }
+
+        [Test]
+        public void RegisterEvent_WithoutPriority_ResolvesToNormal()
+        {
+            var bus = EventBus.CreateBus();
+
+            void Handler(BaseEvent evt)
+            {
+            }
+
+            // 不带优先级的调用应唯一解析到枚举重载（NORMAL），不再有重载二义性
+            bus.RegisterEvent<BaseEvent>(Handler);
+
+            var subscribers = bus.GetEventSubscribers<BaseEvent>();
+            Assert.AreEqual(1, subscribers.Length);
+            Assert.AreEqual(EventPriority.NORMAL, subscribers[0].Priority);
+        }
+
+        [Test]
+        public void ParentAndChildHandlers_MergeByNumericPriorityWithinPhase()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("parent10"), 10);
+            bus.RegisterEvent<DerivedEvent>(_ => order.Add("child5"), 5);
+            bus.RegisterEvent<DerivedEvent>(_ => order.Add("child1"), 1);
+
+            bus.TriggerEvent(new DerivedEvent());
+
+            CollectionAssert.AreEqual(new[] { "parent10", "child5", "child1" }, order);
+        }
+
+        [Test]
+        public void ParentAndChildHandlers_TiePrefersChild()
+        {
+            var bus = EventBus.CreateBus();
+            var order = new List<string>();
+
+            bus.RegisterEvent<BaseEvent>(_ => order.Add("parent0"), 0);
+            bus.RegisterEvent<DerivedEvent>(_ => order.Add("child0"), 0);
+
+            bus.TriggerEvent(new DerivedEvent());
+
+            CollectionAssert.AreEqual(new[] { "child0", "parent0" }, order);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs.meta b/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs.meta
new file mode 100644
index 0000000..8b254b3
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusPriorityTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc534f0e8598cab47b393ccffc90ad98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs b/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs
new file mode 100644
index 0000000..e0005ed
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs
@@ -0,0 +1,228 @@
+using System;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ShrinkEventBus.Tests
+{
+    [TestFixture]
+    public sealed class EventBusRegistrationTests
+    {
+        private class ProbeEvent : EventBase
+        {
+        }
+
+        private sealed class PooledEvent : EventBase
+        {
+            public int Value { get; set; }
+
+            protected override void OnReset()
+            {
+                Value = 0;
+            }
+        }
+
+        private sealed class InstanceSubscriber
+        {
+            public int Hits;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt)
+            {
+                Hits++;
+            }
+        }
+
+        private static class StaticSubscriber
+        {
+            public static int Hits;
+
+            [EventSubscribe(EventPriority.NORMAL)]
+            private static void OnProbe(ProbeEvent evt)
+            {
+                Hits++;
+            }
+        }
+
+        private sealed class InvalidSignatureSubscriber
+        {
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt, int extra)
+            {
+            }
+        }
+
+        [EventBusSubscriber]
+        private sealed class EmptySubscriber
+        {
+        }
+
+        private sealed class UnattributedSubscriber
+        {
+            [EventSubscribe(EventPriority.NORMAL)]
+            private void OnProbe(ProbeEvent evt)
+            {
+            }
+        }
+
+        [Test]
+        public void Register_InstanceScan_RegistersAndUnregisters()
+        {
+            var bus = EventBus.CreateBus();
+            var subscriber = new InstanceSubscriber();
+
+            bus.Register(subscriber);
+            Assert.IsTrue(bus.IsInstanceRegistered(subscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, subscriber.Hits);
+
+            bus.Unregister(subscriber);
+            Assert.IsFalse(bus.IsInstanceRegistered(subscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, subscriber.Hits);
+        }
+
+        [Test]
+        public void Register_StaticTypeScan_RegistersAndUnregisters()
+        {
+            var bus = EventBus.CreateBus();
+            StaticSubscriber.Hits = 0;
+
+            bus.Register(typeof(StaticSubscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+
+            bus.Unregister(typeof(StaticSubscriber));
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+        }
+
+        [Test]
+        public void Register_MethodInfo_RegistersSingleHandler()
+        {
+            var bus = EventBus.CreateBus();
+            StaticSubscriber.Hits = 0;
+            var method = typeof(StaticSubscriber).GetMethod("OnProbe",
+                BindingFlags.Static | BindingFlags.NonPublic);
+            Assert.IsNotNull(method);
+
+            bus.Register(method);
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+
+            bus.Unregister(method);
+            bus.TriggerEvent(new ProbeEvent());
+            Assert.AreEqual(1, StaticSubscriber.Hits);
+        }
+
+        [Test]
+        public void Register_InvalidHandlerSignature_Throws()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.Throws<InvalidOperationException>(() => bus.Register(new InvalidSignatureSubscriber()));
+        }
+
+        [Test]
+        public void AutoRegister_TypeWithoutSubscriberAttribute_Throws()
+        {
+            var bus = EventBus.CreateBus();
+
+            Assert.Throws<InvalidOperationException>(() => bus.AutoRegister(new UnattributedSubscriber()));
+        }
+
+        [Test]
+        public void AutoRegister_SubscriberWithoutHandlers_WarnsInsteadOfThrowing()
+        {
+            var bus = EventBus.CreateBus();
+
+            LogAssert.Expect(LogType.Warning, new Regex(@"has no \[EventSubscribe\] methods"));
+            Assert.DoesNotThrow(() => bus.AutoRegister(new EmptySubscriber()));
+        }
+
+        [Test]
+        public void GetEventSubscribers_ReturnsDefensiveCopy()
+        {
+            var bus = EventBus.CreateBus();
+            bus.RegisterEvent<ProbeEvent>(_ => { }, EventPriority.NORMAL);
+
+            var first = bus.GetEventSubscribers<ProbeEvent>();
+            Assert.AreEqual(1, first.Length);
+
+            first[0] = null;
+            var second = bus.GetEventSubscribers<ProbeEvent>();
+            Assert.IsNotNull(second[0]);
+        }
+
+        [Test]
+        public void UnregisterAllEventsForObject_RemovesScannedHandlers()
+        {
+            var bus = EventBus.CreateBus();
+            var subscriber = new InstanceSubscriber();
+            bus.Register(subscriber);
+
+            bus.UnregisterAllEventsForObject(subscriber);
+            Assert.IsFalse(bus.IsInstanceRegistered(subscriber));
+            bus.TriggerEvent(new ProbeEvent());
+
+            Assert.AreEqual(0, subscriber.Hits);
+
+            bus.Register(subscriber);
+            bus.TriggerEvent(new ProbeEvent());
+
+            Assert.AreEqual(1, subscriber.Hits);
+        }
+
+        [Test]
+        public void EventPool_ReleaseResetsAndReusesInstance()
+        {
+            var evt = EventPool<PooledEvent>.Get();
+            evt.Value = 42;
+
+            EventPool<PooledEvent>.Release(evt);
+            var reused = EventPool<PooledEvent>.Get();
+
+            Assert.AreSame(evt, reused);
+            Assert.AreEqual(0, reused.Value);
+
+            EventPool<PooledEvent>.Release(reused);
+        }
+
+        [Test]
+        public void EventPool_DoubleRelease_DoesNotDuplicatePoolEntry()
+        {
+            var evt = EventPool<PooledEvent>.Get();
+
+            EventPool<PooledEvent>.Release(evt);
+            EventPool<PooledEvent>.Release(evt);
+
+            var first = EventPool<PooledEvent>.Get();
+            var second = EventPool<PooledEvent>.Get();
+
+            Assert.AreSame(evt, first);
+            Assert.AreNotSame(evt, second);
+
+            EventPool<PooledEvent>.Release(first);
+            EventPool<PooledEvent>.Release(second);
+        }
+
+        [Test]
+        public void EventPool_DisposeReturnsToPool()
+        {
+            PooledEvent captured;
+            using (var evt = EventPool<PooledEvent>.Get())
+            {
+                captured = evt;
+                evt.Value = 7;
+            }
+
+            var reused = EventPool<PooledEvent>.Get();
+            Assert.AreSame(captured, reused);
+            Assert.AreEqual(0, reused.Value);
+
+            EventPool<PooledEvent>.Release(reused);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs.meta b/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs.meta
new file mode 100644
index 0000000..cbec877
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusRegistrationTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4570cac2813143c40b9a8edeadf19057
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs b/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs
new file mode 100644
index 0000000..69d8266
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs
@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using UnityEngine;
+
+namespace ShrinkEventBus.Tests
+{
+    [TestFixture]
+    public sealed class EventBusSubscriptionTests
+    {
+        private sealed class SampleEvent : EventBase
+        {
+            public int Value { get; set; }
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            EventBus.UnregisterAllEvents();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            EventBus.UnregisterAllEvents();
+        }
+
+        [Test]
+        public void SubscribeEvent_Dispose_RemovesOnlyOwnedSubscription()
+        {
+            var firstHits = 0;
+            var secondHits = 0;
+
+            using var first = EventBus.SubscribeEvent<SampleEvent>(_ => firstHits++);
+            using var second = EventBus.SubscribeEvent<SampleEvent>(_ => secondHits++);
+
+            EventBus.TriggerEvent(new SampleEvent());
+            Assert.AreEqual(1, firstHits);
+            Assert.AreEqual(1, secondHits);
+
+            first.Dispose();
+
+            EventBus.TriggerEvent(new SampleEvent());
+            Assert.AreEqual(1, firstHits);
+            Assert.AreEqual(2, secondHits);
+        }
+
+        [Test]
+        public void ActiveSubscriptionSnapshot_ContainsExpectedMetadata()
+        {
+            using var subscription = EventBus.SubscribeEvent<SampleEvent>(_ => { }, EventPriority.HIGH, true);
+
+            var snapshots = EventBus.GetActiveSubscriptionsSnapshot();
+
+            Assert.AreEqual(1, snapshots.Count);
+            Assert.AreEqual(subscription.SubscriptionId, snapshots[0].SubscriptionId);
+            Assert.AreEqual(typeof(SampleEvent), snapshots[0].EventType);
+            Assert.AreEqual(EventPriority.HIGH, snapshots[0].Priority);
+            Assert.IsTrue(snapshots[0].ReceiveCanceled);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(snapshots[0].MethodName));
+        }
+
+        [Test]
+        public void RegisterEvent_StillWorksWithoutDisposableSubscription()
+        {
+            var hits = 0;
+
+            void Handler(SampleEvent evt)
+            {
+                hits += evt.Value;
+            }
+
+            EventBus.RegisterEvent<SampleEvent>(Handler);
+            EventBus.TriggerEvent(new SampleEvent { Value = 3 });
+
+            Assert.AreEqual(3, hits);
+
+            EventBus.UnregisterEvent<SampleEvent>(Handler);
+            EventBus.TriggerEvent(new SampleEvent { Value = 5 });
+
+            Assert.AreEqual(3, hits);
+        }
+
+        [Test]
+        public void ActiveSubscriptionSnapshot_EmptyAfterDispose()
+        {
+            var subscription = EventBus.SubscribeEvent<SampleEvent>(_ => Debug.Log("noop"));
+            subscription.Dispose();
+
+            var snapshots = EventBus.GetActiveSubscriptionsSnapshot();
+
+            Assert.AreEqual(0, snapshots.Count);
+            Assert.IsTrue(subscription.IsDisposed);
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs.meta b/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs.meta
new file mode 100644
index 0000000..c1e8486
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/EventBusSubscriptionTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f5ea531619ceaeb46af4f56454624ef7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef b/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef
new file mode 100644
index 0000000..69004b2
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef
@@ -0,0 +1,23 @@
+{
+    "name": "ShrinkEventBus.Tests",
+    "rootNamespace": "ShrinkEventBus.Tests",
+    "references": [
+        "ShrinkEventBus.Runtime",
+        "UniTask",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef.meta b/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef.meta
new file mode 100644
index 0000000..c6c5e74
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/Tests/ShrinkEventBus.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8c47d36b8919bbf4d9c39817eaf577a9
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/img1.png b/Assets/Modules/ShrinkEventBus/img1.png
new file mode 100644
index 0000000..32ee64b
Binary files /dev/null and b/Assets/Modules/ShrinkEventBus/img1.png differ
diff --git a/Assets/Modules/ShrinkEventBus/img1.png.meta b/Assets/Modules/ShrinkEventBus/img1.png.meta
new file mode 100644
index 0000000..6096545
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/img1.png.meta
@@ -0,0 +1,169 @@
+fileFormatVersion: 2
+guid: c0d34cdfe6432fc45b8e3aa75065b201
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -6576374159750988736
+    second: img1_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: img1_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 659
+        height: 658
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 04cfbf97b860cb4a0800000000000000
+      internalID: -6576374159750988736
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      img1_0: -6576374159750988736
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/img2.png b/Assets/Modules/ShrinkEventBus/img2.png
new file mode 100644
index 0000000..6d0ed18
Binary files /dev/null and b/Assets/Modules/ShrinkEventBus/img2.png differ
diff --git a/Assets/Modules/ShrinkEventBus/img2.png.meta b/Assets/Modules/ShrinkEventBus/img2.png.meta
new file mode 100644
index 0000000..19d4137
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/img2.png.meta
@@ -0,0 +1,169 @@
+fileFormatVersion: 2
+guid: 265b481fbf28c6949a2e93bcfcdbe946
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -1076633883802439962
+    second: img2_0
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: img2_0
+      rect:
+        serializedVersion: 2
+        x: 0
+        y: 0
+        width: 659
+        height: 658
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 6ee6ecadf270f01f0800000000000000
+      internalID: -1076633883802439962
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      img2_0: -1076633883802439962
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkEventBus/package.json b/Assets/Modules/ShrinkEventBus/package.json
new file mode 100644
index 0000000..e4f9173
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "com.cneicy.shrink-eventbus",
+  "version": "1.3.0",
+  "displayName": "ShrinkEventBus",
+  "description": "高性能、类型安全的 Unity 事件总线，支持优先级调度与自动注册。",
+  "unity": "2022.3",
+  "documentationUrl": "https://github.com/cneicy/ShrinkEventBus",
+  "changelogUrl": "https://github.com/cneicy/ShrinkEventBus/blob/main/CHANGELOG.md",
+  "licensesUrl": "https://github.com/cneicy/ShrinkEventBus/blob/main/LICENSE",
+  "dependencies": {
+    "com.cysharp.unitask": "2.5.10",
+    "com.unity.nuget.mono-cecil": "1.11.4"
+  },
+  "keywords": ["eventbus", "event", "messaging", "unitask"],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkEventBus/package.json.meta b/Assets/Modules/ShrinkEventBus/package.json.meta
new file mode 100644
index 0000000..fc2f5e7
--- /dev/null
+++ b/Assets/Modules/ShrinkEventBus/package.json.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 09a3fe335f19475db0839afd05b0d8cb
+timeCreated: 1772900717
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkModFramework/Tests/ShrinkModContextHostTests.cs b/Assets/Modules/ShrinkModFramework/Tests/ShrinkModContextHostTests.cs
index 8209e85..960a4c6 100644
--- a/Assets/Modules/ShrinkModFramework/Tests/ShrinkModContextHostTests.cs
+++ b/Assets/Modules/ShrinkModFramework/Tests/ShrinkModContextHostTests.cs
@@ -418,8 +418,12 @@ namespace ShrinkModFramework.Tests
 
         private static void CopyFixture(string fixtureName, string targetPath)
         {
-            var fixturePath = Path.Combine(Application.dataPath, "Modules", "ShrinkModFramework",
-                "Tests", "Fixtures", fixtureName);
+            var package = UnityEditor.PackageManager.PackageInfo.FindForAssembly(
+                typeof(ShrinkModContextHostTests).Assembly);
+            if (package == null || string.IsNullOrWhiteSpace(package.resolvedPath))
+                throw new InvalidOperationException("Could not resolve the ShrinkModFramework package path.");
+
+            var fixturePath = Path.Combine(package.resolvedPath, "Tests", "Fixtures", fixtureName);
             File.Copy(fixturePath, targetPath, true);
         }
 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md b/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md
new file mode 100644
index 0000000..c41aa87
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md
@@ -0,0 +1,11 @@
+# Changelog
+
+本文件记录 `ShrinkNetwork.Integration.App` 的包内变更。
+
+## [0.1.0] - 2026-05-18
+
+### Added
+
+- 新增 `ShrinkNetwork` 与 `ShrinkApp.Core` 的桥接包。
+- 新增 `ShrinkNetworkAppInstaller`，把默认网络服务挂入宿主服务容器。
+- 新增 `ShrinkNetworkAppService` 作为宿主侧网络门面。
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md.meta b/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md.meta
new file mode 100644
index 0000000..f521162
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 12ec7a42482c6dc4b969870ad23daffc
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/README.md b/Assets/Modules/ShrinkNetwork.Integration.App/README.md
new file mode 100644
index 0000000..00f803a
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/README.md
@@ -0,0 +1,23 @@
+# ShrinkNetwork.Integration.App
+
+`ShrinkNetwork.Integration.App` 是 `ShrinkNetwork` 与 `ShrinkApp.Core` 的桥接层。它负责把默认网络服务挂进宿主服务容器，让项目在进入统一宿主模式后，能明确地从 `ShrinkApp` 取得网络服务，而不是在各处直接耦合 `ShrinkNetworkRuntime.Default`。
+
+## 当前能力
+
+- 提供原生 `ShrinkNetworkAppComponent`，发布 `shrink.service.network`
+- 把 `ShrinkNetworkRuntime.Default` 包装为 `ShrinkNetworkAppService`
+- ContextLoader 下由 Starter 组合根装配，服务门面随组件停用可逆注销
+- `ShrinkNetworkAppInstaller` 仅保留给 ClassicHost 兼容路径，已标记过时
+
+## 使用示例
+
+```csharp
+var network = ShrinkApp.ShrinkApp.Services.GetRequired<ShrinkNetwork.Integration.App.ShrinkNetworkAppService>();
+var service = network.Service;
+```
+
+## 说明
+
+- 本包当前不主动绑定传输层，也不替业务决定 TCP / KCP / Loopback。
+- 静态消息合同与静态 handler 的默认注册仍由 `ShrinkNetworkRuntime.Default` 完成。
+- 运行时实例 handler 仍然走 `RegisterHandlers(object target)`。
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/README.md.meta b/Assets/Modules/ShrinkNetwork.Integration.App/README.md.meta
new file mode 100644
index 0000000..6a47091
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 00f656bae7782f54fa051900ddc0575c
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime.meta
new file mode 100644
index 0000000..3c4094b
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 13a446f2618993d4f84f800c349a6306
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef
new file mode 100644
index 0000000..a2ce7a5
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef
@@ -0,0 +1,18 @@
+{
+  "name": "ShrinkNetwork.Integration.App",
+  "rootNamespace": "ShrinkNetwork.Integration.App",
+  "references": [
+    "ShrinkNetwork.Runtime",
+    "ShrinkApp.Core.Runtime",
+        "ShrinkContext.Core.Runtime",
+    "UniTask"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef.meta
new file mode 100644
index 0000000..79bf293
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetwork.Integration.App.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6396a2709306e6245892177071b1c3f2
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs
new file mode 100644
index 0000000..6c4300d
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs
@@ -0,0 +1,89 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using ShrinkContext;
+using ShrinkNetwork;
+using UnityEngine;
+
+namespace ShrinkNetwork.Integration.App
+{
+    /// <summary>ShrinkNetwork 组件的配置。</summary>
+    public sealed class ShrinkNetworkAppModuleConfig
+    {
+        /// <summary>是否在激活时自动绑定 loopback 传输并打开默认会话（演示/调试台用）。</summary>
+        public bool BindLoopbackTransport;
+
+        public int LoopbackSessionId = 1;
+
+        /// <summary>可选：把网络服务同时注册进 ShrinkApp 服务容器（兼容旧调试台读取路径）。</summary>
+        public ShrinkApp.ShrinkAppServices? Services;
+    }
+
+    /// <summary>
+    /// ShrinkNetwork 的原生 Cordis 组件（阶段 3）：
+    /// - 提供 <c>shrink.service.network</c> 余效应键（服务实例），依赖者按键注入；
+    /// - 可选的 loopback 传输绑定是**可逆效应**：停用时解绑传输、清理会话并使挂起 RPC 失败——
+    ///   全部由效应回滚完成，而非手写卸载路径；
+    /// - 与经典 ShrinkNetworkAppInstaller（ModuleId "shrink.network"）二选一使用：
+    ///   两者都发布 "app.module.shrink.network"，同时激活会触发供给冲突。
+    /// </summary>
+    public sealed class ShrinkNetworkAppComponent : IShrinkComponent
+    {
+        public const string ServiceKey = "shrink.service.network";
+        public const string ModuleKey = "app.module.shrink.network";
+
+        private static readonly string[] ProvideKeys = { ModuleKey, ServiceKey };
+
+        public string Name => "shrink.network";
+
+        public IReadOnlyList<string> Inject => Array.Empty<string>();
+
+        public IReadOnlyList<string> Provide => ProvideKeys;
+
+        public async UniTask ApplyAsync(ShrinkCtx ctx, object? config)
+        {
+            var moduleConfig = config as ShrinkNetworkAppModuleConfig ?? new ShrinkNetworkAppModuleConfig();
+            var service = ShrinkNetworkRuntime.Default;
+
+            // set 是可逆效应：停用自动撤回服务键，依赖者随之停用
+            ctx.Set(ServiceKey, service);
+            var facade = new ShrinkNetworkAppService(service);
+            moduleConfig.Services?.Register(facade);
+            if (config is ShrinkApp.ShrinkAppServices appServices)
+            {
+                appServices.Register(facade);
+                ctx.EffectInverse(() =>
+                {
+                    appServices.TryUnregister(facade);
+                    return UniTask.CompletedTask;
+                });
+            }
+            ctx.Set(ModuleKey, Name);
+
+            if (moduleConfig.BindLoopbackTransport)
+            {
+                await ctx.EffectAsync(() => BindLoopbackAsync(service, moduleConfig.LoopbackSessionId));
+            }
+        }
+
+        private static async UniTask<Func<UniTask>> BindLoopbackAsync(ShrinkNetworkService service, int sessionId)
+        {
+            var client = new ShrinkLoopbackTransport();
+            var server = new ShrinkLoopbackTransport();
+            client.LinkPeer(server);
+
+            service.BindTransport(client);
+            client.OpenSession(sessionId);
+            await UniTask.CompletedTask;
+
+            return () =>
+            {
+                // 逆操作：关闭会话并解绑传输；BindTransport(null) 触发会话清理与挂起 RPC 失败
+                client.CloseSession(sessionId);
+                service.BindTransport(null);
+                return UniTask.CompletedTask;
+            };
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs.meta
new file mode 100644
index 0000000..fc517ff
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppComponent.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f956f1f1465b7c749844f59dfd12412a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs
new file mode 100644
index 0000000..ab05d78
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs
@@ -0,0 +1,49 @@
+#nullable enable
+
+using System;
+using System.Linq;
+using Cysharp.Threading.Tasks;
+using ShrinkApp;
+
+namespace ShrinkNetwork.Integration.App
+{
+    [ShrinkAppModuleInstaller]
+    [Obsolete("ClassicHost compatibility only. ContextLoader projects should use ShrinkNetworkAppComponent from a composition root.")]
+    public sealed class ShrinkNetworkAppInstaller : IShrinkAppModuleInstaller
+    {
+        public string ModuleId => "shrink.network";
+        public int Order => -1400;
+        public System.Collections.Generic.IReadOnlyList<string> DependsOn => Array.Empty<string>();
+
+        public void RegisterServices(ShrinkAppContext context)
+        {
+            context.Services.Register(new ShrinkNetworkAppService(ShrinkNetworkRuntime.Default));
+        }
+
+        public UniTask InitializeAsync(ShrinkAppContext context)
+        {
+            return UniTask.CompletedTask;
+        }
+    }
+
+    public sealed class ShrinkNetworkAppService
+    {
+        public ShrinkNetworkAppService(ShrinkNetworkService service)
+        {
+            Service = service ?? throw new ArgumentNullException(nameof(service));
+        }
+
+        public ShrinkNetworkService Service { get; }
+
+        public ShrinkNetworkServiceDiagnosticsSnapshot GetDiagnosticsSnapshot()
+            => Service.GetDiagnosticsSnapshot();
+
+        public System.Collections.Generic.IReadOnlyList<string> GetSessionSummaries()
+        {
+            return Service.Sessions.Values
+                .OrderBy(session => session.SessionId)
+                .Select(session => $"session={session.SessionId}, remote={session.RemoteAddress}, peer={session.PeerKind}")
+                .ToArray();
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs.meta
new file mode 100644
index 0000000..999b5f9
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Runtime/ShrinkNetworkAppInstaller.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff40e733ef9026441b4698e55e421922
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Tests.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Tests.meta
new file mode 100644
index 0000000..7250b39
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 200fb1bcdd99fe34cb64508bd1e24c66
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef
new file mode 100644
index 0000000..6008001
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef
@@ -0,0 +1,25 @@
+{
+    "name": "ShrinkNetwork.Integration.App.Tests",
+    "rootNamespace": "ShrinkNetwork.Integration.App.Tests",
+    "references": [
+        "ShrinkNetwork.Integration.App",
+        "ShrinkNetwork.Runtime",
+        "ShrinkContext.Core.Runtime",
+        "ShrinkApp.Core.Runtime",
+        "UniTask",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef.meta
new file mode 100644
index 0000000..09e24b4
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetwork.Integration.App.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d64f2336fac149741b1d481059053715
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs
new file mode 100644
index 0000000..052d223
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs
@@ -0,0 +1,98 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+using ShrinkContext;
+using ShrinkNetwork;
+
+namespace ShrinkNetwork.Integration.App.Tests
+{
+    /// <summary>
+    /// 阶段 3 验收（EditMode 部分）：Network 组件热插拔——
+    /// 停用时传输解绑、会话清理、服务键撤回、依赖者停用，全部为效应回滚结果。
+    /// </summary>
+    public class ShrinkNetworkAppComponentTests
+    {
+        private ShrinkContextRuntime _runtime = null!;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _runtime = new ShrinkContextRuntime();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _runtime.ShutdownAsync().GetAwaiter().GetResult();
+        }
+
+        private static void Run(UniTask task) => task.GetAwaiter().GetResult();
+
+        [Test]
+        public void Apply_ProvidesServiceKey_AndBindsLoopbackWithSession()
+        {
+            var sessionsBefore = ShrinkNetworkRuntime.Default.Sessions.Count;
+            var fiber = _runtime.Use(new ShrinkNetworkAppComponent(),
+                new ShrinkNetworkAppModuleConfig { BindLoopbackTransport = true, LoopbackSessionId = 7 });
+
+            Assert.AreEqual(ShrinkFiberState.Active, fiber.State);
+            Assert.IsTrue(_runtime.TryGetRaw<ShrinkNetworkService>(_runtime.RootContext,
+                ShrinkNetworkAppComponent.ServiceKey, out var service));
+            Assert.AreSame(ShrinkNetworkRuntime.Default, service);
+            Assert.AreEqual(sessionsBefore + 1, service.Sessions.Count, "loopback 绑定应新建一个会话");
+        }
+
+        [Test]
+        public void Retire_UnbindsTransport_ClearsSessions_AndStopsDependents()
+        {
+            var sessionsBefore = ShrinkNetworkRuntime.Default.Sessions.Count;
+            var consumerFiber = _runtime.Use(new ServiceConsumerComponent());
+            Assert.AreEqual(ShrinkFiberState.Inactive, consumerFiber.State, "网络服务未提供前依赖者等待");
+
+            var networkFiber = _runtime.Use(new ShrinkNetworkAppComponent(),
+                new ShrinkNetworkAppModuleConfig { BindLoopbackTransport = true });
+            Assert.AreEqual(ShrinkFiberState.Active, networkFiber.State);
+            Assert.AreEqual(ShrinkFiberState.Active, consumerFiber.State, "服务键发布后依赖者激活");
+
+            Run(_runtime.RetireAsync(networkFiber));
+
+            Assert.AreEqual(sessionsBefore, ShrinkNetworkRuntime.Default.Sessions.Count,
+                "停用必须解绑传输并清理自己的会话（效应回滚，非手写卸载；不影响他人遗留会话）");
+            Assert.IsFalse(_runtime.TryGetRaw<ShrinkNetworkService>(_runtime.RootContext,
+                ShrinkNetworkAppComponent.ServiceKey, out _), "服务键随 set 的逆操作撤回");
+            Assert.AreEqual(ShrinkFiberState.Inactive, consumerFiber.State, "依赖者随提供者停用");
+        }
+
+        [Test]
+        public void Reactivate_RebindsLoopback()
+        {
+            var sessionsBefore = ShrinkNetworkRuntime.Default.Sessions.Count;
+            var first = _runtime.Use(new ShrinkNetworkAppComponent(),
+                new ShrinkNetworkAppModuleConfig { BindLoopbackTransport = true });
+            Run(_runtime.RetireAsync(first));
+            Assert.AreEqual(sessionsBefore, ShrinkNetworkRuntime.Default.Sessions.Count);
+
+            var second = _runtime.Use(new ShrinkNetworkAppComponent(),
+                new ShrinkNetworkAppModuleConfig { BindLoopbackTransport = true });
+            Assert.AreEqual(ShrinkFiberState.Active, second.State);
+            Assert.AreEqual(sessionsBefore + 1, ShrinkNetworkRuntime.Default.Sessions.Count, "重新激活重新绑定传输");
+        }
+
+        /// <summary>注入网络服务键的消费者组件。</summary>
+        private sealed class ServiceConsumerComponent : IShrinkComponent
+        {
+            public string Name => "network-consumer";
+            public IReadOnlyList<string> Inject { get; } = new[] { ShrinkNetworkAppComponent.ServiceKey };
+            public IReadOnlyList<string> Provide => Array.Empty<string>();
+            public ShrinkNetworkService? Seen { get; private set; }
+
+            public UniTask ApplyAsync(ShrinkCtx ctx, object? config)
+            {
+                Seen = ctx.Get<ShrinkNetworkService>(ShrinkNetworkAppComponent.ServiceKey);
+                return UniTask.CompletedTask;
+            }
+        }
+    }
+}
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs.meta b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs.meta
new file mode 100644
index 0000000..a031e76
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/Tests/ShrinkNetworkAppComponentTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 490be582f048d0d4ea468903e7326aac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/package.json b/Assets/Modules/ShrinkNetwork.Integration.App/package.json
new file mode 100644
index 0000000..691c67e
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "com.cneicy.shrink-network-integration-app",
+  "version": "0.1.0",
+  "displayName": "ShrinkNetwork - App Integration",
+  "description": "ShrinkNetwork 与 ShrinkApp 的桥接层，把默认网络服务纳入统一宿主服务容器。",
+  "unity": "2022.3",
+  "dependencies": {
+    "com.cneicy.shrink-network": "0.2.0",
+    "com.cneicy.shrink-app-core": "0.1.1",
+    "com.cysharp.unitask": "2.5.10",
+    "com.cneicy.shrink-context-core": "0.1.0"
+  },
+  "keywords": [
+    "network",
+    "integration",
+    "app",
+    "rpc"
+  ],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkNetwork.Integration.App/package.json.meta b/Assets/Modules/ShrinkNetwork.Integration.App/package.json.meta
new file mode 100644
index 0000000..bd37eaf
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork.Integration.App/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b37c0ec21665ffb4abd20c33356ec649
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork.Integration.EventBus/package.json b/Assets/Modules/ShrinkNetwork.Integration.EventBus/package.json
index d1c6e78..1f1918e 100644
--- a/Assets/Modules/ShrinkNetwork.Integration.EventBus/package.json
+++ b/Assets/Modules/ShrinkNetwork.Integration.EventBus/package.json
@@ -5,9 +5,9 @@
   "description": "ShrinkNetwork 与 ShrinkEventBus 的桥接层，让特定 EventBase 事件类型可直接走网络同步并在远端重新分发到 EventBus。",
   "unity": "2022.3",
   "dependencies": {
-    "com.cneicy.shrink-network": "0.1.0",
+    "com.cneicy.shrink-network": "0.2.0",
     "com.cneicy.shrink-context-core": "0.1.0",
-    "com.cneicy.shrink-eventbus": "1.1.5"
+    "com.cneicy.shrink-eventbus": "1.3.0"
   },
   "keywords": ["network", "eventbus", "integration", "bridge", "sync"],
   "author": {
diff --git a/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs b/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs
new file mode 100644
index 0000000..6727862
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("ShrinkNetwork.Editor.Tests")]
diff --git a/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs.meta b/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs.meta
new file mode 100644
index 0000000..8adbc8f
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/AssemblyInfo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 360b0480ff82f4d4bbb7cecae33717a3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs
index 6b2c77c..674c2b3 100644
--- a/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs
+++ b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs
@@ -4,8 +4,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Text;
-using System.Text.RegularExpressions;
 using UnityEditor;
 using UnityEngine;
 
@@ -19,7 +19,7 @@ public static class ShrinkDedicatedServerScaffoldGenerator
     private const string TemplateStampFileName = ".shrink-server-template.json";
     private const string TemplateManifestFileName = ".shrink-server-template-files.txt";
 
-    private sealed class MessageSpec
+    internal sealed class MessageSpec
     {
         public string TypeName = string.Empty;
         public string Kind = "message";
@@ -41,7 +41,7 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         public string SuggestedAction = string.Empty;
     }
 
-    private sealed class SubscriberSpec
+    internal sealed class SubscriberSpec
     {
         public string MemberName = string.Empty;
         public string SourcePath = string.Empty;
@@ -49,14 +49,14 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         public string Permission = string.Empty;
     }
 
-    private sealed class EnumSpec
+    internal sealed class EnumSpec
     {
         public string Name = string.Empty;
         public string SourcePath = string.Empty;
         public List<(string Name, string? Value)> Members = new();
     }
 
-    private sealed class DataTypeSpec
+    internal sealed class DataTypeSpec
     {
         public string Name = string.Empty;
         public string Kind = "class";
@@ -78,50 +78,6 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         public string SnapshotElementType = string.Empty;
     }
 
-    private static readonly Regex MessageHeaderRegex = new(
-        @"\[ShrinkNetworkMessage\((?<opcode>-?\d+)\s*,\s*""(?<route>[^""]+)""\)\][\s\S]*?(?<decl>public\s+(?:sealed\s+|partial\s+)?class\s+(?<name>\w+)\s*:\s*(?<bases>[^{\r\n]+))",
-        RegexOptions.Compiled);
-
-    private static readonly Regex PropertyRegex = new(
-        @"public\s+(?<type>[\w<>\[\]\?,\.]+)\s+(?<name>\w+)\s*\{\s*get;\s*set;\s*\}",
-        RegexOptions.Compiled);
-
-    private static readonly Regex NetworkTypeRegex = new(
-        @"public\s+(?:sealed\s+|partial\s+)?class\s+(?<name>\w+)\s*:\s*(?<bases>[^{\r\n]+)",
-        RegexOptions.Compiled);
-
-    private static readonly Regex RegisteredMessageRegex = new(
-        @"RegisterMessage<(?<name>\w+)>\((?<opcode>-?\d+)\s*,\s*""(?<route>[^""]+)""\)",
-        RegexOptions.Compiled);
-
-    private static readonly Regex SubscriberRegex = new(
-        @"\[ShrinkNetworkSubscribe\((?<args>.*?)\)\][\s\S]*?(?:UniTask<.*?>|UniTask|void|Task<.*?>|Task)\s+(?<name>\w+)\s*\(",
-        RegexOptions.Compiled);
-
-    private static readonly Regex StateSyncAttributeRegex = new(
-        @"\[ShrinkNetworkStateSync\(\s*""(?<group>[^""]+)""\s*,\s*ShrinkNetworkStateSyncRole\.(?<role>\w+)\s*\)\]",
-        RegexOptions.Compiled);
-
-    private static readonly Regex EnumHeaderRegex = new(
-        @"public\s+enum\s+(?<name>\w+)\s*",
-        RegexOptions.Compiled);
-
-    private static readonly Regex EnumMemberRegex = new(
-        @"(?m)^\s*(?<name>[A-Za-z_]\w*)(?:\s*=\s*(?<value>[^,\r\n/]+))?\s*,?\s*(?://.*)?$",
-        RegexOptions.Compiled);
-
-    private static readonly Regex DataTypeHeaderRegex = new(
-        @"public\s+(?:sealed\s+|partial\s+|readonly\s+)?(?<kind>class|struct)\s+(?<name>\w+)\s*(?::[^{\r\n]+)?",
-        RegexOptions.Compiled);
-
-    private static readonly Regex AuthorityRegex = new(
-        @"Authority\s*=\s*ShrinkNetworkAuthority\.(?<value>\w+)",
-        RegexOptions.Compiled);
-
-    private static readonly Regex PermissionRegex = new(
-        @"Permission\s*=\s*""(?<value>[^""]+)""",
-        RegexOptions.Compiled);
-
     private static readonly HashSet<string> KnownTypeTokens = new(StringComparer.Ordinal)
     {
         "bool", "byte", "sbyte", "short", "ushort", "int", "uint", "long", "ulong",
@@ -209,7 +165,7 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         return (projectRoot, assetsPath, templateRoot, serverProjectRoot, generatedOutputRoot);
     }
 
-    private static void CopyTemplateProject(string templateRoot, string outputRoot)
+    internal static void CopyTemplateProject(string templateRoot, string outputRoot)
     {
         if (!Directory.Exists(templateRoot))
             throw new DirectoryNotFoundException($"未找到插件内服务器模板：{templateRoot}");
@@ -222,41 +178,95 @@ public static class ShrinkDedicatedServerScaffoldGenerator
                 $"目标目录已存在且不是 ShrinkNetwork 自动生成的模板工程，为避免覆盖人工修改，已中止：{outputRoot}");
         }
 
-        var newManagedFiles = new List<string>();
+        var manifestPath = Path.Combine(outputRoot, TemplateManifestFileName);
+        var previousManagedFiles = ReadTemplateManifest(manifestPath);
+        var templates = new List<(string RelativePath, string OutputPath, byte[] Content)>();
         foreach (var templateFile in Directory.EnumerateFiles(templateRoot, "*", SearchOption.AllDirectories))
         {
             var relativePath = Path.GetRelativePath(templateRoot, templateFile);
             var outputRelativePath = relativePath.EndsWith(".txt", StringComparison.Ordinal)
                 ? relativePath[..^".txt".Length]
                 : relativePath;
-            newManagedFiles.Add(outputRelativePath.Replace('\\', '/'));
-            var outputFile = Path.Combine(outputRoot, outputRelativePath);
-            var outputDir = Path.GetDirectoryName(outputFile);
-            if (!string.IsNullOrWhiteSpace(outputDir))
-                Directory.CreateDirectory(outputDir);
-
             var content = File.ReadAllText(templateFile, Encoding.UTF8);
-            File.WriteAllText(outputFile, content, new UTF8Encoding(false));
+            var normalizedContent = new UTF8Encoding(false).GetBytes(content);
+            var normalizedRelativePath = outputRelativePath.Replace('\\', '/');
+            templates.Add((
+                normalizedRelativePath,
+                ResolveManagedOutputPath(outputRoot, normalizedRelativePath),
+                normalizedContent));
         }
 
-        var manifestPath = Path.Combine(outputRoot, TemplateManifestFileName);
-        if (File.Exists(manifestPath))
+        var newManagedPaths = new HashSet<string>(templates.Select(item => item.RelativePath), StringComparer.Ordinal);
+        var conflicts = new List<string>();
+        foreach (var template in templates)
         {
-            var previousManagedFiles = File.ReadAllLines(manifestPath, Encoding.UTF8)
-                .Where(line => !string.IsNullOrWhiteSpace(line))
-                .ToArray();
-            foreach (var previousManagedFile in previousManagedFiles)
-            {
-                if (newManagedFiles.Contains(previousManagedFile, StringComparer.Ordinal))
-                    continue;
+            if (!File.Exists(template.OutputPath))
+                continue;
 
-                var staleFile = Path.Combine(outputRoot, previousManagedFile.Replace('/', Path.DirectorySeparatorChar));
-                if (File.Exists(staleFile))
-                    File.Delete(staleFile);
+            var currentHash = ComputeSha256(File.ReadAllBytes(template.OutputPath));
+            if (previousManagedFiles.TryGetValue(template.RelativePath, out var previousHash))
+            {
+                if (!string.IsNullOrWhiteSpace(previousHash))
+                {
+                    if (!string.Equals(currentHash, previousHash, StringComparison.OrdinalIgnoreCase))
+                        conflicts.Add(template.RelativePath);
+                }
+                else if (!string.Equals(currentHash, ComputeSha256(template.Content), StringComparison.OrdinalIgnoreCase))
+                {
+                    conflicts.Add(template.RelativePath + "（旧清单无法证明文件未被修改）");
+                }
+            }
+            else if (!string.Equals(currentHash, ComputeSha256(template.Content), StringComparison.OrdinalIgnoreCase))
+            {
+                conflicts.Add(template.RelativePath + "（不在生成清单中）");
             }
         }
 
-        File.WriteAllLines(manifestPath, newManagedFiles.OrderBy(item => item, StringComparer.Ordinal), new UTF8Encoding(false));
+        foreach (var previousManagedFile in previousManagedFiles)
+        {
+            if (newManagedPaths.Contains(previousManagedFile.Key))
+                continue;
+
+            var stalePath = ResolveManagedOutputPath(outputRoot, previousManagedFile.Key);
+            if (!File.Exists(stalePath))
+                continue;
+
+            var currentHash = ComputeSha256(File.ReadAllBytes(stalePath));
+            if (string.IsNullOrWhiteSpace(previousManagedFile.Value) ||
+                !string.Equals(currentHash, previousManagedFile.Value, StringComparison.OrdinalIgnoreCase))
+            {
+                conflicts.Add(previousManagedFile.Key + "（待删除的旧模板文件已被修改）");
+            }
+        }
+
+        if (conflicts.Count > 0)
+        {
+            throw new InvalidOperationException(
+                "检测到人工修改的模板托管文件。生成器未写入任何文件，请先保留或迁移这些修改：" +
+                Environment.NewLine + string.Join(Environment.NewLine, conflicts.OrderBy(item => item, StringComparer.Ordinal)));
+        }
+
+        foreach (var template in templates)
+        {
+            var outputDirectory = Path.GetDirectoryName(template.OutputPath);
+            if (!string.IsNullOrWhiteSpace(outputDirectory))
+                Directory.CreateDirectory(outputDirectory);
+            File.WriteAllBytes(template.OutputPath, template.Content);
+        }
+
+        foreach (var previousManagedFile in previousManagedFiles.Keys)
+        {
+            if (newManagedPaths.Contains(previousManagedFile))
+                continue;
+            var stalePath = ResolveManagedOutputPath(outputRoot, previousManagedFile);
+            if (File.Exists(stalePath))
+                File.Delete(stalePath);
+        }
+
+        var manifestLines = templates
+            .OrderBy(item => item.RelativePath, StringComparer.Ordinal)
+            .Select(item => item.RelativePath + "\t" + ComputeSha256(item.Content));
+        File.WriteAllLines(manifestPath, manifestLines, new UTF8Encoding(false));
 
         var stamp = new StringBuilder();
         stamp.AppendLine("{");
@@ -267,39 +277,55 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         File.WriteAllText(stampPath, stamp.ToString(), new UTF8Encoding(false));
     }
 
+    private static Dictionary<string, string> ReadTemplateManifest(string manifestPath)
+    {
+        var result = new Dictionary<string, string>(StringComparer.Ordinal);
+        if (!File.Exists(manifestPath))
+            return result;
+
+        foreach (var rawLine in File.ReadAllLines(manifestPath, Encoding.UTF8))
+        {
+            var line = rawLine.Trim();
+            if (line.Length == 0)
+                continue;
+
+            var separatorIndex = line.IndexOf('\t');
+            var relativePath = separatorIndex >= 0 ? line[..separatorIndex] : line;
+            var hash = separatorIndex >= 0 ? line[(separatorIndex + 1)..].Trim() : string.Empty;
+            result[relativePath.Replace('\\', '/')] = hash;
+        }
+
+        return result;
+    }
+
+    private static string ResolveManagedOutputPath(string outputRoot, string relativePath)
+    {
+        var normalizedRoot = Path.GetFullPath(outputRoot)
+            .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
+        var fullPath = Path.GetFullPath(Path.Combine(normalizedRoot, relativePath.Replace('/', Path.DirectorySeparatorChar)));
+        if (!fullPath.StartsWith(normalizedRoot, StringComparison.OrdinalIgnoreCase))
+            throw new InvalidOperationException($"模板清单包含越界路径：{relativePath}");
+        return fullPath;
+    }
+
+    private static string ComputeSha256(byte[] content)
+    {
+        using var sha256 = SHA256.Create();
+        return BitConverter.ToString(sha256.ComputeHash(content)).Replace("-", string.Empty);
+    }
+
     private static void GenerateScaffoldFiles(string projectRoot, string assetsPath, string outputDir)
     {
         Directory.CreateDirectory(outputDir);
 
-        var messages = new List<MessageSpec>();
-        var subscribers = new List<SubscriberSpec>();
-        var enums = new List<EnumSpec>();
-        var dataTypes = new List<DataTypeSpec>();
-
-        foreach (var file in Directory.EnumerateFiles(assetsPath, "*.cs", SearchOption.AllDirectories))
-        {
-            if (file.IndexOf($"{Path.DirectorySeparatorChar}Editor{Path.DirectorySeparatorChar}", StringComparison.OrdinalIgnoreCase) >= 0)
-                continue;
-
-            var content = File.ReadAllText(file, Encoding.UTF8);
-            var relativePath = Path.GetRelativePath(projectRoot, file).Replace('\\', '/');
-
-            ExtractMessages(content, relativePath, messages);
-            ExtractSubscribers(content, relativePath, subscribers);
-            ExtractEnums(content, relativePath, enums);
-            ExtractDataTypes(content, relativePath, dataTypes);
-        }
-
-        messages = messages.GroupBy(item => item.TypeName, StringComparer.Ordinal).Select(group => group.First())
+        var scanResult = ShrinkNetworkSemanticScanner.ScanCompiledPlayerAssemblies();
+        var messages = scanResult.Messages
             .OrderBy(item => item.Opcode).ThenBy(item => item.TypeName, StringComparer.Ordinal).ToList();
-        subscribers = subscribers.OrderBy(item => item.Permission, StringComparer.Ordinal)
+        var subscribers = scanResult.Subscribers.OrderBy(item => item.Permission, StringComparer.Ordinal)
             .ThenBy(item => item.MemberName, StringComparer.Ordinal).ToList();
-        enums = enums.GroupBy(item => item.Name, StringComparer.Ordinal).Select(group => group.First())
+        var enums = scanResult.Enums
             .OrderBy(item => item.Name, StringComparer.Ordinal).ToList();
-
-        var messageTypeNames = new HashSet<string>(messages.Select(item => item.TypeName), StringComparer.Ordinal);
-        dataTypes = dataTypes.Where(item => !messageTypeNames.Contains(item.Name))
-            .GroupBy(item => item.Name, StringComparer.Ordinal).Select(group => group.First())
+        var dataTypes = scanResult.DataTypes
             .OrderBy(item => item.Name, StringComparer.Ordinal).ToList();
 
         ValidateTemplateConflicts(messages);
@@ -326,152 +352,6 @@ public static class ShrinkDedicatedServerScaffoldGenerator
         }
     }
 
-    private static void ExtractMessages(string content, string relativePath, List<MessageSpec> target)
-    {
-        var metadataByType = new Dictionary<string, (int Opcode, string Route)>(StringComparer.Ordinal);
-        foreach (Match match in MessageHeaderRegex.Matches(content))
-        {
-            metadataByType[match.Groups["name"].Value] = (
-                int.Parse(match.Groups["opcode"].Value),
-                match.Groups["route"].Value);
-        }
-
-        foreach (Match match in RegisteredMessageRegex.Matches(content))
-        {
-            var typeName = match.Groups["name"].Value;
-            if (!metadataByType.ContainsKey(typeName))
-            {
-                metadataByType[typeName] = (
-                    int.Parse(match.Groups["opcode"].Value),
-                    match.Groups["route"].Value);
-            }
-        }
-
-        foreach (Match match in NetworkTypeRegex.Matches(content))
-        {
-            var typeName = match.Groups["name"].Value;
-            if (!metadataByType.TryGetValue(typeName, out var metadata))
-                continue;
-
-            var bases = match.Groups["bases"].Value;
-            var kind = bases.Contains("IShrinkNetworkRequest", StringComparison.Ordinal)
-                ? "request"
-                : bases.Contains("ShrinkRpcResponseBase", StringComparison.Ordinal)
-                    ? "response"
-                    : bases.Contains("IShrinkNetworkMessage", StringComparison.Ordinal)
-                        ? "message"
-                        : string.Empty;
-            if (string.IsNullOrWhiteSpace(kind))
-                continue;
-
-            var body = TryExtractBody(content, match.Index);
-            var headerStart = Math.Max(0, match.Index - 256);
-            var headerLength = Math.Min(content.Length - headerStart, match.Length + 256);
-            var headerSnippet = content.Substring(headerStart, headerLength);
-            var syncMatch = StateSyncAttributeRegex.Match(headerSnippet);
-            var spec = new MessageSpec
-            {
-                TypeName = typeName,
-                Opcode = metadata.Opcode,
-                Route = metadata.Route,
-                SourcePath = relativePath,
-                HasResult = headerSnippet.Contains("[HasResult]", StringComparison.Ordinal),
-                IsNetworkEvent = headerSnippet.Contains("[ShrinkNetworkEvent]", StringComparison.Ordinal),
-                IsDeltaEvent = bases.Contains("IShrinkNetworkDeltaEvent", StringComparison.Ordinal),
-                SyncGroup = syncMatch.Success ? syncMatch.Groups["group"].Value.Trim() : string.Empty,
-                SyncRole = syncMatch.Success ? syncMatch.Groups["role"].Value.Trim() : string.Empty,
-                Kind = kind
-            };
-
-            foreach (Match propertyMatch in PropertyRegex.Matches(body))
-                spec.Properties.Add((propertyMatch.Groups["type"].Value, propertyMatch.Groups["name"].Value));
-
-            target.Add(spec);
-        }
-    }
-
-    private static void ExtractSubscribers(string content, string relativePath, List<SubscriberSpec> target)
-    {
-        foreach (Match match in SubscriberRegex.Matches(content))
-        {
-            var args = match.Groups["args"].Value;
-            target.Add(new SubscriberSpec
-            {
-                SourcePath = relativePath,
-                MemberName = match.Groups["name"].Value,
-                Authority = AuthorityRegex.Match(args).Groups["value"].Value,
-                Permission = PermissionRegex.Match(args).Groups["value"].Value
-            });
-        }
-    }
-
-    private static void ExtractEnums(string content, string relativePath, List<EnumSpec> target)
-    {
-        foreach (Match match in EnumHeaderRegex.Matches(content))
-        {
-            var body = TryExtractBody(content, match.Index);
-            if (string.IsNullOrWhiteSpace(body))
-                continue;
-
-            var spec = new EnumSpec { Name = match.Groups["name"].Value, SourcePath = relativePath };
-            foreach (Match memberMatch in EnumMemberRegex.Matches(body))
-            {
-                var memberName = memberMatch.Groups["name"].Value;
-                if (string.IsNullOrWhiteSpace(memberName))
-                    continue;
-                var memberValue = memberMatch.Groups["value"].Success ? memberMatch.Groups["value"].Value.Trim() : null;
-                spec.Members.Add((memberName, string.IsNullOrWhiteSpace(memberValue) ? null : memberValue));
-            }
-
-            if (spec.Members.Count > 0)
-                target.Add(spec);
-        }
-    }
-
-    private static void ExtractDataTypes(string content, string relativePath, List<DataTypeSpec> target)
-    {
-        foreach (Match match in DataTypeHeaderRegex.Matches(content))
-        {
-            var body = TryExtractBody(content, match.Index);
-            if (string.IsNullOrWhiteSpace(body))
-                continue;
-
-            var spec = new DataTypeSpec
-            {
-                Name = match.Groups["name"].Value,
-                Kind = match.Groups["kind"].Value,
-                SourcePath = relativePath
-            };
-
-            foreach (Match propertyMatch in PropertyRegex.Matches(body))
-                spec.Properties.Add((propertyMatch.Groups["type"].Value, propertyMatch.Groups["name"].Value));
-
-            if (spec.Properties.Count > 0)
-                target.Add(spec);
-        }
-    }
-
-    private static string TryExtractBody(string content, int startIndex)
-    {
-        var braceIndex = content.IndexOf('{', startIndex);
-        if (braceIndex < 0)
-            return string.Empty;
-
-        var depth = 0;
-        for (var i = braceIndex; i < content.Length; i++)
-        {
-            if (content[i] == '{') depth++;
-            else if (content[i] == '}')
-            {
-                depth--;
-                if (depth == 0)
-                    return content.Substring(braceIndex + 1, i - braceIndex - 1);
-            }
-        }
-
-        return string.Empty;
-    }
-
     private static void ResolvePortableDependencies(
         IReadOnlyList<MessageSpec> messages,
         IReadOnlyList<EnumSpec> enums,
@@ -531,11 +411,22 @@ public static class ShrinkDedicatedServerScaffoldGenerator
 
     private static IEnumerable<string> ExtractTypeDependencies(string typeName)
     {
-        foreach (Match match in Regex.Matches(typeName, @"[A-Za-z_]\w*"))
+        var token = new StringBuilder();
+        foreach (var character in typeName.Append(' '))
         {
-            var token = match.Value;
-            if (!KnownTypeTokens.Contains(token))
-                yield return token;
+            if (char.IsLetterOrDigit(character) || character == '_')
+            {
+                token.Append(character);
+                continue;
+            }
+
+            if (token.Length == 0)
+                continue;
+
+            var value = token.ToString();
+            token.Clear();
+            if (!KnownTypeTokens.Contains(value) && !char.IsDigit(value[0]))
+                yield return value;
         }
     }
 
@@ -1113,11 +1004,15 @@ public static class ShrinkDedicatedServerScaffoldGenerator
             return true;
         }
 
-        var genericMatch = Regex.Match(collectionType, @"^[A-Za-z_][\w\.]*<(?<element>[A-Za-z_][\w\.\?]*)>$");
-        if (genericMatch.Success)
+        var genericStart = collectionType.IndexOf('<');
+        if (genericStart > 0 && collectionType.EndsWith(">", StringComparison.Ordinal))
         {
-            elementType = genericMatch.Groups["element"].Value;
-            return true;
+            var candidate = collectionType.Substring(genericStart + 1, collectionType.Length - genericStart - 2).Trim();
+            if (candidate.Length > 0)
+            {
+                elementType = candidate;
+                return true;
+            }
         }
 
         elementType = string.Empty;
@@ -1137,7 +1032,13 @@ public static class ShrinkDedicatedServerScaffoldGenerator
     private static string SanitizeIdentifier(string value)
     {
         var token = value.Replace("/", "_").Replace("-", "_");
-        token = Regex.Replace(token, @"[^A-Za-z0-9_]", "_");
+        token = new string(token.Select(character =>
+            (character >= 'A' && character <= 'Z') ||
+            (character >= 'a' && character <= 'z') ||
+            (character >= '0' && character <= '9') ||
+            character == '_'
+                ? character
+                : '_').ToArray());
         if (string.IsNullOrWhiteSpace(token))
             return "Room";
         if (!char.IsLetter(token[0]) && token[0] != '_')
diff --git a/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs
new file mode 100644
index 0000000..77d3e9a
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs
@@ -0,0 +1,409 @@
+#if UNITY_EDITOR
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using UnityEditor.Compilation;
+
+internal sealed class ShrinkNetworkSemanticScanResult
+{
+    public List<ShrinkDedicatedServerScaffoldGenerator.MessageSpec> Messages { get; } = new();
+    public List<ShrinkDedicatedServerScaffoldGenerator.SubscriberSpec> Subscribers { get; } = new();
+    public List<ShrinkDedicatedServerScaffoldGenerator.EnumSpec> Enums { get; } = new();
+    public List<ShrinkDedicatedServerScaffoldGenerator.DataTypeSpec> DataTypes { get; } = new();
+}
+
+internal static class ShrinkNetworkSemanticScanner
+{
+    private const string MessageAttributeName = "ShrinkNetwork.ShrinkNetworkMessageAttribute";
+    private const string StateSyncAttributeName = "ShrinkNetwork.ShrinkNetworkStateSyncAttribute";
+    private const string SubscribeAttributeName = "ShrinkNetwork.ShrinkNetworkSubscribeAttribute";
+    private const string MessageInterfaceName = "ShrinkNetwork.IShrinkNetworkMessage";
+    private const string RequestInterfaceName = "ShrinkNetwork.IShrinkNetworkRequest";
+    private const string ResponseBaseName = "ShrinkNetwork.ShrinkRpcResponseBase";
+    private const string HasResultAttributeName = "ShrinkEventBus.HasResultAttribute";
+    private const string NetworkEventAttributeName = "ShrinkNetwork.Integration.EventBus.ShrinkNetworkEventAttribute";
+    private const string DeltaEventInterfaceName = "ShrinkNetwork.Integration.EventBus.IShrinkNetworkDeltaEvent";
+
+    private static readonly Dictionary<Type, string> TypeAliases = new()
+    {
+        [typeof(void)] = "void",
+        [typeof(bool)] = "bool",
+        [typeof(byte)] = "byte",
+        [typeof(sbyte)] = "sbyte",
+        [typeof(short)] = "short",
+        [typeof(ushort)] = "ushort",
+        [typeof(int)] = "int",
+        [typeof(uint)] = "uint",
+        [typeof(long)] = "long",
+        [typeof(ulong)] = "ulong",
+        [typeof(float)] = "float",
+        [typeof(double)] = "double",
+        [typeof(decimal)] = "decimal",
+        [typeof(char)] = "char",
+        [typeof(string)] = "string",
+        [typeof(object)] = "object"
+    };
+
+    internal static ShrinkNetworkSemanticScanResult ScanCompiledPlayerAssemblies()
+    {
+        var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies()
+            .Where(assembly => !assembly.IsDynamic)
+            .GroupBy(assembly => assembly.GetName().Name ?? string.Empty, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
+        var playerAssemblyNames = new HashSet<string>(
+            CompilationPipeline.GetAssemblies(AssembliesType.Player).Select(assembly => assembly.name),
+            StringComparer.Ordinal);
+        var types = playerAssemblyNames
+            .Where(loadedAssemblies.ContainsKey)
+            .SelectMany(name => GetLoadableTypes(loadedAssemblies[name]))
+            .Where(type => type != null)
+            .Distinct()
+            .ToArray();
+
+        return ScanTypes(types!);
+    }
+
+    internal static ShrinkNetworkSemanticScanResult ScanTypesForTests(params Type[] types)
+    {
+        return ScanTypes(types);
+    }
+
+    internal static string FormatTypeForTests(Type type)
+    {
+        return FormatType(type);
+    }
+
+    private static ShrinkNetworkSemanticScanResult ScanTypes(IEnumerable<Type> inputTypes)
+    {
+        var types = inputTypes
+            .Where(type => type != null && !type.ContainsGenericParameters)
+            .Distinct()
+            .OrderBy(type => type.FullName, StringComparer.Ordinal)
+            .ToArray();
+        var availableTypes = new HashSet<Type>(types);
+        var result = new ShrinkNetworkSemanticScanResult();
+        var messageTypes = new HashSet<Type>();
+
+        foreach (var type in types)
+        {
+            var messageAttribute = FindAttribute(type.CustomAttributes, MessageAttributeName);
+            if (messageAttribute == null || !IsNetworkContract(type))
+                continue;
+
+            result.Messages.Add(BuildMessageSpec(type, messageAttribute));
+            messageTypes.Add(type);
+        }
+
+        ThrowOnPortableNameCollision(
+            result.Messages.Select(message => (message.TypeName, message.SourcePath)),
+            "网络消息");
+
+        foreach (var type in types)
+            AddSubscriberSpecs(type, result.Subscribers);
+
+        AddPortableDependencySpecs(result, messageTypes, availableTypes);
+        return result;
+    }
+
+    private static ShrinkDedicatedServerScaffoldGenerator.MessageSpec BuildMessageSpec(
+        Type type,
+        CustomAttributeData messageAttribute)
+    {
+        if (messageAttribute.ConstructorArguments.Count == 0)
+            throw new InvalidOperationException($"{type.FullName} 的 ShrinkNetworkMessage 缺少 opcode。");
+
+        var opcode = Convert.ToInt32(messageAttribute.ConstructorArguments[0].Value, CultureInfo.InvariantCulture);
+        var route = messageAttribute.ConstructorArguments.Count > 1
+            ? messageAttribute.ConstructorArguments[1].Value as string ?? string.Empty
+            : string.Empty;
+        if (string.IsNullOrWhiteSpace(route))
+            throw new InvalidOperationException($"{type.FullName} 的 ShrinkNetworkMessage 必须声明非空 route，服务器合同无法依赖运行时回退值。");
+
+        var stateSyncAttributes = type.CustomAttributes
+            .Where(attribute => IsAttribute(attribute, StateSyncAttributeName))
+            .ToArray();
+        if (stateSyncAttributes.Length > 1)
+            throw new InvalidOperationException($"{type.FullName} 声明了多个 ShrinkNetworkStateSync，服务器脚手架要求每个消息只有一个同步角色。");
+
+        var stateSync = stateSyncAttributes.FirstOrDefault();
+        var spec = new ShrinkDedicatedServerScaffoldGenerator.MessageSpec
+        {
+            TypeName = type.Name,
+            Kind = GetMessageKind(type),
+            Opcode = opcode,
+            Route = route.Trim(),
+            SourcePath = GetSourceName(type),
+            HasResult = HasAttribute(type, HasResultAttributeName),
+            IsNetworkEvent = HasAttribute(type, NetworkEventAttributeName),
+            IsDeltaEvent = Implements(type, DeltaEventInterfaceName),
+            SyncGroup = GetConstructorString(stateSync, 0),
+            SyncRole = GetConstructorEnumName(stateSync, 1)
+        };
+        spec.Properties.AddRange(GetSerializableProperties(type)
+            .Select(property => (FormatType(property.PropertyType), property.Name)));
+        return spec;
+    }
+
+    private static void AddSubscriberSpecs(
+        Type type,
+        ICollection<ShrinkDedicatedServerScaffoldGenerator.SubscriberSpec> target)
+    {
+        const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic |
+                                   BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
+        foreach (var method in type.GetMethods(flags).OrderBy(method => method.MetadataToken))
+        {
+            foreach (var attribute in method.CustomAttributes.Where(item => IsAttribute(item, SubscribeAttributeName)))
+            {
+                target.Add(new ShrinkDedicatedServerScaffoldGenerator.SubscriberSpec
+                {
+                    MemberName = type.Name + "." + method.Name,
+                    SourcePath = GetSourceName(type),
+                    Authority = GetNamedEnumName(attribute, "Authority"),
+                    Permission = GetNamedString(attribute, "Permission")
+                });
+            }
+        }
+    }
+
+    private static void AddPortableDependencySpecs(
+        ShrinkNetworkSemanticScanResult result,
+        ISet<Type> messageTypes,
+        ISet<Type> availableTypes)
+    {
+        var queue = new Queue<Type>(messageTypes
+            .SelectMany(GetSerializableProperties)
+            .Select(property => property.PropertyType));
+        var visited = new HashSet<Type>();
+        var dependencyTypes = new HashSet<Type>();
+
+        while (queue.Count > 0)
+        {
+            var dependency = UnwrapType(queue.Dequeue());
+            if (dependency == null || !visited.Add(dependency))
+                continue;
+
+            if (dependency.IsGenericType)
+            {
+                foreach (var argument in dependency.GetGenericArguments())
+                    queue.Enqueue(argument);
+            }
+
+            if (!availableTypes.Contains(dependency) || messageTypes.Contains(dependency) || IsFrameworkType(dependency))
+                continue;
+
+            dependencyTypes.Add(dependency);
+            if (!dependency.IsEnum)
+            {
+                foreach (var property in GetSerializableProperties(dependency))
+                    queue.Enqueue(property.PropertyType);
+            }
+        }
+
+        ThrowOnPortableNameCollision(
+            dependencyTypes.Select(type => (type.Name, GetSourceName(type))),
+            "消息依赖类型");
+
+        foreach (var type in dependencyTypes.OrderBy(type => type.Name, StringComparer.Ordinal))
+        {
+            if (type.IsEnum)
+                result.Enums.Add(BuildEnumSpec(type));
+            else
+                result.DataTypes.Add(BuildDataTypeSpec(type));
+        }
+    }
+
+    private static ShrinkDedicatedServerScaffoldGenerator.EnumSpec BuildEnumSpec(Type type)
+    {
+        var spec = new ShrinkDedicatedServerScaffoldGenerator.EnumSpec
+        {
+            Name = type.Name,
+            SourcePath = GetSourceName(type)
+        };
+        var underlyingType = Enum.GetUnderlyingType(type);
+        foreach (var name in Enum.GetNames(type))
+        {
+            var rawValue = Enum.Parse(type, name);
+            var value = underlyingType == typeof(ulong) || underlyingType == typeof(uint) || underlyingType == typeof(ushort) || underlyingType == typeof(byte)
+                ? Convert.ToUInt64(rawValue, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture)
+                : Convert.ToInt64(rawValue, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
+            spec.Members.Add((name, value));
+        }
+        return spec;
+    }
+
+    private static ShrinkDedicatedServerScaffoldGenerator.DataTypeSpec BuildDataTypeSpec(Type type)
+    {
+        var spec = new ShrinkDedicatedServerScaffoldGenerator.DataTypeSpec
+        {
+            Name = type.Name,
+            Kind = type.IsValueType ? "struct" : "class",
+            SourcePath = GetSourceName(type)
+        };
+        spec.Properties.AddRange(GetSerializableProperties(type)
+            .Select(property => (FormatType(property.PropertyType), property.Name)));
+        return spec;
+    }
+
+    private static IEnumerable<PropertyInfo> GetSerializableProperties(Type type)
+    {
+        const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+        return type.GetProperties(flags)
+            .Where(property => property.GetIndexParameters().Length == 0 &&
+                               property.GetMethod?.IsPublic == true &&
+                               property.SetMethod?.IsPublic == true)
+            .OrderBy(property => property.MetadataToken);
+    }
+
+    private static string FormatType(Type type)
+    {
+        if (TypeAliases.TryGetValue(type, out var alias))
+            return alias;
+        if (type.IsArray)
+            return FormatType(type.GetElementType()!) + "[" + new string(',', type.GetArrayRank() - 1) + "]";
+        if (type.IsGenericParameter)
+            return type.Name;
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+            return FormatType(type.GetGenericArguments()[0]) + "?";
+        if (type.IsGenericType)
+        {
+            var name = type.Name;
+            var backtickIndex = name.IndexOf('`');
+            if (backtickIndex >= 0)
+                name = name[..backtickIndex];
+            return name + "<" + string.Join(", ", type.GetGenericArguments().Select(FormatType)) + ">";
+        }
+        return type.Name;
+    }
+
+    private static Type? UnwrapType(Type type)
+    {
+        while (type.IsArray || type.IsByRef || type.IsPointer)
+            type = type.GetElementType()!;
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+            return type.GetGenericArguments()[0];
+        return type;
+    }
+
+    private static bool IsFrameworkType(Type type)
+    {
+        var namespaceName = type.Namespace ?? string.Empty;
+        return type.Assembly == typeof(string).Assembly ||
+               namespaceName.StartsWith("System", StringComparison.Ordinal) ||
+               namespaceName.StartsWith("Unity", StringComparison.Ordinal);
+    }
+
+    private static bool IsNetworkContract(Type type)
+    {
+        return Implements(type, MessageInterfaceName) || Implements(type, RequestInterfaceName) || Inherits(type, ResponseBaseName);
+    }
+
+    private static string GetMessageKind(Type type)
+    {
+        if (Implements(type, RequestInterfaceName))
+            return "request";
+        if (Inherits(type, ResponseBaseName))
+            return "response";
+        return "message";
+    }
+
+    private static bool Implements(Type type, string interfaceFullName)
+    {
+        return type.GetInterfaces().Any(item => string.Equals(item.FullName, interfaceFullName, StringComparison.Ordinal));
+    }
+
+    private static bool Inherits(Type type, string baseTypeFullName)
+    {
+        for (var current = type.BaseType; current != null; current = current.BaseType)
+        {
+            if (string.Equals(current.FullName, baseTypeFullName, StringComparison.Ordinal))
+                return true;
+        }
+        return false;
+    }
+
+    private static bool HasAttribute(MemberInfo member, string attributeFullName)
+    {
+        return FindAttribute(member.CustomAttributes, attributeFullName) != null;
+    }
+
+    private static CustomAttributeData? FindAttribute(IEnumerable<CustomAttributeData> attributes, string attributeFullName)
+    {
+        return attributes.FirstOrDefault(attribute => IsAttribute(attribute, attributeFullName));
+    }
+
+    private static bool IsAttribute(CustomAttributeData attribute, string attributeFullName)
+    {
+        return string.Equals(attribute.AttributeType.FullName, attributeFullName, StringComparison.Ordinal);
+    }
+
+    private static string GetConstructorString(CustomAttributeData? attribute, int index)
+    {
+        return attribute != null && attribute.ConstructorArguments.Count > index
+            ? attribute.ConstructorArguments[index].Value as string ?? string.Empty
+            : string.Empty;
+    }
+
+    private static string GetConstructorEnumName(CustomAttributeData? attribute, int index)
+    {
+        if (attribute == null || attribute.ConstructorArguments.Count <= index)
+            return string.Empty;
+        return GetEnumName(attribute.ConstructorArguments[index]);
+    }
+
+    private static string GetNamedEnumName(CustomAttributeData attribute, string memberName)
+    {
+        var argument = attribute.NamedArguments.FirstOrDefault(item => string.Equals(item.MemberName, memberName, StringComparison.Ordinal));
+        return argument.MemberName == null ? string.Empty : GetEnumName(argument.TypedValue);
+    }
+
+    private static string GetNamedString(CustomAttributeData attribute, string memberName)
+    {
+        var argument = attribute.NamedArguments.FirstOrDefault(item => string.Equals(item.MemberName, memberName, StringComparison.Ordinal));
+        return argument.MemberName == null ? string.Empty : argument.TypedValue.Value as string ?? string.Empty;
+    }
+
+    private static string GetEnumName(CustomAttributeTypedArgument argument)
+    {
+        if (!argument.ArgumentType.IsEnum || argument.Value == null)
+            return argument.Value?.ToString() ?? string.Empty;
+        return Enum.GetName(argument.ArgumentType, argument.Value) ?? argument.Value.ToString() ?? string.Empty;
+    }
+
+    private static void ThrowOnPortableNameCollision(IEnumerable<(string Name, string Source)> items, string category)
+    {
+        var collisions = items
+            .GroupBy(item => item.Name, StringComparer.Ordinal)
+            .Where(group => group.Select(item => item.Source).Distinct(StringComparer.Ordinal).Skip(1).Any())
+            .OrderBy(group => group.Key, StringComparer.Ordinal)
+            .ToArray();
+        if (collisions.Length == 0)
+            return;
+
+        var details = collisions.Select(group =>
+            group.Key + ": " + string.Join(", ", group.Select(item => item.Source).Distinct(StringComparer.Ordinal).OrderBy(value => value, StringComparer.Ordinal)));
+        throw new InvalidOperationException(
+            $"{category}存在命名空间不同但简单类型名相同的类型。独立服务器合同会去掉命名空间，无法安全生成：" +
+            Environment.NewLine + string.Join(Environment.NewLine, details));
+    }
+
+    private static string GetSourceName(Type type)
+    {
+        return (type.Assembly.GetName().Name ?? "unknown") + "::" + (type.FullName ?? type.Name);
+    }
+
+    private static IEnumerable<Type> GetLoadableTypes(System.Reflection.Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetTypes();
+        }
+        catch (ReflectionTypeLoadException exception)
+        {
+            return exception.Types.OfType<Type>();
+        }
+    }
+}
+#endif
diff --git a/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs.meta b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs.meta
new file mode 100644
index 0000000..e3ba193
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/Scaffolding/ShrinkNetworkSemanticScanner.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 81f2d65d24dd8184ea8b396ba83ba159
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef b/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef
new file mode 100644
index 0000000..09f56ae
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef
@@ -0,0 +1,17 @@
+{
+  "name": "ShrinkNetwork.Editor",
+  "rootNamespace": "ShrinkNetwork.Editor",
+  "references": [
+    "ShrinkNetwork.Runtime"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef.meta b/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef.meta
new file mode 100644
index 0000000..0cbce8f
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Editor/ShrinkNetwork.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 12dae8366427fee4b805ff52065bd1c0
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/README.md b/Assets/Modules/ShrinkNetwork/README.md
index 26f2a2b..83200a7 100644
--- a/Assets/Modules/ShrinkNetwork/README.md
+++ b/Assets/Modules/ShrinkNetwork/README.md
@@ -229,8 +229,10 @@ Unity 菜单：
 
 生成内容分两部分：
 
-- 模板提供：宿主、TCP / KCP 服务端传输、基础鉴权、代码扫描器
-- 扫描生成：`Generated/*.g.cs` 项目专属消息合同、处理器模板、自动模块
+- 模板提供：宿主、TCP / KCP 服务端传输、基础鉴权与扩展点
+- 语义扫描生成：从 Unity 已编译的 Player 程序集读取类型、特性、继承与属性元数据，产出 `Generated/*.g.cs` 项目专属消息合同、处理器模板和自动模块
+
+完整工程生成会用 SHA-256 清单保护模板托管文件。再次生成前先校验全部文件仍等于上次生成版本；检测到人工修改时不会写入或删除任何模板文件。`Generated/*.g.cs` 仍属于可重建区域。
 
 当前生成器会优先识别三类高价值范式：
 
@@ -238,6 +240,8 @@ Unity 菜单：
 - `[ShrinkNetworkEvent]` 标记的广播型 / 裁决型 / 增量型网络事件
 - `[ShrinkNetworkSubscribe]` 标记的权限声明
 
+扫描以编译后类型为准，因此支持 `partial` 和复杂泛型。导出合同会去掉命名空间；不同命名空间存在同名消息或同名依赖类型时，生成器会列出冲突来源并中止，而不是静默保留第一项。仅手写 `RegisterMessage<T>()` 不属于服务器生成输入。
+
 这意味着即便不手写额外适配层，只要项目遵守同一套特性范式，独立服务器也能先生成出一套可编译、可注册、可继续补业务的骨架。
 
 ## 🔧 API 参考
@@ -294,7 +298,7 @@ new ShrinkMessagePackNetworkSerializer()
 
 - `BindTransport(...)` 只负责绑定传输与启动监听，不会替你注册业务 handler
 - `TriggerEvent` 类桥接若依赖可选程序集，当前通过运行时反射自动接入；未安装扩展包时会静默跳过
-- `GeneratedServers/` 中的产物允许重建，不要把人工业务逻辑直接写进自动生成文件
+- `GeneratedServers/*/Generated/` 中的产物允许重建，不要把人工业务逻辑直接写进自动生成文件；模板托管区虽有哈希保护，也应通过独立业务文件扩展
 - 运行依赖中的 `Kcp-CSharp.dll` 与 `System.Runtime.CompilerServices.Unsafe.dll` 需要与 Unity 平台兼容
 
 ## ✅ 已验证
diff --git a/Assets/Modules/ShrinkNetwork/Tests.meta b/Assets/Modules/ShrinkNetwork/Tests.meta
new file mode 100644
index 0000000..5caedd0
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ebb3512e8166c5d419afec30a64df768
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/Tests/Editor.meta b/Assets/Modules/ShrinkNetwork/Tests/Editor.meta
new file mode 100644
index 0000000..d003cb8
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3f8ea5f563bc3464dad27b5fa7c63adb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef
new file mode 100644
index 0000000..eb7fa79
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef
@@ -0,0 +1,23 @@
+{
+  "name": "ShrinkNetwork.Editor.Tests",
+  "rootNamespace": "ShrinkNetwork.Editor.Tests",
+  "references": [
+    "ShrinkNetwork.Runtime",
+    "ShrinkNetwork.Editor"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "autoReferenced": false,
+  "defineConstraints": [
+    "UNITY_INCLUDE_TESTS"
+  ],
+  "versionDefines": [],
+  "noEngineReferences": false,
+  "optionalUnityReferences": [
+    "TestAssemblies"
+  ]
+}
diff --git a/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef.meta b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef.meta
new file mode 100644
index 0000000..4eb28b3
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetwork.Editor.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ff014bde3ee6e184cb3bb7ffbc42d917
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs
new file mode 100644
index 0000000..bde7bbc
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs
@@ -0,0 +1,138 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using ShrinkNetwork;
+
+namespace ShrinkNetwork.Editor.Tests
+{
+    public sealed class ShrinkNetworkSemanticScannerTests
+    {
+        [Test]
+        public void NamespaceCollisionIsRejectedInsteadOfSilentlyDroppingAContract()
+        {
+            var exception = Assert.Throws<InvalidOperationException>(() =>
+                ShrinkNetworkSemanticScanner.ScanTypesForTests(
+                    typeof(CollisionA.SharedMessage),
+                    typeof(CollisionB.SharedMessage)));
+
+            StringAssert.Contains("SharedMessage", exception!.Message);
+            StringAssert.Contains(typeof(CollisionA.SharedMessage).FullName, exception.Message);
+            StringAssert.Contains(typeof(CollisionB.SharedMessage).FullName, exception.Message);
+        }
+
+        [Test]
+        public void PartialMessageUsesTheCompiledTypeAndIncludesEveryPart()
+        {
+            var result = ShrinkNetworkSemanticScanner.ScanTypesForTests(typeof(PartialMessage));
+
+            CollectionAssert.AreEqual(
+                new[] { "First", "Second" },
+                result.Messages.Single().Properties.Select(property => property.Name));
+        }
+
+        [Test]
+        public void ComplexGenericPropertyKeepsItsSemanticTypeShape()
+        {
+            var result = ShrinkNetworkSemanticScanner.ScanTypesForTests(
+                typeof(ComplexGenericMessage),
+                typeof(SemanticPayload));
+
+            var property = result.Messages.Single().Properties.Single();
+            Assert.AreEqual("Dictionary<string, List<SemanticPayload[]>>", property.Type);
+            Assert.AreEqual("Payloads", property.Name);
+            Assert.AreEqual("SemanticPayload", result.DataTypes.Single().Name);
+        }
+    }
+
+    public sealed class ShrinkDedicatedServerTemplateProtectionTests
+    {
+        private string _root = string.Empty;
+        private string _templateRoot = string.Empty;
+        private string _outputRoot = string.Empty;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _root = Path.Combine(Path.GetTempPath(), "ShrinkNetworkGeneratorTests", Guid.NewGuid().ToString("N"));
+            _templateRoot = Path.Combine(_root, "Template");
+            _outputRoot = Path.Combine(_root, "Output");
+            Directory.CreateDirectory(_templateRoot);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (Directory.Exists(_root))
+                Directory.Delete(_root, true);
+        }
+
+        [Test]
+        public void ModifiedManagedFileBlocksRegenerationBeforeAnyFileIsWritten()
+        {
+            File.WriteAllText(Path.Combine(_templateRoot, "README.md.txt"), "generated-v1");
+            File.WriteAllText(Path.Combine(_templateRoot, "settings.json.txt"), "settings-v1");
+            ShrinkDedicatedServerScaffoldGenerator.CopyTemplateProject(_templateRoot, _outputRoot);
+
+            File.WriteAllText(Path.Combine(_outputRoot, "README.md"), "manual-change");
+            File.WriteAllText(Path.Combine(_templateRoot, "settings.json.txt"), "settings-v2");
+
+            Assert.Throws<InvalidOperationException>(() =>
+                ShrinkDedicatedServerScaffoldGenerator.CopyTemplateProject(_templateRoot, _outputRoot));
+            Assert.AreEqual("manual-change", File.ReadAllText(Path.Combine(_outputRoot, "README.md")));
+            Assert.AreEqual("settings-v1", File.ReadAllText(Path.Combine(_outputRoot, "settings.json")));
+        }
+
+        [Test]
+        public void UnmodifiedManagedFilesCanBeRegeneratedFromANewerTemplate()
+        {
+            File.WriteAllText(Path.Combine(_templateRoot, "README.md.txt"), "generated-v1");
+            ShrinkDedicatedServerScaffoldGenerator.CopyTemplateProject(_templateRoot, _outputRoot);
+            File.WriteAllText(Path.Combine(_templateRoot, "README.md.txt"), "generated-v2");
+
+            ShrinkDedicatedServerScaffoldGenerator.CopyTemplateProject(_templateRoot, _outputRoot);
+
+            Assert.AreEqual("generated-v2", File.ReadAllText(Path.Combine(_outputRoot, "README.md")));
+        }
+    }
+
+    [ShrinkNetworkMessage(9101, "tests/partial")]
+    internal sealed partial class PartialMessage : IShrinkNetworkMessage
+    {
+        public int First { get; set; }
+    }
+
+    internal sealed partial class PartialMessage
+    {
+        public string Second { get; set; } = string.Empty;
+    }
+
+    [ShrinkNetworkMessage(9102, "tests/complex-generic")]
+    internal sealed class ComplexGenericMessage : IShrinkNetworkMessage
+    {
+        public Dictionary<string, List<SemanticPayload[]>> Payloads { get; set; } = new();
+    }
+
+    internal sealed class SemanticPayload
+    {
+        public Guid Id { get; set; }
+    }
+}
+
+namespace ShrinkNetwork.Editor.Tests.CollisionA
+{
+    [ShrinkNetworkMessage(9110, "tests/collision-a")]
+    internal sealed class SharedMessage : IShrinkNetworkMessage
+    {
+    }
+}
+
+namespace ShrinkNetwork.Editor.Tests.CollisionB
+{
+    [ShrinkNetworkMessage(9111, "tests/collision-b")]
+    internal sealed class SharedMessage : IShrinkNetworkMessage
+    {
+    }
+}
diff --git a/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs.meta b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs.meta
new file mode 100644
index 0000000..9e953d2
--- /dev/null
+++ b/Assets/Modules/ShrinkNetwork/Tests/Editor/ShrinkNetworkSemanticScannerTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dac93fdc7d35e3c4db7bdbeb9cc25f62
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkNetwork/package.json b/Assets/Modules/ShrinkNetwork/package.json
index 815269c..61f2afe 100644
--- a/Assets/Modules/ShrinkNetwork/package.json
+++ b/Assets/Modules/ShrinkNetwork/package.json
@@ -5,6 +5,7 @@
   "description": "面向 Unity 的轻量网络框架，提供会话、消息注册、RPC、权限控制，以及 TCP/KCP 传输抽象。",
   "unity": "2022.3",
   "dependencies": {
+    "com.cneicy.shrink-shared-codegen": "0.1.0",
     "com.cysharp.unitask": "2.5.10",
     "com.unity.nuget.newtonsoft-json": "3.2.2"
   },
diff --git a/Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkShared.CodeGen.asmdef b/Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkShared.CodeGen.asmdef
index c08242a..579aaff 100644
--- a/Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkShared.CodeGen.asmdef
+++ b/Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkShared.CodeGen.asmdef
@@ -1,12 +1,7 @@
 {
   "name": "Unity.ShrinkShared.CodeGen",
   "rootNamespace": "ShrinkShared.CodeGen",
-  "references": [
-    "ShrinkEventBus.Runtime",
-    "ShrinkCommand.Runtime",
-    "ShrinkNetwork.Runtime",
-    "ShrinkApp.Core.Runtime"
-  ],
+  "references": [],
   "includePlatforms": [
     "Editor"
   ],
@@ -14,10 +9,10 @@
   "allowUnsafeCode": true,
   "overrideReferences": true,
   "precompiledReferences": [
-    "Unity.Burst.Cecil.dll",
-    "Unity.Burst.Cecil.Mdb.dll",
-    "Unity.Burst.Cecil.Pdb.dll",
-    "Unity.Burst.Cecil.Rocks.dll"
+    "Mono.Cecil.dll",
+    "Mono.Cecil.Mdb.dll",
+    "Mono.Cecil.Pdb.dll",
+    "Mono.Cecil.Rocks.dll"
   ],
   "autoReferenced": false,
   "defineConstraints": [],
diff --git a/Assets/Modules/ShrinkShared.CodeGen/README.md b/Assets/Modules/ShrinkShared.CodeGen/README.md
new file mode 100644
index 0000000..a2ad718
--- /dev/null
+++ b/Assets/Modules/ShrinkShared.CodeGen/README.md
@@ -0,0 +1,5 @@
+# Shrink Shared CodeGen
+
+Editor-only UPM 包，为引用 ShrinkCommand.Runtime、ShrinkNetwork.Runtime 或 ShrinkApp.Core.Runtime 的程序集生成程序集级注册表。
+
+该包只通过 Cecil 按程序集名和类型全名读取元数据，不在 asmdef 或 UPM 层反向引用业务包。因此 App、Command、Network 可以依赖它而不形成循环依赖。运行时不包含此包代码。
diff --git a/Assets/Modules/ShrinkShared.CodeGen/README.md.meta b/Assets/Modules/ShrinkShared.CodeGen/README.md.meta
new file mode 100644
index 0000000..9033778
--- /dev/null
+++ b/Assets/Modules/ShrinkShared.CodeGen/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c9ae00f51ad2a3e4a82845953bf8bff9
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkShared.CodeGen/package.json b/Assets/Modules/ShrinkShared.CodeGen/package.json
new file mode 100644
index 0000000..825b84c
--- /dev/null
+++ b/Assets/Modules/ShrinkShared.CodeGen/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "com.cneicy.shrink-shared-codegen",
+  "version": "0.1.0",
+  "displayName": "Shrink Shared CodeGen",
+  "description": "ShrinkApp、ShrinkCommand 与 ShrinkNetwork 共用的 Unity IL 后处理注册表生成器。",
+  "unity": "2022.3",
+  "dependencies": {
+    "com.unity.nuget.mono-cecil": "1.11.4"
+  },
+  "keywords": ["codegen", "ilpp", "registry"],
+  "author": {
+    "name": "cneicy",
+    "url": "https://github.com/cneicy"
+  }
+}
diff --git a/Assets/Modules/ShrinkShared.CodeGen/package.json.meta b/Assets/Modules/ShrinkShared.CodeGen/package.json.meta
new file mode 100644
index 0000000..51a2018
--- /dev/null
+++ b/Assets/Modules/ShrinkShared.CodeGen/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 12ee30d453322c346b13f068125681d5
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Modules/ShrinkTutorial/package.json b/Assets/Modules/ShrinkTutorial/package.json
index 42d07c3..4bf69fb 100644
--- a/Assets/Modules/ShrinkTutorial/package.json
+++ b/Assets/Modules/ShrinkTutorial/package.json
@@ -6,7 +6,8 @@
   "unity": "2022.3",
   "dependencies": {
     "com.unity.textmeshpro": "3.0.7",
-    "com.unity.ugui": "1.0.0"
+    "com.unity.ugui": "1.0.0",
+    "com.unity.modules.physics": "1.0.0"
   },
   "keywords": [
     "tutorial",
diff --git a/Assets/Resources/ShrinkAppComposition.asset b/Assets/Resources/ShrinkAppComposition.asset
index d297ecc..c47eb48 100644
--- a/Assets/Resources/ShrinkAppComposition.asset
+++ b/Assets/Resources/ShrinkAppComposition.asset
@@ -46,4 +46,8 @@ MonoBehaviour:
     enabled: 1
     isolate: []
     intercept: []
+  - id: demo2.rule-factory
+    enabled: 1
+    isolate: []
+    intercept: []
   jsonOverride: {fileID: 0}
diff --git a/DESIGN.md b/DESIGN.md
index 75d8fed..6d72695 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1,306 +1,226 @@
-# ShrinkSDK 项目设计总结
+# ShrinkSDK 当前架构
 
-> 生成日期：2026-08-16
-> 依据：仓库源码（`Assets/Modules/`、`GeneratedServers/`）、各模块 `package.json` / `README.md` / `CHANGELOG.md`、`.planning/threads/shrinksdkunity.md`、`NETWORK_PITFALLS.md`，以及 `.planning/codebase/` 既有代码库地图（其中部分内容已滞后于当前代码，本文以源码现状为准）。
-
----
+> 当前基线：2026-08-18
+> 本文是仓库唯一的当前架构文档。实现与本文冲突时，以源码、`package.json`、asmdef 和自动化验证结果为准，并应在同一变更中修正文档。迁移过程与旧代码地图只保存在 `Docs/Archive/`，不再作为当前设计依据。
 
 ## 1. 项目定位
 
-ShrinkSDK 是一个**以 Unity 包（UPM）为边界的 SDK 单仓库**，不是单个游戏项目。它为 Unity 游戏提供一整套可独立分发、可拼装组合的基础设施：
+ShrinkSDK 是以 Unity Package Manager 包为发布边界的 SDK 单仓库，不是单个游戏项目。仓库直接拥有 `Assets/Modules/` 下全部包源码；模块目录不再是嵌套 Git 仓库或 gitlink。一次干净克隆应能获得完整源码，Unity 只需要恢复外部 UPM 依赖。
 
-- 事件总线（ShrinkEventBus）
-- 存档与设置（ShrinkDataSaver）
-- 命令系统（ShrinkCommand）
-- 网络框架与独立服务器生成（ShrinkNetwork + GeneratedServers）
-- 模组框架（ShrinkModFramework，Forge 风格）
-- 新手引导（ShrinkTutorial）
-- 统一应用宿主与起盘 Starter（ShrinkApp.Core + ShrinkApp.Starter.Basic，最新一轮工作）
+它提供四层能力：
 
-设计哲学贯穿全仓库：**静态门面 + Attribute 声明式范式 + 编译期注册表 + asmdef 最小抽象 + 可选桥接包**。不做重框架化（无 DI 容器、无第三方状态机），追求低侵入接入 Unity 项目。
+1. 基础模块：EventBus、DataSaver、Command、Network、Tutorial。
+2. 动态组合内核：ShrinkContext.Core，以可逆效应、响应式依赖和 fiber 生命周期承载模块装卸。
+3. 应用与扩展宿主：ShrinkApp、Starter、ModFramework。
+4. 边界适配与生成工具：`*.Integration.*`、共享 IL 后处理器、独立服务器生成器。
 
-## 2. 技术栈
+当前默认应用主路径是 `ContextLoader`。`ClassicHost` 和旧 installer 只作为兼容面保留，不再承载新架构能力。
 
-| 项 | 值 |
-|---|---|
-| Unity 版本 | 2022.3（`ProjectSettings/ProjectVersion.txt`） |
-| 语言 | C#（运行时与独立 .NET 宿主共用合同） |
-| 异步 | UniTask 2.x（`com.cysharp.unitask`） |
-| 序列化 | Newtonsoft.Json（`com.unity.nuget.newtonsoft-json` 3.2.2）；网络层另支持 MessagePack-CSharp 3.1.4 |
-| 编译织入 | Unity ILPostProcessing + Mono.Cecil |
-| UI | uGUI + TextMeshPro |
-| 渲染 | URP 14 |
-| 网络 | 自研传输层：Loopback / TCP（含可选 TLS）/ KCP（Kcp-CSharp.dll） |
-| 独立服务器 | .NET 8 控制台宿主（`GeneratedServers/ShrinkNetwork.ServerHost`） |
-| 测试 | Unity Test Runner（NUnit，EditMode 为主） |
+## 2. 开发原则
 
-## 3. 仓库布局
+### 2.1 包是发布边界，asmdef 是编译边界
+
+- 每个 `Assets/Modules/<Module>/package.json` 都必须能被独立 UPM 消费。
+- 主包不反向依赖集成包；跨模块行为放入 `*.Integration.*` 或 Context adapter。
+- asmdef 只声明实际编译依赖，不依靠根工程中偶然存在的程序集。
+- 内部包依赖版本必须等于被依赖包自身的 `version`，不接受“根工程能编译所以先放着”的漂移。
+
+### 2.2 声明契约，生成注册，避免运行时全域扫描
+
+网络消息、订阅者、命令、事件订阅和 App 安装器使用 Attribute 声明。`ShrinkShared.CodeGen` 在 Unity 编译期写入程序集注册表，运行时读取注册表；实例对象和外部 DLL 走显式实例注册。
+
+独立服务器生成器是编辑器工具，不参与运行时注册。它读取 Unity 已编译的 Player 程序集元数据，而不是用正则解析 C# 文本。因此 `partial`、命名空间、复杂泛型和真实继承关系都由编译器语义决定。可导出的网络消息必须显式声明 `[ShrinkNetworkMessage(opcode, route)]`；单独手写 `RegisterMessage<T>()` 不是可移植的生成输入。
+
+### 2.3 静态门面负责易用性，可实例化内核负责组合
+
+`EventBus`、`ShrinkApp`、`ShrinkNetworkRuntime.Default` 等静态入口是默认根的易用门面，不是生命周期所有者。真实服务可实例化，并由 Context 组件安装、发布、撤回。门面注册也必须被视为可逆效应，组件退役时按实例注销，不能留下失效的全局引用。
+
+### 2.4 运行时变更必须可回滚、可解释
+
+组件通过 `ShrinkCtx.Effect/EffectAsync/EffectInverse` 记录逆操作，通过 `Set/Get` 提供和消费能力。加载失败、依赖消失、热替换失败都应恢复到上一个已提交组合。诊断必须能回答：哪个 fiber 在等待什么、当前 provider 是谁、哪次事务失败、是否完成恢复。
+
+### 2.5 生成内容与人工内容分区
+
+- `GeneratedServers/*/Generated/*.g.cs` 是可重建合同，不承载手写业务。
+- 服务器模板文件由哈希清单管理。重新生成前先验证全部现有文件仍等于上次生成版本；任何人工修改都会让整个复制阶段在写入前中止。
+- 业务扩展应放在非生成文件或独立模块中，不通过修改生成产物维持。
+
+## 3. 仓库结构
 
 ```text
 ShrinkSDK/
-├── Assets/Modules/            # 全部 SDK 模块（每个是独立 UPM 包 + asmdef）
-│   ├── ShrinkEventBus/        # 事件总线（Runtime/Editor/CodeGen/Tests）
-│   ├── ShrinkDataSaver/       # 存档与设置（Runtime/Editor/Tests）
-│   ├── ShrinkCommand/         # 命令系统
-│   ├── ShrinkNetwork/         # 网络框架（Core/Metadata/Routing/Serialization/Transport/Editor 脚手架）
-│   ├── ShrinkModFramework/    # 模组框架（Bootstrap/Core/Metadata/Registry/Loading/Network/Integration）
-│   ├── ShrinkTutorial/        # 新手引导（Core/Storage/Trigger/UI）
-│   ├── ShrinkApp.Core/        # 统一应用宿主层
-│   ├── ShrinkApp.Starter.Basic/ # 最小起盘 Starter
-│   ├── ShrinkShared.CodeGen/  # 共享 IL 织入管线
-│   └── *.Integration.EventBus / *.Integration.App  # 模块间桥接包
-├── Assets/Scenes/             # 示例/演示场景
-├── GeneratedServers/          # 生成的独立 .NET 服务器工程（可重建，不手写业务）
-├── GeneratedModSdk/           # 导出的 Mod SDK 开发包（Libs/Templates/manifest）
-├── Servers/                   # （当前为空）
-├── Packages/manifest.json     # UPM 依赖
-├── ShrinkSDK.sln              # 解决方案（含全部模块 csproj）
-├── NETWORK_PITFALLS.md        # 联网与事件桥接踩坑记录（19 条经验）
-└── .planning/                 # gsd 线程与代码库地图（部分滞后）
+|-- Assets/Modules/                 19 个根仓库直接跟踪的 UPM 包
+|-- Assets/Scenes/                  示例与验收场景
+|-- Assets/Resources/               当前应用配置与组合 Profile
+|-- GeneratedServers/               独立 .NET 宿主、生成合同与烟测工程
+|-- GeneratedModSdk/                Mod SDK 导出物
+|-- Packages/                       根 Unity 工程依赖
+|-- Tools/UpmConsumerValidation/    干净 UPM 消费工程验证
+|-- Docs/Archive/                   已完成迁移与过期地图，仅供追溯
+|-- DESIGN.md                       唯一当前架构文档
+|-- NETWORK_PITFALLS.md             网络实现经验记录，不是架构基线
+`-- .planning/threads/              工作线程恢复记录，不是产品文档
 ```
 
-## 4. 模块清单与依赖关系
+## 4. 包清单
 
-| 包名 | 版本 | 职责 | 关键依赖 |
-|---|---|---|---|
-| `com.cneicy.shrink-eventbus` | 1.3.0 | 高性能类型安全事件总线，优先级调度与自动注册 | UniTask |
-| `com.cneicy.shrink-datasaver` | 2.2.0 | 模块化存档与设置：多槽位、链式迁移、AES 加密、双备份 | Newtonsoft, UniTask |
-| `com.cneicy.shrink-datasaver-integration-eventbus` | 2.1.0 | DataSaver 原生事件 → EventBus 桥接（9 个事件类型） | DataSaver, EventBus |
-| `com.cneicy.shrink-datasaver-integration-app` | 0.1.0 | DataSaver 初始化交给 ShrinkApp 宿主接管 | DataSaver, App.Core |
-| `com.cneicy.shrink-command` | 0.2.0 | 路径式命令系统（Minecraft/Brigadier 风格）、权限、来源判定 | UniTask |
-| `com.cneicy.shrink-command-integration-eventbus` | 0.1.1 | 事件请求执行命令 + 命令生命周期事件发布 | Command, EventBus |
-| `com.cneicy.shrink-command-integration-network` | 0.1.0 | `command/execute` RPC 远程执行命令 | Command, Network |
-| `com.cneicy.shrink-command-integration-app` | 0.1.0 | 默认命令服务纳入宿主容器 | Command, App.Core |
-| `com.cneicy.shrink-network` | 0.2.0 | 会话、消息注册、RPC、权限、TCP/KCP/Loopback 传输 | UniTask, Newtonsoft |
-| `com.cneicy.shrink-network-integration-eventbus` | 0.1.1 | EventBase 事件直接走网络同步并在远端重分发 | Network, EventBus |
-| `com.cneicy.shrink-network-integration-app` | 0.1.0 | 默认网络服务纳入宿主容器 | Network, App.Core |
-| `com.cneicy.shrink-mod-framework` | 0.1.0 | 模组发现、依赖解析、生命周期、注册表、外部 DLL 热载、Harmony | Newtonsoft |
-| `com.cneicy.shrink-tutorial` | 0.1.0 | 数据驱动互动引导：遮罩挖洞、动态锚点、条件完成 | uGUI, TMP |
-| `com.cneicy.shrink-app-core` | 0.1.0 | 统一宿主：模块安装器、服务容器、统一启动流程 | EventBus, UniTask |
-| `com.cneicy.shrink-app-starter-basic` | 0.1.0 | 最小起盘：入口场景生成 + 五模块最小闭环调试台 | App.Core, Command, DataSaver, Network 及各自 Integration.App |
-| `ShrinkShared.CodeGen`（asmdef） | — | 共享 IL 后处理器：四套编译期注册表 + EventBus 织入 | Cecil |
+| 包 | 版本 | 职责 |
+|---|---:|---|
+| `com.cneicy.shrink-eventbus` | 1.3.0 | 类型安全事件总线、优先级派发、编译期自动注册 |
+| `com.cneicy.shrink-datasaver` | 2.2.0 | 多槽位存档、设置、迁移、加密、原子写入与备份 |
+| `com.cneicy.shrink-command` | 0.2.0 | 路径式命令、权限与同步/异步执行 |
+| `com.cneicy.shrink-network` | 0.2.0 | 消息、RPC、权限、诊断、TCP/KCP/Loopback 与服务器生成 |
+| `com.cneicy.shrink-mod-framework` | 0.1.0 | 模组发现、依赖、生命周期、外部 DLL revision 与 Harmony lease |
+| `com.cneicy.shrink-tutorial` | 0.1.0 | 数据驱动引导、遮罩、锚点、触发与持久化 |
+| `com.cneicy.shrink-context-core` | 0.1.0 | 可逆效应、coeffect、fiber、声明式 loader 与诊断 |
+| `com.cneicy.shrink-app-core` | 0.1.1 | App 设置、服务门面、ClassicHost 兼容面与宿主协议 |
+| `com.cneicy.shrink-app-starter-basic` | 0.1.0 | 默认 Context 组合根、配置资产和示例入口 |
+| `com.cneicy.shrink-context-app-adapter` | 0.1.0 | ContextLoader 宿主、Profile/JSON、诊断与基准 |
+| `com.cneicy.shrink-context-eventbus-adapter` | 0.1.0 | EventBus 注册/订阅的可逆效应包装 |
+| `com.cneicy.shrink-datasaver-integration-eventbus` | 2.1.0 | DataSaver 事件桥 |
+| `com.cneicy.shrink-datasaver-integration-app` | 0.1.0 | DataSaver App installer/原生 Context 组件 |
+| `com.cneicy.shrink-command-integration-eventbus` | 0.1.1 | 命令请求与生命周期事件桥 |
+| `com.cneicy.shrink-command-integration-network` | 0.1.0 | `command/execute` RPC 桥 |
+| `com.cneicy.shrink-command-integration-app` | 0.1.0 | Command App installer/原生 Context 组件 |
+| `com.cneicy.shrink-network-integration-eventbus` | 0.1.1 | 网络事件广播、裁决结果与 delta 去重 |
+| `com.cneicy.shrink-network-integration-app` | 0.1.0 | Network App installer/原生 Context 组件 |
+| `com.cneicy.shrink-shared-codegen` | 0.1.0 | App、Command、Network 共用的 Editor-only IL 后处理注册表生成器 |
 
-依赖层次（自底向上）：
+`ShrinkShared.CodeGen` 不反向引用业务 asmdef，只按程序集名与类型全名读取 Cecil 元数据，因此业务包可以依赖它而不形成包循环。
+
+## 5. 总体分层
 
 ```text
-ShrinkShared.CodeGen（编译期，作用于 Command/Network/App 引用方程序集）
-        │
-ShrinkEventBus ←── ShrinkDataSaver ←── DataSaver.Integration.EventBus
-        ↑                                        （独立桥接，不依赖 App）
-ShrinkNetwork  ←── ShrinkCommand（经 Integration.Network 桥）
-        ↑
-ShrinkModFramework（Integration/ 胶水可选自动接入以上三者）
-        ↑
-ShrinkApp.Core（组合根）←── *.Integration.App（各模块安装器）
-        ↑
-ShrinkApp.Starter.Basic（起盘模板）
+Starter / Composition Profile
+            |
+ShrinkAppLoaderBootstrapper ---- ClassicHost (compatibility only)
+            |
+ShrinkContextLoader + ShrinkContextRuntime
+            |
+native module components ---- integration components
+     |                              |
+Command / DataSaver / Network / EventBus / Tutorial
+     |
+transport, storage, external files, generated .NET server
 ```
 
-## 5. 总体架构
+依赖方向只能向下。功能主包不知道 App、Context 或 EventBus 桥；适配包引用双方并负责把副作用变成可撤回效应。
 
-### 5.1 分层视图
+## 6. ContextLoader 当前完成态
 
-```text
-┌──────────────────────────────────────────────────────────┐
-│  Starter 层：ShrinkApp.Starter.Basic（场景/配置/UI 生成） │
-├──────────────────────────────────────────────────────────┤
-│  组合根：ShrinkApp.Core（Host/Services/Installer 排序）  │
-├───────────────┬───────────────┬──────────────────────────┤
-│ 功能模块：    │  EventBus     │  DataSaver   │ Tutorial  │
-│               │  Command      │  Network     │           │
-├───────────────┴───────────────┴──────────────────────────┤
-│ 桥接层：*.Integration.EventBus / *.Integration.Network   │
-│         *.Integration.App（可选包，反射自动发现）        │
-├──────────────────────────────────────────────────────────┤
-│ 扩展面：ShrinkModFramework（模组热载 + Harmony + 上述全） │
-├──────────────────────────────────────────────────────────┤
-│ 编译期：ShrinkShared.CodeGen（Cecil IL 织入/注册表注入） │
-├──────────────────────────────────────────────────────────┤
-│ 独立宿主：GeneratedServers/ShrinkNetwork.ServerHost(.NET)│
-└──────────────────────────────────────────────────────────┘
-```
+Cordis 迁移的阶段 0 至阶段 5 已进入当前架构，不再是待办计划。
 
-### 5.2 四个横切设计模式（全仓库统一）
+### 6.1 核心语义
 
-**模式一：Attribute 声明式范式。** 每个子系统用自己的特性声明能力，处理器/消息/命令/安装器都是 `[Xxx] + 类型` 的组合：`[EventBusSubscriber]+[EventSubscribe]`、`[ShrinkNetworkMessage(opcode, route)]`、`[ShrinkNetworkSubscriber]+[ShrinkNetworkSubscribe]`、`[ShrinkCommand("say <message...>")]`、`[ShrinkMod(modId,...)]`、`[ShrinkAppModuleInstaller]`。
+- `ShrinkCtx.Effect/EffectAsync`：前向执行产生逆操作，按 LIFO 回滚；前向未完成前不会执行逆操作。
+- `ShrinkCtx.Set/Get`：provider 安装和撤回触发依赖者响应；同值但不同 provider uid 仍会触发重载。
+- `ShrinkContextRuntime.Use`：组件实例化为 fiber，状态按 `Loading -> Active -> Unloading -> Inactive` 惯性转换。
+- 退役 provider 时先排空依赖者，再执行 provider 的逆操作。
+- `IShrinkIterativeComponent` 支持分步效应和部分回滚。
+- `Provide` 声明限制组件写入能力；未声明、未激活和策略拒绝是三种不同错误。
 
-**模式二：编译期注册表取代全域反射。** `ShrinkShared.CodeGen/Editor/ShrinkRegistryILPostProcessor.cs` 是唯一的共享 IL 后处理器，对引用了 `ShrinkCommand.Runtime` / `ShrinkNetwork.Runtime` / `ShrinkApp.Core.Runtime` 的程序集做四件事：
+### 6.2 声明式协调
 
-1. `InjectEventBusAutoRegister`：给带 `[EventBusSubscriber]` 的 MonoBehaviour 织入 `Awake → EventBus.AutoRegister(this)` 与 `OnDestroy → UnregisterInstance`（处理了继承基类 Awake/OnDestroy 的 base 调用）。
-2. `InjectShrinkCommandRegistry`：静态命令类型写入程序集级 `[ShrinkCommandStaticRegistry(typeof(...))]`。
-3. `InjectShrinkNetworkRegistry`：`[ShrinkNetworkMessage]` 消息类型与静态订阅者类型分别写入 `[ShrinkNetworkMessageRegistry]` / `[ShrinkNetworkStaticSubscriberRegistry]`。
-4. `InjectShrinkAppRegistry`：`[ShrinkAppModuleInstaller]` 安装器类型写入 `[ShrinkAppInstallerRegistry]`。
+`ShrinkContextLoader.ApplyAsync` 根据 `ShrinkLoaderEntry` 的期望集合增量协调：
 
-运行时 `AutoRegisterAll()` 只读程序集特性，不做 `AppDomain.GetAssemblies()+GetTypes()` 全域扫描——这是模组外部 DLL 与独立服务器共用的关键机制（外来 DLL 不经过 Unity 编译管线，仍可走实例注册路径 `RegisterHandlers(object)` / `RegisterCommands(object)` 兜底）。注意织入器刻意**不处理核心程序集自身**（否则 Cecil 写回会触发 Unity "references itself" 拒载，源码注释中已记录该教训）。
+- 新条目创建 fiber；消失或禁用的条目退役。
+- 组件、配置或 isolate 改变时重建。
+- intercept 元数据可原位更新，不改变 provider uid 或 fiber generation。
+- 事务失败时恢复旧条目、旧 provider 关系和已提交视图。
+- `key -> inject fibers` 倒排索引限制通知候选，再按 realm 精确过滤。
 
-**模式三：静态门面 + 可实例化内核。** `EventBus`（静态门面）委托给 Builder 构建的 `IShrinkEventBus` 实例（默认 LogAndContinue + 按 phase 派发，可 CreateBus 多实例）；`ShrinkNetworkRuntime.Default` / `ShrinkCommandService` 同理。使用方零成本拿到默认单例，高级场景可自建实例。
+### 6.3 隔离、访问与边界
 
-**模式四：可选桥接包 + 运行时反射自动发现。** 模块间集成全部做成独立小包（不污染主包依赖），并用反射探测"对方是否存在"：`ShrinkNetworkService.BindTransport(...)` 自动接入 EventBus 桥（`BindTransport(null)` 解绑）；`ShrinkModFramework/Runtime/Integration/ShrinkModOptionalRuntimeIntegration.cs` 在模组注册时自动尝试把模组实例接到 EventBus/Command/Network。未安装桥接包时静默跳过。
+`isolate` 创建独立解析域；`intercept` 将访问元数据交给领域策略，当前可用于 DataSaver 只读能力。它们是组合与能力介导机制，不是不可信 DLL 的安全沙箱，也不能撤回已经发送的网络数据或外部文件写入。
 
-### 5.3 ShrinkApp 统一宿主（组合根）
+### 6.4 App 默认组合
 
-最新引入的 `ShrinkApp.Core` 把"谁先启动、服务放哪"收口为一条统一链路：
+`ShrinkAppLoaderBootstrapper.DefaultComposition` 接入 Basic Starter 的七个声明式模块：Command、DataSaver、Network 三个原生组件，Command-Network 集成，以及 Command/DataSaver/Network 的 EventBus 集成。
 
-1. `Shrink.Bootstrap`：`[RuntimeInitializeOnLoadMethod(BeforeSceneLoad)]` 创建 `ShrinkAppHost` GameObject（可 DontDestroyOnLoad），组装 `ShrinkAppContext = Host + Settings + Services`。
-2. **安装器发现**：`ShrinkAppGeneratedRegistry` 扫描程序集级 `[ShrinkAppInstallerRegistry]`（由共享织入器生成），实例化所有 `IShrinkAppModuleInstaller`。
-3. **拓扑排序**：按 `Order` + `DependsOn`（显式成环/缺依赖/重复 ModuleId 直接抛错），`ShrinkAppSettings.disabledModuleIds` 可整模块禁用。
-4. **两阶段启动**：先统一 `RegisterServices(context)`（向 `ShrinkAppServices` 类型字典容器注册服务），再按序 `InitializeAsync`。
-5. **事件广播**：成功发 `ShrinkAppStartedEvent`（含模块清单，等待 Unity `Start` 后才发布），失败发 `ShrinkAppStartFailedEvent`。
+`ShrinkAppCompositionProfile` 用 ScriptableObject/JSON 决定条目启用、显式排除、isolate 与 intercept；组件工厂仍由代码注册，配置文件不能按任意类型名反射实例化对象。`ShrinkSDK/Cordis/诊断与组合` 显示 fiber、等待依赖、provider target、事务和外部程序集 revision。
 
-各功能模块通过 `*.Integration.App` 包提供安装器（如 `ShrinkNetworkAppInstaller`，ModuleId `shrink.network`，Order -1400），把各自的默认服务注册进容器。`ShrinkDataSaver` 2.2.0 专门新增 `ShrinkDataSaverRuntime` 把初始化入口从 MonoBehaviour Bootstrap 下沉，为的就是让宿主接管初始化顺序（旧 `ShrinkDataSaverBootstrap` 保留为兼容入口）。
+`ShrinkApp.IsRunning` 与 `ShrinkApp.Services` 已接回 LoaderHost。原生组件停用时使用 `TryUnregister(instance)` 撤回对应门面。旧 `IShrinkAppModuleInstaller` 适配仍可用于 ClassicHost，但默认 ContextLoader 不再通过它启动核心模块。
 
-### 5.4 生命周期入口一览
+## 7. 功能模块与组合关系
 
-| 入口 | 时机 | 作用 |
-|---|---|---|
-| `ShrinkApp.Bootstrap` | BeforeSceneLoad | 创建宿主并按拓扑序启动全部安装器 |
-| `ShrinkModRuntimeBootstrap` | AfterAssembliesLoaded | 读设置、装载模组（场景内/外部 DLL）、接 Harmony |
-| `DataSaverEventBusBridge` | AfterAssembliesLoaded | DataSaver 原生事件桥到 EventBus |
-| `ShrinkTutorialRuntimeBootstrap` | 运行时初始化 | 引导系统自举 |
-| `ShrinkDataSaverBootstrap`（MonoBehaviour，兼容） | 场景 | 委托 `ShrinkDataSaverRuntime`；自动保存轮询、暂停/退出落盘 |
-| EventBus IL 织入 | 编译期 | MonoBehaviour 自动注册/反注册 |
+### 7.1 EventBus
 
-## 6. 各模块设计要点
+静态 `EventBus` 委托给 `IShrinkEventBus` 实例。监听按 phase 和数字优先级稳定归并；订阅句柄可单独释放，实例注册可整体撤销。Context 适配器把二者登记为效应，保证 fiber 卸载自动退订。
 
-### 6.1 ShrinkEventBus 1.3.0
+### 7.2 DataSaver
 
-- **双层结构**：静态门面 `EventBus` + `IShrinkEventBus` 实例（`ShrinkEventBusBuilder` 配置异常策略、类型校验、marker 接口、phase 派发）。
-- **订阅模型**：`Action<T>` 同步与 `Func<T, UniTask>` 异步两种 handler；优先级支持枚举 `EventPriority` 与数字（数字 0 = NORMAL）；`receiveCanceled` 控制取消后是否继续收；`IShrinkEventSubscription` 句柄式订阅 + 实例对象整体注册两套 API。
-- **派发机制**：监听列表按 phase 分桶 + 快照缓存（`ListenerList`），支持父事件监听子事件，跨父子按数字优先级稳定归并；事件对象持有派发时快照而非内置列表。1.3.0 对热路径做了系统性并发加固（总线内单锁、`EventId` 懒生成、`ConcurrentDictionary` 元数据缓存、`EventPool` 容量上限 128 防双重归还）。
-- **声明能力**：`[Cancelable]` / `[HasResult]` 标注事件语义；`EventResult` 承载结果。
-- **自动注册**：编译期织入（见 5.2）+ 静态注册表；1.3.0 修复"无实例订阅方法的类型被织入后在 Awake 抛异常"的问题，现改警告跳过。
-- **兜底管线**：共享织入器覆盖不到、只引用 `ShrinkEventBus.Runtime` 的程序集由模块内 `CodeGen/Editor/EventBusILPostProcessor.cs` 本地兜底。
-- **工具**：`EventBusViewerWindow` 编辑器查看器（走公开快照接口，不反射私有字段）、`EventBusBenchmark`、Tests 目录覆盖派发/优先级/注册/订阅四类行为。
+`ShrinkSave`、`ShrinkSettings` 和 `ShrinkDataSaverRuntime` 构成运行时入口。存储层以临时文件原子替换主文件并轮换 `.bak1/.bak2`；损坏时尝试备份恢复。Context 原生组件发布 reader/writer 能力并在停用时做补偿式收尾。
 
-### 6.2 ShrinkDataSaver 2.2.0
+### 7.3 Command
 
-- **核心对象**：`ShrinkSave`（存档门面：槽位保存/加载/删除、截图存档、跨模块查询缓存）、`ShrinkSettings`（设置门面：读写、监听、防抖持久化）、`ShrinkDataSaverRuntime`（真实初始化与 autosave 驱动，2.2.0 新增）。
-- **模块化存档**：业务实现 `ISaveModule` / `ISaveModule<T>` 注册进保存流；关键模块失败终止保存，非关键失败跳过并记日志。
-- **存储抽象**：`IStorageProvider` → `LocalStorageProvider`（唯一实现）。2.1.0 起升级为异步文件流 + 主文件原子替换（`.tmp` 中转）+ `.bak1`/`.bak2` 双副本轮换备份，主文件损坏自动回退修复；`DeleteSlotAsync` 连带清理主/备/临时文件。
-- **安全**：AES-CBC + PBKDF2-SHA256（`SaveEncryptor`）。
-- **迁移**：`MigrationChain` 链式版本迁移（JObject 弱类型操作），支持缺步检测与回滚。
-- **易用性**：`GetRecentSlotIndex()` / `GetRecommendedContinueSlotAsync()` 把"继续游戏"能力下沉包内。
-- **事件桥**：`DataSaverEventBusBridge` 单向把原生事件映射为 9 个 `EventBase` 事件。
-- **测试**：仓库最扎实的测试面（保存/加载/迁移/加密/序列化/设置六类，`MockStorageProvider` 隔离文件系统）。
+`ShrinkCommandService` 解析字面量与贪婪参数路径，支持来源、权限和同步/Task/UniTask 返回。静态命令使用编译期注册表，实例命令显式注册。网络桥只在 Command 与 Network 两个服务键均可用时激活。
 
-### 6.3 ShrinkCommand 0.2.0
+### 7.4 Network
 
-- **定位**：独立于网络层的 Brigadier 风格命令系统，Unity 与纯 .NET 宿主（独立服务器）共用同一套。
-- **命令模型**：路径式定义（字面量段 + 贪婪参数段），`[ShrinkCommand("say <message...>")]`；方法参数支持 `ShrinkCommandContext` / `IShrinkCommandSource` / 路径参数按序绑定；返回值支持 void/string/Result 的同步与 Task/UniTask 变体。
-- **内建**：`help` / `?` 帮助树。
-- **注册**：静态命令走编译期注册表 `ShrinkCommandGeneratedRegistry`；实例命令 `RegisterCommands(object)` 反射方法签名（模组/运行时对象用）。
-- **集成**：`Integration.EventBus` 用 `ShrinkCommandExecuteRequestEvent` 请求执行并发布 executing/executed/failed 生命周期事件；`Integration.Network` 提供 `command/execute` RPC，远端会话可执行命令（独立服务器与控制台共用同一套命令注册）。
+`ShrinkNetworkService` 组合 serializer、message registry、router 与 transport。包头包含协议/Schema 版本、请求 token、会话 token、route、kind 和 payload。Unity 主线程派发通过有界 dispatch queue；独立服务器使用 inline scheduler。
 
-### 6.4 ShrinkNetwork 0.2.0
+网络合同必须同时满足：
 
-- **消息模型**：三类载荷——`IShrinkNetworkMessage`（单向）、`IShrinkNetworkRequest`（RPC 请求）、`ShrinkRpcResponseBase`（错误码+载荷）。所有消息显式 `[ShrinkNetworkMessage(opcode, route)]`，opcode/route 一一对应，冲突在生成阶段直接报错（不静默兜底）。
-- **包结构**（`ShrinkNetworkPacket`）：`ProtocolVersion` / `SchemaVersion`（版本闸门）/ `Opcode` / `RequestToken`（强类型 RPC 关联，替代裸 int）/ `SessionToken` + 过期时间 / `Route` / `Kind` / `Payload`。
-- **服务内核**（`ShrinkNetworkService`）：持有 `IShrinkNetworkSerializer + ShrinkNetworkMessageRegistry + ShrinkNetworkRouter` 三件套；`BindTransport` 绑定传输并自动接入可选桥接；协议版本窗口校验（越界可主动断链）；`IncomingPacketValidator` 钩子做逐包鉴权；`GetDiagnosticsSnapshot()` 暴露会话/收发/RPC/协议违规/权限拒绝/处理器异常/未知 opcode/分发 miss/序列化失败等全套计数。
-- **并发模型**：会话表与挂起 RPC 并发安全，断线自动失败挂起 RPC；派发可注入 `IShrinkNetworkDispatchScheduler`——独立服务器用 `Inline`，Unity 侧用 `ShrinkNetworkDispatchQueue`（有界队列 + 拒绝/丢弃溢出策略 + 主线程 `PumpAsync` 预算泵出），避免网络线程直入 Unity API。
-- **RPC**：`RpcAsync/CallAsync` + `ShrinkRpcCallOptions`（超时、路由重载、令牌覆盖、DebugLabel）。
-- **权限**：`[ShrinkNetworkSubscribe(Authority=..., Permission=...)]` 处理器级双重约束（来源 + 权限串）。
-- **序列化**：`ShrinkJsonNetworkSerializer`（调试）/ `ShrinkMessagePackNetworkSerializer`（正式，高频实时推荐 MessagePack+KCP）。
-- **传输**：`IShrinkNetworkTransport` 抽象 + Loopback（宿主本地闭环）/ TCP 客户端·服务端（可选 `ShrinkTcpTlsOptions` TLS，读包路径统一走 `Stream` 兼容 SslStream，最大包长保护）/ KCP 客户端·服务端（`ShrinkKcpPeer`、随机 conversationId、远端地址校验）。`IShrinkNetworkSessionControlTransport` 支持服务端主动踢会话。
-- **状态同步范式**：`[ShrinkNetworkStateSync("lan", role)]` 显式声明角色（JoinRequest/JoinResponse/Command/StateDelta/LeaveNotice/Heartbeat），供独立服务器生成器产出可运行同步模块；旧 route 回退识别仍保留。
-- **EventBus 桥**（Integration.EventBus）：`[ShrinkNetworkEvent]` 标注"可上网"的事件类型；扩展方法 `PublishEventAsync / BroadcastEventAsync / RequestEventAsync / UseEventBusBridge`，事件在远端重新分发回 EventBus；区分广播型/远端裁决型/增量型三类语义。
+- 类型实现 `IShrinkNetworkMessage`、`IShrinkNetworkRequest` 或继承 `ShrinkRpcResponseBase`。
+- 类型显式声明 `[ShrinkNetworkMessage(opcode, route)]`。
+- opcode 和 route 在导出集合内唯一。
+- 导出到无命名空间的服务器合同后，简单类型名仍唯一；不同命名空间的同名类型会明确报错，不再静默丢弃。
 
-### 6.5 ShrinkModFramework 0.1.0
+`[ShrinkNetworkStateSync]` 标记 JoinRequest、JoinResponse、Command、StateDelta、LeaveNotice 和 Heartbeat。`[ShrinkNetworkEvent]` 进一步区分广播、远端裁决和增量事件。
 
-- **模组声明**：`[ShrinkMod(modId, displayName, version, AutoApplyHarmonyPatches=...)]` + `[ShrinkModDependency(modId, minVersion)]`；实现 `IShrinkMod` 或继承 `ShrinkModBase`。
-- **生命周期四阶段**（按依赖拓扑序）：`OnConstruct → OnRegisterContent → OnInitialize → OnReady`。
-- **注册表**：`context.GetRegistry<T>("items")` 按类型+名称双重隔离，键唯一，每条记录归属模组（`ShrinkModRegistry/RegistryManager`）。
-- **装载**（`ShrinkModLoader`）：程序集内模组发现 + 依赖排序；外部 DLL 增量热加载（`persistentDataPath/Mods`，目录监听 + 延迟触发，同目录依赖解析；不支持卸载、不支持 IL2CPP 动态加载）。
-- **Harmony**：检测到 `0Harmony` 时按模组自动 `Harmony("shrink.mod.<id>").PatchAll(modAssembly)`；无 Harmony 静默跳过（可选桥接，不打进框架）。
-- **网络抽象**：`IShrinkModNetworkTransport + ShrinkModNetworkManager`，只定义频道/处理器/收发语义，可接 NGO/Mirror/FishNet/自有 Socket。
-- **自动集成**：`ShrinkModOptionalRuntimeIntegration` 在模组注册时反射探测并接入 EventBus/Command/Network（含刷新 Network-EventBus 桥）。
-- **自动启动**：`[RuntimeInitializeOnLoadMethod(AfterAssembliesLoaded)]` 读 `ShrinkModFrameworkSettings` 装载；`ShrinkModBootstrap`（场景物体）仅作手动覆盖。
-- **编辑器脚手架**（`Editor/Scaffolding/`）：外部 DLL 模组模板生成器、仓库内模组模板生成器（推荐路径，复用仓库 sln/asmdef 编译链）、Mod SDK 导出器（`ShrinkSDK/Mod/*` 菜单，产出 `GeneratedModSdk/`：Libs + ExternalMod 模板 + manifest）。
+### 7.5 ModFramework
 
-### 6.6 ShrinkTutorial 0.1.0
+`ShrinkModContextHost` 将模组生命周期纳入 Context apply。热替换单位是 `ModId + revision`；外部 DLL 用 SHA-256 标识 revision，失败或损坏 revision 不会成为 current，旧组合会恢复。Harmony、Registry 与 Network handler 使用可逆 lease 清理。
 
-- **数据驱动**：`ShrinkTutorialData / Step / Database`（ScriptableObject）+ `ShrinkTutorialSettings`；`ShrinkTutorialManager` 单例调度（排队、前置检查、逐步执行、完成/跳过持久化）。
-- **目标定位**：静态 `Hierarchy Path` 或运行时 `AnchorId`（`ShrinkTutorialAnchor` 组件 + `AnchorRegistry`）；步骤支持 `waitForTarget + waitTimeout` 等待动态目标出现。
-- **完成条件**：`ClickTarget`（EventSystem 射线真实命中才过步，防"遮罩挡住但教程已前进"）/ `AnyClick` / `CustomEvent`（业务调 `CompleteStep(eventName)`）/ `Auto`；`DragToTarget` 暂按自定义事件处理。
-- **UI**：独立 Overlay Canvas + 遮罩挖洞（目标区可继续点击）+ 提示框/箭头/跳过按钮（`ShrinkTutorialMask / Dialog`）。
-- **持久化**：`IShrinkTutorialStorage` → 默认 `PlayerPrefs` 实现。
-- **本地化**：仅接口 `IShrinkTutorialLocalizationProvider`，不内置表系统。
-- **入口**：`ShrinkSDK/引导/教程编辑器`、`ShrinkSDK/引导/重置教程进度`；示例场景 `ShrinkTutorialSample.unity` 可由 `ShrinkSDK/引导/创建示例场景` 一键重建（当前示例文案为英文，规避 TMP 默认字体缺中文字形）。
+Mono 中已加载程序集不能真正卸载。系统只回滚组件实例与效应，并通过 `ShrinkModDiagnostics` 暴露 current/history、累计载入字节和软阈值，达到阈值时建议 Domain Reload 或进程重启。
 
-### 6.7 ShrinkApp.Starter.Basic 0.1.0
+## 8. 编译期注册与服务器生成
 
-- **一键起盘**：菜单 `ShrinkApp/Starter/生成 Basic Entry 场景` 生成 `ShrinkAppEntry.unity` + `ShrinkAppSettings` / `ShrinkDataSaverSettings` / `ShrinkAppBasicStarterSettings` 三份配置。
-- **最小闭环调试台**：存档槽操作、命令输入与输出、Loopback 绑定/断开、模块/服务/存档/命令/网络五块只读状态面板，演示 `App + DataSaver + Command + Network` 全链路。
-- **Starter 配置**：自动绑 loopback、默认命令、输出行数上限等。
+### 8.1 Unity 运行时注册
 
-## 7. 独立服务器生成链
+`ShrinkShared.CodeGen/Editor/ShrinkRegistryILPostProcessor.cs` 为引用方程序集生成 EventBus、Command、Network 和 App 注册信息。运行时只消费程序集级注册表；外部 DLL 和运行时对象使用实例注册入口。核心程序集自身不被共享织入器回写，避免程序集自引用。
 
-**目标**：Unity 项目里的消息合同与处理器范式，能直接生成一个可编译、可运行、可继续补业务的 .NET 独立服务器工程（控制台 + 专用服，类似 Minecraft server 的形态）。
+### 8.2 独立服务器生成
 
-**生成器**：`ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs`，菜单 `ShrinkSDK/Network/生成完整独立服务器工程` / `刷新独立服务器 Generated 合同`，输出到 `GeneratedServers/ShrinkNetwork.ServerHost/`。
+菜单入口：
 
-**生成策略**（依赖特性范式而非演示代码命名）：
+- `ShrinkSDK/Network/生成完整独立服务器工程`
+- `ShrinkSDK/Network/刷新独立服务器 Generated 合同`
 
-- 模板部分（`.cs.txt` 源）：`Program.cs`、`Framework/`（`ShrinkDedicatedServerApp`、`ServerHostOptions/Properties`、`ServerAuthStore`、`UnityNetworkCodeScanner`、`IShrinkServerModule` 模块体系）、`AuthServerModule`、TCP/KCP 服务端传输、`server.properties`。
-- 扫描生成部分（`Generated/*.g.cs`）：网络合同 DTO、按 `[ShrinkNetworkStateSync]` 角色推断同步模块、按 `[ShrinkNetworkEvent]` 三分类（广播/裁决/增量）自动生成 handler 模板并注册、`[ShrinkNetworkSubscribe]` 权限声明映射、扫描清单（`UNITY_NETWORK_SCAN.md` / `unity-network-scan.json`）。
+完整生成分两步：
 
-**宿主运行形态**：
+1. 复制 `ServerProjectTemplate` 到 `GeneratedServers/ShrinkNetwork.ServerHost`。模板清单记录每个托管文件的 SHA-256；复制前完成全量冲突检查，检测到人工修改时零写入退出。
+2. 从 Unity `CompilationPipeline` 的 Player 程序集取得已加载类型，通过 `CustomAttributeData`、接口、基类、属性和泛型元数据生成合同、handler、模块与扫描报告。
 
-- 模块自发现：反射本程序集全部 `IShrinkServerModule` 实例化（含生成的 `UnityGeneratedServerModule` 与手写的 `AuthServerModule`）。
-- 双监听：TCP 与 KCP 同端口（默认 17777；历史演示 17001/17002）。
-- 配置体系：`ServerHostProperties.LoadOrCreate()`，优先级 **代码默认值 < server.properties < 环境变量**；支持 `SHRINK_SERVER_CONFIG_PATH` 自定义路径、`SHRINK_SERVER_AUTH_TOKEN` 等环境变量；首启缺文件自动落默认配置。
-- 鉴权与安全基线：默认**拒绝匿名登录**（`AllowAnonymousWhenAuthTokenMissing` 显式开启才放行）；共享口令登录后签发内存态会话令牌（TTL + 续期窗口 + 逐包校验 + 坏令牌踢线，`server/auth/login` / `server/auth/refresh`）；协议/Schema 版本窗口越界可断链；TCP 可选 TLS（服务端证书 + 客户端校验）；TCP/KCP 均有最大包长与远端地址校验。
-- 可观测：`GetDiagnosticsSnapshot()` 全套指标按 `DiagnosticsLogIntervalSeconds` 周期打印，Ctrl+C 前输出最终快照。
+语义扫描天然合并 partial 类型，并只导出公开实例 `get/set` 属性。复杂泛型递归格式化；命名空间不同但简单名相同的消息或依赖类型会中止生成并列出所有来源。`Generated/*.g.cs` 仍是生成器所有的可替换区域。
 
-**验证工具**（烟测闭环）：`GeneratedServers/ShrinkCommand.RuntimeSmoke`、`ShrinkCommand.EventBusSmoke`、`ShrinkNetwork.RuntimeSmoke` 三个控制台工程，覆盖"登录拿令牌 → 业务 RPC → 令牌续期 → 篡改令牌被踢"与远程 `status` 命令链路。
+服务器宿主是 .NET 8 控制台工程，包含 TCP/KCP 服务端、协议窗口、会话令牌、登录/刷新、诊断摘要和 `server.properties`。模板提供运行骨架，业务裁决仍需在非生成代码中实现。
 
-## 8. 场景资产
+## 9. 验证门槛
 
-| 场景 | 用途 |
-|---|---|
-| `SampleScene.unity` | 基础示例 |
-| `ShrinkAppEntry.unity` | Starter 一键生成的入口调试台 |
-| `ShrinkEmbeddedHostNetworkDemo.unity` | 宿主内嵌网络演示（控制器自动 RegisterService，无需手工注册） |
-| `ShrinkLanMovementDemo.unity` | LAN 平台跳跃移动同步演示（状态增量范式样板） |
-| `ShrinkTutorialSample.unity` | 引导系统示例（三类完成路径），可一键重建 |
+一次涉及包边界、生成器或组合根的变更至少经过：
 
-## 9. 安全与健壮性设计（商业级硬化两轮成果）
+1. 内部版本一致性检查：全部 `com.cneicy.*` 依赖等于仓库包版本。
+2. Unity 编译：目标 asmdef 和根项目无编译错误。
+3. EditMode 测试：功能测试、Context 生命周期、语义扫描和模板覆写保护。
+4. 真实 UPM 消费：`Tools/UpmConsumerValidation/Validate-UpmConsumer.ps1` 创建仓库外形态的临时 Unity 工程，通过 `file:` 安装全部 19 个包，启用 testables，验证包注册、程序集加载并运行 EditMode 测试。
+5. 独立宿主：生成工程与 RuntimeSmoke 按变更范围构建或运行。
+6. 涉及真实生命周期时，仍需在目标场景执行 Play Mode 验收；源码检查和 EditMode 不能替代该路径。
 
-1. **传输防线**：TCP/KCP 最大包长保护（防伪造长度触发大分配）、KCP 远端地址校验 + 随机 conversationId、TCP 并发写串行化（防包流交叉，见 NETWORK_PITFALLS #4）。
-2. **协议闸门**：包级 Protocol/Schema 版本 + 服务端窗口校验，违规可主动断链。
-3. **身份与会话**：默认拒绝匿名；共享口令 → 内存态会话令牌（TTL/续期/逐包校验/踢线）。
-4. **加密信道**：TCP 可选 TLS（证书 + SNI + 吊销检查；当前不含双向认证）。
-5. **并发安全**：服务/会话并发集合、断线自动失败挂起 RPC、EventBus 派发竞态修复、Unity 侧有界派发队列 + 溢出策略。
-6. **可观测**：全套指标快照 + 宿主周期摘要（尚无 metrics 导出/trace/告警）。
-7. **生成期报错**：opcode/route 冲突、installer 循环依赖、重复 ModuleId 均在编译/生成阶段失败，不静默兜底。
+## 10. 已知边界
 
-## 10. 测试与验证现状
+- ClassicHost、旧 installer 和静态门面仍是兼容层，暂未删除。
+- Context 的 intercept 不是进程级沙箱；外部程序集 revision 不可从 Mono 卸载。
+- 某些第三方或领域副作用只能补偿，不能保证物理撤回。
+- 服务器生成器输出可编译、可注册的合同和扩展点，不推断完整业务规则。
+- `GeneratedServers/` 中的认证与协议窗口是基础设施，不等于完整账号体系、密钥轮换、审计、trace、dashboard 或故障演练。
+- Profile 的 isolate 变化通过重建条目生效；运行中 fiber 原地迁移 realm 不在当前范围。
 
-- **包内测试**：`ShrinkDataSaver/Tests`（六类，最扎实）；`ShrinkEventBus/Tests`（派发/优先级/注册/订阅四类，1.3.0 后补齐）。
-- **烟测工程**：三个 RuntimeSmoke/EventBusSmoke 控制台工程，覆盖鉴权-续期-踢线与远程命令全链路。
-- **构建验证**：`dotnet build ShrinkSDK.sln`、Assembly-CSharp(-Editor)、ServerHost.csproj 均 0 warning / 0 error（线程 2026-04-07 记录用户实测 Command/Network/独立服务器链路通过）。
-- **缺口**：Network/Command/ModFramework/Tutorial 无包内测试目录；无 CI 配置；Unity 编辑器内"重新生成完整独立服务器工程"的运行时回归未做（线程 Next Steps 首条）。
+## 11. 文档治理
 
-## 11. 已知设计限制与风险
-
-来自 `.planning/codebase/CONCERNS.md`（编码问题部分已修复，如 DataSaver 中文乱码已按 UTF-8 重写）与线程 Notes/Next Steps 的仍有效项：
-
-1. **网络栈生产缺口**：无 TLS 双向认证、无正式身份体系（当前是共享口令+内存令牌，无令牌轮换/外部 IdP）、协议版本是"窗口校验+断开"而非协商式、无 metrics 导出/trace/dashboard/告警、未做压测与模糊包故障演练。
-2. **EventBus 桥回传受限**：`ShrinkNetwork.Integration.EventBus` 的 `HasResult` 事件只回传 `EventResult/IsCanceled/ErrorCode/ErrorMessage`，不自动回传事件对象其它字段的最终改动。
-3. **外部 DLL 模组边界**：不支持运行时卸载程序集；IL2CPP Player 下外部 DLL 动态加载不可用。
-4. **生成器边界**：独立服务器生成以"可编译、可注册、可继续补业务"为目标，不推断完整业务逻辑；`GeneratedServers/` 产物可重建，人工业务不得写进生成文件（覆写保护行为待确认，线程 Next Steps 有记录）。
-5. **教程系统**：DragToTarget 未内建命中判定；圆形高亮视觉按外接矩形挖洞；示例文案为英文（等可用中文 TMP 字体资产后回改）。
-6. **仓库工程面**：无 CI/发布流水线；`.planning/codebase/` 地图滞后于当前模块规模（本文档即为补齐）；部分公开 API 仍有 nullable 语义不一致残留（`route = null` 类签名收口未完成）。
-7. **历史已过期项**：`D:\UnityBuilds\ShrinkSDK` 曾不是 Git 仓库（现为 Git 仓库，当前处于初始提交暂存阶段）；ServerHost nullable warnings 已清零（旧记录过期）。
-
-## 12. 关键文件索引（推荐阅读顺序）
-
-1. 统一宿主：`Assets/Modules/ShrinkApp.Core/Runtime/ShrinkApp.cs` → `ShrinkAppHost.cs` → `ShrinkAppTypes.cs`
-2. 编译期机制：`Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkRegistryILPostProcessor.cs`
-3. 事件系统：`Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs` → `IShrinkEventBus.cs` → `ShrinkEventBusInstance.cs`
-4. 存档系统：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs` → `ShrinkDataSaverRuntime.cs` → `LocalStorageProvider.cs`
-5. 命令系统：`Assets/Modules/ShrinkCommand/Runtime/Core/ShrinkCommandService.cs` → `Metadata/ShrinkCommandAttributes.cs`
-6. 网络框架：`Assets/Modules/ShrinkNetwork/Runtime/Core/ShrinkNetworkService.cs` → `Metadata/ShrinkNetworkPacket.cs` → `Transport/Abstractions/IShrinkNetworkTransport.cs`
-7. 模组框架：`Assets/Modules/ShrinkModFramework/Runtime/Bootstrap/ShrinkModRuntimeBootstrap.cs` → `Loading/ShrinkModLoader.cs` → `Core/IShrinkMod.cs`
-8. 引导系统：`Assets/Modules/ShrinkTutorial/Runtime/Core/ShrinkTutorialManager.cs`
-9. 独立服务器：`GeneratedServers/ShrinkNetwork.ServerHost/Program.cs` → `Framework/ShrinkDedicatedServerApp.cs`
-10. 经验教训：`NETWORK_PITFALLS.md`（19 条联网/桥接/编译链踩坑，含 Kcp DLL 兼容、TCP 并发写、生成器范式化等）
+- 当前架构只更新本文。
+- 包级使用方式和 API 示例放在各包 README。
+- `NETWORK_PITFALLS.md` 记录实现经验，不描述当前模块清单。
+- `Docs/Archive/CORDIS_MIGRATION.completed.md` 保存迁移论证、阶段记录和历史验收数据。
+- `Docs/Archive/codebase-map-2026-05-23/` 保存迁移前代码地图，其中关于 Git 状态、模块规模和测试覆盖的描述均已过期。
+- `.planning/threads/` 只用于恢复工作上下文；其中历史 Notes 不得覆盖本文和当前源码。
diff --git a/CORDIS_MIGRATION.md b/Docs/Archive/CORDIS_MIGRATION.completed.md
similarity index 99%
rename from CORDIS_MIGRATION.md
rename to Docs/Archive/CORDIS_MIGRATION.completed.md
index 1143042..73b6b41 100644
--- a/CORDIS_MIGRATION.md
+++ b/Docs/Archive/CORDIS_MIGRATION.completed.md
@@ -1,4 +1,6 @@
-# ShrinkSDK × Cordis 组织形式改造方案
+# ShrinkSDK × Cordis 组织形式改造方案（已归档）
+
+> 归档说明：阶段 0 至 5 已完成并合入当前架构。本文只保存迁移论证、过程决策和历史验收数据；当前状态以仓库根 `DESIGN.md` 为准。
 
 > 生成日期：2026-08-16；独立重读与阶段 5 路线更新：2026-08-17
 > 参考文献：《Cordis: A Programming Paradigm for Spatiotemporal Composability》（北京大学 / DeepSeek-AI，88 页，`C:\Users\im\Downloads\Cordis_paper_zh-CN.pdf`）
diff --git a/Docs/Archive/DESIGN-2026-08-16.md b/Docs/Archive/DESIGN-2026-08-16.md
new file mode 100644
index 0000000..408b9a2
--- /dev/null
+++ b/Docs/Archive/DESIGN-2026-08-16.md
@@ -0,0 +1,308 @@
+# ShrinkSDK 项目设计总结（2026-08-16 归档）
+
+> 归档说明：本文已被仓库根 `DESIGN.md` 取代，仅供历史追溯，其中模块状态、Git 状态、测试数量和待办均可能过期。
+
+> 生成日期：2026-08-16
+> 依据：仓库源码（`Assets/Modules/`、`GeneratedServers/`）、各模块 `package.json` / `README.md` / `CHANGELOG.md`、`.planning/threads/shrinksdkunity.md`、`NETWORK_PITFALLS.md`，以及 `.planning/codebase/` 既有代码库地图（其中部分内容已滞后于当前代码，本文以源码现状为准）。
+
+---
+
+## 1. 项目定位
+
+ShrinkSDK 是一个**以 Unity 包（UPM）为边界的 SDK 单仓库**，不是单个游戏项目。它为 Unity 游戏提供一整套可独立分发、可拼装组合的基础设施：
+
+- 事件总线（ShrinkEventBus）
+- 存档与设置（ShrinkDataSaver）
+- 命令系统（ShrinkCommand）
+- 网络框架与独立服务器生成（ShrinkNetwork + GeneratedServers）
+- 模组框架（ShrinkModFramework，Forge 风格）
+- 新手引导（ShrinkTutorial）
+- 统一应用宿主与起盘 Starter（ShrinkApp.Core + ShrinkApp.Starter.Basic，最新一轮工作）
+
+设计哲学贯穿全仓库：**静态门面 + Attribute 声明式范式 + 编译期注册表 + asmdef 最小抽象 + 可选桥接包**。不做重框架化（无 DI 容器、无第三方状态机），追求低侵入接入 Unity 项目。
+
+## 2. 技术栈
+
+| 项 | 值 |
+|---|---|
+| Unity 版本 | 2022.3（`ProjectSettings/ProjectVersion.txt`） |
+| 语言 | C#（运行时与独立 .NET 宿主共用合同） |
+| 异步 | UniTask 2.x（`com.cysharp.unitask`） |
+| 序列化 | Newtonsoft.Json（`com.unity.nuget.newtonsoft-json` 3.2.2）；网络层另支持 MessagePack-CSharp 3.1.4 |
+| 编译织入 | Unity ILPostProcessing + Mono.Cecil |
+| UI | uGUI + TextMeshPro |
+| 渲染 | URP 14 |
+| 网络 | 自研传输层：Loopback / TCP（含可选 TLS）/ KCP（Kcp-CSharp.dll） |
+| 独立服务器 | .NET 8 控制台宿主（`GeneratedServers/ShrinkNetwork.ServerHost`） |
+| 测试 | Unity Test Runner（NUnit，EditMode 为主） |
+
+## 3. 仓库布局
+
+```text
+ShrinkSDK/
+├── Assets/Modules/            # 全部 SDK 模块（每个是独立 UPM 包 + asmdef）
+│   ├── ShrinkEventBus/        # 事件总线（Runtime/Editor/CodeGen/Tests）
+│   ├── ShrinkDataSaver/       # 存档与设置（Runtime/Editor/Tests）
+│   ├── ShrinkCommand/         # 命令系统
+│   ├── ShrinkNetwork/         # 网络框架（Core/Metadata/Routing/Serialization/Transport/Editor 脚手架）
+│   ├── ShrinkModFramework/    # 模组框架（Bootstrap/Core/Metadata/Registry/Loading/Network/Integration）
+│   ├── ShrinkTutorial/        # 新手引导（Core/Storage/Trigger/UI）
+│   ├── ShrinkApp.Core/        # 统一应用宿主层
+│   ├── ShrinkApp.Starter.Basic/ # 最小起盘 Starter
+│   ├── ShrinkShared.CodeGen/  # 共享 IL 织入管线
+│   └── *.Integration.EventBus / *.Integration.App  # 模块间桥接包
+├── Assets/Scenes/             # 示例/演示场景
+├── GeneratedServers/          # 生成的独立 .NET 服务器工程（可重建，不手写业务）
+├── GeneratedModSdk/           # 导出的 Mod SDK 开发包（Libs/Templates/manifest）
+├── Servers/                   # （当前为空）
+├── Packages/manifest.json     # UPM 依赖
+├── ShrinkSDK.sln              # 解决方案（含全部模块 csproj）
+├── NETWORK_PITFALLS.md        # 联网与事件桥接踩坑记录（19 条经验）
+└── .planning/                 # gsd 线程与代码库地图（部分滞后）
+```
+
+## 4. 模块清单与依赖关系
+
+| 包名 | 版本 | 职责 | 关键依赖 |
+|---|---|---|---|
+| `com.cneicy.shrink-eventbus` | 1.3.0 | 高性能类型安全事件总线，优先级调度与自动注册 | UniTask |
+| `com.cneicy.shrink-datasaver` | 2.2.0 | 模块化存档与设置：多槽位、链式迁移、AES 加密、双备份 | Newtonsoft, UniTask |
+| `com.cneicy.shrink-datasaver-integration-eventbus` | 2.1.0 | DataSaver 原生事件 → EventBus 桥接（9 个事件类型） | DataSaver, EventBus |
+| `com.cneicy.shrink-datasaver-integration-app` | 0.1.0 | DataSaver 初始化交给 ShrinkApp 宿主接管 | DataSaver, App.Core |
+| `com.cneicy.shrink-command` | 0.2.0 | 路径式命令系统（Minecraft/Brigadier 风格）、权限、来源判定 | UniTask |
+| `com.cneicy.shrink-command-integration-eventbus` | 0.1.1 | 事件请求执行命令 + 命令生命周期事件发布 | Command, EventBus |
+| `com.cneicy.shrink-command-integration-network` | 0.1.0 | `command/execute` RPC 远程执行命令 | Command, Network |
+| `com.cneicy.shrink-command-integration-app` | 0.1.0 | 默认命令服务纳入宿主容器 | Command, App.Core |
+| `com.cneicy.shrink-network` | 0.2.0 | 会话、消息注册、RPC、权限、TCP/KCP/Loopback 传输 | UniTask, Newtonsoft |
+| `com.cneicy.shrink-network-integration-eventbus` | 0.1.1 | EventBase 事件直接走网络同步并在远端重分发 | Network, EventBus |
+| `com.cneicy.shrink-network-integration-app` | 0.1.0 | 默认网络服务纳入宿主容器 | Network, App.Core |
+| `com.cneicy.shrink-mod-framework` | 0.1.0 | 模组发现、依赖解析、生命周期、注册表、外部 DLL 热载、Harmony | Newtonsoft |
+| `com.cneicy.shrink-tutorial` | 0.1.0 | 数据驱动互动引导：遮罩挖洞、动态锚点、条件完成 | uGUI, TMP |
+| `com.cneicy.shrink-app-core` | 0.1.0 | 统一宿主：模块安装器、服务容器、统一启动流程 | EventBus, UniTask |
+| `com.cneicy.shrink-app-starter-basic` | 0.1.0 | 最小起盘：入口场景生成 + 五模块最小闭环调试台 | App.Core, Command, DataSaver, Network 及各自 Integration.App |
+| `ShrinkShared.CodeGen`（asmdef） | — | 共享 IL 后处理器：四套编译期注册表 + EventBus 织入 | Cecil |
+
+依赖层次（自底向上）：
+
+```text
+ShrinkShared.CodeGen（编译期，作用于 Command/Network/App 引用方程序集）
+        │
+ShrinkEventBus ←── ShrinkDataSaver ←── DataSaver.Integration.EventBus
+        ↑                                        （独立桥接，不依赖 App）
+ShrinkNetwork  ←── ShrinkCommand（经 Integration.Network 桥）
+        ↑
+ShrinkModFramework（Integration/ 胶水可选自动接入以上三者）
+        ↑
+ShrinkApp.Core（组合根）←── *.Integration.App（各模块安装器）
+        ↑
+ShrinkApp.Starter.Basic（起盘模板）
+```
+
+## 5. 总体架构
+
+### 5.1 分层视图
+
+```text
+┌──────────────────────────────────────────────────────────┐
+│  Starter 层：ShrinkApp.Starter.Basic（场景/配置/UI 生成） │
+├──────────────────────────────────────────────────────────┤
+│  组合根：ShrinkApp.Core（Host/Services/Installer 排序）  │
+├───────────────┬───────────────┬──────────────────────────┤
+│ 功能模块：    │  EventBus     │  DataSaver   │ Tutorial  │
+│               │  Command      │  Network     │           │
+├───────────────┴───────────────┴──────────────────────────┤
+│ 桥接层：*.Integration.EventBus / *.Integration.Network   │
+│         *.Integration.App（可选包，反射自动发现）        │
+├──────────────────────────────────────────────────────────┤
+│ 扩展面：ShrinkModFramework（模组热载 + Harmony + 上述全） │
+├──────────────────────────────────────────────────────────┤
+│ 编译期：ShrinkShared.CodeGen（Cecil IL 织入/注册表注入） │
+├──────────────────────────────────────────────────────────┤
+│ 独立宿主：GeneratedServers/ShrinkNetwork.ServerHost(.NET)│
+└──────────────────────────────────────────────────────────┘
+```
+
+### 5.2 四个横切设计模式（全仓库统一）
+
+**模式一：Attribute 声明式范式。** 每个子系统用自己的特性声明能力，处理器/消息/命令/安装器都是 `[Xxx] + 类型` 的组合：`[EventBusSubscriber]+[EventSubscribe]`、`[ShrinkNetworkMessage(opcode, route)]`、`[ShrinkNetworkSubscriber]+[ShrinkNetworkSubscribe]`、`[ShrinkCommand("say <message...>")]`、`[ShrinkMod(modId,...)]`、`[ShrinkAppModuleInstaller]`。
+
+**模式二：编译期注册表取代全域反射。** `ShrinkShared.CodeGen/Editor/ShrinkRegistryILPostProcessor.cs` 是唯一的共享 IL 后处理器，对引用了 `ShrinkCommand.Runtime` / `ShrinkNetwork.Runtime` / `ShrinkApp.Core.Runtime` 的程序集做四件事：
+
+1. `InjectEventBusAutoRegister`：给带 `[EventBusSubscriber]` 的 MonoBehaviour 织入 `Awake → EventBus.AutoRegister(this)` 与 `OnDestroy → UnregisterInstance`（处理了继承基类 Awake/OnDestroy 的 base 调用）。
+2. `InjectShrinkCommandRegistry`：静态命令类型写入程序集级 `[ShrinkCommandStaticRegistry(typeof(...))]`。
+3. `InjectShrinkNetworkRegistry`：`[ShrinkNetworkMessage]` 消息类型与静态订阅者类型分别写入 `[ShrinkNetworkMessageRegistry]` / `[ShrinkNetworkStaticSubscriberRegistry]`。
+4. `InjectShrinkAppRegistry`：`[ShrinkAppModuleInstaller]` 安装器类型写入 `[ShrinkAppInstallerRegistry]`。
+
+运行时 `AutoRegisterAll()` 只读程序集特性，不做 `AppDomain.GetAssemblies()+GetTypes()` 全域扫描——这是模组外部 DLL 与独立服务器共用的关键机制（外来 DLL 不经过 Unity 编译管线，仍可走实例注册路径 `RegisterHandlers(object)` / `RegisterCommands(object)` 兜底）。注意织入器刻意**不处理核心程序集自身**（否则 Cecil 写回会触发 Unity "references itself" 拒载，源码注释中已记录该教训）。
+
+**模式三：静态门面 + 可实例化内核。** `EventBus`（静态门面）委托给 Builder 构建的 `IShrinkEventBus` 实例（默认 LogAndContinue + 按 phase 派发，可 CreateBus 多实例）；`ShrinkNetworkRuntime.Default` / `ShrinkCommandService` 同理。使用方零成本拿到默认单例，高级场景可自建实例。
+
+**模式四：可选桥接包 + 运行时反射自动发现。** 模块间集成全部做成独立小包（不污染主包依赖），并用反射探测"对方是否存在"：`ShrinkNetworkService.BindTransport(...)` 自动接入 EventBus 桥（`BindTransport(null)` 解绑）；`ShrinkModFramework/Runtime/Integration/ShrinkModOptionalRuntimeIntegration.cs` 在模组注册时自动尝试把模组实例接到 EventBus/Command/Network。未安装桥接包时静默跳过。
+
+### 5.3 ShrinkApp 统一宿主（组合根）
+
+最新引入的 `ShrinkApp.Core` 把"谁先启动、服务放哪"收口为一条统一链路：
+
+1. `Shrink.Bootstrap`：`[RuntimeInitializeOnLoadMethod(BeforeSceneLoad)]` 创建 `ShrinkAppHost` GameObject（可 DontDestroyOnLoad），组装 `ShrinkAppContext = Host + Settings + Services`。
+2. **安装器发现**：`ShrinkAppGeneratedRegistry` 扫描程序集级 `[ShrinkAppInstallerRegistry]`（由共享织入器生成），实例化所有 `IShrinkAppModuleInstaller`。
+3. **拓扑排序**：按 `Order` + `DependsOn`（显式成环/缺依赖/重复 ModuleId 直接抛错），`ShrinkAppSettings.disabledModuleIds` 可整模块禁用。
+4. **两阶段启动**：先统一 `RegisterServices(context)`（向 `ShrinkAppServices` 类型字典容器注册服务），再按序 `InitializeAsync`。
+5. **事件广播**：成功发 `ShrinkAppStartedEvent`（含模块清单，等待 Unity `Start` 后才发布），失败发 `ShrinkAppStartFailedEvent`。
+
+各功能模块通过 `*.Integration.App` 包提供安装器（如 `ShrinkNetworkAppInstaller`，ModuleId `shrink.network`，Order -1400），把各自的默认服务注册进容器。`ShrinkDataSaver` 2.2.0 专门新增 `ShrinkDataSaverRuntime` 把初始化入口从 MonoBehaviour Bootstrap 下沉，为的就是让宿主接管初始化顺序（旧 `ShrinkDataSaverBootstrap` 保留为兼容入口）。
+
+### 5.4 生命周期入口一览
+
+| 入口 | 时机 | 作用 |
+|---|---|---|
+| `ShrinkApp.Bootstrap` | BeforeSceneLoad | 创建宿主并按拓扑序启动全部安装器 |
+| `ShrinkModRuntimeBootstrap` | AfterAssembliesLoaded | 读设置、装载模组（场景内/外部 DLL）、接 Harmony |
+| `DataSaverEventBusBridge` | AfterAssembliesLoaded | DataSaver 原生事件桥到 EventBus |
+| `ShrinkTutorialRuntimeBootstrap` | 运行时初始化 | 引导系统自举 |
+| `ShrinkDataSaverBootstrap`（MonoBehaviour，兼容） | 场景 | 委托 `ShrinkDataSaverRuntime`；自动保存轮询、暂停/退出落盘 |
+| EventBus IL 织入 | 编译期 | MonoBehaviour 自动注册/反注册 |
+
+## 6. 各模块设计要点
+
+### 6.1 ShrinkEventBus 1.3.0
+
+- **双层结构**：静态门面 `EventBus` + `IShrinkEventBus` 实例（`ShrinkEventBusBuilder` 配置异常策略、类型校验、marker 接口、phase 派发）。
+- **订阅模型**：`Action<T>` 同步与 `Func<T, UniTask>` 异步两种 handler；优先级支持枚举 `EventPriority` 与数字（数字 0 = NORMAL）；`receiveCanceled` 控制取消后是否继续收；`IShrinkEventSubscription` 句柄式订阅 + 实例对象整体注册两套 API。
+- **派发机制**：监听列表按 phase 分桶 + 快照缓存（`ListenerList`），支持父事件监听子事件，跨父子按数字优先级稳定归并；事件对象持有派发时快照而非内置列表。1.3.0 对热路径做了系统性并发加固（总线内单锁、`EventId` 懒生成、`ConcurrentDictionary` 元数据缓存、`EventPool` 容量上限 128 防双重归还）。
+- **声明能力**：`[Cancelable]` / `[HasResult]` 标注事件语义；`EventResult` 承载结果。
+- **自动注册**：编译期织入（见 5.2）+ 静态注册表；1.3.0 修复"无实例订阅方法的类型被织入后在 Awake 抛异常"的问题，现改警告跳过。
+- **兜底管线**：共享织入器覆盖不到、只引用 `ShrinkEventBus.Runtime` 的程序集由模块内 `CodeGen/Editor/EventBusILPostProcessor.cs` 本地兜底。
+- **工具**：`EventBusViewerWindow` 编辑器查看器（走公开快照接口，不反射私有字段）、`EventBusBenchmark`、Tests 目录覆盖派发/优先级/注册/订阅四类行为。
+
+### 6.2 ShrinkDataSaver 2.2.0
+
+- **核心对象**：`ShrinkSave`（存档门面：槽位保存/加载/删除、截图存档、跨模块查询缓存）、`ShrinkSettings`（设置门面：读写、监听、防抖持久化）、`ShrinkDataSaverRuntime`（真实初始化与 autosave 驱动，2.2.0 新增）。
+- **模块化存档**：业务实现 `ISaveModule` / `ISaveModule<T>` 注册进保存流；关键模块失败终止保存，非关键失败跳过并记日志。
+- **存储抽象**：`IStorageProvider` → `LocalStorageProvider`（唯一实现）。2.1.0 起升级为异步文件流 + 主文件原子替换（`.tmp` 中转）+ `.bak1`/`.bak2` 双副本轮换备份，主文件损坏自动回退修复；`DeleteSlotAsync` 连带清理主/备/临时文件。
+- **安全**：AES-CBC + PBKDF2-SHA256（`SaveEncryptor`）。
+- **迁移**：`MigrationChain` 链式版本迁移（JObject 弱类型操作），支持缺步检测与回滚。
+- **易用性**：`GetRecentSlotIndex()` / `GetRecommendedContinueSlotAsync()` 把"继续游戏"能力下沉包内。
+- **事件桥**：`DataSaverEventBusBridge` 单向把原生事件映射为 9 个 `EventBase` 事件。
+- **测试**：仓库最扎实的测试面（保存/加载/迁移/加密/序列化/设置六类，`MockStorageProvider` 隔离文件系统）。
+
+### 6.3 ShrinkCommand 0.2.0
+
+- **定位**：独立于网络层的 Brigadier 风格命令系统，Unity 与纯 .NET 宿主（独立服务器）共用同一套。
+- **命令模型**：路径式定义（字面量段 + 贪婪参数段），`[ShrinkCommand("say <message...>")]`；方法参数支持 `ShrinkCommandContext` / `IShrinkCommandSource` / 路径参数按序绑定；返回值支持 void/string/Result 的同步与 Task/UniTask 变体。
+- **内建**：`help` / `?` 帮助树。
+- **注册**：静态命令走编译期注册表 `ShrinkCommandGeneratedRegistry`；实例命令 `RegisterCommands(object)` 反射方法签名（模组/运行时对象用）。
+- **集成**：`Integration.EventBus` 用 `ShrinkCommandExecuteRequestEvent` 请求执行并发布 executing/executed/failed 生命周期事件；`Integration.Network` 提供 `command/execute` RPC，远端会话可执行命令（独立服务器与控制台共用同一套命令注册）。
+
+### 6.4 ShrinkNetwork 0.2.0
+
+- **消息模型**：三类载荷——`IShrinkNetworkMessage`（单向）、`IShrinkNetworkRequest`（RPC 请求）、`ShrinkRpcResponseBase`（错误码+载荷）。所有消息显式 `[ShrinkNetworkMessage(opcode, route)]`，opcode/route 一一对应，冲突在生成阶段直接报错（不静默兜底）。
+- **包结构**（`ShrinkNetworkPacket`）：`ProtocolVersion` / `SchemaVersion`（版本闸门）/ `Opcode` / `RequestToken`（强类型 RPC 关联，替代裸 int）/ `SessionToken` + 过期时间 / `Route` / `Kind` / `Payload`。
+- **服务内核**（`ShrinkNetworkService`）：持有 `IShrinkNetworkSerializer + ShrinkNetworkMessageRegistry + ShrinkNetworkRouter` 三件套；`BindTransport` 绑定传输并自动接入可选桥接；协议版本窗口校验（越界可主动断链）；`IncomingPacketValidator` 钩子做逐包鉴权；`GetDiagnosticsSnapshot()` 暴露会话/收发/RPC/协议违规/权限拒绝/处理器异常/未知 opcode/分发 miss/序列化失败等全套计数。
+- **并发模型**：会话表与挂起 RPC 并发安全，断线自动失败挂起 RPC；派发可注入 `IShrinkNetworkDispatchScheduler`——独立服务器用 `Inline`，Unity 侧用 `ShrinkNetworkDispatchQueue`（有界队列 + 拒绝/丢弃溢出策略 + 主线程 `PumpAsync` 预算泵出），避免网络线程直入 Unity API。
+- **RPC**：`RpcAsync/CallAsync` + `ShrinkRpcCallOptions`（超时、路由重载、令牌覆盖、DebugLabel）。
+- **权限**：`[ShrinkNetworkSubscribe(Authority=..., Permission=...)]` 处理器级双重约束（来源 + 权限串）。
+- **序列化**：`ShrinkJsonNetworkSerializer`（调试）/ `ShrinkMessagePackNetworkSerializer`（正式，高频实时推荐 MessagePack+KCP）。
+- **传输**：`IShrinkNetworkTransport` 抽象 + Loopback（宿主本地闭环）/ TCP 客户端·服务端（可选 `ShrinkTcpTlsOptions` TLS，读包路径统一走 `Stream` 兼容 SslStream，最大包长保护）/ KCP 客户端·服务端（`ShrinkKcpPeer`、随机 conversationId、远端地址校验）。`IShrinkNetworkSessionControlTransport` 支持服务端主动踢会话。
+- **状态同步范式**：`[ShrinkNetworkStateSync("lan", role)]` 显式声明角色（JoinRequest/JoinResponse/Command/StateDelta/LeaveNotice/Heartbeat），供独立服务器生成器产出可运行同步模块；旧 route 回退识别仍保留。
+- **EventBus 桥**（Integration.EventBus）：`[ShrinkNetworkEvent]` 标注"可上网"的事件类型；扩展方法 `PublishEventAsync / BroadcastEventAsync / RequestEventAsync / UseEventBusBridge`，事件在远端重新分发回 EventBus；区分广播型/远端裁决型/增量型三类语义。
+
+### 6.5 ShrinkModFramework 0.1.0
+
+- **模组声明**：`[ShrinkMod(modId, displayName, version, AutoApplyHarmonyPatches=...)]` + `[ShrinkModDependency(modId, minVersion)]`；实现 `IShrinkMod` 或继承 `ShrinkModBase`。
+- **生命周期四阶段**（按依赖拓扑序）：`OnConstruct → OnRegisterContent → OnInitialize → OnReady`。
+- **注册表**：`context.GetRegistry<T>("items")` 按类型+名称双重隔离，键唯一，每条记录归属模组（`ShrinkModRegistry/RegistryManager`）。
+- **装载**（`ShrinkModLoader`）：程序集内模组发现 + 依赖排序；外部 DLL 增量热加载（`persistentDataPath/Mods`，目录监听 + 延迟触发，同目录依赖解析；不支持卸载、不支持 IL2CPP 动态加载）。
+- **Harmony**：检测到 `0Harmony` 时按模组自动 `Harmony("shrink.mod.<id>").PatchAll(modAssembly)`；无 Harmony 静默跳过（可选桥接，不打进框架）。
+- **网络抽象**：`IShrinkModNetworkTransport + ShrinkModNetworkManager`，只定义频道/处理器/收发语义，可接 NGO/Mirror/FishNet/自有 Socket。
+- **自动集成**：`ShrinkModOptionalRuntimeIntegration` 在模组注册时反射探测并接入 EventBus/Command/Network（含刷新 Network-EventBus 桥）。
+- **自动启动**：`[RuntimeInitializeOnLoadMethod(AfterAssembliesLoaded)]` 读 `ShrinkModFrameworkSettings` 装载；`ShrinkModBootstrap`（场景物体）仅作手动覆盖。
+- **编辑器脚手架**（`Editor/Scaffolding/`）：外部 DLL 模组模板生成器、仓库内模组模板生成器（推荐路径，复用仓库 sln/asmdef 编译链）、Mod SDK 导出器（`ShrinkSDK/Mod/*` 菜单，产出 `GeneratedModSdk/`：Libs + ExternalMod 模板 + manifest）。
+
+### 6.6 ShrinkTutorial 0.1.0
+
+- **数据驱动**：`ShrinkTutorialData / Step / Database`（ScriptableObject）+ `ShrinkTutorialSettings`；`ShrinkTutorialManager` 单例调度（排队、前置检查、逐步执行、完成/跳过持久化）。
+- **目标定位**：静态 `Hierarchy Path` 或运行时 `AnchorId`（`ShrinkTutorialAnchor` 组件 + `AnchorRegistry`）；步骤支持 `waitForTarget + waitTimeout` 等待动态目标出现。
+- **完成条件**：`ClickTarget`（EventSystem 射线真实命中才过步，防"遮罩挡住但教程已前进"）/ `AnyClick` / `CustomEvent`（业务调 `CompleteStep(eventName)`）/ `Auto`；`DragToTarget` 暂按自定义事件处理。
+- **UI**：独立 Overlay Canvas + 遮罩挖洞（目标区可继续点击）+ 提示框/箭头/跳过按钮（`ShrinkTutorialMask / Dialog`）。
+- **持久化**：`IShrinkTutorialStorage` → 默认 `PlayerPrefs` 实现。
+- **本地化**：仅接口 `IShrinkTutorialLocalizationProvider`，不内置表系统。
+- **入口**：`ShrinkSDK/引导/教程编辑器`、`ShrinkSDK/引导/重置教程进度`；示例场景 `ShrinkTutorialSample.unity` 可由 `ShrinkSDK/引导/创建示例场景` 一键重建（当前示例文案为英文，规避 TMP 默认字体缺中文字形）。
+
+### 6.7 ShrinkApp.Starter.Basic 0.1.0
+
+- **一键起盘**：菜单 `ShrinkApp/Starter/生成 Basic Entry 场景` 生成 `ShrinkAppEntry.unity` + `ShrinkAppSettings` / `ShrinkDataSaverSettings` / `ShrinkAppBasicStarterSettings` 三份配置。
+- **最小闭环调试台**：存档槽操作、命令输入与输出、Loopback 绑定/断开、模块/服务/存档/命令/网络五块只读状态面板，演示 `App + DataSaver + Command + Network` 全链路。
+- **Starter 配置**：自动绑 loopback、默认命令、输出行数上限等。
+
+## 7. 独立服务器生成链
+
+**目标**：Unity 项目里的消息合同与处理器范式，能直接生成一个可编译、可运行、可继续补业务的 .NET 独立服务器工程（控制台 + 专用服，类似 Minecraft server 的形态）。
+
+**生成器**：`ShrinkNetwork/Editor/Scaffolding/ShrinkDedicatedServerScaffoldGenerator.cs`，菜单 `ShrinkSDK/Network/生成完整独立服务器工程` / `刷新独立服务器 Generated 合同`，输出到 `GeneratedServers/ShrinkNetwork.ServerHost/`。
+
+**生成策略**（依赖特性范式而非演示代码命名）：
+
+- 模板部分（`.cs.txt` 源）：`Program.cs`、`Framework/`（`ShrinkDedicatedServerApp`、`ServerHostOptions/Properties`、`ServerAuthStore`、`UnityNetworkCodeScanner`、`IShrinkServerModule` 模块体系）、`AuthServerModule`、TCP/KCP 服务端传输、`server.properties`。
+- 扫描生成部分（`Generated/*.g.cs`）：网络合同 DTO、按 `[ShrinkNetworkStateSync]` 角色推断同步模块、按 `[ShrinkNetworkEvent]` 三分类（广播/裁决/增量）自动生成 handler 模板并注册、`[ShrinkNetworkSubscribe]` 权限声明映射、扫描清单（`UNITY_NETWORK_SCAN.md` / `unity-network-scan.json`）。
+
+**宿主运行形态**：
+
+- 模块自发现：反射本程序集全部 `IShrinkServerModule` 实例化（含生成的 `UnityGeneratedServerModule` 与手写的 `AuthServerModule`）。
+- 双监听：TCP 与 KCP 同端口（默认 17777；历史演示 17001/17002）。
+- 配置体系：`ServerHostProperties.LoadOrCreate()`，优先级 **代码默认值 < server.properties < 环境变量**；支持 `SHRINK_SERVER_CONFIG_PATH` 自定义路径、`SHRINK_SERVER_AUTH_TOKEN` 等环境变量；首启缺文件自动落默认配置。
+- 鉴权与安全基线：默认**拒绝匿名登录**（`AllowAnonymousWhenAuthTokenMissing` 显式开启才放行）；共享口令登录后签发内存态会话令牌（TTL + 续期窗口 + 逐包校验 + 坏令牌踢线，`server/auth/login` / `server/auth/refresh`）；协议/Schema 版本窗口越界可断链；TCP 可选 TLS（服务端证书 + 客户端校验）；TCP/KCP 均有最大包长与远端地址校验。
+- 可观测：`GetDiagnosticsSnapshot()` 全套指标按 `DiagnosticsLogIntervalSeconds` 周期打印，Ctrl+C 前输出最终快照。
+
+**验证工具**（烟测闭环）：`GeneratedServers/ShrinkCommand.RuntimeSmoke`、`ShrinkCommand.EventBusSmoke`、`ShrinkNetwork.RuntimeSmoke` 三个控制台工程，覆盖"登录拿令牌 → 业务 RPC → 令牌续期 → 篡改令牌被踢"与远程 `status` 命令链路。
+
+## 8. 场景资产
+
+| 场景 | 用途 |
+|---|---|
+| `SampleScene.unity` | 基础示例 |
+| `ShrinkAppEntry.unity` | Starter 一键生成的入口调试台 |
+| `ShrinkEmbeddedHostNetworkDemo.unity` | 宿主内嵌网络演示（控制器自动 RegisterService，无需手工注册） |
+| `ShrinkLanMovementDemo.unity` | LAN 平台跳跃移动同步演示（状态增量范式样板） |
+| `ShrinkTutorialSample.unity` | 引导系统示例（三类完成路径），可一键重建 |
+
+## 9. 安全与健壮性设计（商业级硬化两轮成果）
+
+1. **传输防线**：TCP/KCP 最大包长保护（防伪造长度触发大分配）、KCP 远端地址校验 + 随机 conversationId、TCP 并发写串行化（防包流交叉，见 NETWORK_PITFALLS #4）。
+2. **协议闸门**：包级 Protocol/Schema 版本 + 服务端窗口校验，违规可主动断链。
+3. **身份与会话**：默认拒绝匿名；共享口令 → 内存态会话令牌（TTL/续期/逐包校验/踢线）。
+4. **加密信道**：TCP 可选 TLS（证书 + SNI + 吊销检查；当前不含双向认证）。
+5. **并发安全**：服务/会话并发集合、断线自动失败挂起 RPC、EventBus 派发竞态修复、Unity 侧有界派发队列 + 溢出策略。
+6. **可观测**：全套指标快照 + 宿主周期摘要（尚无 metrics 导出/trace/告警）。
+7. **生成期报错**：opcode/route 冲突、installer 循环依赖、重复 ModuleId 均在编译/生成阶段失败，不静默兜底。
+
+## 10. 测试与验证现状
+
+- **包内测试**：`ShrinkDataSaver/Tests`（六类，最扎实）；`ShrinkEventBus/Tests`（派发/优先级/注册/订阅四类，1.3.0 后补齐）。
+- **烟测工程**：三个 RuntimeSmoke/EventBusSmoke 控制台工程，覆盖鉴权-续期-踢线与远程命令全链路。
+- **构建验证**：`dotnet build ShrinkSDK.sln`、Assembly-CSharp(-Editor)、ServerHost.csproj 均 0 warning / 0 error（线程 2026-04-07 记录用户实测 Command/Network/独立服务器链路通过）。
+- **缺口**：Network/Command/ModFramework/Tutorial 无包内测试目录；无 CI 配置；Unity 编辑器内"重新生成完整独立服务器工程"的运行时回归未做（线程 Next Steps 首条）。
+
+## 11. 已知设计限制与风险
+
+来自 `.planning/codebase/CONCERNS.md`（编码问题部分已修复，如 DataSaver 中文乱码已按 UTF-8 重写）与线程 Notes/Next Steps 的仍有效项：
+
+1. **网络栈生产缺口**：无 TLS 双向认证、无正式身份体系（当前是共享口令+内存令牌，无令牌轮换/外部 IdP）、协议版本是"窗口校验+断开"而非协商式、无 metrics 导出/trace/dashboard/告警、未做压测与模糊包故障演练。
+2. **EventBus 桥回传受限**：`ShrinkNetwork.Integration.EventBus` 的 `HasResult` 事件只回传 `EventResult/IsCanceled/ErrorCode/ErrorMessage`，不自动回传事件对象其它字段的最终改动。
+3. **外部 DLL 模组边界**：不支持运行时卸载程序集；IL2CPP Player 下外部 DLL 动态加载不可用。
+4. **生成器边界**：独立服务器生成以"可编译、可注册、可继续补业务"为目标，不推断完整业务逻辑；`GeneratedServers/` 产物可重建，人工业务不得写进生成文件（覆写保护行为待确认，线程 Next Steps 有记录）。
+5. **教程系统**：DragToTarget 未内建命中判定；圆形高亮视觉按外接矩形挖洞；示例文案为英文（等可用中文 TMP 字体资产后回改）。
+6. **仓库工程面**：无 CI/发布流水线；`.planning/codebase/` 地图滞后于当前模块规模（本文档即为补齐）；部分公开 API 仍有 nullable 语义不一致残留（`route = null` 类签名收口未完成）。
+7. **历史已过期项**：`D:\UnityBuilds\ShrinkSDK` 曾不是 Git 仓库（现为 Git 仓库，当前处于初始提交暂存阶段）；ServerHost nullable warnings 已清零（旧记录过期）。
+
+## 12. 关键文件索引（推荐阅读顺序）
+
+1. 统一宿主：`Assets/Modules/ShrinkApp.Core/Runtime/ShrinkApp.cs` → `ShrinkAppHost.cs` → `ShrinkAppTypes.cs`
+2. 编译期机制：`Assets/Modules/ShrinkShared.CodeGen/Editor/ShrinkRegistryILPostProcessor.cs`
+3. 事件系统：`Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs` → `IShrinkEventBus.cs` → `ShrinkEventBusInstance.cs`
+4. 存档系统：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs` → `ShrinkDataSaverRuntime.cs` → `LocalStorageProvider.cs`
+5. 命令系统：`Assets/Modules/ShrinkCommand/Runtime/Core/ShrinkCommandService.cs` → `Metadata/ShrinkCommandAttributes.cs`
+6. 网络框架：`Assets/Modules/ShrinkNetwork/Runtime/Core/ShrinkNetworkService.cs` → `Metadata/ShrinkNetworkPacket.cs` → `Transport/Abstractions/IShrinkNetworkTransport.cs`
+7. 模组框架：`Assets/Modules/ShrinkModFramework/Runtime/Bootstrap/ShrinkModRuntimeBootstrap.cs` → `Loading/ShrinkModLoader.cs` → `Core/IShrinkMod.cs`
+8. 引导系统：`Assets/Modules/ShrinkTutorial/Runtime/Core/ShrinkTutorialManager.cs`
+9. 独立服务器：`GeneratedServers/ShrinkNetwork.ServerHost/Program.cs` → `Framework/ShrinkDedicatedServerApp.cs`
+10. 经验教训：`NETWORK_PITFALLS.md`（19 条联网/桥接/编译链踩坑，含 Kcp DLL 兼容、TCP 并发写、生成器范式化等）
diff --git a/Docs/Archive/README.md b/Docs/Archive/README.md
new file mode 100644
index 0000000..b93aea4
--- /dev/null
+++ b/Docs/Archive/README.md
@@ -0,0 +1,10 @@
+# 文档归档
+
+本目录只保存历史设计、已完成迁移方案和过期代码地图，不是当前实现依据。
+
+- 当前唯一架构文档：仓库根 `DESIGN.md`
+- `CORDIS_MIGRATION.completed.md`：Cordis 阶段 0 至 5 的迁移论证和历史验收记录
+- `DESIGN-2026-08-16.md`：合并 Cordis 完成态之前的架构快照
+- `codebase-map-2026-05-23/`：2026-05-23 生成的旧代码地图
+
+归档内容不随代码持续更新。发生冲突时，以源码、包清单、asmdef、自动化验证和根 `DESIGN.md` 为准。
diff --git a/Docs/Archive/codebase-map-2026-05-23/ARCHITECTURE.md b/Docs/Archive/codebase-map-2026-05-23/ARCHITECTURE.md
new file mode 100644
index 0000000..5708bc8
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/ARCHITECTURE.md
@@ -0,0 +1,101 @@
+# 架构
+
+## 架构概览
+
+- 这是一个以 Unity 包为边界的 SDK 单仓架构。
+- 主要由三个可分发模块组成：
+  - `ShrinkEventBus`
+  - `ShrinkDataSaver`
+  - `ShrinkDataSaver.Integration.EventBus`
+- 每个模块都按 `Runtime`、`Editor`、`Tests` 或 `CodeGen` 做职责分离。
+
+## 核心分层
+
+- 事件总线层
+  - 公开入口在 `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+  - 负责注册、触发、注销、调试记录和实例注册状态
+- 事件元数据与执行层
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs`
+  - `Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs`
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventHandlerInfo.cs`
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventPool.cs`
+- 编译织入层
+  - `Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs`
+  - 负责给订阅者自动注入 `AutoRegister` 与 `UnregisterInstance`
+- 存档核心层
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs`
+- 存储与安全层
+  - `Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs`
+- 版本迁移层
+  - `Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs`
+- Unity 入口层
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs`
+- 集成桥接层
+  - `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+
+## 主要数据流
+
+## EventBus 数据流
+
+- 注册流：
+  - `[EventBusSubscriber]` + `[EventSubscribe]`
+  - `EventBusILPostProcessor` 在编译期织入
+  - 运行时通过 `EventBus.AutoRegister(this)` 完成注册
+- 触发流：
+  - `EventBus.TriggerEvent` 或 `EventBus.TriggerEventAsync`
+  - 从 `EventCache<TEvent>.List` 取监听列表
+  - `ListenerList` 返回已排序快照
+  - 依优先级逐个执行 handler
+
+## DataSaver 数据流
+
+- 保存流：
+  - `ShrinkSave.SaveSlotAsync`
+  - 序列化所有已注册模块
+  - 可选加密
+  - 经 `IStorageProvider.WriteAsync` 落盘
+  - 触发保存完成或失败事件
+- 加载流：
+  - `ShrinkSave.LoadSlotAsync`
+  - 从 `IStorageProvider.ReadAsync` 读取
+  - 可选解密
+  - 必要时执行 `MigrationChain.Apply`
+  - 分发给每个已注册模块反序列化
+  - 缓存 `_loadedModuleData` 供查询接口使用
+
+## 生命周期入口
+
+- `EventBus` 通过静态构造与运行时初始化参与系统启动。
+- `ShrinkDataSaverBootstrap` 是 `MonoBehaviour` 入口，负责：
+  - 初始化 `ShrinkSettings`
+  - 初始化 `ShrinkSave`
+  - 自动保存轮询
+  - 应用暂停与退出时落盘设置
+- `DataSaverEventBusBridge` 在 `AfterAssembliesLoaded` 订阅 DataSaver 原生事件。
+
+## 架构风格
+
+- 偏“静态门面 + 小型基础设施”的工具库风格。
+- 对业务方暴露的是简单静态 API，而不是依赖注入容器。
+- 内部通过接口和 asmdef 边界做最小抽象，典型例子是 `IStorageProvider`。
+- 编辑器功能与运行时彻底分离，避免运行时代码依赖 UnityEditor。
+
+## 入口判断
+
+- 真正的运行时入口不是某个 `Main.cs`，而是 Unity 生命周期钩子和静态类。
+- 如果要阅读项目行为，优先从以下文件开始：
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+
+## 结论
+
+- 这套架构的重点是“低侵入接入 Unity 项目”，而不是重框架化。
+- 真正的设计价值在于 asmdef 分层、编译织入、静态门面和模块化存储抽象的组合。
diff --git a/Docs/Archive/codebase-map-2026-05-23/CONCERNS.md b/Docs/Archive/codebase-map-2026-05-23/CONCERNS.md
new file mode 100644
index 0000000..ed43d67
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/CONCERNS.md
@@ -0,0 +1,66 @@
+# 风险与关注点
+
+## 1. 中文编码已明显受损
+
+- 多个文件在 PowerShell 读取时出现明显乱码，不适合继续作为事实来源直接复用。
+- 典型位置：
+  - `Assets/Modules/ShrinkDataSaver/README.md`
+  - `Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs`
+- 这会影响对外文档、Unity Inspector 文本、日志可读性和包元数据质量。
+
+## 2. 仓库当前不在 Git 工作树内
+
+- 在 `D:\UnityBuilds\ShrinkSDK` 执行 `git status --short` 返回 “not a git repository”。
+- 这意味着当前无法依赖 Git 记录变更、提交地图文档或审查历史。
+- 如果这个目录只是导出副本，需要明确真实源码仓位置。
+
+## 3. EventBus 缺少自动化测试证据
+
+- 当前测试基本只覆盖 `Assets/Modules/ShrinkDataSaver/Tests`。
+- `ShrinkEventBus` 的以下关键能力没有看到测试文件：
+  - 优先级排序
+  - 取消事件传播
+  - 异步 handler 路径
+  - `EventPool<T>` 复用语义
+  - IL Post Processor 自动注册
+
+## 4. `ShrinkSettings.Unwatch` API 设计存在可用性问题
+
+- `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs`
+- `Watch<T>` 内部把 `Action<T>` 包成新的 `Action<object>` 存入 `_watchers`。
+- `Unwatch` 却要求外部传 `Action<object>`，调用者几乎无法用原始 `Action<T>` 精确移除。
+- 这不是理论问题，而是实际 API 不对称。
+
+## 5. 截图路径可能留下纹理对象生命周期问题
+
+- `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+- `CaptureScreenshotAsync` 在截图和缩放时会创建 `Texture2D`，但没有看到显式销毁临时纹理。
+- 在频繁截图存档场景下，值得确认是否会累积内存压力。
+
+## 6. 集成桥接存在重复订阅风险窗口
+
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+- 该桥接在 `RuntimeInitializeOnLoadMethod` 里直接给静态事件追加订阅，没有看到“已初始化”防重复保护。
+- 如果遇到特定域重载配置或重复初始化路径，可能造成重复转发。
+- 这一点需要在真实 Unity 运行模式下验证，而不是仅凭源码静态阅读下结论。
+
+## 7. 集成层版本描述需要复核
+
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json`
+- 该包依赖中声明 `com.cneicy.shrink-eventbus` 版本 `1.0.0`，但本仓库内 `ShrinkEventBus` 包版本是 `1.1.4`。
+- 这不一定是错误，但至少说明版本关系需要人工确认。
+
+## 8. 没有看到 CI 或发布流水线
+
+- 当前未发现 `.github/workflows`、GitLab CI 或 Azure Pipelines 配置。
+- 对一个要分发的 Unity SDK 来说，这意味着：
+  - 测试可能不自动跑
+  - 文档与包版本可能靠手工维护
+  - 编译织入问题更难被持续发现
+
+## 结论
+
+- 当前最现实的三个问题是：编码质量、EventBus 测试缺口、以及若干运行时边界没有自动化验证。
+- 如果后续要继续基于这个仓库规划工作，建议先确认真实源码仓与编码基线，再决定是否进入功能开发或补测试阶段。
diff --git a/Docs/Archive/codebase-map-2026-05-23/CONVENTIONS.md b/Docs/Archive/codebase-map-2026-05-23/CONVENTIONS.md
new file mode 100644
index 0000000..782c4fa
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/CONVENTIONS.md
@@ -0,0 +1,76 @@
+# 代码约定
+
+## 总体风格
+
+- 代码整体偏 Unity 常规 C# 风格，使用 PascalCase 命名类型与公开成员，私有字段使用前导下划线。
+- 重要入口类大量使用 `public static class`，例如：
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs`
+  - `Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs`
+- 面向使用者暴露简单 API，内部状态则保留在静态字段中。
+
+## 命名约定
+
+- 事件类统一以 `Event` 结尾，见 `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs`。
+- 事件参数类统一以 `EventArgs` 结尾，见 `Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs`。
+- 配置类统一以 `Settings`、`Options`、`Config` 结尾。
+- 编辑器窗口统一以 `EditorWindow` 结尾，见：
+  - `Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs`
+  - `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs`
+
+## 模式约定
+
+- Unity 运行时与编辑器严格分目录、分 asmdef。
+- 用 Attribute 表达声明式能力：
+  - `[EventBusSubscriber]`
+  - `[EventSubscribe]`
+  - `[Cancelable]`
+  - `[HasResult]`
+- 用接口做最小抽象，而不是引入完整容器：
+  - `IStorageProvider`
+  - `ISaveModule`
+  - `ISaveModule<T>`
+
+## 空值与语法习惯
+
+- 仓库同时使用普通 C# 空值判断和 Unity 对象真值判断。
+- `ShrinkEventBus` 某些文件启用了 `#nullable enable`，例如：
+  - `Assets/Modules/ShrinkEventBus/Runtime/EventBase.cs`
+  - `Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs`
+- 但整个仓库并没有统一启用可空引用，说明这是局部使用而非全局规范。
+
+## 日志与注释
+
+- 日志前缀较统一，常见前缀有：
+  - `[EventBus]`
+  - `[ShrinkDataSaver]`
+  - `[ShrinkDataSaver.Integration]`
+- 源码注释和用户可见菜单文本原本倾向中文。
+- 但当前有多处中文字符串出现乱码，典型位置包括：
+  - `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs`
+  - `Assets/Modules/ShrinkDataSaver/README.md`
+  - `Assets/Modules/ShrinkDataSaver.Integration.EventBus/README.md`
+
+## 错误处理
+
+- 运行时代码多采用“抛异常 + 触发失败事件 + Debug.Log”混合策略。
+- 对非关键模块失败通常记录日志后跳过，对关键模块失败则终止保存，见 `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`。
+- 异步 fire-and-forget 分支会用统一包装打印异常，见 `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`。
+
+## 测试约定
+
+- 测试位于 `Assets/Modules/ShrinkDataSaver/Tests`。
+- 同时使用 `[Test]` 与 `[UnityTest]`。
+- 测试通过 `MockStorageProvider` 隔离文件系统，见 `Assets/Modules/ShrinkDataSaver/Tests/MockStorageProvider.cs`。
+
+## 可读性与组织
+
+- 单文件职责通常比较集中，尤其是 Runtime 层。
+- 但 `ShrinkSave.cs`、`ShrinkDataSaverEditorWindow.cs` 体量偏大，已经承担多个职责。
+
+## 结论
+
+- 当前代码约定的关键词是：静态门面、Attribute 驱动、asmdef 分层、中文日志、最小抽象。
+- 如果后续继续扩展，最需要先统一的是编码、可空规范和部分大文件拆分标准。
diff --git a/Docs/Archive/codebase-map-2026-05-23/INTEGRATIONS.md b/Docs/Archive/codebase-map-2026-05-23/INTEGRATIONS.md
new file mode 100644
index 0000000..d1f3bed
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/INTEGRATIONS.md
@@ -0,0 +1,75 @@
+# 外部集成
+
+## 总览
+
+- 这个仓库外部依赖不多，主要是 Unity 运行时、Unity 编译管线、文件系统和少量第三方包。
+- 没有发现数据库、网络 API、认证服务、WebHook、云函数等后端集成代码。
+
+## Unity 平台能力
+
+- `Assets/Modules/ShrinkEventBus/Runtime/EventAutoRegHelper.cs`
+  - 使用 `RuntimeInitializeOnLoadMethod` 参与运行时初始化。
+- `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs`
+  - 依赖 `Application.persistentDataPath`
+  - 依赖 `DontDestroyOnLoad`
+  - 在 `OnApplicationQuit` 和 `OnApplicationPause` 里刷写设置
+- `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverSettings.cs`
+  - 使用 `Resources.Load`
+  - 编辑器下回退到 `UnityEditor.AssetDatabase`
+
+## 第三方包
+
+- `com.cysharp.unitask`
+  - 用于异步事件处理与异步文件操作
+  - 关键落点：`Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+  - 关键落点：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+  - 关键落点：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs`
+- `com.unity.nuget.newtonsoft-json`
+  - 用于 JSON 序列化、JObject 迁移链和弱类型数据缓存
+  - 关键落点：`Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs`
+  - 关键落点：`Assets/Modules/ShrinkDataSaver/Runtime/MigrationChain.cs`
+  - 关键落点：`Assets/Modules/ShrinkDataSaver/Runtime/SaveTypes.cs`
+
+## 编译管线集成
+
+- `Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs`
+  - 接入 `Unity.CompilationPipeline.Common.ILPostProcessing`
+  - 使用 Mono.Cecil 改写带 `[EventBusSubscriber]` 的 `MonoBehaviour`
+- `Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorAssemblyResolver.cs`
+- `Assets/Modules/ShrinkEventBus/CodeGen/Editor/PostProcessorReflectionImporter.cs`
+
+## 模块间集成
+
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+  - 将 `ShrinkDataSaver` 的原生事件桥接到 `ShrinkEventBus`
+  - 桥接方向是单向的：`ShrinkDataSaver -> ShrinkEventBus`
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEvents.cs`
+  - 定义桥接后的 9 个事件类型
+
+## 本地存储集成
+
+- `Assets/Modules/ShrinkDataSaver/Runtime/IStorageProvider.cs`
+  - 定义存储抽象
+- `Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs`
+  - 当前唯一实现
+  - 使用本地文件系统读写、删除、列举文件
+  - 采用 `.tmp` 文件再替换的方式降低写坏文件的概率
+
+## 编辑器集成
+
+- `Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs`
+  - 通过 Unity 菜单打开事件查看器
+- `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs`
+  - 通过 Unity 菜单操作设置与存档
+
+## 未发现的外部依赖
+
+- 未发现 HTTP 客户端调用。
+- 未发现数据库连接代码。
+- 未发现 OAuth、Steamworks、Firebase、PlayFab、Addressables 等 SDK 实际接入代码。
+- README 中提到 Steam Cloud 场景，但当前仓库里没有直接调用 Steam API 的实现。
+
+## 结论
+
+- 该仓库的“集成”重点不是远程服务，而是 Unity 生命周期、编译后处理、文件系统和模块间桥接。
+- 如果后续要扩展云存档、远程同步或遥测，这里目前只有存储接口和事件桥接两个自然扩展点。
diff --git a/Docs/Archive/codebase-map-2026-05-23/README.md b/Docs/Archive/codebase-map-2026-05-23/README.md
new file mode 100644
index 0000000..7d6a420
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/README.md
@@ -0,0 +1,5 @@
+# 2026-05-23 代码地图（已归档）
+
+此目录原位于 `.planning/codebase/`，现整体归档。它早于 ContextLoader、Cordis 阶段 0 至 5、当前包版本和根仓库 Git 修复，其中关于仓库不是 Git、测试规模、模块布局和风险状态的描述均不再可信。
+
+当前架构见仓库根 `DESIGN.md`。
diff --git a/Docs/Archive/codebase-map-2026-05-23/STACK.md b/Docs/Archive/codebase-map-2026-05-23/STACK.md
new file mode 100644
index 0000000..4263830
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/STACK.md
@@ -0,0 +1,74 @@
+# 技术栈
+
+## 项目定位
+
+- 这是一个 Unity SDK 型仓库，不是完整游戏项目。
+- 当前 Unity 版本是 `2022.3.62f3`，见 `ProjectSettings/ProjectVersion.txt`。
+- 当前仅配置了一个示例场景 `Assets/Scenes/SampleScene.unity`，见 `ProjectSettings/EditorBuildSettings.asset`。
+
+## 运行时基础
+
+- 核心语言是 C#，通过 Unity asmdef 拆分模块。
+- 根解决方案是 `ShrinkSDK.sln`，包含 `ShrinkEventBus`、`ShrinkDataSaver`、集成层、编辑器扩展和测试项目。
+- 运行时代码主要在：
+  - `Assets/Modules/ShrinkEventBus/Runtime`
+  - `Assets/Modules/ShrinkDataSaver/Runtime`
+  - `Assets/Modules/ShrinkDataSaver.Integration.EventBus`
+
+## Unity 包依赖
+
+- `Packages/manifest.json` 中可确认以下关键依赖：
+  - `com.cysharp.unitask`
+  - `com.unity.nuget.newtonsoft-json`
+  - `com.unity.test-framework`
+  - `com.unity.ugui`
+  - `com.unity.textmeshpro`
+  - `com.unity.timeline`
+  - `com.unity.render-pipelines.universal`
+
+## 仓库内 SDK 包
+
+- `Assets/Modules/ShrinkEventBus/package.json`
+  - 包名 `com.cneicy.shrink-eventbus`
+  - 版本 `1.1.4`
+  - 依赖 `UniTask`
+- `Assets/Modules/ShrinkDataSaver/package.json`
+  - 包名 `com.cneicy.shrink-datasaver`
+  - 版本 `2.0.0`
+  - 依赖 `UniTask` 与 `Newtonsoft.Json`
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/package.json`
+  - 包名 `com.cneicy.shrink-datasaver-integration-eventbus`
+  - 版本 `2.0.0`
+  - 依赖 `ShrinkDataSaver` 与 `ShrinkEventBus`
+
+## 程序集拆分
+
+- `Assets/Modules/ShrinkEventBus/Runtime/ShrinkEventBus.Runtime.asmdef`
+- `Assets/Modules/ShrinkEventBus/Editor/ShrinkEventBus.Editor.asmdef`
+- `Assets/Modules/ShrinkEventBus/CodeGen/Editor/Unity.ShrinkEventBus.CodeGen.asmdef`
+- `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaver.Runtime.asmdef`
+- `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaver.Editor.asmdef`
+- `Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef`
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/ShrinkDataSaver.Integration.EventBus.asmdef`
+
+## 关键技术点
+
+- 事件系统使用泛型静态缓存与对象池优化热路径，入口在 `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`。
+- 自动注册依赖 Unity IL Post Processor 与 Mono.Cecil，入口在 `Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs`。
+- 存档系统使用 `UniTask` 处理异步 IO，入口在 `Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`。
+- 序列化基于 `Newtonsoft.Json`，入口在 `Assets/Modules/ShrinkDataSaver/Runtime/DataSerializer.cs`。
+- 加密使用 AES-CBC + PBKDF2-SHA256，入口在 `Assets/Modules/ShrinkDataSaver/Runtime/SaveEncryptor.cs`。
+- 本地存储基于 `Application.persistentDataPath` 与文件系统，入口在 `Assets/Modules/ShrinkDataSaver/Runtime/LocalStorageProvider.cs`。
+
+## 编辑器与测试
+
+- 编辑器工具包括：
+  - `Assets/Modules/ShrinkEventBus/Editor/EventBusViewerWindow.cs`
+  - `Assets/Modules/ShrinkDataSaver/Editor/ShrinkDataSaverEditorWindow.cs`
+- 当前扫描到运行时相关文件约 `62` 个，编辑器相关文件约 `16` 个。
+- 测试主要集中在 `Assets/Modules/ShrinkDataSaver/Tests`，当前统计到 `[Test]`/`[UnityTest]` 标记共 `78` 个。
+
+## 结论
+
+- 这是一个围绕 Unity 包分发设计的多模块 SDK 仓库。
+- 技术选择偏向 Unity 原生能力 + `UniTask` + `Newtonsoft.Json`，没有引入重量级 DI、状态机或第三方测试平台。
diff --git a/Docs/Archive/codebase-map-2026-05-23/STRUCTURE.md b/Docs/Archive/codebase-map-2026-05-23/STRUCTURE.md
new file mode 100644
index 0000000..f866f92
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/STRUCTURE.md
@@ -0,0 +1,119 @@
+# 目录结构
+
+## 顶层结构
+
+- `Assets`
+  - 核心源码、编辑器扩展、测试、示例场景和包描述文件都在这里
+- `Packages`
+  - Unity 包清单与锁文件
+- `ProjectSettings`
+  - Unity 版本、渲染、输入、构建场景等项目配置
+- `Library`、`Temp`、`Logs`、`obj`
+  - Unity 生成目录，不属于源码地图重点
+
+## Assets 下的主要模块
+
+## `Assets/Modules/ShrinkEventBus`
+
+- `Runtime`
+  - 事件总线核心实现
+- `Editor`
+  - 事件查看器窗口
+- `CodeGen/Editor`
+  - IL Post Processor 与 Cecil 辅助类
+- `README.md`
+- `package.json`
+- `Benchmark.txt`
+
+## `Assets/Modules/ShrinkDataSaver`
+
+- `Runtime`
+  - 存档、设置、迁移、加密、存储抽象与配置
+- `Editor`
+  - 数据查看器窗口
+- `Tests`
+  - NUnit 与 Unity Test Runner 测试
+- `README.md`
+- `package.json`
+
+## `Assets/Modules/ShrinkDataSaver.Integration.EventBus`
+
+- `DataSaverEvents.cs`
+- `DataSaverEventBusBridge.cs`
+- `README.md`
+- `package.json`
+- `ShrinkDataSaver.Integration.EventBus.asmdef`
+
+## `Assets/Modules/ShrinkModFramework`
+
+- `Editor/Scaffolding`
+  - Mod SDK 导出器、外部 DLL 模组模板生成器、仓库内模组模板生成器与模板文件
+- `Runtime/Bootstrap`
+  - 自动启动、运行时驱动、设置资产与可选场景入口
+- `Runtime/Core`
+  - `IShrinkMod`、`ShrinkModBase`、`ShrinkModContext`、`ShrinkModHandle`
+- `Runtime/Metadata`
+  - 模组特性、依赖、状态、版本信息
+- `Runtime/Registry`
+  - 模组注册表与注册表管理器
+- `Runtime/Loading`
+  - 模组发现、依赖排序、外部 DLL 装载、Harmony 接入
+- `Runtime/Network`
+  - 模组网络抽象层
+- `Runtime/Integration`
+  - 对 `ShrinkEventBus`、`ShrinkCommand`、`ShrinkNetwork` 的可选自动接入胶水
+- `README.md`
+- `package.json`
+- `Runtime/ShrinkModFramework.Runtime.asmdef`
+
+## 其他目录
+
+- `Assets/Scenes/SampleScene.unity`
+  - 当前唯一启用的示例场景
+- `Assets/Settings`
+  - URP 资源和场景模板
+
+## 关键文件入口
+
+- 事件系统入口：`Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+- 事件订阅反射注册：`Assets/Modules/ShrinkEventBus/Runtime/EventBusRegHelper.cs`
+- 事件订阅编译织入：`Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs`
+- 存档系统入口：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSave.cs`
+- 设置系统入口：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkSettings.cs`
+- Unity 启动器：`Assets/Modules/ShrinkDataSaver/Runtime/ShrinkDataSaverBootstrap.cs`
+- 模块桥接入口：`Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+- 模组框架启动入口：`Assets/Modules/ShrinkModFramework/Runtime/Bootstrap/ShrinkModRuntimeBootstrap.cs`
+- 模组装载入口：`Assets/Modules/ShrinkModFramework/Runtime/Loading/ShrinkModLoader.cs`
+- 模组模板生成入口：`Assets/Modules/ShrinkModFramework/Editor/Scaffolding/ShrinkExternalModTemplateGenerator.cs`
+- 仓库内模组模板生成入口：`Assets/Modules/ShrinkModFramework/Editor/Scaffolding/ShrinkInRepoModTemplateGenerator.cs`
+- Mod SDK 导出入口：`Assets/Modules/ShrinkModFramework/Editor/Scaffolding/ShrinkModSdkExporter.cs`
+
+## 命名组织规律
+
+- 包名与目录名基本一一对应：`ShrinkEventBus`、`ShrinkDataSaver`、`ShrinkDataSaver.Integration.EventBus`
+- `ShrinkModFramework` 继续遵循同样规则，并在 `Runtime` 下进一步按职责拆子目录
+- 命名空间与 asmdef 名称基本一致：
+  - `ShrinkEventBus`
+  - `ShrinkEventBus.Editor`
+  - `ShrinkEventBus.CodeGen`
+  - `ShrinkDataSaver`
+  - `ShrinkDataSaver.Editor`
+  - `ShrinkDataSaver.Integration`
+- 编辑器专属代码全部放在 `Editor` 目录下，符合 Unity 约定。
+
+## 解决方案结构
+
+- `ShrinkSDK.sln` 暴露了 8 个 C# 工程：
+  - `ShrinkEventBus.Runtime`
+  - `ShrinkEventBus.Editor`
+  - `Unity.ShrinkEventBus.CodeGen`
+  - `ShrinkDataSaver.Runtime`
+  - `ShrinkDataSaver.Editor`
+  - `ShrinkDataSaver.Tests`
+  - `ShrinkDataSaver.Integration.EventBus`
+  - `Assembly-CSharp`
+
+## 结论
+
+- 结构上最值得注意的是：这是按“可发布 Unity 包”来组织，而不是按单一游戏功能目录来组织。
+- 阅读顺序建议先从 `Runtime`，再到 `Editor`，最后看 `Tests` 与 `README.md`。
diff --git a/Docs/Archive/codebase-map-2026-05-23/TESTING.md b/Docs/Archive/codebase-map-2026-05-23/TESTING.md
new file mode 100644
index 0000000..de42a77
--- /dev/null
+++ b/Docs/Archive/codebase-map-2026-05-23/TESTING.md
@@ -0,0 +1,65 @@
+# 测试情况
+
+## 当前测试布局
+
+- 测试集中在 `Assets/Modules/ShrinkDataSaver/Tests`。
+- 测试程序集定义见 `Assets/Modules/ShrinkDataSaver/Tests/ShrinkDataSaver.Tests.asmdef`。
+- 该 asmdef：
+  - 仅在 `Editor` 平台启用
+  - 依赖 `UnityEngine.TestRunner` 与 `UnityEditor.TestRunner`
+  - 通过 `UNITY_INCLUDE_TESTS` 控制
+  - 额外引用 `Newtonsoft.Json.dll`
+
+## 已覆盖模块
+
+- `Assets/Modules/ShrinkDataSaver/Tests/ShrinkSaveTests.cs`
+  - 模块注册
+  - 保存、加载、删除
+  - 事件触发
+  - 关键模块失败行为
+  - 版本迁移事件
+  - 查询接口
+  - 自动保存间隔
+  - 元数据读取
+  - `LoadedSlot` 状态
+  - 多模块往返
+- `Assets/Modules/ShrinkDataSaver/Tests/ShrinkSettingsTests.cs`
+  - 设置读写、监听、持久化与防抖行为
+- `Assets/Modules/ShrinkDataSaver/Tests/SaveEncryptorTests.cs`
+  - 加解密往返、错误密码、空输入等边界
+- `Assets/Modules/ShrinkDataSaver/Tests/MigrationChainTests.cs`
+  - 注册、链式迁移、缺步、回滚
+- `Assets/Modules/ShrinkDataSaver/Tests/DataSerializerTests.cs`
+  - JSON 序列化基础行为
+- `Assets/Modules/ShrinkDataSaver/Tests/SaveTypesTests.cs`
+  - 类型层面的默认值与结构行为
+
+## 测试风格
+
+- 同时使用同步 NUnit 测试和基于 `UniTask.ToCoroutine` 的 `UnityTest`。
+- 使用 `MockStorageProvider` 模拟存储后端，避免真实磁盘依赖。
+- 通过 `ResetForTesting()`、`MigrationChain.Clear()` 等内部重置方法控制静态状态污染。
+
+## 当前数量
+
+- 当前扫描到 `[Test]` 与 `[UnityTest]` 标记共 `78` 个。
+- 测试密度主要集中在 `ShrinkDataSaver`，并未均匀覆盖整个仓库。
+
+## 明显缺口
+
+- 没有看到 `ShrinkEventBus` 对应的测试目录。
+- `EventBus` 的优先级排序、取消传播、异步处理、自动注册织入结果，没有自动化测试证据。
+- 编辑器窗口也没有独立测试。
+- 没有发现 CI 配置文件，说明测试是否自动执行未知，当前更像本地手动运行模式。
+
+## 适合后续补强的位置
+
+- `Assets/Modules/ShrinkEventBus/Runtime/EventBus.cs`
+- `Assets/Modules/ShrinkEventBus/Runtime/ListenerList.cs`
+- `Assets/Modules/ShrinkEventBus/CodeGen/Editor/EventBusILPostProcessor.cs`
+- `Assets/Modules/ShrinkDataSaver.Integration.EventBus/DataSaverEventBusBridge.cs`
+
+## 结论
+
+- 这个仓库的测试现状可以概括为：`ShrinkDataSaver` 覆盖较扎实，`ShrinkEventBus` 和集成层明显偏弱。
+- 如果后续要发包或稳定演进，优先级最高的补测点是 EventBus 核心行为与编译织入结果。
diff --git a/Tools/UpmConsumerValidation/README.md b/Tools/UpmConsumerValidation/README.md
new file mode 100644
index 0000000..b3cd975
--- /dev/null
+++ b/Tools/UpmConsumerValidation/README.md
@@ -0,0 +1,22 @@
+# UPM Consumer Validation
+
+`Validate-UpmConsumer.ps1` verifies the package graph from outside the main Unity
+project. It performs three checks:
+
+1. Every dependency on another local `com.cneicy.*` package must use that
+   package's current `package.json` version.
+2. A temporary Unity project is created under `Temp/UpmConsumerValidation`, all
+   local packages are installed through `file:` UPM dependencies, package tests
+   are enabled, and Unity must load every package and asmdef.
+3. The same temporary UPM consumer project runs all package EditMode tests.
+
+Run with the Unity version declared by this repository:
+
+```powershell
+./Tools/UpmConsumerValidation/Validate-UpmConsumer.ps1
+```
+
+Use `-UnityEditorPath` when the matching editor is not installed in a standard
+location. Pass `-KeepProject` to retain the temporary project, reports, and Unity logs for
+investigation. `-SkipTests` is only for a quick package-resolution diagnostic and is not the
+release validation path.
diff --git a/Tools/UpmConsumerValidation/Validate-UpmConsumer.ps1 b/Tools/UpmConsumerValidation/Validate-UpmConsumer.ps1
new file mode 100644
index 0000000..4dfa6c1
--- /dev/null
+++ b/Tools/UpmConsumerValidation/Validate-UpmConsumer.ps1
@@ -0,0 +1,273 @@
+[CmdletBinding()]
+param(
+    [string]$UnityEditorPath,
+    [string]$ProjectRoot,
+    [switch]$KeepProject,
+    [switch]$SkipTests
+)
+
+$ErrorActionPreference = 'Stop'
+
+function Resolve-UnityEditor {
+    param([string]$RequestedPath)
+
+    if ($RequestedPath) {
+        $resolved = Resolve-Path -LiteralPath $RequestedPath -ErrorAction Stop
+        return $resolved.Path
+    }
+
+    $projectVersionPath = Join-Path $script:ResolvedProjectRoot 'ProjectSettings/ProjectVersion.txt'
+    $versionLine = Get-Content -LiteralPath $projectVersionPath |
+        Where-Object { $_ -like 'm_EditorVersion:*' } |
+        Select-Object -First 1
+    if (-not $versionLine) {
+        throw "Unity version was not found in $projectVersionPath"
+    }
+
+    $version = ($versionLine -split ':', 2)[1].Trim()
+    $running = Get-Process Unity -ErrorAction SilentlyContinue |
+        Where-Object { $_.Path -and $_.Path -like "*$version*" } |
+        Select-Object -First 1
+    if ($running) {
+        return $running.Path
+    }
+
+    $candidates = @(
+        "D:/UnityEditor/$version/Editor/Unity.exe",
+        "C:/Program Files/Unity/Hub/Editor/$version/Editor/Unity.exe",
+        "C:/Program Files/Unity Hub/Editor/$version/Editor/Unity.exe"
+    )
+    foreach ($candidate in $candidates) {
+        if (Test-Path -LiteralPath $candidate) {
+            return (Resolve-Path -LiteralPath $candidate).Path
+        }
+    }
+
+    throw "Unity $version was not found. Pass -UnityEditorPath explicitly."
+}
+
+function Convert-ToFileDependency {
+    param([string]$Path)
+    return 'file:' + ([System.IO.Path]::GetFullPath($Path).Replace('\', '/'))
+}
+
+function Convert-ToCSharpLiteral {
+    param([string]$Value)
+    return '"' + $Value.Replace('\', '\\').Replace('"', '\"') + '"'
+}
+
+if (-not $ProjectRoot) {
+    $ProjectRoot = Join-Path $PSScriptRoot '../..'
+}
+$script:ResolvedProjectRoot = (Resolve-Path -LiteralPath $ProjectRoot).Path
+$modulesRoot = Join-Path $script:ResolvedProjectRoot 'Assets/Modules'
+$tempRoot = Join-Path $script:ResolvedProjectRoot 'Temp'
+$consumerRoot = Join-Path $tempRoot 'UpmConsumerValidation'
+$packagesPath = Join-Path $consumerRoot 'Packages'
+$assetsEditorPath = Join-Path $consumerRoot 'Assets/Editor'
+$projectSettingsPath = Join-Path $consumerRoot 'ProjectSettings'
+$reportPath = Join-Path $consumerRoot 'upm-consumer-report.txt'
+$logPath = Join-Path $consumerRoot 'unity-upm-consumer.log'
+$testResultsPath = Join-Path $consumerRoot 'editmode-results.xml'
+$testLogPath = Join-Path $consumerRoot 'unity-editmode-tests.log'
+
+$resolvedTempRoot = [System.IO.Path]::GetFullPath($tempRoot).TrimEnd('\') + '\'
+$resolvedConsumerRoot = [System.IO.Path]::GetFullPath($consumerRoot)
+if (-not $resolvedConsumerRoot.StartsWith($resolvedTempRoot, [System.StringComparison]::OrdinalIgnoreCase)) {
+    throw "Consumer project must stay under the repository Temp directory: $resolvedConsumerRoot"
+}
+
+$packageRecords = @()
+foreach ($directory in Get-ChildItem -LiteralPath $modulesRoot -Directory) {
+    $manifestPath = Join-Path $directory.FullName 'package.json'
+    if (-not (Test-Path -LiteralPath $manifestPath)) {
+        continue
+    }
+
+    $manifest = Get-Content -Raw -LiteralPath $manifestPath | ConvertFrom-Json
+    $packageRecords += [PSCustomObject]@{
+        Directory = $directory.FullName
+        Name = [string]$manifest.name
+        Version = [string]$manifest.version
+        Manifest = $manifest
+    }
+}
+
+$packageByName = @{}
+foreach ($record in $packageRecords) {
+    if ($packageByName.ContainsKey($record.Name)) {
+        throw "Duplicate package name: $($record.Name)"
+    }
+    $packageByName[$record.Name] = $record
+}
+
+$versionErrors = @()
+foreach ($record in $packageRecords) {
+    if (-not $record.Manifest.dependencies) {
+        continue
+    }
+
+    foreach ($dependency in $record.Manifest.dependencies.PSObject.Properties) {
+        if (-not $packageByName.ContainsKey($dependency.Name)) {
+            continue
+        }
+
+        $actualVersion = $packageByName[$dependency.Name].Version
+        if ([string]$dependency.Value -ne $actualVersion) {
+            $versionErrors += "$($record.Name) requires $($dependency.Name) $($dependency.Value), local version is $actualVersion"
+        }
+    }
+}
+if ($versionErrors.Count -gt 0) {
+    throw "Internal package versions are inconsistent:`n$($versionErrors -join "`n")"
+}
+
+if (Test-Path -LiteralPath $consumerRoot) {
+    Remove-Item -LiteralPath $consumerRoot -Recurse -Force
+}
+New-Item -ItemType Directory -Path $packagesPath, $assetsEditorPath, $projectSettingsPath -Force | Out-Null
+
+$dependencies = [ordered]@{
+    'com.cysharp.unitask' = 'https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask'
+    'com.unity.nuget.newtonsoft-json' = '3.2.2'
+    'com.unity.test-framework' = '1.1.33'
+    'com.unity.textmeshpro' = '3.0.7'
+    'com.unity.ugui' = '1.0.0'
+}
+foreach ($record in $packageRecords | Sort-Object Name) {
+    $dependencies[$record.Name] = Convert-ToFileDependency $record.Directory
+}
+
+$consumerManifest = [ordered]@{
+    dependencies = $dependencies
+    testables = @($packageRecords.Name | Sort-Object)
+}
+$consumerManifest | ConvertTo-Json -Depth 8 |
+    Set-Content -LiteralPath (Join-Path $packagesPath 'manifest.json') -Encoding utf8
+Copy-Item -LiteralPath (Join-Path $script:ResolvedProjectRoot 'ProjectSettings/ProjectVersion.txt') `
+    -Destination (Join-Path $projectSettingsPath 'ProjectVersion.txt')
+
+$expectedPackages = ($packageRecords.Name | Sort-Object | ForEach-Object { Convert-ToCSharpLiteral $_ }) -join ",`n        "
+$expectedAssemblies = $packageRecords |
+    ForEach-Object { Get-ChildItem -LiteralPath $_.Directory -Recurse -Filter '*.asmdef' -File } |
+    ForEach-Object { (Get-Content -Raw -LiteralPath $_.FullName | ConvertFrom-Json).name } |
+    Sort-Object -Unique |
+    ForEach-Object { Convert-ToCSharpLiteral $_ }
+$expectedAssemblies = $expectedAssemblies -join ",`n        "
+$escapedReportPath = Convert-ToCSharpLiteral $reportPath
+
+$validatorSource = @"
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditor.PackageManager;
+
+public static class UpmConsumerValidator
+{
+    private static readonly string[] ExpectedPackages =
+    {
+        $expectedPackages
+    };
+
+    private static readonly string[] ExpectedAssemblies =
+    {
+        $expectedAssemblies
+    };
+
+    public static void Run()
+    {
+        try
+        {
+            var installed = UnityEditor.PackageManager.PackageInfo.GetAllRegisteredPackages()
+                .Select(package => package.name)
+                .ToHashSet(StringComparer.Ordinal);
+            var assemblies = CompilationPipeline.GetAssemblies()
+                .Select(assembly => assembly.name)
+                .ToHashSet(StringComparer.Ordinal);
+            var missingPackages = ExpectedPackages.Where(name => !installed.Contains(name)).ToArray();
+            var missingAssemblies = ExpectedAssemblies.Where(name => !assemblies.Contains(name)).ToArray();
+            if (missingPackages.Length > 0 || missingAssemblies.Length > 0)
+            {
+                throw new InvalidOperationException(
+                    "Missing packages: " + string.Join(", ", missingPackages) + Environment.NewLine +
+                    "Missing assemblies: " + string.Join(", ", missingAssemblies));
+            }
+
+            File.WriteAllText($escapedReportPath,
+                "PASS" + Environment.NewLine +
+                "packages=" + ExpectedPackages.Length + Environment.NewLine +
+                "assemblies=" + ExpectedAssemblies.Length + Environment.NewLine);
+            EditorApplication.Exit(0);
+        }
+        catch (Exception exception)
+        {
+            File.WriteAllText($escapedReportPath, "FAIL" + Environment.NewLine + exception);
+            UnityEngine.Debug.LogException(exception);
+            EditorApplication.Exit(1);
+        }
+    }
+}
+"@
+$validatorSource | Set-Content -LiteralPath (Join-Path $assetsEditorPath 'UpmConsumerValidator.cs') -Encoding utf8
+
+$resolvedUnity = Resolve-UnityEditor $UnityEditorPath
+Write-Host "Validating $($packageRecords.Count) local UPM packages with $resolvedUnity"
+$validationProcess = Start-Process -FilePath $resolvedUnity -ArgumentList @(
+    '-batchmode',
+    '-nographics',
+    '-projectPath', $consumerRoot,
+    '-executeMethod', 'UpmConsumerValidator.Run',
+    '-quit',
+    '-logFile', $logPath
+) -WindowStyle Hidden -Wait -PassThru
+$unityExitCode = $validationProcess.ExitCode
+
+if (-not (Test-Path -LiteralPath $reportPath)) {
+    $logTail = if (Test-Path -LiteralPath $logPath) { (Get-Content -LiteralPath $logPath -Tail 120) -join "`n" } else { '<no Unity log>' }
+    throw "UPM consumer validator did not produce a report (Unity exit $unityExitCode).`n$logTail"
+}
+
+$report = Get-Content -Raw -LiteralPath $reportPath
+if ($unityExitCode -ne 0 -or -not $report.StartsWith('PASS', [System.StringComparison]::Ordinal)) {
+    $logTail = (Get-Content -LiteralPath $logPath -Tail 120) -join "`n"
+    throw "UPM consumer validation failed (Unity exit $unityExitCode).`n$report`n$logTail"
+}
+
+Write-Host $report.Trim()
+Write-Host "Unity log: $logPath"
+
+if (-not $SkipTests) {
+    Write-Host 'Running EditMode tests from the real UPM consumer project'
+    $testProcess = Start-Process -FilePath $resolvedUnity -ArgumentList @(
+        '-batchmode',
+        '-nographics',
+        '-projectPath', $consumerRoot,
+        '-runTests',
+        '-testPlatform', 'EditMode',
+        '-testResults', $testResultsPath,
+        '-logFile', $testLogPath
+    ) -WindowStyle Hidden -Wait -PassThru
+    $testExitCode = $testProcess.ExitCode
+
+    if (-not (Test-Path -LiteralPath $testResultsPath)) {
+        $testLogTail = if (Test-Path -LiteralPath $testLogPath) { (Get-Content -LiteralPath $testLogPath -Tail 160) -join "`n" } else { '<no Unity test log>' }
+        throw "Unity Test Runner did not produce results (Unity exit $testExitCode).`n$testLogTail"
+    }
+
+    [xml]$testResults = Get-Content -Raw -LiteralPath $testResultsPath
+    $testRun = $testResults.'test-run'
+    if ($testExitCode -ne 0 -or [string]$testRun.result -ne 'Passed' -or [int]$testRun.failed -ne 0) {
+        $testLogTail = (Get-Content -LiteralPath $testLogPath -Tail 160) -join "`n"
+        throw "UPM consumer EditMode tests failed (Unity exit $testExitCode, result=$($testRun.result), total=$($testRun.total), failed=$($testRun.failed)).`n$testLogTail"
+    }
+
+    Write-Host "EditMode PASS total=$($testRun.total) passed=$($testRun.passed)"
+    Write-Host "Test results: $testResultsPath"
+    Write-Host "Test log: $testLogPath"
+}
+
+if (-not $KeepProject) {
+    Remove-Item -LiteralPath $consumerRoot -Recurse -Force
+}