diff --git a/Cargo.toml b/Cargo.toml
index a036484..a3cb5dd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,6 +33,7 @@ windows-sys = { version = "0.59", features = [
     "Win32_Graphics_Gdi",
     "Win32_NetworkManagement_IpHelper",
     "Win32_NetworkManagement_Ndis",
+    "Win32_Networking_WinHttp",
     "Win32_Networking_WinSock",
     "Win32_Security",
     "Win32_Security_Cryptography",
diff --git a/packages/applechu-schema/src/lib.rs b/packages/applechu-schema/src/lib.rs
index 4ed569c..421bb99 100644
--- a/packages/applechu-schema/src/lib.rs
+++ b/packages/applechu-schema/src/lib.rs
@@ -1124,12 +1124,12 @@ mod tests {
                 "RestartSong",
                 "SkipWarning",
                 "PCBID",
+                "ServerResources",
                 "VFS",
                 "NetEnv",
             ]
         );
     }
-
     #[test]
     fn rejects_malformed_entries_instead_of_silently_dropping_them() {
         let source = r#"
diff --git a/packages/applechu/src/lib.rs b/packages/applechu/src/lib.rs
index 5311707..7d2235e 100644
--- a/packages/applechu/src/lib.rs
+++ b/packages/applechu/src/lib.rs
@@ -33,6 +33,8 @@ pub mod platform;
 #[cfg(target_arch = "x86")]
 mod proxy;
 mod schema_embed;
+#[cfg(target_arch = "x86")]
+mod server_resources;
 mod slider;
 mod system_config;
 mod unlocker;
diff --git a/packages/applechu/src/platform/vfs.rs b/packages/applechu/src/platform/vfs.rs
index dd454b9..43057d7 100644
--- a/packages/applechu/src/platform/vfs.rs
+++ b/packages/applechu/src/platform/vfs.rs
@@ -1,6 +1,7 @@
 use std::ffi::CString;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Mutex, OnceLock};
 
 use once_cell::sync::OnceCell;
 
@@ -11,6 +12,8 @@ use crate::platform::{path_hook, winapi};
 use crate::util::api::Api;
 
 static CONFIG: OnceCell<VfsConfig> = OnceCell::new();
+/// option 根下的子树重定向：(小写目录名, 目标目录)
+static OPTION_OVERRIDES: OnceLock<Mutex<Vec<(String, String)>>> = OnceLock::new();
 static OPTION_API_LOGGED: AtomicBool = AtomicBool::new(false);
 static OPTION_PATH_LOGGED: AtomicBool = AtomicBool::new(false);
 
