@alpaca-software/40kdc-data 0.1.0

package/dist/converters/configs/thousand-sons.js

@@ -0,0 +1,30 @@
+import { registerFaction } from "../faction-config.js";
+const thousandSons = {
+    sourceFactionId: "TS",
+    factionId: "thousand-sons",
+    factionName: "Thousand Sons",
+    factionAbilityName: "Cabal of Sorcerers",
+    factionRuleId: "cabal-of-sorcerers",
+    factionKeywords: ["Chaos", "Tzeentch", "Thousand Sons"],
+    parentFactionId: null,
+    aliases: [],
+    compositionOverrides: {
+        "rubric-marines": [
+            { name: "Aspiring Sorcerer", min: 1, max: 1, default_weapon_ids: ["inferno-bolt-pistol", "force-weapon"], is_leader_model: true },
+            { name: "Rubric Marine", min: 4, max: 9, default_weapon_ids: ["inferno-boltgun", "close-combat-weapon"], is_leader_model: false },
+        ],
+        "scarab-occult-terminators": [
+            { name: "Scarab Occult Sorcerer", min: 1, max: 1, default_weapon_ids: ["inferno-combi-bolter", "force-weapon"], is_leader_model: true },
+            { name: "Scarab Occult Terminator", min: 4, max: 9, default_weapon_ids: ["inferno-combi-bolter", "prosperine-khopesh"], is_leader_model: false },
+        ],
+        "tzaangors": [
+            { name: "Twistbray", profile_name: "Tzaangor", min: 1, max: 1, default_weapon_ids: ["autopistol", "tzaangor-blades"], is_leader_model: true },
+            { name: "Tzaangor", min: 9, max: 19, default_weapon_ids: ["autopistol", "tzaangor-blades"], is_leader_model: false },
+        ],
+        "chaos-spawn": [
+            { name: "Chaos Spawn", min: 2, max: 2, default_weapon_ids: ["hideous-mutations"], is_leader_model: false },
+        ],
+    },
+};
+registerFaction(thousandSons);
+export default thousandSons;

package/dist/converters/configs/tyranids.d.ts

@@ -0,0 +1,3 @@
+import { type FactionConfig } from "../faction-config.js";
+declare const tyranids: FactionConfig;
+export default tyranids;

package/dist/converters/configs/tyranids.js

@@ -0,0 +1,27 @@
+import { registerFaction } from "../faction-config.js";
+const tyranids = {
+    sourceFactionId: "TYR",
+    factionId: "tyranids",
+    factionName: "Tyranids",
+    factionAbilityName: "Shadow in the Warp",
+    factionRuleId: "shadow-in-the-warp",
+    factionKeywords: ["Tyranids"],
+    parentFactionId: null,
+    aliases: [],
+    compositionOverrides: {
+        "hyperadapted-raveners": [
+            { name: "Ravener Prime", min: 1, max: 1, default_weapon_ids: ["ravener-claws-and-talons"], is_leader_model: true },
+            { name: "Ravener", profile_name: "Raveners", min: 4, max: 4, default_weapon_ids: ["ravener-claws-and-talons"], is_leader_model: false },
+        ],
+        "tyranid-warriors-with-melee-bio-weapons": [
+            { name: "Tyranid Prime", profile_name: "Tyranid Warrior", min: 1, max: 1, default_weapon_ids: ["prime-talons"], is_leader_model: true },
+            { name: "Tyranid Warrior", min: 2, max: 5, default_weapon_ids: ["dual-boneswords"], is_leader_model: false },
+        ],
+        "tyranid-warriors-with-ranged-bio-weapons": [
+            { name: "Tyranid Prime", profile_name: "Tyranid Warrior", min: 1, max: 1, default_weapon_ids: ["devourer", "scything-talons"], is_leader_model: true },
+            { name: "Tyranid Warrior", min: 2, max: 5, default_weapon_ids: ["devourer", "scything-talons"], is_leader_model: false },
+        ],
+    },
+};
+registerFaction(tyranids);
+export default tyranids;

package/dist/converters/configs/ultramarines.d.ts

@@ -0,0 +1,3 @@
+import { type FactionConfig } from "../faction-config.js";
+declare const ultramarines: FactionConfig;
+export default ultramarines;

package/dist/converters/configs/ultramarines.js

