@virid/core 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+   Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Ailrid
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,259 +1 @@
-# 🛰️ @virid/core
-
-
-
-> **A Lightweight, Message-Driven Logic Engine inspired by Rust's ECS Architecture and Nestjs.**
-
-[中文说明](README.zh.md)
-
-## ✨ Features
-
-
-
-### 🧩 What is CCS Architecture?
-
-`virid` is built on the **CCS (Component-Controller-System)** architecture. Based on the traditional ECS (Entity-Component-System) pattern, it introduces a "Controller" layer specifically for Web/UI environments to bridge logic and views seamlessly.
-
-#### 1. 💾 Component (Data) — "The Container of Truth"
-
-- **Definition**: Pure data structures containing zero business logic.
-- **Responsibility**: Stores state (e.g., `PlaylistComponent` storing song lists and playback status). In `virid`, Components are managed as **Singletons** within the IoC container.
-
-#### 2. 🎮 Controller (The Bridge) — "The Anchor of Views"
-
-- **Definition**: A proxy layer between the UI framework (Vue) and the core logic (Core).
-- **Responsibility**:
-  - **Projection**: Safely maps data from `Components` to Vue using `@Project`.
-  - **Command**: Captures UI events (like clicks) and transforms them into `Messages` to be dispatched to the engine.
-  - **Context Awareness**: Perceives UI hierarchy and metadata (like list indices) via `@Env`.
-
-#### 3. ⚙️ System (Logic) — "The Arbiter of Causality"
-
-- **Definition**: A collection of stateless static methods and the **only** legitimate place for state transitions.
-- **Responsibility**: Listens for `Messages` and modifies `Component` data accordingly. Systems are **deterministic**, ensuring that the same input always yields the same state transition.
-
-### 🛠️ Decoupling of Logic Sovereignty
-
-### 1. Total UI Demotion: Framework-Agnostic Core
-
-- **Transfer of Sovereignty**: The UI framework is stripped of its authority over state management and business scheduling, relegated to a pure **"State Projection Layer."** All business causality and state machine transitions are executed within the closed loop of `virid Core`.
-- **Physical Isolation**: The Core layer has zero dependencies on `DOM/BOM` APIs. Your core logic runs seamlessly in **Node.js servers, Web Workers, or even Command Line Interface (CLI) tools**.
-- **Seamless Migration**: Logical assets are no longer tethered to a specific UI library. Switch the adapter layer, and you are ready for **Vue, React, or beyond**.
-
-### 2. Production-Grade Testability
-
-- **Farewell to Mocking Hell**: Say goodbye to JSDOM and complex browser simulations. Since the core logic is pure JS/TS, you can boot the Core directly in Node.js and complete unit tests for complex business flows via a **"Send Message -> Assert State"** pattern.
-- **Logic Playback**: As all side effects are triggered by messages, business logic becomes a **pure pipeline**, enabling offline refactoring and automated regression of production logic paths.
-
-### 3. Powerful Inversion of Control (IoC)
-
-- **Deep IoC Architecture**: Built on **InversifyJS** for robust Dependency Injection. `Systems`, `Components`, and `Controllers` are auto-assembled via the container.
-- **Dynamic Lifecycle**: Supports on-demand loading and auto-injection of logic modules. Whether it’s a global singleton `System` or a `Controller` that dies with a component, the container manages the entire lifecycle.
-
----
-
-## 🏎️ Game-Grade Scheduling Engine
-
-- **Deterministic Tick Mechanism**: Introduces a Bevy-inspired message loop where all logical changes advance within discrete "Ticks."
-- **Double-Buffered Message Pool**: Physically isolates "processing" and "incoming" messages, effectively eliminating infinite loops and logical jitter.
-- **Physically Isolated Message Strategies**:
-  - **SingleMessage (Signal)**: Automatically merges identical signals, triggering a single batch process within the same Tick.
-  - **EventMessage (Event)**: Guarantees strict sequential execution, ensuring the atomicity of logical chains.
-
----
-
-## 🛡️ State Security & Access Control
-
-- **Read-Only Data Shield**: Controllers receive read-only proxies by default, strictly prohibiting illegal tampering with `Component` states outside of a `System`.
-- **Atomic Modification Protocol**: Data changes are forced through specific `AtomicModifyMessage` protocols, ensuring every state transition is traceable and auditable.
-
----
-
-## 🧬 Declarative Meta-Programming
-
-- **Decorator-Driven**: Use `@System`, `@Message`, `@Inherit`, and `@Project` to declaratively describe complex dependency networks and reactive logic flows.
-- **Automated Data Routing**: Dispatching a message immediately triggers the response; parameters are injected automatically, eliminating the need to write tedious boilerplate for listeners and dispatchers.
-
-## 📖 Quick Start
-
-⚠️ Important: You MUST import reflect-metadata at the very first line of your entry file (e.g., main.ts), otherwise decorators will not function correctly.
-
-Build a strictly protected state machine in a pure JS environment in just three steps.
-
-### 1. Define Components & Messages
-
-**Components** are pure data structures; **Messages** are the sole driving contracts.
-
-```ts
-import {
-  createvirid,
-  Component,
-  System,
-  Message,
-  SingleMessage,
-  AtomicModifyMessage,
-} from "@virid/core";
-
-// Initialize the core engine
-const app = createVirid();
-
-// Define Data Entity (Component)
-@Component()
-class CounterComponent {
-  public count = 0;
-}
-// Register component
-app.bindComponent(CounterComponent);
-
-// Define operation instructions (Message)
-class IncrementMessage extends SingleMessage {
-  constructor(public amount: number) {
-    super();
-  }
-}
-```
-
-### 2. Implement Systems
-
-**Systems** are stateless static methods. They retrieve components via Dependency Injection (DI) to handle business logic. You don't need to manually instantiate or invoke them—virid will automatically discover and execute them through static analysis.
-
-```ts
-//Define System
-class CounterSystem {
-  @System()
-  static onIncrement(
-    @Message(IncrementMessage) message: IncrementMessage,
-    count: CounterComponent,
-  ) {
-    console.log("---------------------System----------------------");
-    console.log("message :>> ", message);
-    count.count += message.amount;
-  }
-}
-```
-
-### 3. Headless Execution
-
-No browser required. Drive your business logic directly in **Node.js** or any testing framework.
-
-```ts
-// Business logic automatically completes scheduling in the next microtask
-queueMicrotask(() => {
-  IncrementMessage.send(1);
-  IncrementMessage.send(5);
-  queueMicrotask(() => {
-    AtomicModifyMessage.send(
-      CounterComponent,
-      (comp) => {
-        console.log("----------------AtomicModifyMessage------------------");
-        console.log("CounterComponent :>> ", comp);
-      },
-      "Check CounterComponent",
-    );
-  });
-});
-```
-
-## 🛠️ Advanced Engineering Practices
-
-### ⚓ Lifecycle Interception (Middleware & AOP Hooks)
-
-virid provides deep access to the message pipeline, allowing you to easily extend the system with features like **Undo/Redo, State Synchronization, or Automated Logging**.
-
-- **Middleware**: Pre-process messages before they enter the `EventHub`.
-
-  TypeScript
-
-  ```
-  app.useMiddleware((message, next) => {
-    console.log(`[Log]: Intercepted message ${message.constructor.name}`);
-    next(); // Continue the pipeline
-  });
-  ```
-
-- **AOP Hooks**: Perform aspect-oriented processing before or after specific message execution.
-  - `onBeforeExecute`: Triggered before System logic runs (e.g., for permission checks).
-  - `onAfterExecute`: Triggered after logic execution (e.g., for data persistence).
-
-  TypeScript
-
-  ```
-  app.onBeforeExecute(IncrementMessage, (message, context) => {
-    console.log("---------------- onBeforeExecute ------------------");
-    console.log("Message Details:", message);
-    console.log("Target System:", context.targetClass.name);
-    console.log("Method Context:", context.methodName);
-  });
-  ```
-
----
-
-### ⚡ Atomic Modification: The "Snapshot" Privilege
-
-To balance **strict constraints** with **development efficiency**, virid allows direct state mutations via `AtomicModifyMessage` without the need to write a full `System`.
-
-- **Semantic Mutations**: Every atomic modification requires a mandatory `label`, transforming "arbitrary" assignments into auditable, meaningful actions.
-- **Consistency Guarantee**: Atomic modifications still follow the **Tick Scheduling** mechanism, ensuring that data changes are synchronized with System logic.
-
----
-
-### 🚨 Everything is a Message: Robust Error Monitoring
-
-virid treats exceptions as first-class citizens of the system:
-
-- **Automatic Encapsulation**: Any synchronous or asynchronous exception within a `System` or `Hook` is automatically captured by the `Dispatcher` and encapsulated into an `ErrorMessage`.
-- **Defensive Programming**: You can define a dedicated `ErrorSystem` to handle these messages globally (e.g., reporting to Sentry or triggering UI alerts). This ensures the core engine remains resilient and never crashes due to a single component failure.
-
----
-
----
-
-## 🚀 Conclusion: Why virid?
-
-virid is not just another state management library; it is an endeavor to introduce **Deterministic Industrial Standards** to Web development.
-
-As your project scales from dozens to thousands of components, and your business logic evolves from simple CRUD into intricate cross-component choreographies, the virid architecture ensures that your codebase remains:
-
-- **Traceable**: Every logical transition has a clear trail via messages.
-- **Predictable**: Every state modification follows strict, predefined protocols.
-- **Decoupled**: Every business flow can be tested and validated entirely independent of the UI.
-
-### 🛰️ Data Flow Architecture
-
-```mermaid
-graph TD
-    %% 定义外部触发
-    User([External/Logic Call]) -->|Message.send| Writer[MessageWriter]
-
-    %% 核心引擎内部
-    subgraph Engine [Virid Core Engine]
-        direction TB
-        Writer -->|Middleware Pipeline| Hub[EventHub: Staging]
-
-        subgraph Dispatcher [Deterministic Dispatcher]
-            Hub -->|Tick / Buffer Flip| Active[EventHub: Active Pool]
-            Active -->|Sort by Priority| TaskQueue[Task Queue]
-
-            subgraph Executor [Execution Context]
-                TaskQueue -->|Identify| Sys[System Static Method]
-                Container[(Inversify Container)] -.->|Inject Component| Sys
-                Sys -->|Execute| Logic{Business Logic}
-            end
-        end
-
-        Logic -->|Update| Data[(Raw Component Data)]
-
-        %% 异常与反馈流
-        Logic -- "New Message" --> Writer
-        Logic -- "Error" --> ErrorHandler[Error Message System]
-    end
-
-    %% 状态输出
-    Data -->|Optional Projection| Output([External State Observation])
-
-    %% 样式
-    style Engine fill:#fff,stroke:#333,stroke-width:2px
-    style Dispatcher fill:#f5f5f5,stroke:#666,dashed
-    style Container fill:#e1f5fe,stroke:#01579b
-
-```
+todo

