azeroth-shell 0.1.2 → 0.3.0

package/src/cli/tuiFightPanes.mjs

@@ -2,16 +2,21 @@
 // and the loot taken so far. The log is the game's own log (tui.mjs); the meter is phonecraft's DPSMate
 // aggregator fed every tick's events; threat reads the engine's ThreatManager through the session; loot is a
 // session-long tally of what the "You receive" lines handed over. The choice sticks between fights.
-import { bold, dim, cyan, yellow, green, red, inverse, fit, vis, cut, bar, pct } from './text.mjs';
+import { bold, dim, cyan, yellow, green, red, inverse, fit, vis, cut, bar, pct, coinText } from './text.mjs';
 import { createDpsMateMeter, partyMeterSnapshot } from '../domain/bots/dpsMate.ts';
-import { moneyText } from '../domain/economy/money.ts';
+import { runPaneLines, questPaneLines, bagsPaneLines } from './tuiAutopilot.mjs';
+import { iconsOn, iconArt, iconBlank } from './iconArt.mjs';
 
 export const FIGHT_PANES = [
   { id: 'log', label: 'Log' },
   { id: 'meter', label: 'Meter' },
   { id: 'threat', label: 'Threat' },
   { id: 'loot', label: 'Loot' },
+  { id: 'run', label: 'Run' }, // the autopilot's ledger: only once a run exists
+  { id: 'quests', label: 'Quests' }, // during a run: the quests it works on
+  { id: 'bags', label: 'Bags' }, // during a run: the bags, with a cursor, so items can be used while it plays
 ];
