azeroth-shell 0.0.0-stage → 0.1.1

package/src/cli/tuiRaid.mjs

@@ -0,0 +1,127 @@
+// Who walks into an instance and how the paladins bless them. The roster picker is phonecraft's
+// instanceRosterPicker.ts (picks from every companion you own, Fill matches the instance template), the
+// lineup is the 10/20/40 raid group, and the board is the PallyPower grid (engine/game/paladinBoard.ts).
+import { bold, dim, cyan, green, yellow, fit, plural, wrapLines } from './text.mjs';
+import { className } from '../domain/core/ids.ts';
+import { companionLevel, maxCompanionsFor, MAX_COMPANIONS } from '../domain/bots/squad.ts';
+import { resolveOwnedLineup } from '../domain/raid/instanceRoster.ts';
+
+const H = (text) => ({ text, header: true });
+const ROLE_NAME = { tank: 'tank', healer: 'healer', dps: 'damage' };
+
+const owned = (g) => [...(g.state.squad ?? []), ...Object.values(g.state.botRoster ?? {})];
+
+/** The raid size a lineup is kept for: the instance's own, rounded up to 10, 20 or 40. */
+export function lineupSize(maxPlayers) { return maxPlayers > 20 ? 40 : maxPlayers > 10 ? 20 : 10; }
+
+/** The ids that would walk in now, the same resolution the door makes. */
+export function walkingIn(g, def, asRaid) {
+  const cap = maxCompanionsFor(def.maxPlayers);
+  const list = owned(g);
+  const resolved = resolveOwnedLineup({
+    dungeonId: def.id, cap, asRaid: asRaid && cap > MAX_COMPANIONS, ownedIds: new Set(list.map((c) => c.id)),
+    dungeonPicks: g.state.instanceRoster, raidLineup: g.state.raidLineup,
+  });
+  return { cap, ids: resolved ?? (g.state.squad ?? []).map((c) => c.id).slice(0, cap), picked: !!resolved };
+}
+
+/** Pick who walks into this instance: Enter toggles, f fills to the template, c goes back to auto. */
+export function rosterDialog(app, def, getAsRaid) {
+  return {
+    id: `roster-${def.id}`, title: 'Who walks in', hint: 'Enter: in / out',
+    keys: {
+      f: { hint: 'fill', fn: (a) => { const r = a.g.fillInstanceRoster(def.id); a.result(r, r.ok ? `${plural(r.picked, 'companion')} picked for ${def.name}${r.mage ? ', a mage among them' : ''}.` : ''); } },
+      c: { hint: 'auto', fn: (a) => a.result(a.g.clearInstanceRoster(), 'Back to auto: the party you have walks in.') },
+    },
+    rows(a) {
+      const g = a.g, { cap, ids, picked } = walkingIn(g, def, getAsRaid());
+      const set = new Set(ids);
+      const rows = [H(`${bold(def.name)}   ${picked ? `${ids.length} of ${cap} picked` : dim(`auto: your party, ${ids.length} of ${cap}`)}`), H('')];
+      const list = owned(g).sort((x, y) => Number(set.has(y.id)) - Number(set.has(x.id)) || x.name.localeCompare(y.name));
+      if (!list.length) rows.push(H(dim('  You own no companions. Innkeepers hire them out.')));
+      for (const c of list) {
+        rows.push({
+          text: `${set.has(c.id) ? green('✓') : dim('·')} ${fit(c.name, 14)} ${fit(dim(`L${companionLevel(c, a.ch.level)} ${className(c.cls)}`), 14)} ${ROLE_NAME[c.role] ?? c.role}`,
+          detail: () => [bold(c.name), `${className(c.cls)}, ${ROLE_NAME[c.role] ?? c.role}`, '', set.has(c.id) ? 'Walks in.' : 'Stays outside.', '', dim('Enter: in or out   f: fill   c: auto')],
+          act: () => {
+            const next = set.has(c.id) ? ids.filter((x) => x !== c.id) : [...ids, c.id];
+            if (next.length > cap) { a.flashMsg(`${def.name} takes ${cap} companions.`); return; }
+            a.result(g.setInstanceRoster(def.id, next));
+          },
+        });
+      }
+      return rows;
+    },
+  };
+}
+
+/** The raid group kept for the next 10, 20 or 40-man: Enter toggles, f fills by role, c clears. */
+export function lineupDialog(app, size) {
+  return {
+    id: `lineup-${size}`, title: `${size}-man group`, hint: 'Enter: in / out',
+    keys: {
+      f: { hint: 'fill', fn: (a) => { const r = a.g.fillRaidLineup(size); a.result(r, r.ok ? `${r.picked} of ${r.cap} seats filled.` : ''); } },
+      c: { hint: 'clear', fn: (a) => a.result(a.g.clearRaidLineup(), 'Raid group cleared.') },
+    },
+    rows(a) {
+      const g = a.g, cap = size - 1;
+      const cur = g.state.raidLineup?.size === size ? g.state.raidLineup.ids : [];
+      const set = new Set(cur);
+      const counts = { tank: 0, healer: 0, dps: 0 };
+      for (const c of owned(g)) if (set.has(c.id)) counts[c.role] = (counts[c.role] ?? 0) + 1;
+      const rows = [H(`${bold(`${size}-man group`)}   ${cur.length} of ${cap}   ${dim(`${counts.tank} tank, ${counts.healer} healer, ${counts.dps} damage`)}`), H('')];
+      for (const c of owned(g).sort((x, y) => Number(set.has(y.id)) - Number(set.has(x.id)) || x.role.localeCompare(y.role))) {
+        rows.push({
+          text: `${set.has(c.id) ? green('✓') : dim('·')} ${fit(c.name, 14)} ${fit(dim(`L${companionLevel(c, a.ch.level)} ${className(c.cls)}`), 14)} ${ROLE_NAME[c.role] ?? c.role}`,
+          act: () => {
+            const next = set.has(c.id) ? cur.filter((x) => x !== c.id) : [...cur, c.id];
+            if (next.length > cap) { a.flashMsg(`A ${size}-man takes ${cap} companions.`); return; }
+            a.result(g.setRaidLineup(size, next));
+          },
+        });
+      }
+      return rows;
+    },
+  };
+}
+
+/** PallyPower: one row per paladin, the aura and one Blessing per class column. Enter steps forward, - back. */
+export function paladinDialog(app) {
+  const after = (a, r) => { if (a.result(r)) { const n = a.g.refreshPaladinBuffs(); if (n) a.say(dim(`The paladins recast ${plural(n, 'buff')}.`)); } };
+  return {
+    id: 'pallypower', title: 'Paladin blessings', hint: 'Enter: next   -: previous',
+    keys: {
+      a: { hint: 'auto sort', fn: (a) => after(a, a.g.autoSortPaladinAssignments()) },
+      c: { hint: 'clear', fn: (a) => after(a, a.g.clearPaladinAssignments()) },
+    },
+    onKey(a, k, row) {
+      if (k !== '-' || !row?.data) return false;
+      const d = row.data;
+      after(a, d.col ? a.g.stepPaladinBlessing(d.key, d.col, -1) : a.g.stepPaladinAura(d.key, -1));
+      return true;
+    },
+    rows(a) {
+      const b = a.g.paladinBoard();
+      if (!b.rows.length) return [H(dim('No paladin in the party. Seat one to hand out Blessings.'))];
+      const rows = [...wrapLines('Each paladin keeps one aura up and one Blessing on each class. Auto follows the CMaNGOS order.', a.layout().listW - 2).map((t) => H(dim(t))), H('')];
+      for (const p of b.rows) {
+        rows.push(H(`${bold(p.name)} ${dim(`L${p.level}`)}${p.symbols ? dim(`  Symbols of Kings ${p.symbols}, spends ${p.symbolsSpent}`) : ''}`));
+        const auraName = p.auras.find((x) => x.aura === p.aura)?.name ?? (p.aura ?? 'none');
+        rows.push({ text: `  ${fit('Aura', 12)} ${cyan(auraName)}${p.assignedAura ? '' : dim('  auto')}`, data: { key: p.key }, act: () => after(a, a.g.stepPaladinAura(p.key, 1)) });
+        for (const col of b.columns) {
+          const cell = b.cells[`${p.key}|${col.col}`];
+          const name = cell?.name ?? (cell?.effective ?? dim('nobody'));
+          rows.push({
+            text: `  ${fit(col.label, 12)} ${cell?.effective ? (cell.greater ? yellow(name) : name) : dim('—')}${cell?.assigned ? '' : dim('  auto')}${dim(`  ${col.bodies} ${col.bodies === 1 ? 'body' : 'bodies'}`)}`,
+            data: { key: p.key, col: col.col },
+            act: () => after(a, a.g.stepPaladinBlessing(p.key, col.col, 1)),
+          });
+        }
+      }
+      return rows;
+    },
+  };
+}
+
+/** Is there a paladin anywhere in the party (you or a seated companion)? */
+export function partyHasPaladin(g) { return g.state.char.cls === 2 || (g.state.squad ?? []).some((c) => c.cls === 2); }

