diff --git a/.gitignore b/.gitignore
index 6af6a7f..4108192 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,5 @@
 /.playwright-cli/
 /package/
 /kernel/src_old/
+/render_2D/render_2D_old/
+
diff --git a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp b/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp
index 0a7e39a..fe7deba 100644
--- a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp
+++ b/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp
@@ -25,7 +25,7 @@ struct Property_Dirty_Revision {
     std::uint64_t revision{}; /* 该成员最近一次发布所使用的整体 revision。 */
     bool pending{}; /* 当前编辑面是否写入过该成员。 */
 };
-template <typename Struct, Member_Value Member> std::size_t property_dirty_key(const Struct& value, Member Struct::* member) noexcept;
+template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner> std::size_t property_dirty_key(const Struct& value, Member Owner::* member) noexcept;
 /*
  * 属性表不加锁：外部阶段只能通过 set(member) 扩展或标记属性表；advance() 完成发布后，
  * binder 才在同一内部线程阶段查询 revision。调用方保证这三个阶段不重叠，因此这里不需要
@@ -34,8 +34,8 @@ template <typename Struct, Member_Value Member> std::size_t property_dirty_key(c
 struct Struct_Dirty_Storage_Hooks : Dirty_Storage_Hooks {
     template <typename... Values> void after_advance(const Values*... before) noexcept;
     void on_write_access() noexcept;
-    template <typename Struct, Member_Value Member> void on_write_access(const Struct& value, Member Struct::* member);
-    template <typename Struct, Member_Value Member> std::uint64_t property_dirty_revision(const Struct& value, Member Struct::* member) const noexcept;
+    template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner> void on_write_access(const Struct& value, Member Owner::* member);
+    template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner> std::uint64_t property_dirty_revision(const Struct& value, Member Owner::* member) const noexcept;
     std::vector<Property_Dirty_Revision> property_revisions; /* 已被成员写接口使用过的属性 revision。 */
     std::uint64_t whole_property_revision{}; /* 最近一次整对象写入所发布的 revision。 */
     bool pending_whole_property_dirty{}; /* 当前编辑面是否发生过整对象写入。 */
diff --git a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp b/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp
index 7e5dc1a..a2ce7b4 100644
--- a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp
+++ b/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp
@@ -15,8 +15,8 @@ inline std::uint64_t Dirty_Storage_Hooks::dirty_revision() const noexcept {
     return revision;
 }
 
-template <typename Struct, Member_Value Member>
-std::size_t property_dirty_key(const Struct& value, Member Struct::* member) noexcept {
+template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner>
+std::size_t property_dirty_key(const Struct& value, Member Owner::* member) noexcept {
     const auto* const value_address =
         reinterpret_cast<const std::byte*>(std::addressof(value));
     const auto* const member_address =
@@ -45,10 +45,8 @@ inline void Struct_Dirty_Storage_Hooks::on_write_access() noexcept {
     pending_whole_property_dirty = true;
 }
 
-template <typename Struct, Member_Value Member>
-void Struct_Dirty_Storage_Hooks::on_write_access(
-    const Struct& value,
-    Member Struct::* member) {
+template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner>
+void Struct_Dirty_Storage_Hooks::on_write_access(const Struct& value, Member Owner::* member) {
     const std::size_t key = property_dirty_key(value, member);
     for (Property_Dirty_Revision& property : property_revisions) {
         if (property.key != key) continue;
@@ -60,10 +58,8 @@ void Struct_Dirty_Storage_Hooks::on_write_access(
     Dirty_Storage_Hooks::on_write_access();
 }
 
-template <typename Struct, Member_Value Member>
-std::uint64_t Struct_Dirty_Storage_Hooks::property_dirty_revision(
-    const Struct& value,
-    Member Struct::* member) const noexcept {
+template <typename Struct, typename Owner, Member_Value Member> requires std::derived_from<Struct, Owner>
+std::uint64_t Struct_Dirty_Storage_Hooks::property_dirty_revision(const Struct& value, Member Owner::* member) const noexcept {
     const std::size_t key = property_dirty_key(value, member);
     for (const Property_Dirty_Revision& property : property_revisions) {
         if (property.key != key) continue;
diff --git a/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp b/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp
index 5ef5439..ce5e465 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp
+++ b/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp
@@ -7,14 +7,14 @@ template <Exchange_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks>
 struct Export_Struct {
     template <Value_Reader<Val> Fn>
     void get(Fn&& fn) const;
-    template <Copyable_Member Member>
-    auto get(Member Val::* member) const -> std::remove_cv_t<Member>;
+    template <typename Owner, Copyable_Member Member> requires std::derived_from<Val, Owner>
+    auto get(Member Owner::* member) const -> std::remove_cv_t<Member>;
     struct Internal final : Storage_Hooks {
         /* 仅同一内部线程可调用；可写借用会记录本轮修改，且不得跨越 advance。 */
         Val* use();
         void advance();
         template <Value_Writer<Val> Fn> void builder_set(Fn&& fn);
-        template <Member_Value Member, Assignable_To<Member&> T> void builder_set(Member Val::* member, T&& value);
+        template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner> void builder_set(Member Owner::* member, T&& value);
         Val internal_read{};               /* 内部线程生产面。 */
         Val external_read{};               /* 外部线程稳定读面。 */
         mutable std::mutex exchange_mutex; /* 仅保护发布复制与外部读取。 */
@@ -25,18 +25,18 @@ template <Exchange_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks>
 struct Import_Struct {
     template <Value_Writer<Val> Fn>
     void set(Fn&& fn);
-    template <Member_Value Member, Assignable_To<Member&> T>
-    void set(Member Val::* member, T&& value);
+    template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner>
+    void set(Member Owner::* member, T&& value);
     template <Value_Reader<Val> Fn>
     void get(Fn&& fn) const;
-    template <Copyable_Member Member>
-    auto get(Member Val::* member) const -> std::remove_cv_t<Member>;
+    template <typename Owner, Copyable_Member Member> requires std::derived_from<Val, Owner>
+    auto get(Member Owner::* member) const -> std::remove_cv_t<Member>;
     struct Internal final : Storage_Hooks {
         /* 仅同一内部线程可调用；返回借用不得保存到下一次 advance。 */
         Val* use();
         void advance();
         template <Value_Writer<Val> Fn> void builder_set(Fn&& fn);
-        template <Member_Value Member, Assignable_To<Member&> T> void builder_set(Member Val::* member, T&& value);
+        template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner> void builder_set(Member Owner::* member, T&& value);
         Val internal_read{};               /* 内部线程稳定读面。 */
         Val external_write{};              /* 外部线程编辑面。 */
         mutable std::mutex exchange_mutex; /* 仅保护外部编辑与内部推进复制。 */
diff --git a/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp b/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp
index 677f0c9..f896739 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp
+++ b/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp
@@ -9,8 +9,8 @@ void Export_Struct<Val, Storage_Hooks>::get(Fn&& fn) const {
     std::invoke(std::forward<Fn>(fn), std::as_const(internal.external_read));
 }
 template <Exchange_Value Val, typename Storage_Hooks>
-template <Copyable_Member Member>
-auto Export_Struct<Val, Storage_Hooks>::get(Member Val::* member) const -> std::remove_cv_t<Member> {
+template <typename Owner, Copyable_Member Member> requires std::derived_from<Val, Owner>
+auto Export_Struct<Val, Storage_Hooks>::get(Member Owner::* member) const -> std::remove_cv_t<Member> {
     std::lock_guard lock(internal.exchange_mutex);
     return internal.external_read.*member;
 }
@@ -39,8 +39,8 @@ void Export_Struct<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
     external_read = internal_read;
 }
 template <Exchange_Value Val, typename Storage_Hooks>
-template <Member_Value Member, Assignable_To<Member&> T>
-void Export_Struct<Val, Storage_Hooks>::Internal::builder_set(Member Val::* member, T&& value) {
+template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner>
+void Export_Struct<Val, Storage_Hooks>::Internal::builder_set(Member Owner::* member, T&& value) {
     internal_read.*member = std::forward<T>(value);
     external_read = internal_read;
 }
@@ -54,8 +54,8 @@ void Import_Struct<Val, Storage_Hooks>::set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), internal.external_write);
 }
 template <Exchange_Value Val, typename Storage_Hooks>
-template <Member_Value Member, Assignable_To<Member&> T>
-void Import_Struct<Val, Storage_Hooks>::set(Member Val::* member, T&& value) {
+template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner>
+void Import_Struct<Val, Storage_Hooks>::set(Member Owner::* member, T&& value) {
     std::lock_guard lock(internal.exchange_mutex);
     if constexpr (requires { internal.on_write_access(internal.external_write, member); }) {
         internal.on_write_access(internal.external_write, member);
@@ -71,8 +71,8 @@ void Import_Struct<Val, Storage_Hooks>::get(Fn&& fn) const {
     std::invoke(std::forward<Fn>(fn), std::as_const(internal.external_write));
 }
 template <Exchange_Value Val, typename Storage_Hooks>
-template <Copyable_Member Member>
-auto Import_Struct<Val, Storage_Hooks>::get(Member Val::* member) const -> std::remove_cv_t<Member> {
+template <typename Owner, Copyable_Member Member> requires std::derived_from<Val, Owner>
+auto Import_Struct<Val, Storage_Hooks>::get(Member Owner::* member) const -> std::remove_cv_t<Member> {
     std::lock_guard lock(internal.exchange_mutex);
     return internal.external_write.*member;
 }
@@ -98,8 +98,8 @@ void Import_Struct<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
     external_write = internal_read;
 }
 template <Exchange_Value Val, typename Storage_Hooks>
-template <Member_Value Member, Assignable_To<Member&> T>
-void Import_Struct<Val, Storage_Hooks>::Internal::builder_set(Member Val::* member, T&& value) {
+template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner>
+void Import_Struct<Val, Storage_Hooks>::Internal::builder_set(Member Owner::* member, T&& value) {
     internal_read.*member = std::forward<T>(value);
     external_write = internal_read;
 }
diff --git a/kernel/kernel/include/concurrent/design.md b/kernel/kernel/include/concurrent/design.md
index c43c1f8..be92367 100644
--- a/kernel/kernel/include/concurrent/design.md
+++ b/kernel/kernel/include/concurrent/design.md
@@ -33,6 +33,7 @@
 - 前置和后置钩子接收同一组交换前角色裸指针；指针是非拥有借用，只在当前 `advance()` 内有效。
 - List 只有整体 revision；Struct 同时提供整体 revision 和属性 revision。
 - `set(member, value)` 只标记对应属性，回调写入和内部 `use()` 无法识别具体成员，按整对象写入处理并使全部属性 dirty。
+- Struct 的成员接口接受当前值类型及其公开基类的成员指针，Model 值继承链可以用声明该属性的原始成员指针进行 Builder 初始化、外部 set/get 和 dirty 查询。
 - 一次 `advance()` 最多推进一次整体 revision；属性只记录自己最近一次发布对应的整体 revision，不维护第二套计数器。
 - `Dirty_Binder` 消费一个或多个 Storage 的整体 dirty；`Property_Dirty_Binder` 消费同一 Struct Storage 的一个或多个固定成员。
 - revision 是普通 `std::uint64_t`；binder、写入和来源推进遵守同一内部线程模型约定。
diff --git a/kernel/kernel/include/model/Model.hpp b/kernel/kernel/include/model/Model.hpp
index b4ee6de..7e51927 100644
--- a/kernel/kernel/include/model/Model.hpp
+++ b/kernel/kernel/include/model/Model.hpp
@@ -1,23 +1,41 @@
 #pragma once
 #include "../concurrent/Concurrent_Storage_with_dirty.hpp"
 #include "../concurrent/storage/Tagged_Storage.hpp"
+#include "../Error_handling_specification/Failure_Policy.hpp"
 #include "../global.hpp"
 #include <memory>
 #include <proxy/proxy.h>
+#include <stdexcept>
 #include <type_traits>
 #include <utility>
 namespace aethera {
 namespace detail {
-template <typename Model_Pointer> struct Model_Private_Pointer {
-    using element_type = std::remove_reference_t<decltype(*std::declval<Model_Pointer&>()->d)>;
-    decltype(auto) operator*() const noexcept { return *model->d; }
-    Model_Pointer model; /* Owns or borrows the complete Model; dereference exposes its unique Private. */
-};
 template <typename... Types> struct Model_Type_List {};
+template <typename List, typename... Types> struct Append_Model_Types;
 template <typename List, typename... Registrations> struct Append_Model_Registrations;
 template <typename Tag, typename Layer, typename = void> struct Model_Tag_Value;
 template <typename Tag, typename List> struct Model_Registration;
 template <typename Tag, typename Layer, typename List> struct Model_Value;
+template <typename Endpoint> struct Model_State;
+struct Model_Instance;
+struct Model_Private_Access_Root {
+    Model_Instance* instance{}; /* 非拥有借用；Builder 物化 endpoint 后绑定到外层 Root。 */
+};
+template <typename Endpoint, typename Base_Private> struct Model_Private_Base;
+template <typename Endpoint> struct Model_Private_Handle {
+    explicit Model_Private_Handle(Model_Instance* value) noexcept : instance(value) {}
+    decltype(auto) operator*() const noexcept;
+    auto operator->() const noexcept;
+    template <typename Active_Endpoint> void bind() noexcept;
+    Model_Instance* instance{}; /* 非拥有借用；与外层模型的 Root 子对象同寿命。 */
+private:
+    void* (*private_view)(void*){}; /* 把唯一实际 Private 调整为本层 Private 基类视图。 */
+};
+template <typename Model_Pointer> struct Model_Private_Pointer {
+    using element_type = std::remove_reference_t<decltype(*std::declval<Model_Pointer&>()->d)>;
+    decltype(auto) operator*() const noexcept { return *model->d; }
+    Model_Pointer model; /* 按 Model_Pointer 的指针种类拥有或借用完整模型。 */
+};
 template <typename Value, typename Fn> requires Value_Writer<Fn, Value> void initialize_model_value(Value& target, Fn&& fn);
 template <typename Value, typename Owner, typename Member, typename T> requires std::derived_from<Value, Owner> && std::assignable_from<Member&, T> void initialize_model_value(Value& target, Member Owner::* member, T&& value);
 template <typename Value, typename T> requires std::assignable_from<Value&, T> void initialize_model_value(Value& target, T&& value);
@@ -27,8 +45,31 @@ concept Model_Value_Initializer = requires(Value& value, Args&&... args) {
 };
 template <typename Tag, typename Layer> using Registered_Model_Value = typename Model_Value<Tag, Layer, typename Layer::Storage_Registrations>::Type;
 template <typename Tag, typename Layer> using Registered_Model_Storage = typename Model_Registration<Tag, typename Layer::Storage_Registrations>::Type::template Storage<Registered_Model_Value<Tag, Layer>>;
-template <typename Self, typename Base_Private, typename Registrations> struct Model_Private_Base;
-template <typename Self, typename Base_Private> struct Deferred_Model_Private_Base;
+template <typename Endpoint, typename Registrations> struct Model_Storage_Set;
+struct Model_State_Deleter {
+    void operator()(void* value) const noexcept { if (destroy) destroy(value); }
+    void (*destroy)(void*){}; /* 与类型擦除 endpoint state 匹配的析构入口。 */
+};
+struct Model_Instance {
+    Model_Instance();
+    ~Model_Instance();
+    Model_Instance(const Model_Instance&) = delete;
+    Model_Instance& operator=(const Model_Instance&) = delete;
+    Model_Instance(Model_Instance&&) = delete;
+    Model_Instance& operator=(Model_Instance&&) = delete;
+    template <typename Endpoint, typename... Args> void initialize_endpoint(Args&&... args);
+    template <typename Endpoint> Model_State<Endpoint>& state() noexcept;
+    [[nodiscard]] bool initialized() const noexcept;
+private:
+    template <typename>
+    friend struct Model_Private_Handle;
+    std::unique_ptr<void, Model_State_Deleter> state_owner; /* 唯一拥有当前实际 endpoint 的 Private 与完整 Storage Set。 */
+};
+template <typename Self> struct Model_Builder_Instance {
+    template <typename... Args> void initialize_model(Args&&... args);
+    Self& model();
+    std::unique_ptr<Self> ret; /* 构建期间唯一拥有尚未发布的最终模型。 */
+};
 template <template <typename...> typename Concurrent_Storage, typename Tag, typename Layer, typename... Args>
 concept Builder_Settable_Model_Value = std::same_as<Concurrent_Storage<Registered_Model_Value<Tag, Layer>>, Registered_Model_Storage<Tag, Layer>> && Internal_Storage<Registered_Model_Storage<Tag, Layer>> && Model_Value_Initializer<Registered_Model_Value<Tag, Layer>, Args...>;
 template <template <typename...> typename Concurrent_Storage, typename Tag, typename Layer, typename... Args>
@@ -43,45 +84,48 @@ struct Prop_Tag {
 struct State_Tag {
     template <typename Layer> using Value = typename Layer::State;
 };
-/* 在定义层基类上登记 Tag 与 Concurrent Storage；Fixed_Value 仅供 Tag 不映射嵌套类型的复合存储使用。 */
+/* 在定义层基类上注册 Tag 与 Concurrent Storage；Fixed_Value 仅供 Tag 不映射嵌套类型的复合存储使用。 */
 template <typename Tag, template <typename...> typename Concurrent_Storage, typename Fixed_Value = void> struct Storage_Registration {
     using Tag_Type = Tag;
     template <typename Stored_Value> using Storage = Concurrent_Storage<Stored_Value>;
     template <typename Layer> using Value = std::conditional_t<std::is_void_v<Fixed_Value>, typename detail::Model_Tag_Value<Tag, Layer>::Type, Fixed_Value>;
 };
-struct Root {
+struct Root : detail::Model_Instance {
+    using Model_Layers = detail::Model_Type_List<>;
     using Storage_Registrations = detail::Model_Type_List<>;
     struct Private {};
     struct Builder {};
+protected:
+    Root() = default;
+    ~Root() = default;
 };
 /*
- * 在类型基类上扩展 Tag/Concurrent 注册链；Prev<Tag> 给类内值类型接续上一层，不创建运行时 d。
+ * 每层 Def 都携带当前层 Self；注册只形成持久定义链，Builder 使用完整 endpoint 一次物化唯一状态。
+ * 当前层作为 endpoint 时构造自己的状态；被继续继承时只贡献定义与 Private 基类，不构造当前层状态。
  */
-template <typename Base, typename... Registrations> struct Model_Layer : Base {
+template <typename Self, typename Base, typename... Registrations> struct Def : Base {
+    using Model_Self = Self;
+    using Model_Base = Base;
+    using Model_Def = Def;
+    using Model_Layers = typename detail::Append_Model_Types<typename Base::Model_Layers, Self>::Type;
     using Storage_Registrations = typename detail::Append_Model_Registrations<typename Base::Storage_Registrations, Registrations...>::Type;
     template <typename Tag> using Prev = typename detail::Model_Value<Tag, Base, Storage_Registrations>::Type;
-    using Prev_Private = typename Base::Private;
+    using Prev_Private = detail::Model_Private_Base<Self, typename Base::Private>;
     using Prev_Builder = typename Base::Builder;
-};
-/* 最终定义层在 Self 完整后，根据继承链上的注册表构造唯一 Private 与全部 Tagged Storage。 */
-template <typename Self, typename Base, typename... Registrations> struct Def : Model_Layer<Base, Registrations...> {
-    using Layer = Model_Layer<Base, Registrations...>;
-    using Storage_Registrations = typename Layer::Storage_Registrations;
-    using Prev_Private = detail::Deferred_Model_Private_Base<Self, typename Base::Private>;
-    struct Private;
-    struct Builder : Base::Builder {
-        template <typename... Args> explicit Builder(Args&&... args);
+    struct Builder : detail::Model_Builder_Instance<Self> {
+        Builder() = default;
+        template <typename First, typename... Rest> explicit Builder(First&& first, Rest&&... rest);
         std::unique_ptr<Self> build();
         template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Builder_Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
         Builder& set(Args&&... args);
-        std::unique_ptr<Self> ret; /* 构建期间唯一拥有尚未发布的对象。 */
     };
+    Def();
     template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
     Self& set(Args&&... args);
     template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Gettable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
     const Self& get(Args&&... args) const;
-    template <typename... Args> explicit Def(Args&&... args);
-    std::unique_ptr<Private> d; /* 唯一拥有最终 Private 和完整 Tagged Storage 集。 */
+    [[nodiscard]] bool model_initialized() const noexcept { return this->initialized(); }
+    detail::Model_Private_Handle<Self> d; /* 非拥有类型化视图；实际状态始终由公共 Root 唯一拥有。 */
 };
 
 template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<Model*>, Facade>
@@ -91,12 +135,12 @@ template <typename Facade, typename Model> requires pro::proxiable<detail::Model
 proxy<Facade> model_proxy(std::unique_ptr<Model> model) { if (!model) return {}; return proxy<Facade>{detail::Model_Private_Pointer<std::unique_ptr<Model>>{std::move(model)}}; }
 
 template <typename Facade, typename Model, typename... Args> requires pro::proxiable<detail::Model_Private_Pointer<std::unique_ptr<Model>>, Facade>
-proxy<Facade> make_model_proxy(Args&&... args) { return model_proxy<Facade>(std::make_unique<Model>(std::forward<Args>(args)...)); }
+proxy<Facade> make_model_proxy(Args&&... args) { typename Model::Builder builder(std::forward<Args>(args)...); return model_proxy<Facade>(builder.build()); }
 
 template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<std::shared_ptr<Model>>, Facade>
 proxy<Facade> model_proxy_shared(std::shared_ptr<Model> model) { if (!model) return {}; return proxy<Facade>{detail::Model_Private_Pointer<std::shared_ptr<Model>>{std::move(model)}}; }
 
 template <typename Facade, typename Model, typename... Args> requires pro::proxiable<detail::Model_Private_Pointer<std::shared_ptr<Model>>, Facade>
-proxy<Facade> make_model_proxy_shared(Args&&... args) { return model_proxy_shared<Facade>(std::make_shared<Model>(std::forward<Args>(args)...)); }
+proxy<Facade> make_model_proxy_shared(Args&&... args) { typename Model::Builder builder(std::forward<Args>(args)...); std::shared_ptr<Model> model{builder.build()}; return model_proxy_shared<Facade>(std::move(model)); }
 } // namespace aethera
 #include "Model.ipp"
diff --git a/kernel/kernel/include/model/Model.ipp b/kernel/kernel/include/model/Model.ipp
index 1268950..17a33e7 100644
--- a/kernel/kernel/include/model/Model.ipp
+++ b/kernel/kernel/include/model/Model.ipp
@@ -1,142 +1,148 @@
 #pragma once
-
 #include <functional>
 #include <utility>
-
 namespace aethera::detail {
-template <typename Value, typename Fn>
-    requires Value_Writer<Fn, Value>
-void initialize_model_value(Value& target, Fn&& fn) {
-    std::invoke(std::forward<Fn>(fn), target);
-}
+template <typename Value, typename Fn> requires Value_Writer<Fn, Value>
+void initialize_model_value(Value& target, Fn&& fn) { std::invoke(std::forward<Fn>(fn), target); }
 
-template <typename Value, typename Owner, typename Member, typename T>
-    requires std::derived_from<Value, Owner> && std::assignable_from<Member&, T>
-void initialize_model_value(Value& target, Member Owner::* member, T&& value) {
-    target.*member = std::forward<T>(value);
-}
+template <typename Value, typename Owner, typename Member, typename T> requires std::derived_from<Value, Owner> && std::assignable_from<Member&, T>
+void initialize_model_value(Value& target, Member Owner::* member, T&& value) { target.*member = std::forward<T>(value); }
 
 template <typename Value, typename T> requires std::assignable_from<Value&, T>
-void initialize_model_value(Value& target, T&& value) {
-    target = std::forward<T>(value);
-}
+void initialize_model_value(Value& target, T&& value) { target = std::forward<T>(value); }
 
-template <typename List, typename... Registrations>
-struct Append_Model_Registrations;
+template <typename List, typename... Types> struct Append_Model_Types;
+template <typename... Existing, typename... Types>
+struct Append_Model_Types<Model_Type_List<Existing...>, Types...> { using Type = Model_Type_List<Existing..., Types...>; };
 
+template <typename List, typename... Registrations> struct Append_Model_Registrations;
 template <typename... Existing, typename... Registrations>
-struct Append_Model_Registrations<
-    Model_Type_List<Existing...>,
-    Registrations...> {
-    using Type = Model_Type_List<Existing..., Registrations...>;
-};
-
-template <typename Tag, typename Layer, typename>
-struct Model_Tag_Value {
-    using Type = Empty_Model_Value;
-};
+struct Append_Model_Registrations<Model_Type_List<Existing...>, Registrations...> { using Type = Model_Type_List<Existing..., Registrations...>; };
 
+template <typename Tag, typename Layer, typename> struct Model_Tag_Value { using Type = Empty_Model_Value; };
 template <typename Tag, typename Layer>
-struct Model_Tag_Value<Tag, Layer, std::void_t<typename Tag::template Value<Layer>>> {
-    using Type = typename Tag::template Value<Layer>;
-};
-
-template <typename List>
-struct Unique_Model_Tags;
-
-template <>
-struct Unique_Model_Tags<Model_Type_List<>> : std::true_type {};
+struct Model_Tag_Value<Tag, Layer, std::void_t<typename Tag::template Value<Layer>>> { using Type = typename Tag::template Value<Layer>; };
 
+template <typename List> struct Unique_Model_Tags;
+template <> struct Unique_Model_Tags<Model_Type_List<>> : std::true_type {};
 template <typename Registration, typename... Rest>
-struct Unique_Model_Tags<Model_Type_List<Registration, Rest...>> : std::bool_constant<
-                                                                       (!std::same_as<
-                                                                            typename Registration::Tag_Type,
-                                                                            typename Rest::Tag_Type> &&
-                                                                        ...) &&
-                                                                       Unique_Model_Tags<Model_Type_List<Rest...>>::value> {};
-
-template <typename Tag, typename List>
-struct Model_Registration;
+struct Unique_Model_Tags<Model_Type_List<Registration, Rest...>> : std::bool_constant<(!std::same_as<typename Registration::Tag_Type, typename Rest::Tag_Type> && ...) && Unique_Model_Tags<Model_Type_List<Rest...>>::value> {};
 
+template <typename Tag, typename List> struct Model_Registration;
 template <typename Tag, typename Registration, typename... Rest>
 struct Model_Registration<Tag, Model_Type_List<Registration, Rest...>> : Model_Registration<Tag, Model_Type_List<Rest...>> {};
-
 template <typename Tag, template <typename...> typename Concurrent_Storage, typename Fixed_Value, typename... Rest>
-struct Model_Registration<Tag, Model_Type_List<Storage_Registration<Tag, Concurrent_Storage, Fixed_Value>, Rest...>> {
-    using Type = Storage_Registration<Tag, Concurrent_Storage, Fixed_Value>;
-};
+struct Model_Registration<Tag, Model_Type_List<Storage_Registration<Tag, Concurrent_Storage, Fixed_Value>, Rest...>> { using Type = Storage_Registration<Tag, Concurrent_Storage, Fixed_Value>; };
 
-template <typename Tag, typename Layer, typename List>
-struct Model_Value {
+template <typename Tag, typename Layer, typename List> struct Model_Value {
     using Registration = typename Model_Registration<Tag, List>::Type;
     using Type = typename Registration::template Value<Layer>;
 };
 
-template <typename Self, typename Registration>
-struct Attached_Model_Storage {
+template <typename Endpoint, typename Registration> struct Attached_Model_Storage {
     using Tag = typename Registration::Tag_Type;
-    using Value = typename Registration::template Value<Self>;
+    using Value = typename Registration::template Value<Endpoint>;
     using Type = Tagged_Storage<Tag, typename Registration::template Storage<Value>>;
     static_assert(Concurrent_Storage<Type>);
 };
-
-template <typename Self, typename Registrations>
-struct Model_Storage_Set;
-
-template <typename Self, typename... Registrations>
-struct Model_Storage_Set<Self, Model_Type_List<Registrations...>> : Tagged_Storage_Set<
-                                                                        typename Attached_Model_Storage<Self, Registrations>::Type...> {};
-
-template <typename Self, typename Base_Private, typename Registrations>
-struct Model_Private_Base;
-
-template <typename Self, typename Base_Private, typename... Registrations>
-struct Model_Private_Base<Self, Base_Private, Model_Type_List<Registrations...>> : Base_Private, Model_Storage_Set<Self, Model_Type_List<Registrations...>> {
+template <typename Endpoint, typename Registrations> struct Model_Storage_Set;
+template <typename Endpoint, typename... Registrations>
+struct Model_Storage_Set<Endpoint, Model_Type_List<Registrations...>> : Tagged_Storage_Set<typename Attached_Model_Storage<Endpoint, Registrations>::Type...> {
     static_assert(Unique_Model_Tags<Model_Type_List<Registrations...>>::value, "each model storage tag can only be registered once");
 };
 
-template <typename Self, typename Base_Private>
-struct Deferred_Model_Private_Base : Model_Private_Base<Self, Base_Private, typename Self::Storage_Registrations> {};
+template <typename Endpoint, typename Base_Private>
+struct Model_Private_Base : Base_Private, virtual Model_Private_Access_Root {
+    template <typename Tag> auto& get() noexcept { return this->instance->template state<Endpoint>().template get<Tag>(); }
+    template <typename Tag> const auto& get() const noexcept { return this->instance->template state<Endpoint>().template get<Tag>(); }
+};
+
+template <typename Endpoint>
+struct Model_State : Model_Storage_Set<Endpoint, typename Endpoint::Storage_Registrations> {
+    template <typename... Args> explicit Model_State(Args&&... args) : private_data(std::forward<Args>(args)...) {}
+    typename Endpoint::Private private_data; /* 唯一实际 Private；内部包含完整的 Private 继承链。 */
+};
+
+template <typename Endpoint, typename Active_Endpoint>
+void bind_model_handle(Active_Endpoint& model) noexcept {
+    auto& definition = static_cast<typename Endpoint::Model_Def&>(model);
+    definition.d.template bind<Active_Endpoint>();
+}
+template <typename Active_Endpoint, typename... Endpoints>
+void bind_model_handles(Active_Endpoint& model, Model_Type_List<Endpoints...>) noexcept { (bind_model_handle<Endpoints>(model), ...); }
+
+inline Model_Instance::Model_Instance() : state_owner(nullptr, Model_State_Deleter{}) {}
+inline Model_Instance::~Model_Instance() = default;
+inline bool Model_Instance::initialized() const noexcept { return static_cast<bool>(state_owner); }
+
+template <typename Endpoint, typename... Args>
+void Model_Instance::initialize_endpoint(Args&&... args) {
+    if (state_owner) return;
+    auto state = std::make_unique<Model_State<Endpoint>>(std::forward<Args>(args)...);
+    static_cast<Model_Private_Access_Root&>(state->private_data).instance = this;
+    state_owner = std::unique_ptr<void, Model_State_Deleter>{state.release(), Model_State_Deleter{[](void* value) { delete static_cast<Model_State<Endpoint>*>(value); }}};
+    bind_model_handles(static_cast<Endpoint&>(*this), typename Endpoint::Model_Layers{});
+}
+
+template <typename Endpoint> Model_State<Endpoint>& Model_Instance::state() noexcept { return *static_cast<Model_State<Endpoint>*>(state_owner.get()); }
+
+template <typename Endpoint> template <typename Active_Endpoint>
+void Model_Private_Handle<Endpoint>::bind() noexcept {
+    private_view = [](void* state) -> void* {
+        auto& private_data = static_cast<Model_State<Active_Endpoint>*>(state)->private_data;
+        return static_cast<typename Endpoint::Private*>(std::addressof(private_data));
+    };
+}
+
+template <typename Endpoint> decltype(auto) Model_Private_Handle<Endpoint>::operator*() const noexcept { return *static_cast<typename Endpoint::Private*>(private_view(instance->state_owner.get())); }
+template <typename Endpoint> auto Model_Private_Handle<Endpoint>::operator->() const noexcept { return std::addressof(operator*()); }
+
+template <typename Self> template <typename... Args>
+void Model_Builder_Instance<Self>::initialize_model(Args&&... args) {
+    if (ret) return;
+    ret = std::make_unique<Self>();
+    static_cast<Model_Instance&>(*ret).template initialize_endpoint<Self>(std::forward<Args>(args)...);
+}
+template <typename Self> Self& Model_Builder_Instance<Self>::model() {
+    if (!ret) {
+        if constexpr (std::default_initializable<Self> && std::default_initializable<typename Self::Private>) initialize_model();
+        else Failure_Policy::handle_unknown_failure(std::make_exception_ptr(std::logic_error("model builder requires private constructor arguments")));
+    }
+    return *ret;
+}
 } // namespace aethera::detail
 
 namespace aethera {
 template <typename Self, typename Base, typename... Registrations>
-struct Def<Self, Base, Registrations...>::Private : Self::Private {
-    template <typename... Args>
-    explicit Private(Args&&... args) : Self::Private(std::forward<Args>(args)...) {}
-};
+Def<Self, Base, Registrations...>::Def() : d{static_cast<detail::Model_Instance*>(this)} {}
 
-template <typename Self, typename Base, typename... Registrations>
-template <typename... Args>
-Def<Self, Base, Registrations...>::Builder::Builder(Args&&... args) : ret(std::make_unique<Self>(std::forward<Args>(args)...)) {}
-
-template <typename Self, typename Base, typename... Registrations>
-template <typename... Args>
-Def<Self, Base, Registrations...>::Def(Args&&... args) : d(std::make_unique<Private>(std::forward<Args>(args)...)) {}
+template <typename Self, typename Base, typename... Registrations> template <typename First, typename... Rest>
+Def<Self, Base, Registrations...>::Builder::Builder(First&& first, Rest&&... rest) { this->initialize_model(std::forward<First>(first), std::forward<Rest>(rest)...); }
 
 template <typename Self, typename Base, typename... Registrations>
 std::unique_ptr<Self> Def<Self, Base, Registrations...>::Builder::build() {
-    return std::move(ret);
+    if (!this->ret) {
+        if constexpr (std::default_initializable<Self> && std::default_initializable<typename Self::Private>) this->initialize_model();
+        else Failure_Policy::handle_unknown_failure(std::make_exception_ptr(std::logic_error("model builder requires private constructor arguments")));
+    }
+    return std::move(this->ret);
 }
 
-template <typename Self, typename Base, typename... Registrations>
-template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Builder_Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
+template <typename Self, typename Base, typename... Registrations> template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Builder_Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
 typename Def<Self, Base, Registrations...>::Builder& Def<Self, Base, Registrations...>::Builder::set(Args&&... args) {
-    auto& storage = ret->d->template get<Tag>();
+    auto& storage = this->model().d->template get<Tag>();
     storage.internal.builder_set([&](auto& value) { detail::initialize_model_value(value, std::forward<Args>(args)...); });
     return *this;
 }
 
-template <typename Self, typename Base, typename... Registrations>
-template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
+template <typename Self, typename Base, typename... Registrations> template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Settable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
 Self& Def<Self, Base, Registrations...>::set(Args&&... args) {
     auto& storage = d->template get<Tag>();
     storage.set(std::forward<Args>(args)...);
     return static_cast<Self&>(*this);
 }
 
-template <typename Self, typename Base, typename... Registrations>
-template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Gettable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
+template <typename Self, typename Base, typename... Registrations> template <template <typename...> typename Concurrent_Storage, typename Tag, typename... Args> requires detail::Gettable_Model_Value<Concurrent_Storage, Tag, Self, Args...>
 const Self& Def<Self, Base, Registrations...>::get(Args&&... args) const {
     const auto& storage = d->template get<Tag>();
     storage.get(std::forward<Args>(args)...);
diff --git a/kernel/kernel/include/model/design.md b/kernel/kernel/include/model/design.md
index acc09c7..15975a8 100644
--- a/kernel/kernel/include/model/design.md
+++ b/kernel/kernel/include/model/design.md
@@ -1,9 +1,13 @@
 # Model 设计
 
-`Storage_Registration<Tag, Concurrent_Storage, Fixed_Value = void>` 在 `Model_Layer` 或最终 `Def` 的类型参数上登记 Tag 与 Concurrent Storage。通常由 Tag 的 `Value<Layer>` 映射最终嵌套值类型；复合存储不使用嵌套值继承链时才显式传入 `Fixed_Value`。
+`Storage_Registration<Tag, Concurrent_Storage, Fixed_Value = void>` 在任意 `Def<当前层, Base, ...>` 定义层登记 Tag 与 Concurrent Storage。通常由 Tag 的 `Value<Layer>` 映射当前 endpoint 的最终嵌套值类型；复合存储不使用嵌套值继承链时才显式传入 `Fixed_Value`。
 
-业务值类型定义在所属类内并继承 `Prev<Tag>`，因此派生层只增量定义自己的字段，最终值类型自然包含完整继承链。`Model_Layer` 只累计类型参数上的注册关系，不创建存储；最终 `Def::Private` 等完整 `Self` 可见后才根据注册表创建唯一的 `Tagged_Storage_Set`。同一 Tag 重复注册属于编译期错误。
+业务值类型定义在所属类内并继承 `Prev<Tag>`，因此派生层只增量定义自己的字段，最终值类型自然包含完整继承链。每层都是普通类并把自身传给 `Def`；Def 只累计注册定义，不构造该层运行状态。Builder 在完整 endpoint 构造后，才在公共 `Root` 中一次物化该 endpoint 的唯一 `Private + Tagged_Storage_Set`。当一层继续被继承时，它只贡献注册和 Private 基类，不会额外构造自己的 endpoint state。同一 Tag 重复注册属于编译期错误。
+
+每层 `d` 都是对 Root 唯一状态的非拥有类型化视图。最终层 `d` 返回最终 Private；将模型转换为某个基类后，该基类的 `d` 返回同一个最终 Private 对象中的对应 Private 基类子对象。Model 实体必须通过 Builder 或 `make_model_proxy` 物化；普通构造只建立定义层对象，不产生运行状态。
+
+存储的实际类型由当前 endpoint 决定，因此只有最终 Private 直接调用 `get<Tag>()`。继承进来的基类 Private 能力若需要状态，由最终 Private 取得存储并传入对应的基类值引用；基类能力本身不按基类 endpoint 类型重新取得存储。这样不会为了复用基类能力再建立第二份状态源。
 
 跨模块 facade 直接声明消费方所需的 Private 能力。`make_model_proxy`、`make_model_proxy_shared` 与 `model_proxy_view` 分别承载独占、共享和非拥有 Model 生命周期，同时把 proxy 解引用目标映射到该 Model 唯一的 `Private`；实体公开类不实现 facade 转发函数。
 
-Builder 使用 `set<Concurrent_Storage, Tag>(...)` 并且只进入 `internal.builder_set(...)`。最终模型使用外部 `set<Concurrent_Storage, Tag>(...)` 和 `get<Concurrent_Storage, Tag>(...)`。Tag 先定位注册项，再由注册项映射最终值类型并实例化对应存储；concept 同时拒绝没有注册的 Concurrent 和不具备所需能力的调用。
+Builder 使用 `set<Concurrent_Storage, Tag>(...)` 并且只进入 `internal.builder_set(...)`。最终模型使用外部 `set<Concurrent_Storage, Tag>(...)` 和 `get<Concurrent_Storage, Tag>(...)`。Tag 先定位注册项，再由注册项映射当前 endpoint 值类型并实例化对应存储；concept 同时拒绝没有注册的 Concurrent 和不具备所需能力的调用。
diff --git a/kernel/kernel/module/frame_policy/src/Frame_Policy.cpp b/kernel/kernel/module/frame_policy/src/Frame_Policy.cpp
index 23e625a..7eaf18e 100644
--- a/kernel/kernel/module/frame_policy/src/Frame_Policy.cpp
+++ b/kernel/kernel/module/frame_policy/src/Frame_Policy.cpp
@@ -1,119 +1,6 @@
 #include "Frame_Policy.hpp"
 #include "../rely_facade.h"
 #include "time_thread/export/export.h"
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-
 namespace aethera {
 proxy<frame_policy::Timer_Service> frame_policy::make_timer_service() { return time_thread::make_timer_service(); }
-namespace {
-auto capacity_fps(const Sliding_Statistics& statistics) noexcept -> std::optional<double> {
-    const double average = statistics.summary().average;
-    if (!std::isfinite(average) || average <= 0.0) {
-        return std::nullopt;
-    }
-    return 1'000'000'000.0 / average;
-}
-
-auto frame_interval(double frames_per_second) noexcept -> std::expected<std::chrono::nanoseconds, Frame_Policy::Configuration_Result> {
-    using Result = Frame_Policy::Configuration_Result;
-    if (!std::isfinite(frames_per_second) || frames_per_second <= 0.0) {
-        return std::unexpected(Result::invalid_user_frame_rate);
-    }
-    constexpr long double Nanoseconds_Per_Second = 1'000'000'000.0L;
-    const long double interval = Nanoseconds_Per_Second / static_cast<long double>(frames_per_second);
-    constexpr auto Maximum_Interval = static_cast<long double>(std::numeric_limits<std::chrono::nanoseconds::rep>::max());
-    if (!std::isfinite(interval) || interval > Maximum_Interval) {
-        return std::unexpected(Result::interval_out_of_range);
-    }
-    return std::chrono::nanoseconds{static_cast<std::chrono::nanoseconds::rep>(std::max(1.0L, std::ceil(interval)))};
-}
-} // namespace
-
-Frame_Policy::Private::Active_Statistics::Active_Statistics(std::size_t window_size) : window_size(window_size), render(window_size), send(window_size), end_to_end(window_size) {}
-
-auto Frame_Policy::Private::begin_run(const Prop& properties, State& state) -> std::expected<std::chrono::nanoseconds, Configuration_Result> {
-    state = {};
-    statistics.reset();
-    return refresh_run(properties, state);
-}
-
-auto Frame_Policy::Private::refresh_run(const Prop& properties, State& state) -> std::expected<std::chrono::nanoseconds, Configuration_Result> {
-    if (properties.user_frames_per_second && (!std::isfinite(*properties.user_frames_per_second) || *properties.user_frames_per_second <= 0.0)) {
-        state.configuration_error = Configuration_Result::invalid_user_frame_rate;
-        return std::unexpected(*state.configuration_error);
-    }
-    const bool timing_required = properties.statistics_enabled || properties.render_rate_limit_enabled || properties.send_rate_limit_enabled;
-    if (timing_required && properties.statistics_window_size == 0) {
-        state.configuration_error = Configuration_Result::invalid_statistics_window;
-        return std::unexpected(*state.configuration_error);
-    }
-    synchronize_statistics(properties, state);
-    update_derived_state(properties, state);
-    const auto interval = frame_interval(state.effective_frames_per_second);
-    if (!interval) {
-        state.configuration_error = interval.error();
-        return std::unexpected(interval.error());
-    }
-    state.configuration_error.reset();
-    return interval;
-}
-
-void Frame_Policy::Private::record_timer_tick(bool dropped, State& state) {
-    ++state.timer_ticks;
-    if (dropped) {
-        ++state.dropped_timer_ticks;
-    }
-}
-
-void Frame_Policy::Private::record_render(std::chrono::nanoseconds duration, const Prop& properties, State& state) {
-    if (statistics) {
-        statistics->render.add(static_cast<double>(duration.count()));
-    }
-    update_derived_state(properties, state);
-}
-
-void Frame_Policy::Private::record_send(std::chrono::nanoseconds send_duration, std::chrono::nanoseconds end_to_end_duration, const Prop& properties, State& state) {
-    if (statistics) {
-        statistics->send.add(static_cast<double>(send_duration.count()));
-        statistics->end_to_end.add(static_cast<double>(end_to_end_duration.count()));
-    }
-    ++state.completed_frames;
-    update_derived_state(properties, state);
-}
-
-void Frame_Policy::Private::synchronize_statistics(const Prop& properties, State& state) {
-    const bool timing_required = properties.statistics_enabled || properties.render_rate_limit_enabled || properties.send_rate_limit_enabled;
-    if (!timing_required) {
-        statistics.reset();
-    } else if (!statistics || statistics->window_size != properties.statistics_window_size) {
-        statistics.emplace(properties.statistics_window_size);
-    }
-    if (!statistics || !properties.statistics_enabled) {
-        state.render_time_ns = {};
-        state.send_time_ns = {};
-        state.end_to_end_time_ns = {};
-    }
-}
-
-void Frame_Policy::Private::update_derived_state(const Prop& properties, State& state) const noexcept {
-    double effective = properties.user_frames_per_second.value_or(Default_Frames_Per_Second);
-    bool has_limit = properties.user_frames_per_second.has_value();
-    state.render_capacity_fps = properties.render_rate_limit_enabled && statistics ? capacity_fps(statistics->render) : std::nullopt;
-    state.send_capacity_fps = properties.send_rate_limit_enabled && statistics ? capacity_fps(statistics->send) : std::nullopt;
-    if (state.render_capacity_fps) {
-        effective = has_limit ? std::min(effective, *state.render_capacity_fps) : *state.render_capacity_fps;
-        has_limit = true;
-    }
-    if (state.send_capacity_fps) {
-        effective = has_limit ? std::min(effective, *state.send_capacity_fps) : *state.send_capacity_fps;
-        has_limit = true;
-    }
-    state.effective_frames_per_second = has_limit ? effective : Default_Frames_Per_Second;
-    state.render_time_ns = statistics && properties.statistics_enabled ? statistics->render.summary() : Statistics_Summary{};
-    state.send_time_ns = statistics && properties.statistics_enabled ? statistics->send.summary() : Statistics_Summary{};
-    state.end_to_end_time_ns = statistics && properties.statistics_enabled ? statistics->end_to_end.summary() : Statistics_Summary{};
-}
 } // namespace aethera
diff --git a/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp b/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
index 0dd9a8c..6a64600 100644
--- a/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
+++ b/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
@@ -10,7 +10,7 @@
 #include <expected>
 #include <optional>
 namespace aethera {
-struct Frame_Policy : Model_Layer<Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
+struct Frame_Policy : Def<Frame_Policy, Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
     using Configuration_Result = Frame_Policy_Configuration_Result;
     static constexpr double Default_Frames_Per_Second{30.0};
     struct Prop : Prev<Prop_Tag> {
diff --git a/kernel/kernel/module/frame_policy/src/Frame_Policy.ipp b/kernel/kernel/module/frame_policy/src/Frame_Policy.ipp
index ef42430..b8ec129 100644
--- a/kernel/kernel/module/frame_policy/src/Frame_Policy.ipp
+++ b/kernel/kernel/module/frame_policy/src/Frame_Policy.ipp
@@ -1,4 +1,7 @@
 #pragma once
+#include <algorithm>
+#include <cmath>
+#include <limits>
 
 namespace aethera {
 struct Frame_Policy::Private : Prev_Private {
@@ -23,4 +26,99 @@ private:
 
     std::optional<Active_Statistics> statistics; /* 存在即表示本次运行需要耗时窗口。 */
 };
+
+namespace detail {
+inline auto frame_policy_capacity_fps(const Sliding_Statistics& statistics) noexcept -> std::optional<double> {
+    const double average = statistics.summary().average;
+    if (!std::isfinite(average) || average <= 0.0) return std::nullopt;
+    return 1'000'000'000.0 / average;
+}
+template <typename Result>
+auto frame_policy_interval(double frames_per_second) noexcept -> std::expected<std::chrono::nanoseconds, Result> {
+    if (!std::isfinite(frames_per_second) || frames_per_second <= 0.0) return std::unexpected(Result::invalid_user_frame_rate);
+    constexpr long double Nanoseconds_Per_Second = 1'000'000'000.0L;
+    const long double interval = Nanoseconds_Per_Second / static_cast<long double>(frames_per_second);
+    constexpr auto Maximum_Interval = static_cast<long double>(std::numeric_limits<std::chrono::nanoseconds::rep>::max());
+    if (!std::isfinite(interval) || interval > Maximum_Interval) return std::unexpected(Result::interval_out_of_range);
+    return std::chrono::nanoseconds{static_cast<std::chrono::nanoseconds::rep>(std::max(1.0L, std::ceil(interval)))};
+}
+} // namespace detail
+
+inline Frame_Policy::Private::Active_Statistics::Active_Statistics(std::size_t window_size) : window_size(window_size), render(window_size), send(window_size), end_to_end(window_size) {}
+
+inline auto Frame_Policy::Private::begin_run(const Prop& properties, State& state) -> std::expected<std::chrono::nanoseconds, Configuration_Result> {
+    state = {};
+    statistics.reset();
+    return refresh_run(properties, state);
+}
+
+inline auto Frame_Policy::Private::refresh_run(const Prop& properties, State& state) -> std::expected<std::chrono::nanoseconds, Configuration_Result> {
+    if (properties.user_frames_per_second && (!std::isfinite(*properties.user_frames_per_second) || *properties.user_frames_per_second <= 0.0)) {
+        state.configuration_error = Configuration_Result::invalid_user_frame_rate;
+        return std::unexpected(*state.configuration_error);
+    }
+    const bool timing_required = properties.statistics_enabled || properties.render_rate_limit_enabled || properties.send_rate_limit_enabled;
+    if (timing_required && properties.statistics_window_size == 0) {
+        state.configuration_error = Configuration_Result::invalid_statistics_window;
+        return std::unexpected(*state.configuration_error);
+    }
+    synchronize_statistics(properties, state);
+    update_derived_state(properties, state);
+    const auto interval = detail::frame_policy_interval<Configuration_Result>(state.effective_frames_per_second);
+    if (!interval) {
+        state.configuration_error = interval.error();
+        return std::unexpected(interval.error());
+    }
+    state.configuration_error.reset();
+    return interval;
+}
+
+inline void Frame_Policy::Private::record_timer_tick(bool dropped, State& state) {
+    ++state.timer_ticks;
+    if (dropped) ++state.dropped_timer_ticks;
+}
+
+inline void Frame_Policy::Private::record_render(std::chrono::nanoseconds duration, const Prop& properties, State& state) {
+    if (statistics) statistics->render.add(static_cast<double>(duration.count()));
+    update_derived_state(properties, state);
+}
+
+inline void Frame_Policy::Private::record_send(std::chrono::nanoseconds send_duration, std::chrono::nanoseconds end_to_end_duration, const Prop& properties, State& state) {
+    if (statistics) {
+        statistics->send.add(static_cast<double>(send_duration.count()));
+        statistics->end_to_end.add(static_cast<double>(end_to_end_duration.count()));
+    }
+    ++state.completed_frames;
+    update_derived_state(properties, state);
+}
+
+inline void Frame_Policy::Private::synchronize_statistics(const Prop& properties, State& state) {
+    const bool timing_required = properties.statistics_enabled || properties.render_rate_limit_enabled || properties.send_rate_limit_enabled;
+    if (!timing_required) statistics.reset();
+    else if (!statistics || statistics->window_size != properties.statistics_window_size) statistics.emplace(properties.statistics_window_size);
+    if (!statistics || !properties.statistics_enabled) {
+        state.render_time_ns = {};
+        state.send_time_ns = {};
+        state.end_to_end_time_ns = {};
+    }
+}
+
+inline void Frame_Policy::Private::update_derived_state(const Prop& properties, State& state) const noexcept {
+    double effective = properties.user_frames_per_second.value_or(Default_Frames_Per_Second);
+    bool has_limit = properties.user_frames_per_second.has_value();
+    state.render_capacity_fps = properties.render_rate_limit_enabled && statistics ? detail::frame_policy_capacity_fps(statistics->render) : std::nullopt;
+    state.send_capacity_fps = properties.send_rate_limit_enabled && statistics ? detail::frame_policy_capacity_fps(statistics->send) : std::nullopt;
+    if (state.render_capacity_fps) {
+        effective = has_limit ? std::min(effective, *state.render_capacity_fps) : *state.render_capacity_fps;
+        has_limit = true;
+    }
+    if (state.send_capacity_fps) {
+        effective = has_limit ? std::min(effective, *state.send_capacity_fps) : *state.send_capacity_fps;
+        has_limit = true;
+    }
+    state.effective_frames_per_second = has_limit ? effective : Default_Frames_Per_Second;
+    state.render_time_ns = statistics && properties.statistics_enabled ? statistics->render.summary() : Statistics_Summary{};
+    state.send_time_ns = statistics && properties.statistics_enabled ? statistics->send.summary() : Statistics_Summary{};
+    state.end_to_end_time_ns = statistics && properties.statistics_enabled ? statistics->end_to_end.summary() : Statistics_Summary{};
+}
 } // namespace aethera
diff --git a/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
index dfb2493..c4ffe68 100644
--- a/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
+++ b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
@@ -10,8 +10,9 @@ auto positive_duration(std::chrono::steady_clock::duration duration) noexcept ->
     return std::max(std::chrono::nanoseconds{1}, std::chrono::duration_cast<std::chrono::nanoseconds>(duration));
 }
 } // namespace
-Throttled_Latest_only::Throttled_Latest_only(proxy<frame_policy::Timer_Service> timer_service, proxy<frame_policy::Scene> scene, proxy<frame_policy::Sink> sink) : Def(std::move(timer_service), std::move(scene), std::move(sink)) {}
+Throttled_Latest_only::Throttled_Latest_only() = default;
 Throttled_Latest_only::~Throttled_Latest_only() noexcept {
+    if (!model_initialized()) return;
     if (!d->destructible()) {
         std::terminate();
     }
diff --git a/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.hpp b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.hpp
index 77b3805..0186fc2 100644
--- a/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.hpp
+++ b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.hpp
@@ -15,7 +15,7 @@ struct Throttled_Latest_only : Def<Throttled_Latest_only, Frame_Policy> {
     using Stop_Result = Throttled_Latest_Only_Stop_Result;
     using Stop_Completion = std::function<void()>;
     struct Private;
-    Throttled_Latest_only(proxy<frame_policy::Timer_Service> timer_service, proxy<frame_policy::Scene> scene, proxy<frame_policy::Sink> sink);
+    Throttled_Latest_only();
     ~Throttled_Latest_only() noexcept;
     auto start() -> std::expected<void, Start_Result>;
     auto stop(Stop_Completion completion) -> std::expected<void, Stop_Result>;
diff --git a/kernel/kernel/module/frame_policy/test/Throttled_Latest_Only_Tests.cpp b/kernel/kernel/module/frame_policy/test/Throttled_Latest_Only_Tests.cpp
index 64d9566..1ee03b3 100644
--- a/kernel/kernel/module/frame_policy/test/Throttled_Latest_Only_Tests.cpp
+++ b/kernel/kernel/module/frame_policy/test/Throttled_Latest_Only_Tests.cpp
@@ -93,7 +93,6 @@ struct Test_Timer_Service : aethera::Def<Test_Timer_Service, aethera::Root> {
     static constexpr aethera::frame_policy::Timer_Id Timer_Id{7};
     std::shared_ptr<Frame_Policy_Test_Control> control; /* 服务调用记录的共享所有权。 */
     };
-    explicit Test_Timer_Service(std::shared_ptr<Frame_Policy_Test_Control> control) : Def(std::move(control)) {}
 };
 
 struct Test_Frame {
@@ -117,7 +116,6 @@ struct Test_Frame {
 
 struct Test_Scene : aethera::Def<Test_Scene, aethera::Root> {
     struct Private;
-    explicit Test_Scene(std::shared_ptr<Frame_Policy_Test_Control> control) : Def(std::move(control)) {}
 };
 
 struct Test_Scene::Private : Prev_Private {
@@ -145,7 +143,6 @@ struct Test_Scene::Private : Prev_Private {
 
 struct Test_Sink : aethera::Def<Test_Sink, aethera::Root> {
     struct Private;
-    explicit Test_Sink(std::shared_ptr<Frame_Policy_Test_Control> control) : Def(std::move(control)) {}
 };
 
 struct Test_Sink::Private : Prev_Private {
@@ -303,7 +300,7 @@ TEST(Throttled_Latest_Only, Advances_Properties_And_Recovers_From_Invalid_Dynami
     EXPECT_EQ(control->render_calls, render_calls_before_invalid_tick);
     policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         ASSERT_TRUE(state.configuration_error);
-        EXPECT_EQ(*state.configuration_error, aethera::Frame_Policy::Configuration_Result::invalid_user_frame_rate);
+        EXPECT_EQ(*state.configuration_error, aethera::Throttled_Latest_only::Configuration_Result::invalid_user_frame_rate);
     });
 
     policy->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{20.0});
diff --git a/kernel/kernel/module/renderable/src/renderable.hpp b/kernel/kernel/module/renderable/src/renderable.hpp
index 5c42b3d..3c46572 100644
--- a/kernel/kernel/module/renderable/src/renderable.hpp
+++ b/kernel/kernel/module/renderable/src/renderable.hpp
@@ -2,8 +2,7 @@
 #include "model/Model.hpp"
 #include "../rely_facade.h"
 namespace aethera {
-template <typename Self> struct Renderable : Model_Layer<Root> {
-    using Renderable_Type = Self;
+struct Renderable : Def<Renderable, Root> {
     struct Private;
 };
 } // namespace aethera
diff --git a/kernel/kernel/module/renderable/src/renderable.ipp b/kernel/kernel/module/renderable/src/renderable.ipp
index 45324e1..8957b90 100644
--- a/kernel/kernel/module/renderable/src/renderable.ipp
+++ b/kernel/kernel/module/renderable/src/renderable.ipp
@@ -1,15 +1,14 @@
 #pragma once
 namespace aethera {
-template <typename Self> struct Renderable<Self>::Private : Prev_Private {
-    void advance();
+struct Renderable::Private : Prev_Private {
+    template <typename Self> void advance(this Self& self);
     proxy<task_flow::Task_Graph_Component> taskflow();
     proxy<renderable::Task_Graph>& internal_taskflow() noexcept { return graph; }
 private:
     proxy<renderable::Task_Graph> graph{renderable::make_task_graph("renderable")}; /* 唯一拥有本 Renderable 的任务图代理。 */
 };
-template <typename Self> void Renderable<Self>::Private::advance() {
-    auto& private_data = static_cast<typename Self::Private&>(*this);
-    if constexpr (requires { private_data.advance_renderable(); }) private_data.advance_renderable();
+template <typename Self> void Renderable::Private::advance(this Self& self) {
+    if constexpr (requires { self.advance_renderable(); }) self.advance_renderable();
 }
-template <typename Self> proxy<task_flow::Task_Graph_Component> Renderable<Self>::Private::taskflow() { return graph->component(); }
+inline proxy<task_flow::Task_Graph_Component> Renderable::Private::taskflow() { return graph->component(); }
 } // namespace aethera
diff --git a/kernel/kernel/module/renderable/test/Renderable_Tests.cpp b/kernel/kernel/module/renderable/test/Renderable_Tests.cpp
index a390a67..475a6b2 100644
--- a/kernel/kernel/module/renderable/test/Renderable_Tests.cpp
+++ b/kernel/kernel/module/renderable/test/Renderable_Tests.cpp
@@ -3,7 +3,7 @@
 #include <gtest/gtest.h>
 
 namespace {
-struct Test_Renderable : aethera::Def<Test_Renderable, aethera::Renderable<Test_Renderable>> {
+struct Test_Renderable : aethera::Def<Test_Renderable, aethera::Renderable> {
     struct Private : Prev_Private {
         void advance_renderable() { ++advance_count; auto& graph = internal_taskflow(); graph->clear(); (void)graph->add("test.prepare", [] {}); }
         int advance_count{};
diff --git a/kernel/kernel/module/scene/test/Scene_Tests.cpp b/kernel/kernel/module/scene/test/Scene_Tests.cpp
index 20b59b4..bfe8d66 100644
--- a/kernel/kernel/module/scene/test/Scene_Tests.cpp
+++ b/kernel/kernel/module/scene/test/Scene_Tests.cpp
@@ -7,11 +7,10 @@
 #include <vector>
 
 namespace {
-struct Test_Renderable : aethera::Def<Test_Renderable, aethera::Renderable<Test_Renderable>> {
+struct Test_Renderable : aethera::Def<Test_Renderable, aethera::Renderable> {
     struct Private : Prev_Private { void advance_renderable() { auto& graph = internal_taskflow(); graph->clear(); (void)graph->add("test.prepare", [] {}); } };
 };
-struct Test_Dag_Renderable : aethera::Def<Test_Dag_Renderable, aethera::Renderable<Test_Dag_Renderable>> {
-    Test_Dag_Renderable(std::shared_ptr<std::vector<int>> advance_order, int id) : Def(std::move(advance_order), id) {}
+struct Test_Dag_Renderable : aethera::Def<Test_Dag_Renderable, aethera::Renderable> {
     struct Private : Prev_Private {
         Private(std::shared_ptr<std::vector<int>> advance_order, int id) : advance_order(std::move(advance_order)), id(id) {}
         void advance_renderable() { advance_order->push_back(id); auto& graph = internal_taskflow(); graph->clear(); (void)graph->add("prepare", [] {}); }
@@ -29,16 +28,16 @@ TEST(Scene, Advances_Renderables_And_Composes_Task_Graph_In_Dag_Order) {
     builder.add_dependency({3}, {1});
     auto graph = builder.build();
     ASSERT_TRUE(graph.has_value());
-    aethera::Scene scene;
-    EXPECT_TRUE(scene.d->create_frame());
-    scene.set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
-    EXPECT_TRUE(scene.d->advance().has_value());
+    auto scene = aethera::Scene::Builder{}.build();
+    EXPECT_TRUE(scene->d->create_frame());
+    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    EXPECT_TRUE(scene->d->advance().has_value());
     EXPECT_EQ(*advance_order, (std::vector<int>{1, 2, 3}));
-    EXPECT_FALSE(scene.d->taskflow()->empty());
+    EXPECT_FALSE(scene->d->taskflow()->empty());
     advance_order->clear();
     std::optional<aethera::Edit_Dag_Result> edit_error;
-    scene.set<aethera::Owned_Dag, aethera::Scene>([](aethera::Dag<aethera::scene::Renderable>::Editor& editor) { editor.remove({99}); }, [&](std::expected<void, aethera::Edit_Dag_Result> result) { if (!result) edit_error = result.error(); });
-    EXPECT_TRUE(scene.d->advance().has_value());
+    scene->set<aethera::Owned_Dag, aethera::Scene>([](aethera::Dag<aethera::scene::Renderable>::Editor& editor) { editor.remove({99}); }, [&](std::expected<void, aethera::Edit_Dag_Result> result) { if (!result) edit_error = result.error(); });
+    EXPECT_TRUE(scene->d->advance().has_value());
     ASSERT_TRUE(edit_error.has_value());
     EXPECT_EQ(*edit_error, aethera::Edit_Dag_Result::node_not_found);
     EXPECT_EQ(*advance_order, (std::vector<int>{1, 2, 3}));
@@ -63,46 +62,46 @@ TEST(Scene, Owned_Dag_Rolls_Back_The_Whole_Invalid_Edit) {
     builder.add({1}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 1));
     auto graph = builder.build();
     ASSERT_TRUE(graph.has_value());
-    aethera::Scene scene;
-    scene.set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
-    ASSERT_TRUE(scene.d->advance().has_value());
+    auto scene = aethera::Scene::Builder{}.build();
+    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    ASSERT_TRUE(scene->d->advance().has_value());
     advance_order->clear();
     std::optional<aethera::Edit_Dag_Result> edit_error;
-    scene.set<aethera::Owned_Dag, aethera::Scene>([advance_order](aethera::Dag<aethera::scene::Renderable>::Editor& editor) { editor.add({2}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 2)); editor.add_dependency({2}, {99}); }, [&](std::expected<void, aethera::Edit_Dag_Result> result) { if (!result) edit_error = result.error(); });
-    ASSERT_TRUE(scene.d->advance().has_value());
+    scene->set<aethera::Owned_Dag, aethera::Scene>([advance_order](aethera::Dag<aethera::scene::Renderable>::Editor& editor) { editor.add({2}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 2)); editor.add_dependency({2}, {99}); }, [&](std::expected<void, aethera::Edit_Dag_Result> result) { if (!result) edit_error = result.error(); });
+    ASSERT_TRUE(scene->d->advance().has_value());
     ASSERT_TRUE(edit_error.has_value());
     EXPECT_EQ(*edit_error, aethera::Edit_Dag_Result::node_not_found);
     EXPECT_EQ(*advance_order, (std::vector<int>{1}));
 }
 
 TEST(Scene, Render_Returns_Known_Submission_Result) {
-    aethera::Scene scene;
-    auto frame = scene.d->create_frame();
+    auto scene = aethera::Scene::Builder{}.build();
+    auto frame = scene->d->create_frame();
     bool completed{};
-    const auto unavailable_runtime = scene.d->render(frame, [&](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) { completed = true; });
+    const auto unavailable_runtime = scene->d->render(frame, [&](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) { completed = true; });
     ASSERT_FALSE(unavailable_runtime);
     EXPECT_EQ(std::get<aethera::Run_Taskflow_Result>(unavailable_runtime.error()), aethera::Run_Taskflow_Result::runtime_not_initialized);
     EXPECT_FALSE(completed);
     aethera::proxy<aethera::scene::Frame> empty_frame;
-    const auto missing_frame = scene.d->render(empty_frame, [&](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) {});
+    const auto missing_frame = scene->d->render(empty_frame, [&](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) {});
     ASSERT_FALSE(missing_frame);
     EXPECT_EQ(std::get<aethera::scene::Render_State_Result>(missing_frame.error()), aethera::scene::Render_State_Result::frame_missing);
-    const auto missing_completion = scene.d->render(frame, {});
+    const auto missing_completion = scene->d->render(frame, {});
     ASSERT_FALSE(missing_completion);
     EXPECT_EQ(std::get<aethera::scene::Render_State_Result>(missing_completion.error()), aethera::scene::Render_State_Result::completion_missing);
 }
 
 TEST(Scene, Rejects_The_Same_Renderable_Task_Graph_Twice) {
-    Test_Renderable renderable;
+    auto renderable = Test_Renderable::Builder{}.build();
     aethera::Dag<aethera::scene::Renderable>::Builder builder;
-    builder.add({1}, aethera::model_proxy_view<aethera::scene::Renderable>(renderable));
-    builder.add({2}, aethera::model_proxy_view<aethera::scene::Renderable>(renderable));
+    builder.add({1}, aethera::model_proxy_view<aethera::scene::Renderable>(*renderable));
+    builder.add({2}, aethera::model_proxy_view<aethera::scene::Renderable>(*renderable));
     auto graph = builder.build();
     ASSERT_TRUE(graph.has_value());
-    aethera::Scene scene;
-    scene.set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
-    auto frame = scene.d->create_frame();
-    const auto rendered = scene.d->render(frame, [](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) {});
+    auto scene = aethera::Scene::Builder{}.build();
+    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    auto frame = scene->d->create_frame();
+    const auto rendered = scene->d->render(frame, [](aethera::proxy<aethera::scene::Frame>&, std::exception_ptr) {});
     ASSERT_FALSE(rendered);
     EXPECT_EQ(std::get<aethera::Compose_Task_Graph_Result>(rendered.error()), aethera::Compose_Task_Graph_Result::already_composed);
 }
diff --git a/kernel/kernel/module/task_flow/src/Task_Graph_Model.hpp b/kernel/kernel/module/task_flow/src/Task_Graph_Model.hpp
index 888a2ba..a70da4f 100644
--- a/kernel/kernel/module/task_flow/src/Task_Graph_Model.hpp
+++ b/kernel/kernel/module/task_flow/src/Task_Graph_Model.hpp
@@ -10,7 +10,6 @@
 namespace aethera::task_flow {
 struct Task_Graph_Model : Def<Task_Graph_Model, Root> {
     struct Private;
-    explicit Task_Graph_Model(std::shared_ptr<aethera::Task_Graph> graph) : Def(std::move(graph)) {}
 };
 
 struct Task_Graph_Model::Private : Prev_Private {
diff --git a/kernel/kernel/module/time_thread/src/Timer_Service_Model.hpp b/kernel/kernel/module/time_thread/src/Timer_Service_Model.hpp
index 4ccbc22..3c3606d 100644
--- a/kernel/kernel/module/time_thread/src/Timer_Service_Model.hpp
+++ b/kernel/kernel/module/time_thread/src/Timer_Service_Model.hpp
@@ -9,7 +9,6 @@ struct Thread_Timer_Service_State;
 
 struct Timer_Service_Model : Def<Timer_Service_Model, Root> {
     struct Private;
-    explicit Timer_Service_Model(std::shared_ptr<Thread_Timer_Service_State> state) : Def(std::move(state)) {}
 };
 
 struct Timer_Service_Model::Private : Prev_Private {
diff --git a/kernel/kernel/module/time_thread/test/Timer_Service_Tests.cpp b/kernel/kernel/module/time_thread/test/Timer_Service_Tests.cpp
index 9b5a6f2..a798cf6 100644
--- a/kernel/kernel/module/time_thread/test/Timer_Service_Tests.cpp
+++ b/kernel/kernel/module/time_thread/test/Timer_Service_Tests.cpp
@@ -33,7 +33,6 @@ static_assert(Timer_Service_Api<aethera::proxy<aethera::Timer_Service>>);
 
 struct Test_Timer_Time_Source : aethera::Def<Test_Timer_Time_Source, aethera::Root> {
     struct Private;
-    explicit Test_Timer_Time_Source(std::shared_ptr<aethera::Timer_Time_Point> current_time) : Def(std::move(current_time)) {}
 };
 
 struct Test_Timer_Time_Source::Private : Test_Timer_Time_Source::Prev_Private {
@@ -43,6 +42,9 @@ struct Test_Timer_Time_Source::Private : Test_Timer_Time_Source::Prev_Private {
     std::shared_ptr<aethera::Timer_Time_Point> current_time; /* 测试控制的唯一单调时间值。 */
 };
 
+using Test_Timer_Time_Source_Pointer = aethera::detail::Model_Private_Pointer<std::unique_ptr<Test_Timer_Time_Source>>;
+static_assert(pro::proxiable<Test_Timer_Time_Source_Pointer, aethera::Timer_Time_Source>);
+
 struct Timer_Scheduler_Test : testing::Test {
     Timer_Scheduler_Test() :
         scheduler(aethera::make_model_proxy<aethera::Timer_Time_Source, Test_Timer_Time_Source>(current_time)) {}
diff --git a/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp b/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp
index 795783d..7f22d3c 100644
--- a/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp
+++ b/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp
@@ -11,6 +11,14 @@ struct Value {
     int other{};
 };
 
+struct Base_Dirty_Value {
+    int base_number{};
+};
+
+struct Derived_Dirty_Value : Base_Dirty_Value {
+    int derived_number{};
+};
+
 using List = std::vector<int>;
 
 struct Concurrent_Struct_Dirty_Test : testing::Test {
@@ -129,6 +137,15 @@ TEST(Concurrent_Dirty, Binder_Created_After_Publish_Starts_From_Current_Revision
     EXPECT_TRUE(number_dirty.take_dirty());
 }
 
+TEST(Concurrent_Dirty, Inherited_Member_Write_Tracks_The_Base_Property) {
+    aethera::Import_Struct_With_Dirty<Derived_Dirty_Value> storage;
+    aethera::Property_Dirty_Binder base_dirty{storage, &Base_Dirty_Value::base_number};
+    storage.set(&Base_Dirty_Value::base_number, 79);
+    storage.internal.advance();
+    EXPECT_EQ(storage.internal.use()->base_number, 79);
+    EXPECT_TRUE(base_dirty.take_dirty());
+}
+
 struct Concurrent_List_Dirty_Test : testing::Test {
     using Imported = aethera::Import_List_With_Dirty<List>;
     using Exported = aethera::Export_List_With_Dirty<List>;
diff --git a/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp b/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp
index 8130fcc..3a5ea19 100644
--- a/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp
+++ b/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp
@@ -11,6 +11,14 @@ struct Value {
     std::string text;
 };
 
+struct Base_Value {
+    int base_number{};
+};
+
+struct Derived_Value : Base_Value {
+    int derived_number{};
+};
+
 struct Struct_Hooks {
     void before_advance(
         const Value* internal,
@@ -95,4 +103,24 @@ TEST(Concurrent_Struct, Advance_Hooks_Receive_Original_Pointers_In_Order) {
     EXPECT_LT(storage.internal.before_order, storage.internal.after_order);
 }
 
+TEST(Concurrent_Struct, Inherited_Member_Pointers_Work_For_All_Struct_Interfaces) {
+    static_assert(aethera::External_Set_Storage<aethera::Import_Struct<Derived_Value>, decltype(&Base_Value::base_number), int>);
+    static_assert(aethera::External_Get_Storage<aethera::Import_Struct<Derived_Value>, decltype(&Base_Value::base_number)>);
+    aethera::Import_Struct<Derived_Value> imported;
+    imported.internal.builder_set(&Base_Value::base_number, 61);
+    EXPECT_EQ(imported.internal.use()->base_number, 61);
+    EXPECT_EQ(imported.get(&Base_Value::base_number), 61);
+    imported.set(&Base_Value::base_number, 67);
+    EXPECT_EQ(imported.get(&Base_Value::base_number), 67);
+    imported.internal.advance();
+    EXPECT_EQ(imported.internal.use()->base_number, 67);
+
+    aethera::Export_Struct<Derived_Value> exported;
+    exported.internal.builder_set(&Base_Value::base_number, 71);
+    EXPECT_EQ(exported.get(&Base_Value::base_number), 71);
+    exported.internal.use()->base_number = 73;
+    exported.internal.advance();
+    EXPECT_EQ(exported.get(&Base_Value::base_number), 73);
+}
+
 }
diff --git a/kernel/kernel/test/model/Model_Tests.cpp b/kernel/kernel/test/model/Model_Tests.cpp
index 4d65605..0aa8cd2 100644
--- a/kernel/kernel/test/model/Model_Tests.cpp
+++ b/kernel/kernel/test/model/Model_Tests.cpp
@@ -3,6 +3,9 @@
 #include <gtest/gtest.h>
 #include <vector>
 namespace {
+int test_model_private_instances{};
+int test_model_base_private_instances{};
+int test_model_middle_private_instances{};
 PRO_DEF_MEM_DISPATCH(Test_Model_Private_Read, private_value);
 struct Test_Model_Private_Facade : aethera::facade_builder
 ::add_convention<Test_Model_Private_Read, int() const>
@@ -16,7 +19,10 @@ struct Other_Test_Model_Private_Facade : aethera::facade_builder
 struct Number_List_Tag {
     template <typename Layer> using Value = typename Layer::Numbers;
 };
-struct Test_Model_Base : aethera::Model_Layer<aethera::Root, aethera::Storage_Registration<aethera::Prop_Tag, aethera::Import_Struct_With_Dirty>, aethera::Storage_Registration<aethera::State_Tag, aethera::Export_Struct>, aethera::Storage_Registration<Number_List_Tag, aethera::Import_List>> {
+struct Middle_Data_Tag {
+    template <typename Layer> using Value = typename Layer::Middle_Data;
+};
+struct Test_Model_Base : aethera::Def<Test_Model_Base, aethera::Root, aethera::Storage_Registration<aethera::Prop_Tag, aethera::Import_Struct_With_Dirty>, aethera::Storage_Registration<aethera::State_Tag, aethera::Export_Struct>, aethera::Storage_Registration<Number_List_Tag, aethera::Import_List>> {
     struct Prop : Prev<aethera::Prop_Tag> {
         int base_number{};
         int same_name{};
@@ -25,10 +31,12 @@ struct Test_Model_Base : aethera::Model_Layer<aethera::Root, aethera::Storage_Re
         int base_state{};
     };
     struct Numbers : Prev<Number_List_Tag>, std::vector<int> {};
-    struct Private : Prev_Private {};
-    struct Builder : Prev_Builder {};
+    struct Private : Prev_Private {
+        Private() { ++test_model_base_private_instances; }
+        ~Private() { --test_model_base_private_instances; }
+    };
 };
-struct Test_Model_Middle : aethera::Model_Layer<Test_Model_Base> {
+struct Test_Model_Middle : aethera::Def<Test_Model_Middle, Test_Model_Base, aethera::Storage_Registration<Middle_Data_Tag, aethera::Import_Struct>> {
     struct Prop : Prev<aethera::Prop_Tag> {
         int middle_number{};
     };
@@ -36,8 +44,13 @@ struct Test_Model_Middle : aethera::Model_Layer<Test_Model_Base> {
         int middle_state{};
     };
     struct Numbers : Prev<Number_List_Tag> {};
-    struct Private : Prev_Private {};
-    struct Builder : Prev_Builder {};
+    struct Middle_Data : Prev<Middle_Data_Tag> {
+        int middle_number{};
+    };
+    struct Private : Prev_Private {
+        Private() { ++test_model_middle_private_instances; }
+        ~Private() { --test_model_middle_private_instances; }
+    };
 };
 struct Test_Model : aethera::Def<Test_Model, Test_Model_Middle> {
     struct Prop : Prev<aethera::Prop_Tag> {
@@ -49,7 +62,12 @@ struct Test_Model : aethera::Def<Test_Model, Test_Model_Middle> {
         int state{};
     };
     struct Numbers : Prev<Number_List_Tag> {};
+    struct Middle_Data : Prev<Middle_Data_Tag> {
+        int final_number{};
+    };
     struct Private : Prev_Private {
+        Private() { ++test_model_private_instances; }
+        ~Private() { --test_model_private_instances; }
         int private_value() const {
             return 41;
         }
@@ -69,11 +87,44 @@ static_assert(std::derived_from<Test_Model::Numbers, Test_Model_Middle::Numbers>
 static_assert(aethera::Concurrent_Storage<aethera::Import_Struct_With_Dirty<Test_Model::Prop>>);
 static_assert(aethera::Concurrent_Storage<aethera::Export_Struct<Test_Model::State>>);
 static_assert(aethera::Concurrent_Storage<aethera::Import_List<Test_Model::Numbers>>);
+static_assert(aethera::Concurrent_Storage<aethera::Import_Struct<Test_Model::Middle_Data>>);
 static_assert(!aethera::detail::Builder_Settable_Model_Value<aethera::Import_Struct, aethera::Prop_Tag, Test_Model, Test_Prop_Initializer>);
 static_assert(!aethera::detail::Builder_Settable_Model_Value<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag, Test_Model, int>);
 static_assert(!aethera::detail::Settable_Model_Value<aethera::Import_Struct, aethera::Prop_Tag, Test_Model, decltype(&Test_Model::Prop::number), int>);
+static_assert(aethera::detail::Builder_Settable_Model_Value<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name), int>);
+static_assert(aethera::detail::Settable_Model_Value<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name), int>);
+static_assert(aethera::detail::Gettable_Model_Value<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name)>);
+static_assert(aethera::detail::Builder_Settable_Model_Value<aethera::Import_Struct, Middle_Data_Tag, Test_Model, decltype(&Test_Model_Middle::Middle_Data::middle_number), int>);
+static_assert(aethera::detail::Settable_Model_Value<aethera::Import_Struct, Middle_Data_Tag, Test_Model, decltype(&Test_Model_Middle::Middle_Data::middle_number), int>);
 static_assert(pro::proxiable<aethera::detail::Model_Private_Pointer<Test_Model*>, Test_Model_Private_Facade>);
 static_assert(pro::proxiable<aethera::detail::Model_Private_Pointer<Test_Model*>, Other_Test_Model_Private_Facade>);
+TEST(Model, Every_Def_Layer_Can_Materialize_Its_Own_Endpoint) {
+    const int base_instances_before = test_model_base_private_instances;
+    const int middle_instances_before = test_model_middle_private_instances;
+    {
+        Test_Model_Base::Builder builder;
+        builder
+        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Base::Prop::base_number, 3);
+        auto model = builder.build();
+        EXPECT_EQ(test_model_base_private_instances, base_instances_before + 1);
+        EXPECT_EQ(test_model_middle_private_instances, middle_instances_before);
+        EXPECT_EQ(model->d->get<aethera::Prop_Tag>().internal.use()->base_number, 3);
+    }
+    EXPECT_EQ(test_model_base_private_instances, base_instances_before);
+    {
+        Test_Model_Middle::Builder builder;
+        builder
+        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Base::Prop::base_number, 5)
+        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Middle::Prop::middle_number, 7);
+        auto model = builder.build();
+        EXPECT_EQ(test_model_base_private_instances, base_instances_before + 1);
+        EXPECT_EQ(test_model_middle_private_instances, middle_instances_before + 1);
+        EXPECT_EQ(model->d->get<aethera::Prop_Tag>().internal.use()->base_number, 5);
+        EXPECT_EQ(model->d->get<aethera::Prop_Tag>().internal.use()->middle_number, 7);
+    }
+    EXPECT_EQ(test_model_base_private_instances, base_instances_before);
+    EXPECT_EQ(test_model_middle_private_instances, middle_instances_before);
+}
 TEST(Model, Registered_Value_Types_Build_Independent_Storages) {
     Test_Model::Builder builder;
     int struct_initializer_calls{};
@@ -115,6 +166,26 @@ TEST(Model, Registered_Value_Types_Build_Independent_Storages) {
     numbers.internal.advance();
     EXPECT_EQ(*numbers.internal.use(), (std::vector<int>{17, 19}));
 }
+TEST(Model, Every_Def_Layer_Shares_One_Private_And_Storage_Set) {
+    const int instances_before = test_model_private_instances;
+    const int base_instances_before = test_model_base_private_instances;
+    const int middle_instances_before = test_model_middle_private_instances;
+    {
+        auto model = Test_Model::Builder{}.build();
+        auto* middle = static_cast<Test_Model_Middle*>(model.get());
+        auto* base = static_cast<Test_Model_Base*>(model.get());
+        EXPECT_EQ(test_model_private_instances, instances_before + 1);
+        EXPECT_EQ(test_model_base_private_instances, base_instances_before + 1);
+        EXPECT_EQ(test_model_middle_private_instances, middle_instances_before + 1);
+        EXPECT_EQ(std::addressof(*middle->d), std::addressof(static_cast<Test_Model_Middle::Private&>(*model->d)));
+        EXPECT_EQ(std::addressof(*base->d), std::addressof(static_cast<Test_Model_Base::Private&>(*model->d)));
+        auto* properties = std::addressof(model->d->get<aethera::Prop_Tag>());
+        EXPECT_EQ(properties, std::addressof(model->d->get<aethera::Prop_Tag>()));
+    }
+    EXPECT_EQ(test_model_private_instances, instances_before);
+    EXPECT_EQ(test_model_base_private_instances, base_instances_before);
+    EXPECT_EQ(test_model_middle_private_instances, middle_instances_before);
+}
 TEST(Model, Registered_Struct_Set_Publishes_To_The_Same_Tagged_Storage) {
     auto model = Test_Model::Builder{}.build();
     model->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::number, 13);
@@ -122,6 +193,20 @@ TEST(Model, Registered_Struct_Set_Publishes_To_The_Same_Tagged_Storage) {
     properties.internal.advance();
     EXPECT_EQ(properties.internal.use()->number, 13);
 }
+TEST(Model, Derived_Def_Registers_And_Uses_A_New_Concurrent) {
+    Test_Model::Builder builder;
+    builder
+    .set<aethera::Import_Struct, Middle_Data_Tag>(&Test_Model_Middle::Middle_Data::middle_number, 47)
+    .set<aethera::Import_Struct, Middle_Data_Tag>(&Test_Model::Middle_Data::final_number, 53);
+    auto model = builder.build();
+    auto& storage = model->d->get<Middle_Data_Tag>();
+    EXPECT_EQ(storage.internal.use()->middle_number, 47);
+    EXPECT_EQ(storage.internal.use()->final_number, 53);
+    model->set<aethera::Import_Struct, Middle_Data_Tag>(&Test_Model_Middle::Middle_Data::middle_number, 59);
+    storage.internal.advance();
+    EXPECT_EQ(storage.internal.use()->middle_number, 59);
+    EXPECT_EQ(storage.internal.use()->final_number, 53);
+}
 TEST(Model, Same_Name_Properties_In_Base_And_Derived_Layers_Are_Set_Independently) {
     Test_Model::Builder builder;
     builder
diff --git a/kernel/使用规范.md b/kernel/使用规范.md
index c332c35..9fe6aca 100644
--- a/kernel/使用规范.md
+++ b/kernel/使用规范.md
@@ -1,13 +1,17 @@
 # Model 定义层
 
 - 每个 Model 定义层的 `Prop`、`State` 等值类型必须定义在所属类内，并继承 `Prev<Tag>`，使同一 Tag 的值结构沿 Model 层级自然形成继承链。
-- Tag 与 Concurrent Storage 必须通过 `Storage_Registration<Tag, Concurrent_Storage>` 登记在 `Model_Layer` 或最终 `Def` 的类型参数上，禁止在类末尾手工汇总注册表。
-- `Storage_Registration` 只描述类型关系，不创建存储；完整注册链延迟到最终 `Def` 后，由最终 `Private`/`Builder` 展开为真实的 `Tagged_Storage_Set`。
+- 每一层统一使用 `Def<当前层, Base, ...>`，不再区分中间层与末尾层；当前层是普通类，不需要为了传递最终 Self 而模板化。
+- Tag 与 Concurrent Storage 必须通过 `Storage_Registration<Tag, Concurrent_Storage>` 登记在所属 `Def` 的类型参数上，禁止在类末尾手工汇总注册表。
+- `Storage_Registration` 只描述类型关系，不创建存储；完整注册链按 Builder 当前构建的 endpoint 求值，并由公共 `Root` 展开为一份 `Private + Tagged_Storage_Set`。
+- Builder 只拥有一个当前 endpoint 对象槽；被继承的 Def 层不得创建自己的 endpoint state、对象副本或 Storage。每层 `d` 只是同一 Root 状态的非拥有 Private 视图。
+- Model 实体必须通过 `Builder`、`make_model_proxy` 或接收已完成 Builder 对象的 proxy 工厂物化；普通构造不创建运行状态。带参 Builder 只把参数交给当前 endpoint 的最终 Private。
+- 只有当前 endpoint 的最终 `Private` 可以直接通过 `get<Tag>()` 取得存储。被继承的基类 `Private` 能力若需要状态，必须由最终 `Private` 取得存储后传入所需的基类值引用；禁止基类 `Private` 按自己的 endpoint 类型再次解释派生 endpoint 的唯一存储。
 - 每个注册进 Model 的 Concurrent 必须提供 `internal.advance()`、`internal.use()` 和 `internal.builder_set(...)`；外部 `set(...)`、`get(...)` 至少提供一个，也允许同时提供。
 - Model 的 `Builder::set` 只能调用 `internal.builder_set`；最终对象的 `set/get` 只能调用 Concurrent 的外部 `set/get`。所有能力均由 concept 校验 Tag 对应的真实 Concurrent，禁止传入同形但未注册的类型。
 
 ```cpp
-struct Frame_Policy : Model_Layer<Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
+struct Frame_Policy : Def<Frame_Policy, Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
     struct Prop : Prev<Prop_Tag> {
         double frames_per_second{};
     };
diff --git a/render_2D/render_2D/axis/Abs_Axis.cpp b/render_2D/render_2D/axis/Abs_Axis.cpp
deleted file mode 100644
index 6dcf1ef..0000000
--- a/render_2D/render_2D/axis/Abs_Axis.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "Abs_Axis.hpp"                                    /* 轴属性缓存失效实现。 */
-#include <algorithm>
-#include <cmath>
-#include <iomanip>
-#include <sstream>
-namespace aethera::render_2d {
-bool Abs_Axis::State::operator==(const State&) const = default;
-bool Abs_Axis::Prop::operator==(const Prop&) const = default;
-
-Axis_Range Abs_Axis::coordinate_range() const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_coordinate_range();
-}
-Axis_Pixel_Position Abs_Axis::coordinate_to_pixel(Axis_Coordinate coordinate) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_coordinate_to_pixel(coordinate);
-}
-Axis_Coordinate Abs_Axis::pixel_to_coordinate(Axis_Pixel_Position pixel) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_pixel_to_coordinate(pixel);
-}
-Axis_Coordinate Abs_Axis::point_to_coordinate(Point_F point) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_point_to_coordinate(point);
-}
-Axis_Pixel_Sample_Count Abs_Axis::pixel_sample_count(Axis_Range coordinate_range) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_pixel_sample_count(coordinate_range);
-}
-Axis_Coordinate Abs_Axis::tick_step(Axis_Range coordinate_range) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_tick_step(coordinate_range);
-}
-std::string Abs_Axis::tick_label(Axis_Coordinate tick) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_tick_label(tick);
-}
-Axis_Tick_Count Abs_Axis::sub_tick_count(Axis_Coordinate major_step) const {
-    return double_buffer::detail::Internal_Access::layer<Abs_Axis>(this).runtime_sub_tick_count(major_step);
-}
-
-double Abs_Axis::Private::nice_tick_step(Axis_Range coordinate_range) {
-    if (!(coordinate_range.size() > 0.0) || !std::isfinite(coordinate_range.origin) ||
-        !std::isfinite(coordinate_range.target)) return 1.0;
-    return plot::nice_tick_step(coordinate_range, 6);
-}
-std::string Abs_Axis::Private::localized_number(double value, int precision, Number_Locale locale) {
-    std::ostringstream stream;
-    stream << std::fixed << std::setprecision(std::clamp(precision, 0, 12)) << value;
-    std::string result = stream.str();
-    if (result.find('.') != std::string::npos) {
-        while (!result.empty() && result.back() == '0') result.pop_back();
-        if (!result.empty() && result.back() == '.') result.pop_back();
-    }
-    if (locale.decimal_point != '.') std::replace(result.begin(), result.end(), '.', locale.decimal_point);
-    return result;
-}
-}
diff --git a/render_2D/render_2D/axis/Abs_Axis.hpp b/render_2D/render_2D/axis/Abs_Axis.hpp
deleted file mode 100644
index 3d2507a..0000000
--- a/render_2D/render_2D/axis/Abs_Axis.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#pragma once
-#include "Axis_Types.hpp"
-#include "../base/Renderable_2D.hpp"
-#include <renderable.hpp>
-#include <string>
-namespace aethera::render_2d {
-struct Abs_Axis;
-/* 最终轴 Private 的完整计算能力契约；所有结果直接来自当前 Prop。 */
-template <typename T>
-concept Axis_Object = Renderable_Object<T> && std::derived_from<T, Abs_Axis> && requires(
-    const typename T::Private& private_data,
-    const T* object,
-    Axis_Range coordinate_range,
-    Axis_Coordinate tick
-) {
-    { private_data.coordinate_range(object) } -> std::same_as<Axis_Range>;
-    { private_data.tick_step(object, coordinate_range) } -> std::same_as<Axis_Coordinate>;
-    { private_data.tick_label(object, tick) } -> std::same_as<std::string>;
-    { private_data.sub_tick_count(object, tick) } -> std::same_as<Axis_Tick_Count>;
-};
-/* 所有二维坐标轴共享的定义层；最终具体坐标轴直接持有其 Private 运行时实现。 */
-struct Abs_Axis : Def<Abs_Axis, Renderable_2D> {
-    using Axis_Range_Type = Axis_Range;
-    using Axis_Coordinate_Type = Axis_Coordinate;
-    using Axis_Pixel_Position_Type = Axis_Pixel_Position;
-    using Axis_Point_Type = Point_F;
-    using Axis_Pixel_Sample_Count_Type = Axis_Pixel_Sample_Count;
-    using Axis_Tick_Count_Type = Axis_Tick_Count;
-    struct Prop : Prev_Prop {
-        Point_F position{};                                         /* 坐标轴起点在画布中的二维像素位置。 */
-        Axis_Pixel_Length pixel_length{};                           /* 从坐标起点到终点的轴向像素跨度；为 0 时反算返回坐标起点。 */
-        Axis_Orientation orientation{Axis_Orientation::horizontal}; /* 从二维点取轴向分量时使用的方向。 */
-        Axis_Tick_Length tick_length{10.0};                          /* 主刻度线长度，单位为像素。 */
-        Axis_Tick_Length sub_tick_length{5.0};                       /* 次刻度线长度，单位为像素。 */
-        Pen axis_pen{Color::white()};                               /* 轴线、主刻度和次刻度的描边样式。 */
-        std::string unit_text{};                                    /* 坐标轴末端显示的单位文本；空值表示不绘制。 */
-        Font unit_text_font{};                                      /* 刻度标签和单位文本使用的字体。 */
-        Pen unit_text_pen{Color::white()};                          /* 刻度标签和单位文本使用的前景样式。 */
-        Brush unit_text_background_brush{};                         /* 单位文本背景填充；none 表示不填充。 */
-        Axis_Label_Rotation label_rotation_degrees{};               /* 刻度标签顺时针旋转角度，单位为度。 */
-        bool operator==(const Prop&) const;
-    };
-    /* 坐标轴当前没有额外发布状态。 */
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    /* 完整声明及派生轴 CRTP 能力契约见 Abs_Axis.ipp。 */
-    struct Private;
-    [[nodiscard]] Axis_Range coordinate_range() const;
-    [[nodiscard]] Axis_Pixel_Position coordinate_to_pixel(Axis_Coordinate coordinate) const;
-    [[nodiscard]] Axis_Coordinate pixel_to_coordinate(Axis_Pixel_Position pixel) const;
-    [[nodiscard]] Axis_Coordinate point_to_coordinate(Point_F point) const;
-    [[nodiscard]] Axis_Pixel_Sample_Count pixel_sample_count(Axis_Range coordinate_range) const;
-    [[nodiscard]] Axis_Coordinate tick_step(Axis_Range coordinate_range) const;
-    [[nodiscard]] std::string tick_label(Axis_Coordinate tick) const;
-    [[nodiscard]] Axis_Tick_Count sub_tick_count(Axis_Coordinate major_step) const;
-    /* 返回由最终轴 Prop 计算得到的当前有向坐标区间。 */
-    /* 将坐标值映射到当前轴向像素位置。 */
-    /* 将当前轴向像素位置反算为坐标值。 */
-    /* 按轴方向从二维像素点取值并反算为坐标。 */
-    /* 返回给定坐标区间覆盖的整数像素样本数量。 */
-    /* 返回给定坐标区间使用的主刻度步长。 */
-    /* 返回指定主刻度的显示文本。 */
-    /* 返回相邻主刻度之间的次刻度数量。 */
-};
-}
-#include "Abs_Axis.ipp"
diff --git a/render_2D/render_2D/axis/Abs_Axis.ipp b/render_2D/render_2D/axis/Abs_Axis.ipp
deleted file mode 100644
index 750a3a5..0000000
--- a/render_2D/render_2D/axis/Abs_Axis.ipp
+++ /dev/null
@@ -1,230 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <cmath>
-#include <vector>
-namespace aethera::render_2d {
-struct Abs_Axis::Private : Prev_Private {
-    using Axis_Runtime_Interface = void;
-    using Axis_Range_Type = Axis_Range;
-    using Axis_Coordinate_Type = Axis_Coordinate;
-    using Axis_Pixel_Position_Type = Axis_Pixel_Position;
-    using Axis_Point_Type = Point_F;
-    using Axis_Pixel_Sample_Count_Type = Axis_Pixel_Sample_Count;
-    using Axis_Tick_Count_Type = Axis_Tick_Count;
-    [[nodiscard]] virtual Axis_Range runtime_coordinate_range() const = 0;
-    [[nodiscard]] virtual Axis_Pixel_Position runtime_coordinate_to_pixel(Axis_Coordinate coordinate) const = 0;
-    [[nodiscard]] virtual Axis_Coordinate runtime_pixel_to_coordinate(Axis_Pixel_Position pixel) const = 0;
-    [[nodiscard]] virtual Axis_Coordinate runtime_point_to_coordinate(Point_F point) const = 0;
-    [[nodiscard]] virtual Axis_Pixel_Sample_Count runtime_pixel_sample_count(Axis_Range coordinate_range) const = 0;
-    [[nodiscard]] virtual Axis_Coordinate runtime_tick_step(Axis_Range coordinate_range) const = 0;
-    [[nodiscard]] virtual std::string runtime_tick_label(Axis_Coordinate tick) const = 0;
-    [[nodiscard]] virtual Axis_Tick_Count runtime_sub_tick_count(Axis_Coordinate major_step) const = 0;
-    /*
-     * 派生轴 Private 必须继承 Prev_Private，并提供以下 CRTP 能力：
-     * Axis_Range coordinate_range(const T* object) const：从最终轴当前 State 返回权威坐标区间。
-     * double tick_step(const T* object, Axis_Range coordinate_range) const：返回主刻度步长。
-     * std::string tick_label(const T* object, double tick) const：返回主刻度显示文本。
-     * int sub_tick_count(const T* object, double major_step) const：返回次刻度数量；默认固定返回 4。
-     * 坐标映射直接读取 Abs_Axis::Base_Tag 状态并调用最终 Private 的 coordinate_range(...)，不保存变换快照。
-     */
-    struct Prepared_Line {
-        Point_F first{}; /* 线段起点，单位为画布像素。 */
-        Point_F second{}; /* 线段终点，单位为画布像素。 */
-    };
-    struct Prepared_Label {
-        Point_F position{}; /* 标签左上角位置，单位为画布像素。 */
-        std::string text{}; /* 已按最终轴规则格式化的标签文本。 */
-    };
-    struct Prepared_Axis {
-        std::vector<Prepared_Line> lines{}; /* 本轮 Prepare 生成的轴线与刻度线。 */
-        std::vector<Prepared_Label> labels{}; /* 本轮 Prepare 生成的刻度标签。 */
-        Point_F unit_position{}; /* 单位文本左上角位置，单位为画布像素。 */
-        double unit_width{}; /* 单位文本背景的估算宽度，单位为像素。 */
-        bool valid{}; /* 本轮 Prepare 是否生成了可绘制内容。 */
-    };
-    Prepared_Axis prepared{}; /* 由当前 State 推导、仅供紧随其后的 Paint 消费。 */
-    [[nodiscard]] double coordinate_to_pixel(const Attached auto* object, double coordinate) const;
-    [[nodiscard]] double pixel_to_coordinate(const Attached auto* object, double pixel) const;
-    [[nodiscard]] double point_to_coordinate(const Attached auto* object, Point_F point) const;
-    [[nodiscard]] int pixel_sample_count(const Attached auto* object, Axis_Range coordinate_range) const;
-    /* 供派生轴复用的 1/2/5 十进制主刻度算法。 */
-    [[nodiscard]] static double nice_tick_step(Axis_Range coordinate_range);
-    /* 供派生轴复用的定点数值标签格式化算法。 */
-    [[nodiscard]] static std::string localized_number(double value, int precision, Number_Locale locale);
-    /* CRTP 实现：从最终轴当前 State 生成本轮 Paint 使用的线段与标签。 */
-    void prepare_data(Attached auto* object);
-    /* CRTP 实现：将本轮 Prepared_Axis 绘制到 Color_Cache 的写缓冲。 */
-    void paint(Attached auto* object);
-    /* CRTP Prop hook：任一轴属性变化都会使该轴的准备数据和颜色缓存失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> props);
-    /* CRTP 默认：每两个主刻度之间生成 4 个次刻度。 */
-    [[nodiscard]] int sub_tick_count(const Attached auto* object, double major_step) const;
-    /* CRTP 覆盖：轴的事件区域由轴段、刻度长度和标签字号即时计算，不占用整个 viewport。 */
-    [[nodiscard]] Rect_F event_region(const Attached auto* object, Size viewport) const;
-    /* CRTP 覆盖：绑定 Renderable 机制和最终轴公开薄壳分派；派生 Private 必须先调用此实现。 */
-    template <Axis_Object Object>
-    void bind_private_crtp(Object* object);
-};
-inline double Abs_Axis::Private::coordinate_to_pixel(const Attached auto* object, double coordinate) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& axis_prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const Axis_Range range = private_data.coordinate_range(object);
-    const double pixel_origin = axis_prop.orientation == Axis_Orientation::horizontal
-                                    ? axis_prop.position.x
-                                    : axis_prop.position.y;
-    if (range.length() == 0.0) return pixel_origin;
-    return pixel_origin + (coordinate - range.origin) / range.length() * axis_prop.pixel_length;
-}
-inline double Abs_Axis::Private::pixel_to_coordinate(const Attached auto* object, double pixel) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& axis_prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const Axis_Range range = private_data.coordinate_range(object);
-    if (axis_prop.pixel_length == 0.0) return range.origin;
-    const double pixel_origin = axis_prop.orientation == Axis_Orientation::horizontal
-                                    ? axis_prop.position.x
-                                    : axis_prop.position.y;
-    return range.origin + (pixel - pixel_origin) / axis_prop.pixel_length * range.length();
-}
-inline double Abs_Axis::Private::point_to_coordinate(const Attached auto* object, Point_F point) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& axis_prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    return private_data.pixel_to_coordinate(
-        object, axis_prop.orientation == Axis_Orientation::horizontal ? point.x : point.y);
-}
-inline int Abs_Axis::Private::pixel_sample_count(const Attached auto* object,
-                                                 Axis_Range coordinate_range) const {
-    const double first_pixel = coordinate_to_pixel(object, coordinate_range.origin);
-    const double last_pixel = coordinate_to_pixel(object, coordinate_range.target);
-    return std::max(0, static_cast<int>(std::abs(last_pixel - first_pixel)) + 1);
-}
-template <Axis_Object Object>
-void Abs_Axis::Private::bind_private_crtp(Object* object) {
-    Prev_Private::bind_private_crtp(object);
-    this->event_routing_distance_run = [](const Root* root, const Event& event) -> std::optional<double> {
-        if (event.type != Event_Type::wheel && event.type != Event_Type::pointer_press
-            && event.type != Event_Type::pointer_move && event.type != Event_Type::pointer_release) return std::nullopt;
-        const auto* pointer = dynamic_cast<const Pointer_Event_Capability*>(&event);
-        if (!pointer) return std::nullopt;
-        const auto* axis = static_cast<const Object*>(root);
-        const auto& private_data = double_buffer::detail::Internal_Access::get(axis);
-        const auto& layout = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(axis));
-        const Point_F first = layout.position;
-        const Point_F second = layout.orientation == Axis_Orientation::horizontal
-            ? Point_F{first.x + layout.pixel_length, first.y}
-            : Point_F{first.x, first.y + layout.pixel_length};
-        const double segment_x = second.x - first.x;
-        const double segment_y = second.y - first.y;
-        const double length_squared = segment_x * segment_x + segment_y * segment_y;
-        const double projection = length_squared > 0.0
-            ? std::clamp(((pointer->position_x() - first.x) * segment_x
-                + (pointer->position_y() - first.y) * segment_y) / length_squared, 0.0, 1.0)
-            : 0.0;
-        const double nearest_x = first.x + segment_x * projection;
-        const double nearest_y = first.y + segment_y * projection;
-        return std::hypot(pointer->position_x() - nearest_x, pointer->position_y() - nearest_y);
-    };
-}
-inline Rect_F Abs_Axis::Private::event_region(const Attached auto* object, Size) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& layout = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const double margin = std::max(8.0, std::abs(layout.tick_length) + layout.unit_text_font.size * 1.5);
-    const Point_F second = layout.orientation == Axis_Orientation::horizontal
-        ? Point_F{layout.position.x + layout.pixel_length, layout.position.y}
-        : Point_F{layout.position.x, layout.position.y + layout.pixel_length};
-    return Rect_F{layout.position.x - margin, layout.position.y - margin,
-                  second.x - layout.position.x + margin * 2.0,
-                  second.y - layout.position.y + margin * 2.0}.normalized();
-}
-inline void Abs_Axis::Private::prepare_data(Attached auto* object) {
-    using Object = std::remove_pointer_t<decltype(object)>;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    auto& output = prepared;
-    output = {};
-    if (state.pixel_length == 0.0) return;
-    const Axis_Range coordinates = private_data.coordinate_range(object);
-    const double step = private_data.tick_step(object, coordinates);
-    if (!(step > 0.0) || !std::isfinite(step)) return;
-    const Point_F first = state.position;
-    const Point_F last = state.orientation == Axis_Orientation::horizontal
-                             ? Point_F{first.x + state.pixel_length, first.y}
-                             : Point_F{first.x, first.y + state.pixel_length};
-    output.lines.push_back({first, last});
-    const auto [low, high] = std::minmax(coordinates.origin, coordinates.target);
-    const double initial = std::ceil(low / step) * step;
-    for (int tick_index = 0; tick_index < 1000; ++tick_index) {
-        const double tick = initial + tick_index * step;
-        if (tick > high + step * 1e-6) break;
-        const double pixel = coordinate_to_pixel(object, tick);
-        Point_F tick_start{};
-        Point_F tick_end{};
-        Point_F label{};
-        if (state.orientation == Axis_Orientation::horizontal) {
-            tick_start = {pixel, state.position.y};
-            tick_end = {pixel, state.position.y + state.tick_length};
-            label = {pixel + 2.0, state.position.y + state.tick_length + 2.0};
-        }
-        else {
-            tick_start = {state.position.x, pixel};
-            tick_end = {state.position.x + state.tick_length, pixel};
-            label = {state.position.x + state.tick_length + 2.0, pixel - 7.0};
-        }
-        output.lines.push_back({tick_start, tick_end});
-        output.labels.push_back({label, private_data.tick_label(object, tick)});
-        const int subdivisions = std::max(0, private_data.sub_tick_count(object, step));
-        for (int sub_index = 1; sub_index <= subdivisions; ++sub_index) {
-            const double sub_tick = tick + step * sub_index / (subdivisions + 1.0);
-            if (sub_tick >= high) break;
-            const double sub_pixel = coordinate_to_pixel(object, sub_tick);
-            if (state.orientation == Axis_Orientation::horizontal)
-                output.lines.push_back({
-                    {sub_pixel, state.position.y},
-                    {sub_pixel, state.position.y + state.sub_tick_length}
-                });
-            else
-                output.lines.push_back({
-                    {state.position.x, sub_pixel},
-                    {state.position.x + state.sub_tick_length, sub_pixel}
-                });
-        }
-    }
-    if (!state.unit_text.empty()) {
-        output.unit_position = {last.x + 4.0, last.y + 4.0};
-        output.unit_width = std::max(4.0, state.unit_text.size() * state.unit_text_font.size * 0.65);
-    }
-    output.valid = true;
-    double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-inline void Abs_Axis::Private::paint(Attached auto* object) {
-    using Object = std::remove_pointer_t<decltype(object)>;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    auto& cache = private_data.paint_surface();
-    if (!prepared.valid) return;
-    detail::Painter painter(cache, cache.size());
-    for (const auto& line : prepared.lines) painter.line(line.first, line.second, state.axis_pen);
-    for (const auto& label : prepared.labels)
-        painter.text(label.position, label.text, state.unit_text_font, state.unit_text_pen,
-                     state.label_rotation_degrees);
-    if (!state.unit_text.empty()) {
-        painter.rect({
-                         prepared.unit_position.x - 2.0, prepared.unit_position.y - 2.0,
-                         prepared.unit_width + 4.0, state.unit_text_font.size * 1.5 + 4.0
-                     },
-                     Pen{.style = Line_Style::none}, state.unit_text_background_brush);
-        painter.text(prepared.unit_position, state.unit_text, state.unit_text_font, state.unit_text_pen);
-    }
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Abs_Axis::Private::after_prop_set(Object* object, Member Owner::*, Prop_Access<Prop_Type>) {
-    double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-inline int Abs_Axis::Private::sub_tick_count(const Attached auto*, double) const {
-    return 4;
-}
-}
diff --git a/render_2D/render_2D/axis/Axis.hpp b/render_2D/render_2D/axis/Axis.hpp
deleted file mode 100644
index 927701c..0000000
--- a/render_2D/render_2D/axis/Axis.hpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-#include "Abs_Axis.hpp"
-#include "Frequency_Axis.hpp"
-#include "Numeric_Axis.hpp"
-#include "Time_Axis.hpp"
diff --git a/render_2D/render_2D/axis/Axis_Types.cpp b/render_2D/render_2D/axis/Axis_Types.cpp
deleted file mode 100644
index 8693acd..0000000
--- a/render_2D/render_2D/axis/Axis_Types.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "Axis_Types.hpp"
diff --git a/render_2D/render_2D/axis/Axis_Types.hpp b/render_2D/render_2D/axis/Axis_Types.hpp
deleted file mode 100644
index e1df57c..0000000
--- a/render_2D/render_2D/axis/Axis_Types.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-#include "../base/Types.hpp"
-#include <plot/Axis.hpp>
-#include <cstdint>
-namespace aethera::render_2d {
-using plot::Axis_Coordinate;
-using plot::Axis_Point;
-using plot::Axis_Range;
-using plot::Axis_Rectangle;
-using Axis_Pixel_Position = double;
-using Axis_Pixel_Length = double;
-using Axis_Tick_Length = double;
-using Axis_Label_Rotation = double;
-using Axis_Tick_Count = int;
-using Axis_Pixel_Sample_Count = int;
-using Axis_Label_Precision = int;
-using Axis_Time_Tick = int;
-using Axis_Visible_Count = int;
-/* 坐标轴在二维画布中的方向。 */
-enum struct Axis_Orientation : std::uint8_t {
-    horizontal,
-    vertical
-};
-}
diff --git a/render_2D/render_2D/axis/Frequency_Axis.cpp b/render_2D/render_2D/axis/Frequency_Axis.cpp
deleted file mode 100644
index 94dfe51..0000000
--- a/render_2D/render_2D/axis/Frequency_Axis.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "Frequency_Axis.hpp"                              /* 继承轴属性缓存失效实现。 */
-
-namespace aethera::render_2d {
-bool Frequency_Axis::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/axis/Frequency_Axis.hpp b/render_2D/render_2D/axis/Frequency_Axis.hpp
deleted file mode 100644
index 2a89b0d..0000000
--- a/render_2D/render_2D/axis/Frequency_Axis.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-#include "Numeric_Axis.hpp"
-namespace aethera::render_2d {
-/* 根据数值量级自动选择 Hz、kHz 或 MHz 标签的数值轴。 */
-struct Frequency_Axis : Def<Frequency_Axis, Numeric_Axis> {
-    /* Frequency_Axis 不发布额外属性。 */
-    struct Prop : Prev_Prop {};
-    /* Frequency_Axis 没有重复保存数值轴状态，仅保留独立状态层。 */
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    /* 完整声明及频率标签 CRTP 覆盖见 Frequency_Axis.ipp。 */
-    struct Private;
-};
-}
-#include "Frequency_Axis.ipp"
diff --git a/render_2D/render_2D/axis/Frequency_Axis.ipp b/render_2D/render_2D/axis/Frequency_Axis.ipp
deleted file mode 100644
index 798dbbf..0000000
--- a/render_2D/render_2D/axis/Frequency_Axis.ipp
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-namespace aethera::render_2d {
-struct Frequency_Axis::Private : Prev_Private {
-    /* CRTP 覆盖：按绝对量级选择 Hz、kHz 或 MHz，并复用数值轴的小数格式。 */
-    [[nodiscard]] std::string tick_label(const Attached auto* object, double tick) const;
-};
-inline std::string Frequency_Axis::Private::tick_label(const Attached auto* object, double tick) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& state = static_cast<const Numeric_Axis::Prop&>(
-        double_buffer::detail::Internal_Access::current_prop(object));
-    const double absolute = std::abs(tick);
-    if (absolute >= 1'000'000.0) return localized_number(tick / 1'000'000.0, state.precision, state.locale) + " MHz";
-    if (absolute >= 1'000.0) return localized_number(tick / 1'000.0, state.precision, state.locale) + " kHz";
-    return localized_number(tick, state.precision, state.locale) + " Hz";
-}
-}
diff --git a/render_2D/render_2D/axis/Numeric_Axis.cpp b/render_2D/render_2D/axis/Numeric_Axis.cpp
deleted file mode 100644
index 9f9ef6e..0000000
--- a/render_2D/render_2D/axis/Numeric_Axis.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Numeric_Axis.hpp"                                /* 继承轴属性缓存失效实现。 */
-
-namespace aethera::render_2d {
-bool Numeric_Axis::State::operator==(const State&) const = default;
-bool Numeric_Axis::Prop::operator==(const Prop&) const = default;
-}
diff --git a/render_2D/render_2D/axis/Numeric_Axis.hpp b/render_2D/render_2D/axis/Numeric_Axis.hpp
deleted file mode 100644
index 2e47c98..0000000
--- a/render_2D/render_2D/axis/Numeric_Axis.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-#include "Abs_Axis.hpp"
-namespace aethera::render_2d {
-/* 具有显式数值范围和十进制标签的坐标轴定义层。 */
-struct Numeric_Axis : Def<Numeric_Axis, Abs_Axis> {
-    struct Prop : Prev_Prop {
-        Axis_Range coordinate_range{0.0, 20.0}; /* 当前有向数值区间；必须有限且非零。 */
-        Axis_Label_Precision precision{2};      /* 标签最大小数位数；格式化时限制到 0..12。 */
-        Number_Locale locale{};                 /* 数值标签的小数点规则。 */
-        bool wheel_enabled{true};               /* 是否允许滚轮以指针位置为锚点缩放坐标范围。 */
-        bool drag_enabled{true};                /* 是否允许按住鼠标左键拖动坐标范围。 */
-        bool operator==(const Prop&) const;
-    };
-    /* 数值轴当前没有额外发布状态。 */
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    /* 完整声明及数值轴 CRTP 能力见 Numeric_Axis.ipp。 */
-    struct Private;
-};
-}
-#include "Numeric_Axis.ipp"
diff --git a/render_2D/render_2D/axis/Numeric_Axis.ipp b/render_2D/render_2D/axis/Numeric_Axis.ipp
deleted file mode 100644
index c3de8f7..0000000
--- a/render_2D/render_2D/axis/Numeric_Axis.ipp
+++ /dev/null
@@ -1,105 +0,0 @@
-#pragma once
-#include <cmath>
-#include <stdexcept>
-namespace aethera::render_2d {
-struct Numeric_Axis::Private : Prev_Private {
-    bool dragging{};                                          /* 左键拖动手势是否已经开始且尚未释放。 */
-    Point_F last_pointer{};                                   /* 上一个拖动事件的位置，单位为画布局部像素。 */
-    /* CRTP 实现：直接返回 Numeric_Axis::Base_Tag 中唯一保存的数值范围。 */
-    [[nodiscard]] Axis_Range coordinate_range(const Attached auto* object) const;
-    /* CRTP 实现：使用 Abs_Axis::Private 的 1/2/5 十进制算法计算主刻度。 */
-    [[nodiscard]] double tick_step(const Attached auto* object, Axis_Range coordinate_range) const;
-    /* CRTP 可覆盖：按 Numeric_Axis 当前 precision 和 locale 格式化标签；Frequency_Axis 覆盖该能力。 */
-    [[nodiscard]] std::string tick_label(const Attached auto* object, double tick) const;
-    /* CRTP 实现：处理滚轮缩放和左键拖动，并在消费事件后标记 Prepare dirty。 */
-    void handle_event(Attached auto* object, const Event& event);
-    /* CRTP State 钩子：拒绝非有限、零长度范围以及 0..12 之外的精度，并恢复本次无效写入。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> props);
-};
-inline Axis_Range Numeric_Axis::Private::coordinate_range(const Attached auto* object) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    return static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object)).coordinate_range;
-}
-inline double Numeric_Axis::Private::tick_step(const Attached auto*, Axis_Range coordinate_range) const {
-    return nice_tick_step(coordinate_range);
-}
-inline std::string Numeric_Axis::Private::tick_label(const Attached auto* object, double tick) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    return localized_number(tick, state.precision, state.locale);
-}
-inline void Numeric_Axis::Private::handle_event(Attached auto* object, const Event& event) {
-    using Object = std::remove_pointer_t<decltype(object)>;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& current_prop = double_buffer::detail::Internal_Access::current_prop(object);
-    const auto& numeric_state = static_cast<const Prop&>(current_prop);
-    const auto& axis_state = static_cast<const Abs_Axis::Prop&>(current_prop);
-    const auto* pointer = dynamic_cast<const Pointer_Event_Capability*>(&event);
-    if (event.type == Event_Type::wheel && numeric_state.wheel_enabled) {
-        const auto* wheel = dynamic_cast<const Wheel_Event_Capability*>(&event);
-        if (!pointer || !wheel) return;
-        const double anchor_pixel = axis_state.orientation == Axis_Orientation::horizontal
-                                        ? pointer->position_x() : pointer->position_y();
-        const double anchor = pixel_to_coordinate(object, anchor_pixel);
-        const double factor = wheel->angle_delta_y_value() >= 0.0 ? 0.9 : 1.1;
-        const Axis_Range range = numeric_state.coordinate_range;
-        double_buffer::detail::Internal_Access::set<&Prop::coordinate_range>(object, Axis_Range{
-            anchor + (range.origin - anchor) * factor,
-            anchor + (range.target - anchor) * factor
-        });
-        double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-        event.accept();
-        return;
-    }
-    if (!numeric_state.drag_enabled || !pointer) return;
-    if (event.type == Event_Type::pointer_press && pointer->pointer_button() == Mouse_Button::left) {
-        dragging = true;
-        last_pointer = {pointer->position_x(), pointer->position_y()};
-        event.accept();
-        return;
-    }
-    if (event.type == Event_Type::pointer_move) {
-        const Point_F current{pointer->position_x(), pointer->position_y()};
-        if (!dragging) return;
-        const Point_F previous = last_pointer;
-        last_pointer = current;
-        const double delta = axis_state.orientation == Axis_Orientation::horizontal
-                                 ? current.x - previous.x : current.y - previous.y;
-        const double shift = axis_state.pixel_length == 0.0
-                                 ? 0.0 : -delta * numeric_state.coordinate_range.length() / axis_state.pixel_length;
-        double_buffer::detail::Internal_Access::set<&Prop::coordinate_range>(object, Axis_Range{
-            numeric_state.coordinate_range.origin + shift,
-            numeric_state.coordinate_range.target + shift
-        });
-        double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-        event.accept();
-        return;
-    }
-    if (event.type == Event_Type::pointer_release) {
-        const bool was_dragging = dragging;
-        dragging = false;
-        if (was_dragging) event.accept();
-    }
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Numeric_Axis::Private::after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> props) {
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    auto& pending = props.template get<Numeric_Axis::Base_Tag>();
-    const auto& current = static_cast<const Prop&>(double_buffer::detail::Internal_Access::pending_prop(object));
-    if constexpr (std::same_as<Owner, Prop> && std::same_as<Member, Axis_Range>) {
-        if (member != &Prop::coordinate_range) return;
-        const Axis_Range range = pending.coordinate_range;
-        if (std::isfinite(range.origin) && std::isfinite(range.target) && range.size() > 0.0) return;
-        pending.coordinate_range = current.coordinate_range;
-        throw std::invalid_argument("numeric axis coordinate range must be finite and non-empty");
-    }
-    else if constexpr (std::same_as<Owner, Prop> && std::same_as<Member, int>) {
-        if (member != &Prop::precision || (pending.precision >= 0 && pending.precision <= 12)) return;
-        pending.precision = current.precision;
-        throw std::invalid_argument("numeric axis precision must be between 0 and 12");
-    }
-}
-}
diff --git a/render_2D/render_2D/axis/Time_Axis.cpp b/render_2D/render_2D/axis/Time_Axis.cpp
deleted file mode 100644
index 478639e..0000000
--- a/render_2D/render_2D/axis/Time_Axis.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include "Time_Axis.hpp"                                   /* 继承轴属性缓存失效实现。 */
-#include <iomanip>
-#include <sstream>
-namespace aethera::render_2d {
-bool Time_Axis::State::operator==(const State&) const = default;
-bool Time_Axis::Prop::operator==(const Prop&) const = default;
-
-std::size_t Time_Axis::time_point_count() const {
-    return double_buffer::detail::Internal_Access::layer<Time_Axis>(this).runtime_time_point_count();
-}
-Axis_Time_Tick Time_Axis::append_time(Time_Of_Day time) {
-    return double_buffer::detail::Internal_Access::layer<Time_Axis>(this).runtime_append_time(time);
-}
-Time_Of_Day Time_Axis::tick_to_time(Axis_Time_Tick tick) const {
-    return double_buffer::detail::Internal_Access::layer<Time_Axis>(this).runtime_tick_to_time(tick);
-}
-
-std::string Time_Axis::Private::formatted_time(Time_Of_Day time, std::string_view format) {
-    const auto digits = [](int value, int width) {
-        std::ostringstream stream;
-        stream << std::setfill('0') << std::setw(width) << value;
-        return stream.str();
-    };
-    const auto total = time.milliseconds;
-    const int hours = static_cast<int>((total / 3'600'000) % 24);
-    const int minutes = static_cast<int>((total / 60'000) % 60);
-    const int seconds = static_cast<int>((total / 1'000) % 60);
-    const int milliseconds = static_cast<int>(total % 1'000);
-    std::string result;
-    for (std::size_t index = 0; index < format.size();) {
-        const std::string_view rest = format.substr(index);
-        if (rest.starts_with("zzz")) {
-            result += digits(milliseconds, 3);
-            index += 3;
-        }
-        else if (rest.starts_with("hh") || rest.starts_with("HH")) {
-            result += digits(hours, 2);
-            index += 2;
-        }
-        else if (rest.starts_with("mm")) {
-            result += digits(minutes, 2);
-            index += 2;
-        }
-        else if (rest.starts_with("ss")) {
-            result += digits(seconds, 2);
-            index += 2;
-        }
-        else {
-            result.push_back(format[index++]);
-        }
-    }
-    return result;
-}
-}
diff --git a/render_2D/render_2D/axis/Time_Axis.hpp b/render_2D/render_2D/axis/Time_Axis.hpp
deleted file mode 100644
index 0000df4..0000000
--- a/render_2D/render_2D/axis/Time_Axis.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-#include "Abs_Axis.hpp"
-#include <cstddef>
-#include <deque>
-#include <string>
-#include <utility>
-namespace aethera::render_2d {
-struct Time_Axis_Stream_Tag {};
-/* 将连续样本序号显示为一天内时间文本的坐标轴。 */
-struct Time_Axis : Def<Time_Axis, Abs_Axis,
-    Mpmc_Triple_Buffer<Time_Axis_Stream_Tag,
-                       std::pair<Axis_Time_Tick, Time_Of_Day>>> {
-    using Time_Axis_Capability = void;
-    using Axis_Time_Tick_Type = Axis_Time_Tick;
-    using Time_Of_Day_Type = Time_Of_Day;
-    struct Prop : Prev_Prop {
-        Axis_Visible_Count visible_count{100};                   /* 当前坐标区间最多覆盖的样本数量；小于 2 时按 2 计算。 */
-        Axis_Pixel_Length tick_label_spacing_px{8.0};            /* 相邻标签之间预留的像素间距；负值按 0 计算。 */
-        Axis_Pixel_Length estimated_label_width_px{76.0};        /* 当前字体下单个时间标签的估算像素宽度；小于 76 时按 76 计算。 */
-        std::string format{"mm:ss.zzz"};                         /* 标签格式；支持 hh、HH、mm、ss 和 zzz。 */
-        bool newest_at_start{};                                  /* true 时最新样本位于坐标区间起点。 */
-        bool operator==(const Prop&) const;
-    };
-    /* 时间样本是由 append_time 发布给观察方的运行状态。 */
-    struct State : Prev_State {
-        Axis_Time_Tick next_tick{};                              /* 下一次 append_time 分配的单调样本序号。 */
-        bool operator==(const State&) const;
-    };
-    /* 完整声明、时间轴 CRTP 能力及公开薄壳分派见 Time_Axis.ipp。 */
-    struct Private;
-    [[nodiscard]] std::size_t time_point_count() const;
-    Axis_Time_Tick append_time(Time_Of_Day time);
-    [[nodiscard]] Time_Of_Day tick_to_time(Axis_Time_Tick tick) const;
-    /* 返回当前已提交时间样本数量。 */
-    /* 向提交侧追加时间并返回分配的 tick；结果在下一次 advance 后进入当前读面。 */
-    /* 在当前已提交样本中查找 tick；不存在时返回无效时间。 */
-};
-}
-#include "Time_Axis.ipp"
diff --git a/render_2D/render_2D/axis/Time_Axis.ipp b/render_2D/render_2D/axis/Time_Axis.ipp
deleted file mode 100644
index 11e867a..0000000
--- a/render_2D/render_2D/axis/Time_Axis.ipp
+++ /dev/null
@@ -1,117 +0,0 @@
-#pragma once
-#include <algorithm>
-#include <atomic>
-#include <cmath>
-namespace aethera::render_2d {
-struct Time_Axis::Private : Prev_Private {
-    using Time_Axis_Runtime_Interface = void;
-    using Axis_Time_Tick_Type = Axis_Time_Tick;
-    using Time_Of_Day_Type = Time_Of_Day;
-    [[nodiscard]] virtual std::size_t runtime_time_point_count() const = 0;
-    virtual Axis_Time_Tick runtime_append_time(Time_Of_Day time) = 0;
-    [[nodiscard]] virtual Time_Of_Day runtime_tick_to_time(Axis_Time_Tick tick) const = 0;
-    /* CRTP 实现：用固定数量的半开槽位窗口定位 tick；样本不足时保留空槽，禁止把已有样本拉伸铺满整轴。 */
-    [[nodiscard]] Axis_Range coordinate_range(const Attached auto* object) const;
-    /* CRTP 实现：根据像素长度、估算标签宽度和间距计算至少为 1 的整数刻度步长。 */
-    [[nodiscard]] double tick_step(const Attached auto* object, Axis_Range coordinate_range) const;
-    /* CRTP 实现：在当前样本中查找 tick，并按 State::format 生成时间标签。 */
-    [[nodiscard]] std::string tick_label(const Attached auto* object, double tick) const;
-    std::atomic<Axis_Time_Tick> next_tick{};
-    std::span<const std::pair<Axis_Time_Tick, Time_Of_Day>> active_samples{};                  /* 多生产者分配 tick 的唯一权威来源。 */
-    [[nodiscard]] std::size_t time_point_count(const Attached auto* object) const;
-    int append_time(Attached auto* object, Time_Of_Day time);
-    [[nodiscard]] Time_Of_Day tick_to_time(const Attached auto* object, int tick) const;
-    /* 将一天内时间按支持的占位符格式化；未知字符原样保留。 */
-    [[nodiscard]] static std::string formatted_time(Time_Of_Day time, std::string_view format);
-    /* CRTP 覆盖：时间样本写入后使本轴的刻度布局失效；样本仍只保存在 Time_Axis::State。 */
-    template <typename Object, typename Owner, typename Member, typename State_Type>
-    void after_state_set(Object* object, Member Owner::* member, State_Access<State_Type> pending_states);
-    /* CRTP 覆盖：绑定通用轴机制和最终时间轴公开薄壳分派；派生 Private 必须先调用此实现。 */
-    template <Axis_Object Object>
-    void bind_private_crtp(Object* object);
-    void prepare_data(Attached auto* object);
-    void paint(Attached auto* object);
-};
-inline Axis_Range Time_Axis::Private::coordinate_range(const Attached auto* object) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const int visible_count = std::max(2, prop.visible_count);
-    const int latest = std::max(0, next_tick.load(std::memory_order_relaxed) - 1);
-    if (prop.newest_at_start) return {static_cast<double>(latest) + 0.5, static_cast<double>(latest - visible_count) + 0.5};
-    return {static_cast<double>(latest - visible_count) + 0.5, static_cast<double>(latest) + 0.5};
-}
-inline double Time_Axis::Private::tick_step(const Attached auto* object, Axis_Range coordinate_range) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& current_prop = double_buffer::detail::Internal_Access::current_prop(object);
-    const auto& time_state = static_cast<const Prop&>(current_prop);
-    const auto& axis_state = static_cast<const Abs_Axis::Prop&>(current_prop);
-    const double label_width = std::max(76.0, time_state.estimated_label_width_px);
-    const double label_count = std::max(1.0, std::abs(axis_state.pixel_length) / (label_width + std::max(0.0, time_state.tick_label_spacing_px)));
-    return std::max(1.0, std::ceil(coordinate_range.size() / label_count));
-}
-inline std::string Time_Axis::Private::tick_label(const Attached auto* object, double tick) const {
-    using Object = std::remove_cv_t<std::remove_pointer_t<decltype(object)>>;
-    const auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const int target = static_cast<int>(std::llround(tick));
-    const auto find_label = [&](std::span<const std::pair<Axis_Time_Tick, Time_Of_Day>> samples) {
-        const auto current = std::find_if(samples.begin(), samples.end(), [target](const auto& sample) {
-            return sample.first == target;
-        });
-        return current == samples.end() ? std::string{} : formatted_time(current->second, prop.format);
-    };
-    if (!active_samples.empty()) return find_label(active_samples);
-    return double_buffer::detail::Internal_Access::access_query_stream<Time_Axis_Stream_Tag>(object, find_label);
-}
-inline std::size_t Time_Axis::Private::time_point_count(const Attached auto* object) const {
-    return double_buffer::detail::Internal_Access::access_query_stream<Time_Axis_Stream_Tag>(object,
-        [](std::span<const std::pair<Axis_Time_Tick, Time_Of_Day>> samples) {
-            return samples.size();
-        });
-}
-inline int Time_Axis::Private::append_time(Attached auto* object, Time_Of_Day time) {
-    const int tick = next_tick.fetch_add(1, std::memory_order_relaxed);
-    double_buffer::detail::Internal_Access::submit_stream<Time_Axis_Stream_Tag>(object, std::pair{tick, time});
-    double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    return tick;
-}
-inline Time_Of_Day Time_Axis::Private::tick_to_time(const Attached auto* object, int tick) const {
-    return double_buffer::detail::Internal_Access::access_query_stream<Time_Axis_Stream_Tag>(object,
-        [tick](std::span<const std::pair<Axis_Time_Tick, Time_Of_Day>> samples) {
-            const auto current = std::find_if(samples.begin(), samples.end(), [tick](const auto& sample) {
-                return sample.first == tick;
-            });
-            return current == samples.end() ? Time_Of_Day{} : current->second;
-        });
-}
-template <Axis_Object Object>
-void Time_Axis::Private::bind_private_crtp(Object* object) {
-    Prev_Private::bind_private_crtp(object);
-}
-inline void Time_Axis::Private::prepare_data(Attached auto* object) {
-    using Object = std::remove_pointer_t<decltype(object)>;
-    double_buffer::detail::Internal_Access::exchange_stream<Time_Axis_Stream_Tag>(object);
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& prop = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    double_buffer::detail::Internal_Access::accumulate_stream<Time_Axis_Stream_Tag>(object,
-        static_cast<std::size_t>(std::max<Axis_Visible_Count>(2, prop.visible_count)));
-    auto& state = static_cast<State&>(double_buffer::detail::Internal_Access::pending_state(object));
-    state.next_tick = next_tick.load(std::memory_order_relaxed);
-    double_buffer::detail::Internal_Access::access_rendering_stream<Time_Axis_Stream_Tag>(object,
-        [&](std::span<std::pair<Axis_Time_Tick, Time_Of_Day>> samples) {
-            active_samples = samples;
-            Prev_Private::prepare_data(object);
-            active_samples = {};
-        });
-}
-inline void Time_Axis::Private::paint(Attached auto* object) {
-    Prev_Private::paint(object);
-}
-template <typename Object, typename Owner, typename Member, typename State_Type>
-void Time_Axis::Private::after_state_set(Object* object, Member Owner::*, State_Access<State_Type>) {
-    if constexpr (std::same_as<Owner, State>)
-        double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-}
diff --git a/render_2D/render_2D/base/Frame_2D.cpp b/render_2D/render_2D/base/Frame_2D.cpp
deleted file mode 100644
index 2a3167e..0000000
--- a/render_2D/render_2D/base/Frame_2D.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "Frame_2D.hpp"
-#include <algorithm>
-#include <stdexcept>
-namespace aethera::render_2d {
-struct Frame_2D::Private {
-    Blend2D_Cache color{};                                  /* Scene 直接合成的原生 PRGB32 颜色层。 */
-    Pixel_Format output_format{native_pixel_format};        /* 调用方为本帧选择的最终协议格式。 */
-};
-Frame_2D::Frame_2D(Frame_Identity identity, Pixel_Format output_format)
-    : Render_Frame(identity), d(std::make_unique<Private>()) {
-    begin(identity, output_format);
-}
-void Frame_2D::begin(Frame_Identity identity, Pixel_Format output_format,
-                     Frame_Request_Source source) {
-    if (std::ranges::find(supported_pixel_formats, output_format) ==
-        supported_pixel_formats.end())
-        throw std::invalid_argument("Frame_2D output pixel format is unsupported");
-    Render_Frame::begin(identity, source);
-    d->output_format = output_format;
-}
-Frame_2D::~Frame_2D() = default;
-Pixel_Format Frame_2D::output_format() const noexcept {
-    return d->output_format;
-}
-Image_View Frame_2D::image() const { return d->color.view(); }
-Pixel_Buffer Frame_2D::output_pixels() const {
-    return d->color.output_pixels(d->output_format);
-}
-Blend2D_Cache& detail::Frame_2D_Access::render_target(
-    not_null<Frame_2D*> frame) {
-    return frame->d->color;
-}
-}
diff --git a/render_2D/render_2D/base/Frame_2D.hpp b/render_2D/render_2D/base/Frame_2D.hpp
deleted file mode 100644
index 7944f64..0000000
--- a/render_2D/render_2D/base/Frame_2D.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-#include "../render/Blend2D_Cache.hpp"
-#include <frame.hpp>
-#include <ownership.hpp>
-#include <array>
-#include <memory>
-namespace aethera::render_2d {
-struct Frame_2D;
-namespace detail {
-struct Frame_2D_Access {
-    [[nodiscard]] static Blend2D_Cache& render_target(
-        not_null<Frame_2D*> frame);
-};
-}
-struct Frame_2D final : public Render_Frame {
-public:
-    static constexpr Pixel_Format native_pixel_format{
-        Pixel_Format::bgra8_premultiplied
-    };
-    static constexpr std::array supported_pixel_formats{
-        native_pixel_format, Pixel_Format::rgba8
-    };
-    explicit Frame_2D(Frame_Identity identity,
-                      Pixel_Format output_format = native_pixel_format);
-    ~Frame_2D() override;
-    /* 保留二维后端图像分配，只重启物理槽承载的新逻辑帧。 */
-    void begin(Frame_Identity identity,
-               Pixel_Format output_format = native_pixel_format,
-               Frame_Request_Source source = Frame_Request_Source::unspecified);
-    [[nodiscard]] Pixel_Format output_format() const noexcept;
-    [[nodiscard]] Image_View image() const;
-    /* 按本帧声明的输出格式生成连续像素；原生格式只做必要的行打包。 */
-    [[nodiscard]] Pixel_Buffer output_pixels() const;
-private:
-    struct Private;
-    std::unique_ptr<Private> d; /* 最终二维颜色层及本帧输出格式。 */
-    friend struct detail::Frame_2D_Access;
-};
-}
diff --git a/render_2D/render_2D/base/Renderable_2D.hpp b/render_2D/render_2D/base/Renderable_2D.hpp
deleted file mode 100644
index 038d2a7..0000000
--- a/render_2D/render_2D/base/Renderable_2D.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-#include "../render/Blend2D_Cache.hpp"
-#include <renderable.hpp>
-#include <expected>
-#include <functional>
-namespace aethera::render_2d {
-/*
- * 二维绘制能力层。每个对象都具备惰性颜色缓存，是否使用由当前 Prop 决定。
- * Paint 实现只向 Scene 本轮指定的绘制目标输出，不直接选择或清理双缓冲角色。
- */
-struct Renderable_2D
-    : Def<Renderable_2D, Renderable, Tagged_Buffer<Color_Cache, Blend2D_Cache>> {
-    struct Prop : Prev_Prop {
-        bool cache_enabled{};                                /* 是否跨帧复用本对象及其缓存组的完整颜色结果。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-};
-using Renderable_2D_Base = Renderable_2D;
-}
-#include "Renderable_2D.ipp"
diff --git a/render_2D/render_2D/base/Renderable_2D.ipp b/render_2D/render_2D/base/Renderable_2D.ipp
deleted file mode 100644
index 36f6140..0000000
--- a/render_2D/render_2D/base/Renderable_2D.ipp
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-#include <optional>
-#include <stdexcept>
-namespace aethera::render_2d {
-struct Renderable_2D::Private : Prev_Private {
-    using Scene_Attach = std::function<std::expected<void, Dependency_Graph_Error>(not_null<Root*>)>;
-    using Cache_Access = not_null<Blend2D_Cache*> (*)(not_null<Root*>);
-    using Cache_Enabled = bool (*)(not_null<const Root*>);
-    using Event_Region_Run = Rect_F (*)(not_null<const Root*>, Size);
-    Cache_Access pending_cache{};                              /* 非空时返回最终对象本轮可写的缓存物理对象。 */
-    Cache_Enabled cache_enabled{};                            /* 读取最终对象当前发布的运行时缓存策略。 */
-    Event_Region_Run event_region_run{};                       /* 计算最终对象当前事件区域的无虚函数入口。 */
-    Blend2D_Cache* paint_target{};    /* 仅在 Scene Paint 阶段有效的非拥有绘制目标。 */
-    Blend2D_Cache* valid_cache{};     /* 缓存根最近一次完整重绘产生的权威物理缓存。 */
-    Scene_Attach scene_attach{};                               /* Scene Builder 在构造期执行的所属场景及拓扑绑定。 */
-    /* Paint 实现使用：返回 Scene 为本轮指定的目标；未进入 Paint 阶段属于契约错误。 */
-    [[nodiscard]] Blend2D_Cache& paint_surface();
-    /* CRTP 可覆盖：返回最终对象可接收指针与滚轮事件的画布区域；默认覆盖整个 viewport。 */
-    [[nodiscard]] Rect_F event_region(const Attached auto* object, Size viewport) const;
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member,
-                        Prop_Access<Prop_Type> pending_props);
-    template <Attached Object> void bind_private_crtp(Object* object);
-};
-inline bool Renderable_2D::Prop::operator==(const Prop&) const = default;
-inline bool Renderable_2D::State::operator==(const State&) const = default;
-inline Blend2D_Cache& Renderable_2D::Private::paint_surface() {
-    if (!paint_target) throw std::logic_error("2D renderable painted without a scene paint target");
-    return *paint_target;
-}
-inline Rect_F Renderable_2D::Private::event_region(const Attached auto*, Size viewport) const {
-    return {0.0, 0.0, static_cast<double>(viewport.width), static_cast<double>(viewport.height)};
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Renderable_2D::Private::after_prop_set(Object* object, Member Owner::*,
-                                            Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>)
-        double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-template <Attached Object>
-void Renderable_2D::Private::bind_private_crtp(Object* object) {
-    Prev_Private::bind_private_crtp(object);
-    double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    this->event_region_run = [](not_null<const Root*> root, Size viewport) {
-        const auto* value = static_cast<const Object*>(root.get());
-        const auto& private_data = double_buffer::detail::Internal_Access::get(value);
-        return private_data.event_region(value, viewport);
-    };
-    this->pending_cache = [](not_null<Root*> root) {
-        return not_null{&double_buffer::detail::Internal_Access::pending_buffer<Color_Cache>(
-            static_cast<Object*>(root.get()))};
-    };
-    this->cache_enabled = [](not_null<const Root*> root) {
-        const auto* value = static_cast<const Object*>(root.get());
-        const Renderable_2D::Prop& prop =
-            double_buffer::detail::Internal_Access::current_prop_layer<Renderable_2D::Base_Tag>(value);
-        return prop.cache_enabled;
-    };
-}
-}
diff --git a/render_2D/render_2D/main.cpp b/render_2D/render_2D/main.cpp
deleted file mode 100644
index 3604681..0000000
--- a/render_2D/render_2D/main.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "axis/Axis.hpp"
diff --git a/render_2D/render_2D/base/Types.hpp b/render_2D/render_2D/module/base/Types.hpp
similarity index 78%
rename from render_2D/render_2D/base/Types.hpp
rename to render_2D/render_2D/module/base/Types.hpp
index 0ed0436..30a7abf 100644
--- a/render_2D/render_2D/base/Types.hpp
+++ b/render_2D/render_2D/module/base/Types.hpp
@@ -1,11 +1,23 @@
 #pragma once
-#include <visual_common.hpp>
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <span>
+#include <vector>
 namespace aethera::render_2d {
+/* 二维模块使用的非预乘 RGBA8 颜色。 */
+struct Color {
+    std::uint8_t red{};   /* 红色通道。 */
+    std::uint8_t green{}; /* 绿色通道。 */
+    std::uint8_t blue{};  /* 蓝色通道。 */
+    std::uint8_t alpha{}; /* 不透明度通道。 */
+    [[nodiscard]] static constexpr Color transparent() noexcept { return {}; }
+    [[nodiscard]] static constexpr Color black() noexcept { return {0, 0, 0, 255}; }
+    [[nodiscard]] static constexpr Color white() noexcept { return {255, 255, 255, 255}; }
+    [[nodiscard]] static constexpr Color red_color() noexcept { return {255, 0, 0, 255}; }
+    bool operator==(const Color&) const = default;
+};
 /* 缓存依赖标签；具体字段变化通过该图使缓存拥有者失效。 */
 struct Render_Cache_Tag {};
 /* 整数二维坐标。 */
@@ -88,15 +100,25 @@ using Pixel = std::uint32_t;
     const auto blue = static_cast<std::uint32_t>((color.blue * color.alpha + 127) / 255);
     return (static_cast<std::uint32_t>(color.alpha) << 24) | (red << 16) | (green << 8) | blue;
 }
-[[nodiscard]] constexpr Pixel pack_rgba(std::uint8_t red,
-                                        std::uint8_t green,
-                                        std::uint8_t blue,
-                                        std::uint8_t alpha = 255) noexcept {
+[[nodiscard]] constexpr Pixel pack_rgba(std::uint8_t red, std::uint8_t green, std::uint8_t blue, std::uint8_t alpha = 255) noexcept {
     return premultiply(Color{red, green, blue, alpha});
 }
-enum struct Line_Style : std::uint8_t { none, solid, dash, dot };
-enum struct Line_Cap : std::uint8_t { butt, square, round };
-enum struct Line_Join : std::uint8_t { miter, bevel, round };
+enum struct Line_Style : std::uint8_t {
+    none,  /* 不绘制线条。 */
+    solid, /* 连续实线。 */
+    dash,  /* 长划线。 */
+    dot    /* 点线。 */
+};
+enum struct Line_Cap : std::uint8_t {
+    butt,   /* 端点止于路径位置。 */
+    square, /* 方形延伸端点。 */
+    round   /* 圆形端点。 */
+};
+enum struct Line_Join : std::uint8_t {
+    miter, /* 尖角连接。 */
+    bevel, /* 斜切连接。 */
+    round  /* 圆角连接。 */
+};
 /* 线条和文字前景样式。 */
 struct Pen {
     Color color{Color::white()}; /* 描边或文字颜色。 */
@@ -109,7 +131,10 @@ struct Pen {
     }
     bool operator==(const Pen&) const = default;
 };
-enum struct Brush_Style : std::uint8_t { none, solid };
+enum struct Brush_Style : std::uint8_t {
+    none, /* 不填充。 */
+    solid /* 纯色填充。 */
+};
 /* 区域填充样式。 */
 struct Brush {
     Color color{Color::transparent()}; /* 填充颜色。 */
@@ -131,7 +156,11 @@ struct Number_Locale {
     char decimal_point{'.'}; /* 替换默认小数点的字符。 */
     bool operator==(const Number_Locale&) const = default;
 };
-enum struct Image_Interpolation_Mode : std::uint8_t { nearest, bilinear, bicubic };
+enum struct Image_Interpolation_Mode : std::uint8_t {
+    nearest, /* 最近邻采样。 */
+    bilinear, /* 双线性采样。 */
+    bicubic  /* 双三次采样。 */
+};
 enum struct Line_Interpolation_Mode : std::uint8_t {
     nearest_sample,
     linear_value,
diff --git a/render_2D/render_2D/event/Event.hpp b/render_2D/render_2D/module/base/event/Event.hpp
similarity index 100%
rename from render_2D/render_2D/event/Event.hpp
rename to render_2D/render_2D/module/base/event/Event.hpp
diff --git a/render_2D/render_2D/event/Event_Routing_Rules.hpp b/render_2D/render_2D/module/base/event/Event_Routing_Rules.hpp
similarity index 100%
rename from render_2D/render_2D/event/Event_Routing_Rules.hpp
rename to render_2D/render_2D/module/base/event/Event_Routing_Rules.hpp
diff --git a/render_2D/render_2D/render/Blend2D_Cache.cpp b/render_2D/render_2D/module/base/frame/Blend2D_Cache.cpp
similarity index 100%
rename from render_2D/render_2D/render/Blend2D_Cache.cpp
rename to render_2D/render_2D/module/base/frame/Blend2D_Cache.cpp
diff --git a/render_2D/render_2D/render/Blend2D_Cache.hpp b/render_2D/render_2D/module/base/frame/Blend2D_Cache.hpp
similarity index 96%
rename from render_2D/render_2D/render/Blend2D_Cache.hpp
rename to render_2D/render_2D/module/base/frame/Blend2D_Cache.hpp
index 93ecb6e..c63b7ad 100644
--- a/render_2D/render_2D/render/Blend2D_Cache.hpp
+++ b/render_2D/render_2D/module/base/frame/Blend2D_Cache.hpp
@@ -1,7 +1,5 @@
 #pragma once
-#include "../base/Types.hpp"
-#include <renderable.hpp>
-#include <ownership.hpp>
+#include "../Types.hpp"
 #include <memory>
 #include <optional>
 #include <span>
@@ -16,10 +14,10 @@ struct Painter;
  * 该头文件故意不包含任何 Blend2D 头文件，也不暴露 BL* 类型；
  * 具体 Blend2D 图像/上下文实现全部留在 render 目录的实现文件中。
  */
-struct Blend2D_Cache : Color_Cache {
+struct Blend2D_Cache {
     struct Private;
     Blend2D_Cache();
-    ~Blend2D_Cache() override;
+    ~Blend2D_Cache();
     Blend2D_Cache(const Blend2D_Cache& other);
     Blend2D_Cache& operator=(const Blend2D_Cache& other);
     Blend2D_Cache(Blend2D_Cache&& other) noexcept;
diff --git a/render_2D/render_2D/render/Blend2D_Cache.ipp b/render_2D/render_2D/module/base/frame/Blend2D_Cache.ipp
similarity index 100%
rename from render_2D/render_2D/render/Blend2D_Cache.ipp
rename to render_2D/render_2D/module/base/frame/Blend2D_Cache.ipp
diff --git a/render_2D/render_2D/module/base/frame/Frame_2D.cpp b/render_2D/render_2D/module/base/frame/Frame_2D.cpp
new file mode 100644
index 0000000..032e08f
--- /dev/null
+++ b/render_2D/render_2D/module/base/frame/Frame_2D.cpp
@@ -0,0 +1,30 @@
+#include "Frame_2D.hpp"
+#include <algorithm>
+#include <stdexcept>
+namespace aethera::render_2d {
+struct Frame_2D::Private {
+    Blend2D_Cache color{}; /* Scene 合成的原生 PRGB32 颜色层。 */
+    Frame_Identity identity{}; /* 当前逻辑帧标识。 */
+    Frame_Request_Source source{Frame_Request_Source::unspecified}; /* 当前逻辑帧请求来源。 */
+    Pixel_Format output_format{native_pixel_format}; /* 调用方选择的最终像素协议。 */
+};
+Frame_2D::Frame_2D(Frame_Identity identity, Pixel_Format output_format) : d(std::make_unique<Private>()) { begin(identity, output_format); }
+Frame_2D::~Frame_2D() = default;
+Frame_2D::Frame_2D(Frame_2D&&) noexcept = default;
+Frame_2D& Frame_2D::operator=(Frame_2D&&) noexcept = default;
+void Frame_2D::begin(Frame_Identity identity, Pixel_Format output_format, Frame_Request_Source source) {
+    if (std::ranges::find(supported_pixel_formats, output_format) == supported_pixel_formats.end()) throw std::invalid_argument("Frame_2D output pixel format is unsupported");
+    d->identity = identity;
+    d->source = source;
+    d->output_format = output_format;
+}
+Frame_Identity Frame_2D::identity() const noexcept { return d->identity; }
+Frame_Request_Source Frame_2D::source() const noexcept { return d->source; }
+Pixel_Format Frame_2D::output_format() const noexcept { return d->output_format; }
+Image_View Frame_2D::image() const { return d->color.view(); }
+Pixel_Buffer Frame_2D::output_pixels() const { return d->color.output_pixels(d->output_format); }
+Blend2D_Cache& detail::Frame_2D_Access::render_target(Frame_2D* frame) {
+    if (!frame) throw std::invalid_argument("Frame_2D render target is null");
+    return frame->d->color;
+}
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/module/base/frame/Frame_2D.hpp b/render_2D/render_2D/module/base/frame/Frame_2D.hpp
new file mode 100644
index 0000000..94fd09c
--- /dev/null
+++ b/render_2D/render_2D/module/base/frame/Frame_2D.hpp
@@ -0,0 +1,41 @@
+#pragma once
+#include "Blend2D_Cache.hpp"
+#include <array>
+#include <cstdint>
+#include <memory>
+namespace aethera::render_2d {
+struct Frame_Identity {
+    std::uint64_t sequence{};   /* 生产者分配的单调帧序号。 */
+    std::uint64_t generation{}; /* 物理帧槽被复用的代次。 */
+};
+enum struct Frame_Request_Source : std::uint8_t {
+    unspecified /* 调用方未声明请求来源。 */
+};
+struct Frame_2D;
+namespace detail {
+struct Frame_2D_Access {
+    [[nodiscard]] static Blend2D_Cache& render_target(Frame_2D* frame);
+};
+}
+/* Frame Policy 独占拥有并复用的二维物理帧。 */
+struct Frame_2D final {
+    static constexpr Pixel_Format native_pixel_format{Pixel_Format::bgra8_premultiplied};
+    static constexpr std::array supported_pixel_formats{native_pixel_format, Pixel_Format::rgba8};
+    explicit Frame_2D(Frame_Identity identity, Pixel_Format output_format = native_pixel_format);
+    ~Frame_2D();
+    Frame_2D(Frame_2D&&) noexcept;
+    Frame_2D& operator=(Frame_2D&&) noexcept;
+    Frame_2D(const Frame_2D&) = delete;
+    Frame_2D& operator=(const Frame_2D&) = delete;
+    void begin(Frame_Identity identity, Pixel_Format output_format = native_pixel_format, Frame_Request_Source source = Frame_Request_Source::unspecified);
+    [[nodiscard]] Frame_Identity identity() const noexcept;
+    [[nodiscard]] Frame_Request_Source source() const noexcept;
+    [[nodiscard]] Pixel_Format output_format() const noexcept;
+    [[nodiscard]] Image_View image() const;
+    [[nodiscard]] Pixel_Buffer output_pixels() const;
+private:
+    struct Private;
+    std::unique_ptr<Private> d; /* 唯一拥有帧标识、输出协议和最终二维颜色层。 */
+    friend struct detail::Frame_2D_Access;
+};
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/module/renderable/Renderable_2D.hpp b/render_2D/render_2D/module/renderable/Renderable_2D.hpp
new file mode 100644
index 0000000..f1937bf
--- /dev/null
+++ b/render_2D/render_2D/module/renderable/Renderable_2D.hpp
@@ -0,0 +1,10 @@
+#pragma once
+#include "../base/frame/Blend2D_Cache.hpp"
+#include "renderable/src/renderable.hpp"
+namespace aethera::render_2d {
+/* 二维绘制能力定义层；自身与后续派生层都可作为独立 Model endpoint。 */
+struct Renderable_2D : Def<Renderable_2D, aethera::Renderable> {
+    struct Private;
+};
+} // namespace aethera::render_2d
+#include "Renderable_2D.ipp"
diff --git a/render_2D/render_2D/module/renderable/Renderable_2D.ipp b/render_2D/render_2D/module/renderable/Renderable_2D.ipp
new file mode 100644
index 0000000..1ad14ef
--- /dev/null
+++ b/render_2D/render_2D/module/renderable/Renderable_2D.ipp
@@ -0,0 +1,26 @@
+#pragma once
+namespace aethera::render_2d {
+struct Renderable_2D::Private : Prev_Private {
+    void render(Blend2D_Cache& target, Size viewport) noexcept;
+    template <typename Self> void advance_renderable(this Self& self);
+private:
+    Blend2D_Cache* paint_target{}; /* 非拥有借用；仅在单帧 Scene Task Graph 完成前有效。 */
+    Size paint_viewport{};         /* 当前单帧绘制目标的像素尺寸。 */
+};
+
+inline void Renderable_2D::Private::render(Blend2D_Cache& target, Size viewport) noexcept {
+    paint_target = std::addressof(target);
+    paint_viewport = viewport;
+}
+
+template <typename Self> void Renderable_2D::Private::advance_renderable(this Self& self) {
+    auto& graph = self.internal_taskflow();
+    graph->clear();
+    auto* private_data = std::addressof(self); /* 非拥有借用；最终 Model Private 比自身任务图存活更久。 */
+    (void)graph->add("paint", [private_data] {
+        if (!private_data->paint_target || private_data->paint_viewport.empty()) return;
+        detail::Painter painter(*private_data->paint_target, private_data->paint_viewport);
+        if constexpr (requires { private_data->paint(painter, private_data->paint_viewport); }) private_data->paint(painter, private_data->paint_viewport);
+    });
+}
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/module/scene/Render_Scene_2D.cpp b/render_2D/render_2D/module/scene/Render_Scene_2D.cpp
new file mode 100644
index 0000000..42a7f6a
--- /dev/null
+++ b/render_2D/render_2D/module/scene/Render_Scene_2D.cpp
@@ -0,0 +1,63 @@
+#include "Render_Scene_2D.hpp"
+#include <optional>
+#include <string>
+#include <utility>
+namespace aethera::render_2d {
+proxy<scene::Task_Graph> scene::make_task_graph(std::string name) { return task_flow::make_task_graph(std::move(name)); }
+
+Render_Scene_2D::Render_Scene_2D() = default;
+Render_Scene_2D::~Render_Scene_2D() noexcept = default;
+
+Render_Scene_2D::Private::Advance_Result Render_Scene_2D::Private::advance(Blend2D_Cache& target, Size viewport, Color background) {
+    target.ensure_size(viewport);
+    detail::Painter painter(target, viewport);
+    painter.clear();
+    painter.rect({0.0, 0.0, static_cast<double>(viewport.width), static_cast<double>(viewport.height)}, Pen{Color::transparent(), 0.0, Line_Style::none}, Brush{background, Brush_Style::solid});
+    auto next_graph = scene::make_task_graph("render_2d.scene");
+    std::unordered_map<std::uint64_t, proxy<task_flow::Task_Node>> nodes;
+    auto& renderables = get<Render_Scene_2D>();
+    renderables.internal.advance();
+    std::optional<Render_Scene_2D_Error> error;
+    renderables.internal.use().for_each_topological([&](Dag_Node_Id id, proxy<scene::Renderable>& renderable) {
+        if (error) return;
+        renderable->render(target, viewport);
+        renderable->advance();
+        auto component = renderable->taskflow();
+        auto composed = next_graph->compose("renderable." + std::to_string(id.value), component);
+        if (!composed) {
+            error = composed.error();
+            return;
+        }
+        nodes.emplace(id.value, std::move(*composed));
+    });
+    if (error) return std::unexpected(*error);
+    renderables.internal.use().for_each_dependency([&](Dag_Node_Id target_id, Dag_Node_Id source_id) {
+        if (error) return;
+        const auto result = next_graph->precede(nodes.at(source_id.value), nodes.at(target_id.value));
+        if (result != Precede_Task_Graph_Result::preceded) error = result;
+    });
+    if (error) return std::unexpected(*error);
+    graph = std::move(next_graph);
+    return {};
+}
+
+Render_Scene_2D_Result Render_Scene_2D::Private::render(Frame_2D* frame, Completion completion) {
+    if (!frame) return std::unexpected(Render_Scene_2D_Error{Render_Scene_2D_State_Result::frame_missing});
+    if (!completion) return std::unexpected(Render_Scene_2D_Error{Render_Scene_2D_State_Result::completion_missing});
+    auto& properties = get<Prop_Tag>();
+    properties.internal.advance();
+    const Prop current = *properties.internal.use();
+    if (!current.view_active) return std::unexpected(Render_Scene_2D_Error{Render_Scene_2D_State_Result::view_inactive});
+    if (current.viewport.empty()) return std::unexpected(Render_Scene_2D_Error{Render_Scene_2D_State_Result::empty_viewport});
+    auto& target = detail::Frame_2D_Access::render_target(frame);
+    const auto advanced = advance(target, current.viewport, current.background);
+    if (!advanced) return advanced;
+    const auto submitted = graph->run([frame, completion = std::move(completion)](std::exception_ptr failure) mutable { completion(frame, std::move(failure)); });
+    if (submitted != Run_Taskflow_Result::submitted) return std::unexpected(Render_Scene_2D_Error{submitted});
+    return {};
+}
+
+Render_Scene_2D_Result Render_Scene_2D::render(Frame_2D* frame, Completion completion) { return d->render(frame, std::move(completion)); }
+void Render_Scene_2D::activate_view() { set<Import_Struct_With_Dirty, Prop_Tag>(&Prop::view_active, true); }
+void Render_Scene_2D::deactivate_view() { set<Import_Struct_With_Dirty, Prop_Tag>(&Prop::view_active, false); }
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/module/scene/Render_Scene_2D.hpp b/render_2D/render_2D/module/scene/Render_Scene_2D.hpp
new file mode 100644
index 0000000..0a91c39
--- /dev/null
+++ b/render_2D/render_2D/module/scene/Render_Scene_2D.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include "../base/frame/Frame_2D.hpp"
+#include "export/export.h"
+#include "model/Model.hpp"
+#include "relation/Dag.hpp"
+#include "rely_facade.h"
+#include <exception>
+#include <functional>
+namespace aethera::render_2d {
+/* 执行二维 Renderable DAG 并向调用方拥有的物理帧合成像素。 */
+struct Render_Scene_2D : Def<Render_Scene_2D, Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<Render_Scene_2D, Owned_Dag, scene::Renderable>> {
+    struct Prop : Prev<Prop_Tag> {
+        Size viewport{};                    /* 最终帧像素尺寸；空尺寸不提交渲染。 */
+        Color background{Color::black()};   /* 每帧绘制 Renderable 前写入的背景颜色。 */
+        bool view_active{};                 /* true 时允许产生新的完成帧。 */
+    };
+    struct Private;
+    using Completion = std::function<void(Frame_2D*, std::exception_ptr)>;
+    Render_Scene_2D();
+    ~Render_Scene_2D() noexcept;
+    /* frame 是非拥有借用，并须存活到 completion 返回；同一 Scene 仅允许一帧在途。 */
+    [[nodiscard]] Render_Scene_2D_Result render(Frame_2D* frame, Completion completion);
+    void activate_view();
+    void deactivate_view();
+};
+} // namespace aethera::render_2d
+#include "Render_Scene_2D.ipp"
diff --git a/render_2D/render_2D/module/scene/Render_Scene_2D.ipp b/render_2D/render_2D/module/scene/Render_Scene_2D.ipp
new file mode 100644
index 0000000..4e1d45d
--- /dev/null
+++ b/render_2D/render_2D/module/scene/Render_Scene_2D.ipp
@@ -0,0 +1,11 @@
+#pragma once
+#include <unordered_map>
+namespace aethera::render_2d {
+struct Render_Scene_2D::Private : Prev_Private {
+    using Advance_Result = std::expected<void, Render_Scene_2D_Error>;
+    Render_Scene_2D_Result render(Frame_2D* frame, Completion completion);
+private:
+    Advance_Result advance(Blend2D_Cache& target, Size viewport, Color background);
+    proxy<scene::Task_Graph> graph{scene::make_task_graph("render_2d.scene")}; /* 唯一拥有当前单帧组合任务图。 */
+};
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/scene/Scene.hpp b/render_2D/render_2D/module/scene/Scene.hpp
similarity index 100%
rename from render_2D/render_2D/scene/Scene.hpp
rename to render_2D/render_2D/module/scene/Scene.hpp
diff --git a/render_2D/render_2D/module/scene/export/export.h b/render_2D/render_2D/module/scene/export/export.h
new file mode 100644
index 0000000..7925b9c
--- /dev/null
+++ b/render_2D/render_2D/module/scene/export/export.h
@@ -0,0 +1,15 @@
+#pragma once
+#include "task_flow/export/export.h"
+#include <cstdint>
+#include <expected>
+#include <variant>
+namespace aethera::render_2d {
+enum struct Render_Scene_2D_State_Result : std::uint8_t {
+    frame_missing,      /* 未提供调用方拥有的物理帧。 */
+    completion_missing, /* 未提供异步完成接收边界。 */
+    view_inactive,      /* 当前视图未启用。 */
+    empty_viewport      /* 当前视口没有可绘制像素。 */
+};
+using Render_Scene_2D_Error = std::variant<Render_Scene_2D_State_Result, Compose_Task_Graph_Result, Precede_Task_Graph_Result, Run_Taskflow_Result>;
+using Render_Scene_2D_Result = std::expected<void, Render_Scene_2D_Error>;
+} // namespace aethera::render_2d
diff --git a/render_2D/render_2D/module/scene/rely_facade.h b/render_2D/render_2D/module/scene/rely_facade.h
new file mode 100644
index 0000000..e49b766
--- /dev/null
+++ b/render_2D/render_2D/module/scene/rely_facade.h
@@ -0,0 +1,14 @@
+#pragma once
+#include "../base/frame/Blend2D_Cache.hpp"
+#include "global.hpp"
+#include <scene/rely_facade.h>
+#include <string>
+namespace aethera::render_2d::scene {
+struct Renderable : facade_builder
+::add_facade_with_substitution<aethera::scene::Renderable>
+::add_convention<_render, void(Blend2D_Cache&, Size) noexcept>
+::support_relocation<pro::constraint_level::nothrow>
+::build {};
+using Task_Graph = task_flow::Task_Graph_Compose_Facade;
+proxy<Task_Graph> make_task_graph(std::string name);
+} // namespace aethera::render_2d::scene
diff --git a/render_2D/render_2D/plottable/Afterglow.cpp b/render_2D/render_2D/plottable/Afterglow.cpp
deleted file mode 100644
index 8ea0401..0000000
--- a/render_2D/render_2D/plottable/Afterglow.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "Afterglow.hpp"                                   /* Afterglow 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Afterglow::Prop::operator==(const Prop&) const = default;
-bool Afterglow::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Afterglow.hpp b/render_2D/render_2D/plottable/Afterglow.hpp
deleted file mode 100644
index 57000ca..0000000
--- a/render_2D/render_2D/plottable/Afterglow.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <memory_resource>
-#include <span>
-#include <vector>
-namespace aethera::render_2d {
-struct Afterglow_Stream_Tag {};
-struct Afterglow : Def<Afterglow, Renderable_2D,
-    Mpmc_Triple_Buffer<Afterglow_Stream_Tag,
-                       std::shared_ptr<const std::vector<Plot_Value>>>> {
-    using Scene_Object = Render_Scene_2D; using Frequency_Object = Frequency_Axis; using Power_Object = Numeric_Axis;
-    struct Prop : Prev_Prop {
-        std::size_t frequency_point_size{};                        /* 栅格频率列数；零值使用最新频谱尺寸。 */
-        std::size_t power_point_size{};                            /* 栅格功率行数；零值使用默认尺寸。 */
-        Plot_Partition_Grid partition_grid{};                      /* framebuffer 按列×行显式分块；任一维为零时禁用栅格任务。 */
-        bool interpolate{true};                                    /* 是否对频谱列执行线性重采样。 */
-        Plot_Ratio attenuation_rate{0.2};                          /* 每增加一帧历史的强度衰减比例。 */
-        Axis_Range frequency_range{0.0, 10.0};                    /* 输入频谱覆盖的频率范围。 */
-        Axis_Range power_range{0.0, 10.0};                        /* 色块纵向覆盖的功率范围。 */
-        Color_Map color_map{};                                     /* 强度到颜色的映射。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object> struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Frequency_Object*> frequency_axis,
-                not_null<Power_Object*> power_axis,
-                Plot_Partition_Grid partition_grid = {});
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Frequency_Object*> frequency_axis;          /* 不拥有的频率轴；生命周期必须覆盖 Afterglow。 */
-        not_null<Power_Object*> power_axis;                  /* 不拥有的功率轴；生命周期必须覆盖 Afterglow。 */
-    };
-};
-}
-#include "Afterglow.ipp"
diff --git a/render_2D/render_2D/plottable/Afterglow.ipp b/render_2D/render_2D/plottable/Afterglow.ipp
deleted file mode 100644
index 61aad2d..0000000
--- a/render_2D/render_2D/plottable/Afterglow.ipp
+++ /dev/null
@@ -1,257 +0,0 @@
-#pragma once
-#include <optional>
-#include "common/Curve_Plot.hpp"
-#include "common/Raster_Plot.hpp"
-#include <iterator>
-namespace aethera::render_2d {
-struct Afterglow::Private : Prev_Private {
-    struct Prepared {
-        std::vector<std::shared_ptr<const std::vector<Plot_Value>>> source_spectra{}; /* Rendering-role ownership retained across Prepare tasks. */
-        detail::Raster_Layout layout{}; /* 两根轴决定的色块矩阵布局。 */
-        std::vector<Plot_Ratio> intensity{}; /* 历史频谱衰减累加后的未归一化强度。 */
-        std::vector<Pixel> pixels{}; /* 归一化强度经色图转换后的像素矩阵。 */
-        std::vector<Plot_Ratio> partition_maxima{}; /* 各独占分块在累加后产生的归约输入。 */
-        Size canvas{}; /* 当前 Scene viewport 的像素尺寸。 */
-        Plot_Ratio maximum{1.0}; /* 本帧强度归一化分母，最小为 1。 */
-        bool valid{}; /* 轴布局和输入数据是否足以生成色块。 */
-    };
-    Scene_Object* scene{}; /* 不拥有的所属 Scene。 */
-    Frequency_Object* frequency_axis{}; /* 不拥有的频率轴。 */
-    Power_Object* power_axis{}; /* 不拥有的功率轴。 */
-    Prepared prepared{}; /* 当前权威状态推导出的 Paint 输入。 */
-    Plot_Partition_Grid graph_partition_grid{}; /* Prepare/Paint 子图当前固化的 framebuffer 列×行网格。 */
-    void bind_sources(not_null<Frequency_Object*> frequency_axis_value,
-                      not_null<Power_Object*> power_axis_value);
-    /* CRTP 覆盖：构建累加、归一化和着色三阶段 Prepare 子图。 */
-    [[nodiscard]] Task_Graph build_graph(Afterglow* object, const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Afterglow* object, const Prop& state);
-    void prepare_frame(Afterglow* object);
-    void accumulate_partition(Afterglow* object, Plot_Partition_Count index);
-    void normalize_frame();
-    void color_partition(Afterglow* object, Plot_Partition_Count index);
-    void paint_partition(Afterglow* object, Plot_Partition_Count index);
-    /* CRTP 覆盖：本类状态写入后标记 Prepare 数据失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> states);
-};
-template <typename Object>
-Afterglow::Builder<Object>::Builder(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value,
-    Plot_Partition_Grid partition_grid)
-    : Base(), frequency_axis(frequency_axis_value),
-      power_axis(power_axis_value) {
-    this->prop.partition_grid = partition_grid;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Afterglow::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto plot = std::move(result).value();
-    auto& private_data = detail::Internal_Access::layer<Object>(plot.get());
-    private_data.bind_sources(frequency_axis, power_axis);
-    private_data.scene_attach = [object = not_null{plot.get()}](
-        not_null<Root*> root) -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::layer<Object>(object.get());
-        data.scene = scene;
-        const auto frequency_axis = not_null{data.frequency_axis};
-        const auto power_axis = not_null{data.power_axis};
-        return detail::Internal_Access::edit_dependency_graph<Render_Graph_Tag, Render_Cache_Tag>(scene.get(), [&](auto& graph, auto& cache) {
-            graph.add_dependency(frequency_axis.get(), object.get());
-            graph.add_dependency(power_axis.get(), object.get());
-            cache.template add_prop_dependency<&Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), power_axis.get());
-        });
-    };
-    return plot;
-}
-inline bool Afterglow::Private::should_rebuild_graph(Afterglow*,
-                                                       const Prop& state) {
-    return graph_partition_grid != state.partition_grid;
-}
-inline Task_Graph Afterglow::Private::build_graph(Afterglow* object, const Prop& state) {
-    graph_partition_grid = state.partition_grid;
-    const Plot_Partition_Count partition_count =
-        detail::raster_partition_count(graph_partition_grid);
-    Task_Graph graph{"afterglow"};
-    auto begin = graph.add("prepare.frame", [this, object] {
-        prepare_frame(object);
-    });
-    auto normalize = graph.add("prepare.normalize", [this] {
-        normalize_frame();
-    });
-    auto colored = graph.add("prepare.color.complete", [] {});
-    if (partition_count == 0) begin.precede(normalize);
-    normalize.precede(colored);
-    for (Plot_Partition_Count index = 0; index < partition_count; ++index) {
-        auto accumulate = graph.add("prepare.accumulate", [this, object, index] {
-            accumulate_partition(object, index);
-        });
-        auto color = graph.add("prepare.color", [this, object, index] {
-            color_partition(object, index);
-        });
-        auto paint = graph.add("paint.partition", [this, object, index] {
-            paint_partition(object, index);
-        });
-        begin.precede(accumulate);
-        accumulate.precede(normalize);
-        normalize.precede(color);
-        color.precede(colored);
-        colored.precede(paint);
-    }
-    return graph;
-}
-inline void Afterglow::Private::prepare_frame(Afterglow* object) {
-    const auto& state = this->template read_current_prop<Afterglow::Base_Tag>(object);
-    detail::Internal_Access::exchange_stream<Afterglow_Stream_Tag>(object);
-    prepared.source_spectra.clear();
-    detail::Internal_Access::access_rendering_stream<Afterglow_Stream_Tag>(object,
-        [&](std::span<std::shared_ptr<const std::vector<Plot_Value>>> spectra) {
-            prepared.source_spectra.assign(spectra.begin(), spectra.end());
-        });
-    detail::Internal_Access::accumulate_stream<Afterglow_Stream_Tag>(object, std::size_t{64});
-    const auto& frequency_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        frequency_axis);
-    const auto& power_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        power_axis);
-    const std::size_t available = prepared.source_spectra.empty() ? 0 : prepared.source_spectra.back()->size();
-    const int columns = static_cast<int>(state.frequency_point_size ? std::min(state.frequency_point_size, available) : available);
-    const int rows = static_cast<int>(state.power_point_size ? state.power_point_size : std::max<Axis_Pixel_Length>(1.0, std::abs(power_layout.pixel_length)));
-    const Size canvas = this->template read_current_prop<Render_Scene_2D::Base_Tag>(
-        scene).viewport;
-    const auto layout = detail::raster_layout(
-        frequency_axis, state.frequency_range, columns,
-        power_axis, state.power_range, rows,
-        frequency_layout.orientation, power_layout.orientation);
-    if (canvas.empty() || !layout.valid()) {
-        prepared.valid = false;
-        return;
-    }
-    const std::size_t cells = static_cast<std::size_t>(columns) * rows;
-    const bool layout_changed = prepared.canvas != canvas ||
-        prepared.layout.width != layout.width || prepared.layout.height != layout.height ||
-        prepared.layout.target != layout.target ||
-        prepared.layout.first_reversed != layout.first_reversed ||
-        prepared.layout.second_reversed != layout.second_reversed ||
-        prepared.layout.first_horizontal != layout.first_horizontal;
-    prepared.canvas = canvas;
-    prepared.layout = layout;
-    if (layout_changed || prepared.intensity.size() != cells) {
-        prepared.intensity.assign(cells, 0.0);
-        prepared.pixels.assign(cells, 0);
-    }
-    prepared.partition_maxima.assign(
-        detail::raster_partition_count(graph_partition_grid), 1.0);
-    prepared.valid = true;
-}
-inline void Afterglow::Private::accumulate_partition(Afterglow* object, Plot_Partition_Count index) {
-    if (!prepared.valid) return;
-    const auto& state = this->template read_current_prop<Afterglow::Base_Tag>(object);
-    const int columns = prepared.layout.first_horizontal ? prepared.layout.width : prepared.layout.height;
-    const int rows = prepared.layout.first_horizontal ? prepared.layout.height : prepared.layout.width;
-    const detail::Raster_Partition partition = detail::raster_partition(
-        prepared.layout, index, graph_partition_grid);
-    if (partition.empty()) return;
-    Plot_Ratio attenuation{1.0};
-    const Plot_Ratio decay = 1.0 - std::clamp(state.attenuation_rate, 0.0, 1.0);
-    const auto& spectra = prepared.source_spectra;
-    const Plot_Ratio retained = std::pow(decay, static_cast<Plot_Ratio>(spectra.size()));
-    for (int y = partition.first_y; y < partition.last_y; ++y)
-        for (int x = partition.first_x; x < partition.last_x; ++x) {
-            const auto [column, row] =
-                detail::raster_coordinates(prepared.layout, x, y);
-            prepared.intensity[static_cast<std::size_t>(row) * columns +
-                               column] *= retained;
-        }
-    for (auto spectrum = spectra.rbegin(); spectrum != spectra.rend() && attenuation >= 0.01; ++spectrum, attenuation *= decay) {
-        const std::size_t count = std::min<std::size_t>(columns, (*spectrum)->size());
-        for (std::size_t column = 0; column < count; ++column) {
-            const int row = std::clamp(static_cast<int>(detail::normalized_plot_value((**spectrum)[column], state.power_range) * (rows - 1)), 0, rows - 1);
-            const std::size_t pixel = prepared.layout.index(
-                static_cast<int>(column), row);
-            const int x = static_cast<int>(pixel % prepared.layout.width);
-            const int y = static_cast<int>(pixel / prepared.layout.width);
-            if (partition.contains(x, y))
-                prepared.intensity[static_cast<std::size_t>(row) * columns +
-                                   column] += attenuation;
-            if (state.interpolate && row + 1 < rows) {
-                const std::size_t adjacent = prepared.layout.index(
-                    static_cast<int>(column), row + 1);
-                const int adjacent_x = static_cast<int>(
-                    adjacent % prepared.layout.width);
-                const int adjacent_y = static_cast<int>(
-                    adjacent / prepared.layout.width);
-                if (partition.contains(adjacent_x, adjacent_y))
-                    prepared.intensity[
-                        static_cast<std::size_t>(row + 1) * columns +
-                        column] += attenuation * 0.35;
-            }
-        }
-    }
-    Plot_Ratio maximum{1.0};
-    for (int y = partition.first_y; y < partition.last_y; ++y)
-        for (int x = partition.first_x; x < partition.last_x; ++x) {
-            const auto [column, row] =
-                detail::raster_coordinates(prepared.layout, x, y);
-            maximum = std::max(maximum, prepared.intensity[
-                static_cast<std::size_t>(row) * columns + column]);
-        }
-    prepared.partition_maxima[index] = maximum;
-}
-inline void Afterglow::Private::normalize_frame() {
-    prepared.maximum = prepared.valid && !prepared.partition_maxima.empty()
-        ? *std::max_element(prepared.partition_maxima.begin(),
-                            prepared.partition_maxima.end())
-        : 1.0;
-}
-inline void Afterglow::Private::color_partition(Afterglow* object, Plot_Partition_Count index) {
-    if (!prepared.valid) return;
-    const auto& state = this->template read_current_prop<Afterglow::Base_Tag>(object);
-    const int columns = prepared.layout.first_horizontal ? prepared.layout.width : prepared.layout.height;
-    const detail::Raster_Partition partition = detail::raster_partition(
-        prepared.layout, index, graph_partition_grid);
-    for (int y = partition.first_y; y < partition.last_y; ++y)
-        for (int x = partition.first_x; x < partition.last_x; ++x) {
-            const auto [column, row] =
-                detail::raster_coordinates(prepared.layout, x, y);
-            const std::size_t cell = static_cast<std::size_t>(row) *
-                columns + column;
-            prepared.pixels[static_cast<std::size_t>(y) *
-                            prepared.layout.width + x] =
-                premultiply(state.color_map.sample(
-                    prepared.intensity[cell] / prepared.maximum));
-        }
-}
-inline void Afterglow::Private::paint_partition(Afterglow*, Plot_Partition_Count index) {
-    if (!prepared.valid || index >=
-            detail::raster_partition_count(graph_partition_grid))
-        return;
-    const Rect_F region = detail::raster_paint_region(
-        prepared.layout, index, graph_partition_grid);
-    if (region.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas, region);
-    detail::paint_raster(painter, prepared.layout, prepared.pixels, Image_Interpolation_Mode::bilinear);
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Afterglow::Private::after_prop_set(Object* object,
-                                        Member Owner::*,
-                                        Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Afterglow::Private::bind_sources(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value) {
-    frequency_axis = frequency_axis_value;
-    power_axis = power_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/Constellation_Diagram.cpp b/render_2D/render_2D/plottable/Constellation_Diagram.cpp
deleted file mode 100644
index b427fe8..0000000
--- a/render_2D/render_2D/plottable/Constellation_Diagram.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Constellation_Diagram.hpp"                       /* Constellation 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Constellation_Point::operator==(const Constellation_Point&) const = default;
-bool Constellation_Diagram::Prop::operator==(const Prop&) const = default;
-bool Constellation_Diagram::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Constellation_Diagram.hpp b/render_2D/render_2D/plottable/Constellation_Diagram.hpp
deleted file mode 100644
index 429ba1e..0000000
--- a/render_2D/render_2D/plottable/Constellation_Diagram.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <vector>
-namespace aethera::render_2d {
-enum struct Constellation_Diagram_Type : std::uint8_t { psk4 = 4, psk8 = 8, psk16 = 16 };
-struct Constellation_Point {
-    Point_F point{};
-    Plot_Duration_Milliseconds submitted_at_ms{};
-    bool operator==(const Constellation_Point&) const;
-};
-struct Constellation_Stream_Tag {};
-struct Constellation_Diagram : Def<Constellation_Diagram,
-                                   Renderable_2D,
-                                   Mpmc_Triple_Buffer<Constellation_Stream_Tag, Constellation_Point>> {
-    using Scene_Object = Render_Scene_2D;
-    using Axis_Object = Numeric_Axis;
-    struct Prop : Prev_Prop {
-        Plot_Partition_Count partition_count{1}; /* 接收点 Paint 子图的显式分块数；零值禁用接收点任务。 */
-        Plot_Duration_Milliseconds point_lifetime_ms{1000}; /* 接收点保留时间，单位为毫秒。 */
-        Constellation_Diagram_Type type{Constellation_Diagram_Type::psk8}; /* 理想 PSK 锚点数量。 */
-        Plot_Ratio phase_offset_radians{}; /* 理想锚点相位偏移，单位为弧度。 */
-        Axis_Range i_range{0.0, 100.0}; /* 同相分量显示范围。 */
-        Axis_Range q_range{0.0, 100.0}; /* 正交分量显示范围。 */
-        Color point_color{Color::red_color()}; /* 接收点颜色。 */
-        Color anchor_color{Color::yellow()}; /* 理想星座锚点颜色。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Axis_Object*> i_axis,
-                not_null<Axis_Object*> q_axis,
-                Plot_Partition_Count partition_count = 1);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Axis_Object*> i_axis; /* 不拥有的同相分量轴；生命周期必须覆盖星座图。 */
-        not_null<Axis_Object*> q_axis; /* 不拥有的正交分量轴；生命周期必须覆盖星座图。 */
-    };
-};
-}
-#include "Constellation_Diagram.ipp"
diff --git a/render_2D/render_2D/plottable/Constellation_Diagram.ipp b/render_2D/render_2D/plottable/Constellation_Diagram.ipp
deleted file mode 100644
index 1b39c36..0000000
--- a/render_2D/render_2D/plottable/Constellation_Diagram.ipp
+++ /dev/null
@@ -1,212 +0,0 @@
-#pragma once
-#include <optional>
-#include "common/Curve_Plot.hpp"
-#include <algorithm>
-#include <numbers>
-namespace aethera::render_2d {
-struct Constellation_Diagram::Private : Prev_Private {
-    struct Prepared {
-        std::vector<Point_F> points{}; /* 尚未过期的接收点画布坐标。 */
-        std::vector<Point_F> anchors{}; /* 当前调制类型的理想锚点画布坐标。 */
-        Size canvas{}; /* 当前 Scene viewport 的像素尺寸。 */
-        bool valid{}; /* 两根轴是否正交且画布有效。 */
-    };
-    Scene_Object* scene{}; /* 不拥有的所属 Scene。 */
-    Axis_Object* i_axis{}; /* 不拥有的同相分量轴。 */
-    Axis_Object* q_axis{}; /* 不拥有的正交分量轴。 */
-    Prepared prepared{}; /* 当前权威状态推导出的 Paint 输入。 */
-    void bind_sources(not_null<Axis_Object*> i_axis_value,
-                      not_null<Axis_Object*> q_axis_value);
-    /* CRTP 覆盖：从当前点集和轴状态准备画布坐标。 */
-    void prepare_data(Constellation_Diagram* object);
-    /* CRTP 覆盖：构建锚点前驱与并行接收点 Paint 子图。 */
-    [[nodiscard]] Task_Graph build_graph(Constellation_Diagram* object,
-                                         const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Constellation_Diagram* object,
-                                            const Prop& state);
-    void paint_anchors(Constellation_Diagram* object);
-    void paint_partition(Constellation_Diagram* object, Plot_Partition_Count index);
-    [[nodiscard]] static Rect_F point_region(
-        std::span<const Point_F> points, double radius);
-    /* CRTP 覆盖：本类状态写入后标记 Prepare 数据失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> states);
-};
-template <typename Object>
-Constellation_Diagram::Builder<Object>::Builder(
-    not_null<Axis_Object*> i_axis_value,
-    not_null<Axis_Object*> q_axis_value,
-    Plot_Partition_Count partition_count) : Base(), i_axis(i_axis_value), q_axis(q_axis_value) {
-    this->prop.partition_count = partition_count;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Constellation_Diagram::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto plot = std::move(result).value();
-    auto& private_data = detail::Internal_Access::layer<Object>(plot.get());
-    private_data.bind_sources(i_axis, q_axis);
-    private_data.scene_attach = [object = not_null{plot.get()}](
-        not_null<Root*> root) -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::layer<Object>(object.get());
-        data.scene = scene;
-        const auto i_axis = not_null{data.i_axis};
-        const auto q_axis = not_null{data.q_axis};
-        return detail::Internal_Access::edit_dependency_graph<Render_Graph_Tag, Render_Cache_Tag>(scene.get(), [&](auto& graph, auto& cache) {
-            graph.add_dependency(i_axis.get(), object.get());
-            graph.add_dependency(q_axis.get(), object.get());
-            cache.template add_prop_dependency<&Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), i_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), i_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), i_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), i_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), q_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), q_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), q_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), q_axis.get());
-        });
-    };
-    return plot;
-}
-inline void Constellation_Diagram::Private::prepare_data(Constellation_Diagram* object) {
-    const auto& state = this->template read_current_prop<Constellation_Diagram::Base_Tag>(object);
-    detail::Internal_Access::exchange_stream<Constellation_Stream_Tag>(object);
-    const auto current = monotonic_milliseconds();
-    detail::Internal_Access::accumulate_stream<Constellation_Stream_Tag>(object,
-        [&](const Constellation_Point& point) {
-            return current - point.submitted_at_ms <= state.point_lifetime_ms;
-        });
-    const auto& i_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        i_axis);
-    const auto& q_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        q_axis);
-    prepared = {};
-    prepared.canvas = this->template read_current_prop<Render_Scene_2D::Base_Tag>(
-        scene).viewport;
-    if (prepared.canvas.empty() || i_layout.orientation == q_layout.orientation) {
-        return;
-    }
-    detail::Internal_Access::access_rendering_stream<Constellation_Stream_Tag>(object,
-        [&](std::span<Constellation_Point> points) {
-            for (const auto& value : points)
-                if (current - value.submitted_at_ms <= state.point_lifetime_ms)
-                    prepared.points.push_back(detail::map_plot_point(
-                        i_axis, value.point.x,
-                        q_axis, value.point.y,
-                        i_layout.orientation));
-        });
-    const int count = static_cast<int>(state.type);
-    const Plot_Coordinate center_i = state.i_range.center();
-    const Plot_Coordinate center_q = state.q_range.center();
-    const Plot_Coordinate radius = std::min(state.i_range.size(), state.q_range.size()) * 0.4;
-    for (int index = 0; index < count; ++index) {
-        const Plot_Ratio angle = state.phase_offset_radians + 2.0 * std::numbers::pi * index / count;
-        prepared.anchors.push_back(detail::map_plot_point(
-            i_axis, center_i + std::cos(angle) * radius,
-            q_axis, center_q + std::sin(angle) * radius,
-            i_layout.orientation));
-    }
-    prepared.valid = true;
-    detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-inline Task_Graph Constellation_Diagram::Private::build_graph(
-    Constellation_Diagram* object, const Prop& state) {
-    Task_Graph graph{"constellation"};
-    auto prepare = graph.add("prepare", [this, object] {
-        prepare_data(object);
-    });
-    auto anchors = graph.add("paint.anchors", [this, object] {
-        paint_anchors(object);
-    });
-    prepare.precede(anchors);
-    for (Plot_Partition_Count index = 0;
-         index < state.partition_count; ++index) {
-        auto partition = graph.add("paint.partition", [this, object, index] {
-            paint_partition(object, index);
-        });
-        anchors.precede(partition);
-    }
-    return graph;
-}
-inline bool Constellation_Diagram::Private::should_rebuild_graph(
-    Constellation_Diagram*, const Prop& state) {
-    return !graph || graph->size() != state.partition_count + 2;
-}
-inline Rect_F Constellation_Diagram::Private::point_region(
-    std::span<const Point_F> points, double radius) {
-    if (points.empty()) return {};
-    double left = points.front().x;
-    double right = left;
-    double top = points.front().y;
-    double bottom = top;
-    for (const Point_F point : points.subspan(1)) {
-        left = std::min(left, point.x);
-        right = std::max(right, point.x);
-        top = std::min(top, point.y);
-        bottom = std::max(bottom, point.y);
-    }
-    constexpr double antialias_padding{1.0};
-    const double padding = radius + antialias_padding;
-    return {
-        left - padding, top - padding,
-        right - left + padding * 2.0,
-        bottom - top + padding * 2.0
-    };
-}
-inline void Constellation_Diagram::Private::paint_anchors(Constellation_Diagram* object) {
-    const auto& state = this->template read_current_prop<Constellation_Diagram::Base_Tag>(object);
-    if (!prepared.valid || prepared.anchors.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas,
-                            point_region(prepared.anchors, 4.5));
-    /*
-     * 原实现每个点都会创建 BLPath，再分别 fill + stroke；这里改为同色实心圆批量入口。
-     * 旧样式是 radius + 1px 同色描边，最终外半径约增加 0.5px，因此直接使用 4.5/2.5
-     * 保持视觉尺寸，同时只做一次填充状态设置并走后端原生 circle primitive。
-     */
-    painter.solid_circles(prepared.anchors, 4.5, state.anchor_color);
-}
-inline void Constellation_Diagram::Private::paint_partition(
-    Constellation_Diagram* object, Plot_Partition_Count index) {
-    const auto& state =
-    this->template read_current_prop<Constellation_Diagram::Base_Tag>(object);
-    if (!prepared.valid || state.partition_count == 0 ||
-        index >= state.partition_count)
-        return;
-    const std::size_t point_count = prepared.points.size();
-    const auto boundary = [point_count, count = state.partition_count](
-        Plot_Partition_Count position) {
-        return point_count / count * position +
-        std::min<std::size_t>(position, point_count % count);
-    };
-    const std::size_t first = boundary(index);
-    const std::size_t last = boundary(index + 1);
-    const std::span<const Point_F> points{
-        prepared.points.data() + first,
-        last - first
-    };
-    if (points.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas,
-                            point_region(points, 2.5));
-    painter.solid_circles(points, 2.5, state.point_color);
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Constellation_Diagram::Private::after_prop_set(
-    Object* object, Member Owner::* member, Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        if constexpr (std::same_as<Member, Plot_Partition_Count>) {
-            if (member == &Prop::partition_count) {
-                detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-                return;
-            }
-        }
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Constellation_Diagram::Private::bind_sources(
-    not_null<Axis_Object*> i_axis_value,
-    not_null<Axis_Object*> q_axis_value) {
-    i_axis = i_axis_value;
-    q_axis = q_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/Frequency_Trace.cpp b/render_2D/render_2D/plottable/Frequency_Trace.cpp
deleted file mode 100644
index b0c889d..0000000
--- a/render_2D/render_2D/plottable/Frequency_Trace.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Frequency_Trace.hpp"                             /* Frequency Trace 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Frequency_Trace_Sample::operator==(const Frequency_Trace_Sample&) const = default;
-bool Frequency_Trace::Prop::operator==(const Prop&) const = default;
-bool Frequency_Trace::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Frequency_Trace.hpp b/render_2D/render_2D/plottable/Frequency_Trace.hpp
deleted file mode 100644
index 6b44f1c..0000000
--- a/render_2D/render_2D/plottable/Frequency_Trace.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <vector>
-namespace aethera::render_2d {
-struct Frequency_Trace_Sample {
-    Plot_Time_Tick tick{};                                  /* 时间轴上的单调样本序号。 */
-    Plot_Value value{};                                     /* 该时间点对应的频率值。 */
-    bool operator==(const Frequency_Trace_Sample&) const;
-};
-struct Frequency_Trace_Stream_Tag {};
-struct Frequency_Trace : Def<Frequency_Trace, Renderable_2D,
-    Mpmc_Triple_Buffer<Frequency_Trace_Stream_Tag, Frequency_Trace_Sample>> {
-    using Scene_Object = Render_Scene_2D;
-    using Time_Object = Time_Axis;
-    using Value_Object = Numeric_Axis;
-    struct Prop : Prev_Prop {
-        Plot_Partition_Count partition_count{1};                    /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
-        Pen pen{Color::yellow()};                                   /* 频率轨迹折线样式。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Time_Object*> time_axis,
-                not_null<Value_Object*> value_axis,
-                Plot_Partition_Count partition_count = 1);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Time_Object*> time_axis;                    /* 不拥有的时间轴。 */
-        not_null<Value_Object*> value_axis;                  /* 不拥有的数值轴。 */
-    };
-};
-}
-#include "Frequency_Trace.ipp"
diff --git a/render_2D/render_2D/plottable/Frequency_Trace.ipp b/render_2D/render_2D/plottable/Frequency_Trace.ipp
deleted file mode 100644
index 12a8a31..0000000
--- a/render_2D/render_2D/plottable/Frequency_Trace.ipp
+++ /dev/null
@@ -1,160 +0,0 @@
-#pragma once
-#include <optional>
-#include "common/Curve_Plot.hpp"
-namespace aethera::render_2d {
-struct Frequency_Trace::Private : Prev_Private {
-    struct Prepared {
-        std::vector<detail::Curve_Prepared> partitions{};    /* Prepare 子图各分块的曲线输出。 */
-        std::vector<detail::Curve_Sample> samples{};         /* 保留每个值自己的时间 tick，禁止按首尾范围重新均分。 */
-        Size canvas{};                                       /* 当前颜色层尺寸。 */
-        bool valid{};                                        /* 两根轴正交且画布有效。 */
-    };
-    Scene_Object* scene{};           /* 不拥有的所属 Scene。 */
-    Time_Object* time_axis{};        /* 不拥有的时间轴。 */
-    Value_Object* value_axis{};      /* 不拥有的数值轴。 */
-    Prepared prepared{};                                     /* 当前状态和轴状态推导出的 Paint 输入。 */
-    Plot_Partition_Count graph_partition_count{};            /* 当前 Prepare 子图固化的分块数。 */
-    void bind_sources(not_null<Time_Object*> time_axis_value,
-                      not_null<Value_Object*> value_axis_value);
-    /* CRTP 覆盖：按当前样本规模构建分块 Prepare 子图。 */
-    [[nodiscard]] Task_Graph build_graph(Frequency_Trace* object, const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Frequency_Trace* object, const Prop& state);
-    void prepare_frame(Frequency_Trace* object, Plot_Partition_Count partition_count);
-    void prepare_partition(Frequency_Trace* object, Plot_Partition_Count partition_index);
-    void paint_partition(Frequency_Trace* object, Plot_Partition_Count partition_index);
-    /* CRTP 覆盖：本类状态写入后标记 Prepare 数据失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type> void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> pending_states);
-};
-template <typename Object>
-Frequency_Trace::Builder<Object>::Builder(
-    not_null<Time_Object*> time_axis_value,
-    not_null<Value_Object*> value_axis_value,
-    Plot_Partition_Count partition_count)
-    : Base(), time_axis(time_axis_value), value_axis(value_axis_value) {
-    this->prop.partition_count = partition_count;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Frequency_Trace::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto trace = std::move(result).value();
-    const not_null object{trace.get()};
-    auto& private_data = detail::Internal_Access::get(object.get());
-    private_data.bind_sources(time_axis, value_axis);
-    private_data.scene_attach = [object](not_null<Root*> root)
-        -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::get(object.get());
-        data.scene = scene;
-        const auto time = not_null{data.time_axis};
-        const auto value = not_null{data.value_axis};
-        return detail::Internal_Access::edit_dependency_graph<
-            Render_Graph_Tag, Render_Cache_Tag>(
-            scene.get(), [&](auto& graph, auto& cache) {
-                graph.add_dependency(time.get(), object.get());
-                graph.add_dependency(value.get(), object.get());
-                cache.template add_prop_dependency<
-                    &Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::position>(object.get(), time.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::pixel_length>(object.get(), time.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::orientation>(object.get(), time.get());
-                cache.template add_prop_dependency<
-                    &Time_Axis::Prop::visible_count>(object.get(), time.get());
-                cache.template add_prop_dependency<
-                    &Time_Axis::Prop::newest_at_start>(object.get(), time.get());
-                cache.template add_dependency<&Time_Axis::State::next_tick>(
-                    object.get(), time.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::position>(object.get(), value.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::pixel_length>(object.get(), value.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::orientation>(object.get(), value.get());
-                cache.template add_prop_dependency<
-                    &Numeric_Axis::Prop::coordinate_range>(object.get(), value.get());
-            });
-    };
-    return trace;
-}
-inline bool Frequency_Trace::Private::should_rebuild_graph(Frequency_Trace*, const Prop& state) { return graph_partition_count != state.partition_count; }
-inline Task_Graph Frequency_Trace::Private::build_graph(Frequency_Trace* object, const Prop& state) {
-    graph_partition_count = state.partition_count;
-    Task_Graph graph{"frequency_trace"};
-    auto begin = graph.add("prepare.frame", [this, object] { prepare_frame(object, graph_partition_count); });
-    for (Plot_Partition_Count index = 0; index < graph_partition_count; ++index) {
-        auto prepare = graph.add("prepare.partition", [this, object, index] { prepare_partition(object, index); });
-        auto paint = graph.add("paint.partition", [this, object, index] { paint_partition(object, index); });
-        begin.precede(prepare);
-        prepare.precede(paint);
-    }
-    return graph;
-}
-inline void Frequency_Trace::Private::prepare_frame(Frequency_Trace* object, Plot_Partition_Count partition_count) {
-    const auto& state = static_cast<const Prop&>(detail::Internal_Access::current_prop(object));
-    const auto& time_layout = static_cast<const Abs_Axis::Prop&>(
-        detail::Internal_Access::current_prop(time_axis));
-    const auto& value_layout = static_cast<const Abs_Axis::Prop&>(
-        detail::Internal_Access::current_prop(value_axis));
-    const auto visible_count = static_cast<std::size_t>(std::max<Axis_Visible_Count>(
-        2, static_cast<const Time_Axis::Prop&>(
-               detail::Internal_Access::current_prop(
-                   time_axis)).visible_count));
-    detail::Internal_Access::exchange_stream<Frequency_Trace_Stream_Tag>(object);
-    detail::Internal_Access::accumulate_stream<Frequency_Trace_Stream_Tag>(object, visible_count);
-    prepared = {};
-    prepared.partitions.resize(partition_count);
-    prepared.canvas = static_cast<const Render_Scene_2D::Prop&>(
-        detail::Internal_Access::current_prop(scene)).viewport;
-    if (prepared.canvas.empty() || time_layout.orientation == value_layout.orientation) return;
-    detail::Internal_Access::access_rendering_stream<Frequency_Trace_Stream_Tag>(object, [&](std::span<Frequency_Trace_Sample> samples) {
-        prepared.samples.reserve(samples.size());
-        for (const auto& sample : samples)
-            prepared.samples.push_back({static_cast<Plot_Coordinate>(sample.tick), sample.value});
-    });
-    prepared.valid = !prepared.samples.empty();
-}
-inline void Frequency_Trace::Private::prepare_partition(Frequency_Trace* object, Plot_Partition_Count partition_index) {
-    if (!prepared.valid) return;
-    const auto& state = static_cast<const Prop&>(detail::Internal_Access::current_prop(object));
-    const auto& time_layout = static_cast<const Abs_Axis::Prop&>(
-        detail::Internal_Access::current_prop(time_axis));
-    const auto& value_layout = static_cast<const Abs_Axis::Prop&>(
-        detail::Internal_Access::current_prop(value_axis));
-    const auto& value_state = static_cast<const Numeric_Axis::Prop&>(
-        detail::Internal_Access::current_prop(value_axis));
-    const Axis_Range domain{prepared.samples.front().coordinate, prepared.samples.back().coordinate}; const auto range = detail::curve_partition_range(prepared.samples.size(), partition_index, prepared.partitions.size(), domain);
-    const Axis_Range visible_range = detail::Internal_Access::layer<Abs_Axis>(
-        time_axis).runtime_coordinate_range();
-    prepared.partitions[partition_index] = detail::prepare_curve(
-        std::span<const detail::Curve_Sample>(prepared.samples).subspan(
-            range.first_sample, range.sample_count),
-        true, visible_range, value_state.coordinate_range,
-        time_axis, value_axis,
-        time_layout.orientation, value_layout.orientation);
-}
-inline void Frequency_Trace::Private::paint_partition(Frequency_Trace* object, Plot_Partition_Count partition_index) {
-    if (!prepared.valid || partition_index >= prepared.partitions.size()) return;
-    const auto& state = static_cast<const Prop&>(detail::Internal_Access::current_prop(object));
-    const auto& curve = prepared.partitions[partition_index];
-    const Rect_F region = detail::curve_paint_region(curve, state.pen.width + 2.0);
-    if (region.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas, region);
-    detail::paint_curve(painter, curve, state.pen);
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Frequency_Trace::Private::after_prop_set(
-    Object* object, Member Owner::*, Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Frequency_Trace::Private::bind_sources(
-    not_null<Time_Object*> time_axis_value,
-    not_null<Value_Object*> value_axis_value) {
-    time_axis = time_axis_value;
-    value_axis = value_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/Hover_Tooltip.cpp b/render_2D/render_2D/plottable/Hover_Tooltip.cpp
deleted file mode 100644
index f433461..0000000
--- a/render_2D/render_2D/plottable/Hover_Tooltip.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "Hover_Tooltip.hpp"
-namespace aethera::render_2d {
-bool Hover_Tooltip_Properties::operator==(const Hover_Tooltip_Properties&) const = default;
-namespace detail {
-bool update_hover_tooltip(Hover_Tooltip_Runtime& tooltip, const Event& event) {
-    if (event.type == Event_Type::pointer_move) { const auto* pointer = dynamic_cast<const Pointer_Event_Capability*>(&event); if (!pointer) return false; tooltip.active = true; tooltip.position = {pointer->position_x(), pointer->position_y()}; return true; }
-    if (event.type == Event_Type::leave) { tooltip.active = false; return true; }
-    return false;
-}
-}
-}
diff --git a/render_2D/render_2D/plottable/Hover_Tooltip.hpp b/render_2D/render_2D/plottable/Hover_Tooltip.hpp
deleted file mode 100644
index 6ed4d93..0000000
--- a/render_2D/render_2D/plottable/Hover_Tooltip.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-#include "../event/Event.hpp"
-#include "../render/Blend2D_Cache.hpp"
-namespace aethera::render_2d {
-struct Hover_Tooltip_Properties {
-    bool tooltip_enabled{true};                              /* 是否响应指针位置显示提示。 */
-    Font tooltip_font{};                                     /* 提示文字字体。 */
-    Pen tooltip_text_pen{Color::white()};                    /* 提示文字样式。 */
-    Brush tooltip_background_brush{Color{20, 20, 20, 220}, Brush_Style::solid}; /* 提示背景样式。 */
-    bool operator==(const Hover_Tooltip_Properties&) const;
-};
-namespace detail {
-struct Hover_Tooltip_Runtime {
-    bool active{};                                           /* 指针当前是否位于控件内。 */
-    Point_F position{};                                      /* 最近一次指针位置。 */
-};
-bool update_hover_tooltip(Hover_Tooltip_Runtime& tooltip, const Event& event);
-}
-}
diff --git a/render_2D/render_2D/plottable/Plot_Types.cpp b/render_2D/render_2D/plottable/Plot_Types.cpp
deleted file mode 100644
index 2083037..0000000
--- a/render_2D/render_2D/plottable/Plot_Types.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "Plot_Types.hpp"
-#include <algorithm>
-#include <cmath>
-namespace aethera::render_2d {
-Color_Map::Color_Map() : stops{Color{0, 0, 64, 255}, Color{0, 128, 255, 255}, Color::yellow(), Color::red_color()} {}
-Color Color_Map::sample(Plot_Ratio ratio) const {
-    if (stops.empty()) return Color::transparent();
-    if (stops.size() == 1) return stops.front();
-    const Plot_Ratio position = std::clamp(std::isfinite(ratio) ? ratio : 0.0, 0.0, 1.0) * static_cast<Plot_Ratio>(stops.size() - 1);
-    const auto first = static_cast<std::size_t>(std::floor(position));
-    const auto second = std::min(first + 1, stops.size() - 1);
-    const Plot_Ratio fraction = position - static_cast<Plot_Ratio>(first);
-    const auto channel = [fraction](std::uint8_t left, std::uint8_t right) { return static_cast<std::uint8_t>(std::lround(left + (static_cast<int>(right) - left) * fraction)); };
-    return {channel(stops[first].red, stops[second].red), channel(stops[first].green, stops[second].green), channel(stops[first].blue, stops[second].blue), channel(stops[first].alpha, stops[second].alpha)};
-}
-bool Color_Map::operator==(const Color_Map&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Plot_Types.hpp b/render_2D/render_2D/plottable/Plot_Types.hpp
deleted file mode 100644
index f08b67c..0000000
--- a/render_2D/render_2D/plottable/Plot_Types.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-#include "../base/Types.hpp"
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <vector>
-namespace aethera::render_2d {
-using Plot_Coordinate = double;
-using Plot_Value = double;
-using Plot_Ratio = double;
-using Plot_Time_Tick = int;
-using Plot_Duration_Milliseconds = Duration_Milliseconds;
-using Plot_Partition_Count = std::size_t;
-using Plot_Index = std::ptrdiff_t;
-struct Plot_Partition_Grid {
-    Plot_Partition_Count columns{1};                         /* framebuffer 水平方向的分块数。 */
-    Plot_Partition_Count rows{1};                            /* framebuffer 垂直方向的分块数。 */
-    [[nodiscard]] bool valid() const noexcept {
-        return columns != 0 && rows != 0 &&
-            columns <= std::numeric_limits<Plot_Partition_Count>::max() / rows;
-    }
-    bool operator==(const Plot_Partition_Grid&) const = default;
-};
-struct Color_Map {
-    std::vector<Color> stops{}; /* 从低值到高值的离散颜色停靠点；空值使用透明色。 */
-    Color_Map();
-    [[nodiscard]] Color sample(Plot_Ratio ratio) const;
-    bool operator==(const Color_Map&) const;
-};
-}
diff --git a/render_2D/render_2D/plottable/Plottables.hpp b/render_2D/render_2D/plottable/Plottables.hpp
deleted file mode 100644
index b672f7b..0000000
--- a/render_2D/render_2D/plottable/Plottables.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-#include "Afterglow.hpp"
-#include "Constellation_Diagram.hpp"
-#include "Frequency_Trace.hpp"
-#include "Selection_Rectangle_Overlay.hpp"
-#include "Spectrum.hpp"
-#include "Sweep_Spectrum.hpp"
-#include "Waterfall.hpp"
diff --git a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.cpp b/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.cpp
deleted file mode 100644
index 6271ddb..0000000
--- a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "Selection_Rectangle_Overlay.hpp"                 /* Selection Overlay 最终实例及三类依赖实现。 */
-#include <algorithm>
-#include <iomanip>
-#include <sstream>
-namespace aethera::render_2d {
-bool Selection_Rectangle_Overlay::Prop::operator==(const Prop&) const = default;
-bool Selection_Rectangle_Overlay::State::operator==(const State&) const = default;
-Axis_Rectangle Selection_Rectangle_Overlay::Private::axis_rectangle(Axis_Point first, Axis_Point second) {
-    const auto [horizontal_low, horizontal_high] = std::minmax(first.horizontal, second.horizontal);
-    const auto [vertical_low, vertical_high] = std::minmax(first.vertical, second.vertical);
-    return {{horizontal_low, horizontal_high}, {vertical_low, vertical_high}};
-}
-std::string Selection_Rectangle_Overlay::Private::range_label(const Axis_Source& axis, Axis_Range range) {
-    const auto coordinate_label = [&axis](Axis_Coordinate coordinate) {
-        auto label = std::visit([coordinate](const auto value) {
-            return double_buffer::detail::Internal_Access::layer<Abs_Axis>(
-                value.get())
-                .runtime_tick_label(coordinate);
-        }, axis);
-        if (!label.empty()) return label;
-        std::ostringstream stream;
-        stream << std::fixed << std::setprecision(3) << coordinate;
-        return stream.str();
-    };
-    return coordinate_label(range.origin) + " .. " + coordinate_label(range.target);
-}
-Axis_Range Selection_Rectangle_Overlay::Private::coordinate_range(const Axis_Source& axis) {
-    return std::visit([](const auto value) {
-        return double_buffer::detail::Internal_Access::layer<Abs_Axis>(
-            value.get())
-            .runtime_coordinate_range();
-    }, axis);
-}
-double Selection_Rectangle_Overlay::Private::coordinate_to_pixel(const Axis_Source& axis, double coordinate) {
-    return std::visit([coordinate](const auto value) {
-        return double_buffer::detail::Internal_Access::layer<Abs_Axis>(
-            value.get())
-            .runtime_coordinate_to_pixel(coordinate);
-    }, axis);
-}
-double Selection_Rectangle_Overlay::Private::point_to_coordinate(const Axis_Source& axis, Point_F point) {
-    return std::visit([point](const auto value) {
-        return double_buffer::detail::Internal_Access::layer<Abs_Axis>(
-            value.get())
-            .runtime_point_to_coordinate(point);
-    }, axis);
-}
-Rect_F Selection_Rectangle_Overlay::Private::map_rect(const Axis_Source& horizontal,
-                                                       Axis_Range horizontal_range,
-                                                       const Axis_Source& vertical,
-                                                       Axis_Range vertical_range) {
-    return std::visit([&](const auto horizontal_value,
-                          const auto vertical_value) {
-        return detail::map_plot_rect(horizontal_value.get(), horizontal_range,
-                                     vertical_value.get(), vertical_range,
-                                     Axis_Orientation::horizontal);
-    }, horizontal, vertical);
-}
-}
diff --git a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.hpp b/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.hpp
deleted file mode 100644
index fc01e26..0000000
--- a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <functional>
-#include <memory>
-#include <vector>
-#include <variant>
-namespace aethera::render_2d {
-struct Selection_Rectangle_Overlay : Def<Selection_Rectangle_Overlay, Renderable_2D> {
-    using Scene_Object = Render_Scene_2D;
-    using Numeric_Axis_Object = Numeric_Axis;
-    using Frequency_Axis_Object = Frequency_Axis;
-    using Time_Axis_Object = Time_Axis;
-    struct Prop : Prev_Prop {
-        Font label_font{};                                               /* 选择范围标签使用的字体。 */
-        Pen label_pen{Color::white()};                                   /* 选择范围标签的文字样式。 */
-        Brush selection_brush{Color{0, 0, 255, 50}, Brush_Style::solid}; /* 选择矩形内部填充。 */
-        Pen selection_border_pen{Color::white(), 1.0, Line_Style::dash}; /* 选择矩形边框样式。 */
-        std::vector<Axis_Rectangle> selected_regions{};                  /* 已完成选择的轴数据区域。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        std::size_t selected_region_count{}; /* 当前已完成选择的矩形数量。 */
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        template <Axis_Object Horizontal_Axis, Axis_Object Vertical_Axis>
-        Builder(not_null<Horizontal_Axis*> horizontal_axis,
-                not_null<Vertical_Axis*> vertical_axis);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        std::function<void(not_null<Object*>)> initialize{};          /* build 成功后绑定两根最终轴及其 Scene 拓扑。 */
-    };
-};
-}
-#include "Selection_Rectangle_Overlay.ipp"
diff --git a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.ipp b/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.ipp
deleted file mode 100644
index 7ee195d..0000000
--- a/render_2D/render_2D/plottable/Selection_Rectangle_Overlay.ipp
+++ /dev/null
@@ -1,150 +0,0 @@
-#pragma once
-#include "common/Curve_Plot.hpp"
-#include <algorithm>
-#include <cmath>
-#include <optional>
-#include <stdexcept>
-namespace aethera::render_2d {
-struct Selection_Rectangle_Overlay::Private : Prev_Private {
-    using Axis_Source = std::variant<not_null<Numeric_Axis_Object*>,
-        not_null<Frequency_Axis_Object*>, not_null<Time_Axis_Object*>>;
-    Scene_Object* scene{};           /* 不拥有的所属 Scene。 */
-    std::optional<Axis_Source> horizontal_axis{};             /* 保留最终类型的水平坐标轴。 */
-    std::optional<Axis_Source> vertical_axis{};               /* 保留最终类型的垂直坐标轴。 */
-    Axis_Point drag_origin{};                                /* 当前拖动起点的两轴数据坐标。 */
-    Axis_Point drag_current{};                               /* 当前拖动终点的两轴数据坐标。 */
-    Point_F press_position{};                                /* 仅用于区分点击与拖动的按下像素位置。 */
-    bool dragging{};                                         /* 是否正在构造尚未提交的选择矩形。 */
-    static constexpr double minimum_drag_distance_pixels{3.0}; /* 允许提交和绘制选择框的最小像素距离。 */
-    template <typename Horizontal_Axis, typename Vertical_Axis>
-    void bind_sources(not_null<Horizontal_Axis*> horizontal_axis_value,
-                      not_null<Vertical_Axis*> vertical_axis_value);
-    [[nodiscard]] static Axis_Rectangle axis_rectangle(Axis_Point first, Axis_Point second);
-    [[nodiscard]] static std::string range_label(const Axis_Source& axis, Axis_Range range);
-    [[nodiscard]] static Axis_Range coordinate_range(const Axis_Source& axis);
-    [[nodiscard]] static double coordinate_to_pixel(const Axis_Source& axis, double coordinate);
-    [[nodiscard]] static double point_to_coordinate(const Axis_Source& axis, Point_F point);
-    [[nodiscard]] static Rect_F map_rect(const Axis_Source& horizontal, Axis_Range horizontal_range,
-                                         const Axis_Source& vertical, Axis_Range vertical_range);
-    [[nodiscard]] bool has_visible_drag() const;
-    /* CRTP 覆盖：无需 Prepare 子图，直接绘制选择矩形。 */
-    void paint(Selection_Rectangle_Overlay* object);
-    /* CRTP 覆盖：处理拖拽并更新权威选择区域状态。 */
-    void handle_event(Selection_Rectangle_Overlay* object, const Event& event);
-    /* CRTP 覆盖：空闲时只在两轴围成的图域接收事件，拖动期间扩展到完整 viewport。 */
-    [[nodiscard]] Rect_F event_region(const Attached auto* object, Size viewport) const;
-    /* CRTP 覆盖：本类状态写入后只标记 Paint 数据失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type> void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> pending_states);
-    template <typename Object, typename Prop_Type, typename State_Type> void before_advance(Object* object, Prop_Type* pending_prop, State_Access<State_Type> pending_states, const Prop_Type* current_prop, State_Access<const State_Type> current_states);
-};
-template <typename Object>
-template <Axis_Object Horizontal_Axis, Axis_Object Vertical_Axis>
-Selection_Rectangle_Overlay::Builder<Object>::Builder(
-    not_null<Horizontal_Axis*> horizontal_axis,
-    not_null<Vertical_Axis*> vertical_axis) : Base() {
-    static_assert((std::same_as<Horizontal_Axis, Numeric_Axis_Object> ||
-                   std::same_as<Horizontal_Axis, Frequency_Axis_Object> ||
-                   std::same_as<Horizontal_Axis, Time_Axis_Object>) &&
-                  (std::same_as<Vertical_Axis, Numeric_Axis_Object> ||
-                   std::same_as<Vertical_Axis, Frequency_Axis_Object> ||
-                   std::same_as<Vertical_Axis, Time_Axis_Object>),
-                  "selection rectangle axes must preserve one of the supported final axis types");
-    initialize = [horizontal_axis, vertical_axis](not_null<Object*> overlay) {
-        auto& private_data = detail::Internal_Access::layer<Object>(overlay.get());
-        private_data.bind_sources(horizontal_axis, vertical_axis);
-        private_data.scene_attach = [object = overlay, horizontal_axis,
-            vertical_axis](not_null<Root*> root)
-            -> std::expected<void, Dependency_Graph_Error> {
-            const not_null scene{static_cast<Scene_Object*>(root.get())};
-            auto& data = detail::Internal_Access::layer<Object>(object.get());
-            data.scene = scene;
-            return detail::Internal_Access::edit_dependency_graph<Render_Graph_Tag, Render_Cache_Tag>(scene.get(), [&](auto& graph, auto& cache) {
-                graph.add_dependency(horizontal_axis.get(), object.get());
-                graph.add_dependency(vertical_axis.get(), object.get());
-                cache.template add_prop_dependency<&Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-                const auto bind_axis = [&]<Axis_Object Axis>(not_null<Axis*> axis) { cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), axis.get()); cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), axis.get()); cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), axis.get()); if constexpr (std::derived_from<Axis, Numeric_Axis>) { cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), axis.get()); cache.template add_prop_dependency<&Numeric_Axis::Prop::precision>(object.get(), axis.get()); cache.template add_prop_dependency<&Numeric_Axis::Prop::locale>(object.get(), axis.get()); } else if constexpr (std::derived_from<Axis, Time_Axis>) { cache.template add_prop_dependency<&Time_Axis::Prop::visible_count>(object.get(), axis.get()); cache.template add_prop_dependency<&Time_Axis::Prop::newest_at_start>(object.get(), axis.get()); cache.template add_prop_dependency<&Time_Axis::Prop::format>(object.get(), axis.get()); cache.template add_dependency<&Time_Axis::State::next_tick>(object.get(), axis.get()); } };
-                bind_axis(horizontal_axis); bind_axis(vertical_axis);
-            });
-        };
-    };
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Selection_Rectangle_Overlay::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto overlay = std::move(result).value();
-    initialize(overlay.get());
-    return overlay;
-}
-inline void Selection_Rectangle_Overlay::Private::paint(Selection_Rectangle_Overlay* object) {
-    auto& data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const Size canvas = this->template read_current_prop<
-        Render_Scene_2D::Base_Tag>(scene).viewport;
-    auto& cache = data.paint_surface();
-    if (canvas.empty()) return;
-    detail::Painter painter(cache, canvas);
-    const auto& horizontal = horizontal_axis.value();
-    const auto& vertical = vertical_axis.value();
-    const auto plot_region = map_rect(horizontal, coordinate_range(horizontal), vertical, coordinate_range(vertical));
-    auto clip = painter.scoped_clip(plot_region);
-    const auto paint_region = [&](const Axis_Rectangle& region) {
-        const auto rect = map_rect(horizontal, region.horizontal, vertical, region.vertical);
-        painter.rect(rect, state.selection_border_pen, state.selection_brush);
-        const Point_F label_position{rect.x + 4.0, rect.y + 3.0};
-        painter.text(label_position, "X " + range_label(horizontal, region.horizontal), state.label_font, state.label_pen);
-        painter.text({label_position.x, label_position.y + std::max(12.0, state.label_font.size * 1.35)}, "Y " + range_label(vertical, region.vertical), state.label_font, state.label_pen);
-    };
-    for (const auto& region : state.selected_regions) paint_region(region);
-    if (dragging && has_visible_drag()) paint_region(axis_rectangle(drag_origin, drag_current));
-}
-inline bool Selection_Rectangle_Overlay::Private::has_visible_drag() const {
-    const Point_F current_position{
-        coordinate_to_pixel(horizontal_axis.value(), drag_current.horizontal),
-        coordinate_to_pixel(vertical_axis.value(), drag_current.vertical)};
-    return std::hypot(current_position.x - press_position.x, current_position.y - press_position.y) >= minimum_drag_distance_pixels;
-}
-inline void Selection_Rectangle_Overlay::Private::handle_event(Selection_Rectangle_Overlay* object, const Event& event) {
-    const auto* pointer = dynamic_cast<const Pointer_Event_Capability*>(&event);
-    if (!pointer) return;
-    const Point_F point{pointer->position_x(), pointer->position_y()};
-    const Axis_Point axis_point{
-        point_to_coordinate(horizontal_axis.value(), point),
-        point_to_coordinate(vertical_axis.value(), point)};
-    if (event.type == Event_Type::pointer_press && pointer->pointer_button() == Mouse_Button::left) {
-        const auto modifiers = static_cast<std::underlying_type_t<Keyboard_Modifier>>(pointer->keyboard_modifiers());
-        const auto control = static_cast<std::underlying_type_t<Keyboard_Modifier>>(Keyboard_Modifier::control);
-        if ((modifiers & control) == 0) detail::Internal_Access::set<&Prop::selected_regions>(object, std::vector<Axis_Rectangle>{});
-        dragging = true; drag_origin = axis_point; drag_current = axis_point; press_position = point; detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object); event.accept(); return;
-    }
-    if (event.type == Event_Type::pointer_move && dragging) { drag_current = axis_point; detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object); event.accept(); return; }
-    if (event.type != Event_Type::pointer_release || !dragging) return;
-    dragging = false; drag_current = axis_point;
-    if (std::hypot(point.x - press_position.x, point.y - press_position.y) < minimum_drag_distance_pixels) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object); event.accept(); return;
-    }
-    const Axis_Rectangle selected = axis_rectangle(drag_origin, drag_current);
-    detail::Internal_Access::update_prop<&Prop::selected_regions>(object, [=](Prop_Access<Prop> props) {
-        props.template get<Selection_Rectangle_Overlay::Base_Tag>().selected_regions.push_back(selected);
-    });
-    event.accept();
-}
-inline Rect_F Selection_Rectangle_Overlay::Private::event_region(const Attached auto*, Size viewport) const {
-    if (dragging) return {0.0, 0.0, static_cast<double>(viewport.width), static_cast<double>(viewport.height)};
-    const auto& horizontal = horizontal_axis.value();
-    const auto& vertical = vertical_axis.value();
-    return map_rect(horizontal, coordinate_range(horizontal),
-                    vertical, coordinate_range(vertical));
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Selection_Rectangle_Overlay::Private::after_prop_set(Object* object, Member Owner::*, Prop_Access<Prop_Type>) { if constexpr (std::same_as<Owner, Prop>) detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object); }
-template <typename Object, typename Prop_Type, typename State_Type>
-void Selection_Rectangle_Overlay::Private::before_advance(Object*, Prop_Type*, State_Access<State_Type> pending_states, const Prop_Type* current_prop, State_Access<const State_Type>) { pending_states.template get<Selection_Rectangle_Overlay::Base_Tag>().selected_region_count = static_cast<const Prop&>(*current_prop).selected_regions.size(); }
-template <typename Horizontal_Axis, typename Vertical_Axis>
-void Selection_Rectangle_Overlay::Private::bind_sources(
-    not_null<Horizontal_Axis*> horizontal_axis_value,
-    not_null<Vertical_Axis*> vertical_axis_value) {
-    horizontal_axis = horizontal_axis_value;
-    vertical_axis = vertical_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/Spectrum.cpp b/render_2D/render_2D/plottable/Spectrum.cpp
deleted file mode 100644
index 72cc4b2..0000000
--- a/render_2D/render_2D/plottable/Spectrum.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Spectrum.hpp"                                    /* Spectrum 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Spectrum_Frame::operator==(const Spectrum_Frame&) const = default;
-bool Spectrum::Prop::operator==(const Prop&) const = default;
-bool Spectrum::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Spectrum.hpp b/render_2D/render_2D/plottable/Spectrum.hpp
deleted file mode 100644
index 31736ba..0000000
--- a/render_2D/render_2D/plottable/Spectrum.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <utility>
-#include <vector>
-namespace aethera::render_2d {
-using Spectrum_Frequency = Plot_Coordinate;
-using Spectrum_Power = Plot_Value;
-using Spectrum_Interpolation_Ratio = Plot_Ratio;
-using Spectrum_Marker_Index = Plot_Index;
-struct Spectrum_Frame_Tag {};
-struct Spectrum_Frame {
-    std::vector<Spectrum_Power> samples{}; /* 最近提交的当前频谱功率样本。 */
-    bool operator==(const Spectrum_Frame&) const;
-};
-/* 使用频率轴和功率轴分块准备、绘制当前值、保持曲线及频率标记。 */
-struct Spectrum : Def<Spectrum, Renderable_2D,
-                      Tagged_Buffer<Spectrum_Frame_Tag, Spectrum_Frame>> {
-    using Scene_Object = Render_Scene_2D;
-    using Frequency_Object = Frequency_Axis;
-    using Power_Object = Numeric_Axis;
-    struct Prop : Prev_Prop {
-        Spectrum_Frequency center_frequency{50.0}; /* 中心频率标记位置，单位为 Hz。 */
-        Plot_Partition_Count partition_count{1}; /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
-        bool max_hold_visible{}; /* 是否绘制逐点历史最大值曲线。 */
-        bool min_hold_visible{}; /* 是否绘制逐点历史最小值曲线。 */
-        bool max_marker_visible{}; /* 是否标记当前样本的最大值位置。 */
-        bool min_marker_visible{}; /* 是否标记当前样本的最小值位置。 */
-        bool sweep_region_visible{}; /* 是否绘制扫频范围背景。 */
-        bool visible_range_only{true}; /* 是否裁掉频率轴当前范围外的线段。 */
-        Axis_Range frequency_range{}; /* 输入样本首尾对应的有向频率范围，单位为 Hz。 */
-        Axis_Range sweep_frequency_range{40.0, 60.0}; /* 扫频背景覆盖的频率范围，单位为 Hz。 */
-        Line_Interpolation_Mode interpolation_mode{Line_Interpolation_Mode::linear_value}; /* 相邻样本间的插值规则。 */
-        Brush max_brush{}; /* 最大保持曲线下方的填充样式。 */
-        Brush current_brush{}; /* 当前频谱曲线下方的填充样式。 */
-        Brush min_brush{}; /* 最小保持曲线下方的填充样式。 */
-        Pen max_pen{Color::red_color()}; /* 最大保持曲线及最大值标记样式。 */
-        Pen current_pen{Color::green_color()}; /* 当前频谱曲线样式。 */
-        Pen min_pen{Color::white()}; /* 最小保持曲线及最小值标记样式。 */
-        Pen selected_marker_pen{Color{0, 0, 139, 255}, 2.0}; /* 当前选中自定义标记的线条样式。 */
-        Pen marker_pen{Color::red_color()}; /* 未选中自定义标记的线条样式。 */
-        Pen middle_frequency_pen{Color::red_color()}; /* 中心频率垂线样式。 */
-        Brush sweep_region_brush{Color{255, 255, 0, 100}, Brush_Style::solid}; /* 扫频区域背景样式。 */
-        std::vector<Spectrum_Frequency> custom_markers{}; /* 自定义频率标记的唯一权威集合，单位为 Hz。 */
-        Spectrum_Marker_Index selected_marker{-1}; /* 当前选中标记下标；-1 表示未选择。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        std::size_t sample_count{}; /* 最近一次发布帧的样本数。 */
-        std::size_t rendered_point_count{}; /* 最近一次 Prepare 生成的曲线点数。 */
-        std::size_t selectable_marker_count{}; /* 当前可选择的自定义标记数。 */
-        bool operator==(const State&) const;
-    };
-    /* 完整声明、分块子图、内部状态操作和 CRTP 分派见 Spectrum.ipp。 */
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Frequency_Object*> frequency_axis,
-                not_null<Power_Object*> power_axis,
-                Plot_Partition_Count partition_count = 1);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Frequency_Object*> frequency_axis; /* 不拥有的频率轴；生命周期必须覆盖 Spectrum。 */
-        not_null<Power_Object*> power_axis; /* 不拥有的功率轴；生命周期必须覆盖 Spectrum。 */
-    };
-};
-}
-#include "Spectrum.ipp"
diff --git a/render_2D/render_2D/plottable/Spectrum.ipp b/render_2D/render_2D/plottable/Spectrum.ipp
deleted file mode 100644
index 1f24f30..0000000
--- a/render_2D/render_2D/plottable/Spectrum.ipp
+++ /dev/null
@@ -1,321 +0,0 @@
-#pragma once
-#include <optional>
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <iterator>
-#include <optional>
-#include "common/Curve_Plot.hpp"
-namespace aethera::render_2d {
-struct Spectrum::Private : Prev_Private {
-    using Prepared_Curve = detail::Curve_Prepared;
-    struct Prepared_Partition {
-        Prepared_Curve current{}; /* 当前频谱在本分块内的曲线。 */
-        Prepared_Curve maximum{}; /* 最大保持在本分块内的曲线。 */
-        Prepared_Curve minimum{}; /* 最小保持在本分块内的曲线。 */
-        Rect_F clip{}; /* 本分块对应的画布裁剪矩形。 */
-    };
-    enum struct Marker_Style : std::uint8_t { middle, normal, selected };
-    struct Prepared_Marker {
-        Point_F first{}; /* 标记线在功率轴起点侧的端点。 */
-        Point_F second{}; /* 标记线在功率轴终点侧的端点。 */
-        Marker_Style style{Marker_Style::normal}; /* Paint 阶段选择描边样式的业务类型。 */
-    };
-    struct Prepared_Extreme {
-        Point_F point{}; /* 当前帧极值映射到画布的位置。 */
-        bool maximum{}; /* true 使用最大值样式，false 使用最小值样式。 */
-    };
-    struct Prepared {
-        std::vector<Prepared_Partition> partitions{}; /* Prepare 子图各分块的独立输出。 */
-        std::vector<Prepared_Marker> markers{}; /* 中心频率及自定义频率标记。 */
-        std::array<std::optional<Prepared_Extreme>, 2> extremes{}; /* 最大/最小值由两个独立 Prepare 节点写入。 */
-        Rect_F sweep_region{}; /* 扫频背景在画布中的矩形。 */
-        Size canvas_size{}; /* 所属 Scene viewport 决定的颜色层尺寸。 */
-        bool valid{}; /* 两根轴与画布是否足以生成绘制数据。 */
-    };
-    Scene_Object* scene{}; /* 不拥有的所属二维 Scene；Builder 已登记状态层依赖。 */
-    Frequency_Object* frequency_axis{}; /* 不拥有的频率轴；Prepare 直接读取其当前状态。 */
-    Power_Object* power_axis{}; /* 不拥有的功率轴；Prepare 直接读取其当前状态。 */
-    Prepared prepared{}; /* 当前权威 State、Frame 和轴状态推导出的 Paint 输入。 */
-    std::vector<Spectrum_Power> maxima{}; /* 当前样本历史逐点最大值；只由 Prepare 更新。 */
-    std::vector<Spectrum_Power> minima{}; /* 当前样本历史逐点最小值；只由 Prepare 更新。 */
-    bool hold_history_reset{}; /* prepare.frame 是否已用当前帧初始化整段保持值。 */
-    std::size_t graph_partition_count{};
-    /* Builder 内部绑定 Scene 与两根轴；三个来源都必须比 Spectrum 生命周期更长。 */
-    void bind_render_sources(not_null<Frequency_Object*> frequency_axis_value,
-                             not_null<Power_Object*> power_axis_value);
-    /* CRTP State 钩子：Spectrum 业务状态写入后标记自身 Prepare；其他继承层状态由各自 Private 负责。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> pending_states);
-/* CRTP 子图能力：按显式 partition_count 构建并行 Prepare 图。 */
-    [[nodiscard]] Task_Graph build_graph(Spectrum* object, const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Spectrum* object, const Prop& state);
-    void prepare_frame(Spectrum* object, std::size_t partition_count);
-    void update_hold_partition(Spectrum* object, std::size_t partition_index);
-    void prepare_extreme(Spectrum* object, bool maximum);
-    void prepare_partition(Spectrum* object, std::size_t partition_index);
-    void begin_paint(Spectrum* object);
-    void paint_partition(Spectrum* object, std::size_t partition_index);
-    void paint_overlays(Spectrum* object);
-};
-template <typename Object>
-Spectrum::Builder<Object>::Builder(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value,
-    Plot_Partition_Count partition_count)
-    : Base(), frequency_axis(frequency_axis_value),
-      power_axis(power_axis_value) {
-    this->prop.partition_count = partition_count;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Spectrum::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto spectrum = std::move(result).value();
-    auto& private_data = detail::Internal_Access::layer<Object>(spectrum.get());
-    private_data.bind_render_sources(frequency_axis, power_axis);
-    private_data.scene_attach = [object = not_null{spectrum.get()}](
-        not_null<Root*> root) -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::layer<Object>(object.get());
-        data.scene = scene;
-        const auto frequency_axis = not_null{data.frequency_axis};
-        const auto power_axis = not_null{data.power_axis};
-        return detail::Internal_Access::edit_dependency_graph<Render_Graph_Tag, Render_Cache_Tag>(scene.get(), [&](auto& graph, auto& cache) {
-            graph.add_dependency(frequency_axis.get(), object.get());
-            graph.add_dependency(power_axis.get(), object.get());
-            cache.template add_prop_dependency<&Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), power_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), power_axis.get());
-        });
-    };
-    return spectrum;
-}
-inline bool Spectrum::Private::should_rebuild_graph(Spectrum*, const Prop& state) {
-    return graph_partition_count != state.partition_count;
-}
-inline Task_Graph Spectrum::Private::build_graph(Spectrum* object, const Prop& state) {
-    const Plot_Partition_Count partition_count = state.partition_count;
-    graph_partition_count = partition_count;
-    Task_Graph graph{"spectrum"};
-    auto prepare_begin = graph.add("prepare.frame", [this, object, partition_count] {
-        prepare_frame(object, partition_count);
-    });
-    auto hold_complete = graph.add("prepare.hold.complete", [] {});
-    std::vector<Task_Node> hold_partitions;
-    hold_partitions.reserve(partition_count);
-    for (std::size_t index = 0; index < partition_count; ++index) {
-        auto partition = graph.add("prepare.hold.partition", [this, object, index] {
-            update_hold_partition(object, index);
-        });
-        prepare_begin.precede(partition);
-        partition.precede(hold_complete);
-        hold_partitions.push_back(partition);
-    }
-    if (hold_partitions.empty()) prepare_begin.precede(hold_complete);
-    std::vector<Task_Node> prepared_partitions;
-    prepared_partitions.reserve(partition_count);
-    for (std::size_t index = 0; index < partition_count; ++index) {
-        auto partition = graph.add("prepare.partition", [this, object, index] {
-            prepare_partition(object, index);
-        });
-        hold_complete.precede(partition);
-        prepared_partitions.push_back(partition);
-    }
-    auto maximum = graph.add("prepare.extreme.maximum", [this, object] {
-        prepare_extreme(object, true);
-    });
-    auto minimum = graph.add("prepare.extreme.minimum", [this, object] {
-        prepare_extreme(object, false);
-    });
-    prepare_begin.precede(maximum);
-    prepare_begin.precede(minimum);
-    auto paint_begin = graph.add("paint.begin", [this, object] {
-        begin_paint(object);
-    });
-    if (prepared_partitions.empty()) prepare_begin.precede(paint_begin);
-    for (const auto& partition : prepared_partitions) partition.precede(paint_begin);
-    auto overlays = graph.add("paint.overlays", [this, object] {
-        paint_overlays(object);
-    });
-    for (std::size_t index = 0; index < partition_count; ++index) {
-        auto partition = graph.add("paint.partition", [this, object, index] {
-            paint_partition(object, index);
-        });
-        paint_begin.precede(partition);
-        partition.precede(overlays);
-    }
-    maximum.precede(overlays);
-    minimum.precede(overlays);
-    if (partition_count == 0) paint_begin.precede(overlays);
-    return graph;
-}
-inline void Spectrum::Private::prepare_frame(Spectrum* object, std::size_t partition_count) {
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto frequency = frequency_axis;
-    const auto power = power_axis;
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const auto& frame = double_buffer::detail::Internal_Access::current_buffer<Spectrum_Frame_Tag>(object);
-    hold_history_reset = maxima.size() != frame.samples.size();
-    if (hold_history_reset) {
-        maxima = frame.samples;
-        minima = frame.samples;
-    }
-    const auto& scene_state = this->template read_current_prop<Render_Scene_2D::Base_Tag>(
-        scene);
-    const auto& frequency_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(frequency);
-    const auto& power_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(power);
-    const auto& power_state = this->template read_current_prop<Numeric_Axis::Base_Tag>(power);
-    prepared = {};
-    prepared.partitions.resize(partition_count);
-    if (frequency_layout.orientation == power_layout.orientation) return;
-    if (scene_state.viewport.empty()) return;
-    prepared.canvas_size = scene_state.viewport;
-    if (state.sweep_region_visible) prepared.sweep_region = detail::map_plot_rect(frequency, state.sweep_frequency_range, power, power_state.coordinate_range, frequency_layout.orientation);
-    prepared.markers.push_back({detail::map_plot_point(frequency, state.center_frequency, power, power_state.coordinate_range.origin, frequency_layout.orientation), detail::map_plot_point(frequency, state.center_frequency, power, power_state.coordinate_range.target, frequency_layout.orientation), Marker_Style::middle});
-    for (std::size_t index = 0; index < state.custom_markers.size(); ++index) {
-        const Spectrum_Frequency frequency = state.custom_markers[index];
-        const Marker_Style style = static_cast<Spectrum_Marker_Index>(index) == state.selected_marker ? Marker_Style::selected : Marker_Style::normal;
-        prepared.markers.push_back({detail::map_plot_point(frequency_axis, frequency, power, power_state.coordinate_range.origin, frequency_layout.orientation), detail::map_plot_point(frequency_axis, frequency, power, power_state.coordinate_range.target, frequency_layout.orientation), style});
-    }
-    prepared.valid = true;
-}
-inline void Spectrum::Private::update_hold_partition(
-    Spectrum* object, std::size_t partition_index) {
-    if (hold_history_reset || graph_partition_count == 0) return;
-    const auto& frame = double_buffer::detail::Internal_Access::
-        current_buffer<Spectrum_Frame_Tag>(object);
-    const std::size_t first = frame.samples.size() * partition_index /
-                              graph_partition_count;
-    const std::size_t last = frame.samples.size() * (partition_index + 1) /
-                             graph_partition_count;
-    for (std::size_t index = first; index < last; ++index) {
-        maxima[index] = std::max(maxima[index], frame.samples[index]);
-        minima[index] = std::min(minima[index], frame.samples[index]);
-    }
-}
-inline void Spectrum::Private::prepare_extreme(Spectrum* object, bool maximum) {
-    const auto& state = static_cast<const Prop&>(
-        double_buffer::detail::Internal_Access::current_prop(object));
-    const std::size_t slot = maximum ? 0 : 1;
-    if (!prepared.valid || (maximum ? !state.max_marker_visible
-                                    : !state.min_marker_visible)) {
-        prepared.extremes[slot].reset();
-        return;
-    }
-    const auto& frame = double_buffer::detail::Internal_Access::
-        current_buffer<Spectrum_Frame_Tag>(object);
-    if (frame.samples.empty()) {
-        prepared.extremes[slot].reset();
-        return;
-    }
-    const auto iterator = maximum
-        ? std::max_element(frame.samples.begin(), frame.samples.end())
-        : std::min_element(frame.samples.begin(), frame.samples.end());
-    const auto index = static_cast<std::size_t>(
-        std::distance(frame.samples.begin(), iterator));
-    const Spectrum_Interpolation_Ratio denominator = frame.samples.size() > 1
-        ? static_cast<Spectrum_Interpolation_Ratio>(frame.samples.size() - 1)
-        : 1.0;
-    const Spectrum_Frequency frequency = state.frequency_range.origin +
-        state.frequency_range.length() *
-            static_cast<Spectrum_Interpolation_Ratio>(index) / denominator;
-    const auto& frequency_layout = this->template read_current_prop<
-        Abs_Axis::Base_Tag>(frequency_axis);
-    prepared.extremes[slot] = Prepared_Extreme{
-        detail::map_plot_point(frequency_axis, frequency,
-                               power_axis, *iterator,
-                               frequency_layout.orientation),
-        maximum};
-}
-inline void Spectrum::Private::prepare_partition(Spectrum* object, std::size_t partition_index) {
-    if (!prepared.valid || partition_index >= prepared.partitions.size()) return;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const auto& frame = double_buffer::detail::Internal_Access::current_buffer<Spectrum_Frame_Tag>(object);
-    if (frame.samples.empty()) return;
-    const auto frequency = frequency_axis;
-    const auto power = power_axis;
-    const auto& frequency_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(frequency);
-    const auto& power_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(power);
-    const auto& frequency_state = this->template read_current_prop<Numeric_Axis::Base_Tag>(frequency);
-    const auto& power_state = this->template read_current_prop<Numeric_Axis::Base_Tag>(power);
-    const auto range = detail::curve_partition_range(frame.samples.size(), partition_index, prepared.partitions.size(), state.frequency_range);
-    auto& partition = prepared.partitions[partition_index];
-    partition.clip = detail::map_plot_rect(frequency, range.domain, power, power_state.coordinate_range, frequency_layout.orientation);
-    partition.current = detail::prepare_curve(std::span<const Spectrum_Power>(frame.samples).subspan(range.first_sample, range.sample_count), range.domain, state.interpolation_mode, state.visible_range_only, frequency_state.coordinate_range, power_state.coordinate_range, frequency, power, frequency_layout.orientation, power_layout.orientation);
-    if (state.max_hold_visible && maxima.size() == frame.samples.size()) partition.maximum = detail::prepare_curve(std::span<const Spectrum_Power>(maxima).subspan(range.first_sample, range.sample_count), range.domain, state.interpolation_mode, state.visible_range_only, frequency_state.coordinate_range, power_state.coordinate_range, frequency, power, frequency_layout.orientation, power_layout.orientation);
-    if (state.min_hold_visible && minima.size() == frame.samples.size()) partition.minimum = detail::prepare_curve(std::span<const Spectrum_Power>(minima).subspan(range.first_sample, range.sample_count), range.domain, state.interpolation_mode, state.visible_range_only, frequency_state.coordinate_range, power_state.coordinate_range, frequency, power, frequency_layout.orientation, power_layout.orientation);
-}
-inline void Spectrum::Private::begin_paint(Spectrum* object) {
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    auto& published = static_cast<State&>(double_buffer::detail::Internal_Access::pending_state(object));
-    const auto& frame = double_buffer::detail::Internal_Access::current_buffer<Spectrum_Frame_Tag>(object);
-    published.sample_count = frame.samples.size();
-    published.rendered_point_count = 0;
-    for (const auto& partition : prepared.partitions) published.rendered_point_count += partition.current.points.size();
-    published.selectable_marker_count = state.custom_markers.size();
-    auto& cache = private_data.paint_surface();
-    if (!prepared.valid) return;
-    if (!state.sweep_region_visible || prepared.sweep_region.empty()) return;
-    detail::Painter painter(cache, prepared.canvas_size, prepared.sweep_region);
-    painter.rect(prepared.sweep_region, Pen{.style = Line_Style::none},
-                 state.sweep_region_brush);
-}
-inline void Spectrum::Private::paint_partition(Spectrum* object,
-                                         std::size_t partition_index) {
-    if (!prepared.valid || partition_index >= prepared.partitions.size()) return;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    const auto& partition = prepared.partitions[partition_index];
-    if (partition.clip.empty()) return;
-    const Rect_F clip = partition.clip.normalized();
-    constexpr double overlap{2.0};
-    detail::Painter painter(
-        private_data.paint_surface(), prepared.canvas_size,
-        {clip.x - overlap, clip.y - overlap,
-         clip.width + overlap * 2.0, clip.height + overlap * 2.0});
-    const auto clip_scope = painter.scoped_clip(clip);
-    detail::paint_curve(painter, partition.maximum, state.max_pen,
-                        state.max_brush);
-    detail::paint_curve(painter, partition.minimum, state.min_pen,
-                        state.min_brush);
-    detail::paint_curve(painter, partition.current, state.current_pen,
-                        state.current_brush);
-}
-inline void Spectrum::Private::paint_overlays(Spectrum* object) {
-    if (!prepared.valid) return;
-    auto& private_data = double_buffer::detail::Internal_Access::get(object);
-    const auto& state = static_cast<const Prop&>(double_buffer::detail::Internal_Access::current_prop(object));
-    detail::Painter painter(private_data.paint_surface(), prepared.canvas_size);
-    for (const auto& marker : prepared.markers) {
-        const Pen& pen = marker.style == Marker_Style::middle ? state.middle_frequency_pen : marker.style == Marker_Style::selected ? state.selected_marker_pen : state.marker_pen;
-        if (pen.enabled()) painter.line(marker.first, marker.second, pen);
-    }
-    for (const auto& extreme : prepared.extremes) {
-        if (!extreme) continue;
-        const Pen& pen = extreme->maximum ? state.max_pen : state.min_pen;
-        painter.circle(extreme->point, 3.0, pen, Brush{pen.color, Brush_Style::solid});
-    }
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Spectrum::Private::after_prop_set(Object* object, Member Owner::*,
-                                       Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Spectrum::Private::bind_render_sources(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value) {
-    frequency_axis = frequency_axis_value;
-    power_axis = power_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/Sweep_Spectrum.cpp b/render_2D/render_2D/plottable/Sweep_Spectrum.cpp
deleted file mode 100644
index df5b696..0000000
--- a/render_2D/render_2D/plottable/Sweep_Spectrum.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "Sweep_Spectrum.hpp"                              /* Sweep Spectrum 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Sweep_Spectrum::Prop::operator==(const Prop&) const = default;
-bool Sweep_Spectrum::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Sweep_Spectrum.hpp b/render_2D/render_2D/plottable/Sweep_Spectrum.hpp
deleted file mode 100644
index 6db76fe..0000000
--- a/render_2D/render_2D/plottable/Sweep_Spectrum.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <memory_resource>
-#include <span>
-#include <vector>
-namespace aethera::render_2d {
-struct Sweep_Spectrum_Stream_Tag {};
-/*
- * 一次输入交换可以包含同一扫频周期的一组块更新。index 是块在完整扫频中的
- * 固定槽位，而不是历史序号；未出现在本组中的槽位必须保留原值。
- */
-struct Sweep_Spectrum_Block {
-    std::size_t index{};                                      /* 当前完整扫频周期内的块位置。 */
-    std::vector<Plot_Value> values{};                         /* 该频率块按频率递增排列的功率值。 */
-};
-struct Sweep_Spectrum : Def<Sweep_Spectrum, Renderable_2D,
-    Mpmc_Triple_Buffer<Sweep_Spectrum_Stream_Tag,
-                       std::shared_ptr<const Sweep_Spectrum_Block>>> {
-    using Scene_Object = Render_Scene_2D;
-    using Frequency_Object = Frequency_Axis;
-    using Power_Object = Numeric_Axis;
-    struct Prop : Prev_Prop {
-        std::size_t bins_per_block{};                              /* 每个扫频块期望的功率点数；零值接受首块尺寸。 */
-        std::size_t block_count{1};                               /* 一个完整扫频周期包含的块数；零值按 1 处理。 */
-        Plot_Partition_Count partition_count{1};                  /* 曲线 Prepare/Paint 子图的显式分块数；零值禁用曲线分块任务。 */
-        bool visible_range_only{true};                            /* 是否裁掉频率轴可见范围外的线段。 */
-        Axis_Range frequency_range{};                             /* 全部扫描块覆盖的频率范围。 */
-        Pen pen{Color::yellow()};                                 /* 扫频折线样式。 */
-        Pen current_frequency_pen{Color::red_color(), 2.0};       /* 当前扫频位置垂线样式。 */
-        Line_Interpolation_Mode interpolation_mode{Line_Interpolation_Mode::linear_value}; /* 相邻功率点插值方式。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Frequency_Object*> frequency_axis,
-                not_null<Power_Object*> power_axis,
-                Plot_Partition_Count partition_count = 1);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Frequency_Object*> frequency_axis;          /* 不拥有的频率轴。 */
-        not_null<Power_Object*> power_axis;                  /* 不拥有的功率轴。 */
-    };
-};
-}
-#include "Sweep_Spectrum.ipp"
diff --git a/render_2D/render_2D/plottable/Sweep_Spectrum.ipp b/render_2D/render_2D/plottable/Sweep_Spectrum.ipp
deleted file mode 100644
index f9363de..0000000
--- a/render_2D/render_2D/plottable/Sweep_Spectrum.ipp
+++ /dev/null
@@ -1,233 +0,0 @@
-#pragma once
-#include <optional>
-#include "common/Curve_Plot.hpp"
-#include <algorithm>
-#include <iterator>
-namespace aethera::render_2d {
-struct Sweep_Spectrum::Private : Prev_Private {
-    struct Prepared {
-        std::vector<detail::Curve_Prepared> partitions{};     /* 单条组合折线各 Prepare 分块的曲线输出。 */
-        std::vector<Plot_Value> values{};                     /* 各频率段最新数据按槽位顺序拼接的功率值。 */
-        Axis_Range domain{};                                  /* 当前已有频率段共同覆盖的业务坐标区间。 */
-        Point_F marker_first{};                               /* 最新写入段末端扫描位置线的首端点。 */
-        Point_F marker_second{};                              /* 最新写入段末端扫描位置线的末端点。 */
-        Size canvas{};                                       /* 当前 Scene viewport 的像素尺寸。 */
-        bool valid{};                                        /* 两根轴正交、画布及组合折线均有效。 */
-    };
-    Scene_Object* scene{};           /* 不拥有的所属 Scene。 */
-    Frequency_Object* frequency_axis{}; /* 不拥有的频率轴。 */
-    Power_Object* power_axis{};      /* 不拥有的功率轴。 */
-    /*
-     * 完整扫频的唯一持久状态。每次交换得到一组块更新并原位覆盖相应槽位；
-     * 三缓冲只负责跨线程交付输入组，不承担扫频历史保存职责。
-     */
-    std::vector<std::shared_ptr<const Sweep_Spectrum_Block>> sweep_blocks{};
-    std::size_t latest_block_index{};                        /* 最近输入组最后更新的块，决定红色扫描线。 */
-    bool has_latest_block{};
-    Prepared prepared{};                                     /* 当前块集合推导出的绘制输入。 */
-    Plot_Partition_Count graph_partition_count{};            /* 当前 Prepare 子图分块数。 */
-    void bind_sources(not_null<Frequency_Object*> frequency_axis_value,
-                      not_null<Power_Object*> power_axis_value);
-    /* CRTP 覆盖：按扫描点规模构建分块 Prepare 子图。 */
-    [[nodiscard]] Task_Graph build_graph(Sweep_Spectrum* object, const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Sweep_Spectrum* object, const Prop& state);
-    void prepare_frame(Sweep_Spectrum* object);
-    void prepare_partition(Sweep_Spectrum* object, Plot_Partition_Count index);
-    void paint_partition(Sweep_Spectrum* object, Plot_Partition_Count index);
-    void paint_marker(Sweep_Spectrum* object);
-    [[nodiscard]] std::size_t stored_point_count() const;
-    template <typename Object, typename Owner, typename Member, typename Prop_Type> void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> states);
-};
-template <typename Object>
-Sweep_Spectrum::Builder<Object>::Builder(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value,
-    Plot_Partition_Count partition_count)
-    : Base(), frequency_axis(frequency_axis_value),
-      power_axis(power_axis_value) {
-    this->prop.partition_count = partition_count;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Sweep_Spectrum::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto sweep = std::move(result).value();
-    const not_null object{sweep.get()};
-    auto& private_data = detail::Internal_Access::get(object.get());
-    private_data.bind_sources(frequency_axis, power_axis);
-    private_data.scene_attach = [object](not_null<Root*> root)
-        -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::get(object.get());
-        data.scene = scene;
-        const auto frequency = not_null{data.frequency_axis};
-        const auto power = not_null{data.power_axis};
-        return detail::Internal_Access::edit_dependency_graph<
-            Render_Graph_Tag, Render_Cache_Tag>(
-            scene.get(), [&](auto& graph, auto& cache) {
-                graph.add_dependency(frequency.get(), object.get());
-                graph.add_dependency(power.get(), object.get());
-                cache.template add_prop_dependency<
-                    &Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::position>(object.get(), frequency.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::pixel_length>(object.get(), frequency.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::orientation>(object.get(), frequency.get());
-                cache.template add_prop_dependency<
-                    &Numeric_Axis::Prop::coordinate_range>(object.get(), frequency.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::position>(object.get(), power.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::pixel_length>(object.get(), power.get());
-                cache.template add_prop_dependency<
-                    &Abs_Axis::Prop::orientation>(object.get(), power.get());
-                cache.template add_prop_dependency<
-                    &Numeric_Axis::Prop::coordinate_range>(object.get(), power.get());
-            });
-    };
-    return sweep;
-}
-inline bool Sweep_Spectrum::Private::should_rebuild_graph(Sweep_Spectrum*, const Prop& state) { return graph_partition_count != state.partition_count; }
-inline Task_Graph Sweep_Spectrum::Private::build_graph(Sweep_Spectrum* object, const Prop& state) {
-    graph_partition_count = state.partition_count;
-    Task_Graph graph{"sweep_spectrum"};
-    auto begin = graph.add("prepare.frame", [this, object] { prepare_frame(object); });
-    std::vector<Task_Node> prepare_tasks;
-    for (Plot_Partition_Count index = 0; index < graph_partition_count; ++index) {
-        auto task = graph.add("prepare.partition", [this, object, index] { prepare_partition(object, index); });
-        begin.precede(task);
-        prepare_tasks.push_back(task);
-    }
-    auto marker = graph.add("paint.marker", [this, object] { paint_marker(object); });
-    if (graph_partition_count == 0) begin.precede(marker);
-    for (Plot_Partition_Count index = 0; index < graph_partition_count; ++index) {
-        auto partition = graph.add("paint.partition", [this, object, index] { paint_partition(object, index); });
-        if (prepare_tasks.empty()) begin.precede(partition);
-        else prepare_tasks[index].precede(partition);
-        partition.precede(marker);
-    }
-    return graph;
-}
-inline void Sweep_Spectrum::Private::prepare_frame(Sweep_Spectrum* object) {
-    const auto frequency = frequency_axis;
-    const auto power = power_axis;
-    const auto& state = this->template read_current_prop<
-        Sweep_Spectrum::Base_Tag>(object);
-    const auto& frequency_layout = this->template read_current_prop<
-        Abs_Axis::Base_Tag>(frequency);
-    const auto& power_layout = this->template read_current_prop<
-        Abs_Axis::Base_Tag>(power);
-    const auto& power_state = this->template read_current_prop<
-        Numeric_Axis::Base_Tag>(power);
-    prepared = {};
-    prepared.canvas = this->template read_current_prop<
-        Render_Scene_2D::Base_Tag>(scene).viewport;
-    const std::size_t block_count = std::max<std::size_t>(1, state.block_count);
-    if (sweep_blocks.size() != block_count) {
-        sweep_blocks.assign(block_count, {});
-        latest_block_index = 0;
-        has_latest_block = false;
-    }
-    detail::Internal_Access::exchange_stream<Sweep_Spectrum_Stream_Tag>(object);
-    /* 当前 rendering 队列就是本次输入组；组内所有合法块依次覆盖持久槽位。 */
-    detail::Internal_Access::access_rendering_stream<Sweep_Spectrum_Stream_Tag>(object, [&](std::span<std::shared_ptr<const Sweep_Spectrum_Block>> blocks) {
-        for (const auto& block : blocks) {
-            if (!block || block->index >= block_count) continue;
-            sweep_blocks[block->index] = block;
-            latest_block_index = block->index;
-            has_latest_block = true;
-        }
-    });
-    std::size_t available_blocks{};
-    for (const auto& block : sweep_blocks) {
-        if (!block) continue;
-        ++available_blocks;
-        prepared.values.insert(prepared.values.end(), block->values.begin(), block->values.end());
-    }
-    if (prepared.canvas.empty() || frequency_layout.orientation == power_layout.orientation || available_blocks == 0) return;
-    prepared.partitions.resize(graph_partition_count);
-    if (prepared.values.empty()) return;
-    const double domain_progress = available_blocks == block_count ? 1.0 :
-        static_cast<double>(latest_block_index + 1) / static_cast<double>(block_count);
-    const double marker_progress = has_latest_block ?
-        static_cast<double>(latest_block_index + 1) / static_cast<double>(block_count) : 0.0;
-    const auto domain_target = state.frequency_range.origin + state.frequency_range.length() * domain_progress;
-    const auto latest_frequency = state.frequency_range.origin + state.frequency_range.length() * marker_progress;
-    prepared.domain = {state.frequency_range.origin, domain_target};
-    prepared.marker_first = detail::map_plot_point(
-        frequency, latest_frequency, power, power_state.coordinate_range.origin,
-        frequency_layout.orientation);
-    prepared.marker_second = detail::map_plot_point(
-        frequency, latest_frequency, power, power_state.coordinate_range.target,
-        frequency_layout.orientation);
-    prepared.valid = true;
-}
-inline void Sweep_Spectrum::Private::prepare_partition(Sweep_Spectrum* object, Plot_Partition_Count index) {
-    if (!prepared.valid) return;
-    const auto frequency = frequency_axis;
-    const auto power = power_axis;
-    const auto& state = this->template read_current_prop<
-        Sweep_Spectrum::Base_Tag>(object);
-    const auto& frequency_layout = this->template read_current_prop<
-        Abs_Axis::Base_Tag>(frequency);
-    const auto& power_layout = this->template read_current_prop<
-        Abs_Axis::Base_Tag>(power);
-    const auto& frequency_state = this->template read_current_prop<
-        Numeric_Axis::Base_Tag>(frequency);
-    const auto& power_state = this->template read_current_prop<
-        Numeric_Axis::Base_Tag>(power);
-    const auto range = detail::curve_partition_range(
-        prepared.values.size(), index, prepared.partitions.size(),
-        prepared.domain);
-    prepared.partitions[index] = detail::prepare_curve(
-        std::span<const Plot_Value>(prepared.values).subspan(
-            range.first_sample, range.sample_count),
-        range.domain, state.interpolation_mode, state.visible_range_only,
-        frequency_state.coordinate_range, power_state.coordinate_range,
-        frequency, power, frequency_layout.orientation,
-        power_layout.orientation);
-}
-inline void Sweep_Spectrum::Private::paint_partition(Sweep_Spectrum* object, Plot_Partition_Count index) {
-    if (!prepared.valid || index >= prepared.partitions.size()) return;
-    const auto& state = this->template read_current_prop<Sweep_Spectrum::Base_Tag>(object);
-    const auto& curve = prepared.partitions[index];
-    const Rect_F region = detail::curve_paint_region(curve, state.pen.width + 2.0);
-    if (region.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas, region);
-    detail::paint_curve(painter, curve, state.pen);
-}
-inline void Sweep_Spectrum::Private::paint_marker(Sweep_Spectrum* object) {
-    if (!prepared.valid) return;
-    const auto& state = this->template read_current_prop<Sweep_Spectrum::Base_Tag>(object);
-    const double padding = state.current_frequency_pen.width + 2.0;
-    const auto [left, right] = std::minmax(prepared.marker_first.x, prepared.marker_second.x);
-    const auto [top, bottom] = std::minmax(prepared.marker_first.y, prepared.marker_second.y);
-    detail::Painter painter(this->paint_surface(), prepared.canvas,
-                           {left - padding, top - padding,
-                            right - left + padding * 2.0,
-                            bottom - top + padding * 2.0});
-    painter.line(prepared.marker_first, prepared.marker_second,
-                 state.current_frequency_pen);
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Sweep_Spectrum::Private::after_prop_set(
-    Object* object, Member Owner::*, Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Sweep_Spectrum::Private::bind_sources(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Power_Object*> power_axis_value) {
-    frequency_axis = frequency_axis_value;
-    power_axis = power_axis_value;
-}
-inline std::size_t Sweep_Spectrum::Private::stored_point_count() const {
-    std::size_t count{};
-    for (const auto& block : sweep_blocks)
-        if (block) count += block->values.size();
-    return count;
-}
-}
diff --git a/render_2D/render_2D/plottable/Waterfall.cpp b/render_2D/render_2D/plottable/Waterfall.cpp
deleted file mode 100644
index bac0250..0000000
--- a/render_2D/render_2D/plottable/Waterfall.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "Waterfall.hpp"                                   /* Waterfall 最终实例及三类依赖实现。 */
-namespace aethera::render_2d {
-bool Waterfall_Row::operator==(const Waterfall_Row&) const = default;
-bool Waterfall::Prop::operator==(const Prop&) const = default;
-bool Waterfall::State::operator==(const State&) const = default;
-}
diff --git a/render_2D/render_2D/plottable/Waterfall.hpp b/render_2D/render_2D/plottable/Waterfall.hpp
deleted file mode 100644
index e1aacc5..0000000
--- a/render_2D/render_2D/plottable/Waterfall.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-#include "../axis/Axis.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include "../scene/Render_Scene_2D.hpp"
-#include "Hover_Tooltip.hpp"
-#include "Plot_Types.hpp"
-#include <expected>
-#include <memory>
-#include <memory_resource>
-#include <span>
-#include <vector>
-namespace aethera::render_2d {
-struct Waterfall_Row {
-    Plot_Time_Tick tick{};                    /* 使用层从绑定时间轴取得的行位置 tick。 */
-    std::vector<Plot_Value> values{};         /* 该时间槽从低频到高频排列的功率值。 */
-    bool operator==(const Waterfall_Row&) const;
-};
-struct Waterfall_Stream_Tag {};
-struct Waterfall : Def<Waterfall, Renderable_2D,
-    Mpmc_Triple_Buffer<Waterfall_Stream_Tag, std::shared_ptr<const Waterfall_Row>>> {
-    using Scene_Object = Render_Scene_2D;
-    using Frequency_Object = Frequency_Axis;
-    using Time_Object = Time_Axis;
-    struct Prop : Prev_Prop {
-        bool tooltip_enabled{true};                                                     /* 是否响应指针位置显示提示。 */
-        Font tooltip_font{};                                                            /* 提示文字字体。 */
-        Pen tooltip_text_pen{Color::white()};                                           /* 提示文字样式。 */
-        Brush tooltip_background_brush{Color{20, 20, 20, 220}, Brush_Style::solid};     /* 提示背景样式。 */
-        std::size_t frequency_bin_count{};                                              /* 目标频率列数；零值使用最新行尺寸。 */
-        Plot_Partition_Grid partition_grid{};                                           /* framebuffer 按列×行显式分块；任一维为零时禁用栅格任务。 */
-        bool visible_range_only{true};                                                  /* 是否按频率轴范围裁剪栅格。 */
-        Axis_Range frequency_range{0.0, 10.0};                                          /* 每行频谱覆盖的频率范围。 */
-        Axis_Range power_range{0.0, 10.0};                                              /* 颜色映射使用的功率范围。 */
-        Image_Interpolation_Mode interpolation_mode{Image_Interpolation_Mode::bilinear}; /* 栅格放大时的图像插值方式。 */
-        Color_Map color_map{};                                                          /* 功率到颜色的映射。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {
-        bool operator==(const State&) const;
-    };
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        Builder(not_null<Frequency_Object*> frequency_axis,
-                not_null<Time_Object*> time_axis,
-                Plot_Partition_Grid partition_grid = {});
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        not_null<Frequency_Object*> frequency_axis; /* 不拥有的频率轴；生命周期必须覆盖 Waterfall。 */
-        not_null<Time_Object*> time_axis;           /* 不拥有的时间轴；生命周期必须覆盖 Waterfall。 */
-    };
-};
-}
-#include "Waterfall.ipp"
diff --git a/render_2D/render_2D/plottable/Waterfall.ipp b/render_2D/render_2D/plottable/Waterfall.ipp
deleted file mode 100644
index 5ab7aa9..0000000
--- a/render_2D/render_2D/plottable/Waterfall.ipp
+++ /dev/null
@@ -1,291 +0,0 @@
-#pragma once
-#include <optional>
-#include "common/Curve_Plot.hpp"
-#include "common/Raster_Plot.hpp"
-#include <algorithm>
-#include <cmath>
-#include <iomanip>
-#include <iterator>
-#include <sstream>
-namespace aethera::render_2d {
-struct Waterfall::Private : Prev_Private {
-    struct Prepared {
-        struct Tile {
-            detail::Raster_Partition source{}; /* 含插值 halo 的独占不可变源区域。 */
-            Rect_F target{}; /* source 在完整热图目标矩形中的精确投影。 */
-            std::vector<Pixel> pixels{};
-        };
-        std::vector<std::shared_ptr<const Waterfall_Row>> rows_by_slot{}; /* 时间槽到本帧源行的唯一映射；空槽保持空指针。 */
-        detail::Raster_Layout layout{}; /* 可视频段与完整时间窗口组成的色块布局。 */
-        std::vector<Tile> tiles{}; /* 每个任务只写、随后只读自己的插值源块。 */
-        Rect_F tooltip_box{}; /* 当前 hover 提示框的画布矩形。 */
-        std::string tooltip_text{}; /* 当前 hover 频率文本；空值表示不绘制。 */
-        Size canvas{}; /* 当前 Scene viewport 的像素尺寸。 */
-        int source_first{}; /* 可视频段在源频谱行中的首列。 */
-        bool valid{}; /* 轴布局和行数据是否足以生成色块。 */
-    };
-    Scene_Object* scene{}; /* 不拥有的所属 Scene。 */
-    Frequency_Object* frequency_axis{}; /* 不拥有的频率轴。 */
-    Time_Object* time_axis{}; /* 不拥有的时间轴，同时权威决定保留行数。 */
-    Prepared prepared{}; /* 当前权威状态推导出的 Paint 输入。 */
-    detail::Hover_Tooltip_Runtime tooltip{}; /* 事件侧当前 hover 位置。 */
-    Plot_Partition_Grid graph_partition_grid{}; /* Prepare/Paint 子图当前固化的 framebuffer 列×行网格。 */
-    void bind_sources(not_null<Frequency_Object*> frequency_axis_value,
-                      not_null<Time_Object*> time_axis_value);
-    /* CRTP 覆盖：按当前色块工作量构建分块 Prepare 子图。 */
-    [[nodiscard]] Task_Graph build_graph(Waterfall* object, const Prop& state);
-    [[nodiscard]] bool should_rebuild_graph(Waterfall* object, const Prop& state);
-    void prepare_frame(Waterfall* object);
-    void prepare_partition(Waterfall* object, Plot_Partition_Count index);
-    void paint_partition(Waterfall* object, Plot_Partition_Count index);
-    void paint_tooltip(Waterfall* object);
-    /* CRTP 覆盖：更新 hover 位置并请求重绘。 */
-    void handle_event(Waterfall* object, const Event& event);
-    /* CRTP 覆盖：本类状态写入后标记 Prepare 数据失效。 */
-    template <typename Object, typename Owner, typename Member, typename Prop_Type>
-    void after_prop_set(Object* object, Member Owner::* member, Prop_Access<Prop_Type> states);
-};
-template <typename Object>
-Waterfall::Builder<Object>::Builder(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Time_Object*> time_axis_value,
-    Plot_Partition_Grid partition_grid)
-    : Base(), frequency_axis(frequency_axis_value),
-      time_axis(time_axis_value) {
-    this->prop.partition_grid = partition_grid;
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Waterfall::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto plot = std::move(result).value();
-    auto& private_data = detail::Internal_Access::layer<Object>(plot.get());
-    private_data.bind_sources(frequency_axis, time_axis);
-    private_data.scene_attach = [object = not_null{plot.get()}](
-        not_null<Root*> root) -> std::expected<void, Dependency_Graph_Error> {
-        const not_null scene{static_cast<Scene_Object*>(root.get())};
-        auto& data = detail::Internal_Access::layer<Object>(object.get());
-        data.scene = scene;
-        const auto frequency_axis = not_null{data.frequency_axis};
-        const auto time_axis = not_null{data.time_axis};
-        return detail::Internal_Access::edit_dependency_graph<Render_Graph_Tag, Render_Cache_Tag>(scene.get(), [&](auto& graph, auto& cache) {
-            graph.add_dependency(frequency_axis.get(), object.get());
-            graph.add_dependency(time_axis.get(), object.get());
-            cache.template add_prop_dependency<&Render_Scene_2D::Prop::viewport>(object.get(), scene.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Numeric_Axis::Prop::coordinate_range>(object.get(), frequency_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::position>(object.get(), time_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::pixel_length>(object.get(), time_axis.get());
-            cache.template add_prop_dependency<&Abs_Axis::Prop::orientation>(object.get(), time_axis.get());
-            cache.template add_prop_dependency<&Time_Axis::Prop::visible_count>(object.get(), time_axis.get());
-            cache.template add_prop_dependency<&Time_Axis::Prop::newest_at_start>(object.get(), time_axis.get());
-            cache.template add_dependency<&Time_Axis::State::next_tick>(object.get(), time_axis.get());
-        });
-    };
-    return plot;
-}
-inline bool Waterfall::Private::should_rebuild_graph(Waterfall*, const Prop& state) {
-    return graph_partition_grid != state.partition_grid;
-}
-inline Task_Graph Waterfall::Private::build_graph(Waterfall* object,
-                                                    const Prop& state) {
-    graph_partition_grid = state.partition_grid;
-    const Plot_Partition_Count partition_count =
-        detail::raster_partition_count(graph_partition_grid);
-    Task_Graph graph{"waterfall"};
-    auto begin = graph.add("prepare.frame", [this, object] {
-        prepare_frame(object);
-    });
-    auto tooltip_task = graph.add("paint.tooltip", [this, object] {
-        paint_tooltip(object);
-    });
-    if (partition_count == 0) begin.precede(tooltip_task);
-    for (Plot_Partition_Count index = 0; index < partition_count; ++index) {
-        auto prepare = graph.add("prepare.partition", [this, object, index] {
-            prepare_partition(object, index);
-        });
-        auto paint = graph.add("paint.partition", [this, object, index] {
-            paint_partition(object, index);
-        });
-        begin.precede(prepare);
-        prepare.precede(paint);
-        paint.precede(tooltip_task);
-    }
-    return graph;
-}
-inline void Waterfall::Private::prepare_frame(Waterfall* object) {
-    const auto& state = this->template read_current_prop<Waterfall::Base_Tag>(object);
-    detail::Internal_Access::exchange_stream<Waterfall_Stream_Tag>(object);
-    const auto row_limit = static_cast<std::size_t>(std::max<Axis_Visible_Count>(
-        2, this->template read_current_prop<Time_Axis::Base_Tag>(
-               time_axis).visible_count));
-    detail::Internal_Access::accumulate_stream<Waterfall_Stream_Tag>(object, row_limit);
-    prepared = {};
-    std::vector<std::shared_ptr<const Waterfall_Row>> source_rows;
-    detail::Internal_Access::access_rendering_stream<Waterfall_Stream_Tag>(object,
-        [&](std::span<std::shared_ptr<const Waterfall_Row>> rows) {
-            source_rows.assign(rows.begin(), rows.end());
-        });
-    const auto& frequency_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        frequency_axis);
-    const auto& time_layout = this->template read_current_prop<Abs_Axis::Base_Tag>(
-        time_axis);
-    prepared.canvas = this->template read_current_prop<Render_Scene_2D::Base_Tag>(
-        scene).viewport;
-    if (source_rows.empty()) {
-        return;
-    }
-    const auto shortest = std::min_element(source_rows.begin(), source_rows.end(), [](const auto& left, const auto& right) {
-        return left->values.size() < right->values.size();
-    });
-    const std::size_t available = (*shortest)->values.size();
-    const int source_columns = static_cast<int>(state.frequency_bin_count ? std::min(state.frequency_bin_count, available) : available);
-    const auto selection = detail::raster_axis_selection(
-        state.frequency_range,
-        detail::Internal_Access::layer<Abs_Axis>(
-            frequency_axis).runtime_coordinate_range(),
-        source_columns, state.visible_range_only);
-    if (!selection) {
-        return;
-    }
-    const int time_slots = std::max<Axis_Visible_Count>(
-        2, this->template read_current_prop<Time_Axis::Base_Tag>(
-               time_axis).visible_count);
-    const Axis_Range time_range = detail::Internal_Access::layer<Abs_Axis>(
-        time_axis).runtime_coordinate_range();
-    prepared.layout = detail::raster_layout(
-        frequency_axis, selection->range, selection->count(),
-        time_axis, time_range, time_slots,
-        frequency_layout.orientation, time_layout.orientation);
-    if (prepared.canvas.empty() || !prepared.layout.valid()) {
-        return;
-    }
-    prepared.source_first = selection->first;
-    prepared.tiles.resize(detail::raster_partition_count(graph_partition_grid));
-    const Axis_Coordinate direction = time_range.length() < 0.0 ? -1.0 : 1.0;
-    const Axis_Coordinate first_center = time_range.origin + direction * 0.5;
-    prepared.rows_by_slot.resize(static_cast<std::size_t>(time_slots));
-    bool has_visible_row{};
-    for (const auto& source_row : source_rows) {
-        const int slot = static_cast<int>(std::llround(
-            (static_cast<Axis_Coordinate>(source_row->tick) - first_center) /
-            direction));
-        if (slot >= 0 && slot < time_slots) {
-            prepared.rows_by_slot[static_cast<std::size_t>(slot)] = source_row;
-            has_visible_row = true;
-        }
-    }
-    if (!has_visible_row) {
-        return;
-    }
-    if (state.tooltip_enabled && tooltip.active && prepared.layout.target.contains(tooltip.position)) {
-        std::ostringstream text;
-        text << std::fixed << std::setprecision(2)
-             << detail::Internal_Access::layer<Abs_Axis>(
-                    frequency_axis)
-                    .runtime_point_to_coordinate(tooltip.position)
-             << " Hz";
-        prepared.tooltip_text = text.str();
-        prepared.tooltip_box = {tooltip.position.x + 8.0, tooltip.position.y + 8.0, 110.0, 24.0};
-    }
-    prepared.valid = true;
-}
-inline void Waterfall::Private::prepare_partition(Waterfall* object, Plot_Partition_Count index) {
-    if (!prepared.valid) return;
-    const auto& state = this->template read_current_prop<Waterfall::Base_Tag>(object);
-    const detail::Raster_Partition core = detail::raster_partition(
-        prepared.layout, index, graph_partition_grid);
-    if (core.empty() || index >= prepared.tiles.size()) return;
-    const int halo = state.interpolation_mode == Image_Interpolation_Mode::nearest
-        ? 0 : state.interpolation_mode == Image_Interpolation_Mode::bilinear ? 1 : 2;
-    auto& tile = prepared.tiles[index];
-    tile.source = {
-        std::max(0, core.first_x - halo),
-        std::min(prepared.layout.width, core.last_x + halo),
-        std::max(0, core.first_y - halo),
-        std::min(prepared.layout.height, core.last_y + halo)};
-    const int tile_width = tile.source.last_x - tile.source.first_x;
-    const int tile_height = tile.source.last_y - tile.source.first_y;
-    tile.pixels.assign(static_cast<std::size_t>(tile_width) * tile_height, 0);
-    const Rect_F target = prepared.layout.target.normalized();
-    const auto project_x = [&](int boundary) {
-        return target.x + target.width * boundary / prepared.layout.width;
-    };
-    const auto project_y = [&](int boundary) {
-        return target.y + target.height * boundary / prepared.layout.height;
-    };
-    const double left = project_x(tile.source.first_x);
-    const double top = project_y(tile.source.first_y);
-    tile.target = {left, top, project_x(tile.source.last_x) - left,
-                   project_y(tile.source.last_y) - top};
-    for (int y = tile.source.first_y; y < tile.source.last_y; ++y) {
-        for (int x = tile.source.first_x; x < tile.source.last_x; ++x) {
-            const auto [column, slot] =
-                detail::raster_coordinates(prepared.layout, x, y);
-            if (slot < 0 || static_cast<std::size_t>(slot) >=
-                    prepared.rows_by_slot.size())
-                continue;
-            const auto& row =
-                prepared.rows_by_slot[static_cast<std::size_t>(slot)];
-            if (!row) continue;
-            const std::size_t source = static_cast<std::size_t>(
-                prepared.source_first + column);
-            tile.pixels[static_cast<std::size_t>(y - tile.source.first_y) *
-                            tile_width + (x - tile.source.first_x)] =
-                premultiply(state.color_map.sample(
-                    detail::normalized_plot_value(row->values[source],
-                                                  state.power_range)));
-        }
-    }
-}
-inline void Waterfall::Private::paint_partition(Waterfall* object,
-                                          Plot_Partition_Count index) {
-    const auto& state = this->template read_current_prop<Waterfall::Base_Tag>(object);
-    if (!prepared.valid || index >=
-            detail::raster_partition_count(graph_partition_grid) ||
-        index >= prepared.tiles.size())
-        return;
-    const Rect_F region = detail::raster_paint_region(
-        prepared.layout, index, graph_partition_grid);
-    if (region.empty()) return;
-    const auto& tile = prepared.tiles[index];
-    const int tile_width = tile.source.last_x - tile.source.first_x;
-    const int tile_height = tile.source.last_y - tile.source.first_y;
-    if (tile_width <= 0 || tile_height <= 0 || tile.pixels.empty()) return;
-    detail::Painter painter(this->paint_surface(), prepared.canvas, region);
-    painter.heatmap(tile.target, tile_width, tile_height, tile.pixels,
-                    state.interpolation_mode);
-}
-inline void Waterfall::Private::paint_tooltip(Waterfall* object) {
-    if (!prepared.valid || prepared.tooltip_text.empty()) return;
-    const auto& state = this->template read_current_prop<Waterfall::Base_Tag>(object);
-    detail::Painter painter(this->paint_surface(), prepared.canvas,
-                           prepared.tooltip_box);
-    painter.rect(prepared.tooltip_box, Pen{state.tooltip_text_pen.color},
-                 state.tooltip_background_brush);
-    painter.text({prepared.tooltip_box.x + 4.0,
-                  prepared.tooltip_box.y + 3.0},
-                 prepared.tooltip_text, state.tooltip_font,
-                 state.tooltip_text_pen);
-}
-inline void Waterfall::Private::handle_event(Waterfall* object, const Event& event) {
-    if (detail::update_hover_tooltip(tooltip, event))
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-}
-template <typename Object, typename Owner, typename Member, typename Prop_Type>
-void Waterfall::Private::after_prop_set(Object* object,
-                                        Member Owner::*,
-                                        Prop_Access<Prop_Type>) {
-    if constexpr (std::same_as<Owner, Prop>) {
-        detail::Internal_Access::mark_dirty<Render_Graph_Tag>(object);
-    }
-}
-inline void Waterfall::Private::bind_sources(
-    not_null<Frequency_Object*> frequency_axis_value,
-    not_null<Time_Object*> time_axis_value) {
-    frequency_axis = frequency_axis_value;
-    time_axis = time_axis_value;
-}
-}
diff --git a/render_2D/render_2D/plottable/common/Curve_Plot.cpp b/render_2D/render_2D/plottable/common/Curve_Plot.cpp
deleted file mode 100644
index 7e3fb3a..0000000
--- a/render_2D/render_2D/plottable/common/Curve_Plot.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "Curve_Plot.hpp"
-#include <algorithm>
-#include <cmath>
-namespace aethera::render_2d::detail {
-namespace {
-std::size_t partition_boundary(std::size_t work_size,
-                               Plot_Partition_Count index,
-                               Plot_Partition_Count count) {
-    return work_size / count * index +
-        std::min<std::size_t>(index, work_size % count);
-}
-Plot_Value power_domain_lerp(Plot_Value first, Plot_Value second, Plot_Ratio ratio) {
-    const Plot_Value first_power = std::pow(10.0, std::clamp(first, -3'000.0, 3'000.0) / 10.0);
-    const Plot_Value second_power = std::pow(10.0, std::clamp(second, -3'000.0, 3'000.0) / 10.0);
-    return 10.0 * std::log10(std::max(first_power + (second_power - first_power) * ratio, 1e-300));
-}
-Plot_Value cubic_value(Plot_Value previous, Plot_Value first, Plot_Value second, Plot_Value next, Plot_Ratio ratio) {
-    const Plot_Ratio ratio2 = ratio * ratio;
-    const Plot_Ratio ratio3 = ratio2 * ratio;
-    return 0.5 * ((2.0 * first) + (-previous + second) * ratio + (2.0 * previous - 5.0 * first + 4.0 * second - next) * ratio2 + (-previous + 3.0 * first - 3.0 * second + next) * ratio3);
-}
-}
-Curve_Partition_Range curve_partition_range(std::size_t sample_count, Plot_Partition_Count partition_index, Plot_Partition_Count partition_count, Axis_Range domain) {
-    if (sample_count == 0 || partition_count == 0) return {};
-    const std::size_t segment_count = sample_count > 1 ? sample_count - 1 : 1;
-    const std::size_t first_sample = std::min(
-        partition_boundary(segment_count, partition_index, partition_count),
-        sample_count - 1);
-    const std::size_t last_sample = std::min(
-        partition_boundary(segment_count, partition_index + 1,
-                           partition_count),
-        sample_count - 1);
-    const Plot_Ratio denominator = sample_count > 1 ? static_cast<Plot_Ratio>(sample_count - 1) : 1.0;
-    return {first_sample, last_sample - first_sample + 1, {domain.origin + domain.length() * static_cast<Plot_Ratio>(first_sample) / denominator, domain.origin + domain.length() * static_cast<Plot_Ratio>(last_sample) / denominator}};
-}
-std::vector<Curve_Sample> interpolate_curve(std::span<const Plot_Value> values, Axis_Range domain, Line_Interpolation_Mode mode) {
-    std::vector<Curve_Sample> result;
-    if (values.empty()) return result;
-    if (values.size() == 1) return {{domain.origin, values.front()}};
-    constexpr int subdivisions = 4;
-    const Plot_Ratio denominator = static_cast<Plot_Ratio>(values.size() - 1);
-    const auto coordinate = [domain, denominator](std::size_t index) { return domain.origin + domain.length() * static_cast<Plot_Ratio>(index) / denominator; };
-    result.push_back({coordinate(0), values.front()});
-    for (std::size_t index = 0; index + 1 < values.size(); ++index) {
-        const Plot_Coordinate first_coordinate = coordinate(index);
-        const Plot_Coordinate second_coordinate = coordinate(index + 1);
-        const Plot_Value first = values[index];
-        const Plot_Value second = values[index + 1];
-        switch (mode) {
-        case Line_Interpolation_Mode::nearest_sample: { const Plot_Coordinate middle = (first_coordinate + second_coordinate) * 0.5; result.push_back({middle, first}); result.push_back({middle, second}); result.push_back({second_coordinate, second}); break; }
-        case Line_Interpolation_Mode::linear_value: result.push_back({second_coordinate, second}); break;
-        case Line_Interpolation_Mode::linear_power_domain: for (int part = 1; part <= subdivisions; ++part) { const Plot_Ratio ratio = static_cast<Plot_Ratio>(part) / subdivisions; result.push_back({first_coordinate + (second_coordinate - first_coordinate) * ratio, power_domain_lerp(first, second, ratio)}); } break;
-        case Line_Interpolation_Mode::step_left: result.push_back({second_coordinate, first}); result.push_back({second_coordinate, second}); break;
-        case Line_Interpolation_Mode::step_right: result.push_back({first_coordinate, second}); result.push_back({second_coordinate, second}); break;
-        case Line_Interpolation_Mode::cubic_value: { const Plot_Value previous = values[index == 0 ? 0 : index - 1]; const Plot_Value next = values[std::min(index + 2, values.size() - 1)]; for (int part = 1; part <= subdivisions; ++part) { const Plot_Ratio ratio = static_cast<Plot_Ratio>(part) / subdivisions; result.push_back({first_coordinate + (second_coordinate - first_coordinate) * ratio, cubic_value(previous, first, second, next, ratio)}); } break; }
-        }
-    }
-    return result;
-}
-std::vector<Curve_Sample> visible_curve_samples(std::vector<Curve_Sample> samples, Axis_Range visible_range) {
-    const auto [low, high] = std::minmax(visible_range.origin, visible_range.target);
-    if (samples.size() < 2) return !samples.empty() && samples.front().coordinate >= low && samples.front().coordinate <= high ? std::move(samples) : std::vector<Curve_Sample>{};
-    std::size_t first = samples.size();
-    std::size_t last{};
-    for (std::size_t index = 0; index + 1 < samples.size(); ++index) { const auto [segment_low, segment_high] = std::minmax(samples[index].coordinate, samples[index + 1].coordinate); if (segment_high < low || segment_low > high) continue; first = std::min(first, index); last = std::max(last, index + 1); }
-    if (first == samples.size()) return {};
-    return {samples.begin() + static_cast<std::ptrdiff_t>(first), samples.begin() + static_cast<std::ptrdiff_t>(last + 1)};
-}
-Rect_F curve_paint_region(const Curve_Prepared& curve, double padding) {
-    bool initialized{};
-    double left{};
-    double top{};
-    double right{};
-    double bottom{};
-    const auto include = [&](const Point_F& point) {
-        if (!initialized) {
-            left = right = point.x;
-            top = bottom = point.y;
-            initialized = true;
-            return;
-        }
-        left = std::min(left, point.x);
-        top = std::min(top, point.y);
-        right = std::max(right, point.x);
-        bottom = std::max(bottom, point.y);
-    };
-    for (const auto& point : curve.points) include(point);
-    for (const auto& point : curve.fill) include(point);
-    if (!initialized) return {};
-    padding = std::max(1.0, padding);
-    return {left - padding, top - padding,
-            right - left + padding * 2.0,
-            bottom - top + padding * 2.0};
-}
-void paint_curve(Painter& painter, const Curve_Prepared& curve, const Pen& pen, const Brush& brush) {
-    if (curve.points.size() < 2) return;
-    if (brush.enabled()) painter.polygon(curve.fill, Pen{.style = Line_Style::none}, brush);
-    painter.polyline(curve.points, pen);
-}
-}
diff --git a/render_2D/render_2D/plottable/common/Curve_Plot.hpp b/render_2D/render_2D/plottable/common/Curve_Plot.hpp
deleted file mode 100644
index 568a17e..0000000
--- a/render_2D/render_2D/plottable/common/Curve_Plot.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#pragma once
-#include "../../axis/Axis.hpp"
-#include "../../render/Blend2D_Cache.hpp"
-#include "../Plot_Types.hpp"
-#include <span>
-#include <vector>
-#include <cmath>
-namespace aethera::render_2d::detail {
-using double_buffer::detail::Internal_Access;
-struct Curve_Sample {
-    Plot_Coordinate coordinate{};                            /* 曲线样本的横向业务坐标。 */
-    Plot_Value value{};                                     /* 曲线样本的纵向业务值。 */
-};
-struct Curve_Prepared {
-    std::vector<Point_F> points{};                           /* 映射到画布后的折线点。 */
-    std::vector<Point_F> fill{};                             /* 含值轴基线闭合点的填充多边形。 */
-};
-struct Curve_Partition_Range {
-    std::size_t first_sample{};                             /* 分块包含的首个样本下标。 */
-    std::size_t sample_count{};                             /* 分块包含的样本数；相邻块共享边界样本。 */
-    Axis_Range domain{};                                    /* 分块样本对应的业务坐标范围。 */
-};
-[[nodiscard]] Curve_Partition_Range curve_partition_range(std::size_t sample_count, Plot_Partition_Count partition_index, Plot_Partition_Count partition_count, Axis_Range domain);
-[[nodiscard]] std::vector<Curve_Sample> interpolate_curve(std::span<const Plot_Value> values, Axis_Range domain, Line_Interpolation_Mode mode);
-[[nodiscard]] std::vector<Curve_Sample> visible_curve_samples(std::vector<Curve_Sample> samples, Axis_Range visible_range);
-template <typename Coordinate_Axis, typename Value_Axis>
-[[nodiscard]] Point_F map_plot_point(const Coordinate_Axis* coordinate_axis, Plot_Coordinate coordinate, const Value_Axis* value_axis, Plot_Value value, Axis_Orientation coordinate_orientation) {
-    const auto& coordinate_private = Internal_Access::layer<Abs_Axis>(coordinate_axis);
-    const auto& value_private = Internal_Access::layer<Abs_Axis>(value_axis);
-    const Axis_Pixel_Position coordinate_pixel = coordinate_private.runtime_coordinate_to_pixel(coordinate);
-    const Axis_Pixel_Position value_pixel = value_private.runtime_coordinate_to_pixel(value);
-    return coordinate_orientation == Axis_Orientation::horizontal
-               ? Point_F{coordinate_pixel, value_pixel}
-               : Point_F{value_pixel, coordinate_pixel};
-}
-template <typename Coordinate_Axis, typename Value_Axis>
-[[nodiscard]] Rect_F map_plot_rect(const Coordinate_Axis* coordinate_axis, Axis_Range coordinate_range, const Value_Axis* value_axis, Axis_Range value_range, Axis_Orientation coordinate_orientation) {
-    const Point_F first = map_plot_point(coordinate_axis, coordinate_range.origin, value_axis, value_range.origin, coordinate_orientation);
-    const Point_F second = map_plot_point(coordinate_axis, coordinate_range.target, value_axis, value_range.target, coordinate_orientation);
-    return Rect_F{first.x, first.y, second.x - first.x, second.y - first.y}.normalized();
-}
-template <typename Coordinate_Axis, typename Value_Axis>
-[[nodiscard]] Curve_Prepared prepare_curve(std::span<const Curve_Sample> source, bool visible_only, Axis_Range visible_coordinate_range, Axis_Range value_range, const Coordinate_Axis* coordinate_axis, const Value_Axis* value_axis, Axis_Orientation coordinate_orientation, Axis_Orientation value_orientation) {
-    Curve_Prepared result;
-    std::vector<Curve_Sample> samples{source.begin(), source.end()};
-    if (visible_only) samples = visible_curve_samples(std::move(samples), visible_coordinate_range);
-    for (const auto& sample : samples)
-        if (std::isfinite(sample.coordinate) && std::isfinite(sample.value))
-            result.points.push_back(map_plot_point(coordinate_axis, sample.coordinate, value_axis, sample.value, coordinate_orientation));
-    if (result.points.size() < 2) return result;
-    const Axis_Pixel_Position baseline = Internal_Access::layer<Abs_Axis>(value_axis)
-                                             .runtime_coordinate_to_pixel(value_range.target);
-    Point_F first = result.points.front();
-    Point_F last = result.points.back();
-    if (value_orientation == Axis_Orientation::horizontal) { first.x = baseline; last.x = baseline; }
-    else { first.y = baseline; last.y = baseline; }
-    result.fill.reserve(result.points.size() + 2);
-    result.fill.push_back(first);
-    result.fill.insert(result.fill.end(), result.points.begin(), result.points.end());
-    result.fill.push_back(last);
-    return result;
-}
-template <typename Coordinate_Axis, typename Value_Axis>
-[[nodiscard]] Curve_Prepared prepare_curve(std::span<const Plot_Value> values, Axis_Range domain, Line_Interpolation_Mode mode, bool visible_only, Axis_Range visible_coordinate_range, Axis_Range value_range, const Coordinate_Axis* coordinate_axis, const Value_Axis* value_axis, Axis_Orientation coordinate_orientation, Axis_Orientation value_orientation) {
-    const auto samples = interpolate_curve(values, domain, mode);
-    return prepare_curve(std::span<const Curve_Sample>{samples}, visible_only, visible_coordinate_range, value_range, coordinate_axis, value_axis, coordinate_orientation, value_orientation);
-}
-/* 返回曲线及填充覆盖的 framebuffer 视图，padding 用于描边与抗锯齿重叠边界。 */
-[[nodiscard]] Rect_F curve_paint_region(const Curve_Prepared& curve, double padding);
-void paint_curve(Painter& painter, const Curve_Prepared& curve, const Pen& pen, const Brush& brush = {});
-}
diff --git a/render_2D/render_2D/plottable/common/Raster_Plot.cpp b/render_2D/render_2D/plottable/common/Raster_Plot.cpp
deleted file mode 100644
index 7fa6b42..0000000
--- a/render_2D/render_2D/plottable/common/Raster_Plot.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-#include "Raster_Plot.hpp"
-#include "Curve_Plot.hpp"
-#include <algorithm>
-namespace aethera::render_2d::detail {
-namespace {
-Plot_Partition_Count partition_boundary(Plot_Partition_Count work_size,
-                                        Plot_Partition_Count index,
-                                        Plot_Partition_Count count) {
-    return work_size / count * index +
-        std::min(index, work_size % count);
-}
-}
-bool Raster_Layout::valid() const noexcept { return width > 0 && height > 0 && !target.empty(); }
-int Raster_Axis_Selection::count() const noexcept { return last - first + 1; }
-bool Raster_Partition::empty() const noexcept {
-    return first_x >= last_x || first_y >= last_y;
-}
-bool Raster_Partition::contains(int x, int y) const noexcept {
-    return x >= first_x && x < last_x && y >= first_y && y < last_y;
-}
-std::size_t Raster_Layout::index(int first, int second) const noexcept {
-    if (first_reversed) first = (first_horizontal ? width : height) - 1 - first;
-    if (second_reversed) second = (first_horizontal ? height : width) - 1 - second;
-    const int x = first_horizontal ? first : second;
-    const int y = first_horizontal ? second : first;
-    return static_cast<std::size_t>(y) * static_cast<std::size_t>(width) + static_cast<std::size_t>(x);
-}
-Plot_Ratio normalized_plot_value(Plot_Value value, Axis_Range range) {
-    return range.length() == 0.0 ? 0.0 : std::clamp((value - range.origin) / range.length(), 0.0, 1.0);
-}
-std::optional<Raster_Axis_Selection> raster_axis_selection(Axis_Range data_range, Axis_Range visible_range, int source_count, bool visible_only) {
-    if (source_count <= 0) return std::nullopt;
-    if (!visible_only || source_count == 1 || data_range.length() == 0.0) return Raster_Axis_Selection{0, source_count - 1, data_range};
-    const auto [data_low, data_high] = std::minmax(data_range.origin, data_range.target);
-    const auto [visible_low, visible_high] = std::minmax(visible_range.origin, visible_range.target);
-    const Axis_Coordinate clipped_low = std::max(data_low, visible_low);
-    const Axis_Coordinate clipped_high = std::min(data_high, visible_high);
-    if (clipped_low > clipped_high) return std::nullopt;
-    const auto position = [data_range, source_count](Axis_Coordinate coordinate) { return (coordinate - data_range.origin) / data_range.length() * static_cast<Axis_Coordinate>(source_count - 1); };
-    const auto [position_low, position_high] = std::minmax(position(clipped_low), position(clipped_high));
-    int first = std::clamp(static_cast<int>(std::floor(position_low)), 0, source_count - 1);
-    int last = std::clamp(static_cast<int>(std::ceil(position_high)), first, source_count - 1);
-    if (first == last) { if (last + 1 < source_count) ++last; else if (first > 0) --first; }
-    const auto coordinate = [data_range, source_count](int index) { return data_range.origin + data_range.length() * static_cast<Axis_Coordinate>(index) / static_cast<Axis_Coordinate>(source_count - 1); };
-    return Raster_Axis_Selection{first, last, {coordinate(first), coordinate(last)}};
-}
-Plot_Partition_Count raster_partition_count(Plot_Partition_Grid grid) noexcept {
-    return grid.valid() ? grid.columns * grid.rows : 0;
-}
-Raster_Partition raster_partition(const Raster_Layout& layout,
-                                  Plot_Partition_Count partition_index,
-                                  Plot_Partition_Grid grid) {
-    const Plot_Partition_Count count = raster_partition_count(grid);
-    if (!layout.valid() || partition_index >= count) return {};
-    const auto column = partition_index % grid.columns;
-    const auto row = partition_index / grid.columns;
-    return {
-        static_cast<int>(partition_boundary(layout.width, column,
-                                            grid.columns)),
-        static_cast<int>(partition_boundary(layout.width, column + 1,
-                                            grid.columns)),
-        static_cast<int>(partition_boundary(layout.height, row,
-                                            grid.rows)),
-        static_cast<int>(partition_boundary(layout.height, row + 1,
-                                            grid.rows))};
-}
-std::pair<int, int> raster_coordinates(const Raster_Layout& layout,
-                                       int x, int y) noexcept {
-    int first = layout.first_horizontal ? x : y;
-    int second = layout.first_horizontal ? y : x;
-    if (layout.first_reversed)
-        first = (layout.first_horizontal ? layout.width : layout.height) - 1 - first;
-    if (layout.second_reversed)
-        second = (layout.first_horizontal ? layout.height : layout.width) - 1 - second;
-    return {first, second};
-}
-Rect_F raster_paint_region(const Raster_Layout& layout,
-                           Plot_Partition_Count partition_index,
-                           Plot_Partition_Grid grid) {
-    const Raster_Partition partition =
-        raster_partition(layout, partition_index, grid);
-    if (partition.empty()) return {};
-    const Rect_F target = layout.target.normalized();
-    const auto pixel_boundary = [](double origin, double extent,
-                                   int source_boundary, int source_extent,
-                                   bool last) {
-        const double projected = origin + extent * source_boundary /
-            static_cast<double>(source_extent);
-        return last ? std::ceil(projected) : std::floor(projected);
-    };
-    const double left = pixel_boundary(target.x, target.width,
-        partition.first_x, layout.width, false);
-    const double right = pixel_boundary(target.x, target.width,
-        partition.last_x, layout.width, partition.last_x == layout.width);
-    const double top = pixel_boundary(target.y, target.height,
-        partition.first_y, layout.height, false);
-    const double bottom = pixel_boundary(target.y, target.height,
-        partition.last_y, layout.height, partition.last_y == layout.height);
-    return {left, top, right - left, bottom - top};
-}
-void paint_raster(Painter& painter, const Raster_Layout& layout, std::span<const Pixel> pixels, Image_Interpolation_Mode interpolation) {
-    if (layout.valid() && pixels.size() == static_cast<std::size_t>(layout.width) * static_cast<std::size_t>(layout.height)) painter.heatmap(layout.target, layout.width, layout.height, pixels, interpolation);
-}
-}
diff --git a/render_2D/render_2D/plottable/common/Raster_Plot.hpp b/render_2D/render_2D/plottable/common/Raster_Plot.hpp
deleted file mode 100644
index 8614e0c..0000000
--- a/render_2D/render_2D/plottable/common/Raster_Plot.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-#pragma once
-#include "../../axis/Axis.hpp"
-#include "../../render/Blend2D_Cache.hpp"
-#include "../Plot_Types.hpp"
-#include "Curve_Plot.hpp"
-#include <span>
-#include <optional>
-#include <utility>
-#include <vector>
-namespace aethera::render_2d::detail {
-using double_buffer::detail::Internal_Access;
-struct Raster_Layout {
-    int width{};                                             /* 像素矩阵宽度。 */
-    int height{};                                            /* 像素矩阵高度。 */
-    Rect_F target{};                                         /* 栅格映射到画布的目标矩形。 */
-    bool first_reversed{};                                   /* 第一坐标轴是否按像素反向。 */
-    bool second_reversed{};                                  /* 第二坐标轴是否按像素反向。 */
-    bool first_horizontal{};                                 /* 第一坐标轴是否映射到矩阵水平方向。 */
-    [[nodiscard]] bool valid() const noexcept;
-    [[nodiscard]] std::size_t index(int first, int second) const noexcept;
-};
-struct Raster_Axis_Selection {
-    int first{};                                             /* 源数据中首个被选中的格点下标。 */
-    int last{};                                              /* 源数据中最后一个被选中的格点下标。 */
-    Axis_Range range{};                                      /* 选中格点覆盖的业务坐标范围。 */
-    [[nodiscard]] int count() const noexcept;
-};
-struct Raster_Partition {
-    int first_x{};                                           /* framebuffer 矩阵中包含的首列。 */
-    int last_x{};                                            /* framebuffer 矩阵中不包含的尾列。 */
-    int first_y{};                                           /* framebuffer 矩阵中包含的首行。 */
-    int last_y{};                                            /* framebuffer 矩阵中不包含的尾行。 */
-    [[nodiscard]] bool empty() const noexcept;
-    [[nodiscard]] bool contains(int x, int y) const noexcept;
-};
-[[nodiscard]] Plot_Ratio normalized_plot_value(Plot_Value value, Axis_Range range);
-[[nodiscard]] std::optional<Raster_Axis_Selection> raster_axis_selection(Axis_Range data_range, Axis_Range visible_range, int source_count, bool visible_only);
-template <typename First_Axis, typename Second_Axis>
-[[nodiscard]] Raster_Layout raster_layout(const First_Axis* first_axis, Axis_Range first_range, int first_count, const Second_Axis* second_axis, Axis_Range second_range, int second_count, Axis_Orientation first_orientation, Axis_Orientation second_orientation) {
-    if (first_orientation == second_orientation || first_count <= 0 || second_count <= 0) return {};
-    const bool horizontal = first_orientation == Axis_Orientation::horizontal;
-    return {horizontal ? first_count : second_count,
-            horizontal ? second_count : first_count,
-            map_plot_rect(first_axis, first_range, second_axis, second_range, first_orientation),
-            Internal_Access::layer<Abs_Axis>(first_axis).runtime_coordinate_to_pixel(first_range.origin) >
-                Internal_Access::layer<Abs_Axis>(first_axis).runtime_coordinate_to_pixel(first_range.target),
-            Internal_Access::layer<Abs_Axis>(second_axis).runtime_coordinate_to_pixel(second_range.origin) >
-                Internal_Access::layer<Abs_Axis>(second_axis).runtime_coordinate_to_pixel(second_range.target),
-            horizontal};
-}
-[[nodiscard]] Plot_Partition_Count raster_partition_count(
-    Plot_Partition_Grid grid) noexcept;
-[[nodiscard]] Raster_Partition raster_partition(
-    const Raster_Layout& layout, Plot_Partition_Count partition_index,
-    Plot_Partition_Grid grid);
-[[nodiscard]] std::pair<int, int> raster_coordinates(
-    const Raster_Layout& layout, int x, int y) noexcept;
-/* 将目标矩形切成互斥的整数 framebuffer 视图；每个目标像素只有一个写入者。 */
-[[nodiscard]] Rect_F raster_paint_region(const Raster_Layout& layout,
-                                         Plot_Partition_Count partition_index,
-                                         Plot_Partition_Grid grid);
-void paint_raster(Painter& painter, const Raster_Layout& layout, std::span<const Pixel> pixels, Image_Interpolation_Mode interpolation);
-}
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.cpp b/render_2D/render_2D/scene/Render_Scene_2D.cpp
deleted file mode 100644
index e1a2743..0000000
--- a/render_2D/render_2D/scene/Render_Scene_2D.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "Render_Scene_2D.hpp"                             /* 二维 Paint Taskflow、批次事件路由、缓存失效与合成实现。 */
-namespace aethera::render_2d {
-Render_Scene_2D::Private::~Private() = default;
-bool Render_Scene_2D::Prop::operator==(const Prop&) const = default;
-
-void Render_Scene_2D::submit_event(Event_Pointer event) {
-    if (!event) throw std::invalid_argument("2D Scene input event is null");
-    observe_event(not_null{event.get()});
-    submit_stream<Scene_Event_Stream_Tag>(std::move(event));
-}
-
-Render_Scene_2D::Render_Result_Type Render_Scene_2D::render(
-    not_null<Frame_2D*> frame, Frame_Callback callback) {
-    return double_buffer::detail::Internal_Access::get(this).render(
-        this, frame, std::move(callback));
-}
-
-Render_Frame_Result Render_Scene_2D::render_frame(
-    not_null<Render_Frame*> frame, Render_Frame_Callbacks callbacks) {
-    auto* concrete = dynamic_cast<Frame_2D*>(frame.get());
-    if (!concrete) return Render_Frame_Result::incompatible_frame;
-    const auto result = render(
-        not_null{concrete},
-        [callbacks = std::move(callbacks)](not_null<Frame_2D*> completed) mutable {
-            if (callbacks.submitted) callbacks.submitted(completed, false);
-            if (callbacks.completed) callbacks.completed(completed);
-        });
-    if (result) return Render_Frame_Result::submitted;
-    switch (result.error()) {
-    case Render_Result::frame_in_flight:
-        return Render_Frame_Result::frame_pipeline_busy;
-    case Render_Result::view_inactive:
-        return Render_Frame_Result::view_inactive;
-    case Render_Result::empty_viewport:
-        return Render_Frame_Result::empty_viewport;
-    }
-    return Render_Frame_Result::backend_unavailable;
-}
-void Render_Scene_2D::activate_view() {
-    double_buffer::detail::Internal_Access::get(this).set_view_active(this, true);
-}
-void Render_Scene_2D::deactivate_view() {
-    double_buffer::detail::Internal_Access::get(this).set_view_active(this, false);
-}
-
-}
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.hpp b/render_2D/render_2D/scene/Render_Scene_2D.hpp
deleted file mode 100644
index 0f5388a..0000000
--- a/render_2D/render_2D/scene/Render_Scene_2D.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-#include "../base/Frame_2D.hpp"
-#include "../base/Renderable_2D.hpp"
-#include "../render/Blend2D_Cache.hpp"
-#include <scene.hpp>
-#include <ownership.hpp>
-#include <expected>
-#include <functional>
-#include <memory>
-namespace aethera::render_2d {
-/* 执行二维 Renderable 图、合成颜色层并发布最终像素帧。 */
-struct Render_Scene_2D : Def<Render_Scene_2D, Scene,
-                             Dependency_Graph_Type<Render_Cache_Tag, Renderable_2D_Base>>,
-                         Render_Frame_Scene {
-    struct Prop : Prev_Prop {
-        Size viewport{}; /* 最终帧的像素尺寸；空尺寸不执行渲染。 */
-        Color background{Color::black()}; /* 每帧合成前写入的背景颜色。 */
-        bool view_active{}; /* 视图是否接受 render(frame*) 产生新的完成帧。 */
-        bool operator==(const Prop&) const;
-    };
-    struct State : Prev_State {};
-    /* 完整声明、合成顺序和 CRTP 分派见 Render_Scene_2D.ipp。 */
-    struct Private;
-    template <typename Object>
-    struct Builder : Prev_Builder<Object> {
-        using Base = Prev_Builder<Object>;
-        using Final_Builder = typename Object::template Builder<Object>;
-        Builder();
-        template <Attached Renderable_Object> requires std::derived_from<Renderable_Object, Renderable_2D_Base>
-        Final_Builder& add_renderable(not_null<Renderable_Object*> renderable);
-        [[nodiscard]] std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> build();
-    private:
-        std::vector<std::function<std::expected<void, Dependency_Graph_Error>(
-            not_null<Object*>)>> attachments{}; /* 仅在 build 期间绑定已构造 Renderable。 */
-    };
-    enum struct Render_Result { frame_in_flight, view_inactive, empty_viewport };
-    using Frame_Callback = std::function<void(not_null<Frame_2D*>)>;
-    using Render_Result_Type = std::expected<void, Render_Result>;
-    using Render_Frame_Type = Frame_2D;
-    void submit_event(Event_Pointer event);
-    [[nodiscard]] Render_Result_Type render(
-        not_null<Frame_2D*> frame, Frame_Callback callback);
-    [[nodiscard]] Render_Frame_Result render_frame(
-        not_null<Render_Frame*> frame,
-        Render_Frame_Callbacks callbacks) override;
-    /*
-     * 向调用方拥有的 Frame 合成一次。Scene 只借用传入地址；全部绘制、
-     * completion Taskflow 和 Trace 收口并清除借用后，唯一回调通知调用方。
-     */
-    /*
-     * 返回最终像素完成后、帧回调前执行的直接 Taskflow。
-     * 只能在 Scene 没有运行时修改该图；禁止在执行期间 emplace/erase/clear。
-     * completion Taskflow 完成前调用方必须保持本帧像素所有权；节点若启动更晚结束的异步工作，
-     * 必须捕获拥有像素所有权的对象，禁止只捕获会被下一帧复用的裸 Frame_2D*。
-     */
-    void activate_view();
-    void deactivate_view();
-};
-}
-#include "Render_Scene_2D.ipp"
diff --git a/render_2D/render_2D/scene/Render_Scene_2D.ipp b/render_2D/render_2D/scene/Render_Scene_2D.ipp
deleted file mode 100644
index dc1d410..0000000
--- a/render_2D/render_2D/scene/Render_Scene_2D.ipp
+++ /dev/null
@@ -1,478 +0,0 @@
-#pragma once
-#include "../event/Event_Routing_Rules.hpp"
-#include <atomic>
-#include <optional>
-#include <stdexcept>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-namespace aethera::render_2d {
-template <typename Object>
-Render_Scene_2D::Builder<Object>::Builder() : Base() {}
-template <typename Object>
-template <Attached Renderable_Object>
-    requires std::derived_from<Renderable_Object, Renderable_2D_Base>
-typename Render_Scene_2D::Builder<Object>::Final_Builder& Render_Scene_2D::Builder<Object>::add_renderable(
-    not_null<Renderable_Object*> renderable) {
-    this->template add_dependency_node<Render_Graph_Tag>(renderable.get());
-    attachments.emplace_back([renderable](not_null<Object*> scene) {
-        auto& data = Base::private_access(renderable.get())
-                         .template get<Renderable_2D_Base::Base_Tag>();
-        if (!data.scene_attach)
-            throw std::logic_error("2D renderable has no scene attachment contract");
-        auto attach = std::move(data.scene_attach);
-        return attach(scene);
-    });
-    return static_cast<Final_Builder&>(*this);
-}
-template <typename Object>
-std::expected<std::unique_ptr<Object>, Dependency_Graph_Error> Render_Scene_2D::Builder<Object>::build() {
-    auto result = Base::build();
-    if (!result) return std::unexpected(result.error());
-    auto scene = std::move(result).value();
-    for (auto& attach : attachments) {
-        auto attach_result = attach(scene.get());
-        if (!attach_result) return std::unexpected(attach_result.error());
-    }
-    /*
-     * Renderable attachment changes the Scene dependency graphs after the base
-     * Builder has performed its initial commit.  Commit those attachments here,
-     * while no frame topology can be running, so the first render observes a
-     * fully built Prepare/Paint DAG instead of publishing a background-only
-     * bootstrap frame.
-    */
-    double_buffer::detail::Internal_Access::advance(scene.get());
-    /* after_advance writes derived DAG diagnostics into the State write side;
-     * publish that already-computed result before handing the Scene to its caller. */
-    double_buffer::detail::Internal_Access::advance(scene.get());
-    return scene;
-}
-struct Render_Scene_2D::Private : Prev_Private {
-    struct Paint_Node {
-        not_null<Root*> object;                              /* Paint 拓扑位置对应的最终对象；Scene 不拥有。 */
-        not_null<Renderable_2D_Base::Private*> private_data; /* 对象的二维能力层；对象存活期间有效。 */
-        Root* cache_owner{};        /* 所属缓存根；空值表示直接绘制最终帧。 */
-        bool paint_requested{};                              /* Scene 按本轮组级失效结果计算的执行许可。 */
-    };
-    struct Cache_Group {
-        not_null<Root*> owner;                               /* 显式选择缓存的二维 Renderable 根。 */
-        std::vector<not_null<Root*>> members{};              /* 本缓存覆盖的根及无冲突后继节点。 */
-        bool rebuild{};                                      /* 本轮是否因任一成员失效而整体重绘。 */
-    };
-    struct Event_Target {
-        not_null<Renderable_2D_Base*> object;                 /* 当前 Paint 图中的事件候选对象；Scene 不拥有。 */
-        not_null<Renderable_2D_Base::Private*> private_data;  /* 候选对象的二维能力层；仅在本次 Prepare 分发期间有效。 */
-    };
-    std::atomic_bool frame_in_flight{};                       /* Scene 当前是否仍借用一个外部 Frame。 */
-    std::unique_ptr<Task_Graph> frame_taskflow{};
-    ~Private();
-    Frame_2D* active_frame{};        /* 异步帧 DAG 借用的外部帧；完成回调前保持存活。 */
-    Blend2D_Cache* frame_target{};   /* 当前异步帧的最终颜色层；帧 DAG 完成后清空。 */
-    /* 最终 Private 实现：Prepare 完成后按 Paint 图拓扑边并行绘制并合成颜色层。 */
-    std::vector<Paint_Node> paint_order{};                    /* Paint 图当前拓扑序及 Scene 缓存分组结果。 */
-    std::vector<Cache_Group> cache_groups{};                  /* 仅保存显式缓存根对应的执行分组。 */
-    template <Attached Object> void ensure_frame_taskflow(Object* object);
-    /* Def CRTP hook：二维 Paint 图结构变化后重建其独立 Taskflow。 */
-    template <Attached Object>
-    void after_advance(Object* object, Prop* pending_prop, State_Access<State> pending_states, const Prop* current_prop, State_Access<State> current_states);
-    /* 每帧在 Prepare 完成后计算组级 dirty，并为所有二维节点指定唯一绘制目标。 */
-    template <Attached Object> void prepare_paint_targets(Object* object, Blend2D_Cache& frame, Size viewport);
-    /* Prepare 开始时交换 Scene 事件批次，按区域、Paint 逆序和最近目标规则逐事件完成接受链。 */
-    template <Attached Object>
-    void dispatch_events(Object* object, Size viewport,
-                         std::uint64_t frame_sequence);
-    template <Attached Object>
-    [[nodiscard]] std::expected<void, Render_Result> render(
-        Object* object, not_null<Frame_2D*> frame,
-        Frame_Callback callback);
-    template <Attached Object> void set_view_active(Object* object, bool active);
-    /* CRTP 覆盖：Builder 挂接最终 Private 后安装二维 Scene 的无虚函数业务分派。 */
-    template <Attached Object>
-    void bind_private_crtp(Object* object);
-};
-template <Attached Object>
-void Render_Scene_2D::Private::after_advance(
-    Object* object, Prop*, State_Access<State> pending_states,
-    const Prop*, State_Access<State>) {
-    bool rebuild = paint_order.empty();
-    double_buffer::detail::Internal_Access::
-        access_pending_dependency_graph<Render_Graph_Tag>(
-            object, [&](auto& graph_state) {
-                rebuild = rebuild || graph_state.dirty();
-            });
-    for (auto& node : paint_order) {
-        const bool enabled = node.private_data->cache_enabled &&
-                             node.private_data->cache_enabled(node.object);
-        if (enabled == (node.cache_owner == node.object)) continue;
-        node.private_data->valid_cache = nullptr;
-        rebuild = true;
-    }
-    if (!rebuild) return;
-
-    const auto dependencies =
-        double_buffer::detail::Internal_Access::current_dependency_graph<Render_Graph_Tag>(object);
-    paint_order.clear();
-    cache_groups.clear();
-    std::unordered_map<Root*, Root*>
-        cache_owner_by_object;
-    std::unordered_map<Root*, std::size_t> cache_group_by_owner;
-    const auto order_result = dependencies.for_each_topological_view(
-        [&](const auto& view, const Dependency_Graph::Node& node) {
-            auto* base_data = view.private_data(node);
-            if (!base_data) return;
-            const not_null data{
-                static_cast<Renderable_2D_Base::Private*>(base_data)};
-            Root* cache_owner{};
-            if (data->cache_enabled && data->cache_enabled(node.object)) {
-                cache_owner = node.object;
-            }
-            else {
-                bool conflict{};
-                for (const auto dependency : node.dependencies) {
-                    if (!view.private_data(*dependency)) continue;
-                    const auto current =
-                        cache_owner_by_object.find(dependency->object.get());
-                    const auto dependency_owner =
-                        current == cache_owner_by_object.end()
-                            ? nullptr
-                            : current->second;
-                    if (!dependency_owner ||
-                        (cache_owner && cache_owner != dependency_owner)) {
-                        conflict = true;
-                        break;
-                    }
-                    cache_owner = dependency_owner;
-                }
-                if (conflict) cache_owner = nullptr;
-            }
-            cache_owner_by_object.emplace(node.object.get(), cache_owner);
-            paint_order.push_back(
-                Paint_Node{node.object, data, cache_owner, false});
-            if (!cache_owner) return;
-            auto [group, inserted] =
-                cache_group_by_owner.emplace(
-                    cache_owner, cache_groups.size());
-            if (inserted) cache_groups.push_back(Cache_Group{cache_owner});
-            cache_groups[group->second].members.push_back(node.object);
-        });
-    if (!order_result)
-        throw std::logic_error(
-            "render scene graph became invalid while building cache groups");
-}
-template <Attached Object>
-void Render_Scene_2D::Private::prepare_paint_targets(Object*, Blend2D_Cache& frame, Size viewport) {
-    for (auto& group : cache_groups) {
-        const auto owner_node = std::find_if(paint_order.begin(), paint_order.end(), [&](const Paint_Node& value) { return value.object == group.owner; });
-        if (owner_node == paint_order.end() || !owner_node->private_data->pending_cache)
-            throw std::logic_error("2D cache group lost its cache owner capability");
-        group.rebuild = !owner_node->private_data->valid_cache;
-        for (const auto member : group.members) {
-            const auto node = std::find_if(paint_order.begin(), paint_order.end(), [member](const Paint_Node& value) { return value.object == member; });
-            if (node == paint_order.end()) continue;
-            group.rebuild = group.rebuild ||
-                double_buffer::detail::Internal_Access::dirty<Render_Graph_Tag>(
-                    member.get());
-        }
-        if (group.rebuild) {
-            const not_null target{
-                owner_node->private_data->pending_cache(group.owner)};
-            target->ensure_size(viewport);
-            target->clear();
-            for (const auto member : group.members) {
-                double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(
-                    member.get());
-                const auto node = std::find_if(paint_order.begin(), paint_order.end(), [member](const Paint_Node& value) { return value.object == member; });
-                if (node != paint_order.end()) { node->private_data->paint_target = target; node->paint_requested = true; }
-            }
-        } else {
-            for (const auto member : group.members) {
-                const auto node = std::find_if(paint_order.begin(), paint_order.end(), [member](const Paint_Node& value) { return value.object == member; });
-                if (node != paint_order.end()) {
-                    node->private_data->paint_target = owner_node->private_data->valid_cache;
-                    node->paint_requested = false;
-                }
-            }
-        }
-    }
-    for (auto& node : paint_order) {
-        if (node.cache_owner) continue;
-        node.private_data->paint_target = &frame;
-        node.paint_requested = true;
-        double_buffer::detail::Internal_Access::mark_dirty<Render_Graph_Tag>(
-            node.object.get());
-    }
-}
-template <Attached Object>
-void Render_Scene_2D::Private::ensure_frame_taskflow(Object* object) {
-    if (frame_taskflow) return;
-    if (!runtime->taskflow)
-        runtime->taskflow = std::make_unique<Task_Graph>("scene.render");
-    frame_taskflow = std::make_unique<Task_Graph>("render_2d.frame");
-    auto& graph = *frame_taskflow;
-    graph.describe("owner_kind", "scene")
-         .describe("owner_component", "scene");
-    auto begin = graph.add("scene.begin", [this, object] {
-        if (!active_frame)
-            throw std::logic_error("2D frame DAG lost its active frame");
-        const auto frame = not_null{active_frame};
-        const Prop& prop =
-            double_buffer::detail::Internal_Access::current_prop_layer<
-                Render_Scene_2D::Base_Tag>(object);
-        frame->mark(Frame_Trace_Marker::scene_render_started);
-        frame->mark(Frame_Trace_Marker::event_dispatch_started);
-        dispatch_events(object, prop.viewport, frame->identity().sequence);
-        frame->mark(Frame_Trace_Marker::event_dispatch_finished);
-        double_buffer::detail::Internal_Access::
-            current_dependency_graph<Render_Cache_Tag>(object).for_each(
-                [](const Dependency_Graph::Node& node) {
-                    if (!double_buffer::detail::Internal_Access::
-                            take_dirty<Render_Cache_Tag>(node.object.get()))
-                        return;
-                    double_buffer::detail::Internal_Access::
-                        mark_dirty<Render_Graph_Tag>(node.object.get());
-                });
-        auto& state = static_cast<State&>(
-            double_buffer::detail::Internal_Access::pending_state(object));
-        auto& target = detail::Frame_2D_Access::render_target(frame);
-        frame_target = &target;
-        frame->mark(Frame_Trace_Marker::prepare_started);
-    });
-    begin.describe("dimension", "2D").describe("stage", "frame setup");
-
-    auto prepare_frame_target = graph.add(
-        "scene.frame_target", [this, object] {
-            if (!active_frame || !frame_target)
-                throw std::logic_error("2D frame target lost its frame");
-            const auto frame = not_null{active_frame};
-            const Prop& prop =
-                double_buffer::detail::Internal_Access::current_prop_layer<
-                    Render_Scene_2D::Base_Tag>(object);
-            frame->mark(Frame_Trace_Marker::paint_frame_target_started);
-            frame_target->ensure_size(prop.viewport);
-            frame_target->clear();
-            frame->mark(Frame_Trace_Marker::paint_frame_target_finished);
-        });
-    auto paint_background = graph.add(
-        "scene.background", [this, object] {
-            if (!active_frame || !frame_target)
-                throw std::logic_error("2D background lost its frame target");
-            const auto frame = not_null{active_frame};
-            const Prop& prop =
-                double_buffer::detail::Internal_Access::current_prop_layer<
-                    Render_Scene_2D::Base_Tag>(object);
-            frame->mark(Frame_Trace_Marker::paint_background_started);
-            {
-                detail::Painter painter(*frame_target, prop.viewport);
-                painter.rect(
-                    {0.0, 0.0, static_cast<double>(prop.viewport.width),
-                     static_cast<double>(prop.viewport.height)},
-                    Pen{.style = Line_Style::none},
-                    Brush{prop.background, Brush_Style::solid});
-            }
-            frame->mark(Frame_Trace_Marker::paint_background_finished);
-        });
-    auto prepare_cache_targets = graph.add(
-        "scene.cache_targets", [this, object] {
-            if (!active_frame || !frame_target)
-                throw std::logic_error("2D cache setup lost its frame");
-            const auto frame = not_null{active_frame};
-            const Prop& prop =
-                double_buffer::detail::Internal_Access::current_prop_layer<
-                    Render_Scene_2D::Base_Tag>(object);
-            frame->mark(Frame_Trace_Marker::paint_cache_targets_started);
-            prepare_paint_targets(object, *frame_target, prop.viewport);
-            frame->mark(Frame_Trace_Marker::paint_cache_targets_finished);
-        });
-    auto render_ready = graph.add("scene.render.ready", [this] {
-        if (!active_frame)
-            throw std::logic_error("2D render lost its active frame");
-        active_frame->mark(Frame_Trace_Marker::prepare_finished);
-        active_frame->mark(Frame_Trace_Marker::paint_started);
-        active_frame->mark(Frame_Trace_Marker::paint_taskflow_started);
-    });
-    auto renderables = graph.compose("scene.renderables", *runtime->taskflow);
-    renderables.describe("dimension", "2D").describe("backend", "Blend2D");
-    auto composite_caches = graph.add("scene.cache_composite", [this] {
-        if (!frame_target)
-            throw std::logic_error("2D cache composite lost its frame target");
-        for (auto& group : cache_groups) {
-            auto owner = std::find_if(
-                paint_order.begin(), paint_order.end(),
-                [&](const Paint_Node& value) {
-                    return value.object == group.owner;
-                });
-            if (owner == paint_order.end()) continue;
-            if (group.rebuild)
-                owner->private_data->valid_cache =
-                    owner->private_data->paint_target;
-            if (owner->private_data->valid_cache)
-                frame_target->composite(*owner->private_data->valid_cache);
-        }
-    });
-    auto finish = graph.add("scene.render.complete", [this, object] {
-        auto& state = static_cast<State&>(
-            double_buffer::detail::Internal_Access::pending_state(object));
-        state.event_statistics = event_statistics.state();
-        active_frame->mark(Frame_Trace_Marker::paint_taskflow_finished);
-        active_frame->mark(Frame_Trace_Marker::paint_finished);
-        active_frame->mark(Frame_Trace_Marker::scene_render_finished);
-    });
-    auto completion = graph.compose("scene.completion", completion_graph);
-    completion.describe("owner", "scene").describe("stage", "frame consumers");
-
-    begin.precede(prepare_frame_target);
-    begin.precede(prepare_cache_targets);
-    prepare_frame_target.precede(paint_background);
-    paint_background.precede(render_ready);
-    prepare_cache_targets.precede(render_ready);
-    render_ready.precede(renderables);
-    renderables.precede(composite_caches);
-    composite_caches.precede(finish);
-    finish.precede(completion);
-}
-template <Attached Object>
-std::expected<void, Render_Scene_2D::Render_Result>
-Render_Scene_2D::Private::render(
-    Object* object, not_null<Frame_2D*> frame,
-    Frame_Callback callback) {
-    frame->mark(Frame_Trace_Marker::scene_render_entered);
-    if (!callback)
-        throw std::logic_error(
-            "Render_Scene_2D requires a frame callback before render");
-    bool available{};
-    if (!frame_in_flight.compare_exchange_strong(
-            available, true, std::memory_order_acq_rel,
-            std::memory_order_acquire))
-        return std::unexpected(Render_Result::frame_in_flight);
-    const auto release_admission = [this] {
-        frame_in_flight.store(false, std::memory_order_release);
-    };
-    try {
-        /*
-         * The caller writes properties and tagged input buffers before render().
-         * Commit the complete Scene object here, before submitting the frame
-         * topology: this advances every attached Renderable, publishes the
-         * current input buffers, and rebuilds dirty Prepare/Paint graphs while
-         * no Taskflow is running.  The completion callback only publishes
-         * results; it must not modify a graph that is still executing.
-         */
-        frame->mark(Frame_Trace_Marker::scene_advance_started);
-        double_buffer::detail::Internal_Access::advance(object);
-        frame->mark(Frame_Trace_Marker::scene_advance_finished);
-        const Prop& prop = double_buffer::detail::Internal_Access::current_prop_layer<Render_Scene_2D::Base_Tag>(object);
-        if (!prop.view_active) {
-            release_admission();
-            return std::unexpected(Render_Result::view_inactive);
-        }
-        if (prop.viewport.empty()) {
-            release_admission();
-            return std::unexpected(Render_Result::empty_viewport);
-        }
-        ensure_frame_taskflow(object);
-        active_frame = frame.get();
-    }
-    catch (...) {
-        release_admission();
-        throw;
-    }
-    frame->mark(Frame_Trace_Marker::scene_render_requested);
-    const bool trace_started = aethera::detail::begin_taskflow_trace(*frame);
-    try {
-        auto completion = [this, object, frame,
-                           callback = std::move(callback),
-                           trace_started]() mutable {
-            /*
-             * render_2d.frame 的原生 Taskflow 已经完成。先发布 Scene 自身状态、
-             * 结束 Trace 并清除全部 Frame 借用，再通过唯一回调通知帧策略。
-             */
-            double_buffer::detail::Internal_Access::
-                current_dependency_graph<Render_Graph_Tag>(object).for_each_bound(
-                    [](Renderable* renderable, Renderable::Private& data) {
-                        data.publish_renderable_state(renderable);
-                    });
-            double_buffer::detail::Internal_Access::publish_state<Render_Scene_2D::Base_Tag>(object);
-
-            frame->mark(Frame_Trace_Marker::frame_ready);
-            if (trace_started)
-                aethera::detail::finish_taskflow_trace(*frame);
-            active_frame = nullptr;
-            frame_target = nullptr;
-            frame_in_flight.store(false, std::memory_order_release);
-            callback(frame);
-        };
-        if (frame->taskflow_trace_requested())
-            aethera::detail::run_taskflow(
-                *frame_taskflow, *frame, "render_2d.frame", std::move(completion));
-        else
-            aethera::detail::run_taskflow(*frame_taskflow, std::move(completion));
-    }
-    catch (...) {
-        if (trace_started)
-            aethera::detail::finish_taskflow_trace(*frame);
-        active_frame = nullptr;
-        frame_target = nullptr;
-        frame_in_flight.store(false, std::memory_order_release);
-        throw;
-    }
-    return {};
-}
-template <Attached Object>
-void Render_Scene_2D::Private::dispatch_events(Object* object, Size viewport,
-                                                std::uint64_t frame_sequence) {
-    auto events = this->take_events(object);
-    if (events.empty()) return;
-    /* Paint 拓扑在一帧事件批次内不会变化。只解析一次候选对象；每个事件仍按
-     * 当时的动态区域重新筛选、排序并完整分发，不合并也不丢弃输入。 */
-    std::vector<Event_Target> candidates;
-    const auto graph = double_buffer::detail::Internal_Access::current_dependency_graph<Render_Graph_Tag>(object);
-    const auto graph_result = graph.for_each_topological_view(
-        [&](const auto& view, const Dependency_Graph::Node& node) {
-            auto* renderable =
-                static_cast<Renderable_2D_Base*>(view.object(node));
-            auto* data = static_cast<Renderable_2D_Base::Private*>(
-                view.private_data(node));
-            if (renderable && data && data->event_run)
-                candidates.push_back({renderable, data});
-        });
-    if (!graph_result)
-        throw std::logic_error(
-            "render scene paint graph became invalid during event dispatch");
-    for (const auto& owned_event : events) {
-        const Event& event = *owned_event;
-        /* 批次交换只结束等帧阶段；每个事件真正进入路由时才开始计算分发耗时。 */
-        event.mark_dispatch_started(frame_sequence);
-        const auto* pointer = dynamic_cast<const Pointer_Event_Capability*>(&event);
-        std::vector<Event_Target> order;
-        order.reserve(candidates.size());
-        for (const auto& target : candidates) {
-            if (pointer) {
-                const Rect_F region = target.private_data->event_region_run(
-                    target.object, viewport);
-                if (!region.contains(
-                        {pointer->position_x(), pointer->position_y()}))
-                    continue;
-            }
-            order.push_back(target);
-        }
-        std::vector<Event_Target> delivery_order(order.rbegin(), order.rend());
-        detail::Nearest_Event_Target_Rule::apply(delivery_order, [&](const Event_Target& target) {
-            return target.private_data->event_routing_distance_run
-                ? target.private_data->event_routing_distance_run(target.object, event)
-                : std::nullopt;
-        });
-        for (const auto& target : delivery_order) {
-            if (event.is_accepted()) break;
-            target.private_data->event_run(target.object, event);
-        }
-        event.mark_dispatch_completed();
-    }
-}
-template <Attached Object>
-void Render_Scene_2D::Private::set_view_active(Object* object, bool active) {
-    double_buffer::detail::Internal_Access::set<&Prop::view_active>(object, active);
-}
-template <Attached Object>
-void Render_Scene_2D::Private::bind_private_crtp(Object* object) {
-    Prev_Private::bind_private_crtp(object);
-}
-}
diff --git a/render_2D/tests/Model_Adaptation_Test.cpp b/render_2D/tests/Model_Adaptation_Test.cpp
new file mode 100644
index 0000000..c25da19
--- /dev/null
+++ b/render_2D/tests/Model_Adaptation_Test.cpp
@@ -0,0 +1,40 @@
+#include <render_2D/module/renderable/Renderable_2D.hpp>
+#include <render_2D/module/scene/Render_Scene_2D.hpp>
+#include <gtest/gtest.h>
+#include <variant>
+
+namespace {
+struct Test_Renderable_2D : aethera::Def<Test_Renderable_2D, aethera::render_2d::Renderable_2D> {
+    struct Private : Prev_Private {};
+};
+
+static_assert(pro::proxiable<aethera::detail::Model_Private_Pointer<Test_Renderable_2D*>, aethera::render_2d::scene::Renderable>);
+
+TEST(Render_2D_Model, Every_Def_Layer_Uses_The_Final_Private_Instance) {
+    auto renderable = Test_Renderable_2D::Builder{}.build();
+    auto* renderable_2d_layer = static_cast<aethera::render_2d::Renderable_2D*>(renderable.get());
+    auto* kernel_renderable_layer = static_cast<aethera::Renderable*>(renderable.get());
+    EXPECT_EQ(std::addressof(*renderable_2d_layer->d), std::addressof(static_cast<aethera::render_2d::Renderable_2D::Private&>(*renderable->d)));
+    EXPECT_EQ(std::addressof(*kernel_renderable_layer->d), std::addressof(static_cast<aethera::Renderable::Private&>(*renderable->d)));
+}
+
+TEST(Render_2D_Model, Scene_Endpoint_Publishes_Properties_And_Owned_Dag) {
+    aethera::Dag<aethera::render_2d::scene::Renderable>::Builder dag_builder;
+    dag_builder.add({1}, aethera::make_model_proxy<aethera::render_2d::scene::Renderable, Test_Renderable_2D>());
+    auto dag = dag_builder.build();
+    ASSERT_TRUE(dag.has_value());
+    aethera::render_2d::Render_Scene_2D::Builder scene_builder;
+    scene_builder
+    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::render_2d::Render_Scene_2D::Prop::viewport, aethera::render_2d::Size{32, 24})
+    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::render_2d::Render_Scene_2D::Prop::view_active, true);
+    auto scene = scene_builder.build();
+    scene->set<aethera::Owned_Dag, aethera::render_2d::Render_Scene_2D>(std::move(*dag));
+    auto& properties = scene->d->get<aethera::Prop_Tag>();
+    EXPECT_EQ(properties.internal.use()->viewport, (aethera::render_2d::Size{32, 24}));
+    EXPECT_TRUE(properties.internal.use()->view_active);
+    aethera::render_2d::Frame_2D frame({1, 0});
+    const auto rendered = scene->render(&frame, [](aethera::render_2d::Frame_2D*, std::exception_ptr) {});
+    ASSERT_FALSE(rendered.has_value());
+    EXPECT_EQ(std::get<aethera::Run_Taskflow_Result>(rendered.error()), aethera::Run_Taskflow_Result::runtime_not_initialized);
+}
+} // namespace