@@ -0,0 +1,16 @@
+import { registerFaction } from "../faction-config.js";
+const ultramarines = {
+    sourceFactionId: "SM",
+    factionId: "ultramarines",
+    factionName: "Ultramarines",
+    factionAbilityName: "Oath of Moment",
+    factionRuleId: "oath-of-moment",
+    factionKeywords: ["Imperium", "Adeptus Astartes", "Ultramarines"],
+    parentFactionId: "adeptus-astartes",
+    aliases: [],
+    compositionOverrides: {},
+    skipUnits: true,
+    detachmentFilter: ["Blade of Ultramar"],
+};
+registerFaction(ultramarines);
+export default ultramarines;

package/dist/converters/configs/white-scars.d.ts

@@ -0,0 +1,3 @@
+import { type FactionConfig } from "../faction-config.js";
+declare const whiteScars: FactionConfig;
+export default whiteScars;

package/dist/converters/configs/white-scars.js

@@ -0,0 +1,16 @@
+import { registerFaction } from "../faction-config.js";
+const whiteScars = {
+    sourceFactionId: "SM",
+    factionId: "white-scars",
+    factionName: "White Scars",
+    factionAbilityName: "Oath of Moment",
+    factionRuleId: "oath-of-moment",
+    factionKeywords: ["Imperium", "Adeptus Astartes", "White Scars"],
+    parentFactionId: "adeptus-astartes",
+    aliases: [],
+    compositionOverrides: {},
+    skipUnits: true,
+    detachmentFilter: ["Reclamation Force"],
+};
+registerFaction(whiteScars);
+export default whiteScars;

package/dist/converters/configs/world-eaters.d.ts

@@ -0,0 +1,3 @@
+import { type FactionConfig } from "../faction-config.js";
+declare const worldEaters: FactionConfig;
+export default worldEaters;

package/dist/converters/configs/world-eaters.js

@@ -0,0 +1,43 @@
+import { registerFaction } from "../faction-config.js";
+const worldEaters = {
+    sourceFactionId: "WE",
+    factionId: "world-eaters",
+    factionName: "World Eaters",
+    factionAbilityName: "Blessings of Khorne",
+    factionRuleId: "blessings-of-khorne",
+    factionKeywords: ["Chaos", "Khorne", "World Eaters"],
+    parentFactionId: null,
+    aliases: [],
+    compositionOverrides: {
+        "khorne-berzerkers": [
+            { name: "Berzerker Champion", profile_name: "Khorne Berzerker", min: 1, max: 1, default_weapon_ids: ["bolt-pistol", "chainblade"], is_leader_model: true },
+            { name: "Khorne Berzerker", min: 9, max: 19, default_weapon_ids: ["bolt-pistol", "chainblade"], is_leader_model: false },
+        ],
+        "jakhals": [
+            { name: "Jakhal Pack Leader", profile_name: "Jakhal", min: 1, max: 1, default_weapon_ids: ["autopistol", "jakhal-chainblades"], is_leader_model: true },
+            { name: "Dishonoured", profile_name: "Jakhal", min: 1, max: 2, default_weapon_ids: ["mauler-chainblade"], is_leader_model: false },
+            { name: "Jakhal", min: 8, max: 17, default_weapon_ids: ["autopistol", "jakhal-chainblades"], is_leader_model: false },
+        ],
+        "eightbound": [
+            { name: "Eightbound Champion", profile_name: "Eightbound", min: 1, max: 1, default_weapon_ids: ["chainblades"], is_leader_model: true },
+            { name: "Eightbound", min: 2, max: 5, default_weapon_ids: ["chainblades"], is_leader_model: false },
+        ],
+        "exalted-eightbound": [
+            { name: "Exalted Eightbound Champion", profile_name: "Exalted Eightbound", min: 1, max: 1, default_weapon_ids: ["chainblades"], is_leader_model: true },
+            { name: "Exalted Eightbound", min: 2, max: 5, default_weapon_ids: ["chainblades"], is_leader_model: false },
+        ],
+        "chaos-terminators": [
+            { name: "Terminator Champion", profile_name: "World Eaters Terminator", min: 1, max: 1, default_weapon_ids: ["combi-bolter", "accursed-weapon"], is_leader_model: true },
+            { name: "Chaos Terminator", profile_name: "World Eaters Terminator", min: 4, max: 4, default_weapon_ids: ["combi-bolter", "accursed-weapon"], is_leader_model: false },
+        ],
+        "goremongers": [
+            { name: "Goremonger Pack Leader", profile_name: "Goremongers", min: 1, max: 1, default_weapon_ids: ["autopistol", "chainblade", "close-combat-weapon"], is_leader_model: true },
+            { name: "Goremonger", profile_name: "Goremongers", min: 7, max: 7, default_weapon_ids: ["autopistol", "chainblade", "close-combat-weapon"], is_leader_model: false },
+        ],
+        "chaos-spawn": [
+            { name: "Chaos Spawn", min: 2, max: 2, default_weapon_ids: ["hideous-mutations"], is_leader_model: false },
+        ],
+    },
+};
+registerFaction(worldEaters);
+export default worldEaters;

