azeroth-shell 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azeroth-shell",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Azeroth shell. A WoW Classic 1.12 text RPG for the terminal, built on CMaNGOS data.",
   "keywords": [
@@ -12,6 +12,15 @@
     "tui",
     "cmangos"
   ],
+  "author": "Simen Lien",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LienSimen/azsh.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LienSimen/azsh/issues"
+  },
+  "homepage": "https://github.com/LienSimen/azsh#readme",
   "bin": {
     "azeroth-shell": "bin/azsh.mjs",
     "azsh": "bin/azsh.mjs"
@@ -25,6 +34,7 @@
     "node": ">=22.18"
   },
   "scripts": {
+    "test": "npm run check:all",
     "start": "node bin/azsh.mjs",
     "check": "node --import ./src/cli/register.mjs src/cli/bootCheck.mjs",
     "data:pack": "node scripts/pack-data.mjs",

package/src/cli/fileRepository.mjs

@@ -1,5 +1,7 @@
 // SaveRepository on disk: one JSON file per slot under the saves dir (default ~/.azsh/saves).
 // Same seam as phonecraft's MemorySaveRepository: migrate() on load, summarize() for list().
+// Two terminals may play two characters at once; a <slot>.lock file (holder's pid) keeps the same character
+// from being opened twice, since each process would otherwise overwrite the other's progress on every save.
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, renameSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -9,10 +11,16 @@ export const DEFAULT_SAVES_DIR = join(process.env.AZSH_HOME ?? join(homedir(), '
 
 const safeSlot = (slot) => String(slot).replace(/[^\w.-]/g, '_');
 
+/** Signal 0 probes without killing: ESRCH means gone, EPERM means alive but not ours (still alive). */
+const pidAlive = (pid) => { try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; } };
+
 export class FileSaveRepository {
   constructor(dir = DEFAULT_SAVES_DIR) {
     this.dir = dir;
+    /** Slots this process holds the lock on; released on unlock() and when the process exits. */
+    this.held = new Set();
     mkdirSync(dir, { recursive: true });
+    process.on('exit', () => { for (const slot of this.held) this.unlock(slot); });
   }
   path(slot) { return join(this.dir, `${safeSlot(slot)}.json`); }
   async load(slot) {
@@ -22,10 +30,47 @@ export class FileSaveRepository {
   }
   async save(save) {
     const p = this.path(save.slot);
-    const tmp = `${p}.tmp`;
+    // The temp name carries the pid so two processes saving different slots never trip over one another.
+    const tmp = `${p}.${process.pid}.tmp`;
     writeFileSync(tmp, JSON.stringify(save));
     renameSync(tmp, p);
   }
+
+  // ---- locks ------------------------------------------------------------------------------------------
+  // <slot>.lock holds `{ pid, at }`. A lock whose pid is gone (crash, killed window) is stale and taken over.
+
+  lockPath(slot) { return join(this.dir, `${safeSlot(slot)}.lock`); }
+
+  /** Pid of the live process playing this slot, or null when nobody is (a stale lock counts as nobody). */
+  lockedBy(slot) {
+    let info;
+    try { info = JSON.parse(readFileSync(this.lockPath(slot), 'utf8')); } catch { return null; }
+    const pid = Number(info?.pid);
+    if (!pid || pid === process.pid) return null;
+    return pidAlive(pid) ? pid : null;
+  }
+
+  /** Take the slot for this process. `{ ok: true }`, or `{ ok: false, pid }` when another live process has it. */
+  lock(slot) {
+    if (this.held.has(slot)) return { ok: true };
+    const p = this.lockPath(slot);
+    const body = JSON.stringify({ pid: process.pid, at: Date.now() });
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try { writeFileSync(p, body, { flag: 'wx' }); this.held.add(slot); return { ok: true }; }
+      catch (err) { if (err.code !== 'EEXIST') throw err; }
+      const pid = this.lockedBy(slot);
+      if (pid) return { ok: false, pid };
+      try { unlinkSync(p); } catch { /* the other side may have just released it */ }
+    }
+    return { ok: false, pid: this.lockedBy(slot) };
+  }
+
+  /** Release a slot this process holds. Never touches another process's lock. */
+  unlock(slot) {
+    if (!this.held.has(slot)) return;
+    this.held.delete(slot);
+    try { unlinkSync(this.lockPath(slot)); } catch { /* already gone */ }
+  }
   async list() {
     const out = [];
     for (const f of readdirSync(this.dir)) {

package/src/cli/repl.mjs

@@ -132,6 +132,9 @@ export async function main(argv = []) {
     state = await createCharacter(ds, ask);
     slot = `${state.char.name.toLowerCase()}-${Date.now().toString(36)}`;
   }
+  // Another terminal already playing this character would trade overwrites with us on every save.
+  const held = repo.lock(slot);
+  if (!held.ok) { console.log(red(`${state.char.name} is open in another terminal (pid ${held.pid}). Close it there first.`)); rl.close(); return; }
 
   const g = createGame(ds, state, { travelPace: 'instant' });
   if (g.state.char.journey) g.completeJourneyNow();
@@ -166,6 +169,7 @@ export async function main(argv = []) {
     try { await persist(); } catch (err) { console.log(red(`save failed: ${err.message}`)); }
   }
   await persist();
+  repo.unlock(slot);
   console.log(dim(`Saved ${g.state.char.name}. Farewell.`));
   rl.close();
 }

package/src/cli/tui.mjs

@@ -13,7 +13,7 @@ import { openRun } from './tuiDungeon.mjs';
 import { openLoot } from './tuiLoot.mjs';
 import { fightPaneRule, fightPaneLines } from './tuiFightPanes.mjs';
 import { MemoryPrefs, FilePrefs } from './prefs.mjs';
-import { settingsDialog, globalSettingsOpts } from './tuiSettings.mjs';
+import { settingsDialog, globalSettingsOpts, refreshMs } from './tuiSettings.mjs';
 import { autopilotSettingsDialog } from './tuiAutopilotSettings.mjs';
 import { macrosDialog, runMacro } from './tuiMacros.mjs';
 import { outfitterDialog } from './tuiOutfitter.mjs';
@@ -108,6 +108,7 @@ export class App {
     this.cmd = null;
     this.closed = false;
     this.timers = [];
+    this.lastPaint = 0; this.paintTimer = null; // renderSoon holds timer-driven repaints to the Screen refresh setting
     this.lastActivity = null;
     term.onKey = (k) => { try { this.onKey(k); } catch (err) { this.say(red(`Error: ${err.message}`)); if (process.env.AZSH_DEBUG) this.say(dim(String(err.stack).split('\n').slice(1, 4).join(' '))); this.render(); } };
     term.onResize = () => this.render();
@@ -117,6 +118,9 @@ export class App {
 
   /** `updatedAt` is when the save was last written: the gap since is offline rest and regen. */
   startGame(state, slot, createdAt, isNew, updatedAt) {
+    // Another terminal already playing this character would trade overwrites with us on every save.
+    const held = this.repo.lock?.(slot) ?? { ok: true };
+    if (!held.ok) { this.say(red(`${state.char.name} is open in another terminal (pid ${held.pid}). Close it there first.`)); return false; }
     this.slot = slot; this.createdAt = createdAt ?? Date.now();
     const awayMs = updatedAt > 0 ? Math.max(0, Date.now() - updatedAt) : 0;
     // Travel pace is a setting (instant by default, like phonecraft); `skipping` lets Arrive now land a trip at any pace.
@@ -173,8 +177,10 @@ export class App {
     if (this.closed) return;
     this.closed = true;
     for (const t of this.timers) this.term.clearInterval(t);
+    clearTimeout(this.paintTimer);
     this.fight?.stop?.(); this.auto?.stop?.();
     await this.persist();
+    if (this.slot != null) this.repo.unlock?.(this.slot);
     this.term.close();
     this.restoreConsole?.();
     if (this.g) console.log(dim(`Saved ${this.g.state.char.name}. Farewell.`));
@@ -453,8 +459,18 @@ export class App {
     return { W, H, logH, top, mainH, listW, detailW };
   }
 
+  /** A repaint from a game loop (a fight tick, the autopilot, a dungeon walk). The game keeps ticking every
+   *  100 ms; the screen catches up at most once per Screen refresh, and the last change is always painted. */
+  renderSoon() {
+    if (!this.term.isTTY) { this.render(); return; }
+    const wait = this.lastPaint + refreshMs(this.prefs) - Date.now();
+    if (wait <= 0) this.render();
+    else if (!this.paintTimer) this.paintTimer = setTimeout(() => { this.paintTimer = null; this.render(); }, wait);
+  }
+
   render() {
     if (this.closed) return;
+    clearTimeout(this.paintTimer); this.paintTimer = null; this.lastPaint = Date.now();
     const L = this.layout();
     const lines = [];
     lines.push(...this.headerLines(L));
@@ -580,16 +596,18 @@ export async function runTui({ term = new RealTerm(), argv = [] } = {}) {
   const saves = await repo.list();
   const begin = async (save) => {
     app.stack = [];
-    app.startGame(save.state, save.slot, save.createdAt, false, save.updatedAt);
+    // false: another terminal took this character between the picker's check and now; back to the picker.
+    if (app.startGame(save.state, save.slot, save.createdAt, false, save.updatedAt) === false) return reopenPicker();
     app.render();
   };
+  const reopenPicker = () => savePicker(app, { onPlay: (save) => { void begin(save); }, onNew: createFlow });
   const createFlow = () => characterCreation(app, (state) => {
     app.stack = [];
     app.startGame(state, `${state.char.name.toLowerCase()}-${Date.now().toString(36)}`, Date.now(), true);
     void app.persist();
     app.render();
   });
-  if (saves.length && !argv.includes('--new')) await savePicker(app, { onPlay: (save) => { void begin(save); }, onNew: createFlow });
+  if (saves.length && !argv.includes('--new')) await reopenPicker();
   else createFlow();
   return new Promise((resolve) => { app.onQuit = resolve; });
 }

package/src/cli/tuiBg.mjs

@@ -95,7 +95,7 @@ export function startBattleground(app, bgId) {
   app.say(yellow(`You enter ${def.name} for the ${TEAM[team]}. ${run.teamSize}v${run.teamSize}.`) + dim('  The gates open in 10 seconds.'));
   const view = bgView(app, bg);
   app.push(view);
-  bg.timer = app.term.setInterval(() => { if (!bg.paused) { stepBg(app, bg, STEPS_PER_TICK * bg.speed); app.render(); } }, 100);
+  bg.timer = app.term.setInterval(() => { if (!bg.paused) { stepBg(app, bg, STEPS_PER_TICK * bg.speed); app.renderSoon(); } }, 100);
   return bg;
 }
 

package/src/cli/tuiCheck.mjs

@@ -1071,6 +1071,13 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   app.top().cursor = rowIndex((r, t) => /^\d+\s+empty$/.test(t.trim()) && !('b' in (r.data ?? {}))); term.press('return');
   app.top().cursor = rowIndex((r, t) => t.trim() === potion.name); term.press('return');
   check('a global bar slot takes a bag item', (g.state.globalActionBar?.items ?? []).includes(potion.entry));
+  g.state.char.health = Math.max(1, Math.floor(g.state.char.health / 2));
+  const potions = countItem(g.state.inventory, potion.entry);
+  app.top().cursor = rowIndex((r, t) => /Fire the whole global bar/.test(t)); term.press('return');
+  check('firing the global bar drinks the potion', countItem(g.state.inventory, potion.entry) === potions - 1);
+  app.top().cursor = rowIndex((r, t) => t.includes(potion.name) && !('b' in (r.data ?? {}))); term.press('return');
+  app.top().cursor = rowIndex((r, t) => t.trim() === 'Clear'); term.press('return');
+  check('Clear empties the global slot', !(g.state.globalActionBar?.items ?? []).includes(potion.entry));
   term.press('escape'); home(); term.press('1');
   g.state.char.health = Math.max(1, Math.floor(g.state.char.health / 2));
   const mob = app.rowsOf(app.top()).findIndex((r) => r.data?.creature);
@@ -1268,6 +1275,17 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   home(); term.press(':'); for (const ch of 'settings') term.press(ch); term.press('return');
   pickRow(/^Travel pace/);
   check('Settings sets a real-time travel pace', app.prefs.get('travelPace') === 1);
+  pickRow(/^Screen refresh/);
+  check('Settings steps the screen refresh up from 100 ms', app.prefs.get('refreshMs') === 250);
+  // On a real terminal a game loop's repaint waits out the refresh; a key's render paints at once and drops it.
+  term.isTTY = true;
+  app.render(); const painted = term.frames;
+  app.renderSoon(); app.renderSoon();
+  check('renderSoon holds a repaint inside the refresh window', term.frames === painted && app.paintTimer != null);
+  app.render();
+  check('render paints and cancels the held repaint', term.frames === painted + 1 && app.paintTimer == null);
+  term.isTTY = false;
+  app.prefs.set('refreshMs', 100);
   home();
   const here = g.state.char.zoneId;
   const dest = (ds.zone(here)?.neighbors ?? []).map((id) => ds.zone(id)).find((z) => z && g.previewTravel(z.id).ok);
@@ -1275,7 +1293,8 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   show('on the road');
   check('a trip at 1x takes time', !!g.state.char.journey && g.state.char.zoneId !== dest.id);
   check('the header counts it down', strip(frame()).split('\n')[0].includes(`→ ${dest.name}`));
-  check('the World tab opens on the journey card', app.tab === 0 && /On the road to/.test(strip(frame())));
+  check('the Travel tab stays open, on the journey card', app.tab === 7 && /On the road to/.test(strip(frame())));
+  term.press('1'); check('the World tab carries the card too', /On the road to/.test(strip(frame()))); term.press('8');
   app.top().cursor = rowIndex((r, t) => /journey options/.test(t)); term.press('return');
   pickRow(/^Travel at 4x/);
   check('the trip can be sped up', g.journeyStatus()?.timeScale === 4);
@@ -1685,6 +1704,39 @@ check('b in Bags outside a bank town only flashes', app.stack.length === 0);
   await open();
   await choose(/^Keeper/);
   check('Enter on a save still plays it', played?.state?.char?.name === 'Keeper');
+  // Locks: one character per process. A second repo stands in for a second terminal (same pid, so a
+  // hand-written lock with a foreign live pid plays the other side; a dead pid is a stale lock).
+  const { writeFileSync: writeLock, readFileSync: readLock } = await import('node:fs');
+  const other = new FileSaveRepository(join(dir, 'saves'));
+  check('lock() takes a free slot', repo10.lock('keeper').ok === true && existsSync(repo10.lockPath('keeper')));
+  check('a lock we hold reads as free to us', repo10.lockedBy('keeper') === null);
+  check('and as free to a second repo in the same process too', other.lockedBy('keeper') === null); // same pid: a reopen in-process is not a second terminal
+  check('a different slot locks independently', other.lock('elsewhere').ok === true);
+  writeLock(other.lockPath('ghost'), JSON.stringify({ pid: 2_000_000_000, at: 1 })); // no such process
+  check('a stale lock (dead pid) is taken over', other.lock('ghost').ok === true && JSON.parse(readLock(other.lockPath('ghost'), 'utf8')).pid === process.pid);
+  const livePid = process.ppid || process.pid + 1; // the parent shell is alive and is not us
+  const foreign = JSON.stringify({ pid: livePid, at: Date.now() });
+  writeLock(other.lockPath('taken'), foreign);
+  const refused = other.lock('taken');
+  check('a live lock from another process is refused', refused.ok === false && refused.pid === livePid && readLock(other.lockPath('taken'), 'utf8') === foreign);
+  other.unlock('taken');
+  check('unlock() never removes a lock we do not hold', existsSync(other.lockPath('taken')));
+  repo10.unlock('keeper');
+  check('unlock() releases ours', !existsSync(repo10.lockPath('keeper')));
+  // The picker: a character held by another live process is marked and refuses to play or be managed.
+  writeLock(repo10.lockPath('keeper'), foreign);
+  played = null;
+  await open(); show('save picker, keeper open elsewhere');
+  const marked = () => app10.rowsOf(app10.top()).some((r) => /open in another terminal/.test(strip(r.text)));
+  check('the picker marks a character open in another terminal', marked());
+  await choose(/^Keeper.*open in another terminal/); // the imported copy is a Keeper too
+  check('Enter refuses to play it', played === null && app10.log.map(strip).some((l) => /Keeper is open in another terminal/.test(l)));
+  app10.top().cursor = at((r, t) => /^Keeper.*open in another terminal/.test(t)); term10.press('m'); await tick();
+  check('m refuses to manage it', app10.top()?.title === 'Choose a character' && app10.log.map(strip).filter((l) => /Keeper is open in another terminal/.test(l)).length === 2);
+  check('startGame on a held slot backs out', app10.startGame(newGameState(ds, human.id, 1, 'Keeper', 31, 0), 'keeper', Date.now(), true) === false && app10.g == null);
+  writeLock(repo10.lockPath('keeper'), JSON.stringify({ pid: 2_000_000_000, at: 1 }));
+  await open();
+  check('a stale lock does not mark the character', !marked());
   term10.close?.();
   rmSync(dir, { recursive: true, force: true });
   if (exported) rmSync(exported, { force: true });

package/src/cli/tuiFight.mjs

@@ -71,7 +71,7 @@ export function startFight(app, creatureEntry, { onEnd, label, begin, after, res
       this.logEvents(events);
       if (!session.ended) this.onTick?.();
       if (session.ended) this.finish();
-      app.render();
+      app.renderSoon();
     },
     logEvents(events) {
       app.meter?.ingest(events);
@@ -532,7 +532,7 @@ export function startAutopilot(app, steps = 200, farmQuery, quest) {
       }
       // The step line already tells the story; the engine's activity rows for it would repeat it.
       app.lastActivity = app.g.state.activity[0] ?? null;
-      app.render();
+      app.renderSoon();
       return true;
     },
     stop() { if (this.timer) app.term.clearInterval(this.timer); this.timer = null; if (app.auto === this) app.auto = null; void app.persist(); app.render(); },

package/src/cli/tuiFloor.mjs

@@ -453,7 +453,7 @@ function floorView(app, f) {
     f.timer = a.term.setInterval(() => {
       if (a.top()?.id !== 'floor' || a.fight) return;
       for (let i = 0; i < f.speed; i++) if (stepFloor(a, f)) break;
-      a.render();
+      a.renderSoon();
     }, TICK_MS);
   };
   const view = {

package/src/cli/tuiSaves.mjs

@@ -14,8 +14,12 @@ export async function savePicker(app, { onPlay, onNew }) {
   const live = new Set(saves.map((m) => m.slot));
   const orphans = [...new Map(deleted.filter((b) => !live.has(b.slot)).map((b) => [b.slot, b])).values()];
   const reopen = () => { app.stack = []; void savePicker(app, { onPlay, onNew }); };
+  // A character another terminal is playing right now is listed but cannot be opened or managed from here:
+  // two processes on one save would overwrite each other's progress on every action.
+  const busy = (m) => repo.lockedBy?.(m.slot) ?? null;
+  const refuse = (m, pid) => { app.say(red(`${m.name} is open in another terminal (pid ${pid}). Close it there first.`)); reopen(); }; // Enter popped the picker; put it back
   const options = saves.map((m) => ({
-    label: `${bold(m.name)}  ${dim(`L${m.level} ${className(m.cls)}`)}`,
+    label: `${bold(m.name)}  ${dim(`L${m.level} ${className(m.cls)}`)}${busy(m) ? `  ${yellow('open in another terminal')}` : ''}`,
     detail: [bold(m.name), `Level ${m.level} ${className(m.cls)}`, dim(`last played ${when(m.updatedAt)}`), '', dim('Enter: play   m: back up, restore, export, delete')],
     value: { kind: 'play', meta: m },
   }));
@@ -26,10 +30,16 @@ export async function savePicker(app, { onPlay, onNew }) {
     if (v.kind === 'new') return onNew();
     if (v.kind === 'import') return importFlow(app, reopen);
     if (v.kind === 'restore') { await repo.restoreBackup(v.backup.file); app.say(green(`${v.backup.name ?? v.backup.slot} is back.`)); return reopen(); }
+    const pid = busy(v.meta);
+    if (pid) return refuse(v.meta, pid);
     const save = await repo.load(v.meta.slot);
     if (save) onPlay(save);
   }, { hint: 'Enter: play' });
-  view.keys = { m: { hint: 'manage', fn: (a, row) => { if (row?.data?.kind === 'play') manageMenu(a, row.data.meta, reopen); } } };
+  view.keys = { m: { hint: 'manage', fn: (a, row) => {
+    if (row?.data?.kind !== 'play') return;
+    const pid = busy(row.data.meta);
+    if (pid) refuse(row.data.meta, pid); else manageMenu(a, row.data.meta, reopen);
+  } } };
   app.render();
   return view;
 }

package/src/cli/tuiSettings.mjs

@@ -12,7 +12,14 @@ import { paceLabel, nextPace } from './tuiWorld.mjs';
 const H = (text) => ({ text, header: true });
 const QUALITY_NAME = ['Poor', 'Common', 'Uncommon', 'Rare', 'Epic'];
 const DE_STEPS = [null, 2, 3, 4]; // off, then the ceiling
+const REFRESH_STEPS = [50, 100, 250, 500, 1000]; // ms between screen repaints while the game runs on its own
 const onOff = (v) => (v ? green('on') : dim('off'));
+
+/** How often a running game loop repaints the screen, from the prefs file (100 ms, every engine tick, by default). */
+export function refreshMs(prefs) {
+  const ms = prefs.get('refreshMs');
+  return REFRESH_STEPS.includes(ms) ? ms : 100;
+}
 const box = (v) => (v ? green('✓') : dim('·'));
 
 /** The `createGame` options that back the every-character layers (and account macros) with the prefs file. */
@@ -50,6 +57,14 @@ export function settingsDialog(app) {
       const rows = [{ text: `Autopilot settings  ${dim('resting, pulls, fighting, questing   (:autopilot)')}`, act: (a2) => a2.push(autopilotSettingsDialog(a2)) }, H(''), H(bold('Loot'))];
       rows.push({ text: `Auto-loot                 ${onOff(autoLootOn(a))}`, detail: () => [bold('Auto-loot'), '', 'On: a corpse\'s drops and coin go straight into your bags.', 'Off: the loot window opens and you take what you want.'], act: (a2) => a2.prefs.set('autoLoot', !autoLootOn(a2)) });
 
+      const ms = refreshMs(a.prefs);
+      rows.push(H(''), H(bold('Screen')));
+      rows.push({
+        text: `Screen refresh            ${ms === 100 ? dim('100 ms') : cyan(`${ms} ms`)}`,
+        detail: () => [bold('Screen refresh'), '', 'How often fights, the autopilot, dungeon walks and battlegrounds repaint the screen.', 'The game itself still ticks every 100 ms; this only changes how often you see it.', 'Slower is calmer and lighter on a slow terminal or a remote session; 50 ms is smoother at high speed.', 'Key presses always repaint at once.'],
+        act: (a2) => a2.prefs.set('refreshMs', REFRESH_STEPS[(REFRESH_STEPS.indexOf(ms) + 1) % REFRESH_STEPS.length]),
+      });
+
       const pace = a.prefs.get('travelPace') ?? 'instant';
       rows.push(H(''), H(bold('Travel')));
       rows.push({

package/src/cli/tuiSimLab.mjs

@@ -26,7 +26,7 @@ export function simLabDialog(app, owner) {
     s.timer = a.term.setInterval(() => {
       s.run.step(STEP_MS);
       if (s.run.done) { stop(); a.say(green(`Dummy parse done: ${nf(s.report.dps.avg)} DPS.`)); }
-      a.render();
+      a.renderSoon();
     }, 50);
   };
   const view = {

package/src/cli/tuiViews.mjs

@@ -258,9 +258,16 @@ export function travelTo(app, dest) {
   if (!app.result(res)) return;
   app.vendor = null; app.cmds.setVendor(null);
   afterDeparture(app, () => `You travel to ${bold(dest.name)}. ${dim(`${secondsText(pv.totalSeconds * 1000)}${pv.totalCopper ? `, ${moneyText(pv.totalCopper)}` : ''}`)}`);
+  landOnTab(app);
+}
+
+/** After a departure: stay on the Travel tab when the trip started there (you may want to go on), else open World. */
+export function landOnTab(app) {
+  const travel = app.tabs.findIndex((t) => t.view?.id === 'travel');
+  const i = app.tab === travel && !app.stack.length ? travel : 0;
   app.stack = [];
-  app.switchTab(0);
-  app.tabs[0].view.cursor = 0; app.tabs[0].view.scroll = 0;
+  app.switchTab(i);
+  const v = app.tabs[i]?.view; if (v) { v.cursor = 0; v.scroll = 0; }
 }
 
 function questsView(app) {
@@ -861,7 +868,7 @@ function travelView(app) {
     id: 'travel', title: 'Travel', hint: 'Enter: go',
     rows(a) {
       const g = a.g, ds = a.ds, z = a.zone(), ch = a.ch;
-      const rows = [{ text: `You are in ${cyan(z?.name ?? ch.zoneId)}`, header: true }, { text: '', header: true }, { text: 'On foot', header: true }];
+      const rows = [...journeyRows(a), { text: `You are in ${cyan(z?.name ?? ch.zoneId)}`, header: true }, { text: '', header: true }, { text: 'On foot', header: true }];
       for (const id of z?.neighbors ?? []) { const d = ds.zone(id); if (d) rows.push({ text: `${d.name} ${dim(`L${d.levelRange[0]}-${d.levelRange[1]}`)}`, detail: () => travelPreviewLines(a, d), act: () => travelTo(a, d) }); }
       const taxi = g.taxiOptions();
       if (taxi.length) {
@@ -874,12 +881,12 @@ function travelView(app) {
       rows.push({
         text: bind ? `Hearth to ${ds.zone(bind.zone)?.name ?? bind.zone}${bind.name ? dim(` (${bind.name})`) : ''}${cd > 0 ? red(`  ${secondsText(cd)}`) : ''}` : dim('No home set: speak with an innkeeper.'),
         detail: () => [bold('Hearthstone'), bind ? `Bound at ${bind.name ?? ds.zone(bind.zone)?.name}` : 'Not bound', cd > 0 ? red(`Ready in ${secondsText(cd)}`) : green('Ready')],
-        act: () => { const r = g.castHearth(); if (a.result(r)) { a.vendor = null; afterDeparture(a, () => `You hearth to ${a.zone()?.name}.`); a.switchTab(0); } },
+        act: () => { const r = g.castHearth(); if (a.result(r)) { a.vendor = null; afterDeparture(a, () => `You hearth to ${a.zone()?.name}.`); landOnTab(a); } },
       });
       const ports = g.classTravelOptions();
       if (ports.length) {
         rows.push({ text: '', header: true }, { text: 'Teleports', header: true });
-        for (const p of ports) rows.push({ text: `${p.name} → ${ds.zone(p.toZone)?.name ?? p.toZone}${p.reagents.some((r) => r.have < r.count) ? red('  no reagent') : ''}`, act: () => { const r = g.castTeleport(p.spellId); if (a.result(r)) { afterDeparture(a, () => `You teleport to ${a.zone()?.name}.`); a.switchTab(0); } } });
+        for (const p of ports) rows.push({ text: `${p.name} → ${ds.zone(p.toZone)?.name ?? p.toZone}${p.reagents.some((r) => r.have < r.count) ? red('  no reagent') : ''}`, act: () => { const r = g.castTeleport(p.spellId); if (a.result(r)) { afterDeparture(a, () => `You teleport to ${a.zone()?.name}.`); landOnTab(a); } } });
       }
       rows.push(...portalRows(a));
       return rows;

package/src/cli/tuiWorld.mjs

@@ -56,7 +56,7 @@ export function pickPocketTag(app, creature) {
 
 // ---- journeys ------------------------------------------------------------------------------------------
 // With a real-time travel pace (Settings) a trip takes wall-clock time: the game loop calls journeyTick, the
-// header shows where you are headed, and the World tab opens on this card. Instant pace never gets here.
+// header shows where you are headed, and the World and Travel tabs carry this card. Instant pace never gets here.
 
 const PACES = ['instant', 1, 2, 4];
 export const paceLabel = (p) => (p === 'instant' ? 'instant' : `${p}x real time`);
@@ -86,8 +86,7 @@ export function journeyTick(app) {
   if (!app.g.state.char.journey) {
     app.say(green(`You arrive in ${app.zone()?.name ?? app.ch.zoneId}.`));
     app.journeyWas = null;
-    const world = app.tabs[0]?.view;
-    if (world) { world.cursor = 0; world.scroll = 0; }
+    for (const v of [app.tabs[0]?.view, app.top()]) if (v) { v.cursor = 0; v.scroll = 0; }
   }
 }