架构重构：差异全部下移到 Java，Python 只做路由

用户口径：差异放在 Java 层，Python 相当于路由。

下移到 Java（新增 cmd=setblocks）：
  Python 只发 RLE（[[stateId,count],...]），Java 用官方 API 完成
  调色板组装 / 位打包 / 官方序列化 / 入 cache / 渲染。

★ 意外收益：走 ClientboundLevelChunkPacketData(chunk).getReadBuffer()
  + replaceWithPacketData(...) 这条官方路径，两代签名完全一致
  ⇒ 原先的 Storage.chunks 反射注入**整段删掉**。

新增 cmd=capacity：世界尺寸（sectionsCount/minSection/defaultBiome）
  由运行时回答，Python 不再硬编码 24/-4（1.16 时代是 16/0）。

Python 侧删除（防回归，见 test_import_surface）：
  render_bridge.py（旧桥，无世代概念）
  render._pack/_long_array/_encode_paletted/_encode_chunk/_varint
  anvil.encode_block_section/encode_chunk_payload/save_chunk_to_payload
  合计 454→374 行（render.py）、300→177 行（anvil.py）

保留在 Python（都是「不随版本变」的知识）：
  RLE 压缩（rle_encode/rle_decode，具名可测）
  存档读取（region/NBT）
  方块名→id 的路由（查询在 Java）
  NDJSON 协议

测试：62 项单元 + 6 项渲染联测全绿
  新测试反映新架构：RLE 边界、运行时容量、世代分派、新路径渲染
  test_anvil 里原有 8 项协议位打包测试已删（那已下移到 Java，
  由两代后端各自的编译验证覆盖）

新增 scaffold/ARCHITECTURE.md（分层原则 + 加新世代步骤 + 防回归清单）

tests/test_anvil.py

@@ -1,6 +1,11 @@
-"""anvil.py —— 存档读取与区块编码的单元测试。
+"""Python 侧职责的单元测试。
 