package/dist/converters/faction-config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Faction-specific configuration for the generic converter.
+ *
+ * Each faction provides a config that parameterizes the conversion pipeline.
+ * Configs are stored in ./configs/ and imported by convert-faction.ts.
+ */
+export interface ModelEntry {
+    name: string;
+    profile_name?: string | null;
+    min: number;
+    max: number;
+    default_weapon_ids?: string[];
+    is_leader_model: boolean;
+}
+export interface FactionConfig {
+    /** Source faction ID in army-assist data (e.g., "WE", "EC"). */
+    sourceFactionId: string;
+    /** 40kdc entity ID (e.g., "world-eaters", "emperors-children"). */
+    factionId: string;
+    /** Display name (e.g., "World Eaters", "Emperor's Children"). */
+    factionName: string;
+    /** Faction ability name used for view selection on shared units. */
+    factionAbilityName: string;
+    /** 40kdc ID for the faction rule ability (e.g., "blessings-of-khorne"). */
+    factionRuleId: string;
+    /** Top-level faction keywords (e.g., ["Chaos", "Khorne", "World Eaters"]). */
+    factionKeywords: string[];
+    /** Parent faction ID if this is a subfaction, null otherwise. */
+    parentFactionId: string | null;
+    /** Aliases for the faction name. */
+    aliases: string[];
+    /**
+     * Manual composition overrides for multi-model units.
+     * Keyed by 40kdc unit ID (e.g., "khorne-berzerkers").
+     * Single-model units (vehicles, characters) get auto-generated compositions.
+     */
+    compositionOverrides: Record<string, ModelEntry[]>;
+    /**
+     * For subfactions that share a source faction (e.g., SM chapters):
+     * only include detachments whose names match this list.
+     * Stratagems and enhancements are filtered to matching detachments.
+     * If undefined, all detachments are included.
+     */
+    detachmentFilter?: string[];
+    /**
+     * If true, skip unit/weapon/leader-attachment/unit-composition generation.
+     * Used by subfactions whose units are inherited from the parent faction.
+     */
+    skipUnits?: boolean;
+}
+export declare function registerFaction(config: FactionConfig): void;
+export declare function getFactionConfig(factionId: string): FactionConfig;
+export declare function listFactions(): string[];

package/dist/converters/faction-config.js

@@ -0,0 +1,22 @@
+/**
+ * Faction-specific configuration for the generic converter.
+ *
+ * Each faction provides a config that parameterizes the conversion pipeline.
+ * Configs are stored in ./configs/ and imported by convert-faction.ts.
+ */
+/** Registry of all known faction configs, keyed by 40kdc faction ID. */
+const registry = new Map();
+export function registerFaction(config) {
+    registry.set(config.factionId, config);
+}
+export function getFactionConfig(factionId) {
+    const config = registry.get(factionId);
+    if (!config) {
+        const available = [...registry.keys()].join(", ");
+        throw new Error(`Unknown faction "${factionId}". Available: ${available}`);
+    }
+    return config;
+}
+export function listFactions() {
+    return [...registry.keys()].sort();
+}

package/dist/converters/id-generator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates kebab-case entity IDs from display names.
+ */
+/** Convert a display name to a kebab-case entity ID. */
+export declare function nameToId(name: string): string;
+/** Convert a stratagem type string to the schema enum value and detachment ID. */
+export declare function parseStratagemType(typeStr: string): {
+    type: string;
+    detachmentName: string;
+};
+/** Convert a player turn string to schema enum. */
+export declare function parsePlayerTurn(turn: string): string;
+/** Map source phase names to schema phase enum values. Filters out invalid phases. */
+export declare function mapPhases(phases: string[]): string[];

