linkchat-extension-spire 0.1.7 → 0.1.9

package/README.md

@@ -1,16 +1,16 @@
-# Spire for LinkChat — 0.1.7
+# Spire for LinkChat — 0.1.9
 
-按需安装的频道合作卡牌爬塔 TUI。需要支持扩展 API 1 的 LinkChatCLI **0.7.0-beta.2 及以上**（旧宿主只支持键盘，见下），以及管理员安装并启用 `linkchat-spire` 后端包；后端规则版本 `spire-tui-2`、内容版本 `0.1.0-alpha.2.dev17`，存档版本不一致时明确拒绝加载，不会静默升级进行中的局。
+按需安装的频道合作卡牌爬塔 TUI。需要支持扩展 API 1 的 LinkChatCLI **0.7.0-beta.2 及以上**（旧宿主只支持键盘）；路线图与目标的颜色要 **0.7.3 及以上**，更旧的宿主会把颜色剥离，以及管理员安装并启用 `linkchat-spire` 后端包；后端规则版本 `spire-tui-2`、内容版本 `0.1.0-alpha.2.dev17`，存档版本不一致时明确拒绝加载，不会静默升级进行中的局。
 
-离线包安装：`linkchat extension install spire --from /绝对路径/linkchat-extension-spire-0.1.7.tgz`；省略 `--from` 时从官方 registry 安装 `linkchat-extension-spire@latest`。安装后重新打开 LinkChat，输入 `/spire`。2–4 人同频道创建或加入房间，各自准备后开始。断线或退出会暂停整局；所有人重新准备后继续。
+离线包安装：`linkchat extension install spire --from /绝对路径/linkchat-extension-spire-0.1.9.tgz`；省略 `--from` 时从官方 registry 安装 `linkchat-extension-spire@latest`。安装后重新打开 LinkChat，输入 `/spire`。2–4 人同频道创建或加入房间，各自准备后开始。断线或退出会暂停整局；所有人重新准备后继续。
 
 ## 操作
 
-**战斗**：我方在左、敌人在右（宽度不足 100 列或高度不足 30 行时改为上下分区）；每个信息块自上而下是意图、名称、格挡与血条、生命、增益、减益，多个意图字段会换行而不是被截断。手牌竖排并编号 1–9、0：数字键只把光标移到该位置，Enter 才是执行；每页最多十项，PgUp/PgDn 翻页，方向键跨页时页码同步。能量右侧是固定的 `[E 结束回合]` 按钮，和 E 键共用同一套校验，按钮会显示 `[已结束回合]` 或 `[等待队友]`。
+**战斗**：我方在左、敌人在右（默认 80×25 终端使用紧凑双栏，队友在左、敌人在右；有效宽度不足 68 列或高度不足 24 行时改为上下分区）；每个信息块自上而下是意图、名称、格挡与血条、生命、增益、减益，多个意图字段会换行而不是被截断。手牌竖排并编号 1–9、0：数字键只把光标移到该位置，Enter 才是执行；每页最多十项，PgUp/PgDn 翻页，方向键跨页时页码同步。能量右侧是固定的 `[E 结束回合]` 按钮，和 E 键共用同一套校验，按钮会显示 `[已结束回合]` 或 `[等待队友]`。
 
 **选择单体目标**：不再弹出目标名单。使用需要目标的牌或药水后，合法目标会加上边框，直接用键鼠选中战场上的那个实体（名称、血条、状态都属于同一目标）：左右键循环、Enter 或单击提交、Esc 取消本地未提交的操作且不消耗任何东西。目标死亡、牌被消耗或阶段变化时会重新校验，点击不会因为列表重排落到别的身份上。战斗之外使用单体药水时仍给出目标列表。
 
-**地图**：按后端给出的真实节点与连线绘制，`●` 当前位置、`✓` 已走过、带编号的是可前往的房间、灰色为暂不可达。悬停或点击只查看房间类型与真实后继，未知房间始终显示为未知；点击可达节点只是高亮，Enter 或"确认前往"才提交路线投票（多人提交的是本人一票）。`[回到当前位置 C]`、`[查看全图 F]` 可点，滚轮查看地图其余部分。
+**地图**：开局先确认当前角色或选择其他角色，再显示路线。M 打开／关闭地图，战斗中查看地图不会提交路线投票。普通视图按真实七列格位纵向分层，起点在下、向上前进；每个房间保留编号（如 `05-C`）和类型。`●` 当前位置、`✓` 已走过、数字为当前可选路线；黄色强调选中房间、普通出边和目标，投票人数仍在房间名后显示。↑ 查看更高层、↓ 查看更低层，←/→ 浏览同层房间，数字键定位可选路线，Enter 对选中的可达房间提交本人路线投票；悬停只查看，单击可达房间即投票。详情显示带编号的真实后继，飞靴额外可达单独列出，不画成普通地图边。`C` 回到当前位置，`F` 切换紧凑连接表，滚轮向上查看更高层、向下查看更低层；窄屏或高度不足时自动显示连接表，每行保留来源和目标编号、类型。地图阶段不再显示底部节点列表；直接在地图选点，底部保留详情和操作提示，Tab 查看其他面板。地图视图最低支持 40 列、12 行；暂停和缺少地图数据时仍保留操作列表。未知房间始终显示为未知。
 
 **商店**：分类页签（卡牌 / 遗物 / 药水 / 删牌服务）+ 竖向商品列表 + 右侧详情（窄窗口改为列表下方的展开页）。详情显示当前实际价格、半价状态、购买后余额；买不起时显示还差多少并禁止提交，药水栏满时给出"管理药水栏"入口。选中商品后点击 `[购买]` 或按 Enter 即成交，不再二次确认。删牌服务会先给出价格，选完牌再确认费用与目标。`离开商店` 始终在列表里。`[`、`]` 切换分类。
 
@@ -18,7 +18,7 @@
 
 **宝箱**：单人时点选遗物即为一次明确的领取，客户端会在服务端确认后接着领取同一件遗物（按 reward ID 精确匹配，结果不明时不会猜）；多人保留投票、分配、领取三个阶段，投票按钮本身就是确认。
 
-**其他**：Tab 依次查看牌组、抽牌堆、弃牌堆、消耗堆、遗物、药水、状态、日志；Esc 返回或暂停退出；药水面板 D 丢弃药水；多选可用数字键定位、空格勾选、确认行提交，规则允许空选时会给出明确的取消项。请求结果不明时按 R 重试同一操作，不会重复出牌。
+**其他**：Tab 依次查看行动、牌组、遗物、药水、状态、日志，标签随窗口宽度换行；抽牌堆、消耗堆和弃牌堆仅在战斗中显示于能量栏下一行，依次位于左、中、右，点击或按 A / S / D 查看（药水面板的 D 仍为丢弃药水），Esc 返回；Esc 返回或暂停退出；药水面板 D 丢弃药水；多选可用数字键定位、空格勾选、确认行提交，规则允许空选时会给出明确的取消项。请求结果不明时按 R 重试同一操作，不会重复出牌。
 
 **鼠标**（需要客户端宿主 0.7.0 及以上）：鼠标移到某行即高亮该行（等同选中），**单击即生效**；点顶部面板名切换面板；滚轮滚动列表（地图页滚动地图），弹窗有长说明时滚轮翻页。游戏界面会接管鼠标，想在终端里选中或复制文本请按住 Shift 拖拽。旧宿主上鼠标点击不会生效。
 

package/index.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 const BASE = '/api/games/spire/rooms';
 const hpText = creature => creature.awaitingRevive ? '0（待复活）' : creature.hpDisplay === 'infinite' && creature.hp > 0 ? '∞' : `${creature.hp}/${creature.maxHp}`;
 export const phases = { lobby: '等待队友', map: '路线投票', combat: '战斗', reward: '战利品', rest: '休息', shop: '商店', event: '事件', treasure: '宝箱', actComplete: '本幕完成', ending: '结局事件', victory: '通关', defeat: '攀登结束', abandoned: '已放弃' };