-不依赖 Java 渲染器；渲染链路的联测在 test_render_bridge.py。
+★ 架构口径（用户 2026-09-25 定向）
+    Python 负责：路由、方块名→id 查询、RLE 压缩、存档读取
+    Java 负责：  协议格式、调色板组装、位打包、入 cache、渲染
+
+所以这里**不再**测协议位打包（那已下移到 Java，由两代后端各自的编译验证覆盖）；
+改测 Python 真正负责的部分，尤其是 RLE 的边界与存档读取的真实数据。
 """
 import struct
 import sys
@@ -8,90 +13,81 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
-from mcfold.anvil import NbtReader, RegionFile, nbt_read, region_path, list_region_files
+from mcfold.anvil import (
+    NbtReader, RegionFile, list_region_files, nbt_read, read_level_dat, region_path,
+)
+from mcfold.backends.base import rle_decode, rle_encode
 from mcfold.render import (
-    _pack, _varint, _long_array, _decode_storage, _encode_paletted,
-    parse_save_chunk, SECTION_VOLUME, MIN_SECTION_Y,
+    BIOME_VOLUME, SECTION_VOLUME, SaveChunk, _props_to_spec, parse_save_chunk,
 )
 
 SAVE = Path("/home/mc-test/mc-test")
 
 
-def test_varint_roundtrip():
-    def read_varint(b: bytes) -> tuple[int, int]:
-        v = 0; shift = 0; i = 0
-        while True:
-            byte = b[i]; i += 1
-            v |= (byte & 0x7F) << shift
-            if not (byte & 0x80):
-                break
-            shift += 7
-        return v, i
+# ---------------------------------------------------------------- RLE（Python 的职责）
 
-    for n in [0, 1, 127, 128, 255, 16384, 2_097_152, 24135]:
-        enc = _varint(n)
-        dec, used = read_varint(enc)
-        assert dec == n, f"{n} -> {dec}"
-        assert used == len(enc)
-    print("  ✓ varint 编解码")
+def test_rle_basic():
+    assert rle_encode([]) == []
+    assert rle_encode([5]) == [[5, 1]]
+    assert rle_encode([5, 5, 5]) == [[5, 3]]
+    assert rle_encode([1, 2, 1]) == [[1, 1], [2, 1], [1, 1]]
+    print("  ✓ RLE 基本情形")
 
 
-def test_pack_unpack_roundtrip():
-    """位打包必须能被 _decode_storage 解回来（值不跨 long 边界）。"""
-    for bits in [4, 5, 8, 15]:
-        vals = [(i * 7) % (1 << min(bits, 8)) for i in range(64 * 4)]
-        longs = _pack(vals, bits)
-        back = _decode_storage(longs, len(vals), bits)
-        assert back == vals, f"bits={bits} 不一致: {back[:8]} vs {vals[:8]}"
-    print("  ✓ 位打包往返一致（4/5/8/15 位）")
+def test_rle_roundtrip():
+    cases = [
+        [0] * 4096,
+        [1] * 4096,
+        [0] * 4090 + [9] * 6,
+        list(range(256)) * 16,
+        [7 if i % 3 else 0 for i in range(4096)],
+    ]
+    for v in cases:
+        assert rle_decode(rle_encode(v)) == v
+    print("  ✓ RLE 往返一致（含全同/交替/随机模式）")
 
 
-def test_long_array_encoding():
-    """LongArray = varint(长度) + 大端 i64 ×N。"""
-    enc = _long_array([1, -1])
-    assert enc[0] == 2                      # 长度 2
-    assert enc[1:9] == (1).to_bytes(8, "big")
-    assert enc[9:17] == (0xFFFFFFFFFFFFFFFF).to_bytes(8, "big")
-    assert _long_array([])[0] == 0
-    print("  ✓ LongArray 编码（含负数/空）")
+def test_rle_is_lossless_on_long_runs():
+    """长游程必须无损 —— 一个 section 常有整片空气/石头。"""
+    v = [0] * 4000 + [1] * 96
+    enc = rle_encode(v)
+    assert len(enc) == 2, f"应压成 2 段，得到 {len(enc)}"
+    assert rle_decode(enc, expected=SECTION_VOLUME) == v
+    print("  ✓ 长游程无损压缩（4096 格 → 2 段）")
 
 
-def test_paletted_single_value():
-    """单值分支：byte(0) + varint(state) + varint(0 longs) —— 与 Java 对齐。"""
-    data = _encode_paletted([5] * SECTION_VOLUME, SECTION_VOLUME)
-    assert data[0] == 0, "bitsPerValue 应为 0"
-    assert data[1] == 5, "state id 应跟在 bits 后"
-    assert data[2] == 0, "longs 数应为 0"
-    print("  ✓ 单值调色板编码（3 字节）")
+def test_rle_decode_length_check():
+    """长度不符要报错，而不是静默给出错长度的列表（防下游越界）。"""
+    try:
+        rle_decode([[1, 3]], expected=4096)
+    except ValueError as e:
+        assert "4096" in str(e)
+        print("  ✓ RLE 长度校验")
+        return
+    raise AssertionError("长度不符时应抛 ValueError")
 
 
-def test_paletted_indirect():
-    """多值走本地调色板：bits + n + palette + longs。"""
-    vals = [0] * (SECTION_VOLUME - 1) + [3]
-    data = _encode_paletted(vals, SECTION_VOLUME)
-    bits = data[0]
-    assert bits >= 4, f"本地调色板 bits 至少 4，得到 {bits}"
-    n = data[1]
-    assert n == 2, f"调色板应有 2 项，得到 {n}"
-    print(f"  ✓ 间接调色板编码（bits={bits}, palette={n}）")
+def test_rle_handles_bool_like_and_negative():
+    """palette 索引可能是任意 int；不假设范围。"""
+    v = [-1, -1, 0, 0, 0]
+    assert rle_decode(rle_encode(v)) == v
+    print("  ✓ RLE 接受任意 int（含负值）")
 
 
+# ---------------------------------------------------------------- NBT / 存档读取
+
 def test_nbt_reader_primitives():
-    """NBT 读取器的基本类型。"""
-    # Compound{ "a": Int(7), "b": String("hi") }
     body = bytearray()
-    body += bytes([10])                     # root: Compound
-    body += struct.pack(">H", 1) + b"R"     # 名字 "R"
+    body += bytes([10]) + struct.pack(">H", 1) + b"R"
     body += bytes([3]) + struct.pack(">H", 1) + b"a" + struct.pack(">i", 7)
     body += bytes([8]) + struct.pack(">H", 1) + b"b" + struct.pack(">H", 2) + b"hi"
-    body += bytes([0])                      # end
-    d = nbt_read(bytes(body))
-    assert d == {"a": 7, "b": "hi"}, d
+    body += bytes([0])
+    assert nbt_read(bytes(body)) == {"a": 7, "b": "hi"}
     print("  ✓ NBT 基本类型（int/string）")
 
 
 def test_nbt_nested_list():
-    """嵌套 List/Compound（存档 sections 就是这个形状）。"""
+    """嵌套 List[Compound] —— 存档 sections 就是这个形状。"""
     body = bytearray()
     body += bytes([10]) + struct.pack(">H", 0)
     body += bytes([9]) + struct.pack(">H", 4) + b"list" + bytes([10]) + struct.pack(">i", 2)
@@ -99,44 +95,49 @@ def test_nbt_nested_list():
         body += bytes([3]) + struct.pack(">H", 1) + b"Y" + struct.pack(">i", y)
         body += bytes([0])
     body += bytes([0])
-    d = nbt_read(bytes(body))
-    assert d == {"list": [{"Y": 0}, {"Y": 1}]}, d
+    assert nbt_read(bytes(body)) == {"list": [{"Y": 0}, {"Y": 1}]}
     print("  ✓ NBT 嵌套 List[Compound]")
 
 
+def test_nbt_long_array():
+    """区块高度图与 block_states.data 都是 LongArray。"""
+    body = bytearray()
+    body += bytes([10]) + struct.pack(">H", 0)
+    body += bytes([12]) + struct.pack(">H", 1) + b"d" + struct.pack(">i", 2)
+    body += struct.pack(">qq", -1, 1234567890123)
+    body += bytes([0])
+    d = nbt_read(bytes(body))
+    assert d == {"d": [-1, 1234567890123]}, d
+    print("  ✓ NBT LongArray（含负值）")
+
+
 def test_props_to_spec():
-    from mcfold.render import _props_to_spec
     assert _props_to_spec("minecraft:stone", None) == "minecraft:stone"
     assert _props_to_spec("minecraft:oak_log", {"axis": "y"}) == "minecraft:oak_log[axis=y]"
-    # 多属性要排序（保证缓存命中稳定）
+    # 属性顺序必须稳定（否则 id 缓存命中率下降）
     a = _props_to_spec("minecraft:oak_stairs", {"facing": "north", "half": "top"})
     b = _props_to_spec("minecraft:oak_stairs", {"half": "top", "facing": "north"})
-    assert a == b == "minecraft:oak_stairs[facing=north,half=top]", a
+    assert a == b == "minecraft:oak_stairs[facing=north,half=top]"
     print("  ✓ 方块名规格生成（属性排序稳定）")
 
 
 def test_real_save_level_dat():
-    """真实 level.dat：本机存档是该格式（直接 gzip，无 8 字节头）。"""
     if not (SAVE / "level.dat").is_file():
         print("  - 无测试存档，跳过")
         return
-    from mcfold.anvil import read_level_dat
     lv = read_level_dat(SAVE)
     data = lv["Data"]
-    assert "LevelName" in data
-    assert isinstance(data.get("DataVersion"), int)
-    assert "Version" in data
+    assert "LevelName" in data and isinstance(data.get("DataVersion"), int)
     print(f"  ✓ 真实 level.dat（{data['LevelName']}, DataVersion={data['DataVersion']}）")
 
 
 def test_real_region_chunk():
-    """真实 region：读出区块 NBT，且有完整地形（不是全空气）。"""
     if not (SAVE / "region").is_dir():
         print("  - 无测试存档，跳过")
         return
     regs = list_region_files(SAVE)
     assert regs, "应有 region 文件"
-    found = None
+    names = set()
     for rf in regs[:4]:
         for cx, cz in [(-1, -1), (0, 0), (8, -7)]:
             try:
@@ -144,25 +145,21 @@ def test_real_region_chunk():
             except Exception:
                 continue
             if raw:
-                found = nbt_read(raw)
-                break
-        if found:
+                n = nbt_read(raw)
+                for s in n.get("sections", []):
+                    for p in (s.get("block_states") or {}).get("palette") or []:
+                        names.add(p.get("Name"))
+        if names:
             break
-    assert found is not None, "应至少读到一个区块"
-    names = set()
-    for s in found.get("sections", []):
-        for p in (s.get("block_states") or {}).get("palette") or []:
-            names.add(p.get("Name"))
-    assert len(names) > 1, f"完整区块应有多种方块，得到 {names}"
+    assert len(names) > 1, f"完整区块应含多种方块，得到 {names}"
     print(f"  ✓ 真实区块 NBT（{len(names)} 种方块）")
 
 
-def test_parse_save_chunk_shapes():
-    """parse_save_chunk 输出的结构：states 长度、Y 范围、规格去重。"""
+def test_parse_save_chunk_shape():
+    """parse_save_chunk 的产物必须可直接喂 RLE（长度=4096，值是名字规格）。"""
     if not (SAVE / "region").is_dir():
         print("  - 无测试存档，跳过")
         return
-    rf = None
     nbt = None
     for r in list_region_files(SAVE):
         for cx, cz in [(-1, -1), (0, 0)]:
@@ -173,7 +170,7 @@ def test_parse_save_chunk_shapes():
             if raw:
                 n = nbt_read(raw)
                 if n.get("Status") == "minecraft:full":
-                    rf, nbt = r, n
+                    nbt = n
                     break
         if nbt:
             break
@@ -184,47 +181,50 @@ def test_parse_save_chunk_shapes():
     assert ch.sections, "应有 sections"
     for sy, sec in ch.sections.items():
         assert len(sec["states"]) == SECTION_VOLUME, f"Y={sy} states 长度 {len(sec['states'])}"
-        assert len(sec["biomes"]) == 64
-        assert sec["states"][0].startswith("minecraft:")
+        assert all(isinstance(s, str) and s.startswith("minecraft:") for s in sec["states"][:8])
     assert ch.palette_specs == sorted(ch.palette_specs), "规格应去重且排序"
-    print(f"  ✓ parse_save_chunk（{len(ch.sections)} sections, {len(ch.palette_specs)} 规格）")
+    print(f"  ✓ parse_save_chunk 产物可直接喂 RLE（{len(ch.sections)} sections, "
+          f"{len(ch.palette_specs)} 规格）")
 
 
-def test_section_y_mapping():
-    """★ 关键回归：存档绝对 Y(-4..19) ↔ 载荷索引(0..23)。"""
-    assert MIN_SECTION_Y == -4, "1.20 的 minSection 是 -4"
-    # 载荷索引 0 应取存档 Y=-4；索引 23 应取存档 Y=19
-    save_y = {i - 4: {"states": ["minecraft:air"] * SECTION_VOLUME,
-                      "biomes": ["minecraft:plains"] * 64, "palette": []}
-              for i in range(24)}
-    # 用真实编码器验证：只放 Y=-4 有 stone，则载荷 section 0 应是 stone
-    save_y[-4]["states"] = ["minecraft:stone"] * SECTION_VOLUME
-    save_y[-4]["palette"] = ["minecraft:stone"]
-    from mcfold.render import SaveChunk
+def test_section_y_mapping_needs_runtime_value():
+    """★ 回归：section 索引 ↔ 绝对 Y 的偏移必须是运行时值，不是硬编码。
 