package/README.zh.md

@@ -1,203 +1 @@
-# 🛰️ @virid/core
-
-> **A Lightweight, Message-Driven Logic Engine inspired by Rust's ECS Architecture and Nestjs.** **受 Rust Bevy ECS 架构与Nestjs启发的轻量级消息驱动逻辑引擎。**
-
-## ✨ 特点
-
-### 🧩 什么是 CCS 架构？
-
-`virid` 采用 **CCS (Controller-Component-System)** 架构。它在传统 ECS 的基础上，为 Web/UI 环境引入了“控制器”层，实现了逻辑与视图的完美桥接。
-
-#### 1. 💾 Component (数据) —— “逻辑的容器”
-
-- **定义**：纯粹的数据结构，不包含任何业务逻辑。
-- **职责**：存储状态。在 `virid` 中，它是 IoC 容器管理的单例。
-
-#### 2. 🎮 Controller (控制器) —— “视图的锚点”
-
-- **定义**：UI 框架（Vue）与核心逻辑（Core）之间的代理。
-- **职责**：
-  - **投影 (Projection)**：将 Component 里的数据安全地映射给 Vue。
-  - **指令 (Command)**：接收用户的点击事件，并将其转化为 `Message` 发送给引擎。
-
-#### 3. ⚙️ System (系统) —— “因果的裁判”
-
-- **定义**：无状态的静态方法集合，是逻辑变更的唯一合法场所。
-- **职责**：监听 `Message`，根据指令修改 `Component` 中的数据。它是确定性的，确保同样的输入永远得到同样的输出。
-
-### 🛠️ 逻辑主权
-
-#### 1. 彻底的 UI 降级：框架无关核心
-
-- **主权移交**：UI 框架被剥夺了状态管理与业务调度的权限，退化为纯粹的 **“状态投影层”**。所有的业务因果律、状态机转换均在 `virid Core` 中闭环执行。
-- **物理隔离**：Core 层不依赖任何 `DOM/BOM` API。核心逻辑可以无缝运行在 **Node.js 服务端、Web Worker、甚至是命令行 (CLI) 工具**中。
-- **无缝迁移**：逻辑资产不再与特定 UI 框架绑定。只需更换一个适配层，就能适配 vue 或React 应用。
-
-#### 2. 生产级的可测试性
-
-- **告别模拟 (Mock) 地狱**：无需 JSDOM，无需模拟复杂的浏览器环境。由于核心逻辑是纯 JS/TS 驱动的，可以直接在 Node.js 中启动 Core，通过 **“发送消息 -> 断言状态”** 的方式，完成对复杂业务流的单元测试。
-- **逻辑回放**：所有副作用都通过消息触发，让业务逻辑变成**纯净的流水线**，支持对线上逻辑路径进行离线重构与自动化回归。
-
-#### 3. 强力控制反转
-
-- **深度 IoC 架构**：基于 **InversifyJS** 实现依赖注入。`System`、`Component` 与 `Controller` 之间通过容器自动装配。
-- **动态生命周期**：支持逻辑模块的按需加载与自动注入。无论是全局单例的 `System` 还是随组件销毁的 `Controller`，均由容器统一接管生命周期。
-
-### 🏎️ 游戏级调度引擎
-
-- **确定性 Tick 机制**: 引入类 Bevy 的消息循环，所有逻辑变更在 Tick 中推进。
-- **双缓冲消息池**: 物理隔离“正在处理”与“新产生”的消息，避死循环与逻辑抖动。
-- **物理隔离消息策略**:
-  - **SingleMessage (信号)**: 自动合并同类项，同 Tick 内仅触发一次批量处理。
-  - **EventMessage (事件)**: 严格保序执行，确保逻辑链条的原子性。
-
-### 🛡️ 状态安全与权限控制
-
-- **只读数据护盾**: Controller 层(@virid/vue中)默认获得只读代理，禁止在 System 之外非法篡改 Component 状态。
-- **原子修改协议**: 强制通过特定的 `AtomicModifyMessage` 变更数据，让每一次状态改变都有迹可循、可被审计。
-
-### 🧬 声明式元编程
-
-- **装饰器驱动**: 使用 `@System`, `@Message`, `@Inherit`, `@Project` 等装饰器，以声明式的方式描述复杂的依赖网络和逻辑响应流。
-- **自动数据路由**: 消息发送即触发，参数自动注入，无需手动编写复杂的监听与分发代码。
-
-## 📖 快速上手
-
-只需三步，即可在纯 JS 环境中构建一个受严格保护的状态机。
-
-#### 1. 定义组件与消息 (Component & Message)
-
-组件(Component)是纯粹的数据结构，消息是唯一的驱动契约。
-
-```ts
-import {
-  createvirid,
-  Component,
-  System,
-  Message,
-  SingleMessage,
-  AtomicModifyMessage,
-} from "@virid/core";
-
-// Initialize the core engine
-const app = createvirid();
-
-// Define Data Entity (Component)
-@Component()
-class CounterComponent {
-  public count = 0;
-}
-// Register component
-app.bindComponent(CounterComponent);
-
-// Define operation instructions (Message)
-class IncrementMessage extends SingleMessage {
-  constructor(public amount: number) {
-    super();
-  }
-}
-```
-
-#### 2. 编写系统 (System)
-
-系统是无状态的静态方法，通过依赖注入获取组件并处理业务逻辑。**你无需任何操作，他们是纯static的，virid会自动找到他们并正确地调用他们。**
-
-```ts
-//Define System
-class CounterSystem {
-  @System()
-  static onIncrement(
-    @Message(IncrementMessage) message: IncrementMessage,
-    count: CounterComponent,
-  ) {
-    console.log("---------------------System----------------------");
-    console.log("message :>> ", message);
-    count.count += message.amount;
-  }
-}
-```
-
-#### 3. 纯环境运行 (Headless Execution)
-
-无需浏览器，直接在 Node.js 或测试框架中驱动你的业务。
-
-```ts
-// Business logic automatically completes scheduling in the next microtask
-queueMicrotask(() => {
-  IncrementMessage.send(1);
-  IncrementMessage.send(5);
-  queueMicrotask(() => {
-    AtomicModifyMessage.send(
-      CounterComponent,
-      (comp) => {
-        console.log("----------------AtomicModifyMessage------------------");
-        console.log("CounterComponent :>> ", comp);
-      },
-      "Check CounterComponent",
-    );
-  });
-});
-```
-
-## 🛠️ 高级工程实践 (Advanced Engineering)
-
-### ⚓ 全生命周期拦截 (Lifecycle Hooks & Middleware)
-
-virid 提供了深度介入消息管道的能力，你可以轻易地将其扩展为支持 **Undo/Redo**、**状态同步** 或 **自动日志** 的系统。
-
-- **Middleware**: 在消息进入 EventHub 之前进行预处理。
-
-  TypeScript
-
-  ```ts
-  app.useMiddleware((message, next) => {
-    console.log(`Identified message ${message.constructor.name}`);
-    next(); // 继续流转
-  });
-  ```
-
-- **AOP Hooks**: 针对特定消息的执行前后进行切面处理。
-  - `onBeforeExecute`: 在 System 逻辑运行前触发（如权限检查）。
-  - `onAfterExecute`: 在逻辑运行后触发（如数据持久化）。
-
-  ```ts
-  app.onBeforeExecute(IncrementMessage, (message, context) => {
-    console.log("----------------onBeforeExecute------------------");
-    console.log("message :>> ", message);
-    console.log("targetClass :>> ", context.targetClass);
-    console.log("methodName :>> ", context.methodName);
-    console.log("params :>> ", context.params);
-  });
-  ```
-
-### ⚡ 原子修改：“快照”特权 (Atomic Modification)
-
-为了兼顾“严苛约束”与“开发效率”，virid 允许通过 `AtomicModifyMessage` 直接描述状态变更，而无需编写完整的 System。
-
-- **语义化变更**：每一条原子修改都强制要求一个 `label`，让原本“随意的”赋值操作变得可被审计。
-- **一致性保证**：原子修改依然遵循 Tick 调度，确保数据变更与 System 逻辑同步生效。
-
-### 🚨 万物皆消息：健壮的异常监控 (Error as Message)
-
-virid 将异常视为系统的一等公民：
-
-- **自动封装**：任何 System 或 Hook 中的同步/异步异常，都会被 Dispatcher 自动捕获并封装为 `ErrorMessage`。
-- **防御式编程**：你可以定义一个 `ErrorSystem` 统一处理这些消息（如发送 Sentry 日志或触发 UI 告警），确保核心逻辑引擎永远不会因为单一组件的崩溃而宕机。
-
----
-
-## 🚀 结语：为什么是 virid？
-
-virid 不是在重复造一个状态库，它是在为 Web 开发引入一套**具备强确定性的工业标准**。
-
-当你的项目从几十个组件增长到几千个，当你的业务逻辑从简单的 CRUD 变成复杂的跨组件联动时，virid 的架构将确保你的代码依然：**逻辑可寻迹、修改可预期、测试可脱离 UI。**
-
-```
-数据流转示意图
-User -->|Dispatch| Writer[MessageWriter]
-Writer -->|Middleware| Hub[EventHub: Staging]
-Hub -->|Tick/Flip| Active[EventHub: Active]
-Active -->|Execute| System[System/Hook]
-System -->|Update| Component[Raw Component Data]
-Component -->|Reactive| UI[Vue/React View]
-```
+todo