diff --git a/kernel/kernel/include/concurrent/Concurrent.hpp b/kernel/kernel/include/concurrent/Concurrent.hpp
new file mode 100644
index 0000000..54a1e6d
--- /dev/null
+++ b/kernel/kernel/include/concurrent/Concurrent.hpp
@@ -0,0 +1,35 @@
+#pragma once
+#include <concepts>
+#include <utility>
+namespace aethera {
+namespace detail {
+struct Builder_Set_Probe {
+    template <typename Value> void operator()(Value&) const;
+};
+}
+template <typename Attachment>
+concept Concurrent_Internal = requires(Attachment& attachment) {
+    attachment.internal.advance();
+    attachment.internal.use();
+    attachment.internal.builder_set(detail::Builder_Set_Probe{});
+};
+template <typename Attachment, typename... Args>
+concept Concurrent_External_Set = requires(Attachment& attachment, Args&&... args) {
+    attachment.set(std::forward<Args>(args)...);
+};
+template <typename Attachment, typename... Args>
+concept Concurrent_External_Get = requires(const Attachment& attachment, Args&&... args) {
+    attachment.get(std::forward<Args>(args)...);
+};
+template <typename Attachment>
+concept Concurrent_Attachment = Concurrent_Internal<Attachment> && (Concurrent_External_Set<Attachment, detail::Builder_Set_Probe> || Concurrent_External_Get<Attachment, detail::Builder_Set_Probe>);
+}
+namespace aethera::detail {
+
+/* 默认推进钩子：不记录状态；参数是 advance 入口捕获的交换前角色。 */
+struct No_Concurrent_Hooks {
+    template <typename... Values> void before_advance(const Values*... before) noexcept;
+    template <typename... Values> void after_advance(const Values*... before) noexcept;
+};
+}
+#include "Concurrent.ipp"
diff --git a/kernel/kernel/include/concurrent/Concurrent.ipp b/kernel/kernel/include/concurrent/Concurrent.ipp
new file mode 100644
index 0000000..5875791
--- /dev/null
+++ b/kernel/kernel/include/concurrent/Concurrent.ipp
@@ -0,0 +1,5 @@
+#pragma once
+namespace aethera::detail {
+template <typename... Values> void No_Concurrent_Hooks::before_advance(const Values*...) noexcept {}
+template <typename... Values> void No_Concurrent_Hooks::after_advance(const Values*...) noexcept {}
+}
diff --git a/kernel/kernel/include/concurrent/Concurrent_Advance.hpp b/kernel/kernel/include/concurrent/Concurrent_Advance.hpp
deleted file mode 100644
index 55c2771..0000000
--- a/kernel/kernel/include/concurrent/Concurrent_Advance.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-#include <concepts>
-#include <utility>
-namespace aethera {
-namespace detail {
-struct Builder_Set_Probe {
-    template <typename Value> void operator()(Value&) const;
-};
-}
-template <typename Storage>
-concept Internal_Storage = requires(Storage& storage) {
-    storage.internal.advance();
-    storage.internal.use();
-    storage.internal.builder_set(detail::Builder_Set_Probe{});
-};
-template <typename Storage, typename... Args>
-concept External_Set_Storage = requires(Storage& storage, Args&&... args) {
-    storage.set(std::forward<Args>(args)...);
-};
-template <typename Storage, typename... Args>
-concept External_Get_Storage = requires(const Storage& storage, Args&&... args) {
-    storage.get(std::forward<Args>(args)...);
-};
-template <typename Storage>
-concept Concurrent_Storage = Internal_Storage<Storage> && (External_Set_Storage<Storage, detail::Builder_Set_Probe> || External_Get_Storage<Storage, detail::Builder_Set_Probe>);
-}
-namespace aethera::detail {
-
-/* 默认推进钩子：不记录状态；参数是 advance 入口捕获的交换前角色。 */
-struct No_Storage_Hooks {
-    template <typename... Values> void before_advance(const Values*... before) noexcept;
-    template <typename... Values> void after_advance(const Values*... before) noexcept;
-};
-}
-#include "Concurrent_Advance.ipp"
diff --git a/kernel/kernel/include/concurrent/Concurrent_Advance.ipp b/kernel/kernel/include/concurrent/Concurrent_Advance.ipp
deleted file mode 100644
index 9131dce..0000000
--- a/kernel/kernel/include/concurrent/Concurrent_Advance.ipp
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-namespace aethera::detail {
-template <typename... Values> void No_Storage_Hooks::before_advance(const Values*...) noexcept {}
-template <typename... Values> void No_Storage_Hooks::after_advance(const Values*...) noexcept {}
-}
diff --git a/kernel/kernel/include/concurrent/Concurrent_Registration.hpp b/kernel/kernel/include/concurrent/Concurrent_Registration.hpp
new file mode 100644
index 0000000..78a407a
--- /dev/null
+++ b/kernel/kernel/include/concurrent/Concurrent_Registration.hpp
@@ -0,0 +1,58 @@
+#pragma once
+#include "Concurrent.hpp"
+#include "../model/Model.hpp"
+#include <functional>
+#include <type_traits>
+#include <utility>
+namespace aethera {
+namespace detail {
+template <typename Value, typename Fn> requires Value_Writer<Fn, Value> void initialize_concurrent_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_concurrent_value(Value& target, Member Owner::* member, T&& value);
+template <typename Value, typename T> requires std::assignable_from<Value&, T> void initialize_concurrent_value(Value& target, T&& value);
+template <typename Value, typename... Args>
+concept Concurrent_Value_Initializer = requires(Value& value, Args&&... args) { initialize_concurrent_value(value, std::forward<Args>(args)...); };
+template <typename Endpoint, typename Base> struct Concurrent_Model_API;
+template <typename Endpoint, typename Base> struct Concurrent_Builder_API;
+template <typename Endpoint, typename Base> struct Concurrent_Private_API;
+struct Concurrent_Registration_Protocol {
+    template <typename Endpoint, typename Base> using Model_API = Concurrent_Model_API<Endpoint, Base>;
+    template <typename Endpoint, typename Base> using Builder_API = Concurrent_Builder_API<Endpoint, Base>;
+    template <typename Endpoint, typename Base> using Private_API = Concurrent_Private_API<Endpoint, Base>;
+};
+template <template <typename...> typename Concurrent, typename Tag> struct Concurrent_Registration_Entry {
+    using Tag_Type = Tag;
+    using Protocol = Concurrent_Registration_Protocol;
+    template <typename Endpoint> using Value = typename Model_Tag_Value<Tag, Endpoint>::Type;
+    template <typename Endpoint> using Attachment = Concurrent<Value<Endpoint>>;
+    template <typename Endpoint> static constexpr bool Valid = Concurrent_Attachment<Attachment<Endpoint>>;
+};
+template <typename Tag, typename Endpoint, typename = void> struct Is_Concurrent_Model_Tag : std::false_type {};
+template <typename Tag, typename Endpoint>
+struct Is_Concurrent_Model_Tag<Tag, Endpoint, std::void_t<typename Model_Registration<Tag, typename Endpoint::Model_Registrations>::Type>> : std::bool_constant<std::same_as<typename Model_Registration<Tag, typename Endpoint::Model_Registrations>::Type::Protocol, Concurrent_Registration_Protocol>> {};
+template <typename Tag, typename Endpoint>
+concept Concurrent_Model_Tag = Is_Concurrent_Model_Tag<Tag, Endpoint>::value;
+template <typename Tag, typename Endpoint, typename... Args>
+concept Builder_Settable_Concurrent = Concurrent_Model_Tag<Tag, Endpoint> && Concurrent_Internal<Registered_Model_Attachment<Tag, Endpoint>> && Concurrent_Value_Initializer<Registered_Model_Value<Tag, Endpoint>, Args...>;
+template <typename Tag, typename Endpoint, typename... Args>
+concept Settable_Concurrent = Concurrent_Model_Tag<Tag, Endpoint> && Concurrent_External_Set<Registered_Model_Attachment<Tag, Endpoint>, Args...>;
+template <typename Tag, typename Endpoint, typename... Args>
+concept Gettable_Concurrent = Concurrent_Model_Tag<Tag, Endpoint> && Concurrent_External_Get<Registered_Model_Attachment<Tag, Endpoint>, Args...>;
+template <typename Endpoint, typename Base> struct Concurrent_Model_API : Base {
+    template <typename Tag, typename... Args> requires Settable_Concurrent<Tag, Endpoint, Args...> Endpoint& set(Args&&... args);
+    template <typename Tag, typename... Args> requires Gettable_Concurrent<Tag, Endpoint, Args...> const Endpoint& get(Args&&... args) const;
+};
+template <typename Endpoint, typename Base> struct Concurrent_Builder_API : Base {
+    template <typename Tag, typename... Args> requires Builder_Settable_Concurrent<Tag, Endpoint, Args...> typename Endpoint::Builder& set(Args&&... args);
+};
+template <typename Endpoint, typename Base> struct Concurrent_Private_API : Base {
+    template <typename Tag> requires Concurrent_Model_Tag<Tag, Endpoint> auto& concurrent() noexcept;
+    template <typename Tag> requires Concurrent_Model_Tag<Tag, Endpoint> const auto& concurrent() const noexcept;
+};
+} // namespace detail
+/* 同一 Concurrent 模板可连续注册多个 Tag；每个 Tag 在最终 endpoint 上独立求值。 */
+template <template <typename...> typename Concurrent, typename... Tags> requires (sizeof...(Tags) > 0)
+struct Concurrent_Registration {
+    using Entries = detail::Model_Type_List<detail::Concurrent_Registration_Entry<Concurrent, Tags>...>;
+};
+} // namespace aethera
+#include "Concurrent_Registration.ipp"
diff --git a/kernel/kernel/include/concurrent/Concurrent_Registration.ipp b/kernel/kernel/include/concurrent/Concurrent_Registration.ipp
new file mode 100644
index 0000000..d4f6e98
--- /dev/null
+++ b/kernel/kernel/include/concurrent/Concurrent_Registration.ipp
@@ -0,0 +1,32 @@
+#pragma once
+namespace aethera::detail {
+template <typename Value, typename Fn> requires Value_Writer<Fn, Value>
+void initialize_concurrent_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_concurrent_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_concurrent_value(Value& target, T&& value) { target = std::forward<T>(value); }
+template <typename Endpoint, typename Base> template <typename Tag, typename... Args> requires Settable_Concurrent<Tag, Endpoint, Args...>
+Endpoint& Concurrent_Model_API<Endpoint, Base>::set(Args&&... args) {
+    auto& self = static_cast<Endpoint&>(*this);
+    self.d->template concurrent<Tag>().set(std::forward<Args>(args)...);
+    return self;
+}
+template <typename Endpoint, typename Base> template <typename Tag, typename... Args> requires Gettable_Concurrent<Tag, Endpoint, Args...>
+const Endpoint& Concurrent_Model_API<Endpoint, Base>::get(Args&&... args) const {
+    const auto& self = static_cast<const Endpoint&>(*this);
+    self.d->template concurrent<Tag>().get(std::forward<Args>(args)...);
+    return self;
+}
+template <typename Endpoint, typename Base> template <typename Tag, typename... Args> requires Builder_Settable_Concurrent<Tag, Endpoint, Args...>
+typename Endpoint::Builder& Concurrent_Builder_API<Endpoint, Base>::set(Args&&... args) {
+    auto& builder = static_cast<typename Endpoint::Builder&>(*this);
+    auto& concurrent = this->model().d->template concurrent<Tag>();
+    concurrent.internal.builder_set([&](auto& value) { initialize_concurrent_value(value, std::forward<Args>(args)...); });
+    return builder;
+}
+template <typename Endpoint, typename Base> template <typename Tag> requires Concurrent_Model_Tag<Tag, Endpoint>
+auto& Concurrent_Private_API<Endpoint, Base>::concurrent() noexcept { return this->template attachment<Tag>(); }
+template <typename Endpoint, typename Base> template <typename Tag> requires Concurrent_Model_Tag<Tag, Endpoint>
+const auto& Concurrent_Private_API<Endpoint, Base>::concurrent() const noexcept { return this->template attachment<Tag>(); }
+} // namespace aethera::detail
diff --git a/kernel/kernel/include/concurrent/design.md b/kernel/kernel/include/concurrent/design.md
index be92367..8a87625 100644
--- a/kernel/kernel/include/concurrent/design.md
+++ b/kernel/kernel/include/concurrent/design.md
@@ -1,49 +1,59 @@
-# 并发存储设计
+# 并发结构设计
+
+并发结构是一种可由 Model 选择性组合的协议，和关系结构同级；DAG 不属于并发结构，也不复用本协议的函数名。
 
 ## 文件职责
 
-| 文件                            | 职责                                        |
-|---------------------------------|---------------------------------------------|
-| `Concurrent_Advance`            | 提供推进钩子和统一 Concurrent concept。     |
-| `Concurrent_Struct_Storage`     | 结构值的导入、导出发布。                    |
-| `Concurrent_List_Storage`       | 双槽列表和可外部查询的三槽导入批次。        |
-| `Concurrent_Storage`            | 并发存储总入口。                            |
-| `Concurrent_Storage_with_dirty` | 可选整体/属性 dirty revision 与对应绑定器。 |
-| `Tagged_Storage`                | 按编译期 Tag 组合并定位存储。               |
+| 文件 | 职责 |
+|---|---|
+| `Concurrent.hpp` | 定义并发附件 concept 和推进钩子。 |
+| `Concurrent_Registration.hpp` | 定义注册项以及 Model、Builder、Private 三组 CRTP API。 |
+| `structure/Struct.hpp` | 定义结构值的导入、导出并发实现。 |
+| `list/List.hpp` | 定义双槽列表和可外部查询的三槽导入批次。 |
+| `dirty/Dirty.hpp` | 定义可选整体/属性 dirty revision 和绑定器。 |
+| `model/detail/Attachment.hpp` | 按编译期 Tag 组合并定位所有协议共用的模型附件。 |
 
-声明位于 `.hpp`，模板实现位于同名 `.ipp`。每种存储的 `advance()` 直接完成钩子、角色推进和 dirty 流程，不再通过 View
-或交换中间函数转发。 并发结构是透明机制对象：字段和机制函数均公开，不使用 `friend`、访问分区或继承转发 `using`。 所有
-注册进 Model 的 Internal 必须提供 `use()`、`advance()` 和 `builder_set(...)`；外部必须提供 `set(...)`、`get(...)` 中至少一个。能力直接通过 concept 检查真实函数，不额外保存能力标记，也不要求外部读写能力同时存在。
+声明位于 `.hpp`，模板实现位于同名 `.ipp`。具体并发实现是公开的透明机制对象，不使用 View、兼容转发或额外能力标记。
 
-## 存储语义
+## 协议
 
-| 类型                    | 外部操作                     | `advance()`                      |
-|-------------------------|------------------------------|----------------------------------|
-| `Export_Struct`         | 读取已发布值                 | 将内部值复制到外部读面。         |
-| `Import_Struct`         | 编辑外部写面                 | 将外部值复制到内部读面。         |
-| `Import_List`           | 追加外部列表                 | 交换内外列表并清空复用槽。       |
-| `Export_List`           | 读取已发布列表               | 交换内外列表并清空新的内部写槽。 |
-| `Readable_Import_Batch` | 写入新批次、查询上一内部批次 | 三槽轮换并清空新的外部写槽。     |
+每个注册进 Model 的并发附件必须提供：
 
-列表交换槽位，结构值按 `Exchange_Value` 契约复制。当前角色引用是槽位身份的唯一来源。
+- 内部 `internal.use()`：取得当前内部角色的非拥有借用。
+- 内部 `internal.advance()`：在安全点推进角色或发布值。
+- 内部 `internal.builder_set(...)`：仅供 Builder 初始化尚未发布的值。
+- 外部 `set(...)`、`get(...)` 至少一个；可同时提供。
+
+`Concurrent_Registration<Concrete, Tags...>` 为所有 Tag 实例化同一个具体并发模板，并向最终 endpoint 选择性附加实体 `set<Tag>/get<Tag>`、Builder `set<Tag>` 和 Private `concurrent<Tag>()`。concept 直接检查真实函数，未注册 Tag 或能力不匹配的调用在编译期拒绝。
+
+## 具体实现
+
+| 类型 | 外部操作 | `advance()` |
+|---|---|---|
+| `Export_Struct_Concurrent` | 读取已发布值 | 将内部值复制到外部读面。 |
+| `Import_Struct_Concurrent` | 编辑外部写面 | 将外部值复制到内部读面。 |
+| `Import_List_Concurrent` | 追加外部列表 | 交换内外列表并清空复用槽。 |
+| `Export_List_Concurrent` | 读取已发布列表 | 交换内外列表并清空新的内部写槽。 |
+| `Readable_Import_Batch_Concurrent` | 写入新批次、查询上一内部批次 | 三槽轮换并清空新的外部写槽。 |
+
+列表交换槽位，结构值按 `Exchange_Value` 契约复制。当前角色指针是槽位身份的唯一来源。
 
 ## 推进与 Dirty
 