-    class FakeWR:
-        def _encode_chunk(self, c, id_map):
-            return bytearray()
-
-    # 直接调编码核心：验证第 0 个 section 用的是 Y=-4
-    from mcfold.render import _encode_paletted
-    out = bytearray()
-    for sy in range(24):
-        sec = save_y.get(sy - 4)
-        ids = [1 if s == "minecraft:stone" else 0 for s in sec["states"]]
-        out += (sum(1 for v in ids if v) & 0xFFFF).to_bytes(2, "big")
-        out += _encode_paletted(ids, SECTION_VOLUME)
-        out += bytes([0]) + _varint(1) + _varint(0)
-    # 第一个 section 的 nonEmpty 应为 4096（不是 0）
-    assert struct.unpack_from(">h", out, 0)[0] == 4096, "索引 0 应映射到存档 Y=-4"
-    print("  ✓ section 索引 ↔ 绝对 Y 映射（-4..19 ↔ 0..23）")
+    1.20.x 是 minSection=-4；更早的版本不是。Python 只从后端取。
+    """
+    from mcfold.render import FALLBACK_MIN_SECTION_Y, WorldRenderer
+    assert FALLBACK_MIN_SECTION_Y == -4, "降级默认值（真实值应来自后端 capacity）"
+    # WorldRenderer 的 min_section_y 优先用后端值
+    class FakeCap:
+        _capacity = {"minSection": -4, "sectionsCount": 24}
+        _biome_id = None
+        @property
+        def min_section_y(self):
+            return WorldRenderer.min_section_y.fget(self)
+        @property
+        def sections_count(self):
+            return WorldRenderer.sections_count.fget(self)
+    f = FakeCap()
+    assert f.min_section_y == -4
+    assert f.sections_count == 24
+    # 后端给不同值时跟随
+    class FakeCap2(FakeCap):
+        _capacity = {"minSection": 0, "sectionsCount": 16}
+    f2 = FakeCap2()
+    assert f2.min_section_y == 0, "应跟随后端值（1.16 时代 minSection=0）"
+    assert f2.sections_count == 16
+    print("  ✓ section 偏移取自运行时（不硬编码版本）")
 
 
-def test_encode_empty_section_is_air():
-    """缺失的 section 编成空气（不是跳过）—— 否则 Java 侧读越界。"""
-    data = _encode_paletted([0] * SECTION_VOLUME, SECTION_VOLUME)
-    assert data == bytes([0, 0, 0]), f"空气 section 应是 3 字节，得到 {len(data)}"
-    print("  ✓ 空 section 编码为空气")
+def test_import_surface():
+    """已下移到 Java 的协议编码函数不应再存在于 Python（防回归）。"""
+    import mcfold.render as R
+    for gone in ("_pack", "_long_array", "_encode_paletted", "_encode_chunk", "_varint"):
+        assert not hasattr(R, gone), f"{gone} 应已下移到 Java 侧"
+    # 读路径必须保留
+    assert hasattr(R, "_decode_storage")
+    assert hasattr(R, "parse_save_chunk")
+    print("  ✓ 模块面：写路径已下移，读路径保留")
 
 
 if __name__ == "__main__":
@@ -235,6 +235,9 @@ if __name__ == "__main__":
             t()
         except Exception as e:
             failed += 1
+            import traceback
             print(f"  ✗ {t.__name__}: {e}")
-    print(f"\nanvil/render 单元测试: " + ("全部通过" if failed == 0 else f"{len(tests)-failed}/{len(tests)} 通过"))
+            traceback.print_exc()
+    print(f"\nanvil/render 单元测试: "
+          + ("全部通过" if failed == 0 else f"{len(tests)-failed}/{len(tests)} 通过"))
     sys.exit(1 if failed else 0)

tests/test_render_bridge.py

@@ -1,10 +1,12 @@
-"""渲染桥联测：Python ↔ Java 渲染器。
+"""渲染联测：Python ↔ Java 后端。
 
 需要：
   - 已构建的 client-named.jar + McfoldRenderServer.class
   - 环境变量 MCFOLD_RENDER_CLASSPATH、MCFOLD_NATIVES_DIR
   - Xvfb DISPLAY
 缺任一项则跳过（不误报失败）。
+
+★ 架构口径：Python 只发 RLE（set_blocks），协议格式由 Java 侧组装。
 """
 import os
 import sys