package/dist/converters/id-generator.js

@@ -0,0 +1,65 @@
+/**
+ * Generates kebab-case entity IDs from display names.
+ */
+const ENTITY_ID_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+/** Convert a display name to a kebab-case entity ID. */
+export function nameToId(name) {
+    const id = name
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "") // strip diacritics
+        .replace(/[''\u2019]/g, "") // strip apostrophes/right-quotes
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-") // non-alphanumeric → hyphens
+        .replace(/^-+|-+$/g, ""); // trim leading/trailing hyphens
+    if (!ENTITY_ID_PATTERN.test(id)) {
+        throw new Error(`Generated ID "${id}" from name "${name}" does not match entity-id pattern`);
+    }
+    return id;
+}
+/** Convert a stratagem type string to the schema enum value and detachment ID. */
+export function parseStratagemType(typeStr) {
+    // Format: "Berzerker Warband - Battle Tactic Stratagem"
+    // Require spaces around the separator to avoid splitting on internal hyphens
+    // (e.g., "Spearhead-at-Arms" has hyphens but the delimiter is " - ")
+    const match = typeStr.match(/^(.+)\s+-\s+(.+?)\s*Stratagem$/i);
+    if (!match) {
+        throw new Error(`Cannot parse stratagem type: "${typeStr}"`);
+    }
+    const detachmentName = match[1].trim();
+    const rawType = match[2].trim().toLowerCase();
+    const typeMap = {
+        "battle tactic": "battle-tactic",
+        "strategic ploy": "strategic-ploy",
+        "epic deed": "epic-deed",
+        wargear: "wargear",
+    };
+    const type = typeMap[rawType];
+    if (!type) {
+        throw new Error(`Unknown stratagem type: "${rawType}" from "${typeStr}"`);
+    }
+    return { type, detachmentName };
+}
+/** Convert a player turn string to schema enum. */
+export function parsePlayerTurn(turn) {
+    const lower = turn.toLowerCase().trim();
+    if (lower.includes("either"))
+        return "either";
+    if (lower.includes("your"))
+        return "your-turn";
+    if (lower.includes("opponent"))
+        return "opponent-turn";
+    throw new Error(`Cannot parse player turn: "${turn}"`);
+}
+/** Map source phase names to schema phase enum values. Filters out invalid phases. */
+export function mapPhases(phases) {
+    const phaseMap = {
+        command: "command",
+        movement: "movement",
+        shooting: "shooting",
+        charge: "charge",
+        fight: "fight",
+    };
+    return phases
+        .map((p) => phaseMap[p.toLowerCase()])
+        .filter((p) => p !== undefined);
+}

package/dist/converters/keyword-filter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Filters keywords for shared units to return only the target faction's view.
+ *
+ * Source data stores all views' keywords in a flat list, grouped by faction
+ * keyword markers (is_faction_keyword === "true"). Each group starts with one
+ * or more faction keyword entries, followed by regular keywords for that view.
+ */
+export interface SourceKeyword {
+    datasheet_id: string;
+    keyword: string;
+    model: string;
+    is_faction_keyword: string;
+}
+interface KeywordResult {
+    factionKeywords: string[];
+    regularKeywords: string[];
+}
+/**
+ * Get keywords for a specific faction from a shared unit's keyword list.
+ * Finds the group whose faction keywords include `factionName` and returns
+ * deduplicated faction + regular keywords for that view.
+ *
+ * For single-view units (one group), returns all keywords as-is.
+ */
+export declare function getKeywordsForFaction(keywords: SourceKeyword[], factionName: string): KeywordResult;
+export {};

package/dist/converters/keyword-filter.js

