release: v0.2.4 里程碑快照（孤儿提交，无父；树 = dev 68362e5）

本批内容见 CHANGELOG.md 的 0.2.4 段。按 D41 用孤儿快照推 main，保留「公开史只有里程碑」的模型。

crates/core/tests/liteloader/install.rs

@@ -0,0 +1,297 @@
+//! 解析 → 计划 → 落盘 → 继承解析 → 启动参数顺序（两条父链：原版 / Forge）。
+
+use unlucky_core::addon::loader::{LoaderInstallPlan, LoaderPlanInput};
+use unlucky_core::download::blocking::block_on;
+use unlucky_core::game::arguments::Environment;
+use unlucky_core::game::inherit::resolve;
+use unlucky_core::game::install::execute;
+use unlucky_core::game::layout::GameLayout;
+use unlucky_core::launch::command_builder::tokenize;
+
+use crate::support::{
+    engine, liteloader_release, prefill, put_version, read_version, TempDir, FORGE_1122,
+    VANILLA_1122,
+};
+
+/// 原版父链：装完能落盘，清单指向原版，`arguments.game` 带 tweakClass。
+#[test]
+fn installs_over_vanilla_and_writes_the_manifest() {
+    let temp = TempDir::new("vanilla");
+    let layout = GameLayout::new(temp.path());
+    put_version(&layout, "1.12.2", VANILLA_1122);
+
+    let release = liteloader_release("1.12.2");
+    assert_eq!(release.version_id, "1.12.2-liteloader-1.12.2-SNAPSHOT");
+    let plan = LoaderInstallPlan::build(LoaderPlanInput {
+        layout: &layout,
+        release: &release,
+        environment: &Environment::host(),
+        parent_installed: true,
+    })
+    .expect("父版本已装，计划应可组");
+    assert!(!plan.vanilla_install_needed);
+    assert!(plan.install.client_jar().is_none(), "jar 归原版层");
+
+    // 三个库：launchwrapper（Mojang 库仓）+ asm-all（Central）+ 本体 jar（官方直链）。
+    let names: Vec<&str> = plan.files().iter().map(|file| file.name.as_str()).collect();
+    assert_eq!(names.len(), 3, "{names:?}");
+    let loader_jar = plan
+        .files()
+        .iter()
+        .find(|file| file.name == "com.mumfrey:liteloader:1.12.2-SNAPSHOT")
+        .expect("缺本体 jar");
+    assert!(
+        loader_jar
+            .url
+            .ends_with("/1.12.2-SNAPSHOT/liteloader-1.12.2-20171128.144431-4-release.jar"),
+        "本体直链：{}",
+        loader_jar.url
+    );
+    let asm = plan
+        .files()
+        .iter()
+        .find(|file| file.name.contains("asm-all"))
+        .expect("缺 asm-all");
+    assert!(
+        asm.url.starts_with("https://repo1.maven.org/maven2/"),
+        "asm-all 只能从 Central 取：{}",
+        asm.url
+    );
+
+    // 全部落点先铺好占位文件（库无 sha1/size → 存在即信），执行段只写版本 JSON。
+    let engine = engine(temp.path());
+    let prefilled = prefill(&plan.install);
+    assert_eq!(prefilled, 3);
+    let report = block_on(execute(&engine, &plan.install, 4, None)).expect("执行应成功");
+    assert!(report.is_complete(), "{:?}", report.failures(3));
+
+    let written = read_version(&layout, &release.version_id);
+    assert_eq!(written.inherits_from.as_deref(), Some("1.12.2"));
+    assert_eq!(
+        written.main_class.as_deref(),
+        Some("net.minecraft.launchwrapper.Launch")
+    );
+    assert!(
+        written.minecraft_arguments.is_none(),
+        "loader 层不许写 minecraftArguments：那会顶掉父链"
+    );
+}
+
+/// Forge 父链：**父链的 FMLTweaker 必须还在**，LiteLoader 的 tweakClass 追加在它后面。
+///
+/// 这条是 M218 SURVEY-p1 的「准入条件」：靠 `--tweakClass` 生效，就要求继承时
+/// `arguments.game` 是追加、`minecraftArguments` 不被子层覆盖。启动参数顺序照
+/// `core::launch::game_args` 的第 24 项（legacy 子串）→ 第 25 项（`arguments.game`）复现，
+/// 真实 argv 由 `tests/launch/cmdline_snapshot.rs` 钉住。
+#[test]
+fn stacks_on_forge_and_keeps_the_forge_tweak_class() {
+    let temp = TempDir::new("forge");
+    let layout = GameLayout::new(temp.path());
+    put_version(&layout, "1.12.2", VANILLA_1122);
+    put_version(&layout, "1.12.2-forge-14.23.5.2860", FORGE_1122);
+
+    let release = liteloader_release("1.12.2-forge-14.23.5.2860");
+    assert!(!release.parent_is_vanilla());
+    let plan = LoaderInstallPlan::build(LoaderPlanInput {
+        layout: &layout,
+        release: &release,
+        environment: &Environment::host(),
+        parent_installed: true,
+    })
+    .expect("父版本已装，计划应可组");
+    assert_eq!(plan.install.jar_id, "1.12.2", "jar 仍取原版那层");
+
+    let engine = engine(temp.path());
+    prefill(&plan.install);
+    let report = block_on(execute(&engine, &plan.install, 4, None)).expect("执行应成功");
+    assert!(report.is_complete(), "{:?}", report.failures(3));
+
+    let installed = read_version(&layout, &release.version_id);
+    let mut source = std::collections::BTreeMap::new();
+    source.insert("1.12.2".to_string(), read_version(&layout, "1.12.2"));
+    source.insert(
+        "1.12.2-forge-14.23.5.2860".to_string(),
+        read_version(&layout, "1.12.2-forge-14.23.5.2860"),
+    );
+    source.insert(release.version_id.clone(), installed);
+    let resolved = resolve(&source, &source[&release.version_id]).expect("三层继承应可解析");
+
+    // ① 父链的 legacy 参数整串还在（子层没写 minecraftArguments）。
+    let legacy = resolved
+        .minecraft_arguments
+        .as_deref()
+        .expect("Forge 的 minecraftArguments 不许被子层顶掉");
+    assert!(
+        legacy.contains("net.minecraftforge.fml.common.launcher.FMLTweaker"),
+        "Forge 的 tweakClass 丢了：{legacy}"
+    );
+
+    // ② 启动顺序：legacy（第 24 项）在前，arguments.game（第 25 项）在后。
+    let mut game: Vec<String> = tokenize(legacy);
+    game.extend(
+        resolved
+            .arguments
+            .as_ref()
+            .expect("arguments 应保留")
+            .expand(&Environment::host())
+            .game,
+    );
+    let forge_at = game
+        .iter()
+        .position(|token| token.contains("FMLTweaker"))
+        .expect("Forge tweakClass 不在游戏参数里");
+    let liteloader_at = game
+        .iter()
+        .position(|token| token == "com.mumfrey.liteloader.launch.LiteLoaderTweaker")
+        .expect("LiteLoader tweakClass 不在游戏参数里");
+    assert!(
+        forge_at < liteloader_at,
+        "launchwrapper 按出现顺序应用 tweak：Forge 必须在前，实际 {game:?}"
+    );
+    assert_eq!(game[liteloader_at - 1], "--tweakClass");
+
+    // ③ 主类与库顺序：Forge 的库在前（classpath 先到先得），LiteLoader 的在后。
+    assert_eq!(
+        resolved.main_class.as_deref(),
+        Some("net.minecraft.launchwrapper.Launch")
+    );
+    let libraries: Vec<&str> = resolved
+        .libraries
+        .as_deref()
+        .expect("libraries")
+        .iter()
+        .map(|library| library.name.as_str())
+        .collect();
+    let forge_lib = libraries
+        .iter()
+        .position(|name| name.starts_with("net.minecraftforge:forge:"))
+        .expect("缺 Forge 本体库");
+    let liteloader_lib = libraries
+        .iter()
+        .position(|name| name.starts_with("com.mumfrey:liteloader:"))
+        .expect("缺 LiteLoader 本体库");
+    assert!(forge_lib < liteloader_lib, "{libraries:?}");
+}
+
+/// **新式 args 的父链**：父版本用 `arguments.game`（没有 `minecraftArguments`）。
+///
+/// 现实里 LiteLoader 只到 1.12.2，碰不到这种父版本；但「追加语义」是这套路线的准入条件，
+/// 两种父版本形状都得钉住——否则哪天上游把老版本清单改成新式，我们会静默丢参数。
+/// 这里用一份**手工夹具**（`--launchTarget forgeclient` 是 Forge 1.13+ 的真实形态）说明：
+/// 父层参数在前、LiteLoader 的 tweakClass 在后，中间不互相覆盖。
+#[test]
+fn new_style_parent_args_are_appended_not_replaced() {
+    const MODERN_PARENT: &str = r#"{
+      "id": "1.12.2-modern-1.0",
+      "inheritsFrom": "1.12.2",
+      "mainClass": "net.minecraft.launchwrapper.Launch",
+      "arguments": {"game": ["--launchTarget", "forgeclient"], "jvm": ["-Dmodern=1"]},
+      "libraries": [{"name": "example:modern:1.0", "url": "https://example.invalid/"}]
+    }"#;
+
+    let temp = TempDir::new("modern-args");
+    let layout = GameLayout::new(temp.path());
+    put_version(&layout, "1.12.2", VANILLA_1122);
+    put_version(&layout, "1.12.2-modern-1.0", MODERN_PARENT);
+
+    let release = liteloader_release("1.12.2-modern-1.0");
+    let plan = LoaderInstallPlan::build(LoaderPlanInput {
+        layout: &layout,
+        release: &release,
+        environment: &Environment::host(),
+        parent_installed: true,
+    })
+    .expect("计划应可组");
+    let engine = engine(temp.path());
+    prefill(&plan.install);
+    let report = block_on(execute(&engine, &plan.install, 4, None)).expect("执行应成功");
+    assert!(report.is_complete(), "{:?}", report.failures(3));
+
+    let mut source = std::collections::BTreeMap::new();
+    source.insert("1.12.2".to_string(), read_version(&layout, "1.12.2"));
+    source.insert(
+        "1.12.2-modern-1.0".to_string(),
+        read_version(&layout, "1.12.2-modern-1.0"),
+    );
+    source.insert(
+        release.version_id.clone(),
+        read_version(&layout, &release.version_id),
+    );
+    let resolved = resolve(&source, &source[&release.version_id]).expect("三层继承应可解析");
+
+    // 子层没写 legacy 串：继承结果里的 `minecraftArguments` 只能是祖父层（原版）那一份，
+    // 里面绝不能出现 LiteLoader 的 tweakClass（写了就说明我们用了覆盖语义）。
+    let legacy = resolved
+        .minecraft_arguments
+        .as_deref()
+        .expect("原版那份 legacy 串应沿链继承下来");
+    assert!(
+        !legacy.contains("LiteLoaderTweaker"),
+        "loader 层不许往 minecraftArguments 里写：{legacy}"
+    );
+    let game = resolved
+        .arguments
+        .as_ref()
+        .expect("arguments")
+        .expand(&Environment::host())
+        .game;
+    let assert_order = |needle: &str| {
+        game.iter()
+            .position(|token| token == needle)
+            .unwrap_or_else(|| panic!("缺 `{needle}`：{game:?}"))
+    };
+    assert!(
+        assert_order("forgeclient")
+            < assert_order("com.mumfrey.liteloader.launch.LiteLoaderTweaker"),
+        "父层参数必须在前：{game:?}"
+    );
+}
+
+/// LiteLoader 生效所依赖的**两条继承合并律**（M222 第一步核实，直接钉在合并函数上）。
+///
+/// 1. `arguments.game`：父在前、子在后**追加**（所以 tweakClass 能叠在父链参数之后）；
+/// 2. `minecraftArguments`：**子覆盖父**（所以 loader 层绝不能写它，否则父链的 tweakClass
+///    整串消失）。
+///
+/// 抓得住：有人把 `minecraftArguments` 改成追加（HMCL/原版语义不是这样），或把
+/// `arguments.game` 改成整体替换（LiteLoader/其它叠层加载器当场失效）。
+/// 抓不住：真实启动 argv 的顺序（那是 `launch::game_args` 的第 24/25 项，
+/// 由 `tests/launch/cmdline_snapshot.rs` 钉住；本 mission 没有改那一层）。
+#[test]
+fn merge_laws_liteloader_depends_on() {
+    use unlucky_core::game::inherit::merge;
+    use unlucky_core::game::manifest::VersionJson;
+
+    let parse = |json: &str| VersionJson::from_json_str(json).expect("夹具应可解析");
+
+    let parent = parse(
+        r#"{"id":"p","minecraftArguments":"--tweakClass FMLTweaker","arguments":{"game":["--parent"]}}"#,
+    );
+    let child = parse(r#"{"id":"c","arguments":{"game":["--child"]}}"#);
+    let merged = merge(&child, &parent);
+    assert_eq!(
+        merged.minecraft_arguments.as_deref(),
+        Some("--tweakClass FMLTweaker"),
+        "子没写就继承父（这条是「叠在 Forge 上」的前提）"
+    );
+    let game: Vec<String> = merged
+        .arguments
+        .as_ref()
+        .expect("arguments")
+        .expand(&Environment::host())
+        .game;
+    assert_eq!(
+        game,
+        ["--parent", "--child"],
+        "arguments.game 是父在前、子在后追加"
+    );
+
+    // 子写了 minecraftArguments：整串替换（不是追加）。
+    let loud_child = parse(r#"{"id":"c2","minecraftArguments":"--tweakClass LiteLoaderTweaker"}"#);
+    let merged = merge(&loud_child, &parent);
+    assert_eq!(
+        merged.minecraft_arguments.as_deref(),
+        Some("--tweakClass LiteLoaderTweaker"),
+        "子覆盖父：这正是 loader 层不许写 minecraftArguments 的原因"
+    );
+}