@@ -12,16 +14,15 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
-from mcfold.render import (
-    SECTION_VOLUME, _encode_paletted, _varint, parse_save_chunk,
-)
-from mcfold.render_bridge import RenderBridge, RenderBridgeError
+from mcfold.backends import Gen_1_20, backend_class
+from mcfold.backends.base import BackendError, rle_encode
+from mcfold.render import SECTION_VOLUME, WorldRenderer, parse_save_chunk
 
 SAVE = Path("/home/mc-test/mc-test")
 STORE = Path("/home/newqqagent/mcview/store/vanilla-1.20.1")
 
 
-def _bridge_available() -> tuple[bool, str]:
+def _available() -> tuple[bool, str]:
     cp = os.environ.get("MCFOLD_RENDER_CLASSPATH")
     if not cp:
         return False, "未设 MCFOLD_RENDER_CLASSPATH"
@@ -29,139 +30,181 @@ def _bridge_available() -> tuple[bool, str]:
     if not any("client-named" in p for p in paths):
         return False, "classpath 缺 client-named.jar"
     if not any("McfoldRenderServer" in p or "classes" in p for p in paths):
-        return False, "classpath 缺 McfoldRenderServer.class"
+        return False, "classpath 缺编译产物"
     if not os.environ.get("DISPLAY"):
         return False, "无 DISPLAY"
     return True, ""
 
 