package/src/cli/tuiRep.mjs

@@ -0,0 +1,65 @@
+// The reputation window (phonecraft panels/reputationPanel.ts): every faction you know, grouped by its parent,
+// with your standing inside the rank. Enter on one: watch it on the xp bar, declare war or peace, or park it at
+// the bottom (inactive). The engine refuses what the client would (forced peace, hidden factions).
+import { bold, dim, yellow, green, red, cyan, brightBlue, magenta, fit, bar } from './text.mjs';
+import { getStanding, progressInRank, effectiveFactionFlags, isFactionVisible, isInactiveFlags, isFactionAtWar, canToggleAtWar, canToggleInactive } from '../domain/creature/reputation.ts';
+
+const H = (text) => ({ text, header: true });
+const RANK_PAINT = [red, red, yellow, yellow, green, green, cyan, brightBlue];
+
+function factionRow(app, f) {
+  const ch = app.ch;
+  const standing = getStanding(ch.reputations, f, ch.race, ch.cls);
+  const p = progressInRank(standing);
+  const atWar = isFactionAtWar(f, ch.reputations, ch.factionFlags, ch.race, ch.cls);
+  const watched = ch.watchedFaction === f.id;
+  const paint = RANK_PAINT[p.rank] ?? dim;
+  return {
+    text: `${watched ? magenta('◆ ') : '  '}${fit(f.name, 30)} ${bar(p.current, p.span, 16, paint)} ${paint(fit(p.name, 10))} ${dim(`${p.current}/${p.span}`)}${atWar ? red('  at war') : ''}`,
+    data: { faction: f },
+    detail: () => [bold(f.name), paint(`${p.name}  ${p.current}/${p.span}`), dim(`standing ${standing}${p.remaining ? `, ${p.remaining} to the next rank` : ''}`), '', ...(f.description ? [f.description, ''] : []), atWar ? red('At war: their guards attack you on sight.') : '', watched ? magenta('Shown on your xp bar.') : '', '', dim('Enter: watch, war, park')],
+    act: (a) => factionMenu(a, f),
+  };
+}
+
+function factionMenu(app, f) {
+  const g = app.g, ch = app.ch;
+  const eff = effectiveFactionFlags(f, ch.factionFlags, ch.race, ch.cls);
+  const atWar = isFactionAtWar(f, ch.reputations, ch.factionFlags, ch.race, ch.cls);
+  const inactive = isInactiveFlags(eff);
+  const watched = ch.watchedFaction === f.id;
+  const opts = [{ label: watched ? 'Stop watching it' : 'Watch it on the xp bar', value: () => app.result(g.setWatchedFaction(watched ? 0 : f.id), watched ? 'Back to the xp bar.' : `Watching ${f.name}.`) }];
+  if (canToggleAtWar(eff, !atWar)) opts.push({ label: atWar ? 'Make peace' : red('Declare war'), value: () => app.result(g.setFactionAtWar(f.id, !atWar), atWar ? `At peace with ${f.name}.` : `At war with ${f.name}.`) });
+  if (canToggleInactive(eff, !inactive)) opts.push({ label: inactive ? 'Bring it back up' : 'Park it at the bottom', value: () => app.result(g.setFactionInactive(f.id, !inactive)) });
+  app.pick(f.name, opts, (fn) => fn());
+}
+
+export function reputationDialog(app) {
+  return {
+    id: 'reputation', title: 'Reputation', hint: 'Enter: watch / war / park',
+    rows(a) {
+      const ch = a.ch;
+      const known = a.ds.factions().filter((f) => isFactionVisible(f, ch.reputations, ch.factionFlags, ch.race, ch.cls));
+      const parked = [], groups = new Map();
+      for (const f of known) {
+        if (isInactiveFlags(effectiveFactionFlags(f, ch.factionFlags, ch.race, ch.cls))) { parked.push(f); continue; }
+        if (known.some((x) => x.team === f.id && x.id !== f.id)) continue; // a group header, not a faction you earn
+        const key = f.team || 0;
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(f);
+      }
+      const atWar = a.g.atWarFactions().size;
+      const rows = [H(`${bold('Reputation')}   ${dim(`${known.length} factions${atWar ? `, at war with ${atWar}` : ''}`)}`)];
+      const groupName = (id) => a.ds.faction(id)?.name ?? 'Other';
+      for (const [key, list] of [...groups].sort((x, y) => groupName(x[0]).localeCompare(groupName(y[0])))) {
+        rows.push(H(''), H(cyan(key ? groupName(key) : 'Other')));
+        for (const f of list.sort((x, y) => x.name.localeCompare(y.name))) rows.push(factionRow(a, f));
+      }
+      if (parked.length) {
+        rows.push(H(''), H(dim('Inactive')));
+        for (const f of parked) rows.push(factionRow(a, f));
+      }
+      return rows;
+    },
+  };
+}

