azeroth-shell 0.1.2 → 0.2.0

package/src/cli/combatLogFormat.ts

@@ -333,6 +333,28 @@ function wrap(
   return { segs, cls: lineCls(type, source, crit), type, source, dest };
 }
 
+/**
+ * One thing happening reads as one line. The engine reports a stance as a form change plus its aura,
+ * a multi-effect aura once per effect, and a buff or damageless debuff as its aura plus a 0 spell_hit
+ * the meters count as the cast. The log keeps the first aura line and drops the rest.
+ */
+export function dropLogRepeats(events: readonly CombatEvent[]): CombatEvent[] {
+  const key = (t: number, unit: Side, name: string, on: boolean) => `${t}|${unit}|${name}|${on}`;
+  const auras = new Set<string>();
+  for (const ev of events) if (ev.kind === 'aura' && ev.applied) auras.add(key(ev.t, ev.actor, ev.name, true));
+  const seen = new Set<string>();
+  return events.filter((ev) => {
+    if (ev.kind === 'spell_hit') {
+      return !(ev.amount === 0 && (ev.result === 'hit' || ev.result === 'crit') && ev.target != null && auras.has(key(ev.t, ev.target, ev.name, true)));
+    }
+    if (ev.kind !== 'aura' && ev.kind !== 'form') return true;
+    const k = key(ev.t, ev.actor, ev.name, ev.kind === 'aura' ? ev.applied : !!ev.form);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+
 /** Format one combat event into 1.12 combat-log wording. Null = drop the row. */
 export function formatCombatLog(ev: CombatEvent, names: CombatLogNames): FormattedCombatLog | null {
   const who = (a: Side) => whoOf(a, names);

package/src/cli/gzLoader.mjs

@@ -1,20 +1,62 @@
 // Module hooks: an `import x from './t.json' with { type: 'json' }` whose file is missing resolves to
 // `t.json.gz` and is gunzipped on load. Lets every bake table ship gzipped without touching the
 // 42 modules that static-import one. Registered in-thread by src/cli/register.mjs.
-// Also strips .ts under node_modules (an npm install), where Node refuses to strip types itself.
-import { existsSync, readFileSync } from 'node:fs';
+//
+// Every .ts module is also type-stripped here instead of by Node, with the stripped JS cached on disk
+// under $AZSH_HOME/cache: Node's own stripper runs its wasm over all 900+ engine files on every launch
+// (about a second), and deciding each file's module kind walks up for a package.json; a cache hit skips
+// both. Stripping keeps line positions, so stack traces stay right. Set AZSH_NO_JS_CACHE to bypass.
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { stripTypeScriptTypes } from 'node:module';
 import { gunzipSync } from 'node:zlib';
 import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CACHE_DIR = process.env.AZSH_NO_JS_CACHE ? null : join(process.env.AZSH_HOME ?? join(homedir(), '.azsh'), 'cache', 'js');
+let cacheReady = false;
+
+/** Stripped source for one .ts file: from the cache when its stamp (size, mtime, Node version) still matches. */
+function stripCached(path) {
+  const st = statSync(path);
+  const stamp = `// ${process.version} ${st.size} ${Math.floor(st.mtimeMs)}\n`;
+  const file = CACHE_DIR && join(CACHE_DIR, `${createHash('sha1').update(path).digest('hex').slice(0, 20)}.mjs`);
+  if (file) {
+    try {
+      const cached = readFileSync(file, 'utf8');
+      if (cached.startsWith(stamp)) return cached.slice(stamp.length);
+    } catch { /* miss */ }
+  }
+  // The stripper announces itself as experimental on its first call; that would print over the screen.
+  const warn = process.emitWarning;
+  process.emitWarning = () => {};
+  let source;
+  try { source = stripTypeScriptTypes(readFileSync(path, 'utf8')); }
+  finally { process.emitWarning = warn; }
+  if (file) {
+    try {
+      if (!cacheReady) { mkdirSync(CACHE_DIR, { recursive: true }); cacheReady = true; }
+      const tmp = `${file}.${process.pid}.tmp`; // another launch filling the same entry must not read half a file
+      writeFileSync(tmp, stamp + source);
+      renameSync(tmp, file);
+    } catch { /* a read-only home: strip every launch */ }
+  }
+  return source;
+}
 
 export function resolve(specifier, context, next) {
-  if (specifier.endsWith('.json') && /^\.\.?\//.test(specifier) && context.parentURL) {
+  if (!/^\.\.?\//.test(specifier) || !context.parentURL) return next(specifier, context);
+  if (specifier.endsWith('.json')) {
     const url = new URL(specifier, context.parentURL);
     const path = fileURLToPath(url);
     if (!existsSync(path) && existsSync(`${path}.gz`)) {
       return { url: `${url.href}.gz`, format: 'json', shortCircuit: true };
     }
   }
+  // Node's own resolve labels a .ts file's format by walking up to its package.json, once per file; every
+  // engine module is ESM, so say so here and skip the walk. A missing file still fails, in `load`.
+  if (specifier.endsWith('.ts')) return { url: new URL(specifier, context.parentURL).href, format: 'module', shortCircuit: true };
   return next(specifier, context);
 }
 
@@ -23,9 +65,8 @@ export function load(url, context, next) {
     const source = gunzipSync(readFileSync(fileURLToPath(url))).toString('utf8');
     return { format: 'json', source, shortCircuit: true };
   }
-  if (url.endsWith('.ts') && url.includes('/node_modules/')) {
-    const source = stripTypeScriptTypes(readFileSync(fileURLToPath(url), 'utf8'));
-    return { format: 'module', source, shortCircuit: true };
+  if (url.endsWith('.ts') && url.startsWith('file:')) {
+    return { format: 'module', source: stripCached(fileURLToPath(url)), shortCircuit: true };
   }
   return next(url, context);
 }

package/src/cli/hdArt.mjs

@@ -0,0 +1,81 @@
+// The full-size art sixel draws (sixel.mjs, modelArt.mjs): creature sprites, icons and one gear file per body,
+// about 72 MB, too much to ship to every terminal that cannot draw it. The package carries only the manifest
+// (src/data/hd-art.json: the release tag, and each file's name, size and sha256); the files are assets of that
+// GitHub release, fetched on request into ~/.azsh/art/<tag>/ and checked against the manifest.
+//
+// A checkout that baked them (npm run art:hd) has them in src/data and uses those; AZSH_ART_DIR points
+// anywhere else. scripts/publish-hd-art.mjs writes the manifest and uploads a release.
+import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Readable } from 'node:stream';
+
+const DATA_DIR = fileURLToPath(new URL('../data/', import.meta.url));
+
+let manifest;
+/** { tag, base, files: [{ name, path, size, sha256 }] }, or null when the package has none. */
+export function hdManifest() {
+  if (manifest !== undefined) return manifest;
+  try { manifest = JSON.parse(readFileSync(join(DATA_DIR, 'hd-art.json'), 'utf8')); } catch { manifest = null; }
+  return manifest;
+}
+
+/** Where downloaded art goes: ~/.azsh/art/<tag>/. */
+export function downloadDir() {
+  const m = hdManifest();
+  return process.env.AZSH_ART_DIR ?? join(process.env.AZSH_HOME ?? join(homedir(), '.azsh'), 'art', m?.tag ?? 'local');
+}
+
+/** The file to read for an art path ("model-art-hd.bin.br", "gear-art-hd/orc-male.bin.br"): the download, or a
+ *  checkout's own bake (unless AZSH_ART_DIR says where the art is). Null when neither is there. */
+export function hdArtPath(path) {
+  const got = join(downloadDir(), path);
+  if (existsSync(got)) return got;
+  if (process.env.AZSH_ART_DIR) return null;
+  const baked = join(DATA_DIR, path);
+  return existsSync(baked) ? baked : null;
+}
+
+/** The manifest's files not on disk yet. */
+export function missingHdArt() {
+  const m = hdManifest();
+  return m ? m.files.filter((f) => !hdArtPath(f.path)) : [];
+}
+
+/** Bytes still to fetch. */
+export const missingHdBytes = () => missingHdArt().reduce((n, f) => n + f.size, 0);
+
+/**
+ * Fetch every missing file from the release. `onProgress(done, total)` in bytes. Each file is written beside
+ * its place, hashed as it streams, and moved in only when the sha256 matches. Resolves { ok, reason }.
+ */
+export async function downloadHdArt(onProgress = () => {}) {
+  const m = hdManifest();
+  if (!m) return { ok: false, reason: 'This build has no art manifest.' };
+  const todo = missingHdArt(), total = todo.reduce((n, f) => n + f.size, 0);
+  let done = 0;
+  for (const f of todo) {
+    const dest = join(downloadDir(), f.path), part = `${dest}.part`;
+    mkdirSync(dirname(dest), { recursive: true });
+    try {
+      const res = await fetch(`${m.base}${f.name}`);
+      if (!res.ok || !res.body) return { ok: false, reason: `${f.name}: HTTP ${res.status}` };
+      const hash = createHash('sha256'), out = createWriteStream(part);
+      for await (const chunk of Readable.fromWeb(res.body)) {
+        hash.update(chunk);
+        if (!out.write(chunk)) await new Promise((r) => out.once('drain', r));
+        done += chunk.length;
+        onProgress(done, total);
+      }
+      await new Promise((r, j) => out.end((e) => (e ? j(e) : r())));
+      if (hash.digest('hex') !== f.sha256) { rmSync(part, { force: true }); return { ok: false, reason: `${f.name} did not match its checksum` }; }
+      renameSync(part, dest);
+    } catch (e) {
+      rmSync(part, { force: true });
+      return { ok: false, reason: `${f.name}: ${e.message}` };
+    }
+  }
+  return { ok: true };
+}

package/src/cli/iconArt.mjs

@@ -0,0 +1,135 @@
+// Spell and item icons for the windowed game, drawn as truecolour half-block cells like the model art
+// (modelArt.mjs): a cell is ▀ with the top pixel in the foreground and the bottom one in the background.
+// The pack src/data/icon-art.bin.gz (scripts/bake-icon-art.mjs) holds every icon the spells, items,
+// talents and professions name at three sizes a pixel each: 8x8 (4 lines, a detail pane), 6x6 (3 lines, a
+// bag grid or an ability bar) and 4x4 (2 lines, a list row or an aura strip). Icons are keyed by the icon
+// name the tables carry (`spell_holy_holysmite`, `inv_ore_truesilver_01`). No pack, or NO_COLOR: no art,
+// never an error.
+import { readFileSync } from 'node:fs';
+import { gunzipSync } from 'node:zlib';
+import { useColor, vis, wrapLines } from './text.mjs';
+import { sixelIconCells } from './sixel.mjs';
+
+const PACK_URL = new URL('../data/icon-art.bin.gz', import.meta.url);
+const SIZES = [8, 6, 4];
+const BYTES = SIZES.map((g) => g * g * 3);
+const RECORD = BYTES.reduce((a, b) => a + b, 0);
+
+let index = null; // name -> byte offset of the 8x8 square
+let pack = null;
+
+function load() {
+  if (index) return index;
+  index = new Map();
+  try {
+    pack = gunzipSync(readFileSync(PACK_URL));
+    if (pack.toString('ascii', 0, 5) !== 'AZICO' || pack[5] !== 1) return index;
+    const count = pack.readUInt32LE(6);
+    let off = 10;
+    for (let i = 0; i < count && off < pack.length; i++) {
+      const len = pack[off];
+      index.set(pack.toString('ascii', off + 1, off + 1 + len), off + 1 + len);
+      off += 1 + len + RECORD;
+    }
+  } catch { pack = null; }
+  return index;
+}
+
+/** Are icons drawable at all (colour on and the pack present)? Cheap once loaded. */
+export const iconsOn = () => useColor && load().size > 0;
+
+/** Is there art for this icon name? */
+export const hasIcon = (name) => !!name && useColor && load().has(String(name).toLowerCase());
+
+/** Lines an icon of `cols` pixels a side takes: 4, 3 or 2. */
+export const iconRows = (cols) => cols / 2;
+
+const RESET = '\x1b[0m';
+const cache = new Map();
+const CACHE_MAX = 768;
+
+/**
+ * The icon `name` as `cols / 2` rows of `cols` cells, each cell a self-contained painted ▀ (it resets after
+ * itself), or null when there is no art. `tone` 'gray' draws it desaturated and dark: a talent you cannot
+ * take yet. A grid (iconGrid.mjs) lays cells one by one so it can paint a rank or a count over a corner;
+ * where the terminal draws sixel the icon is a picture instead (sixel.mjs), and `holes` ([{ x, y, w }] in
+ * cells) are the corners it leaves see-through for that text.
+ */
+export function iconCells(name, cols = 4, tone = '', holes = []) {
+  if (!name || !useColor) return null;
+  const six = sixelIconCells(name, cols, tone, holes);
+  if (six) return six;
+  const key = `${String(name).toLowerCase()}|${cols}|${tone}`;
+  const hit = cache.get(key);
+  if (hit !== undefined) return hit;
+  const sz = SIZES.indexOf(cols);
+  const off = load().get(String(name).toLowerCase());
+  let rows = null;
+  if (off != null && sz >= 0) {
+    let start = off;
+    for (let i = 0; i < sz; i++) start += BYTES[i];
+    const px = (k) => {
+      const r = pack[k], g = pack[k + 1], b = pack[k + 2];
+      if (tone !== 'gray') return `${r};${g};${b}`;
+      const l = Math.round((0.3 * r + 0.59 * g + 0.11 * b) * 0.6);
+      return `${l};${l};${l}`;
+    };
+    rows = [];
+    for (let y = 0; y < cols; y += 2) {
+      const row = [];
+      for (let x = 0; x < cols; x++) row.push(`\x1b[38;2;${px(start + (y * cols + x) * 3)}m\x1b[48;2;${px(start + ((y + 1) * cols + x) * 3)}m▀${RESET}`);
+      rows.push(row);
+    }
+  }
+  if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value);
+  cache.set(key, rows);
+  return rows;
+}
+
+/**
+ * The icon `name` as `cols / 2` lines of `cols` half-block cells (cols 8, 6 or 4), or null when there is no
+ * art. Each line resets at its end, so it can sit inside any painted text.
+ */
+export function iconArt(name, cols = 4, tone = '') {
+  return iconCells(name, cols, tone)?.map((row) => row.join('')) ?? null;
+}
+
+/** A blank the size of an icon, for rows in a list that mixes icons and none. */
+export const iconBlank = (cols = 4) => Array.from({ length: cols / 2 }, () => ' '.repeat(cols));
+
+/**
+ * `lines` with the icon beside their head: the first `cols / 2` lines get an icon cell row and a space
+ * before them (the name, the kind, the first facts), the rest run on at full width. Without art the lines
+ * come back as they are. The result remembers its parts (`iconHead`) so a pane can wrap it with
+ * wrapIconLines and keep the text beside the icon instead of wrapping under it.
+ */
+export function withIcon(name, lines, cols = 8) {
+  const art = iconArt(name, cols);
+  if (!art) return lines;
+  const out = [];
+  for (let i = 0; i < Math.max(art.length, lines.length); i++) out.push(i < art.length ? `${art[i]} ${lines[i] ?? ''}` : lines[i]);
+  out.iconHead = { art, lines };
+  return out;
+}
+
+/**
+ * Detail lines wrapped to `width`. Beside an icon (a withIcon result) the text wraps to the room right of
+ * it, so a long first sentence never runs back under the art; once the icon's rows are used the rest of
+ * that sentence and every later line take the full width.
+ */
+export function wrapIconLines(lines, width) {
+  const wrap = (l, w) => (vis(l) > w ? wrapLines(l, w) : [l]);
+  const head = lines?.iconHead;
+  if (!head) return (lines ?? []).flatMap((l) => wrap(l, width));
+  const { art, lines: text } = head;
+  const beside = width - vis(art[0]) - 1;
+  const out = [];
+  for (const l of text) {
+    if (out.length >= art.length) { out.push(...wrap(l, width)); continue; }
+    const pieces = wrap(l, beside);
+    while (pieces.length && out.length < art.length) out.push(`${art[out.length]} ${pieces.shift()}`);
+    if (pieces.length) out.push(...wrap(pieces.join(' '), width));
+  }
+  while (out.length < art.length) out.push(art[out.length]);
+  return out;
+}

package/src/cli/iconGrid.mjs

@@ -0,0 +1,100 @@
+// Icon grids for views that draw their list side as a picture instead of rows: the paperdoll's slots round
+// your body (tuiGear.mjs) and the talent trees' 4x7 nodes (tuiTalents.mjs). A grid is a canvas of one-column
+// cells, each a painted character that resets after itself, so icons, frames, arrows and text can be laid
+// over one another and joined into lines at the end. The view keeps its rows (detail, Enter, row keys all
+// work as in a list); the grid only decides where each row is drawn and where the arrows move the cursor.
+import { iconCells } from './iconArt.mjs';
+
+const RESET = '\x1b[0m';
+const SGR_RE = /\x1b\[[0-9;]*m/g;
+
+/** A painted string split into one string per visible column, each carrying the paint open at it. A sixel
+ *  marker (sixel.mjs) is no paint: it rides on the next cell only. */
+export function splitCells(s) {
+  const out = [];
+  let open = '', mark = '';
+  const str = String(s);
+  let i = 0;
+  while (i < str.length) {
+    if (str[i] === '\x1b') {
+      SGR_RE.lastIndex = i;
+      const m = SGR_RE.exec(str);
+      if (m && m.index === i && m[0].startsWith('\x1b[9999;')) { mark += m[0]; i += m[0].length; continue; }
+      if (m && m.index === i) { open = m[0] === RESET || m[0] === '\x1b[m' ? '' : open + m[0]; i += m[0].length; continue; }
+    }
+    out.push(mark + (open ? `${open}${str[i]}${RESET}` : str[i]));
+    mark = '';
+    i++;
+  }
+  return out;
+}
+
+/** A blank canvas `w` columns by `h` lines. */
+export function canvas(w, h) {
+  const cells = Array.from({ length: Math.max(0, h) }, () => Array(Math.max(0, w)).fill(' '));
+  const put = (x, y, c) => { if (y >= 0 && y < h && x >= 0 && x < w) cells[y][x] = c; };
+  return {
+    w, h, put,
+    /** Painted text from (x, y), cut at `max` columns (default: the canvas edge). */
+    text(x, y, s, max = w - x) { splitCells(s).slice(0, Math.max(0, max)).forEach((c, k) => put(x + k, y, c)); },
+    /** Lines of art (equal widths) with their top-left at (x, y); blank art cells leave the canvas as it is. */
+    art(x, y, lines) { lines.forEach((l, dy) => splitCells(l).forEach((c, dx) => { if (c !== ' ') put(x + dx, y + dy, c); })); },
+    lines: () => cells.map((r) => r.join('')),
+  };
+}
+
+const paint = (codes, ch) => `\x1b[${codes}m${ch}${RESET}`;
+const EMPTY_BG = '48;2;34;34;38';
+
+/**
+ * One framed icon at (x, y): a column of frame each side of an `s`-wide icon (s / 2 lines), so a cell is
+ * s + 2 columns. The frame is thin in `frame` (an SGR code: the item's quality, the talent's state) and
+ * thick and bright when `selected`. No icon draws a dark slot with `empty` (a short label) on its middle
+ * line. `badge` (a rank, a count) sits in the bottom-right corner and `mark` (an upgrade arrow) top-right,
+ * each `{ text, codes }` on black.
+ */
+export function drawCell(cv, x, y, s, { icon, tone = '', frame = '90', selected = false, empty = '', badge = null, mark = null } = {}) {
+  const rows = s / 2;
+  const holes = [badge?.text && { x: s - badge.text.length, y: rows - 1, w: badge.text.length }, mark?.text && { x: s - mark.text.length, y: 0, w: mark.text.length }].filter(Boolean);
+  const art = icon ? iconCells(icon, s, tone, holes) : null;
+  for (let dy = 0; dy < rows; dy++) {
+    cv.put(x, y + dy, selected ? paint('1;97', '▐') : paint(frame, '▕'));
+    cv.put(x + s + 1, y + dy, selected ? paint('1;97', '▌') : paint(frame, '▏'));
+    for (let dx = 0; dx < s; dx++) cv.put(x + 1 + dx, y + dy, art ? art[dy][dx] : paint(EMPTY_BG, ' '));
+  }
+  if (!art && empty) {
+    const label = empty.slice(0, s);
+    const lx = x + 1 + Math.floor((s - label.length) / 2);
+    [...label].forEach((ch, k) => cv.put(lx + k, y + Math.floor((rows - 1) / 2), paint(`${EMPTY_BG};38;2;110;110;118`, ch)));
+  }
+  const corner = (o, yy) => [...o.text].reverse().forEach((ch, k) => cv.put(x + s - k, yy, paint(`48;2;0;0;0;${o.codes}`, ch)));
+  if (badge?.text) corner(badge, y + rows - 1);
+  if (mark?.text) corner(mark, y);
+}
+
+/**
+ * Where the cursor goes from row `cur` toward `dir` among the drawn points `{ i, x, y, g? }`, or null.
+ * Up and down take the nearest point that way scored `|dy| * dyW + |dx| * dxW`, inside the same group `g`
+ * when points have one (one talent tree). Left and right take the nearest point that way on the same line,
+ * or up to `slack` lines off when that line has none.
+ */
+export function gridStep(pts, cur, dir, { dyW = 1, dxW = 10, slack = 0 } = {}) {
+  const at = pts.find((p) => p.i === cur) ?? pts[0];
+  if (!at) return null;
+  if (at.i !== cur) return at.i;
+  let best = null, bestScore = Infinity;
+  for (const p of pts) {
+    if (p === at) continue;
+    const dx = p.x - at.x, dy = p.y - at.y;
+    let score;
+    if (dir === 'up' || dir === 'down') {
+      if ((dir === 'up' ? -dy : dy) <= 0 || (at.g != null && p.g !== at.g)) continue;
+      score = Math.abs(dy) * dyW + Math.abs(dx) * dxW;
+    } else {
+      if ((dir === 'left' ? -dx : dx) <= 0 || Math.abs(dy) > slack) continue;
+      score = Math.abs(dy) * 100 + Math.abs(dx);
+    }
+    if (score < bestScore) { bestScore = score; best = p; }
+  }
+  return best?.i ?? null;
+}