@lycoristech/azurdata 0.0.1

package/data/version.json

@@ -0,0 +1,5 @@
+{
+  "generatedAt": "2026-04-09T22:17:20.993Z",
+  "shipCount": 746,
+  "schemaVersion": "0.0.1"
+}

package/dist/cjs/client/AzurData.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzurData = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ships_js_1 = require("./ships.js");
+const fetcher_js_1 = require("./fetcher.js");
+function resolveThisDir() {
+    // CJS: __dirname is injected by Node
+    // ESM under tsx/ts-node: __dirname is polyfilled
+    // Pure ESM: falls back to cwd
+    try {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore __dirname exists in CJS but not in ESM type defs
+        if (typeof __dirname === "string")
+            return __dirname; // eslint-disable-line no-undef
+    }
+    catch { /* not CJS */ }
+    return process.cwd();
+}
+class AzurData {
+    ships;
+    /** Sync constructor — loads baked data from disk. No network. */
+    constructor(options = {}) {
+        const dataDir = options.dataPath ?? AzurData.resolveDefaultDataPath();
+        const shipsJson = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dataDir, "ships.json"), "utf8"));
+        const idMapJson = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dataDir, "id-map.json"), "utf8"));
+        this.ships = new ships_js_1.Ships({ data: shipsJson, idMap: idMapJson });
+    }
+    /**
+     * Async factory — fetches latest data from GitHub, caches locally,
+     * falls back to baked data if offline.
+     *
+     * ```ts
+     * const azur = await AzurData.init({ fetchLatest: true });
+     * ```
+     */
+    static async init(options = {}) {
+        const { fetchLatest = true, ...fetchOpts } = options;
+        if (fetchLatest) {
+            const fetched = await (0, fetcher_js_1.fetchLatestData)(fetchOpts);
+            if (fetched) {
+                const instance = Object.create(AzurData.prototype);
+                instance.ships = new ships_js_1.Ships({
+                    data: fetched.ships,
+                    idMap: fetched.idMap,
+                });
+                return instance;
+            }
+        }
+        // Fallback to baked data
+        return new AzurData();
+    }
+    static resolveDefaultDataPath() {
+        const thisDir = resolveThisDir();
+        let candidate = thisDir;
+        for (let i = 0; i < 5; i++) {
+            const dataPath = node_path_1.default.resolve(candidate, "data");
+            if (node_fs_1.default.existsSync(node_path_1.default.join(dataPath, "ships.json")))
+                return dataPath;
+            candidate = node_path_1.default.resolve(candidate, "..");
+        }
+        return node_path_1.default.resolve(process.cwd(), "data");
+    }
+}
+exports.AzurData = AzurData;