package/src/cli/tuiSaves.mjs

@@ -0,0 +1,69 @@
+// The character picker and what you can do to a save from it (phonecraft's save slots panel): play, back up,
+// restore a backup, export to a file, import one, delete. Saves are files under ~/.azsh/saves; backups sit
+// beside them in backups/. A delete or a restore always leaves a backup of what it replaced.
+import { bold, dim, green, red, yellow, cyan } from './text.mjs';
+import { className } from '../domain/core/ids.ts';
+
+const when = (ms) => new Date(ms).toLocaleString();
+
+/** The picker. `onPlay(save)` and `onNew()` hand the screen to the game. */
+export async function savePicker(app, { onPlay, onNew }) {
+  const repo = app.repo;
+  const saves = await repo.list();
+  const deleted = (await repo.listBackups?.()) ?? [];
+  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 }); };
+  const options = saves.map((m) => ({
+    label: `${bold(m.name)}  ${dim(`L${m.level} ${className(m.cls)}`)}`,
+    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 },
+  }));
+  options.push({ label: green('New character'), value: { kind: 'new' } });
+  if (repo.importSave) options.push({ label: dim('Import a save file'), value: { kind: 'import' } });
+  for (const b of orphans) options.push({ label: dim(`Bring back ${b.name ?? b.slot} (deleted)`), value: { kind: 'restore', backup: b } });
+  const view = app.pick('Choose a character', options, async (v) => {
+    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 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); } } };
+  app.render();
+  return view;
+}
+
+function manageMenu(app, meta, reopen) {
+  const repo = app.repo;
+  app.pick(meta.name, [
+    { label: 'Back it up now', value: async () => { const f = await repo.backup(meta.slot, 'by hand'); app.say(f ? green(`Backed up ${meta.name}.`) : red('Nothing to back up.')); app.render(); } },
+    { label: 'Restore a backup', value: async () => restoreMenu(app, meta, reopen) },
+    { label: 'Export to a file', value: async () => { const p = await repo.exportSave(meta.slot); app.say(p ? green(`Wrote ${p}`) : red('Could not export.')); app.render(); } },
+    { label: red('Delete'), value: () => app.confirm(`Delete ${meta.name}? A backup is kept; "Bring back" on this list undoes it.`, async () => { await repo.delete(meta.slot); app.say(yellow(`${meta.name} deleted.`)); reopen(); }) },
+  ], (fn) => { void fn(); });
+}
+
+async function restoreMenu(app, meta, reopen) {
+  const list = await app.repo.listBackups(meta.slot);
+  if (!list.length) { app.flashMsg(`No backups of ${meta.name} yet.`); app.render(); return; }
+  app.pick(`${meta.name}: restore which?`, list.map((b) => ({
+    label: `${when(b.at)}  ${dim(`L${b.level}${b.reason ? `, ${b.reason}` : ''}`)}`,
+    value: b,
+  })), (b) => app.confirm(`Restore ${meta.name} to ${when(b.at)}? What you have now is backed up first.`, async () => {
+    await app.repo.restoreBackup(b.file);
+    app.say(green(`${meta.name} restored to ${when(b.at)}.`));
+    reopen();
+  }));
+  app.render();
+}
+
+function importFlow(app, reopen) {
+  app.prompt('Save file to import (path): ', async (path) => {
+    try {
+      const save = await app.repo.importSave(path.trim().replace(/^"|"$/g, ''));
+      app.say(save ? green(`Imported ${save.state.char.name}.`) : red('That file is not a save.'));
+    } catch (err) { app.say(red(`Could not import: ${err.message}`)); }
+    reopen();
+  });
+}

