From 2df7179266c24a6ce33bb902a692d4b5f9c61115 Mon Sep 17 00:00:00 2001
From: Joywayer <joywayer@163.com>
Date: Thu, 27 Aug 2026 17:16:11 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BA=8C=E4=B8=83=E7=8E=8B=EF=BC=9A=E5=89=8D?=
 =?UTF-8?q?=E7=AB=AF=E5=AD=90=E9=A1=B9=E7=9B=AE=20B=20=E5=AE=9E=E6=96=BD?=
 =?UTF-8?q?=E8=AE=A1=E5=88=92?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

13 个任务，每个自带 TDD 循环与提交：GameState 骨架与事件契约、roomtype 解析、
语义化发包、分发器与失败回包、五组 handler、重连与开局、服务端真包夹具、
增量 vs 全量一致性、平台接线。

自检修掉两处：Task 8 一条拿自己跟自己比的恒真断言；Task 12 引用的
fx.roomtype / snapPoint.packetIndex 在 Task 11 的夹具结构里没定义
——packetIndex 是两条路径的对齐锚点，缺了一致性测试无从比对。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../2026-08-27-二七王前端B-网络与数据镜像.md  | 2636 +++++++++++++++++
 1 file changed, 2636 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-08-27-二七王前端B-网络与数据镜像.md