package/dist/cjs/client/fetcher.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchLatestData = fetchLatestData;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const config_js_1 = require("../config.js");
+const DEFAULT_CACHE_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".azurdata");
+const DEFAULT_MAX_AGE = 6 * 60 * 60 * 1000; // 6 hours
+/**
+ * Fetch latest data from GitHub, with local cache and baked-data fallback.
+ *
+ * Flow:
+ * 1. If cache exists and is fresh (< maxAge) → load from cache
+ * 2. Else fetch version.json from remote → compare with cache
+ * 3. If remote is newer → fetch ships.json + id-map.json, write to cache
+ * 4. If any fetch fails → fall back to cache, then to null (caller uses baked data)
+ */
+async function fetchLatestData(options = {}) {
+    const cacheDir = options.cacheDir ?? DEFAULT_CACHE_DIR;
+    const maxAge = options.maxAge ?? DEFAULT_MAX_AGE;
+    const baseUrl = options.dataUrl ?? config_js_1.DATA_BASE_URL;
+    // Check cache freshness
+    const cachedShipsPath = node_path_1.default.join(cacheDir, "ships.json");
+    const cachedIdMapPath = node_path_1.default.join(cacheDir, "id-map.json");
+    const cachedVersionPath = node_path_1.default.join(cacheDir, "version.json");
+    if (isCacheFresh(cachedVersionPath, maxAge)) {
+        return loadFromCache(cachedShipsPath, cachedIdMapPath);
+    }
+    // Fetch remote version
+    let remoteVersion = null;
+    try {
+        remoteVersion = await fetchJson(`${baseUrl}/version.json`);
+    }
+    catch {
+        // Network error — try cache regardless of age
+        return loadFromCache(cachedShipsPath, cachedIdMapPath);
+    }
+    // Compare with cached version
+    if (remoteVersion && isCacheUpToDate(cachedVersionPath, remoteVersion)) {
+        // Touch the cache file to reset maxAge timer
+        touchFile(cachedVersionPath);
+        return loadFromCache(cachedShipsPath, cachedIdMapPath);
+    }
+    // Fetch fresh data
+    try {
+        const [ships, idMap] = await Promise.all([
+            fetchJson(`${baseUrl}/ships.json`),
+            fetchJson(`${baseUrl}/id-map.json`),
+        ]);
+        if (!ships || !idMap) {
+            return loadFromCache(cachedShipsPath, cachedIdMapPath);
+        }
+        // Write to cache atomically
+        writeCache(cacheDir, {
+            "ships.json": ships,
+            "id-map.json": idMap,
+            "version.json": remoteVersion,
+        });
+        return { ships, idMap };
+    }
+    catch {
+        return loadFromCache(cachedShipsPath, cachedIdMapPath);
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        return null;
+    return (await res.json());
+}
+function isCacheFresh(versionPath, maxAge) {
+    try {
+        const stat = node_fs_1.default.statSync(versionPath);
+        return Date.now() - stat.mtimeMs < maxAge;
+    }
+    catch {
+        return false;
+    }
+}
+function isCacheUpToDate(versionPath, remote) {
+    try {
+        const cached = JSON.parse(node_fs_1.default.readFileSync(versionPath, "utf8"));
+        return cached.generatedAt === remote.generatedAt;
+    }
+    catch {
+        return false;
+    }
+}
+function touchFile(filePath) {
+    try {
+        const now = new Date();
+        node_fs_1.default.utimesSync(filePath, now, now);
+    }
+    catch { /* ignore */ }
+}
+function loadFromCache(shipsPath, idMapPath) {
+    try {
+        if (!node_fs_1.default.existsSync(shipsPath) || !node_fs_1.default.existsSync(idMapPath))
+            return null;
+        const ships = JSON.parse(node_fs_1.default.readFileSync(shipsPath, "utf8"));
+        const idMap = JSON.parse(node_fs_1.default.readFileSync(idMapPath, "utf8"));
+        return { ships, idMap };
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(cacheDir, files) {
+    node_fs_1.default.mkdirSync(cacheDir, { recursive: true });
+    for (const [name, data] of Object.entries(files)) {
+        const target = node_path_1.default.join(cacheDir, name);
+        const tmp = target + ".tmp";
+        node_fs_1.default.writeFileSync(tmp, JSON.stringify(data), "utf8");
+        node_fs_1.default.renameSync(tmp, target); // atomic on most filesystems
+    }
+}

package/dist/cjs/client/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ships = exports.AzurData = void 0;
+var AzurData_js_1 = require("./AzurData.js");
+Object.defineProperty(exports, "AzurData", { enumerable: true, get: function () { return AzurData_js_1.AzurData; } });
+var ships_js_1 = require("./ships.js");
+Object.defineProperty(exports, "Ships", { enumerable: true, get: function () { return ships_js_1.Ships; } });

package/dist/cjs/client/ships.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ships = void 0;
+const fuse_js_1 = __importDefault(require("fuse.js"));
+class Ships {
+    data;
+    idMap;
+    fuse;
+    constructor(options) {
+        this.data = options.data;
+        this.idMap = options.idMap;
+        this.fuse = new fuse_js_1.default(Object.values(options.data), {
+            keys: [
+                { name: "names.en", weight: 3 },
+                { name: "names.code", weight: 2 },
+                { name: "names.jp", weight: 1 },
+                { name: "names.cn", weight: 1 },
+            ],
+            threshold: options.fuseThreshold ?? 0.4,
+            includeScore: true,
+        });
+    }
+    // Primary getter. Accepts:
+    //   - canonical group_type: "20212"
+    //   - legacy 3-digit code: "115" (via idMap)
+    //   - any name in idMap (case-insensitive)
+    //   - fuzzy match via fuse.js
+    get(nameOrId) {
+        if (typeof nameOrId !== "string" || nameOrId.length === 0)
+            return undefined;
+        // 1. Direct id hit
+        if (this.data[nameOrId])
+            return this.data[nameOrId];
+        // 2. Exact id-map hit (case sensitive first)
+        const directId = this.idMap[nameOrId];
+        if (directId && this.data[directId])
+            return this.data[directId];
+        // 3. Case-insensitive id-map hit
+        // Build a lowercased copy lazily
+        const lower = nameOrId.toLowerCase();
+        const ciIdMap = this.getCiIdMap();
+        const ciId = ciIdMap[lower];
+        if (ciId && this.data[ciId])
+            return this.data[ciId];
+        // 4. Fuse.js fuzzy
+        const results = this.fuse.search(nameOrId, { limit: 1 });
+        if (results.length > 0 && results[0].score !== undefined && results[0].score < 0.5) {
+            return results[0].item;
+        }
+        return undefined;
+    }
+    _ciIdMap;
+    getCiIdMap() {
+        if (!this._ciIdMap) {
+            this._ciIdMap = {};
+            for (const [k, v] of Object.entries(this.idMap)) {
+                this._ciIdMap[k.toLowerCase()] = v;
+            }
+        }
+        return this._ciIdMap;
+    }
+    getAll() {
+        return Object.values(this.data);
+    }
+    getById(id) {
+        return this.data[id];
+    }
+    count() {
+        return Object.keys(this.data).length;
+    }
+    // Search multiple matches
+    search(query, limit = 10) {
+        const results = this.fuse.search(query, { limit });
+        return results.map(r => r.item);
+    }
+}
+exports.Ships = Ships;

package/dist/cjs/config.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_BASE_URL = exports.THUMBNAILS_URL = exports.PAINTINGS_URL = exports.IMAGE_BASE_URL = void 0;
+// Central config for GitHub URLs.
+const GITHUB_USER = "iujab";
+const GITHUB_BRANCH = "main";
+// Image URLs (azurlane-images repo)
+const IMAGES_REPO = "azurlane-images";
+exports.IMAGE_BASE_URL = `https://raw.githubusercontent.com/${GITHUB_USER}/${IMAGES_REPO}/${GITHUB_BRANCH}`;
+exports.PAINTINGS_URL = `${exports.IMAGE_BASE_URL}/paintings`;
+exports.THUMBNAILS_URL = `${exports.IMAGE_BASE_URL}/thumbnails`;
+// Data URLs (azurdata repo — for runtime fetch)
+const DATA_REPO = "AzurAPI";
+exports.DATA_BASE_URL = `https://raw.githubusercontent.com/${GITHUB_USER}/${DATA_REPO}/${GITHUB_BRANCH}/data`;

package/dist/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ships = exports.AzurData = void 0;
+var index_js_1 = require("./client/index.js");
+Object.defineProperty(exports, "AzurData", { enumerable: true, get: function () { return index_js_1.AzurData; } });
+Object.defineProperty(exports, "Ships", { enumerable: true, get: function () { return index_js_1.Ships; } });

package/dist/cjs/ingest/files.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadShipDataTemplate = loadShipDataTemplate;
+exports.loadShipDataStatistics = loadShipDataStatistics;
+exports.loadShipDataBreakout = loadShipDataBreakout;
+exports.loadShipSkinWords = loadShipSkinWords;
+exports.loadShopTemplate = loadShopTemplate;
+exports.loadShipDataStrengthen = loadShipDataStrengthen;
+exports.loadShipDataBlueprint = loadShipDataBlueprint;
+exports.loadShipDataTrans = loadShipDataTrans;
+exports.loadShipDataGroup = loadShipDataGroup;
+exports.loadShipSkinTemplate = loadShipSkinTemplate;
+exports.loadTransformDataTemplate = loadTransformDataTemplate;
+exports.loadFleetTechShipTemplate = loadFleetTechShipTemplate;
+exports.loadFleetTechShipClass = loadFleetTechShipClass;
+exports.loadFleetTechGroup = loadFleetTechGroup;
+exports.loadShipDataByType = loadShipDataByType;
+exports.loadShipDataByStar = loadShipDataByStar;
+exports.loadSkillDataTemplate = loadSkillDataTemplate;
+exports.loadSkillDataDisplay = loadSkillDataDisplay;
+exports.loadVoiceActorCn = loadVoiceActorCn;
+exports.loadEquipDataByType = loadEquipDataByType;
+exports.loadShipDataCreateExchange = loadShipDataCreateExchange;
+exports.loadAttributeInfoByType = loadAttributeInfoByType;
+const fs_1 = __importDefault(require("fs"));
+const index_js_1 = require("../schema/raw/index.js");
+const upstream_js_1 = require("./upstream.js");
+function readJsonFile(filePath) {
+    try {
+        const raw = fs_1.default.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        // Many upstream files have an "all" key containing an array of IDs
+        // (an index listing all record keys). Strip it before validation.
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const obj = parsed;
+            if ("all" in obj && Array.isArray(obj["all"])) {
+                const { all: _all, ...rest } = obj;
+                return rest;
+            }
+        }
+        return parsed;
+    }
+    catch {
+        // File missing or unreadable — treat as empty
+        return {};
+    }
+}
+function loadFile(schema, filePath) {
+    const data = readJsonFile(filePath);
+    // Empty object stub — return as-is (valid empty record)
+    if (data !== null && typeof data === "object" && !Array.isArray(data) && Object.keys(data).length === 0) {
+        return {};
+    }
+    const result = schema.safeParse(data);
+    if (!result.success) {
+        throw new Error(`Zod parse failed for file: ${filePath}\n${result.error.message}`);
+    }
+    return result.data;
+}
+// ---------------------------------------------------------------------------
+// sharecfgdata/ files
+// ---------------------------------------------------------------------------
+function loadShipDataTemplate(region = "EN") {
+    return loadFile(index_js_1.ShipDataTemplateSchema, (0, upstream_js_1.regionPath)(region, "sharecfgdata", "ship_data_template.json"));
+}
+function loadShipDataStatistics(region = "EN") {
+    return loadFile(index_js_1.ShipDataStatisticsSchema, (0, upstream_js_1.regionPath)(region, "sharecfgdata", "ship_data_statistics.json"));
+}
+function loadShipDataBreakout(region = "EN") {
+    return loadFile(index_js_1.ShipDataBreakoutSchema, (0, upstream_js_1.regionPath)(region, "sharecfgdata", "ship_data_breakout.json"));
+}
+function loadShipSkinWords(region = "EN") {
+    return loadFile(index_js_1.ShipSkinWordsSchema, (0, upstream_js_1.regionPath)(region, "sharecfgdata", "ship_skin_words.json"));
+}
+function loadShopTemplate(region = "EN") {
+    return loadFile(index_js_1.ShopTemplateSchema, (0, upstream_js_1.regionPath)(region, "sharecfgdata", "shop_template.json"));
+}
+// ---------------------------------------------------------------------------
+// ShareCfg/ files
+// ---------------------------------------------------------------------------
+function loadShipDataStrengthen(region = "EN") {
+    return loadFile(index_js_1.ShipDataStrengthenSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_strengthen.json"));
+}
+function loadShipDataBlueprint(region = "EN") {
+    return loadFile(index_js_1.ShipDataBlueprintSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_blueprint.json"));
+}
+function loadShipDataTrans(region = "EN") {
+    return loadFile(index_js_1.ShipDataTransSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_trans.json"));
+}
+function loadShipDataGroup(region = "EN") {
+    return loadFile(index_js_1.ShipDataGroupSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_group.json"));
+}
+function loadShipSkinTemplate(region = "EN") {
+    return loadFile(index_js_1.ShipSkinTemplateSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_skin_template.json"));
+}
+function loadTransformDataTemplate(region = "EN") {
+    return loadFile(index_js_1.TransformDataTemplateSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "transform_data_template.json"));
+}
+function loadFleetTechShipTemplate(region = "EN") {
+    return loadFile(index_js_1.FleetTechShipTemplateSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "fleet_tech_ship_template.json"));
+}
+function loadFleetTechShipClass(region = "EN") {
+    return loadFile(index_js_1.FleetTechShipClassSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "fleet_tech_ship_class.json"));
+}
+function loadFleetTechGroup(region = "EN") {
+    return loadFile(index_js_1.FleetTechGroupSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "fleet_tech_group.json"));
+}
+function loadShipDataByType(region = "EN") {
+    return loadFile(index_js_1.ShipDataByTypeSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_by_type.json"));
+}
+function loadShipDataByStar(region = "EN") {
+    return loadFile(index_js_1.ShipDataByStarSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_by_star.json"));
+}
+function loadSkillDataTemplate(region = "EN") {
+    return loadFile(index_js_1.SkillDataTemplateSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "skill_data_template.json"));
+}
+function loadSkillDataDisplay(region = "EN") {
+    return loadFile(index_js_1.SkillDataDisplaySchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "skill_data_display.json"));
+}
+function loadVoiceActorCn(region = "EN") {
+    return loadFile(index_js_1.VoiceActorCnSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "voice_actor_CN.json"));
+}
+function loadEquipDataByType(region = "EN") {
+    return loadFile(index_js_1.EquipDataByTypeSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "equip_data_by_type.json"));
+}
+function loadShipDataCreateExchange(region = "EN") {
+    return loadFile(index_js_1.ShipDataCreateExchangeSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "ship_data_create_exchange.json"));
+}
+function loadAttributeInfoByType(region = "EN") {
+    return loadFile(index_js_1.AttributeInfoByTypeSchema, (0, upstream_js_1.regionPath)(region, "ShareCfg", "attribute_info_by_type.json"));
+}