+const panesOf = (app) => FIGHT_PANES.filter((p) => (p.id === 'run' ? app.auto || app.lastRun : p.id === 'quests' || p.id === 'bags' ? !!app.auto : true));
 // The meter's views, like a classic meter addon's modes. Each ranks the party by its own number.
 const METER_VIEWS = [
   { id: 'damage', title: 'Damage done', value: (a) => a.damage },
@@ -26,10 +31,22 @@ const meterView = (app) => METER_VIEWS.find((v) => v.id === app.meterSort) ?? ME
 
 export const fightPane = (app) => app.fightPane ?? 'log';
 
+/** The pane shows in a fight and on the autopilot's between-fight panel, so a run holds the chosen pane
+ *  instead of dropping to the log after every kill. */
+export const showsPanes = (app) => !app.stack.length && (app.auto ? !app.auto.browsing : !!app.fight);
+
+/** What Tab moves to next ("meter", "threat", "loot", "log"), for the hint line. */
+export function nextPaneId(app) {
+  const panes = panesOf(app);
+  const i = Math.max(0, panes.findIndex((p) => p.id === fightPane(app)));
+  return panes[(i + 1) % panes.length].id;
+}
+
 /** Tab / Shift-Tab in a fight: the next or previous pane. */
 export function cycleFightPane(app, dir = 1) {
-  const i = Math.max(0, FIGHT_PANES.findIndex((p) => p.id === fightPane(app)));
-  app.fightPane = FIGHT_PANES[(i + dir + FIGHT_PANES.length) % FIGHT_PANES.length].id;
+  const panes = panesOf(app);
+  const i = Math.max(0, panes.findIndex((p) => p.id === fightPane(app)));
+  app.fightPane = panes[(i + dir + panes.length) % panes.length].id;
   app.render();
 }
 
@@ -67,21 +84,23 @@ export function noteLoot(app, taken = [], copper = 0) {
 
 /** The rule between the frames and the pane. In a fight it carries the pane tabs. */
 export function fightPaneRule(app, L) {
-  if (!app.fight || app.stack.length) return dim('─'.repeat(L.W));
+  if (!showsPanes(app)) return dim('─'.repeat(L.W));
   const cur = fightPane(app);
-  const tabs = FIGHT_PANES.map((p) => (p.id === cur ? inverse(` ${p.label} `) : dim(` ${p.label} `))).join(dim('─'));
+  const tabs = panesOf(app).map((p) => (p.id === cur ? inverse(` ${p.label} `) : dim(` ${p.label} `))).join(dim('─'));
   const left = `${dim('──')}${tabs}`;
-  const right = `${dim('Tab: switch')}${dim('──')}`;
+  const folded = cur === 'log' && app.fight?.folded?.() ? dim(`log folded at ${app.fight.speed}x, - unfolds it   `) : '';
+  const right = `${folded}${dim('Tab: switch')}${dim('──')}`;
   const mid = Math.max(0, L.W - vis(left) - vis(right));
   return cut(`${left}${dim('─'.repeat(mid))}${right}`, L.W);
 }
 
 /** The pane's lines (exactly L.logH of them). */
 export function fightPaneLines(app, L) {
-  const ctl = app.fight;
-  if (!ctl || app.stack.length || fightPane(app) === 'log') return app.logLines(L);
+  if (!showsPanes(app) || fightPane(app) === 'log') return app.logLines(L);
+  const ctl = app.fight ?? app.lastFight; // between autopilot fights: the one just over
   const pane = fightPane(app);
-  const lines = pane === 'meter' ? meterLines(app, ctl, L) : pane === 'threat' ? threatLines(app, ctl, L) : lootLines(app, L);
+  const lines = pane === 'run' ? runPaneLines(app, L) : pane === 'quests' ? questPaneLines(app, L) : pane === 'bags' ? bagsPaneLines(app, L)
+    : pane === 'loot' ? lootLines(app, L) : !ctl ? [dim(' No fight yet.')] : pane === 'meter' ? meterLines(app, ctl, L) : threatLines(app, ctl, L);
   const out = lines.slice(0, L.logH).map((l) => fit(l, L.W));
   while (out.length < L.logH) out.push('');
   return out;
@@ -211,16 +230,25 @@ function threatLines(app, ctl, L) {
 function lootLines(app, L) {
   const t = app.lootTally ?? { rows: [], copper: 0 };
   const n = t.rows.reduce((a, r) => a + r.count, 0);
-  const lines = [` ${bold('Loot this sitting')} ${dim(`${n} item${n === 1 ? '' : 's'}${t.copper ? ` · ${moneyText(t.copper)}` : ''}`)}`];
+  const lines = [` ${bold('Loot this sitting')} ${dim(`${n} item${n === 1 ? '' : 's'}${t.copper ? ` · ${coinText(t.copper)}` : ''}`)}`];
   if (!t.rows.length && !t.copper) { lines.push(dim(' Nothing looted yet. Whatever you take shows up here.')); return lines; }
   const colW = Math.max(24, Math.floor((L.W - 2) / Math.max(1, Math.min(3, Math.floor(L.W / 30)))));
   const cols = Math.max(1, Math.floor((L.W - 2) / colW));
-  const cells = t.rows.map((r) => `${app.itemLabel(r.item)}${r.count > 1 ? dim(` x${r.count}`) : ''}`);
-  const rowsAvail = L.logH - 1;
+  // With icons each cell is two lines: a 4px icon down its left, the name beside the top and the count and
+  // kind beside the bottom.
+  const icons = iconsOn() && L.W >= 40;
+  const h = icons ? 2 : 1;
+  const cells = t.rows.map((r) => {
+    if (!icons) return [`${app.itemLabel(r.item)}${r.count > 1 ? dim(` x${r.count}`) : ''}`];
+    const it = app.ds.item(r.item);
+    const art = iconArt(it?.icon, 4) ?? iconBlank(4);
+    return [`${art[0]} ${app.itemLabel(r.item)}`, `${art[1]} ${dim([r.count > 1 ? `x${r.count}` : '', it?.typeName].filter(Boolean).join(' · '))}`];
+  });
+  const rowsAvail = Math.floor((L.logH - 1) / h);
   for (let i = 0; i < rowsAvail; i++) {
     const slice = cells.slice(i * cols, i * cols + cols);
     if (!slice.length) break;
-    lines.push(` ${slice.map((c) => fit(c, colW - 1)).join(' ')}`);
+    for (let k = 0; k < h; k++) lines.push(` ${slice.map((c) => fit(c[k], colW - 1)).join(' ')}`);
   }
   const shown = Math.min(cells.length, rowsAvail * cols);
   if (shown < cells.length) lines[lines.length - 1] = fit(lines[lines.length - 1], L.W - 10) + dim(`+${cells.length - shown} more`);

package/src/cli/tuiFloor.mjs

@@ -21,7 +21,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { bold, dim, yellow, green, red, cyan, fit } from './text.mjs';
 import { startFight } from './tuiFight.mjs';
-import { pullStop, restBetween } from './tuiDungeon.mjs';
+import { pullStop, restBetween, readyUp } from './tuiDungeon.mjs';
 import { prePull } from './squad.mjs';
 import { decodeNavMesh, registerNavMeshForMap, navMeshForMap } from '../domain/nav/navmesh.ts';
 import { bakeSlugForInstance } from '../world/bakeSlug.ts';
@@ -82,9 +82,13 @@ function stampTemplates(app, ents) {
 /** The floor for the current run, built on first use and kept on the app while the run lasts. */
 function floorFor(app, def) {
   const run = app.g.state.instance;
-  if (app.floor?.dungeonId === run.dungeonId) return app.floor;
-  // Bodies of stops already cleared stay dead on the rebuilt floor, with any loose kills from before.
-  const cleared = new Set(app.floorKills?.[run.dungeonId] ?? []);
+  // One floor per entry: a hearth or a taxi out never cleared app.floor, so the next run of the dungeon walked the old one.
+  const enteredAt = app.g.state.instanceEnteredAtMs ?? null;
+  if (app.floor?.dungeonId === run.dungeonId && app.floor.enteredAt === enteredAt) return app.floor;
+  // Bodies of stops already cleared stay dead on the rebuilt floor, with any loose kills from before. The kills
+  // ride on the run, not the dungeon: a fresh run of the same dungeon stood the last run's dead back up, and an
+  // event's body (the Ring of Law's champion, one guid every run) was born dead and paid out unfought.
+  const cleared = new Set(run.floorClearedGuids ?? []);
   for (const enc of def.encounters) if (isCleared(run, enc.id)) for (const gd of enc.spawnGuids ?? []) cleared.add(gd);
   const bossEntries = new Set(def.encounters.filter((e) => e.kind === 'boss' && e.creatureEntry > 0).map((e) => e.creatureEntry));
   const world = createContinuousWorld({
@@ -96,7 +100,7 @@ function floorFor(app, def) {
     skipEntry: (entry) => !bossEntries.has(entry) && isTechnicalTriggerCreature(app.ds.creature(entry)),
   });
   stampTemplates(app, world.entities);
-  const f = { dungeonId: run.dungeonId, def, world, runMs: 0, patrolIndex: new Map(), target: null, walking: false, follow: true, speed: 1, timer: null, script: null, questScanMs: -Infinity, waiting: [], eventHoldUntil: 0,
+  const f = { dungeonId: run.dungeonId, enteredAt, def, world, runMs: 0, patrolIndex: new Map(), target: null, walking: false, follow: true, speed: 1, timer: null, script: null, questScanMs: -Infinity, waiting: [], eventHoldUntil: 0,
     rng: mulberry32(((app.g.state.rngSeed ?? 1) ^ 0x9e3779b9) >>> 0) };
   f.script = scriptContext(app, f);
   app.floor = f;
@@ -158,8 +162,13 @@ function markEngaged(f, ents) {
 
 function remember(app, f, guids) {
   resolveKill(f.world, guids);
-  app.floorKills ??= {};
-  app.floorKills[f.dungeonId] = [...new Set([...(app.floorKills[f.dungeonId] ?? []), ...guids])];
+  keepKills(app, f);
+}
+
+/** The floor's dead onto the run, so a step outside keeps them and a fresh run starts without them. */
+function keepKills(app, f) {
+  const run = app.g.state.instance;
+  if (run?.dungeonId === f.dungeonId) app.g.state.instance = { ...run, floorClearedGuids: [...f.world.clearedGuids] };
 }
 
 /** One floor tick: patrols, the walk, the scripts, then what sees you. Returns true when a pull started. */
@@ -277,7 +286,7 @@ function engage(app, f, ents) {
   if (!live.length) return false;
   const fight = app.fight;
   if (!fight) return fightBodies(app, f, live);
-  if (!fight.floor) { f.waiting.push(...live); return false; }
+  if (!fight.floor || fight.ended) { f.waiting.push(...live); return false; } // a fight over (its win still on screen) takes nobody in
   let n = 0;
   for (const e of live) {
     if (fight.session.sideOfGuid?.(e.guid)) continue;
@@ -339,6 +348,7 @@ function fightBodies(app, f, ents) {
 /** The event is lost: its summoned bodies go, claimed ones stand down, and it waits a minute before it arms again. */
 function failEvent(app, f) {
   f.script.resetGauntletOnWipe();
+  keepKills(app, f); // the event's fallen came off the floor's dead; a rebuilt floor must not bring them back dead
   f.eventHoldUntil = f.runMs + EVENT_HOLD_MS;
   app.say(red('The event fails. Rest (z) before you go again; it waits a minute.'));
 }
@@ -398,6 +408,8 @@ function reopen(app) {
 export function walkTo(app, f, enc) {
   const dest = enc.origin;
   if (!dest) { app.flashMsg(`${enc.name} has no place on the floor.`); return; }
+  // Buff and drink before setting off: whatever sees you on the way pulls with no time for it.
+  readyUp(app);
   const r = setMoveOrder(f.world, dest, f.def.mapId);
   f.target = enc.id;
   f.walking = true;
@@ -407,7 +419,7 @@ export function walkTo(app, f, enc) {
 
 /** P on a stop: an event starts where it stands, anything else is pulled from here. */
 function pullFromHere(app, f, enc) {
-  if (!floorGauntletWaves(enc)) { pullStop(app, f.def, enc, { floor: true, onTick: () => stepInFight(app, f), onDone: (r) => settle(app, f, r) }); if (app.fight) app.fight.floor = f; return; }
+  if (!floorGauntletWaves(enc)) { pullStop(app, f.def, enc, { floor: true, ready: true, onTick: () => stepInFight(app, f), onDone: (r) => settle(app, f, r) }); if (app.fight) app.fight.floor = f; return; }
   const run = app.g.state.instance;
   const need = requiredFlags(enc).filter((fl) => !hasFlag(run, fl));
   if (need.length) { app.flashMsg(`${enc.name} has not been set off yet (${need.join(', ')}).`); return; }

package/src/cli/tuiGear.mjs

@@ -1,7 +1,6 @@
-// The Gear tab's lower rows: what repairs cost and where, the ammo you shoot, and the food, water and elixirs the
+// The Character tab's lower rows: what repairs cost and where, the ammo you shoot, and the food, water and elixirs the
 // game uses for you out of combat. Per-slot durability and r (repair this one) ride on the slot rows themselves.
-import { bold, dim, yellow, green, red, qualityPaint, itemText, secondsText } from './text.mjs';
-import { moneyText } from '../domain/economy/money.ts';
+import { bold, dim, yellow, green, red, qualityPaint, itemText, secondsText, coinText } from './text.mjs';
 import { equippedEntry, equippedInstance } from '../domain/items/itemInstance.ts';
 import { gearEnchantDisplayName } from '../domain/professions/gearEnchant.ts';
 import { hasDurability, maxDurability, currentDurability, repairCostSlot } from '../domain/items/durability.ts';
@@ -49,14 +48,23 @@ export function repairOne(app, slot) {
   const cost = repairCostSlot(app.ch, slot, (e) => app.ds.item(e));
   if (!cost) { app.flashMsg('That piece needs no repair.'); return; }
   const r = app.g.repairSlot(slot, q.vendorEntry ?? undefined);
-  app.result(r, r.ok ? `${q.vendorName} repairs it for ${moneyText(r.spent)}.` : '');
+  app.result(r, r.ok ? `${q.vendorName} repairs it for ${coinText(r.spent)}.` : '');
+}
+
+/** Enter on Repair all, or R on the Character tab: mend everything you wear at the repairer the quote prices against. */
+export function repairAll(app) {
+  const q = app.g.repairQuote();
+  if (!q.cost) { app.flashMsg('Nothing needs repair.'); return; }
+  if (!q.vendorName) { app.flashMsg('Nobody here repairs.'); return; }
+  const r = app.g.repairAll(q.vendorEntry ?? undefined);
+  app.result(r, r.ok ? `Repaired for ${coinText(r.spent)}.` : '');
 }
 
 export function slotRepairLines(app, slot) {
   const cost = repairCostSlot(app.ch, slot, (e) => app.ds.item(e));
   if (!cost) return [];
   const q = app.g.repairQuote();
-  return [q.vendorName ? dim(`r: repair this piece for ${moneyText(cost)} at ${q.vendorName}`) : dim(`Repairing this piece costs about ${moneyText(cost)}.`)];
+  return [q.vendorName ? dim(`r: repair this piece for ${coinText(cost)} at ${q.vendorName}`) : dim(`Repairing this piece costs about ${coinText(cost)}.`)];
 }
 
 const rangedWeapon = (app) => { const e = equippedEntry(app.ch.equipped.ranged); return e != null ? app.ds.item(e) : undefined; };
@@ -118,19 +126,14 @@ export function autoConsumablesDialog(app) {
   };
 }
 
-/** The rows under the paperdoll on the Gear tab. */
+/** The rows under the paperdoll on the Character tab. */
 export function gearExtraRows(app) {
   const rows = [H(''), H('Upkeep')];
   const q = app.g.repairQuote();
   rows.push({
-    text: `Repair all  ${q.cost ? yellow(moneyText(q.cost)) : dim('nothing to mend')}${q.cost ? dim(q.vendorName ? `  at ${q.vendorName}` : '  nobody here repairs') : ''}`,
-    detail: () => [bold('Repair'), '', q.cost ? `Mending everything you wear costs ${moneyText(q.cost)}.` : 'Everything you wear is in good shape.', q.vendorName ? dim(`Priced at ${q.vendorName}.`) : dim('A smith or general goods vendor repairs.'), '', dim('Enter: repair all   r on a slot: repair one piece')],
-    act: (a) => {
-      if (!q.cost) { a.flashMsg('Nothing needs repair.'); return; }
-      if (!q.vendorName) { a.flashMsg('Nobody here repairs.'); return; }
-      const r = a.g.repairAll(q.vendorEntry ?? undefined);
-      a.result(r, r.ok ? `Repaired for ${moneyText(r.spent)}.` : '');
-    },
+    text: `Repair all  ${q.cost ? coinText(q.cost) : dim('nothing to mend')}${q.cost ? dim(q.vendorName ? `  at ${q.vendorName}` : '  nobody here repairs') : ''}`,
+    detail: () => [bold('Repair'), '', q.cost ? `Mending everything you wear costs ${coinText(q.cost)}.` : 'Everything you wear is in good shape.', q.vendorName ? dim(`Priced at ${q.vendorName}.`) : dim('A smith or general goods vendor repairs.'), '', dim('Enter: repair all   r on a slot: repair one piece')],
+    act: (a) => repairAll(a),
   });
   const weapon = rangedWeapon(app);
   const hasAmmo = app.g.state.inventory.stacks.some((s) => isAmmoItem(app.ds.item(s.item)));

package/src/cli/tuiLoot.mjs

@@ -2,9 +2,8 @@
 // keeps the haul in `state.pendingLoot`; Enter takes one row into the bags, a takes everything that fits, Esc
 // closes it (outdoor leftovers are gone then, an opened bag item keeps its remainder). With auto-loot on (the
 // default) fights never hold their loot and this window does not open.
-import { bold, dim, yellow, green, red, qualityPaint } from './text.mjs';
+import { bold, dim, yellow, green, red, qualityPaint, coinText } from './text.mjs';
 import { itemLines } from './tuiViews.mjs';
-import { moneyText } from '../domain/economy/money.ts';
 import { formatItemName } from '../domain/items/itemDisplayName.ts';
 import { farmNext } from './tuiFight.mjs';
 import { noteLoot } from './tuiFightPanes.mjs';
@@ -32,7 +31,7 @@ export function takeAll(app) {
   if (!app.result(r)) return;
   noteLoot(app, r.taken, r.copper);
   for (const t of r.taken) app.say(`  ${yellow('You receive')} ${app.itemLabel(t.item)}${t.count > 1 ? ` x${t.count}` : ''}`);
-  if (r.copper) app.say(`  ${yellow('You loot')} ${moneyText(r.copper)}`);
+  if (r.copper) app.say(`  ${yellow('You loot')} ${coinText(r.copper)}`);
   if (r.remaining) app.say(red(`  ${r.remaining} left in there: your bags are full.`));
   if (r.emptied && app.top()?.id === 'loot') app.pop();
 }
@@ -69,14 +68,15 @@ export function lootDialog(app) {
       const rows = [{ text: `${KIND_LABEL[L.kind] ?? L.kind}: ${L.title}`, header: true }];
       if (L.copper > 0) {
         rows.push({
-          text: yellow(moneyText(L.copper)),
-          detail: () => [bold('Money'), moneyText(L.copper)],
-          act: (a2) => { const r = a2.g.takeLootMoney(); if (a2.result(r)) { noteLoot(a2, [], r.copper); a2.say(`  ${yellow('You loot')} ${moneyText(r.copper)}`); if (r.emptied) a2.pop(); } },
+          text: coinText(L.copper),
+          detail: () => [bold('Money'), coinText(L.copper)],
+          act: (a2) => { const r = a2.g.takeLootMoney(); if (a2.result(r)) { noteLoot(a2, [], r.copper); a2.say(`  ${yellow('You loot')} ${coinText(r.copper)}`); if (r.emptied) a2.pop(); } },
         });
       }
       L.rows.forEach((r, i) => {
         rows.push({
           text: `${rowName(a, r)}${r.count > 1 ? ` x${r.count}` : ''}${r.blocked ? red('  bags full') : ''}`,
+          icon: a.ds.item(r.item)?.icon, sub: dim(a.ds.item(r.item)?.typeName ?? ''),
           detail: () => itemLines(a, a.ds.item(r.item), r.blocked ? ['', red('No room in your bags for this.')] : []),
           act: (a2) => {
             const res = a2.g.takeLoot(i);

package/src/cli/tuiMap.mjs

@@ -0,0 +1,214 @@
+// The world map on the Travel tab: phonecraft's combined Azeroth terrain map (the picture every zone's
+// `mapPos` is measured on; scripts/bake-world-map.mjs) drawn in the detail pane with pins for where you
+// stand, the zone under the cursor and the route a journey takes between them. On the road the pin walks its
+// leg. Two packs, like the creature art: src/data/world-map.bin.gz as truecolour half-block cells (two map
+// pixels a row), or src/data/world-map-sixel.bin.br as the terminal's own pixels where it draws sixel
+// (sixel.mjs). No pack, no colour, or no room: no map, never an error.
+import { readFileSync } from 'node:fs';
+import { gunzipSync, brotliDecompressSync } from 'node:zlib';
+import { useColor, cyan, yellow, dim, vis } from './text.mjs';
+import { sixelImage, sixelOn, cellSize } from './sixel.mjs';
+
+const SMALL_URL = new URL('../data/world-map.bin.gz', import.meta.url);
+const SIXEL_URL = new URL('../data/world-map-sixel.bin.br', import.meta.url);
+
+// ---- the packs ----------------------------------------------------------------------------------------
+
+/** A pack as { w, h, pal, idx } (a palette index per pixel, every pixel drawn), or null. */
+function parse(buf) {
+  if (buf.toString('ascii', 0, 5) !== 'AZMAP' || buf[5] !== 1) return null;
+  const w = buf.readUInt16LE(6), h = buf.readUInt16LE(8), palLen = buf[10], palEnd = 11 + palLen * 3;
+  const idx = buf.subarray(palEnd, palEnd + w * h);
+  return idx.length === w * h ? { w, h, pal: buf.subarray(11, palEnd), idx } : null;
+}
+
+let small, big; // undefined: not read yet; null: not there
+function smallMap() {
+  if (small === undefined) { try { small = parse(gunzipSync(readFileSync(SMALL_URL))); } catch { small = null; } }
+  return small;
+}
+function sixelMap() {
+  if (big === undefined) { try { big = parse(brotliDecompressSync(readFileSync(SIXEL_URL))); } catch { big = null; } }
+  return big;
+}
+
+/** Is there a map to draw? */
+export const hasWorldMap = () => useColor && !!smallMap();
+
+/** The map area-averaged to tw x th, as packed rgb. */
+function resample(m, tw, th) {
+  const out = new Uint8Array(tw * th * 3), sx = m.w / tw, sy = m.h / th;
+  for (let ty = 0; ty < th; ty++) {
+    const y0 = Math.floor(ty * sy), y1 = Math.max(y0 + 1, Math.floor((ty + 1) * sy));
+    for (let tx = 0; tx < tw; tx++) {
+      const x0 = Math.floor(tx * sx), x1 = Math.max(x0 + 1, Math.floor((tx + 1) * sx));
+      let r = 0, g = 0, b = 0, n = 0;
+      for (let y = y0; y < y1 && y < m.h; y++) for (let x = x0; x < x1 && x < m.w; x++) {
+        const p = m.idx[y * m.w + x] * 3;
+        r += m.pal[p]; g += m.pal[p + 1]; b += m.pal[p + 2]; n++;
+      }
+      if (!n) continue;
+      const d = (ty * tw + tx) * 3;
+      out[d] = r / n; out[d + 1] = g / n; out[d + 2] = b / n;
+    }
+  }
+  return out;
+}
+
+// ---- what to pin -----------------------------------------------------------------------------------------
+
+/**
+ * The pins in map fractions (0..1 from the top-left, a zone's `mapPos`): `you`, walking its leg when a journey
+ * is under way; `dest`, the zone under the cursor (a journey's destination when none is given); `route`, the
+ * zones the trip passes after you, in order. `legs` is a travel preview's plan (or any list of { to }); a
+ * journey under way brings its own legs.
+ */
+function marks(app, dest, legs) {
+  const ds = app.ds, pos = (id) => ds.zone(id)?.mapPos ?? null;
+  const st = app.g.state.char.journey ? app.g.journeyStatus() : null;
+  let you = pos(app.ch.zoneId);
+  if (st) {
+    const i = st.progress.legIndex, leg = st.legs[i];
+    const a = leg ? pos(leg.from) : null, b = leg ? pos(leg.to) : null;
+    const t = leg?.seconds > 0 ? Math.min(1, Math.max(0, st.progress.legElapsedSeconds / leg.seconds)) : 1;
+    // Snapped to 1/250 of the map, so a tick that moves the pin under a pixel does not redraw (or re-encode) it.
+    you = a && b ? [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t].map((v) => Math.round(v * 250) / 250) : b ?? a ?? you;
+    legs = st.legs.slice(i);
+    dest ??= ds.zone(st.destination);
+  }
+  const route = [];
+  for (const l of legs ?? []) { const p = pos(l.to); if (p) route.push(p); }
+  return { you, dest: dest?.mapPos ?? null, route };
+}
+
+const at3 = (p) => (p ? `${p[0].toFixed(3)},${p[1].toFixed(3)}` : '-');
+
+// ---- half-block cells -------------------------------------------------------------------------------------
+
+const RESET = '\x1b[0m';
+const YOU = { glyph: '●', rgb: '255;210;60' }, DEST = { glyph: '◆', rgb: '90;220;255' }, ROUTE = { glyph: '·', rgb: '255;240;190' };
+
+/** The cells a straight line crosses between two cells (Bresenham), both ends included. */
+function lineCells([x0, y0], [x1, y1]) {
+  const out = [], dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0), sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+  let err = dx + dy, x = x0, y = y0;
+  for (;;) {
+    out.push([x, y]);
+    if (x === x1 && y === y1) return out;
+    const e2 = 2 * err;
+    if (e2 >= dy) { err += dy; x += sx; }
+    if (e2 <= dx) { err += dx; y += sy; }
+  }
+}
+
+/** The map as half-block lines that fit maxCols x maxRows keeping its proportions, the pins as glyphs on
+ *  their cells (the cell's own colour behind them). */
+function halfBlockLines(m, mk, maxCols, maxRows) {
+  const scale = Math.min(maxCols / m.w, (maxRows * 2) / m.h);
+  const gw = Math.max(2, Math.round(m.w * scale)), gh = Math.max(2, Math.round(m.h * scale) + 1) & ~1, rows = gh / 2;
+  const s = resample(m, gw, gh);
+  const cell = (p) => [Math.min(gw - 1, Math.floor(p[0] * gw)), Math.min(rows - 1, Math.floor(p[1] * rows))];
+  const over = new Map();
+  const pts = [mk.you, ...mk.route].filter(Boolean).map(cell);
+  for (let i = 0; i + 1 < pts.length; i++) for (const c of lineCells(pts[i], pts[i + 1])) over.set(c.join(), ROUTE);
+  if (mk.dest) over.set(cell(mk.dest).join(), DEST);
+  if (mk.you) over.set(cell(mk.you).join(), YOU);
+  const lines = [];
+  for (let y = 0; y < rows; y++) {
+    let line = '';
+    for (let x = 0; x < gw; x++) {
+      const t = (y * 2 * gw + x) * 3, u = ((y * 2 + 1) * gw + x) * 3, o = over.get(`${x},${y}`);
+      if (o) line += `\x1b[38;2;${o.rgb}m\x1b[48;2;${(s[t] + s[u]) >> 1};${(s[t + 1] + s[u + 1]) >> 1};${(s[t + 2] + s[u + 2]) >> 1}m${o.glyph}${RESET}`;
+      else line += `\x1b[38;2;${s[t]};${s[t + 1]};${s[t + 2]}m\x1b[48;2;${s[u]};${s[u + 1]};${s[u + 2]}m▀${RESET}`;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+const cache = new Map();
+const CACHE_MAX = 48;
+function remember(key, lines) {
+  if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value);
+  cache.set(key, lines);
+  return lines;
+}
+
+// ---- sixel pixels ------------------------------------------------------------------------------------------
+
+const fitted = new Map(); // `${w}|${tw}x${th}` -> the map resampled to that size, kept for the next pin move
+const FIT_MAX = 4;
+
+/** The pins painted on the fitted map: a dashed route, a cyan diamond at the destination, a gold disc on you,
+ *  each with a dark rim so it reads on any terrain. Sizes follow the picture's width. */
+function paintPixels(base, tw, th, mk) {
+  const rgba = new Uint8Array(tw * th * 4);
+  for (let i = 0; i < tw * th; i++) { rgba[i * 4] = base[i * 3]; rgba[i * 4 + 1] = base[i * 3 + 1]; rgba[i * 4 + 2] = base[i * 3 + 2]; rgba[i * 4 + 3] = 255; }
+  const put = (x, y, c) => { if (x >= 0 && y >= 0 && x < tw && y < th) { const d = (y * tw + x) * 4; rgba[d] = c[0]; rgba[d + 1] = c[1]; rgba[d + 2] = c[2]; } };
+  const disc = (cx, cy, r, c) => { for (let y = Math.floor(cy - r); y <= cy + r; y++) for (let x = Math.floor(cx - r); x <= cx + r; x++) if ((x - cx) ** 2 + (y - cy) ** 2 <= r * r) put(x, y, c); };
+  const diamond = (cx, cy, r, c) => { for (let y = Math.floor(cy - r); y <= cy + r; y++) for (let x = Math.floor(cx - r); x <= cx + r; x++) if (Math.abs(x - cx) + Math.abs(y - cy) <= r) put(x, y, c); };
+  const DARK = [24, 20, 16], r = Math.max(3, tw / 90), px = (p) => [p[0] * tw, p[1] * th];
+  const pts = [mk.you, ...mk.route].filter(Boolean).map(px);
+  const dash = r * 2.2, gap = r * 1.6;
+  for (const [rad, c] of [[r / 2.6 + 1, DARK], [r / 2.6, [255, 240, 190]]]) {
+    let along = 0;
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const [x0, y0] = pts[i], [x1, y1] = pts[i + 1], len = Math.hypot(x1 - x0, y1 - y0);
+      for (let d = 0; d <= len; d++) if ((along + d) % (dash + gap) < dash) disc(x0 + ((x1 - x0) * d) / len, y0 + ((y1 - y0) * d) / len, rad, c);
+      along += len;
+    }
+  }
+  if (mk.dest) { const [x, y] = px(mk.dest); diamond(x, y, r * 1.5 + 1.5, DARK); diamond(x, y, r * 1.5, [90, 220, 255]); }
+  if (mk.you) { const [x, y] = px(mk.you); disc(x, y, r + 1.5, DARK); disc(x, y, r, [255, 210, 60]); disc(x, y, r / 3, DARK); }
+  return rgba;
+}
+
+/** The map as sixel placeholder lines (sixel.mjs) fitted to maxCols x maxRows, or null when sixel is off. */
+function sixelLines(m, mk, key, maxCols, maxRows) {
+  if (!sixelOn()) return null;
+  const { w: cw, h: ch } = cellSize();
+  const scale = Math.min((maxCols * cw) / m.w, (maxRows * ch) / m.h);
+  const tw = Math.max(1, Math.round(m.w * scale)), th = Math.max(1, Math.round(m.h * scale));
+  return sixelImage(`map|${m.w}|${tw}x${th}|${key}`, () => {
+    const fitKey = `${m.w}|${tw}x${th}`;
+    let base = fitted.get(fitKey);
+    if (!base) {
+      if (fitted.size >= FIT_MAX) fitted.delete(fitted.keys().next().value);
+      fitted.set(fitKey, (base = resample(m, tw, th)));
+    }
+    return { w: tw, h: th, rgba: paintPixels(base, tw, th, mk) };
+  }, maxCols, maxRows);
+}
+
+// ---- the lines a pane draws ---------------------------------------------------------------------------------
+
+/**
+ * The world map for a detail pane, as lines no wider than `maxCols` and no more than `maxRows` of them (the
+ * last a legend): you pinned where you stand, `dest` (a zone) pinned if given, the `legs` of a planned trip
+ * (or the journey under way) drawn as a route. Null without colour, a pack, a position, or room.
+ */
+export function worldMapLines(app, { dest = null, legs = null, maxCols, maxRows } = {}) {
+  if (!useColor || !(maxCols >= 10) || !(maxRows >= 6)) return null;
+  const m = smallMap();
+  if (!m) return null;
+  const mk = marks(app, dest, legs);
+  if (!mk.you && !mk.dest) return null;
+  const key = [mk.you, mk.dest, ...mk.route].map(at3).join('|');
+  const rows = maxRows - 1;
+  let art = sixelLines(sixelMap() ?? m, mk, key, maxCols, rows);
+  if (!art) {
+    const ck = `${maxCols}x${rows}|${key}`;
+    art = cache.get(ck) ?? remember(ck, halfBlockLines(m, mk, maxCols, rows));
+  }
+  const legend = `${yellow(YOU.glyph)} you${mk.dest ? `  ${cyan(DEST.glyph)} destination` : ''}${mk.route.length ? dim('  ┄ route') : ''}`;
+  return [...art, legend];
+}
+
+/** `lines` with the map under them, as large as the detail pane has room for; `lines` alone when there is none. */
+export function withWorldMap(app, lines, opts = {}) {
+  const L = app.layout?.();
+  if (!L || !(L.detailW > 2)) return lines;
+  const w = L.detailW - 2, used = lines.reduce((n, l) => n + Math.max(1, Math.ceil(vis(l) / w)), 0);
+  const map = worldMapLines(app, { ...opts, maxCols: w, maxRows: L.mainH - used - 1 });
+  return map ? [...lines, '', ...map] : lines;
+}

package/src/cli/tuiPaperdoll.mjs

@@ -0,0 +1,108 @@
+// The Character tab as a sheet: you in your gear in the middle, the worn pieces' icons down both sides
+// the way the client's paperdoll lays them out (head to wrists on the left, hands to trinkets on the right,
+// the weapons and the bag bar underneath), each framed in its quality colour. Arrows move between the
+// slots (Up and Down in order, Shift+arrows across the picture), the detail pane is the piece's tooltip, and Enter, x and r act on the slot as they do in the list.
+// The rows are the gear view's own (a slot row carries `cell`); this file only places them. No colour, or a
+// window too small for the sheet, and the view lists its rows as before.
+import { canvas, drawCell, gridStep } from './iconGrid.mjs';
+import { iconsOn } from './iconArt.mjs';
+import { artWidth } from './modelArt.mjs';
+import { bold, dim, green, inverse, fit, cut, vis, qualityPaint, qualityCodes, plural } from './text.mjs';
+import { SLOT_LABEL } from '../domain/items/equipment.ts';
+
+const LEFT = ['head', 'neck', 'shoulder', 'back', 'chest', 'shirt', 'wrist'];
+const RIGHT = ['hands', 'waist', 'legs', 'feet', 'finger1', 'finger2', 'trinket1', 'trinket2'];
+const WEAPONS = ['mainhand', 'offhand', 'ranged'];
+const BAGS = ['bag1', 'bag2', 'bag3', 'bag4'];
+const SIDE = RIGHT.length;
+// What an empty slot says on its dark square (four columns at most).
+const SHORT = {
+  head: 'Head', neck: 'Neck', shoulder: 'Shld', back: 'Back', chest: 'Chst', shirt: 'Shrt', wrist: 'Wrst',
+  hands: 'Hand', waist: 'Wst', legs: 'Legs', feet: 'Feet', finger1: 'Ring', finger2: 'Ring', trinket1: 'Trk', trinket2: 'Trk',
+  mainhand: 'MH', offhand: 'OH', ranged: 'Rng', bag1: 'Bag', bag2: 'Bag', bag3: 'Bag', bag4: 'Bag',
+};
+
+/** The icon size the sheet takes in a `w` x `h` list pane and how many of the `extras` rows (repair, ammo,
+ *  outfits) fit under it, or null when it does not fit and the view should list instead. Big icons win over
+ *  the upkeep rows: R and o reach those from the keys, and the view leaves undrawn ones out of its rows. */
+function sheetSize(w, h, extras) {
+  for (const s of [6, 4]) {
+    for (const room of [extras, 0]) {
+      const need = 2 + SIDE * (s / 2) + 1 + s / 2 + (room ? 1 + room : 0);
+      if (h >= need && w >= 7 * (s + 2) + 6) return { s, extras: room };
+    }
+  }
+  return null;
+}
+
+/** Will the Character tab draw as the sheet right now? `extras` is how many rows follow the slots. */
+export function paperdollPlan(app, extras) {
+  if (!iconsOn()) return null;
+  const L = app.layout();
+  return L.detailW ? sheetSize(L.listW, L.mainH, extras) : null;
+}
+
+/**
+ * The sheet's lines for the gear view's `rows` in a `W` x `H` pane, with `body(cols, lines)` drawing the
+ * character (playerArt) and `title` heading it, plus where the arrows go; null when it does not fit. `hint`
+ * replaces the keys line (a companion's sheet has no repair or outfits).
+ */
+export function paperdollGrid(app, rows, W, H, body, title, hint) {
+  const extraRows = rows.map((r, i) => ({ r, i })).filter(({ r }) => !r.cell && !r.header);
+  const plan = iconsOn() ? sheetSize(W, H, extraRows.length) : null;
+  if (!plan) return null;
+  const { s } = plan, cw = s + 2, ch = s / 2;
+  const cur = app.top()?.cursor ?? 0;
+  const cv = canvas(W, H);
+  const pts = [];
+  const index = new Map(rows.map((r, i) => [r.cell?.slot, i]));
+  const top = 2, colH = SIDE * ch;
+
+  const ups = rows.filter((r) => r.cell?.up).length;
+  cv.text(1, 0, `${title ?? bold('Equipment')}   ${ups ? green(`▲ ${plural(ups, 'upgrade')} in your bags   u: put on all`) : dim(hint ?? `s: stats   Shift+arrows: move   Enter: change${plan.extras ? '' : '   R: repair all   o: outfits'}`)}`);
+
+  // Labels take a share of the width beside each column; the body gets the middle.
+  const lw = Math.max(0, Math.min(22, Math.floor((W - 2 * cw) * 0.28)));
+  const midX = cw + lw + 1, midW = W - 2 * cw - 2 * lw - 2;
+  const art = midW >= 6 ? body(midW, colH) : null;
+  if (art?.length) cv.art(midX + Math.floor((midW - artWidth(art)) / 2), top + Math.max(0, Math.floor((colH - art.length) / 2)), art);
+
+  const cell = (slot, x, y, px, py, side) => {
+    const i = index.get(slot);
+    if (i == null) return;
+    const c = rows[i].cell, it = c.it;
+    const sel = i === cur;
+    drawCell(cv, x, y, s, {
+      icon: it?.icon, frame: it ? qualityCodes(it.quality) : '90', selected: sel, empty: SHORT[slot],
+      mark: c.up ? { text: '▲', codes: '92' } : null,
+    });
+    pts.push({ i, x: px, y: py });
+    if (!side || lw < 4) return;
+    const name = it ? qualityPaint(it.quality)(it.name) : dim(SLOT_LABEL[slot] ?? slot);
+    const lines = [sel ? bold(name) : name, ...(ch > 2 ? [c.sub ?? '', c.dur ?? ''] : [c.dur || c.sub || ''])].slice(0, ch);
+    lines.forEach((t, k) => {
+      const text = cut(t, lw - 1);
+      cv.text(side === 'left' ? x + cw + 1 : x - 1 - vis(text), y + k, text);
+    });
+  };
+  LEFT.forEach((slot, k) => cell(slot, 0, top + k * ch, 0, k, 'left'));
+  RIGHT.forEach((slot, k) => cell(slot, W - cw, top + k * ch, 4, k, 'right'));
+
+  // Under the columns: the weapons centred under the body, the bag bar at the right edge.
+  const by = top + colH + 1;
+  const bagsX = W - BAGS.length * cw;
+  const wx = Math.max(0, Math.min(Math.round(midX + midW / 2 - 1.5 * cw), bagsX - 3 * cw - 2));
+  WEAPONS.forEach((slot, k) => cell(slot, wx + k * cw, by, 1 + k, SIDE));
+  BAGS.forEach((slot, k) => cell(slot, bagsX + k * cw, by, 5 + k, SIDE));
+
+  // Upkeep rows (repair all, ammo, outfits, auto use) under the sheet when they fit.
+  const ey = by + ch + 1;
+  extraRows.slice(0, plan.extras).forEach(({ r, i }, k) => {
+    const sel = i === cur;
+    const text = ` ${sel ? '▶' : ' '} ${r.text}`;
+    cv.text(0, ey + k, sel ? inverse(fit(text, W - 1)) : text, W - 1);
+    pts.push({ i, x: 1, y: SIDE + 1 + k });
+  });
+
+  return { lines: cv.lines(), nav: (dir, from) => gridStep(pts, from, dir, { dyW: 1, dxW: 10 }) };
+}