-def test_bridge_protocol():
-    """桥的协议层：registry / lookup / resolve —— 不涉及渲染。"""
-    ok, why = _bridge_available()
+def _open_backend():
+    ok, why = _available()
     if not ok:
-        print(f"  - 跳过（{why}）")
-        return
-    br = RenderBridge(
+        return None, why
+    br = Gen_1_20(
         game_dir=str(STORE / "instances" / "default"),
         assets=str(STORE / "assets"), asset_index="1.20.1",
     )
     try:
         br.start()
-    except RenderBridgeError as e:
-        print(f"  - 跳过（启动失败：{str(e)[:80]}）")
+    except BackendError as e:
+        return None, f"启动失败：{str(e)[:100]}"
+    return br, ""
+
+
+# ---------------------------------------------------------------- 世代分派
+
+def test_generation_dispatch():
+    """判据是 DeltaTracker 是否存在（不是硬编码版本号）。"""
+    jars = {
+        "1.20.1": "/tmp/client-1.20.1.jar",
+        "1.21.1": "/tmp/genb/client-1.21.1-named.jar",
+    }
+    present = {v: p for v, p in jars.items() if Path(p).is_file()}
+    if not present:
+        print("  - 无 named jar，跳过")
+        return
+    for ver, jar in present.items():
+        cls = backend_class(jar)
+        if ver == "1.20.1":
+            assert cls is Gen_1_20, f"{ver} 应选 Gen_1_20，得到 {cls.__name__}"
+        else:
+            # 1.21+ 必须有 DeltaTracker ⇒ 选 gen_1_21
+            from mcfold.backends import Gen_1_21
+            assert cls is Gen_1_21, f"{ver} 应选 Gen_1_21，得到 {cls.__name__}"
+        print(f"  ✓ 世代分派 {ver} → {cls.__name__}")
+
+
+def test_generation_metadata():
+    """每个后端要能说清自己的 API 特征（加新世代时的对照依据）。"""
+    notes = Gen_1_20.api_notes()
+    assert "setLevel" in notes and "render" in notes
+    assert notes.get("deltaTracker") is False
+    from mcfold.backends import Gen_1_21
+    n21 = Gen_1_21.api_notes()
+    assert n21.get("deltaTracker") is True, "1.21+ 用 DeltaTracker"
+    assert "DeltaTracker" in n21["render"]
+    print(f"  ✓ 世代元信息（1.20: {notes['render']}）")
+
+
+# ---------------------------------------------------------------- 协议层
+
+def test_capacity_from_runtime():
+    """★ 世界尺寸必须问后端，不是 Python 硬编码。"""
+    br, why = _open_backend()
+    if br is None:
+        print(f"  - 跳过（{why}）")
+        return
+    try:
+        cap = br._request({"cmd": "capacity"})
+        assert cap["sectionsCount"] > 0, cap
+        assert "minSection" in cap and "maxSection" in cap
+        # 1.20.1 实测 24 / -4 / 20
+        assert cap["sectionsCount"] == 24, cap
+        assert cap["minSection"] == -4, cap
+        assert cap["maxSection"] == 20, cap
+        print(f"  ✓ 运行时世界尺寸（sections={cap['sectionsCount']}, "
+              f"min={cap['minSection']}, biome={cap.get('defaultBiome')}）")
+    finally:
+        br.stop()
+
+
+def test_resolve_and_lookup():
+    """方块名↔state id 是渲染器侧权威映射（Python 不复制这张表）。"""
+    br, why = _open_backend()
+    if br is None:
+        print(f"  - 跳过（{why}）")
         return
     try:
         reg = br.registry_info()
-        assert reg["ok"] and reg["blockCount"] > 500, reg
-        assert reg["stateCount"] > 1000, reg
-
-        # state id → 方块名（含属性）
-        st = br.lookup_state(1)
-        assert st["block"] == "minecraft:stone", st
-        assert st["inRange"] is True
-
-        # 方块名(+属性) → state id
-        r = br._request({"cmd": "resolve", "blocks": [
-            "minecraft:stone",
-            "minecraft:oak_log[axis=y]",
-            "minecraft:grass_block[snowy=false]",
-            "minecraft:this_block_does_not_exist",
-        ]})
-        ids = r["ids"]
-        assert ids[0] > 0, "stone 应有有效 id"
-        assert ids[1] > 0, "oak_log[axis=y] 应可解析"
-        assert ids[2] > 0, "grass_block 应可解析"
-        assert ids[3] == -1, "不存在的方块应返回 -1"
-        assert r["unknown"] == 1
-        print(f"  ✓ 桥协议（blocks={reg['blockCount']}, states={reg['stateCount']}, "
-              f"resolve 3 中 / 1 未知）")
+        assert reg["blockCount"] > 500 and reg["stateCount"] > 1000
+        assert br.lookup_state(1)["block"] == "minecraft:stone"
+        ids = br.resolve_blocks([
+            "minecraft:stone", "minecraft:oak_log[axis=y]",
+            "minecraft:grass_block[snowy=false]", "minecraft:no_such_block",
+        ])
+        assert ids[0] > 0 and ids[1] > 0 and ids[2] > 0
+        assert ids[3] == -1, "未知方块应返回 -1"
+        print(f"  ✓ 名字↔id（blocks={reg['blockCount']}, states={reg['stateCount']}）")
     finally:
         br.stop()
 
 
-def test_bridge_render_synthetic():
-    """合成数据渲染：验证「注入 → 网格重建 → 出图」全链路。"""
-    ok, why = _bridge_available()
-    if not ok:
+# ---------------------------------------------------------------- 渲染（新路径）
+
+def test_set_blocks_render():
+    """新路径：Python 只发 RLE，Java 组装协议 + 官方序列化 + 入 cache。"""
+    br, why = _open_backend()
+    if br is None:
         print(f"  - 跳过（{why}）")
         return
-    br = RenderBridge(
-        game_dir=str(STORE / "instances" / "default"),
-        assets=str(STORE / "assets"), asset_index="1.20.1",
-    )
     try:
-        br.start()
-    except RenderBridgeError as e:
-        print(f"  - 跳过（启动失败：{str(e)[:80]}）")
-        return
-    try:
-        # 先设视野中心（否则区块被丢弃）
-        br._request({"cmd": "viewport", "cx": 0, "cz": 0, "radius": 12})
+        cap = br._request({"cmd": "capacity"})
+        n_sec = cap["sectionsCount"]
+        stone, grass, log = br.resolve_blocks([
+            "minecraft:stone", "minecraft:grass_block[snowy=false]",
+            "minecraft:oak_log[axis=y]",
+        ])
+        assert stone > 0 and grass > 0 and log > 0
 
-        # 造：地板 stone（索引 4 = y=0 = 世界 y=64）+ 中间一根原木
-        stone = br._request({"cmd": "resolve", "blocks": ["minecraft:stone"]})["ids"][0]
-        log = br._request({"cmd": "resolve", "blocks": ["minecraft:oak_log[axis=y]"]})["ids"][0]
-        assert stone > 0 and log > 0
-
-        payload = bytearray()
-        for sy in range(24):
-            ids = [0] * SECTION_VOLUME
-            if sy == 4:
-                ids = [stone] * SECTION_VOLUME          # 地板（世界 y=64）
-            elif sy in (5, 6, 7):
-                for x in range(7, 9):                   # 中间 2x2 柱子
+        br.set_viewport(0, 0, radius=12)
+        sections = {}
+        for idx in range(n_sec):
+            v = [0] * SECTION_VOLUME
+            if idx < 4:
+                v = [stone] * SECTION_VOLUME          # 地基
+            elif idx == 4:
+                v = [grass] * SECTION_VOLUME          # 地表
+            elif idx == 5:
+                for x in range(7, 9):                 # 索引 = x + z*16 + y*256
                     for z in range(7, 9):
-                        ids[x + z * 16] = log
-            non_empty = sum(1 for v in ids if v != 0)
-            payload += (non_empty & 0xFFFF).to_bytes(2, "big")
-            payload += _encode_paletted(ids, SECTION_VOLUME)
-            payload += bytes([0]) + _varint(1) + _varint(0)
+                        v[x + z * 16] = log
+            sections[idx] = v
 
-        items = [(cx, cz, bytes(payload)) for cx in range(-3, 4) for cz in range(-3, 4)]
-        fed = br._request({"cmd": "chunks", "items": [
-            {"cx": cx, "cz": cz, "data": __import__("base64").b64encode(d).decode()}
-            for cx, cz, d in items
-        ]}, timeout=180)
-        assert fed["failed"] == 0, f"注入失败: {fed.get('firstError')}"
-        assert fed["loadedChunks"] > 0, f"仓库为空: {fed}"
+        total_placed = 0
+        for cx in range(-3, 4):
+            for cz in range(-3, 4):
+                r = br.set_blocks(cx, cz, sections)
+                assert r["ok"], r
+                total_placed += r["placed"]
+        assert total_placed > 0, "应写入方块"
 
-        br.set_camera(8.0, 72.0, 8.0, yaw=45.0, pitch=25.0)
+        wr = WorldRenderer(br)
+        wr._capacity = cap
+        dbg = br.debug()
+        assert dbg["loadedChunks"] > 0, f"仓库为空: {dbg}"
+
+        br.set_camera(8.0, 72.0, 8.0, yaw=45.0, pitch=30.0)
         res = br.render(frames=80)
-        assert res.width > 0 and res.height > 0
         assert res.chunks_rendered > 0, f"没有区块被渲染: {res.raw}"
         assert res.distinct_colors > 400, f"画面过单调: {res.distinct_colors}"
-        assert res.has_world_content is True
-        print(f"  ✓ 合成数据渲染（chunks={res.chunks_rendered}, "
-              f"colors={res.distinct_colors}, {len(res.image)}B PNG）")
+        assert res.has_world_content
+        print(f"  ✓ 新路径渲染（placed={total_placed}, chunks={res.chunks_rendered}, "
+              f"colors={res.distinct_colors}）")
     finally:
         br.stop()
 
 
-def test_bridge_render_real_save():
-    """真实存档渲染：最终验收判据。"""
-    ok, why = _bridge_available()
+def test_real_save_render():
+    """真实存档经新路径（RLE 路由）渲染 —— 最终验收。"""
+    ok, why = _available()
     if not ok:
         print(f"  - 跳过（{why}）")
         return
     if not (SAVE / "level.dat").is_file():
         print("  - 跳过（无测试存档）")
         return
-    from mcfold.render import WorldRenderer
     wr = WorldRenderer.open(store=str(STORE), java="java")
     try:
-        info = wr.load_save(SAVE, center=(8, -7), radius=4)
+        info = wr.load_save(SAVE, center=(8, -7), radius=3)
         assert info["injected"] > 0, info
         assert info["unknownBlocks"] == 0, f"有未解析方块: {info}"
-
         wr.camera(x=130.0, y=95.0, z=-110.0, yaw=135.0, pitch=35.0)
-        dbg = wr.debug()
-        assert dbg["loadedChunks"] > 0, f"仓库为空: {dbg}"
-        assert dbg["playerChunk"] == "8,-7", f"相机区块不对: {dbg}"
-
-        res = wr.screenshot(frames=100)
+        d = wr.debug()
+        assert d["loadedChunks"] > 0, d
+        res = wr.screenshot(frames=90)
         assert res.chunks_rendered > 0, res.raw
         assert res.distinct_colors > 2000, f"真实地形应色彩丰富: {res.distinct_colors}"
-        assert res.has_world_content is True
+        assert res.has_world_content
         print(f"  ✓ 真实存档渲染（injected={info['injected']}, "
               f"specs={info['uniqueSpecs']}, chunks={res.chunks_rendered}, "
               f"colors={res.distinct_colors}）")
@@ -180,5 +223,6 @@ if __name__ == "__main__":
             import traceback
             print(f"  ✗ {t.__name__}: {e}")
             traceback.print_exc()
-    print(f"\n渲染桥联测: " + ("全部通过" if failed == 0 else f"{len(tests)-failed}/{len(tests)} 通过"))
+    print(f"\n渲染联测: "
+          + ("全部通过" if failed == 0 else f"{len(tests)-failed}/{len(tests)} 通过"))
     sys.exit(1 if failed else 0)