@@ -0,0 +1,78 @@
+/**
+ * Filters keywords for shared units to return only the target faction's view.
+ *
+ * Source data stores all views' keywords in a flat list, grouped by faction
+ * keyword markers (is_faction_keyword === "true"). Each group starts with one
+ * or more faction keyword entries, followed by regular keywords for that view.
+ */
+/**
+ * Split keywords into view groups delimited by faction keyword entries.
+ * Each group starts when a faction keyword is encountered after regular keywords
+ * (or at the start).
+ */
+function splitKeywordGroups(keywords) {
+    const groups = [];
+    let current = null;
+    for (const kw of keywords) {
+        if (kw.is_faction_keyword === "true") {
+            if (current === null || current.regularKeywords.length > 0) {
+                // Start a new group when we see a faction keyword after regular ones
+                // (or at the very start)
+                if (current !== null)
+                    groups.push(current);
+                current = { factionKeywords: [], regularKeywords: [] };
+            }
+            current.factionKeywords.push(kw.keyword);
+        }
+        else {
+            if (current === null) {
+                current = { factionKeywords: [], regularKeywords: [] };
+            }
+            current.regularKeywords.push(kw.keyword);
+        }
+    }
+    if (current !== null)
+        groups.push(current);
+    return groups;
+}
+/**
+ * Get keywords for a specific faction from a shared unit's keyword list.
+ * Finds the group whose faction keywords include `factionName` and returns
+ * deduplicated faction + regular keywords for that view.
+ *
+ * For single-view units (one group), returns all keywords as-is.
+ */
+export function getKeywordsForFaction(keywords, factionName) {
+    const groups = splitKeywordGroups(keywords);
+    if (groups.length <= 1) {
+        // Single-view unit — return everything
+        const group = groups[0] ?? { factionKeywords: [], regularKeywords: [] };
+        return {
+            factionKeywords: [...new Set(group.factionKeywords)],
+            regularKeywords: [...new Set(group.regularKeywords)],
+        };
+    }
+    // Multi-view unit — find the group matching the target faction
+    for (const group of groups) {
+        if (group.factionKeywords.includes(factionName)) {
+            return {
+                factionKeywords: [...new Set(group.factionKeywords)],
+                regularKeywords: [...new Set(group.regularKeywords)],
+            };
+        }
+    }
+    // Fallback: faction name not found in any group. Return all keywords
+    // deduplicated — better than throwing for edge cases.
+    const allFaction = new Set();
+    const allRegular = new Set();
+    for (const group of groups) {
+        group.factionKeywords.forEach((k) => allFaction.add(k));
+        group.regularKeywords.forEach((k) => allRegular.add(k));
+    }
+    console.warn(`Warning: faction "${factionName}" not found in keyword groups for ` +
+        `datasheet ${keywords[0]?.datasheet_id}. Returning all keywords.`);
+    return {
+        factionKeywords: [...allFaction],
+        regularKeywords: [...allRegular],
+    };
+}

package/dist/converters/stat-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Parses army-assist display-format stat strings into typed values
+ * for the 40kdc-data schemas.
+ */
+/** Strip inch marks and parse to integer. "8\"" → 8, "14\"" → 14, "*" → 0 */
+export declare function parseMove(s: string): number;
+/** Parse target-number stat. "3+" → 3, "6+" → 6, "" → null */
+export declare function parseTargetNumber(s: string): number | null;
+/** Parse a stat-value field. Returns integer for fixed values, string for dice expressions. */
+export declare function parseStatValue(s: string): number | string;
+/** Parse weapon range. "36\"" → 36, "Melee" → "Melee", "" → "Melee", "N/A" → "Melee" */
+export declare function parseRange(s: string): number | "Melee";
+/** Parse BS/WS. "3+" → 3, "N/A" or "" → null */
+export declare function parseBSWS(s: string): number | null;
+/** Parse invulnerable save. "4+" → 4, "" → null */
+export declare function parseInvuln(s: string): number | null;
+/** Parse toughness, wounds, OC — always integers. */
+export declare function parseIntStat(s: string): number;
+/** Parse weapon keywords from the description field. "Pistol, Hazardous" → ["Pistol", "Hazardous"] */
+export declare function parseWeaponKeywords(description: string): string[];
+/** Parse AP value. "0" → 0, "-2" → -2 */
+export declare function parseAP(s: string): number;

package/dist/converters/stat-parser.js

