@pietrovich/wot-utils 0.2.2 → 0.2.3

package/dist/index.js

@@ -3,8 +3,8 @@
 // src/index.ts
 import "module";
 import { config } from "dotenv";
-import { resolve as resolve7 } from "path";
-import { Command as Command21 } from "commander";
+import { resolve as resolve6 } from "path";
+import { Command as Command23 } from "commander";
 
 // src/lib/WGData.ts
 import { mkdirSync } from "fs";
@@ -382,10 +382,10 @@ function printVehiclesTable(vehicles) {
 }
 
 // src/commands/vehicle/list.ts
-function listVehiclesCommand(app2) {
+function listVehiclesCommand(app) {
   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 vehicles = await app.getVehicles();
       const items = options.all ? vehicles : vehicles.slice(0, 3);
       if (options.json) {
         printJson(items);
@@ -405,10 +405,10 @@ function listVehiclesCommand(app2) {
 
 // src/commands/vehicle/export.ts
 import { Command as Command2 } from "commander";
-function exportCommand(app2) {
+function exportCommand(app) {
   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 });
+      await app.exportVehicles({ output: options.output, useCache: options.cache });
     } catch (error) {
       if (error instanceof WGApiError) {
         console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
@@ -422,20 +422,20 @@ function exportCommand(app2) {
 
 // src/commands/cache/purge.ts
 import { Command as Command3 } from "commander";
-function cachePurgeCommand(app2) {
+function cachePurgeCommand(app) {
   return new Command3("purge").description("Delete all cached API responses").action(async () => {
-    await app2.purgeCache();
+    await app.purgeCache();
     console.error("Cache purged.");
   });
 }
 
 // src/commands/vehicle/best-config.ts
 import { Command as Command4 } from "commander";
-function bestConfigCommand(app2) {
+function bestConfigCommand(app) {
   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));
+      const result = await app.inferBestConfig(query);
+      console.log(app.configToProfileId(result));
     } catch (error) {
       if (error instanceof WGApiError) {
         console.error(`API error [${error.code}] ${error.field}: ${error.message}`);
@@ -488,11 +488,11 @@ function printTable(rows) {
 function extractProfile(data) {
   return Object.values(data)[0];
 }
-function vehicleStatsCommand(app2) {
+function vehicleStatsCommand(app) {
   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 vehicles = await app.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 = [];
@@ -505,7 +505,7 @@ function vehicleStatsCommand(app2) {
           const results = await Promise.all(
             batch.map(async (v) => {
               try {
-                const data = await app2.getStatsForBestConfig(v.tank_id);
+                const data = await app.getStatsForBestConfig(v.tank_id);
                 const profile = extractProfile(data);
                 return {
                   name: v.short_name,
@@ -532,7 +532,7 @@ function vehicleStatsCommand(app2) {
         }
         return;
       }
-      const result = await app2.getStatsForBestConfig(query);
+      const result = await app.getStatsForBestConfig(query);
       if (options.raw) {
         console.log(JSON.stringify(result, null, 2));
         return;
@@ -551,10 +551,10 @@ function vehicleStatsCommand(app2) {
 
 // src/commands/vehicle/chars.ts
 import { Command as Command6 } from "commander";
-function charsCommand(app2) {
+function charsCommand(app) {
   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();
+      const { uniqueCharacters, maxLength, longestShortName, avgLength, medianLength, p80Length, p90Length } = await app.getShortNameStats();
       console.log("uniqueCharacters:", uniqueCharacters);
       console.log("maxLength:", maxLength);
       console.log("longestShortName:", longestShortName);
@@ -621,10 +621,10 @@ function save() {
 }
 
 // src/commands/vehicle/long-aliases.ts
-function longAliasesCommand(app2) {
+function longAliasesCommand(app) {
   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();
+      const vehicles = await app.getVehicles();
       let dirty = false;
       for (const vehicle2 of vehicles) {
         const alias = lookupShortName(vehicle2);
@@ -1067,9 +1067,11 @@ var AtlasManager = class {
 };
 
 // src/commands/dds/decode.ts
+import { Command as Command13 } from "commander";
+
+// src/lib/utils/dds.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
@@ -1636,22 +1638,26 @@ var DDSUtils = class _DDSUtils {
   }
 };
 
+// src/lib/utils/dds.ts
+async function convertToPngFile(file, pngFileName) {
+  const buffer = await readFile4(file);
+  const frames = new DDSUtils().decode(buffer.buffer);
+  if (frames.length === 0) {
+    throw new Error("No frames decoded from DDS file");
+  }
+  const frame = frames[0];
+  const png = new PNG3({ width: frame.width, height: frame.height });
+  png.data = Buffer.from(frame.image);
+  const outName = pngFileName ?? basename3(file, extname2(file)) + ".png";
+  const outPath = join4(dirname2(file), outName);
+  await writeFile6(outPath, PNG3.sync.write(png));
+  return outPath;
+}
+
 // 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));
+    const outPath = await convertToPngFile(file);
     console.log(`Decoded \u2192 ${outPath}`);
   });
 }
@@ -2224,10 +2230,10 @@ function nameText() {
 // src/lib/icons/pogs/PogsClear.ts
 var iconAligner = createAligner(PogsConstants, "bl.+", [18, 1]);
 var PogsClear = class {
-  createBaker(app2) {
+  createBaker(app) {
     return new ImageBaker(
       PogsConstants,
-      [barAndShield(), vehicleIcon(app2, iconAligner), tierText(), nameText()]
+      [barAndShield(), vehicleIcon(app, iconAligner), tierText(), nameText()]
     );
   }
 };
@@ -2235,13 +2241,13 @@ var PogsClear = class {
 // src/lib/icons/pogs/PogsColor.ts
 var iconAligner2 = createAligner(PogsConstants, "bl.+", [18, 1]);
 var PogsColor = class {
-  createBaker(app2) {
+  createBaker(app) {
     return new ImageBaker(
       PogsConstants,
       [
         gradientBackground(),
         barAndShield(),
-        vehicleIcon(app2, iconAligner2),
+        vehicleIcon(app, iconAligner2),
         tierText(),
         nameText()
       ],
@@ -2290,12 +2296,12 @@ function preRenderedBackground(version2, flavor = "") {
 var iconAligner3 = createAligner(PogsConstants, "bl.+", [18, "(bh - 1).+"]);
 var PogsClearV1 = class {
   version = 1;
-  createBaker(app2) {
+  createBaker(app) {
     return new ImageBaker(
       PogsConstants,
       [
         preRenderedBackground(this.version, "clear"),
-        vehicleIcon(app2, iconAligner3),
+        vehicleIcon(app, iconAligner3),
         tierText(),
         nameText()
       ]
@@ -2310,9 +2316,9 @@ var PogsClearV2 = class extends PogsClearV1 {
 
 // src/lib/icons/layers/text-view-range.ts
 var defaultAligner3 = createAligner(PogsConstants, "br.+", [37, "bh - 1"]);
-function textViewRange(app2, aligner = defaultAligner3) {
+function textViewRange(app, aligner = defaultAligner3) {
   return async (_box, _prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const viewRange = profiles[vehicle2.tank_id]?.turret?.view_range;
     if (viewRange === void 0) {
       return null;
@@ -2331,9 +2337,9 @@ function textViewRange(app2, aligner = defaultAligner3) {
 
 // src/lib/icons/layers/text-reload.ts
 var defaultAligner4 = createAligner(PogsConstants, "br.+", [37, "bh - 8"]);
-function textReload(app2, aligner = defaultAligner4) {
+function textReload(app, aligner = defaultAligner4) {
   return async (_box, _prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const reloadTime = profiles[vehicle2.tank_id]?.gun?.reload_time;
     if (reloadTime === void 0) {
       return null;
@@ -2352,9 +2358,9 @@ function textReload(app2, aligner = defaultAligner4) {
 
 // src/lib/icons/layers/text-hull-armor.ts
 var defaultAligner5 = createAligner(PogsConstants, "br", ["r", "b - 1"]);
-function textHullArmor(app2, aligner = defaultAligner5) {
+function textHullArmor(app, aligner = defaultAligner5) {
   return async (_box, _prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const hull = profiles[vehicle2.tank_id]?.armor?.hull;
     if (hull === void 0) {
       return null;
@@ -2374,9 +2380,9 @@ function textHullArmor(app2, aligner = defaultAligner5) {
 
 // src/lib/icons/layers/text-turret-armor.ts
 var defaultAligner6 = createAligner(PogsConstants, "br", ["r", "b - 8"]);
-function textTurretArmor(app2, aligner = defaultAligner6) {
+function textTurretArmor(app, aligner = defaultAligner6) {
   return async (_box, prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const turret = profiles[vehicle2.tank_id]?.armor?.turret;
     if (!turret) {
       return null;
@@ -2398,9 +2404,9 @@ function textTurretArmor(app2, aligner = defaultAligner6) {
 
 // src/lib/icons/layers/text-penetration.ts
 var defaultAligner7 = createAligner(PogsConstants, "rt", ["r", 2]);
-function textPenetration(app2, aligner = defaultAligner7) {
+function textPenetration(app, aligner = defaultAligner7) {
   return async (_box, _prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const text = profiles[vehicle2.tank_id]?.ammo?.[0].penetration?.[1];
     if (text === void 0) {
       return null;
@@ -2419,9 +2425,9 @@ function textPenetration(app2, aligner = defaultAligner7) {
 
 // src/lib/icons/layers/text-damage.ts
 var defaultAligner8 = createAligner(PogsConstants, "rt", ["r", 9]);
-function textDamage(app2, aligner = defaultAligner8) {
+function textDamage(app, aligner = defaultAligner8) {
   return async (_box, _prev, vehicle2) => {
-    const profiles = await app2.getStatsForBestConfig(vehicle2);
+    const profiles = await app.getStatsForBestConfig(vehicle2);
     const text = profiles[vehicle2.tank_id]?.ammo?.[0].damage?.[1];
     if (text === void 0) {
       return null;
@@ -2473,7 +2479,7 @@ async function renderOneToFile(vehicle2, baker, outDir) {
   const info = await (await baker.bake(vehicle2)).png().toFile(outPath);
   console.log(`${outPath} \u2014 ${info.width}\xD7${info.height}px`);
 }
-function iconRenderCommand(app2) {
+function iconRenderCommand(app) {
   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) {
@@ -2502,8 +2508,8 @@ Provide an existing path or add --create to create it.`);
       } 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));
+      const vehicles = options.all ? await app.getVehicles() : [await app.findVehicle(query)];
+      const bakers = Array.from({ length: CONCURRENCY }, () => builder.createBaker(app));
       let idx = 0;
       await Promise.all(
         bakers.map(async (baker) => {
@@ -2543,14 +2549,14 @@ function parseSize(input) {
       throw new Error(`Invalid size "${input}". Use xs, s/small, m/medium, or l/large.`);
   }
 }
-function iconFetchCommand(app2) {
+function iconFetchCommand(app) {
   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({
+      await app.fetchIcons({
         query,
         size: parseSize(options.size),
         force: options.force,
@@ -2569,14 +2575,14 @@ function iconFetchCommand(app2) {
 
 // src/commands/icon/shrink.ts
 import { Command as Command18 } from "commander";
-function iconShrinkCommand(app2) {
+function iconShrinkCommand(app) {
   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({
+      await app.fetchIcons({
         query,
         size: "xs",
         force: options.force ?? false,
@@ -2624,8 +2630,8 @@ var TomatoApi = class {
     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));
+    return new Promise((resolve7) => {
+      this.queue.push(() => this.runVehicleVisuals(vehicleId, filename, resolve7));
       void this.drain();
     });
   }
@@ -2635,8 +2641,8 @@ var TomatoApi = class {
     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));
+    return new Promise((resolve7) => {
+      this.queue.push(() => this.runVehicleLoadouts(vehicleId, filename, resolve7));
       void this.drain();
     });
   }
@@ -2646,47 +2652,47 @@ var TomatoApi = class {
     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));
+    return new Promise((resolve7) => {
+      this.queue.push(() => this.runVehicleProLoadouts(vehicleId, filename, resolve7));
       void this.drain();
     });
   }
-  async runVehicleVisuals(vehicleId, filename, resolve8) {
+  async runVehicleVisuals(vehicleId, filename, resolve7) {
     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 });
+      resolve7({ 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)) });
+      resolve7({ 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) {
+  async runVehicleLoadouts(vehicleId, filename, resolve7) {
     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 });
+      resolve7({ 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)) });
+      resolve7({ 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) {
+  async runVehicleProLoadouts(vehicleId, filename, resolve7) {
     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 });
+      resolve7({ 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)) });
+      resolve7({ vehicleId, fileName: filename, success: false, elapsed: Date.now() - t0, data: void 0, error: err instanceof Error ? err : new Error(String(err)) });
       throw err;
     }
   }
@@ -2818,11 +2824,11 @@ function printSummary(succeeded, failed) {
   const summary = failed === 0 ? `${total} requests, ${succeeded} succeeded` : `${total} requests, ${succeeded} succeeded, ${failed} failed`;
   console.log(summary);
 }
-function tomatoFetchCommand(app2, tomato2) {
+function tomatoFetchCommand(app, 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);
+        const vehicle2 = await app.findVehicle(query);
         console.error(`Fetching data for ${vehicle2.short_name} (${vehicle2.tank_id})\u2026`);
         const results = await fetchVehicle(tomato2, vehicle2);
         printErrors(results);
@@ -2841,7 +2847,7 @@ function tomatoFetchCommand(app2, tomato2) {
       }
       const selectedTypes = new Set(activeAliases.map(fromTypeAlias));
       const tier = options.tier;
-      const vehicles = await app2.getVehicles();
+      const vehicles = await app.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.`);
@@ -2876,68 +2882,378 @@ function tomatoFetchCommand(app2, tomato2) {
 }
 
 // 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);
+import { Command as Command21 } from "commander";
+
+// src/commands/bake/all.ts
+import { join as join12 } from "path";
+
+// src/lib/pipeline/pogs.ts
+import { access as access3, copyFile, mkdir as mkdir5, readdir as readdir3, rename, rm as rm2, unlink, writeFile as writeFile10 } from "fs/promises";
+import { join as join10 } from "path";
+
+// src/lib/utils/game-resources.ts
+import { access as access2, mkdir as mkdir4, readdir as readdir2, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import { basename as basename5, join as join9 } from "path";
+import { unzip } from "fflate";
+var GUI_PKG_RE = /gui-part\d+\.pkg$/;
+var ICON_ATLAS_FILES = /* @__PURE__ */ new Set([
+  "gui/flash/atlases/battleAtlas.dds",
+  "gui/flash/atlases/battleAtlas.xml",
+  "gui/flash/atlases/vehicleMarkerAtlas.dds",
+  "gui/flash/atlases/vehicleMarkerAtlas.xml"
+]);
+async function extractIconAtlases(srcDir, outDir, onProgress) {
+  await mkdir4(outDir, { recursive: true });
+  const expectedFiles = [...ICON_ATLAS_FILES].map((f) => join9(outDir, basename5(f)));
+  const allPresent = await Promise.all(expectedFiles.map((f) => access2(f).then(() => true, () => false)));
+  if (allPresent.every(Boolean)) {
+    return { pkgsFound: 0, filesExtracted: 0, skipped: true };
+  }
+  const entries = await readdir2(srcDir, { recursive: true });
+  const pkgFiles = entries.filter((e) => GUI_PKG_RE.test(e)).map((e) => join9(srcDir, e));
+  if (pkgFiles.length === 0) {
+    throw new Error(`No gui-partN.pkg files found in: ${srcDir}`);
+  }
+  let filesExtracted = 0;
+  for (const pkgFile of pkgFiles) {
+    onProgress?.(`Checking: ${pkgFile}`);
+    let data;
     try {
-      execFileSync("bash", [scriptPath, ...extraArgs], {
-        stdio: "inherit",
-        env: { ...process.env, PIE_WOT_CWD: process.cwd() }
+      data = await readFile8(pkgFile);
+    } catch {
+      onProgress?.(`  Warning: failed to read package file, skipping.`);
+      continue;
+    }
+    const extracted = await new Promise((resolve7, reject) => {
+      unzip(data, { filter: (file) => ICON_ATLAS_FILES.has(file.name) }, (err, files) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve7(files);
+        }
       });
-    } catch (err) {
-      process.exit(err.status ?? 1);
+    });
+    const names = Object.keys(extracted);
+    if (names.length === 0) {
+      onProgress?.(`  No target files.`);
+      continue;
+    }
+    onProgress?.(`  Extracting ${names.length} file(s): ${names.join(" ")}`);
+    await Promise.all(
+      names.map((name) => writeFile9(join9(outDir, basename5(name)), extracted[name]))
+    );
+    filesExtracted += names.length;
+  }
+  return { pkgsFound: pkgFiles.length, filesExtracted, skipped: false };
+}
+
+// src/lib/pipeline/pogs.ts
+var ATLAS_NAMES = ["battleAtlas", "vehicleMarkerAtlas"];
+var RENDER_CONCURRENCY = 5;
+var STATS_BATCH_SIZE = 5;
+var REQUIRED_SRC_FILES = ATLAS_NAMES.flatMap((name) => [`${name}.dds`, `${name}.xml`]);
+async function ensureAtlasAssets(srcDir, gameDir) {
+  const present = await Promise.all(REQUIRED_SRC_FILES.map((f) => pathExists(join10(srcDir, f))));
+  if (present.every(Boolean)) {
+    return;
+  }
+  const missing = REQUIRED_SRC_FILES.filter((_, i) => !present[i]);
+  if (!gameDir) {
+    throw new Error(
+      `Missing atlas files in ${srcDir}: ${missing.join(", ")}
+Run with --game-dir <wot-dir> to extract them automatically.`
+    );
+  }
+  console.log("Some source atlas files are missing \u2014 extracting from game directory...");
+  await extractIconAtlases(gameDir, srcDir, (msg) => console.log(msg));
+}
+async function pathExists(p) {
+  return access3(p).then(() => true, () => false);
+}
+async function copyPngs(fromDir, toDir) {
+  const entries = await readdir3(fromDir);
+  await Promise.all(
+    entries.filter((e) => e.endsWith(".png")).map((e) => copyFile(join10(fromDir, e), join10(toDir, e)))
+  );
+}
+async function cleanBuild(outDir) {
+  await rm2(join10(outDir, ".build"), { recursive: true, force: true });
+  await rm2(join10(outDir, "res_mods"), { recursive: true, force: true });
+  const entries = await readdir3(outDir).catch(() => []);
+  await Promise.all(
+    entries.filter((e) => /\.(png|xml|dds)$/.test(e)).map((e) => unlink(join10(outDir, e)))
+  );
+}
+async function decodeDds(srcDir) {
+  for (const name of ATLAS_NAMES) {
+    const ddsPath = join10(srcDir, `${name}.dds`);
+    const pngPath = join10(srcDir, `${name}.png`);
+    if (await pathExists(ddsPath) && !await pathExists(pngPath)) {
+      const out = await convertToPngFile(ddsPath);
+      console.log(`Decoded \u2192 ${out}`);
+    }
+  }
+}
+async function extractAtlases(srcDir, buildDir, atlasManager2) {
+  const atlasesDir = join10(buildDir, "atlases");
+  await mkdir5(atlasesDir, { recursive: true });
+  for (const name of ATLAS_NAMES) {
+    const destDir = join10(atlasesDir, name);
+    if (await pathExists(destDir)) {
+      console.log(`skipping ${name} extraction \u2014 ${destDir} already exists`);
+      continue;
+    }
+    const xmlPath = join10(srcDir, `${name}.xml`);
+    const pngPath = join10(srcDir, `${name}.png`);
+    const count = await atlasManager2.extractAll(xmlPath, pngPath, destDir);
+    console.log(`Extracted ${count} textures \u2192 ${destDir}`);
+    await Promise.all([
+      copyFile(pngPath, join10(atlasesDir, `${name}.png`)),
+      copyFile(xmlPath, join10(atlasesDir, `${name}.xml`))
+    ]);
+  }
+}
+async function warmCache(app) {
+  console.log("warm up vehicle data cache");
+  const vehicles = await app.getVehicles();
+  console.log(`  ${vehicles.length} vehicles`);
+  console.log("warm up vehicle profile cache");
+  let profilesCount = 0;
+  for (let i = 0; i < vehicles.length; i += STATS_BATCH_SIZE) {
+    const batch = vehicles.slice(i, i + STATS_BATCH_SIZE);
+    await Promise.all(
+      batch.map(async (v) => {
+        try {
+          await app.getStatsForBestConfig(v.tank_id);
+          profilesCount++;
+        } catch {
+        }
+      })
+    );
+  }
+  console.log(`  ${profilesCount} profiles`);
+  return { vehiclesCount: vehicles.length, profilesCount };
+}
+async function renderOneToFile2(vehicle2, baker, outDir) {
+  const outPath = join10(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`);
+}
+async function renderIcons(app, builder, buildDir, vehiclesCount) {
+  const iconsDir = join10(buildDir, "icons");
+  const existing = await readdir3(iconsDir).catch(() => []);
+  const pngCount = existing.filter((e) => e.endsWith(".png")).length;
+  if (pngCount >= vehiclesCount) {
+    console.log(`skipping icons render \u2014 ${iconsDir} already has ${pngCount} icons`);
+    return;
+  }
+  console.log("generating icons");
+  await mkdir5(iconsDir, { recursive: true });
+  const vehicles = await app.getVehicles();
+  const bakers = Array.from({ length: RENDER_CONCURRENCY }, () => builder.createBaker(app));
+  let idx = 0;
+  await Promise.all(
+    bakers.map(async (baker) => {
+      while (idx < vehicles.length) {
+        const vehicle2 = vehicles[idx++];
+        await renderOneToFile2(vehicle2, baker, iconsDir);
+      }
+    })
+  );
+}
+async function overlayIcons(buildDir) {
+  console.log("overlaying generated icons into atlas directories");
+  const iconsDir = join10(buildDir, "icons");
+  for (const name of ATLAS_NAMES) {
+    await copyPngs(iconsDir, join10(buildDir, "atlases", name));
+  }
+}
+var SUFFIX_RE = /_(7x7|bob|IGR)\.png$/;
+var SUFFIX_EXCLUDED = /* @__PURE__ */ new Set(["battleLoadingFormBgTips.png", "battleLoadingFormBgTips_7x7.png"]);
+async function replaceSuffixed(buildDir) {
+  console.log("replacing suffixed variants in atlas with base icons");
+  const iconsDir = join10(buildDir, "icons");
+  for (const name of ATLAS_NAMES) {
+    const atlasDir = join10(buildDir, "atlases", name);
+    const entries = await readdir3(atlasDir);
+    for (const filename of entries) {
+      if (!SUFFIX_RE.test(filename) || SUFFIX_EXCLUDED.has(filename)) {
+        continue;
+      }
+      const base = filename.replace(SUFFIX_RE, ".png");
+      if (SUFFIX_EXCLUDED.has(base)) {
+        continue;
+      }
+      const basePath = join10(atlasDir, base);
+      if (!await pathExists(basePath)) {
+        continue;
+      }
+      await copyFile(basePath, join10(atlasDir, filename));
+      await copyFile(basePath, join10(iconsDir, filename));
+    }
+  }
+}
+async function packAtlases(outDir, buildDir, atlasManager2) {
+  const atlasesOutDir = join10(outDir, "res_mods", "version", "gui", "flash", "atlases");
+  await mkdir5(atlasesOutDir, { recursive: true });
+  for (const name of ATLAS_NAMES) {
+    const result = await atlasManager2.pack(join10(buildDir, "atlases", name));
+    if (result.bins > 1) {
+      console.warn(`Warning: ${name} textures span ${result.bins} bins \u2014 only the first will be written`);
+    }
+    const pngPath = join10(atlasesOutDir, `${name}.png`);
+    await writeFile10(pngPath, result.pngBuffer);
+    await writeFile10(join10(atlasesOutDir, `${name}.xml`), result.xml);
+    await rename(pngPath, join10(atlasesOutDir, `${name}.dds`));
+    console.log(`Packed ${result.count} textures \u2192 ${name}.dds (${result.width}\xD7${result.height})`);
+  }
+}
+async function copyContour(outDir, buildDir) {
+  const contourDir = join10(outDir, "res_mods", "version", "gui", "flash", "maps", "icons", "vehicle", "contour");
+  await mkdir5(contourDir, { recursive: true });
+  await copyPngs(join10(buildDir, "icons"), contourDir);
+}
+async function pogsPipeline(app, atlasManager2, builder, options) {
+  const { srcDir, outDir, buildDir, clean, cleanAtlasDir, gameDir, prune } = options;
+  if (clean) {
+    await cleanBuild(outDir);
+    if (cleanAtlasDir) {
+      await rm2(srcDir, { recursive: true, force: true });
+    }
+  }
+  await ensureAtlasAssets(srcDir, gameDir);
+  await decodeDds(srcDir);
+  await extractAtlases(srcDir, buildDir, atlasManager2);
+  const { vehiclesCount } = await warmCache(app);
+  await renderIcons(app, builder, buildDir, vehiclesCount);
+  await overlayIcons(buildDir);
+  await replaceSuffixed(buildDir);
+  await packAtlases(outDir, buildDir, atlasManager2);
+  await copyContour(outDir, buildDir);
+  if (prune) {
+    await rm2(buildDir, { recursive: true, force: true });
+  }
+}
+
+// src/commands/bake/bake-command.ts
+import { join as join11 } from "path";
+import { Command as Command20 } from "commander";
+function resolveBakeOptions(options) {
+  const srcDir = options.atlasDir ?? join11(options.out, ".atlases");
+  const clean = options.clean ?? options.fresh;
+  const prune = options.prune ?? options.tidy;
+  return {
+    srcDir,
+    outDir: options.out,
+    buildDir: join11(options.out, ".build"),
+    gameDir: options.gameDir,
+    cleanAtlasDir: !options.atlasDir,
+    clean,
+    prune
+  };
+}
+function bakeSubcommand(name, description) {
+  return new Command20(name).description(description).requiredOption("--out <dir>", "output directory for the final mod files").option("--atlas-dir <dir>", "directory with extracted atlas DDS/PNG/XML files (default: <out>/.atlases)").option("--game-dir <dir>", "WoT game directory \u2014 used to extract missing atlas files automatically").option("--clean", "wipe build artefacts before starting").option("--fresh", "alias for --clean").option("--prune", "remove intermediate build directory after completion").option("--tidy", "alias for --prune");
+}
+
+// src/commands/bake/all.ts
+function bakeAllCommand(app, atlasManager2) {
+  return bakeSubcommand("all", "Bake all icon sets (clear + color)").action(async (options) => {
+    const resolved = resolveBakeOptions(options);
+    await pogsPipeline(app, atlasManager2, new PogsClearV2(), {
+      ...resolved,
+      outDir: join12(options.out, "clear"),
+      buildDir: join12(options.out, "clear", ".build")
+    });
+    await pogsPipeline(app, atlasManager2, new PogsColorV1(), {
+      ...resolved,
+      outDir: join12(options.out, "color"),
+      buildDir: join12(options.out, "color", ".build"),
+      clean: false,
+      cleanAtlasDir: false
+    });
+  });
+}
+
+// src/commands/bake/clear.ts
+function bakeClearCommand(app, atlasManager2) {
+  return bakeSubcommand("clear", "Bake PogS clear icon set (no colour background)").action(async (options) => {
+    await pogsPipeline(app, atlasManager2, new PogsClearV2(), resolveBakeOptions(options));
+  });
+}
+
+// src/commands/bake/color.ts
+function bakeColorCommand(app, atlasManager2) {
+  return bakeSubcommand("color", "Bake PogS colour icon set (DMG/FSR/VR/RLD labels, pre-rendered background v1)").action(async (options) => {
+    await pogsPipeline(app, atlasManager2, new PogsColorV1(), resolveBakeOptions(options));
+  });
+}
+
+// src/commands/bake/run.ts
+function bakeCommand(app, atlasManager2) {
+  const bake = new Command21("bake").description("Bake PogS icon sets");
+  bake.addCommand(bakeAllCommand(app, atlasManager2));
+  bake.addCommand(bakeClearCommand(app, atlasManager2));
+  bake.addCommand(bakeColorCommand(app, atlasManager2));
+  return bake;
+}
+
+// src/commands/game/extract-icon-assets.ts
+import { join as join13 } from "path";
+import { Command as Command22 } from "commander";
+function extractIconAssetsCommand() {
+  return new Command22("extract-icon-assets").alias("extract-icons").description(
+    "Extract battle and vehicle marker atlas files from a WoT installation directory"
+  ).argument("<src-dir>", "WoT game directory (searched recursively for gui-partN.pkg files)").argument("<out-dir>", "destination directory for extracted files (created if absent)").action(async (srcDir, outDir) => {
+    const { pkgsFound, filesExtracted, skipped } = await extractIconAtlases(
+      srcDir,
+      outDir,
+      (msg) => console.log(msg)
+    );
+    if (skipped) {
+      console.log(`All atlas files already present in ${outDir}, nothing to do.`);
+    } else {
+      console.log(`Done. Scanned ${pkgsFound} package(s), extracted ${filesExtracted} file(s) \u2192 ${outDir}`);
+    }
+    const ddsFiles = ["battleAtlas.dds", "vehicleMarkerAtlas.dds"];
+    for (const ddsFile of ddsFiles) {
+      const ddsPath = join13(outDir, ddsFile);
+      try {
+        const pngPath = await convertToPngFile(ddsPath);
+        console.log(`Converted \u2192 ${pngPath}`);
+      } catch (err) {
+        console.error(`Warning: failed to convert ${ddsFile}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
   });
 }
 
 // src/index.ts
 var _version = "";
-var version = _version || "0.2.1";
-config({ path: resolve7(process.env.PIE_WOT_CWD ?? process.cwd(), ".env") });
-var app = new WGData();
+var version = _version || "0.2.2";
+config({ path: resolve6(process.env.PIE_WOT_CWD ?? process.cwd(), ".env") });
+var wgData = new WGData();
 var atlasManager = new AtlasManager();
 var tomatoApi = new TomatoApi();
-var program = new Command21();
+var program = new Command23();
 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");
+var vehicle = new Command23("vehicle").description("WoT vehicle data");
+vehicle.addCommand(listVehiclesCommand(wgData));
+vehicle.addCommand(exportCommand(wgData));
+vehicle.addCommand(vehicleStatsCommand(wgData));
+vehicle.addCommand(bestConfigCommand(wgData));
+vehicle.addCommand(charsCommand(wgData));
+vehicle.addCommand(longAliasesCommand(wgData));
+var atlas = new Command23("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");
+var font = new Command23("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");
+var cache = new Command23("cache").description("API response cache");
+cache.addCommand(cachePurgeCommand(wgData));
+var dds = new Command23("dds").description("DDS texture tools");
 dds.addCommand(ddsDecodeCommand());
 dds.addCommand(ddsEncodeCommand());
 program.addCommand(vehicle);
@@ -2945,14 +3261,17 @@ program.addCommand(atlas);
 program.addCommand(font);
 program.addCommand(cache);
 program.addCommand(dds);
-var icon = new Command21("icon").description("Vehicle icon generation tools");
+var icon = new Command23("icon").description("Vehicle icon generation tools");
 icon.addCommand(dumpBackgroundCommand());
-icon.addCommand(iconRenderCommand(app));
-icon.addCommand(iconFetchCommand(app));
-icon.addCommand(iconShrinkCommand(app));
+icon.addCommand(iconRenderCommand(wgData));
+icon.addCommand(iconFetchCommand(wgData));
+icon.addCommand(iconShrinkCommand(wgData));
 program.addCommand(icon);
-var tomato = new Command21("tomato").description("Tomato.gg data fetcher");
-tomato.addCommand(tomatoFetchCommand(app, tomatoApi));
+var tomato = new Command23("tomato").description("Tomato.gg data fetcher");
+tomato.addCommand(tomatoFetchCommand(wgData, tomatoApi));
 program.addCommand(tomato);
-program.addCommand(bakeCommand());
+program.addCommand(bakeCommand(wgData, atlasManager));
+var game = new Command23("game").description("WoT game installation tools");
+game.addCommand(extractIconAssetsCommand());
+program.addCommand(game);
 await program.parseAsync();