-const tabs = ['action', 'deck', 'draw', 'discard', 'exhaust', 'relics', 'potions', 'status', 'log'];
+const tabs = ['action', 'deck', 'relics', 'potions', 'status', 'log'];
 const tabNames = {action:'行动',deck:'牌组',draw:'抽牌堆',discard:'弃牌堆',exhaust:'消耗堆',relics:'遗物',potions:'药水',status:'状态',log:'日志'};
 const powerNames = {strength:'力量',dexterity:'敏捷',weak:'虚弱',vulnerable:'易伤',frail:'脆弱',rage:'狂怒',thorns:'反伤',demonForm:'恶魔形态',darkEmbrace:'黑暗之拥',feelNoPain:'无惧疼痛',rupture:'撕裂',noDraw:'无法抽牌',noBlock:'无法从卡牌获得格挡',darkShackles:'黑暗枷锁',slow:'缓慢',slippery:'滑溜',paperCuts:'纸割'};
 Object.assign(powerNames, {juggling:'杂耍',aggression:'侵略',barricade:'壁垒',corruption:'腐化',colossus:'巨像',crimsonMantle:'猩红披风',cruelty:'残酷',inferno:'炼狱',juggernaut:'势不可挡',pyre:'柴堆',plating:'覆甲',unmovable:'坚如磐石',freeAttack:'免费攻击',vicious:'凶狠',tank:'坦克',guarded:'被守护',covered:'被掩护',intercept:'拦截',oneTwoPunch:'连环拳',stampede:'奔踏',calamity:'灾祸',tagTeam:'接力',knockdown:'击倒',beaconOfHope:'希望灯塔',fasten:'紧固',prepTime:'准备时间',retainHand:'保留手牌',nostalgia:'怀旧',automation:'自动化',panache:'华丽',bomb:'炸弹',rollingBoulder:'滚石',theGambit:'赌局',coordinate:'协同',blockNextTurn:'下回合格挡',setupStrike:'临时力量',vigor:'活力',artifact:'人工制品',poison:'中毒',strangle:'绞杀',freeSkill:'免费技能',drawNextTurn:'下回合抽牌',focus:'集中',temporaryFocus:'临时集中',freePower:'免费能力',energyNextTurn:'下回合能量',temporaryStrengthDown:'临时力量降低',doom:'灾厄',hang:'绞刑',debilitate:'衰弱',sicEm:'咬住',veilpiercer:'虚无免费'});
@@ -82,8 +82,6 @@ export const internalIntentKeys = {
 };
 const signed = value => `${value > 0 ? '+' : ''}${value}`;
 // --- act map (§D) -----------------------------------------------------------
