@pietrovich/wot-utils 0.2.0

package/dist/index.js

@@ -0,0 +1,2958 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "module";
+import { config } from "dotenv";
+import { resolve as resolve7 } from "path";
+import { Command as Command21 } from "commander";
+
+// src/lib/WGData.ts
+import { mkdirSync } from "fs";
+import { writeFile as writeFile2, access } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join2, basename, resolve as resolve2 } from "path";
+import sharp from "sharp";
+
+// src/lib/config.ts
+function getAppId() {
+  const appId = process.env.WG_APP_ID;
+  if (!appId) {
+    console.error("Error: No application ID. Set WG_APP_ID in .env.");
+    process.exit(1);
+  }
+  return appId;
+}
+
+// src/lib/api.ts
+var WGApiError = class extends Error {
+  constructor(field, code, message) {
+    super(message);
+    this.field = field;
+    this.code = code;
+    this.name = "WGApiError";
+  }
+  field;
+  code;
+};
+
+// src/lib/logger.ts
+import pino from "pino";
+var level = process.env.DEBUG ? "debug" : "info";
+var logger = process.env.LOG_FILE ? pino({ level }, pino.destination(process.env.LOG_FILE)) : pino({
+  level,
+  transport: {
+    target: "pino-pretty",
+    options: { destination: 2, colorize: true }
+  }
+});
+
+// src/lib/cache.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile, rm } from "fs/promises";
+import { isAbsolute, join, resolve } from "path";
+function getCacheDir() {
+  const dir = process.env.WG_CACHE_DIR ?? ".data/cache";
+  if (isAbsolute(dir)) {
+    return dir;
+  }
+  return resolve(process.env.PIE_WOT_CWD ?? process.cwd(), dir);
+}
+function cacheKey(prefix, endpoint, params) {
+  const sorted = Object.entries(params).sort(([a], [b]) => a.localeCompare(b));
+  const input = `${endpoint}:${JSON.stringify(sorted)}`;
+  const hash = createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return `${prefix}-${hash}`;
+}
+async function getCached(prefix, endpoint, params = {}) {
+  const file = join(getCacheDir(), `${cacheKey(prefix, endpoint, params)}.json`);
+  try {
+    const raw = await readFile(file, "utf-8");
+    return JSON.parse(raw).data;
+  } catch {
+    return null;
+  }
+}
+async function setCached(prefix, endpoint, params, data) {
+  const dir = getCacheDir();
+  await mkdir(dir, { recursive: true });
+  const file = join(dir, `${cacheKey(prefix, endpoint, params)}.json`);
+  const entry = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), data };
+  await writeFile(file, JSON.stringify(entry, null, 2));
+}
+async function purgeCache() {
+  await rm(getCacheDir(), { recursive: true, force: true });
+}
+
+// src/lib/WGData.ts
+var IMAGE_KEY = {
+  small: "small_icon",
+  medium: "contour_icon",
+  large: "big_icon",
+  xs: "contour_icon"
+  // derived from medium — cropped locally, not fetched from WG
+};
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function downloadIcon(url, dest) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await writeFile2(dest, buffer);
+}
+var WGData = class {
+  appId;
+  limitOutput = 1e4;
+  iconsBaseDir;
+  vehicles = null;
+  constructor() {
+    this.appId = getAppId();
+    this.limitOutput = process.env.LIMIT_OUTPUT ? Number(process.env.LIMIT_OUTPUT) : 3;
+    const rawCacheDir = process.env.WG_CACHE_DIR ?? ".data/wg/cache";
+    const cacheDir = isAbsolute2(rawCacheDir) ? rawCacheDir : resolve2(process.env.PIE_WOT_CWD ?? process.cwd(), rawCacheDir);
+    this.iconsBaseDir = join2(cacheDir, "..", "icons");
+    for (const size of Object.keys(IMAGE_KEY)) {
+      mkdirSync(join2(this.iconsBaseDir, size), { recursive: true });
+    }
+  }
+  async getVehicles() {
+    if (!this.vehicles) {
+      const endpoint = "encyclopedia/vehicles";
+      const cached = await getCached("list-vehicles", endpoint);
+      if (cached) {
+        this.vehicles = cached;
+        logger.debug("vehicles: cache hit");
+        return Object.values(cached);
+      }
+      logger.debug("vehicles: fetching from API");
+      this.vehicles = await this.fetchVehicles();
+      await setCached("list-vehicles", endpoint, {}, this.vehicles);
+    }
+    return Object.values(this.vehicles);
+  }
+  async exportVehicles({ output, useCache = true } = {}) {
+    const endpoint = "encyclopedia/vehicles";
+    const params = { application_id: this.appId };
+    const outputPath = output ?? `wg-export-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
+    let data = null;
+    if (useCache) {
+      data = await getCached("export", endpoint, params);
+    }
+    if (!data) {
+      data = await this.fetchVehicles();
+      if (useCache) {
+        await setCached("export", endpoint, params, data);
+      }
+    }
+    await writeFile2(outputPath, JSON.stringify(data, null, 2));
+    console.error(`Exported ${Object.keys(data).length} vehicles to ${outputPath}`);
+  }
+  async fetchVehicleIcon(vehicle2, size, force = false) {
+    const url = vehicle2.images?.[IMAGE_KEY[size]];
+    if (!url) {
+      return { skipped: true, downloaded: false, failed: false, path: null, error: null };
+    }
+    const dest = join2(this.iconsBaseDir, size, basename(url));
+    if (!force && await fileExists(dest)) {
+      logger.debug({ tag: vehicle2.tag, size, dest }, "icon: cached");
+      return { skipped: true, downloaded: false, failed: false, path: dest, error: null };
+    }
+    logger.debug({ tag: vehicle2.tag, size, url }, "icon: downloading");
+    try {
+      await downloadIcon(url, dest);
+      if (size === "xs") {
+        const { data: trimmed, info } = await sharp(dest).trim().toBuffer({ resolveWithObject: true });
+        const SCALE_FACTOR = 0.8;
+        const scaled = await sharp(trimmed).resize(Math.round(info.width * SCALE_FACTOR), Math.round(info.height * SCALE_FACTOR)).toBuffer();
+        await writeFile2(dest, scaled);
+      }
+      return { skipped: false, downloaded: true, failed: false, path: dest, error: null };
+    } catch (err) {
+      return { skipped: false, downloaded: false, failed: true, path: null, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async getDefaultVehicleIcon(vehicle2, size) {
+    const result = await this.fetchVehicleIcon(vehicle2, size, false);
+    if (!result.path) {
+      return null;
+    }
+    return sharp(result.path).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  }
+  async fetchIcons({ force = false, concurrency = 10, size, query }) {
+    const vehicles = query ? [await this.findVehicle(query)] : await this.getVehicles();
+    let downloaded = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (let i = 0; i < vehicles.length; i += concurrency) {
+      const batch = vehicles.slice(i, i + concurrency);
+      await Promise.all(
+        batch.map(async (vehicle2) => {
+          const result = await this.fetchVehicleIcon(vehicle2, size, force);
+          const name = vehicle2.images?.[IMAGE_KEY[size]] ? basename(vehicle2.images[IMAGE_KEY[size]]) : vehicle2.tag;
+          if (result.downloaded) {
+            downloaded++;
+            console.error(`\u2193 ${name}`);
+          } else if (result.failed) {
+            failed++;
+            console.error(`\u2717 ${name}: ${result.error}`);
+          } else {
+            skipped++;
+          }
+        })
+      );
+    }
+    console.error(`
+Done: ${downloaded} downloaded, ${skipped} skipped, ${failed} failed`);
+  }
+  getBestConfig(vehicle2) {
+    const tree = vehicle2.modules_tree;
+    const parent = /* @__PURE__ */ new Map();
+    for (const node of Object.values(tree)) {
+      if (node.next_modules) {
+        for (const childId of node.next_modules) {
+          parent.set(childId, node.module_id);
+        }
+      }
+    }
+    const depths = /* @__PURE__ */ new Map();
+    const depth = (id) => {
+      let d = depths.get(id);
+      if (d === void 0) {
+        const p = parent.get(id);
+        d = p === void 0 ? 0 : 1 + depth(p);
+        depths.set(id, d);
+      }
+      return d;
+    };
+    const byType = /* @__PURE__ */ new Map();
+    for (const node of Object.values(tree)) {
+      const current = byType.get(node.type);
+      if (current === void 0) {
+        byType.set(node.type, node);
+      } else {
+        const nd = depth(node.module_id);
+        const cd = depth(current.module_id);
+        if (nd > cd || nd === cd && node.module_id > current.module_id) {
+          byType.set(node.type, node);
+        }
+      }
+    }
+    const result = {};
+    for (const [type, node] of byType) {
+      result[type] = node.module_id;
+    }
+    logger.debug({ tank_id: vehicle2.tank_id, config: result }, "best config");
+    return result;
+  }
+  async inferBestConfig(query) {
+    return this.getBestConfig(await this.findVehicle(query));
+  }
+  configToProfileId(config2) {
+    return Object.values(config2).filter((id) => id != null).sort((a, b) => a - b).join("-");
+  }
+  async getStatsForBestConfig(query) {
+    const vehicle2 = typeof query === "object" ? query : await this.findVehicle(query);
+    const config2 = this.getBestConfig(vehicle2);
+    const profileId = this.configToProfileId(config2);
+    const endpoint = "encyclopedia/vehicleprofile";
+    const params = {
+      application_id: this.appId,
+      tank_id: String(vehicle2.tank_id),
+      profile_id: profileId
+    };
+    const cacheFilePrefix = `vehicle-${String(vehicle2.tank_id).padStart(5, "0")}-profile`;
+    const cached = await getCached(cacheFilePrefix, endpoint, params);
+    if (cached) {
+      logger.debug({ tank_id: vehicle2.tank_id, profileId }, "profile: cache hit");
+      return cached;
+    }
+    logger.debug({ tank_id: vehicle2.tank_id, profileId }, "profile: fetching from API");
+    const url = new URL(`https://api.worldoftanks.eu/wot/${endpoint}/`);
+    for (const [k, v] of Object.entries(params)) {
+      url.searchParams.set(k, v);
+    }
+    const response = await fetch(url.toString());
+    const json = await response.json();
+    if (json.status === "error") {
+      const err = json.error;
+      logger.warn({ params }, "failed to find profile");
+      throw new WGApiError(err.field, err.code, err.message);
+    }
+    const data = json.data;
+    await setCached(cacheFilePrefix, endpoint, params, data);
+    return data;
+  }
+  async getShortNameStats() {
+    const vehicles = await this.getVehicles();
+    const chars = /* @__PURE__ */ new Set();
+    let longestShortName = "";
+    const lengths = [];
+    for (const v of vehicles) {
+      for (const c of v.short_name) {
+        chars.add(c);
+      }
+      lengths.push(v.short_name.length);
+      if (v.short_name.length > longestShortName.length) {
+        longestShortName = v.short_name;
+      }
+    }
+    const sorted = [...lengths].sort((a, b) => a - b);
+    const n = sorted.length;
+    const avgLength = Math.round(lengths.reduce((s, l) => s + l, 0) / n);
+    const medianLength = n % 2 === 0 ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2 : sorted[Math.floor(n / 2)];
+    const p80Length = sorted[Math.ceil(0.8 * n) - 1];
+    const p90Length = sorted[Math.ceil(0.9 * n) - 1];
+    return {
+      uniqueCharacters: [...chars].sort().join(""),
+      maxLength: sorted[n - 1],
+      longestShortName,
+      avgLength,
+      medianLength,
+      p80Length,
+      p90Length
+    };
+  }
+  async purgeCache() {
+    await purgeCache();
+  }
+  async findVehicle(query) {
+    const vehicles = await this.getVehicles();
+    const q = String(query);
+    const isId = /^\d+$/.test(q);
+    const vehicle2 = vehicles.find((v) => {
+      if (isId) {
+        return v.tank_id === Number(q);
+      }
+      return v.tag === q || v.short_name === q;
+    });
+    if (!vehicle2) {
+      throw new Error(`Vehicle not found: ${query}`);
+    }
+    logger.debug({ tank_id: vehicle2.tank_id, tag: vehicle2.tag }, "vehicle found");
+    return vehicle2;
+  }
+  async fetchVehicles() {
+    const fields = [
+      "-crew",
+      "-default_profile",
+      "-description",
+      "-prices_xp",
+      "-price_gold",
+      "-price_credit",
+      "-next_tanks"
+    ].join(",");
+    const url = new URL("https://api.worldoftanks.eu/wot/encyclopedia/vehicles/");
+    url.searchParams.set("application_id", this.appId);
+    const tmp = `${url.toString()}&fields=${fields}`;
+    const response = await fetch(tmp);
+    const json = await response.json();
+    if (json.status === "error") {
+      const err = json.error;
+      throw new WGApiError(err.field, err.code, err.message);
+    }
+    return json.data;
+  }
+};
+
+// src/commands/vehicle/list.ts
+import { Command } from "commander";
+
+// src/lib/format.ts
+import Table from "cli-table3";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+var GREEN = "\x1B[32m";
+var RESET = "\x1B[0m";
+function printVehiclesTable(vehicles) {
+  const table = new Table({
+    head: ["Short", "Tag", "Name", "ID", ""],
+    colAligns: ["left", "left", "left", "right", "left"]
+  });
+  for (const v of vehicles) {
+    table.push([v.short_name, v.tag, v.name, v.tank_id, `${GREEN}\u2713${RESET}`]);
+  }
+  console.log(table.toString());
+}
+
+// src/commands/vehicle/list.ts
+function listVehiclesCommand(app2) {
+  return new Command("list").description("List vehicles from the WoT encyclopedia").option("--all", "show all vehicles (default: first 3)").option("--json", "output as JSON").action(async (options) => {
+    try {
+      const vehicles = await app2.getVehicles();
+      const items = options.all ? vehicles : vehicles.slice(0, 3);
+      if (options.json) {
+        printJson(items);
+      } else {
+        printVehiclesTable(items);
+      }
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/vehicle/export.ts
+import { Command as Command2 } from "commander";
+function exportCommand(app2) {
+  return new Command2("export").description("Export all vehicles to a JSON file").option("--output <path>", "output file path (default: wg-export-<timestamp>.json)").option("--no-cache", "bypass cache and fetch fresh data").action(async (options) => {
+    try {
+      await app2.exportVehicles({ output: options.output, useCache: options.cache });
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/cache/purge.ts
+import { Command as Command3 } from "commander";
+function cachePurgeCommand(app2) {
+  return new Command3("purge").description("Delete all cached API responses").action(async () => {
+    await app2.purgeCache();
+    console.error("Cache purged.");
+  });
+}
+
+// src/commands/vehicle/best-config.ts
+import { Command as Command4 } from "commander";
+function bestConfigCommand(app2) {
+  return new Command4("best-config").description("Infer best module configuration for a vehicle").argument("<query>", "tank_id (number), tag, or short_name").action(async (query) => {
+    try {
+      const result = await app2.inferBestConfig(query);
+      console.log(app2.configToProfileId(result));
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/vehicle/stats.ts
+import { Command as Command5 } from "commander";
+function formatArmor(a) {
+  try {
+    return `${a.front} / ${a.sides} / ${a.rear}`;
+  } catch {
+    return "";
+  }
+}
+function printProfile(profile) {
+  console.log(`profile:      ${profile.profile_id}`);
+  console.log(`view range:   ${profile.turret.view_range} m`);
+  console.log(`hull armor:   ${formatArmor(profile.armor.hull)}  (front / sides / rear)`);
+  console.log(`turret armor: ${formatArmor(profile.armor.turret)}  (front / sides / rear)`);
+  console.log(`reload time:  ${profile.gun.reload_time.toFixed(2)} s`);
+}
+function printTable(rows) {
+  const headers = ["Name", "View Range", "Reload (s)", "Hull (f/s/r)", "Turret (f/s/r)"];
+  const cells = rows.map((r) => [
+    r.name,
+    String(r.viewRange),
+    r.reloadTime.toFixed(2),
+    formatArmor(r.hullArmor),
+    formatArmor(r.turretArmor)
+  ]);
+  const widths = headers.map((h, i) => Math.max(h.length, ...cells.map((row) => row[i].length)));
+  const pad = (s, w) => s.padEnd(w);
+  const formatRow = (row) => row.map((cell, i) => pad(cell, widths[i])).join("  ");
+  console.log(formatRow(headers));
+  console.log(widths.map((w) => "-".repeat(w)).join("  "));
+  for (const row of cells) {
+    try {
+      console.log(formatRow(row));
+    } catch (e) {
+      console.log(`!!!! ${row[0]} ${e instanceof Error ? e.message : e}`);
+    }
+  }
+}
+function extractProfile(data) {
+  return Object.values(data)[0];
+}
+function vehicleStatsCommand(app2) {
+  return new Command5("stats").description("Fetch stats for the best module configuration of a vehicle").argument("[query]", "tank_id (number), tag, or short_name").option("--all", "fetch stats for all vehicles and print as a table").option("-q, --quiet", "suppress progress output").option("--json", "output results as JSON array instead of a table (use with --all)").option("--raw", "print full JSON response (single vehicle only)").action(async (query, options) => {
+    try {
+      if (!query || options.all) {
+        const vehicles = await app2.getVehicles();
+        const sorted = [...vehicles].sort((a, b) => a.short_name.localeCompare(b.short_name));
+        const targets = options.all ? sorted : sorted.slice(0, 10);
+        const rows = [];
+        const batchSize = 5;
+        for (let i = 0; i < targets.length; i += batchSize) {
+          const batch = targets.slice(i, i + batchSize);
+          if (!options.raw && !options.quiet) {
+            console.error(`${i + 1}\u2013${Math.min(i + batchSize, targets.length)} / ${targets.length}`);
+          }
+          const results = await Promise.all(
+            batch.map(async (v) => {
+              try {
+                const data = await app2.getStatsForBestConfig(v.tank_id);
+                const profile = extractProfile(data);
+                return {
+                  name: v.short_name,
+                  viewRange: profile.turret.view_range,
+                  reloadTime: profile.gun.reload_time,
+                  hullArmor: profile.armor.hull,
+                  turretArmor: profile.armor.turret
+                };
+              } catch {
+                return null;
+              }
+            })
+          );
+          for (const row of results) {
+            if (row) {
+              rows.push(row);
+            }
+          }
+        }
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else {
+          printTable(rows);
+        }
+        return;
+      }
+      const result = await app2.getStatsForBestConfig(query);
+      if (options.raw) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      printProfile(extractProfile(result));
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/vehicle/chars.ts
+import { Command as Command6 } from "commander";
+function charsCommand(app2) {
+  return new Command6("chars").description("List unique characters found in vehicle short names").action(async () => {
+    try {
+      const { uniqueCharacters, maxLength, longestShortName, avgLength, medianLength, p80Length, p90Length } = await app2.getShortNameStats();
+      console.log("uniqueCharacters:", uniqueCharacters);
+      console.log("maxLength:", maxLength);
+      console.log("longestShortName:", longestShortName);
+      console.log("avgLength:", avgLength);
+      console.log("medianLength:", medianLength);
+      console.log("p80Length:", p80Length);
+      console.log("p90Length:", p90Length);
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/vehicle/long-aliases.ts
+import { Command as Command7 } from "commander";
+
+// src/lib/icons/pogs/short-names.ts
+import { readFileSync, writeFileSync } from "fs";
+import JSON5 from "json5";
+
+// src/lib/pkg-root.ts
+import { existsSync } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+function findPkgRoot(url) {
+  let d = dirname(fileURLToPath(url));
+  while (!existsSync(resolve3(d, "package.json"))) {
+    d = dirname(d);
+  }
+  return d;
+}
+function resolveAsset(url, ...parts) {
+  const adjacent = resolve3(dirname(fileURLToPath(url)), "assets", ...parts);
+  if (existsSync(adjacent)) {
+    return adjacent;
+  }
+  return resolve3(findPkgRoot(url), "assets", ...parts);
+}
+
+// src/lib/icons/pogs/short-names.ts
+var shortNamesPath = resolveAsset(new URL(import.meta.url), "pogs", "short-names.json5");
+var dict = {
+  ...JSON5.parse(readFileSync(shortNamesPath, "utf8"))
+};
+function lookupShortName(vehicle2) {
+  return dict[vehicle2.tag] ?? vehicle2.short_name;
+}
+function isResolved(vehicle2) {
+  return vehicle2.tag in dict;
+}
+function add(vehicle2, alias) {
+  dict[vehicle2.tag] = alias;
+}
+function save() {
+  const sorted = Object.fromEntries(
+    Object.entries(dict).sort(([, a], [, b]) => b.length - a.length)
+  );
+  writeFileSync(shortNamesPath, JSON.stringify(sorted, null, 2) + "\n", "utf8");
+}
+
+// src/commands/vehicle/long-aliases.ts
+function longAliasesCommand(app2) {
+  return new Command7("long-aliases").description("List vehicles whose shortened alias exceeds 10 characters").option("--update", "back-fill dictionary with aliases that are too long or unresolved").action(async (options) => {
+    try {
+      const vehicles = await app2.getVehicles();
+      let dirty = false;
+      for (const vehicle2 of vehicles) {
+        const alias = lookupShortName(vehicle2);
+        const tooLong = alias.length > 10;
+        const unresolved = !isResolved(vehicle2);
+        if (tooLong || unresolved) {
+          console.log(`${vehicle2.tank_id} ${vehicle2.tag} "${alias}"`);
+          if (options.update) {
+            add(vehicle2, alias);
+            dirty = true;
+          }
+        }
+      }
+      if (dirty) {
+        save();
+      }
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/font/render.ts
+import { Command as Command8 } from "commander";
+import sharp3 from "sharp";
+
+// src/lib/fonts/pogs-numbers.ts
+import { readFileSync as readFileSync2 } from "fs";
+import JSON52 from "json5";
+var pogsNumbers = JSON52.parse(
+  readFileSync2(resolveAsset(new URL(import.meta.url), "fonts", "pogs", "numbers.json5"), "utf8")
+);
+
+// src/lib/fonts/pogs-numbers-bold.ts
+import { readFileSync as readFileSync3 } from "fs";
+import JSON53 from "json5";
+var pogsNumbersBold = JSON53.parse(
+  readFileSync3(resolveAsset(new URL(import.meta.url), "fonts", "pogs", "numbers-bold.json5"), "utf8")
+);
+
+// src/lib/fonts/pogs-4px.ts
+import { readFileSync as readFileSync4 } from "fs";
+import JSON54 from "json5";
+var pogs4px = JSON54.parse(
+  readFileSync4(resolveAsset(new URL(import.meta.url), "fonts", "pogs", "4px.json5"), "utf8")
+);
+
+// src/lib/fonts/pogs-3px.ts
+import { readFileSync as readFileSync5 } from "fs";
+import JSON55 from "json5";
+var pogs3px = JSON55.parse(
+  readFileSync5(resolveAsset(new URL(import.meta.url), "fonts", "pogs", "3px.json5"), "utf8")
+);
+
+// src/lib/fonts/index.ts
+var fonts = {
+  pogsNumbers,
+  pogsNumbersBold,
+  pogs4px,
+  pogs3px
+};
+
+// src/lib/render-text.ts
+import sharp2 from "sharp";
+
+// src/lib/fonts/glyph.ts
+function charToPixel(ch) {
+  const c = ch.toLowerCase().trim();
+  switch (c) {
+    case "-":
+      return "quarter";
+    case "+":
+      return "half";
+    case "*":
+    case "=":
+      return "three-quarter";
+  }
+  if (c === "#" || /^[a-z]$/.test(c)) {
+    return "full";
+  }
+  return "empty";
+}
+function normalizeGlyph(rawRows, noTrim = false) {
+  const trimmed = noTrim ? rawRows : rawRows.map((row) => row.replace(/\s+$/u, ""));
+  const width = trimmed.reduce((max, row) => Math.max(max, row.length), 0);
+  const rows = trimmed.map((row) => {
+    const padded = row.padEnd(width, " ");
+    return Array.from(padded, charToPixel);
+  });
+  return { width, height: rows.length, rows };
+}
+
+// src/lib/PixelFont.ts
+var PIXEL_KIND_ALPHA = {
+  empty: 0,
+  quarter: 64,
+  half: 128,
+  "three-quarter": 191,
+  full: 255
+};
+var PixelFont = class {
+  glyphMap;
+  pixelCache = /* @__PURE__ */ new Map();
+  constructor(font2) {
+    this.glyphMap = new Map(
+      Object.entries(font2.glyphs).map(([ch, rows]) => {
+        return [ch, normalizeGlyph(rows, ch === " ")];
+      })
+    );
+  }
+  getPixels(char) {
+    let result = this.pixelCache.get(char);
+    if (result === void 0) {
+      const glyph = this.glyphMap.get(char) ?? null;
+      result = glyph === null ? null : { width: glyph.width, height: glyph.height, alpha: glyph.rows.map((row) => row.map((k) => PIXEL_KIND_ALPHA[k])) };
+      this.pixelCache.set(char, result);
+    }
+    return result;
+  }
+};
+
+// src/lib/colors.ts
+var Colors = {
+  white: 4294967295,
+  black: 255,
+  beige: 4172968703,
+  yellow: 3956737535
+};
+
+// src/lib/render-text.ts
+var CHAR_GAP = 1;
+var prepareGlyphsCache = /* @__PURE__ */ new Map();
+function prepareGlyphs(fontName, text) {
+  const str = String(text);
+  const key = `${fontName}:${str}`;
+  let result = prepareGlyphsCache.get(key);
+  if (result === void 0) {
+    const fontDef = fonts[fontName];
+    if (!fontDef) {
+      throw new Error(`Unknown font: "${fontName}". Available: ${Object.keys(fonts).join(", ")}`);
+    }
+    const pf = new PixelFont(fontDef);
+    const chars = [...str];
+    const charPixels = chars.map((ch) => pf.getPixels(ch));
+    const charWidths = charPixels.map((p) => p?.width ?? 0);
+    const width = charWidths.reduce((s, w) => s + w, 0) + CHAR_GAP * Math.max(0, chars.length - 1);
+    const height = chars.length > 0 ? Math.max(...charPixels.map((p) => p?.height ?? 0)) : 0;
+    result = { chars, charPixels, charWidths, width, height };
+    prepareGlyphsCache.set(key, result);
+  }
+  return result;
+}
+function renderText(fontName, text, color = Colors.white) {
+  const { chars, charPixels, charWidths, width, height } = prepareGlyphs(fontName, text);
+  const cr = color >>> 24 & 255;
+  const cg = color >>> 16 & 255;
+  const cb = color >>> 8 & 255;
+  const ca = color & 255;
+  const data = Buffer.alloc(width * height * 4, 0);
+  let x = 0;
+  for (let ci = 0; ci < chars.length; ci++) {
+    const pixels = charPixels[ci];
+    if (pixels) {
+      for (let row = 0; row < pixels.alpha.length; row++) {
+        for (let col = 0; col < pixels.alpha[row].length; col++) {
+          const alpha = pixels.alpha[row][col];
+          if (alpha === 0) {
+            continue;
+          }
+          const off = (row * width + (x + col)) * 4;
+          data[off] = cr;
+          data[off + 1] = cg;
+          data[off + 2] = cb;
+          data[off + 3] = Math.round(alpha / 255 * ca);
+        }
+      }
+    }
+    x += charWidths[ci] + CHAR_GAP;
+  }
+  return { data, width, height };
+}
+async function renderWithShadow(fontName, text, color = Colors.white, shadowColor = Colors.black, distance = 1) {
+  const main = renderText(fontName, text, color);
+  const shadow = renderText(fontName, text, shadowColor);
+  const width = main.width + distance;
+  const height = main.height + distance;
+  const base = Buffer.alloc(width * height * 4, 0);
+  const { data } = await sharp2(base, { raw: { width, height, channels: 4 } }).composite([
+    { input: shadow.data, raw: { width: shadow.width, height: shadow.height, channels: 4 }, left: distance, top: distance },
+    { input: main.data, raw: { width: main.width, height: main.height, channels: 4 }, left: 0, top: 0 }
+  ]).raw().toBuffer({ resolveWithObject: true });
+  return { data, width, height };
+}
+
+// src/commands/font/render.ts
+var DEFAULT_SAMPLE = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var PADDING = 2;
+function renderCommand() {
+  return new Command8("render").description("Render a font sample as a PNG image in CWD").argument("[font]", `font name (${Object.keys(fonts).join(", ")})`).argument("[text]", "text to render", DEFAULT_SAMPLE).action(async (fontName, text) => {
+    if (!fontName) {
+      console.log(Object.keys(fonts).join("\n"));
+      return;
+    }
+    if (!fonts[fontName]) {
+      console.error(`Unknown font: ${fontName}. Available: ${Object.keys(fonts).join(", ")}`);
+      process.exit(1);
+    }
+    const { data: textData, width: textW, height: textH } = renderText(fontName, text);
+    const totalW = PADDING * 2 + textW;
+    const totalH = PADDING * 2 + textH;
+    const buf = Buffer.alloc(totalW * totalH * 3, 255);
+    for (let row = 0; row < textH; row++) {
+      for (let col = 0; col < textW; col++) {
+        const alpha = textData[(row * textW + col) * 4 + 3];
+        if (alpha === 0) {
+          continue;
+        }
+        const grey = 255 - alpha;
+        const off = ((PADDING + row) * totalW + (PADDING + col)) * 3;
+        buf[off] = grey;
+        buf[off + 1] = grey;
+        buf[off + 2] = grey;
+      }
+    }
+    const outPath = `${fontName}.png`;
+    await sharp3(buf, { raw: { width: totalW, height: totalH, channels: 3 } }).png().toFile(outPath);
+    console.log(`${outPath} \u2014 ${[...text].length} chars, ${totalW}\xD7${totalH}px`);
+  });
+}
+
+// src/commands/atlas/pick.ts
+import { Command as Command9 } from "commander";
+import { writeFile as writeFile3 } from "fs/promises";
+import { PNG } from "pngjs";
+function pickCommand(atlas2) {
+  return new Command9("pick").description("Extract a named texture region from an atlas and save as PNG").argument("<atlas>", "path to atlas XML").argument("<image>", "path to atlas image (always read as PNG)").argument("<name>", "texture name to extract").action(async (atlasPath, imagePath, name) => {
+    const result = await atlas2.pick(atlasPath, imagePath, name);
+    if (!result) {
+      console.error(`Texture not found: ${name}`);
+      console.error(`Run 'pie-wot atlas inspect ${atlasPath}' to list available textures`);
+      process.exit(1);
+    }
+    const outPath = `${name}.png`;
+    await writeFile3(outPath, PNG.sync.write(result));
+    console.log(`${outPath} \u2014 ${result.width}\xD7${result.height}px`);
+  });
+}
+
+// src/commands/atlas/inspect.ts
+import { Command as Command10 } from "commander";
+function inspectAtlasCommand(atlas2) {
+  return new Command10("inspect").description("List all texture names in an atlas XML").argument("<atlas>", "path to atlas XML").action(async (atlasPath) => {
+    const names = await atlas2.listNames(atlasPath);
+    names.forEach((name) => console.log(name));
+  });
+}
+
+// src/commands/atlas/extract.ts
+import { Command as Command11 } from "commander";
+function extractAtlasCommand(atlas2) {
+  return new Command11("extract").description("Extract all textures from an atlas into separate PNG files").option("--from <path>", "base path \u2014 derives <path>.png (image) and <path>.xml (map)").option("--image <path>", "atlas image path (PNG)").option("--map <path>", "atlas XML map path").requiredOption("--to <dir>", "destination directory").action(async (options) => {
+    let imagePath;
+    let mapPath;
+    if (options.from) {
+      imagePath = `${options.from}.png`;
+      mapPath = `${options.from}.xml`;
+    } else if (options.image && options.map) {
+      imagePath = options.image;
+      mapPath = options.map;
+    } else {
+      console.error("Provide either --from <path> or both --image <path> and --map <path>");
+      process.exit(1);
+    }
+    const count = await atlas2.extractAll(mapPath, imagePath, options.to);
+    console.log(`Extracted ${count} textures \u2192 ${options.to}`);
+  });
+}
+
+// src/commands/atlas/pack.ts
+import { Command as Command12 } from "commander";
+import { writeFile as writeFile4 } from "fs/promises";
+function packAtlasCommand(atlas2) {
+  return new Command12("pack").description("Pack a directory of PNGs into a texture atlas").option("--from <dir>", "source directory containing PNG images").option("--src <dir>", "alias for --from").option("--to <path>", "output base path (gets .png and .xml extensions)").option("--dst <path>", "alias for --to").option("--padding <n>", "pixels of padding between textures", "0").option("--max-width <n>", "maximum atlas width in pixels", "4096").action(
+    async (options) => {
+      const fromDir = options.from ?? options.src;
+      const toPath = options.to ?? options.dst;
+      if (!fromDir) {
+        console.error("Provide --from <dir> or --src <dir>");
+        process.exit(1);
+      }
+      if (!toPath) {
+        console.error("Provide --to <path> or --dst <path>");
+        process.exit(1);
+      }
+      const result = await atlas2.pack(fromDir, {
+        padding: parseInt(options.padding, 10),
+        maxWidth: parseInt(options.maxWidth, 10)
+      });
+      if (result.bins > 1) {
+        console.warn(`Warning: textures span ${result.bins} bins \u2014 only the first will be written`);
+      }
+      await writeFile4(`${toPath}.png`, result.pngBuffer);
+      await writeFile4(`${toPath}.xml`, result.xml);
+      console.log(`Packed ${result.count} textures \u2192 ${toPath}.png (${result.width}\xD7${result.height})`);
+    }
+  );
+}
+
+// src/lib/AtlasManager.ts
+import { readFile as readFile3, readdir, writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
+import { join as join3, basename as basename2, extname } from "path";
+import { PNG as PNG2 } from "pngjs";
+import { MaxRectsPacker } from "maxrects-packer";
+
+// src/lib/texture-atlas.ts
+import { readFile as readFile2 } from "fs/promises";
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser();
+async function readTextureAtlas(xmlPath) {
+  const xml = await readFile2(xmlPath, "utf-8");
+  const doc = parser.parse(xml);
+  const raw = doc.root?.SubTexture;
+  if (!raw) {
+    return [];
+  }
+  const entries = Array.isArray(raw) ? raw : [raw];
+  const regions = [];
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) {
+      continue;
+    }
+    const e = entry;
+    const name = typeof e.name === "string" ? e.name.trim() : null;
+    const x = Number(e.x);
+    const y = Number(e.y);
+    const width = Number(e.width);
+    const height = Number(e.height);
+    if (name && !isNaN(x) && !isNaN(y) && !isNaN(width) && !isNaN(height)) {
+      regions.push({ name, x, y, width, height });
+    }
+  }
+  return regions;
+}
+
+// src/lib/AtlasManager.ts
+function copyRegion(src, region) {
+  const out = new PNG2({ width: region.width, height: region.height });
+  for (let row = 0; row < region.height; row++) {
+    const srcOffset = ((region.y + row) * src.width + region.x) * 4;
+    const dstOffset = row * region.width * 4;
+    src.data.copy(out.data, dstOffset, srcOffset, srcOffset + region.width * 4);
+  }
+  return out;
+}
+function buildXml(regions) {
+  const entries = regions.map(
+    (r) => `  <SubTexture>
+    <name> ${r.name} </name>
+    <x> ${r.x} </x>
+    <y> ${r.y} </y>
+    <width> ${r.width} </width>
+    <height> ${r.height} </height>
+  </SubTexture>`
+  ).join("\n");
+  return `<root>
+${entries}
+</root>
+`;
+}
+var AtlasManager = class {
+  async listNames(mapPath) {
+    const regions = await readTextureAtlas(mapPath);
+    return regions.map((r) => r.name).sort();
+  }
+  async pick(mapPath, imagePath, name) {
+    const regions = await readTextureAtlas(mapPath);
+    const region = regions.find((r) => r.name === name);
+    if (!region) {
+      return null;
+    }
+    const src = PNG2.sync.read(await readFile3(imagePath));
+    return copyRegion(src, region);
+  }
+  async extractAll(mapPath, imagePath, destDir) {
+    const regions = await readTextureAtlas(mapPath);
+    const src = PNG2.sync.read(await readFile3(imagePath));
+    await mkdir2(destDir, { recursive: true });
+    for (const region of regions) {
+      const out = copyRegion(src, region);
+      await writeFile5(join3(destDir, `${region.name}.png`), PNG2.sync.write(out));
+    }
+    return regions.length;
+  }
+  async pack(srcDir, { padding = 0, maxWidth = 4096 } = {}) {
+    const files = (await readdir(srcDir)).filter((f) => extname(f).toLowerCase() === ".png").sort();
+    if (files.length === 0) {
+      throw new Error(`No PNG files found in ${srcDir}`);
+    }
+    const entries = await Promise.all(
+      files.map(async (file) => {
+        const png = PNG2.sync.read(await readFile3(join3(srcDir, file)));
+        return { name: basename2(file, ".png"), png, x: 0, y: 0, width: png.width, height: png.height };
+      })
+    );
+    const packer = new MaxRectsPacker(maxWidth, 32768, padding, {
+      smart: true,
+      pot: false,
+      square: false,
+      allowRotation: false
+    });
+    packer.addArray(entries);
+    const bin = packer.bins[0];
+    const out = new PNG2({ width: bin.width, height: bin.height });
+    out.data.fill(0);
+    const regions = [];
+    for (const rect of bin.rects) {
+      const { x, y, width, height, name, png } = rect;
+      for (let row = 0; row < height; row++) {
+        const srcOffset = row * width * 4;
+        const dstOffset = ((y + row) * bin.width + x) * 4;
+        png.data.copy(out.data, dstOffset, srcOffset, srcOffset + width * 4);
+      }
+      regions.push({ name, x, y, width, height });
+    }
+    regions.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+      pngBuffer: PNG2.sync.write(out),
+      xml: buildXml(regions),
+      width: bin.width,
+      height: bin.height,
+      count: entries.length,
+      bins: packer.bins.length
+    };
+  }
+};
+
+// src/commands/dds/decode.ts
+import { readFile as readFile4, writeFile as writeFile6 } from "fs/promises";
+import { extname as extname2, join as join4, dirname as dirname2, basename as basename3 } from "path";
+import { Command as Command13 } from "commander";
+import { PNG as PNG3 } from "pngjs";
+
+// src/lib/utex-mod/DDSUtils.ts
+var DDSUtils = class _DDSUtils {
+  // ── DDS header flags ────────────────────────────────────────────────────────
+  static DDSD_CAPS = 1;
+  // always required
+  static DDSD_HEIGHT = 2;
+  // always required
+  static DDSD_WIDTH = 4;
+  // always required
+  static DDSD_PIXELFORMAT = 4096;
+  // always required
+  static DDSD_MIPMAPCOUNT = 131072;
+  static DDSD_LINEARSIZE = 524288;
+  // ── DDS pixel format flags ──────────────────────────────────────────────────
+  static DDPF_ALPHAPIXELS = 1;
+  static DDPF_ALPHA = 2;
+  static DDPF_FOURCC = 4;
+  static DDPF_RGB = 64;
+  static DDPF_LUMINANCE = 131072;
+  // ── DDS caps flags ──────────────────────────────────────────────────────────
+  static DDSCAPS_COMPLEX = 8;
+  static DDSCAPS_MIPMAP = 4194304;
+  static DDSCAPS_TEXTURE = 4096;
+  // Reusable scratch buffers — allocated once per instance to avoid per-call
+  // heap pressure in tight decode/encode loops. WARNING: contents are not
+  // cleared between calls; never hold a reference to these across method
+  // invocations or assume they are zero-initialised on entry.
+  _int8 = new Uint8Array(4);
+  _int = new Uint32Array(this._int8.buffer);
+  // shares memory with _int8 for LE uint32 reinterpretation
+  _arr16 = new Uint8Array(16);
+  // 4-color palette slot for readBCcolor (16 RGBA entries × 1 byte)
+  // ── public API ──────────────────────────────────────────────────────────────
+  decode(buff) {
+    var data = new Uint8Array(buff), offset = 4;
+    var head = this.readHeader(data, offset);
+    offset += 124;
+    var pf = head.pixFormat;
+    if (pf.flags & _DDSUtils.DDPF_FOURCC && pf.fourCC == "DX10") {
+      offset += 20;
+    }
+    var w = head.width, h = head.height, out = [];
+    var fmt = pf.fourCC;
+    var mcnt = Math.max(1, head.mmcount);
+    for (var it = 0; it < mcnt; it++) {
+      var img = new Uint8Array(w * h * 4);
+      if (fmt == "DXT1") {
+        offset = this.readBC1(data, offset, img, w, h);
+      } else if (fmt == "DXT3") {
+        offset = this.readBC2(data, offset, img, w, h);
+      } else if (fmt == "DXT5") {
+        offset = this.readBC3(data, offset, img, w, h);
+      } else if (fmt == "DX10") {
+        throw new Error("Not supported: BC7 (DX10)");
+      } else if (fmt == "ATC ") {
+        throw new Error("Not supported: ATC");
+      } else if (fmt == "ATCA") {
+        throw new Error("Not supported: ATCA");
+      } else if (fmt == "ATCI") {
+        throw new Error("Not supported: ATCI");
+      } else if (pf.flags & _DDSUtils.DDPF_ALPHAPIXELS && pf.flags & _DDSUtils.DDPF_RGB) {
+        throw new Error("Not supported: (complex-A)");
+      } else if (pf.flags & _DDSUtils.DDPF_ALPHA || pf.flags & _DDSUtils.DDPF_ALPHAPIXELS || pf.flags & _DDSUtils.DDPF_LUMINANCE) {
+        throw new Error("Not supported: (complex-B)");
+      } else {
+        throw new Error(
+          `Unknown texture format \u2014 head flags: ${head.flags.toString(2)}, pixelFormat flags: ${pf.flags.toString(2)}`
+        );
+      }
+      out.push({ width: w, height: h, image: img.buffer });
+      w = w >> 1;
+      h = h >> 1;
+    }
+    return out;
+  }
+  encode(img, w, h, forceAlpha = true) {
+    var imageAsByteArray = new Uint8Array(img);
+    var aAnd = 255;
+    for (var i = 3; i < imageAsByteArray.length; i += 4) {
+      aAnd &= imageAsByteArray[i];
+    }
+    var gotAlpha = forceAlpha || aAnd < 250;
+    var data = new Uint8Array(124 + w * h * 2), offset = 0;
+    this.writeASCII(data, offset, "DDS ");
+    offset += 4;
+    this.writeHeader(data, w, h, gotAlpha, offset);
+    offset += 124;
+    var mcnt = 0;
+    while (w * h != 0) {
+      if (gotAlpha) {
+        offset = this.writeBC3(imageAsByteArray, w, h, data, offset);
+      } else {
+        offset = this.writeBC1(imageAsByteArray, w, h, data, offset);
+      }
+      imageAsByteArray = this.mipmapB(imageAsByteArray, w, h);
+      w = w >> 1;
+      h = h >> 1;
+      mcnt++;
+    }
+    data[28] = mcnt;
+    return data.buffer.slice(0, offset);
+  }
+  // ── DDS header I/O ──────────────────────────────────────────────────────────
+  readHeader(data, offset) {
+    var hd = {};
+    offset += 4;
+    hd.flags = this.readUintLE(data, offset);
+    offset += 4;
+    hd.height = this.readUintLE(data, offset);
+    offset += 4;
+    hd.width = this.readUintLE(data, offset);
+    offset += 4;
+    hd.pitch = this.readUintLE(data, offset);
+    offset += 4;
+    hd.depth = this.readUintLE(data, offset);
+    offset += 4;
+    hd.mmcount = this.readUintLE(data, offset);
+    offset += 4;
+    offset += 11 * 4;
+    hd.pixFormat = this.readPixFormat(data, offset);
+    offset += 32;
+    hd.caps = this.readUintLE(data, offset);
+    offset += 4;
+    hd.caps2 = this.readUintLE(data, offset);
+    offset += 4;
+    hd.caps3 = this.readUintLE(data, offset);
+    offset += 4;
+    hd.caps4 = this.readUintLE(data, offset);
+    return hd;
+  }
+  writeHeader(data, w, h, gotAlpha, offset) {
+    var flgs = _DDSUtils.DDSD_CAPS | _DDSUtils.DDSD_HEIGHT | _DDSUtils.DDSD_WIDTH | _DDSUtils.DDSD_PIXELFORMAT;
+    flgs |= _DDSUtils.DDSD_MIPMAPCOUNT | _DDSUtils.DDSD_LINEARSIZE;
+    var caps = _DDSUtils.DDSCAPS_COMPLEX | _DDSUtils.DDSCAPS_MIPMAP | _DDSUtils.DDSCAPS_TEXTURE;
+    var pitch = (w * h >> 1) * (gotAlpha ? 2 : 1), depth = gotAlpha ? 1 : 0;
+    this.writeUintLE(data, offset, 124);
+    offset += 4;
+    this.writeUintLE(data, offset, flgs);
+    offset += 4;
+    this.writeUintLE(data, offset, h);
+    offset += 4;
+    this.writeUintLE(data, offset, w);
+    offset += 4;
+    this.writeUintLE(data, offset, pitch);
+    offset += 4;
+    this.writeUintLE(data, offset, depth);
+    offset += 4;
+    this.writeUintLE(data, offset, 10);
+    offset += 4;
+    offset += 11 * 4;
+    this.writePixFormat(data, gotAlpha, offset);
+    offset += 32;
+    this.writeUintLE(data, offset, caps);
+  }
+  readPixFormat(data, offset) {
+    var pf = {};
+    offset += 4;
+    pf.flags = this.readUintLE(data, offset);
+    offset += 4;
+    pf.fourCC = this.readASCII(data, offset, 4);
+    offset += 4;
+    pf.bitCount = this.readUintLE(data, offset);
+    offset += 4;
+    pf.RMask = this.readUintLE(data, offset);
+    offset += 4;
+    pf.GMask = this.readUintLE(data, offset);
+    offset += 4;
+    pf.BMask = this.readUintLE(data, offset);
+    offset += 4;
+    pf.AMask = this.readUintLE(data, offset);
+    return pf;
+  }
+  writePixFormat(data, gotAlpha, offset) {
+    var flgs = _DDSUtils.DDPF_FOURCC;
+    this.writeUintLE(data, offset, 32);
+    offset += 4;
+    this.writeUintLE(data, offset, flgs);
+    offset += 4;
+    this.writeASCII(data, offset, gotAlpha ? "DXT5" : "DXT1");
+  }
+  // ── BC codec ────────────────────────────────────────────────────────────────
+  readBC1(data, offset, img, w, h) {
+    var sqr = new Uint8Array(4 * 4 * 4);
+    for (var y = 0; y < h; y += 4) {
+      for (var x = 0; x < w; x += 4) {
+        this.readBCcolor(data, offset, sqr);
+        this.write4x4(img, w, h, x, y, sqr);
+        offset += 8;
+      }
+    }
+    return offset;
+  }
+  writeBC1(img, w, h, data, offset) {
+    var sqr = new Uint8Array(16 * 4);
+    for (var y = 0; y < h; y += 4) {
+      for (var x = 0; x < w; x += 4) {
+        this.read4x4(img, w, h, x, y, sqr);
+        this.writeBCcolor(data, offset, sqr);
+        offset += 8;
+      }
+    }
+    return offset;
+  }
+  readBC2(data, offset, img, w, h) {
+    var pos = { boff: offset * 8 };
+    var sqr = new Uint8Array(4 * 4 * 4);
+    for (var y = 0; y < h; y += 4) {
+      for (var x = 0; x < w; x += 4) {
+        this.readBCcolor(data, offset + 8, sqr);
+        for (var i = 0; i < 64; i += 4) {
+          var code = this.readBits(data, pos, 4);
+          sqr[i + 3] = 255 * (code / 15);
+        }
+        this.write4x4(img, w, h, x, y, sqr);
+        offset += 16;
+        pos.boff += 64;
+      }
+    }
+    return offset;
+  }
+  inter8(a, b) {
+    var al = [a, b];
+    if (a > b) {
+      al.push(
+        6 / 7 * a + 1 / 7 * b,
+        // bit code 010
+        5 / 7 * a + 2 / 7 * b,
+        // bit code 011
+        4 / 7 * a + 3 / 7 * b,
+        // bit code 100
+        3 / 7 * a + 4 / 7 * b,
+        // bit code 101
+        2 / 7 * a + 5 / 7 * b,
+        // bit code 110
+        1 / 7 * a + 6 / 7 * b
+      );
+    } else {
+      al.push(
+        4 / 5 * a + 1 / 5 * b,
+        // bit code 010
+        3 / 5 * a + 2 / 5 * b,
+        // bit code 011
+        2 / 5 * a + 3 / 5 * b,
+        // bit code 100
+        1 / 5 * a + 4 / 5 * b,
+        // bit code 101
+        0,
+        // bit code 110
+        255
+      );
+    }
+    return al;
+  }
+  readBC3(data, offset, img, w, h) {
+    var pos = { boff: offset * 8 };
+    var sqr = new Uint8Array(4 * 4 * 4);
+    for (var y = 0; y < h; y += 4) {
+      for (var x = 0; x < w; x += 4) {
+        this.readBCcolor(data, offset + 8, sqr);
+        var al = this.inter8(data[offset], data[offset + 1]);
+        pos.boff += 16;
+        for (var i = 0; i < 64; i += 4) {
+          var code = this.readBits(data, pos, 3);
+          sqr[i + 3] = al[code];
+        }
+        pos.boff += 64;
+        this.write4x4(img, w, h, x, y, sqr);
+        offset += 16;
+      }
+    }
+    return offset;
+  }
+  writeBC3(img, w, h, data, offset) {
+    var sqr = new Uint8Array(16 * 4);
+    for (var y = 0; y < h; y += 4) {
+      for (var x = 0; x < w; x += 4) {
+        this.read4x4(img, w, h, x, y, sqr);
+        var min = sqr[3], max = sqr[3];
+        for (var i = 7; i < 64; i += 4) {
+          var a = sqr[i];
+          if (a < min) {
+            min = a;
+          } else if (max < a) {
+            max = a;
+          }
+        }
+        data[offset] = max;
+        data[offset + 1] = min;
+        offset += 2;
+        var al = this.inter8(max, min);
+        for (var i = 0; i < 64; i += 32) {
+          var bits = 0, boff = 0;
+          for (var j = 0; j < 32; j += 4) {
+            var code = 0, cd = 500;
+            var a = sqr[i + j + 3];
+            for (var k = 0; k < 8; k++) {
+              var dst = Math.abs(al[k] - a);
+              if (dst < cd) {
+                cd = dst;
+                code = k;
+              }
+            }
+            bits = bits | code << boff;
+            boff += 3;
+          }
+          data[offset] = bits;
+          data[offset + 1] = bits >> 8;
+          data[offset + 2] = bits >> 16;
+          offset += 3;
+        }
+        this.writeBCcolor(data, offset, sqr);
+        offset += 8;
+      }
+    }
+    return offset;
+  }
+  readBCcolor(data, offset, sqr) {
+    var c0 = data[offset + 1] << 8 | data[offset];
+    var c1 = data[offset + 3] << 8 | data[offset + 2];
+    var c0b = (c0 & 31) * (255 / 31), c0g = (c0 >>> 5 & 63) * (255 / 63), c0r = (c0 >> 11) * (255 / 31);
+    var c1b = (c1 & 31) * (255 / 31), c1g = (c1 >>> 5 & 63) * (255 / 63), c1r = (c1 >> 11) * (255 / 31);
+    var clr = this._arr16;
+    clr[0] = ~~c0r;
+    clr[1] = ~~c0g;
+    clr[2] = ~~c0b;
+    clr[3] = 255;
+    clr[4] = ~~c1r;
+    clr[5] = ~~c1g;
+    clr[6] = ~~c1b;
+    clr[7] = 255;
+    if (c1 < c0) {
+      var fr = 2 / 3, ifr = 1 - fr;
+      clr[8] = ~~(fr * c0r + ifr * c1r);
+      clr[9] = ~~(fr * c0g + ifr * c1g);
+      clr[10] = ~~(fr * c0b + ifr * c1b);
+      clr[11] = 255;
+      fr = 1 / 3;
+      ifr = 1 - fr;
+      clr[12] = ~~(fr * c0r + ifr * c1r);
+      clr[13] = ~~(fr * c0g + ifr * c1g);
+      clr[14] = ~~(fr * c0b + ifr * c1b);
+      clr[15] = 255;
+    } else {
+      var fr = 1 / 2, ifr = 1 - fr;
+      clr[8] = ~~(fr * c0r + ifr * c1r);
+      clr[9] = ~~(fr * c0g + ifr * c1g);
+      clr[10] = ~~(fr * c0b + ifr * c1b);
+      clr[11] = 255;
+      clr[12] = 0;
+      clr[13] = 0;
+      clr[14] = 0;
+      clr[15] = 0;
+    }
+    this.toSquare(data, sqr, clr, offset);
+  }
+  writeBCcolor(data, offset, sqr) {
+    var ends = this.mostDistant(sqr);
+    var c0r = sqr[ends >> 8], c0g = sqr[(ends >> 8) + 1], c0b = sqr[(ends >> 8) + 2];
+    var c1r = sqr[ends & 255], c1g = sqr[(ends & 255) + 1], c1b = sqr[(ends & 255) + 2];
+    var c0 = c0r >> 3 << 11 | c0g >> 2 << 5 | c0b >> 3;
+    var c1 = c1r >> 3 << 11 | c1g >> 2 << 5 | c1b >> 3;
+    if (c0 < c1) {
+      var t = c0;
+      c0 = c1;
+      c1 = t;
+    }
+    var c0b = Math.floor((c0 & 31) * (255 / 31)), c0g = Math.floor((c0 >>> 5 & 63) * (255 / 63)), c0r = Math.floor((c0 >> 11) * (255 / 31));
+    var c1b = Math.floor((c1 & 31) * (255 / 31)), c1g = Math.floor((c1 >>> 5 & 63) * (255 / 63)), c1r = Math.floor((c1 >> 11) * (255 / 31));
+    data[offset + 0] = c0 & 255;
+    data[offset + 1] = c0 >> 8;
+    data[offset + 2] = c1 & 255;
+    data[offset + 3] = c1 >> 8;
+    var fr = 2 / 3, ifr = 1 - fr;
+    var c2r = Math.floor(fr * c0r + ifr * c1r), c2g = Math.floor(fr * c0g + ifr * c1g), c2b = Math.floor(fr * c0b + ifr * c1b);
+    fr = 1 / 3;
+    ifr = 1 - fr;
+    var c3r = Math.floor(fr * c0r + ifr * c1r), c3g = Math.floor(fr * c0g + ifr * c1g), c3b = Math.floor(fr * c0b + ifr * c1b);
+    var boff = offset * 8 + 32;
+    for (var i = 0; i < 64; i += 4) {
+      var r = sqr[i], g = sqr[i + 1], b = sqr[i + 2];
+      var ds0 = this.colorDist(r, g, b, c0r, c0g, c0b);
+      var ds1 = this.colorDist(r, g, b, c1r, c1g, c1b);
+      var ds2 = this.colorDist(r, g, b, c2r, c2g, c2b);
+      var ds3 = this.colorDist(r, g, b, c3r, c3g, c3b);
+      var dsm = Math.min(ds0, Math.min(ds1, Math.min(ds2, ds3)));
+      var code = 0;
+      if (dsm == ds1) {
+        code = 1;
+      } else if (dsm == ds2) {
+        code = 2;
+      } else if (dsm == ds3) {
+        code = 3;
+      }
+      data[boff >> 3] |= code << (boff & 7);
+      boff += 2;
+    }
+  }
+  toSquare(data, sqr, clr, offset) {
+    var boff = offset + 4 << 3;
+    for (var i = 0; i < 64; i += 4) {
+      var code = data[boff >> 3] >> (boff & 7) & 3;
+      boff += 2;
+      code = code << 2;
+      sqr[i] = clr[code];
+      sqr[i + 1] = clr[code + 1];
+      sqr[i + 2] = clr[code + 2];
+      sqr[i + 3] = clr[code + 3];
+    }
+  }
+  read4x4(a, w, h, sx, sy, b) {
+    for (var y = 0; y < 4; y++) {
+      var si = (sy + y) * w + sx << 2, ti = y << 4;
+      b[ti + 0] = a[si + 0];
+      b[ti + 1] = a[si + 1];
+      b[ti + 2] = a[si + 2];
+      b[ti + 3] = a[si + 3];
+      b[ti + 4] = a[si + 4];
+      b[ti + 5] = a[si + 5];
+      b[ti + 6] = a[si + 6];
+      b[ti + 7] = a[si + 7];
+      b[ti + 8] = a[si + 8];
+      b[ti + 9] = a[si + 9];
+      b[ti + 10] = a[si + 10];
+      b[ti + 11] = a[si + 11];
+      b[ti + 12] = a[si + 12];
+      b[ti + 13] = a[si + 13];
+      b[ti + 14] = a[si + 14];
+      b[ti + 15] = a[si + 15];
+    }
+  }
+  write4x4(a, w, h, sx, sy, b) {
+    for (var y = 0; y < 4; y++) {
+      var si = (sy + y) * w + sx << 2, ti = y << 4;
+      a[si + 0] = b[ti + 0];
+      a[si + 1] = b[ti + 1];
+      a[si + 2] = b[ti + 2];
+      a[si + 3] = b[ti + 3];
+      a[si + 4] = b[ti + 4];
+      a[si + 5] = b[ti + 5];
+      a[si + 6] = b[ti + 6];
+      a[si + 7] = b[ti + 7];
+      a[si + 8] = b[ti + 8];
+      a[si + 9] = b[ti + 9];
+      a[si + 10] = b[ti + 10];
+      a[si + 11] = b[ti + 11];
+      a[si + 12] = b[ti + 12];
+      a[si + 13] = b[ti + 13];
+      a[si + 14] = b[ti + 14];
+      a[si + 15] = b[ti + 15];
+    }
+  }
+  rotate(sqr, rot) {
+    if (rot == 0) {
+      return;
+    }
+    for (var i = 0; i < 64; i += 4) {
+      var r = sqr[i];
+      var g = sqr[i + 1];
+      var b = sqr[i + 2];
+      var a = sqr[i + 3];
+      if (rot == 1) {
+        var t = a;
+        a = r;
+        r = t;
+      }
+      if (rot == 2) {
+        var t = a;
+        a = g;
+        g = t;
+      }
+      if (rot == 3) {
+        var t = a;
+        a = b;
+        b = t;
+      }
+      sqr[i] = r;
+      sqr[i + 1] = g;
+      sqr[i + 2] = b;
+      sqr[i + 3] = a;
+    }
+  }
+  readBits(data, pos, k) {
+    var out = 0, ok = k;
+    while (k != 0) {
+      out = out | this.readBit(data, pos) << ok - k;
+      k--;
+    }
+    return out;
+  }
+  readBit(data, pos) {
+    var boff = pos.boff;
+    pos.boff++;
+    return data[boff >> 3] >> (boff & 7) & 1;
+  }
+  mipmapB(buff, w, h) {
+    var nw = w >> 1, nh = h >> 1;
+    var nbuf = new Uint8Array(nw * nh * 4);
+    for (var y = 0; y < nh; y++) {
+      for (var x = 0; x < nw; x++) {
+        var ti = y * nw + x << 2, si = (y << 1) * w + (x << 1) << 2;
+        var a0 = buff[si + 3], a1 = buff[si + 7];
+        var r = buff[si] * a0 + buff[si + 4] * a1;
+        var g = buff[si + 1] * a0 + buff[si + 5] * a1;
+        var b = buff[si + 2] * a0 + buff[si + 6] * a1;
+        si += w << 2;
+        var a2 = buff[si + 3], a3 = buff[si + 7];
+        r += buff[si] * a2 + buff[si + 4] * a3;
+        g += buff[si + 1] * a2 + buff[si + 5] * a3;
+        b += buff[si + 2] * a2 + buff[si + 6] * a3;
+        var a = a0 + a1 + a2 + a3 + 2 >> 2, ia = a == 0 ? 0 : 0.25 / a;
+        nbuf[ti] = ~~(r * ia + 0.5);
+        nbuf[ti + 1] = ~~(g * ia + 0.5);
+        nbuf[ti + 2] = ~~(b * ia + 0.5);
+        nbuf[ti + 3] = a;
+      }
+    }
+    return nbuf;
+  }
+  colorDist(r, g, b, r0, g0, b0) {
+    return (r - r0) * (r - r0) + (g - g0) * (g - g0) + (b - b0) * (b - b0);
+  }
+  mostDistant(sqr) {
+    var ends = 0, dd = 0;
+    for (var i = 0; i < 64; i += 4) {
+      var r = sqr[i], g = sqr[i + 1], b = sqr[i + 2];
+      for (var j = i + 4; j < 64; j += 4) {
+        var dst = this.colorDist(r, g, b, sqr[j], sqr[j + 1], sqr[j + 2]);
+        if (dst > dd) {
+          dd = dst;
+          ends = i << 8 | j;
+        }
+      }
+    }
+    return ends;
+  }
+  // ── I/O helpers ─────────────────────────────────────────────────────────────
+  readUintLE(buff, p) {
+    this._int8[0] = buff[p + 0];
+    this._int8[1] = buff[p + 1];
+    this._int8[2] = buff[p + 2];
+    this._int8[3] = buff[p + 3];
+    return this._int[0];
+  }
+  writeUintLE(buff, p, n) {
+    this._int[0] = n;
+    buff[p + 0] = this._int8[0];
+    buff[p + 1] = this._int8[1];
+    buff[p + 2] = this._int8[2];
+    buff[p + 3] = this._int8[3];
+  }
+  readASCII(buff, p, l) {
+    let s = "";
+    for (let i = 0; i < l; i++) {
+      s += String.fromCharCode(buff[p + i]);
+    }
+    return s;
+  }
+  writeASCII(buff, p, s) {
+    for (let i = 0; i < s.length; i++) {
+      buff[p + i] = s.charCodeAt(i);
+    }
+  }
+};
+
+// src/commands/dds/decode.ts
+function ddsDecodeCommand() {
+  return new Command13("decode").description("Decode a DDS texture to a 32-bit RGBA PNG").argument("<file>", "path to the .dds file").action(async (file) => {
+    const buffer = await readFile4(file);
+    const frames = new DDSUtils().decode(buffer.buffer);
+    if (frames.length === 0) {
+      console.error("No frames decoded from DDS file");
+      process.exit(1);
+    }
+    const frame = frames[0];
+    const png = new PNG3({ width: frame.width, height: frame.height });
+    png.data = Buffer.from(frame.image);
+    const ext = extname2(file);
+    const outName = basename3(file, ext) + ".png";
+    const outPath = join4(dirname2(file), outName);
+    await writeFile6(outPath, PNG3.sync.write(png));
+    console.log(`Decoded \u2192 ${outPath}`);
+  });
+}
+
+// src/commands/dds/encode.ts
+import { readFile as readFile5, writeFile as writeFile7 } from "fs/promises";
+import { extname as extname3, join as join5, dirname as dirname3, basename as basename4 } from "path";
+import { Command as Command14 } from "commander";
+import { PNG as PNG4 } from "pngjs";
+function ddsEncodeCommand() {
+  return new Command14("encode").description("Encode a 32-bit RGBA PNG to a DXT5/BC3 DDS texture").argument("<file>", "path to the .png file").action(async (file) => {
+    const buffer = await readFile5(file);
+    const png = PNG4.sync.read(buffer);
+    const ddsBuffer = new DDSUtils().encode(png.data.buffer, png.width, png.height, true);
+    const ext = extname3(file);
+    const outName = basename4(file, ext) + ".dds";
+    const outPath = join5(dirname3(file), outName);
+    await writeFile7(outPath, Buffer.from(ddsBuffer));
+    console.log(`Encoded \u2192 ${outPath}`);
+  });
+}
+
+// src/commands/icon/dump-background.ts
+import { join as join6 } from "path";
+import { Command as Command15 } from "commander";
+
+// src/lib/icons/pogs/background-colors.ts
+var bgColors = {
+  Heavy: [
+    [123, 72, 36],
+    [121, 67, 33],
+    [117, 65, 32],
+    [114, 63, 31],
+    [110, 61, 30],
+    [108, 60, 29],
+    [105, 58, 29],
+    [102, 57, 28],
+    [98, 54, 27],
+    [93, 51, 26],
+    [90, 50, 25],
+    [86, 49, 24],
+    [81, 46, 23],
+    [77, 43, 22],
+    [72, 40, 20],
+    [68, 38, 18],
+    [64, 35, 17],
+    [59, 33, 16],
+    [55, 31, 15],
+    [51, 29, 14],
+    [48, 27, 13],
+    [43, 24, 12],
+    [39, 21, 11],
+    [35, 20, 9]
+  ],
+  Light: [
+    [104, 102, 63],
+    [104, 102, 63],
+    [104, 102, 63],
+    [104, 102, 63],
+    [104, 102, 63],
+    [103, 101, 62],
+    [101, 99, 61],
+    [98, 96, 59],
+    [95, 93, 58],
+    [92, 90, 56],
+    [88, 87, 54],
+    [85, 83, 51],
+    [81, 79, 49],
+    [77, 75, 47],
+    [73, 71, 44],
+    [69, 67, 42],
+    [65, 63, 40],
+    [61, 59, 37],
+    [57, 56, 35],
+    [53, 52, 33],
+    [50, 49, 31],
+    [47, 46, 29],
+    [44, 43, 27],
+    [42, 41, 26]
+  ],
+  Medium: [
+    [95, 125, 85],
+    [94, 124, 84],
+    [91, 122, 81],
+    [88, 120, 78],
+    [85, 118, 76],
+    [81, 114, 74],
+    [77, 111, 71],
+    [74, 108, 68],
+    [70, 105, 64],
+    [66, 102, 61],
+    [61, 99, 58],
+    [56, 96, 54],
+    [52, 93, 51],
+    [47, 88, 46],
+    [43, 85, 43],
+    [39, 81, 39],
+    [34, 78, 36],
+    [31, 75, 34],
+    [26, 72, 30],
+    [22, 70, 27],
+    [18, 66, 23],
+    [14, 63, 20],
+    [11, 60, 17],
+    [6, 57, 14]
+  ],
+  Spg: [
+    [177, 34, 55],
+    [174, 33, 54],
+    [171, 33, 53],
+    [167, 32, 52],
+    [164, 31, 51],
+    [158, 31, 49],
+    [154, 30, 48],
+    [149, 29, 47],
+    [143, 28, 44],
+    [139, 27, 43],
+    [132, 25, 41],
+    [126, 24, 39],
+    [120, 23, 38],
+    [113, 23, 36],
+    [108, 21, 35],
+    [101, 20, 32],
+    [95, 19, 30],
+    [90, 18, 28],
+    [83, 16, 26],
+    [77, 15, 24],
+    [71, 14, 22],
+    [64, 13, 20],
+    [60, 12, 19],
+    [53, 10, 17]
+  ],
+  TankDestroyer: [
+    [49, 104, 175],
+    [40, 96, 170],
+    [39, 93, 164],
+    [38, 92, 163],
+    [38, 90, 160],
+    [37, 88, 155],
+    [36, 86, 151],
+    [34, 82, 145],
+    [33, 79, 139],
+    [32, 76, 135],
+    [30, 73, 129],
+    [29, 70, 124],
+    [28, 67, 117],
+    [27, 63, 111],
+    [25, 60, 105],
+    [23, 56, 98],
+    [22, 52, 93],
+    [21, 49, 87],
+    [20, 46, 81],
+    [19, 43, 75],
+    [17, 39, 68],
+    [15, 35, 62],
+    [14, 33, 58],
+    [12, 29, 52]
+  ]
+};
+
+// src/lib/icons/pogs/pogs-constants.ts
+var PogsConstants = {
+  width: 80,
+  height: 24
+};
+
+// src/lib/icons/ImageBaker.ts
+import sharp4 from "sharp";
+var counter = 0;
+var ImageBaker = class {
+  #box;
+  #layers;
+  #finalizer;
+  constructor(box, layers, finalizer) {
+    this.#box = box;
+    this.#layers = layers;
+    this.#finalizer = finalizer;
+  }
+  async bake(vehicle2) {
+    counter++;
+    logger.debug(`baking ${vehicle2.short_name} (id:${vehicle2.tank_id}) icon (job:${counter})...`);
+    const blank = Buffer.alloc(this.#box.width * this.#box.height * 4, 0);
+    const overlays = [];
+    let prev = null;
+    for (const fn of this.#layers) {
+      let overlay = null;
+      try {
+        overlay = await fn(this.#box, prev, vehicle2);
+      } catch (e) {
+        logger.error("==============");
+        logger.error(`Error processing vehicle ${vehicle2.short_name} (${vehicle2.tank_id})`);
+        logger.error(e);
+        logger.error("==============");
+        process.exit(1);
+      }
+      if (overlay) {
+        overlays.push(overlay);
+      }
+      prev = overlay;
+    }
+    const result = sharp4(blank, { raw: { width: this.#box.width, height: this.#box.height, channels: 4 } }).composite(overlays);
+    const final = this.#finalizer ? this.#finalizer(result) : result;
+    logger.debug(`.  baked ${vehicle2.short_name} (${vehicle2.tank_id}) icon successfully
+`);
+    return final;
+  }
+};
+
+// src/lib/icons/layers/gradient-background.ts
+var TYPE_TO_KEY = {
+  lightTank: "Light",
+  mediumTank: "Medium",
+  heavyTank: "Heavy",
+  "AT-SPG": "TankDestroyer",
+  SPG: "Spg"
+};
+function gradientBackground(colors = bgColors) {
+  const cache2 = /* @__PURE__ */ new Map();
+  return async (box, _prev, vehicle2) => {
+    const key = TYPE_TO_KEY[vehicle2.type];
+    const rows = colors[key];
+    if (!rows) {
+      throw new Error(`No gradient colors for vehicle type: ${vehicle2.type}`);
+    }
+    let overlay = cache2.get(key);
+    if (overlay === void 0) {
+      const height = rows.length;
+      const pixels = Buffer.alloc(box.width * height * 4);
+      for (let y = 0; y < height; y++) {
+        const [r, g, b] = rows[y];
+        for (let x = 0; x < box.width; x++) {
+          const i = (y * box.width + x) * 4;
+          pixels[i] = r;
+          pixels[i + 1] = g;
+          pixels[i + 2] = b;
+          pixels[i + 3] = 255;
+        }
+      }
+      overlay = {
+        input: pixels,
+        raw: { width: box.width, height, channels: 4 },
+        left: 0,
+        top: 0,
+        meta: { width: box.width, height, left: 0, top: 0 }
+      };
+      cache2.set(key, overlay);
+    }
+    return overlay;
+  };
+}
+
+// src/lib/icons/layers/bar-and-shield.ts
+import sharp5 from "sharp";
+var SHIELD_PATH = resolveAsset(new URL(import.meta.url), "pogs/sheild.png");
+var STRIPE_PATH = resolveAsset(new URL(import.meta.url), "pogs/stripe.png");
+function barAndShield() {
+  const cache2 = /* @__PURE__ */ new Map();
+  return async (box, _prev, _vehicle) => {
+    const key = `${box.width}x${box.height}`;
+    let overlay = cache2.get(key);
+    if (overlay === void 0) {
+      const blank = Buffer.alloc(box.width * box.height * 4, 0);
+      const { data } = await sharp5(blank, { raw: { width: box.width, height: box.height, channels: 4 } }).composite([
+        { input: STRIPE_PATH, top: 0, left: 0 },
+        { input: SHIELD_PATH, top: 2, left: 1 }
+      ]).raw().toBuffer({ resolveWithObject: true });
+      overlay = { input: data, raw: { width: box.width, height: box.height, channels: 4 }, left: 0, top: 0, meta: { width: box.width, height: box.height, left: 0, top: 0 } };
+      cache2.set(key, overlay);
+    }
+    return overlay;
+  };
+}
+
+// src/commands/icon/dump-background.ts
+function dumpBackgroundCommand() {
+  return new Command15("dump-background").description("Write a composited tank-type icon background (gradient + shield) for each type to cwd").action(async () => {
+    const baker = new ImageBaker(PogsConstants, [
+      gradientBackground(),
+      barAndShield()
+    ]);
+    for (const type of Object.keys(bgColors)) {
+      const stub = { type };
+      const outPath = join6(process.cwd(), `${type.toLowerCase()}.png`);
+      await (await baker.bake(stub)).png().toFile(outPath);
+      console.log(`Written ${outPath}`);
+    }
+  });
+}
+
+// src/commands/icon/render.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7 } from "path";
+import { Command as Command16 } from "commander";
+
+// src/lib/icons/layers/vehicle-icon.ts
+import sharp6 from "sharp";
+
+// src/lib/utils.ts
+function darkenIcon(buffer, factor) {
+  const out = Buffer.from(buffer);
+  for (let i = 0; i < out.length; i += 4) {
+    if (out[i] === 0 && out[i + 1] === 0 && out[i + 2] === 0) {
+      continue;
+    }
+    out[i] = Math.round(out[i] * factor);
+    out[i + 1] = Math.round(out[i + 1] * factor);
+    out[i + 2] = Math.round(out[i + 2] * factor);
+  }
+  return out;
+}
+
+// src/lib/box-utils/Aligner.ts
+var ALIASES = {
+  // top-left
+  tl: "tl",
+  lt: "tl",
+  "top-left": "tl",
+  "left-top": "tl",
+  // top-middle
+  tm: "tm",
+  tc: "tm",
+  ct: "tm",
+  top: "tm",
+  "top-center": "tm",
+  "top-middle": "tm",
+  "center-top": "tm",
+  "middle-top": "tm",
+  // top-right
+  tr: "tr",
+  rt: "tr",
+  "top-right": "tr",
+  "right-top": "tr",
+  // left-middle
+  lm: "lm",
+  lc: "lm",
+  cl: "lm",
+  ml: "lm",
+  left: "lm",
+  "left-center": "lm",
+  "left-middle": "lm",
+  "center-left": "lm",
+  "middle-left": "lm",
+  // center
+  c: "c",
+  m: "c",
+  cc: "c",
+  center: "c",
+  middle: "c",
+  // right-middle
+  rm: "rm",
+  rc: "rm",
+  cr: "rm",
+  mr: "rm",
+  right: "rm",
+  "right-center": "rm",
+  "right-middle": "rm",
+  "center-right": "rm",
+  "middle-right": "rm",
+  // bottom-left
+  bl: "bl",
+  lb: "bl",
+  "bottom-left": "bl",
+  "left-bottom": "bl",
+  // bottom-middle
+  bm: "bm",
+  bc: "bm",
+  cb: "bm",
+  mb: "bm",
+  bottom: "bm",
+  "bottom-center": "bm",
+  "bottom-middle": "bm",
+  "center-bottom": "bm",
+  "middle-bottom": "bm",
+  // bottom-right
+  br: "br",
+  rb: "br",
+  "bottom-right": "br",
+  "right-bottom": "br"
+};
+var OFFSETS = {
+  tl: [0, 0],
+  tm: [0.5, 0],
+  tr: [1, 0],
+  lm: [0, 0.5],
+  c: [0.5, 0.5],
+  rm: [1, 0.5],
+  bl: [0, 1],
+  bm: [0.5, 1],
+  br: [1, 1]
+};
+var ROUND_SUFFIXES = /* @__PURE__ */ new Set([".u", ".d", ".+", ".-"]);
+var INNER_RE = /^(t|l|c|r|b|w|bw|h|bh)(?:\s*([+\-\/])\s*(\d+(?:\.\d+)?))?$/;
+var Aligner = class _Aligner {
+  params;
+  #bx;
+  #by;
+  #sx = 0;
+  #sy = 0;
+  constructor(box, rectAnchor, boxAnchor) {
+    this.params = { box, rectAnchor, boxAnchor };
+    [this.#bx, this.#by] = Array.isArray(boxAnchor) ? [_Aligner.#resolveAxisExpr(boxAnchor[0], box.width, box.height, "x"), _Aligner.#resolveAxisExpr(boxAnchor[1], box.width, box.height, "y")] : _Aligner.#resolveAnchorWithRound(boxAnchor, box.width, box.height);
+  }
+  align(rect) {
+    const [ox, oy] = _Aligner.#resolveAnchorWithRound(this.params.rectAnchor, rect.width, rect.height);
+    return { left: this.#bx + this.#sx - ox, top: this.#by + this.#sy - oy, width: rect.width, height: rect.height };
+  }
+  clone(overrides) {
+    const a = new _Aligner(
+      overrides?.box ?? this.params.box,
+      overrides?.rectAnchor ?? this.params.rectAnchor,
+      overrides?.boxAnchor ?? this.params.boxAnchor
+    );
+    a.#sx = this.#sx;
+    a.#sy = this.#sy;
+    return a;
+  }
+  shift(x, y) {
+    const a = new _Aligner(this.params.box, this.params.rectAnchor, this.params.boxAnchor);
+    a.#sx = this.#sx + x;
+    a.#sy = this.#sy + y;
+    return a;
+  }
+  static #applySuffixRound(suffix, n) {
+    return suffix === ".u" || suffix === ".+" ? Math.ceil(n) : Math.floor(n);
+  }
+  static #resolveOffset(alias, w, h) {
+    const [fx, fy] = OFFSETS[ALIASES[alias]];
+    return [fx * w, fy * h];
+  }
+  static #resolveAnchorWithRound(alias, w, h) {
+    const last2 = alias.slice(-2);
+    const hasSuffix = ROUND_SUFFIXES.has(last2);
+    const pureAlias = hasSuffix ? alias.slice(0, -2) : alias;
+    const suffix = hasSuffix ? last2 : void 0;
+    const [rx, ry] = _Aligner.#resolveOffset(pureAlias, w, h);
+    return [_Aligner.#applySuffixRound(suffix, rx), _Aligner.#applySuffixRound(suffix, ry)];
+  }
+  static #resolveDimRef(dim, bw, bh, axis) {
+    if (dim === "t" || dim === "l") {
+      return 0;
+    }
+    if (dim === "c") {
+      return axis === "x" ? bw / 2 : bh / 2;
+    }
+    if (dim === "r" || dim === "w" || dim === "bw") {
+      return bw;
+    }
+    return bh;
+  }
+  static #resolveInner(expr, bw, bh, axis) {
+    const match = INNER_RE.exec(expr.trim());
+    if (!match) {
+      throw new Error(`Invalid axis expression: "${expr}"`);
+    }
+    const [, dim, op, numStr] = match;
+    const base = _Aligner.#resolveDimRef(dim, bw, bh, axis);
+    if (!op) {
+      return base;
+    }
+    const n = Number(numStr);
+    if (op === "+") {
+      return base + n;
+    }
+    if (op === "-") {
+      return base - n;
+    }
+    return base / n;
+  }
+  static #resolveAxisExpr(expr, bw, bh, axis) {
+    if (typeof expr === "number") {
+      return expr;
+    }
+    const s = String(expr);
+    const groupMatch = /^\((.+)\)([.][ud+\-])$/.exec(s);
+    if (groupMatch) {
+      return _Aligner.#applySuffixRound(groupMatch[2], _Aligner.#resolveInner(groupMatch[1], bw, bh, axis));
+    }
+    const last2 = s.slice(-2);
+    if (ROUND_SUFFIXES.has(last2)) {
+      return _Aligner.#applySuffixRound(last2, _Aligner.#resolveInner(s.slice(0, -2).trim(), bw, bh, axis));
+    }
+    return Math.floor(_Aligner.#resolveInner(s, bw, bh, axis));
+  }
+};
+
+// src/lib/box-utils/index.ts
+function createAligner(box, rectAnchor, boxAnchor) {
+  return new Aligner(box, rectAnchor, boxAnchor);
+}
+
+// src/lib/icons/layers/vehicle-icon.ts
+var MAX_ICON_W = 62;
+var MAX_ICON_H = 15;
+var defaultAligner = createAligner(PogsConstants, "bm.+", [40, "bh"]);
+function fitToBox(srcW, srcH) {
+  const aspect = srcW / srcH;
+  let w = srcW;
+  let h = srcH;
+  if (w > MAX_ICON_W) {
+    w = MAX_ICON_W;
+    h = Math.trunc(w / aspect);
+  }
+  if (h > MAX_ICON_H) {
+    h = MAX_ICON_H;
+    w = Math.trunc(h * aspect);
+  }
+  return { width: w, height: h };
+}
+function vehicleIcon(data, aligner = defaultAligner) {
+  return async (box, _prev, vehicle2) => {
+    const iconResult = await data.getDefaultVehicleIcon(vehicle2, "medium");
+    if (!iconResult) {
+      return null;
+    }
+    const { data: iconData, info: iconInfo } = iconResult;
+    const { width: iconW, height: iconH } = fitToBox(iconInfo.width, iconInfo.height);
+    const { data: scaledData, info: scaledInfo } = await sharp6(darkenIcon(iconData, 0.5), {
+      raw: { width: iconInfo.width, height: iconInfo.height, channels: iconInfo.channels }
+    }).resize(iconW, iconH).raw().toBuffer({ resolveWithObject: true });
+    const { data: trimmedData, info: trimmedInfo } = await sharp6(scaledData, {
+      raw: { width: scaledInfo.width, height: scaledInfo.height, channels: scaledInfo.channels }
+    }).trim({ threshold: 13 }).raw().toBuffer({ resolveWithObject: true });
+    const { width, height } = trimmedInfo;
+    const { left, top } = aligner.align({ width: trimmedInfo.width, height: trimmedInfo.height });
+    return {
+      input: trimmedData,
+      raw: { width, height, channels: trimmedInfo.channels },
+      left,
+      top,
+      meta: { width, height, left, top }
+    };
+  };
+}
+
+// src/lib/icons/layers/tier-text.ts
+var defaultAligner2 = createAligner(PogsConstants, "tm.+", [10, 5]);
+function tierText(aligner = defaultAligner2) {
+  const cache2 = /* @__PURE__ */ new Map();
+  return async (_box, _prev, vehicle2) => {
+    let rendered = cache2.get(vehicle2.tier);
+    if (rendered === void 0) {
+      const fontName = vehicle2.tier > 12 ? "pogsNumbersBold" : "pogsNumbers";
+      rendered = await renderWithShadow(fontName, String(vehicle2.tier));
+      cache2.set(vehicle2.tier, rendered);
+    }
+    const { width, height } = rendered;
+    const text = String(vehicle2.tier);
+    const { left, top } = aligner.align(rendered);
+    return {
+      input: rendered.data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text }
+    };
+  };
+}
+
+// src/lib/icons/layers/name-text.ts
+var NAME_X = 18;
+var NAME_Y = 2;
+function nameText() {
+  return async (_box, _prev, vehicle2) => {
+    const alias = lookupShortName(vehicle2).toLowerCase();
+    const { data, width, height } = await renderWithShadow("pogs4px", alias);
+    return { input: data, raw: { width, height, channels: 4 }, left: NAME_X, top: NAME_Y, meta: { width, height, left: NAME_X, top: NAME_Y, text: alias } };
+  };
+}
+
+// src/lib/icons/pogs/PogsClear.ts
+var iconAligner = createAligner(PogsConstants, "bl.+", [18, 1]);
+var PogsClear = class {
+  createBaker(app2) {
+    return new ImageBaker(
+      PogsConstants,
+      [barAndShield(), vehicleIcon(app2, iconAligner), tierText(), nameText()]
+    );
+  }
+};
+
+// src/lib/icons/pogs/PogsColor.ts
+var iconAligner2 = createAligner(PogsConstants, "bl.+", [18, 1]);
+var PogsColor = class {
+  createBaker(app2) {
+    return new ImageBaker(
+      PogsConstants,
+      [
+        gradientBackground(),
+        barAndShield(),
+        vehicleIcon(app2, iconAligner2),
+        tierText(),
+        nameText()
+      ],
+      (s) => s.removeAlpha()
+    );
+  }
+};
+
+// src/lib/icons/layers/pre-rendered-background.ts
+import { readFile as readFile6 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import sharp7 from "sharp";
+var TYPE_MAP = {
+  lightTank: "lt",
+  mediumTank: "mt",
+  heavyTank: "ht",
+  "AT-SPG": "td",
+  SPG: "at"
+};
+var selfUrl = new URL(import.meta.url);
+function preRenderedBackground(version2, flavor = "") {
+  const cache2 = /* @__PURE__ */ new Map();
+  const dir = resolveAsset(selfUrl, `pogs-fixed/pre-rendered/combined-v${version2}`);
+  return async (box, _prev, vehicle2) => {
+    if (version2 === 1) {
+      flavor = "";
+    }
+    const isPrem = vehicle2.is_premium || vehicle2.is_premium_igr || vehicle2.is_gift;
+    const mappedType = TYPE_MAP[vehicle2.type];
+    const flavorSuffix = flavor ? `.${flavor}` : "";
+    const premSuffix = isPrem ? ".prem" : "";
+    const filename = `${mappedType}${flavorSuffix}${premSuffix}.png`;
+    let overlay = cache2.get(filename);
+    if (overlay === void 0) {
+      const filePath = resolve4(dir, filename);
+      const fileBuffer = await readFile6(filePath);
+      const { data } = await sharp7(fileBuffer).ensureAlpha().extract({ left: 0, top: 0, width: box.width, height: box.height }).raw().toBuffer({ resolveWithObject: true });
+      overlay = { input: data, raw: { width: box.width, height: box.height, channels: 4 }, left: 0, top: 0, meta: { width: box.width, height: box.height, left: 0, top: 0 } };
+      cache2.set(filename, overlay);
+    }
+    return overlay;
+  };
+}
+
+// src/lib/icons/pogs/PogsClearV1.ts
+var iconAligner3 = createAligner(PogsConstants, "bl.+", [18, "(bh - 1).+"]);
+var PogsClearV1 = class {
+  version = 1;
+  createBaker(app2) {
+    return new ImageBaker(
+      PogsConstants,
+      [
+        preRenderedBackground(this.version, "clear"),
+        vehicleIcon(app2, iconAligner3),
+        tierText(),
+        nameText()
+      ]
+    );
+  }
+};
+
+// src/lib/icons/pogs/PogsClearV2.ts
+var PogsClearV2 = class extends PogsClearV1 {
+  version = 2;
+};
+
+// src/lib/icons/layers/text-view-range.ts
+var defaultAligner3 = createAligner(PogsConstants, "br.+", [37, "bh - 1"]);
+function textViewRange(app2, aligner = defaultAligner3) {
+  return async (_box, _prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const viewRange = profiles[vehicle2.tank_id]?.turret?.view_range;
+    if (viewRange === void 0) {
+      return null;
+    }
+    const { data, width, height } = await renderWithShadow("pogs4px", viewRange, Colors.beige);
+    const { left, top } = aligner.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text: viewRange }
+    };
+  };
+}
+
+// src/lib/icons/layers/text-reload.ts
+var defaultAligner4 = createAligner(PogsConstants, "br.+", [37, "bh - 8"]);
+function textReload(app2, aligner = defaultAligner4) {
+  return async (_box, _prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const reloadTime = profiles[vehicle2.tank_id]?.gun?.reload_time;
+    if (reloadTime === void 0) {
+      return null;
+    }
+    const { data, width, height } = await renderWithShadow("pogs4px", reloadTime, Colors.yellow);
+    const { left, top } = aligner.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text: reloadTime }
+    };
+  };
+}
+
+// src/lib/icons/layers/text-hull-armor.ts
+var defaultAligner5 = createAligner(PogsConstants, "br", ["r", "b - 1"]);
+function textHullArmor(app2, aligner = defaultAligner5) {
+  return async (_box, _prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const hull = profiles[vehicle2.tank_id]?.armor?.hull;
+    if (hull === void 0) {
+      return null;
+    }
+    const text = `${hull.front}*${hull.sides}*${hull.rear}`;
+    const { data, width, height } = await renderWithShadow("pogs4px", text, Colors.white);
+    const { left, top } = aligner.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text }
+    };
+  };
+}
+
+// src/lib/icons/layers/text-turret-armor.ts
+var defaultAligner6 = createAligner(PogsConstants, "br", ["r", "b - 8"]);
+function textTurretArmor(app2, aligner = defaultAligner6) {
+  return async (_box, prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const turret = profiles[vehicle2.tank_id]?.armor?.turret;
+    if (!turret) {
+      return null;
+    }
+    const text = `${turret.front}*`;
+    const { data, width, height } = await renderWithShadow("pogs4px", text, Colors.white);
+    const offsetX = -1 * prev.meta.width + width;
+    const shifted = aligner.shift(offsetX, 0);
+    const { left, top } = shifted.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text }
+    };
+  };
+}
+
+// src/lib/icons/layers/text-penetration.ts
+var defaultAligner7 = createAligner(PogsConstants, "rt", ["r", 2]);
+function textPenetration(app2, aligner = defaultAligner7) {
+  return async (_box, _prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const text = profiles[vehicle2.tank_id]?.ammo?.[0].penetration?.[1];
+    if (text === void 0) {
+      return null;
+    }
+    const { data, width, height } = await renderWithShadow("pogs4px", text, Colors.beige);
+    const { left, top } = aligner.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text }
+    };
+  };
+}
+
+// src/lib/icons/layers/text-damage.ts
+var defaultAligner8 = createAligner(PogsConstants, "rt", ["r", 9]);
+function textDamage(app2, aligner = defaultAligner8) {
+  return async (_box, _prev, vehicle2) => {
+    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const text = profiles[vehicle2.tank_id]?.ammo?.[0].damage?.[1];
+    if (text === void 0) {
+      return null;
+    }
+    const { data, width, height } = await renderWithShadow("pogs4px", text, Colors.beige);
+    const { left, top } = aligner.align({ width, height });
+    return {
+      input: data,
+      raw: { width, height, channels: 4 },
+      left,
+      top,
+      meta: { width, height, left, top, text }
+    };
+  };
+}
+
+// src/lib/icons/pogs/PogsColorV1.ts
+var PogsColorV1 = class {
+  version = 1;
+  createBaker(data) {
+    return new ImageBaker(
+      PogsConstants,
+      [
+        preRenderedBackground(this.version, ""),
+        vehicleIcon(data),
+        textViewRange(data),
+        textReload(data),
+        textPenetration(data),
+        textDamage(data),
+        textHullArmor(data),
+        textTurretArmor(data),
+        tierText(),
+        nameText()
+      ],
+      (s) => s.removeAlpha()
+    );
+  }
+};
+
+// src/lib/icons/pogs/PogsColorV2.ts
+var PogsColorV2 = class extends PogsColorV1 {
+  version = 2;
+};
+
+// src/commands/icon/render.ts
+var CONCURRENCY = 5;
+async function renderOneToFile(vehicle2, baker, outDir) {
+  const outPath = join7(outDir, `${vehicle2.nation}-${vehicle2.tag}.png`);
+  const info = await (await baker.bake(vehicle2)).png().toFile(outPath);
+  console.log(`${outPath} \u2014 ${info.width}\xD7${info.height}px`);
+}
+function iconRenderCommand(app2) {
+  return new Command16("render").description("Render a vehicle icon with its short name label composited over a type background").argument("[query]", "tank_id (number), tag, or short_name").option("--all", "render all vehicles").option("--color", "use color variant (default)").option("--clear", "use clear variant (no color background)").option("--bg <version>", "use pre-rendered background at given version").option("--pre-rendered-bg <version>", "alias for --bg").option("--to <dir>", "output directory (default: current working directory)").option("--create", "create output directory if it does not exist").action(async (query, options) => {
+    try {
+      if (!query && !options.all) {
+        console.error("Provide a query argument or use --all to render all vehicles.");
+        process.exit(1);
+      }
+      const outDir = options.to ?? process.cwd();
+      if (options.to && !existsSync2(outDir)) {
+        if (!options.create) {
+          console.error(`Directory does not exist: ${outDir}
+Provide an existing path or add --create to create it.`);
+          process.exit(1);
+        }
+        mkdirSync2(outDir, { recursive: true });
+      }
+      const bgVersion = options.bg ?? options.preRenderedBg ?? (options.clear ? "v2" : void 0);
+      let builder;
+      const useColor = !options.clear;
+      if (bgVersion !== void 0) {
+        const version2 = parseInt(bgVersion.replace(/\D+/g, ""), 10);
+        if (version2 === 1) {
+          builder = useColor ? new PogsColorV1() : new PogsClearV1();
+        } else {
+          builder = useColor ? new PogsColorV2() : new PogsClearV2();
+        }
+      } else {
+        builder = useColor ? new PogsColor() : new PogsClear();
+      }
+      const vehicles = options.all ? await app2.getVehicles() : [await app2.findVehicle(query)];
+      const bakers = Array.from({ length: CONCURRENCY }, () => builder.createBaker(app2));
+      let idx = 0;
+      await Promise.all(
+        bakers.map(async (baker) => {
+          while (idx < vehicles.length) {
+            const vehicle2 = vehicles[idx++];
+            await renderOneToFile(vehicle2, baker, outDir);
+          }
+        })
+      );
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/icon/fetch.ts
+import { Command as Command17 } from "commander";
+function parseSize(input) {
+  switch (input.toLowerCase()) {
+    case "s":
+    case "small":
+      return "small";
+    case "m":
+    case "medium":
+      return "medium";
+    case "l":
+    case "large":
+      return "large";
+    case "xs":
+      return "xs";
+    default:
+      throw new Error(`Invalid size "${input}". Use xs, s/small, m/medium, or l/large.`);
+  }
+}
+function iconFetchCommand(app2) {
+  return new Command17("fetch").description("Download vehicle icons into .data/icons/{size}/").argument("[query]", "tank_id (number), tag, or short_name \u2014 omit to fetch all").option("--size <size>", "icon size: s/small, m/medium (default), l/large", "medium").option("--all", "fetch icons for all vehicles").option("--force", "re-download icons that already exist locally").option("--concurrency <n>", "parallel downloads", "10").action(async (query, options) => {
+    if (!query && !options.all) {
+      console.error("Provide a query to fetch a single vehicle, or pass --all to fetch every vehicle.");
+      process.exit(1);
+    }
+    try {
+      await app2.fetchIcons({
+        query,
+        size: parseSize(options.size),
+        force: options.force,
+        concurrency: Math.max(1, parseInt(options.concurrency, 10) || 10)
+      });
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/icon/shrink.ts
+import { Command as Command18 } from "commander";
+function iconShrinkCommand(app2) {
+  return new Command18("shrink").description("Fetch medium icons, trim transparent borders, save as xs in .data/icons/xs/").argument("[query]", "tank_id (number), tag, or short_name \u2014 omit to process all").option("--all", "process icons for all vehicles").option("--force", "re-process icons that are already cached").option("--concurrency <n>", "parallel downloads", "10").action(async (query, options) => {
+    if (!query && !options.all) {
+      console.error("Provide a query to shrink a single vehicle icon, or pass --all to process every vehicle.");
+      process.exit(1);
+    }
+    try {
+      await app2.fetchIcons({
+        query,
+        size: "xs",
+        force: options.force ?? false,
+        concurrency: Math.max(1, parseInt(options.concurrency, 10) || 10)
+      });
+    } catch (error) {
+      if (error instanceof WGApiError) {
+        console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
+      } else {
+        console.error("Error:", error instanceof Error ? error.message : error);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/lib/tomato-api.ts
+import { appendFile, mkdir as mkdir3, readFile as readFile7, stat, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname4, join as join8, resolve as resolve5 } from "path";
+var HttpError = class extends Error {
+  constructor(status, url) {
+    super(`HTTP ${status} for ${url}`);
+    this.status = status;
+  }
+  status;
+};
+var TomatoApi = class {
+  BACKOFF_INTERVAL = 65 * 1e3;
+  dataDir;
+  apiKey;
+  rateLimit;
+  logPath;
+  lastRequestAt = 0;
+  draining = false;
+  queue = [];
+  constructor(dataDir = "./tomato/data", apiKey = "", rateLimit = 30) {
+    this.dataDir = resolve5(findPkgRoot(new URL(import.meta.url)), dataDir);
+    this.apiKey = apiKey || process.env.TOMATO_API_KEY || "";
+    this.rateLimit = rateLimit;
+    this.logPath = join8(this.dataDir, "requests.log");
+  }
+  async fetchVehicleVisuals(vehicleId, forceUpdate = false) {
+    const filename = "index.json";
+    const t0 = Date.now();
+    if (!forceUpdate && await this.hasData(vehicleId, filename)) {
+      return { vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data: await this.loadData(vehicleId, filename) };
+    }
+    return new Promise((resolve8) => {
+      this.queue.push(() => this.runVehicleVisuals(vehicleId, filename, resolve8));
+      void this.drain();
+    });
+  }
+  async fetchVehicleLoadouts(vehicleId, forceUpdate = false) {
+    const filename = "loadouts.json";
+    const t0 = Date.now();
+    if (!forceUpdate && await this.hasData(vehicleId, filename)) {
+      return { vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data: await this.loadData(vehicleId, filename) };
+    }
+    return new Promise((resolve8) => {
+      this.queue.push(() => this.runVehicleLoadouts(vehicleId, filename, resolve8));
+      void this.drain();
+    });
+  }
+  async fetchVehicleProLoadouts(vehicleId, forceUpdate = false) {
+    const filename = "pro-loadouts.json";
+    const t0 = Date.now();
+    if (!forceUpdate && await this.hasData(vehicleId, filename)) {
+      return { vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data: await this.loadData(vehicleId, filename) };
+    }
+    return new Promise((resolve8) => {
+      this.queue.push(() => this.runVehicleProLoadouts(vehicleId, filename, resolve8));
+      void this.drain();
+    });
+  }
+  async runVehicleVisuals(vehicleId, filename, resolve8) {
+    const t0 = Date.now();
+    const url = `https://tomato.gg/wot/vehicles/visuals/${vehicleId}.json`;
+    try {
+      const data = await this.request(url);
+      await this.saveResponse(vehicleId, filename, data);
+      resolve8({ vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data });
+    } catch (err) {
+      resolve8({ vehicleId, fileName: filename, success: false, elapsed: Date.now() - t0, data: void 0, error: err instanceof Error ? err : new Error(String(err)) });
+      throw err;
+    }
+  }
+  async runVehicleLoadouts(vehicleId, filename, resolve8) {
+    const t0 = Date.now();
+    const url = `https://api.tomato.gg/api/tank/loadout-performance/${vehicleId}?cache=true`;
+    try {
+      const data = await this.request(url);
+      await this.saveResponse(vehicleId, filename, data);
+      resolve8({ vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data });
+    } catch (err) {
+      resolve8({ vehicleId, fileName: filename, success: false, elapsed: Date.now() - t0, data: void 0, error: err instanceof Error ? err : new Error(String(err)) });
+      throw err;
+    }
+  }
+  async runVehicleProLoadouts(vehicleId, filename, resolve8) {
+    const t0 = Date.now();
+    const url = `https://api.tomato.gg/api/tank/top-loadouts/${vehicleId}?cache=true`;
+    try {
+      const data = await this.request(url);
+      await this.saveResponse(vehicleId, filename, data);
+      resolve8({ vehicleId, fileName: filename, success: true, elapsed: Date.now() - t0, data });
+    } catch (err) {
+      if (err instanceof HttpError && err.status === 404) {
+        await this.saveResponse(vehicleId, filename, null);
+      }
+      resolve8({ vehicleId, fileName: filename, success: false, elapsed: Date.now() - t0, data: void 0, error: err instanceof Error ? err : new Error(String(err)) });
+      throw err;
+    }
+  }
+  async request(url) {
+    const response = await fetch(url, {
+      headers: { "x-api-key": this.apiKey },
+      signal: AbortSignal.timeout(1e4)
+    });
+    await this.logRequest(url, response.status);
+    if (!response.ok) {
+      throw new HttpError(response.status, url);
+    }
+    return response.json();
+  }
+  async drain() {
+    if (this.draining) {
+      return;
+    }
+    this.draining = true;
+    try {
+      while (this.queue.length > 0) {
+        await this.waitForRateLimit();
+        this.lastRequestAt = Date.now();
+        const task = this.queue.shift();
+        try {
+          await task();
+        } catch (err) {
+          if (err instanceof HttpError && err.status !== 404) {
+            this.lastRequestAt += this.BACKOFF_INTERVAL;
+            console.log(`Looks like rate/limit wall hit. Backing of for ${this.BACKOFF_INTERVAL / 1e3} sec`);
+          }
+        }
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  async waitForRateLimit() {
+    const intervalMs = Math.ceil(6e4 / this.rateLimit);
+    const last = await this.getLastRequestTime();
+    const waitMs = last + intervalMs - Date.now();
+    if (waitMs > 0) {
+      await new Promise((r) => setTimeout(r, waitMs));
+    }
+  }
+  async getLastRequestTime() {
+    let logMtime = 0;
+    try {
+      const s = await stat(this.logPath);
+      logMtime = s.mtimeMs;
+    } catch {
+    }
+    return Math.max(this.lastRequestAt, logMtime);
+  }
+  resolveFilePath(vehicleId, filename) {
+    return join8(this.dataDir, String(vehicleId), filename);
+  }
+  async hasData(vehicleId, filename) {
+    try {
+      await stat(this.resolveFilePath(vehicleId, filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async loadData(vehicleId, filename) {
+    const content = await readFile7(this.resolveFilePath(vehicleId, filename), "utf-8");
+    return JSON.parse(content);
+  }
+  async saveResponse(vehicleId, filename, data) {
+    const filePath = this.resolveFilePath(vehicleId, filename);
+    await mkdir3(dirname4(filePath), { recursive: true });
+    await writeFile8(filePath, JSON.stringify(data, null, 2));
+  }
+  async logRequest(url, status) {
+    await mkdir3(this.dataDir, { recursive: true });
+    await appendFile(this.logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${url} ${status}
+`);
+  }
+};
+
+// src/commands/tomato/fetch.ts
+import { Command as Command19 } from "commander";
+
+// src/lib/vehicle-type-helpers.ts
+var TYPE_MAP2 = {
+  lightTank: "lt",
+  mediumTank: "mt",
+  heavyTank: "ht",
+  "AT-SPG": "td",
+  SPG: "at"
+};
+var ALIAS_MAP = Object.fromEntries(
+  Object.entries(TYPE_MAP2).map(([type, alias]) => [alias, type])
+);
+function fromTypeAlias(alias) {
+  const type = ALIAS_MAP[alias];
+  if (!type) {
+    throw new Error(`Unknown vehicle type alias: ${alias}`);
+  }
+  return type;
+}
+
+// src/commands/tomato/fetch.ts
+var TYPE_ALIASES = ["lt", "mt", "ht", "td", "at"];
+async function fetchVehicle(tomato2, vehicle2) {
+  return Promise.all([
+    tomato2.fetchVehicleVisuals(vehicle2.tank_id),
+    tomato2.fetchVehicleLoadouts(vehicle2.tank_id),
+    tomato2.fetchVehicleProLoadouts(vehicle2.tank_id)
+  ]);
+}
+function vehicleLine(results, vehicle2, prefix = "") {
+  const succeeded = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  const elapsed = results.reduce((sum, r) => sum + r.elapsed, 0);
+  const status = failed === 0 ? "OK" : succeeded === 0 ? "FAILED" : "PARTIAL";
+  return `${prefix}${vehicle2.short_name} (${vehicle2.tank_id}): ${status} (${succeeded}/${failed}) ${elapsed}ms`;
+}
+function printErrors(results) {
+  for (const r of results) {
+    if (!r.success) {
+      console.error(`    error [${r.fileName}]: ${r.error?.message ?? "unknown"}`);
+    }
+  }
+}
+function printSummary(succeeded, failed) {
+  const total = succeeded + failed;
+  const summary = failed === 0 ? `${total} requests, ${succeeded} succeeded` : `${total} requests, ${succeeded} succeeded, ${failed} failed`;
+  console.log(summary);
+}
+function tomatoFetchCommand(app2, tomato2) {
+  return new Command19("fetch").description("Fetch Tomato.gg data for one vehicle or a filtered batch").argument("[query]", "tank_id (number), tag, or short_name").option("--tier <n>", "tier filter for batch mode", Number, 11).option("--lt", "include light tanks").option("--mt", "include medium tanks").option("--ht", "include heavy tanks").option("--td", "include tank destroyers (AT-SPG)").option("--at", "include SPGs (artillery)").action(async (query, options) => {
+    try {
+      if (query) {
+        const vehicle2 = await app2.findVehicle(query);
+        console.error(`Fetching data for ${vehicle2.short_name} (${vehicle2.tank_id})\u2026`);
+        const results = await fetchVehicle(tomato2, vehicle2);
+        printErrors(results);
+        console.error(vehicleLine(results, vehicle2));
+        const failed = results.filter((r) => !r.success).length;
+        printSummary(results.length - failed, failed);
+        if (failed > 0) {
+          process.exit(1);
+        }
+        return;
+      }
+      const activeAliases = TYPE_ALIASES.filter((a) => Boolean(options[a]));
+      if (activeAliases.length === 0) {
+        console.error("Specify a <query> or --tier with at least one type flag (--lt, --mt, --ht, --td, --at).");
+        process.exit(1);
+      }
+      const selectedTypes = new Set(activeAliases.map(fromTypeAlias));
+      const tier = options.tier;
+      const vehicles = await app2.getVehicles();
+      const targets = vehicles.filter((v) => v.tier === tier && selectedTypes.has(v.type));
+      if (targets.length === 0) {
+        console.error(`No vehicles match tier ${tier} with the given type filters.`);
+        process.exit(1);
+      }
+      console.error(`Fetching data for ${targets.length} vehicles (tier ${tier})\u2026`);
+      let totalSucceeded = 0;
+      let totalFailed = 0;
+      const total = targets.length;
+      const width = String(total).length;
+      let idx = 0;
+      for (const vehicle2 of targets) {
+        idx++;
+        const results = await fetchVehicle(tomato2, vehicle2);
+        const succeeded = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+        totalSucceeded += succeeded;
+        totalFailed += failed;
+        const progress = `${String(idx).padStart(width)}/${total} `;
+        console.error(vehicleLine(results, vehicle2, `  ${progress}`));
+        printErrors(results);
+      }
+      printSummary(totalSucceeded, totalFailed);
+      if (totalFailed > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/bake/run.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve6 } from "path";
+import { Command as Command20 } from "commander";
+var SCRIPTS = {
+  "clear": "bake-pogs-clear.sh",
+  "color": "bake-pogs-color-dmg-fsr-vr-rld.sh",
+  "simple": "bake-pogs-color-dmg-fsr-vr-rld.sh"
+};
+var scriptsDir = resolve6(findPkgRoot(new URL(import.meta.url)), "scripts");
+function bakeCommand() {
+  const names = Object.keys(SCRIPTS).join(", ");
+  return new Command20("bake").description("Run a bundled build script").argument("<script>", `available: ${names}`).allowUnknownOption(true).allowExcessArguments(true).passThroughOptions(true).action((scriptName, _options, cmd) => {
+    const filename = SCRIPTS[scriptName];
+    if (filename === void 0) {
+      console.error(`Unknown script: ${scriptName}
+Available: ${names}`);
+      process.exit(1);
+    }
+    const scriptPath = resolve6(scriptsDir, filename);
+    if (!existsSync3(scriptPath)) {
+      console.error(`Script not found: ${scriptPath}`);
+      process.exit(1);
+    }
+    const extraArgs = cmd.args.slice(1);
+    try {
+      execFileSync("bash", [scriptPath, ...extraArgs], {
+        stdio: "inherit",
+        env: { ...process.env, PIE_WOT_CWD: process.cwd() }
+      });
+    } catch (err) {
+      process.exit(err.status ?? 1);
+    }
+  });
+}
+
+// src/index.ts
+var _version = "";
+var version = _version || "0.1.12";
+config({ path: resolve7(process.env.PIE_WOT_CWD ?? process.cwd(), ".env") });
+var app = new WGData();
+var atlasManager = new AtlasManager();
+var tomatoApi = new TomatoApi();
+var program = new Command21();
+program.name("pie-wot").description("CLI utilities for World of Tanks data and assets").version(version).enablePositionalOptions();
+var vehicle = new Command21("vehicle").description("WoT vehicle data");
+vehicle.addCommand(listVehiclesCommand(app));
+vehicle.addCommand(exportCommand(app));
+vehicle.addCommand(vehicleStatsCommand(app));
+vehicle.addCommand(bestConfigCommand(app));
+vehicle.addCommand(charsCommand(app));
+vehicle.addCommand(longAliasesCommand(app));
+var atlas = new Command21("atlas").description("Texture atlas tools");
+atlas.addCommand(inspectAtlasCommand(atlasManager));
+atlas.addCommand(pickCommand(atlasManager));
+atlas.addCommand(extractAtlasCommand(atlasManager));
+atlas.addCommand(packAtlasCommand(atlasManager));
+var font = new Command21("font").description("Pixel font tools");
+font.addCommand(renderCommand());
+var cache = new Command21("cache").description("API response cache");
+cache.addCommand(cachePurgeCommand(app));
+var dds = new Command21("dds").description("DDS texture tools");
+dds.addCommand(ddsDecodeCommand());
+dds.addCommand(ddsEncodeCommand());
+program.addCommand(vehicle);
+program.addCommand(atlas);
+program.addCommand(font);
+program.addCommand(cache);
+program.addCommand(dds);
+var icon = new Command21("icon").description("Vehicle icon generation tools");
+icon.addCommand(dumpBackgroundCommand());
+icon.addCommand(iconRenderCommand(app));
+icon.addCommand(iconFetchCommand(app));
+icon.addCommand(iconShrinkCommand(app));
+program.addCommand(icon);
+var tomato = new Command21("tomato").description("Tomato.gg data fetcher");
+tomato.addCommand(tomatoFetchCommand(app, tomatoApi));
+program.addCommand(tomato);
+program.addCommand(bakeCommand());
+await program.parseAsync();