-- 各 Storage 的 `advance()` 直接保证钩子顺序和角色推进，不判断业务是否变化。
-- 前置和后置钩子接收同一组交换前角色裸指针；指针是非拥有借用，只在当前 `advance()` 内有效。
+- 各实现的 `advance()` 直接保证钩子、角色推进和 dirty 顺序，不判断业务值是否变化。
+- 前置和后置钩子接收同一组交换前角色的非拥有裸指针，只在当前 `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、写入和来源推进遵守同一内部线程模型约定。
+- `set(member, value)` 只标记对应属性；回调写入和内部 `use()` 按整对象写入处理。
+- 成员接口接受当前值类型及其公开基类的成员指针，Model 值继承链可用声明属性的原始成员指针初始化、读写和查询 dirty。
+- 一次 `advance()` 最多推进一次整体 revision；属性记录最近一次发布对应的整体 revision，不维护第二套计数器。
+- `Dirty_Binder` 消费一个或多个并发附件的整体 dirty；`Property_Dirty_Binder` 消费同一 Struct 附件的固定成员。
 
 ## 线程契约
 
-- Storage 不提供等待、事件或快照；Struct 的发布复制和 List 的角色交换只使用各自交换锁保护。
-- 内部 `use()` 可与外部稳定角色的 `get()/set()` 并行；`advance()` 通过交换锁与同一 Storage 的外部操作互斥。
-- 同一存储的 `use()/advance()` 必须由同一内部线程串行调用。
+- 并发附件不提供同步等待、事件或快照；Struct 的发布复制和 List 的角色交换只使用各自交换锁保护。
+- 内部 `use()` 可与外部稳定角色的 `get()/set()` 并行；`advance()` 通过交换锁与同一附件的外部操作互斥。
+- 同一附件的 `use()/advance()` 必须由同一内部线程串行调用。
 - `use()` 返回当前内部角色的非拥有裸指针；指针不得跨越下一次 `advance()`，也不得交给其他线程。
-- 前置钩子、角色推进和后置钩子均在内部线程直接执行；钩子必须 `noexcept`，不得保存参数指针或重入同一存储。
-- `get()/set()` 的调用方函数在交换锁内执行，只允许直接读写传入值；禁止重入当前 Storage，也禁止调用可能反向进入当前 Storage 或其所属策略的函数。
-- 属性 revision 表会在成员首次写入时增长；其写入不得与 binder 查询或 `advance()` 重叠。
+- 钩子必须 `noexcept`，不得保存参数指针或重入同一附件。
+- `get()/set()` 的回调在交换锁内执行，只允许直接访问传入值；禁止重入当前附件或调用可能反向进入所属策略的函数。
+- 属性 revision 表首次使用成员写入时增长；成员写入不得与 binder 查询或 `advance()` 重叠。
diff --git a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp b/kernel/kernel/include/concurrent/dirty/Dirty.hpp
similarity index 76%
rename from kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp
rename to kernel/kernel/include/concurrent/dirty/Dirty.hpp
index fe7deba..ae250b7 100644
--- a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.hpp
+++ b/kernel/kernel/include/concurrent/dirty/Dirty.hpp
@@ -5,15 +5,15 @@
 #include <tuple>
 #include <utility>
 #include <vector>
-#include "base/Concurrent_List.hpp"
-#include "base/Concurrent_Struct.hpp"
+#include "../list/List.hpp"
+#include "../structure/Struct.hpp"
 namespace aethera {
 namespace detail {
 /*
  * Dirty 仅属于内部线程；revision 随成功发布递增，不承担跨线程同步。
- * pending_dirty 服从 Storage 的外部写入与 advance 不重叠契约。
+ * pending_dirty 服从并发附件的外部写入与 advance 不重叠契约。
  */
-struct Dirty_Storage_Hooks : No_Storage_Hooks {
+struct Dirty_Concurrent_Hooks : No_Concurrent_Hooks {
     template <typename... Values> void after_advance(const Values*... before) noexcept;
     void on_write_access() noexcept;
     std::uint64_t dirty_revision() const noexcept;
@@ -29,9 +29,9 @@ template <typename Struct, typename Owner, Member_Value Member> requires std::de
 /*
  * 属性表不加锁：外部阶段只能通过 set(member) 扩展或标记属性表；advance() 完成发布后，
  * binder 才在同一内部线程阶段查询 revision。调用方保证这三个阶段不重叠，因此这里不需要
- * 锁、原子或其他同步；破坏该阶段顺序属于违反 Storage 线程契约。
+ * 锁、原子或其他同步；破坏该阶段顺序属于违反并发附件线程契约。
  */
-struct Struct_Dirty_Storage_Hooks : Dirty_Storage_Hooks {
+struct Struct_Dirty_Concurrent_Hooks : Dirty_Concurrent_Hooks {
     template <typename... Values> void after_advance(const Values*... before) noexcept;
     void on_write_access() 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);
@@ -41,11 +41,11 @@ struct Struct_Dirty_Storage_Hooks : Dirty_Storage_Hooks {
     bool pending_whole_property_dirty{}; /* 当前编辑面是否发生过整对象写入。 */
 };
 }
-template <Exchange_Value Val> using Export_Struct_With_Dirty = Export_Struct<Val, detail::Struct_Dirty_Storage_Hooks>;
-template <Exchange_Value Val> using Import_Struct_With_Dirty = Import_Struct<Val, detail::Struct_Dirty_Storage_Hooks>;
-template <List_Value Val> using Import_List_With_Dirty = Import_List<Val, detail::Dirty_Storage_Hooks>;
-template <List_Value Val> using Export_List_With_Dirty = Export_List<Val, detail::Dirty_Storage_Hooks>;
-template <List_Value Val> using Readable_Import_Batch_With_Dirty = Readable_Import_Batch<Val, detail::Dirty_Storage_Hooks>;
+template <Exchange_Value Val> using Dirty_Export_Struct_Concurrent = Export_Struct_Concurrent<Val, detail::Struct_Dirty_Concurrent_Hooks>;
+template <Exchange_Value Val> using Dirty_Import_Struct_Concurrent = Import_Struct_Concurrent<Val, detail::Struct_Dirty_Concurrent_Hooks>;
+template <List_Value Val> using Dirty_Import_List_Concurrent = Import_List_Concurrent<Val, detail::Dirty_Concurrent_Hooks>;
+template <List_Value Val> using Dirty_Export_List_Concurrent = Export_List_Concurrent<Val, detail::Dirty_Concurrent_Hooks>;
+template <List_Value Val> using Dirty_Readable_Import_Batch_Concurrent = Readable_Import_Batch_Concurrent<Val, detail::Dirty_Concurrent_Hooks>;
 template <typename Source>
 concept Dirty_Revision_Source = requires(const Source& source) {
     {
@@ -61,7 +61,7 @@ concept Property_Dirty_Revision_Source = std::is_member_object_pointer_v<Member>
     -> std::same_as<std::uint64_t>;
 };
 /*
- * 内部线程对固定 Storage 集合的整体 dirty 游标。Source 必须比 Binder 活得久；
+ * 内部线程对固定并发附件集合的整体 dirty 游标。Source 必须比 Binder 活得久；
  * dirty/take_dirty 与所有 Source 的 advance 必须由同一内部线程调用。
  */
 template <Dirty_Revision_Source... Sources> requires (sizeof...(Sources) > 0)
@@ -75,7 +75,7 @@ struct Dirty_Binder : Non_Copyable {
     std::array<std::uint64_t, sizeof...(Sources)> seen{}; /* 本消费者已处理的来源 revision。 */
 };
 /*
- * 内部线程对同一 Struct Storage 固定成员集合的 dirty 游标。Source 必须比 Binder 活得久；
+ * 内部线程对同一 Struct 并发附件固定成员集合的 dirty 游标。Source 必须比 Binder 活得久；
  * 整对象写入会使全部成员 dirty，成员写入只推进对应成员。
  */
 template <typename Source, typename... Members> requires (sizeof...(Members) > 0 && (Property_Dirty_Revision_Source<Source, Members> && ...))
@@ -85,9 +85,9 @@ struct Property_Dirty_Binder : Non_Copyable {
     bool take_dirty() noexcept;
     template <std::size_t... Index> bool dirty_impl(std::index_sequence<Index...>) const noexcept;
     template <std::size_t... Index> bool take_dirty_impl(std::index_sequence<Index...>) noexcept;
-    const Source* source; /* 被观察 Struct Storage 的非拥有借用。 */
+    const Source* source; /* 被观察 Struct 并发附件的非拥有借用。 */
     std::tuple<Members...> members; /* 固定观察的成员指针。 */
     std::array<std::uint64_t, sizeof...(Members)> seen{}; /* 本消费者已处理的成员 revision。 */
 };
 }
-#include "Concurrent_Storage_with_dirty.ipp"
+#include "Dirty.ipp"
diff --git a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp b/kernel/kernel/include/concurrent/dirty/Dirty.ipp
similarity index 87%
rename from kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp
rename to kernel/kernel/include/concurrent/dirty/Dirty.ipp
index a2ce7b4..e1f4421 100644
--- a/kernel/kernel/include/concurrent/Concurrent_Storage_with_dirty.ipp
+++ b/kernel/kernel/include/concurrent/dirty/Dirty.ipp
@@ -3,15 +3,15 @@
 
 namespace aethera::detail {
 
-template <typename... Values> void Dirty_Storage_Hooks::after_advance(const Values*...) noexcept {
+template <typename... Values> void Dirty_Concurrent_Hooks::after_advance(const Values*...) noexcept {
     if (!pending_dirty) return;
     pending_dirty = false;
     ++revision;
 }
-inline void Dirty_Storage_Hooks::on_write_access() noexcept {
+inline void Dirty_Concurrent_Hooks::on_write_access() noexcept {
     pending_dirty = true;
 }
-inline std::uint64_t Dirty_Storage_Hooks::dirty_revision() const noexcept {
+inline std::uint64_t Dirty_Concurrent_Hooks::dirty_revision() const noexcept {
     return revision;
 }
 
@@ -25,9 +25,9 @@ std::size_t property_dirty_key(const Struct& value, Member Owner::* member) noex
 }
 
 template <typename... Values>
-void Struct_Dirty_Storage_Hooks::after_advance(const Values*... before) noexcept {
+void Struct_Dirty_Concurrent_Hooks::after_advance(const Values*... before) noexcept {
     const bool changed = pending_dirty;
-    Dirty_Storage_Hooks::after_advance(before...);
+    Dirty_Concurrent_Hooks::after_advance(before...);
     if (!changed) return;
     if (pending_whole_property_dirty) {
         whole_property_revision = revision;
@@ -40,26 +40,26 @@ void Struct_Dirty_Storage_Hooks::after_advance(const Values*... before) noexcept
     }
 }
 
-inline void Struct_Dirty_Storage_Hooks::on_write_access() noexcept {
-    Dirty_Storage_Hooks::on_write_access();
+inline void Struct_Dirty_Concurrent_Hooks::on_write_access() noexcept {
+    Dirty_Concurrent_Hooks::on_write_access();
     pending_whole_property_dirty = true;
 }
 
 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) {
+void Struct_Dirty_Concurrent_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;
         property.pending = true;
-        Dirty_Storage_Hooks::on_write_access();
+        Dirty_Concurrent_Hooks::on_write_access();
         return;
     }
     property_revisions.push_back({key, 0, true});
-    Dirty_Storage_Hooks::on_write_access();
+    Dirty_Concurrent_Hooks::on_write_access();
 }
 
 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 {
+std::uint64_t Struct_Dirty_Concurrent_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_List.hpp b/kernel/kernel/include/concurrent/list/List.hpp
similarity index 81%
rename from kernel/kernel/include/concurrent/base/Concurrent_List.hpp
rename to kernel/kernel/include/concurrent/list/List.hpp
index 1bf5a80..62152dd 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_List.hpp
+++ b/kernel/kernel/include/concurrent/list/List.hpp
@@ -1,11 +1,11 @@
 #pragma once
 #include "../../global.hpp"
-#include "../Concurrent_Advance.hpp"
+#include "../Concurrent.hpp"
 #include <mutex>
 namespace aethera {
-template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> struct Import_List {
+template <List_Value Val, typename Concurrent_Hooks = detail::No_Concurrent_Hooks> struct Import_List_Concurrent {
     template <Value_Writer<Val> Fn> void set(Fn&& fn);
-    struct Internal final : Storage_Hooks {
+    struct Internal final : Concurrent_Hooks {
         /* 仅同一内部线程可调用；返回借用不得保存到下一次 advance。 */
         Val* use();
         void advance();
@@ -17,9 +17,9 @@ template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> str
     };
     Internal internal{}; /* 内部线程入口；use/advance 必须由同一线程调用。 */
 };
-template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> struct Export_List {
+template <List_Value Val, typename Concurrent_Hooks = detail::No_Concurrent_Hooks> struct Export_List_Concurrent {
     template <Value_Reader<Val> Fn> void get(Fn&& fn) const;
-    struct Internal final : Storage_Hooks {
+    struct Internal final : Concurrent_Hooks {
         /* 仅同一内部线程可调用；可写借用会记录本轮修改，且不得跨越 advance。 */
         Val* use();
         void advance();
@@ -31,10 +31,10 @@ template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> str
     };
     Internal internal{}; /* 内部线程入口；use/advance 必须由同一线程调用。 */
 };
-template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> struct Readable_Import_Batch {
+template <List_Value Val, typename Concurrent_Hooks = detail::No_Concurrent_Hooks> struct Readable_Import_Batch_Concurrent {
     template <Value_Writer<Val> Fn> void set(Fn&& fn);
     template <Value_Reader<Val> Fn> void get(Fn&& fn) const;
-    struct Internal final : Storage_Hooks {
+    struct Internal final : Concurrent_Hooks {
         /* 仅同一内部线程可调用；返回借用不得保存到下一次 advance。 */
         Val* use();
         void advance();
@@ -48,4 +48,4 @@ template <List_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks> str
     Internal internal{}; /* 内部线程入口；use/advance 必须由同一线程调用。 */
 };
 }
-#include "Concurrent_List.ipp"
+#include "List.ipp"
diff --git a/kernel/kernel/include/concurrent/base/Concurrent_List.ipp b/kernel/kernel/include/concurrent/list/List.ipp
similarity index 60%
rename from kernel/kernel/include/concurrent/base/Concurrent_List.ipp
rename to kernel/kernel/include/concurrent/list/List.ipp
index 4e01dc9..6a93803 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_List.ipp
+++ b/kernel/kernel/include/concurrent/list/List.ipp
@@ -2,20 +2,20 @@
 #include <functional>
 #include <utility>
 namespace aethera {
-template <List_Value Val, typename Storage_Hooks> template <Value_Writer<Val> Fn> void Import_List<Val, Storage_Hooks>::set(Fn&& fn) {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Writer<Val> Fn> void Import_List_Concurrent<Val, Concurrent_Hooks>::set(Fn&& fn) {
     std::lock_guard lock(internal.exchange_mutex);
     if constexpr (requires { internal.on_write_access(); }) {
         internal.on_write_access();
     }
     std::invoke(std::forward<Fn>(fn), *internal.external);
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Writer<Val> Fn> void Import_List<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Writer<Val> Fn> void Import_List_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), *internal);
 }
-template <List_Value Val, typename Storage_Hooks> Val* Import_List<Val, Storage_Hooks>::Internal::use() {
+template <List_Value Val, typename Concurrent_Hooks> Val* Import_List_Concurrent<Val, Concurrent_Hooks>::Internal::use() {
     return this->internal;
 }
-template <List_Value Val, typename Storage_Hooks> void Import_List<Val, Storage_Hooks>::Internal::advance() {
+template <List_Value Val, typename Concurrent_Hooks> void Import_List_Concurrent<Val, Concurrent_Hooks>::Internal::advance() {
     std::lock_guard lock(exchange_mutex);
     Val* const internal_before = this->internal;
     Val* const external_before = this->external;
@@ -26,20 +26,20 @@ template <List_Value Val, typename Storage_Hooks> void Import_List<Val, Storage_
     static_assert(noexcept(this->after_advance(internal_before, external_before)));
     this->after_advance(internal_before, external_before);
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Reader<Val> Fn> void Export_List<Val, Storage_Hooks>::get(Fn&& fn) const {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Reader<Val> Fn> void Export_List_Concurrent<Val, Concurrent_Hooks>::get(Fn&& fn) const {
     std::lock_guard lock(internal.exchange_mutex);
     std::invoke(std::forward<Fn>(fn), std::as_const(*internal.external));
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Writer<Val> Fn> void Export_List<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Writer<Val> Fn> void Export_List_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), *internal);
 }
-template <List_Value Val, typename Storage_Hooks> Val* Export_List<Val, Storage_Hooks>::Internal::use() {
+template <List_Value Val, typename Concurrent_Hooks> Val* Export_List_Concurrent<Val, Concurrent_Hooks>::Internal::use() {
     if constexpr (requires { this->on_write_access(); }) {
         this->on_write_access();
     }
     return this->internal;
 }
-template <List_Value Val, typename Storage_Hooks> void Export_List<Val, Storage_Hooks>::Internal::advance() {
+template <List_Value Val, typename Concurrent_Hooks> void Export_List_Concurrent<Val, Concurrent_Hooks>::Internal::advance() {
     std::lock_guard lock(exchange_mutex);
     Val* const internal_before = this->internal;
     Val* const external_before = this->external;
@@ -50,24 +50,24 @@ template <List_Value Val, typename Storage_Hooks> void Export_List<Val, Storage_
     static_assert(noexcept(this->after_advance(internal_before, external_before)));
     this->after_advance(internal_before, external_before);
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Writer<Val> Fn> void Readable_Import_Batch<Val, Storage_Hooks>::set(Fn&& fn) {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Writer<Val> Fn> void Readable_Import_Batch_Concurrent<Val, Concurrent_Hooks>::set(Fn&& fn) {
     std::lock_guard lock(internal.exchange_mutex);
     if constexpr (requires { internal.on_write_access(); }) {
         internal.on_write_access();
     }
     std::invoke(std::forward<Fn>(fn), *internal.external_write);
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Reader<Val> Fn> void Readable_Import_Batch<Val, Storage_Hooks>::get(Fn&& fn) const {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Reader<Val> Fn> void Readable_Import_Batch_Concurrent<Val, Concurrent_Hooks>::get(Fn&& fn) const {
     std::lock_guard lock(internal.exchange_mutex);
     std::invoke(std::forward<Fn>(fn), std::as_const(*internal.external_read));
 }
-template <List_Value Val, typename Storage_Hooks> template <Value_Writer<Val> Fn> void Readable_Import_Batch<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
+template <List_Value Val, typename Concurrent_Hooks> template <Value_Writer<Val> Fn> void Readable_Import_Batch_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), *internal_read);
 }
-template <List_Value Val, typename Storage_Hooks> Val* Readable_Import_Batch<Val, Storage_Hooks>::Internal::use() {
+template <List_Value Val, typename Concurrent_Hooks> Val* Readable_Import_Batch_Concurrent<Val, Concurrent_Hooks>::Internal::use() {
     return internal_read;
 }
-template <List_Value Val, typename Storage_Hooks> void Readable_Import_Batch<Val, Storage_Hooks>::Internal::advance() {
+template <List_Value Val, typename Concurrent_Hooks> void Readable_Import_Batch_Concurrent<Val, Concurrent_Hooks>::Internal::advance() {
     std::lock_guard lock(exchange_mutex);
     Val* const external_write_before = external_write;
     Val* const internal_read_before = internal_read;
diff --git a/kernel/kernel/include/concurrent/storage/Tagged_Storage.hpp b/kernel/kernel/include/concurrent/storage/Tagged_Storage.hpp
deleted file mode 100644
index b86e46f..0000000
--- a/kernel/kernel/include/concurrent/storage/Tagged_Storage.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-namespace aethera {
-template <class Tag, class T> struct Tagged_Storage : T {};
-template <class... Storages> struct Tagged_Storage_Set : Storages... {
-    template <class Tag> auto& get() noexcept;
-    template <class Tag> const auto& get() const noexcept;
-    template <class Tag, class T> static T& get_impl(Tagged_Storage<Tag, T>& value) noexcept;
-    template <class Tag, class T> static const T& get_impl(const Tagged_Storage<Tag, T>& value) noexcept;
-};
-}
-#include "Tagged_Storage.ipp"
diff --git a/kernel/kernel/include/concurrent/storage/Tagged_Storage.ipp b/kernel/kernel/include/concurrent/storage/Tagged_Storage.ipp
deleted file mode 100644
index 5762c7b..0000000
--- a/kernel/kernel/include/concurrent/storage/Tagged_Storage.ipp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-namespace aethera {
-template <class... Storages> template <class Tag> auto& Tagged_Storage_Set<Storages...>::get() noexcept {
-    return get_impl<Tag>(*this);
-}
-template <class... Storages> template <class Tag> const auto& Tagged_Storage_Set<Storages...>::get() const noexcept {
-    return get_impl<Tag>(*this);
-}
-template <class... Storages> template <class Tag, class T> T& Tagged_Storage_Set<Storages...>::get_impl(
-    Tagged_Storage<Tag, T>& value) noexcept {
-    return value;
-}
-template <class... Storages> template <class Tag, class T> const T& Tagged_Storage_Set<Storages...>::get_impl(
-    const Tagged_Storage<Tag, T>& value) noexcept {
-    return value;
-}
-}
diff --git a/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp b/kernel/kernel/include/concurrent/structure/Struct.hpp
similarity index 85%
rename from kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp
rename to kernel/kernel/include/concurrent/structure/Struct.hpp
index ce5e465..cc08f67 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_Struct.hpp
+++ b/kernel/kernel/include/concurrent/structure/Struct.hpp
@@ -1,15 +1,15 @@
 #pragma once
 #include "../../global.hpp"
-#include "../Concurrent_Advance.hpp"
+#include "../Concurrent.hpp"
 #include <mutex>
 namespace aethera {
-template <Exchange_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks>
-struct Export_Struct {
+template <Exchange_Value Val, typename Concurrent_Hooks = detail::No_Concurrent_Hooks>
+struct Export_Struct_Concurrent {
     template <Value_Reader<Val> Fn>
     void get(Fn&& fn) const;
     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 {
+    struct Internal final : Concurrent_Hooks {
         /* 仅同一内部线程可调用；可写借用会记录本轮修改，且不得跨越 advance。 */
         Val* use();
         void advance();
@@ -21,8 +21,8 @@ struct Export_Struct {
     };
     Internal internal{}; /* 内部线程入口；use/advance 必须由同一线程调用。 */
 };
-template <Exchange_Value Val, typename Storage_Hooks = detail::No_Storage_Hooks>
-struct Import_Struct {
+template <Exchange_Value Val, typename Concurrent_Hooks = detail::No_Concurrent_Hooks>
+struct Import_Struct_Concurrent {
     template <Value_Writer<Val> Fn>
     void set(Fn&& fn);
     template <typename Owner, Member_Value Member, Assignable_To<Member&> T> requires std::derived_from<Val, Owner>
@@ -31,7 +31,7 @@ struct Import_Struct {
     void get(Fn&& fn) const;
     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 {
+    struct Internal final : Concurrent_Hooks {
         /* 仅同一内部线程可调用；返回借用不得保存到下一次 advance。 */
         Val* use();
         void advance();
@@ -44,4 +44,4 @@ struct Import_Struct {
     Internal internal{}; /* 内部线程入口；use/advance 必须由同一线程调用。 */
 };
 } // namespace aethera
-#include "Concurrent_Struct.ipp"
+#include "Struct.ipp"
diff --git a/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp b/kernel/kernel/include/concurrent/structure/Struct.ipp
similarity index 61%
rename from kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp
rename to kernel/kernel/include/concurrent/structure/Struct.ipp
index f896739..736f73d 100644
--- a/kernel/kernel/include/concurrent/base/Concurrent_Struct.ipp
+++ b/kernel/kernel/include/concurrent/structure/Struct.ipp
@@ -2,27 +2,27 @@
 #include <functional>
 #include <utility>
 namespace aethera {
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 template <Value_Reader<Val> Fn>
-void Export_Struct<Val, Storage_Hooks>::get(Fn&& fn) const {
+void Export_Struct_Concurrent<Val, Concurrent_Hooks>::get(Fn&& fn) const {
     std::lock_guard lock(internal.exchange_mutex);
     std::invoke(std::forward<Fn>(fn), std::as_const(internal.external_read));
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 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> {
+auto Export_Struct_Concurrent<Val, Concurrent_Hooks>::get(Member Owner::* member) const -> std::remove_cv_t<Member> {
     std::lock_guard lock(internal.exchange_mutex);
     return internal.external_read.*member;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
-Val* Export_Struct<Val, Storage_Hooks>::Internal::use() {
+template <Exchange_Value Val, typename Concurrent_Hooks>
+Val* Export_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::use() {
     if constexpr (requires { this->on_write_access(); }) {
         this->on_write_access();
     }
     return &internal_read;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
-void Export_Struct<Val, Storage_Hooks>::Internal::advance() {
+template <Exchange_Value Val, typename Concurrent_Hooks>
+void Export_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::advance() {
     std::lock_guard lock(exchange_mutex);
     Val* const internal_before = &internal_read;
     Val* const external_before = &external_read;
@@ -32,30 +32,30 @@ void Export_Struct<Val, Storage_Hooks>::Internal::advance() {
     static_assert(noexcept(this->after_advance(internal_before, external_before)));
     this->after_advance(internal_before, external_before);
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 template <Value_Writer<Val> Fn>
-void Export_Struct<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
+void Export_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), internal_read);
     external_read = internal_read;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 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) {
+void Export_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Member Owner::* member, T&& value) {
     internal_read.*member = std::forward<T>(value);
     external_read = internal_read;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 template <Value_Writer<Val> Fn>
-void Import_Struct<Val, Storage_Hooks>::set(Fn&& fn) {
+void Import_Struct_Concurrent<Val, Concurrent_Hooks>::set(Fn&& fn) {
     std::lock_guard lock(internal.exchange_mutex);
     if constexpr (requires { internal.on_write_access(); }) {
         internal.on_write_access();
     }
     std::invoke(std::forward<Fn>(fn), internal.external_write);
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 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) {
+void Import_Struct_Concurrent<Val, Concurrent_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);
@@ -64,24 +64,24 @@ void Import_Struct<Val, Storage_Hooks>::set(Member Owner::* member, T&& value) {
     }
     internal.external_write.*member = std::forward<T>(value);
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 template <Value_Reader<Val> Fn>
-void Import_Struct<Val, Storage_Hooks>::get(Fn&& fn) const {
+void Import_Struct_Concurrent<Val, Concurrent_Hooks>::get(Fn&& fn) const {
     std::lock_guard lock(internal.exchange_mutex);
     std::invoke(std::forward<Fn>(fn), std::as_const(internal.external_write));
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 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> {
+auto Import_Struct_Concurrent<Val, Concurrent_Hooks>::get(Member Owner::* member) const -> std::remove_cv_t<Member> {
     std::lock_guard lock(internal.exchange_mutex);
     return internal.external_write.*member;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
-Val* Import_Struct<Val, Storage_Hooks>::Internal::use() {
+template <Exchange_Value Val, typename Concurrent_Hooks>
+Val* Import_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::use() {
     return &internal_read;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
-void Import_Struct<Val, Storage_Hooks>::Internal::advance() {
+template <Exchange_Value Val, typename Concurrent_Hooks>
+void Import_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::advance() {
     std::lock_guard lock(exchange_mutex);
     Val* const internal_before = &internal_read;
     Val* const external_before = &external_write;
@@ -91,15 +91,15 @@ void Import_Struct<Val, Storage_Hooks>::Internal::advance() {
     static_assert(noexcept(this->after_advance(internal_before, external_before)));
     this->after_advance(internal_before, external_before);
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 template <Value_Writer<Val> Fn>
-void Import_Struct<Val, Storage_Hooks>::Internal::builder_set(Fn&& fn) {
+void Import_Struct_Concurrent<Val, Concurrent_Hooks>::Internal::builder_set(Fn&& fn) {
     std::invoke(std::forward<Fn>(fn), internal_read);
     external_write = internal_read;
 }
-template <Exchange_Value Val, typename Storage_Hooks>
+template <Exchange_Value Val, typename Concurrent_Hooks>
 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) {
+void Import_Struct_Concurrent<Val, Concurrent_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/model/Model.hpp b/kernel/kernel/include/model/Model.hpp
index 7e51927..8509e55 100644
--- a/kernel/kernel/include/model/Model.hpp
+++ b/kernel/kernel/include/model/Model.hpp
@@ -1,29 +1,39 @@
 #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 "detail/Attachment.hpp"
 #include <memory>
 #include <proxy/proxy.h>
-#include <stdexcept>
 #include <type_traits>
 #include <utility>
 namespace aethera {
 namespace detail {
 template <typename... Types> struct Model_Type_List {};
+template <typename First, typename Second> struct Concat_Model_Types;
 template <typename List, typename... Types> struct Append_Model_Types;
-template <typename List, typename... Registrations> struct Append_Model_Registrations;
+template <typename List, typename... Registration_Groups> struct Append_Model_Registrations;
+template <typename List> struct Unique_Model_Protocols;
 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 Tag, typename Layer> using Registered_Model_Value = typename Model_Value<Tag, Layer, typename Layer::Model_Registrations>::Type;
+template <typename Tag, typename Layer> using Registered_Model_Attachment = typename Model_Registration<Tag, typename Layer::Model_Registrations>::Type::template Attachment<Layer>;
+template <typename Endpoint, typename Registrations> struct Model_Attachments;
 template <typename Endpoint> struct Model_State;
+template <typename Endpoint, typename Base, typename Protocols> struct Model_API_Set;
+template <typename Endpoint, typename Base, typename Protocols> struct Model_Builder_API_Set;
+template <typename Endpoint, typename Base, typename Protocols> struct Model_Private_API_Set;
+template <typename Self, typename Base, typename... Registrations> struct Model_Definition_Base;
+template <typename Registration>
+concept Model_Registration_Group = requires { typename Registration::Entries; };
+struct Empty_Model_Value {};
 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) {}
+    explicit Model_Private_Handle(Model_Instance* value) noexcept;
     decltype(auto) operator*() const noexcept;
     auto operator->() const noexcept;
     template <typename Active_Endpoint> void bind() noexcept;
@@ -33,21 +43,11 @@ 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; }
+    decltype(auto) operator*() const noexcept;
     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);
-template <typename Value, typename... Args>
-concept Model_Value_Initializer = requires(Value& value, Args&&... args) {
-    initialize_model_value(value, std::forward<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 Endpoint, typename Registrations> struct Model_Storage_Set;
 struct Model_State_Deleter {
-    void operator()(void* value) const noexcept { if (destroy) destroy(value); }
+    void operator()(void* value) const noexcept;
     void (*destroy)(void*){}; /* 与类型擦除 endpoint state 匹配的析构入口。 */
 };
 struct Model_Instance {
@@ -63,20 +63,13 @@ struct Model_Instance {
 private:
     template <typename>
     friend struct Model_Private_Handle;
-    std::unique_ptr<void, Model_State_Deleter> state_owner; /* 唯一拥有当前实际 endpoint 的 Private 与完整 Storage Set。 */
+    std::unique_ptr<void, Model_State_Deleter> state_owner; /* 唯一拥有当前实际 endpoint 的 Private 与完整 Attachment 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>
-concept Settable_Model_Value = std::same_as<Concurrent_Storage<typename Model_Value<Tag, Layer, typename Layer::Storage_Registrations>::Type>, Registered_Model_Storage<Tag, Layer>> && External_Set_Storage<Registered_Model_Storage<Tag, Layer>, Args...>;
-template <template <typename...> typename Concurrent_Storage, typename Tag, typename Layer, typename... Args>
-concept Gettable_Model_Value = std::same_as<Concurrent_Storage<typename Model_Value<Tag, Layer, typename Layer::Storage_Registrations>::Type>, Registered_Model_Storage<Tag, Layer>> && External_Get_Storage<Registered_Model_Storage<Tag, Layer>, Args...>;
-struct Empty_Model_Value {};
 } // namespace detail
 struct Prop_Tag {
     template <typename Layer> using Value = typename Layer::Prop;
@@ -84,63 +77,48 @@ struct Prop_Tag {
 struct State_Tag {
     template <typename Layer> using Value = typename Layer::State;
 };
-/* 在定义层基类上注册 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 : detail::Model_Instance {
     using Model_Layers = detail::Model_Type_List<>;
-    using Storage_Registrations = detail::Model_Type_List<>;
+    using Model_Registrations = detail::Model_Type_List<>;
+    using Model_Protocols = detail::Model_Type_List<>;
     struct Private {};
     struct Builder {};
 protected:
     Root() = default;
     ~Root() = default;
 };
-/*
- * 每层 Def 都携带当前层 Self；注册只形成持久定义链，Builder 使用完整 endpoint 一次物化唯一状态。
- * 当前层作为 endpoint 时构造自己的状态；被继续继承时只贡献定义与 Private 基类，不构造当前层状态。
- */
-template <typename Self, typename Base, typename... Registrations> struct Def : Base {
+/* 每层 Def 只登记扩展定义；完整 endpoint 选择性组合各 Registration 提供的 CRTP API 并物化唯一状态。 */
+template <typename Self, typename Base, detail::Model_Registration_Group... Registrations> struct Def : detail::Model_Definition_Base<Self, Base, Registrations...>::Type {
     using Model_Self = Self;
     using Model_Base = Base;
     using Model_Def = Def;
+    using Definition_Base = typename detail::Model_Definition_Base<Self, Base, Registrations...>::Type;
     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 = detail::Model_Private_Base<Self, typename Base::Private>;
+    using Model_Registrations = typename detail::Append_Model_Registrations<typename Base::Model_Registrations, Registrations...>::Type;
+    using Model_Protocols = typename detail::Unique_Model_Protocols<Model_Registrations>::Type;
+    template <typename Tag> using Prev = typename detail::Model_Value<Tag, Base, Model_Registrations>::Type;
+    using Prev_Private_Core = detail::Model_Private_Base<Self, typename Base::Private>;
+    using Prev_Private = typename detail::Model_Private_API_Set<Self, Prev_Private_Core, Model_Protocols>::Type;
     using Prev_Builder = typename Base::Builder;
-    struct Builder : detail::Model_Builder_Instance<Self> {
+    using Builder_API = typename detail::Model_Builder_API_Set<Self, detail::Model_Builder_Instance<Self>, Model_Protocols>::Type;
+    struct Builder : Builder_API {
         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);
     };
     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;
-    [[nodiscard]] bool model_initialized() const noexcept { return this->initialized(); }
+    [[nodiscard]] bool model_initialized() const noexcept;
     detail::Model_Private_Handle<Self> d; /* 非拥有类型化视图；实际状态始终由公共 Root 唯一拥有。 */
 };
-
 template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<Model*>, Facade>
-proxy<Facade> model_proxy_view(Model& model) { return proxy<Facade>{detail::Model_Private_Pointer<Model*>{std::addressof(model)}}; }
-
+proxy<Facade> model_proxy_view(Model& model);
 template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<std::unique_ptr<Model>>, Facade>
-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)}}; }
-
+proxy<Facade> model_proxy(std::unique_ptr<Model> 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) { typename Model::Builder builder(std::forward<Args>(args)...); return model_proxy<Facade>(builder.build()); }
-
+proxy<Facade> make_model_proxy(Args&&... args);
 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)}}; }
-
+proxy<Facade> model_proxy_shared(std::shared_ptr<Model> 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) { typename Model::Builder builder(std::forward<Args>(args)...); std::shared_ptr<Model> model{builder.build()}; return model_proxy_shared<Facade>(std::move(model)); }
+proxy<Facade> make_model_proxy_shared(Args&&... args);
 } // namespace aethera
 #include "Model.ipp"
diff --git a/kernel/kernel/include/model/Model.ipp b/kernel/kernel/include/model/Model.ipp
index 17a33e7..254ceb8 100644
--- a/kernel/kernel/include/model/Model.ipp
+++ b/kernel/kernel/include/model/Model.ipp
@@ -1,80 +1,97 @@
 #pragma once
-#include <functional>
-#include <utility>
+#include <stdexcept>
 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 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); }
-
-template <typename List, typename... Types> struct Append_Model_Types;
+template <typename... First, typename... Second>
+struct Concat_Model_Types<Model_Type_List<First...>, Model_Type_List<Second...>> { using Type = Model_Type_List<First..., Second...>; };
 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 List>
+struct Append_Model_Registrations<List> { using Type = List; };
+template <typename List, typename Registration, typename... Rest>
+struct Append_Model_Registrations<List, Registration, Rest...> {
+    using Appended = typename Concat_Model_Types<List, typename Registration::Entries>::Type;
+    using Type = typename Append_Model_Registrations<Appended, Rest...>::Type;
+};
+template <typename List, typename Type> struct Append_Unique_Model_Type;
+template <typename... Types, typename Type>
+struct Append_Unique_Model_Type<Model_Type_List<Types...>, Type> { using Type_List = std::conditional_t<(std::same_as<Type, Types> || ...), Model_Type_List<Types...>, Model_Type_List<Types..., Type>>; };
+template <typename Entries, typename Protocols = Model_Type_List<>> struct Collect_Unique_Model_Protocols;
+template <typename Protocols>
+struct Collect_Unique_Model_Protocols<Model_Type_List<>, Protocols> { using Type = Protocols; };
+template <typename Entry, typename... Rest, typename Protocols>
+struct Collect_Unique_Model_Protocols<Model_Type_List<Entry, Rest...>, Protocols> {
+    using Appended = typename Append_Unique_Model_Type<Protocols, typename Entry::Protocol>::Type_List;
+    using Type = typename Collect_Unique_Model_Protocols<Model_Type_List<Rest...>, Appended>::Type;
+};
+template <typename List>
+struct Unique_Model_Protocols { using Type = typename Collect_Unique_Model_Protocols<List>::Type; };
 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 {};
-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;
-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>; };
-
+template <typename Tag, typename Entry, typename... Rest> requires std::same_as<Tag, typename Entry::Tag_Type>
+struct Model_Registration<Tag, Model_Type_List<Entry, Rest...>> { using Type = Entry; };
+template <typename Tag, typename Entry, typename... Rest> requires (!std::same_as<Tag, typename Entry::Tag_Type>)
+struct Model_Registration<Tag, Model_Type_List<Entry, Rest...>> : Model_Registration<Tag, Model_Type_List<Rest...>> {};
 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 Endpoint, typename Registration> struct Attached_Model_Storage {
-    using Tag = typename Registration::Tag_Type;
-    using Value = typename Registration::template Value<Endpoint>;
-    using Type = Tagged_Storage<Tag, typename Registration::template Storage<Value>>;
-    static_assert(Concurrent_Storage<Type>);
+template <typename List> struct Unique_Model_Tags;
+template <> struct Unique_Model_Tags<Model_Type_List<>> : std::true_type {};
+template <typename Entry, typename... Rest>
+struct Unique_Model_Tags<Model_Type_List<Entry, Rest...>> : std::bool_constant<(!std::same_as<typename Entry::Tag_Type, typename Rest::Tag_Type> && ...) && Unique_Model_Tags<Model_Type_List<Rest...>>::value> {};
+template <typename Endpoint, typename Entry> struct Attached_Model_Value {
+    static_assert(Entry::template Valid<Endpoint>, "registered attachment does not satisfy its protocol");
+    using Type = Model_Attachment<typename Entry::Tag_Type, typename Entry::template Attachment<Endpoint>>;
 };
-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 Endpoint, typename... Entries>
+struct Model_Attachments<Endpoint, Model_Type_List<Entries...>> : Model_Attachment_Set<typename Attached_Model_Value<Endpoint, Entries>::Type...> {
+    static_assert(Unique_Model_Tags<Model_Type_List<Entries...>>::value, "each model attachment tag can only be registered once");
+};
+template <typename Endpoint, typename Base>
+struct Model_API_Set<Endpoint, Base, Model_Type_List<>> { using Type = Base; };
+template <typename Endpoint, typename Base, typename Protocol, typename... Rest>
+struct Model_API_Set<Endpoint, Base, Model_Type_List<Protocol, Rest...>> { using Type = typename Model_API_Set<Endpoint, typename Protocol::template Model_API<Endpoint, Base>, Model_Type_List<Rest...>>::Type; };
+template <typename Endpoint, typename Base>
+struct Model_Builder_API_Set<Endpoint, Base, Model_Type_List<>> { using Type = Base; };
+template <typename Endpoint, typename Base, typename Protocol, typename... Rest>
+struct Model_Builder_API_Set<Endpoint, Base, Model_Type_List<Protocol, Rest...>> { using Type = typename Model_Builder_API_Set<Endpoint, typename Protocol::template Builder_API<Endpoint, Base>, Model_Type_List<Rest...>>::Type; };
+template <typename Endpoint, typename Base>
+struct Model_Private_API_Set<Endpoint, Base, Model_Type_List<>> { using Type = Base; };
+template <typename Endpoint, typename Base, typename Protocol, typename... Rest>
+struct Model_Private_API_Set<Endpoint, Base, Model_Type_List<Protocol, Rest...>> { using Type = typename Model_Private_API_Set<Endpoint, typename Protocol::template Private_API<Endpoint, Base>, Model_Type_List<Rest...>>::Type; };
+template <typename Self, typename Base, typename... Registrations>
+struct Model_Definition_Base {
+    using Registrations_List = typename Append_Model_Registrations<typename Base::Model_Registrations, Registrations...>::Type;
+    using Protocols = typename Unique_Model_Protocols<Registrations_List>::Type;
+    using Type = typename Model_API_Set<Self, Base, Protocols>::Type;
 };
-
 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>(); }
+protected:
+    template <typename Tag> auto& attachment() noexcept;
+    template <typename Tag> const auto& attachment() const noexcept;
 };
-
-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)...) {}
+template <typename Endpoint> struct Model_State : Model_Attachments<Endpoint, typename Endpoint::Model_Registrations> {
+    template <typename... Args> explicit Model_State(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), ...); }
-
+template <typename Endpoint, typename Active_Endpoint> void bind_model_handle(Active_Endpoint& model) noexcept;
+template <typename Active_Endpoint, typename... Endpoints> void bind_model_handles(Active_Endpoint& model, Model_Type_List<Endpoints...>) noexcept;
 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); }
-
+inline void Model_State_Deleter::operator()(void* value) const noexcept { if (destroy) destroy(value); }
+template <typename Endpoint, typename Base_Private> template <typename Tag>
+auto& Model_Private_Base<Endpoint, Base_Private>::attachment() noexcept { return this->instance->template state<Endpoint>().template get<Tag>(); }
+template <typename Endpoint, typename Base_Private> template <typename Tag>
+const auto& Model_Private_Base<Endpoint, Base_Private>::attachment() const noexcept { return this->instance->template state<Endpoint>().template get<Tag>(); }
+template <typename Endpoint> template <typename... Args>
+Model_State<Endpoint>::Model_State(Args&&... args) : private_data(std::forward<Args>(args)...) {}
+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), ...); }
 template <typename Endpoint, typename... Args>
 void Model_Instance::initialize_endpoint(Args&&... args) {
     if (state_owner) return;
@@ -83,20 +100,15 @@ void Model_Instance::initialize_endpoint(Args&&... args) {
     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> Model_Private_Handle<Endpoint>::Model_Private_Handle(Model_Instance* value) noexcept : instance(value) {}
 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));
-    };
+    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 Model_Pointer> decltype(auto) Model_Private_Pointer<Model_Pointer>::operator*() const noexcept { return *model->d; }
 template <typename Self> template <typename... Args>
 void Model_Builder_Instance<Self>::initialize_model(Args&&... args) {
     if (ret) return;
@@ -111,15 +123,12 @@ template <typename Self> Self& Model_Builder_Instance<Self>::model() {
     return *ret;
 }
 } // namespace aethera::detail
-
 namespace aethera {
-template <typename Self, typename Base, typename... Registrations>
+template <typename Self, typename Base, detail::Model_Registration_Group... Registrations>
 Def<Self, Base, Registrations...>::Def() : d{static_cast<detail::Model_Instance*>(this)} {}
-
-template <typename Self, typename Base, typename... Registrations> template <typename First, typename... Rest>
+template <typename Self, typename Base, detail::Model_Registration_Group... 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>
+template <typename Self, typename Base, detail::Model_Registration_Group... Registrations>
 std::unique_ptr<Self> Def<Self, Base, Registrations...>::Builder::build() {
     if (!this->ret) {
         if constexpr (std::default_initializable<Self> && std::default_initializable<typename Self::Private>) this->initialize_model();
@@ -127,25 +136,16 @@ std::unique_ptr<Self> Def<Self, Base, Registrations...>::Builder::build() {
     }
     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...>
-typename Def<Self, Base, Registrations...>::Builder& Def<Self, Base, Registrations...>::Builder::set(Args&&... args) {
-    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...>
-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...>
-const Self& Def<Self, Base, Registrations...>::get(Args&&... args) const {
-    const auto& storage = d->template get<Tag>();
-    storage.get(std::forward<Args>(args)...);
-    return static_cast<const Self&>(*this);
-}
+template <typename Self, typename Base, detail::Model_Registration_Group... Registrations>
+bool Def<Self, Base, Registrations...>::model_initialized() const noexcept { return this->initialized(); }
+template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<Model*>, Facade>
+proxy<Facade> model_proxy_view(Model& model) { return proxy<Facade>{detail::Model_Private_Pointer<Model*>{std::addressof(model)}}; }
+template <typename Facade, typename Model> requires pro::proxiable<detail::Model_Private_Pointer<std::unique_ptr<Model>>, Facade>
+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) { 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) { 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
diff --git a/kernel/kernel/include/model/design.md b/kernel/kernel/include/model/design.md
index 15975a8..93aafad 100644
--- a/kernel/kernel/include/model/design.md
+++ b/kernel/kernel/include/model/design.md
@@ -1,13 +1,22 @@
 # Model 设计
 
-`Storage_Registration<Tag, Concurrent_Storage, Fixed_Value = void>` 在任意 `Def<当前层, Base, ...>` 定义层登记 Tag 与 Concurrent Storage。通常由 Tag 的 `Value<Layer>` 映射当前 endpoint 的最终嵌套值类型；复合存储不使用嵌套值继承链时才显式传入 `Fixed_Value`。
+`Model` 只负责定义层、注册项、附件物化和 CRTP API 组合，不认识并发结构、关系结构或任何具体容器。新的能力族应在 `Concurrent_Registration`、`Relation_Registration` 的同级位置定义自己的注册协议，不得把协议分支加回 `Model`。
 
-业务值类型定义在所属类内并继承 `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` 物化；普通构造只建立定义层对象，不产生运行状态。
+- `Entries`：一个注册组展开得到的注册项列表。
+- 注册项：定义 `Tag_Type`、`Protocol`、`Value<Endpoint>`、`Attachment<Endpoint>` 和 `Valid<Endpoint>`。
+- `Protocol`：分别定义 `Model_API<Endpoint, Base>`、`Builder_API<Endpoint, Base>` 和 `Private_API<Endpoint, Base>`。
+- concept：在最终 endpoint 物化时检查具体附件是否满足该协议。
 
-存储的实际类型由当前 endpoint 决定，因此只有最终 Private 直接调用 `get<Tag>()`。继承进来的基类 Private 能力若需要状态，由最终 Private 取得存储并传入对应的基类值引用；基类能力本身不按基类 endpoint 类型重新取得存储。这样不会为了复用基类能力再建立第二份状态源。
+`Def<Self, Base, Registrations...>` 累计各层注册项，对协议去重，然后选择性组合协议提供的 Model、Builder 和 Private CRTP API。没有注册某协议的最终类型不会继承该协议的函数。
 
-跨模块 facade 直接声明消费方所需的 Private 能力。`make_model_proxy`、`make_model_proxy_shared` 与 `model_proxy_view` 分别承载独占、共享和非拥有 Model 生命周期，同时把 proxy 解引用目标映射到该 Model 唯一的 `Private`；实体公开类不实现 facade 转发函数。
+业务值类型定义在所属类内并继承 `Prev<Tag>`。派生层只增量定义自己的字段，最终 endpoint 的值类型自然包含完整继承链。每层都是普通类并把自身传给 `Def`，中间层不需要模板化，也不需要末尾 `Def`。
 
-Builder 使用 `set<Concurrent_Storage, Tag>(...)` 并且只进入 `internal.builder_set(...)`。最终模型使用外部 `set<Concurrent_Storage, Tag>(...)` 和 `get<Concurrent_Storage, Tag>(...)`。Tag 先定位注册项，再由注册项映射当前 endpoint 值类型并实例化对应存储；concept 同时拒绝没有注册的 Concurrent 和不具备所需能力的调用。
+Builder 在构建具体 endpoint 时，才由公共 `Root` 一次物化该 endpoint 的唯一 `Private + Model_Attachment_Set`。被继承的定义层只贡献注册、值类型和 Private 基类，不创建自己的状态。相同 Tag 重复注册属于编译期错误。
+
+每层 `d` 都是对 Root 唯一状态的非拥有类型化视图。最终层 `d` 返回最终 Private；模型转换为某个基类后，该基类的 `d` 返回同一最终 Private 对象中的对应基类子对象。Model 实体必须通过 Builder 或 Model proxy 工厂物化；普通构造只建立定义对象，不产生运行状态。
+
+跨模块 facade 直接声明消费方需要的 Private 能力。`make_model_proxy`、`make_model_proxy_shared` 与 `model_proxy_view` 分别承载独占、共享和非拥有生命周期，同时把 proxy 解引用目标映射到 Model 的唯一 Private；实体公开类不实现 facade 值转发。
+
+并发结构使用 `Concurrent_Registration<Concrete, Tags...>` 注册，关系结构使用 `Relation_Registration<Concrete, Tags...>` 注册。一个具体实现可在同一注册组连续绑定多个 Tag。Builder 和实体只写 Tag，例如 `set<Prop_Tag>(...)`；具体附件类型由注册项和最终 endpoint 唯一确定。
diff --git a/kernel/kernel/include/model/detail/Attachment.hpp b/kernel/kernel/include/model/detail/Attachment.hpp
new file mode 100644
index 0000000..b426c06
--- /dev/null
+++ b/kernel/kernel/include/model/detail/Attachment.hpp
@@ -0,0 +1,11 @@
+#pragma once
+namespace aethera {
+template <class Tag, class T> struct Model_Attachment : T {};
+template <class... Attachments> struct Model_Attachment_Set : Attachments... {
+    template <class Tag> auto& get() noexcept;
+    template <class Tag> const auto& get() const noexcept;
+    template <class Tag, class T> static T& get_impl(Model_Attachment<Tag, T>& value) noexcept;
+    template <class Tag, class T> static const T& get_impl(const Model_Attachment<Tag, T>& value) noexcept;
+};
+}
+#include "Attachment.ipp"
diff --git a/kernel/kernel/include/model/detail/Attachment.ipp b/kernel/kernel/include/model/detail/Attachment.ipp
new file mode 100644
index 0000000..8f1c9ef
--- /dev/null
+++ b/kernel/kernel/include/model/detail/Attachment.ipp
@@ -0,0 +1,15 @@
+#pragma once
+namespace aethera {
+template <class... Attachments> template <class Tag> auto& Model_Attachment_Set<Attachments...>::get() noexcept {
+    return get_impl<Tag>(*this);
+}
+template <class... Attachments> template <class Tag> const auto& Model_Attachment_Set<Attachments...>::get() const noexcept {
+    return get_impl<Tag>(*this);
+}
+template <class... Attachments> template <class Tag, class T> T& Model_Attachment_Set<Attachments...>::get_impl(Model_Attachment<Tag, T>& value) noexcept {
+    return value;
+}
+template <class... Attachments> template <class Tag, class T> const T& Model_Attachment_Set<Attachments...>::get_impl(const Model_Attachment<Tag, T>& value) noexcept {
+    return value;
+}
+}
diff --git a/kernel/kernel/include/relation/Relation.hpp b/kernel/kernel/include/relation/Relation.hpp
new file mode 100644
index 0000000..efacb2b
--- /dev/null
+++ b/kernel/kernel/include/relation/Relation.hpp
@@ -0,0 +1,18 @@
+#pragma once
+#include <concepts>
+#include <utility>
+namespace aethera {
+namespace detail {
+struct Relation_Build_Probe {
+    template <typename Relation> void operator()(Relation&) const;
+};
+}
+template <typename Attachment>
+concept Relation_Attachment = requires(Attachment& attachment, typename Attachment::Graph graph, typename Attachment::Edit edit, typename Attachment::Edit_Completion completion) {
+    { attachment.edit(std::move(graph)) } -> std::same_as<void>;
+    { attachment.edit(std::move(edit), std::move(completion)) } -> std::same_as<void>;
+    { attachment.internal.relation() } -> std::same_as<typename Attachment::Graph&>;
+    { attachment.internal.commit() } -> std::same_as<void>;
+    { attachment.internal.build(detail::Relation_Build_Probe{}) } -> std::same_as<void>;
+};
+} // namespace aethera
diff --git a/kernel/kernel/include/relation/Relation_Registration.hpp b/kernel/kernel/include/relation/Relation_Registration.hpp
new file mode 100644
index 0000000..63fedd9
--- /dev/null
+++ b/kernel/kernel/include/relation/Relation_Registration.hpp
@@ -0,0 +1,50 @@
+#pragma once
+#include "Relation.hpp"
+#include "../model/Model.hpp"
+#include <type_traits>
+#include <utility>
+namespace aethera {
+namespace detail {
+template <typename Endpoint, typename Base> struct Relation_Model_API;
+template <typename Endpoint, typename Base> struct Relation_Builder_API;
+template <typename Endpoint, typename Base> struct Relation_Private_API;
+struct Relation_Registration_Protocol {
+    template <typename Endpoint, typename Base> using Model_API = Relation_Model_API<Endpoint, Base>;
+    template <typename Endpoint, typename Base> using Builder_API = Relation_Builder_API<Endpoint, Base>;
+    template <typename Endpoint, typename Base> using Private_API = Relation_Private_API<Endpoint, Base>;
+};
+template <template <typename...> typename Relation, typename Tag> struct Relation_Registration_Entry {
+    using Tag_Type = Tag;
+    using Protocol = Relation_Registration_Protocol;
+    template <typename> using Value = Tag;
+    template <typename> using Attachment = Relation<Tag>;
+    template <typename Endpoint> static constexpr bool Valid = Relation_Attachment<Attachment<Endpoint>>;
+};
+template <typename Tag, typename Endpoint, typename = void> struct Is_Relation_Model_Tag : std::false_type {};
+template <typename Tag, typename Endpoint>
+struct Is_Relation_Model_Tag<Tag, Endpoint, std::void_t<typename Model_Registration<Tag, typename Endpoint::Model_Registrations>::Type>> : std::bool_constant<std::same_as<typename Model_Registration<Tag, typename Endpoint::Model_Registrations>::Type::Protocol, Relation_Registration_Protocol>> {};
+template <typename Tag, typename Endpoint>
+concept Relation_Model_Tag = Is_Relation_Model_Tag<Tag, Endpoint>::value;
+template <typename Tag, typename Endpoint, typename... Args>
+concept Editable_Relation = Relation_Model_Tag<Tag, Endpoint> && requires(Registered_Model_Attachment<Tag, Endpoint>& relation, Args&&... args) { relation.edit(std::forward<Args>(args)...); };
+template <typename Tag, typename Endpoint, typename Fn>
+concept Buildable_Relation = Relation_Model_Tag<Tag, Endpoint> && std::invocable<Fn, typename Registered_Model_Attachment<Tag, Endpoint>::Graph&>;
+template <typename Endpoint, typename Base> struct Relation_Model_API : Base {
+    template <typename Tag, typename... Args> requires Editable_Relation<Tag, Endpoint, Args...> Endpoint& edit(Args&&... args);
+};
+template <typename Endpoint, typename Base> struct Relation_Builder_API : Base {
+    template <typename Tag, typename Fn> requires Buildable_Relation<Tag, Endpoint, Fn> typename Endpoint::Builder& relation(Fn&& fn);
+};
+template <typename Endpoint, typename Base> struct Relation_Private_API : Base {
+    template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint> auto& relation_attachment() noexcept;
+    template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint> auto& relation() noexcept;
+    template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint> void commit();
+};
+} // namespace detail
+/* 同一 Relation 模板可连续注册多个 Tag；Tag 同时是该关系实现的节点/值参数。 */
+template <template <typename...> typename Relation, typename... Tags> requires (sizeof...(Tags) > 0)
+struct Relation_Registration {
+    using Entries = detail::Model_Type_List<detail::Relation_Registration_Entry<Relation, Tags>...>;
+};
+} // namespace aethera
+#include "Relation_Registration.ipp"
diff --git a/kernel/kernel/include/relation/Relation_Registration.ipp b/kernel/kernel/include/relation/Relation_Registration.ipp
new file mode 100644
index 0000000..213fb94
--- /dev/null
+++ b/kernel/kernel/include/relation/Relation_Registration.ipp
@@ -0,0 +1,21 @@
+#pragma once
+namespace aethera::detail {
+template <typename Endpoint, typename Base> template <typename Tag, typename... Args> requires Editable_Relation<Tag, Endpoint, Args...>
+Endpoint& Relation_Model_API<Endpoint, Base>::edit(Args&&... args) {
+    auto& self = static_cast<Endpoint&>(*this);
+    self.d->template relation_attachment<Tag>().edit(std::forward<Args>(args)...);
+    return self;
+}
+template <typename Endpoint, typename Base> template <typename Tag, typename Fn> requires Buildable_Relation<Tag, Endpoint, Fn>
+typename Endpoint::Builder& Relation_Builder_API<Endpoint, Base>::relation(Fn&& fn) {
+    auto& builder = static_cast<typename Endpoint::Builder&>(*this);
+    this->model().d->template relation_attachment<Tag>().internal.build(std::forward<Fn>(fn));
+    return builder;
+}
+template <typename Endpoint, typename Base> template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint>
+auto& Relation_Private_API<Endpoint, Base>::relation_attachment() noexcept { return this->template attachment<Tag>(); }
+template <typename Endpoint, typename Base> template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint>
+auto& Relation_Private_API<Endpoint, Base>::relation() noexcept { return this->template attachment<Tag>().internal.relation(); }
+template <typename Endpoint, typename Base> template <typename Tag> requires Relation_Model_Tag<Tag, Endpoint>
+void Relation_Private_API<Endpoint, Base>::commit() { this->template attachment<Tag>().internal.commit(); }
+} // namespace aethera::detail
diff --git a/kernel/kernel/include/relation/Dag.hpp b/kernel/kernel/include/relation/dag/Dag_Relation.hpp
similarity index 64%
rename from kernel/kernel/include/relation/Dag.hpp
rename to kernel/kernel/include/relation/dag/Dag_Relation.hpp
index 80ad3d1..2eda547 100644
--- a/kernel/kernel/include/relation/Dag.hpp
+++ b/kernel/kernel/include/relation/dag/Dag_Relation.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include "../global.hpp"
+#include "../../global.hpp"
 #include <cstdint>
 #include <expected>
 #include <functional>
@@ -12,47 +12,39 @@ struct Dag_Node_Id {
     std::uint64_t value{}; /* 一张 DAG 内的稳定节点标识；0 表示未分配。 */
 };
 
-enum struct Build_Dag_Result : std::uint8_t {
-    invalid_node_id,
-    node_object_missing,
-    duplicate_node_id,
-    node_not_found,
-    dependency_cycle
-};
-
-enum struct Edit_Dag_Result : std::uint8_t {
-    invalid_node_id,
-    node_object_missing,
-    duplicate_node_id,
-    node_not_found,
-    dependency_cycle
+enum struct Dag_Result : std::uint8_t {
+    invalid_node_id,     /* 节点标识为保留值 0。 */
+    node_object_missing, /* 节点没有承载有效对象。 */
+    duplicate_node_id,   /* 同一张图中出现重复节点标识。 */
+    node_not_found,      /* 依赖或编辑命令引用了不存在的节点。 */
+    dependency_cycle     /* 依赖边形成环。 */
 };
 
 /* 拥有节点 proxy 和实例级依赖边的完整 DAG 定义；proxy 的实际持有对象由使用方决定。 */
 template <typename Node_Facade>
-struct Dag {
+struct Dag_Relation {
     struct Builder;
     struct Editor;
-    Dag();
-    ~Dag();
-    Dag(Dag&&) noexcept;
-    Dag& operator=(Dag&&) noexcept;
-    Dag(const Dag&) = delete;
-    Dag& operator=(const Dag&) = delete;
+    Dag_Relation();
+    ~Dag_Relation();
+    Dag_Relation(Dag_Relation&&) noexcept;
+    Dag_Relation& operator=(Dag_Relation&&) noexcept;
+    Dag_Relation(const Dag_Relation&) = delete;
+    Dag_Relation& operator=(const Dag_Relation&) = delete;
     /* 按 DAG 拓扑顺序访问节点；回调期间不得修改本图。 */
     template <typename Callback> void for_each_topological(Callback&& callback);
     /* 逐条访问 target 依赖 source 的直接依赖边；回调期间不得修改本图。 */
     template <typename Callback> void for_each_dependency(Callback&& callback) const;
 private:
     template <typename>
-    friend struct Owned_Dag;
+    friend struct Owned_Dag_Relation;
     struct Private;
     std::unique_ptr<Private> d; /* 唯一拥有公共节点对象 proxy、依赖边和组合子图。 */
 };
 
 /* 构建期间允许中间拓扑无效；build() 对最终完整 DAG 统一验证。 */
 template <typename Node_Facade>
-struct Dag<Node_Facade>::Builder {
+struct Dag_Relation<Node_Facade>::Builder {
     Builder();
     ~Builder();
     Builder(Builder&&) noexcept;
@@ -63,8 +55,8 @@ struct Dag<Node_Facade>::Builder {
     Builder& remove(Dag_Node_Id id);
     Builder& add_dependency(Dag_Node_Id target, Dag_Node_Id source);
     Builder& remove_dependency(Dag_Node_Id target, Dag_Node_Id source);
-    Builder& compose(Dag graph);
-    auto build() -> std::expected<Dag, Build_Dag_Result>;
+    Builder& compose(Dag_Relation graph);
+    auto build() -> std::expected<Dag_Relation, Dag_Result>;
 private:
     struct Private;
     std::unique_ptr<Private> d; /* 唯一拥有尚未发布的整体构图事务。 */
@@ -72,42 +64,42 @@ private:
 
 /* Editor 只记录一次运行时事务；回调退出前不会修改正在执行的权威 DAG。 */
 template <typename Node_Facade>
-struct Dag<Node_Facade>::Editor {
+struct Dag_Relation<Node_Facade>::Editor {
     void add(Dag_Node_Id id, proxy<Node_Facade> object);
     void remove(Dag_Node_Id id);
     void add_dependency(Dag_Node_Id target, Dag_Node_Id source);
     void remove_dependency(Dag_Node_Id target, Dag_Node_Id source);
-    void compose(Dag graph);
+    void compose(Dag_Relation graph);
 private:
     template <typename>
-    friend struct Owned_Dag;
+    friend struct Owned_Dag_Relation;
     struct Private;
     Editor();
     std::unique_ptr<Private> d; /* 唯一拥有本次命令事务；编辑回调返回后立即失效。 */
 };
 
-/* Model 可注册的拥有型 DAG storage；内部 advance 在所有者安全点验证并提交待处理事务。 */
+/* Model 可注册的拥有型 DAG 关系；内部 commit 在所有者安全点验证并提交待处理事务。 */
 template <typename Node_Facade>
-struct Owned_Dag {
-    using Graph = Dag<Node_Facade>;
+struct Owned_Dag_Relation {
+    using Graph = Dag_Relation<Node_Facade>;
     using Edit = std::move_only_function<void(typename Graph::Editor&)>;
-    using Edit_Completion = std::move_only_function<void(std::expected<void, Edit_Dag_Result>)>;
-    void set(Graph graph);
-    void set(Edit edit, Edit_Completion completion = {});
+    using Edit_Completion = std::move_only_function<void(std::expected<void, Dag_Result>)>;
+    void edit(Graph graph);
+    void edit(Edit edit, Edit_Completion completion = {});
     struct Internal {
         Internal();
         ~Internal();
         Internal(const Internal&) = delete;
         Internal& operator=(const Internal&) = delete;
-        Graph& use();
-        void advance();
-        template <typename Fn> void builder_set(Fn&& fn);
+        Graph& relation();
+        void commit();
+        template <typename Fn> void build(Fn&& fn);
     private:
-        friend struct Owned_Dag;
+        friend struct Owned_Dag_Relation;
         struct Private;
         std::unique_ptr<Private> d; /* 唯一拥有权威 DAG 与待执行事务队列。 */
     };
-    Internal internal{}; /* 仅关系所有者的内部执行线程可调用 use/advance。 */
+    Internal internal{}; /* 仅关系所有者的内部执行线程可调用 relation/commit。 */
 };
 } // namespace aethera
-#include "Dag.ipp"
+#include "Dag_Relation.ipp"
diff --git a/kernel/kernel/include/relation/Dag.ipp b/kernel/kernel/include/relation/dag/Dag_Relation.ipp
similarity index 71%
rename from kernel/kernel/include/relation/Dag.ipp
rename to kernel/kernel/include/relation/dag/Dag_Relation.ipp
index f61ab21..6d5c6e5 100644
--- a/kernel/kernel/include/relation/Dag.ipp
+++ b/kernel/kernel/include/relation/dag/Dag_Relation.ipp
@@ -21,20 +21,20 @@ struct Dag_Edge {
 };
 inline bool same_dag_id(Dag_Node_Id left, Dag_Node_Id right) noexcept { return left.value == right.value; }
 inline bool same_dag_edge(const Dag_Edge& left, const Dag_Edge& right) noexcept { return same_dag_id(left.target, right.target) && same_dag_id(left.source, right.source); }
-template <typename Node_Facade> auto dag_topological_indices(const std::vector<Dag_Node<Node_Facade>>& nodes, const std::vector<Dag_Edge>& edges) -> std::expected<std::vector<std::size_t>, Build_Dag_Result> {
+template <typename Node_Facade> auto dag_topological_indices(const std::vector<Dag_Node<Node_Facade>>& nodes, const std::vector<Dag_Edge>& edges) -> std::expected<std::vector<std::size_t>, Dag_Result> {
     std::unordered_map<std::uint64_t, std::size_t> indices;
     indices.reserve(nodes.size());
     for (std::size_t index{}; index < nodes.size(); ++index) {
-        if (nodes[index].id.value == 0) return std::unexpected(Build_Dag_Result::invalid_node_id);
-        if (!nodes[index].object) return std::unexpected(Build_Dag_Result::node_object_missing);
-        if (!indices.emplace(nodes[index].id.value, index).second) return std::unexpected(Build_Dag_Result::duplicate_node_id);
+        if (nodes[index].id.value == 0) return std::unexpected(Dag_Result::invalid_node_id);
+        if (!nodes[index].object) return std::unexpected(Dag_Result::node_object_missing);
+        if (!indices.emplace(nodes[index].id.value, index).second) return std::unexpected(Dag_Result::duplicate_node_id);
     }
     std::vector<std::size_t> indegrees(nodes.size());
     std::vector<std::vector<std::size_t>> dependents(nodes.size());
     for (const auto& edge : edges) {
         const auto target = indices.find(edge.target.value);
         const auto source = indices.find(edge.source.value);
-        if (target == indices.end() || source == indices.end()) return std::unexpected(Build_Dag_Result::node_not_found);
+        if (target == indices.end() || source == indices.end()) return std::unexpected(Dag_Result::node_not_found);
         ++indegrees[target->second];
         dependents[source->second].push_back(target->second);
     }
@@ -48,106 +48,96 @@ template <typename Node_Facade> auto dag_topological_indices(const std::vector<D
         order.push_back(index);
         for (const auto dependent : dependents[index]) if (--indegrees[dependent] == 0) ready.push_back(dependent);
     }
-    if (order.size() != nodes.size()) return std::unexpected(Build_Dag_Result::dependency_cycle);
+    if (order.size() != nodes.size()) return std::unexpected(Dag_Result::dependency_cycle);
     return order;
 }
-inline auto edit_result(Build_Dag_Result result) noexcept -> Edit_Dag_Result {
-    switch (result) {
-    case Build_Dag_Result::invalid_node_id: return Edit_Dag_Result::invalid_node_id;
-    case Build_Dag_Result::node_object_missing: return Edit_Dag_Result::node_object_missing;
-    case Build_Dag_Result::duplicate_node_id: return Edit_Dag_Result::duplicate_node_id;
-    case Build_Dag_Result::node_not_found: return Edit_Dag_Result::node_not_found;
-    case Build_Dag_Result::dependency_cycle: return Edit_Dag_Result::dependency_cycle;
-    }
-    std::terminate();
-}
 } // namespace detail
 
-template <typename Node_Facade> struct Dag<Node_Facade>::Private {
+template <typename Node_Facade> struct Dag_Relation<Node_Facade>::Private {
     std::vector<detail::Dag_Node<Node_Facade>> nodes; /* 按插入顺序保存唯一拥有的节点对象。 */
     std::vector<detail::Dag_Edge> edges;              /* 直接依赖边；拓扑顺序由此即时计算。 */
 };
-template <typename Node_Facade> Dag<Node_Facade>::Dag() : d(std::make_unique<Private>()) {}
-template <typename Node_Facade> Dag<Node_Facade>::~Dag() = default;
-template <typename Node_Facade> Dag<Node_Facade>::Dag(Dag&&) noexcept = default;
-template <typename Node_Facade> auto Dag<Node_Facade>::operator=(Dag&&) noexcept -> Dag& = default;
-template <typename Node_Facade> template <typename Callback> void Dag<Node_Facade>::for_each_topological(Callback&& callback) {
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Dag_Relation() : d(std::make_unique<Private>()) {}
+template <typename Node_Facade> Dag_Relation<Node_Facade>::~Dag_Relation() = default;
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Dag_Relation(Dag_Relation&&) noexcept = default;
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::operator=(Dag_Relation&&) noexcept -> Dag_Relation& = default;
+template <typename Node_Facade> template <typename Callback> void Dag_Relation<Node_Facade>::for_each_topological(Callback&& callback) {
     const auto order = detail::dag_topological_indices(d->nodes, d->edges);
     if (!order) Failure_Policy::handle_unknown_failure(std::make_exception_ptr(std::logic_error("authoritative DAG is invalid")));
     for (const auto index : *order) std::invoke(callback, d->nodes[index].id, d->nodes[index].object);
 }
-template <typename Node_Facade> template <typename Callback> void Dag<Node_Facade>::for_each_dependency(Callback&& callback) const { for (const auto& edge : d->edges) std::invoke(callback, edge.target, edge.source); }
+template <typename Node_Facade> template <typename Callback> void Dag_Relation<Node_Facade>::for_each_dependency(Callback&& callback) const { for (const auto& edge : d->edges) std::invoke(callback, edge.target, edge.source); }
 
-template <typename Node_Facade> struct Dag<Node_Facade>::Builder::Private {
-    Dag graph{}; /* 唯一拥有构造期尚未发布的完整 DAG。 */
+template <typename Node_Facade> struct Dag_Relation<Node_Facade>::Builder::Private {
+    Dag_Relation graph{}; /* 唯一拥有构造期尚未发布的完整 DAG。 */
 };
-template <typename Node_Facade> Dag<Node_Facade>::Builder::Builder() : d(std::make_unique<Private>()) {}
-template <typename Node_Facade> Dag<Node_Facade>::Builder::~Builder() = default;
-template <typename Node_Facade> Dag<Node_Facade>::Builder::Builder(Builder&&) noexcept = default;
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::operator=(Builder&&) noexcept -> Builder& = default;
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::add(Dag_Node_Id id, proxy<Node_Facade> object) -> Builder& { d->graph.d->nodes.push_back({id, std::move(object)}); return *this; }
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::remove(Dag_Node_Id id) -> Builder& {
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Builder::Builder() : d(std::make_unique<Private>()) {}
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Builder::~Builder() = default;
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Builder::Builder(Builder&&) noexcept = default;
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::operator=(Builder&&) noexcept -> Builder& = default;
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::add(Dag_Node_Id id, proxy<Node_Facade> object) -> Builder& { d->graph.d->nodes.push_back({id, std::move(object)}); return *this; }
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::remove(Dag_Node_Id id) -> Builder& {
     std::erase_if(d->graph.d->nodes, [&](const auto& node) { return detail::same_dag_id(node.id, id); });
     std::erase_if(d->graph.d->edges, [&](const auto& edge) { return detail::same_dag_id(edge.target, id) || detail::same_dag_id(edge.source, id); });
     return *this;
 }
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::add_dependency(Dag_Node_Id target, Dag_Node_Id source) -> Builder& {
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::add_dependency(Dag_Node_Id target, Dag_Node_Id source) -> Builder& {
     const detail::Dag_Edge edge{target, source};
     if (std::ranges::none_of(d->graph.d->edges, [&](const auto& current) { return detail::same_dag_edge(current, edge); })) d->graph.d->edges.push_back(edge);
     return *this;
 }
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::remove_dependency(Dag_Node_Id target, Dag_Node_Id source) -> Builder& {
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::remove_dependency(Dag_Node_Id target, Dag_Node_Id source) -> Builder& {
     const detail::Dag_Edge edge{target, source};
     std::erase_if(d->graph.d->edges, [&](const auto& current) { return detail::same_dag_edge(current, edge); });
     return *this;
 }
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::compose(Dag graph) -> Builder& {
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::compose(Dag_Relation graph) -> Builder& {
     for (auto& node : graph.d->nodes) d->graph.d->nodes.push_back(std::move(node));
     d->graph.d->edges.insert(d->graph.d->edges.end(), graph.d->edges.begin(), graph.d->edges.end());
     graph.d->nodes.clear();
     graph.d->edges.clear();
     return *this;
 }
-template <typename Node_Facade> auto Dag<Node_Facade>::Builder::build() -> std::expected<Dag, Build_Dag_Result> {
+template <typename Node_Facade> auto Dag_Relation<Node_Facade>::Builder::build() -> std::expected<Dag_Relation, Dag_Result> {
     const auto order = detail::dag_topological_indices(d->graph.d->nodes, d->graph.d->edges);
     if (!order) return std::unexpected(order.error());
     return std::move(d->graph);
 }
 
-template <typename Node_Facade> struct Dag<Node_Facade>::Editor::Private {
+template <typename Node_Facade> struct Dag_Relation<Node_Facade>::Editor::Private {
     struct Add { Dag_Node_Id id{}; proxy<Node_Facade> object{}; };
     struct Remove { Dag_Node_Id id{}; };
     struct Add_Dependency { Dag_Node_Id target{}; Dag_Node_Id source{}; };
     struct Remove_Dependency { Dag_Node_Id target{}; Dag_Node_Id source{}; };
-    struct Compose { Dag graph{}; };
+    struct Compose { Dag_Relation graph{}; };
     using Command = std::variant<Add, Remove, Add_Dependency, Remove_Dependency, Compose>;
     std::vector<Command> commands; /* 编辑回调期间唯一拥有的顺序命令事务。 */
 };
-template <typename Node_Facade> Dag<Node_Facade>::Editor::Editor() : d(std::make_unique<Private>()) {}
-template <typename Node_Facade> void Dag<Node_Facade>::Editor::add(Dag_Node_Id id, proxy<Node_Facade> object) { d->commands.emplace_back(typename Private::Add{id, std::move(object)}); }
-template <typename Node_Facade> void Dag<Node_Facade>::Editor::remove(Dag_Node_Id id) { d->commands.emplace_back(typename Private::Remove{id}); }
-template <typename Node_Facade> void Dag<Node_Facade>::Editor::add_dependency(Dag_Node_Id target, Dag_Node_Id source) { d->commands.emplace_back(typename Private::Add_Dependency{target, source}); }
-template <typename Node_Facade> void Dag<Node_Facade>::Editor::remove_dependency(Dag_Node_Id target, Dag_Node_Id source) { d->commands.emplace_back(typename Private::Remove_Dependency{target, source}); }
-template <typename Node_Facade> void Dag<Node_Facade>::Editor::compose(Dag graph) { d->commands.emplace_back(typename Private::Compose{std::move(graph)}); }
+template <typename Node_Facade> Dag_Relation<Node_Facade>::Editor::Editor() : d(std::make_unique<Private>()) {}
+template <typename Node_Facade> void Dag_Relation<Node_Facade>::Editor::add(Dag_Node_Id id, proxy<Node_Facade> object) { d->commands.emplace_back(typename Private::Add{id, std::move(object)}); }
+template <typename Node_Facade> void Dag_Relation<Node_Facade>::Editor::remove(Dag_Node_Id id) { d->commands.emplace_back(typename Private::Remove{id}); }
+template <typename Node_Facade> void Dag_Relation<Node_Facade>::Editor::add_dependency(Dag_Node_Id target, Dag_Node_Id source) { d->commands.emplace_back(typename Private::Add_Dependency{target, source}); }
+template <typename Node_Facade> void Dag_Relation<Node_Facade>::Editor::remove_dependency(Dag_Node_Id target, Dag_Node_Id source) { d->commands.emplace_back(typename Private::Remove_Dependency{target, source}); }
+template <typename Node_Facade> void Dag_Relation<Node_Facade>::Editor::compose(Dag_Relation graph) { d->commands.emplace_back(typename Private::Compose{std::move(graph)}); }
 
-template <typename Node_Facade> struct Owned_Dag<Node_Facade>::Internal::Private {
+template <typename Node_Facade> struct Owned_Dag_Relation<Node_Facade>::Internal::Private {
     using Deferred_Command = std::move_only_function<void(Graph&)>;
     Graph graph{};                                      /* Scene 内部线程使用的唯一权威 DAG。 */
     moodycamel::ConcurrentQueue<Deferred_Command> queue; /* 外部生产、内部安全点消费的异步命令队列。 */
 };
-template <typename Node_Facade> Owned_Dag<Node_Facade>::Internal::Internal() : d(std::make_unique<Private>()) {}
-template <typename Node_Facade> Owned_Dag<Node_Facade>::Internal::~Internal() = default;
-template <typename Node_Facade> auto Owned_Dag<Node_Facade>::Internal::use() -> Graph& { return d->graph; }
-template <typename Node_Facade> template <typename Fn> void Owned_Dag<Node_Facade>::Internal::builder_set(Fn&& fn) { std::invoke(std::forward<Fn>(fn), d->graph); }
-template <typename Node_Facade> void Owned_Dag<Node_Facade>::Internal::advance() {
+template <typename Node_Facade> Owned_Dag_Relation<Node_Facade>::Internal::Internal() : d(std::make_unique<Private>()) {}
+template <typename Node_Facade> Owned_Dag_Relation<Node_Facade>::Internal::~Internal() = default;
+template <typename Node_Facade> auto Owned_Dag_Relation<Node_Facade>::Internal::relation() -> Graph& { return d->graph; }
+template <typename Node_Facade> template <typename Fn> void Owned_Dag_Relation<Node_Facade>::Internal::build(Fn&& fn) { std::invoke(std::forward<Fn>(fn), d->graph); }
+template <typename Node_Facade> void Owned_Dag_Relation<Node_Facade>::Internal::commit() {
     typename Private::Deferred_Command command;
     while (d->queue.try_dequeue(command)) command(d->graph);
 }
-template <typename Node_Facade> void Owned_Dag<Node_Facade>::set(Graph graph) {
+template <typename Node_Facade> void Owned_Dag_Relation<Node_Facade>::edit(Graph graph) {
     typename Internal::Private::Deferred_Command command = [graph = std::move(graph)](Graph& current) mutable { current = std::move(graph); };
     if (!internal.d->queue.enqueue(std::move(command))) Failure_Policy::handle_unknown_failure(std::make_exception_ptr(std::bad_alloc{}));
 }
-template <typename Node_Facade> void Owned_Dag<Node_Facade>::set(Edit edit, Edit_Completion completion) {
+template <typename Node_Facade> void Owned_Dag_Relation<Node_Facade>::edit(Edit edit, Edit_Completion completion) {
     typename Internal::Private::Deferred_Command command = [edit = std::move(edit), completion = std::move(completion)](Graph& current) mutable {
         typename Graph::Editor editor;
         edit(editor);
@@ -193,7 +183,7 @@ template <typename Node_Facade> void Owned_Dag<Node_Facade>::set(Edit edit, Edit
         };
         bool transaction_open{true};
         try {
-            std::optional<Edit_Dag_Result> edit_error;
+            std::optional<Dag_Result> edit_error;
             for (auto& edit_command : editor.d->commands) {
                 std::visit([&](auto& operation) {
                 using Operation = std::remove_cvref_t<decltype(operation)>;
@@ -204,7 +194,7 @@ template <typename Node_Facade> void Owned_Dag<Node_Facade>::set(Edit edit, Edit
                 else if constexpr (std::same_as<Operation, typename Graph::Editor::Private::Remove>) {
                     const auto found = std::ranges::find_if(current.d->nodes, [&](const auto& node) { return detail::same_dag_id(node.id, operation.id); });
                     if (found == current.d->nodes.end()) {
-                        edit_error = Edit_Dag_Result::node_not_found;
+                        edit_error = Dag_Result::node_not_found;
                         return;
                     }
                     Undo_Remove inverse;
@@ -250,7 +240,7 @@ template <typename Node_Facade> void Owned_Dag<Node_Facade>::set(Edit edit, Edit
             if (!validation) {
                 rollback();
                 transaction_open = false;
-                if (completion) completion(std::unexpected(detail::edit_result(validation.error())));
+                if (completion) completion(std::unexpected(validation.error()));
                 return;
             }
             transaction_open = false;
diff --git a/kernel/kernel/include/relation/design.md b/kernel/kernel/include/relation/design.md
new file mode 100644
index 0000000..2acfe6e
--- /dev/null
+++ b/kernel/kernel/include/relation/design.md
@@ -0,0 +1,14 @@
+# 关系结构设计
+
+关系结构与并发结构是同级协议，不共享 `set/get/advance` 语义。`Relation_Registration<Relation, Tags...>` 负责把一种关系实现连续注册给一个或多个 Tag，并提供三组按需组合的能力：实体侧事务 `edit<Tag>(...)`、Builder 侧 `relation<Tag>(...)` 初始化，以及 Private 侧 `relation<Tag>()/commit<Tag>()`。
+
+`Relation_Attachment` 是关系实现的约束。实现必须提供权威 `Graph`、事务 `Edit`、事务完成回调，以及内部 `relation()`、`commit()`、`build(...)`。新关系类型只要满足该协议即可注册，不需要修改 `Model`。
+
+`dag/Dag_Relation.hpp` 是 DAG 这一种具体关系实现：
+
+- `Dag_Relation<Node_Facade>` 唯一拥有节点 proxy 和依赖边，拓扑顺序按权威关系即时计算。
+- `Dag_Relation::Builder` 负责构建期整体校验。
+- `Dag_Relation::Editor` 只记录单次事务命令。
+- `Owned_Dag_Relation<Node_Facade>` 接收外部事务，并由关系所有者在安全点调用 `commit()` 验证和提交。
+
+关系模块不提供同步等待、事件或快照。编辑完成回调在调用 `commit()` 的内部线程执行；调用方不得把它当成跨线程异常传播边界。
diff --git a/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp b/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
index 6a64600..88c9404 100644
--- a/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
+++ b/kernel/kernel/module/frame_policy/src/Frame_Policy.hpp
@@ -1,7 +1,8 @@
 #pragma once
 #include "../export/export.h"
 #include "scene/export/export.h"
-#include "concurrent/base/Concurrent_Struct.hpp"
+#include "concurrent/Concurrent_Registration.hpp"
+#include "concurrent/dirty/Dirty.hpp"
 #include "model/Model.hpp"
 #include "statistics/Sliding_Statistics.hpp"
 #include <chrono>
@@ -10,7 +11,7 @@
 #include <expected>
 #include <optional>
 namespace aethera {
-struct Frame_Policy : Def<Frame_Policy, Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
+struct Frame_Policy : Def<Frame_Policy, Root, Concurrent_Registration<Dirty_Import_Struct_Concurrent, Prop_Tag>, Concurrent_Registration<Export_Struct_Concurrent, State_Tag>> {
     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/Throttled_Latest_Only.cpp b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
index c4ffe68..a3b8c54 100644
--- a/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
+++ b/kernel/kernel/module/frame_policy/src/Throttled_Latest_Only.cpp
@@ -69,10 +69,10 @@ auto Throttled_Latest_only::Private::prepare_start() -> std::expected<std::chron
         if (phase != Phase::starting) {
             std::terminate();
         }
-        auto& properties_storage = get<Prop_Tag>();
+        auto& properties_storage = concurrent<Prop_Tag>();
         properties_storage.internal.advance();
         const Prop& properties = *properties_storage.internal.use();
-        auto& state = *get<State_Tag>().internal.use();
+        auto& state = *concurrent<State_Tag>().internal.use();
         const auto interval = begin_run(properties, state);
         publish_state();
         if (!interval) {
@@ -178,10 +178,10 @@ void Throttled_Latest_only::Private::frame_due() {
         if (phase != Phase::running || !timer_id) {
             return;
         }
-        auto& properties_storage = get<Prop_Tag>();
+        auto& properties_storage = concurrent<Prop_Tag>();
         properties_storage.internal.advance();
         const Prop& properties = *properties_storage.internal.use();
-        auto& state = *get<State_Tag>().internal.use();
+        auto& state = *concurrent<State_Tag>().internal.use();
         const auto refreshed_interval = refresh_run(properties, state);
         if (refreshed_interval) {
             interval = *refreshed_interval;
@@ -230,7 +230,7 @@ void Throttled_Latest_only::Private::frame_due() {
 }
 void Throttled_Latest_only::Private::record_render_submission(scene::Render_Result result) {
     std::lock_guard lock(mutex);
-    auto& state = *get<State_Tag>().internal.use();
+    auto& state = *concurrent<State_Tag>().internal.use();
     if (result) state.render_submission_error.reset();
     else {
         const bool impossible = std::visit([](auto error) {
@@ -256,8 +256,8 @@ void Throttled_Latest_only::Private::rendered(std::size_t slot_index, proxy<scen
             std::terminate();
         }
         const auto render_end = std::chrono::steady_clock::now();
-        const Prop& properties = *get<Prop_Tag>().internal.use();
-        auto& state = *get<State_Tag>().internal.use();
+        const Prop& properties = *concurrent<Prop_Tag>().internal.use();
+        auto& state = *concurrent<State_Tag>().internal.use();
         record_render(positive_duration(render_end - slot.render_start), properties, state);
         if (phase != Phase::running) {
             slot.phase = Frame_Phase::idle;
@@ -313,8 +313,8 @@ void Throttled_Latest_only::Private::sent(std::size_t slot_index, proxy<scene::F
             std::terminate();
         }
         const auto send_end = std::chrono::steady_clock::now();
-        const Prop& properties = *get<Prop_Tag>().internal.use();
-        auto& state = *get<State_Tag>().internal.use();
+        const Prop& properties = *concurrent<Prop_Tag>().internal.use();
+        auto& state = *concurrent<State_Tag>().internal.use();
         record_send(positive_duration(send_end - slot.send_start), positive_duration(send_end - slot.render_start), properties, state);
         slot.phase = Frame_Phase::idle;
         if (phase == Phase::running) {
@@ -385,7 +385,7 @@ void Throttled_Latest_only::Private::finish_stop_if_ready() {
     }
 }
 void Throttled_Latest_only::Private::publish_state() {
-    get<State_Tag>().internal.advance();
+    concurrent<State_Tag>().internal.advance();
 }
 bool Throttled_Latest_only::Private::destructible() const noexcept {
     std::lock_guard lock(mutex);
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 1ee03b3..6f5309d 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
@@ -169,11 +169,11 @@ std::unique_ptr<aethera::Throttled_Latest_only> make_policy(const std::shared_pt
     auto sink = aethera::make_model_proxy<aethera::frame_policy::Sink, Test_Sink>(control);
     aethera::Throttled_Latest_only::Builder builder(std::move(timer_service), std::move(scene), std::move(sink));
     builder
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, user_frames_per_second)
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::render_rate_limit_enabled, render_rate_limit_enabled)
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::send_rate_limit_enabled, send_rate_limit_enabled)
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::statistics_enabled, statistics_enabled)
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::statistics_window_size, statistics_window_size);
+        .set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, user_frames_per_second)
+        .set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::render_rate_limit_enabled, render_rate_limit_enabled)
+        .set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::send_rate_limit_enabled, send_rate_limit_enabled)
+        .set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::statistics_enabled, statistics_enabled)
+        .set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::statistics_window_size, statistics_window_size);
     return builder.build();
 }
 
@@ -183,10 +183,10 @@ TEST(Throttled_Latest_Only, Publishes_And_Clears_Scene_Submission_Failure) {
     ASSERT_TRUE(policy->start().has_value());
     control->render_result = std::unexpected(aethera::scene::Render_Error{aethera::Run_Taskflow_Result::runtime_not_initialized});
     control->fire_timer();
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { ASSERT_TRUE(state.render_submission_error.has_value()); EXPECT_EQ(std::get<aethera::Run_Taskflow_Result>(*state.render_submission_error), aethera::Run_Taskflow_Result::runtime_not_initialized); });
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { ASSERT_TRUE(state.render_submission_error.has_value()); EXPECT_EQ(std::get<aethera::Run_Taskflow_Result>(*state.render_submission_error), aethera::Run_Taskflow_Result::runtime_not_initialized); });
     control->render_result = aethera::scene::Render_Result{};
     control->fire_timer();
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { EXPECT_FALSE(state.render_submission_error.has_value()); });
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { EXPECT_FALSE(state.render_submission_error.has_value()); });
     control->complete_render();
     bool stopped{};
     ASSERT_TRUE(policy->stop([&] { stopped = true; }).has_value());
@@ -245,7 +245,7 @@ TEST(Throttled_Latest_Only, Keeps_One_Render_In_Flight_And_Drops_Overlapping_Tic
         control->complete_send();
     }
 
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         EXPECT_EQ(state.timer_ticks, 6);
         EXPECT_EQ(state.dropped_timer_ticks, 4);
         EXPECT_EQ(state.completed_frames, 2);
@@ -278,7 +278,7 @@ TEST(Throttled_Latest_Only, Stop_Drains_All_Frame_Borrows) {
     control->complete_render();
     EXPECT_TRUE(stopped);
     EXPECT_EQ(control->frames_alive, 0);
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         EXPECT_EQ(state.timer_ticks, 2);
         EXPECT_EQ(state.completed_frames, 0);
     });
@@ -288,26 +288,26 @@ TEST(Throttled_Latest_Only, Advances_Properties_And_Recovers_From_Invalid_Dynami
     auto control = std::make_shared<Frame_Policy_Test_Control>();
     auto policy = make_policy(control);
     ASSERT_TRUE(policy->start());
-    policy->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{120.0});
+    policy->set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{120.0});
     control->fire_timer();
     EXPECT_EQ(control->rescheduled_interval, 8333334ns);
     control->complete_render();
     control->complete_send();
 
-    policy->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{0.0});
+    policy->set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{0.0});
     const auto render_calls_before_invalid_tick = control->render_calls;
     control->fire_timer();
     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) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         ASSERT_TRUE(state.configuration_error);
         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});
+    policy->set<aethera::Prop_Tag>(&aethera::Throttled_Latest_only::Prop::user_frames_per_second, std::optional<double>{20.0});
     control->fire_timer();
     EXPECT_EQ(control->rescheduled_interval, 50ms);
     EXPECT_EQ(control->render_calls, render_calls_before_invalid_tick + 1);
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { EXPECT_FALSE(state.configuration_error); });
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) { EXPECT_FALSE(state.configuration_error); });
     control->complete_render();
     control->complete_send();
 
@@ -352,7 +352,7 @@ TEST(Throttled_Latest_Only, Defaults_To_Thirty_Frames_Per_Second) {
     EXPECT_EQ(control->rescheduled_interval, 33333334ns);
     control->complete_render();
     control->complete_send();
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         EXPECT_DOUBLE_EQ(state.effective_frames_per_second, 30.0);
         EXPECT_FALSE(state.render_capacity_fps.has_value());
         EXPECT_FALSE(state.send_capacity_fps.has_value());
@@ -378,7 +378,7 @@ TEST(Throttled_Latest_Only, Combines_Optional_Adaptive_Rate_Limits) {
     control->complete_send();
     control->fire_timer();
 
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         ASSERT_TRUE(state.render_capacity_fps.has_value());
         ASSERT_TRUE(state.send_capacity_fps.has_value());
         EXPECT_DOUBLE_EQ(state.effective_frames_per_second, std::min(*state.render_capacity_fps, *state.send_capacity_fps));
@@ -406,7 +406,7 @@ TEST(Throttled_Latest_Only, Publishes_Optional_Sliding_Statistics) {
     control->fire_timer();
     control->fire_timer();
 
-    policy->get<aethera::Export_Struct, aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
+    policy->get<aethera::State_Tag>([](const aethera::Throttled_Latest_only::State& state) {
         EXPECT_EQ(state.timer_ticks, 3);
         EXPECT_EQ(state.dropped_timer_ticks, 0);
         EXPECT_EQ(state.completed_frames, 3);
diff --git a/kernel/kernel/module/scene/src/Scene.cpp b/kernel/kernel/module/scene/src/Scene.cpp
index e645b9f..9305773 100644
--- a/kernel/kernel/module/scene/src/Scene.cpp
+++ b/kernel/kernel/module/scene/src/Scene.cpp
@@ -18,7 +18,7 @@ proxy<scene::Task_Graph>& Scene::Private::taskflow() {
 auto Scene::Private::create_taskflow() -> std::expected<proxy<scene::Task_Graph>, Create_Taskflow_Error> {
     auto result = scene::make_task_graph("scene.renderables");
     std::unordered_map<std::uint64_t, proxy<task_flow::Task_Node>> nodes;
-    auto& renderables = get<Scene>().internal.use();
+    auto& renderables = relation<scene::Renderable>();
     std::optional<Create_Taskflow_Error> error;
     renderables.for_each_topological([&](Dag_Node_Id id, proxy<scene::Renderable>& renderable) {
         if (error) return;
@@ -39,9 +39,9 @@ auto Scene::Private::create_taskflow() -> std::expected<proxy<scene::Task_Graph>
     return result;
 }
 auto Scene::Private::advance() -> std::expected<void, Create_Taskflow_Error> {
-    auto& renderables = get<Scene>();
-    renderables.internal.advance();
-    renderables.internal.use().for_each_topological([](Dag_Node_Id, proxy<scene::Renderable>& renderable) {
+    commit<scene::Renderable>();
+    auto& renderables = relation<scene::Renderable>();
+    renderables.for_each_topological([](Dag_Node_Id, proxy<scene::Renderable>& renderable) {
         renderable->advance();
     });
     auto next_graph = create_taskflow();
diff --git a/kernel/kernel/module/scene/src/Scene.hpp b/kernel/kernel/module/scene/src/Scene.hpp
index 29766b4..ddc1c95 100644
--- a/kernel/kernel/module/scene/src/Scene.hpp
+++ b/kernel/kernel/module/scene/src/Scene.hpp
@@ -1,13 +1,14 @@
 #pragma once
 #include "../export/export.h"
 #include "model/Model.hpp"
-#include "relation/Dag.hpp"
+#include "relation/dag/Dag_Relation.hpp"
+#include "relation/Relation_Registration.hpp"
 #include <functional>
 #include <proxy/proxy.h>
 #include "../rely_facade.h"
 namespace aethera {
-/* Scene 通过 Tag + Owned_Dag 在类型系统中表达其对 Renderable DAG 的唯一所有权。 */
-struct Scene : Def<Scene, Root, Storage_Registration<Scene, Owned_Dag, scene::Renderable>> {
+/* Scene 通过 Tag + Owned_Dag_Relation 在类型系统中表达其对 Renderable DAG 的唯一所有权。 */
+struct Scene : Def<Scene, Root, Relation_Registration<Owned_Dag_Relation, scene::Renderable>> {
     struct Private;
     Scene();
     ~Scene() noexcept;
diff --git a/kernel/kernel/module/scene/test/Scene_Tests.cpp b/kernel/kernel/module/scene/test/Scene_Tests.cpp
index bfe8d66..002d02e 100644
--- a/kernel/kernel/module/scene/test/Scene_Tests.cpp
+++ b/kernel/kernel/module/scene/test/Scene_Tests.cpp
@@ -20,7 +20,7 @@ struct Test_Dag_Renderable : aethera::Def<Test_Dag_Renderable, aethera::Renderab
 };
 TEST(Scene, Advances_Renderables_And_Composes_Task_Graph_In_Dag_Order) {
     auto advance_order = std::make_shared<std::vector<int>>();
-    aethera::Dag<aethera::scene::Renderable>::Builder builder;
+    aethera::Dag_Relation<aethera::scene::Renderable>::Builder builder;
     builder.add({2}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 2));
     builder.add({1}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 1));
     builder.add({3}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Dag_Renderable>(advance_order, 3));
@@ -30,47 +30,47 @@ TEST(Scene, Advances_Renderables_And_Composes_Task_Graph_In_Dag_Order) {
     ASSERT_TRUE(graph.has_value());
     auto scene = aethera::Scene::Builder{}.build();
     EXPECT_TRUE(scene->d->create_frame());
-    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    scene->edit<aethera::scene::Renderable>(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());
     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(); });
+    std::optional<aethera::Dag_Result> edit_error;
+    scene->edit<aethera::scene::Renderable>([](aethera::Dag_Relation<aethera::scene::Renderable>::Editor& editor) { editor.remove({99}); }, [&](std::expected<void, aethera::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(*edit_error, aethera::Dag_Result::node_not_found);
     EXPECT_EQ(*advance_order, (std::vector<int>{1, 2, 3}));
 }
 
 TEST(Scene, Dag_Rejects_Unallocated_Id_And_Missing_Object) {
-    aethera::Dag<aethera::scene::Renderable>::Builder invalid_id_builder;
+    aethera::Dag_Relation<aethera::scene::Renderable>::Builder invalid_id_builder;
     invalid_id_builder.add({0}, aethera::make_model_proxy<aethera::scene::Renderable, Test_Renderable>());
     const auto invalid_id = invalid_id_builder.build();
     ASSERT_FALSE(invalid_id.has_value());
-    EXPECT_EQ(invalid_id.error(), aethera::Build_Dag_Result::invalid_node_id);
-    aethera::Dag<aethera::scene::Renderable>::Builder missing_object_builder;
+    EXPECT_EQ(invalid_id.error(), aethera::Dag_Result::invalid_node_id);
+    aethera::Dag_Relation<aethera::scene::Renderable>::Builder missing_object_builder;
     missing_object_builder.add({1}, {});
     const auto missing_object = missing_object_builder.build();
     ASSERT_FALSE(missing_object.has_value());
-    EXPECT_EQ(missing_object.error(), aethera::Build_Dag_Result::node_object_missing);
+    EXPECT_EQ(missing_object.error(), aethera::Dag_Result::node_object_missing);
 }
 
 TEST(Scene, Owned_Dag_Rolls_Back_The_Whole_Invalid_Edit) {
     auto advance_order = std::make_shared<std::vector<int>>();
-    aethera::Dag<aethera::scene::Renderable>::Builder builder;
+    aethera::Dag_Relation<aethera::scene::Renderable>::Builder builder;
     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());
     auto scene = aethera::Scene::Builder{}.build();
-    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    scene->edit<aethera::scene::Renderable>(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(); });
+    std::optional<aethera::Dag_Result> edit_error;
+    scene->edit<aethera::scene::Renderable>([advance_order](aethera::Dag_Relation<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::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(*edit_error, aethera::Dag_Result::node_not_found);
     EXPECT_EQ(*advance_order, (std::vector<int>{1}));
 }
 
@@ -93,13 +93,13 @@ TEST(Scene, Render_Returns_Known_Submission_Result) {
 
 TEST(Scene, Rejects_The_Same_Renderable_Task_Graph_Twice) {
     auto renderable = Test_Renderable::Builder{}.build();
-    aethera::Dag<aethera::scene::Renderable>::Builder builder;
+    aethera::Dag_Relation<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));
     auto graph = builder.build();
     ASSERT_TRUE(graph.has_value());
     auto scene = aethera::Scene::Builder{}.build();
-    scene->set<aethera::Owned_Dag, aethera::Scene>(std::move(*graph));
+    scene->edit<aethera::scene::Renderable>(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);
diff --git a/kernel/kernel/test/concurrent/Concurrent_Storage_Interface_Tests.cpp b/kernel/kernel/test/concurrent/Concurrent_Storage_Interface_Tests.cpp
deleted file mode 100644
index 2d36f21..0000000
--- a/kernel/kernel/test/concurrent/Concurrent_Storage_Interface_Tests.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "concurrent/Concurrent_Advance.hpp"
-#include "concurrent/base/Concurrent_List.hpp"
-#include "concurrent/base/Concurrent_Struct.hpp"
-#include "concurrent/storage/Tagged_Storage.hpp"
-
-#include <gtest/gtest.h>
-#include <proxy/proxy.h>
-
-#include <concepts>
-#include <utility>
-#include <vector>
-
-namespace {
-
-struct Value {
-    int number{};
-};
-
-using List = std::vector<int>;
-
-struct Internal_Only_Storage {
-    struct Internal {
-        void advance();
-        Value* use();
-        template <typename Fn> void builder_set(Fn&& fn);
-    } internal;
-};
-
-static_assert(aethera::Concurrent_Storage<aethera::Export_Struct<Value>>);
-static_assert(aethera::Concurrent_Storage<aethera::Import_Struct<Value>>);
-static_assert(aethera::Concurrent_Storage<aethera::Import_List<List>>);
-static_assert(aethera::Concurrent_Storage<aethera::Export_List<List>>);
-static_assert(aethera::Concurrent_Storage<aethera::Readable_Import_Batch<List>>);
-static_assert(aethera::Internal_Storage<Internal_Only_Storage>);
-static_assert(!aethera::Concurrent_Storage<Internal_Only_Storage>);
-
-TEST(Concurrent_Storage_Interface, Internal_Operations_Use_The_Common_Contract) {
-    aethera::Import_Struct<Value> storage;
-    storage.internal.builder_set([](Value& value) { value.number = 29; });
-    EXPECT_EQ(storage.internal.use()->number, 29);
-    storage.set(&Value::number, 31);
-    storage.internal.advance();
-    EXPECT_EQ(storage.internal.use()->number, 31);
-}
-
-struct First_Tag {};
-struct Second_Tag {};
-
-using First_Storage =
-    aethera::Tagged_Storage<First_Tag, aethera::Import_Struct<Value>>;
-using Second_Storage =
-    aethera::Tagged_Storage<Second_Tag, aethera::Export_Struct<Value>>;
-using Storage_Set = aethera::Tagged_Storage_Set<First_Storage, Second_Storage>;
-
-static_assert(std::same_as<
-              decltype(std::declval<Storage_Set&>().get<First_Tag>()),
-              aethera::Import_Struct<Value>&>);
-static_assert(std::same_as<
-              decltype(std::declval<const Storage_Set&>().get<Second_Tag>()),
-              const aethera::Export_Struct<Value>&>);
-
-TEST(Concurrent_Storage_Interface, Tagged_Set_Returns_The_Selected_Storage) {
-    Storage_Set storages;
-
-    storages.get<First_Tag>().set(&Value::number, 37);
-    storages.get<First_Tag>().internal.advance();
-    EXPECT_EQ(storages.get<First_Tag>().internal.use()->number, 37);
-
-    storages.get<Second_Tag>().internal.use()->number = 41;
-    storages.get<Second_Tag>().internal.advance();
-    const Storage_Set& const_storages = storages;
-    EXPECT_EQ(const_storages.get<Second_Tag>().get(&Value::number), 41);
-}
-
-}
diff --git a/kernel/kernel/test/concurrent/Concurrent_Tests.cpp b/kernel/kernel/test/concurrent/Concurrent_Tests.cpp
new file mode 100644
index 0000000..f067d52
--- /dev/null
+++ b/kernel/kernel/test/concurrent/Concurrent_Tests.cpp
@@ -0,0 +1,75 @@
+#include "concurrent/Concurrent.hpp"
+#include "concurrent/list/List.hpp"
+#include "concurrent/structure/Struct.hpp"
+#include "model/detail/Attachment.hpp"
+
+#include <gtest/gtest.h>
+#include <proxy/proxy.h>
+
+#include <concepts>
+#include <utility>
+#include <vector>
+
+namespace {
+
+struct Value {
+    int number{};
+};
+
+using List = std::vector<int>;
+
+struct Internal_Only_Attachment {
+    struct Internal {
+        void advance();
+        Value* use();
+        template <typename Fn> void builder_set(Fn&& fn);
+    } internal;
+};
+
+static_assert(aethera::Concurrent_Attachment<aethera::Export_Struct_Concurrent<Value>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Import_Struct_Concurrent<Value>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Import_List_Concurrent<List>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Export_List_Concurrent<List>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Readable_Import_Batch_Concurrent<List>>);
+static_assert(aethera::Concurrent_Internal<Internal_Only_Attachment>);
+static_assert(!aethera::Concurrent_Attachment<Internal_Only_Attachment>);
+
+TEST(Concurrent_Protocol, Internal_Operations_Use_The_Common_Contract) {
+    aethera::Import_Struct_Concurrent<Value> storage;
+    storage.internal.builder_set([](Value& value) { value.number = 29; });
+    EXPECT_EQ(storage.internal.use()->number, 29);
+    storage.set(&Value::number, 31);
+    storage.internal.advance();
+    EXPECT_EQ(storage.internal.use()->number, 31);
+}
+
+struct First_Tag {};
+struct Second_Tag {};
+
+using First_Attachment =
+    aethera::Model_Attachment<First_Tag, aethera::Import_Struct_Concurrent<Value>>;
+using Second_Attachment =
+    aethera::Model_Attachment<Second_Tag, aethera::Export_Struct_Concurrent<Value>>;
+using Attachment_Set = aethera::Model_Attachment_Set<First_Attachment, Second_Attachment>;
+
+static_assert(std::same_as<
+              decltype(std::declval<Attachment_Set&>().get<First_Tag>()),
+              aethera::Import_Struct_Concurrent<Value>&>);
+static_assert(std::same_as<
+              decltype(std::declval<const Attachment_Set&>().get<Second_Tag>()),
+              const aethera::Export_Struct_Concurrent<Value>&>);
+
+TEST(Model_Attachment, Tagged_Set_Returns_The_Selected_Attachment) {
+    Attachment_Set attachments;
+
+    attachments.get<First_Tag>().set(&Value::number, 37);
+    attachments.get<First_Tag>().internal.advance();
+    EXPECT_EQ(attachments.get<First_Tag>().internal.use()->number, 37);
+
+    attachments.get<Second_Tag>().internal.use()->number = 41;
+    attachments.get<Second_Tag>().internal.advance();
+    const Attachment_Set& const_attachments = attachments;
+    EXPECT_EQ(const_attachments.get<Second_Tag>().get(&Value::number), 41);
+}
+
+}
diff --git a/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp b/kernel/kernel/test/concurrent/dirty/Dirty_Tests.cpp
similarity index 80%
rename from kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp
rename to kernel/kernel/test/concurrent/dirty/Dirty_Tests.cpp
index 7f22d3c..3c48310 100644
--- a/kernel/kernel/test/concurrent/Concurrent_Dirty_Tests.cpp
+++ b/kernel/kernel/test/concurrent/dirty/Dirty_Tests.cpp
@@ -1,4 +1,4 @@
-#include "concurrent/Concurrent_Storage_with_dirty.hpp"
+#include "concurrent/dirty/Dirty.hpp"
 
 #include <gtest/gtest.h>
 
@@ -21,8 +21,8 @@ struct Derived_Dirty_Value : Base_Dirty_Value {
 
 using List = std::vector<int>;
 
-struct Concurrent_Struct_Dirty_Test : testing::Test {
-    using Storage = aethera::Import_Struct_With_Dirty<Value>;
+struct Struct_Concurrent_Dirty_Test : testing::Test {
+    using Storage = aethera::Dirty_Import_Struct_Concurrent<Value>;
     using Member = int Value::*;
     Storage storage;
     aethera::Dirty_Binder<Storage> whole_dirty{storage};
@@ -38,7 +38,7 @@ struct Concurrent_Struct_Dirty_Test : testing::Test {
         &Value::other};
 };
 
-TEST_F(Concurrent_Struct_Dirty_Test, Member_Write_Dirties_Whole_And_Only_That_Member) {
+TEST_F(Struct_Concurrent_Dirty_Test, Member_Write_Dirties_Whole_And_Only_That_Member) {
     storage.set(&Value::number, 7);
     EXPECT_FALSE(whole_dirty.dirty());
     EXPECT_FALSE(number_dirty.dirty());
@@ -51,7 +51,7 @@ TEST_F(Concurrent_Struct_Dirty_Test, Member_Write_Dirties_Whole_And_Only_That_Me
     EXPECT_TRUE(either_property_dirty.take_dirty());
 }
 
-TEST_F(Concurrent_Struct_Dirty_Test, Different_Members_Have_Independent_Revisions) {
+TEST_F(Struct_Concurrent_Dirty_Test, Different_Members_Have_Independent_Revisions) {
     storage.set(&Value::number, 11);
     storage.internal.advance();
     ASSERT_TRUE(number_dirty.take_dirty());
@@ -64,7 +64,7 @@ TEST_F(Concurrent_Struct_Dirty_Test, Different_Members_Have_Independent_Revision
     EXPECT_TRUE(other_dirty.take_dirty());
 }
 
-TEST_F(Concurrent_Struct_Dirty_Test, Whole_Object_Write_Dirties_Every_Member) {
+TEST_F(Struct_Concurrent_Dirty_Test, Whole_Object_Write_Dirties_Every_Member) {
     storage.set([](Value& value) {
         value.number = 17;
         value.other = 19;
@@ -77,7 +77,7 @@ TEST_F(Concurrent_Struct_Dirty_Test, Whole_Object_Write_Dirties_Every_Member) {
     EXPECT_TRUE(either_property_dirty.take_dirty());
 }
 
-TEST_F(Concurrent_Struct_Dirty_Test, Two_Member_Writes_Dirty_Both_Properties_In_One_Revision) {
+TEST_F(Struct_Concurrent_Dirty_Test, Two_Member_Writes_Dirty_Both_Properties_In_One_Revision) {
     const std::uint64_t before = storage.internal.dirty_revision();
     storage.set(&Value::number, 20);
     storage.set(&Value::other, 21);
@@ -90,7 +90,7 @@ TEST_F(Concurrent_Struct_Dirty_Test, Two_Member_Writes_Dirty_Both_Properties_In_
     EXPECT_TRUE(either_property_dirty.take_dirty());
 }
 
-TEST_F(Concurrent_Struct_Dirty_Test, Multiple_Writes_Publish_One_Whole_Revision) {
+TEST_F(Struct_Concurrent_Dirty_Test, Multiple_Writes_Publish_One_Whole_Revision) {
     const std::uint64_t before = storage.internal.dirty_revision();
     storage.set(&Value::number, 23);
     storage.set(&Value::number, 29);
@@ -107,8 +107,8 @@ TEST_F(Concurrent_Struct_Dirty_Test, Multiple_Writes_Publish_One_Whole_Revision)
     EXPECT_FALSE(number_dirty.take_dirty());
 }
 
-TEST(Concurrent_Dirty, Export_Struct_Whole_Access_Dirties_All_Properties) {
-    aethera::Export_Struct_With_Dirty<Value> storage;
+TEST(Concurrent_Dirty, Export_Struct_Concurrent_Whole_Access_Dirties_All_Properties) {
+    aethera::Dirty_Export_Struct_Concurrent<Value> storage;
     aethera::Dirty_Binder whole_dirty{storage};
     aethera::Property_Dirty_Binder number_dirty{storage, &Value::number};
     aethera::Property_Dirty_Binder other_dirty{storage, &Value::other};
@@ -122,7 +122,7 @@ TEST(Concurrent_Dirty, Export_Struct_Whole_Access_Dirties_All_Properties) {
 }
 
 TEST(Concurrent_Dirty, Binder_Created_After_Publish_Starts_From_Current_Revision) {
-    aethera::Import_Struct_With_Dirty<Value> storage;
+    aethera::Dirty_Import_Struct_Concurrent<Value> storage;
     storage.set(&Value::number, 33);
     storage.internal.advance();
 
@@ -138,7 +138,7 @@ TEST(Concurrent_Dirty, Binder_Created_After_Publish_Starts_From_Current_Revision
 }
 
 TEST(Concurrent_Dirty, Inherited_Member_Write_Tracks_The_Base_Property) {
-    aethera::Import_Struct_With_Dirty<Derived_Dirty_Value> storage;
+    aethera::Dirty_Import_Struct_Concurrent<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();
@@ -146,10 +146,10 @@ TEST(Concurrent_Dirty, Inherited_Member_Write_Tracks_The_Base_Property) {
     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>;
-    using Batch = aethera::Readable_Import_Batch_With_Dirty<List>;
+struct List_Concurrent_Dirty_Test : testing::Test {
+    using Imported = aethera::Dirty_Import_List_Concurrent<List>;
+    using Exported = aethera::Dirty_Export_List_Concurrent<List>;
+    using Batch = aethera::Dirty_Readable_Import_Batch_Concurrent<List>;
     Imported imported;
     Exported exported;
     Batch batch;
@@ -159,7 +159,7 @@ struct Concurrent_List_Dirty_Test : testing::Test {
         batch};
 };
 
-TEST_F(Concurrent_List_Dirty_Test, Each_List_Write_Entry_Advances_Whole_Dirty) {
+TEST_F(List_Concurrent_Dirty_Test, Each_List_Write_Entry_Advances_Whole_Dirty) {
     imported.set([](List& values) { values.push_back(37); });
     imported.internal.advance();
     EXPECT_TRUE(dirty.take_dirty());
@@ -175,8 +175,8 @@ TEST_F(Concurrent_List_Dirty_Test, Each_List_Write_Entry_Advances_Whole_Dirty) {
 }
 
 TEST(Concurrent_Dirty, Whole_Binder_Tracks_Each_Source_Independently) {
-    aethera::Export_Struct_With_Dirty<Value> first;
-    aethera::Export_Struct_With_Dirty<Value> second;
+    aethera::Dirty_Export_Struct_Concurrent<Value> first;
+    aethera::Dirty_Export_Struct_Concurrent<Value> second;
     aethera::Dirty_Binder dirty{first, second};
 
     first.internal.use()->number = 47;
diff --git a/kernel/kernel/test/concurrent/Concurrent_List_Tests.cpp b/kernel/kernel/test/concurrent/list/List_Tests.cpp
similarity index 78%
rename from kernel/kernel/test/concurrent/Concurrent_List_Tests.cpp
rename to kernel/kernel/test/concurrent/list/List_Tests.cpp
index 6f5ca71..115066e 100644
--- a/kernel/kernel/test/concurrent/Concurrent_List_Tests.cpp
+++ b/kernel/kernel/test/concurrent/list/List_Tests.cpp
@@ -1,4 +1,4 @@
-#include "concurrent/base/Concurrent_List.hpp"
+#include "concurrent/list/List.hpp"
 
 #include <gtest/gtest.h>
 
@@ -8,8 +8,8 @@ namespace {
 
 using List = std::vector<int>;
 
-TEST(Concurrent_List, Import_Rotates_External_Batch_To_Internal) {
-    aethera::Import_List<List> storage;
+TEST(List_Concurrent, Import_Rotates_External_Batch_To_Internal) {
+    aethera::Import_List_Concurrent<List> storage;
     List* const internal_before = storage.internal.internal;
     List* const external_before = storage.internal.external;
 
@@ -26,8 +26,8 @@ TEST(Concurrent_List, Import_Rotates_External_Batch_To_Internal) {
     EXPECT_TRUE(storage.internal.external->empty());
 }
 
-TEST(Concurrent_List, Export_Publishes_Produced_Batch_And_Clears_Reuse_Slot) {
-    aethera::Export_List<List> storage;
+TEST(List_Concurrent, Export_Publishes_Produced_Batch_And_Clears_Reuse_Slot) {
+    aethera::Export_List_Concurrent<List> storage;
     List* const internal_before = storage.internal.internal;
     List* const external_before = storage.internal.external;
     storage.internal.use()->assign({3, 5});
@@ -42,8 +42,8 @@ TEST(Concurrent_List, Export_Publishes_Produced_Batch_And_Clears_Reuse_Slot) {
     });
 }
 
-TEST(Concurrent_List, Readable_Import_Batch_Exposes_Previous_Internal_Batch) {
-    aethera::Readable_Import_Batch<List> storage;
+TEST(List_Concurrent, Readable_Import_Batch_Concurrent_Exposes_Previous_Internal_Batch) {
+    aethera::Readable_Import_Batch_Concurrent<List> storage;
 
     storage.set([](List& values) {
         values = {7};
@@ -66,8 +66,8 @@ TEST(Concurrent_List, Readable_Import_Batch_Exposes_Previous_Internal_Batch) {
     EXPECT_TRUE(storage.internal.external_write->empty());
 }
 
-TEST(Concurrent_List, Readable_Import_Batch_Rotates_All_Three_Pointers) {
-    aethera::Readable_Import_Batch<List> storage;
+TEST(List_Concurrent, Readable_Import_Batch_Concurrent_Rotates_All_Three_Pointers) {
+    aethera::Readable_Import_Batch_Concurrent<List> storage;
     List* const write_before = storage.internal.external_write;
     List* const internal_before = storage.internal.internal_read;
     List* const read_before = storage.internal.external_read;
diff --git a/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp b/kernel/kernel/test/concurrent/structure/Struct_Tests.cpp
similarity index 78%
rename from kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp
rename to kernel/kernel/test/concurrent/structure/Struct_Tests.cpp
index 3a5ea19..d42ab13 100644
--- a/kernel/kernel/test/concurrent/Concurrent_Struct_Tests.cpp
+++ b/kernel/kernel/test/concurrent/structure/Struct_Tests.cpp
@@ -1,4 +1,4 @@
-#include "concurrent/base/Concurrent_Struct.hpp"
+#include "concurrent/structure/Struct.hpp"
 
 #include <gtest/gtest.h>
 
@@ -49,8 +49,8 @@ struct Struct_Hooks {
     int order{};
 };
 
-TEST(Concurrent_Struct, Export_Publishes_Only_On_Advance) {
-    aethera::Export_Struct<Value> storage;
+TEST(Struct_Concurrent, Export_Publishes_Only_On_Advance) {
+    aethera::Export_Struct_Concurrent<Value> storage;
 
     storage.internal.use()->number = 7;
     storage.internal.use()->text = "pending";
@@ -67,8 +67,8 @@ TEST(Concurrent_Struct, Export_Publishes_Only_On_Advance) {
     EXPECT_EQ(storage.get(&Value::number), 7);
 }
 
-TEST(Concurrent_Struct, Import_Consumes_Only_On_Advance) {
-    aethera::Import_Struct<Value> storage;
+TEST(Struct_Concurrent, Import_Consumes_Only_On_Advance) {
+    aethera::Import_Struct_Concurrent<Value> storage;
 
     storage.set(&Value::number, 13);
     storage.set([](Value& value) {
@@ -86,8 +86,8 @@ TEST(Concurrent_Struct, Import_Consumes_Only_On_Advance) {
     EXPECT_EQ(storage.get(&Value::number), 17);
 }
 
-TEST(Concurrent_Struct, Advance_Hooks_Receive_Original_Pointers_In_Order) {
-    aethera::Export_Struct<Value, Struct_Hooks> storage;
+TEST(Struct_Concurrent, Advance_Hooks_Receive_Original_Pointers_In_Order) {
+    aethera::Export_Struct_Concurrent<Value, Struct_Hooks> storage;
     Value* const internal = storage.internal.use();
     Value* const external = &storage.internal.external_read;
     internal->number = 19;
@@ -103,10 +103,10 @@ 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;
+TEST(Struct_Concurrent, Inherited_Member_Pointers_Work_For_All_Struct_Interfaces) {
+    static_assert(aethera::Concurrent_External_Set<aethera::Import_Struct_Concurrent<Derived_Value>, decltype(&Base_Value::base_number), int>);
+    static_assert(aethera::Concurrent_External_Get<aethera::Import_Struct_Concurrent<Derived_Value>, decltype(&Base_Value::base_number)>);
+    aethera::Import_Struct_Concurrent<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);
@@ -115,7 +115,7 @@ TEST(Concurrent_Struct, Inherited_Member_Pointers_Work_For_All_Struct_Interfaces
     imported.internal.advance();
     EXPECT_EQ(imported.internal.use()->base_number, 67);
 
-    aethera::Export_Struct<Derived_Value> exported;
+    aethera::Export_Struct_Concurrent<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;
diff --git a/kernel/kernel/test/model/Model_Tests.cpp b/kernel/kernel/test/model/Model_Tests.cpp
index 0aa8cd2..137e3bb 100644
--- a/kernel/kernel/test/model/Model_Tests.cpp
+++ b/kernel/kernel/test/model/Model_Tests.cpp
@@ -1,4 +1,7 @@
-#include "concurrent/base/Concurrent_List.hpp"
+#include "concurrent/Concurrent_Registration.hpp"
+#include "concurrent/dirty/Dirty.hpp"
+#include "concurrent/list/List.hpp"
+#include "concurrent/structure/Struct.hpp"
 #include "model/Model.hpp"
 #include <gtest/gtest.h>
 #include <vector>
@@ -19,10 +22,13 @@ struct Other_Test_Model_Private_Facade : aethera::facade_builder
 struct Number_List_Tag {
     template <typename Layer> using Value = typename Layer::Numbers;
 };
+struct Other_Number_List_Tag {
+    template <typename Layer> using Value = typename Layer::Other_Numbers;
+};
 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 Test_Model_Base : aethera::Def<Test_Model_Base, aethera::Root, aethera::Concurrent_Registration<aethera::Dirty_Import_Struct_Concurrent, aethera::Prop_Tag>, aethera::Concurrent_Registration<aethera::Export_Struct_Concurrent, aethera::State_Tag>, aethera::Concurrent_Registration<aethera::Import_List_Concurrent, Number_List_Tag, Other_Number_List_Tag>> {
     struct Prop : Prev<aethera::Prop_Tag> {
         int base_number{};
         int same_name{};
@@ -31,12 +37,13 @@ struct Test_Model_Base : aethera::Def<Test_Model_Base, aethera::Root, aethera::S
         int base_state{};
     };
     struct Numbers : Prev<Number_List_Tag>, std::vector<int> {};
+    struct Other_Numbers : Prev<Other_Number_List_Tag>, std::vector<int> {};
     struct Private : Prev_Private {
         Private() { ++test_model_base_private_instances; }
         ~Private() { --test_model_base_private_instances; }
     };
 };
-struct Test_Model_Middle : aethera::Def<Test_Model_Middle, Test_Model_Base, aethera::Storage_Registration<Middle_Data_Tag, aethera::Import_Struct>> {
+struct Test_Model_Middle : aethera::Def<Test_Model_Middle, Test_Model_Base, aethera::Concurrent_Registration<aethera::Import_Struct_Concurrent, Middle_Data_Tag>> {
     struct Prop : Prev<aethera::Prop_Tag> {
         int middle_number{};
     };
@@ -44,6 +51,7 @@ struct Test_Model_Middle : aethera::Def<Test_Model_Middle, Test_Model_Base, aeth
         int middle_state{};
     };
     struct Numbers : Prev<Number_List_Tag> {};
+    struct Other_Numbers : Prev<Other_Number_List_Tag> {};
     struct Middle_Data : Prev<Middle_Data_Tag> {
         int middle_number{};
     };
@@ -62,6 +70,7 @@ struct Test_Model : aethera::Def<Test_Model, Test_Model_Middle> {
         int state{};
     };
     struct Numbers : Prev<Number_List_Tag> {};
+    struct Other_Numbers : Prev<Other_Number_List_Tag> {};
     struct Middle_Data : Prev<Middle_Data_Tag> {
         int final_number{};
     };
@@ -79,23 +88,28 @@ struct Test_Model : aethera::Def<Test_Model, Test_Model_Middle> {
 struct Test_Prop_Initializer {
     void operator()(Test_Model::Prop&) const;
 };
+template <typename Model>
+concept Exposes_Relation_Model_API = requires(Model& model) { model.template edit<aethera::Prop_Tag>(0); };
+template <typename Builder>
+concept Exposes_Relation_Builder_API = requires(Builder& builder) { builder.template relation<aethera::Prop_Tag>([](auto&) {}); };
 static_assert(std::derived_from<Test_Model_Middle::Prop, Test_Model_Base::Prop>);
 static_assert(std::derived_from<Test_Model::Prop, Test_Model_Middle::Prop>);
 static_assert(std::derived_from<Test_Model_Middle::State, Test_Model_Base::State>);
 static_assert(std::derived_from<Test_Model::State, Test_Model_Middle::State>);
 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(aethera::Concurrent_Attachment<aethera::Dirty_Import_Struct_Concurrent<Test_Model::Prop>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Export_Struct_Concurrent<Test_Model::State>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Import_List_Concurrent<Test_Model::Numbers>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Import_List_Concurrent<Test_Model::Other_Numbers>>);
+static_assert(aethera::Concurrent_Attachment<aethera::Import_Struct_Concurrent<Test_Model::Middle_Data>>);
+static_assert(!aethera::detail::Builder_Settable_Concurrent<aethera::Prop_Tag, Test_Model, int>);
+static_assert(aethera::detail::Builder_Settable_Concurrent<aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name), int>);
+static_assert(aethera::detail::Settable_Concurrent<aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name), int>);
+static_assert(aethera::detail::Gettable_Concurrent<aethera::Prop_Tag, Test_Model, decltype(&Test_Model_Base::Prop::same_name)>);
+static_assert(aethera::detail::Builder_Settable_Concurrent<Middle_Data_Tag, Test_Model, decltype(&Test_Model_Middle::Middle_Data::middle_number), int>);
+static_assert(aethera::detail::Settable_Concurrent<Middle_Data_Tag, Test_Model, decltype(&Test_Model_Middle::Middle_Data::middle_number), int>);
+static_assert(!Exposes_Relation_Model_API<Test_Model>);
+static_assert(!Exposes_Relation_Builder_API<Test_Model::Builder>);
 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) {
@@ -104,23 +118,23 @@ TEST(Model, Every_Def_Layer_Can_Materialize_Its_Own_Endpoint) {
     {
         Test_Model_Base::Builder builder;
         builder
-        .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Base::Prop::base_number, 3);
+        .set<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(model->d->concurrent<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);
+        .set<aethera::Prop_Tag>(&Test_Model_Base::Prop::base_number, 5)
+        .set<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(model->d->concurrent<aethera::Prop_Tag>().internal.use()->base_number, 5);
+        EXPECT_EQ(model->d->concurrent<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);
@@ -129,22 +143,25 @@ TEST(Model, Registered_Value_Types_Build_Independent_Storages) {
     Test_Model::Builder builder;
     int struct_initializer_calls{};
     builder
-    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>([&](Test_Model::Prop& properties) {
+    .set<aethera::Prop_Tag>([&](Test_Model::Prop& properties) {
         ++struct_initializer_calls;
         properties.base_number = 2;
         properties.middle_number = 3;
     })
-    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::number, 5)
-    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::other, 7)
-    .set<aethera::Export_Struct, aethera::State_Tag>([](Test_Model::State& state) {
+    .set<aethera::Prop_Tag>(&Test_Model::Prop::number, 5)
+    .set<aethera::Prop_Tag>(&Test_Model::Prop::other, 7)
+    .set<aethera::State_Tag>([](Test_Model::State& state) {
         state.base_state = 17;
         state.middle_state = 19;
         state.state = 23;
     })
-    .set<aethera::Import_List, Number_List_Tag>([](Test_Model::Numbers& numbers) {
+    .set<Number_List_Tag>([](Test_Model::Numbers& numbers) {
         numbers.assign({11, 13});
+    })
+    .set<Other_Number_List_Tag>([](Test_Model::Other_Numbers& numbers) {
+        numbers.assign({17, 19});
     });
-    auto& building_properties = builder.ret->d->get<aethera::Prop_Tag>();
+    auto& building_properties = builder.ret->d->concurrent<aethera::Prop_Tag>();
     EXPECT_EQ(struct_initializer_calls, 1);
     EXPECT_EQ(building_properties.internal.internal_read.base_number, 2);
     EXPECT_EQ(building_properties.internal.internal_read.middle_number, 3);
@@ -153,14 +170,16 @@ TEST(Model, Registered_Value_Types_Build_Independent_Storages) {
     Test_Model* const building_model = builder.ret.get();
     auto model = builder.build();
     EXPECT_EQ(model.get(), building_model);
-    model->get<aethera::Export_Struct, aethera::State_Tag>([](const Test_Model::State& state) {
+    model->get<aethera::State_Tag>([](const Test_Model::State& state) {
         EXPECT_EQ(state.base_state, 17);
         EXPECT_EQ(state.middle_state, 19);
         EXPECT_EQ(state.state, 23);
     });
-    auto& numbers = model->d->get<Number_List_Tag>();
+    auto& numbers = model->d->concurrent<Number_List_Tag>();
     EXPECT_EQ(*numbers.internal.use(), (std::vector<int>{11, 13}));
-    model->set<aethera::Import_List, Number_List_Tag>([](Test_Model::Numbers& values) {
+    auto& other_numbers = model->d->concurrent<Other_Number_List_Tag>();
+    EXPECT_EQ(*other_numbers.internal.use(), (std::vector<int>{17, 19}));
+    model->set<Number_List_Tag>([](Test_Model::Numbers& values) {
         values.assign({17, 19});
     });
     numbers.internal.advance();
@@ -179,30 +198,30 @@ TEST(Model, Every_Def_Layer_Shares_One_Private_And_Storage_Set) {
         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>()));
+        auto* properties = std::addressof(model->d->concurrent<aethera::Prop_Tag>());
+        EXPECT_EQ(properties, std::addressof(model->d->concurrent<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) {
+TEST(Model, Registered_Struct_Set_Publishes_To_The_Same_Attachment) {
     auto model = Test_Model::Builder{}.build();
-    model->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::number, 13);
-    auto& properties = model->d->get<aethera::Prop_Tag>();
+    model->set<aethera::Prop_Tag>(&Test_Model::Prop::number, 13);
+    auto& properties = model->d->concurrent<aethera::Prop_Tag>();
     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);
+    .set<Middle_Data_Tag>(&Test_Model_Middle::Middle_Data::middle_number, 47)
+    .set<Middle_Data_Tag>(&Test_Model::Middle_Data::final_number, 53);
     auto model = builder.build();
-    auto& storage = model->d->get<Middle_Data_Tag>();
+    auto& storage = model->d->concurrent<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);
+    model->set<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);
@@ -210,15 +229,15 @@ TEST(Model, Derived_Def_Registers_And_Uses_A_New_Concurrent) {
 TEST(Model, Same_Name_Properties_In_Base_And_Derived_Layers_Are_Set_Independently) {
     Test_Model::Builder builder;
     builder
-    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Base::Prop::same_name, 29)
-    .set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::same_name, 31);
+    .set<aethera::Prop_Tag>(&Test_Model_Base::Prop::same_name, 29)
+    .set<aethera::Prop_Tag>(&Test_Model::Prop::same_name, 31);
     auto model = builder.build();
-    const auto* properties = model->d->get<aethera::Prop_Tag>().internal.use();
+    const auto* properties = model->d->concurrent<aethera::Prop_Tag>().internal.use();
     EXPECT_EQ(static_cast<const Test_Model_Base::Prop&>(*properties).same_name, 29);
     EXPECT_EQ(properties->same_name, 31);
-    model->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model_Base::Prop::same_name, 37);
-    model->set<aethera::Import_Struct_With_Dirty, aethera::Prop_Tag>(&Test_Model::Prop::same_name, 41);
-    auto& storage = model->d->get<aethera::Prop_Tag>();
+    model->set<aethera::Prop_Tag>(&Test_Model_Base::Prop::same_name, 37);
+    model->set<aethera::Prop_Tag>(&Test_Model::Prop::same_name, 41);
+    auto& storage = model->d->concurrent<aethera::Prop_Tag>();
     storage.internal.advance();
     properties = storage.internal.use();
     EXPECT_EQ(static_cast<const Test_Model_Base::Prop&>(*properties).same_name, 37);
diff --git a/kernel/kernel/test/relation/dag/Dag_Relation_Tests.cpp b/kernel/kernel/test/relation/dag/Dag_Relation_Tests.cpp
new file mode 100644
index 0000000..d740b6a
--- /dev/null
+++ b/kernel/kernel/test/relation/dag/Dag_Relation_Tests.cpp
@@ -0,0 +1,44 @@
+#include "model/Model.hpp"
+#include "relation/Relation_Registration.hpp"
+#include "relation/dag/Dag_Relation.hpp"
+#include <gtest/gtest.h>
+#include <optional>
+namespace {
+struct Test_Relation_Node : aethera::facade_builder
+::support_relocation<pro::constraint_level::nothrow>
+::build {};
+struct Test_Relation_Model : aethera::Def<Test_Relation_Model, aethera::Root, aethera::Relation_Registration<aethera::Owned_Dag_Relation, Test_Relation_Node>> {
+    struct Private : Prev_Private {};
+};
+template <typename Model>
+concept Exposes_Concurrent_Model_API = requires(Model& model) { model.template set<Test_Relation_Node>(0); };
+template <typename Builder>
+concept Exposes_Concurrent_Builder_API = requires(Builder& builder) { builder.template set<Test_Relation_Node>(0); };
+static_assert(aethera::Relation_Attachment<aethera::Owned_Dag_Relation<Test_Relation_Node>>);
+static_assert(aethera::detail::Relation_Model_Tag<Test_Relation_Node, Test_Relation_Model>);
+static_assert(!Exposes_Concurrent_Model_API<Test_Relation_Model>);
+static_assert(!Exposes_Concurrent_Builder_API<Test_Relation_Model::Builder>);
+TEST(Dag_Relation, Registration_Composes_Only_Relation_APIs) {
+    bool initialized{};
+    Test_Relation_Model::Builder builder;
+    builder
+    .relation<Test_Relation_Node>([&](auto& relation) {
+        initialized = true;
+        std::size_t nodes{};
+        relation.for_each_topological([&](auto, auto&) { ++nodes; });
+        EXPECT_EQ(nodes, 0);
+    });
+    auto model = builder.build();
+    EXPECT_TRUE(initialized);
+    std::optional<std::expected<void, aethera::Dag_Result>> completion;
+    model->edit<Test_Relation_Node>([](auto& editor) { editor.remove({1}); }, [&](auto result) { completion.emplace(std::move(result)); });
+    EXPECT_FALSE(completion.has_value());
+    model->d->commit<Test_Relation_Node>();
+    ASSERT_TRUE(completion.has_value());
+    ASSERT_FALSE(completion->has_value());
+    EXPECT_EQ(completion->error(), aethera::Dag_Result::node_not_found);
+    std::size_t nodes{};
+    model->d->relation<Test_Relation_Node>().for_each_topological([&](auto, auto&) { ++nodes; });
+    EXPECT_EQ(nodes, 0);
+}
+} // namespace
diff --git a/kernel/main.cmake b/kernel/main.cmake
index 6c78707..9e3b054 100644
--- a/kernel/main.cmake
+++ b/kernel/main.cmake
@@ -66,7 +66,8 @@ if (Aethera_BUILD_TESTS)
     append_glob_source(Aethera_Kernel_module_test_sources
             "${Aethera_Kernel_test_dir}/concurrent"
             "${Aethera_Kernel_test_dir}/error"
-            "${Aethera_Kernel_test_dir}/model")
+            "${Aethera_Kernel_test_dir}/model"
+            "${Aethera_Kernel_test_dir}/relation")
     foreach (Aethera_Kernel_module_test_source IN LISTS Aethera_Kernel_module_test_sources)
         if (NOT Aethera_Kernel_module_test_source MATCHES "\\.(c|cc|cpp|cxx)$")
             continue()
diff --git a/kernel/使用规范.md b/kernel/使用规范.md
index 9fe6aca..0a6c42e 100644
--- a/kernel/使用规范.md
+++ b/kernel/使用规范.md
@@ -1,17 +1,19 @@
-# Model 定义层
+# Model 定义与扩展规范
 
-- 每个 Model 定义层的 `Prop`、`State` 等值类型必须定义在所属类内，并继承 `Prev<Tag>`，使同一 Tag 的值结构沿 Model 层级自然形成继承链。
-- 每一层统一使用 `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，禁止传入同形但未注册的类型。
+- 每个 Model 定义层的 `Prop`、`State` 等值类型必须定义在所属类内并继承 `Prev<Tag>`，使同一 Tag 的值结构沿 Model 层级形成继承链。
+- 每层统一使用 `Def<当前层, Base, Registrations...>`；中间类是普通类，不需要模板化，也不区分末尾层。
+- 注册写在所属 `Def` 的模板参数上。并发结构使用 `Concurrent_Registration<Concrete, Tags...>`，关系结构使用 `Relation_Registration<Concrete, Tags...>`。
+- 同一个注册组可以连续登记多个 Tag；相同 Tag 在完整继承链只能注册一次。
+- 注册只描述协议、Tag 和具体附件的映射。完整注册链按 Builder 正在构建的最终 endpoint 求值，并由公共 `Root` 一次物化唯一的 `Private + Model_Attachment_Set`。
+- Builder 只拥有一个最终 endpoint 对象槽；被继承的 Def 层不得创建自己的 endpoint state、对象副本或附件。每层 `d` 只是同一 Root 状态的非拥有 Private 视图。
+- Model 实体必须通过 `Builder`、`make_model_proxy` 或接收已完成 Builder 对象的 proxy 工厂物化；普通构造不创建运行状态。
+- 新协议必须与 `Concurrent_Registration`、`Relation_Registration` 同级，并自行提供 concept、注册项和 Model/Builder/Private 三组 CRTP API。禁止在 `Model` 内增加协议分支。
+- 最终 endpoint 只继承实际注册协议的 API；未注册关系结构的 Builder 和实体不得出现关系函数，未注册并发结构的类型不得出现并发函数。
+- 每个注册进 Model 的并发附件必须提供内部 `advance/use/builder_set`，外部 `set/get` 至少提供一个。Builder 的 `set<Tag>` 只进入 `internal.builder_set`，实体 `set/get` 只进入外部接口。
+- 关系结构不统一成并发接口。关系实体通过 `edit<Tag>` 提交事务，Builder 通过 `relation<Tag>` 初始化，Private 在所有者安全点通过 `relation<Tag>/commit<Tag>` 使用和提交。
 
 ```cpp
-struct Frame_Policy : Def<Frame_Policy, Root, Storage_Registration<Prop_Tag, Import_Struct_With_Dirty>, Storage_Registration<State_Tag, Export_Struct>> {
+struct Frame_Policy : Def<Frame_Policy, Root, Concurrent_Registration<Dirty_Import_Struct_Concurrent, Prop_Tag>, Concurrent_Registration<Export_Struct_Concurrent, State_Tag>> {
     struct Prop : Prev<Prop_Tag> {
         double frames_per_second{};
     };
diff --git a/render_2D/render_2D/module/scene/Render_Scene_2D.cpp b/render_2D/render_2D/module/scene/Render_Scene_2D.cpp
index 42a7f6a..0a6177d 100644
--- a/render_2D/render_2D/module/scene/Render_Scene_2D.cpp
+++ b/render_2D/render_2D/module/scene/Render_Scene_2D.cpp
@@ -15,10 +15,10 @@ Render_Scene_2D::Private::Advance_Result Render_Scene_2D::Private::advance(Blend
     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();
+    commit<scene::Renderable>();
+    auto& renderables = relation<scene::Renderable>();
     std::optional<Render_Scene_2D_Error> error;
-    renderables.internal.use().for_each_topological([&](Dag_Node_Id id, proxy<scene::Renderable>& renderable) {
+    renderables.for_each_topological([&](Dag_Node_Id id, proxy<scene::Renderable>& renderable) {
         if (error) return;
         renderable->render(target, viewport);
         renderable->advance();
@@ -31,7 +31,7 @@ Render_Scene_2D::Private::Advance_Result Render_Scene_2D::Private::advance(Blend
         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) {
+    renderables.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;
@@ -44,7 +44,7 @@ Render_Scene_2D::Private::Advance_Result Render_Scene_2D::Private::advance(Blend
 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>();
+    auto& properties = concurrent<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});
@@ -58,6 +58,6 @@ Render_Scene_2D_Result Render_Scene_2D::Private::render(Frame_2D* frame, Complet
 }
 
 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); }
+void Render_Scene_2D::activate_view() { set<Prop_Tag>(&Prop::view_active, true); }
+void Render_Scene_2D::deactivate_view() { set<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
index 0a91c39..ac046d7 100644
--- a/render_2D/render_2D/module/scene/Render_Scene_2D.hpp
+++ b/render_2D/render_2D/module/scene/Render_Scene_2D.hpp
@@ -2,13 +2,16 @@
 #include "../base/frame/Frame_2D.hpp"
 #include "export/export.h"
 #include "model/Model.hpp"
-#include "relation/Dag.hpp"
+#include "concurrent/Concurrent_Registration.hpp"
+#include "concurrent/dirty/Dirty.hpp"
+#include "relation/dag/Dag_Relation.hpp"
+#include "relation/Relation_Registration.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 Render_Scene_2D : Def<Render_Scene_2D, Root, Concurrent_Registration<Dirty_Import_Struct_Concurrent, Prop_Tag>, Relation_Registration<Owned_Dag_Relation, scene::Renderable>> {
     struct Prop : Prev<Prop_Tag> {
         Size viewport{};                    /* 最终帧像素尺寸；空尺寸不提交渲染。 */
         Color background{Color::black()};   /* 每帧绘制 Renderable 前写入的背景颜色。 */
diff --git a/render_2D/tests/Model_Adaptation_Test.cpp b/render_2D/tests/Model_Adaptation_Test.cpp
index c25da19..07f7e6b 100644
--- a/render_2D/tests/Model_Adaptation_Test.cpp
+++ b/render_2D/tests/Model_Adaptation_Test.cpp
@@ -9,6 +9,7 @@ struct Test_Renderable_2D : aethera::Def<Test_Renderable_2D, aethera::render_2d:
 };
 
 static_assert(pro::proxiable<aethera::detail::Model_Private_Pointer<Test_Renderable_2D*>, aethera::render_2d::scene::Renderable>);
+static_assert(aethera::Relation_Attachment<aethera::Owned_Dag_Relation<aethera::render_2d::scene::Renderable>>);
 
 TEST(Render_2D_Model, Every_Def_Layer_Uses_The_Final_Private_Instance) {
     auto renderable = Test_Renderable_2D::Builder{}.build();
@@ -19,17 +20,17 @@ TEST(Render_2D_Model, Every_Def_Layer_Uses_The_Final_Private_Instance) {
 }
 
 TEST(Render_2D_Model, Scene_Endpoint_Publishes_Properties_And_Owned_Dag) {
-    aethera::Dag<aethera::render_2d::scene::Renderable>::Builder dag_builder;
+    aethera::Dag_Relation<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);
+    .set<aethera::Prop_Tag>(&aethera::render_2d::Render_Scene_2D::Prop::viewport, aethera::render_2d::Size{32, 24})
+    .set<aethera::Prop_Tag>(&aethera::render_2d::Render_Scene_2D::Prop::view_active, true)
+    .relation<aethera::render_2d::scene::Renderable>([dag = std::move(*dag)](auto& relation) mutable { relation = std::move(dag); });
     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>();
+    auto& properties = scene->d->concurrent<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});