package/dist/cjs/ingest/index.js

@@ -0,0 +1,18 @@
+"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("./upstream.js"), exports);
+__exportStar(require("./files.js"), exports);

package/dist/cjs/ingest/upstream.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPSTREAM_ROOT = void 0;
+exports.regionPath = regionPath;
+const path_1 = __importDefault(require("path"));
+exports.UPSTREAM_ROOT = path_1.default.resolve(process.cwd(), "upstream/azurlane-data");
+function regionPath(region, ...segments) {
+    return path_1.default.join(exports.UPSTREAM_ROOT, region, ...segments);
+}

package/dist/cjs/normalize/construction.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeConstruction = normalizeConstruction;
+const enums_js_1 = require("../translate/enums.js");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Flatten all string tokens from a description entry tuple.
+ * description entries are [string, unknown, number?] tuples.
+ */
+function descEntryText(entry) {
+    return entry[0];
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+function normalizeConstruction(inputs) {
+    const { groupType, groupRow, lb3RowId, shipType, initialStar, fleetTechShipTemplate, shipDataCreateExchange, shipDataByType, shipDataByStar, lookups, constructionTimeOverride, } = inputs;
+    const result = {};
+    // -------------------------------------------------------------------------
+    // 1. construction.availableIn
+    // -------------------------------------------------------------------------
+    const descriptions = groupRow.description ?? [];
+    let lightFlag = false;
+    let heavyFlag = false;
+    let aviationFlag = false;
+    let limitedFlag = false;
+    for (const entry of descriptions) {
+        const text = descEntryText(entry);
+        const lower = text.toLowerCase();
+        if (lower.includes("light construction") ||
+            (lower.includes("light") && lower.includes("construction"))) {
+            lightFlag = true;
+        }
+        if (lower.includes("heavy construction") ||
+            (lower.includes("heavy") && lower.includes("construction"))) {
+            heavyFlag = true;
+        }
+        if (lower.includes("special construction") ||
+            (lower.includes("aviation") && lower.includes("construction"))) {
+            aviationFlag = true;
+        }
+        if (lower.startsWith("event:") ||
+            lower === "limited build") {
+            limitedFlag = true;
+        }
+    }
+    // exchange: true if lb3RowId appears as a value in any exchange_ship_id array
+    let exchangeFlag = false;
+    const lb3RowIdNum = Number(lb3RowId);
+    for (const exchangeRow of Object.values(shipDataCreateExchange)) {
+        if (exchangeRow === undefined)
+            continue;
+        const ids = exchangeRow.exchange_ship_id ?? [];
+        if (ids.includes(lb3RowIdNum)) {
+            exchangeFlag = true;
+            break;
+        }
+    }
+    const anyAvailableIn = lightFlag || heavyFlag || aviationFlag || limitedFlag || exchangeFlag;
+    const hasConstructionTime = constructionTimeOverride !== undefined;
+    if (anyAvailableIn || hasConstructionTime) {
+        const availableIn = anyAvailableIn
+            ? {
+                light: lightFlag,
+                heavy: heavyFlag,
+                aviation: aviationFlag,
+                limited: limitedFlag,
+                exchange: exchangeFlag,
+            }
+            : undefined;
+        result.construction = {
+            ...(hasConstructionTime ? { constructionTime: constructionTimeOverride } : {}),
+            ...(availableIn !== undefined ? { availableIn } : {}),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // 2. scrapValue
+    // -------------------------------------------------------------------------
+    const typeRow = shipDataByType[String(shipType)];
+    const goldRatio = typeRow?.distory_resource_gold_ratio ?? 0;
+    const fixGold = typeRow?.fix_resource_gold ?? 0;
+    const coin = Math.floor(goldRatio * 120 + fixGold);
+    // medal: from ship_data_by_star[initialStar].destory_item — find item_id === 15001
+    const starRow = shipDataByStar[String(initialStar)];
+    const destroyItems = starRow?.destory_item ?? [];
+    let medal = 0;
+    for (const [, itemId, qty] of destroyItems) {
+        if (itemId === 15001) {
+            medal = qty;
+            break;
+        }
+    }
+    if (coin > 0 || medal > 0) {
+        result.scrapValue = { coin, oil: 0, medal };
+    }
+    // -------------------------------------------------------------------------
+    // 3. fleetTech
+    // -------------------------------------------------------------------------
+    const techRow = fleetTechShipTemplate[groupType];
+    if (techRow !== undefined) {
+        const collection = techRow.pt_get;
+        const maxLimitBreak = techRow.pt_upgrage;
+        const maxLevel = techRow.pt_level;
+        const total = collection + maxLimitBreak + maxLevel;
+        const techPoints = {
+            collection,
+            maxLimitBreak,
+            maxLevel,
+            total,
+        };
+        // collection bonus
+        let collectionBonus;
+        if (techRow.add_get_attr !== 0 && techRow.add_get_value !== 0) {
+            collectionBonus = {
+                stat: enums_js_1.FLEET_TECH_STAT_MAP[techRow.add_get_attr] ?? "unknown",
+                bonus: techRow.add_get_value,
+                applicable: techRow.add_get_shiptype.map((id) => lookups.hullTypeName(id)),
+            };
+        }
+        // maxLevel bonus
+        let maxLevelBonus;
+        if (techRow.add_level_attr !== 0 && techRow.add_level_value !== 0) {
+            maxLevelBonus = {
+                stat: enums_js_1.FLEET_TECH_STAT_MAP[techRow.add_level_attr] ?? "unknown",
+                bonus: techRow.add_level_value,
+                applicable: techRow.add_level_shiptype.map((id) => lookups.hullTypeName(id)),
+            };
+        }
+        result.fleetTech = {
+            techPoints,
+            statsBonus: {
+                ...(collectionBonus !== undefined ? { collection: collectionBonus } : {}),
+                ...(maxLevelBonus !== undefined ? { maxLevel: maxLevelBonus } : {}),
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // 4. obtainedFrom
+    // -------------------------------------------------------------------------
+    const mapPrefixes = ["explore chapter", "exploring stage"];
+    const fromMaps = [];
+    let firstNonMapText;
+    for (const entry of descriptions) {
+        const text = descEntryText(entry);
+        const lower = text.toLowerCase();
+        const isMap = mapPrefixes.some((prefix) => lower.startsWith(prefix));
+        if (isMap) {
+            // Extract the stage code using a regex: match Chapter/Stage followed by digits/dashes
+            const match = /\b(?:Chapter|Stage)\s+([0-9\-SEX\s]+)/i.exec(text);
+            if (match !== null && match[1] !== undefined) {
+                fromMaps.push(`Chapter ${match[1].trim()}`);
+            }
+            else {
+                // Fallback: take last whitespace-separated token
+                const tokens = text.trim().split(/\s+/);
+                const last = tokens[tokens.length - 1];
+                if (last !== undefined) {
+                    fromMaps.push(last);
+                }
+            }
+        }
+        else if (firstNonMapText === undefined) {
+            firstNonMapText = text;
+        }
+    }
+    let obtainedFromStr;
+    if (firstNonMapText !== undefined) {
+        obtainedFromStr = firstNonMapText;
+    }
+    else if (fromMaps.length > 0) {
+        obtainedFromStr = "Map Drop";
+    }
+    else {
+        obtainedFromStr = "Unknown";
+    }
+    const shouldEmitObtainedFrom = fromMaps.length > 0 || obtainedFromStr !== "Unknown";
+    if (shouldEmitObtainedFrom) {
+        result.obtainedFrom = {
+            ...(fromMaps.length > 0 ? { fromMaps } : {}),
+            obtainedFrom: obtainedFromStr,
+        };
+    }
+    return result;
+}