@@ -123,6 +126,11 @@ pub fn resolve_path(path: &str) -> Option<PathBuf> {
     if normalized == VFS_TMP_ICF && !config.allow_amfs_downloads {
         return Some(PathBuf::from(&config.appdata).join("tmpIcf.icf"));
     }
+    // 自定义 option 的挂载点优先于盘符映射：它的位置可能正好落在某个映射盘上，
+    // 未注册覆盖时返回 `None`，下面的分支一个都不少。
+    if let Some(target) = option_override(config, &normalized) {
+        return Some(target);
+    }
     if let Some(tail) = strip_drive(&normalized, 'e') {
         return Some(join_root(&config.amfs, tail));
     }
@@ -136,7 +144,7 @@ pub fn resolve_path(path: &str) -> Option<PathBuf> {
         return Some(join_root(&config.nthome, tail));
     }
     if let Some(tail) = strip_prefix_dir(&normalized, VFS_OPTION) {
-        return Some(join_root(&config.option, tail));
+        return Some(option_target(config, tail));
     }
     if let Some(tail) = strip_prefix_dir(&normalized, VFS_APM) {
         return Some(join_root(&config.option, tail));
@@ -144,6 +152,64 @@ pub fn resolve_path(path: &str) -> Option<PathBuf> {
     None
 }
 
+/// option 源路径 → 真实路径
+///
+/// 根下第一段命中自定义 option 覆盖时，该段**被替换**为解压目录（不是简单叠加），
+/// 其余路径原样接在后面；未命中时与没有覆盖时完全一致，落在配置的 option 根下。
+fn option_target(config: &VfsConfig, tail: &str) -> PathBuf {
+    if tail.is_empty() {
+        return PathBuf::from(&config.option);
+    }
+    let mut segments = tail.splitn(2, '\\');
+    let name = segments.next().unwrap_or_default().to_ascii_lowercase();
+    let rest = segments.next().unwrap_or_default();
+    match override_dir(&name) {
+        Some(target) => join_root(&target, rest),
+        None => join_root(&config.option, tail),
+    }
+}
+
+/// 命中挂载根（mount 根由本模块 hook 给出）的 option 子树
+///
+/// 与 [`option_target`] 同理：第一段被替换为解压目录。`normalized` 已小写，
+/// 因此比较也用小写。
+fn option_override(config: &VfsConfig, normalized: &str) -> Option<PathBuf> {
+    let option_root = config.option.trim_end_matches('\\').to_ascii_lowercase();
+    let tail = strip_prefix_dir(normalized, &option_root)?;
+    if tail.is_empty() {
+        return None;
+    }
+    let mut segments = tail.splitn(2, '\\');
+    let name = segments.next()?.to_ascii_lowercase();
+    let rest = segments.next().unwrap_or_default();
+    Some(join_root(&override_dir(&name)?, rest))
+}
+
+/// 查 option 根下某个子目录名的重定向目标（`None` 表示未挂载）
+fn override_dir(name: &str) -> Option<String> {
+    let overrides = OPTION_OVERRIDES.get()?.lock().ok()?;
+    overrides
+        .iter()
+        .find(|(candidate, _)| candidate == name)
+        .map(|(_, target)| target.clone())
+}
+
+/// 注册（或替换）option 根下一个子目录的重定向
+///
+/// 由服务器下发功能在解压完成后调用：`c:\mount\option\<name>\...` 将指向
+/// `target`，读取与枚举都由游戏走真实文件 API 完成。传空 `target` 注销。
+pub fn set_option_override(name: &str, target: &str) {
+    let overrides = OPTION_OVERRIDES.get_or_init(|| Mutex::new(Vec::new()));
+    let Ok(mut overrides) = overrides.lock() else {
+        return;
+    };
+    let key = name.trim_matches('\\').to_ascii_lowercase();
+    overrides.retain(|(candidate, _)| *candidate != key);
+    if !target.is_empty() {
+        overrides.push((key, winapi::fixup_path(Path::new(target))));
+    }
+}
+
 fn strip_drive(path: &str, drive: char) -> Option<&str> {
     let bytes = path.as_bytes();
     if bytes.len() < 2 || bytes[0] != drive as u8 || bytes[1] != b':' {
@@ -205,6 +271,14 @@ pub fn amfs_path() -> Option<String> {
     CONFIG.get().map(|config| config.amfs.clone())
 }
 
+/// 游戏原始请求中 option 的**源前缀**（重定向前），规范化小写
+///
+/// 游戏访问 option 时传入的是 `c:\mount\option\...`，`resolve_path` 之后才被
+/// 改写为真实目录；虚拟包匹配必须对源前缀做判断。
+pub fn option_source_prefix() -> String {
+    VFS_OPTION.to_owned()
+}
+
 pub fn appdata_path() -> Option<String> {
     CONFIG.get().map(|config| config.appdata.clone())
 }
diff --git a/packages/applechu/src/platform/vfs/tests.rs b/packages/applechu/src/platform/vfs/tests.rs
index d578c15..9bfa29d 100644
--- a/packages/applechu/src/platform/vfs/tests.rs
+++ b/packages/applechu/src/platform/vfs/tests.rs
@@ -1,7 +1,7 @@
 use std::fs;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use super::select_option_path;
+use super::{option_override, option_target, select_option_path, set_option_override, VfsConfig};
 
 #[test]
 fn configured_option_directory_wins_when_non_empty() {
@@ -56,6 +56,71 @@ fn missing_candidates_keep_configured_option_path() {
     remove_test_tree(&root);
 }
 
+#[test]
+fn option_override_redirects_only_the_mounted_subtree() {
+    // Given: 一个注册了重定向的自定义 option 根。
+    let config = test_config("override-only-mounted");
+    set_option_override("a9z1", "D:\\cache\\ServerResources.d\\A9Z1");
+
+    // Then: 该子树的任何路径都指向解压目录——无论游戏走源路径
+    //       (`c:\mount\option\...`) 还是 mount 根 (`<option>\...`) 拼路径。
+    let mounted = |rest: &str| {
+        std::path::PathBuf::from(format!("D:\\cache\\ServerResources.d\\A9Z1\\{rest}"))
+    };
+    assert_eq!(
+        option_target(&config, "a9z1\\music\\*"),
+        mounted("music\\*")
+    );
+    assert_eq!(
+        option_target(&config, "a9z1\\data.conf"),
+        mounted("data.conf")
+    );
+    assert_eq!(
+        option_override(&config, "d:\\game\\option\\a9z1\\music"),
+        Some(mounted("music"))
+    );
+
+    // 其他 option、option 根本身，以及未挂载的选项，行为完全不变。
+    assert_eq!(
+        option_target(&config, "a001\\music"),
+        std::path::PathBuf::from("D:\\game\\option\\a001\\music")
+    );
+    assert_eq!(
+        option_target(&config, ""),
+        std::path::PathBuf::from(&config.option)
+    );
+    assert_eq!(option_override(&config, "d:\\game\\option\\a001"), None);
+    assert_eq!(option_override(&config, "d:\\game\\option"), None);
+
+    set_option_override("a9z1", "");
+}
+
+#[test]
+fn clearing_an_override_restores_the_plain_option_root() {
+    // Given: 先注册再注销同名重定向。
+    let config = test_config("override-clear");
+    set_option_override("a9z2", "D:\\cache\\A9Z2");
+    set_option_override("a9z2", "");
+
+    // Then: 完全回到配置的 option 根，行为与没有覆盖时一致。
+    assert_eq!(
+        option_target(&config, "a9z2\\*"),
+        std::path::PathBuf::from("D:\\game\\option\\a9z2\\*")
+    );
+    assert_eq!(option_override(&config, "d:\\game\\option\\a9z2"), None);
+}
+
+/// 测试用的最小 VFS 配置（`option` 指向游戏目录下的 option）
+fn test_config(_case: &str) -> VfsConfig {
+    VfsConfig {
+        amfs: "D:\\game\\amfs\\".to_owned(),
+        option: "D:\\game\\option\\".to_owned(),
+        appdata: "D:\\game\\appdata\\".to_owned(),
+        nthome: "C:\\Users\\Default\\".to_owned(),
+        allow_amfs_downloads: false,
+    }
+}
+
 fn temporary_directory(case: &str) -> std::path::PathBuf {
     let nonce = SystemTime::now()
         .duration_since(UNIX_EPOCH)
diff --git a/packages/applechu/src/server_resources/deflate.rs b/packages/applechu/src/server_resources/deflate.rs
new file mode 100644
index 0000000..95fd785
--- /dev/null
+++ b/packages/applechu/src/server_resources/deflate.rs
@@ -0,0 +1,176 @@
+//! 解压：调用游戏自带的 zlib（`gm::Deflate` / `projClient::Deflate`）
+//!
+//! 资源包若使用 deflate 压缩，直接复用游戏内嵌的 zlib 1.2.8，不自写 inflate。
+//! 挂钩点选用游戏自己的高层封装 `sub_9AB850`（RVA `0x5AB850`）：它按 `__thiscall` 接收
+//! `(this, 输入 std::string*, 输出 std::string*)`，内部完成初始化、inflate
+//! 与结果赋值，因此不需要我们手工维护 `z_stream`。
+//!
+//! `this` 需要一个带虚表的对象（布局 `[vtable][z_stream]`，共 0x3C 字节），
+//! 虚表指针取自 IDA 里的 `off_18EFDBC`。
+
+use crate::util::pattern;
+
+/// `gm::Deflate` 的虚表（IDA: `off_18EFDBC`）
+const DEFLATE_VTABLE_RVA: usize = 0x14E_FDBC;
+/// 高层解压封装的函数头特征（`sub_9AB850`）
+const INFLATE_SIGNATURE: &str = concat!(
+    "55 8D AC 24 E4 DF FC FF B8 1C 20 03 00 E8 ?? ?? ?? ?? ",
+    "6A FF 68 ?? ?? ?? ?? 64 A1 00 00 00 00 50"
+);
+
+/// 对象大小：`[vtable]` + `z_stream`(0x38)
+const DEFLATE_OBJECT_SIZE: usize = 0x3C;
+/// MSVC `std::string` 对象大小
+const STD_STRING_SIZE: usize = 0x18;
+/// `_Myres` 达到该值表示数据在堆上
+const SSO_CAPACITY: u32 = 16;
+
+type InflateFn = unsafe extern "thiscall" fn(*mut u8, *mut u8, *mut u8) -> i32;
+
+/// 用游戏自带的 zlib 解压 `input`
+pub fn inflate(input: &[u8]) -> Result<Vec<u8>, String> {
+    let Some(api) = crate::util::api::API.get() else {
+        return Err("api handle is not available".to_owned());
+    };
+    let base = api.game_base();
+    if base == 0 {
+        return Err("game base is not available".to_owned());
+    }
+
+    let entry = pattern::scan(api, INFLATE_SIGNATURE);
+    if entry == 0 {
+        return Err("deflate entry signature not found".to_owned());
+    }
+    let vtable = base
+        .checked_add(DEFLATE_VTABLE_RVA)
+        .ok_or_else(|| "deflate vtable address overflowed".to_owned())?;
+
+    // 对象与两个 std::string 都放在本线程栈上；z_stream 由被调函数负责清零
+    let mut object = [0u8; DEFLATE_OBJECT_SIZE];
+    object[..4].copy_from_slice(&(vtable as u32).to_le_bytes());
+
+    let mut input_buffer = [0u8; STD_STRING_SIZE];
+    let mut output_buffer = [0u8; STD_STRING_SIZE];
+    unsafe {
+        std::ptr::write_bytes(output_buffer.as_mut_ptr(), 0, STD_STRING_SIZE);
+        layout_string(&mut input_buffer, input)?;
+        // 空输出的 `_Myres` 置 0，避免被调函数在赋值前尝试释放栈内存
+        output_buffer[0x14..0x18].copy_from_slice(&0u32.to_le_bytes());
+    }
+
+    let inflate: InflateFn = unsafe { std::mem::transmute(entry) };
+    let status = unsafe {
+        inflate(
+            object.as_mut_ptr(),
+            input_buffer.as_mut_ptr(),
+            output_buffer.as_mut_ptr(),
+        )
+    };
+
+    // 读出解压结果
+    let result = unsafe { read_string(&output_buffer) }
+        .ok_or_else(|| format!("deflate returned {status} without a usable output buffer"))?;
+
+    // 输出若落在堆上，用游戏的释放函数回收，避免每次解压泄漏
+    unsafe {
+        let capacity = u32::from_le_bytes(output_buffer[0x14..0x18].try_into().unwrap());
+        if capacity >= SSO_CAPACITY {
+            let pointer = u32::from_le_bytes(output_buffer[0..4].try_into().unwrap()) as usize;
+            deallocate(pointer, capacity as usize + 1);
+        }
+    }
+
+    if result.is_empty() && status != 1 {
+        return Err(format!("deflate failed with status {status}"));
+    }
+    Ok(result)
+}
+
+/// 在调用方缓冲区内布置一个指向 `data` 的 MSVC `std::string`
+///
+/// 使用「堆视图」布局（`_Myres >= 16`），让被调函数直接读 `_Bx._Ptr`；
+/// 这里只借用 `data` 的指针，不负责其生命周期。
+unsafe fn layout_string(buffer: &mut [u8; STD_STRING_SIZE], data: &[u8]) -> Result<(), String> {
+    let length = u32::try_from(data.len()).map_err(|_| "input is too large".to_owned())?;
+    buffer[0..4].copy_from_slice(&(data.as_ptr() as u32).to_le_bytes());
+    buffer[0x10..0x14].copy_from_slice(&length.to_le_bytes());
+    // 置为 SSO 上限以上的值，确保走指针路径且不被误判为可释放
+    buffer[0x14..0x18].copy_from_slice(&u32::MAX.to_le_bytes());
+    Ok(())
+}
+
+/// 读取 MSVC `std::string` 内容
+unsafe fn read_string(buffer: &[u8; STD_STRING_SIZE]) -> Option<Vec<u8>> {
+    let length = u32::from_le_bytes(buffer[0x10..0x14].try_into().ok()?) as usize;
+    if length == 0 {
+        return Some(Vec::new());
+    }
+    if length > 1 << 26 {
+        return None;
+    }
+    let capacity = u32::from_le_bytes(buffer[0x14..0x18].try_into().ok()?);
+    let data = if capacity >= SSO_CAPACITY {
+        u32::from_le_bytes(buffer[0..4].try_into().ok()?) as usize as *const u8
+    } else {
+        buffer.as_ptr()
+    };
+    if data.is_null() {
+        return None;
+    }
+    Some(std::slice::from_raw_parts(data, length).to_vec())
+}
+
+/// 释放游戏内嵌 zlib 分配的字符串缓冲（`std::string::_Deallocate`，`sub_448A31`）
+unsafe fn deallocate(pointer: usize, size: usize) {
+    if pointer == 0 {
+        return;
+    }
+    let Some(api) = crate::util::api::API.get() else {
+        return;
+    };
+    let base = api.game_base();
+    if base == 0 {
+        return;
+    }
+    let Some(free) = base.checked_add(0x48A31) else {
+        return;
+    };
+    let free: unsafe extern "cdecl" fn(usize, usize, usize) = std::mem::transmute(free);
+    free(pointer, size, 1);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn layouts_heap_backed_string_view() {
+        // Given: 一段输入数据。
+        let data = b"hello";
+        let mut buffer = [0u8; STD_STRING_SIZE];
+
+        // When: 布置成 std::string 视图。
+        unsafe { layout_string(&mut buffer, data).unwrap() };
+
+        // Then: 长度与指针写入正确，容量足以让被调函数走指针路径。
+        assert_eq!(
+            u32::from_le_bytes(buffer[0x10..0x14].try_into().unwrap()),
+            5
+        );
+        assert!(u32::from_le_bytes(buffer[0x14..0x18].try_into().unwrap()) >= SSO_CAPACITY);
+        assert_eq!(
+            u32::from_le_bytes(buffer[0..4].try_into().unwrap()) as usize,
+            data.as_ptr() as usize
+        );
+    }
+
+    #[test]
+    fn reads_inline_and_heap_strings() {
+        // Given: 一个内联存储的空字符串。
+        let mut inline = [0u8; STD_STRING_SIZE];
+        inline[0x14..0x18].copy_from_slice(&15u32.to_le_bytes());
+
+        // When/Then: 空长度读出空内容。
+        assert_eq!(unsafe { read_string(&inline) }, Some(Vec::new()));
+    }
+}
diff --git a/packages/applechu/src/server_resources/dispatcher.rs b/packages/applechu/src/server_resources/dispatcher.rs
new file mode 100644
index 0000000..5a71fdc
--- /dev/null
+++ b/packages/applechu/src/server_resources/dispatcher.rs
@@ -0,0 +1,116 @@
+//! 原生 API 分发器钩子
+//!
+//! 对应 AquaMai 的 `Packet::ProcImpl`。游戏在 `projClient` 的收包状态机里
+//! 先解密再分发：`sub_9A0AB0` 调 `sub_42FD83`（AES 解密）得到明文响应，
+//! 随即调 `sub_99FA60`（本模块挂钩的分发器）把 `(逻辑 API 名, 明文响应)`
+//! 交给具体 handler。
+//!
+//! 挂在这一层相比 WinHTTP 的优势：
+//! - 拿到的是**已解密的明文**，不需要自己调用 `gm::Aes`；
+//! - 拿到的是**逻辑 API 名**（如 `GetGameSettingApi`），不必从 URL 猜。
+//!
+//! ## 签名（2.50 实测，唯一匹配）
+//!
+//! `sub_99FA60` 是 `__thiscall`：`(this, apiName*, response*, out*)`，
+//! 前两个字符串参数是 MSVC `std::string`（`_Bx`@0，`_Mysize`@0x10，
+//! `_Myres`@0x14；`_Myres >= 16` 时数据在 `_Bx._Ptr`，否则在对象内）。
+
+use crate::util::api::Api;
+use crate::util::pattern;
+
+/// `sub_99FA60` 的函数头特征（本二进制唯一；栈 cookie 与 SEH 立刻数按 `??` 处理）
+const DISPATCHER_SIGNATURE: &str = concat!(
+    "55 8B EC 6A FF 68 ?? ?? ?? ?? 64 A1 00 00 00 00 50 ",
+    "83 EC 08 53 56 57 A1 ?? ?? ?? ?? 33 C5 50 8D 45 F4 ",
+    "64 A3 00 00 00 00 8B F9 8B 45 10 B9"
+);
+
+/// MSVC `std::string::_Myres` 达到该值表示数据在堆上
+const SSO_CAPACITY: u32 = 16;
+
+type DispatcherFn = unsafe extern "thiscall" fn(*mut u8, *mut u8, *mut u8, *mut u8) -> i32;
+
+static ORIGINAL: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+static TARGET: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+
+/// 安装分发器钩子，返回是否成功
+pub fn install(api: &Api) -> Result<(), String> {
+    let target = pattern::scan(api, DISPATCHER_SIGNATURE);
+    if target == 0 {
+        return Err("client dispatcher signature not found".to_owned());
+    }
+    let Some(trampoline) = api.hook_create(target, hooked_dispatcher as *const () as usize) else {
+        return Err("client dispatcher hook could not be created".to_owned());
+    };
+    if !api.hook_enable(target) {
+        api.hook_remove(target);
+        return Err("client dispatcher hook could not be enabled".to_owned());
+    }
+    ORIGINAL.store(trampoline, std::sync::atomic::Ordering::Release);
+    TARGET.store(target, std::sync::atomic::Ordering::Release);
+    api.log_info(&format!(
+        "ServerResources: client dispatcher hooked at 0x{target:08X}"
+    ));
+    Ok(())
+}
+
+pub fn shutdown() {
+    let target = TARGET.swap(0, std::sync::atomic::Ordering::AcqRel);
+    if target != 0 {
+        if let Some(api) = crate::util::api::API.get() {
+            api.hook_disable(target);
+            api.hook_remove(target);
+        }
+    }
+    ORIGINAL.store(0, std::sync::atomic::Ordering::Release);
+}
+
+/// 读取 MSVC `std::string` 的内容
+///
+/// # Safety
+/// `value` 必须指向有效的 `std::string` 对象
+unsafe fn read_std_string(value: *const u8) -> Option<String> {
+    if value.is_null() {
+        return None;
+    }
+    let length = std::ptr::read_unaligned(value.add(0x10).cast::<u32>()) as usize;
+    let capacity = std::ptr::read_unaligned(value.add(0x14).cast::<u32>());
+    if length == 0 {
+        return Some(String::new());
+    }
+    // 上限保护：异常长度不至于越界读取
+    if length > 1 << 20 {
+        return None;
+    }
+    let data = if capacity >= SSO_CAPACITY {
+        let pointer = std::ptr::read_unaligned(value.cast::<u32>()) as usize;
+        if pointer == 0 {
+            return None;
+        }
+        pointer as *const u8
+    } else {
+        value
+    };
+    let bytes = std::slice::from_raw_parts(data, length);
+    Some(String::from_utf8_lossy(bytes).into_owned())
+}
+
+unsafe extern "thiscall" fn hooked_dispatcher(
+    this: *mut u8,
+    api_name: *mut u8,
+    response: *mut u8,
+    out: *mut u8,
+) -> i32 {
+    let original = ORIGINAL.load(std::sync::atomic::Ordering::Acquire);
+    if original == 0 {
+        return 0;
+    }
+    let original: DispatcherFn = std::mem::transmute(original);
+
+    // 读逻辑 API 名与响应（失败则原样放行）
+    if let (Some(name), Some(body)) = (read_std_string(api_name), read_std_string(response)) {
+        crate::server_resources::on_net_response(&name, &body);
+    }
+
+    original(this, api_name, response, out)
+}
diff --git a/packages/applechu/src/server_resources/download.rs b/packages/applechu/src/server_resources/download.rs
new file mode 100644
index 0000000..758f02a
--- /dev/null
+++ b/packages/applechu/src/server_resources/download.rs
@@ -0,0 +1,260 @@
+//! 资源包下载
+//!
+//! 使用进程内的 WinHTTP 直接下载，不经过游戏的连接池，也不硬编码服务器地址
+//! （地址来自服务器下发的 `entry.url`）。对应 AquaMai `GetFileImpl` 的下载段。
+
+use std::ffi::c_void;
+use std::ptr;
+
+use windows_sys::Win32::Networking::WinHttp::{
+    WinHttpCloseHandle, WinHttpConnect, WinHttpOpen, WinHttpOpenRequest, WinHttpQueryDataAvailable,
+    WinHttpReadData, WinHttpReceiveResponse, WinHttpSendRequest, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
+    WINHTTP_FLAG_SECURE, WINHTTP_FLAG_SECURE_DEFAULTS,
+};
+
+/// 单个响应体的上限，避免异常响应耗尽内存
+const MAX_DOWNLOAD: usize = 256 * 1024 * 1024;
+/// 网络超时（毫秒）：连接 / 发送 / 接收
+const TIMEOUT_MS: i32 = 30_000;
+const WINHTTP_OPTION_CONNECT_TIMEOUT: u32 = 3;
+const WINHTTP_OPTION_SEND_TIMEOUT: u32 = 4;
+const WINHTTP_OPTION_RECEIVE_TIMEOUT: u32 = 5;
+
+/// 下载 `url` 指向的资源包
+pub fn download(url: &str) -> Result<Vec<u8>, String> {
+    let parsed = ParsedUrl::parse(url)?;
+    let agent_name = crate::platform::winapi::string_to_wide("AppleChu");
+    let server = crate::platform::winapi::string_to_wide(&parsed.host);
+    let path = crate::platform::winapi::string_to_wide(&parsed.path_and_query);
+
+    unsafe {
+        let session = WinHttpOpen(
+            agent_name.as_ptr(),
+            WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
+            ptr::null(),
+            ptr::null(),
+            0,
+        );
+        if session.is_null() {
+            return Err("WinHttpOpen failed".to_owned());
+        }
+
+        let result = (|| -> Result<Vec<u8>, String> {
+            apply_timeout(session)?;
+
+            let connect = WinHttpConnect(session, server.as_ptr(), parsed.port, 0);
+            if connect.is_null() {
+                return Err(format!("WinHttpConnect failed for {}", parsed.host));
+            }
+
+            let request_result = (|| -> Result<Vec<u8>, String> {
+                let flags = if parsed.secure {
+                    WINHTTP_FLAG_SECURE | WINHTTP_FLAG_SECURE_DEFAULTS
+                } else {
+                    0
+                };
+                let request = WinHttpOpenRequest(
+                    connect,
+                    ptr::null(),
+                    path.as_ptr(),
+                    ptr::null(),
+                    ptr::null(),
+                    ptr::null(),
+                    flags,
+                );
+                if request.is_null() {
+                    return Err("WinHttpOpenRequest failed".to_owned());
+                }
+
+                let body_result = (|| -> Result<Vec<u8>, String> {
+                    if WinHttpSendRequest(request, ptr::null(), 0, ptr::null(), 0, 0, 0) == 0 {
+                        return Err("WinHttpSendRequest failed".to_owned());
+                    }
+                    if WinHttpReceiveResponse(request, ptr::null_mut()) == 0 {
+                        return Err("WinHttpReceiveResponse failed".to_owned());
+                    }
+
+                    let status = query_status(request);
+                    if !(200..300).contains(&status) {
+                        return Err(format!("download returned HTTP {status}"));
+                    }
+
+                    let mut body = Vec::new();
+                    loop {
+                        let mut available = 0u32;
+                        if WinHttpQueryDataAvailable(request, &mut available) == 0 {
+                            return Err("WinHttpQueryDataAvailable failed".to_owned());
+                        }
+                        if available == 0 {
+                            break;
+                        }
+                        let mut chunk = vec![0u8; available as usize];
+                        let mut read = 0u32;
+                        if WinHttpReadData(
+                            request,
+                            chunk.as_mut_ptr().cast::<c_void>(),
+                            available,
+                            &mut read,
+                        ) == 0
+                        {
+                            return Err("WinHttpReadData failed".to_owned());
+                        }
+                        if read == 0 {
+                            break;
+                        }
+                        if body.len() + read as usize > MAX_DOWNLOAD {
+                            return Err("download exceeded size limit".to_owned());
+                        }
+                        chunk.truncate(read as usize);
+                        body.extend_from_slice(&chunk);
+                    }
+                    Ok(body)
+                })();
+
+                WinHttpCloseHandle(request);
+                body_result
+            })();
+
+            WinHttpCloseHandle(connect);
+            request_result
+        })();
+
+        WinHttpCloseHandle(session);
+        result
+    }
+}
+
+/// 设置连接/发送/接收超时；失败不致命，仅在无超时保护下继续
+unsafe fn apply_timeout(session: *mut c_void) -> Result<(), String> {
+    use windows_sys::Win32::Networking::WinHttp::WinHttpSetOption;
+    let value = TIMEOUT_MS;
+    for option in [
+        WINHTTP_OPTION_CONNECT_TIMEOUT,
+        WINHTTP_OPTION_SEND_TIMEOUT,
+        WINHTTP_OPTION_RECEIVE_TIMEOUT,
+    ] {
+        let ok = WinHttpSetOption(
+            session,
+            option,
+            (&value as *const i32).cast::<c_void>(),
+            std::mem::size_of::<i32>() as u32,
+        );
+        if ok == 0 {
+            return Err(format!("WinHttpSetOption({option}) failed"));
+        }
+    }
+    Ok(())
+}
+
+/// 读取 HTTP 状态码；失败按 0 处理，交由范围判断拒绝
+unsafe fn query_status(request: *mut c_void) -> u32 {
+    use windows_sys::Win32::Networking::WinHttp::{
+        WinHttpQueryHeaders, WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_QUERY_STATUS_CODE,
+    };
+    let mut status = 0u32;
+    let mut length = std::mem::size_of::<u32>() as u32;
+    let ok = WinHttpQueryHeaders(
+        request,
+        WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
+        ptr::null(),
+        (&mut status as *mut u32).cast::<c_void>(),
+        &mut length,
+        ptr::null_mut(),
+    );
+    if ok == 0 {
+        0
+    } else {
+        status
+    }
+}
+
+/// 仅支持 http/https 的简化 URL 分解
+struct ParsedUrl {
+    secure: bool,
+    host: String,
+    port: u16,
+    path_and_query: String,
+}
+
+impl ParsedUrl {
+    fn parse(url: &str) -> Result<Self, String> {
+        let (secure, rest) = if let Some(rest) = url.strip_prefix("https://") {
+            (true, rest)
+        } else if let Some(rest) = url.strip_prefix("http://") {
+            (false, rest)
+        } else {
+            return Err(format!("unsupported url scheme: {url}"));
+        };
+
+        let (authority, path_and_query) = match rest.find('/') {
+            Some(index) => (&rest[..index], &rest[index..]),
+            None => (rest, "/"),
+        };
+        if authority.is_empty() {
+            return Err(format!("url has no host: {url}"));
+        }
+
+        let (host, port) = match authority.rsplit_once(':') {
+            Some((host, port)) => {
+                let port = port
+                    .parse::<u16>()
+                    .map_err(|_| format!("invalid port in url: {url}"))?;
+                (host.to_owned(), port)
+            }
+            None => (authority.to_owned(), if secure { 443 } else { 80 }),
+        };
+
+        Ok(Self {
+            secure,
+            host,
+            port,
+            path_and_query: path_and_query.to_owned(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_https_url_with_default_port() {
+        // Given: 无显式端口的 https 地址。
+        let parsed = ParsedUrl::parse("https://play.mumet.net/pack/option.bin").unwrap();
+
+        // Then: 使用 443 且保留完整路径。
+        assert!(parsed.secure);
+        assert_eq!(parsed.host, "play.mumet.net");
+        assert_eq!(parsed.port, 443);
+        assert_eq!(parsed.path_and_query, "/pack/option.bin");
+    }
+
+    #[test]
+    fn parses_http_url_with_query_and_explicit_port() {
+        // Given: 带查询串与显式端口的 http 地址。
+        let parsed = ParsedUrl::parse("http://127.0.0.1:8080/a/b?c=d").unwrap();
+
+        // Then: 端口与查询串被正确分离。
+        assert!(!parsed.secure);
+        assert_eq!(parsed.host, "127.0.0.1");
+        assert_eq!(parsed.port, 8080);
+        assert_eq!(parsed.path_and_query, "/a/b?c=d");
+    }
+
+    #[test]
+    fn missing_path_defaults_to_root() {
+        // Given: 只有主机名的地址。
+        let parsed = ParsedUrl::parse("https://example.com").unwrap();
+
+        // Then: 路径补为 `/`。
+        assert_eq!(parsed.path_and_query, "/");
+    }
+
+    #[test]
+    fn rejects_unsupported_scheme() {
+        // Given: 非 http(s) 地址。
+        // Then: 解析失败，避免把任意协议交给 WinHTTP。
+        assert!(ParsedUrl::parse("ftp://example.com/a").is_err());
+        assert!(ParsedUrl::parse("file:///c:/x").is_err());
+    }
+}
diff --git a/packages/applechu/src/server_resources/entry.rs b/packages/applechu/src/server_resources/entry.rs
new file mode 100644
index 0000000..135af10
--- /dev/null
+++ b/packages/applechu/src/server_resources/entry.rs
@@ -0,0 +1,299 @@
+//! 服务器下发条目与条件筛选
+//!
+//! 对应 `<field>.entries[]` 中的单个条目，以及 AquaMai
+//! `ConditionalMessage.ShouldShow()` 的等价判定。
+//!
+//! 字段名与 AquaMai 保持一致，只替换品牌前缀：`_appleChuResources` /
+//! `minimumAppleChuVersion` / `maximumAppleChuVersion`，其余（`url` / `sign` /
+//! `locales` / `minimumGameVersion` / `maximumGameVersion`）完全相同。
+
+use crate::server_resources::json::JsonValue;
+
+/// 单个下发条目
+#[derive(Clone, Debug, Default)]
+pub struct ServerResourcesEntry {
+    pub url: String,
+    pub sign: String,
+    pub locales: Vec<String>,
+    pub minimum_apple_chu_version: Option<String>,
+    pub maximum_apple_chu_version: Option<String>,
+    pub minimum_game_version: i64,
+    pub maximum_game_version: i64,
+}
+
+impl ServerResourcesEntry {
+    /// 从 JSON 对象解析；缺少 `url` 或 `sign` 视为无效条目
+    ///
+    /// 字段名按「AppleChu 优先、AquaMai 兼容」读取：同一份响应里两种命名
+    /// 都能生效，方便服务端一次性同时服务 AquaMai 与 AppleChu。
+    pub fn from_json(value: &JsonValue) -> Option<Self> {
+        let url = value.get("url").and_then(JsonValue::as_str)?;
+        let sign = value.get("sign").and_then(JsonValue::as_str)?;
+        if url.is_empty() || sign.is_empty() {
+            return None;
+        }
+
+        Some(Self {
+            url: url.to_owned(),
+            sign: sign.to_owned(),
+            locales: value
+                .get("locales")
+                .map(JsonValue::string_array)
+                .unwrap_or_default(),
+            minimum_apple_chu_version: optional_string_any(
+                value,
+                &["minimumAppleChuVersion", "minimumAquaMaiVersion"],
+            ),
+            maximum_apple_chu_version: optional_string_any(
+                value,
+                &["maximumAppleChuVersion", "maximumAquaMaiVersion"],
+            ),
+            minimum_game_version: value
+                .get("minimumGameVersion")
+                .and_then(JsonValue::as_i64)
+                .unwrap_or(0),
+            maximum_game_version: value
+                .get("maximumGameVersion")
+                .and_then(JsonValue::as_i64)
+                .unwrap_or(0),
+        })
+    }
+
+    /// 当前环境是否满足该条目的条件
+    ///
+    /// - `locales`：本期不筛（AppleChu 尚无语言来源），字段保留待后续接入；
+    /// - AppleChu 版本：按 semver 数值比较；
+    /// - 游戏版本：按整数比较，0 表示不限制。
+    pub fn should_show(&self, locale: Option<&str>, game_version: i64) -> bool {
+        if !locale_matches(&self.locales, locale) {
+            return false;
+        }
+
+        let apple_chu_version = env!("CARGO_PKG_VERSION");
+        if let Some(minimum) = &self.minimum_apple_chu_version {
+            if !version_at_least(apple_chu_version, minimum) {
+                return false;
+            }
+        }
+        if let Some(maximum) = &self.maximum_apple_chu_version {
+            if version_greater(apple_chu_version, maximum) {
+                return false;
+            }
+        }
+
+        if self.minimum_game_version != 0 && game_version < self.minimum_game_version {
+            return false;
+        }
+        if self.maximum_game_version != 0 && game_version > self.maximum_game_version {
+            return false;
+        }
+
+        true
+    }
+}
+
+/// 从 `_appleChuResources` 根对象取出全部条目
+pub fn parse_entries(resources: &JsonValue) -> Vec<ServerResourcesEntry> {
+    resources
+        .get("entries")
+        .and_then(JsonValue::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(ServerResourcesEntry::from_json)
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// 选出第一个满足条件的条目
+pub fn select_entry<'a>(
+    entries: &'a [ServerResourcesEntry],
+    locale: Option<&str>,
+    game_version: i64,
+) -> Option<&'a ServerResourcesEntry> {
+    entries
+        .iter()
+        .find(|entry| entry.should_show(locale, game_version))
+}
+
+/// 按候选键顺序取第一个非空字符串（AppleChu 键优先，AquaMai 键兜底）
+fn optional_string_any(value: &JsonValue, keys: &[&str]) -> Option<String> {
+    keys.iter().find_map(|key| {
+        value
+            .get(key)
+            .and_then(JsonValue::as_str)
+            .map(str::trim)
+            .filter(|text| !text.is_empty())
+            .map(ToOwned::to_owned)
+    })
+}
+
+/// 语言筛选：空列表表示不限制
+///
+/// 当前客户端尚未解析机台语言，`locale` 恒为 `None`，此时不因语言排除条目。
+fn locale_matches(locales: &[String], locale: Option<&str>) -> bool {
+    if locales.is_empty() {
+        return true;
+    }
+    match locale {
+        Some(current) => locales
+            .iter()
+            .any(|item| item.eq_ignore_ascii_case(current)),
+        // 无语言来源时不做排除，避免误杀全部条目
+        None => true,
+    }
+}
+
+/// 解析 `major.minor.patch` 为可比较的三元组
+fn parse_version(text: &str) -> Option<(u32, u32, u32)> {
+    let mut parts = text.trim().split('.');
+    let major = parts.next()?.parse::<u32>().ok()?;
+    let minor = parts.next().unwrap_or("0").parse::<u32>().unwrap_or(0);
+    let patch = parts.next().unwrap_or("0").parse::<u32>().unwrap_or(0);
+    Some((major, minor, patch))
+}
+
+/// `current >= minimum`；任一侧无法解析时视为满足，避免因版本串怪异而误杀
+fn version_at_least(current: &str, minimum: &str) -> bool {
+    match (parse_version(current), parse_version(minimum)) {
+        (Some(current), Some(minimum)) => current >= minimum,
+        _ => true,
+    }
+}
+
+/// `current > maximum`；任一侧无法解析时视为不超限
+fn version_greater(current: &str, maximum: &str) -> bool {
+    match (parse_version(current), parse_version(maximum)) {
+        (Some(current), Some(maximum)) => current > maximum,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::server_resources::json;
+
+    fn entry_from(text: &str) -> ServerResourcesEntry {
+        let value = json::parse(text).expect("测试 JSON 必须有效");
+        ServerResourcesEntry::from_json(&value).expect("测试条目必须有效")
+    }
+
+    #[test]
+    fn parses_full_entry() {
+        // Given: 服务器返回的完整条目。
+        let entry = entry_from(
+            r#"{"url":"https://example/option.bin","sign":"AAAA","locales":["zh"],
+                "minimumAppleChuVersion":"2.0.0","maximumAppleChuVersion":null,
+                "minimumGameVersion":25000,"maximumGameVersion":0}"#,
+        );
+
+        // Then: 字段逐项落入结构体。
+        assert_eq!(entry.url, "https://example/option.bin");
+        assert_eq!(entry.locales, vec!["zh".to_owned()]);
+        assert_eq!(entry.minimum_game_version, 25000);
+        assert_eq!(entry.maximum_game_version, 0);
+        assert!(entry.maximum_apple_chu_version.is_none());
+    }
+
+    #[test]
+    fn entry_without_signature_is_rejected() {
+        // Given: 缺 sign 的条目。
+        // Then: 解析失败，避免无签名内容进入下载流程。
+        let value = json::parse(r#"{"url":"https://example/option.bin"}"#).unwrap();
+        assert!(ServerResourcesEntry::from_json(&value).is_none());
+    }
+
+    #[test]
+    fn accepts_aquamai_version_field_names() {
+        // Given: 服务端按 AquaMai 命名下发版本范围（同一份响应同时服务两个客户端）。
+        let entry = entry_from(
+            r#"{"url":"u","sign":"s","minimumAquaMaiVersion":"2.0.0","maximumAquaMaiVersion":"9.9.9"}"#,
+        );
+
+        // Then: 兼容读取，语义与 AppleChu 命名一致。
+        assert_eq!(entry.minimum_apple_chu_version.as_deref(), Some("2.0.0"));
+        assert_eq!(entry.maximum_apple_chu_version.as_deref(), Some("9.9.9"));
+        assert!(entry.should_show(None, 0));
+    }
+
+    #[test]
+    fn apple_chu_field_names_take_priority() {
+        // Given: 两种命名同时出现。
+        let entry = entry_from(
+            r#"{"url":"u","sign":"s","minimumAppleChuVersion":"2.0.0","minimumAquaMaiVersion":"9.0.0"}"#,
+        );
+
+        // Then: 取 AppleChu 命名，不因兼容读取而放宽条件。
+        assert_eq!(entry.minimum_apple_chu_version.as_deref(), Some("2.0.0"));
+    }
+
+    #[test]
+    fn game_version_range_filters_entries() {
+        // Given: 限制游戏版本 25000 及以上的条目。
+        let entry = entry_from(
+            r#"{"url":"u","sign":"s","minimumGameVersion":25000,"maximumGameVersion":25099}"#,
+        );
+
+        // Then: 只有落在区间内的版本命中。
+        assert!(entry.should_show(None, 25000));
+        assert!(entry.should_show(None, 25099));
+        assert!(!entry.should_show(None, 24999));
+        assert!(!entry.should_show(None, 25100));
+    }
+
+    #[test]
+    fn zero_game_version_means_unrestricted() {
+        // Given: 未限制游戏版本的条目。
+        let entry = entry_from(r#"{"url":"u","sign":"s"}"#);
+
+        // Then: 任意游戏版本都命中。
+        assert!(entry.should_show(None, 0));
+        assert!(entry.should_show(None, 999999));
+    }
+
+    #[test]
+    fn apple_chu_version_range_is_compared_semantically() {
+        // Given: 上限低于当前版本（2.1.0）的条目，以及下限高于当前版本的条目。
+        let too_new = entry_from(r#"{"url":"u","sign":"s","maximumAppleChuVersion":"1.9.9"}"#);
+        let too_old = entry_from(r#"{"url":"u","sign":"s","minimumAppleChuVersion":"9.0.0"}"#);
+
+        // Then: 两者都被排除；宽区间则命中。
+        assert!(!too_new.should_show(None, 0));
+        assert!(!too_old.should_show(None, 0));
+        assert!(
+            entry_from(r#"{"url":"u","sign":"s","minimumAppleChuVersion":"2.0.0"}"#)
+                .should_show(None, 0)
+        );
+    }
+
+    #[test]
+    fn empty_locales_do_not_restrict() {
+        // Given: 未声明语言的条目。
+        let entry = entry_from(r#"{"url":"u","sign":"s"}"#);
+
+        // Then: 有无语言信息都命中。
+        assert!(entry.should_show(None, 0));
+        assert!(entry.should_show(Some("zh"), 0));
+    }
+
+    #[test]
+    fn select_entry_skips_non_matching_entries() {
+        // Given: 首条被版本排除，次条可用。
+        let value = json::parse(
+            r#"{"entries":[
+                {"url":"a","sign":"s","minimumGameVersion":999999},
+                {"url":"b","sign":"s"}
+            ]}"#,
+        )
+        .unwrap();
+        let entries = parse_entries(&value);
+
+        // When: 选出唯一条目。
+        let selected = select_entry(&entries, None, 25000).expect("应选中第二条");
+
+        // Then: 得到第一条可用条目。
+        assert_eq!(selected.url, "b");
+    }
+}
diff --git a/packages/applechu/src/server_resources/json.rs b/packages/applechu/src/server_resources/json.rs
new file mode 100644
index 0000000..d7caf61
--- /dev/null
+++ b/packages/applechu/src/server_resources/json.rs
@@ -0,0 +1,415 @@
+//! 最小 JSON 解析与序列化
+//!
+//! 仅覆盖网络响应改写所需的能力，不引入第三方依赖：
+//! - 解析对象 / 数组 / 字符串 / 数字 / 布尔 / null；
+//! - 保留对象键顺序，数字以原始字面量保存，保证未修改内容可逐字节回写；
+//! - 数字读取对「数字被序列化成字符串」的场景保持宽松（MinatoCore 的
+//!   SegaStringSerializer 会把整数写成 `"25000"`）。
+
+use std::fmt::Write as _;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum JsonValue {
+    Null,
+    Bool(bool),
+    /// 数字保留原始字面量，避免浮点往返丢失精度
+    Number(String),
+    String(String),
+    Array(Vec<JsonValue>),
+    Object(Vec<(String, JsonValue)>),
+}
+
+impl JsonValue {
+    /// 按键取值；非对象返回 `None`
+    pub fn get(&self, key: &str) -> Option<&JsonValue> {
+        match self {
+            JsonValue::Object(entries) => entries
+                .iter()
+                .find(|(name, _)| name == key)
+                .map(|(_, value)| value),
+            _ => None,
+        }
+    }
+
+    pub fn as_array(&self) -> Option<&[JsonValue]> {
+        match self {
+            JsonValue::Array(items) => Some(items),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            JsonValue::String(value) => Some(value),
+            _ => None,
+        }
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            JsonValue::Bool(value) => Some(*value),
+            // 兼容布尔被写成字符串
+            JsonValue::String(value) => match value.trim() {
+                "true" | "1" => Some(true),
+                "false" | "0" => Some(false),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    /// 读取整数；数字或数字字符串均可接受
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            JsonValue::Number(text) => text.trim().parse::<i64>().ok(),
+            JsonValue::String(text) => text.trim().parse::<i64>().ok(),
+            _ => None,
+        }
+    }
+
+    /// 读取字符串数组；非数组返回空切片语义（调用方按「不限制」处理）
+    pub fn string_array(&self) -> Vec<String> {
+        self.as_array()
+            .map(|items| {
+                items
+                    .iter()
+                    .filter_map(|item| item.as_str().map(ToOwned::to_owned))
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    fn write_to(&self, output: &mut String) {
+        match self {
+            JsonValue::Null => output.push_str("null"),
+            JsonValue::Bool(true) => output.push_str("true"),
+            JsonValue::Bool(false) => output.push_str("false"),
+            JsonValue::Number(text) => output.push_str(text),
+            JsonValue::String(value) => write_json_string(value, output),
+            JsonValue::Array(items) => {
+                output.push('[');
+                for (index, item) in items.iter().enumerate() {
+                    if index > 0 {
+                        output.push(',');
+                    }
+                    item.write_to(output);
+                }
+                output.push(']');
+            }
+            JsonValue::Object(entries) => {
+                output.push('{');
+                for (index, (key, value)) in entries.iter().enumerate() {
+                    if index > 0 {
+                        output.push(',');
+                    }
+                    write_json_string(key, output);
+                    output.push(':');
+                    value.write_to(output);
+                }
+                output.push('}');
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for JsonValue {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut output = String::new();
+        self.write_to(&mut output);
+        formatter.write_str(&output)
+    }
+}
+
+fn write_json_string(value: &str, output: &mut String) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            '\u{08}' => output.push_str("\\b"),
+            '\u{0c}' => output.push_str("\\f"),
+            control if (control as u32) < 0x20 => {
+                let _ = write!(output, "\\u{:04x}", control as u32);
+            }
+            other => output.push(other),
+        }
+    }
+    output.push('"');
+}
+
+/// 解析 JSON 文本；失败返回 `None`
+pub fn parse(text: &str) -> Option<JsonValue> {
+    let mut parser = Parser {
+        bytes: text.as_bytes(),
+        position: 0,
+    };
+    parser.skip_whitespace();
+    let value = parser.parse_value()?;
+    parser.skip_whitespace();
+    // 尾部只允许空白，避免把不完整解析当成成功
+    (parser.position == parser.bytes.len()).then_some(value)
+}
+
+struct Parser<'a> {
+    bytes: &'a [u8],
+    position: usize,
+}
+
+impl Parser<'_> {
+    fn skip_whitespace(&mut self) {
+        while let Some(byte) = self.bytes.get(self.position) {
+            if matches!(byte, b' ' | b'\t' | b'\n' | b'\r') {
+                self.position += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn peek(&self) -> Option<u8> {
+        self.bytes.get(self.position).copied()
+    }
+
+    fn parse_value(&mut self) -> Option<JsonValue> {
+        match self.peek()? {
+            b'{' => self.parse_object(),
+            b'[' => self.parse_array(),
+            b'"' => self.parse_string().map(JsonValue::String),
+            b't' => self.parse_literal("true", JsonValue::Bool(true)),
+            b'f' => self.parse_literal("false", JsonValue::Bool(false)),
+            b'n' => self.parse_literal("null", JsonValue::Null),
+            _ => self.parse_number(),
+        }
+    }
+
+    fn parse_literal(&mut self, literal: &str, value: JsonValue) -> Option<JsonValue> {
+        let end = self.position.checked_add(literal.len())?;
+        (self.bytes.get(self.position..end)? == literal.as_bytes()).then(|| {
+            self.position = end;
+            value
+        })
+    }
+
+    fn parse_object(&mut self) -> Option<JsonValue> {
+        self.position += 1; // 跳过 '{'
+        let mut entries = Vec::new();
+        self.skip_whitespace();
+        if self.peek()? == b'}' {
+            self.position += 1;
+            return Some(JsonValue::Object(entries));
+        }
+        loop {
+            self.skip_whitespace();
+            let key = self.parse_string()?;
+            self.skip_whitespace();
+            if self.peek()? != b':' {
+                return None;
+            }
+            self.position += 1;
+            self.skip_whitespace();
+            let value = self.parse_value()?;
+            entries.push((key, value));
+            self.skip_whitespace();
+            match self.peek()? {
+                b',' => self.position += 1,
+                b'}' => {
+                    self.position += 1;
+                    return Some(JsonValue::Object(entries));
+                }
+                _ => return None,
+            }
+        }
+    }
+
+    fn parse_array(&mut self) -> Option<JsonValue> {
+        self.position += 1; // 跳过 '['
+        let mut items = Vec::new();
+        self.skip_whitespace();
+        if self.peek()? == b']' {
+            self.position += 1;
+            return Some(JsonValue::Array(items));
+        }
+        loop {
+            self.skip_whitespace();
+            items.push(self.parse_value()?);
+            self.skip_whitespace();
+            match self.peek()? {
+                b',' => self.position += 1,
+                b']' => {
+                    self.position += 1;
+                    return Some(JsonValue::Array(items));
+                }
+                _ => return None,
+            }
+        }
+    }
+
+    fn parse_string(&mut self) -> Option<String> {
+        if self.peek()? != b'"' {
+            return None;
+        }
+        self.position += 1;
+        let mut output = String::new();
+        loop {
+            let byte = self.peek()?;
+            self.position += 1;
+            match byte {
+                b'"' => return Some(output),
+                b'\\' => {
+                    let escape = self.peek()?;
+                    self.position += 1;
+                    match escape {
+                        b'"' => output.push('"'),
+                        b'\\' => output.push('\\'),
+                        b'/' => output.push('/'),
+                        b'b' => output.push('\u{08}'),
+                        b'f' => output.push('\u{0c}'),
+                        b'n' => output.push('\n'),
+                        b'r' => output.push('\r'),
+                        b't' => output.push('\t'),
+                        b'u' => output.push(self.parse_unicode_escape()?),
+                        _ => return None,
+                    }
+                }
+                // 多字节 UTF-8 序列：按首字节长度整体复制
+                other if other < 0x80 => output.push(other as char),
+                other => {
+                    let extra = match other {
+                        0xC0..=0xDF => 1,
+                        0xE0..=0xEF => 2,
+                        0xF0..=0xF7 => 3,
+                        _ => return None,
+                    };
+                    let start = self.position - 1;
+                    let end = start.checked_add(extra + 1)?;
+                    let slice = self.bytes.get(start..end)?;
+                    output.push_str(std::str::from_utf8(slice).ok()?);
+                    self.position = end;
+                }
+            }
+        }
+    }
+
+    fn parse_unicode_escape(&mut self) -> Option<char> {
+        let hex = self.bytes.get(self.position..self.position + 4)?;
+        let code = u32::from_str_radix(std::str::from_utf8(hex).ok()?, 16).ok()?;
+        self.position += 4;
+        // 代理对：高代理后必须紧跟 `\uXXXX` 低代理
+        if (0xD800..0xDC00).contains(&code) {
+            if self.bytes.get(self.position..self.position + 2)? != b"\\u" {
+                return None;
+            }
+            self.position += 2;
+            let low_hex = self.bytes.get(self.position..self.position + 4)?;
+            let low = u32::from_str_radix(std::str::from_utf8(low_hex).ok()?, 16).ok()?;
+            self.position += 4;
+            let combined = 0x1_0000 + ((code - 0xD800) << 10) + (low - 0xDC00);
+            char::from_u32(combined)
+        } else {
+            char::from_u32(code)
+        }
+    }
+
+    fn parse_number(&mut self) -> Option<JsonValue> {
+        let start = self.position;
+        while let Some(byte) = self.peek() {
+            if matches!(byte, b'-' | b'+' | b'.' | b'e' | b'E' | b'0'..=b'9') {
+                self.position += 1;
+            } else {
+                break;
+            }
+        }
+        if start == self.position {
+            return None;
+        }
+        let text = std::str::from_utf8(self.bytes.get(start..self.position)?).ok()?;
+        Some(JsonValue::Number(text.to_owned()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_nested_objects_and_arrays() {
+        // Given: 带嵌套的响应片段。
+        let text = r#"{"a":{"b":[1,2,{"c":"d"}]},"e":null}"#;
+
+        // When: 解析后按键逐层取值。
+        let value = parse(text).expect("有效 JSON 必须解析成功");
+
+        // Then: 结构与取值符合预期。
+        let array = value
+            .get("a")
+            .and_then(|a| a.get("b"))
+            .and_then(JsonValue::as_array)
+            .expect("嵌套数组必须存在");
+        assert_eq!(array.len(), 3);
+        assert_eq!(array[0].as_i64(), Some(1));
+        assert_eq!(array[2].get("c").and_then(JsonValue::as_str), Some("d"));
+        assert_eq!(value.get("e"), Some(&JsonValue::Null));
+    }
+
+    #[test]
+    fn round_trips_without_changing_bytes() {
+        // Given: 一段格式紧凑的响应。
+        let text = r#"{"gameSetting":{"dataVersion":"2.50.01","maxCountMusic":300},"isAou":false}"#;
+
+        // When: 解析再序列化。
+        let value = parse(text).expect("有效 JSON 必须解析成功");
+
+        // Then: 输出与输入逐字节一致（键顺序与数字字面量都保留）。
+        assert_eq!(value.to_string(), text);
+    }
+
+    #[test]
+    fn accepts_numbers_serialized_as_strings() {
+        // Given: MinatoCore 会把整数写成字符串。
+        let text = r#"{"minimumGameVersion":"25000"}"#;
+
+        // When: 读取该字段。
+        let value = parse(text).expect("有效 JSON 必须解析成功");
+
+        // Then: 宽松读取仍能得到整数。
+        assert_eq!(
+            value.get("minimumGameVersion").and_then(JsonValue::as_i64),
+            Some(25000)
+        );
+    }
+
+    #[test]
+    fn decodes_escapes_and_surrogate_pairs() {
+        // Given: 含转义与代理对的字符串。
+        let text = r#"{"s":"a\"b\\c中😀"}"#;
+
+        // When: 解析。
+        let value = parse(text).expect("有效 JSON 必须解析成功");
+
+        // Then: 转义与代理对都被正确还原。
+        assert_eq!(
+            value.get("s").and_then(JsonValue::as_str),
+            Some("a\"b\\c中😀")
+        );
+    }
+
+    #[test]
+    fn rejects_trailing_garbage() {
+        // Given: 合法值后跟随多余内容。
+        // Then: 解析失败，避免把截断响应当成完整数据。
+        assert!(parse(r#"{"a":1} extra"#).is_none());
+        assert!(parse(r#"{"a":}"#).is_none());
+    }
+
+    #[test]
+    fn missing_field_is_none() {
+        // Given: 服务器未下发该字段的响应。
+        let value = parse(r#"{"gameSetting":{}}"#).expect("有效 JSON 必须解析成功");
+
+        // Then: 缺失字段返回 None，调用方据此跳过处理。
+        assert!(value.get("_appleChuResources").is_none());
+    }
+}
diff --git a/packages/applechu/src/server_resources/mod.rs b/packages/applechu/src/server_resources/mod.rs
new file mode 100644
index 0000000..f638216
--- /dev/null
+++ b/packages/applechu/src/server_resources/mod.rs
@@ -0,0 +1,426 @@
+//! 服务器下发自定义 Option 资源
+//!
+//! 架构对齐 AquaMai `ServerResources`：监听游戏正常的 `GetGameSettingApi`
+//! 响应 → 读 `_appleChuResources` → 条件筛选 → 下载 → RSA 验签 → 缓存 →
+//! 解压为磁盘上的 option 目录树 → 交给 VFS 与游戏本身。
+//!
+//! 缓存只保留资源包本体（与 AquaMai 落一个缓存文件一致，不进游戏目录）；
+//! 解压出的 `AXXX` 树由 `platform/vfs` 重定向呈现，读取与子目录枚举都走游戏
+//! 原有的文件 API，本功能只补 option 根那一级枚举（见 `vfs_bridge`）。
+//!
+//! 流程细节见 `D:\Git\work\plan\服务器下发-架构.md`。
+
+pub mod deflate;
+pub mod dispatcher;
+pub mod download;
+pub mod entry;
+pub mod json;
+pub mod net_packet;
+pub mod package;
+pub mod power_on_gate;
+pub mod vfs_bridge;
+
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Mutex, OnceLock};
+
+use crate::config::Config;
+use crate::platform::vfs;
+use crate::server_resources::json::JsonValue;
+use crate::util::api::Api;
+
+crate::config_section! {
+    pub(crate) struct ServerResourcesConfig => SERVER_RESOURCES_CONFIG_SECTION {
+        section: "ServerResources",
+        order: 355,
+        default_on: false,
+        always_enabled: false,
+        hidden: false,
+        group: "network",
+        comment: "服务器下发自定义 Option 资源",
+        fields: {
+            pub public_key: String = String::new(),
+            advanced: true,
+            comment: "RSA 公钥（base64 modulus），留空则忽略服务器下发";
+            pub cache_path: String = String::from("tmp/ServerResources"),
+            advanced: true,
+            comment: "资源包缓存路径（相对游戏目录）";
+            pub native_dispatcher: bool = true,
+            advanced: true,
+            comment: "挂在原生收包分发器上；关闭则退回 WinHTTP 响应层";
+            pub hold_boot: bool = true,
+            advanced: true,
+            comment: "下载期间挂起开机流程";
+        }
+    }
+}
+
+/// 已挂载的自定义 option 根
+struct MountedOption {
+    /// 根目录名（`AXXX`，保留包内原始大小写）
+    root: String,
+    /// 解压目录绝对路径
+    directory: PathBuf,
+}
+
+/// 当前生效的自定义 option；供枚举注入追加到 option 根
+static MOUNTED: OnceLock<Mutex<Vec<MountedOption>>> = OnceLock::new();
+static DOWNLOAD_STARTED: AtomicBool = AtomicBool::new(false);
+
+fn mounted() -> &'static Mutex<Vec<MountedOption>> {
+    MOUNTED.get_or_init(|| Mutex::new(Vec::new()))
+}
+
+/// 已挂载的自定义 option 根目录名（按挂载顺序）
+pub(crate) fn mounted_roots() -> Vec<String> {
+    mounted()
+        .lock()
+        .map(|mounted| mounted.iter().map(|entry| entry.root.clone()).collect())
+        .unwrap_or_default()
+}
+
+pub(crate) fn is_enabled(config: &Config) -> bool {
+    config
+        .section::<ServerResourcesConfig>()
+        .is_some_and(|section| section.enabled)
+}
+
+/// 初始化：注册信令处理与枚举注入
+#[applechu_macros::config_section(stage = Late, order = 60, shutdown = shutdown)]
+pub(crate) fn init(api: &Api, config: &Config) -> Result<(), String> {
+    if !is_enabled(config) {
+        return Ok(());
+    }
+
+    let Some(section) = config.section::<ServerResourcesConfig>() else {
+        return Ok(());
+    };
+    if section.public_key.trim().is_empty() {
+        api.log_warn("ServerResources: public_key is empty, resource download is disabled");
+        return Ok(());
+    }
+
+    // 信令来源：优先挂在原生分发器（拿逻辑 API 名 + 明文响应），
+    // 关闭或挂钩失败时退回 WinHTTP 响应层。
+    if section.native_dispatcher {
+        match dispatcher::install(api) {
+            Ok(()) => {}
+            Err(error) => {
+                api.log_warn(&format!(
+                    "ServerResources: native dispatcher unavailable ({error}), falling back to WinHTTP"
+                ));
+                net_packet::subscribe(on_response);
+                net_packet::install(api, config)?;
+            }
+        }
+    } else {
+        net_packet::subscribe(on_response);
+        net_packet::install(api, config)?;
+    }
+    vfs_bridge::install(api)?;
+    if section.hold_boot {
+        // 闸门装不上不致命：退化为「下载不阻塞开机」
+        if let Err(error) = power_on_gate::install(api) {
+            api.log_warn(&format!("ServerResources: boot gate unavailable: {error}"));
+        }
+    }
+    api.log_info("ServerResources: waiting for GetGameSettingApi response");
+    Ok(())
+}
+
+/// 关闭：还原钩子并注销已挂载的 option
+pub(crate) fn shutdown() {
+    power_on_gate::shutdown();
+    dispatcher::shutdown();
+    vfs_bridge::shutdown();
+    if let Ok(mounted) = mounted().lock() {
+        for entry in mounted.iter() {
+            vfs::set_option_override(&entry.root, "");
+        }
+    }
+}
+
+/// 原生分发器回传的响应：解析 JSON 后进入条件筛选
+///
+/// 与 WinHTTP 层共用同一段逻辑，区别只在信令来源。
+pub(crate) fn on_net_response(api_name: &str, body: &str) {
+    let Some(mut value) = json::parse(body) else {
+        return;
+    };
+    // 广播给 chu-abi 模组（与 WinHTTP 路径行为一致）
+    net_packet::publish(api_name, &value);
+    on_response(api_name, &mut value);
+}
+
+/// 信令回调：在 `GetGameSettingApi` 响应中查找下发条目
+fn on_response(api_name: &str, response: &mut JsonValue) -> bool {
+    // 只监听登录设置响应；其他 API 与包含资源字段的响应都不处理
+    if api_name != "GetGameSettingApi" {
+        return false;
+    }
+    if let Some(resources) = locate_resources(response) {
+        let entries = entry::parse_entries(resources);
+        if entries.is_empty() {
+            return false;
+        }
+
+        let game_version = game_version_from(response);
+        let Some(selected) = entry::select_entry(&entries, None, game_version) else {
+            log_info(&format!(
+                "ServerResources: {count} entr{suffix} present but none matched (gameVersion={game_version})",
+                count = entries.len(),
+                suffix = if entries.len() == 1 { "y" } else { "ies" }
+            ));
+            return false;
+        };
+
+        log_info(&format!(
+            "ServerResources: entry matched, url={} gameVersion={game_version}",
+            selected.url
+        ));
+        start_download(selected);
+    }
+    // 本功能只读取响应，不改写，因此始终返回 false
+    false
+}
+
+/// 找到下发的资源字段
+///
+/// 根级优先；为兼容把字段嵌进 `gameSetting` 的服务器实现，再往里找一层。
+/// 字段名 `_appleChuResources` 与 AquaMai 的 `_aquaMaiResources` 结构一致。
+fn locate_resources(response: &JsonValue) -> Option<&JsonValue> {
+    response
+        .get(RESOURCES_FIELD)
+        .or_else(|| response.get("gameSetting")?.get(RESOURCES_FIELD))
+}
+
+/// 下发字段名（与 AquaMai 的 `_aquaMaiResources` 同构，仅换品牌前缀）
+pub(crate) const RESOURCES_FIELD: &str = "_appleChuResources";
+
+/// 从同一响应派生游戏版本整数（`romVersion` / `dataVersion`）
+///
+/// 取 `major*10000 + minor*100 + release`；缺失或异常时返回 0（不限制）。
+fn game_version_from(response: &JsonValue) -> i64 {
+    let setting = response.get("gameSetting");
+    let rom_version = setting
+        .and_then(|value| value.get("romVersion"))
+        .and_then(JsonValue::as_str)
+        .unwrap_or_default();
+    version_to_int(rom_version)
+}
+
+fn version_to_int(text: &str) -> i64 {
+    let mut parts = text.trim().split('.');
+    let major = parts
+        .next()
+        .and_then(|part| part.trim().parse::<i64>().ok());
+    let minor = parts
+        .next()
+        .and_then(|part| part.trim().parse::<i64>().ok());
+    let release = parts
+        .next()
+        .and_then(|part| part.trim().parse::<i64>().ok());
+    match (major, minor, release) {
+        (Some(major), Some(minor), Some(release)) => major * 10_000 + minor * 100 + release,
+        (Some(major), Some(minor), None) => major * 10_000 + minor * 100,
+        _ => 0,
+    }
+}
+
+/// 启动后台下载（只允许一次）
+///
+/// 下载与解压在独立线程，避免阻塞收包线程；期间由开机闸门把
+/// `projGame::PowerOn` 状态机停在当前帧，结束后放行。
+fn start_download(selected: &entry::ServerResourcesEntry) {
+    if DOWNLOAD_STARTED.swap(true, Ordering::AcqRel) {
+        return;
+    }
+    power_on_gate::begin_block();
+    let url = selected.url.clone();
+    let sign = selected.sign.clone();
+    std::thread::spawn(move || {
+        if let Err(error) = fetch_and_mount(&url, &sign) {
+            log_warn(&format!("ServerResources: {error}"));
+        }
+        // 无论成功失败都恢复开机，避免下载异常时卡住
+        power_on_gate::end_block();
+    });
+}
+
+fn fetch_and_mount(url: &str, sign: &str) -> Result<(), String> {
+    let Some(api) = crate::util::api::API.get() else {
+        return Err("api handle is not available".to_owned());
+    };
+    let Some((public_key, cache_path)) = api_config() else {
+        return Err("ServerResources config is not available".to_owned());
+    };
+
+    let cache = resolve_cache_path(&cache_path);
+
+    // 1) 缓存命中：签名一致则直接加载，不重新下载
+    if let Ok(cached) = std::fs::read(&cache) {
+        if crate::util::crypto::verify_signature(&public_key, &cached, sign) {
+            api.log_info("ServerResources: cache hit, loading from cache");
+            return mount_package(&cached);
+        }
+        api.log_warn("ServerResources: cache signature mismatch, re-downloading");
+        let _ = std::fs::remove_file(&cache);
+    }
+
+    // 2) 下载 → 验签 → 写缓存
+    let bytes = download::download(url)?;
+    if !crate::util::crypto::verify_signature(&public_key, &bytes, sign) {
+        return Err("downloaded package failed signature verification".to_owned());
+    }
+    if let Some(parent) = std::path::Path::new(&cache).parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    if let Err(error) = std::fs::write(&cache, &bytes) {
+        api.log_warn(&format!("ServerResources: cache write failed: {error}"));
+    }
+    mount_package(&bytes)
+}
+
+/// 解析包并挂载：解压到缓存目录，再把 option 子树重定向过去
+fn mount_package(bytes: &[u8]) -> Result<(), String> {
+    let package = package::OptionPackage::parse(bytes)?;
+    let root = package.root().to_owned();
+    let directory = extract_dir(&root)?;
+
+    // 覆盖安装：先清掉上一次的内容，避免残留已从包中移除的文件
+    let _ = std::fs::remove_dir_all(&directory);
+    std::fs::create_dir_all(&directory)
+        .map_err(|error| format!("cannot create {}: {error}", directory.display()))?;
+    let written = package.extract_to(&directory)?;
+
+    // 挂载：`c:\mount\option\<root>\...` 指向解压目录
+    let target = directory.to_string_lossy().into_owned();
+    vfs::set_option_override(&root, &target);
+    if let Ok(mut mounted) = mounted().lock() {
+        mounted.retain(|entry| entry.root != root);
+        mounted.push(MountedOption {
+            root: root.clone(),
+            directory: directory.clone(),
+        });
+    }
+    log_info(&format!(
+        "ServerResources: option mounted root={root} files={written} dir={}",
+        directory.display()
+    ));
+    Ok(())
+}
+
+/// 缓存文件绝对路径（相对游戏目录）
+fn resolve_cache_path(configured: &str) -> String {
+    let base = crate::proxy::base_dir().unwrap_or_else(|| ".".to_owned());
+    let relative = configured.trim();
+    if relative.is_empty() {
+        format!("{base}\\tmp\\ServerResources")
+    } else {
+        let normalized = relative.replace('/', "\\");
+        if normalized.contains(':') {
+            normalized
+        } else {
+            format!("{base}\\{normalized}")
+        }
+    }
+}
+
+/// 某个自定义 option 的解压目录：缓存路径加 `.d` 后缀
+///
+/// 解压目录与缓存文件同名不同层级，改 `cache_path` 时两者一起走。
+fn extract_dir(root: &str) -> Result<PathBuf, String> {
+    let Some((_, cache_path)) = api_config() else {
+        return Err("ServerResources config is not available".to_owned());
+    };
+    let cache = resolve_cache_path(&cache_path);
+    let mut directory = PathBuf::from(format!("{cache}.d"));
+    // 包内根目录名已由 `package` 校验过（无分隔符与 `..`），这里再挡一次
+    if root.is_empty() || root.contains(['\\', '/', ':']) || root.contains("..") {
+        return Err(format!("option package has an unsafe root name: {root}"));
+    }
+    directory.push(root);
+    Ok(directory)
+}
+
+/// 取当前配置中的 ServerResources 段（公钥与缓存路径）
+fn api_config() -> Option<(String, String)> {
+    let base = crate::proxy::base_dir()?;
+    let config = Config::global(&base);
+    config
+        .section::<ServerResourcesConfig>()
+        .map(|section| (section.public_key.clone(), section.cache_path.clone()))
+}
+
+fn log_info(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_info(message);
+    }
+}
+
+fn log_warn(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_warn(message);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn game_version_builds_from_semver_text() {
+        // Given: 服务器下发的 romVersion 文本。
+        // Then: 转成 major*10000 + minor*100 + release。
+        assert_eq!(version_to_int("2.50.00"), 25000);
+        assert_eq!(version_to_int("2.50.01"), 25001);
+        assert_eq!(version_to_int("2.45"), 24500);
+    }
+
+    #[test]
+    fn malformed_version_is_unrestricted() {
+        // Given: 非数字版本串。
+        // Then: 归零，条件筛选视为不限制。
+        assert_eq!(version_to_int(""), 0);
+        assert_eq!(version_to_int("abc"), 0);
+        assert_eq!(version_to_int("2.x.1"), 0);
+    }
+
+    #[test]
+    fn game_version_reads_from_response() {
+        // Given: 含 gameSetting.romVersion 的响应。
+        let value = json::parse(r#"{"gameSetting":{"romVersion":"2.50.00"}}"#).unwrap();
+
+        // Then: 版本整数被正确派生。
+        assert_eq!(game_version_from(&value), 25000);
+        assert_eq!(game_version_from(&json::parse("{}").unwrap()), 0);
+    }
+
+    #[test]
+    fn cache_path_is_relative_to_game_directory() {
+        // Given: 配置中的相对缓存路径。
+        // Then: 展开到游戏目录下，且不因缺少 base_dir 而 panic。
+        let path = resolve_cache_path("tmp/ServerResources");
+        assert!(path.ends_with("tmp\\ServerResources"));
+    }
+
+    #[test]
+    fn extract_directory_sits_next_to_the_cache_file() {
+        // Given: 一个合法的包内根目录名。
+        // Then: 解压目录是缓存路径加 `.d`，再拼上根目录名。
+        let directory = extract_dir("A123").expect("应能构造解压目录");
+        assert!(directory
+            .to_string_lossy()
+            .ends_with("ServerResources.d\\A123"));
+    }
+
+    #[test]
+    fn unsafe_root_names_are_rejected() {
+        // Given: 含分隔符或穿越段的根目录名。
+        // Then: 一律拒绝，避免解压写出缓存目录之外。
+        assert!(extract_dir("").is_err());
+        assert!(extract_dir("..").is_err());
+        assert!(extract_dir("a\\b").is_err());
+        assert!(extract_dir("C:").is_err());
+    }
+}
diff --git a/packages/applechu/src/server_resources/net_packet.rs b/packages/applechu/src/server_resources/net_packet.rs
new file mode 100644
index 0000000..55509a3
--- /dev/null
+++ b/packages/applechu/src/server_resources/net_packet.rs
@@ -0,0 +1,383 @@
+//! 网络响应桥
+//!
+//! 在游戏自身的 WinHTTP 调用上挂钩，取出**完整响应体**与**请求路径**，
+//! 再广播给订阅者。对应 AquaMai 的 `NetPacketHook.OnNetPacketComplete`。
+//!
+//! 之所以在这一层而不是原生分发器（RVA 0x59FA60）上挂钩：分发器依赖固定
+//! RVA，跨版本会漂移；WinHTTP 导入是稳定 ABI，且 `patches/network.rs` 的
+//! `DisableEncryption` 默认生效时响应本就是明文，无需调用 `gm::Aes` 解密。
+//!
+//! 逻辑 API 名从请求路径末段取得（如 `.../GetGameSettingApi` → `GetGameSettingApi`），
+//! 与游戏自身的 API 名表（宽字符串 `0x18F46BC` 起）一致。
+
+use std::collections::HashMap;
+use std::ffi::c_void;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Mutex, OnceLock};
+
+use crate::config::Config;
+use crate::server_resources::json::{self, JsonValue};
+use crate::util::api::Api;
+use crate::util::iat_hook::hook_iat;
+
+const WINHTTP_DLL: &str = "winhttp.dll";
+const WINHTTP_OPEN_REQUEST: &str = "WinHttpOpenRequest";
+const WINHTTP_QUERY_DATA_AVAILABLE: &str = "WinHttpQueryDataAvailable";
+const WINHTTP_READ_DATA: &str = "WinHttpReadData";
+const WINHTTP_CLOSE_HANDLE: &str = "WinHttpCloseHandle";
+
+type WinHttpOpenRequestFn = unsafe extern "system" fn(
+    *mut c_void,
+    *const u16,
+    *const u16,
+    *const u16,
+    *const u16,
+    *const *const u16,
+    u32,
+) -> *mut c_void;
+type WinHttpQueryDataAvailableFn = unsafe extern "system" fn(*mut c_void, *mut u32) -> i32;
+type WinHttpReadDataFn = unsafe extern "system" fn(*mut c_void, *mut c_void, u32, *mut u32) -> i32;
+type WinHttpCloseHandleFn = unsafe extern "system" fn(*mut c_void) -> i32;
+
+static ORIG_OPEN_REQUEST: AtomicUsize = AtomicUsize::new(0);
+static ORIG_QUERY_DATA_AVAILABLE: AtomicUsize = AtomicUsize::new(0);
+static ORIG_READ_DATA: AtomicUsize = AtomicUsize::new(0);
+static ORIG_CLOSE_HANDLE: AtomicUsize = AtomicUsize::new(0);
+
+/// 响应处理回调：返回 `true` 表示已改写响应，需要重新序列化回写
+pub type ResponseHandler = fn(api: &str, response: &mut JsonValue) -> bool;
+
+static HANDLERS: OnceLock<Mutex<Vec<ResponseHandler>>> = OnceLock::new();
+static REQUESTS: OnceLock<Mutex<HashMap<usize, RequestState>>> = OnceLock::new();
+
+/// 单个请求的累积状态
+#[derive(Default)]
+struct RequestState {
+    /// 请求路径（用于解析逻辑 API 名）
+    path: String,
+    /// 已读取的响应体
+    body: Vec<u8>,
+    /// 是否已派发，避免同一请求重复处理
+    dispatched: bool,
+}
+
+fn handlers() -> &'static Mutex<Vec<ResponseHandler>> {
+    HANDLERS.get_or_init(|| Mutex::new(Vec::new()))
+}
+
+fn requests() -> &'static Mutex<HashMap<usize, RequestState>> {
+    REQUESTS.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// 注册响应处理回调
+pub fn subscribe(handler: ResponseHandler) {
+    if let Ok(mut handlers) = handlers().lock() {
+        if !handlers.contains(&handler) {
+            handlers.push(handler);
+        }
+    }
+}
+
+/// 安装 WinHTTP 响应桥
+pub fn install(api: &Api, config: &Config) -> Result<(), String> {
+    if !crate::server_resources::is_enabled(config) {
+        return Ok(());
+    }
+
+    unsafe {
+        let opened = hook_iat(
+            api.game_base(),
+            WINHTTP_DLL,
+            WINHTTP_OPEN_REQUEST,
+            hooked_open_request as *const (),
+        );
+        let Some(opened) = opened else {
+            return Err("WinHttpOpenRequest import not found".to_owned());
+        };
+        ORIG_OPEN_REQUEST.store(opened as usize, Ordering::SeqCst);
+
+        let queried = hook_iat(
+            api.game_base(),
+            WINHTTP_DLL,
+            WINHTTP_QUERY_DATA_AVAILABLE,
+            hooked_query_data_available as *const (),
+        );
+        let Some(queried) = queried else {
+            return Err("WinHttpQueryDataAvailable import not found".to_owned());
+        };
+        ORIG_QUERY_DATA_AVAILABLE.store(queried as usize, Ordering::SeqCst);
+
+        let read = hook_iat(
+            api.game_base(),
+            WINHTTP_DLL,
+            WINHTTP_READ_DATA,
+            hooked_read_data as *const (),
+        );
+        let Some(read) = read else {
+            return Err("WinHttpReadData import not found".to_owned());
+        };
+        ORIG_READ_DATA.store(read as usize, Ordering::SeqCst);
+
+        let closed = hook_iat(
+            api.game_base(),
+            WINHTTP_DLL,
+            WINHTTP_CLOSE_HANDLE,
+            hooked_close_handle as *const (),
+        );
+        if let Some(closed) = closed {
+            ORIG_CLOSE_HANDLE.store(closed as usize, Ordering::SeqCst);
+        }
+    }
+
+    api.log_info("patch applied: net response bridge (WinHTTP)");
+    Ok(())
+}
+
+/// 上传一次完整响应：解析 JSON 后依次交给订阅者
+///
+/// 响应不是合法 JSON 时静默跳过（游戏存在二进制/空响应）。
+fn dispatch(path: &str, body: &[u8]) {
+    let Some(name) = api_name_from_path(path) else {
+        return;
+    };
+    let Ok(text) = std::str::from_utf8(body) else {
+        return;
+    };
+    // 只处理 JSON 对象响应；纯文本/二进制响应不进入改写流程
+    let Some(mut value) = json::parse(text.trim_start_matches('\u{feff}')) else {
+        return;
+    };
+
+    let mut modified = false;
+    if let Ok(handlers) = handlers().lock() {
+        for handler in handlers.iter() {
+            if handler(&name, &mut value) {
+                modified = true;
+            }
+        }
+    }
+
+    // 同时广播给 chu-abi 模组，使其能读取/协作处理该响应
+    publish(&name, &value);
+
+    // 改写结果记录到日志；回写由调用方（游戏自身缓冲）决定，
+    // 本桥只读响应，不修改游戏的内存流。
+    if modified {
+        log_info(&format!(
+            "net response modified by subscriber: {name} ({} bytes)",
+            value.to_string().len()
+        ));
+    }
+}
+
+/// 把一次响应广播到 `net_packet` 主题，供 chu-abi 模组订阅
+///
+/// 载荷为 `{"api":"<名>","response":<响应>}`，便于订阅方按 API 过滤。
+pub(crate) fn publish(api_name: &str, response: &JsonValue) {
+    let Some(api) = crate::util::api::API.get() else {
+        return;
+    };
+    let mut envelope = String::with_capacity(response.to_string().len() + 32);
+    envelope.push_str("{\"api\":");
+    write_json_string(api_name, &mut envelope);
+    envelope.push_str(",\"response\":");
+    envelope.push_str(&response.to_string());
+    envelope.push('}');
+    api.publish(PUBLISH_TOPIC, envelope.as_bytes());
+}
+
+/// 对外广播主题名（chu-abi 模组按此订阅）
+const PUBLISH_TOPIC: &str = "net_packet";
+
+/// 在本模块内构造转义后的 JSON 字符串（避免把 json 模块的私有工具外泄）
+fn write_json_string(value: &str, output: &mut String) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            control if (control as u32) < 0x20 => {
+                use std::fmt::Write as _;
+                let _ = write!(output, "\\u{:04x}", control as u32);
+            }
+            other => output.push(other),
+        }
+    }
+    output.push('"');
+}
+
+/// 从请求路径解析逻辑 API 名（末段，去掉查询串与扩展）
+fn api_name_from_path(path: &str) -> Option<String> {
+    let without_query = path.split(['?', '#']).next().unwrap_or(path);
+    let segment = without_query
+        .rsplit(['/', '\\'])
+        .find(|part| !part.is_empty())?;
+    (!segment.is_empty()).then(|| segment.to_owned())
+}
+
+unsafe fn with_request<F: FnOnce(&mut RequestState)>(handle: usize, modify: F) {
+    if let Ok(mut requests) = requests().lock() {
+        let state = requests.entry(handle).or_default();
+        modify(state);
+    }
+}
+
+/// 完成一次派发：取出累积的响应体，标记已派发
+unsafe fn finish_request(handle: usize) {
+    let payload = {
+        let Ok(mut requests) = requests().lock() else {
+            return;
+        };
+        match requests.get_mut(&handle) {
+            Some(state) if !state.dispatched && !state.body.is_empty() => {
+                state.dispatched = true;
+                let body = std::mem::take(&mut state.body);
+                Some((state.path.clone(), body))
+            }
+            _ => None,
+        }
+    };
+    if let Some((path, body)) = payload {
+        dispatch(&path, &body);
+    }
+}
+
+unsafe extern "system" fn hooked_open_request(
+    connect: *mut c_void,
+    verb: *const u16,
+    object_name: *const u16,
+    version: *const u16,
+    referrer: *const u16,
+    accept_types: *const *const u16,
+    flags: u32,
+) -> *mut c_void {
+    let original = ORIG_OPEN_REQUEST.load(Ordering::SeqCst);
+    if original == 0 {
+        return std::ptr::null_mut();
+    }
+    let original: WinHttpOpenRequestFn = std::mem::transmute(original);
+    let result = original(
+        connect,
+        verb,
+        object_name,
+        version,
+        referrer,
+        accept_types,
+        flags,
+    );
+
+    if !result.is_null() && !object_name.is_null() {
+        let path = crate::platform::winapi::wide_to_string(object_name).unwrap_or_default();
+        with_request(result as usize, |state| {
+            state.path = path;
+            state.body.clear();
+            state.dispatched = false;
+        });
+    }
+    result
+}
+
+unsafe extern "system" fn hooked_query_data_available(
+    request: *mut c_void,
+    available: *mut u32,
+) -> i32 {
+    let original = ORIG_QUERY_DATA_AVAILABLE.load(Ordering::SeqCst);
+    if original == 0 {
+        return 0;
+    }
+    let original: WinHttpQueryDataAvailableFn = std::mem::transmute(original);
+    let result = original(request, available);
+    if result != 0 && !available.is_null() && *available == 0 {
+        // 可用字节为 0 表示响应体结束，此时游戏不会再调用 ReadData
+        finish_request(request as usize);
+    }
+    result
+}
+
+unsafe extern "system" fn hooked_read_data(
+    request: *mut c_void,
+    buffer: *mut c_void,
+    bytes_to_read: u32,
+    bytes_read: *mut u32,
+) -> i32 {
+    let original = ORIG_READ_DATA.load(Ordering::SeqCst);
+    if original == 0 {
+        return 0;
+    }
+    let original: WinHttpReadDataFn = std::mem::transmute(original);
+    let result = original(request, buffer, bytes_to_read, bytes_read);
+    if result != 0 && !bytes_read.is_null() {
+        let read = *bytes_read as usize;
+        if read > 0 && !buffer.is_null() {
+            let chunk = std::slice::from_raw_parts(buffer as *const u8, read);
+            with_request(request as usize, |state| {
+                // 上限保护：异常响应不至于无界增长
+                const MAX_BODY: usize = 8 * 1024 * 1024;
+                if state.body.len() + chunk.len() <= MAX_BODY {
+                    state.body.extend_from_slice(chunk);
+                }
+            });
+        } else if read == 0 {
+            // 读到 0 字节表示响应体结束
+            finish_request(request as usize);
+        }
+    }
+    result
+}
+
+unsafe extern "system" fn hooked_close_handle(handle: *mut c_void) -> i32 {
+    let original = ORIG_CLOSE_HANDLE.load(Ordering::SeqCst);
+    if original == 0 {
+        return 0;
+    }
+    // 游戏可能不等待 0 字节就读完即关闭，这里兜底派发一次
+    finish_request(handle as usize);
+    if let Ok(mut requests) = requests().lock() {
+        requests.remove(&(handle as usize));
+    }
+    let original: WinHttpCloseHandleFn = std::mem::transmute(original);
+    original(handle)
+}
+
+fn log_info(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_info(message);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn api_name_is_last_path_segment() {
+        // Given: 游戏实际使用的几种请求路径形态。
+        let cases = [
+            ("/NetDelivery/GetGameSettingApi", "GetGameSettingApi"),
+            ("/NetDelivery/GetGameSettingApi?k=v", "GetGameSettingApi"),
+            ("NetDelivery\\GetGameSettingApi", "GetGameSettingApi"),
+            ("GetGameSettingApi", "GetGameSettingApi"),
+        ];
+
+        // When/Then: 都取到末段逻辑名。
+        for (path, expected) in cases {
+            assert_eq!(api_name_from_path(path).as_deref(), Some(expected));
+        }
+    }
+
+    #[test]
+    fn empty_path_has_no_api_name() {
+        // Given: 空路径。
+        // Then: 不产生逻辑名，调用方跳过处理。
+        assert!(api_name_from_path("").is_none());
+        assert!(api_name_from_path("/").is_none());
+    }
+
+    #[test]
+    fn dispatch_ignores_non_json_bodies() {
+        // Given: 一段非 JSON 响应。
+        // When/Then: 派发不 panic 且不触发任何处理（无订阅者时也安全）。
+        dispatch("/x/GetGameSettingApi", b"not json at all");
+        dispatch("/x/GetGameSettingApi", &[0xff, 0xfe, 0x00]);
+    }
+}
diff --git a/packages/applechu/src/server_resources/package.rs b/packages/applechu/src/server_resources/package.rs
new file mode 100644
index 0000000..19dc80f
--- /dev/null
+++ b/packages/applechu/src/server_resources/package.rs
@@ -0,0 +1,373 @@
+//! Option 资源包（zip 容器）解析与解压
+//!
+//! 服务器下发的资源包是一个 zip，内容为单个 `AXXX` 目录树（与磁盘 option
+//! 同构，`data.conf` 可有可无）。本模块把它解析为文件表，再**解压到缓存目录**：
+//! 挂载与读取都交给 `platform/vfs` 与游戏本身，内存里不长期保留内容。
+//!
+//! 支持 zip 的 `store`（method 0）与 `deflate`（method 8）。deflate 复用游戏
+//! 自带的 zlib（`projClient::Deflate`，RTTI 0x1C5CC34）。
+
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+const EOCD_SIGNATURE: u32 = 0x0605_4b50;
+const CENTRAL_SIGNATURE: u32 = 0x0201_4b50;
+const METHOD_STORE: u16 = 0;
+const METHOD_DEFLATE: u16 = 8;
+/// zip 注释最长 65535 字节，EOCD 结构 22 字节
+const EOCD_SEARCH_LIMIT: usize = 22 + 0xffff;
+
+/// 内存中的 Option 资源包
+pub struct OptionPackage {
+    /// **小写**路径（`/` 分隔）→ 条目；Windows 路径不区分大小写，
+    /// 包内 `a189/data.conf` 与 `A189/data.conf` 必须视为同一条
+    files: BTreeMap<String, Entry>,
+    /// 根目录名（`AXXX`，保留原始大小写）
+    root: String,
+}
+
+/// 单个文件条目
+struct Entry {
+    /// 原始大小写路径（`/` 分隔）
+    name: String,
+    data: Vec<u8>,
+}
+
+impl OptionPackage {
+    /// 解析 zip 字节流
+    pub fn parse(bytes: &[u8]) -> Result<Self, String> {
+        let central = locate_central_directory(bytes)?;
+        let mut files: BTreeMap<String, Entry> = BTreeMap::new();
+        let mut root: Option<String> = None;
+        let mut cursor = central;
+        let mut pending = 0usize;
+
+        loop {
+            let signature = read_u32(bytes, cursor)
+                .ok_or_else(|| "zip central directory is truncated".to_owned())?;
+            if signature != CENTRAL_SIGNATURE {
+                break;
+            }
+            let method = read_u16(bytes, cursor + 10)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?;
+            let compressed_size = read_u32(bytes, cursor + 20)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?
+                as usize;
+            let name_len = read_u16(bytes, cursor + 28)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?
+                as usize;
+            let extra_len = read_u16(bytes, cursor + 30)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?
+                as usize;
+            let comment_len = read_u16(bytes, cursor + 32)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?
+                as usize;
+            let local_offset = read_u32(bytes, cursor + 42)
+                .ok_or_else(|| "zip central entry is truncated".to_owned())?
+                as usize;
+
+            let name_start = cursor + 46;
+            let name_bytes = bytes
+                .get(name_start..name_start + name_len)
+                .ok_or_else(|| "zip entry name is truncated".to_owned())?;
+            let name = String::from_utf8_lossy(name_bytes).replace('\\', "/");
+
+            // 目录条目以 `/` 结尾，不需要建立文件
+            if !name.ends_with('/') && !name.is_empty() {
+                let data = read_entry_data(bytes, local_offset, method, compressed_size)?;
+                // 解压前就挡住路径穿越，避免写出缓存目录之外
+                let key = safe_relative(&name)?;
+                if let Some(segment) = name.split('/').next() {
+                    if !segment.is_empty() {
+                        match &root {
+                            Some(existing) if existing != segment => {
+                                return Err(format!(
+                                    "option package spans multiple roots: {existing} and {segment}"
+                                ));
+                            }
+                            _ => root = Some(segment.to_owned()),
+                        }
+                    }
+                }
+                files.insert(key, Entry { name, data });
+            }
+
+            pending += 1;
+            if pending > 10_000 {
+                return Err("option package has too many entries".to_owned());
+            }
+            cursor = name_start
+                .checked_add(name_len)
+                .and_then(|value| value.checked_add(extra_len))
+                .and_then(|value| value.checked_add(comment_len))
+                .ok_or_else(|| "zip central directory offset overflowed".to_owned())?;
+        }
+
+        if files.is_empty() {
+            return Err("option package contains no files".to_owned());
+        }
+        let root = root.ok_or_else(|| "option package has no root directory".to_owned())?;
+
+        Ok(Self { files, root })
+    }
+
+    /// 根目录名（`AXXX`）
+    pub fn root(&self) -> &str {
+        &self.root
+    }
+
+    pub fn file_count(&self) -> usize {
+        self.files.len()
+    }
+
+    /// 把包内文件全部解到 `directory` 下，返回写出数量
+    ///
+    /// 调用方负责先清干净目标目录，避免上一次的包留下孤儿文件。
+    pub fn extract_to(&self, directory: &Path) -> Result<usize, String> {
+        let mut written = 0usize;
+        for entry in self.files.values() {
+            let relative = relative_path(&entry.name)?;
+            let target = directory.join(relative);
+            if let Some(parent) = target.parent() {
+                std::fs::create_dir_all(parent)
+                    .map_err(|error| format!("cannot create {}: {error}", parent.display()))?;
+            }
+            std::fs::write(&target, &entry.data)
+                .map_err(|error| format!("cannot write {}: {error}", target.display()))?;
+            written += 1;
+        }
+        Ok(written)
+    }
+}
+
+/// 校验并归一化条目路径，返回 zip 内相对路径（`/` 分隔、小写）
+///
+/// 拒绝绝对路径、盘符与 `..`，避免 zip 条目写出解压目录之外。
+fn safe_relative(name: &str) -> Result<String, String> {
+    let mut normalized = String::new();
+    for segment in name.split('/') {
+        if segment.is_empty() || segment == "." || segment == ".." {
+            return Err(format!("option package entry has an unsafe path: {name}"));
+        }
+        if segment.contains(':') || segment.contains('\\') {
+            return Err(format!("option package entry has an unsafe path: {name}"));
+        }
+        if !normalized.is_empty() {
+            normalized.push('/');
+        }
+        normalized.push_str(segment);
+    }
+    if normalized.is_empty() {
+        return Err("option package has an empty entry name".to_owned());
+    }
+    Ok(normalized.to_ascii_lowercase())
+}
+
+/// 条目路径 → 可直接 `join` 到解压目录的相对路径
+fn relative_path(name: &str) -> Result<PathBuf, String> {
+    safe_relative(name)?;
+    let mut path = PathBuf::new();
+    for segment in name.split('/') {
+        path.push(segment);
+    }
+    Ok(path)
+}
+
+/// 定位中央目录起始偏移
+fn locate_central_directory(bytes: &[u8]) -> Result<usize, String> {
+    // EOCD 结构本身 22 字节，短于它不可能是 zip
+    if bytes.len() < 22 {
+        return Err("zip is too short".to_owned());
+    }
+    let search_start = bytes.len().saturating_sub(EOCD_SEARCH_LIMIT);
+    let mut index = bytes.len() - 22;
+    loop {
+        if read_u32(bytes, index) == Some(EOCD_SIGNATURE) {
+            let offset = read_u32(bytes, index + 16)
+                .ok_or_else(|| "zip end-of-central-directory is truncated".to_owned())?
+                as usize;
+            if offset < bytes.len() {
+                return Ok(offset);
+            }
+        }
+        if index == search_start {
+            return Err("zip end-of-central-directory not found".to_owned());
+        }
+        index -= 1;
+    }
+}
+
+/// 读取单个条目的数据（store 直接切片，deflate 交给游戏内嵌 zlib）
+fn read_entry_data(
+    bytes: &[u8],
+    local_offset: usize,
+    method: u16,
+    compressed_size: usize,
+) -> Result<Vec<u8>, String> {
+    // 本地文件头：签名(4) + 版本(2) + 标志(2) + 方法(2) + 时间(2) + 日期(2)
+    //            + CRC(4) + 压缩大小(4) + 原始大小(4) + 名称长度(2) + 扩展长度(2)
+    let name_len = read_u16(bytes, local_offset + 26)
+        .ok_or_else(|| "zip local header is truncated".to_owned())? as usize;
+    let extra_len = read_u16(bytes, local_offset + 28)
+        .ok_or_else(|| "zip local header is truncated".to_owned())? as usize;
+    let data_start = local_offset
+        .checked_add(30)
+        .and_then(|value| value.checked_add(name_len))
+        .and_then(|value| value.checked_add(extra_len))
+        .ok_or_else(|| "zip local header offset overflowed".to_owned())?;
+    let data = bytes
+        .get(data_start..data_start + compressed_size)
+        .ok_or_else(|| "zip entry data is truncated".to_owned())?;
+
+    match method {
+        METHOD_STORE => Ok(data.to_vec()),
+        METHOD_DEFLATE => crate::server_resources::deflate::inflate(data),
+        other => Err(format!("unsupported zip compression method {other}")),
+    }
+}
+
+fn read_u16(bytes: &[u8], offset: usize) -> Option<u16> {
+    let slice = bytes.get(offset..offset + 2)?;
+    Some(u16::from_le_bytes([slice[0], slice[1]]))
+}
+
+fn read_u32(bytes: &[u8], offset: usize) -> Option<u32> {
+    let slice = bytes.get(offset..offset + 4)?;
+    Some(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
+}
+
+/// 测试用的最小 zip 构造器（store 模式）
+#[cfg(test)]
+pub fn build_store_zip(files: &[(&str, &[u8])]) -> Vec<u8> {
+    let mut buffer = Vec::new();
+    let mut entries = Vec::new();
+    for (name, data) in files {
+        let offset = buffer.len() as u32;
+        buffer.extend_from_slice(&0x0403_4b50u32.to_le_bytes());
+        buffer.extend_from_slice(&20u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u32.to_le_bytes());
+        buffer.extend_from_slice(&(data.len() as u32).to_le_bytes());
+        buffer.extend_from_slice(&(data.len() as u32).to_le_bytes());
+        buffer.extend_from_slice(&(name.len() as u16).to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(name.as_bytes());
+        buffer.extend_from_slice(data);
+        entries.push((name.to_string(), data.len() as u32, offset));
+    }
+    let central_start = buffer.len() as u32;
+    for (name, size, offset) in &entries {
+        buffer.extend_from_slice(&CENTRAL_SIGNATURE.to_le_bytes());
+        buffer.extend_from_slice(&20u16.to_le_bytes());
+        buffer.extend_from_slice(&20u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u32.to_le_bytes());
+        buffer.extend_from_slice(&size.to_le_bytes());
+        buffer.extend_from_slice(&size.to_le_bytes());
+        buffer.extend_from_slice(&(name.len() as u16).to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u16.to_le_bytes());
+        buffer.extend_from_slice(&0u32.to_le_bytes());
+        buffer.extend_from_slice(&offset.to_le_bytes());
+        buffer.extend_from_slice(name.as_bytes());
+    }
+    let central_size = buffer.len() as u32 - central_start;
+    buffer.extend_from_slice(&EOCD_SIGNATURE.to_le_bytes());
+    buffer.extend_from_slice(&0u16.to_le_bytes());
+    buffer.extend_from_slice(&0u16.to_le_bytes());
+    buffer.extend_from_slice(&(entries.len() as u16).to_le_bytes());
+    buffer.extend_from_slice(&(entries.len() as u16).to_le_bytes());
+    buffer.extend_from_slice(&central_size.to_le_bytes());
+    buffer.extend_from_slice(&central_start.to_le_bytes());
+    buffer.extend_from_slice(&0u16.to_le_bytes());
+    buffer
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sample() -> Vec<u8> {
+        build_store_zip(&[
+            ("A200/data.conf", b"[Version]\nName = CHUNITHM\n"),
+            ("A200/music/music9001/Music.xml", b"<Music/>"),
+            ("A200/music/music9001/9001_03.c2s", b"\x01\x02\x03"),
+            ("A200/releaseTag/releaseTag000099/ReleaseTag.xml", b"<Tag/>"),
+        ])
+    }
+
+    #[test]
+    fn parses_root_and_files() {
+        // Given: 一个单根 Option 包。
+        let package = OptionPackage::parse(&sample()).expect("应解析成功");
+
+        // Then: 根目录与文件数量正确。
+        assert_eq!(package.root(), "A200");
+        assert_eq!(package.file_count(), 4);
+    }
+
+    #[test]
+    fn rejects_packages_spanning_multiple_roots() {
+        // Given: 含两个 AXXX 根的包。
+        let bytes = build_store_zip(&[("A200/a.txt", b"a"), ("A201/b.txt", b"b")]);
+
+        // Then: 解析失败，避免挂载出无法归属的内容。
+        assert!(OptionPackage::parse(&bytes).is_err());
+    }
+
+    #[test]
+    fn rejects_truncated_input() {
+        // Given: 被截断的 zip。
+        let bytes = sample();
+        let truncated = &bytes[..bytes.len() / 2];
+
+        // Then: 解析失败而不是 panic。
+        assert!(OptionPackage::parse(truncated).is_err());
+        assert!(OptionPackage::parse(b"").is_err());
+    }
+
+    #[test]
+    fn rejects_entries_escaping_the_extraction_root() {
+        // Given: 试图穿越目录的 zip 条目。
+        // Then: 解析即失败，不会写出解压目录之外。
+        assert!(OptionPackage::parse(&build_store_zip(&[("A200/../../evil.txt", b"x")])).is_err());
+        assert!(OptionPackage::parse(&build_store_zip(&[("C:/evil.txt", b"x")])).is_err());
+        assert!(OptionPackage::parse(&build_store_zip(&[("/abs.txt", b"x")])).is_err());
+    }
+
+    #[test]
+    fn extracts_the_tree_under_the_target_directory() {
+        // Given: 一个含嵌套目录的单根包。
+        let package = OptionPackage::parse(&sample()).unwrap();
+        let directory =
+            std::env::temp_dir().join(format!("applechu-option-extract-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&directory);
+
+        // When: 解压到目标目录。
+        let written = package.extract_to(&directory).expect("解压应成功");
+
+        // Then: 文件按包内层级落地，内容一致。
+        assert_eq!(written, 4);
+        assert_eq!(
+            std::fs::read(directory.join("A200/music/music9001/9001_03.c2s")).unwrap(),
+            b"\x01\x02\x03"
+        );
+        let _ = std::fs::remove_dir_all(&directory);
+    }
+
+    #[test]
+    fn entry_paths_are_lowercased_for_lookup() {
+        // Given: 大小写不一致的条目路径。
+        // Then: 归一化后一致，且共享同一个 map key（后者覆盖前者）。
+        assert_eq!(safe_relative("A200/Data.Conf").unwrap(), "a200/data.conf");
+        assert_eq!(safe_relative("a200/data.conf").unwrap(), "a200/data.conf");
+    }
+}
diff --git a/packages/applechu/src/server_resources/power_on_gate.rs b/packages/applechu/src/server_resources/power_on_gate.rs
new file mode 100644
index 0000000..1756f03
--- /dev/null
+++ b/packages/applechu/src/server_resources/power_on_gate.rs
@@ -0,0 +1,193 @@
+//! 开机闸门：下载期间挂起 PowerOn 状态机
+//!
+//! 对应 AquaMai 在 `PowerOnProcess.OnUpdate` 上把 state 顶到 255 的做法。
+//! 这里改用更稳的方式：挂钩 `projGame::PowerOn` 状态机的每帧更新（虚表
+//! `0x19249BC` 的第 0 槽），下载进行中直接返回、不调用原函数，状态机因此
+//! 停在同一帧；下载结束（或超时）后恢复调用。
+//!
+//! 安全性：
+//! - 收包分发器与下载都在各自线程，冻结 PowerOn 更新不会阻塞它们；
+//! - 设了最长冻结时间，下载卡死也不会把开机永久挂住。
+
+use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
+
+use crate::util::api::Api;
+
+/// `projGame::PowerOn` 虚表 RVA（IDA: `0x19249BC`）
+const POWER_ON_VTABLE_RVA: usize = 0x152_49BC;
+/// 状态机每帧更新在虚表中的槽位
+const UPDATE_SLOT: usize = 0;
+/// 最长冻结时间：超时自动放行，避免下载卡死导致开机永久挂起
+const MAX_BLOCK_MS: u32 = 60_000;
+
+/// 原更新函数（trampoline）
+static ORIGINAL: AtomicUsize = AtomicUsize::new(0);
+/// 被挂钩的更新函数地址
+static TARGET: AtomicUsize = AtomicUsize::new(0);
+/// 是否正在冻结开机流程
+static BLOCKING: AtomicBool = AtomicBool::new(false);
+/// 冻结开始时刻（`GetTickCount`）
+static BLOCK_STARTED: AtomicU64 = AtomicU64::new(0);
+/// 已记录过冻结日志，避免刷屏
+static BLOCK_LOGGED: AtomicBool = AtomicBool::new(false);
+
+/// 读取系统启动以来的毫秒数（`GetTickCount`，与游戏同源）
+#[cfg(windows)]
+fn now_ms() -> u32 {
+    extern "system" {
+        fn GetTickCount() -> u32;
+    }
+    unsafe { GetTickCount() }
+}
+
+#[cfg(not(windows))]
+fn now_ms() -> u32 {
+    0
+}
+
+type UpdateFn = unsafe extern "thiscall" fn(*mut u8);
+
+/// 安装闸门；须在 VFS / 脚本初始化之后的 `Late` 阶段调用
+pub fn install(api: &Api) -> Result<(), String> {
+    let base = api.game_base();
+    if base == 0 {
+        return Err("game base is not available".to_owned());
+    }
+    let vtable = base
+        .checked_add(POWER_ON_VTABLE_RVA)
+        .ok_or_else(|| "PowerOn vtable address overflowed".to_owned())?;
+
+    let mut slot = [0u8; 4];
+    if !api.mem_read(vtable + UPDATE_SLOT * 4, &mut slot) {
+        return Err("PowerOn update slot could not be read".to_owned());
+    }
+    let update = u32::from_le_bytes(slot) as usize;
+    let (text_base, text_size) = (api.text_base(), api.text_size() as usize);
+    if update == 0 || !(text_base..text_base + text_size).contains(&update) {
+        return Err(format!(
+            "PowerOn update slot 0x{update:08X} is outside the code segment"
+        ));
+    }
+
+    let Some(trampoline) = api.hook_create(update, hooked_update as *const () as usize) else {
+        return Err("PowerOn update hook could not be created".to_owned());
+    };
+    if !api.hook_enable(update) {
+        api.hook_remove(update);
+        return Err("PowerOn update hook could not be enabled".to_owned());
+    }
+    ORIGINAL.store(trampoline, Ordering::Release);
+    TARGET.store(update, Ordering::Release);
+    api.log_info(&format!(
+        "ServerResources: boot gate armed on PowerOn update at 0x{update:08X}"
+    ));
+    Ok(())
+}
+
+pub fn shutdown() {
+    BLOCKING.store(false, Ordering::Release);
+    let target = TARGET.swap(0, Ordering::AcqRel);
+    if target != 0 {
+        if let Some(api) = crate::util::api::API.get() {
+            api.hook_disable(target);
+            api.hook_remove(target);
+        }
+    }
+    ORIGINAL.store(0, Ordering::Release);
+    BLOCK_LOGGED.store(false, Ordering::Release);
+}
+
+/// 开始冻结开机流程
+pub fn begin_block() {
+    BLOCK_STARTED.store(u64::from(now_ms()), Ordering::Release);
+    BLOCKING.store(true, Ordering::Release);
+    if !BLOCK_LOGGED.swap(true, Ordering::AcqRel) {
+        log_info("ServerResources: boot held while downloading server resources");
+    }
+}
+
+/// 结束冻结，恢复开机流程
+pub fn end_block() {
+    if BLOCKING.swap(false, Ordering::Release) {
+        log_info("ServerResources: boot resumed");
+    }
+    BLOCK_LOGGED.store(false, Ordering::Release);
+}
+
+/// 是否处于冻结中（含超时判定）
+fn blocking() -> bool {
+    if !BLOCKING.load(Ordering::Acquire) {
+        return false;
+    }
+    let started = BLOCK_STARTED.load(Ordering::Acquire);
+    if started == 0 {
+        return false;
+    }
+    let now = u64::from(now_ms());
+    if now.wrapping_sub(started) > u64::from(MAX_BLOCK_MS) {
+        // 超时自动放行，避免下载异常时开机永久挂起
+        BLOCKING.store(false, Ordering::Release);
+        log_warn("ServerResources: boot gate timed out, resuming boot");
+        return false;
+    }
+    true
+}
+
+unsafe extern "thiscall" fn hooked_update(this: *mut u8) {
+    if blocking() {
+        // 停在当前帧：不推进状态机，也不调用原函数
+        return;
+    }
+    let original = ORIGINAL.load(Ordering::Acquire);
+    if original == 0 {
+        return;
+    }
+    let original: UpdateFn = std::mem::transmute(original);
+    original(this);
+}
+
+fn log_info(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_info(message);
+    }
+}
+
+fn log_warn(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_warn(message);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gate_is_open_by_default() {
+        // Given: 未开始冻结。
+        // Then: 不阻塞开机，超时判定也不会误触发。
+        assert!(!blocking());
+    }
+
+    #[test]
+    fn block_and_release_round_trip() {
+        // Given: 开始冻结。
+        begin_block();
+
+        // When/Then: 冻结生效，释放后恢复。
+        assert!(blocking());
+        end_block();
+        assert!(!blocking());
+    }
+
+    #[test]
+    fn stale_start_time_opens_the_gate() {
+        // Given: 冻结但开始时刻被设为 0（异常状态）。
+        BLOCKING.store(true, Ordering::Release);
+        BLOCK_STARTED.store(0, Ordering::Release);
+
+        // Then: 判定为不阻塞，避免永久挂起。
+        assert!(!blocking());
+        BLOCKING.store(false, Ordering::Release);
+    }
+}
diff --git a/packages/applechu/src/server_resources/vfs_bridge.rs b/packages/applechu/src/server_resources/vfs_bridge.rs
new file mode 100644
index 0000000..9313d7b
--- /dev/null
+++ b/packages/applechu/src/server_resources/vfs_bridge.rs
@@ -0,0 +1,593 @@
+//! Option 枚举注入
+//!
+//! 服务器下发的自定义 option 解压在缓存目录里，由 `platform/vfs` 把
+//! `c:\mount\option\<AXXX>\...` 重定向到那里——**读取与子目录枚举都交给游戏走
+//! 真实文件 API**。唯独 option 根那一级枚举需要本模块补一刀：包内根目录并不在
+//! 游戏真实的 option 目录里，`FindFirstFile` 扫 `c:\mount\option\*` 时看不见它。
+//!
+//! 语义是**叠加**：真实枚举照常跑并原样返回，虚拟根追加在其后，磁盘原有
+//! option（A001 等）的顺序与内容完全不变。
+//!
+//! 游戏 option 扫描走的是 **ANSI**（`FindFirstFileExA` + `FindNextFileA`），
+//! 因此 A 与 W 两个变体都必须挂。
+
+use std::collections::HashMap;
+use std::ffi::c_void;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{Mutex, OnceLock};
+
+use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE};
+use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_DIRECTORY;
+
+use crate::platform::{vfs, winapi};
+use crate::util::api::Api;
+use crate::util::iat_hook::hook_iat;
+
+const KERNEL32_DLL: &str = "kernel32.dll";
+/// 合成枚举句柄的高位标记
+const SYNTHETIC_FLAG: usize = 1 << 31;
+/// 同时打开的合成枚举上限，避免异常调用把状态表撑爆
+const MAX_SYNTHETIC: usize = 64;
+/// `WIN32_FIND_DATAA` / `WIN32_FIND_DATAW` 的名称都在偏移 44，
+/// 宽度分别是 260 字节与 260 个 UTF-16 单元
+const FIND_DATA_NAME_OFFSET: usize = 44;
+const FIND_DATA_NAME_MAX: usize = 260;
+const FIND_DATA_SIZE_A: usize = 320;
+const FIND_DATA_SIZE_W: usize = 592;
+
+type FindFirstFileAFn = unsafe extern "system" fn(*const i8, *mut c_void) -> HANDLE;
+type FindFirstFileWFn = unsafe extern "system" fn(*const u16, *mut c_void) -> HANDLE;
+type FindFirstFileExAFn =
+    unsafe extern "system" fn(*const i8, u32, *mut c_void, u32, *mut c_void, u32) -> HANDLE;
+type FindFirstFileExWFn =
+    unsafe extern "system" fn(*const u16, u32, *mut c_void, u32, *mut c_void, u32) -> HANDLE;
+type FindNextFileFn = unsafe extern "system" fn(HANDLE, *mut c_void) -> i32;
+type FindCloseFn = unsafe extern "system" fn(HANDLE) -> i32;
+
+/// 包装后的 API 指针（未命中虚拟内容时转交 path_hook 的下一跳）
+static NEXT_FIND_FIRST_FILE_A: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_FIRST_FILE_W: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_FIRST_FILE_EX_A: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_FIRST_FILE_EX_W: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_NEXT_FILE_A: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_NEXT_FILE_W: AtomicUsize = AtomicUsize::new(0);
+static NEXT_FIND_CLOSE: AtomicUsize = AtomicUsize::new(0);
+
+/// 合成枚举句柄 → 枚举状态
+static SYNTHETIC: OnceLock<Mutex<HashMap<usize, SyntheticState>>> = OnceLock::new();
+static NEXT_SYNTHETIC: AtomicUsize = AtomicUsize::new(0);
+
+struct SyntheticState {
+    /// 真实枚举结束后才吐出的虚拟条目
+    injected: Vec<String>,
+    /// 真实枚举句柄；根目录不存在时为 0（此时虚拟条目立即可用）
+    real: usize,
+    /// 真实枚举是否已结束
+    real_done: bool,
+    /// 该句柄属于宽字符还是 ANSI 变体（决定填充与转交哪个 API）
+    wide: bool,
+}
+
+fn synthetic() -> &'static Mutex<HashMap<usize, SyntheticState>> {
+    SYNTHETIC.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// 安装枚举注入；须在 `platform` 阶段（`path_hook` 安装完成）之后调用
+///
+/// 游戏只导入其中一部分 API，缺失的跳过而不是整体失败。
+pub fn install(api: &Api) -> Result<(), String> {
+    let mut bound = 0usize;
+    let mut missing: Vec<&str> = Vec::new();
+
+    for (name, detour, slot) in hooks() {
+        // 只挂游戏主模块：path_hook 已把它的下一跳铺进各模块的 IAT
+        let previous = unsafe { hook_iat(api.game_base(), KERNEL32_DLL, name, detour) };
+        match previous {
+            Some(previous) => {
+                slot.store(previous as usize, Ordering::SeqCst);
+                bound += 1;
+            }
+            None => missing.push(name),
+        }
+    }
+
+    if bound == 0 {
+        return Err("no directory enumeration import found in game module".to_owned());
+    }
+    api.log_info(&format!(
+        "ServerResources: option enumeration hook installed ({bound} APIs)"
+    ));
+    if !missing.is_empty() {
+        api.log_warn(&format!(
+            "ServerResources: not imported by game module, skipped: {}",
+            missing.join(", ")
+        ));
+    }
+    Ok(())
+}
+
+/// 需要挂接的 API 表
+fn hooks() -> [(&'static str, *const (), &'static AtomicUsize); 7] {
+    [
+        (
+            "FindFirstFileA",
+            hooked_find_first_file_a as *const (),
+            &NEXT_FIND_FIRST_FILE_A,
+        ),
+        (
+            "FindFirstFileW",
+            hooked_find_first_file_w as *const (),
+            &NEXT_FIND_FIRST_FILE_W,
+        ),
+        (
+            "FindFirstFileExA",
+            hooked_find_first_file_ex_a as *const (),
+            &NEXT_FIND_FIRST_FILE_EX_A,
+        ),
+        (
+            "FindFirstFileExW",
+            hooked_find_first_file_ex_w as *const (),
+            &NEXT_FIND_FIRST_FILE_EX_W,
+        ),
+        (
+            "FindNextFileA",
+            hooked_find_next_file_a as *const (),
+            &NEXT_FIND_NEXT_FILE_A,
+        ),
+        (
+            "FindNextFileW",
+            hooked_find_next_file_w as *const (),
+            &NEXT_FIND_NEXT_FILE_W,
+        ),
+        (
+            "FindClose",
+            hooked_find_close as *const (),
+            &NEXT_FIND_CLOSE,
+        ),
+    ]
+}
+
+/// 卸载：还原导入（把下一跳写回）并丢弃未完成的枚举状态
+pub fn shutdown() {
+    if let Ok(mut synthetic) = synthetic().lock() {
+        synthetic.clear();
+    }
+    for (name, _, slot) in hooks() {
+        unsafe { restore(name, slot) };
+    }
+}
+
+unsafe fn restore(name: &str, slot: &AtomicUsize) {
+    let previous = slot.swap(0, Ordering::AcqRel);
+    if previous == 0 {
+        return;
+    }
+    if let Some(api) = crate::util::api::API.get() {
+        let _ = hook_iat(api.game_base(), KERNEL32_DLL, name, previous as *const ());
+    }
+}
+
+/// 枚举通配路径是否正对 option 根（`c:\mount\option\*`）
+///
+/// 游戏请求的是重定向前的源路径。通配符必须落在最后一段，且目录必须**正好**
+/// 是 option 根——更深一层已由 `platform/vfs` 重定向到真实目录，游戏自己能枚举。
+fn is_option_root_glob(path: &str) -> bool {
+    let normalized = winapi::normalize_path(path);
+    let Some(star) = normalized.rfind('*') else {
+        return false;
+    };
+    if normalized[star..].contains('\\') {
+        return false;
+    }
+    normalized[..star].trim_end_matches('\\') == option_source()
+}
+
+fn option_source() -> String {
+    vfs::option_source_prefix()
+        .trim_end_matches('\\')
+        .to_ascii_lowercase()
+}
+
+// ---------------------------------------------------------------------------
+// `WIN32_FIND_DATA` 读写（A 与 W 共用偏移）
+// ---------------------------------------------------------------------------
+
+unsafe fn fill_find_data(name: &str, data: *mut c_void, wide: bool) {
+    if data.is_null() {
+        return;
+    }
+    let size = if wide {
+        FIND_DATA_SIZE_W
+    } else {
+        FIND_DATA_SIZE_A
+    };
+    std::ptr::write_bytes(data as *mut u8, 0, size);
+    // 注入的都是 option 根目录
+    std::ptr::write_unaligned(data as *mut u32, FILE_ATTRIBUTE_DIRECTORY);
+
+    let target = (data as *mut u8).add(FIND_DATA_NAME_OFFSET);
+    if wide {
+        let units = target.cast::<u16>();
+        for (index, unit) in name.encode_utf16().take(FIND_DATA_NAME_MAX - 1).enumerate() {
+            std::ptr::write_unaligned(units.add(index), unit);
+        }
+    } else {
+        for (index, byte) in name.bytes().take(FIND_DATA_NAME_MAX - 1).enumerate() {
+            *target.add(index) = byte;
+        }
+    }
+}
+
+unsafe fn name_from(data: *const c_void, wide: bool) -> String {
+    if data.is_null() {
+        return String::new();
+    }
+    let name = (data as *const u8).add(FIND_DATA_NAME_OFFSET);
+    let mut length = 0usize;
+    if wide {
+        let units = name.cast::<u16>();
+        while length < FIND_DATA_NAME_MAX && *units.add(length) != 0 {
+            length += 1;
+        }
+        String::from_utf16_lossy(std::slice::from_raw_parts(units, length))
+    } else {
+        while length < FIND_DATA_NAME_MAX && *name.add(length) != 0 {
+            length += 1;
+        }
+        String::from_utf8_lossy(std::slice::from_raw_parts(name, length)).into_owned()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 枚举注入
+// ---------------------------------------------------------------------------
+
+fn next_synthetic_handle() -> usize {
+    let token = NEXT_SYNTHETIC.fetch_add(1, Ordering::Relaxed);
+    token | SYNTHETIC_FLAG
+}
+
+/// 把已挂载的自定义 option 根接到 `real` 枚举结果之后
+///
+/// `real` 是调用方已经取到的真实枚举结果（也可能失败）。真实根目录存在时真实
+/// 条目先行、虚拟条目排在其后；不存在时用合成句柄直接交付虚拟条目。
+unsafe fn inject_option_roots(real: HANDLE, data: *mut c_void, wide: bool) -> HANDLE {
+    let roots = crate::server_resources::mounted_roots();
+    if roots.is_empty() {
+        return real;
+    }
+
+    if real == INVALID_HANDLE_VALUE {
+        // 真实 option 目录不存在：合成句柄，首个条目随 FindFirstFile 一起交付
+        let mut injected: Vec<String> = roots.into_iter().rev().collect();
+        let Some(first) = injected.pop() else {
+            return real;
+        };
+        let Some(handle_value) = reserve_synthetic(SyntheticState {
+            injected,
+            real: 0,
+            real_done: true,
+            wide,
+        }) else {
+            return real;
+        };
+        fill_find_data(&first, data, wide);
+        return handle_value as HANDLE;
+    }
+
+    // 真实根目录存在：真实条目先行，虚拟根排在最后；同名则不再重复
+    let first = name_from(data, wide);
+    let injected: Vec<String> = roots
+        .into_iter()
+        .filter(|root| !root.eq_ignore_ascii_case(&first))
+        .rev()
+        .collect();
+    if injected.is_empty() {
+        return real;
+    }
+    let Some(handle_value) = reserve_synthetic(SyntheticState {
+        injected,
+        real: real as usize,
+        real_done: false,
+        wide,
+    }) else {
+        return real;
+    };
+    handle_value as HANDLE
+}
+
+/// 登记一个合成枚举状态；超出上限时返回 `None`（调用方回退真实结果）
+fn reserve_synthetic(state: SyntheticState) -> Option<usize> {
+    let mut synthetic = synthetic().lock().ok()?;
+    if synthetic.len() >= MAX_SYNTHETIC {
+        log_warn("ServerResources: too many open enumerations, skipping injection");
+        return None;
+    }
+    let handle_value = next_synthetic_handle();
+    synthetic.insert(handle_value, state);
+    Some(handle_value)
+}
+
+/// 合成句柄的下一项；不是合成句柄时返回 `None`（调用方转交真实 API）
+unsafe fn synthetic_next(handle: HANDLE, data: *mut c_void) -> Option<i32> {
+    if (handle as usize) & SYNTHETIC_FLAG == 0 {
+        return None;
+    }
+    let Ok(mut synthetic) = synthetic().lock() else {
+        return Some(0);
+    };
+    let Some(state) = synthetic.get_mut(&(handle as usize)) else {
+        return Some(0);
+    };
+
+    // 先走真实枚举；结束后再追加虚拟条目，保证原有顺序不变
+    if !state.real_done {
+        if state.real != 0 {
+            let slot = if state.wide {
+                &NEXT_FIND_NEXT_FILE_W
+            } else {
+                &NEXT_FIND_NEXT_FILE_A
+            };
+            if let Some(next) = next_fn::<FindNextFileFn>(slot) {
+                if next(state.real as HANDLE, data) != 0 {
+                    // 真实目录已有同名项则不再追加虚拟根，避免重复
+                    let name = name_from(data, state.wide);
+                    state
+                        .injected
+                        .retain(|root| !root.eq_ignore_ascii_case(&name));
+                    return Some(1);
+                }
+            }
+        }
+        state.real_done = true;
+    }
+
+    match state.injected.pop() {
+        Some(root) => {
+            fill_find_data(&root, data, state.wide);
+            Some(1)
+        }
+        None => Some(0),
+    }
+}
+
+/// 关闭合成句柄，回收其真实句柄
+unsafe fn synthetic_close(handle: HANDLE) -> Option<i32> {
+    if (handle as usize) & SYNTHETIC_FLAG == 0 {
+        return None;
+    }
+    let real = synthetic()
+        .lock()
+        .ok()
+        .and_then(|mut synthetic| synthetic.remove(&(handle as usize)).map(|state| state.real))
+        .unwrap_or(0);
+    if real != 0 {
+        if let Some(next) = next_fn::<FindCloseFn>(&NEXT_FIND_CLOSE) {
+            next(real as HANDLE);
+        }
+    }
+    Some(1)
+}
+
+unsafe fn inject_from_path(
+    path: Option<String>,
+    real: HANDLE,
+    data: *mut c_void,
+    wide: bool,
+) -> HANDLE {
+    match path {
+        Some(path) if is_option_root_glob(&path) => inject_option_roots(real, data, wide),
+        _ => real,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 枚举钩子
+// ---------------------------------------------------------------------------
+
+unsafe extern "system" fn hooked_find_first_file_a(path: *const i8, data: *mut c_void) -> HANDLE {
+    let Some(next) = next_fn::<FindFirstFileAFn>(&NEXT_FIND_FIRST_FILE_A) else {
+        return INVALID_HANDLE_VALUE;
+    };
+    let real = next(path, data);
+    let text = winapi::cstr_to_string(path);
+    inject_from_path(text, real, data, false)
+}
+
+unsafe extern "system" fn hooked_find_first_file_w(path: *const u16, data: *mut c_void) -> HANDLE {
+    let Some(next) = next_fn::<FindFirstFileWFn>(&NEXT_FIND_FIRST_FILE_W) else {
+        return INVALID_HANDLE_VALUE;
+    };
+    let real = next(path, data);
+    let text = winapi::wide_to_string(path);
+    inject_from_path(text, real, data, true)
+}
+
+unsafe extern "system" fn hooked_find_first_file_ex_a(
+    path: *const i8,
+    info_level: u32,
+    data: *mut c_void,
+    search_op: u32,
+    filter: *mut c_void,
+    flags: u32,
+) -> HANDLE {
+    let Some(next) = next_fn::<FindFirstFileExAFn>(&NEXT_FIND_FIRST_FILE_EX_A) else {
+        return INVALID_HANDLE_VALUE;
+    };
+    let real = next(path, info_level, data, search_op, filter, flags);
+    let text = winapi::cstr_to_string(path);
+    inject_from_path(text, real, data, false)
+}
+
+unsafe extern "system" fn hooked_find_first_file_ex_w(
+    path: *const u16,
+    info_level: u32,
+    data: *mut c_void,
+    search_op: u32,
+    filter: *mut c_void,
+    flags: u32,
+) -> HANDLE {
+    let Some(next) = next_fn::<FindFirstFileExWFn>(&NEXT_FIND_FIRST_FILE_EX_W) else {
+        return INVALID_HANDLE_VALUE;
+    };
+    let real = next(path, info_level, data, search_op, filter, flags);
+    let text = winapi::wide_to_string(path);
+    inject_from_path(text, real, data, true)
+}
+
+unsafe extern "system" fn hooked_find_next_file_a(handle: HANDLE, data: *mut c_void) -> i32 {
+    if let Some(result) = synthetic_next(handle, data) {
+        return result;
+    }
+    match next_fn::<FindNextFileFn>(&NEXT_FIND_NEXT_FILE_A) {
+        Some(next) => next(handle, data),
+        None => 0,
+    }
+}
+
+unsafe extern "system" fn hooked_find_next_file_w(handle: HANDLE, data: *mut c_void) -> i32 {
+    if let Some(result) = synthetic_next(handle, data) {
+        return result;
+    }
+    match next_fn::<FindNextFileFn>(&NEXT_FIND_NEXT_FILE_W) {
+        Some(next) => next(handle, data),
+        None => 0,
+    }
+}
+
+unsafe extern "system" fn hooked_find_close(handle: HANDLE) -> i32 {
+    if let Some(result) = synthetic_close(handle) {
+        return result;
+    }
+    match next_fn::<FindCloseFn>(&NEXT_FIND_CLOSE) {
+        Some(next) => next(handle),
+        None => 0,
+    }
+}
+
+/// 取出下一跳函数指针；未挂接时为 `None`
+unsafe fn next_fn<T>(slot: &AtomicUsize) -> Option<T> {
+    let value = slot.load(Ordering::SeqCst);
+    if value == 0 {
+        return None;
+    }
+    Some(std::mem::transmute_copy::<usize, T>(&value))
+}
+
+fn log_warn(message: &str) {
+    if let Some(api) = crate::util::api::API.get() {
+        api.log_warn(message);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn synthetic_handles_are_flagged_and_unique() {
+        // Given: 连续分配两个合成枚举句柄。
+        let first = next_synthetic_handle();
+        let second = next_synthetic_handle();
+
+        // Then: 都带高位标记且互不相同，不会与内核句柄混淆。
+        assert_ne!(first, second);
+        assert_ne!(first & SYNTHETIC_FLAG, 0);
+        assert_ne!(second & SYNTHETIC_FLAG, 0);
+    }
+
+    #[test]
+    fn only_the_option_root_glob_is_claimed() {
+        // Given: option 根的各种通配写法。
+        // Then: 只有根那一级被认领；更深一层由重定向交给游戏自己枚举。
+        assert!(is_option_root_glob("c:\\mount\\option\\*"));
+        assert!(is_option_root_glob("C:\\mount\\option\\*.*"));
+        assert!(!is_option_root_glob("c:\\mount\\option\\A123\\*"));
+        assert!(!is_option_root_glob("c:\\mount\\option2\\*"));
+        assert!(!is_option_root_glob("c:\\mount\\option\\*\\data.conf"));
+        assert!(!is_option_root_glob("c:\\mount\\option\\A123\\data.conf"));
+    }
+
+    #[test]
+    fn find_data_name_round_trips_in_both_variants() {
+        // Given: 分别按 ANSI / 宽字符填充的 FIND_DATA 缓冲区。
+        let mut ansi = vec![0u8; FIND_DATA_SIZE_A];
+        let mut wide = vec![0u8; FIND_DATA_SIZE_W];
+
+        unsafe {
+            // When: 写入 option 根目录条目。
+            fill_find_data("A123", ansi.as_mut_ptr().cast(), false);
+            fill_find_data("A124", wide.as_mut_ptr().cast(), true);
+
+            // Then: 名称与目录属性都能读回。
+            assert_eq!(name_from(ansi.as_ptr().cast(), false), "A123");
+            assert_eq!(name_from(wide.as_ptr().cast(), true), "A124");
+            assert_eq!(
+                u32::from_le_bytes(ansi[0..4].try_into().unwrap()),
+                FILE_ATTRIBUTE_DIRECTORY
+            );
+            assert_eq!(
+                u32::from_le_bytes(wide[0..4].try_into().unwrap()),
+                FILE_ATTRIBUTE_DIRECTORY
+            );
+        }
+    }
+
+    #[test]
+    fn state_keeps_real_handle_after_injection() {
+        // Given: 一次带真实句柄的枚举。
+        let handle_value = next_synthetic_handle();
+        synthetic().lock().unwrap().insert(
+            handle_value,
+            SyntheticState {
+                injected: Vec::new(),
+                real: 0x1234,
+                real_done: false,
+                wide: false,
+            },
+        );
+
+        // Then: 关闭时取出真实句柄（调用方据此转交 FindClose），状态被清除。
+        unsafe {
+            assert_eq!(synthetic_close(handle_value as HANDLE), Some(1));
+        }
+        assert!(!synthetic().lock().unwrap().contains_key(&handle_value));
+    }
+
+    #[test]
+    fn virtual_roots_are_deferred_until_real_enumeration_ends() {
+        // Given: 一个真实枚举已结束的合成句柄，带两个虚拟根（倒序存放）。
+        let handle_value = next_synthetic_handle();
+        synthetic().lock().unwrap().insert(
+            handle_value,
+            SyntheticState {
+                injected: vec!["A124".to_owned(), "A123".to_owned()],
+                real: 0,
+                real_done: false,
+                wide: false,
+            },
+        );
+
+        // When: 真实句柄为 0（根目录不存在），逐个取虚拟条目。
+        let mut buffer = vec![0u8; FIND_DATA_SIZE_A];
+        let mut names = Vec::new();
+        unsafe {
+            while synthetic_next(handle_value as HANDLE, buffer.as_mut_ptr().cast()) == Some(1) {
+                names.push(name_from(buffer.as_ptr().cast(), false));
+            }
+        }
+
+        // Then: 按挂载顺序交出，取完后返回 0。
+        assert_eq!(names, vec!["A123".to_owned(), "A124".to_owned()]);
+    }
+
+    #[test]
+    fn unknown_handles_are_left_to_real_api() {
+        // Given: 不带合成标记的内核句柄。
+        // Then: 枚举与关闭都不认领。
+        unsafe {
+            assert_eq!(synthetic_next(0x1234 as HANDLE, std::ptr::null_mut()), None);
+            assert_eq!(synthetic_close(0x1234 as HANDLE), None);
+        }
+    }
+}
diff --git a/packages/applechu/src/util/api.rs b/packages/applechu/src/util/api.rs
index 1f3d91e..e6a8eb0 100644
--- a/packages/applechu/src/util/api.rs
+++ b/packages/applechu/src/util/api.rs
@@ -262,6 +262,23 @@ impl Api {
             .is_some_and(|func| unsafe { func(target as *mut c_void) == 0 })
     }
 
+    /// 向订阅了 `topic` 的模组广播一段字节
+    ///
+    /// 把游戏侧事件（如网络响应）暴露给 chu-abi 模组；无订阅者时为空操作。
+    pub fn publish(&self, topic: &str, data: &[u8]) -> bool {
+        let Ok(topic) = CString::new(topic) else {
+            return false;
+        };
+        let Ok(size) = u32::try_from(data.len()) else {
+            return false;
+        };
+        self.raw()
+            .and_then(|api| api.publish)
+            .is_some_and(|func| unsafe {
+                func(topic.as_ptr(), data.as_ptr().cast_mut().cast(), size) == 0
+            })
+    }
+
     pub fn register_present_callback(&self, cb: chu_abi::ChuModPresentCallback) -> bool {
         self.raw()
             .and_then(|api| api.register_present_callback)
diff --git a/packages/applechu/src/util/crypto.rs b/packages/applechu/src/util/crypto.rs
new file mode 100644
index 0000000..0aea549
--- /dev/null
+++ b/packages/applechu/src/util/crypto.rs
@@ -0,0 +1,165 @@
+//! RSA 验签与 base64 解码
+//!
+//! 服务器下发的资源包由 MuNET 私钥签名，客户端用内置公钥验签。
+//! 签名算法与 AquaMai 一致：RSA PKCS#1 v1.5 + SHA-256。
+//! 公钥以 base64 编码的 modulus 形式给出，指数固定 65537。
+
+use std::ffi::c_void;
+use std::ptr;
+
+use windows_sys::Win32::Security::Cryptography::{
+    BCryptCloseAlgorithmProvider, BCryptDestroyKey, BCryptImportKeyPair,
+    BCryptOpenAlgorithmProvider, BCryptVerifySignature, BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE,
+    BCRYPT_PAD_PKCS1, BCRYPT_PKCS1_PADDING_INFO, BCRYPT_RSAPUBLIC_BLOB, BCRYPT_RSA_ALGORITHM,
+    BCRYPT_SHA256_ALGORITHM,
+};
+
+use crate::util::hash::sha256;
+
+/// `BCRYPT_RSAKEY_BLOB` 的公钥魔数（"RSA1"）
+const BCRYPT_RSAPUBLIC_MAGIC: u32 = 0x3141_5352;
+/// 固定公钥指数 65537（大端字节序）
+const PUBLIC_EXPONENT: [u8; 3] = [0x01, 0x00, 0x01];
+
+/// 解码标准 base64（忽略空白，要求正确的 `=` 填充）
+pub fn base64_decode(input: &str) -> Option<Vec<u8>> {
+    let mut output = Vec::with_capacity(input.len() / 4 * 3);
+    let mut accumulator: u32 = 0;
+    let mut bits = 0u32;
+
+    for byte in input.bytes() {
+        let value = match byte {
+            b'A'..=b'Z' => byte - b'A',
+            b'a'..=b'z' => byte - b'a' + 26,
+            b'0'..=b'9' => byte - b'0' + 52,
+            b'+' => 62,
+            b'/' => 63,
+            b'=' => break,
+            b' ' | b'\t' | b'\r' | b'\n' => continue,
+            _ => return None,
+        };
+        accumulator = (accumulator << 6) | u32::from(value);
+        bits += 6;
+        if bits >= 8 {
+            bits -= 8;
+            output.push((accumulator >> bits) as u8);
+        }
+    }
+
+    Some(output)
+}
+
+/// 用内置公钥验证 `data` 上的 `signature`（base64）
+///
+/// `modulus_base64` 是 RSA 公钥的 base64 modulus；解析或验证失败均返回 `false`。
+pub fn verify_signature(modulus_base64: &str, data: &[u8], signature_base64: &str) -> bool {
+    let Some(modulus) = base64_decode(modulus_base64) else {
+        return false;
+    };
+    let Some(signature) = base64_decode(signature_base64) else {
+        return false;
+    };
+    let Some(digest) = sha256(data) else {
+        return false;
+    };
+    verify_rsa_sha256(&modulus, &signature, &digest)
+}
+
+/// 组装 `BCRYPT_RSAPUBLIC_BLOB` 并调用 BCrypt 验签
+fn verify_rsa_sha256(modulus: &[u8], signature: &[u8], digest: &[u8; 32]) -> bool {
+    if modulus.is_empty() || signature.is_empty() {
+        return false;
+    }
+    let Ok(modulus_len) = u32::try_from(modulus.len()) else {
+        return false;
+    };
+
+    // BCRYPT_RSAKEY_BLOB 头部 + 公钥指数 + modulus
+    let mut blob = Vec::with_capacity(24 + PUBLIC_EXPONENT.len() + modulus.len());
+    blob.extend_from_slice(&BCRYPT_RSAPUBLIC_MAGIC.to_le_bytes());
+    blob.extend_from_slice(&(modulus.len() as u32 * 8).to_le_bytes()); // BitLength
+    blob.extend_from_slice(&(PUBLIC_EXPONENT.len() as u32).to_le_bytes()); // cbPublicExp
+    blob.extend_from_slice(&modulus_len.to_le_bytes()); // cbModulus
+    blob.extend_from_slice(&0u32.to_le_bytes()); // cbPrime1
+    blob.extend_from_slice(&0u32.to_le_bytes()); // cbPrime2
+    blob.extend_from_slice(&PUBLIC_EXPONENT);
+    blob.extend_from_slice(modulus);
+
+    unsafe {
+        let mut algorithm: BCRYPT_ALG_HANDLE = ptr::null_mut();
+        if BCryptOpenAlgorithmProvider(&mut algorithm, BCRYPT_RSA_ALGORITHM, ptr::null(), 0) != 0 {
+            return false;
+        }
+
+        let mut key: BCRYPT_KEY_HANDLE = ptr::null_mut();
+        let imported = BCryptImportKeyPair(
+            algorithm,
+            ptr::null_mut(),
+            BCRYPT_RSAPUBLIC_BLOB,
+            &mut key,
+            blob.as_ptr(),
+            blob.len() as u32,
+            0,
+        ) == 0;
+
+        let verified = if imported {
+            let padding = BCRYPT_PKCS1_PADDING_INFO {
+                pszAlgId: BCRYPT_SHA256_ALGORITHM,
+            };
+            BCryptVerifySignature(
+                key,
+                (&padding as *const BCRYPT_PKCS1_PADDING_INFO).cast::<c_void>(),
+                digest.as_ptr(),
+                digest.len() as u32,
+                signature.as_ptr(),
+                signature.len() as u32,
+                BCRYPT_PAD_PKCS1,
+            ) == 0
+        } else {
+            false
+        };
+
+        if !key.is_null() {
+            BCryptDestroyKey(key);
+        }
+        BCryptCloseAlgorithmProvider(algorithm, 0);
+        verified
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn base64_round_trips_known_vectors() {
+        // Given: RFC 4648 的标准测试向量。
+        let cases = [
+            ("", ""),
+            ("Zg==", "f"),
+            ("Zm8=", "fo"),
+            ("Zm9v", "foo"),
+            ("Zm9vYmFy", "foobar"),
+            ("+/8=", "\u{ff}\u{fe}"),
+        ];
+
+        // When/Then: 解码结果与原文一致。
+        for (encoded, plain) in cases {
+            assert_eq!(base64_decode(encoded).unwrap(), plain.as_bytes());
+        }
+    }
+
+    #[test]
+    fn base64_rejects_invalid_alphabet() {
+        // Given: 含非法字符的输入。
+        // Then: 解码失败而不是静默给出错误字节。
+        assert!(base64_decode("Zm9v*").is_none());
+    }
+
+    #[test]
+    fn empty_modulus_never_verifies() {
+        // Given: 未配置公钥（空 modulus）。
+        // Then: 任何签名都不通过，避免"无公钥即放行"。
+        assert!(!verify_signature("", b"data", "AAAA"));
+    }
+}
diff --git a/packages/applechu/src/util/hash.rs b/packages/applechu/src/util/hash.rs
index 64d01aa..a18c16a 100644
--- a/packages/applechu/src/util/hash.rs
+++ b/packages/applechu/src/util/hash.rs
@@ -12,7 +12,8 @@ pub fn sha256_file(path: impl AsRef<std::path::Path>) -> Option<String> {
     Some(digest.iter().map(|byte| format!("{byte:02X}")).collect())
 }
 
-fn sha256(data: &[u8]) -> Option<[u8; 32]> {
+/// 计算任意字节序列的 SHA-256（用于资源包验签与完整性比对）
+pub fn sha256(data: &[u8]) -> Option<[u8; 32]> {
     unsafe {
         let mut algorithm: BCRYPT_ALG_HANDLE = std::ptr::null_mut();
         if BCryptOpenAlgorithmProvider(&mut algorithm, BCRYPT_SHA256_ALGORITHM, std::ptr::null(), 0)
diff --git a/packages/applechu/src/util/mod.rs b/packages/applechu/src/util/mod.rs
index 4be9af1..6c61f3f 100644
--- a/packages/applechu/src/util/mod.rs
+++ b/packages/applechu/src/util/mod.rs
@@ -1,4 +1,5 @@
 pub mod api;
+pub mod crypto;
 pub mod hash;
 pub mod iat_hook;
 pub mod logging;