-const MAP_CELL = 10;
-const FLIGHT_COLOUR = '\x1b[95m';   // a move only a WingedBoots charge allows
 function mapData(view) {
   const nodes = (view?.nodes ?? []).filter(node => node && typeof node.id === 'string');
   const byId = new Map(nodes.map(node => [node.id, node]));
@@ -122,202 +120,131 @@ const joinGlyph = directions => {
   const key = `${set.has('u') ? 'u' : ''}${set.has('d') ? 'd' : ''}${set.has('l') ? 'l' : ''}${set.has('r') ? 'r' : ''}`;
   return JOIN[key] ?? '─';
 };
-function mapLabel(view, data, node, full, options) {
-  if (full) return node.id === view.current ? '●' : data.visited.has(node.id) ? '✓' : data.reachable.has(node.id) ? '◆' : '·';
+const mapCode = node => `${String(node.row).padStart(2, '0')}-${String.fromCharCode(65 + node.col)}`;
+function mapLabel(view, data, node, options) {
   const route = mapRouteIndex(node.id, options);
-  const mark = node.id === view.current ? '● ' : data.visited.has(node.id) ? '✓ ' : '';
-  return `${mark}${route >= 0 ? route + 1 : ''}[${node.type}]`;
+  return `${node.id === view.current ? '● ' : data.visited.has(node.id) ? '✓ ' : ''}${route >= 0 ? route + 1 : ''}[${node.type}]`;
 }
-// Where can I go is the first question a map answers, so the state is a colour:
-// the position bright cyan, a room you can enter bright green, the rest grey.
-function mapPaint(view, data, node, label) {
-  const colour = node.id === view.current ? '\x1b[1;96m' : data.reachable.has(node.id) ? '\x1b[92m' : '\x1b[90m';
+function mapPaint(view, data, node, label, focus) {
+  const child = data.byId.get(focus)?.children?.includes(node.id);
+  const colour = node.id === focus || child ? '\x1b[1;93m' : node.id === view.current ? '\x1b[1;96m' : data.reachable.has(node.id) ? '\x1b[92m' : '\x1b[90m';
   return `${colour}${label}\x1b[0m`;
 }
-// A vote is a coloured digit after the room, so a party sees the tally on the map.
 function mapVotes(node, players) {
   const seats = (players ?? []).filter(player => player.vote === node.id).length;
   return seats ? { text: `\x1b[33m${seats}\x1b[0m`, width: 1 } : { text: '', width: 0 };
 }
-// One lane column per room that links forward. Two rooms whose spans overlap
-// cannot share a column; rooms whose spans are separated by a blank line can, so
-// a gap is only as wide as its busiest stretch.
-function mapLanes(data, layers, index, extra) {
-  const plans = [];
-  for (const parent of data.rows.get(layers[index]) ?? []) {
-    const kids = (data.rows.get(layers[index + 1]) ?? []).filter(child => (parent.children ?? []).includes(child.id));
-    const flights = (extra?.get(parent.id) ?? []).filter(id => !kids.some(child => child.id === id));
-    if (!kids.length && !flights.length) continue;
-    const targets = [...kids.map(kid => kid.col), ...flights.map(id => data.byId.get(id).col)].sort((left, right) => left - right);
-    plans.push({ id: parent.id, line: parent.col, kids: targets,
-                 flight: new Set(flights),
-                 owns: new Set([...kids.map(kid => kid.id), ...flights]),
-                 top: Math.min(parent.col, ...targets), bottom: Math.max(parent.col, ...targets), lane: 0 });
-  }
-  // A room at line L draws a rail along line L. A visitor whose kid lands on L
-  // must therefore sit to its right, or the visitor's rail would cross the
-  // resident's lane -- and a crossing there reads as a move that does not exist.
-  const resident = new Map(plans.map(plan => [plan.line, plan.id]));
-  const before = new Map(plans.map(plan => [plan.id, new Set()]));
-  for (const plan of plans) {
-    for (const line of plan.kids) {
-      const host = resident.get(line);
-      if (host !== undefined && host !== plan.id) before.get(plan.id).add(host);
-    }
-  }
-  const order = [];
-  const pending = new Set(plans.map(plan => plan.id));
-  while (pending.size) {
-    const next = [...pending].filter(id => before.get(id).size === 0).sort()[0];
-    if (next === undefined) break;                       // a cycle: no order removes it
-    order.push(next);
-    pending.delete(next);
-    for (const id of pending) before.get(id).delete(next);
-  }
-  for (const id of pending) order.push(id);
-  const rank = new Map(order.map((id, at) => [id, at]));
-  const placed = [];
-  for (const plan of [...plans].sort((left, right) => rank.get(left.id) - rank.get(right.id))) {
-    let column = Math.max(-1, ...[...before.get(plan.id)].map(id => placed.find(entry => entry.id === id)?.lane ?? -1)) + 1;
-    while (placed.some(entry => entry.lane === column && !(entry.bottom + 1 < plan.top || plan.bottom + 1 < entry.top))) column += 1;
-    plan.lane = column;
-    placed.push(plan);
-  }
-  return { plans, lanes: placed.length ? Math.max(...placed.map(entry => entry.lane)) + 1 : 0 };
-}
-function drawMap(view, width, session) {
-  const data = mapData(view);
-  const layers = [...data.rows.keys()].sort((left, right) => left - right);
-  const options = session?.options ?? [];
-  const full = session?.full ?? false;
-  const labels = new Map(data.nodes.map(node => [node.id, mapLabel(view, data, node, full, options)]));
-  const votes = new Map(data.nodes.map(node => [node.id, mapVotes(node, session?.players)]));
-  const side = new Map(data.nodes.map(node => [node.id, displayWidth(labels.get(node.id)) + votes.get(node.id).width]));
-  const widest = full ? Math.max(2, ...side.values()) : Math.max(6, ...side.values());
-  // §D: while a WingedBoots has charges the server accepts any room in the next
-  // layer, so those moves are drawn too — a plan must not miss a legal route.
-  const extra = new Map();
-  if (data.current) {
-    const here = data.current.row;
-    const flights = (view.reachable ?? []).filter(id => !(data.current.children ?? []).includes(id)
-      && data.byId.get(id)?.row === here + 1);
-    if (flights.length) extra.set(data.current.id, flights);
-  }
-  const gaps = [];
-  for (let index = 0; index + 1 < layers.length; index++) gaps.push(mapLanes(data, layers, index, extra));
-  const xs = [0];
-  // One column is kept for the rail itself: a room whose label is the widest
-  // still needs a dash between it and its lane, or the link starts in mid-air.
-  for (let index = 0; index + 1 < layers.length; index++) xs.push(xs[index] + widest + gaps[index].lanes + 2);
-  const roomWidth = index => Math.max(0, ...(data.rows.get(layers[index]) ?? []).map(node => side.get(node.id)));
-  const anchor = data.byId.get(session?.anchor) ?? data.current;
-  const home = Math.max(0, layers.indexOf(anchor ? anchor.row : layers[0]));
-  // Only the layers on screen take width: the hidden ones must not push the map right.
-  const fits = (start, span) => start + span - 1 < layers.length
-    && xs[start + span - 1] - xs[start] + roomWidth(start + span - 1) <= width;
-  const spanFrom = start => { let span = 1; while (fits(start, span + 1)) span += 1; return span; };
-  const widestSpan = Math.max(...layers.map((_, start) => spanFrom(start)));
-  const scroll = session?.scroll;
-  const scrolled = scroll !== undefined && scroll !== null;
-  let from = Math.max(0, Math.min(Math.max(0, layers.length - widestSpan),
-    scrolled ? scroll : Math.max(0, home - Math.floor(widestSpan / 2))));
-  let span = spanFrom(from);
-  // Following the position, it must stay in view: shift the window back when the
-  // widest span did not fit where it was centred. A deliberate scroll may leave it.
-  if (!scrolled) {
-    while (from > 0 && from + span <= home) { from -= 1; span = spanFrom(from); }
-    if (from > home) { from = home; span = spanFrom(from); }
-  }
-  const shown = index => index >= from && index < from + span;
-  const origin = xs[from];
-  const at = index => xs[index] - origin;
-  const slot = new Map(data.nodes.map(node => [node.id, node.col]));
-  const height = Math.max(0, ...slot.values()) + 1;
-  // A sparse canvas: a name, a lane and a rail may share a column, never a cell.
-  const node = new Map();
-  const rail = new Map();
-  const cellOf = (line, col) => {
-    const key = `${line}:${col}`;
-    let part = rail.get(key);
-    if (!part) { part = { line, col, v: null, vd: new Set(), h: new Map(), kid: new Map(), flight: false }; rail.set(key, part); }
-    return part;
-  };
-  const add = (line, col, owner, directions, kid, flight) => {
-    if (col < 0 || col >= width) return;                 // the window cuts the drawing
-    const part = cellOf(line, col);
-    for (const direction of directions) {
-      if (direction === 'u' || direction === 'd') { if (part.v === null) part.v = owner; part.vd.add(direction); }
-      else part.h.set(owner, (part.h.get(owner) ?? new Set()).add(direction));
-    }
-    if (kid !== undefined) part.kid.set(owner, kid);
-    if (flight) part.flight = true;
-  };
-  for (let index = 0; index < layers.length; index++) {
-    if (!shown(index)) continue;
-    for (const room of data.rows.get(layers[index]) ?? []) {
-      const label = `${mapPaint(view, data, room, labels.get(room.id))}${votes.get(room.id).text}`;
-      node.set(`${slot.get(room.id)}:${at(index)}`, { room, label, plain: labels.get(room.id) });
-    }
-  }
-  const targets = new Map();                     // parent -> the rooms it links to
-  const kidLines = new Map();                    // parent -> the lines those rooms sit on
-  for (let index = 0; index + 1 < layers.length; index++) {
-    if (!shown(index) || !shown(index + 1)) continue;
-    for (const plan of gaps[index].plans) {
-      targets.set(plan.id, plan.owns);
-      kidLines.set(plan.id, new Set(plan.kids));
-      const lane = at(index) + widest + 1 + plan.lane;
-      const begin = at(index) + side.get(plan.id);
-      for (let x = begin; x < lane; x++) add(plan.line, x, plan.id, 'lr');
-      for (let line = plan.top; line <= plan.bottom; line++) {
-        const directions = [];
-        if (line > plan.top) directions.push('u');
-        if (line < plan.bottom) directions.push('d');
-        if (line === plan.line) directions.push('l');
-        if (plan.kids.includes(line)) directions.push('r');
-        if (directions.length) add(line, lane, plan.id, directions);
+function drawMap(view, width, session = {}) {
+  const data = mapData(view), layers = [...data.rows.keys()].sort((a,b) => a-b);
+  const focus = data.byId.has(session.focus) ? session.focus : view.current;
+  const codeLabel = n => `${n.id===focus?'›':' '} ${mapCode(n)}`;
+  const labels = new Map(data.nodes.map(n => [n.id, mapLabel(view, data, n, session.options)]));
+  const cols = Math.max(6, ...data.nodes.map(n => n.col)) + 1;
+  // An 80-column terminal gives the extension 75 columns after host margins.
+  // Reserve only measured text plus a separator before falling back to a table.
+  const needed = Math.max(8, ...data.nodes.map(n => displayWidth(labels.get(n.id)) + mapVotes(n, session.players).width + 1));
+  const slot = Math.max(needed, width >= cols * 12 ? 12 : 6);
+  const unsafeGap = layers.some((layer,i)=>{
+    const rooms=data.rows.get(layer), next=data.rows.get(layers[i+1])??[];
+    const edges=rooms.flatMap(n=>(n.children??[]).map(id=>[n,data.byId.get(id)]).filter(([,kid])=>kid));
+    return edges.some(([a,b])=>b.row!==layers[i+1] || (Math.abs(a.col-b.col)>1 && rooms.length>1 && next.length>1)) ||
+      edges.some(([a,b])=>edges.some(([c,d])=>(a.col-c.col)*(b.col-d.col)<0));
+  });
+  const compact = session.full || cols * slot > width || (session.height??24)<7 || unsafeGap;
+  const blocks = [];
+  const cell = (n, col, text) => ({id:n.id, row:0, col, width:displayWidth(text), height:1});
+  const plainRow = text => ({text, cells:[], tone:'muted'});
+  for (let i=0; i<layers.length; i++) {
+    const rooms = data.rows.get(layers[i]), block = [];
+    if (compact) {
+      for (const n of rooms) {
+        const label = `${codeLabel(n)} ${labels.get(n.id)}`;
+        const kids = (n.children ?? []).map(id => data.byId.get(id)).filter(Boolean);
+        const targets=kids.length ? kids.map(k=>`${mapCode(k)}[${k.type}]`) : ['终点'];
+        let suffix='';
+        const emit=()=>block.push({text:mapPaint(view,data,n,label,focus)+mapVotes(n,session.players).text+suffix,cells:[cell(n,0,label)],tone:'text'});
+        for(const target of targets){
+          const next=`${suffix?' ·':' →'} ${target}`;
+          if(suffix && displayWidth(label+suffix+next)+mapVotes(n,session.players).width>width){emit();suffix='';}
+          suffix+=`${suffix?' ·':' →'} ${target}`;
+        }
+        emit();
       }
-      for (const line of plan.kids) {
-        const kid = (data.rows.get(layers[index + 1]) ?? []).find(room => room.col === line);
-        const flight = kid && plan.flight.has(kid.id);
-        for (let x = lane + 1; x < at(index + 1); x++) add(line, x, plan.id, 'lr', kid?.id, flight);
+    } else {
+      for (const codes of [true,false]) {
+        const pieces = rooms.map(n => {
+          const text = codes ? codeLabel(n) : labels.get(n.id);
+          return {at:n.col*slot, text:mapPaint(view,data,n,text,focus)+(codes?'':mapVotes(n,session.players).text), node:n, plain:text};
+        });
+        const placed = place(pieces,width);
+        block.push({text:placed.text,tone:'text',cells:placed.placed.map(e=>cell(e.node,e.from,e.plain))});
       }
-    }
-  }
-  const lines = [];
-  for (let line = 0; line < height; line++) {
-    const row = [];
-    for (const [key, part] of rail) {
-      if (part.line !== line) continue;
-      const directions = new Set();
-      if (part.v !== null) {
-        // A lane joins its own taps. A foreign rail crossing it is cut -- unless
-        // both lead to the same room, where the join is simply true.
-        for (const direction of part.vd) directions.add(direction);
-        // A rail crossing a lane joins it: whatever the player follows, the run
-        // stays on the room's own line, and every line on that line leads to the
-        // one room this line reaches.
-        for (const set of part.h.values()) for (const direction of set) directions.add(direction);
-      } else {
-        for (const set of part.h.values()) for (const direction of set) directions.add(direction);
+      if (i+1<layers.length) {
+        const ink = Array.from({length:3},()=>new Map());
+        const put=(y,x,dirs,owner)=>{
+          let c=ink[y].get(x); if(!c){c={dirs:new Set(),owners:new Set()};ink[y].set(x,c);}
+          for(const d of dirs)c.dirs.add(d);c.owners.add(owner);
+        };
+        const horizontal=(y,a,b,owner)=>{
+          for(let x=Math.min(a,b);x<=Math.max(a,b);x++)put(y,x,`${x>Math.min(a,b)?'l':''}${x<Math.max(a,b)?'r':''}`,owner);
+        };
+        const edges=rooms.flatMap(n=>(n.children??[]).map(id=>[n,data.byId.get(id)]).filter(([,kid])=>kid));
+        // Original noncrossing edges use separate midpoint tracks. Branches
+        // share the source row; merges share only the destination row.
+        for(const [n,kid] of edges){
+          const a=n.col*slot+2,b=kid.col*slot+2,m=Math.round((a+b)/2);
+          horizontal(0,a,m,n.id);put(0,a,'u',n.id);put(0,m,'d',n.id);
+          put(1,m,'ud',n.id);
+          horizontal(2,m,b,n.id);put(2,m,'u',n.id);put(2,b,'d',n.id);
+        }
+        for(const row of ink){
+          const pieces=[...row].map(([at,c])=>({at,text:`${c.owners.has(focus)?'\x1b[1;93m':'\x1b[90m'}${joinGlyph(c.dirs)}\x1b[0m`}));
+          block.push(plainRow(place(pieces,width).text));
+        }
       }
-      if (!directions.size) continue;
-      const glyph = joinGlyph(directions);
-      row.push({ at: part.col, text: part.flight ? `${FLIGHT_COLOUR}${glyph}\x1b[0m` : glyph });
     }
-    for (const [key, room] of node) {
-      const [on, col] = key.split(':').map(Number);
-      if (on === line) row.push({ at: col, text: room.label, node: room.room, plain: room.plain });
+    blocks.push(block);
+  }
+  const budget=Math.max(3,session.height??24);
+  const anchor=data.byId.get(session.anchor)??data.current;
+  const home=Math.max(0,layers.indexOf(anchor?.row));
+  let from=Math.max(0,Math.min(blocks.length-1,session.scroll??Math.max(0,home-1)));
+  let lines=[],span=0;
+  // Scroll offsets count from the bottom (the beginning of the act).
+  // Reverse layers, but keep same-layer rooms and wrapped targets in reading order.
+  if(compact){
+    const all=[...blocks].reverse().flat();
+    const focusId=session.anchor??anchor?.id;
+    const focusEnd=all.findLastIndex(line=>line.cells.some(c=>c.id===focusId));
+    const offset=Math.max(0,Math.min(Math.max(0,all.length-budget),session.scroll??(focusEnd>=0?all.length-focusEnd-1:0)));
+    const start=Math.max(0,all.length-budget-offset);
+    lines=all.slice(start,start+budget);
+    return {lines,from:offset,span:lines.length,total:all.length,height:lines.length,compact:true};
+  }
+  // Show the focused layer even if the preceding layer uses the whole budget.
+  if(session.scroll===undefined && from<home && blocks[from].length+2>budget)from=home;
+  for(let i=from;i<blocks.length;i++){
+    const last=i===blocks.length-1;
+    if(lines.length+blocks[i].length>budget){
+      if(lines.length+2<=budget){lines.push(...blocks[i].slice(0,2));span++;}
+      break;
     }
-    const placed = place(row.sort((left, right) => left.at - right.at), width);
-    const here = placed.placed.filter(entry => entry.node);
-    const tone = here.some(entry => entry.node.id === view.current) ? 'selected'
-      : here.some(entry => data.reachable.has(entry.node.id)) ? 'text' : 'muted';
-    lines.push({ text: placed.text, tone,
-      cells: here.map(entry => ({ id: entry.node.id, row: 0, col: entry.from, width: displayWidth(entry.plain ?? entry.text), height: 1 })) });
+    lines.push(...blocks[i]);span++;
+    if(last)break;
+  }
+  // Remove dangling connectors at the viewport boundary.
+  while(lines.length && !lines.at(-1).cells.length)lines.pop();
+  // Reflect the geometry vertically, including each connector's directions.
+  // Labels remain code-above-type; neither text nor ANSI escapes are mirrored.
+  const mirror={'┌':'└','└':'┌','┐':'┘','┘':'┐','┬':'┴','┴':'┬'};
+  lines.reverse();
+  for(let i=0;i<lines.length;i++){
+    if(lines[i].cells.length){
+      [lines[i],lines[i+1]]=[lines[i+1],lines[i]];
+      i++;
+    }else lines[i]={...lines[i],text:lines[i].text.replace(/[┌└┐┘┬┴]/g,ch=>mirror[ch])};
   }
-  return { lines, from, span, total: layers.length, height,
-           flight: (extra.get(data.current?.id) ?? []).length > 0 };
+  return {lines,from,span,total:layers.length,height:lines.length,compact:false};
 }
 
 // The package ships without dependencies, so the tab strip is measured here.
@@ -356,10 +283,11 @@ export function createScreen(ctx) {
   let enemyPage = 0;              // the enemy block page the battlefield is showing
   let listPage = 0;               // the 1-9/0 page of the item list
   let pageSize = 10;              // how many items a page holds at the current size
+  let mapBudget = 10;
   let mapScroll;                  // the map row the view starts at (undefined follows the anchor)
   let mapAnchor;                  // the room the viewport is parked on (a click or 回到当前位置)
   let mapFocus;                   // the node being looked at on the map, never a submitted route
-  let mapFull = false;            // §D 查看全图: every row of the act, markers only
+  let mapFull = false;            // compact adjacency overview, with room types retained
   let chain;                      // §G: the claim that follows this player's own treasure pick
   let rewardLog = new Map();      // §F reward id -> claimed / skipped; display only, never a receipt
   let rewardOpen;                 // §F the card reward whose candidates are expanded
@@ -370,7 +298,11 @@ export function createScreen(ctx) {
   const changed = () => { if (!closed && !ctx.signal.aborted) ctx.redraw(); };
   const errorText = e => e instanceof Error ? e.message : '游戏请求失败。';
   const me = () => state?.players.find(p => p.id === ctx.user.id);
-  const activeTab = () => tabs[tab];
+  let characterConfirmed=false, mapOpen, mapReturnTab=0;
+  const needsCharacterChoice=()=>!characterConfirmed && !state?.paused && ['lobby','map'].includes(state?.phase) && state?.options.some(row=>row.action?.type==='character');
+  let pileView;
+  const activeTab = () => pileView ?? tabs[tab];
+  function openPile(key) { if(state?.phase!=='combat' || modal)return; pileView=key; index=0;selected=undefined;listPage=0;changed(); }
   const logItems = () => state.log.map((entry, i) => typeof entry === 'string' ? {id:String(i),label:entry} : {id:String(entry.id),label:entry.text});
   // A phase this build cannot render stays read only, so nothing is submitted.
   const canAct = () => !!state && online && synced && !busy && !pending && !unsupported;
@@ -379,6 +311,7 @@ export function createScreen(ctx) {
     if (modal) return modal.items;
     if (!roomId) return [{ id: 'create', label: '创建合作房间（2–4 人）' }, {id:'solo',label:'单人攀登 · 开始／继续'}, ...rooms.filter(r=>r.mode!=='solo').map(r => ({ id: r.id, room: r, label: `${r.players.some(p => p.id === ctx.user.id) ? '继续' : '加入'} · ${r.players.map(p => p.name).join(' / ')} · ${r.players.length}/4 · ${phases[r.phase] ?? r.phase}${r.paused ? ' · 已暂停' : ''}${r.compatible === false ? ' · 版本不兼容' : ''}` }))];
     if (!state) return [];
+    if(needsCharacterChoice())return [{id:'keepCharacter',label:`使用当前角色：${me()?.characterName??me()?.character??'铁甲战士'}`},...state.options.filter(row=>row.action?.type==='character')];
     if (['deck','draw','discard','exhaust'].includes(activeTab())) return (state.self[activeTab()] ?? []).map(cardItem);
     if (activeTab() === 'relics') return state.self.relics.map(r => ({ id: r.id ?? r.key, label: `${r.name}：${r.description}` }));
     if (activeTab() === 'potions') return state.self.potions.map(p => ({ id: p.id, label: `${p.name}：${p.description}`, potion: p }));
@@ -427,14 +360,7 @@ export function createScreen(ctx) {
         : { id: 'rewardDone', label: state.players.length > 1 ? '奖励已结算 · 等待队友' : '奖励已结算 · 等待继续' });
       return rows;
     }
-    if (state.phase === 'map' && !state.paused && Array.isArray(state.mapView?.nodes)) {
-      // §D: the map only highlights; going there is this explicit row (or Enter
-      // on the route itself).
-      const rows = [...state.options];
-      const route = rows.find(row => row.action?.type === 'vote' && (row.id === selected || row.id === mapFocus));
-      rows.push({ id: 'mapConfirm', label: route ? `确认前往：${route.label}` : '确认前往（先选择一条路线）', action: route?.action });
-      return rows;
-    }
+    if(state.phase==='map' && !state.paused && state.mapView?.nodes?.length)return [{id:'openMap',label:'打开地图 M'}];
     return state.options;
   }
   function anchor() {
@@ -459,8 +385,11 @@ export function createScreen(ctx) {
         choiceReturn=undefined;
       }
     }
+    if (state?.mapView?.current !== s.mapView?.current || state?.act?.index !== s.act?.index) {
+      mapFocus=undefined; mapAnchor=undefined; mapScroll=undefined;
+    }
     if (state?.phaseId !== s.phaseId || state?.paused !== s.paused) {
-      modal = undefined; selected = undefined; index = 0; tab = 0;
+      modal = undefined; mapOpen=undefined; pileView=undefined; selected = undefined; index = 0; tab = 0;
       rewardLog = new Map(); rewardOpen = undefined; rewardPick = new Map(); skipQueue = []; skipKnown = new Set();
     }
     if (s.leaseId) { leaseId = s.leaseId; synced = true; }
@@ -494,7 +423,7 @@ export function createScreen(ctx) {
     serverProtocol = result.protocol; rooms = result.rooms; anchor(); loading = false;
   }
   function connect(id) {
-    connection?.close(); roomId = id; state = undefined; leaseId = undefined; synced = false; loading = true; tab = 0; selected = undefined;
+    connection?.close(); characterConfirmed=false;mapOpen=undefined; roomId = id; state = undefined; leaseId = undefined; synced = false; loading = true; tab = 0; selected = undefined;
     connection = ctx.connect(`/ws/games/spire/rooms/${id}`, accept, connected => {
       online = connected; synced = false;
       if (!connected) note = '连接中断，正在重连；操作已暂停。';
@@ -509,6 +438,7 @@ export function createScreen(ctx) {
       const envelope = { ...pending, leaseId };
       try {
         const response = await ctx.request(`${BASE}/${roomId}/actions`, 'POST', envelope);
+        if(envelope.action.type==='character'){characterConfirmed=true;mapOpen=undefined;}
         pending = undefined; note = ''; modal = undefined; accept(response);
       } catch (e) {
         // Unknown transport outcomes retain the operation id; R retries exactly
@@ -542,7 +472,7 @@ export function createScreen(ctx) {
   }
   // The keyboard branches and clicks move the same state through these, so the
   // two input paths cannot drift apart.
-  function switchTab(next) { tab = ((next % tabs.length) + tabs.length) % tabs.length; index = 0; selected = undefined; changed(); }
+  function switchTab(next) { pileView=undefined; tab = ((next % tabs.length) + tabs.length) % tabs.length; index = 0; selected = undefined; changed(); }
   function moveTo(next) { const list = items(); index = Math.max(0, Math.min(next, list.length - 1)); selected = list[index]?.id; changed(); }
   function pageDetail(delta) { modal.detailOffset = Math.max(0, (modal.detailOffset ?? 0) + delta); changed(); }
   function clickRow(id) {
@@ -713,7 +643,7 @@ export function createScreen(ctx) {
   }
 function mapHeader(width, view) {
     const left = `路线选择 · ${state?.act?.name ?? view.act?.name ?? ''}`.trim();
-    const buttons = ['[回到当前位置 C]', '[查看全图 F]'];
+    const buttons = width<70 ? ['[当前位置 C]', '[总览 F]'] : ['[回到当前位置 C]', '[紧凑总览 F]'];
     const right = buttons.join(' ');
     const head = cut(left, Math.max(8, width - displayWidth(right) - 1));
     const out = pad(head, Math.max(8, width - displayWidth(right))) + right;
@@ -725,9 +655,10 @@ function mapHeader(width, view) {
     const node = data.byId.get(mapFocus ?? view.current);
     if (!node) return '悬停或点击节点查看房间类型与真实后继。';
     const successors = (node.children ?? []).map(id => data.byId.get(id)).filter(Boolean)
-      .map(next => `[${next.type}]`).join(' ') || '无';
+      .map(next => `${mapCode(next)}[${next.type}]`).join(' ') || '无';
     const standing = node.id === view.current ? '当前位置' : data.reachable.has(node.id) ? '可前往' : data.visited.has(node.id) ? '已走过' : '暂不可达 · 仅查看';
-    return `选中：${node.type} · ${standing} · 后继：${successors}`;
+    const extra = node.id === view.current ? (view.reachable ?? []).filter(id => !(node.children ?? []).includes(id)).map(id => data.byId.get(id)).filter(Boolean).map(n => `${mapCode(n)}[${n.type}]`).join(' ') : '';
+    return `选中：${node.type} · ${standing} · ${mapCode(node)} · 后继：${successors}${extra ? ` · 飞靴额外可达：${extra}` : ''}`;
   }
   // --- shop (§E) ---------------------------------------------------------------
   const SHOP_TABS = [['card', '卡牌'], ['relic', '遗物'], ['potion', '药水'], ['removal', '删牌服务']];
@@ -942,6 +873,8 @@ function mapHeader(width, view) {
       }); return;
     }
     if (!canAct()) return;
+    if(row.id==='keepCharacter'){characterConfirmed=true;mapOpen=undefined;selected=undefined;index=0;changed();return;}
+    if(row.id==='openMap'){mapOpen=true;mapReturnTab=tab;tab=0;changed();return;}
     if (tab === 0 && row.pick) {
       const limit = state.pendingChoice?.maximum ?? state.pendingDecision?.maximum ?? 1;
       if (picked.has(row.pick)) picked.delete(row.pick);
@@ -949,7 +882,7 @@ function mapHeader(width, view) {
       else note=`最多选择 ${limit} 张牌。`;
       changed();return;
     }
-    if (tab === 0 && row.card) { cardAction(row.card); return; }
+    if (tab === 0 && !pileView && row.card) { cardAction(row.card); return; }
     if (activeTab() === 'potions' && row.potion) {
       if (state.self.potionsLocked) { note = '请先完成事件交易，当前不能使用或丢弃药水。'; changed(); return; }
       if (row.potion.usage === 'Automatic') { note = '这瓶药水会自动生效，不能主动使用。'; changed(); return; }
@@ -1076,17 +1009,38 @@ function mapHeader(width, view) {
   }
   // The drawing reads the view state and the party; this supplies both.
   const mapLines = (view, width) => drawMap(view, width,
-    { full: mapFull, scroll: mapScroll, anchor: mapAnchor, players: state?.players, options: state?.options });
+    { full: mapFull, scroll: mapScroll, anchor: mapAnchor, focus:mapFocus, height:mapBudget, players: state?.players, options: state?.options });
+  const mapNavigation = () => !modal && !targeting && !needsCharacterChoice() && tab===0 && (mapOpen??state?.phase==='map') && !state?.paused && !state.pendingChoice && !state.pendingDecision && Boolean(state.mapView?.nodes?.length);
   const screen = {
     render(width, rows) {
       columns = width; height = rows; hits = [];
       const frame = [], add = (text, tone = 'text') => frame.push({ text, tone });
       const mark = hit => hits.push({ row: frame.length, col: 0, width: Infinity, height: 1, ...hit });
-      if (width < 40 || rows < 20) { add('请扩大终端至至少 40 列、20 行。', 'title'); add('Esc 返回聊天', 'muted'); return frame; }
+      if (width < 40 || rows < (mapNavigation()?12:20)) { add(`请扩大终端至至少 40 列、${mapNavigation()?12:20} 行。`, 'title'); add('Esc 返回聊天', 'muted'); return frame; }
       const own = me();
-      const heading = state ? `${state.act ? `第 ${state.act.index + 1} 幕 ${state.act.name} · ` : ''}第 ${state.floor} 层 · ${phases[state.phase]}${state.paused ? ' · 暂停' : ''}` : `Spire · ${ctx.channel.name} · 合作房间`;
+      const heading = needsCharacterChoice() ? '选择初始角色' : state ? `${state.act ? `第 ${state.act.index + 1} 幕 ${state.act.name} · ` : ''}第 ${state.floor} 层 · ${phases[state.phase]}${state.paused ? ' · 暂停' : ''}` : `Spire · ${ctx.channel.name} · 合作房间`;
       const status = state ? `金币 ${own?.gold ?? 0} · 药水 ${(own?.potions ?? []).length}/${own?.potionCapacity ?? 3} · ${state.online?.includes(ctx.user.id) ? '已连接' : '离线'}` : '';
       add(status ? pad(cut(heading, Math.max(8, width - displayWidth(status) - 2)), width - displayWidth(status)) + status : cut(heading, width), 'title');
+      if(mapNavigation()) {
+        const view=state.mapView, head=mapHeader(width,view), headerRow=frame.length;
+        add(head.text,'muted');
+        for(const button of head.buttons) hits.push({kind:button.id,id:button.id,row:headerRow,col:button.at,width:button.width,height:1});
+        mapBudget=Math.max(3,rows-frame.length-5);
+        const drawn=mapLines(view,width);
+        for(const line of drawn.lines){
+          const row=frame.length;add(line.text,line.tone);
+          for(const cell of line.cells)hits.push({kind:'node',id:cell.id,row,col:cell.col,width:cell.width,height:1});
+        }
+        while(frame.length<rows-5)add('');
+        add(cut(`本幕${drawn.compact?'连接表':'路线'} · ${drawn.from+1}–${Math.min(drawn.total,drawn.from+drawn.span)}/${drawn.total} · ↑ 前进 · 滚轮查看`,width),'muted');
+        add(cut(mapDetailText(view,mapData(view)),width),'muted');
+        add(cut(busy?'操作处理中…':pending?note:note||(!synced?'等待服务器确认状态…':''),width),pending?'error':'muted');
+        add(cut(state.phase==='map'?'↑↓←→ 选节点 · Enter / 单击 投票 · C 定位 · F 总览':'↑↓←→ 查看节点 · 仅查看路线 · M 返回',width),'muted');
+        mark({kind:'tab',advance:true});
+        add(cut('[面板 Tab] · M 关闭地图 · 悬停查看',width),'muted');
+        hits=hits.filter(hit=>hit.row<rows);
+        return frame.slice(0,rows);
+      }
       if (unsupported) add(`此扩展版本不认识该阶段「${unsupported}」，请在更新扩展后继续（当前只读）。`, 'error');
       if (targeting) add(cut(`正在使用：${targeting.label}   ·   点击目标或 ←/→ 选择 · Enter 确认 · Esc 取消`, width), 'selected');
       if (state) {
@@ -1098,7 +1052,41 @@ function mapHeader(width, view) {
           const partyBlocks = party.map(p => allyBlock(p));
           const legalEnemy = enemy => Boolean(targeting && enemy && targeting.arena === 'enemy' && targetIds().includes(enemy.id));
           const legalAlly = id => Boolean(targeting && targeting.arena === 'ally' && targetIds().includes(id));
-          if (wideBattlefield()) {
+          if(width>=68 && rows>=24 && !wideBattlefield()) {
+            // Medium terminals keep the two teams side by side. Party members
+            // stack in the left column; enemies page independently on the right.
+            const leftWidth=Math.floor((width-3)/2),rightWidth=width-leftWidth-3;
+            const budget=Math.max(4,rows-frame.length-10);
+            const room=Math.max(2,Math.min(5,Math.floor(budget/party.length)));
+            const perPage=Math.max(1,Math.floor(budget/room));
+            const pages=Math.max(1,Math.ceil(alive.length/perPage));
+            if(chosen>=0)enemyPage=Math.floor(chosen/perPage);
+            enemyPage=Math.max(0,Math.min(pages-1,enemyPage??0));
+            const shown=alive.slice(enemyPage*perPage,(enemyPage+1)*perPage);
+            const compactBlock=(creature,arena,span)=>{
+              const name=`${arena==='ally'&&creature.id===ctx.user.id?'› ':''}${creature.name}${creature.done?' · 已结束':''}`;
+              const health=`${hpText(creature)} HP · 格挡 ${creature.block}`;
+              const intent=arena==='enemy'?intentLines(creature.intent,creature,state).join(' · '):resourcesText(creature);
+              const powers=powerEntries(creature).map(p=>p.text).join(' · ');
+              const body=[name,health];
+              if(room>=4)body.push(healthBar(creature.hp,creature.maxHp));
+              if(room>=3)body.push(intent||powers||'无额外状态');
+              if(room>=5)body.push(intent?powers:'');
+              return body.map(line=>displayWidth(line)>span-2?cut(line,span-3)+'…':line);
+            };
+            const columns=[party.map(p=>({id:String(p.id),lines:compactBlock(p,'ally',leftWidth),legal:legalAlly(String(p.id))})),
+              shown.map(e=>({id:e.id,lines:compactBlock(e,'enemy',rightWidth),legal:legalEnemy(e)}))];
+            const startRow=frame.length,rendered=[[],[]];
+            columns.forEach((entries,side)=>entries.forEach(entry=>{
+              const top=rendered[side].length;
+              const body=entry.legal?tint(entry.lines,targetTint(entry,targeting.arena),aimed(entry)):entry.lines;
+              rendered[side].push(...body);
+              while(rendered[side].length<top+room)rendered[side].push('');
+              hits.push({kind:'entity',id:entry.id,row:startRow+top,col:side?leftWidth+3:0,width:side?rightWidth:leftWidth,height:room});
+            }));
+            for(let i=0;i<Math.max(...rendered.map(c=>c.length));i++)add(pad(rendered[0][i]??'',leftWidth)+' │ '+(rendered[1][i]??''));
+            if(pages>1){mark({kind:'enemyPage',pages});add(`敌人 ${enemyPage+1}/${pages} 页 · ←/→ 或点击翻页`,'muted');}
+          } else if (wideBattlefield()) {
             // The party column is as wide as what it prints (a fixed third used to
             // cut 增益/减益 short); the enemies share what is left.
             const natural = Math.max(MIN_BLOCK - 2, ...partyBlocks.flat().map(line => displayWidth(line)));
@@ -1164,6 +1152,13 @@ function mapHeader(width, view) {
           const buttonAt = Math.max(8, width - displayWidth(button) - 1);
           if (!modal) mark({ kind: 'endTurn', id: 'endTurn', col: buttonAt, width: displayWidth(button) });
           add(pad(energy, buttonAt) + button, 'title');
+          const piles=[['draw','A','抽牌堆',state.self.draw?.length??state.self.drawCount??0],
+            ['exhaust','S','消耗堆',state.self.exhaust?.length??state.self.exhaustCount??0],
+            ['discard','D','弃牌堆',state.self.discard.length]];
+          const pileLabels=piles.map(([,key,name,count])=>width<60?`${key} ${name.slice(0,2)}(${count})`:`[${key} ${name}（${count}）]`);
+          const positions=[0,Math.floor((width-displayWidth(pileLabels[1]))/2),width-displayWidth(pileLabels[2])];
+          if(!modal)for(let i=0;i<piles.length;i++)mark({kind:'pile',id:piles[i][0],col:positions[i],width:displayWidth(pileLabels[i])});
+          add(place(pileLabels.map((text,i)=>({at:positions[i],text})),width).text,'muted');
         } else {
           add(`${state.event ?? ''}  金币 ${own?.gold ?? 0}`, 'muted');
           // §2: outside combat there is no battlefield, so the party, its health
@@ -1174,33 +1169,28 @@ function mapHeader(width, view) {
             add(cut(`${player.id === ctx.user.id ? '› ' : '  '}${player.name}${player.characterName ? ` · ${player.characterName}` : ''} ${hpText(player)} HP · 金币 ${player.gold ?? 0}${flag ? ` · ${flag}` : ''}${player.vote ? ` · 已投票 ${player.vote}` : ''}`, width), player.id === ctx.user.id ? 'selected' : 'text');
           }
           if (['event', 'ending', 'victory'].includes(state.phase) && state.eventProgress?.description) add(state.eventProgress.description, 'muted');
-          if (state.phase === 'map' && Array.isArray(state.mapView?.nodes) && state.mapView.nodes.length) {
-            // §D: the real act map, drawn from the backend's nodes and edges only.
-            const head = mapHeader(width, state.mapView);
-            const headRow = frame.length;
-            add(head.text, 'muted');
-            for (const button of head.buttons) hits.push({ kind: button.id, id: button.id, row: headRow, col: button.at, width: button.width, height: 1 });
-            const drawn = mapLines(state.mapView, width);
-            for (const line of drawn.lines) {
-              const top = frame.length;
-              add(line.text, line.tone);
-              for (const cell of line.cells) hits.push({ kind: 'node', id: cell.id, row: top, col: cell.col, width: cell.width, height: 1 });
-            }
-            if (drawn.total > drawn.span) add(`本幕 ${drawn.total} 层 · 显示第 ${drawn.from + 1}–${Math.min(drawn.total, drawn.from + drawn.span)} 层 · 滚轮查看`, 'muted');
-            // A cramped frame spends its rows on the map itself: the legend and
-            // the hint are the first things to go, never the rooms.
-            add(mapDetailText(state.mapView, mapData(state.mapView)), 'muted');
-            if (rows >= 24) add(`图例：数字 可前往 · ● 当前位置 · ✓ 已走过 · 黄色数字 已投票人数 · 点击可前往的房间即投票${drawn.flight ? ' · 洋红连线 额外可达（下一层任意房间）' : ''}`, 'muted');
-          }
+
         }
         const labels = tabs.map((key, i) => {
           const count = ['deck', 'draw', 'discard', 'exhaust'].includes(key) ? state.self[key]?.length ?? (key === 'draw' ? state.self.drawCount : key === 'exhaust' ? state.self.exhaustCount : 0) : undefined;
           const label = tabNames[key] + (count === undefined ? '' : `（${count}）`);
-          return i === tab ? `[${label}]` : label;
+          return !pileView && i === tab ? `[${label}]` : label;
         });
         const decision = state.pendingChoice ?? state.pendingDecision;
-        if (!modal && !(tab === 0 && decision)) mark(width < 100 ? { kind: 'tab', advance: true } : { kind: 'tab', spans: tabSpans(labels) });
-        add(modal?.title ?? (tab === 0 && decision ? `${decision.owner === ctx.user.id ? '' : '等待队友 · '}${decision.title}` : width < 100 ? `${labels[tab]} · Tab 切换面板` : labels.join(' · ')), 'title');
+        if(modal || (tab===0 && decision)) {
+          add(modal?.title ?? `${decision.owner===ctx.user.id?'':'等待队友 · '}${decision.title}`,'title');
+        }else {
+          let text='',spans=[];
+          const flush=()=>{mark({kind:'tab',spans});add(text,'title');text='';spans=[];};
+          for(let i=0;i<labels.length;i++){
+            const label=labels[i];
+            if(text && displayWidth(text+' · '+label)>width)flush();
+            const from=displayWidth(text)+(text?3:0);
+            text+=(text?' · ':'')+label;spans.push({tab:i,from,to:from+displayWidth(label)});
+          }
+          if(text)flush();
+          if(pileView)add(`${tabNames[pileView]} · Esc 返回 · Tab 切换面板`,'title');
+        }
         if (modal?.detail) {
           const lines = ctx.wrap(modal.detail, Math.max(1, width - 2));
           const count = Math.max(1, Math.min(6, rows - frame.length - 9));
@@ -1211,14 +1201,15 @@ function mapHeader(width, view) {
         }
       } else add('频道成员可加入 · R 刷新房间列表', 'muted');
       if (loading) add('正在加载…', 'muted');
-      const logLines = state?.phase === 'combat' && !modal && activeTab() !== 'log' ? Math.min(2, Math.max(0, rows - frame.length - 8)) : 0;
-      if (state) add('');                                          // breathing room above the list
-      anchor(); const list = items(), available = Math.max(1, rows - frame.length - 3 - (logLines ? logLines + 1 : 0));
+      const footerRows=activeTab()==='potions' && !modal ? 2 : 1;
+      const logLines = state?.phase === 'combat' && !modal && activeTab() !== 'log' ? Math.min(2, Math.max(0, rows - frame.length - footerRows - 3)) : 0;
+      if (state && state.phase!=='combat') add('');                                          // breathing room above the list
+      anchor(); const list = items(), available = Math.max(1, rows - frame.length - footerRows - 1 - (logLines ? logLines + 1 : 0));
       pageSize = available;
       const maxPage = Math.max(0, Math.ceil(list.length / available) - 1);
       listPage = Math.max(0, Math.min(maxPage, listPage));
       const start = listPage * available;
-      if (!list.length && !loading) add(state?.phase === 'combat' && !state.paused ? '没有手牌。按 E 结束回合。' : '等待队友，或按 Esc 返回聊天。', 'muted');
+      if (!list.length && !loading) add(pileView ? `${tabNames[pileView]}为空。Esc 返回战斗。` : state?.phase === 'combat' && !state.paused ? '没有手牌。按 E 结束回合。' : '等待队友，或按 Esc 返回聊天。', 'muted');
       // §E: a wide frame puts the shop's detail beside the goods; a narrow one
       // expands it below the list instead.
       const pane = state && state.phase === 'shop' && !modal && list[index]?.shop
@@ -1255,15 +1246,14 @@ function mapHeader(width, view) {
         }
       }
       if (maxPage > 0) add(`第 ${listPage + 1}/${maxPage + 1} 页 · PgUp/PgDn 翻页 · 共 ${list.length} 项`, 'muted');
-      while (frame.length < rows - 3 - (logLines ? logLines + 1 : 0)) add('');
+      while (frame.length < rows - footerRows - (logLines ? logLines + 1 : 0)) add('');
       if (logLines) {
         add('战斗日志', 'muted');
         const recent = logItems().slice(-logLines);
         for (let i = 0; i < logLines; i++) add(recent[i]?.label ?? '', 'muted');
       }
       add(busy ? '操作处理中…' : pending ? note : note || (state && !synced ? '等待服务器确认状态…' : ''), pending ? 'error' : 'muted');
-      add(roomId ? '↑↓ / 1–0 选择 · Enter 确认 · Tab 面板 · E 结束回合 · PgUp/PgDn 翻页' : '↑↓ 选择 · Enter 创建/加入 · R 刷新', 'muted');
-      add('Esc 返回 / 暂停退出 · ? 说明 · R 重试 · B 房间 · D 丢弃药水', 'muted');
+      if(activeTab()==='potions' && !modal)add('D 丢弃药水', 'muted');
       const visible = Math.min(rows, frame.length); hits = hits.filter(hit => hit.row < visible);
       return frame.slice(0, rows);
     },
@@ -1286,10 +1276,41 @@ function mapHeader(width, view) {
         if (name === 'return' || name === 'enter') { submitTarget(targeting.id); return; }
         if (value === 'e') { cancelTargeting(); return; }
       }
-      if (!modal && state?.phase === 'map' && Array.isArray(state.mapView?.nodes)) {
+      if(value==='m' && state?.mapView?.nodes?.length && !modal && !targeting && !state.paused && !needsCharacterChoice() && !state.pendingChoice && !state.pendingDecision){
+        if(mapNavigation()){mapOpen=false;tab=mapReturnTab;}
+        else{mapReturnTab=tab;tab=0;mapOpen=true;}
+        changed();return;
+      }
+      if (mapNavigation()) {
         if (value === 'c') { mapScroll = undefined; mapFocus = undefined; mapAnchor = undefined; mapFull = false; changed(); return; }
-        if (value === 'f') { mapFull = !mapFull; changed(); return; }
+        if (value === 'f') { mapFull = !mapFull; mapScroll=undefined; changed(); return; }
+        if(tab===0 && ['left','right','up','down'].includes(name)) {
+          const data=mapData(state.mapView), here=data.byId.get(mapFocus)??data.current??data.nodes[0];
+          const candidates=data.nodes.filter(n=> name==='left'? n.row===here.row&&n.col<here.col : name==='right'? n.row===here.row&&n.col>here.col : name==='up'?n.row>here.row:n.row<here.row);
+          candidates.sort((a,b)=>Math.abs(a.row-here.row)-Math.abs(b.row-here.row)||Math.abs(a.col-here.col)-Math.abs(b.col-here.col));
+          if(candidates[0]){mapFocus=candidates[0].id;mapAnchor=mapFocus;mapScroll=undefined;}
+          changed();return;
+        }
+        if(['pageup','pagedown','home','end'].includes(name)){
+          const drawn=mapLines(state.mapView,columns),max=Math.max(0,drawn.total-drawn.span);
+          mapScroll=name==='home'?max:name==='end'?0:Math.max(0,Math.min(max,(mapScroll??drawn.from)+(name==='pageup'?1:-1)*Math.max(1,drawn.span-1)));
+          changed();return;
+        }
+        if(/^[0-9]$/.test(value??'')){
+          const routes=state.options.filter(row=>row.action?.type==='vote'),at=value==='0'?9:Number(value)-1;
+          if(routes[at]){mapFocus=routes[at].action.node;mapAnchor=mapFocus;mapScroll=undefined;changed();}
+          return;
+        }
+        if(['return','enter'].includes(name)){
+          const row=state.phase==='map' && state.options.find(row=>row.action?.type==='vote' && row.action.node===(mapFocus??state.mapView.current));
+          if(row)void submit({...row.action,phaseId:state.phaseId});
+          return;
+        }
       }
+      if(mapNavigation() && ['a','s','d','e',' '].includes(value))return;
+      if(!modal && !targeting && !pileView && tab===0 && state?.phase==='combat' && ['left','right'].includes(name)){enemyPage=Math.max(0,enemyPage+(name==='right'?1:-1));changed();return;}
+      if(!modal && !targeting && state?.phase==='combat' && ['a','s','d'].includes(value) && !(value==='d' && activeTab()==='potions')){openPile({a:'draw',s:'exhaust',d:'discard'}[value]);return;}
+      if(name==='escape' && pileView && !modal){pileView=undefined;index=0;selected=undefined;changed();return;}
       if (value === ' ' && !modal && !targeting) {
         const row = items()[index];
         if (row?.pick) {
@@ -1305,14 +1326,14 @@ function mapHeader(width, view) {
       // never play a card by itself. Enter, or a click, is what acts.
       if (!modal && !targeting && /^[0-9]$/.test(value ?? '')) {
         const list = items(), at = listPage * pageSize + (value === '0' ? 9 : Number(value) - 1);
-        if (at < list.length) moveTo(at);
+        if (at < list.length) { moveTo(at); if(state?.phase==='map' && tab===0){mapFocus=list[at].action?.node;mapAnchor=mapFocus;mapScroll=undefined;} }
         return;
       }
       if (name === 'escape' || key.ctrl && ['c', 'd'].includes(name)) {
         if (modal) { selected = modal.previousSelected; index = modal.previousIndex; modal = undefined; anchor(); changed(); }
         else ctx.closeScreen(); return;
       }
-      if (columns < 38 || height < 20) return;
+      if (columns < 40 || height < (mapNavigation()?12:20)) return;
       if (value === '?' && !modal) {
         const row = items()[index];
         const lines = ctx.wrap(row?.label ?? '方向键选择，Enter 确认；全部玩家结束回合后敌人行动。退出或掉线会暂停整局。', Math.max(1, columns - 4));
@@ -1327,7 +1348,6 @@ function mapHeader(width, view) {
         void guard(async () => { connection?.close(); connection = undefined; roomId = undefined; state = undefined; modal = undefined; pending = undefined; online = synced = false; selected = 'create'; index = 0; await loadRooms(); }); return;
       }
       if (name === 'tab' && !modal && state) { switchTab(tab + (key.shift ? -1 : 1)); return; }
-      if (value === 's' && !modal && state) { switchTab(tabs.indexOf('status')); return; }
       // The key and the button share one entry point.
       if (value === 'e' && !modal && !targeting) { endTurn(); return; }
       if (name === 'space' && !modal && tab===0 && state?.pendingChoice?.maximum>1) { confirm();return; }
@@ -1351,7 +1371,7 @@ function mapHeader(width, view) {
       if (name === 'return' || name === 'enter') confirm();
     },
     mouse(event) {
-      if (columns < 38 || height < 20) return;
+      if (columns < 40 || height < (mapNavigation()?12:20)) return;
       if (event.action === 'move') {
         // Hover lights a row, or shows which target the pointer is on.
         const pointed = hitAt(event.x, event.y);
@@ -1374,11 +1394,13 @@ function mapHeader(width, view) {
           // §D: clicking a room you can travel to is the vote itself; any other
           // room is only looked at, and parks the view there.
           mapFocus = hit.id; mapAnchor = hit.id; mapScroll = undefined;
-          const row = items().find(row => row.action?.type === 'vote' && row.id === hit.id);
+          const row = state.phase==='map' && state.options.find(row => row.action?.type === 'vote' && row.action.node === hit.id);
           if (row) { void submit({ ...row.action, phaseId: state.phaseId }); return; }
           changed();
           return;
         }
+        if(hit?.kind==='enemyPage' && !targeting && !modal){enemyPage=(enemyPage+1)%hit.pages;changed();return;}
+        if (hit?.kind === 'pile') {openPile(hit.id);return;}
         if (hit?.kind === 'shopBuy') {
           const row = items()[index];
           const price = row?.shop?.price ?? 0;
@@ -1402,10 +1424,10 @@ function mapHeader(width, view) {
         // An open detail pane pages first, exactly like PgUp/PgDn do.
         if (modal?.detail) { pageDetail(step * 3); return; }
         // §D: on the map the wheel looks around the act instead of moving the cursor.
-        if (state?.phase === 'map' && Array.isArray(state.mapView?.nodes)) {
+        if (mapNavigation()) {
           const drawn = mapLines(state.mapView, columns);
-          mapScroll = Math.max(0, Math.min(Math.max(0, drawn.total - drawn.span), (mapScroll ?? drawn.from) + step));
-          mapFull = false; changed(); return;
+          mapScroll = Math.max(0, Math.min(Math.max(0, drawn.total - drawn.span), (mapScroll ?? drawn.from) - step));
+          changed(); return;
         }
         moveTo(index + step);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkchat-extension-spire",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "Optional cooperative card-climbing TUI for LinkChat",
   "license": "UNLICENSED",
@@ -22,7 +22,6 @@
     "directory": "extensions/spire"
   },
   "publishConfig": {
-    "access": "public",
-    "tag": "beta"
+    "access": "public"
   }
 }