diff --git a/docs/superpowers/plans/2026-08-27-二七王前端B-网络与数据镜像.md b/docs/superpowers/plans/2026-08-27-二七王前端B-网络与数据镜像.md
new file mode 100644
index 0000000..30b6e2f
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-27-二七王前端B-网络与数据镜像.md
@@ -0,0 +1,2636 @@
+# 二七王前端 · 子项目 B：网络与数据镜像 · 实施计划
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** 把二七王前端接上服务端——语义化发包、唯一收包分发、把服务端快照镜像成 `GameState`、重连即重画，全部用单测覆盖。
+
+**Architecture:** 点击 → `Rpc.sendXxx(意图)` → `RpcHelper.sendRpc('youle','erqiwang',…)`；推送 → `SubGameHooks._ReceiveData` → `Dispatcher`（纯路由表）→ 一 rpc 一 handler → 写 `GameState` → emit 语义事件。handler **不引用任何 UI 组件**，故 B 可脱离 C 独立完成与测试。
+
+**Tech Stack:** 纯静态 ES5 JavaScript（浏览器 `<script>` 加载）；无构建、无包管理器；测试用 Node 原生 + A 阶段建好的 `client/tests/` 框架（`_load.js` 用 `vm.runInThisContext` 加载全局脚本、`_assert.js` 极简断言、`run.js` spawn 逐个跑）。
+
+**Spec:** `docs/superpowers/specs/2026-08-27-二七王前端B-网络与数据镜像-design.md`
+
+## Global Constraints
+
+- **严格 ES5**：正式代码只用 `var` / `function`，禁 `let`/`const`/箭头/模板串/`class`；`for...in` 配 `hasOwnProperty` 守卫。**git 提交闸已启用**（`.githooks/pre-commit` → `check-redlines.js`），命中即阻断提交，**不许 `--no-verify`**。测试代码可用现代语法。
+- **可编辑范围**：只动 `client/js/01_SubGame/codes/`、`client/tests/`、`client/index.html`。**禁改** `js/vendor/`、`js/00_Surface/`、`server/`、`gameabc-framework/`、三个平台契约转发壳（`01_SubGame/00_/01_/02_SubGame_*.js`）。
+- **发包必须用 `RpcHelper.sendRpc('youle', 'erqiwang', rpc, data)`**，**不能**用 `sendGameRpc`（它预设 `route="room"`，包会被路由到平台房间模块、永远到不了子游戏 `mod.js`，且不报错）。
+- **请求包只带意图**：操作类型 + 目标标识 + 座位号。**禁止**出现 `score`/`isWin`/`phase`/`nextSeat`/`handCards` 之类由前端算出的结论字段。
+- **成败只认 `data.success`**：不用 `status`/`code`，不写 `status` 兼容兜底。
+- **`GameState` 只镜像不派生**：只存服务端下发过的字段，字段名对齐协议；**缺字段不兜底**（不填 `|| 0` / `|| []`），必需字段缺失则 `console.error` 并跳过该包。
+- **`countdown` 不做任何界面推进**：服务端没有对应定时器，归零不会自动推进任何东西。B 只负责把秒数存下来。
+- **handler 不引用 UI 组件**：这是 B 能独立测试的前提。
+- **提交**：中文提交信息、聚焦一件事、结尾保留 `Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>`；不用 `git add -A`。
+
+---
+
+## 文件结构
+
+| 文件 | 职责 |
+|---|---|
+| `codes/state/Events.js` | 事件常量，追加到 `EventBus.Events` |
+| `codes/state/GameState.js` | 服务端快照的镜像（前端 SSOT）+ `reset`/`snapshot`/各 `applyXxx` |
+| `codes/state/RoomOptions.js` | `roomtype` 位串解析（与服务端 `class.config.js` 的 `parse()` 同规则） |
+| `codes/net/Rpc.js` | 语义化发包，一操作一方法 |
+| `codes/net/Dispatcher.js` | 唯一收包入口 + 纯路由表 |
+| `codes/net/handlers/DealHandler.js` | `fapai` |
+| `codes/net/handlers/CallHandler.js` | `jiaofen` / `shangzhuang` |
+| `codes/net/handlers/MainHandler.js` | `xuanzhu` |
+| `codes/net/handlers/BuryHandler.js` | `maipai` |
+| `codes/net/handlers/PlayHandler.js` | `chupai1` / `chupai2` / `chupai3` |
+| `codes/net/handlers/QueryHandler.js` | `mingpai` / `tishi` |
+| `codes/net/handlers/ReadyHandler.js` | `zhunbei` |
+| `codes/net/handlers/ResultHandler.js` | `jiesuan` + `Free`（解散） |
+| `codes/net/handlers/ResyncHandler.js` | `deskinfo`（重连）+ `StartWar`（开局）+ `setRoomDes` |
+| `codes/net/handlers/FailHandler.js` | 失败回包 |
+| `codes/SubGameHooks.js` | 改：接上 `_ReceiveData`/`StartWar`/`Reconnect`/`Free`/`setRoomDes` |
+| `client/index.html` | 改：加入 `state/`、`net/` 的加载段 |
+| `client/tests/test_*.js` | 8 个新测试文件 |
+| `client/tests/fixtures/` | 服务端真包夹具（导出脚本 + JSON） |
+
+---
+
+## Task 1: 事件常量与 GameState 骨架
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/state/Events.js`
+- Create: `client/js/01_SubGame/codes/state/GameState.js`
+- Test: `client/tests/test_gamestate.js`
+
+**Interfaces:**
+- Produces: 全局 `EQW_Events`（事件名常量，同时追加进 `EventBus.Events`）；全局 `EQW_GameState`，含数据分组 `room`/`aset`/`turn`/`call`/`my`/`table`/`result`、`reset()`、`snapshot()`
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_gamestate.js`**
+
+```js
+// GameState 骨架：初始值、reset 的清空范围、snapshot 深拷贝
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+
+// ---- 事件常量已追加进 EventBus.Events ----
+t.eq('事件常量非空', Object.keys(EQW_Events).length > 0, true);
+t.eq('RESET 已入 EventBus.Events', EventBus.Events.EQW_RESET, EQW_Events.EQW_RESET);
+t.eq('事件名互不重复',
+     Object.keys(EQW_Events).length,
+     Object.keys(EQW_Events).map(k => EQW_Events[k]).filter((v, i, a) => a.indexOf(v) === i).length);
+
+// ---- 初始值 ----
+t.eq('初始 mySeat', EQW_GameState.room.mySeat, -1);
+t.eq('初始 banker', EQW_GameState.aset.banker, -1);
+t.eq('初始 flower', EQW_GameState.aset.flower, 0);
+t.eq('初始手牌', EQW_GameState.my.cards, []);
+t.eq('初始三家叫分', EQW_GameState.call.calls, [null, null, null]);
+
+// ---- snapshot 是深拷贝、且不含方法 ----
+EQW_GameState.my.cards = [1, 2, 3];
+const snap = EQW_GameState.snapshot();
+t.eq('snapshot 取到值', snap.my.cards, [1, 2, 3]);
+EQW_GameState.my.cards.push(4);
+t.eq('snapshot 是深拷贝（不随后续修改）', snap.my.cards, [1, 2, 3]);
+t.eq('snapshot 不含方法', typeof snap.reset, 'undefined');
+t.eq('snapshot 含全部分组',
+     Object.keys(snap).sort(),
+     ['aset', 'call', 'my', 'result', 'room', 'table', 'turn']);
+
+// ---- reset：清对局态，但 mySeat / options 不清（跨局不变）----
+EQW_GameState.room.mySeat = 2;
+EQW_GameState.room.options = { climb: 1 };
+EQW_GameState.aset.banker = 1;
+EQW_GameState.aset.flower = 3;
+EQW_GameState.table.pushlist = [[1], [2]];
+EQW_GameState.result.aset = { grade: 5 };
+EQW_GameState.reset();
+
+t.eq('reset 后 mySeat 保留', EQW_GameState.room.mySeat, 2);
+t.eq('reset 后 options 保留', EQW_GameState.room.options, { climb: 1 });
+t.eq('reset 后 banker 清空', EQW_GameState.aset.banker, -1);
+t.eq('reset 后 flower 清空', EQW_GameState.aset.flower, 0);
+t.eq('reset 后 pushlist 清空', EQW_GameState.table.pushlist, []);
+t.eq('reset 后 result 清空', EQW_GameState.result.aset, null);
+t.eq('reset 后手牌清空', EQW_GameState.my.cards, []);
+
+// ---- reset 两次结果一致（幂等）----
+const afterFirst = EQW_GameState.snapshot();
+EQW_GameState.reset();
+t.eq('reset 幂等', EQW_GameState.snapshot(), afterFirst);
+
+process.exit(t.done('gamestate') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_gamestate.js`
+Expected: `EQW_Events is not defined`（或文件不存在的 ENOENT）。
+
+- [ ] **Step 3: 写 `client/js/01_SubGame/codes/state/Events.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_Events: 玩法事件常量 ///////////////////////////
+///////////////////////////////////////////////////////////////
+// 前端红线：框架保持游戏中立，玩法专属事件由子游戏追加到 EventBus.Events。
+//
+// 【事件只带「发生了什么」，不带数据】——订阅者从 EQW_GameState 读。
+// 这样同一份数据不会在事件载荷与状态里各存一份（SSOT）。
+// 唯一例外是 EQW_RPC_FAILED，它带 {rpc, errcode}：那是一次性的错误信息，
+// 不属于对局状态、不该进 GameState。
+var EQW_Events = EQW_Events || {
+
+    EQW_RESET:          'eqw.reset',           //新一局发牌，全部清场
+    EQW_HAND_CHANGED:   'eqw.hand_changed',    //自己手牌变化
+    EQW_CALL_CHANGED:   'eqw.call_changed',    //叫分推进
+    EQW_BANKER_SET:     'eqw.banker_set',      //上庄
+    EQW_MAIN_SET:       'eqw.main_set',        //选主
+    EQW_BURY_DONE:      'eqw.bury_done',       //埋牌完成
+    EQW_CARD_PLAYED:    'eqw.card_played',     //有人出牌
+    EQW_TRICK_END:      'eqw.trick_end',       //一轮结束（chupai3 带 maxseat）
+    EQW_TURN_CHANGED:   'eqw.turn_changed',    //控制权或倒计时变化
+    EQW_MINGPAI:        'eqw.mingpai',         //收到明牌数据
+    EQW_TIP:            'eqw.tip',             //收到对家提示
+    EQW_ASET_RESULT:    'eqw.aset_result',     //小局结算
+    EQW_ACCOUNT_RESULT: 'eqw.account_result',  //大局/解散结算
+    EQW_READY_CHANGED:  'eqw.ready_changed',   //有人准备
+    EQW_RESYNC_ALL:     'eqw.resync_all',      //重连/开局全量重画
+    EQW_RPC_FAILED:     'eqw.rpc_failed'       //失败回包 {rpc, errcode}
+};
+
+//追加到框架事件总线的事件表（框架不认识玩法事件，由子游戏注册）
+if (typeof EventBus !== 'undefined' && EventBus.Events) {
+    for (var _eqwEvtKey in EQW_Events) {
+        if (EQW_Events.hasOwnProperty(_eqwEvtKey)) {
+            EventBus.Events[_eqwEvtKey] = EQW_Events[_eqwEvtKey];
+        }
+    }
+}
+```
+
+- [ ] **Step 4: 写 `client/js/01_SubGame/codes/state/GameState.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_GameState: 服务端快照的镜像（前端 SSOT）////////
+///////////////////////////////////////////////////////////////
+// 前端红线「视图 = f(服务端快照)」的落点：本对象只存【服务端下发过的字段】，
+// 不存任何前端算出来的结论。手牌排序、牌面标记、花色统计等由 core/ 的纯函数
+// 在渲染时现算，不落地成状态。
+//
+// 三条硬约束：
+//   1. 只镜像不派生——存进来的必须是服务端给过的
+//   2. 字段名对齐协议——协议叫 currcall 就叫 currcall，便于逐条核对
+//   3. 缺字段不兜底——包里没有的保持原值，不填默认值掩盖；必需字段缺失
+//      则 console.error 并跳过该包（服务端漏发，修在服务端）
+var EQW_GameState = EQW_GameState || {
+
+    //数据分组名（snapshot / reset 按此遍历；新增分组要同步加进来）
+    _GROUPS: ['room', 'aset', 'turn', 'call', 'my', 'table', 'result'],
+
+    //—— 房间级（跨小局）——
+    room: {
+        asetCount: 0,      //总局数        ← fapai.asetcount / deskinfo.count / setRoomDes
+        asetIdx: 0,        //当前第几局    ← fapai.asetidx / deskinfo.idx
+        mySeat: -1,        //自己的座位    ← 平台 C_Player.seat
+        playerScores: [],  //三家总积分    ← deskinfo.PlayerInfo
+        options: null      //roomtype 解析结果
+    },
+
+    //—— 小局级 ——
+    aset: {
+        step: 0,           //1叫分 2选主/投降 3埋牌 5出牌 6结算
+        banker: -1,
+        call: -1,          //庄家叫分
+        multiple: 0,       //基础子数
+        flower: 0,         //主牌花色（0 = 未选主）
+        curmultiple: 0,    //当前抓分倍数（带符号，服务端权威，前端不自算）
+        grade: 0,          //闲家已捡分
+        baozhu: 0,         //是否已有人报无主
+        touxiang: 0        //是否允许投降
+    },
+
+    //—— 当前控制权与倒计时（任何阶段都读这里）——
+    turn: {
+        seat: -1,          //该谁操作
+        countdown: 0       //展示用秒数；服务端无对应定时器，归零【不做任何界面推进】
+    },
+
+    //—— 叫分过程 ——
+    call: {
+        currcall: 0,
+        calls: [null, null, null]   //null 未叫 / 0 不叫 / >0 叫了多少
+    },
+
+    //—— 自己 ——
+    my: {
+        cards: [],
+        mustCard: [],      //本轮必出牌（服务端建议，只发给轮到的那家）
+        bottomCards: [],   //底牌（庄家恒有；闲家仅 70 分坐庄时有）
+        buryCards: []      //埋牌底牌（仅庄家）
+    },
+
+    //—— 桌面 ——
+    table: {
+        ancard3s: 0,       //开底标志（70 分坐庄）
+        playproc: null,
+        pushlist: [],
+        seatlist: [],
+        liangpai: null,
+        mingpai: null
+    },
+
+    //—— 结算 ——
+    result: {
+        chupai: null,
+        bottom: null,
+        aset: null,
+        account: null
+    },
+
+    //新一局开局时清空对局态；room.mySeat 与 room.options 跨局不变，不清
+    reset: function () {
+        this.room.asetIdx = 0;
+        this.room.playerScores = [];
+
+        this.aset = { step: 0, banker: -1, call: -1, multiple: 0, flower: 0,
+                      curmultiple: 0, grade: 0, baozhu: 0, touxiang: 0 };
+        this.turn = { seat: -1, countdown: 0 };
+        this.call = { currcall: 0, calls: [null, null, null] };
+        this.my   = { cards: [], mustCard: [], bottomCards: [], buryCards: [] };
+        this.table = { ancard3s: 0, playproc: null, pushlist: [], seatlist: [],
+                       liangpai: null, mingpai: null };
+        this.result = { chupai: null, bottom: null, aset: null, account: null };
+    },
+
+    //深拷贝快照（只含数据分组，不含方法），供测试做「增量 vs 全量」比对
+    snapshot: function () {
+        var out = {};
+        for (var i = 0; i < this._GROUPS.length; i++) {
+            var g = this._GROUPS[i];
+            out[g] = JSON.parse(JSON.stringify(this[g]));
+        }
+        return out;
+    }
+};
+```
+
+- [ ] **Step 5: 运行，确认通过**
+
+Run: `node client/tests/test_gamestate.js`
+Expected: 全 PASS。
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/state/Events.js client/js/01_SubGame/codes/state/GameState.js client/tests/test_gamestate.js
+git commit -F - <<'EOF'
+二七王：前端事件常量与 GameState 骨架
+
+GameState 是服务端快照的镜像、前端 SSOT：只镜像不派生、字段名对齐协议、
+缺字段不兜底。reset 清对局态但保留 mySeat 与 options（跨局不变）。
+事件只带「发生了什么」，数据由订阅者从 GameState 读，避免同一份数据两处存。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 2: roomtype 位串解析
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/state/RoomOptions.js`
+- Test: `client/tests/test_roomoptions.js`
+
+**Interfaces:**
+- Produces: 全局 `EQW_RoomOptions_Parse`，含 `parse(roomtype)` → `{ asetCount, deductAA, bangwang, climb, nocheck }`
+
+> 协议 §0.5：`roomtype` 是定长数字位串（字符串），每一位 `'0'/'1'`。服务端解析入口是 `class.config.js` 的 `parse()`（SSOT），前端这份必须**同规则**。
+> 位定义：位0 局数（`'0'`=6局 / `'1'`=12局）、位1 扣卡（`'0'`=房主 / `'1'`=AA）、位2 傍王、位3 爬坡、位4 查牌模式（`'0'`=可查牌 / `'1'`=不查牌）。
+> **对缺失、非字符串、过短的 `roomtype` 一律按 `'0'` 处理**（与服务端一致）。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_roomoptions.js`**
+
+```js
+// roomtype 位串解析（协议 §0.5），必须与服务端 class.config.js 的 parse() 同规则
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/01_SubGame/codes/state/RoomOptions.js');
+
+const P = EQW_RoomOptions_Parse.parse;
+
+// ---- 缺省 "00000" = 6局 / 房主扣卡 / 无傍王 / 常规算子 / 可查牌 ----
+t.eq('缺省', P('00000'), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+
+// ---- 协议 §0.5 的示例：10100 = 12局 / 房主扣卡 / 傍王开 / 常规算子 / 可查牌 ----
+t.eq('示例 10100', P('10100'), { asetCount: 12, deductAA: 0, bangwang: 1, climb: 0, nocheck: 0 });
+
+// ---- 逐位 ----
+t.eq('位0 局数', P('10000').asetCount, 12);
+t.eq('位1 AA扣卡', P('01000').deductAA, 1);
+t.eq('位2 傍王', P('00100').bangwang, 1);
+t.eq('位3 爬坡', P('00010').climb, 1);
+t.eq('位4 不查牌', P('00001').nocheck, 1);
+t.eq('全开', P('11111'), { asetCount: 12, deductAA: 1, bangwang: 1, climb: 1, nocheck: 1 });
+
+// ---- 反面：缺失/非字符串/过短一律按 '0' ----
+t.eq('undefined', P(undefined), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+t.eq('null', P(null), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+t.eq('空串', P(''), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+t.eq('过短只有两位', P('11'), { asetCount: 12, deductAA: 1, bangwang: 0, climb: 0, nocheck: 0 });
+t.eq('非字符串（数字）', P(11111), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+t.eq('非字符串（数组）', P([]), { asetCount: 6, deductAA: 0, bangwang: 0, climb: 0, nocheck: 0 });
+
+// ---- 超长不报错，只取前 5 位 ----
+t.eq('超长', P('1111199999').bangwang, 1);
+
+process.exit(t.done('roomoptions') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_roomoptions.js`
+Expected: `EQW_RoomOptions_Parse is not defined`。
+
+- [ ] **Step 3: 写实现 `client/js/01_SubGame/codes/state/RoomOptions.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_RoomOptions_Parse: roomtype 位串解析 ///////////
+///////////////////////////////////////////////////////////////
+// 协议 §0.5：roomtype 是建房时拼好的定长数字位串（字符串），每一位 '0'/'1'。
+// 服务端解析入口是 class.config.js 的 parse()，本文件必须与之【同规则】。
+//
+//   位0 局数    '0'=6局(缺省)  '1'=12局
+//   位1 扣卡    '0'=房主扣卡   '1'=AA 每人扣卡
+//   位2 傍王    '0'=关         '1'=开
+//   位3 爬坡    '0'=常规算子   '1'=爬坡
+//   位4 查牌    '0'=可查牌     '1'=不查牌
+//
+// 对【缺失、非字符串、过短】的 roomtype 一律按 '0' 处理（与服务端一致），
+// 这是协议明文规定的行为，不是隐式兜底。
+var EQW_RoomOptions_Parse = EQW_RoomOptions_Parse || {
+
+    //取第 idx 位，越界或非字符串时按 '0'
+    _bit: function (roomtype, idx) {
+        if (typeof roomtype !== 'string') { return 0; }
+        if (idx >= roomtype.length) { return 0; }
+        return roomtype.charAt(idx) === '1' ? 1 : 0;
+    },
+
+    parse: function (roomtype) {
+        return {
+            asetCount: this._bit(roomtype, 0) ? 12 : 6,
+            deductAA:  this._bit(roomtype, 1),
+            bangwang:  this._bit(roomtype, 2),
+            climb:     this._bit(roomtype, 3),
+            nocheck:   this._bit(roomtype, 4)
+        };
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_roomoptions.js`
+Expected: 全 PASS。
+
+- [ ] **Step 5: 对照服务端确认同规则**
+
+打开 `server/games/erqiwang/class.config.js`，找到 `parse()` 与位下标常量（`IDX_ASET` / `IDX_DEDUCT` / `IDX_BANGWANG` / `IDX_CLIMB` / `IDX_NOCHECK`），**逐位核对**你的实现与它一致。若发现不一致，**以服务端为准**改前端并在报告里说明。
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/state/RoomOptions.js client/tests/test_roomoptions.js
+git commit -F - <<'EOF'
+二七王：前端 roomtype 位串解析
+
+与服务端 class.config.js 的 parse() 同规则；缺失/非字符串/过短一律按 '0'，
+这是协议 §0.5 明文规定的行为。已逐位对照服务端确认。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 3: 语义化发包
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/Rpc.js`
+- Test: `client/tests/test_rpc_send.js`
+
+**Interfaces:**
+- Consumes: `RpcHelper.sendRpc(app, route, rpc, gameData, options)`（框架）；`EQW_GameState.room.mySeat`
+- Produces: 全局 `EQW_Rpc`，含 `jiaofen(call)` / `touxiang()` / `xuanzhu(flower)` / `maipai(cards)` / `chupai(cards)` / `mingpai()` / `tishi(tip)` / `zhunbei()`
+
+> **route 必须是 `erqiwang`**：`RpcHelper.sendGameRpc` 预设 `route="room"`（平台房间模块），用它包会被路由错、到不了子游戏 `mod.js`，且不报错。必须显式 `sendRpc('youle', 'erqiwang', …)`。
+> `RpcHelper` 已自动注入 `agentid`/`gameid`/`playerid`/`roomcode`，这里只补 `seat` 与业务字段。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_rpc_send.js`**
+
+```js
+// 语义化发包：route 正确、只带意图、参数形状校验
+const { load, throws } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/01_SubGame/codes/state/GameState.js');
+
+// 桩掉 RpcHelper，捕获发出的包
+const sent = [];
+global.RpcHelper = {
+    sendRpc: function (app, route, rpc, data) { sent.push({ app, route, rpc, data }); }
+};
+
+load('client/js/01_SubGame/codes/net/Rpc.js');
+
+EQW_GameState.room.mySeat = 2;
+
+// ---- route 必须是 erqiwang，不是 room ----
+sent.length = 0;
+EQW_Rpc.jiaofen(60);
+t.eq('发了一个包', sent.length, 1);
+t.eq('app', sent[0].app, 'youle');
+t.eq('route 是 erqiwang', sent[0].route, 'erqiwang');
+t.eq('rpc', sent[0].rpc, 'jiaofen');
+t.eq('业务字段', sent[0].data, { seat: 2, call: 60 });
+
+// ---- seat 自动从 GameState 带上 ----
+EQW_GameState.room.mySeat = 0;
+sent.length = 0;
+EQW_Rpc.zhunbei();
+t.eq('seat 自动带上', sent[0].data.seat, 0);
+EQW_GameState.room.mySeat = 2;
+
+// ---- 各方法的字段集合 ----
+const call = (fn) => { sent.length = 0; fn(); return sent[0]; };
+
+t.eq('不叫', call(() => EQW_Rpc.jiaofen(0)).data, { seat: 2, call: 0 });
+t.eq('投降', call(() => EQW_Rpc.touxiang()).data, { seat: 2 });
+t.eq('选主', call(() => EQW_Rpc.xuanzhu(3)).data, { seat: 2, flower: 3 });
+t.eq('埋牌', call(() => EQW_Rpc.maipai([1,2,3,4,5,6,7,8])).data, { seat: 2, cards: [1,2,3,4,5,6,7,8] });
+t.eq('出牌', call(() => EQW_Rpc.chupai([10,11])).data, { seat: 2, cards: [10,11] });
+t.eq('明牌', call(() => EQW_Rpc.mingpai()).data, { seat: 2 });
+t.eq('提示', call(() => EQW_Rpc.tishi(1)).data, { seat: 2, tip: 1 });
+t.eq('准备', call(() => EQW_Rpc.zhunbei()).data, { seat: 2 });
+
+// ---- 【核心】只带意图：所有发包的字段集合不含任何结论字段 ----
+const FORBIDDEN = ['score', 'isWin', 'phase', 'nextSeat', 'nextseat', 'handCards',
+                   'grade', 'multiple', 'result', 'banker', 'curmultiple', 'upgrade'];
+sent.length = 0;
+EQW_Rpc.jiaofen(60); EQW_Rpc.touxiang(); EQW_Rpc.xuanzhu(1);
+EQW_Rpc.maipai([1,2,3,4,5,6,7,8]); EQW_Rpc.chupai([9]);
+EQW_Rpc.mingpai(); EQW_Rpc.tishi(2); EQW_Rpc.zhunbei();
+
+const leaked = [];
+sent.forEach(p => Object.keys(p.data).forEach(k => {
+    if (FORBIDDEN.indexOf(k) >= 0) { leaked.push(p.rpc + '.' + k); }
+}));
+t.eq('发包不含任何结论字段', leaked, []);
+
+// ---- 参数形状校验：非法即抛错，不发残缺包 ----
+sent.length = 0;
+t.eq('牌 id 非数组抛错', throws(() => EQW_Rpc.chupai('5')), true);
+t.eq('空数组抛错', throws(() => EQW_Rpc.chupai([])), true);
+t.eq('字符串牌 id 抛错', throws(() => EQW_Rpc.chupai(['5'])), true);
+t.eq('小数牌 id 抛错', throws(() => EQW_Rpc.chupai([1.5])), true);
+t.eq('越界牌 id 抛错', throws(() => EQW_Rpc.chupai([108])), true);
+t.eq('负数牌 id 抛错', throws(() => EQW_Rpc.chupai([-1])), true);
+t.eq('重复牌 id 抛错', throws(() => EQW_Rpc.chupai([5, 5])), true);
+t.eq('埋牌非 8 张抛错', throws(() => EQW_Rpc.maipai([1,2,3])), true);
+t.eq('叫分越界抛错', throws(() => EQW_Rpc.jiaofen(71)), true);
+t.eq('叫分非 5 的倍数抛错', throws(() => EQW_Rpc.jiaofen(7)), true);
+t.eq('花色越界抛错', throws(() => EQW_Rpc.xuanzhu(5)), true);
+t.eq('提示类型越界抛错', throws(() => EQW_Rpc.tishi(4)), true);
+t.eq('校验失败时一个包都没发', sent.length, 0);
+
+// ---- 合法边界值不抛 ----
+t.eq('牌 id 0 合法', throws(() => EQW_Rpc.chupai([0])), false);
+t.eq('牌 id 107 合法', throws(() => EQW_Rpc.chupai([107])), false);
+t.eq('叫分 5 合法', throws(() => EQW_Rpc.jiaofen(5)), false);
+t.eq('叫分 70 合法', throws(() => EQW_Rpc.jiaofen(70)), false);
+
+process.exit(t.done('rpc_send') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_rpc_send.js`
+Expected: `EQW_Rpc is not defined`。
+
+- [ ] **Step 3: 写实现 `client/js/01_SubGame/codes/net/Rpc.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_Rpc: 语义化发包（一操作一方法）/////////////////
+///////////////////////////////////////////////////////////////
+// 前端 04 §1：业务不直接拼包，走两层封装——
+//   业务 → EQW_Rpc.xxx(意图) → RpcHelper（注入平台字段）→ 引擎发送
+//
+// 【route 必须是 erqiwang】RpcHelper.sendGameRpc 预设 route="room"（平台房间模块），
+// 用它包会被路由到平台、永远到不了子游戏 mod.js，而且不会有任何报错。
+//
+// 【请求包只带意图，不带结论】（前端 04 §1 / 服务端 04 §8）
+// 可以带：操作类型、目标标识（牌 id / 花色 / 提示类型）、座位号（仅供一致性校验）。
+// 禁止带：分数、番数、判定结果、阶段推进指令、nextSeat、handCards。
+// 前端 shared/ 的计算只用于本地提示与预校验，【结果不回传】。
+// 一句话：前端能自己推出来的东西，就是玩家能改的东西——这是防作弊的根本。
+//
+// 本文件只做【形状】校验（牌 id 范围/去重/张数），不做【规则】校验
+// （这手牌能不能出、叫分够不够低由服务端裁定）。形状不合法就 fail-fast 抛错，
+// 不发出残缺包——服务端会按 PARAM 拒绝，但让错误暴露在最近处更省事。
+var EQW_Rpc = EQW_Rpc || {
+
+    APP:   'youle',
+    ROUTE: 'erqiwang',
+
+    //—— 内部：取自己的座位 ——
+    _seat: function () {
+        return EQW_GameState.room.mySeat;
+    },
+
+    //—— 内部：发送 ——
+    _send: function (rpc, data) {
+        data.seat = this._seat();
+        RpcHelper.sendRpc(this.APP, this.ROUTE, rpc, data);
+    },
+
+    //—— 内部：牌 id 列表形状校验（协议 §0.2）——
+    //必须是非空数组，元素是 0–107 的整数，互不重复
+    _checkCards: function (cards, expectCount) {
+        if (Object.prototype.toString.call(cards) !== '[object Array]' || cards.length === 0) {
+            throw new Error('[EQW_Rpc] cards 必须是非空数组');
+        }
+        if (typeof expectCount === 'number' && cards.length !== expectCount) {
+            throw new Error('[EQW_Rpc] cards 张数应为 ' + expectCount + '，实际 ' + cards.length);
+        }
+        var seen = {};
+        for (var i = 0; i < cards.length; i++) {
+            var c = cards[i];
+            if (typeof c !== 'number' || c !== Math.floor(c) || c < 0 || c > 107) {
+                throw new Error('[EQW_Rpc] 非法牌 id: ' + c + '（须为 0–107 的整数）');
+            }
+            if (seen[c]) { throw new Error('[EQW_Rpc] 牌 id 重复: ' + c); }
+            seen[c] = true;
+        }
+    },
+
+    //—— 叫分（call: 5–70 的 5 的倍数；0 = 不叫）——
+    jiaofen: function (call) {
+        if (typeof call !== 'number' || call !== Math.floor(call)) {
+            throw new Error('[EQW_Rpc] call 必须是整数');
+        }
+        if (call !== 0 && (call < 5 || call > 70 || call % 5 !== 0)) {
+            throw new Error('[EQW_Rpc] 非法叫分: ' + call + '（须为 0 或 5–70 的 5 的倍数）');
+        }
+        this._send('jiaofen', { call: call });
+    },
+
+    //—— 投降（仅 70 分坐庄、选主阶段；合法性由服务端裁定）——
+    touxiang: function () {
+        this._send('touxiang', {});
+    },
+
+    //—— 选主（flower: 1方块 2梅花 3红心 4黑桃）——
+    xuanzhu: function (flower) {
+        if (typeof flower !== 'number' || flower < 1 || flower > 4) {
+            throw new Error('[EQW_Rpc] 非法花色: ' + flower + '（须为 1–4）');
+        }
+        this._send('xuanzhu', { flower: flower });
+    },
+
+    //—— 埋牌（恒 8 张）——
+    maipai: function (cards) {
+        this._checkCards(cards, 8);
+        this._send('maipai', { cards: cards });
+    },
+
+    //—— 出牌 ——
+    chupai: function (cards) {
+        this._checkCards(cards);
+        this._send('chupai', { cards: cards });
+    },
+
+    //—— 明牌（查看他家未出主牌）——
+    mingpai: function () {
+        this._send('mingpai', {});
+    },
+
+    //—— 出牌提示（tip: 1踩 2没分 3有分）——
+    tishi: function (tip) {
+        if (tip !== 1 && tip !== 2 && tip !== 3) {
+            throw new Error('[EQW_Rpc] 非法提示类型: ' + tip + '（须为 1踩 2没分 3有分）');
+        }
+        this._send('tishi', { tip: tip });
+    },
+
+    //—— 准备 ——
+    zhunbei: function () {
+        this._send('zhunbei', {});
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_rpc_send.js`
+Expected: 全 PASS。
+
+- [ ] **Step 5: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/Rpc.js client/tests/test_rpc_send.js
+git commit -F - <<'EOF'
+二七王：前端语义化发包
+
+route 显式写 erqiwang——RpcHelper.sendGameRpc 预设 route="room"，
+用它包会被路由到平台房间模块、到不了子游戏 mod.js 且不报错。
+
+只做形状校验（牌 id 范围/去重/张数），规则合法性由服务端裁定；
+不合形状即抛错、不发残缺包。测试断言发包字段集合不含任何结论字段。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 4: 分发器与失败回包
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/Dispatcher.js`
+- Create: `client/js/01_SubGame/codes/net/handlers/FailHandler.js`
+- Test: `client/tests/test_dispatcher.js`
+
+**Interfaces:**
+- Consumes: `EQW_Events`、`EventBus.emit`
+- Produces: 全局 `EQW_Dispatcher`，含 `dispatch(msg)`（`msg = {rpc, data}`）、`register(rpc, handler)`；全局 `EQW_FailHandler`，含 `handle(rpc, data)`
+
+> **判定顺序是关键**：`dispatch` 先看 `data.success`——为 `false` 一律交 `FailHandler`，不进业务 handler。这样每个业务 handler 都能假定自己拿到的是成功包。
+> 原因见协议 §0.2：失败回包的 **rpc 与请求同名**（`chupai` 失败回 `chupai`，成功走 `chupai1/2/3`），若不先分流，业务 handler 就得每个都自己判一遍。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_dispatcher.js`**
+
+```js
+// 分发器：success 优先分流、未知 rpc 不崩、路由表完整性
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/net/handlers/FailHandler.js');
+load('client/js/01_SubGame/codes/net/Dispatcher.js');
+
+// ---- 注册与分发 ----
+const got = [];
+EQW_Dispatcher.register('testRpc', function (d) { got.push(d); });
+EQW_Dispatcher.dispatch({ rpc: 'testRpc', data: { success: true, v: 1 } });
+t.eq('成功包进业务 handler', got, [{ success: true, v: 1 }]);
+
+// ---- success:false 优先走 FailHandler，不进业务 handler ----
+const failed = [];
+EventBus.on(EQW_Events.EQW_RPC_FAILED, function (e) { failed.push(e); });
+got.length = 0;
+EQW_Dispatcher.dispatch({ rpc: 'testRpc', data: { success: false, errcode: 5 } });
+t.eq('失败包不进业务 handler', got, []);
+t.eq('失败包 emit RPC_FAILED', failed, [{ rpc: 'testRpc', errcode: 5 }]);
+
+// ---- 失败包即使 rpc 没注册过也要被处理（如 chupai 只会以失败包出现）----
+failed.length = 0;
+EQW_Dispatcher.dispatch({ rpc: 'chupai', data: { success: false, errcode: 6 } });
+t.eq('未注册 rpc 的失败包也处理', failed, [{ rpc: 'chupai', errcode: 6 }]);
+
+// ---- 未知 rpc 的成功包：只警告、不抛错 ----
+let threw = false;
+try { EQW_Dispatcher.dispatch({ rpc: 'brandNewRpc', data: { success: true } }); }
+catch (e) { threw = true; }
+t.eq('未知 rpc 不抛错', threw, false);
+
+// ---- 畸形入参不崩 ----
+[null, undefined, {}, { rpc: 'testRpc' }, { data: {} }].forEach((bad, i) => {
+    let boom = false;
+    try { EQW_Dispatcher.dispatch(bad); } catch (e) { boom = true; }
+    t.eq('畸形入参 #' + i + ' 不崩', boom, false);
+});
+
+// ---- 路由表完整性：协议里每个服务端推送 rpc 都要有 handler ----
+// （本条在 Task 10 全部 handler 就位后才会真正通过；此刻先写下期望，
+//   Task 10 完成时它会自动转绿——这正是它存在的意义：漏接一个包就会红）
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/state/RoomOptions.js');
+['fapai','jiaofen','shangzhuang','xuanzhu','maipai',
+ 'chupai1','chupai2','chupai3','mingpai','tishi','jiesuan','zhunbei'].forEach(rpc => {
+    t.eq('已注册 handler: ' + rpc, EQW_Dispatcher.hasHandler(rpc), true);
+});
+
+process.exit(t.done('dispatcher') ? 0 : 1);
+```
+
+> **注意**：最后那组断言在本任务结束时**会失败**（handler 还没写）。这是有意的——它是 Task 5–10 的验收信号。**本任务的 Step 4 只验证前面几组通过**，最后一组留到 Task 10。请在本任务提交时**临时注释掉**最后那组，并在注释里写明「Task 10 完成后取消注释」；Task 10 会把它放开。
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_dispatcher.js`
+Expected: `EQW_FailHandler is not defined`。
+
+- [ ] **Step 3: 写 `client/js/01_SubGame/codes/net/handlers/FailHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_FailHandler: 失败回包 //////////////////////////
+///////////////////////////////////////////////////////////////
+// 协议 §0.2：服务端受理请求时任一校验不通过，回一个【rpc 与请求同名】的失败包，
+// data 只含 success:false 与 errcode，且只回给请求者。
+//
+// errcode（服务端 youle_erqiwang.ERR）：
+//   1 PLAYER 玩家/房间/座位校验不通过   2 NODESK 牌桌或牌局不存在
+//   3 STEP   当前阶段不允许该操作        4 SEAT   位置不符或还没轮到
+//   5 PARAM  参数非法                    6 RULE   规则不允许
+//
+// 失败信息是【一次性】的，不属于对局状态，故不进 GameState，只随事件带出去。
+var EQW_FailHandler = EQW_FailHandler || {
+
+    ERR: {
+        PLAYER: 1, NODESK: 2, STEP: 3, SEAT: 4, PARAM: 5, RULE: 6
+    },
+
+    handle: function (rpc, data) {
+        var errcode = (data && typeof data.errcode === 'number') ? data.errcode : 0;
+        console.warn('[EQW] 请求失败: rpc=' + rpc + ' errcode=' + errcode);
+        EventBus.emit(EQW_Events.EQW_RPC_FAILED, { rpc: rpc, errcode: errcode });
+    }
+};
+```
+
+- [ ] **Step 4: 写 `client/js/01_SubGame/codes/net/Dispatcher.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_Dispatcher: 唯一收包入口 + 纯路由表 ////////////
+///////////////////////////////////////////////////////////////
+// 前端 04 §2：收包统一分发，一 rpc 一处理器。
+// 【本文件只分发，不写业务】——新增一种服务端推送 = 注册一条 rpc → handler。
+//
+// 判定顺序（关键）：先看 data.success，为 false 一律交 FailHandler、不进业务 handler。
+// 因为协议 §0.2 规定失败回包的 rpc 与【请求】同名（chupai 失败回 chupai，
+// 而成功走 chupai1/2/3），不先分流的话每个业务 handler 都得自己判一遍。
+var EQW_Dispatcher = EQW_Dispatcher || {
+
+    _handlers: {},
+
+    //注册一条 rpc → handler
+    register: function (rpc, handler) {
+        if (typeof rpc !== 'string' || typeof handler !== 'function') {
+            throw new Error('[EQW_Dispatcher] register 参数非法: ' + rpc);
+        }
+        if (this._handlers.hasOwnProperty(rpc)) {
+            throw new Error('[EQW_Dispatcher] rpc 重复注册: ' + rpc);
+        }
+        this._handlers[rpc] = handler;
+    },
+
+    hasHandler: function (rpc) {
+        return this._handlers.hasOwnProperty(rpc);
+    },
+
+    //唯一收包入口。msg = { rpc, data }
+    dispatch: function (msg) {
+        if (!msg || typeof msg.rpc !== 'string') {
+            console.warn('[EQW_Dispatcher] 畸形数据包，已忽略');
+            return;
+        }
+        var data = msg.data || {};
+
+        //成败只认 data.success（前端 04 §4）：失败包一律先分流
+        if (data.success === false) {
+            EQW_FailHandler.handle(msg.rpc, data);
+            return;
+        }
+
+        var h = this._handlers[msg.rpc];
+        if (h) {
+            h(data);
+        } else {
+            //平台日后新增推送不该让前端崩
+            console.warn('[EQW_Dispatcher] 未处理的 rpc: ' + msg.rpc);
+        }
+    }
+};
+```
+
+- [ ] **Step 5: 运行，确认通过**
+
+Run: `node client/tests/test_dispatcher.js`
+Expected: 前面几组全 PASS（最后一组路由表完整性已按 Step 1 的说明临时注释掉）。
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/Dispatcher.js client/js/01_SubGame/codes/net/handlers/FailHandler.js client/tests/test_dispatcher.js
+git commit -F - <<'EOF'
+二七王：收包分发器与失败回包处理
+
+分发器只分发不写业务。判定顺序上先看 data.success，失败包一律先分流给
+FailHandler——协议规定失败回包的 rpc 与请求同名（chupai 失败回 chupai，
+成功走 chupai1/2/3），不先分流则每个业务 handler 都要自己判一遍。
+
+未知 rpc 只警告不抛错，畸形入参不崩。路由表完整性断言留待全部 handler 就位。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 5: 发牌与叫分 handler
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/DealHandler.js`
+- Create: `client/js/01_SubGame/codes/net/handlers/CallHandler.js`
+- Modify: `client/js/01_SubGame/codes/state/GameState.js`（加 `applyFapai` / `applyJiaofen` / `applyShangzhuang` 与内部助手 `_apply`）
+- Test: `client/tests/test_handlers_call.js`
+
+**Interfaces:**
+- Consumes: `EQW_GameState`、`EQW_Events`、`EventBus`
+- Produces: 全局 `EQW_DealHandler.handle(data)`；`EQW_CallHandler.handleJiaofen(data)` / `handleShangzhuang(data)`；`EQW_GameState._apply(target, src, map)`（内部助手，`map` 为 `{目标键: 源键}`，源键在包里不存在则不写）
+
+> 协议字段：
+> `fapai` = `asetidx` / `asetcount` / `cards`(自己 28 张) / `seat`(当前等待叫分者) / `countdown`
+> `jiaofen` = `seat` / `call` / `currcall` / `multiple` / `nextseat` / `countdown`
+> `shangzhuang` = `seat` / `call` / `banker` / `grade`(庄家叫分) / `multiple` / `bottomcards` / `ancard3s` / `cards`(36 张，庄家才有) / `countdown` / `touxiang` / `curmultiple`
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_handlers_call.js`**
+
+```js
+// 发牌 / 叫分 / 上庄 handler
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/net/handlers/DealHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/CallHandler.js');
+
+const S = EQW_GameState;
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+// ================= fapai =================
+S.reset(); S.room.mySeat = 1; evts.length = 0;
+EQW_DealHandler.handle({ success: true, asetidx: 2, asetcount: 6,
+                         cards: [1, 2, 3], seat: 0, countdown: 15 });
+
+t.eq('局数', S.room.asetIdx, 2);
+t.eq('总局数', S.room.asetCount, 6);
+t.eq('手牌', S.my.cards, [1, 2, 3]);
+t.eq('当前叫分者', S.turn.seat, 0);
+t.eq('倒计时', S.turn.countdown, 15);
+t.eq('step 置为叫分', S.aset.step, 1);
+t.eq('mySeat 未被 reset 冲掉', S.room.mySeat, 1);
+t.eq('fapai 发了 RESET/HAND/TURN 事件',
+     ['EQW_RESET','EQW_HAND_CHANGED','EQW_TURN_CHANGED'].every(e => evts.indexOf(e) >= 0), true);
+
+// fapai 必须先 reset：上一局的残留要清掉
+S.aset.banker = 2; S.table.pushlist = [[9]];
+EQW_DealHandler.handle({ success: true, asetidx: 3, asetcount: 6, cards: [4], seat: 1, countdown: 15 });
+t.eq('fapai 清掉上局 banker', S.aset.banker, -1);
+t.eq('fapai 清掉上局 pushlist', S.table.pushlist, []);
+
+// ================= jiaofen =================
+S.reset(); evts.length = 0;
+EQW_CallHandler.handleJiaofen({ success: true, seat: 0, call: 60, currcall: 60,
+                                multiple: 3, nextseat: 1, countdown: 15 });
+t.eq('记录该家叫分', S.call.calls, [60, null, null]);
+t.eq('当前叫到的分', S.call.currcall, 60);
+t.eq('基础子数', S.aset.multiple, 3);
+t.eq('下一个叫分者', S.turn.seat, 1);
+t.eq('jiaofen 发事件', evts.indexOf('EQW_CALL_CHANGED') >= 0, true);
+
+// 不叫（call = 0）也要记下来，与「还没叫」(null) 区分
+EQW_CallHandler.handleJiaofen({ success: true, seat: 1, call: 0, currcall: 60,
+                                multiple: 3, nextseat: 2, countdown: 15 });
+t.eq('不叫记为 0，与未叫 null 区分', S.call.calls, [60, 0, null]);
+
+// ================= shangzhuang =================
+S.reset(); evts.length = 0;
+EQW_CallHandler.handleShangzhuang({ success: true, seat: 0, call: 70, banker: 0, grade: 70,
+                                    multiple: 2, bottomcards: [1,2,3,4,5,6,7,8], ancard3s: 1,
+                                    cards: [1,2,3], countdown: 20, touxiang: 1, curmultiple: 3 });
+t.eq('庄家', S.aset.banker, 0);
+t.eq('庄家叫分', S.aset.call, 70);
+t.eq('基础子数', S.aset.multiple, 2);
+t.eq('允许投降', S.aset.touxiang, 1);
+t.eq('抓分倍数', S.aset.curmultiple, 3);
+t.eq('开底标志', S.table.ancard3s, 1);
+t.eq('底牌', S.my.bottomCards, [1,2,3,4,5,6,7,8]);
+t.eq('摸底后手牌', S.my.cards, [1,2,3]);
+t.eq('step 置为选主', S.aset.step, 2);
+t.eq('控制权给庄家', S.turn.seat, 0);
+t.eq('shangzhuang 发事件',
+     ['EQW_BANKER_SET','EQW_HAND_CHANGED'].every(e => evts.indexOf(e) >= 0), true);
+
+// 闲家视角：没有 cards / bottomcards（非 70 分），缺字段不能把已有值抹掉
+S.reset(); S.my.cards = [7, 8, 9];
+EQW_CallHandler.handleShangzhuang({ success: true, seat: 0, call: 55, banker: 0, grade: 55,
+                                    multiple: 4, countdown: 20, touxiang: 0, curmultiple: 3 });
+t.eq('闲家手牌不被抹', S.my.cards, [7, 8, 9]);
+t.eq('闲家无底牌', S.my.bottomCards, []);
+t.eq('非 70 分无开底标志', S.table.ancard3s, 0);
+
+process.exit(t.done('handlers_call') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_handlers_call.js`
+Expected: `EQW_DealHandler is not defined`。
+
+- [ ] **Step 3: 给 `GameState.js` 加内部助手 `_apply`**
+
+在 `snapshot` 方法之后加入（注意保持对象字面量的逗号正确）：
+
+```js
+    //把包里的字段写进目标分组。map = { 目标键: 源键 }。
+    //【缺字段不兜底】源键在包里不存在就不写，保持原值——不填默认值掩盖漏发。
+    _apply: function (target, src, map) {
+        for (var dst in map) {
+            if (!map.hasOwnProperty(dst)) { continue; }
+            var srcKey = map[dst];
+            if (src.hasOwnProperty(srcKey)) { target[dst] = src[srcKey]; }
+        }
+    },
+```
+
+- [ ] **Step 4: 写 `client/js/01_SubGame/codes/net/handlers/DealHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_DealHandler: 发牌（fapai）//////////////////////
+///////////////////////////////////////////////////////////////
+// 协议 §1：asetidx 当前局数 / asetcount 总局数 / cards 自己的 28 张 /
+//          seat 当前等待叫分者 / countdown 叫分倒计时
+//
+// fapai 是一局的起点，先 reset 清掉上一局的残留（reset 保留 mySeat 与 options）。
+var EQW_DealHandler = EQW_DealHandler || {
+
+    handle: function (data) {
+        if (!data.hasOwnProperty('cards')) {
+            console.error('[EQW_DealHandler] fapai 缺 cards，已跳过该包');
+            return;
+        }
+
+        EQW_GameState.reset();
+
+        EQW_GameState._apply(EQW_GameState.room, data, {
+            asetIdx:   'asetidx',
+            asetCount: 'asetcount'
+        });
+        EQW_GameState._apply(EQW_GameState.my, data, { cards: 'cards' });
+        EQW_GameState._apply(EQW_GameState.turn, data, {
+            seat:      'seat',
+            countdown: 'countdown'
+        });
+        EQW_GameState.aset.step = 1;   //发完牌进入叫分阶段
+
+        EventBus.emit(EQW_Events.EQW_RESET);
+        EventBus.emit(EQW_Events.EQW_HAND_CHANGED);
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    }
+};
+```
+
+- [ ] **Step 5: 写 `client/js/01_SubGame/codes/net/handlers/CallHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_CallHandler: 叫分（jiaofen）与上庄（shangzhuang）
+///////////////////////////////////////////////////////////////
+// 协议 §3 jiaofen：seat 叫分者 / call 分数(0=不叫) / currcall 当前叫到的分 /
+//                  multiple 该叫分对应基础子数 / nextseat 下一个叫分者 / countdown
+// 协议 §4 shangzhuang：seat / call / banker / grade 庄家叫分 / multiple /
+//                  bottomcards 底牌(庄家恒有，闲家仅 70 分时有) / ancard3s 开底标志 /
+//                  cards 摸底后的 36 张(仅庄家) / countdown 选主倒计时 /
+//                  touxiang 是否允许投降 / curmultiple 当前抓分倍数(带符号)
+var EQW_CallHandler = EQW_CallHandler || {
+
+    handleJiaofen: function (data) {
+        if (!data.hasOwnProperty('seat')) {
+            console.error('[EQW_CallHandler] jiaofen 缺 seat，已跳过该包');
+            return;
+        }
+
+        //记录这一家叫了多少：0 = 不叫，与「还没叫」(null) 区分
+        if (data.hasOwnProperty('call') && data.seat >= 0 && data.seat < 3) {
+            EQW_GameState.call.calls[data.seat] = data.call;
+        }
+        EQW_GameState._apply(EQW_GameState.call, data, { currcall: 'currcall' });
+        EQW_GameState._apply(EQW_GameState.aset, data, { multiple: 'multiple' });
+        EQW_GameState._apply(EQW_GameState.turn, data, {
+            seat:      'nextseat',
+            countdown: 'countdown'
+        });
+
+        EventBus.emit(EQW_Events.EQW_CALL_CHANGED);
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    },
+
+    handleShangzhuang: function (data) {
+        if (!data.hasOwnProperty('banker')) {
+            console.error('[EQW_CallHandler] shangzhuang 缺 banker，已跳过该包');
+            return;
+        }
+
+        EQW_GameState._apply(EQW_GameState.aset, data, {
+            banker:     'banker',
+            call:       'grade',        //协议里庄家叫分叫 grade
+            multiple:   'multiple',
+            touxiang:   'touxiang',
+            curmultiple:'curmultiple'
+        });
+        EQW_GameState._apply(EQW_GameState.table, data, { ancard3s: 'ancard3s' });
+        //底牌与摸底后的手牌只有庄家（及 70 分时的闲家）才有，缺就不写、不抹已有值
+        EQW_GameState._apply(EQW_GameState.my, data, {
+            bottomCards: 'bottomcards',
+            cards:       'cards'
+        });
+        EQW_GameState._apply(EQW_GameState.turn, data, { countdown: 'countdown' });
+
+        EQW_GameState.aset.step = 2;                      //进入选主/投降
+        EQW_GameState.turn.seat = EQW_GameState.aset.banker;  //控制权归庄家
+
+        EventBus.emit(EQW_Events.EQW_BANKER_SET);
+        if (data.hasOwnProperty('cards')) { EventBus.emit(EQW_Events.EQW_HAND_CHANGED); }
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    }
+};
+```
+
+- [ ] **Step 6: 运行，确认通过**
+
+Run: `node client/tests/test_handlers_call.js`
+Expected: 全 PASS。
+
+- [ ] **Step 7: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/DealHandler.js client/js/01_SubGame/codes/net/handlers/CallHandler.js client/js/01_SubGame/codes/state/GameState.js client/tests/test_handlers_call.js
+git commit -F - <<'EOF'
+二七王：发牌与叫分 handler
+
+fapai 是一局起点，先 reset 清上局残留（保留 mySeat 与 options）。
+叫分里 0（不叫）与 null（还没叫）严格区分。上庄的 bottomcards/cards 只有庄家有，
+缺字段时保持原值、不抹掉闲家已有手牌——GameState 的「缺字段不兜底」在此体现。
+
+新增 GameState._apply 助手：按 {目标键:源键} 映射写入，源键不存在就不写。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 6: 选主与埋牌 handler
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/MainHandler.js`
+- Create: `client/js/01_SubGame/codes/net/handlers/BuryHandler.js`
+- Test: `client/tests/test_handlers_bury.js`
+
+**Interfaces:**
+- Consumes: `EQW_GameState`、`EQW_Events`、`EventBus`
+- Produces: 全局 `EQW_MainHandler.handleXuanzhu(data)`；`EQW_BuryHandler.handle(data)`
+
+> 协议字段：
+> `xuanzhu` = `banker` / `flower` / `countdown`(埋牌倒计时) / `cards`(选主后自己的牌)
+> `maipai` = `cards`(埋牌后手牌，仅庄家) / `burycards`(埋牌底牌，仅庄家) / `seat`(首出者，必为庄家) / `countdown`(出牌倒计时) / `liangpai`(仅闲家 + 可查牌 + 庄家达标)
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_handlers_bury.js`**
+
+```js
+// 选主 / 埋牌 handler
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/net/handlers/MainHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/BuryHandler.js');
+
+const S = EQW_GameState;
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+// ================= xuanzhu =================
+S.reset(); evts.length = 0;
+EQW_MainHandler.handleXuanzhu({ success: true, banker: 1, flower: 3,
+                                countdown: 30, cards: [5, 6, 7] });
+t.eq('主牌花色', S.aset.flower, 3);
+t.eq('庄家', S.aset.banker, 1);
+t.eq('选主后手牌', S.my.cards, [5, 6, 7]);
+t.eq('step 置为埋牌', S.aset.step, 3);
+t.eq('控制权归庄家', S.turn.seat, 1);
+t.eq('倒计时', S.turn.countdown, 30);
+t.eq('选主发事件',
+     ['EQW_MAIN_SET','EQW_HAND_CHANGED'].every(e => evts.indexOf(e) >= 0), true);
+
+// 闲家视角：没有 cards，不抹已有手牌
+S.reset(); S.my.cards = [1, 2];
+EQW_MainHandler.handleXuanzhu({ success: true, banker: 0, flower: 2, countdown: 30 });
+t.eq('闲家手牌不被抹', S.my.cards, [1, 2]);
+t.eq('闲家也拿到花色', S.aset.flower, 2);
+
+// ================= maipai =================
+S.reset(); evts.length = 0;
+EQW_BuryHandler.handle({ success: true, cards: [1,2,3], burycards: [9,10,11,12,13,14,15,16],
+                         seat: 1, countdown: 20 });
+t.eq('埋牌后手牌', S.my.cards, [1,2,3]);
+t.eq('埋牌底牌', S.my.buryCards, [9,10,11,12,13,14,15,16]);
+t.eq('step 置为出牌', S.aset.step, 5);
+t.eq('首出者', S.turn.seat, 1);
+t.eq('埋牌发事件',
+     ['EQW_BURY_DONE','EQW_HAND_CHANGED','EQW_TURN_CHANGED'].every(e => evts.indexOf(e) >= 0), true);
+
+// 闲家视角：无 cards/burycards，但可能有 liangpai
+S.reset(); S.my.cards = [4, 5]; evts.length = 0;
+EQW_BuryHandler.handle({ success: true, seat: 0, countdown: 20,
+                         liangpai: { cards: [52, 53, 2, 15] } });
+t.eq('闲家手牌不被抹', S.my.cards, [4, 5]);
+t.eq('闲家无埋牌底牌', S.my.buryCards, []);
+t.eq('亮牌数据', S.table.liangpai, { cards: [52, 53, 2, 15] });
+
+// 不达标/不查牌：无 liangpai 字段，保持 null
+S.reset();
+EQW_BuryHandler.handle({ success: true, seat: 0, countdown: 20 });
+t.eq('无亮牌时保持 null', S.table.liangpai, null);
+
+process.exit(t.done('handlers_bury') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_handlers_bury.js`
+Expected: `EQW_MainHandler is not defined`。
+
+- [ ] **Step 3: 写 `client/js/01_SubGame/codes/net/handlers/MainHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_MainHandler: 选主（xuanzhu）///////////////////
+///////////////////////////////////////////////////////////////
+// 协议 §7：banker 庄家 / flower 主牌花色(1方块 2梅花 3红心 4黑桃) /
+//          countdown 埋牌倒计时 / cards 选主后自己手上的牌
+//
+// 选主后正 2 / 正 7 升格、主花色普通牌并入主牌段（design §3），手牌需整体重排——
+// 但【重排是渲染时的事】，由 core/CardOrder 现算，不在这里落地成状态。
+//
+// 投降（touxiang）没有成功推送：点投降后服务端直接结算，前端收到的是 jiesuan。
+// 失败时才回一个同名的 touxiang 失败包，由 FailHandler 统一处理。
+var EQW_MainHandler = EQW_MainHandler || {
+
+    handleXuanzhu: function (data) {
+        if (!data.hasOwnProperty('flower')) {
+            console.error('[EQW_MainHandler] xuanzhu 缺 flower，已跳过该包');
+            return;
+        }
+
+        EQW_GameState._apply(EQW_GameState.aset, data, {
+            banker: 'banker',
+            flower: 'flower'
+        });
+        EQW_GameState._apply(EQW_GameState.my, data, { cards: 'cards' });
+        EQW_GameState._apply(EQW_GameState.turn, data, { countdown: 'countdown' });
+
+        EQW_GameState.aset.step = 3;                          //进入埋牌
+        EQW_GameState.turn.seat = EQW_GameState.aset.banker;  //埋牌由庄家做
+
+        EventBus.emit(EQW_Events.EQW_MAIN_SET);
+        if (data.hasOwnProperty('cards')) { EventBus.emit(EQW_Events.EQW_HAND_CHANGED); }
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    }
+};
+```
+
+- [ ] **Step 4: 写 `client/js/01_SubGame/codes/net/handlers/BuryHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_BuryHandler: 埋牌（maipai）////////////////////
+///////////////////////////////////////////////////////////////
+// 协议 §9：cards 埋牌后手牌(仅庄家) / burycards 埋牌底牌(仅庄家) /
+//          seat 首出者(必为庄家) / countdown 出牌倒计时 /
+//          liangpai 亮牌(仅闲家 + 可查牌模式 + 庄家固定主牌达门槛)
+//
+// 注意 burycards（埋牌底牌，庄家埋下的 8 张）与 bottomcards（底牌，发牌留桌的 8 张）
+// 是两批不同的牌，协议 §0.0 与验收清单专门警告过别写反。
+var EQW_BuryHandler = EQW_BuryHandler || {
+
+    handle: function (data) {
+        if (!data.hasOwnProperty('seat')) {
+            console.error('[EQW_BuryHandler] maipai 缺 seat，已跳过该包');
+            return;
+        }
+
+        //庄家才有的两项，闲家缺字段时保持原值、不抹手牌
+        EQW_GameState._apply(EQW_GameState.my, data, {
+            cards:     'cards',
+            buryCards: 'burycards'
+        });
+        //闲家才可能有的亮牌
+        EQW_GameState._apply(EQW_GameState.table, data, { liangpai: 'liangpai' });
+        EQW_GameState._apply(EQW_GameState.turn, data, {
+            seat:      'seat',
+            countdown: 'countdown'
+        });
+
+        EQW_GameState.aset.step = 5;   //进入出牌
+
+        EventBus.emit(EQW_Events.EQW_BURY_DONE);
+        if (data.hasOwnProperty('cards')) { EventBus.emit(EQW_Events.EQW_HAND_CHANGED); }
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    }
+};
+```
+
+- [ ] **Step 5: 运行，确认通过**
+
+Run: `node client/tests/test_handlers_bury.js`
+Expected: 全 PASS。
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/MainHandler.js client/js/01_SubGame/codes/net/handlers/BuryHandler.js client/tests/test_handlers_bury.js
+git commit -F - <<'EOF'
+二七王：选主与埋牌 handler
+
+选主后主牌集合变化、手牌需重排，但重排是渲染时由 core/CardOrder 现算，
+不在状态里落地——GameState 只镜像不派生。
+
+埋牌区分 burycards（埋牌底牌）与 bottomcards（底牌），两批不同的牌；
+闲家无 cards/burycards 但可能有 liangpai，缺字段一律不抹已有值。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 7: 出牌 handler
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/PlayHandler.js`
+- Test: `client/tests/test_handlers_play.js`
+
+**Interfaces:**
+- Consumes: `EQW_GameState`、`EQW_Events`、`EventBus`
+- Produces: 全局 `EQW_PlayHandler.handle(data, order)`（`order` 为 1/2/3，对应 `chupai1/2/3`）
+
+> 这是最复杂的一个。三个包的字段不完全相同：
+> - **`chupai1`**（首家）独有：`shuaicuo` 甩错标志、`count` 出牌数量、`flower` 出牌花色、`cardtype` 牌型、`shuai` 甩牌分量
+> - **`chupai1/2`** 有：`nextseat`、`mustcard`（只发给 `nextseat` 那一家）
+> - **`chupai3`**（末家）独有：`maxseat` 本轮谁最大、`grade` 本轮闲家得分
+> - **共有**：`seat`、`cards`、`seatlist`(仅可查牌)、`countdown`、`baozhu`、`cardsinhand`(仅出牌者)、`curmultiple`(1 和 3 有)
+>
+> **`cardsinhand` 只有出牌者自己有**——收到就更新自己的手牌；别人出牌时没这个字段，不能抹掉自己的手牌。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_handlers_play.js`**
+
+```js
+// 出牌 handler（chupai1/2/3）
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/net/handlers/PlayHandler.js');
+
+const S = EQW_GameState;
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+// ================= chupai1（首家出牌，自己出的）=================
+S.reset(); S.room.mySeat = 0; S.my.cards = [1,2,3,4]; evts.length = 0;
+EQW_PlayHandler.handle({ success: true, seat: 0, cards: [1,2], count: 2, flower: 3,
+                         cardtype: 201, nextseat: 1, countdown: 15, baozhu: 0,
+                         cardsinhand: [3,4], curmultiple: 2,
+                         seatlist: [[0,0,0,0,[5,2]],[0,0,0,0,[6,1]],[0,0,0,0,[7,3]]] }, 1);
+
+t.eq('出牌者手牌被更新', S.my.cards, [3,4]);
+t.eq('下一个出牌者', S.turn.seat, 1);
+t.eq('倒计时', S.turn.countdown, 15);
+t.eq('抓分倍数', S.aset.curmultiple, 2);
+t.eq('牌况表', S.table.seatlist.length, 3);
+t.eq('出牌发事件', evts.indexOf('EQW_CARD_PLAYED') >= 0, true);
+
+// ================= chupai2（别人出牌）=================
+// 别人出牌时没有 cardsinhand，不能抹掉自己的手牌
+S.reset(); S.room.mySeat = 0; S.my.cards = [3,4]; evts.length = 0;
+EQW_PlayHandler.handle({ success: true, seat: 1, cards: [5,6], nextseat: 2,
+                         countdown: 15, baozhu: 0 }, 2);
+t.eq('别人出牌不抹自己手牌', S.my.cards, [3,4]);
+t.eq('控制权推进', S.turn.seat, 2);
+
+// mustcard 只发给下一个出牌者
+S.reset(); S.room.mySeat = 2;
+EQW_PlayHandler.handle({ success: true, seat: 1, cards: [5,6], nextseat: 2,
+                         countdown: 15, mustcard: [7,8] }, 2);
+t.eq('必出牌', S.my.mustCard, [7,8]);
+
+// 没有 mustcard 时要清空——否则上一轮的建议会残留
+S.reset(); S.my.mustCard = [7,8];
+EQW_PlayHandler.handle({ success: true, seat: 1, cards: [5,6], nextseat: 0, countdown: 15 }, 2);
+t.eq('无 mustcard 时清空', S.my.mustCard, []);
+
+// ================= chupai3（末家出牌，本轮结束）=================
+S.reset(); evts.length = 0;
+EQW_PlayHandler.handle({ success: true, seat: 2, cards: [9,10], maxseat: 0, grade: 25,
+                         countdown: 15, baozhu: 1, curmultiple: -2 }, 3);
+t.eq('本轮最大者', S.result.chupai.maxseat, 0);
+t.eq('本轮闲家得分', S.result.chupai.grade, 25);
+t.eq('累计捡分', S.aset.grade, 25);
+t.eq('报无主标志', S.aset.baozhu, 1);
+t.eq('抓分倍数（带符号）', S.aset.curmultiple, -2);
+t.eq('本轮结束发事件', evts.indexOf('EQW_TRICK_END') >= 0, true);
+
+// 本轮闲家没得分时不带 grade，累计分不该被抹
+S.reset(); S.aset.grade = 40;
+EQW_PlayHandler.handle({ success: true, seat: 2, cards: [9,10], maxseat: 1, countdown: 15 }, 3);
+t.eq('无 grade 时累计分保持', S.aset.grade, 40);
+
+// ================= 甩错 =================
+S.reset(); evts.length = 0;
+EQW_PlayHandler.handle({ success: true, seat: 0, cards: [11], shuaicuo: 1, count: 1,
+                         flower: 3, cardtype: 101, nextseat: 1, countdown: 15 }, 1);
+t.eq('甩错标志', S.table.playproc.shuaicuo, 1);
+
+// ================= 缺必需字段 =================
+S.reset();
+EQW_PlayHandler.handle({ success: true, cards: [1] }, 1);   //缺 seat
+t.eq('缺 seat 时跳过该包', S.turn.seat, -1);
+
+process.exit(t.done('handlers_play') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_handlers_play.js`
+Expected: `EQW_PlayHandler is not defined`。
+
+- [ ] **Step 3: 写实现 `client/js/01_SubGame/codes/net/handlers/PlayHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_PlayHandler: 出牌（chupai1 / 2 / 3）///////////
+///////////////////////////////////////////////////////////////
+// 协议 §11–§13。三个包字段不完全相同：
+//   chupai1 首家独有：shuaicuo 甩错标志 / count 出牌数量 / flower 出牌花色 /
+//                     cardtype 牌型 / shuai 甩牌分量构成
+//   chupai1/2 有：nextseat 下一个出牌者 / mustcard 必出牌(只发给 nextseat 那一家)
+//   chupai3 末家独有：maxseat 本轮谁最大 / grade 本轮闲家得分
+//   共有：seat / cards / seatlist(仅可查牌) / countdown / baozhu /
+//         cardsinhand(仅出牌者自己有) / curmultiple(1 和 3 有)
+//
+// 【cardsinhand 只有出牌者自己有】：收到就更新自己的手牌；别人出牌时没这个字段，
+// 绝不能抹掉自己的手牌——这正是「缺字段不兜底」要防的。
+//
+// 【mustcard 没有就要清空】：它是「本轮跟牌的必出牌」，只对当前这一轮有效。
+// 上一轮的建议残留下来会让界面自动选中错误的牌。
+var EQW_PlayHandler = EQW_PlayHandler || {
+
+    //order: 1/2/3，对应 chupai1/2/3
+    handle: function (data, order) {
+        if (!data.hasOwnProperty('seat') || !data.hasOwnProperty('cards')) {
+            console.error('[EQW_PlayHandler] chupai' + order + ' 缺 seat 或 cards，已跳过该包');
+            return;
+        }
+
+        //—— 本轮桌面：记下这一手（谁出的、出了什么、首家的牌型信息）——
+        if (!EQW_GameState.table.playproc) { EQW_GameState.table.playproc = {}; }
+        var proc = EQW_GameState.table.playproc;
+        proc.order = order;
+        EQW_GameState._apply(proc, data, {
+            seat:     'seat',
+            cards:    'cards',
+            count:    'count',
+            flower:   'flower',
+            cardtype: 'cardtype',
+            shuai:    'shuai',
+            shuaicuo: 'shuaicuo'
+        });
+
+        //—— 自己的手牌：只有出牌者本人才收到 cardsinhand ——
+        EQW_GameState._apply(EQW_GameState.my, data, { cards: 'cardsinhand' });
+
+        //—— 必出牌：本轮有效，没给就清空 ——
+        if (data.hasOwnProperty('mustcard')) {
+            EQW_GameState.my.mustCard = data.mustcard;
+        } else {
+            EQW_GameState.my.mustCard = [];
+        }
+
+        //—— 牌况与报无主（仅可查牌模式下发）——
+        EQW_GameState._apply(EQW_GameState.table, data, { seatlist: 'seatlist' });
+        EQW_GameState._apply(EQW_GameState.aset, data, {
+            baozhu:      'baozhu',
+            curmultiple: 'curmultiple'
+        });
+
+        //—— 控制权与倒计时 ——
+        EQW_GameState._apply(EQW_GameState.turn, data, {
+            seat:      'nextseat',
+            countdown: 'countdown'
+        });
+
+        EventBus.emit(EQW_Events.EQW_CARD_PLAYED);
+        if (data.hasOwnProperty('cardsinhand')) { EventBus.emit(EQW_Events.EQW_HAND_CHANGED); }
+
+        //—— 末家出完：本轮结束，记下谁最大、闲家得了多少分 ——
+        if (order === 3) {
+            if (!EQW_GameState.result.chupai) { EQW_GameState.result.chupai = {}; }
+            EQW_GameState._apply(EQW_GameState.result.chupai, data, {
+                seat:    'seat',
+                cards:   'cards',
+                maxseat: 'maxseat',
+                grade:   'grade'
+            });
+            //本轮闲家得分累加进小局捡分；没得分时不带 grade，累计值保持不变
+            if (data.hasOwnProperty('grade')) {
+                EQW_GameState.aset.grade = EQW_GameState.aset.grade + data.grade;
+            }
+            EventBus.emit(EQW_Events.EQW_TRICK_END);
+        }
+
+        EventBus.emit(EQW_Events.EQW_TURN_CHANGED);
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_handlers_play.js`
+Expected: 全 PASS。
+
+**注意**：测试里「累计捡分」那条期望 `S.aset.grade === 25`（从 0 累加 25）。若你的实现改成了直接赋值而非累加，这条会过但语义错——`grade` 是**本轮**得分，小局捡分要累加。请确认实现是累加。
+
+- [ ] **Step 5: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/PlayHandler.js client/tests/test_handlers_play.js
+git commit -F - <<'EOF'
+二七王：出牌 handler
+
+三个包字段不同：chupai1 带牌型信息、chupai1/2 带 nextseat 与 mustcard、
+chupai3 带 maxseat 与本轮得分。
+
+两个易错点已覆盖：cardsinhand 只有出牌者自己有，别人出牌时缺该字段不能抹掉
+自己的手牌；mustcard 只对当前轮有效，没给就要清空，否则上一轮的建议会残留。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 8: 明牌、提示、准备 handler
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/QueryHandler.js`
+- Create: `client/js/01_SubGame/codes/net/handlers/ReadyHandler.js`
+- Test: `client/tests/test_handlers_query.js`
+
+**Interfaces:**
+- Produces: 全局 `EQW_QueryHandler.handleMingpai(data)` / `handleTishi(data)`；`EQW_ReadyHandler.handle(data)`
+
+> 协议字段：
+> `mingpai`（只回给请求者）= `seat` 请求者 / `others` 另外两家各自未出的全部主牌，元素 `{seat, zhucards}`
+> `tishi`（只转发给对家）= `seat` 发出提示的闲家 / `tip` 1踩 2没分 3有分
+> `zhunbei` = `seat`
+>
+> **提示是一次性的**：它不是对局状态，收到就 emit 事件让气泡显示，**但仍需短暂存进 `GameState.table`**——因为重连时不重放，存下来只为让 C 阶段能读到"最近一次是谁提示了什么"。若判断不需要，可只 emit 不存；本计划选择**只 emit 不存**，理由见实现注释。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_handlers_query.js`**
+
+```js
+// 明牌 / 提示 / 准备 handler
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/net/handlers/QueryHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/ReadyHandler.js');
+
+const S = EQW_GameState;
+const payloads = [];
+EventBus.on(EQW_Events.EQW_TIP, d => payloads.push(d));
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+// ================= mingpai =================
+S.reset(); evts.length = 0;
+EQW_QueryHandler.handleMingpai({ success: true, seat: 1,
+    others: [{ seat: 0, zhucards: [52, 2] }, { seat: 2, zhucards: [53, 15] }] });
+t.eq('明牌数据入状态', S.table.mingpai,
+     [{ seat: 0, zhucards: [52, 2] }, { seat: 2, zhucards: [53, 15] }]);
+t.eq('明牌发事件', evts.indexOf('EQW_MINGPAI') >= 0, true);
+
+// ================= tishi =================
+// 提示是一次性的，不进 GameState，只随事件带出去
+S.reset(); payloads.length = 0; evts.length = 0;
+const before = S.snapshot();                       // 处理前的状态快照
+EQW_QueryHandler.handleTishi({ success: true, seat: 2, tip: 1 });
+t.eq('提示发事件', evts.indexOf('EQW_TIP') >= 0, true);
+t.eq('提示内容随事件带出', payloads, [{ seat: 2, tip: 1 }]);
+t.eq('提示未改动 GameState 任何字段', S.snapshot(), before);
+
+// ================= zhunbei =================
+S.reset(); evts.length = 0;
+EQW_ReadyHandler.handle({ success: true, seat: 1 });
+t.eq('准备发事件', evts.indexOf('EQW_READY_CHANGED') >= 0, true);
+
+// ================= 缺必需字段 =================
+S.reset();
+EQW_QueryHandler.handleMingpai({ success: true });         //缺 others
+t.eq('明牌缺 others 时不写', S.table.mingpai, null);
+payloads.length = 0;
+EQW_QueryHandler.handleTishi({ success: true, seat: 0 });  //缺 tip
+t.eq('提示缺 tip 时不发事件', payloads, []);
+
+process.exit(t.done('handlers_query') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_handlers_query.js`
+Expected: `EQW_QueryHandler is not defined`。
+
+- [ ] **Step 3: 写 `client/js/01_SubGame/codes/net/handlers/QueryHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_QueryHandler: 明牌（mingpai）与提示（tishi）///
+///////////////////////////////////////////////////////////////
+// 协议 §13.6 mingpai（只回给请求者）：
+//   seat 请求者 / others 另外两家各自未出的全部主牌 [{seat, zhucards}]
+//   受理条件：可查牌模式 + 出牌阶段 + 已有【任一】玩家报无主（design §9.3）
+//
+// 协议 §13.8 tishi（只转发给对家，即另一闲家）：
+//   seat 发出提示的闲家 / tip 1=踩 2=没分 3=有分
+//   注意：成功时【不给发送者回执】，只转发给对家；只有失败才回给发送者。
+//
+// 明牌数据进 GameState（面板可反复开关查看），提示不进——
+// 提示是一次性的通知、不是对局状态，重连也不重放，存下来只会变成幽灵数据。
+var EQW_QueryHandler = EQW_QueryHandler || {
+
+    handleMingpai: function (data) {
+        if (!data.hasOwnProperty('others')) {
+            console.error('[EQW_QueryHandler] mingpai 缺 others，已跳过该包');
+            return;
+        }
+        EQW_GameState.table.mingpai = data.others;
+        EventBus.emit(EQW_Events.EQW_MINGPAI);
+    },
+
+    handleTishi: function (data) {
+        if (!data.hasOwnProperty('seat') || !data.hasOwnProperty('tip')) {
+            console.error('[EQW_QueryHandler] tishi 缺 seat 或 tip，已跳过该包');
+            return;
+        }
+        //一次性通知：不进 GameState，随事件把内容带给订阅者
+        EventBus.emit(EQW_Events.EQW_TIP, { seat: data.seat, tip: data.tip });
+    }
+};
+```
+
+- [ ] **Step 4: 写 `client/js/01_SubGame/codes/net/handlers/ReadyHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_ReadyHandler: 准备（zhunbei）//////////////////
+///////////////////////////////////////////////////////////////
+// 协议 §16：seat 位置序号。
+// 准备状态由平台的玩家信息 UI 呈现（清单 T-15：准备标识用平台的），
+// 子游戏只需把事件发出去，让关心的组件（如结算面板的「下一局」按钮）响应。
+var EQW_ReadyHandler = EQW_ReadyHandler || {
+
+    handle: function (data) {
+        if (!data.hasOwnProperty('seat')) {
+            console.error('[EQW_ReadyHandler] zhunbei 缺 seat，已跳过该包');
+            return;
+        }
+        EventBus.emit(EQW_Events.EQW_READY_CHANGED, { seat: data.seat });
+    }
+};
+```
+
+- [ ] **Step 5: 运行，确认通过**
+
+Run: `node client/tests/test_handlers_query.js`
+Expected: 全 PASS。
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/QueryHandler.js client/js/01_SubGame/codes/net/handlers/ReadyHandler.js client/tests/test_handlers_query.js
+git commit -F - <<'EOF'
+二七王：明牌、提示、准备 handler
+
+明牌数据进 GameState（面板可反复开关查看）；提示不进——它是一次性通知、
+不是对局状态，重连也不重放，存下来只会变成幽灵数据，故只随事件带出。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 9: 结算与解散 handler
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/ResultHandler.js`
+- Test: `client/tests/test_handlers_result.js`
+
+**Interfaces:**
+- Produces: 全局 `EQW_ResultHandler.handleJiesuan(data)` / `handleFree(deskfree)`
+
+> 协议 §14：结算包由 `chupai` + `bottom` + `aset`（末局再加 `account`）拼装。三种来源组成不同：
+> - **正常出牌结算**：含 `chupai` + `bottom` + `aset`
+> - **投降结算**：只含 `aset`，无 `chupai`、无 `bottom`
+> - **解散结算**：只含 `aset` + `account`，且**走另一个入口**
+>
+> **解散的特殊性**（协议 §14.1 + 平台代码核实）：它进不了 `_ReceiveData`（`route` 是平台的 `room`），平台通过 `Game_Modify.Free(Desk.deskfree)` 交给子游戏。参数是**已经取出来的 `deskfree`**，所以取值路径是 `deskfree.data.aset`（比协议文档描述的少一层）。且 `deskfree` **可能是 `null`**（开战后、首局发牌前解散）。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_handlers_result.js`**
+
+```js
+// 结算 / 解散 handler
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/net/handlers/ResultHandler.js');
+
+const S = EQW_GameState;
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+const ASET = { banker: 0, call: 60, multiple: 3, flower: 3, grade: 45, upgrade: 1,
+               bangwang: 0, climb: 0,
+               seatlist: [{ grade: 6, score: 6 }, { grade: -3, score: -3 }, { grade: -3, score: -3 }] };
+
+// ================= 正常出牌结算 =================
+S.reset(); evts.length = 0;
+EQW_ResultHandler.handleJiesuan({ success: true,
+    chupai: { seat: 2, cards: [9], maxseat: 0, grade: 10 },
+    bottom: { cards: [1,2,3,4,5,6,7,8], multiple: 2, grade1: 20, grade2: 40 },
+    aset: ASET });
+
+t.eq('小局结算入状态', S.result.aset, ASET);
+t.eq('抠底入状态', S.result.bottom.grade2, 40);
+t.eq('最后一手入状态', S.result.chupai.maxseat, 0);
+t.eq('step 置为结算', S.aset.step, 6);
+t.eq('结算发事件', evts.indexOf('EQW_ASET_RESULT') >= 0, true);
+t.eq('非末局不发大局结算事件', evts.indexOf('EQW_ACCOUNT_RESULT') < 0, true);
+
+// ================= 投降结算（无 chupai / 无 bottom）=================
+S.reset(); evts.length = 0;
+EQW_ResultHandler.handleJiesuan({ success: true, aset: { banker: 0, call: 70, multiple: 1,
+                                                          upgrade: -99, seatlist: [] } });
+t.eq('投降结算入状态', S.result.aset.upgrade, -99);
+t.eq('投降无 chupai', S.result.chupai, null);
+t.eq('投降无 bottom', S.result.bottom, null);
+t.eq('投降也发结算事件', evts.indexOf('EQW_ASET_RESULT') >= 0, true);
+
+// ================= 末局：带 account =================
+const ACCOUNT = [{ score: 12, grades: [6,6], grade_jf_total: 8, grade_cg_total: 4, grade_bw_total: 0 },
+                 { score: -6, grades: [-3,-3], grade_jf_total: -4, grade_cg_total: -2, grade_bw_total: 0 },
+                 { score: -6, grades: [-3,-3], grade_jf_total: -4, grade_cg_total: -2, grade_bw_total: 0 }];
+S.reset(); evts.length = 0;
+EQW_ResultHandler.handleJiesuan({ success: true, aset: ASET, account: ACCOUNT });
+t.eq('大局结算入状态', S.result.account, ACCOUNT);
+t.eq('末局发大局结算事件', evts.indexOf('EQW_ACCOUNT_RESULT') >= 0, true);
+
+// ================= 解散：走 Free 入口，取值少一层 =================
+S.reset(); evts.length = 0;
+EQW_ResultHandler.handleFree({ rpc: 'jiesuan',
+    data: { success: true, aset: { banker: -1, call: -1, multiple: 0, upgrade: 0, seatlist: [] },
+            account: ACCOUNT } });
+t.eq('解散取到 aset', S.result.aset.multiple, 0);
+t.eq('解散取到 account', S.result.account, ACCOUNT);
+t.eq('解散发大局结算事件', evts.indexOf('EQW_ACCOUNT_RESULT') >= 0, true);
+
+// ================= 解散：deskfree 为 null（首局发牌前解散）=================
+S.reset(); evts.length = 0;
+let boom = false;
+try { EQW_ResultHandler.handleFree(null); } catch (e) { boom = true; }
+t.eq('deskfree 为 null 不崩', boom, false);
+t.eq('deskfree 为 null 不写状态', S.result.aset, null);
+t.eq('deskfree 为 null 不发结算事件', evts.indexOf('EQW_ACCOUNT_RESULT') < 0, true);
+
+// deskfree 存在但 data 缺失也要容忍
+boom = false;
+try { EQW_ResultHandler.handleFree({ rpc: 'jiesuan' }); } catch (e) { boom = true; }
+t.eq('deskfree.data 缺失不崩', boom, false);
+
+process.exit(t.done('handlers_result') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_handlers_result.js`
+Expected: `EQW_ResultHandler is not defined`。
+
+- [ ] **Step 3: 写实现 `client/js/01_SubGame/codes/net/handlers/ResultHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_ResultHandler: 结算（jiesuan）与解散（Free）///
+///////////////////////////////////////////////////////////////
+// 协议 §14：结算包由 chupai + bottom + aset 拼装，末局再加 account。
+// 三种来源的组成不同：
+//   正常出牌结算：chupai + bottom + aset（末局加 account）
+//   投降结算：    只有 aset（末局加 account），无 chupai、无 bottom
+//   解散结算：    只有 aset + account，且【走另一个入口】，见下
+//
+// 【解散的特殊性】（协议 §14.1，已对平台代码核实）：
+// 解散包的 route 是平台的 "room"，平台 12_Logic.js 按 route 分流时把它交给
+// Net[rpc] 而【不是】Game_Modify._ReceiveData——所以它根本进不了子游戏的分发表。
+// 平台另有专门入口：07_Desk.js 的 Game_Modify.Free(Desk.deskfree)。
+// 两个后果：
+//   1. 取值路径比协议文档少一层——平台已把 deskfree 取出来传进来，
+//      所以是 deskfree.data.aset，不是 data.deskfree.data.aset；
+//   2. 参数可能是 null——解散若发生在开战后、首局发牌前，服务端 get_disbandRoom
+//      返回 null，平台走「不带 deskfree」分支。这时只做房间收尾、不弹结算。
+var EQW_ResultHandler = EQW_ResultHandler || {
+
+    handleJiesuan: function (data) {
+        if (!data.hasOwnProperty('aset')) {
+            console.error('[EQW_ResultHandler] jiesuan 缺 aset，已跳过该包');
+            return;
+        }
+        this._applyResult(data);
+    },
+
+    //平台解散入口。deskfree = { rpc:"jiesuan", data:{ success, aset, account } }，可能为 null
+    handleFree: function (deskfree) {
+        if (!deskfree || !deskfree.data) {
+            //首局发牌前解散：没有结算数据，只做房间收尾，不弹结算面板
+            console.warn('[EQW_ResultHandler] 解散包无 deskfree 数据（首局发牌前解散）');
+            return;
+        }
+        var d = deskfree.data;
+        if (!d.hasOwnProperty('aset')) {
+            console.error('[EQW_ResultHandler] 解散包缺 aset，已跳过');
+            return;
+        }
+        this._applyResult(d);
+    },
+
+    //三种来源共用的落地逻辑：有哪组就写哪组，缺的保持 null
+    _applyResult: function (d) {
+        EQW_GameState._apply(EQW_GameState.result, d, {
+            chupai:  'chupai',
+            bottom:  'bottom',
+            aset:    'aset',
+            account: 'account'
+        });
+        EQW_GameState.aset.step = 6;
+
+        EventBus.emit(EQW_Events.EQW_ASET_RESULT);
+        //account 只在末局或解散时才有
+        if (d.hasOwnProperty('account')) {
+            EventBus.emit(EQW_Events.EQW_ACCOUNT_RESULT);
+        }
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_handlers_result.js`
+Expected: 全 PASS。
+
+- [ ] **Step 5: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/ResultHandler.js client/tests/test_handlers_result.js
+git commit -F - <<'EOF'
+二七王：结算与解散 handler
+
+三种结算来源组成不同（正常出牌 / 投降 / 解散），共用一套落地逻辑：
+有哪组写哪组，缺的保持 null。
+
+解散走平台的 Game_Modify.Free 入口而非收包分发表——它的 route 是 room，
+被平台分流走了。取值路径因此比协议文档少一层，且参数可能为 null
+（首局发牌前解散），已覆盖。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 10: 重连与开局 handler + 路由表注册
+
+**Files:**
+- Create: `client/js/01_SubGame/codes/net/handlers/ResyncHandler.js`
+- Modify: `client/js/01_SubGame/codes/net/Dispatcher.js`（文件末尾注册全部 rpc）
+- Modify: `client/tests/test_dispatcher.js`（取消 Task 4 临时注释掉的那组断言）
+- Test: `client/tests/test_resync.js`
+
+**Interfaces:**
+- Consumes: 全部 handler
+- Produces: 全局 `EQW_ResyncHandler.handleDeskinfo(deskinfo)` / `handleStartWar(msg)` / `handleSetRoomDes(roomcode, asetcount, roomtype)`
+
+> `deskinfo` 按 `step` 只带对应阶段的分组（协议文末）：
+> 恒有 `count` / `idx` / `PlayerInfo` / `step` / `MyCards`
+> `CallRun`(step1) `ChooseMain`(step2) `BuryCards`(step3) `PushCards`(step5) `Balance`(step6)
+>
+> **重连不重放一次性事件**：70 分坐庄的 3 秒开底是上庄时的一次性事件，`deskinfo` 不重放，前端不得补播。
+>
+> `StartWar` 的差异化下发（前端 04 §3）：`_msg.data.deskwar || _msg.data`，若 `sendtype === 1` 且有 `seatlist[]`，按本座位取 `seatlist[i].data`。
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_resync.js`**
+
+```js
+// 重连（deskinfo）与开局（StartWar）
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/state/RoomOptions.js');
+load('client/js/01_SubGame/codes/net/handlers/ResyncHandler.js');
+
+const S = EQW_GameState;
+const evts = [];
+Object.keys(EQW_Events).forEach(k => EventBus.on(EQW_Events[k], () => evts.push(k)));
+
+// ================= setRoomDes：房间选项 =================
+S.reset(); S.room.options = null;
+EQW_ResyncHandler.handleSetRoomDes(123456, 12, '10100');
+t.eq('总局数', S.room.asetCount, 12);
+t.eq('傍王开', S.room.options.bangwang, 1);
+t.eq('可查牌', S.room.options.nocheck, 0);
+
+// ================= deskinfo：step 5 出牌阶段 =================
+S.reset(); S.room.mySeat = 1; evts.length = 0;
+EQW_ResyncHandler.handleDeskinfo({
+    count: 6, idx: 2, PlayerInfo: [10, -5, -5], step: 5, MyCards: [1,2,3],
+    PushCards: {
+        banker: 0, call: 60, multiple: 3, flower: 3, countdown: 15,
+        grade: 25, playproc: { round: 4, currseat: 1, cards: [[9],[],[]] },
+        seatlist: [[0,0,0,0,[5,2]],[0,0,0,0,[6,1]],[0,0,0,0,[7,3]]],
+        liangpai: { cards: [52,53] }, pushlist: [[[1],[2],[3]]],
+        curmultiple: 2, mustcard: [4,5]
+    }
+});
+t.eq('总局数', S.room.asetCount, 6);
+t.eq('当前局', S.room.asetIdx, 2);
+t.eq('三家总分', S.room.playerScores, [10, -5, -5]);
+t.eq('阶段', S.aset.step, 5);
+t.eq('手牌', S.my.cards, [1,2,3]);
+t.eq('庄家', S.aset.banker, 0);
+t.eq('主牌花色', S.aset.flower, 3);
+t.eq('捡分', S.aset.grade, 25);
+t.eq('抓分倍数', S.aset.curmultiple, 2);
+t.eq('当前轮出牌情况', S.table.playproc.round, 4);
+t.eq('出牌历史', S.table.pushlist.length, 1);
+t.eq('亮牌', S.table.liangpai, { cards: [52,53] });
+t.eq('必出牌', S.my.mustCard, [4,5]);
+t.eq('控制权（由 playproc.currseat 给出）', S.turn.seat, 1);
+t.eq('重连发全量重画事件', evts.indexOf('EQW_RESYNC_ALL') >= 0, true);
+
+// ================= deskinfo：step 1 叫分阶段 =================
+S.reset(); evts.length = 0;
+EQW_ResyncHandler.handleDeskinfo({
+    count: 6, idx: 1, PlayerInfo: [0,0,0], step: 1, MyCards: [7,8],
+    CallRun: { seat: 2, countdown: 15, nowcall: 65, multiple: 2, call: [null, 0, 65] }
+});
+t.eq('叫分阶段', S.aset.step, 1);
+t.eq('当前叫分者', S.turn.seat, 2);
+t.eq('当前叫到的分', S.call.currcall, 65);
+t.eq('三家叫分', S.call.calls, [null, 0, 65]);
+
+// ================= deskinfo：step 2 选主阶段（庄家有 bottomcards）=================
+S.reset(); evts.length = 0;
+EQW_ResyncHandler.handleDeskinfo({
+    count: 6, idx: 1, PlayerInfo: [0,0,0], step: 2, MyCards: [1,2],
+    ChooseMain: { banker: 0, call: 70, multiple: 2, countdown: 20,
+                  bottomcards: [1,2,3,4,5,6,7,8], touxiang: 1 }
+});
+t.eq('选主阶段', S.aset.step, 2);
+t.eq('底牌', S.my.bottomCards, [1,2,3,4,5,6,7,8]);
+t.eq('允许投降', S.aset.touxiang, 1);
+t.eq('控制权归庄家', S.turn.seat, 0);
+
+// 重连【不重放】70 分开底：deskinfo 里没有 ancard3s
+t.eq('重连不重放开底', S.table.ancard3s, 0);
+
+// ================= deskinfo：step 6 结算阶段 =================
+S.reset(); evts.length = 0;
+EQW_ResyncHandler.handleDeskinfo({
+    count: 6, idx: 6, PlayerInfo: [12,-6,-6], step: 6, MyCards: [],
+    Balance: { readystate: [1,0,0], aset: { banker: 0, upgrade: 1, seatlist: [] } }
+});
+t.eq('结算阶段', S.aset.step, 6);
+t.eq('小局结算数据', S.result.aset.upgrade, 1);
+
+// ================= StartWar：差异化下发 =================
+S.reset(); S.room.mySeat = 2; evts.length = 0;
+EQW_ResyncHandler.handleStartWar({ data: { deskwar: { sendtype: 1, seatlist: [
+    { seat: 0, data: { count: 6, idx: 1, PlayerInfo: [0,0,0], step: 1, MyCards: [90] } },
+    { seat: 2, data: { count: 6, idx: 1, PlayerInfo: [0,0,0], step: 1, MyCards: [11,12] } }
+] } } });
+t.eq('按本座位取到自己那份', S.my.cards, [11,12]);
+
+// 非差异化下发：直接用 data
+S.reset(); S.room.mySeat = 0;
+EQW_ResyncHandler.handleStartWar({ data: { count: 6, idx: 1, PlayerInfo: [0,0,0],
+                                           step: 1, MyCards: [3,4] } });
+t.eq('非差异化下发', S.my.cards, [3,4]);
+
+// 畸形入参不崩
+let boom = false;
+try { EQW_ResyncHandler.handleStartWar(null); EQW_ResyncHandler.handleDeskinfo(null); }
+catch (e) { boom = true; }
+t.eq('畸形入参不崩', boom, false);
+
+process.exit(t.done('resync') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_resync.js`
+Expected: `EQW_ResyncHandler is not defined`。
+
+- [ ] **Step 3: 写实现 `client/js/01_SubGame/codes/net/handlers/ResyncHandler.js`**
+
+```js
+///////////////////////////////////////////////////////////////
+////////// EQW_ResyncHandler: 重连（deskinfo）与开局（StartWar）
+///////////////////////////////////////////////////////////////
+// 前端 04 §3：重连 = 重画。断线重连与硬刷新本质相同，复用同一条路径：
+//   填 GameState → emit EQW_RESYNC_ALL → 各组件据数据重建界面
+// 【绝不为重连单写一套渲染】。
+//
+// deskinfo 按 step 只带对应阶段的分组（协议文末）：
+//   恒有 count / idx / PlayerInfo / step / MyCards
+//   CallRun(step1) ChooseMain(step2) BuryCards(step3) PushCards(step5) Balance(step6)
+//
+// 【重连不重放一次性事件】：70 分坐庄的 3 秒开底是上庄时的一次性事件，
+// deskinfo 里没有 ancard3s，前端也不得补播。
+var EQW_ResyncHandler = EQW_ResyncHandler || {
+
+    //平台房间信息（roomcode / 总局数 / roomtype 位串）
+    handleSetRoomDes: function (roomcode, asetcount, roomtype) {
+        if (typeof asetcount === 'number') { EQW_GameState.room.asetCount = asetcount; }
+        EQW_GameState.room.options = EQW_RoomOptions_Parse.parse(roomtype);
+    },
+
+    //开局：makewar 可能差异化下发（sendtype:1 + seatlist[]），先取自己那份
+    handleStartWar: function (msg) {
+        if (!msg || !msg.data) {
+            console.warn('[EQW_ResyncHandler] StartWar 无数据，已忽略');
+            return;
+        }
+        var raw = msg.data.deskwar || msg.data;
+        var mine = raw;
+        if (raw && raw.sendtype === 1 && Object.prototype.toString.call(raw.seatlist) === '[object Array]') {
+            mine = null;
+            for (var i = 0; i < raw.seatlist.length; i++) {
+                if (raw.seatlist[i] && raw.seatlist[i].seat === EQW_GameState.room.mySeat) {
+                    mine = raw.seatlist[i].data;
+                    break;
+                }
+            }
+            if (!mine) {
+                console.error('[EQW_ResyncHandler] StartWar 差异化下发里没有本座位的数据');
+                return;
+            }
+        }
+        this.handleDeskinfo(mine);
+    },
+
+    //重连：deskinfo 全量快照
+    handleDeskinfo: function (info) {
+        if (!info) {
+            console.warn('[EQW_ResyncHandler] deskinfo 为空，已忽略');
+            return;
+        }
+
+        EQW_GameState.reset();
+
+        //—— 恒有的部分 ——
+        EQW_GameState._apply(EQW_GameState.room, info, {
+            asetCount:    'count',
+            asetIdx:      'idx',
+            playerScores: 'PlayerInfo'
+        });
+        EQW_GameState._apply(EQW_GameState.aset, info, { step: 'step' });
+        EQW_GameState._apply(EQW_GameState.my, info, { cards: 'MyCards' });
+
+        //—— 按阶段分组 ——
+        if (info.CallRun)    { this._applyCallRun(info.CallRun); }
+        if (info.ChooseMain) { this._applyChooseMain(info.ChooseMain); }
+        if (info.BuryCards)  { this._applyBuryCards(info.BuryCards); }
+        if (info.PushCards)  { this._applyPushCards(info.PushCards); }
+        if (info.Balance)    { this._applyBalance(info.Balance); }
+
+        EventBus.emit(EQW_Events.EQW_RESYNC_ALL);
+    },
+
+    _applyCallRun: function (g) {
+        EQW_GameState._apply(EQW_GameState.call, g, {
+            currcall: 'nowcall',
+            calls:    'call'
+        });
+        EQW_GameState._apply(EQW_GameState.aset, g, { multiple: 'multiple' });
+        EQW_GameState._apply(EQW_GameState.turn, g, {
+            seat:      'seat',
+            countdown: 'countdown'
+        });
+    },
+
+    _applyChooseMain: function (g) {
+        EQW_GameState._apply(EQW_GameState.aset, g, {
+            banker:   'banker',
+            call:     'call',
+            multiple: 'multiple',
+            touxiang: 'touxiang'
+        });
+        EQW_GameState._apply(EQW_GameState.my, g, { bottomCards: 'bottomcards' });
+        EQW_GameState._apply(EQW_GameState.turn, g, { countdown: 'countdown' });
+        EQW_GameState.turn.seat = EQW_GameState.aset.banker;   //选主由庄家做
+    },
+
+    _applyBuryCards: function (g) {
+        EQW_GameState._apply(EQW_GameState.aset, g, {
+            banker:   'banker',
+            call:     'call',
+            multiple: 'multiple',
+            flower:   'flower'
+        });
+        EQW_GameState._apply(EQW_GameState.my, g, { bottomCards: 'bottomcards' });
+        EQW_GameState._apply(EQW_GameState.turn, g, { countdown: 'countdown' });
+        EQW_GameState.turn.seat = EQW_GameState.aset.banker;   //埋牌由庄家做
+    },
+
+    _applyPushCards: function (g) {
+        EQW_GameState._apply(EQW_GameState.aset, g, {
+            banker:      'banker',
+            call:        'call',
+            multiple:    'multiple',
+            flower:      'flower',
+            grade:       'grade',
+            curmultiple: 'curmultiple'
+        });
+        EQW_GameState._apply(EQW_GameState.my, g, {
+            buryCards: 'burycards',
+            mustCard:  'mustcard'
+        });
+        EQW_GameState._apply(EQW_GameState.table, g, {
+            playproc: 'playproc',
+            pushlist: 'pushlist',
+            seatlist: 'seatlist',
+            liangpai: 'liangpai'
+        });
+        EQW_GameState._apply(EQW_GameState.turn, g, { countdown: 'countdown' });
+        //当前该谁出牌由 playproc.currseat 给出（服务端权威，前端不推导）
+        if (g.playproc && typeof g.playproc.currseat === 'number') {
+            EQW_GameState.turn.seat = g.playproc.currseat;
+        }
+    },
+
+    _applyBalance: function (g) {
+        EQW_GameState._apply(EQW_GameState.result, g, { aset: 'aset' });
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_resync.js`
+Expected: 全 PASS。
+
+- [ ] **Step 5: 在 `Dispatcher.js` 末尾注册全部 rpc**
+
+在文件末尾（对象字面量之后）追加：
+
+```js
+//—— 路由表：一 rpc 一处理器（协议里每个服务端推送都要在这里注册）——
+//新增一种推送 = 加一条注册 + 写对应 handler；本文件不写业务。
+EQW_Dispatcher.register('fapai',       function (d) { EQW_DealHandler.handle(d); });
+EQW_Dispatcher.register('jiaofen',     function (d) { EQW_CallHandler.handleJiaofen(d); });
+EQW_Dispatcher.register('shangzhuang', function (d) { EQW_CallHandler.handleShangzhuang(d); });
+EQW_Dispatcher.register('xuanzhu',     function (d) { EQW_MainHandler.handleXuanzhu(d); });
+EQW_Dispatcher.register('maipai',      function (d) { EQW_BuryHandler.handle(d); });
+EQW_Dispatcher.register('chupai1',     function (d) { EQW_PlayHandler.handle(d, 1); });
+EQW_Dispatcher.register('chupai2',     function (d) { EQW_PlayHandler.handle(d, 2); });
+EQW_Dispatcher.register('chupai3',     function (d) { EQW_PlayHandler.handle(d, 3); });
+EQW_Dispatcher.register('mingpai',     function (d) { EQW_QueryHandler.handleMingpai(d); });
+EQW_Dispatcher.register('tishi',       function (d) { EQW_QueryHandler.handleTishi(d); });
+EQW_Dispatcher.register('jiesuan',     function (d) { EQW_ResultHandler.handleJiesuan(d); });
+EQW_Dispatcher.register('zhunbei',     function (d) { EQW_ReadyHandler.handle(d); });
+```
+
+**注意加载顺序**：`Dispatcher.js` 现在依赖全部 handler 存在，所以在 `index.html` 里必须**排在 handlers 之后**（Task 12 处理）。测试里也要先 load 全部 handler 再 load `Dispatcher.js`。
+
+- [ ] **Step 6: 放开 `test_dispatcher.js` 里的路由表完整性断言**
+
+把 Task 4 Step 1 里临时注释掉的那组取消注释，并在文件顶部补上全部 handler 的 `load`（顺序：state → handlers → Dispatcher）。
+
+Run: `node client/tests/test_dispatcher.js`
+Expected: 全 PASS，包括 12 条「已注册 handler」。
+
+- [ ] **Step 7: 跑全部测试**
+
+Run: `node client/tests/run.js`
+Expected: 全绿。
+
+- [ ] **Step 8: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/net/handlers/ResyncHandler.js client/js/01_SubGame/codes/net/Dispatcher.js client/tests/test_resync.js client/tests/test_dispatcher.js
+git commit -F - <<'EOF'
+二七王：重连与开局 handler，路由表注册齐全
+
+重连即重画：断线重连与硬刷新复用同一条路径（填 GameState → emit RESYNC_ALL），
+不为重连单写一套渲染。deskinfo 按 step 分组填充，重连不重放 70 分开底那类
+一次性事件。StartWar 支持差异化下发，按本座位取自己那份。
+
+路由表 12 条注册齐全，test_dispatcher 的完整性断言随之转绿——
+漏接一个包就会红。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 11: 服务端真包夹具
+
+**Files:**
+- Create: `client/tests/fixtures/export_packets.js`（导出脚本）
+- Create: `client/tests/fixtures/packets.json`（脚本产物，提交进仓库）
+- Test: `client/tests/test_fixture.js`
+
+**Interfaces:**
+- Produces: `client/tests/fixtures/packets.json`，结构：
+
+```
+{
+  roomtype: "00000",                      // 本局的 roomtype 位串（Task 12 用它还原房间选项）
+  seats: [ [ {rpc, data}, ... ] ×3 ],     // 每个座位按时序收到的下发包
+  deskinfo: [                             // 若干快照点
+    { step: 5,                            //   该时点的阶段
+      seat: 0,                            //   取的是哪个座位的 deskinfo
+      packetIndex: 7,                     //   【关键】对应 seats[seat] 的前 N 个包
+      info: { ... } }                     //   get_deskinfo 的返回值
+  ]
+}
+```
+
+**`packetIndex` 是一致性测试的锚点**：它表示「喂完 `seats[seat]` 的前 `packetIndex` 个包」与「此刻的 `info`」是**同一时点**。取快照时必须记下当前已发包数，否则 Task 12 无从对齐两条路径。
+
+> **不手写假包。** 服务端 `server/games/erqiwang/test/_rpc.js` 是现成的 L3 脚手架：它装配 `mod.js`、把 `SendPack`/`sendpack_toother` 全指向同一个 `sent` 数组，**逐个快照真实的下发包**。
+> 用它跑一局，把 `sent` 导出成 JSON 给前端回放——这样测的是**真实契约**，而不是我对协议文档的理解。文档写错或理解偏差都会在这里暴露。
+
+- [ ] **Step 1: 读懂服务端脚手架**
+
+打开 `server/games/erqiwang/test/_rpc.js`，读 `setup()` 的签名与返回值（`{ sent, o_room }` 之类），以及 `server/games/erqiwang/test/test_rpc.js` 里它是怎么被用来跑一局的。**照它的用法**写导出脚本，不要另起炉灶。
+
+同时确认 `sent` 数组里每一项的结构——它可能是 `{seat, rpc, data}` 或嵌套形式，导出脚本要按实际结构取值。
+
+- [ ] **Step 2: 写导出脚本 `client/tests/fixtures/export_packets.js`**
+
+用 `_rpc.js` 的 `setup()` 跑一局完整流程（发牌 → 叫分 → 上庄 → 选主 → 埋牌 → 若干轮出牌 → 结算），把每一步的下发包按座位收集，并在若干关键时刻额外调 `youle_erqiwang.export.get_deskinfo(o_room, seat)` 取全量快照，一起写进 `packets.json`。
+
+要点：
+- **按座位分开存**：下发是差异化的（`cardsinhand` 只给出牌者、`mustcard` 只给 `nextseat`、`bottomcards` 只给庄家），必须保留这个差异，否则测不出「缺字段不兜底」。
+- **同时存 `deskinfo`**：在每个阶段各取一次（step 1/2/3/5/6），供 Task 12 的一致性测试用。**取快照时必须记下该座位当前已收到的包数，写进 `packetIndex`**——它是两条路径的对齐锚点，缺了它 Task 12 无从比对。
+- **记下 `roomtype`**：Task 12 要用它还原房间选项。
+- 输出用 `JSON.stringify(obj, null, 2)` 便于 review diff。
+- 脚本用 `node client/tests/fixtures/export_packets.js` 运行，**产物提交进仓库**（这样前端测试不依赖服务端环境）。
+
+- [ ] **Step 3: 运行导出，检查产物**
+
+Run: `node client/tests/fixtures/export_packets.js`
+Expected: 生成 `client/tests/fixtures/packets.json`。
+
+打开产物人工核对：包序列是否覆盖了 `fapai` / `jiaofen` / `shangzhuang` / `xuanzhu` / `maipai` / `chupai1/2/3` / `jiesuan`；三个座位的差异是否真的存在（例如只有一个座位的 `shangzhuang` 带 `bottomcards`）。
+
+- [ ] **Step 4: 写 `client/tests/test_fixture.js` 守住夹具质量**
+
+```js
+// 夹具自检：真包必须覆盖全部阶段，且保留座位差异
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('./_load');
+const t = require('./_assert')();
+
+const fx = JSON.parse(fs.readFileSync(path.join(ROOT, 'client/tests/fixtures/packets.json'), 'utf8'));
+
+t.eq('三个座位', fx.seats.length, 3);
+
+const rpcsOf = seat => fx.seats[seat].map(p => p.rpc);
+const allRpcs = [].concat(rpcsOf(0), rpcsOf(1), rpcsOf(2));
+
+['fapai','jiaofen','shangzhuang','xuanzhu','maipai','chupai1','chupai2','chupai3','jiesuan']
+  .forEach(rpc => t.eq('夹具覆盖 ' + rpc, allRpcs.indexOf(rpc) >= 0, true));
+
+// 差异化下发确实存在：bottomcards 不该三家都有
+const withBottom = [0,1,2].filter(s =>
+    fx.seats[s].some(p => p.rpc === 'shangzhuang' && p.data.hasOwnProperty('bottomcards')));
+t.eq('底牌只发给部分座位', withBottom.length < 3, true);
+
+// deskinfo 快照覆盖多个阶段
+const steps = fx.deskinfo.map(d => d.step).filter((v, i, a) => a.indexOf(v) === i).sort();
+t.eq('deskinfo 覆盖 ≥3 个阶段', steps.length >= 3, true);
+
+// 每个包都有 success（协议 §0.1：每个下发包的 data 必带 success）
+const noSuccess = [];
+[0,1,2].forEach(s => fx.seats[s].forEach(p => {
+    if (!p.data || !p.data.hasOwnProperty('success')) { noSuccess.push(s + ':' + p.rpc); }
+}));
+t.eq('每个下发包都带 success', noSuccess, []);
+
+process.exit(t.done('fixture') ? 0 : 1);
+```
+
+- [ ] **Step 5: 运行，确认通过**
+
+Run: `node client/tests/test_fixture.js`
+Expected: 全 PASS。若「每个下发包都带 success」失败，说明**服务端有包漏了 `success`**——这是服务端红线（主动推送的 `data` 必须自带 `success`）。**报告给我，不要在前端兜底。**
+
+- [ ] **Step 6: 提交**
+
+```bash
+git add client/tests/fixtures/export_packets.js client/tests/fixtures/packets.json client/tests/test_fixture.js
+git commit -F - <<'EOF'
+二七王：前端测试的服务端真包夹具
+
+用服务端 test/_rpc.js 脚手架跑一局，把真实下发包按座位导出成 JSON 供前端回放。
+不手写假包——测的是真实契约，协议文档写错或前端理解偏差都会在这里暴露。
+
+夹具自检守住质量：覆盖全部阶段、保留座位差异（如底牌只发给部分座位）、
+每个下发包都带 success。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 12: 增量 vs 全量一致性（核心验收）
+
+**Files:**
+- Test: `client/tests/test_consistency.js`
+
+**Interfaces:**
+- Consumes: `client/tests/fixtures/packets.json`、全部 handler、`EQW_GameState`
+
+> **这是 B 阶段最重要的一条测试。** 它把前端红线「视图 = f(服务端快照)」变成可执行的断言：
+>
+> > 任意时刻丢弃 `this.data`、仅凭最近一次服务端快照重画，界面必须完全一致——做不到即"前端私存了状态"或"服务端漏发了字段"，都要修。
+>
+> 不一致意味着两件事之一，**都要修**：
+> - 前端私存了服务端不知道的状态（增量路径写了 `deskinfo` 里没有的东西）
+> - 服务端漏发了字段（`deskinfo` 缺了增量推送给过的信息）——这时**修在服务端**
+
+- [ ] **Step 1: 写测试 `client/tests/test_consistency.js`**
+
+```js
+// 【核心验收】增量累积的 GameState 必须与 deskinfo 全量重建的完全相等
+const fs = require('fs');
+const path = require('path');
+const { ROOT, load } = require('./_load');
+const t = require('./_assert')();
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/state/RoomOptions.js');
+load('client/js/01_SubGame/codes/net/handlers/DealHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/CallHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/MainHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/BuryHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/PlayHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/QueryHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/ReadyHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/ResultHandler.js');
+load('client/js/01_SubGame/codes/net/handlers/ResyncHandler.js');
+load('client/js/01_SubGame/codes/net/Dispatcher.js');
+
+const fx = JSON.parse(fs.readFileSync(path.join(ROOT, 'client/tests/fixtures/packets.json'), 'utf8'));
+
+// 这些字段是「一次性事件」或「重连不重放」的，不参与一致性比对。
+// 每加一条都必须写清理由——这个白名单是本测试唯一的松口处，滥用它等于废掉这条守卫。
+const EXCLUDE = [
+    // 70 分坐庄的 3 秒开底是上庄时的一次性事件，协议明确 deskinfo 不重放
+    'table.ancard3s',
+    // 本轮必出牌只对当前轮有效；deskinfo 仅在轮到本家时才带 mustcard
+    'my.mustCard',
+    // 结算明细来自 jiesuan 包，deskinfo 的 Balance 只在结算阶段带 aset
+    'result.chupai', 'result.bottom', 'result.account'
+];
+
+function pick(snap, exclude) {
+    const out = JSON.parse(JSON.stringify(snap));
+    exclude.forEach(p => {
+        const parts = p.split('.');
+        let o = out;
+        for (let i = 0; i < parts.length - 1; i++) { o = o && o[parts[i]]; }
+        if (o) { delete o[parts[parts.length - 1]]; }
+    });
+    return out;
+}
+
+// 对每个座位、每个 deskinfo 快照点做比对
+let compared = 0;
+fx.deskinfo.forEach(snapPoint => {
+    const seat = snapPoint.seat;
+
+    // —— 路径 A：增量累积 ——
+    EQW_GameState.reset();
+    EQW_GameState.room.mySeat = seat;
+    EQW_GameState.room.options = EQW_RoomOptions_Parse.parse(fx.roomtype);
+    fx.seats[seat].slice(0, snapPoint.packetIndex).forEach(p => {
+        EQW_Dispatcher.dispatch({ rpc: p.rpc, data: p.data });
+    });
+    const incremental = EQW_GameState.snapshot();
+
+    // —— 路径 B：deskinfo 全量重建 ——
+    EQW_GameState.reset();
+    EQW_GameState.room.mySeat = seat;
+    EQW_GameState.room.options = EQW_RoomOptions_Parse.parse(fx.roomtype);
+    EQW_ResyncHandler.handleDeskinfo(snapPoint.info);
+    const full = EQW_GameState.snapshot();
+
+    t.eq('座位' + seat + ' step' + snapPoint.step + ' 增量 == 全量',
+         pick(incremental, EXCLUDE), pick(full, EXCLUDE));
+    compared++;
+});
+
+t.eq('比对点数量 > 0', compared > 0, true);
+
+process.exit(t.done('consistency') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行**
+
+Run: `node client/tests/test_consistency.js`
+
+**这一步很可能不会一次通过。** 出现不一致时，**先判定根因再动手**：
+
+| 现象 | 根因 | 处置 |
+|---|---|---|
+| 增量有、全量没有 | 前端在增量路径写了 `deskinfo` 里没有的东西 | 改前端：那个字段不该存，或该字段确属一次性事件 → 加进 `EXCLUDE` 并写明理由 |
+| 全量有、增量没有 | 增量 handler 漏写了某字段 | 改前端 handler |
+| 两边都有但值不同 | 字段语义理解错（如累加 vs 赋值） | 对照协议文档判定谁对 |
+| `deskinfo` 缺了增量给过的信息 | **服务端漏发** | **不要在前端兜底**——记录下来报告给我，修在服务端 |
+
+**禁止**：为了让这条测试变绿而随意往 `EXCLUDE` 里加字段。每加一条都要在注释里写清「为什么这个字段本就不该在两条路径间一致」。
+
+- [ ] **Step 3: 修到通过，跑全部测试**
+
+Run: `node client/tests/run.js`
+Expected: 全绿。
+
+- [ ] **Step 4: 提交**
+
+```bash
+git add client/tests/test_consistency.js
+git commit -F - <<'EOF'
+二七王：增量 vs 全量一致性测试（B 阶段核心验收）
+
+把前端红线「视图 = f(服务端快照)」变成可执行断言：按序喂推送包累积出的
+GameState，必须与同一时点 deskinfo 全量重建的完全相等。
+
+不一致只有两种可能，都要修：前端私存了服务端不知道的状态，或服务端漏发了字段。
+EXCLUDE 白名单只收「一次性事件」与「重连不重放」两类，每条都写明理由。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## Task 13: 平台接线与加载
+
+**Files:**
+- Modify: `client/js/01_SubGame/codes/SubGameHooks.js`
+- Modify: `client/index.html`
+- Test: `client/tests/test_hooks.js`
+
+**Interfaces:**
+- Produces: `SubGameHooks._ReceiveData` / `StartWar` / `Reconnect` / `ReconnectNoMakewar` / `Free` / `setRoomDes` / `appStart` 的实现
+
+> 平台入口与去向（均已对平台代码核实）：
+> - `_ReceiveData(_msg)`——`_msg` 是**完整包** `{app, route, rpc, data}`（平台 `12_Logic.js:258` 按 route 分流，只有子游戏路由才到这里）
+> - `StartWar(_msg)`——开局，可能差异化下发
+> - `Reconnect(_deskinfo)`——断线重连的全量快照
+> - `Free(_msg)`——解散，`_msg` 即 `Desk.deskfree`，**可能为 `null`**
+> - `setRoomDes(roomcode, asetcount, roomtype)`——房间信息
+> - `appStart()`——启动编排（B 阶段只需初始化 `mySeat`；UI 初始化留给 C）
+
+- [ ] **Step 1: 写失败的测试 `client/tests/test_hooks.js`**
+
+```js
+// SubGameHooks 接线：平台入口 → 新架构
+const { load } = require('./_load');
+const t = require('./_assert')();
+
+global.window = global;   // 转发壳用 window.SubGameHooks 判定
+
+load('client/js/gameabc-framework/system/EventBus.js');
+load('client/js/gameabc-framework/system/SpriteEventController.js');
+load('client/js/01_SubGame/codes/state/Events.js');
+load('client/js/01_SubGame/codes/state/GameState.js');
+load('client/js/01_SubGame/codes/state/RoomOptions.js');
+['DealHandler','CallHandler','MainHandler','BuryHandler','PlayHandler',
+ 'QueryHandler','ReadyHandler','ResultHandler','ResyncHandler','FailHandler']
+  .forEach(h => load('client/js/01_SubGame/codes/net/handlers/' + h + '.js'));
+load('client/js/01_SubGame/codes/net/Dispatcher.js');
+load('client/js/01_SubGame/codes/SubGameHooks.js');
+
+const S = EQW_GameState;
+
+// ---- _ReceiveData：完整包 → 分发 ----
+S.reset(); S.room.mySeat = 0;
+SubGameHooks._ReceiveData({ app: 'youle', route: 'erqiwang', rpc: 'fapai',
+                            data: { success: true, asetidx: 1, asetcount: 6,
+                                    cards: [1,2], seat: 0, countdown: 15 } });
+t.eq('_ReceiveData 分发到 handler', S.my.cards, [1,2]);
+
+// ---- setRoomDes ----
+SubGameHooks.setRoomDes(123, 12, '00010');
+t.eq('setRoomDes 解析选项', S.room.options.climb, 1);
+
+// ---- Free：null 不崩 ----
+let boom = false;
+try { SubGameHooks.Free(null); } catch (e) { boom = true; }
+t.eq('Free(null) 不崩', boom, false);
+
+// ---- Reconnect ----
+S.reset(); S.room.mySeat = 1;
+SubGameHooks.Reconnect({ count: 6, idx: 3, PlayerInfo: [0,0,0], step: 1, MyCards: [5,6] });
+t.eq('Reconnect 填状态', S.my.cards, [5,6]);
+t.eq('Reconnect 填局数', S.room.asetIdx, 3);
+
+// ---- 畸形入参一律不崩 ----
+boom = false;
+try {
+    SubGameHooks._ReceiveData(null);
+    SubGameHooks._ReceiveData({});
+    SubGameHooks.StartWar(null);
+    SubGameHooks.Reconnect(null);
+    SubGameHooks.setRoomDes();
+} catch (e) { boom = true; }
+t.eq('畸形入参不崩', boom, false);
+
+process.exit(t.done('hooks') ? 0 : 1);
+```
+
+- [ ] **Step 2: 运行，确认失败**
+
+Run: `node client/tests/test_hooks.js`
+Expected: `SubGameHooks._ReceiveData is not a function`。
+
+- [ ] **Step 3: 在 `SubGameHooks.js` 里实现这些 hook**
+
+在文件里已有的事件转发（`utlmousedown`/`mouseup`/`gamemydraw` 等）之后追加。**只做解包与转交，不写业务**（前端 04 §3 红线：受限入口只接不写）：
+
+```js
+//—— 网络与对局（B 阶段接线）——
+//平台入口只解包转交，业务全在 net/ 的 handler 里。
+
+// 对局推送。_msg 是完整包 {app, route, rpc, data}
+// （平台 12_Logic.js 按 route 分流，只有子游戏路由 erqiwang 才到这里）
+SubGameHooks._ReceiveData = function (_msg) {
+    if (!_msg) { return; }
+    EQW_Dispatcher.dispatch({ rpc: _msg.rpc, data: _msg.data });
+};
+
+// 开局。可能差异化下发（sendtype:1 + seatlist[]）
+SubGameHooks.StartWar = function (_msg) {
+    EQW_ResyncHandler.handleStartWar(_msg);
+};
+
+// 断线重连：拿到 get_deskinfo 的全量快照
+SubGameHooks.Reconnect = function (_deskinfo) {
+    EQW_ResyncHandler.handleDeskinfo(_deskinfo);
+};
+
+// 重连但未开战：没有牌局数据，无需重画对局
+SubGameHooks.ReconnectNoMakewar = function () {
+    console.log('[EQW] 重连（未开战）');
+};
+
+// 解散。_msg 即 Desk.deskfree，可能为 null（首局发牌前解散）
+SubGameHooks.Free = function (_msg) {
+    EQW_ResultHandler.handleFree(_msg);
+};
+
+// 房间信息（房号 / 总局数 / roomtype 位串）
+SubGameHooks.setRoomDes = function (roomcode, asetcount, roomtype) {
+    EQW_ResyncHandler.handleSetRoomDes(roomcode, asetcount, roomtype);
+};
+
+// 启动编排。B 阶段只记下自己的座位；UI 初始化留给 C 阶段
+SubGameHooks.appStart = function () {
+    if (typeof C_Player !== 'undefined' && typeof C_Player.seat === 'number') {
+        EQW_GameState.room.mySeat = C_Player.seat;
+    }
+    if (typeof Desk !== 'undefined' && Desk.roomtype) {
+        EQW_GameState.room.options = EQW_RoomOptions_Parse.parse(Desk.roomtype);
+    }
+};
+```
+
+- [ ] **Step 4: 运行，确认通过**
+
+Run: `node client/tests/test_hooks.js`
+Expected: 全 PASS。
+
+- [ ] **Step 5: 在 `index.html` 加入 state/ 与 net/ 的加载段**
+
+在现有 `codes/ui/LayoutSolver.js` 之后、`codes/SubGameHooks.js` **之前**插入。**顺序即依赖**：
+
+```html
+<!-- 5.5 对局状态与事件 -->
+<script type="text/javascript" src="js/01_SubGame/codes/state/Events.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/state/GameState.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/state/RoomOptions.js"></script>
+<!-- 5.6 网络：handler 在前，Dispatcher 在后（它注册时要引用全部 handler） -->
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/FailHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/DealHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/CallHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/MainHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/BuryHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/PlayHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/QueryHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/ReadyHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/ResultHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/handlers/ResyncHandler.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/Dispatcher.js"></script>
+<script type="text/javascript" src="js/01_SubGame/codes/net/Rpc.js"></script>
+```
+
+- [ ] **Step 6: 验证加载顺序**
+
+写一个临时脚本（放 `/tmp`，**不提交**），按 `index.html` 里 script 标签的实际顺序用 `vm.runInThisContext` 依次加载 `codes/` 下全部文件（框架依赖 `EventBus.js`、`AlignmentUtils.js`、`SpriteEventController.js` 也要按其在 index.html 中的位置先加载），确认：
+
+- 加载过程无异常抛出（顺序错了会因引用未定义的全局而报错）
+- 这些全局全部就绪：`EQW_Events`、`EQW_GameState`、`EQW_RoomOptions_Parse`、`EQW_Dispatcher`、`EQW_Rpc`、以及 10 个 handler
+- `EQW_Dispatcher.hasHandler('chupai1')` 为 `true`（证明注册确实跑了）
+
+把输出贴进报告。
+
+- [ ] **Step 7: 跑两套测试**
+
+Run: `node client/tests/run.js && node server/games/erqiwang/test/run.js`
+Expected: 两边全绿。
+
+- [ ] **Step 8: 提交**
+
+```bash
+git add client/js/01_SubGame/codes/SubGameHooks.js client/index.html client/tests/test_hooks.js
+git commit -F - <<'EOF'
+二七王：平台接线与加载段
+
+SubGameHooks 只解包转交、不写业务：_ReceiveData 收到的是完整包，
+按 rpc 分发；Free 的参数是平台已取出的 deskfree、可能为 null；
+appStart 只记座位与房间选项，UI 初始化留给 C 阶段。
+
+index.html 里 handler 排在 Dispatcher 之前——后者注册时要引用全部 handler。
+
+Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
+EOF
+```
+
+---
+
+## 完成检查
+
+全部任务做完后逐条核对：
+
+- [ ] `node client/tests/run.js` 全绿（新增 10 个测试文件）
+- [ ] `node server/games/erqiwang/test/run.js` 全绿（B 不该动服务端）
+- [ ] **增量 vs 全量一致性测试通过**，`EXCLUDE` 里每条都有书面理由
+- [ ] 发包测试确认字段集合不含任何结论字段
+- [ ] 路由表覆盖协议里全部 12 个服务端推送 rpc
+- [ ] `handlers/` 下无任何一处引用 UI 组件（`grep -rn "View\|Sprite" codes/net/` 应只命中注释）
+- [ ] 三个平台契约转发壳一字未动（`git diff --name-only` 无 `01_SubGame/0*.js`）
+- [ ] 提交全部通过 `.githooks/pre-commit` 的红线闸（严格 ES5、可编辑范围）
+- [ ] 浏览器打开 `client/index.html` 控制台无报错（人工执行）