azeroth-shell 0.1.2 → 0.3.0

package/src/cli/modelArt.mjs

@@ -0,0 +1,298 @@
+// Model art for the windowed game, drawn as truecolour half-block cells (▀ with the top pixel in the
+// foreground and the bottom one in the background), two pixels a row. Two packs:
+//   src/data/model-art.bin.gz  (scripts/bake-model-art.mjs)  creature sprites by display id, a palette each
+//   src/data/gear-art.bin.br   (scripts/bake-gear-art.py)    the sixteen player bodies with their skins, faces,
+//                                                            hair and every item appearance, one shared palette
+// A creature is one sprite; a character is a skin with its layers stacked on it (paperdoll.mjs decides the
+// layers). Either is scaled to the room it gets, so the same pack serves a 12-column corner and a 32-column
+// pane. Transparent pixels stay bare spaces, so the art sits on whatever the screen paints behind it. No
+// pack, or NO_COLOR: no art, never an error.
+import { readFileSync } from 'node:fs';
+import { gunzipSync, brotliDecompressSync } from 'node:zlib';
+import { useColor } from './text.mjs';
+import { sixelCreature, sixelImage, sixelOn, forgetSixelPacks } from './sixel.mjs';
+import { hdArtPath } from './hdArt.mjs';
+
+const PACK_URL = new URL('../data/model-art.bin.gz', import.meta.url);
+const GEAR_URL = new URL('../data/gear-art.bin.br', import.meta.url); // brotli: a fifth smaller than gzip for a hundred thousand tiny images
+
+// ---- the creature pack ------------------------------------------------------------------------------
+
+let index = null; // displayId -> byte offset of the sprite header in `pack`
+let pack = null;
+
+function load() {
+  if (index) return index;
+  index = new Map();
+  try {
+    pack = gunzipSync(readFileSync(PACK_URL));
+    if (pack.toString('ascii', 0, 5) !== 'AZART' || pack[5] !== 1) return index;
+    const count = pack.readUInt32LE(6);
+    let off = 10;
+    for (let i = 0; i < count && off + 7 <= pack.length; i++) {
+      const id = pack.readUInt32LE(off), w = pack[off + 4], h = pack[off + 5], palLen = pack[off + 6];
+      index.set(id, off);
+      off += 7 + palLen * 3 + w * h;
+    }
+  } catch { pack = null; }
+  return index;
+}
+
+/** The baked sprite for a display id: `{ w, h, pal, idx }` (idx 0 is transparent, n is pal[n-1]), or null. */
+export function spriteOf(displayId) {
+  const off = load().get(displayId);
+  if (off == null) return null;
+  const w = pack[off + 4], h = pack[off + 5], palLen = pack[off + 6];
+  const palStart = off + 7, idxStart = palStart + palLen * 3;
+  return { w, h, pal: pack.subarray(palStart, idxStart), idx: pack.subarray(idxStart, idxStart + w * h) };
+}
+
+/** Is there art for this display id? Cheap once the pack is loaded. */
+export const hasArt = (displayId) => useColor && load().has(displayId);
+
+/** A sprite as an image: `rgb` per pixel and an `on` mask (1 where the pixel is drawn). */
+function spriteImage(sp) {
+  const n = sp.w * sp.h, rgb = new Uint8Array(n * 3), on = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    const p = sp.idx[i];
+    if (!p) continue;
+    on[i] = 1;
+    rgb[i * 3] = sp.pal[(p - 1) * 3]; rgb[i * 3 + 1] = sp.pal[(p - 1) * 3 + 1]; rgb[i * 3 + 2] = sp.pal[(p - 1) * 3 + 2];
+  }
+  return { w: sp.w, h: sp.h, rgb, on };
+}
+
+// ---- the gear pack ------------------------------------------------------------------------------------
+
+let gear = null; // { buf, pal, bodies: slug -> { canvas, skins: skin -> offset, overlays: key -> { off, x, y, w, h } }, items: entry -> key }
+
+function loadGear() {
+  if (gear) return gear;
+  gear = { buf: null, pal: null, bodies: new Map(), items: new Map() };
+  try {
+    const buf = brotliDecompressSync(readFileSync(GEAR_URL)); // about 170 ms once, on the first character drawn
+    if (buf.toString('ascii', 0, 6) !== 'AZGEAR' || buf[6] !== 1) return gear;
+    let off = 7;
+    const palLen = buf[off++];
+    const pal = buf.subarray(off, off + palLen * 3); off += palLen * 3;
+    const bodyCount = buf[off++];
+    const bodies = new Map();
+    for (let b = 0; b < bodyCount; b++) {
+      const slugLen = buf[off++];
+      const slug = buf.toString('ascii', off, off + slugLen); off += slugLen;
+      const canvas = buf[off++];
+      const body = { canvas, skins: new Map(), overlays: new Map() };
+      const skinCount = buf[off++];
+      for (let i = 0; i < skinCount; i++) { body.skins.set(buf[off], off + 1); off += 1 + canvas * canvas; }
+      const ovCount = buf.readUInt16LE(off); off += 2;
+      for (let i = 0; i < ovCount; i++) {
+        const keyLen = buf[off++];
+        const key = buf.toString('ascii', off, off + keyLen); off += keyLen;
+        const x = buf[off], y = buf[off + 1], w = buf[off + 2], h = buf[off + 3]; off += 4;
+        body.overlays.set(key, { off, x, y, w, h });
+        off += w * h;
+      }
+      bodies.set(slug, body);
+    }
+    const items = new Map();
+    const itemCount = buf.readUInt16LE(off); off += 2;
+    for (let i = 0; i < itemCount; i++) {
+      const entry = buf.readUInt32LE(off); off += 4;
+      const keyLen = buf[off++];
+      items.set(entry, buf.toString('ascii', off, off + keyLen)); off += keyLen;
+    }
+    gear = { buf, pal, bodies, items };
+  } catch { /* no gear pack: characters draw as bare bodies from the creature pack, or not at all */ }
+  return gear;
+}
+
+/** The gear pack's body for a slug ("human-male"): `{ canvas, skins, overlays }`, or null. */
+export const gearBody = (slug) => (useColor ? loadGear().bodies.get(slug) ?? null : null);
+/** The overlay key ("5-29958": InventoryType-appearance) an item entry draws as, or null. */
+export const gearKeyOfItem = (entry) => loadGear().items.get(entry) ?? null;
+
+/**
+ * A character composed on the gear pack: the body's `skin` with `layers` ({ key, z, mirrored }) stacked
+ * in z order, then cropped and drawn like a creature. A mirrored layer flips about the frame's centre (a
+ * main-hand weapon drawn in the off hand). Null without the pack, the body or room.
+ */
+export function compositeArt(slug, skin, layers, maxCols, maxRows) {
+  if (!useColor || maxCols < 2 || maxRows < 3) return null;
+  const look = `${slug}|${skin}|${layers.map((l) => (l.mirrored ? `~${l.key}` : l.key)).join(',')}`;
+  if (sixelOn()) {
+    const hd = gearBodyHd(slug);
+    const six = hd && sixelImage(`g${look}`, () => {
+      const img = compose(hd, hd.buf, hd.pal, skin, layers);
+      return img && rgbaOf(crop(img));
+    }, maxCols, maxRows);
+    if (six) return six;
+  }
+  const g = loadGear(), body = g.bodies.get(slug);
+  if (!body || !g.buf) return null;
+  const key = `${look}|${maxCols}x${maxRows}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const img = compose(body, g.buf, g.pal, skin, layers);
+  return img ? remember(key, renderImage(crop(img), maxCols, maxRows)) : null;
+}
+
+/** A body's `skin` with `layers` stacked on it, as { w, h, rgb, on } on the body's square canvas; null
+ *  without the skin. The pack (`buf`, `pal`) is the small one or a body's hd file. */
+function compose(body, buf, pal, skin, layers) {
+  const skinOff = body.skins.get(skin) ?? body.skins.get(0);
+  if (skinOff == null) return null;
+  const c = body.canvas, n = c * c, rgb = new Uint8Array(n * 3), on = new Uint8Array(n);
+  const paint = (k, p) => { on[k] = 1; rgb[k * 3] = pal[(p - 1) * 3]; rgb[k * 3 + 1] = pal[(p - 1) * 3 + 1]; rgb[k * 3 + 2] = pal[(p - 1) * 3 + 2]; };
+  for (let k = 0; k < n; k++) { const p = buf[skinOff + k]; if (p) paint(k, p); }
+  for (const l of [...layers].sort((a, b) => a.z - b.z)) {
+    const ov = body.overlays.get(l.key);
+    if (!ov) continue;
+    const x0 = l.mirrored ? c - (ov.x + ov.w) : ov.x;
+    for (let y = 0; y < ov.h; y++) for (let x = 0; x < ov.w; x++) {
+      const p = buf[ov.off + y * ov.w + x];
+      if (!p) continue;
+      const cx = x0 + (l.mirrored ? ov.w - 1 - x : x), cy = ov.y + y;
+      if (cx < 0 || cx >= c || cy >= c) continue;
+      paint(cy * c + cx, p);
+    }
+  }
+  return { w: c, h: c, rgb, on };
+}
+
+/** { w, h, rgb, on } as { w, h, rgba }, the shape sixel.mjs scales. */
+function rgbaOf({ w, h, rgb, on }) {
+  const rgba = new Uint8Array(w * h * 4);
+  for (let i = 0; i < w * h; i++) if (on[i]) { rgba[i * 4] = rgb[i * 3]; rgba[i * 4 + 1] = rgb[i * 3 + 1]; rgba[i * 4 + 2] = rgb[i * 3 + 2]; rgba[i * 4 + 3] = 255; }
+  return { w, h, rgba };
+}
+
+// ---- the hd gear bodies (sixel) -------------------------------------------------------------------------
+
+const gearHd = new Map(); // slug -> { buf, pal, canvas, skins, overlays } or null
+
+/** Forget every full-size pack read or found missing, so the next draw looks again (after a download), and
+ *  the half-block art cached in their place. */
+export function forgetHdArt() { forgetSixelPacks(); gearHd.clear(); cache.clear(); }
+
+/** A body's hd file (scripts/bake-gear-art.py --hd): its palette, then the body section the small pack has
+ *  for it. Version 1 (a release's 128 px bodies) holds the canvas and each x y w h in a byte, version 2 (256 px,
+ *  past a byte) in a u16. Read the first time the body is drawn. */
+function gearBodyHd(slug) {
+  if (gearHd.has(slug)) return gearHd.get(slug);
+  let body = null;
+  try {
+    const buf = brotliDecompressSync(readFileSync(hdArtPath(`gear-art-hd/${slug}.bin.br`)));
+    const version = buf[7];
+    if (buf.toString('ascii', 0, 7) === 'AZGEARB' && (version === 1 || version === 2)) {
+      let off = 8;
+      const n = version === 2 ? 2 : 1, num = (o) => (n === 2 ? buf.readUInt16LE(o) : buf[o]);
+      const palLen = buf[off++];
+      const pal = buf.subarray(off, off + palLen * 3); off += palLen * 3;
+      off += 1 + buf[off]; // the slug again
+      const canvas = num(off); off += n;
+      body = { buf, pal, canvas, skins: new Map(), overlays: new Map() };
+      const skinCount = buf[off++];
+      for (let i = 0; i < skinCount; i++) { body.skins.set(buf[off], off + 1); off += 1 + canvas * canvas; }
+      const ovCount = buf.readUInt16LE(off); off += 2;
+      for (let i = 0; i < ovCount; i++) {
+        const keyLen = buf[off++];
+        const key = buf.toString('ascii', off, off + keyLen); off += keyLen;
+        const x = num(off), y = num(off + n), w = num(off + 2 * n), h = num(off + 3 * n); off += 4 * n;
+        body.overlays.set(key, { off, x, y, w, h });
+        off += w * h;
+      }
+    }
+  } catch { /* no hd file for this body: the half-block art draws it */ }
+  gearHd.set(slug, body);
+  return body;
+}
+
+// ---- drawing ------------------------------------------------------------------------------------------
+
+/** The image cut to its drawn pixels (the whole image when nothing is drawn). */
+function crop(img) {
+  const { w, h, rgb, on } = img;
+  let x0 = w, y0 = h, x1 = -1, y1 = -1;
+  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+    if (on[y * w + x]) { if (x < x0) x0 = x; if (x > x1) x1 = x; if (y < y0) y0 = y; if (y > y1) y1 = y; }
+  }
+  if (x1 < 0) return img;
+  const cw = x1 - x0 + 1, ch = y1 - y0 + 1, crgb = new Uint8Array(cw * ch * 3), con = new Uint8Array(cw * ch);
+  for (let y = 0; y < ch; y++) for (let x = 0; x < cw; x++) {
+    const s = (y + y0) * w + x + x0, d = y * cw + x;
+    con[d] = on[s]; crgb[d * 3] = rgb[s * 3]; crgb[d * 3 + 1] = rgb[s * 3 + 1]; crgb[d * 3 + 2] = rgb[s * 3 + 2];
+  }
+  return { w: cw, h: ch, rgb: crgb, on: con };
+}
+
+// Area-average the image into gw x gh samples: colour from the drawn pixels, coverage from their share.
+function sample(img, gw, gh) {
+  const { w, h, rgb, on } = img;
+  const cw = w / gw, ch = h / gh;
+  const out = new Float32Array(gw * gh * 4);
+  for (let gy = 0; gy < gh; gy++) for (let gx = 0; gx < gw; gx++) {
+    const sx0 = Math.floor(gx * cw), sx1 = Math.max(sx0 + 1, Math.floor((gx + 1) * cw));
+    const sy0 = Math.floor(gy * ch), sy1 = Math.max(sy0 + 1, Math.floor((gy + 1) * ch));
+    let r = 0, g = 0, b = 0, a = 0, n = 0;
+    for (let y = sy0; y < sy1 && y < h; y++) for (let x = sx0; x < sx1 && x < w; x++) {
+      const k = y * w + x;
+      n++;
+      if (!on[k]) continue;
+      r += rgb[k * 3]; g += rgb[k * 3 + 1]; b += rgb[k * 3 + 2]; a++;
+    }
+    const k = (gy * gw + gx) * 4;
+    if (a) { out[k] = r / a; out[k + 1] = g / a; out[k + 2] = b / a; }
+    out[k + 3] = n ? a / n : 0;
+  }
+  return out;
+}
+
+const fg = (s, k) => `\x1b[38;2;${s[k] | 0};${s[k + 1] | 0};${s[k + 2] | 0}m`;
+const bg = (s, k) => `\x1b[48;2;${s[k] | 0};${s[k + 1] | 0};${s[k + 2] | 0}m`;
+const RESET = '\x1b[0m';
+
+/** The image as half-block lines that fit `maxCols` x `maxRows` keeping its proportions; each line as wide as the art. */
+function renderImage(img, maxCols, maxRows) {
+  const scale = Math.min(1, maxCols / img.w, (maxRows * 2) / img.h);
+  const gw = Math.max(1, Math.round(img.w * scale)), gh = Math.max(2, Math.round(img.h * scale) + 1) & ~1;
+  const s = sample(img, gw, gh);
+  const lines = [];
+  for (let y = 0; y < gh; y += 2) {
+    let line = '';
+    for (let x = 0; x < gw; x++) {
+      const t = (y * gw + x) * 4, u = ((y + 1) * gw + x) * 4;
+      const ta = s[t + 3] > 0.5, ua = s[u + 3] > 0.5;
+      if (ta && ua) line += `${fg(s, t)}${bg(s, u)}▀${RESET}`;
+      else if (ta) line += `${fg(s, t)}▀${RESET}`;
+      else if (ua) line += `${fg(s, u)}▄${RESET}`;
+      else line += ' ';
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+const cache = new Map();
+const CACHE_MAX = 96;
+function remember(key, lines) {
+  if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value);
+  cache.set(key, lines);
+  return lines;
+}
+
+/**
+ * A creature's sprite as lines of half-block cells that fit in `maxCols` x `maxRows` (keeping its
+ * proportions), or null when there is no art, no colour, or no room (under 3 rows).
+ */
+export function creatureArt(displayId, maxCols, maxRows) {
+  if (!useColor || maxCols < 2 || maxRows < 3) return null;
+  const six = sixelCreature(displayId, maxCols, maxRows); // real pixels where the terminal draws sixel
+  if (six) return six;
+  const sp = spriteOf(displayId);
+  if (!sp) return null;
+  const key = `${displayId}|${maxCols}x${maxRows}`;
+  return cache.get(key) ?? remember(key, renderImage(spriteImage(sp), maxCols, maxRows));
+}
+
+/** Width in cells of art lines (every line is the same width). */
+export const artWidth = (lines) => (lines?.length ? lines[0].replace(/\x1b\[[0-9;]*m/g, '').length : 0);

package/src/cli/oocPrep.mjs

@@ -0,0 +1,32 @@
+// Out-of-combat prep before a pull: the rotation's buffs phase (armours, Intellect, imbues, conjures, the pet)
+// cast standing still, not on the fight's first ticks. phonecraft autopilotController.ts prepOoc (:889) without
+// its fillMana: the mana the buffs cost stays spent, and the autopilot drinks it back before it pulls.
+import { pickOocAction, useOocPrepItem } from '../autopilot/combatRotation.ts';
+import { maxPower } from '../domain/character/character.ts';
+import { powerType } from '../domain/character/characterStats.ts';
+
+const MAX_PREP_ACTIONS = 8; // each pick is a guarded rule cast once; the cap keeps a refused rule from looping
+
+/** Cast what the buffs phase wants up. Returns the names cast and the mana left as a fraction (1 for non-mana). */
+export function prepOoc(g, ds) {
+  const cast = [];
+  for (let i = 0; i < MAX_PREP_ACTIONS; i++) {
+    const action = pickOocAction(g.rotation(), g.state, ds);
+    if (!action) break;
+    if (action.kind === 'spell') {
+      if (!g.castOutOfCombat(action.spellId).ok) break;
+      cast.push(ds.spell(action.spellId)?.name ?? `spell ${action.spellId}`);
+    } else if (action.kind === 'item') {
+      if (!useOocPrepItem(g, action)) break;
+      cast.push(ds.item(action.itemEntry)?.name ?? `item ${action.itemEntry}`);
+    } else break;
+  }
+  const ch = g.state.char;
+  const max = powerType(ch) === 'mana' ? maxPower(ch, ds) : 0;
+  return { cast: [...new Set(cast)], manaPct: max > 0 ? ch.power / max : 1 };
+}
+
+/** The log line for a prep that cast something, or null. */
+export function prepText(prep) {
+  return prep.cast.length ? `Buffed up: ${prep.cast.join(', ')}` : null;
+}

package/src/cli/paperdoll.mjs

@@ -0,0 +1,76 @@
+// A character (you, a companion, a saved hero) as layers on the gear pack: skin, face, facial hair and hair
+// from the appearance, then every equipped item's appearance overlay in phonecraft's draw order
+// (src/ui/core/paperdollSprite.ts). The pixels are modelArt.mjs's; this file only decides what stacks.
+import { clampAppearance, deterministicAppearance, DEFAULT_APPEARANCE, bodySlug, hairStyleHiddenByHelm } from '../domain/character/appearance.ts';
+import { equippedEntry } from '../domain/items/itemInstance.ts';
+import { compositeArt, gearBody, gearKeyOfItem } from './modelArt.mjs';
+
+// Composite draw order, bottom → top (the skin base is underneath):
+//   face → shirt → legs → feet → chest/robe → waist → tabard → wrist → hands
+//   → facial/beard (over torso gear so long beards drape on chest) → hair → cloak → shoulders → helm
+//   → weapons → off-hand. Appearance and gear share one z space so beard and hair interleave with armour.
+const Z_APPEARANCE = { face: 1, facial: 10, hair: 11 };
+const Z_BY_INVTYPE = {
+  4: 2, 7: 3, 8: 4, 5: 5, 20: 5, 6: 6, 19: 7, 9: 8, 10: 9, 16: 12, 3: 13, 1: 14,
+  13: 15, 17: 15, 21: 15, 15: 15, 25: 15, 26: 15, 14: 16, 22: 16, 23: 16,
+};
+const Z_GEAR_DEFAULT = 15, Z_MIRRORED = 16;
+const WEAPON_SLOTS = new Set(['mainhand', 'offhand', 'ranged']);
+// Overlays are keyed by the item's InventoryType, so a one-hander only exists drawn in the main hand; in the
+// off hand it is mirrored about the frame's centre. Shields and held-in-off-hand items are baked on that side.
+const MAINHAND_INVTYPES = new Set([13, 17, 21]);
+const HUNTER = 3;
+
+// The bake holds every weapon unsheathed, so a hunter with an axe and a gun would swing both: one set is
+// drawn. The class that auto-attacks at range carries the ranged item; everyone else the melee pair.
+// An empty set yields to the other, so a wand-only priest still holds something.
+function drawnWeaponSlots(c) {
+  const hasMelee = equippedEntry(c.equipped?.mainhand) != null || equippedEntry(c.equipped?.offhand) != null;
+  const hasRanged = equippedEntry(c.equipped?.ranged) != null;
+  if (!hasMelee) return new Set(['ranged']);
+  if (!hasRanged || c.cls !== HUNTER) return new Set(['mainhand', 'offhand']);
+  return new Set(['ranged']);
+}
+
+/**
+ * What a subject ({ race, gender, cls, name, equipped, appearance }) composes into: the body slug, the skin
+ * and the layers `{ key, z, mirrored }`. The look is the stored appearance (clamped to the body's choices),
+ * else the deterministic-by-name one companions get, else the default. Null when the pack lacks the body.
+ */
+export function paperdollLayers(c) {
+  const slug = bodySlug(c.race, c.gender);
+  const body = slug ? gearBody(slug) : null;
+  if (!body) return null;
+  const look = c.appearance ? clampAppearance(c.appearance, c.race, c.gender)
+    : c.name ? deterministicAppearance(c.name, c.race, c.gender) : DEFAULT_APPEARANCE;
+  const has = (k) => body.overlays.has(k);
+  const layers = [];
+  const headOn = equippedEntry(c.equipped?.head) != null;
+  const face = `face-${look.face}-skin-${look.skin}`;
+  if (look.face > 0 && has(face)) layers.push({ key: face, z: Z_APPEARANCE.face });
+  // One colour option drives beard as well as scalp; the bake has the per-colour beard where it was good.
+  const facial = has(`facial-${look.facialHair}-${look.hairColor}`) ? `facial-${look.facialHair}-${look.hairColor}`
+    : has(`facial-${look.facialHair}-0`) ? `facial-${look.facialHair}-0` : null;
+  if (facial) layers.push({ key: facial, z: Z_APPEARANCE.facial });
+  // Hair is additive over a bald base: style 0 is none. A helm hides hair, never horns or tusks.
+  const hair = `hair-${look.hairStyle}-${look.hairColor}`;
+  if (look.hairStyle > 0 && !(headOn && hairStyleHiddenByHelm(c.race, c.gender)) && has(hair)) layers.push({ key: hair, z: Z_APPEARANCE.hair });
+  const drawn = drawnWeaponSlots(c);
+  for (const [slot, v] of Object.entries(c.equipped ?? {})) {
+    if (WEAPON_SLOTS.has(slot) && !drawn.has(slot)) continue;
+    const entry = equippedEntry(v);
+    if (entry == null) continue;
+    const key = gearKeyOfItem(entry);
+    if (!key || !has(key)) continue;
+    const inv = Number(key.split('-')[0]);
+    const mirrored = slot === 'offhand' && MAINHAND_INVTYPES.has(inv);
+    layers.push({ key, z: mirrored ? Z_MIRRORED : Z_BY_INVTYPE[inv] ?? Z_GEAR_DEFAULT, mirrored });
+  }
+  return { slug, skin: look.skin, layers };
+}
+
+/** The subject drawn in its gear as half-block lines fitting `maxCols` x `maxRows`, or null. */
+export function paperdollArt(c, maxCols, maxRows) {
+  const p = paperdollLayers(c);
+  return p ? compositeArt(p.slug, p.skin, p.layers, maxCols, maxRows) : null;
+}

package/src/cli/perfCheck.mjs

@@ -0,0 +1,56 @@
+// Timing probe for the windowed game: module import, boot stages, heap, a repaint on every tab, and a live fight
+// tick by tick, all headless. Numbers, not pass/fail; run with `npm run check:perf` and compare against the last
+// run. The import is timed from a child process so the loader cache state is what a real launch would see.
+import { execFileSync } from 'node:child_process';
+
+const registerUrl = new URL('./register.mjs', import.meta.url).href;
+const mb = (n) => `${(n / 1048576).toFixed(0)} MB`;
+const now = () => performance.now();
+const heap = () => process.memoryUsage();
+
+// 1. Import cost, twice: the first run fills the stripped-JS cache when it is empty, the second is a normal launch.
+const probe = 'const t = performance.now(); await import(process.argv[1]); console.log((performance.now() - t).toFixed(0));';
+const tuiUrl = new URL('./tui.mjs', import.meta.url).href;
+const importMs = () => Number(execFileSync(process.execPath, ['--import', registerUrl, '--input-type=module', '-e', probe, tuiUrl], { encoding: 'utf8' }).trim());
+console.log(`import tui.mjs: ${importMs()} ms, then ${importMs()} ms`);
+
+// 2. Boot stages and heap, in this process.
+const { bootDataStore } = await import('./bootData.mjs');
+const { HeadlessTerm } = await import('./term.mjs');
+const { App } = await import('./tui.mjs');
+const { newGameState } = await import('../engine/game.ts');
+console.log(`heap after imports: ${mb(heap().heapUsed)}`);
+let t = now(), stage = null;
+const stages = [];
+const ds = bootDataStore((s) => { if (stage) stages.push([stage, now() - t]); stage = s; t = now(); });
+stages.push([stage, now() - t]);
+console.log(`boot: ${stages.map(([s, ms]) => `${s} ${ms.toFixed(0)}`).join(', ')} = ${stages.reduce((a, [, ms]) => a + ms, 0).toFixed(0)} ms; heap ${mb(heap().heapUsed)}, rss ${mb(heap().rss)}`);
+
+// 3. A repaint on every tab, and the world rows alone.
+const term = new HeadlessTerm(110, 34);
+const repo = { async save() {}, async list() { return []; }, async load() { return null; } };
+const app = new App({ term, ds, repo });
+term.open();
+const human = ds.races().find((r) => r.name === 'Human');
+app.startGame(newGameState(ds, human.id, 1, 'Perftest', 12345, 0), 'perftest', Date.now(), true);
+const per = (fn, n = 50) => { fn(); const t0 = now(); for (let i = 0; i < n; i++) fn(); return (now() - t0) / n; };
+const tabs = [];
+for (let i = 0; i < app.tabs.length; i++) { app.switchTab(i); tabs.push(`${app.tabs[i].label} ${per(() => app.render()).toFixed(2)}`); }
+app.switchTab(0);
+console.log(`repaint ms/frame: ${tabs.join(', ')}; world rows alone ${per(() => app.rowsOf(app.top())).toFixed(2)}`);
+
+// 4. A live fight: the engine tick and the repaint timed apart.
+const mobRow = app.rowsOf(app.top()).findIndex((r) => r.data?.creature);
+app.top().cursor = mobRow; term.press('return');
+if (!app.fight) { console.log('FAIL no fight started'); process.exit(1); }
+const s = app.fight.session;
+let n = 0, eng = 0, ren = 0;
+while (app.fight && n < 5000) {
+  const a = now(); const ev = s.tick(); eng += now() - a;
+  app.fight.logEvents(ev);
+  const b = now(); app.render(); ren += now() - b;
+  if (s.ended) { app.fight.finish(); app.fight?.release(); } // no hold on the win: the timing stops at the end
+  n++;
+}
+console.log(`fight: ${n} ticks, engine ${(eng / n).toFixed(2)} ms/tick, repaint ${(ren / n).toFixed(2)} ms/frame`);
+app.closed = true;

package/src/cli/repl.mjs

@@ -4,7 +4,7 @@ import { createInterface } from 'node:readline';
 import { stdin, stdout } from 'node:process';
 import { bootDataStore } from './bootData.mjs';
 import { FileSaveRepository } from './fileRepository.mjs';
-import { formatCombatLog, combatLogPlainText, POWER_MERGE_MS } from './combatLogFormat.ts';
+import { formatCombatLog, combatLogPlainText, dropLogRepeats, POWER_MERGE_MS } from './combatLogFormat.ts';
 import { createGame, newGameState } from '../engine/game.ts';
 import { toSave } from '../persistence/saveShape.ts';
 import { className, raceName } from '../domain/core/ids.ts';
@@ -17,6 +17,7 @@ import { planStep, noteQuestDefeat } from '../autopilot/plan.ts';
 
 // Deaths on one quest before world questing gives up on it and moves to the next.
 const QUEST_SKIP_DEFEATS = 2;
+import { prepOoc, prepText } from './oocPrep.mjs';
 import { pullOpts, squadLogNames, squadModeOf, setSquadMode, SQUAD_MODE_LABEL, SQUAD_MODE_WORDS, COMPANION_HINT_LINES } from './squad.mjs';
 
 const useColor = stdout.isTTY && !process.env.NO_COLOR;
@@ -136,7 +137,8 @@ export async function main(argv = []) {
   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' });
+  // Wall clock, like the TUI: both write the same saves, and a fight-chain stamp reads hours off there.
+  const g = createGame(ds, state, { travelPace: 'instant', wallWorldClock: true });
   if (g.state.char.journey) g.completeJourneyNow();
   // Real createInfo has no starting weapon (ETL gap KI-003); phonecraft's harness.mjs hands one over too.
   if (!save && g.state.char.equipped.mainhand == null) {
@@ -236,7 +238,7 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
     // the web client's combat log does, and drop a zero total (rage decay).
     let pend = null;
     const flush = () => { if (pend && pend.amount > 0) rows.push(line(pend.t, pend.remake(pend.amount))); pend = null; };
-    for (const ev of events) {
+    for (const ev of dropLogRepeats(events)) {
       const row = formatCombatLog(ev, n);
       if (!row) continue;
       if (row.merge) {
@@ -263,6 +265,8 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
 
   /** g.fight with the squad when the squad mode says so; the log names the companions. */
   const quickFight = (entry) => {
+    const buffed = prepText(prepOoc(g, ds));
+    if (buffed) out(dim(`  ${buffed}`));
     const opts = pullOpts(g, ds, buffPace, entry, (l) => out(dim(`  ${l}`)));
     const r = g.fight(entry, opts);
     return { r, logNames: opts ? squadLogNames(g, entry, names()) : names() };
@@ -577,9 +581,12 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
   // the fight as a real-time session and call `settle(outcome)` when it ends; without it fights are
   // auto-resolved by the engine. `ap.lastKind` is the kind of the step `next()` just took.
   // `quest` pins the run to one quest log entry (Do Quest); it stops when that quest is done or stuck.
-  function createAutopilot(args, { liveFight, quest } = {}) {
+  // `maxSteps` overrides the step count in `args` (Infinity: no cap). `clock` gives the run's real elapsed
+  // ms, so the Stop after setting counts wall time; without it the planner's own clock runs (a second a
+  // step, ten a rest).
+  function createAutopilot(args, { liveFight, quest, maxSteps, clock } = {}) {
     const m = String(args ?? '').match(/^(\d+)?\s*(?:farm\s+(.+))?$/i);
-    const steps = Math.min(Number(m?.[1] ?? 20), 5000);
+    const steps = maxSteps ?? Math.min(Number(m?.[1] ?? 20), 5000);
     // A reward choice is the player's to make, so Do Quest stops at the hand-in for those.
     let mode = quest != null ? { kind: 'quest', entry: quest, pin: true, handInByHand: !!ds.quest(quest)?.rewChoiceItems?.length } : { kind: 'quest' };
     if (m?.[2]) {
@@ -599,6 +606,8 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
     let done = false;
     let lastKind = null;
     let lastQuest = null; // the quest the latest step worked on, blamed when the planner gives up
+    let restedForBuffs = false; // the pull's buffs already sent the run to rest once
+    let stopReason = null; // why the run ended: the planner's stop step, or 'steps' when the step budget ran out
     const skipped = [];
     const inLog = (entry) => g.state.questlog.quests.some((qs) => qs.entry === entry && qs.status !== 'turnedIn');
     const blacklist = (entry, why) => {
@@ -617,7 +626,7 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
       } else if (r.outcome === 'win') { prog.consecutiveDefeats = 0; prog.recovering = false; }
     };
     const next = () => {
-      if (done || i >= steps) { done = true; return null; }
+      if (done || i >= steps) { if (!done) stopReason = { reason: 'steps', detail: `${steps} steps done` }; done = true; return null; }
       i++;
       lastKind = null;
       if (isDead()) {
@@ -628,7 +637,17 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
       let step = null;
       let line = '';
       try {
+        if (clock) prog.elapsedMs = clock();
         step = planStep(g.state, ds, mode, cfg, prog);
+        // The planner parks quests it cannot finish on its own; those join the blacklist too, so the
+        // run panel stops offering them as next and later runs skip them from the first step.
+        if (skipping) {
+          for (const e of sets.blockedQuests) {
+            if (questBlacklist.has(e) || !inLog(e)) continue;
+            questBlacklist.add(e); skipped.push(e);
+            out(`${dim(String(i).padStart(3) + '.')} ${yellow(`skipping ${nm(e)}: no way to finish it from here`)}`);
+          }
+        }
         lastKind = step.kind;
         if (prog.eliteNeedsSquad && !companionHintShown && !(g.state.squad ?? []).length) {
           companionHintShown = true;
@@ -638,6 +657,18 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
         switch (step.kind) {
           case 'fight': {
             const c = ds.creature(step.creatureEntry);
+            // Buff before the pull, then drink back what the buffs cost: casting them on the fight's first ticks
+            // sent a mage in at three quarters of its bar. Once per pull, so a buff that falls off while it
+            // drinks is recast without another rest.
+            const prep = prepOoc(g, ds);
+            const buffed = prepText(prep);
+            if (buffed && !restedForBuffs && cfg.restMode === 'eat-then-wait' && prep.manaPct < cfg.recoverToPct) {
+              restedForBuffs = true; prog.recovering = true; lastKind = 'buff';
+              line = `${buffed}  ${dim('rest before the pull')}`;
+              break;
+            }
+            restedForBuffs = false;
+            if (buffed) out(`${dim(String(i).padStart(3) + '.')} ${buffed}`);
             if (liveFight) {
               const started = liveFight(step, (r) => settle(r, step));
               if (!started.ok) { sets.blockedFights.add(step.creatureEntry); line = red(`fight ${c?.name}: ${started.reason}`); }
@@ -669,6 +700,7 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
             const why = `${step.reason}${step.detail ? ` (${step.detail})` : ''}`;
             // Stuck or beaten on a quest: drop that quest and plan again rather than end the run.
             if (skipping && (step.reason === 'noTargets' || step.reason === 'defeated') && lastQuest != null && !sets.blockedQuests.has(lastQuest) && inLog(lastQuest)) { line = blacklist(lastQuest, step.detail ?? step.reason); break; }
+            stopReason = { reason: step.reason, detail: step.detail };
             line = yellow(`autopilot stopped: ${why}`); done = true; break;
           }
           default: line = dim(`unhandled step ${step.kind}`);
@@ -682,7 +714,16 @@ export function createCommands({ g, ds, out, persist, slot, arrive, skipJourney
       return line ? `${dim(String(i).padStart(3) + '.')} ${line}` : '';
     };
     const summary = () => `Level ${g.state.char.level}, ${moneyText(g.state.char.gold)}, ${zoneHere()?.name}.${skipped.length ? ` Skipped: ${skipped.map(nm).join(', ')}.` : ''}`;
-    return { next, steps, summary, get done() { return done; }, get lastKind() { return lastKind; }, get step() { return i; } };
+    // The windowed game reads the rest for its run panel, Run pane and end card: why the run stopped, which
+    // quests it dropped, the death streak and the planner's own clock (one second a step, ten a rest).
+    return {
+      next, steps, summary, mode, skipped,
+      get done() { return done; }, get lastKind() { return lastKind; }, get step() { return i; },
+      get stopReason() { return stopReason; }, get defeats() { return prog.consecutiveDefeats; }, get elapsedMs() { return prog.elapsedMs; },
+      get lastQuest() { return lastQuest; },
+      skips: (entry) => questBlacklist.has(entry) || sets.blockedQuests.has(entry),
+      questDefeats: (entry) => prog.questDefeats.get(entry) ?? 0,
+    };
   }
 
   function runAutopilot(args) {

package/src/cli/rotationText.mjs

@@ -10,14 +10,14 @@ export const SUBJECT_LABEL = { self: 'you', target: 'the enemy', pet: 'your pet'
 const ALLY_ROLE_LABEL = { tank: 'tank', healer: 'healer', damage: 'DPS' };
 const COND_OP_LABEL = { '<': 'less than', '<=': 'at most', '>': 'more than', '>=': 'at least', '==': 'equal to', '!=': 'not equal to' };
 const RAID_JOB_LABEL = { 'main-tank': 'Main tank', 'off-tank': 'Off-tank', healer: 'Healer', dps: 'DPS' };
-const SCHOOL_NAMES = ['Physical', 'Holy', 'Fire', 'Nature', 'Frost', 'Shadow', 'Arcane'];
-const TOTEM_ELEMENTS = ['Fire', 'Earth', 'Water', 'Air'];
-const AOE_MODE_NAMES = { 0: 'auto', 1: 'AoE', 2: 'single-target' };
+export const SCHOOL_NAMES = ['Physical', 'Holy', 'Fire', 'Nature', 'Frost', 'Shadow', 'Arcane'];
+export const TOTEM_ELEMENTS = ['Fire', 'Earth', 'Water', 'Air'];
+export const AOE_MODE_NAMES = { 0: 'auto', 1: 'AoE', 2: 'single-target' };
 
 const titleCase = (k) => k.charAt(0) + k.slice(1).toLowerCase().replace(/_/g, ' ');
-const CREATURE_TYPE_NAME = new Map(Object.entries(CREATURE_TYPE).map(([k, v]) => [v, titleCase(k)]));
-const DISPEL_TYPE_NAME = new Map(Object.entries(DISPEL_TYPE).map(([k, v]) => [v, titleCase(k)]));
-const creatureMaskName = (mask) => {
+export const CREATURE_TYPE_NAME = new Map(Object.entries(CREATURE_TYPE).map(([k, v]) => [v, titleCase(k)]));
+export const DISPEL_TYPE_NAME = new Map(Object.entries(DISPEL_TYPE).map(([k, v]) => [v, titleCase(k)]));
+export const creatureMaskName = (mask) => {
   const hit = [...CREATURE_TYPE_NAME].filter(([t]) => (((1 << (t - 1)) & (mask ?? 0)) !== 0));
   return hit.length ? hit.map(([, n]) => n).join(' or ') : 'that creature type';
 };