package/src/cli/tuiSearch.mjs

@@ -0,0 +1,363 @@
+// World search (s on the World tab): "where do I find X?" Type a name and every place that answers is a
+// row: the vendors that sell an item and the zone each stands in, the creatures that drop it, the node that
+// yields it, who crafts it; an NPC by name and where it is; a dungeon and its entrance; a gather node and the
+// zones it grows in; a zone, a quest, an object. Enter acts on the place: open it when you are already there
+// (the vendor, the fight, the portal, the node), travel there when you are not. The matching is the wiki's
+// (substring, then character subsequence), over the wiki's name index plus a gather-node index of our own.
+import { bold, dim, yellow, green, red, cyan, qualityPaint, secondsText, plural } from './text.mjs';
+import { wikiIndex, wikiTokens, rowMatches } from './wikiIndex.ts';
+import { wikiSourceIndexSync } from './wikiSources.ts';
+import { wikiPage } from './tuiWiki.mjs';
+import { itemLines, creatureLines, questLines, travelPreviewLines, travelTo, vendorDialog, trainerDialog, innDialog, questDialog, conPaint } from './tuiViews.mjs';
+import { profTrainerDialog } from './tuiProfessions.mjs';
+import { entryDialog } from './tuiDungeon.mjs';
+import { startFight } from './tuiFight.mjs';
+import { moneyText } from '../domain/economy/money.ts';
+import { vendorPriceMultiplierFor } from '../engine/game/vendorOffers.ts';
+import { className } from '../domain/core/ids.ts';
+
+const H = (text) => ({ text, header: true });
+/** Wiki kinds a world search answers. Spells, talents and factions have no place to go to. */
+const WORLD_KINDS = new Set(['item', 'npc', 'zone', 'dungeon', 'object', 'quest', 'recipe']);
+const MAX_HITS = 40;
+const MAX_PLACES_PER_ITEM = 8;
+const SOURCE_ORDER = { vendor: 0, gather: 1, crafted: 2, fishing: 3, object: 4, drop: 5, skin: 6, pickpocket: 7, 'quest-reward': 8, container: 9, disenchant: 10, spell: 11, mail: 12 };
+
+// ---- the place index ----------------------------------------------------------------------------------------
+
+const cache = new WeakMap();
+
+/** Who stands where: NPC entry → zone ids, gather node → zone ids, object entry → zone ids, plus one search row per distinct node name. */
+export function placeIndex(ds) {
+  const hit = cache.get(ds);
+  if (hit) return hit;
+  const npcZones = new Map(), nodeZones = new Map(), objectZones = new Map(), nodeRowsByName = new Map();
+  const add = (map, key, zone) => { const l = map.get(key); if (l) { if (!l.includes(zone)) l.push(zone); } else map.set(key, [zone]); };
+  for (const z of ds.zones()) {
+    for (const t of z.trainers ?? []) add(npcZones, t.entry, z.id);
+    for (const list of [z.vendors, z.profTrainers, z.weaponTrainers, z.petTrainers, z.ridingTrainers, z.huntable]) for (const e of list ?? []) add(npcZones, e, z.id);
+    for (const i of z.innkeepers ?? []) add(npcZones, i.entry, z.id);
+    for (const f of z.flightMasters ?? []) add(npcZones, f.entry, z.id);
+    for (const o of z.objects ?? []) add(objectZones, o, z.id);
+    for (const id of z.nodes ?? []) {
+      const n = ds.gatherNode(id);
+      if (!n) continue;
+      add(nodeZones, id, z.id);
+      let row = nodeRowsByName.get(n.name);
+      if (!row) nodeRowsByName.set(n.name, (row = { kind: 'node', id, name: n.name, lower: n.name.toLowerCase(), sub: `${ds.profession(n.skill)?.name ?? n.skill} ${n.orange}`, ids: [], zones: [] }));
+      row.ids.push(id);
+      if (!row.zones.includes(z.id)) row.zones.push(z.id);
+    }
+  }
+  const nodeRows = [...nodeRowsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
+  const built = { npcZones, nodeZones, objectZones, nodeRows };
+  cache.set(ds, built);
+  return built;
+}
+
+/** The wiki's world-facing rows plus our node rows: the pool a search runs over. */
+function searchPool(ds) {
+  const ix = wikiIndex(ds), pi = placeIndex(ds);
+  // A vein or herb is also a gameobject row in the wiki; the node row (skill, yield, zones) is the one to show.
+  const nodeNames = new Set(pi.nodeRows.map((r) => r.lower));
+  return [...ix.all.filter((r) => WORLD_KINDS.has(r.kind) && !(r.kind === 'object' && nodeNames.has(r.lower))), ...pi.nodeRows];
+}
+
+/**
+ * wikiSearch's buckets (exact, prefix, substring, then subsequence only when nothing contains the words),
+ * with one change for typos: the loose bucket ranks by how little longer the name is than what was typed,
+ * so "hoger" puts Hogger first instead of forty items whose letters happen to contain h-o-g-e-r in order.
+ */
+export function worldSearch(pool, tokens) {
+  if (!tokens.length) return [];
+  const q = tokens.join(' ');
+  const exact = [], prefix = [], substr = [], loose = [];
+  for (const row of pool) {
+    if (!rowMatches(row, tokens)) continue;
+    if (row.lower === q) exact.push(row);
+    else if (row.lower.startsWith(q)) prefix.push(row);
+    else if (tokens.every((t) => row.lower.includes(t))) substr.push(row);
+    else loose.push(row);
+  }
+  // Within the tight buckets a name close in length to the query wins ("deadmines": The Deadmines before
+  // Deadmines Cleaver); the bucket and then the pool's kind order break ties.
+  const bucket = new Map([...prefix.map((r) => [r, 0]), ...substr.map((r) => [r, 1])]);
+  const order = new Map([...prefix, ...substr].map((r, i) => [r, i]));
+  const closeness = (r) => r.lower.length - q.length;
+  const tight = [...exact, ...[...prefix, ...substr].sort((a, b) => closeness(a) - closeness(b) || bucket.get(a) - bucket.get(b) || order.get(a) - order.get(b))];
+  if (tight.length) return tight;
+  return loose.sort((a, b) => (a.lower.length - b.lower.length) || a.name.localeCompare(b.name));
+}
+
+// ---- places ------------------------------------------------------------------------------------------------
+
+/** Where an NPC stands: its zones, or the dungeon it lives in. `{ zones, dungeon }`, both possibly empty. */
+function npcPlace(app, entry) {
+  const zones = placeIndex(app.ds).npcZones.get(entry) ?? [];
+  const dungeon = zones.length ? null : app.ds.instanceForCreature(entry) ?? null;
+  return { zones, dungeon };
+}
+
+function zoneName(app, id) { return app.ds.zone(id)?.name ?? id; }
+
+/** The zone list as a short label, the current zone first and highlighted. */
+function zonesLabel(app, zones, max = 3) {
+  if (!zones.length) return '';
+  const here = app.ch.zoneId;
+  const sorted = [...zones].sort((a, b) => (a === here ? -1 : b === here ? 1 : 0));
+  const shown = sorted.slice(0, max).map((z) => (z === here ? green('here') : zoneName(app, z)));
+  return shown.join(', ') + (sorted.length > max ? dim(` +${sorted.length - max} more`) : '');
+}
+
+/** Travel to a zone after a confirm that quotes the journey; or do `here()` when already standing in it. */
+function goTo(app, zoneId, here) {
+  if (zoneId === app.ch.zoneId) { if (here) here(); else app.flashMsg('You are already here.'); return; }
+  const dest = app.ds.zone(zoneId);
+  if (!dest) { app.flashMsg('No road leads there.'); return; }
+  const pv = app.g.previewTravel(dest.id);
+  if (!app.result(pv)) return;
+  app.confirm(`Travel to ${dest.name}? ${secondsText(pv.totalSeconds * 1000)}${pv.totalCopper ? `, ${moneyText(pv.totalCopper)} in fares` : ''}`, () => travelTo(app, dest));
+}
+
+/** Enter on a place with several zones: travel to the one you pick, the current zone first. */
+function goToOne(app, zones, title, here) {
+  if (!zones.length) { app.flashMsg('No reachable place for that.'); return; }
+  if (zones.length === 1) { goTo(app, zones[0], here); return; }
+  const hereId = app.ch.zoneId;
+  const sorted = [...zones].sort((a, b) => (a === hereId ? -1 : b === hereId ? 1 : 0) || zoneName(app, a).localeCompare(zoneName(app, b)));
+  app.pick(title, sorted.map((z) => {
+    const dest = app.ds.zone(z);
+    return { label: z === hereId ? green(`${zoneName(app, z)}  (here)`) : `${zoneName(app, z)} ${dim(dest ? `levels ${dest.levelRange[0]}-${dest.levelRange[1]}` : '')}`, value: z, detail: dest ? () => travelPreviewLines(app, dest) : undefined };
+  }), (z) => goTo(app, z, here));
+}
+
+function travelHint(app, zones) {
+  if (!zones.length) return dim('No reachable place is known for this.');
+  if (zones.includes(app.ch.zoneId)) return dim('Enter: open it here');
+  const dest = app.ds.zone(zones[0]);
+  const pv = dest ? app.g.previewTravel(dest.id) : null;
+  if (pv && !pv.ok) return red(pv.reason);
+  return dim(`Enter: travel to ${zoneName(app, zones[0])}${pv ? ` (${secondsText(pv.totalSeconds * 1000)}${pv.totalCopper ? `, ${moneyText(pv.totalCopper)}` : ''})` : ''}${zones.length > 1 ? ', or pick another zone' : ''}`);
+}
+
+// ---- rows per kind ------------------------------------------------------------------------------------------
+
+/** A vendor/trainer/innkeeper/creature as one place row. `tag` names the role. */
+function npcRow(app, entry, { indent = '', note = '' } = {}) {
+  const ds = app.ds, ch = app.ch;
+  const c = ds.creature(entry);
+  const v = ds.vendor(entry), tr = ds.trainer(entry), pt = ds.profTrainer(entry);
+  const inn = ds.zones().some((z) => (z.innkeepers ?? []).some((i) => i.entry === entry));
+  const name = c?.name ?? v?.name ?? tr?.name ?? pt?.name ?? `creature ${entry}`;
+  const role = v ? `<${v.subname ?? 'Vendor'}>` : pt ? `<${ds.profession(pt.skill)?.name ?? pt.skill} Trainer>` : tr ? `<${tr.subname || `${className(ds.trainerClass(entry)) || ''} Trainer`.trim()}>` : inn ? '<Innkeeper>' : c ? `L${c.level}` : '';
+  const { zones, dungeon } = npcPlace(app, entry);
+  const hostile = !!c && !v && !tr && !pt && !inn && (ds.zones().some((z) => z.huntable.includes(entry)) || !!dungeon);
+  const where = dungeon ? `${cyan(dungeon.name)}${dungeon.portalZone ? dim(`, entrance in ${zoneName(app, dungeon.portalZone)}`) : ''}` : zonesLabel(app, zones);
+  const paint = hostile && c ? conPaint(ch.level, c.level) : (s) => s;
+  const here = () => {
+    if (v) { app.push(vendorDialog(app, v)); return; }
+    if (pt) { app.push(profTrainerDialog(app, pt)); return; }
+    if (tr) { app.push(trainerDialog(app, tr)); return; }
+    if (inn) { const i = (app.zone()?.innkeepers ?? []).find((x) => x.entry === entry); if (i) app.push(innDialog(app, i)); return; }
+    if (hostile && app.zone()?.huntable.includes(entry)) { startFight(app, entry); return; }
+    app.flashMsg(`${name} is around here somewhere.`);
+  };
+  return {
+    text: `${indent}${paint(name)} ${dim(role)}${note}  ${where || dim('(nowhere you can walk to)')}`,
+    data: { entry },
+    detail: () => {
+      const out = c && hostile ? creatureLines(app, c).filter((l) => !/Enter: fight live/.test(l)) : [bold(name), dim(role.replace(/[<>]/g, ''))];
+      if (v) out.push(dim(`${v.items.length} wares${v.canRepair ? ', repairs' : ''}`));
+      out.push('', cyan('Where'), ...(dungeon ? [`  ${dungeon.name}${dungeon.portalZone ? ` (entrance in ${zoneName(app, dungeon.portalZone)})` : ''}`] : zones.length ? zones.map((z) => `  ${zoneName(app, z)}${z === ch.zoneId ? green('  here') : ''}`) : [dim('  no reachable zone lists this one')]));
+      out.push('', dungeon ? dim(`Enter: go to the entrance in ${zoneName(app, dungeon.portalZone)}`) : travelHint(app, zones));
+      return out;
+    },
+    act: () => {
+      if (dungeon) { goTo(app, dungeon.portalZone, () => app.push(entryDialog(app, dungeon))); return; }
+      goToOne(app, zones, `Where to find ${name}`, here);
+    },
+  };
+}
+
+function zoneRow(app, z) {
+  const here = z.id === app.ch.zoneId;
+  return {
+    text: `${cyan(z.name)} ${dim(`Zone  levels ${z.levelRange[0]}-${z.levelRange[1]}${z.faction ? `, ${z.faction}` : ''}`)}${here ? green('  (here)') : ''}`,
+    detail: () => (here ? [bold(z.name), dim('You are here.')] : travelPreviewLines(app, z)),
+    act: () => goTo(app, z.id),
+  };
+}
+
+function dungeonRow(app, def) {
+  const ch = app.ch, low = ch.level < def.minLevel;
+  const raid = (def.maxPlayers ?? 5) > 5;
+  return {
+    text: `${low ? dim(def.name) : cyan(def.name)} ${dim(`Dungeon  L${def.levelRange[0]}-${def.levelRange[1]}${raid ? `, ${def.maxPlayers}-man raid` : ''}`)}${low ? red(`  requires ${def.minLevel}`) : ''}  ${dim('entrance in')} ${def.portalZone === ch.zoneId ? green(`${zoneName(app, def.portalZone)} (here)`) : zoneName(app, def.portalZone)}`,
+    detail: () => {
+      const bosses = def.encounters.filter((e) => e.kind === 'boss');
+      return [bold(def.name), dim(`levels ${def.levelRange[0]}-${def.levelRange[1]}, requires ${def.minLevel}${raid ? `, ${def.maxPlayers} players` : ''}`), `Entrance in ${zoneName(app, def.portalZone)}`, '', cyan(`Bosses (${bosses.length})`), ...bosses.slice(0, 12).map((b) => `  ${b.name}`), ...(bosses.length > 12 ? [dim(`  and ${bosses.length - 12} more`)] : []), '', travelHint(app, [def.portalZone])];
+    },
+    act: () => goTo(app, def.portalZone, () => app.push(entryDialog(app, def))),
+  };
+}
+
+function nodeRow(app, row, { indent = '', note = '' } = {}) {
+  const ds = app.ds, n = ds.gatherNode(row.id);
+  const zones = row.zones ?? placeIndex(ds).nodeZones.get(row.id) ?? [];
+  const prof = ds.profession(n?.skill)?.name ?? n?.skill ?? '';
+  const sk = n ? app.ch.skills[n.skill] : null;
+  return {
+    text: `${indent}${green(row.name)} ${dim(`${prof} ${n?.orange ?? ''}`)}${note}  ${zonesLabel(app, zones) || dim('(nowhere you can walk to)')}`,
+    detail: () => {
+      const out = [bold(row.name), dim(`${prof}, skill ${n?.orange ?? '?'}`), sk ? `Your ${prof}: ${sk.current}/${sk.max}` : red(`You do not know ${prof}.`), ''];
+      if (n) { out.push(cyan('Yields')); for (const y of n.yield) out.push(`  ${app.itemLabel(y.item)} ${dim(`${y.minCount === y.maxCount ? y.minCount : `${y.minCount}-${y.maxCount}`}, ${y.chance}%`)}`); out.push(''); }
+      out.push(cyan(`Found in (${zones.length})`), ...zones.slice(0, 14).map((z) => `  ${zoneName(app, z)}${z === app.ch.zoneId ? green('  here') : ''}`), ...(zones.length > 14 ? [dim(`  and ${zones.length - 14} more`)] : []));
+      out.push('', zones.includes(app.ch.zoneId) ? dim('Enter: gather it from the World tab') : travelHint(app, zones));
+      return out;
+    },
+    act: () => goToOne(app, zones, `Where to gather ${row.name}`, () => { app.stack = []; app.switchTab(0); app.flashMsg(`${row.name} is in this zone: see Gathering on the World tab.`); }),
+  };
+}
+
+function objectRow(app, go, { indent = '', note = '', zones: given } = {}) {
+  const zones = given ?? placeIndex(app.ds).objectZones.get(go.entry) ?? [];
+  return {
+    text: `${indent}${go.name} ${dim('Object')}${note}  ${zonesLabel(app, zones) || dim('(nowhere you can walk to)')}`,
+    detail: () => [bold(go.name), dim('object'), '', cyan(`Found in (${zones.length})`), ...zones.slice(0, 14).map((z) => `  ${zoneName(app, z)}${z === app.ch.zoneId ? green('  here') : ''}`), '', travelHint(app, zones)],
+    act: () => goToOne(app, zones, `Where to find ${go.name}`, () => { app.stack = []; app.switchTab(0); app.flashMsg(`${go.name} is in this zone: see Objects on the World tab.`); }),
+  };
+}
+
+function questRow(app, q, { indent = '', note = '' } = {}) {
+  const zones = q.starterZones ?? [];
+  const qs = app.g.state.questlog.quests.find((s) => s.entry === q.entry);
+  return {
+    text: `${indent}${yellow('!')} ${q.title} ${dim(`Quest L${q.questLevel}`)}${note}  ${dim('from')} ${q.starterName || '?'}${zones.length ? `, ${zonesLabel(app, zones)}` : ''}`,
+    detail: () => [...questLines(app, q, qs), '', cyan('Starts in'), ...(zones.length ? zones.map((z) => `  ${zoneName(app, z)}`) : [dim('  unknown')]), '', travelHint(app, zones)],
+    act: () => goToOne(app, zones, `Where ${q.title} starts`, () => app.push(questDialog(app, q, qs ? 'log' : 'offer'))),
+  };
+}
+
+function recipeRow(app, r, { indent = '', note = '' } = {}) {
+  const ds = app.ds, prof = ds.profession(r.skill)?.name ?? r.skill;
+  const trainers = ds.zones().flatMap((z) => (z.profTrainers ?? []).filter((e) => ds.profTrainer(e)?.skill === r.skill).map((e) => ({ e, z: z.id })));
+  const zones = [...new Set(trainers.map((t) => t.z))];
+  return {
+    text: `${indent}${r.name} ${dim(`Recipe  ${prof} ${r.orange}`)}${note}  ${zones.length ? `${dim(`${prof} trainers in`)} ${zonesLabel(app, zones)}` : ''}`,
+    detail: () => [bold(r.name), dim(`${prof} ${r.orange}`), '', cyan('Makes'), `  ${app.itemLabel(r.product.item)}${r.product.count > 1 ? ` x${r.product.count}` : ''}`, '', cyan('Reagents'), ...r.reagents.map((g) => `  ${g.count} ${app.itemLabel(g.item)}`), '', dim('Enter: the wiki page (who teaches it, what it needs)')],
+    act: () => app.push(wikiPage(app, 'recipe', r.id)),
+  };
+}
+
+/** An item hit: the item line, then every place that gives it, best first. */
+function itemRows(app, entry) {
+  const ds = app.ds, it = ds.item(entry);
+  if (!it) return [];
+  const rows = [{ text: `${qualityPaint(it.quality)(bold(it.name))} ${dim(`Item${it.typeName ? `  ${it.typeName}` : ''}${it.itemLevel ? `  ilvl ${it.itemLevel}` : ''}`)}`, detail: () => [...itemLines(app, it), '', dim('Enter: the wiki page, every source')], act: () => app.push(wikiPage(app, 'item', entry)) }];
+  const { sources, more } = wikiSourceIndexSync(ds).itemSources(entry);
+  const here = app.ch.zoneId;
+  const pi = placeIndex(ds);
+  const nodeNames = new Set(pi.nodeRows.map((r) => r.lower));
+  // One row per place, not per DB row: a herb is one gather source per zone and one gameobject per spawn
+  // entry, and the gameobject IS the node. Same-name sources merge, their zones union, the best chance kept.
+  const merged = new Map();
+  for (const s of sources) {
+    let zones = [], key = `${s.kind}:${s.ref}`;
+    if (s.kind === 'vendor' || s.kind === 'drop' || s.kind === 'skin' || s.kind === 'pickpocket') { const p = npcPlace(app, s.ref); zones = p.zones.length ? p.zones : p.dungeon ? [p.dungeon.portalZone] : []; }
+    else if (s.kind === 'gather') { const n = ds.gatherNode(s.ref); if (!n) continue; key = `gather:${n.name.toLowerCase()}`; zones = s.zone ? [s.zone] : pi.nodeZones.get(s.ref) ?? []; }
+    else if (s.kind === 'object' || s.kind === 'fishing') { const go = ds.gameObject(s.ref); if (!go) continue; if (nodeNames.has(go.name.toLowerCase())) continue; key = `${s.kind}:${go.name.toLowerCase()}`; zones = pi.objectZones.get(s.ref) ?? []; }
+    else if (s.kind === 'quest-reward') zones = ds.quest(s.ref)?.starterZones ?? [];
+    const m = merged.get(key);
+    if (m) { for (const z of zones) if (!m.zones.includes(z)) m.zones.push(z); if ((s.chance ?? 0) > (m.s.chance ?? 0)) m.s = { ...s, zone: undefined }; continue; }
+    merged.set(key, { s: { ...s }, zones: [...zones] });
+  }
+  const placed = [...merged.values()].map((m) => ({ ...m, hereNow: m.zones.includes(here) }));
+  // The reachable before the unreachable, where-you-stand first, then by kind (a shop beats a 2% drop), then by chance.
+  placed.sort((a, b) => (b.zones.length > 0) - (a.zones.length > 0) || b.hereNow - a.hereNow || (SOURCE_ORDER[a.s.kind] ?? 99) - (SOURCE_ORDER[b.s.kind] ?? 99) || (b.s.chance ?? 0) - (a.s.chance ?? 0));
+  const indent = '    ';
+  let shown = 0;
+  for (const { s, zones } of placed) {
+    if (shown >= MAX_PLACES_PER_ITEM) break;
+    const pct = s.chance != null ? dim(`  ${Math.round(s.chance * 10) / 10}%${s.questOnly ? ' (quest)' : ''}`) : '';
+    if (s.kind === 'vendor') {
+      const v = ds.vendor(s.ref);
+      if (!v) continue;
+      const price = it.buyPrice ? dim(`  ${moneyText(Math.floor(it.buyPrice * vendorPriceMultiplierFor(ds, app.ch, v.entry)))}`) : '';
+      rows.push(npcRow(app, s.ref, { indent: `${indent}${dim('sold by')} `, note: price }));
+    } else if (s.kind === 'drop' || s.kind === 'skin' || s.kind === 'pickpocket') {
+      if (!ds.creature(s.ref)) continue;
+      rows.push(npcRow(app, s.ref, { indent: `${indent}${dim(s.kind === 'drop' ? 'dropped by' : s.kind === 'skin' ? 'skinned from' : 'picked from')} `, note: pct }));
+    } else if (s.kind === 'gather') {
+      const n = ds.gatherNode(s.ref);
+      if (!n) continue;
+      rows.push(nodeRow(app, { id: n.id, name: n.name, zones }, { indent: `${indent}${dim('gathered from')} `, note: pct }));
+    } else if (s.kind === 'object' || s.kind === 'fishing') {
+      const go = ds.gameObject(s.ref);
+      if (!go) continue;
+      rows.push(objectRow(app, go, { indent: `${indent}${dim(s.kind === 'fishing' ? 'fished from' : 'found in')} `, note: pct, zones }));
+    } else if (s.kind === 'quest-reward') {
+      const q = ds.quest(s.ref);
+      if (!q) continue;
+      rows.push(questRow(app, q, { indent: `${indent}${dim('reward from')} `, note: s.choice ? dim('  (a choice)') : '' }));
+    } else if (s.kind === 'crafted') {
+      const r = ds.recipe(s.ref);
+      if (!r) continue;
+      rows.push(recipeRow(app, r, { indent: `${indent}${dim('crafted with')} ` }));
+    } else continue;
+    shown++;
+  }
+  const rest = placed.length - shown + more;
+  if (rest > 0) rows.push({ text: `${indent}${dim(`and ${plural(rest, 'more source')}: open the wiki page`)}`, act: () => app.push(wikiPage(app, 'item', entry)) });
+  if (!placed.length && !more) rows.push(H(`${indent}${dim('No known source: not sold, dropped, gathered or crafted.')}`));
+  return rows;
+}
+
+/** The rows for one search hit. */
+function hitRows(app, r) {
+  const ds = app.ds;
+  switch (r.kind) {
+    case 'item': return itemRows(app, r.id);
+    case 'npc': return [npcRow(app, r.id)];
+    case 'zone': { const z = ds.zone(r.id); return z ? [zoneRow(app, z)] : []; }
+    case 'dungeon': { const d = ds.instance(r.id); return d ? [dungeonRow(app, d)] : []; }
+    case 'node': return [nodeRow(app, r)];
+    case 'object': { const go = ds.gameObject(r.id); return go ? [objectRow(app, go)] : []; }
+    case 'quest': { const q = ds.quest(r.id); return q ? [questRow(app, q)] : []; }
+    case 'recipe': { const rc = ds.recipe(r.id); return rc ? [recipeRow(app, rc)] : []; }
+    default: return [];
+  }
+}
+
+// ---- the dialog ----------------------------------------------------------------------------------------------
+
+/** The search window. `query` starts it filled in. */
+export function worldSearchDialog(app, query = '') {
+  const s = { query };
+  const view = {
+    id: 'world-search', title: 'Search the world', hint: 'Enter: go there / open',
+    keys: {
+      s: { hint: 'search', fn: (a) => a.prompt('Find in the world: ', (t) => { s.query = t; view.cursor = 0; view.scroll = 0; a.render(); }, s.query) },
+      w: { hint: 'wiki', fn: (a, row) => { if (row?.data?.entry) a.push(wikiPage(a, 'npc', row.data.entry)); else a.flashMsg('Open the wiki with /.'); } },
+    },
+    rows(a) {
+      const rows = [H(s.query ? `Find: ${yellow(s.query)}` : dim('Press s and type a name: an item, a vendor, a creature, a dungeon, an ore or herb, a zone...')), H('')];
+      if (!s.query.trim()) {
+        rows.push(H(dim('  "mining pick" lists who sells one and where they stand; "copper vein" the zones it is mined in;')), H(dim('  "deadmines" the entrance; "hogger" where he prowls. Enter travels there, or opens it when you are there.')));
+        return rows;
+      }
+      const hits = worldSearch(searchPool(a.ds), wikiTokens(s.query));
+      if (!hits.length) { rows.push(H(dim('  Nothing by that name. The wiki (/) searches spells and talents too.'))); return rows; }
+      for (const r of hits.slice(0, MAX_HITS)) rows.push(...hitRows(a, r));
+      if (hits.length > MAX_HITS) rows.push(H(''), H(dim(`  ${hits.length - MAX_HITS} more matches. Narrow the search.`)));
+      return rows;
+    },
+  };
+  return view;
+}
+
+/** s on the World tab: open the search and start typing. */
+export function openWorldSearch(app, query = '') {
+  const v = worldSearchDialog(app, query);
+  app.push(v);
+  if (!query) v.keys.s.fn(app);
+}