@@ -0,0 +1,84 @@
+/**
+ * Parses army-assist display-format stat strings into typed values
+ * for the 40kdc-data schemas.
+ */
+/** Strip inch marks and parse to integer. "8\"" → 8, "14\"" → 14, "*" → 0 */
+export function parseMove(s) {
+    const cleaned = s.replace(/["″]/g, "").trim();
+    if (cleaned === "" || cleaned === "-" || cleaned === "*")
+        return 0;
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse movement: "${s}"`);
+    return n;
+}
+/** Parse target-number stat. "3+" → 3, "6+" → 6, "" → null */
+export function parseTargetNumber(s) {
+    const cleaned = s.replace("+", "").trim();
+    if (cleaned === "" || cleaned === "-" || cleaned === "N/A")
+        return null;
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse target number: "${s}"`);
+    return n;
+}
+/** Parse a stat-value field. Returns integer for fixed values, string for dice expressions. */
+export function parseStatValue(s) {
+    const cleaned = s.trim();
+    if (cleaned === "" || cleaned === "-")
+        return 0;
+    // Dice expressions: D6, 2D6, D6+2, D3+1, etc.
+    if (/^\d*[dD]\d/i.test(cleaned))
+        return cleaned;
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse stat value: "${s}"`);
+    return n;
+}
+/** Parse weapon range. "36\"" → 36, "Melee" → "Melee", "" → "Melee", "N/A" → "Melee" */
+export function parseRange(s) {
+    const cleaned = s.replace(/["″]/g, "").trim();
+    if (cleaned === "" || cleaned.toLowerCase() === "melee" || cleaned === "N/A")
+        return "Melee";
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse range: "${s}"`);
+    return n;
+}
+/** Parse BS/WS. "3+" → 3, "N/A" or "" → null */
+export function parseBSWS(s) {
+    return parseTargetNumber(s);
+}
+/** Parse invulnerable save. "4+" → 4, "" → null */
+export function parseInvuln(s) {
+    return parseTargetNumber(s);
+}
+/** Parse toughness, wounds, OC — always integers. */
+export function parseIntStat(s) {
+    const cleaned = s.trim();
+    if (cleaned === "" || cleaned === "-")
+        return 0;
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse int stat: "${s}"`);
+    return n;
+}
+/** Parse weapon keywords from the description field. "Pistol, Hazardous" → ["Pistol", "Hazardous"] */
+export function parseWeaponKeywords(description) {
+    if (!description || description.trim() === "")
+        return [];
+    return description
+        .split(",")
+        .map((k) => k.trim())
+        .filter((k) => k.length > 0);
+}
+/** Parse AP value. "0" → 0, "-2" → -2 */
+export function parseAP(s) {
+    const cleaned = s.trim();
+    if (cleaned === "" || cleaned === "-" || cleaned === "0")
+        return 0;
+    const n = parseInt(cleaned, 10);
+    if (isNaN(n))
+        throw new Error(`Cannot parse AP: "${s}"`);
+    return n;
+}

package/dist/converters/view-selector.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Handles multi-view data for shared units.
+ *
+ * Shared units (e.g., Chaos Land Raider) appear in multiple factions with the
+ * same UUID. Their abilities, models, and weapons tables contain repeated entry
+ * groups — one per faction "view". Views are delimited by the line number
+ * resetting to 1.
+ *
+ * For World Eaters, the correct view is identified by having
+ * "Blessings of Khorne" as a Faction-type ability.
+ */
+export interface SourceAbility {
+    datasheet_id: string;
+    line: string;
+    ability_id: string;
+    model: string;
+    name: string;
+    description: string;
+    type: string;
+    parameter: string;
+    phases: string[];
+}
+interface ViewGroup<T extends {
+    line: string;
+}> {
+    index: number;
+    entries: T[];
+}
+/** Split an array of line-numbered entries into view groups by line-number resets. */
+export declare function splitIntoViews<T extends {
+    line: string;
+}>(entries: T[]): ViewGroup<T>[];
+/**
+ * Find the view index for a faction's shared unit.
+ * Identifies the correct view by matching the faction's primary ability name
+ * among the Faction-type abilities in each view.
+ * Returns 0 for faction-exclusive units (single view).
+ */
+export declare function findFactionViewIndex(abilities: SourceAbility[], factionAbilityName: string): number;
+/** Extract entries for a specific view index from a line-numbered array. */
+export declare function getViewEntries<T extends {
+    line: string;
+}>(entries: T[], viewIndex: number): T[];
+/**
+ * Split points entries (no line field) into views for a shared unit.
+ *
+ * Points entries are ordered by view. For simple cases (1 entry per view),
+ * indexing by viewIndex works. For multi-squad-size units, views are
+ * delimited by the model count resetting (decreasing from prev entry).
+ */
+export declare function getPointsForView<T extends {
+    models: string;
+}>(entries: T[], viewIndex: number, numViews: number): T[];
+export {};