@lycoristech/azurdata 0.0.1

package/dist/cjs/normalize/skills.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkills = normalizeSkills;
+const enums_js_1 = require("../translate/enums.js");
+const strings_js_1 = require("../translate/strings.js");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Strip trailing Roman numeral suffix (Ⅰ–Ⅴ or ASCII I/II/III/IV/V) from a skill
+ * name, returning just the "root" portion for comparison purposes.
+ *
+ * Examples:
+ *   "All Out Assault Ⅰ"    → "All Out Assault"
+ *   "All Out Assault Ⅱ"    → "All Out Assault"
+ *   "Smokescreen: Light Cruisers" → "Smokescreen: Light Cruisers"
+ *   "Burn Order"            → "Burn Order"
+ */
+function rootSkillName(name) {
+    // Trim Unicode Roman numerals (Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ) and ASCII (I–X variants)
+    // at end of string, optionally preceded by a colon/period and more text.
+    return name
+        .replace(/\s+[ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩiIvVxX]+(?:[:.][^\s]*)*\s*$/, "")
+        .trim();
+}
+/**
+ * Normalize a `skill_id` value (number | number[] | undefined) to a number[].
+ */
+function normalizeSkillIdList(raw) {
+    if (raw === undefined)
+        return [];
+    if (Array.isArray(raw))
+        return raw;
+    return [raw];
+}
+/**
+ * Build the description string for a skill.
+ */
+function buildDescription(skillTemplate, idStr) {
+    const row = skillTemplate[idStr];
+    if (row === undefined)
+        return "";
+    const rawDesc = row.desc;
+    if (rawDesc === undefined || rawDesc === "")
+        return "";
+    const substitutions = (0, strings_js_1.extractMaxLevelSubstitutions)(row.desc_add, row.max_level ?? 10);
+    return (0, strings_js_1.substitutePlaceholders)(rawDesc, substitutions);
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function normalizeSkills(inputs) {
+    const { rowIds, en, groupType } = inputs;
+    const { template, breakout, skillDataTemplate, skillDataDisplay, trans, transformDataTemplate, } = en;
+    // -------------------------------------------------------------------------
+    // 1. Resolve the LB3 row ID (the row whose key ends with "4", or last entry).
+    // -------------------------------------------------------------------------
+    const lb3RowId = rowIds.find((id) => id.endsWith("4")) ?? rowIds[rowIds.length - 1] ?? groupType;
+    // -------------------------------------------------------------------------
+    // 2. Get the base skill ID list from the LB3 row.
+    // -------------------------------------------------------------------------
+    const lb3Template = template[lb3RowId];
+    const baseSkillIds = lb3Template?.buff_list_display ?? [];
+    // -------------------------------------------------------------------------
+    // 3. Apply retrofit skill upgrades (if any).
+    //
+    // TODO: The retrofit skill-upgrade/replace logic is a best-effort
+    // approximation.  AzurAPI's historical output was inconsistent here; some
+    // versions replaced the base skill, others appended.  The implementation
+    // below attempts a root-name match and replaces when found, otherwise
+    // appends.  If this causes issues, simplify to just using `baseSkillIds`
+    // directly.
+    // -------------------------------------------------------------------------
+    let finalSkillIds = [...baseSkillIds];
+    if (trans !== undefined && transformDataTemplate !== undefined) {
+        const transRow = trans[groupType];
+        if (transRow !== undefined) {
+            // Collect all retrofit skill IDs: from trans.skill_id + each transform node's skill_id
+            const retrofitSkillIds = new Set();
+            // From the top-level trans row
+            const topSkillIds = normalizeSkillIdList(transRow.skill_id);
+            for (const sid of topSkillIds) {
+                if (sid !== 0)
+                    retrofitSkillIds.add(sid);
+            }
+            // From each transform_data_template node referenced in transform_list
+            const seenTransformIds = new Set();
+            for (const outerList of transRow.transform_list) {
+                for (const pair of outerList) {
+                    const transformId = pair[1];
+                    if (transformId === undefined || seenTransformIds.has(transformId))
+                        continue;
+                    seenTransformIds.add(transformId);
+                    const tRow = transformDataTemplate[String(transformId)];
+                    if (tRow === undefined)
+                        continue;
+                    const tSkillIds = normalizeSkillIdList(tRow.skill_id);
+                    for (const sid of tSkillIds) {
+                        if (sid !== 0)
+                            retrofitSkillIds.add(sid);
+                    }
+                }
+            }
+            // Merge retrofit skills: replace base skill if root names match, else append
+            for (const retrofitId of retrofitSkillIds) {
+                const retrofitRow = skillDataTemplate[String(retrofitId)];
+                if (retrofitRow === undefined)
+                    continue;
+                const retrofitName = retrofitRow.name;
+                if (retrofitName === undefined)
+                    continue;
+                const retrofitRoot = rootSkillName(retrofitName);
+                // Try to find a base skill with the same root name
+                let replaced = false;
+                for (let i = 0; i < finalSkillIds.length; i++) {
+                    const baseId = finalSkillIds[i];
+                    if (baseId === undefined)
+                        continue;
+                    const baseRow = skillDataTemplate[String(baseId)];
+                    if (baseRow === undefined)
+                        continue;
+                    const baseName = baseRow.name;
+                    if (baseName === undefined)
+                        continue;
+                    const baseRoot = rootSkillName(baseName);
+                    if (baseRoot === retrofitRoot && baseRoot.length > 0) {
+                        finalSkillIds[i] = retrofitId;
+                        replaced = true;
+                        break;
+                    }
+                }
+                if (!replaced) {
+                    // No matching base skill — append if not already present
+                    if (!finalSkillIds.includes(retrofitId)) {
+                        finalSkillIds.push(retrofitId);
+                    }
+                }
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // 4. Build skill objects.
+    // -------------------------------------------------------------------------
+    const skills = [];
+    for (const skillId of finalSkillIds) {
+        const idStr = String(skillId);
+        const skillRow = skillDataTemplate[idStr];
+        const displayRow = skillDataDisplay[idStr];
+        // Resolve name: prefer skill_data_template, fallback to skill_data_display
+        let nameEn = skillRow?.name ?? displayRow?.name;
+        if (nameEn === undefined || nameEn.trim() === "") {
+            // No name at all — skip this skill
+            console.warn(`normalizeSkills: skill ID ${skillId} has no name in skill_data_template or skill_data_display — skipping (group_type ${groupType})`);
+            continue;
+        }
+        nameEn = nameEn.trim();
+        const type = skillRow?.type ?? 0;
+        const color = (0, enums_js_1.skillColor)(type);
+        const description = buildDescription(skillDataTemplate, idStr);
+        skills.push({
+            color,
+            names: { en: nameEn },
+            description,
+        });
+    }
+    // -------------------------------------------------------------------------
+    // 5. Build limit breaks.
+    //
+    // rowIds[0..2] correspond to LB1/LB2/LB3 source rows.
+    // The terminal row (index 3, ending in "4") has breakout_view: "None" → skip.
+    // -------------------------------------------------------------------------
+    // We want the first THREE non-terminal rows: rowIds[0], [1], [2]
+    const limitBreaks = [];
+    for (let i = 0; i < 3; i++) {
+        const rowId = rowIds[i];
+        if (rowId === undefined) {
+            // Fewer than 3 rows — some ships (e.g. META 4-star ships) may have fewer LB stages
+            continue;
+        }
+        const breakoutRow = breakout[rowId];
+        if (breakoutRow === undefined) {
+            // Row missing from breakout table — skip
+            continue;
+        }
+        const bonuses = (0, strings_js_1.splitLimitBreakBonuses)(breakoutRow.breakout_view);
+        limitBreaks.push(bonuses);
+    }
+    // If all three limit-break arrays are empty/absent, omit the field
+    const hasLimitBreaks = limitBreaks.length > 0 && limitBreaks.some((lb) => lb.length > 0);
+    return {
+        skills,
+        limitBreaks: hasLimitBreaks ? limitBreaks : undefined,
+    };
+}

package/dist/cjs/normalize/skins.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkins = normalizeSkins;
+const config_js_1 = require("../config.js");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const DEFAULT_BASE_URL = config_js_1.PAINTINGS_URL;
+/**
+ * Returns true if l2d_animations is non-empty
+ * (Array with length > 0, or object with at least one key).
+ */
+function hasLive2d(l2dAnimations) {
+    if (l2dAnimations === undefined || l2dAnimations === null)
+        return false;
+    if (Array.isArray(l2dAnimations))
+        return l2dAnimations.length > 0;
+    if (typeof l2dAnimations === "object") {
+        return Object.keys(l2dAnimations).length > 0;
+    }
+    return false;
+}
+/**
+ * Returns true if the shop entry's `time` value represents "always"
+ * (i.e. the string "always").
+ */
+function isAlwaysAvailable(time) {
+    return time === "always";
+}
+/**
+ * Build the variant images map for a skin painting.
+ *
+ * Variant mapping:
+ *   {name}.webp        → "default" (base file — the EN version, may be censored)
+ *   {name}_rw.webp     → "censored_nobg" (EN character layer without background)
+ *   {name}_n.webp      → "uncensored" (JP/original version)
+ *   {name}_n_rw.webp   → "uncensored_nobg" (JP character without background)
+ *   {name}_bj.webp     → "background" (background layer only)
+ *
+ * "censored" is an alias for "default" since the base file IS the EN version.
+ */
+function buildVariantImages(painting, baseUrl, available) {
+    const lower = painting.toLowerCase();
+    const has = (suffix) => {
+        const key = suffix === "" ? lower : `${lower}${suffix}`;
+        return available ? available.has(key) : true;
+    };
+    const url = (suffix) => `${baseUrl}/${painting}${suffix}.webp`;
+    const images = {};
+    if (has(""))
+        images.default = url("");
+    if (has(""))
+        images.censored = url(""); // alias for default
+    if (has("_rw"))
+        images.censored_nobg = url("_rw");
+    if (has("_n"))
+        images.uncensored = url("_n");
+    if (has("_n_rw"))
+        images.uncensored_nobg = url("_n_rw");
+    if (has("_bj"))
+        images.background = url("_bj");
+    return Object.keys(images).length > 0 ? images : undefined;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function normalizeSkins(inputs) {
+    const { groupType, skinTemplate, shopTemplate, thumbnailBaseUrl, availablePaintings } = inputs;
+    const base = thumbnailBaseUrl ?? DEFAULT_BASE_URL;
+    const groupTypeNum = Number(groupType);
+    // Filter skin rows belonging to this ship group, then sort by skin ID ascending
+    const skinEntries = Object.entries(skinTemplate)
+        .filter(([, row]) => row !== undefined && row.ship_group === groupTypeNum)
+        .sort(([a], [b]) => {
+        const diff = Number(a) - Number(b);
+        return diff;
+    });
+    if (skinEntries.length === 0) {
+        return { skins: [] };
+    }
+    const skins = [];
+    for (const [skinId, row] of skinEntries) {
+        if (row === undefined)
+            continue;
+        // name: row.name if non-empty, else row.desc if non-empty, else "(unnamed)"
+        const name = row.name.trim().length > 0
+            ? row.name.trim()
+            : (row.desc?.trim().length ?? 0) > 0
+                ? (row.desc?.trim() ?? "(unnamed)")
+                : "(unnamed)";
+        // image URL
+        const image = `${base}/${row.painting}.webp`;
+        // shop info
+        const shopId = row.shop_id;
+        let cost;
+        let isAlways = false;
+        let hasValidShop = false;
+        if (shopId !== undefined && shopId !== 0) {
+            const shopEntry = shopTemplate[String(shopId)];
+            if (shopEntry !== undefined) {
+                const isShopGenre = shopEntry.genre === "skin_shop" || shopEntry.effect_args !== undefined;
+                const resourceNum = shopEntry.resource_num;
+                if (isShopGenre && resourceNum !== undefined && resourceNum > 0) {
+                    cost = resourceNum;
+                }
+                isAlways = isAlwaysAvailable(shopEntry.time);
+                hasValidShop = true;
+            }
+        }
+        // obtainedFrom heuristic
+        let obtainedFrom;
+        if (row.skin_type === -1) {
+            obtainedFrom = "Default";
+        }
+        else if (hasValidShop && isAlways) {
+            obtainedFrom = "Skin Shop";
+        }
+        else if (shopId !== undefined && shopId !== 0) {
+            obtainedFrom = "Limited (Event)";
+        }
+        else if (row.skin_type === 7 ||
+            name.toLowerCase().includes("pledge")) {
+            obtainedFrom = "Wedding";
+        }
+        else {
+            obtainedFrom = "Special";
+        }
+        // live2dModel
+        const live2dModel = hasLive2d(row.l2d_animations) ? true : undefined;
+        const info = {
+            ...(cost !== undefined ? { cost } : {}),
+            obtainedFrom,
+            ...(live2dModel !== undefined ? { live2dModel } : {}),
+            enClient: "Yes",
+        };
+        // Build variant images object
+        const images = buildVariantImages(row.painting, base, availablePaintings);
+        skins.push({ name, image, images, info });
+    }
+    return { skins };
+}

package/dist/cjs/normalize/slots.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSlots = normalizeSlots;
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function normalizeSlots(inputs) {
+    const { lb0RowId, lb3RowId, template, statistics, lookups } = inputs;
+    const tmplLb0 = template[lb0RowId];
+    const tmplLb3 = template[lb3RowId];
+    // If either template row is missing, return empty — orchestrator decides what to do.
+    if (tmplLb0 === undefined || tmplLb3 === undefined) {
+        return [];
+    }
+    const statsLb0 = statistics[lb0RowId];
+    const statsLb3 = statistics[lb3RowId];
+    const proficiencyLb0 = statsLb0?.equipment_proficiency ?? [];
+    const proficiencyLb3 = statsLb3?.equipment_proficiency ?? [];
+    // Equipment slot arrays: equip_1, equip_2, equip_3 (ignore 4th augment slot)
+    const equipSlots = [
+        tmplLb0.equip_1,
+        tmplLb0.equip_2,
+        tmplLb0.equip_3,
+    ];
+    const slots = [];
+    for (let i = 0; i < 3; i++) {
+        const equipArr = equipSlots[i];
+        const equipTypeId = equipArr?.[0];
+        const type = equipTypeId !== undefined ? lookups.equipTypeName(equipTypeId) : "Unknown";
+        const minEfficiency = proficiencyLb0[i] ?? 0;
+        const maxEfficiency = proficiencyLb3[i] ?? 0;
+        slots.push({ type, minEfficiency, maxEfficiency });
+    }
+    return slots;
+}

package/dist/cjs/normalize/stats.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeStats = normalizeStats;
+const enums_js_1 = require("../translate/enums.js");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Build a strengthen bonus array (12 elements) from the `durability` field.
+ *
+ * Strengthen durability mapping (0-indexed):
+ *   [0] → firepower (attrs index 1)
+ *   [1] → torpedo   (attrs index 2)
+ *   [2] → (unused / always 0)
+ *   [3] → aviation  (attrs index 4)
+ *   [4] → reload    (attrs index 5)
+ */
+function buildStrengthenBonus(durability) {
+    const bonus = new Array(12).fill(0);
+    bonus[1] = durability[0] ?? 0; // firepower
+    bonus[2] = durability[1] ?? 0; // torpedo
+    bonus[4] = durability[3] ?? 0; // aviation
+    bonus[5] = durability[4] ?? 0; // reload
+    return bonus;
+}
+/**
+ * Compute a single stat value at the given level.
+ * Formula: base + floor(growth * (level - 1) / 1000) + floor(growthExtra * max(level - 100, 0) / 1000) + strengthenBonus
+ */
+function computeStat(base, growth, growthExtra, level, strengthenBonus) {
+    const fromGrowth = Math.floor((growth * (level - 1)) / 1000);
+    const fromExtra = level > 100 ? Math.floor((growthExtra * (level - 100)) / 1000) : 0;
+    return base + fromGrowth + fromExtra + strengthenBonus;
+}
+/**
+ * Build a StatBlock for a given level from the statistics arrays.
+ */
+function buildStatBlock(attrs, attrsGrowth, attrsGrowthExtra, level, strengthenBonus) {
+    const partial = {};
+    for (let i = 0; i < 12; i++) {
+        const field = enums_js_1.STAT_INDEX_TO_FIELD[i];
+        if (field === undefined)
+            continue;
+        const stat = computeStat(attrs[i] ?? 0, attrsGrowth[i] ?? 0, attrsGrowthExtra[i] ?? 0, level, strengthenBonus[i] ?? 0);
+        partial[field] = stat;
+    }
+    // Ensure all required StatBlock fields are present (default 0)
+    const block = {
+        health: partial.health ?? 0,
+        firepower: partial.firepower ?? 0,
+        torpedo: partial.torpedo ?? 0,
+        evasion: partial.evasion ?? 0,
+        antiwar: partial.antiwar ?? 0,
+        aviation: partial.aviation ?? 0,
+        reload: partial.reload ?? 0,
+        speed: partial.speed ?? 0,
+        luck: partial.luck ?? 0,
+        accuracy: partial.accuracy ?? 0,
+    };
+    return block;
+}
+/**
+ * Retrofit raw stat name → StatBlock field mapping.
+ */
+const RETROFIT_RAW_NAME_MAP = {
+    durability: "health",
+    cannon: "firepower",
+    torpedo: "torpedo",
+    antiaircraft: "antiwar",
+    air: "aviation",
+    reload: "reload",
+    hit: "accuracy",
+    dodge: "evasion",
+    speed: "speed",
+};
+/**
+ * Compute retrofit stat deltas by walking the transform_list.
+ * Returns a partial StatBlock delta (only fields with non-zero deltas).
+ */
+function computeRetrofitDeltas(groupType, trans, transformDataTemplate) {
+    const transRow = trans[groupType];
+    if (transRow === undefined)
+        return {};
+    const deltas = {};
+    const seenTransformIds = new Set();
+    for (const outerList of transRow.transform_list) {
+        for (const pair of outerList) {
+            const transformId = pair[1];
+            if (transformId === undefined || seenTransformIds.has(transformId))
+                continue;
+            seenTransformIds.add(transformId);
+            const tRow = transformDataTemplate[String(transformId)];
+            if (tRow === undefined)
+                continue;
+            for (const effectEntry of tRow.effect) {
+                for (const [rawStatName, delta] of Object.entries(effectEntry)) {
+                    const field = RETROFIT_RAW_NAME_MAP[rawStatName];
+                    if (field === undefined)
+                        continue;
+                    const current = deltas[field] ?? 0;
+                    deltas[field] = current + delta;
+                }
+            }
+        }
+    }
+    return deltas;
+}
+/**
+ * Apply retrofit deltas to a StatBlock, returning a new StatBlock.
+ */
+function applyRetrofitDeltas(base, deltas) {
+    return {
+        health: base.health + (deltas.health ?? 0),
+        firepower: base.firepower + (deltas.firepower ?? 0),
+        torpedo: base.torpedo + (deltas.torpedo ?? 0),
+        evasion: base.evasion + (deltas.evasion ?? 0),
+        antiwar: base.antiwar + (deltas.antiwar ?? 0),
+        aviation: base.aviation + (deltas.aviation ?? 0),
+        reload: base.reload + (deltas.reload ?? 0),
+        speed: base.speed + (deltas.speed ?? 0),
+        luck: base.luck + (deltas.luck ?? 0),
+        accuracy: base.accuracy + (deltas.accuracy ?? 0),
+    };
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function normalizeStats(inputs) {
+    const { lb3RowId, en, groupType, strengthenId } = inputs;
+    const { statistics, strengthen, trans, transformDataTemplate } = en;
+    // ------------------------------------------------------------------
+    // Get the LB3 statistics row
+    // ------------------------------------------------------------------
+    const statsRow = statistics[lb3RowId];
+    if (statsRow === undefined) {
+        throw new Error(`normalizeStats: missing statistics row "${lb3RowId}" for group_type "${groupType}"`);
+    }
+    const attrs = statsRow.attrs;
+    const attrsGrowth = statsRow.attrs_growth;
+    const attrsGrowthExtra = statsRow.attrs_growth_extra ?? new Array(12).fill(0);
+    // ------------------------------------------------------------------
+    // Strengthen bonus
+    // ------------------------------------------------------------------
+    const strengthenRow = strengthen[strengthenId];
+    const durability = strengthenRow?.durability ?? [];
+    const strengthenBonus = buildStrengthenBonus(durability);
+    // ------------------------------------------------------------------
+    // Compute stat blocks at level 100 and 120
+    // ------------------------------------------------------------------
+    const level100 = buildStatBlock(attrs, attrsGrowth, attrsGrowthExtra, 100, strengthenBonus);
+    const level120 = buildStatBlock(attrs, attrsGrowth, attrsGrowthExtra, 120, strengthenBonus);
+    // ------------------------------------------------------------------
+    // Retrofit deltas
+    // ------------------------------------------------------------------
+    const hasRetrofit = groupType in trans;
+    let level100Retrofit;
+    let level120Retrofit;
+    if (hasRetrofit) {
+        const deltas = computeRetrofitDeltas(groupType, trans, transformDataTemplate);
+        level100Retrofit = applyRetrofitDeltas(level100, deltas);
+        level120Retrofit = applyRetrofitDeltas(level120, deltas);
+    }
+    // ------------------------------------------------------------------
+    // Enhance value
+    // ------------------------------------------------------------------
+    const enhanceValue = {
+        firepower: durability[0] ?? 0,
+        torpedo: durability[1] ?? 0,
+        aviation: durability[3] ?? 0,
+        reload: durability[4] ?? 0,
+    };
+    // ------------------------------------------------------------------
+    // Assemble output
+    // ------------------------------------------------------------------
+    const stats = {
+        level100,
+        level120,
+        ...(level100Retrofit !== undefined ? { level100Retrofit } : {}),
+        ...(level120Retrofit !== undefined ? { level120Retrofit } : {}),
+    };
+    return { stats, enhanceValue };
+}

package/dist/cjs/output/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./writeShips.js"), exports);
+__exportStar(require("./writeShipList.js"), exports);
+__exportStar(require("./writeIdMap.js"), exports);
+__exportStar(require("./writeVersion.js"), exports);

package/dist/cjs/output/writeIdMap.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeIdMap = writeIdMap;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ---------------------------------------------------------------------------
+// writeIdMap
+// ---------------------------------------------------------------------------
+/**
+ * Write a name/alias → canonical id map to disk.
+ *
+ * Shape: Record<string, string>
+ *
+ * For each ship: emits names.en → id, names.cn → id, names.jp → id, names.code → id
+ * For each groupRow: emits padded code → group_type string (legacy AzurAPI lookup)
+ *
+ * Last-writer-wins for duplicate names.
+ */
+function writeIdMap(ships, groupRows, outputPath = "data/id-map.json") {
+    const map = {};
+    // Collect all EN names first so we don't let names.code overwrite a real ship name
+    const enNames = new Set();
+    for (const ship of ships) {
+        if (ship.names.en !== undefined)
+            enNames.add(ship.names.en);
+    }
+    // Per-ship name entries (first-writer-wins for code names to avoid collisions)
+    for (const ship of ships) {
+        const { id, names } = ship;
+        if (names.en !== undefined)
+            map[names.en] = id;
+        if (names.cn !== undefined && !(names.cn in map))
+            map[names.cn] = id;
+        if (names.jp !== undefined && !(names.jp in map))
+            map[names.jp] = id;
+        if (names.code !== undefined && !(names.code in map) && !enNames.has(names.code)) {
+            map[names.code] = id;
+        }
+    }
+    // Legacy 3-digit code → group_type mapping from groupRows
+    for (const row of groupRows) {
+        const paddedCode = String(row.code).padStart(3, "0");
+        map[paddedCode] = String(row.group_type);
+    }
+    const json = JSON.stringify(map, null, 2);
+    const dir = path_1.default.dirname(path_1.default.resolve(outputPath));
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(outputPath, json, "utf-8");
+}

package/dist/cjs/output/writeShipList.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeShipList = writeShipList;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ---------------------------------------------------------------------------
+// writeShipList
+// ---------------------------------------------------------------------------
+/**
+ * Write a minimal ship list to disk.
+ * Shape: Array<{ id: string; name: string; hullType: string; rarity: string }>
+ *
+ * `name` is resolved in priority order: names.en → names.code → id
+ */
+function writeShipList(ships, outputPath = "data/ship-list.json") {
+    const list = ships.map((ship) => ({
+        id: ship.id,
+        name: ship.names.en ?? ship.names.code ?? ship.id,
+        hullType: ship.hullType,
+        rarity: ship.rarity,
+    }));
+    // Sort by id numerically for deterministic output
+    list.sort((a, b) => Number(a.id) - Number(b.id));
+    const json = JSON.stringify(list, null, 2);
+    const dir = path_1.default.dirname(path_1.default.resolve(outputPath));
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(outputPath, json, "utf-8");
+}