From 06b0cf4418d07ef1dd77365b53b49d00fddd422a Mon Sep 17 00:00:00 2001
From: mandalore <samleboy08@gmail.com>
Date: Fri, 4 Sep 2026 18:09:48 -0500
Subject: [PATCH] Add Generate Matrix: auto-build the team scouting matchup
 matrix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Duplicates the team's Google Sheets matchup-matrix template once per
opposing team at a loaded event, pre-filled with names, factions,
career win% (all already computed by this page), and cleaned army
lists. New "Which team is yours?" selector + Generate Matrix button,
team-events only.

- Auth: Google Identity Services token client (drive.file +
  spreadsheets scopes) — the viewer signs in with their own Google
  account via a real OAuth popup, no backend, no client secret.
- Template layout is located at runtime by searching each tab for its
  own placeholder text ("Player N - Faction", "Opponent N") rather
  than hardcoded A1 ranges, so it survives the template changing later.
  Distinguishes the real input area from the template's own "mobile
  matrix" mirror and reference sections (which repeat the same
  placeholder text) by checking for literal typed values vs formulas —
  CSV export can't tell these apart, only the real Sheets API response
  can, which is how this was actually verified before writing this.
  Auto-picks between the template's 5-man/8-man tab variants by team
  size.
- List cleaning via a vendored copy of desjani's 40k-compactor
  (src/vendor/40k-compactor/, see NOTICE.md) — it isn't actually
  published to npm despite documenting `npm install 40k-compactor`
  (verified: 404 against the registry under every plausible name), so
  it can't be a normal dependency; vendored instead, MIT per direct
  confirmation from the maintainer. Verified against 40k-compactor's
  own sample list fixtures with real Node before committing.
- Generating a matrix needs the same BCP auth token already used for
  faction/disposition backfill (list text is a subscriber-gated
  endpoint) — reuses the existing token UI/storage as-is; missing
  lists are reported, not a hard failure.
- nginx CSP updated (script/connect/frame-src) for Google's identity
  script and the Drive/Sheets REST APIs.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SBzcNkW7JcYipnAX6HfgmK
---
 sites/scouting/index.html                     |   20 +
 .../scouting/scouting.gateway-gamers.net.conf |    5 +-
 sites/scouting/src/main.js                    |   58 +
 sites/scouting/src/matrix.js                  |  353 ++
 .../src/vendor/40k-compactor/NOTICE.md        |   21 +
 .../src/vendor/40k-compactor/index.js         |   13 +
 .../40k-compactor/modules/abbreviations.js    |  318 ++
 .../40k-compactor/modules/faction_colors.js   |   51 +
 .../vendor/40k-compactor/modules/parsers.js   |   12 +
 .../modules/parsers/gwapp_v11.js              |  468 +++
 .../modules/parsers/nr_gw_parser.js           |  255 ++
 .../modules/parsers/nr_tournament_parser.js   |  290 ++
 .../modules/parsers/v11_detector.js           |  111 +
 .../modules/parsers/v11_parser.js             |  160 +
 .../modules/parsers/war_organ_parser.js       |  395 +++
 .../vendor/40k-compactor/modules/renderers.js |  784 ++++
 .../src/vendor/40k-compactor/modules/utils.js |  524 +++
 .../40k-compactor/skippable_wargear.json      | 3137 +++++++++++++++++
 18 files changed, 6974 insertions(+), 1 deletion(-)
 create mode 100644 sites/scouting/src/matrix.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/NOTICE.md
 create mode 100644 sites/scouting/src/vendor/40k-compactor/index.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/abbreviations.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/faction_colors.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/gwapp_v11.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_gw_parser.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_tournament_parser.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_detector.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_parser.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/parsers/war_organ_parser.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/renderers.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/modules/utils.js
 create mode 100644 sites/scouting/src/vendor/40k-compactor/skippable_wargear.json

diff --git a/sites/scouting/index.html b/sites/scouting/index.html
index 506dc47..ca733a3 100644
--- a/sites/scouting/index.html
+++ b/sites/scouting/index.html
@@ -5,6 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Gateway Gamers — Scouting</title>
     <link rel="stylesheet" href="/src/style.css" />
+    <!-- Google Identity Services — powers the "Generate Matrix" Google sign-in popup -->
+    <script src="https://accounts.google.com/gsi/client" async defer></script>
   </head>
   <body class="min-h-screen flex flex-col">
 
@@ -133,6 +135,24 @@
             <input id="player-filter" type="text" placeholder="Filter by name, team, or faction…" class="input input-bordered input-sm w-full sm:w-72" />
           </div>
 
+          <!-- Generate Matrix (team events only) -->
+          <div class="card card-border bg-base-200 mb-4 hidden" id="matrix-card">
+            <div class="card-body py-4">
+              <div class="flex items-center gap-2 flex-wrap">
+                <label class="text-sm opacity-70" for="matrix-team-select">Which team is yours?</label>
+                <select id="matrix-team-select" class="select select-bordered select-sm max-w-xs"></select>
+                <button id="matrix-generate-btn" type="button" class="btn btn-sm btn-warning uppercase tracking-wide" disabled>
+                  Generate Matrix
+                </button>
+              </div>
+              <p class="text-xs opacity-50 mt-1">
+                Duplicates the team matrix template, once per opposing team, pre-filled with names, factions, career win%, and cleaned lists.
+                List formatting by <a href="https://desjani.github.io/40kCompactor/" target="_blank" rel="noopener" class="link">40k Compactor</a> (Desjani), MIT licensed.
+              </p>
+              <p class="text-sm mt-2 hidden" id="matrix-status"></p>
+            </div>
+          </div>
+
           <!-- Team accordion (team events) -->
           <div class="space-y-2 hidden" id="team-list"></div>
 
diff --git a/sites/scouting/scouting.gateway-gamers.net.conf b/sites/scouting/scouting.gateway-gamers.net.conf
index 2508679..9fae010 100644
--- a/sites/scouting/scouting.gateway-gamers.net.conf
+++ b/sites/scouting/scouting.gateway-gamers.net.conf
@@ -33,7 +33,10 @@ server {
     # blocks without it (script-src stays locked down — this only affects
     # CSS, and nothing here renders untrusted external content into a
     # style attribute).
-    add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' https://newprod-api.bestcoastpairings.com; img-src 'self' data:;" always;
+    # script-src/connect-src/frame-src additions are for "Generate Matrix":
+    # Google Identity Services (accounts.google.com) for the sign-in popup,
+    # and the Drive/Sheets REST APIs the browser calls directly afterward.
+    add_header Content-Security-Policy "default-src 'self'; script-src 'self' https://accounts.google.com; style-src 'self' 'unsafe-inline'; connect-src 'self' https://newprod-api.bestcoastpairings.com https://www.googleapis.com https://sheets.googleapis.com https://accounts.google.com https://oauth2.googleapis.com; frame-src https://accounts.google.com; img-src 'self' data:;" always;
 
     location /images/ {
         alias /var/www/domains/gateway-gamers.net/shared/images/;
diff --git a/sites/scouting/src/main.js b/sites/scouting/src/main.js
index 2c861bd..d9d6740 100644
--- a/sites/scouting/src/main.js
+++ b/sites/scouting/src/main.js
@@ -1,3 +1,5 @@
+import { generateMatrix, configureMatrixHelpers } from "./matrix.js";
+
 /* ---- Shared: header / footer ---- */
 function loadHTML(file, elementId, callback) {
   fetch(file)
@@ -611,6 +613,22 @@ function renderTeamList(teams, itcRanks, itcLoading, careerRecords, careerLoadin
     `<p class="text-sm opacity-50">No teams match${q ? ` "${esc(filterText)}"` : ""}.</p>`;
 }
 
+// Rebuilding the <select> on every render() (which fires often — ITC/career
+// loads, backfill, the filter box) would blow away whatever the viewer
+// already picked. Only rebuild when the actual team list changed.
+let lastMatrixTeamSignature = null;
+function populateMatrixTeamSelect(teams) {
+  const signature = teams.map(t => t.id).join(",");
+  if (signature === lastMatrixTeamSignature) return;
+  lastMatrixTeamSignature = signature;
+
+  const sel = $("matrix-team-select");
+  const prev = sel.value;
+  sel.innerHTML = teams.map(t => `<option value="${esc(t.id)}">${esc(t.name)}</option>`).join("");
+  if (teams.some(t => t.id === prev)) sel.value = prev;
+  $("matrix-generate-btn").disabled = false;
+}
+
 function renderPlayers(roster, itcRanks, itcLoading, careerRecords, careerLoading, filterText) {
   const q = (filterText || "").trim().toLowerCase();
   const rows = roster.filter(r => {
@@ -655,6 +673,7 @@ function render() {
       : r
   );
   const teams = isTeamEvent ? computeTeamRollups(roster, teamplayers) : [];
+  state.teams = teams; // stashed for the Generate Matrix button, which runs outside render()
 
   const tokenStatusEl = $("bcp-token-status");
   if (tokenStatusEl) {
@@ -699,6 +718,10 @@ function render() {
   $("team-list").classList.toggle("hidden", !isTeamEvent);
   $("player-table-wrap").classList.toggle("hidden", isTeamEvent);
 
+  const showMatrix = isTeamEvent && teams.length >= 2;
+  $("matrix-card").classList.toggle("hidden", !showMatrix);
+  if (showMatrix) populateMatrixTeamSelect(teams);
+
   const filterText = $("player-filter").value;
   if (isTeamEvent) {
     renderTeamList(teams, itcRanks, itcLoading, careerRecords, careerLoading, filterText);
@@ -814,6 +837,41 @@ $("bcp-token-clear").addEventListener("click", () => {
   $("bcp-token-status").textContent = "Cleared.";
 });
 
+configureMatrixHelpers({ fullName, fmtWpct });
+
+$("matrix-generate-btn").addEventListener("click", async () => {
+  if (!state || !state.teams?.length) return;
+  const ourTeamId = $("matrix-team-select").value;
+  const ourTeam = state.teams.find(t => t.id === ourTeamId);
+  const opposingTeams = state.teams.filter(t => t.id !== ourTeamId && t.members.length);
+  if (!ourTeam || !opposingTeams.length) return;
+
+  const btn = $("matrix-generate-btn");
+  const statusEl = $("matrix-status");
+  btn.disabled = true;
+  statusEl.classList.remove("hidden", "text-error", "text-success");
+  statusEl.textContent = "Starting…";
+
+  try {
+    const { url, skipped } = await generateMatrix({
+      event: state.event,
+      ourTeam,
+      opposingTeams,
+      careerRecords: state.careerRecords,
+      bcpToken: getToken(),
+      onProgress: msg => { statusEl.textContent = msg; },
+    });
+    statusEl.classList.add("text-success");
+    statusEl.innerHTML = `Done — <a href="${esc(url)}" target="_blank" rel="noopener" class="link">open the matrix</a>.` +
+      (skipped.length ? `<br>${skipped.length} note(s): ${skipped.map(s => esc(`${s.team}: ${s.reason}`)).join(" · ")}` : "");
+  } catch (err) {
+    statusEl.classList.add("text-error");
+    statusEl.textContent = `Couldn't generate the matrix: ${String(err.message || err)}`;
+  } finally {
+    btn.disabled = false;
+  }
+});
+
 /* ---- Boot: seed from ?event= if present ---- */
 const seeded = new URLSearchParams(location.search).get("event");
 if (seeded) {
diff --git a/sites/scouting/src/matrix.js b/sites/scouting/src/matrix.js
new file mode 100644
index 0000000..6f9ae89
--- /dev/null
+++ b/sites/scouting/src/matrix.js
@@ -0,0 +1,353 @@
+/* ---- Generate Matrix: duplicate the team's Google Sheets matchup matrix
+   template, once per opposing team, pre-filled from this page's own roster
+   data plus cleaned army lists (via the vendored 40k-compactor). ----
+
+   Auth: Google Identity Services (GIS) token client — the viewer signs in
+   with their own Google account (a real OAuth popup), no backend, no
+   client secret. Scopes are drive.file (only files this app creates, not
+   full Drive access) and spreadsheets. */
+
+import { detectFormat, parseGwAppV11, parseWarOrganV11, parseV11List, generateDiscordText, buildAbbreviationIndex } from "./vendor/40k-compactor/index.js";
+import skippableWargear from "./vendor/40k-compactor/skippable_wargear.json";
+
+const GOOGLE_CLIENT_ID = "698705216189-rqbg3f7vlosi3077c3n410a7lpmsn16r.apps.googleusercontent.com";
+const TEMPLATE_FILE_ID = "1tSG1BxqLwmMtwFnaHozaLqVsKlmk_QsCXRorIxQBcMo";
+const SCOPES = "https://www.googleapis.com/auth/drive.file https://www.googleapis.com/auth/spreadsheets";
+
+const DRIVE_API = "https://www.googleapis.com/drive/v3";
+const SHEETS_API = "https://sheets.googleapis.com/v4/spreadsheets";
+
+/* ---- List cleaning (vendored 40k-compactor — see vendor/40k-compactor/NOTICE.md) ---- */
+
+// detectFormat() only distinguishes the 11th-edition dialects this parser
+// set understands; NR_TOURNAMENT isn't separately parseable from the
+// functions this tool exports (no dedicated parser in the vendored code),
+// so it falls back to the generic V11 parser same as an unrecognized format.
+const PARSERS = {
+  GW_APP_V11: parseGwAppV11,
+  WAR_ORGAN_V11: parseWarOrganV11,
+  V11_GENERIC: parseV11List,
+};
+
+// Returns cleaned, sheet-friendly (plain, not Discord-markdown) list text,
+// or null if the list couldn't be parsed — callers should fall back to the
+// raw text rather than dropping the list entirely.
+function cleanListText(rawText) {
+  if (!rawText) return null;
+  try {
+    const lines = String(rawText).split("\n");
+    const format = detectFormat(lines);
+    const parser = PARSERS[format] || parseV11List;
+    const parsed = parser(lines, skippableWargear);
+    if (!parsed) return null;
+    const abbrIndex = buildAbbreviationIndex(parsed);
+    return generateDiscordText(
+      parsed,
+      true, // plain text — this is going in a spreadsheet cell, not Discord
+      true, // use abbreviations
+      abbrIndex,
+      false, // hide subunits?
+      skippableWargear,
+      true, // combine identical units?
+      { multilineHeader: true, colorMode: "none" }
+    );
+  } catch (err) {
+    console.warn("[matrix] list cleaning failed, falling back to raw text:", err);
+    return null;
+  }
+}
+
+/* ---- Google auth ---- */
+
+let tokenClient = null;
+let cachedToken = null; // { access_token, expires_at }
+
+function ensureTokenClient() {
+  if (tokenClient) return tokenClient;
+  if (!window.google?.accounts?.oauth2) {
+    throw new Error("Google Identity Services hasn't loaded yet — try again in a moment.");
+  }
+  tokenClient = window.google.accounts.oauth2.initTokenClient({
+    client_id: GOOGLE_CLIENT_ID,
+    scope: SCOPES,
+    callback: () => {}, // overridden per-request in getAccessToken()
+  });
+  return tokenClient;
+}
+
+function getAccessToken() {
+  if (cachedToken && cachedToken.expires_at > Date.now() + 30_000) {
+    return Promise.resolve(cachedToken.access_token);
+  }
+  return new Promise((resolve, reject) => {
+    const client = ensureTokenClient();
+    client.callback = resp => {
+      if (resp.error) { reject(new Error(`Google sign-in failed: ${resp.error}`)); return; }
+      cachedToken = { access_token: resp.access_token, expires_at: Date.now() + (resp.expires_in || 3600) * 1000 };
+      resolve(resp.access_token);
+    };
+    client.requestAccessToken({ prompt: cachedToken ? "" : "consent" });
+  });
+}
+
+/* ---- Google API helpers ---- */
+
+async function googleFetch(url, token, options = {}) {
+  const r = await fetch(url, {
+    ...options,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...options.headers },
+  });
+  if (!r.ok) {
+    const body = await r.text().catch(() => "");
+    throw new Error(`Google API ${r.status}: ${body.slice(0, 300)}`);
+  }
+  return r.json();
+}
+
+const copyTemplate = (token, name) =>
+  googleFetch(`${DRIVE_API}/files/${TEMPLATE_FILE_ID}/copy?fields=id,webViewLink`, token, {
+    method: "POST",
+    body: JSON.stringify({ name }),
+  });
+
+const getSpreadsheet = (token, fileId) =>
+  googleFetch(`${SHEETS_API}/${fileId}?includeGridData=true`, token);
+
+const batchUpdate = (token, fileId, requests) =>
+  googleFetch(`${SHEETS_API}/${fileId}:batchUpdate`, token, {
+    method: "POST",
+    body: JSON.stringify({ requests }),
+  });
+
+const batchUpdateValues = (token, fileId, data) =>
+  googleFetch(`${SHEETS_API}/${fileId}/values:batchUpdate`, token, {
+    method: "POST",
+    body: JSON.stringify({ valueInputOption: "USER_ENTERED", data }),
+  });
+
+/* ---- Template layout ----
+   Deliberately not hardcoding A1 ranges: the implementation searches each
+   template tab for its own placeholder text ("Player N - Faction", the
+   "Opponent N" row) and works relative to what it finds, so this survives
+   the template being tweaked later (rows/columns inserted, etc.) without
+   needing a code change. See the plan file for how this was mapped out. */
+
+const PLAYER_ROW_RE = /^Player (\d+) - Faction$/;
+const OPPONENT_COL_RE = /^Opponent (\d+)$/;
+
+// The template repeats "Player N - Faction" / "Opponent N" in more than one
+// place — a primary input area, plus a "mobile matrix" mirror and a couple
+// of reference/lookup sections the sheet's own instructions say to ignore
+// ("Ignore the mobile matrix... I have no clue what the purpose is"). CSV
+// export can't tell these apart (it only shows computed values), but the
+// real API response can: only treat a cell as a genuine placeholder if it's
+// literal typed text (userEnteredValue.stringValue), not a formula result
+// (e.g. a mirror cell like `=B6`) that merely displays the same text.
+function isLiteralText(cell, expected) {
+  return cell.userEnteredValue?.stringValue === expected && (cell.formattedValue || "") === expected;
+}
+
+// Scans a tab's grid for the template's placeholder cells. Returns null if
+// this isn't a matrix template tab (e.g. the instructions tab, or a tab a
+// team has already filled in and renamed).
+function locateTemplate(sheet) {
+  const rows = sheet.data?.[0]?.rowData || [];
+
+  // { col -> [{ row, size }] } — group by column so mirrored/reference
+  // occurrences (which land in different columns) don't get mixed together.
+  const playerHitsByCol = new Map();
+  const opponentHitsByRow = new Map();
+
+  rows.forEach((rowData, rIdx) => {
+    (rowData.values || []).forEach((cell, cIdx) => {
+      const text = cell.formattedValue || "";
+      const pm = text.match(PLAYER_ROW_RE);
+      if (pm && isLiteralText(cell, text)) {
+        if (!playerHitsByCol.has(cIdx)) playerHitsByCol.set(cIdx, []);
+        playerHitsByCol.get(cIdx).push({ row: rIdx, size: Number(pm[1]) });
+      }
+      const om = text.match(OPPONENT_COL_RE);
+      if (om && isLiteralText(cell, text)) {
+        if (!opponentHitsByRow.has(rIdx)) opponentHitsByRow.set(rIdx, []);
+        opponentHitsByRow.get(rIdx).push({ col: cIdx, size: Number(om[1]) });
+      }
+    });
+  });
+
+  // The real input area is the single column/row with the longest run of
+  // *consecutive* placeholder numbers (1, 2, 3, …) — mirrors elsewhere in
+  // the sheet may repeat the same set, but this is how we'd tell a genuine
+  // partial/edited copy apart from a stray one-off match either way.
+  const longestRun = hits => {
+    const sorted = [...hits].sort((a, b) => a.size - b.size);
+    let best = [], current = [];
+    for (const h of sorted) {
+      if (current.length && h.size !== current[current.length - 1].size + 1) { current = []; }
+      current.push(h);
+      if (current.length > best.length) best = current;
+    }
+    return best;
+  };
+
+  let playerCol = null, playerRows = [];
+  for (const [col, hits] of playerHitsByCol) {
+    const run = longestRun(hits);
+    if (run.length > playerRows.length) { playerCol = col; playerRows = run; }
+  }
+
+  let opponentRowIdx = null, opponentHits = [];
+  for (const [row, hits] of opponentHitsByRow) {
+    const run = longestRun(hits);
+    if (run.length > opponentHits.length) { opponentRowIdx = row; opponentHits = run; }
+  }
+
+  if (!playerRows.length || !opponentHits.length) return null;
+
+  return {
+    sheetId: sheet.properties.sheetId,
+    title: sheet.properties.title,
+    teamSize: Math.max(...opponentHits.map(c => c.size)),
+    playerCol,
+    playerRows: playerRows.map(p => p.row).sort((a, b) => a - b),
+    opponentRow: opponentRowIdx, // "Name and Win Rate" row
+    factionRow: opponentRowIdx - 1, // one row up, per the template's own layout
+    listRow: opponentRowIdx - 2, // two rows up — "top of each appropriate column"
+    opponentCols: opponentHits.sort((a, b) => a.size - b.size).map(c => c.col),
+  };
+}
+
+// Finds every matrix-template tab in the copied file (there's one per
+// supported team size, e.g. 5-man and 8-man) and returns them keyed by size.
+function findTemplates(spreadsheet) {
+  const templates = new Map(); // teamSize -> layout
+  for (const sheet of spreadsheet.sheets) {
+    const layout = locateTemplate(sheet);
+    if (layout) templates.set(layout.teamSize, layout);
+  }
+  return templates;
+}
+
+function colLetter(idx) {
+  let s = "", n = idx;
+  do { s = String.fromCharCode(65 + (n % 26)) + s; n = Math.floor(n / 26) - 1; } while (n >= 0);
+  return s;
+}
+
+const a1 = (sheetTitle, col, row) => `'${sheetTitle.replace(/'/g, "''")}'!${colLetter(col)}${row + 1}`;
+
+/* ---- Row/column value builders ---- */
+
+function playerLabel(member) {
+  const name = fullNameOf(member);
+  const faction = member.faction?.name || "Unknown";
+  return `${name} - ${faction}`;
+}
+
+// fullName/fmtWpct live in main.js today; passed in rather than duplicated.
+let fullNameOf = () => "";
+let fmtWpctOf = () => "—";
+export function configureMatrixHelpers({ fullName, fmtWpct }) {
+  fullNameOf = fullName;
+  fmtWpctOf = fmtWpct;
+}
+
+function opponentNameAndWinRate(member, careerRecords) {
+  const name = fullNameOf(member);
+  const uid = member.userId || member.user?.id;
+  const rec = careerRecords.get(uid);
+  const wpct = rec ? fmtWpctOf(rec.w, rec.l, rec.t) : "—";
+  return `${name} (${wpct})`;
+}
+
+/* ---- Orchestration ---- */
+
+// team: one entry from computeTeamRollups(). onProgress(msg) for UI status.
+export async function generateMatrix({ event, ourTeam, opposingTeams, careerRecords, bcpToken, onProgress }) {
+  onProgress?.("Signing in to Google…");
+  const token = await getAccessToken();
+
+  onProgress?.("Copying the matrix template…");
+  const copy = await copyTemplate(token, `${event.name || "Event"} — Matrix`);
+
+  onProgress?.("Reading the template…");
+  const spreadsheet = await getSpreadsheet(token, copy.id);
+  const templates = findTemplates(spreadsheet);
+  if (!templates.size) {
+    throw new Error("Couldn't find a recognizable template tab (looking for 'Player 1 - Faction' / 'Opponent 1' placeholders) in the copied spreadsheet.");
+  }
+
+  const skipped = [];
+  let done = 0;
+
+  for (const oppTeam of opposingTeams) {
+    onProgress?.(`Building tab ${++done}/${opposingTeams.length}: ${oppTeam.name}…`);
+
+    // Nearest template size at or above this team's actual size (an
+    // undersized opponent just leaves trailing columns blank).
+    const sizes = [...templates.keys()].sort((a, b) => a - b);
+    const size = sizes.find(s => s >= Math.max(oppTeam.members.length, ourTeam.members.length)) || sizes[sizes.length - 1];
+    const template = templates.get(size);
+
+    let title;
+    try {
+      const dup = await batchUpdate(token, copy.id, [{
+        duplicateSheet: {
+          sourceSheetId: template.sheetId,
+          newSheetName: oppTeam.name.slice(0, 100),
+        },
+      }]);
+      title = dup.replies[0].duplicateSheet.properties.title;
+    } catch (err) {
+      skipped.push({ team: oppTeam.name, reason: `Couldn't duplicate tab: ${err.message}` });
+      continue;
+    }
+
+    const data = [];
+    ourTeam.members.forEach((member, i) => {
+      const row = template.playerRows[i];
+      if (row == null) return; // template has fewer rows than our roster
+      data.push({ range: a1(title, template.playerCol, row), values: [[playerLabel(member)]] });
+    });
+
+    let listSkips = 0;
+    for (let i = 0; i < oppTeam.members.length; i++) {
+      const col = template.opponentCols[i];
+      if (col == null) break; // opposing team is larger than this template supports
+      const member = oppTeam.members[i];
+      data.push({ range: a1(title, col, template.opponentRow), values: [[opponentNameAndWinRate(member, careerRecords)]] });
+      data.push({ range: a1(title, col, template.factionRow), values: [[member.faction?.name || "Unknown"]] });
+
+      if (member.listId && bcpToken) {
+        try {
+          const list = await fetchArmyListText(member.listId, bcpToken);
+          const cleaned = cleanListText(list) || list;
+          data.push({ range: a1(title, col, template.listRow), values: [[cleaned]] });
+        } catch {
+          listSkips++;
+        }
+      } else if (member.listId) {
+        listSkips++;
+      }
+    }
+    if (listSkips) skipped.push({ team: oppTeam.name, reason: `${listSkips} list(s) not fetched — add a BCP auth token above to include them.` });
+
+    try {
+      await batchUpdateValues(token, copy.id, data);
+    } catch (err) {
+      skipped.push({ team: oppTeam.name, reason: `Tab created but couldn't write data: ${err.message}` });
+    }
+  }
+
+  return { url: copy.webViewLink || `https://docs.google.com/spreadsheets/d/${copy.id}/edit`, skipped };
+}
+
+// Same BCP endpoint/shape as fetchArmyList() in main.js (kept local rather
+// than imported to keep this module's dependency surface self-contained).
+async function fetchArmyListText(listId, token) {
+  const r = await fetch(`https://newprod-api.bestcoastpairings.com/v1/armylists/${listId}`, {
+    headers: { "client-id": "web-app", "env": "bcp", "accept": "application/json", authorization: `Bearer ${token}` },
+  });
+  if (!r.ok) throw new Error(`armylists/${r.status}`);
+  const list = await r.json();
+  return list.armyListText || "";
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/NOTICE.md b/sites/scouting/src/vendor/40k-compactor/NOTICE.md
new file mode 100644
index 0000000..23925a8
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/NOTICE.md
@@ -0,0 +1,21 @@
+# 40k Compactor (vendored)
+
+Source: https://github.com/desjani/40kCompactor (tool page: https://desjani.github.io/40kCompactor/)
+Author: Desjani
+
+This directory is a copy of the `40k-compactor` npm package's source
+(v1.8.1) — it isn't actually published to the npm registry (verified:
+404 on `registry.npmjs.org/40k-compactor` and every plausible name
+variant, despite the project's own README documenting `npm install
+40k-compactor`), so it can't be a normal `package.json` dependency.
+Vendored directly instead.
+
+**License:** MIT, per direct confirmation from the maintainer (the
+upstream repo has no LICENSE file or `license` field as of this
+writing — this notice documents how permission was obtained). Used
+here to reformat submitted army lists before they're written into a
+generated scouting matrix — see `src/matrix.js`.
+
+Unmodified from upstream except this file. To update, re-fetch
+`index.js`, everything under `modules/`, and `skippable_wargear.json`
+from the repo's `main` branch.
diff --git a/sites/scouting/src/vendor/40k-compactor/index.js b/sites/scouting/src/vendor/40k-compactor/index.js
new file mode 100644
index 0000000..bf6d8fe
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/index.js
@@ -0,0 +1,13 @@
+import { detectFormat, parseV11List, parseGwAppV11, parseWarOrganV11 } from './modules/parsers.js';
+import { generateDiscordText, buildFactionColorMap } from './modules/renderers.js';
+import { buildAbbreviationIndex } from './modules/abbreviations.js';
+
+export {
+    detectFormat,
+    parseV11List,
+    parseGwAppV11,
+    parseWarOrganV11,
+    generateDiscordText,
+    buildFactionColorMap,
+    buildAbbreviationIndex
+};
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/abbreviations.js b/sites/scouting/src/vendor/40k-compactor/modules/abbreviations.js
new file mode 100644
index 0000000..f6cb386
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/abbreviations.js
@@ -0,0 +1,318 @@
+// Dynamic abbreviation generator: build abbreviation map from parsed list data
+// The goal: do not depend on any external JSON (wargear.json or abbreviation_rules.json).
+// We'll derive reasonable abbreviations by: using explicit nameshort from parsed items if
+// present, else generating a short token by taking initials of significant words.
+import { normalizeWargearName } from './utils.js';
+
+// Generate a base abbreviation following project rules:
+// - Trim parenthetical content and punctuation, split on words
+// - Single word -> first two letters uppercase (e.g. "Plasma" -> "PL")
+// - Multi-word -> for each word:
+//     * if word === 'and' -> use '&'
+//     * if word === 'of'  -> use 'o' (lowercase)
+//     * otherwise take first letter uppercase
+// Example: "Icon of Khorne" -> "IoK" ; "Skullsmasher and Mangler" -> "S&M"
+function makeBaseAbbreviation(name) {
+    if (!name) return null;
+    const cleaned = name.replace(/\(.*?\)/g, '').replace(/[\-]/g, ' ').replace(/["'`.,;:?!]/g, '').trim();
+    const parts = cleaned.split(/\s+/).filter(Boolean);
+    if (parts.length === 0) return null;
+    if (parts.length === 1) {
+        return parts[0].slice(0, 2).toUpperCase();
+    }
+    const tokens = parts.map(p => {
+        const low = p.toString().toLowerCase();
+        if (low === 'and') return '&';
+        if (low === 'of') return 'o';
+        return p[0].toUpperCase();
+    });
+    return tokens.join('');
+}
+
+// Helper exported so renderers can reuse the exact same abbreviation logic when
+// the dynamic map isn't available at runtime.
+export function makeAbbrevForName(name) {
+    return makeBaseAbbreviation(name);
+}
+
+export function buildAbbreviationIndex(parsedData, customAbbrs = {}) {
+    // Build a flat map: lowercased full item name -> abbreviation string
+    const flat = Object.create(null);
+
+    // Keep namespace-specific used and collision maps.
+    // Namespaces: 'unit' (units/subunits) and 'wargear' (wargear/specials)
+    const used = {
+        unit: Object.create(null),
+        wargear: Object.create(null)
+    };
+
+    const collisionGroups = {
+        unit: Object.create(null),
+        wargear: Object.create(null)
+    };
+
+    // 1. Load Custom Abbreviations (Priority 999)
+    if (customAbbrs) {
+        for (const [name, abbr] of Object.entries(customAbbrs)) {
+            if (!name || !abbr) continue;
+            const lowerName = normalizeWargearName(name);
+            flat[lowerName] = abbr;
+            
+            // If multiple custom rules map to the same abbr, the last one wins in 'used' map,
+            // but 'flat' map will hold all of them.
+            // We treat custom rules as "locked" in both namespaces.
+            for (const ns of ['unit', 'wargear']) {
+                if (!used[ns][abbr]) {
+                    used[ns][abbr] = { name: name, keys: [lowerName], priority: 999 };
+                } else {
+                    // If collision with another custom rule, just append key
+                    if (used[ns][abbr].priority === 999) {
+                        used[ns][abbr].keys.push(lowerName);
+                    } else {
+                        // Should not happen if we process custom first, but just in case
+                        used[ns][abbr] = { name: name, keys: [lowerName], priority: 999 };
+                    }
+                }
+            }
+        }
+    }
+
+    const getPriority = (it) => {
+        if (!it || !it.type) return 1;
+        if (it.type === 'unit') return 5;
+        if (it.type === 'subunit') return 4;
+        if (it.type === 'wargear') return 3;
+        if (it.type === 'special') return 2;
+        return 1;
+    };
+
+    const getNamespace = (type) => {
+        if (type === 'unit' || type === 'subunit') return 'unit';
+        return 'wargear';
+    };
+
+    // Produce an abbreviation taking first letter uppercase + `step` more letters lowercase per significant word.
+    const makeAbbrevWithStep = (name, step = 0) => {
+        if (!name) return '';
+        const cleaned = name.replace(/\(.*?\)/g, '').replace(/[\-]/g, ' ').replace(/["'`.,;:?!]/g, '').trim();
+        const parts = cleaned.split(/\s+/).filter(Boolean);
+        if (parts.length === 0) return '';
+        if (parts.length === 1) {
+            const w = parts[0];
+            const head = w.slice(0, 1).toUpperCase();
+            const extra = w.slice(1, 1 + Math.max(1, step)).toLowerCase();
+            return (head + extra) || w.slice(0, 2).toUpperCase();
+        }
+        const tokens = parts.map(p => {
+            const low = p.toString().toLowerCase();
+            if (low === 'and') return '&';
+            if (low === 'of') return 'o';
+            const head = p.slice(0, 1).toUpperCase();
+            const extra = p.slice(1, 1 + Math.max(0, step)).toLowerCase();
+            return head + extra;
+        });
+        return tokens.join('');
+    };
+
+    const reassignFlatKeys = (keys, newAbbr) => {
+        (keys || []).forEach(k => { flat[k] = newAbbr; });
+    };
+
+    // Resolve a collision group by iteratively expanding only conflicting members
+    // one letter per word per iteration until all become unique and don't clash with external 'used'.
+    const resolveGroup = (base, ns) => {
+        const grp = collisionGroups[ns][base];
+        if (!grp) return;
+
+        // Initialize steps/abbrs if missing
+        for (const m of grp.members) {
+            if (typeof m.step !== 'number') m.step = 0;
+        }
+
+        const nsUsed = used[ns];
+
+        const maxIterations = 100; // safety guard
+        let iter = 0;
+        while (iter++ < maxIterations) {
+            // Compute current abbreviations for members
+            const abbrMap = new Map(); // abbr -> members[]
+            for (const m of grp.members) {
+                const ab = makeAbbrevWithStep(m.name, m.step);
+                m.nextAbbr = ab;
+                if (!abbrMap.has(ab)) abbrMap.set(ab, []);
+                abbrMap.get(ab).push(m);
+            }
+
+            // Determine which members are in conflict (internal or external)
+            let anyConflict = false;
+            for (const m of grp.members) {
+                const ab = m.nextAbbr;
+                const internalConflict = (abbrMap.get(ab) || []).length > 1;
+                const external = nsUsed[ab];
+                // If external exists and is high priority (custom), we must conflict
+                const externalIsCustom = external && external.priority === 999;
+                const externalConflict = !!(external && (!external.keys || !m.keys || external.keys.some(k => !(m.keys||[]).includes(k))));
+                // Note: if external is one of our group's previous assignments for the same member, this shouldn't count as conflict
+                const externalIsSelf = external && external.name === m.name;
+                const conflict = internalConflict || (externalConflict && !externalIsSelf) || (externalIsCustom && !externalIsSelf);
+                m._conflict = conflict;
+                if (conflict) anyConflict = true;
+            }
+
+            if (!anyConflict) {
+                // Commit: update used and flat for all members
+                for (const m of grp.members) {
+                    const ab = m.nextAbbr;
+                    if (m.abbr && m.abbr !== ab && nsUsed[m.abbr]) delete nsUsed[m.abbr];
+                    reassignFlatKeys(m.keys, ab);
+                    nsUsed[ab] = { name: m.name, keys: m.keys, priority: m.priority };
+                    m.abbr = ab;
+                }
+                // Clean temp fields
+                grp.members.forEach(m => { delete m.nextAbbr; delete m._conflict; });
+                return;
+            }
+
+            // Increment step for conflicting members only (per spec)
+            for (const m of grp.members) {
+                if (m._conflict && m.priority !== 999) m.step = (m.step || 0) + 1;
+            }
+        }
+
+        // Fallback: if still conflicted after max iterations, append numerals to force uniqueness
+        const abbrCount = Object.create(null);
+        for (const m of grp.members) {
+            let ab = makeAbbrevWithStep(m.name, m.step || 0);
+            if (abbrCount[ab]) {
+                abbrCount[ab] += 1;
+                ab = ab + String(abbrCount[ab]);
+            } else {
+                abbrCount[ab] = 1;
+            }
+            if (m.abbr && m.abbr !== ab && nsUsed[m.abbr]) delete nsUsed[m.abbr];
+            reassignFlatKeys(m.keys, ab);
+            nsUsed[ab] = { name: m.name, keys: m.keys, priority: m.priority };
+            m.abbr = ab;
+        }
+        grp.members.forEach(m => { delete m.nextAbbr; delete m._conflict; });
+    };
+
+    const registerInGroup = (name, key, priority, base, ns) => {
+        let grp = collisionGroups[ns][base];
+        const nsUsed = used[ns];
+        if (!grp) {
+            const existing = nsUsed[base];
+            if (!existing) return null; // should not happen
+            grp = collisionGroups[ns][base] = { members: [
+                { name: existing.name, keys: existing.keys || [], priority: existing.priority || 1, abbr: base, step: 0 },
+                { name, keys: [key], priority, abbr: base, step: 0 }
+            ] };
+            // Remove the simplistic base entry; will be re-assigned after resolution
+            delete nsUsed[base];
+            resolveGroup(base, ns);
+            // return abbr for the new member
+            const last = grp.members[1];
+            return last.abbr;
+        }
+        // Add to existing group; reset steps so the entire set resolves fairly from the same baseline
+        grp.members.forEach(m => { m.step = 0; });
+        grp.members.push({ name, keys: [key], priority, abbr: '', step: 0 });
+        resolveGroup(base, ns);
+        const me = grp.members[grp.members.length - 1];
+        return me.abbr;
+    };
+
+    if (!parsedData) return { __flat_abbr: flat };
+
+    const processItem = (name, type) => {
+        if (!name) return;
+        const key = normalizeWargearName(name);
+        if (key === 'warlord') return;
+        if (flat[key]) return;
+
+        // Check if a singular or plural variation already has an abbreviation
+        const singularKey = key.endsWith('s') ? key.slice(0, -1) : key;
+        const pluralKey = key.endsWith('s') ? key : key + 's';
+        if (flat[singularKey]) {
+            flat[key] = flat[singularKey];
+            return;
+        }
+        if (flat[pluralKey]) {
+            flat[key] = flat[pluralKey];
+            return;
+        }
+
+        const ns = getNamespace(type);
+        const base = makeBaseAbbreviation(name);
+        if (base && base.toUpperCase() !== 'NULL') {
+            const priority = getPriority({ type });
+            const nsUsed = used[ns];
+            const nsCollisionGroups = collisionGroups[ns];
+            if (nsUsed[base]) {
+                const assigned = registerInGroup(name, key, priority, base, ns);
+                if (assigned) flat[key] = assigned;
+            } else if (nsCollisionGroups[base]) {
+                const assigned = registerInGroup(name, key, priority, base, ns);
+                if (assigned) flat[key] = assigned;
+            } else {
+                flat[key] = base;
+                nsUsed[base] = { name, keys: [key], priority };
+            }
+        }
+    };
+
+    if (Array.isArray(parsedData.units)) {
+        for (const unit of parsedData.units) {
+            if (unit.isAttached && Array.isArray(unit.attachedParts)) {
+                for (const part of unit.attachedParts) {
+                    processItem(part.name, 'unit');
+                    if (Array.isArray(part.wargear)) {
+                        for (const wg of part.wargear) {
+                            processItem(wg.name, 'wargear');
+                        }
+                    }
+                    if (Array.isArray(part.enhancements)) {
+                        for (const enh of part.enhancements) {
+                            processItem(enh.name, 'special');
+                        }
+                    }
+                    if (Array.isArray(part.subunits)) {
+                        for (const sub of part.subunits) {
+                            processItem(sub.name, 'subunit');
+                            if (Array.isArray(sub.wargear)) {
+                                for (const wg of sub.wargear) {
+                                    processItem(wg.name, 'wargear');
+                                }
+                            }
+                        }
+                    }
+                }
+            } else {
+                processItem(unit.name, 'unit');
+            }
+
+            if (Array.isArray(unit.wargear)) {
+                for (const wg of unit.wargear) {
+                    processItem(wg.name, 'wargear');
+                }
+            }
+            if (Array.isArray(unit.enhancements)) {
+                for (const enh of unit.enhancements) {
+                    processItem(enh.name, 'special');
+                }
+            }
+            if (Array.isArray(unit.subunits)) {
+                for (const sub of unit.subunits) {
+                    processItem(sub.name, 'subunit');
+                    if (Array.isArray(sub.wargear)) {
+                        for (const wg of sub.wargear) {
+                            processItem(wg.name, 'wargear');
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return { __flat_abbr: flat };
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/faction_colors.js b/sites/scouting/src/vendor/40k-compactor/modules/faction_colors.js
new file mode 100644
index 0000000..f22cd45
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/faction_colors.js
@@ -0,0 +1,51 @@
+// Faction color mapping for Discord/ANSI output.
+// Only colors from the project's ansiPalette are used here.
+// Keys should match the top-level keys from `skippable_wargear.json` or the
+// `DISPLAY_FACTION`/`FACTION_KEYWORD` values produced by parsers.
+//
+// Rules applied when choosing colors:
+// - Allowed hexes: '#000000','#FF0000','#00FF00','#FFFF00','#0000FF','#FF00FF','#00FFFF','#FFFFFF','#808080'
+// - Unit != Subunit
+// - Subunit != Wargear
+// - Wargear != Points
+// - Treat '#000000' and '#808080' as equivalent for uniqueness purposes
+export default {
+    // Use simple color names (allowed: black, red, green, yellow, blue, magenta, cyan, white, grey)
+    // Each entry now includes an explicit `header` color so the page header can be colored per-faction.
+    // Each entry also includes an `attached` color for the attached unit role tags ([L1], [BG1], etc.)
+    "World Eaters":        { unit: 'red',    subunit: 'grey',  wargear: 'yellow', points: 'green',  header: 'red',    attached: 'cyan' },
+    "Adepta Sororitas":    { unit: 'white',  subunit: 'grey',  wargear: 'red',    points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Adeptus Custodes":    { unit: 'yellow', subunit: 'red',   wargear: 'white',  points: 'yellow', header: 'yellow', attached: 'cyan' },
+    "Adeptus Mechanicus":  { unit: 'red',     subunit: 'grey',  wargear: 'white',  points: 'green',  header: 'red',    attached: 'cyan' },
+    "Adeptus Titanicus":   { unit: 'white',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'yellow', attached: 'cyan' },
+    "Aeldari":             { unit: 'green',  subunit: 'blue',  wargear: 'white',  points: 'grey',   header: 'green',  attached: 'yellow' },
+    "Astra Militarum":     { unit: 'grey',   subunit: 'green', wargear: 'cyan',   points: 'yellow', header: 'grey',   attached: 'magenta' },
+    "Black Templars":      { unit: 'white',  subunit: 'grey',  wargear: 'black',  points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Blood Angels":        { unit: 'red',    subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'red',    attached: 'cyan' },
+    "Chaos Daemons":       { unit: 'red',    subunit: 'grey',  wargear: 'green',  points: 'yellow', header: 'red',    attached: 'cyan' },
+    "Chaos Knights":       { unit: 'red',    subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'red',    attached: 'cyan' },
+    "Chaos Space Marines": { unit: 'red',    subunit: 'grey',  wargear: 'green',  points: 'yellow', header: 'red',    attached: 'cyan' },
+    "Dark Angels":         { unit: 'green',  subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'green',  attached: 'cyan' },
+    "Death Guard":         { unit: 'green',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'green',  attached: 'cyan' },
+    "Deathwatch":          { unit: 'black',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'black',  attached: 'cyan' },
+    "Drukhari":            { unit: 'magenta',subunit: 'grey',  wargear: 'cyan',   points: 'yellow', header: 'magenta', attached: 'white' },
+    "Emperor's Children":  { unit: 'magenta',subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'magenta', attached: 'cyan' },
+    "Genestealer Cults":   { unit: 'cyan',   subunit: 'grey',  wargear: 'green',  points: 'yellow', header: 'cyan',   attached: 'magenta' },
+    "Grey Knights":        { unit: 'white',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Imperial Fists":      { unit: 'yellow', subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'yellow', attached: 'cyan' },
+    "Imperial Knights":    { unit: 'white',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Iron Hands":          { unit: 'grey',   subunit: 'white', wargear: 'grey',   points: 'white',  header: 'grey',   attached: 'cyan' },
+    "Leagues of Votann":   { unit: 'white',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Necrons":             { unit: 'white',  subunit: 'grey',  wargear: 'white',   points: 'green', header: 'green',  attached: 'cyan' },
+    "Orks":                { unit: 'green',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'green',  attached: 'cyan' },
+    "Raven Guard":         { unit: 'black',  subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'black',  attached: 'cyan' },
+    "Salamanders":         { unit: 'green',  subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'green',  attached: 'cyan' },
+    "Space Marines":       { unit: 'blue',   subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'blue',   attached: 'cyan' },
+    "Space Wolves":        { unit: 'blue',   subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'blue',   attached: 'cyan' },
+    "T'au Empire":         { unit: 'yellow',   subunit: 'grey',  wargear: 'white',  points: 'Cyan', header: 'cyan',    attached: 'magenta' },
+    "Thousand Sons":       { unit: 'magenta',subunit: 'grey',  wargear: 'blue',   points: 'yellow', header: 'magenta', attached: 'cyan' },
+    "Tyranids":            { unit: 'cyan',   subunit: 'grey',  wargear: 'green',  points: 'yellow', header: 'cyan',   attached: 'magenta' },
+    "Ultramarines":        { unit: 'blue',   subunit: 'grey',  wargear: 'white',  points: 'yellow', header: 'blue',   attached: 'cyan' },
+    "White Scars":         { unit: 'white',  subunit: 'grey',  wargear: 'red',    points: 'yellow', header: 'white',  attached: 'cyan' },
+    "Agents of the Imperium": { unit: 'white', subunit: 'grey', wargear: 'blue', points: 'yellow', header: 'white', attached: 'cyan' }
+};
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers.js
new file mode 100644
index 0000000..f30bc34
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers.js
@@ -0,0 +1,12 @@
+import { detectV11Format } from './parsers/v11_detector.js';
+import { parseV11List } from './parsers/v11_parser.js';
+import { parseGwAppV11 } from './parsers/gwapp_v11.js';
+import { parseWarOrganV11 } from './parsers/war_organ_parser.js';
+import { parseNRTournament } from './parsers/nr_tournament_parser.js';
+import { parseNRGW } from './parsers/nr_gw_parser.js';
+
+export { parseV11List, parseGwAppV11, parseWarOrganV11, parseNRTournament, parseNRGW };
+
+export function detectFormat(lines) {
+    return detectV11Format(lines);
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/gwapp_v11.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/gwapp_v11.js
new file mode 100644
index 0000000..29893a7
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/gwapp_v11.js
@@ -0,0 +1,468 @@
+import { isWargearSkippable } from '../utils.js';
+
+export function parseGwAppV11(lines, skippableWargearMap = {}) {
+    const result = {
+        edition: '11th',
+        metadata: {
+            armyName: '',
+            totalPoints: 0,
+            faction: '',
+            battleSize: '',
+            pointsLimit: 0,
+            detachments: [],
+            detachmentPoints: 0,
+            forceDispositions: []
+        },
+        units: []
+    };
+
+    if (!Array.isArray(lines) || lines.length === 0) return result;
+
+    // Filter out empty lines for metadata parsing
+    const cleanLines = lines.map(l => l.trimEnd());
+    const nonEmptyLines = cleanLines.filter(l => l.trim().length > 0);
+
+    if (nonEmptyLines.length === 0) return result;
+
+    // Helper to map translated section headers to standard English versions
+    const getCanonicalSectionHeader = (line) => {
+        if (!line) return null;
+        let norm = line.toLowerCase().trim();
+        try {
+            norm = norm.normalize('NFD').replace(/\p{M}/gu, '');
+        } catch (e) {}
+
+        const mapping = {
+            // Attached units
+            "attached units": "Attached Units",
+            "unites attachees": "Attached Units",
+            "unidades acopladas": "Attached Units",
+            "angegliederte einheiten": "Attached Units",
+            "unita associate": "Attached Units",
+
+            // Characters
+            "characters": "Characters",
+            "personnages": "Characters",
+            "personajes": "Characters",
+            "charaktermodelle": "Characters",
+            "personaggi": "Characters",
+
+            // Battleline
+            // TODO: confirm Spanish/German/Italian equivalents against real exports
+            // before adding — "ligne" (French) is confirmed against a live export.
+            "battleline": "Battleline",
+            "ligne": "Battleline",
+
+            // Dedicated transports
+            "dedicated transports": "Dedicated Transports",
+            "transports assignes": "Dedicated Transports",
+            "transport assigne": "Dedicated Transports",
+            "transportes asignados": "Dedicated Transports",
+            "angeschlossene transportfahrzeuge": "Dedicated Transports",
+            "trasporti dedicati": "Dedicated Transports",
+
+            // Other datasheets
+            "other datasheets": "Other Datasheets",
+            "autres fiches techniques": "Other Datasheets",
+            "otras hojas de datos": "Other Datasheets",
+            "andere datenblatter": "Other Datasheets",
+            "altre schede tecniche": "Other Datasheets"
+        };
+
+        return mapping[norm] || null;
+    };
+
+    const forceDispPrefixRegex = /^(Force\s+Dispositions|Dispositions\s+des\s+Forces|Disposiciones\s+de\s+la?\s+fuerza|Streitkräfteaufstellungen?)\s*:\s*/i;
+    const attachedUnitHeaderRegex = /^(Attached Unit|Unité|Unidad acoplada|Angegliederte Einheit|Unità associata|Unita associata)\s+(\d+)(?:\s+Attachée)?$/i;
+    const detachmentPointsRegex = /^(.*?)\s*\((\d+[\d,]*)\s*(?:Detachment\s*Points|Points?\s*de\s*D[eé]tachement|Puntos\s*de\s*Destacamento|Detachement[- ]*Punkte|Detachementpunkte|Punti\s*(?:di\s*)?Distaccamento)\)$/i;
+
+    const isUnitHeader = (trimmed) => {
+        const unitMatch = trimmed.match(/^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+        if (!unitMatch) return false;
+        const name = unitMatch[1].toLowerCase().trim();
+        const battleSizes = [
+            'strike force', 'force de frappe', 'fuerza de choque', 'fuerza de incursión', 'angriffstrupp', 'forza d\'attacco',
+            'incursion', 'incursión', 'scharmützel', 'incursione',
+            'combat patrol', 'patrouille de combat', 'patrulla de combate', 'kampfpatrouille', 'pattuglia da combattimento',
+            'onslaught', 'aufmarsch', 'embestida', 'guerra aperta',
+        ];
+        if (battleSizes.some(bs => name.includes(bs))) {
+            return false;
+        }
+        if (name.includes('detachment') || name.includes('détachement') || name.includes('destacamento') || name.includes('detachement') || name.includes('distaccamento')) {
+            return false;
+        }
+        return true;
+    };
+
+    // 1. Parse Metadata Headers
+    let cleanLinesIndex = 0;
+    const getNextNonEmptyLine = () => {
+        while (cleanLinesIndex < cleanLines.length) {
+            const trimmed = cleanLines[cleanLinesIndex].trim();
+            if (trimmed.length > 0) {
+                return { line: trimmed, index: cleanLinesIndex++ };
+            }
+            cleanLinesIndex++;
+        }
+        return null;
+    };
+
+    const first = getNextNonEmptyLine();
+    if (!first) return result;
+
+    const line1 = first.line;
+    const line1Match = line1.match(/^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+    if (line1Match) {
+        result.metadata.armyName = line1Match[1].trim();
+        result.metadata.totalPoints = parseInt(line1Match[2].replace(/,/g, ''), 10) || 0;
+    } else {
+        result.metadata.armyName = line1;
+    }
+
+    const second = getNextNonEmptyLine();
+    if (second) {
+        result.metadata.faction = second.line.trim();
+
+        // Some lists express a subfaction as its own header line directly below the
+        // main faction, e.g.:
+        //   Space Marines
+        //   Dark Angels
+        //   Strike Force (2000 points)
+        // Detect this by peeking at the next line: if it's a plain line (not a battle
+        // size, force disposition, section header, or unit header), treat it as a
+        // subfaction and fold it into the faction name as "Space Marines - Dark Angels".
+        const savedIndex = cleanLinesIndex;
+        const peek = getNextNonEmptyLine();
+        if (peek) {
+            const peekLine = peek.line;
+            const looksLikeBattleSize = /^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i.test(peekLine);
+            const looksLikeMetadataMarker = looksLikeBattleSize ||
+                forceDispPrefixRegex.test(peekLine) ||
+                detachmentPointsRegex.test(peekLine) ||
+                getCanonicalSectionHeader(peekLine) ||
+                attachedUnitHeaderRegex.test(peekLine) ||
+                isUnitHeader(peekLine);
+            if (!looksLikeMetadataMarker) {
+                result.metadata.faction = `${result.metadata.faction} - ${peekLine}`;
+            } else {
+                cleanLinesIndex = savedIndex;
+            }
+        }
+    }
+
+    const metadataLines = [];
+    let bodyStartIndex = cleanLines.length;
+
+    while (cleanLinesIndex < cleanLines.length) {
+        let nextIndex = cleanLinesIndex;
+        while (nextIndex < cleanLines.length && cleanLines[nextIndex].trim().length === 0) {
+            nextIndex++;
+        }
+        if (nextIndex >= cleanLines.length) {
+            bodyStartIndex = cleanLines.length;
+            break;
+        }
+        const lineVal = cleanLines[nextIndex].trim();
+        if (getCanonicalSectionHeader(lineVal) || attachedUnitHeaderRegex.test(lineVal) || isUnitHeader(lineVal)) {
+            bodyStartIndex = nextIndex;
+            break;
+        }
+        metadataLines.push(lineVal);
+        cleanLinesIndex = nextIndex + 1;
+    }
+
+    let detachmentsSet = false;
+    let battleSizeSet = false;
+    let forceDispositionsSet = false;
+
+    metadataLines.forEach(line => {
+        const trimmedLine = line.trim();
+        if (trimmedLine.length === 0) return;
+
+        if (forceDispPrefixRegex.test(trimmedLine)) {
+            const dispStr = trimmedLine.replace(forceDispPrefixRegex, '').trim();
+            const cleanedDisp = dispStr.replace(/,$/, '');
+            result.metadata.forceDispositions = cleanedDisp.split(',').map(d => d.trim()).filter(Boolean);
+            forceDispositionsSet = true;
+            return;
+        }
+
+        const detachmentMatch = trimmedLine.match(detachmentPointsRegex);
+        if (detachmentMatch) {
+            const detStr = detachmentMatch[1].trim();
+            result.metadata.detachmentPoints = parseInt(detachmentMatch[2].replace(/,/g, ''), 10) || 0;
+            result.metadata.detachments = detStr.split(/\s+(?:and|et|y|und|e)\s+/i).map(d => d.trim()).filter(Boolean);
+            detachmentsSet = true;
+            return;
+        }
+
+        const battleSizeMatch = trimmedLine.match(/^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+        if (battleSizeMatch) {
+            result.metadata.battleSize = battleSizeMatch[1].trim();
+            result.metadata.pointsLimit = parseInt(battleSizeMatch[2].replace(/,/g, ''), 10) || 0;
+            battleSizeSet = true;
+            return;
+        }
+
+        // Bare line with no distinguishing marker. GW App's newer export format lists
+        // Force Dispositions as a plain line (no "Force Dispositions:" prefix) once the
+        // detachment has already been parsed, so prefer that reading over the legacy
+        // bare detachment/battle-size fallback below.
+        if (!forceDispositionsSet && detachmentsSet) {
+            const cleanedDisp = trimmedLine.replace(/,$/, '');
+            result.metadata.forceDispositions = cleanedDisp.split(',').map(d => d.trim()).filter(Boolean);
+            forceDispositionsSet = true;
+        } else if (!detachmentsSet) {
+            result.metadata.detachments = [trimmedLine];
+            detachmentsSet = true;
+        } else if (!battleSizeSet) {
+            result.metadata.battleSize = trimmedLine;
+            battleSizeSet = true;
+        } else if (result.metadata.forceDispositions.length === 0) {
+            // Newer app versions drop the "Force Dispositions:" label and just list
+            // the disposition(s) as a bare line, e.g. "Purge the Foe".
+            result.metadata.forceDispositions = trimmedLine.split(',').map(d => d.trim()).filter(Boolean);
+        }
+    });
+
+    // 2. Group Remaining Lines into Sections and Unit Blocks
+    let currentSection = 'Characters';
+    let currentAttachedGroup = null;
+
+    // Helper to parse quantity and name: e.g. "2x Storm Bolter" -> { name: "Storm Bolter", quantity: 2 }
+    const parseQtyAndName = (str, unitName) => {
+        const cleaned = str.trim();
+        let name = cleaned;
+        let quantity = 1;
+        const match = cleaned.match(/^(\d+)x?\s+(.*)$/i);
+        if (match) {
+            name = match[2].trim();
+            quantity = parseInt(match[1], 10);
+        }
+        const skippable = isWargearSkippable(skippableWargearMap, result.metadata.faction, unitName, name);
+        return {
+            name,
+            quantity,
+            skippable
+        };
+    };
+
+    // Parse a single line's indent and bullet properties
+    const parseLineDetails = (line) => {
+        const leadingSpaces = line.length - line.trimStart().length;
+        const trimmed = line.trim();
+        const bulletMatch = trimmed.match(/^([•◦\u25e6\u2022])\s*(.*)$/);
+        if (bulletMatch) {
+            return {
+                leadingSpaces,
+                hasBullet: true,
+                content: bulletMatch[2].trim()
+            };
+        }
+        return {
+            leadingSpaces,
+            hasBullet: false,
+            content: trimmed
+        };
+    };
+
+    // Helper to compile a tree of indented lines into a structured unit object
+    const parseUnitBlock = (unitName, unitPoints, blockLines) => {
+        const unit = {
+            name: unitName,
+            points: unitPoints,
+            category: currentSection,
+            isAttached: false,
+            isWarlord: false,
+            wargear: [],
+            enhancements: [],
+            subunits: []
+        };
+
+        if (blockLines.length === 0) return unit;
+
+        // Build tree using indentation
+        const root = { content: 'Root', indent: -1, children: [] };
+        const stack = [root];
+
+        blockLines.forEach(line => {
+            const details = parseLineDetails(line);
+            const node = {
+                content: details.content,
+                indent: details.leadingSpaces,
+                hasBullet: details.hasBullet,
+                children: []
+            };
+
+            while (stack.length > 1 && stack[stack.length - 1].indent >= node.indent) {
+                stack.pop();
+            }
+
+            stack[stack.length - 1].children.push(node);
+            stack.push(node);
+        });
+
+        // Helper to collect all wargear items recursively from a node's descendants
+        const collectWargearRecursive = (node, targetArray) => {
+            const parsed = parseQtyAndName(node.content, unitName);
+            targetArray.push(parsed);
+            node.children.forEach(child => {
+                collectWargearRecursive(child, targetArray);
+            });
+        };
+
+        // Traverse the tree recursively to find properties at indent level 2 and potential 'Attached as' headers at level 0
+        const elements = [];
+        let attachedAsNode = null;
+        let attachedAsMatchResult = null;
+        const findNodes = (nodes) => {
+            nodes.forEach(node => {
+                const match = node.content.match(/^(attached as|attach[eé]e en tant que|acoplado como|angegliedert als|associato come)\s*:\s*(.*)$/i);
+                if (match) {
+                    attachedAsNode = node;
+                    attachedAsMatchResult = match;
+                }
+                if (node.indent === 2) {
+                    elements.push(node);
+                }
+                if (node.children && node.children.length > 0) {
+                    findNodes(node.children);
+                }
+            });
+        };
+        findNodes(root.children);
+
+        if (attachedAsNode && attachedAsMatchResult) {
+            unit.attachedAs = attachedAsMatchResult[2].trim();
+            const roleStr = unit.attachedAs.toLowerCase();
+            if (/(leader|meneur|l[ií]der|anfuehrer|anführer|capo|comandante)/i.test(roleStr)) {
+                unit.role = 'Leader';
+            } else if (/(bodyguard|gardes?\s+du\s+corps|escolta|leibwaechter|leibwächter|guardia\s+del\s+corpo)/i.test(roleStr)) {
+                unit.role = 'Bodyguard';
+            } else {
+                unit.role = 'Bodyguard';
+            }
+        }
+
+        elements.forEach(node => {
+            const content = node.content;
+            const warlordRegex = /^(warlord|seigneur de guerre|se[nñ]or de la guerra|kriegsherr|signore della guerra)$/i;
+            const enhancementRegex = /^(enhancement|optimisation|mejora|aufwertung|verbesserung|potenziamento)\s*:\s*(.*)$/i;
+
+            if (warlordRegex.test(content)) {
+                unit.isWarlord = true;
+            } else {
+                const enhancementMatch = content.match(enhancementRegex);
+                if (enhancementMatch) {
+                    const enhName = enhancementMatch[2].trim();
+                    unit.enhancements.push({ name: enhName });
+                } else {
+                    // A unit item: could be a subunit (if it has bulleted children) or unit wargear
+                    const hasBulletedChildren = node.children.some(c => c.hasBullet);
+                    if (hasBulletedChildren) {
+                        // It is a subunit!
+                        const parsedSub = parseQtyAndName(content, unitName);
+                        const subunit = {
+                            name: parsedSub.name,
+                            quantity: parsedSub.quantity,
+                            wargear: []
+                        };
+                        // Collect wargear from all of its descendants
+                        node.children.forEach(child => {
+                            collectWargearRecursive(child, subunit.wargear);
+                        });
+                        unit.subunits.push(subunit);
+                    } else {
+                        // It is a top-level wargear item
+                        collectWargearRecursive(node, unit.wargear);
+                    }
+                }
+            }
+        });
+
+        return unit;
+    };
+
+    // Start parsing the body lines
+    let i = bodyStartIndex;
+
+    while (i < cleanLines.length) {
+        const line = cleanLines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            i++;
+            continue;
+        }
+
+        const canonicalHeader = getCanonicalSectionHeader(trimmed);
+
+        // Check for section transitions
+        if (canonicalHeader) {
+            currentSection = canonicalHeader;
+            currentAttachedGroup = null;
+            i++;
+            continue;
+        }
+
+        // Check for attached unit group headers
+        const attachedMatch = trimmed.match(attachedUnitHeaderRegex);
+        if (currentSection === 'Attached Units' && attachedMatch) {
+            currentAttachedGroup = {
+                name: `Attached Unit ${attachedMatch[2]}`,
+                points: 0,
+                category: 'Attached Units',
+                isAttached: true,
+                attachedParts: []
+            };
+            result.units.push(currentAttachedGroup);
+            i++;
+            continue;
+        }
+
+        // Check for unit header line, e.g. "Commander Farsight (80 points)"
+        const unitMatch = trimmed.match(/^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+        if (unitMatch) {
+            const unitName = unitMatch[1].trim();
+            const unitPoints = parseInt(unitMatch[2].replace(/,/g, ''), 10) || 0;
+            const blockLines = [];
+            i++;
+
+            // Collect all subsequent lines belonging to this unit block
+            while (i < cleanLines.length) {
+                const nextLine = cleanLines[i];
+                const nextTrimmed = nextLine.trim();
+                if (!nextTrimmed) {
+                    i++;
+                    continue;
+                }
+
+                // If next line starts a new section, attached group, or unit header, stop
+                if (getCanonicalSectionHeader(nextTrimmed) ||
+                    (currentSection === 'Attached Units' && attachedUnitHeaderRegex.test(nextTrimmed)) ||
+                    nextTrimmed.match(/^(.*?)\s*\((\d+[\d,]*)\s*(?:pts|points|punkte|puntos|punti)\)$/i) ||
+                    /^(?:exported with app version|exporte avec la version|export|esport)/i.test(nextTrimmed)) {
+                    break;
+                }
+
+                blockLines.push(nextLine);
+                i++;
+            }
+
+            const unit = parseUnitBlock(unitName, unitPoints, blockLines);
+
+            if (currentSection === 'Attached Units' && currentAttachedGroup) {
+                unit.category = 'Attached Units';
+                currentAttachedGroup.attachedParts.push(unit);
+                currentAttachedGroup.points += unit.points;
+            } else {
+                result.units.push(unit);
+            }
+            continue;
+        }
+
+        i++;
+    }
+
+    return result;
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_gw_parser.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_gw_parser.js
new file mode 100644
index 0000000..56ce2e7
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_gw_parser.js
@@ -0,0 +1,255 @@
+import { isWargearSkippable, parseNewRecruitHeader } from '../utils.js';
+
+export function parseNRGW(lines, skippableWargearMap = {}) {
+    if (!Array.isArray(lines) || lines.length === 0) {
+        return {
+            edition: '11th',
+            metadata: {
+                title: '', armyName: '', faction: '', detachment: '', detachments: [],
+                pointsTotal: 0, totalPoints: 0, pointsLimit: 0, forceDispositions: [],
+                warlordName: '', warlordId: '', enhancements: []
+            },
+            units: []
+        };
+    }
+
+    const cleanLines = lines.map(l => l ? l.replace(/\u00a0/g, ' ') : '');
+    const { metadata, nextIndex } = parseNewRecruitHeader(cleanLines);
+    const result = {
+        edition: '11th',
+        metadata,
+        units: []
+    };
+
+    let currentUnit = null;
+    let currentSubunit = null;
+    let currentCategory = 'Other Datasheets';
+    let inAttachedSection = false;
+    let currentAttachedGroup = null;
+    let warlordFoundExplicitly = false;
+
+    const parseQtyAndName = (str, unitName) => {
+        const cleaned = str.trim();
+        let name = cleaned;
+        let quantity = 1;
+        const match = cleaned.match(/^(\d+)x?\s+(.*)$/i);
+        if (match) {
+            name = match[2].trim();
+            quantity = parseInt(match[1], 10);
+        }
+        name = name.replace(/^with\s+/i, '').trim();
+        const skippable = isWargearSkippable(skippableWargearMap, result.metadata.faction, unitName, name);
+        return {
+            name,
+            quantity,
+            skippable
+        };
+    };
+
+    // Add a parsed wargear item to a target list, summing into an existing entry of
+    // the same name instead of pushing a duplicate. The same wargear name can appear
+    // across multiple separate bullet lines within one unit/subunit (e.g. two "1x
+    // Drone burst cannon" bullets for the same model).
+    const addWargear = (targetArray, parsedWg) => {
+        const existing = targetArray.find(w => w.name === parsedWg.name);
+        if (existing) {
+            existing.quantity += parsedWg.quantity;
+        } else {
+            targetArray.push(parsedWg);
+        }
+    };
+
+    const getCategory = (str) => {
+        const lower = str.trim().toLowerCase();
+        if (lower.startsWith('character')) return 'Characters';
+        if (lower.startsWith('battleline')) return 'Battleline';
+        if (lower.startsWith('dedicated transport')) return 'Dedicated Transports';
+        if (lower.startsWith('other datasheet')) return 'Other Datasheets';
+        return null;
+    };
+
+    const getNextNonEmptyLineIndentAndContent = (startIndex) => {
+        let idx = startIndex;
+        while (idx < cleanLines.length) {
+            const line = cleanLines[idx];
+            const trimmed = line.trim();
+            if (trimmed.length > 0) {
+                const leadingSpaces = line.length - line.trimStart().length;
+                return { indent: leadingSpaces, content: trimmed };
+            }
+            idx++;
+        }
+        return null;
+    };
+
+    for (let i = nextIndex; i < cleanLines.length; i++) {
+        const line = cleanLines[i];
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        const leadingSpaces = line.length - line.trimStart().length;
+
+        // 1. Check for the "Attached Units" section header
+        if (/^attached units$/i.test(trimmed)) {
+            inAttachedSection = true;
+            currentCategory = 'Attached Units';
+            currentUnit = null;
+            currentSubunit = null;
+            currentAttachedGroup = null;
+            continue;
+        }
+
+        // 2. Check for Category header (also ends an "Attached Units" section, since
+        // a list can mix attached groups with standalone Characters/Battleline units)
+        const cat = getCategory(trimmed);
+        if (cat) {
+            currentCategory = cat;
+            currentUnit = null;
+            currentSubunit = null;
+            inAttachedSection = false;
+            currentAttachedGroup = null;
+            continue;
+        }
+
+        // 3. Check for an "Attached Unit N" group header within the Attached Units section
+        const attachedGroupMatch = inAttachedSection && trimmed.match(/^attached unit\s+(\d+)$/i);
+        if (attachedGroupMatch) {
+            currentAttachedGroup = {
+                name: `Attached Unit ${attachedGroupMatch[1]}`,
+                points: 0,
+                category: 'Attached Units',
+                isAttached: true,
+                attachedParts: []
+            };
+            result.units.push(currentAttachedGroup);
+            currentUnit = null;
+            currentSubunit = null;
+            continue;
+        }
+
+        // 4. Check for bulleted lines (starts with • or * or -)
+        const bulletMatch = trimmed.match(/^([•\*\-◦\u25e6\u2022])\s*(.*)$/);
+        if (bulletMatch) {
+            const content = bulletMatch[2].trim();
+
+            // Check for "Attached as: Leader/Bodyguard" role marker
+            const attachedAsMatch = content.match(/^attached as\s*:\s*(.*)$/i);
+            if (attachedAsMatch) {
+                if (currentUnit) {
+                    currentUnit.attachedAs = attachedAsMatch[1].trim();
+                    const roleStr = currentUnit.attachedAs.toLowerCase();
+                    if (/leader/i.test(roleStr)) {
+                        currentUnit.role = 'Leader';
+                    } else if (/bodyguard/i.test(roleStr)) {
+                        currentUnit.role = 'Bodyguard';
+                    }
+                }
+                continue;
+            }
+
+            if (content.toLowerCase() === 'warlord') {
+                if (currentUnit) {
+                    currentUnit.isWarlord = true;
+                    warlordFoundExplicitly = true;
+                }
+                continue;
+            }
+
+            // Check for enhancement:
+            const enhMatch = content.match(/^(.*?)\s*\(\+(\d+)\s*(?:pts|points|pt)\)/i);
+            if (enhMatch) {
+                if (currentUnit) {
+                    currentUnit.enhancements.push({
+                        name: enhMatch[1].trim(),
+                        points: parseInt(enhMatch[2], 10) || 0
+                    });
+                }
+                continue;
+            }
+
+            // Subunit detection based on next line indentation
+            const next = getNextNonEmptyLineIndentAndContent(i + 1);
+            const isSubunitHeader = next && next.indent > leadingSpaces;
+
+            if (isSubunitHeader && leadingSpaces <= 2) {
+                // It is a subunit header
+                const match = content.match(/^(?:(\d+)x?\s+)?(.*)$/);
+                const quantity = match && match[1] ? parseInt(match[1], 10) : 1;
+                const name = match ? match[2].trim() : content;
+
+                currentSubunit = {
+                    name,
+                    quantity,
+                    wargear: []
+                };
+
+                if (currentUnit) {
+                    currentUnit.subunits.push(currentSubunit);
+                }
+            } else {
+                // It is wargear (unit-level or subunit-level)
+                const items = content.split(',').map(s => s.trim()).filter(Boolean);
+                items.forEach(it => {
+                    const parsedWg = parseQtyAndName(it, currentUnit ? currentUnit.name : '');
+                    if (currentSubunit && leadingSpaces > 2) {
+                        addWargear(currentSubunit.wargear, parsedWg);
+                    } else if (currentUnit) {
+                        addWargear(currentUnit.wargear, parsedWg);
+                    }
+                });
+            }
+            continue;
+        }
+
+        // 5. Unit Header line
+        const unitMatch = trimmed.match(/^(?![•\*\-\s])(.*?)\s*\((\d+)\s*(?:pts|points|pt)\)$/i);
+        if (unitMatch) {
+            const name = unitMatch[1].trim();
+            const points = parseInt(unitMatch[2], 10) || 0;
+
+            currentUnit = {
+                name,
+                points,
+                quantity: 1,
+                category: inAttachedSection ? 'Attached Units' : currentCategory,
+                wargear: [],
+                enhancements: [],
+                subunits: []
+            };
+
+            if (inAttachedSection && currentAttachedGroup) {
+                currentAttachedGroup.attachedParts.push(currentUnit);
+                currentAttachedGroup.points += points;
+            } else {
+                result.units.push(currentUnit);
+            }
+            currentSubunit = null; // Reset subunit context
+            continue;
+        }
+    }
+
+    // This format has no per-unit ID, so an explicit inline "Warlord" bullet (handled
+    // above) is the authoritative signal. Only fall back to matching the header's
+    // WARLORD name when no unit carried that marker, and flag just the first match —
+    // duplicate-named units (e.g. two identical Knight Castellans) must not all be
+    // flagged just because they share a name with the true warlord.
+    if (!warlordFoundExplicitly && result.metadata.warlordName) {
+        const wantName = result.metadata.warlordName.toLowerCase();
+        outer:
+        for (const u of result.units) {
+            if (Array.isArray(u.attachedParts)) {
+                for (const part of u.attachedParts) {
+                    if ((part.name || '').toLowerCase() === wantName) {
+                        part.isWarlord = true;
+                        break outer;
+                    }
+                }
+            } else if ((u.name || '').toLowerCase() === wantName) {
+                u.isWarlord = true;
+                break;
+            }
+        }
+    }
+
+    return result;
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_tournament_parser.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_tournament_parser.js
new file mode 100644
index 0000000..645ebc0
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/nr_tournament_parser.js
@@ -0,0 +1,290 @@
+import { isWargearSkippable, parseNewRecruitHeader } from '../utils.js';
+
+export function parseNRTournament(lines, skippableWargearMap = {}) {
+    if (!Array.isArray(lines) || lines.length === 0) {
+        return {
+            edition: '11th',
+            metadata: {
+                title: '', armyName: '', faction: '', detachment: '', detachments: [],
+                pointsTotal: 0, totalPoints: 0, pointsLimit: 0, forceDispositions: [],
+                warlordName: '', warlordId: '', enhancements: []
+            },
+            units: []
+        };
+    }
+
+    const cleanLines = lines.map(l => l ? l.replace(/\u00a0/g, ' ') : '');
+    const { metadata, nextIndex } = parseNewRecruitHeader(cleanLines);
+    const result = {
+        edition: '11th',
+        metadata,
+        units: []
+    };
+
+    let currentUnit = null;
+    let currentSubunit = null;
+
+    const parseQtyAndName = (str, unitName) => {
+        const cleaned = str.trim();
+        let name = cleaned;
+        let quantity = 1;
+        const match = cleaned.match(/^(\d+)x?\s+(.*)$/i);
+        if (match) {
+            name = match[2].trim();
+            quantity = parseInt(match[1], 10);
+        }
+        name = name.replace(/^with\s+/i, '').trim();
+        const skippable = isWargearSkippable(skippableWargearMap, result.metadata.faction, unitName, name);
+        return {
+            name,
+            quantity,
+            skippable
+        };
+    };
+
+    // Add a parsed wargear item to a subunit's wargear list, summing into an existing
+    // entry of the same name instead of pushing a duplicate. A subunit's loadout is
+    // often split across several "N with ..." lines/segments (e.g. rank-and-file vs.
+    // an icon bearer), so the same wargear name can legitimately appear more than once.
+    const addWargear = (targetArray, parsedWg) => {
+        const existing = targetArray.find(w => w.name === parsedWg.name);
+        if (existing) {
+            existing.quantity += parsedWg.quantity;
+        } else {
+            targetArray.push(parsedWg);
+        }
+    };
+
+    for (let i = nextIndex; i < cleanLines.length; i++) {
+        const line = cleanLines[i];
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // 1. Enhancement line
+        const enhMatch = trimmed.match(/^(?:•?\s*)?Enhancement\s*:\s*(.*?)\s*\(\+(\d+)\s*(?:pts|points|pt)\)/i);
+        if (enhMatch) {
+            if (currentUnit) {
+                currentUnit.enhancements.push({
+                    name: enhMatch[1].trim(),
+                    points: parseInt(enhMatch[2], 10) || 0
+                });
+            }
+            continue;
+        }
+
+        // 2. Subunit line (starts with • or *)
+        if (trimmed.startsWith('•') || trimmed.startsWith('*')) {
+            const subContent = trimmed.substring(1).trim();
+
+            // Check if it has inline wargear via colon:
+            const colonIdx = subContent.indexOf(':');
+            if (colonIdx !== -1) {
+                const subHeader = subContent.substring(0, colonIdx).trim();
+                const itemsStr = subContent.substring(colonIdx + 1).trim();
+
+                const match = subHeader.match(/^(?:(\d+)x?\s+)?(.*)$/);
+                const quantity = match && match[1] ? parseInt(match[1], 10) : 1;
+                const name = match ? match[2].trim() : subHeader;
+
+                currentSubunit = {
+                    name,
+                    quantity,
+                    wargear: []
+                };
+
+                // An inline subunit's item text can itself lead with a "N with ..."
+                // model-count multiplier (e.g. "2x Shas'ui: 2 with Gun Drone, Plasma rifle")
+                // when all N models in the subunit share one loadout. Distinguish that
+                // from a per-item "Nx Item" quantity on the first item (no "with").
+                const modelPrefixMatch = itemsStr.match(/^(\d+)\s+with\s+(.*)$/i);
+                const modelMultiplier = modelPrefixMatch ? (parseInt(modelPrefixMatch[1], 10) || 1) : 1;
+                const rawItemsStr = modelPrefixMatch ? modelPrefixMatch[2] : itemsStr;
+
+                const items = rawItemsStr.split(',').map(s => s.trim()).filter(Boolean);
+                items.forEach(it => {
+                    const parsedWg = parseQtyAndName(it, currentUnit ? currentUnit.name : '');
+                    parsedWg.quantity = parsedWg.quantity * modelMultiplier;
+                    addWargear(currentSubunit.wargear, parsedWg);
+                });
+
+                if (currentUnit) {
+                    currentUnit.subunits.push(currentSubunit);
+                }
+                // Inline subunit is done
+                currentSubunit = null;
+            } else {
+                // Multi-line subunit header
+                const match = subContent.match(/^(?:(\d+)x?\s+)?(.*)$/);
+                const quantity = match && match[1] ? parseInt(match[1], 10) : 1;
+                const name = match ? match[2].trim() : subContent;
+
+                currentSubunit = {
+                    name,
+                    quantity,
+                    wargear: []
+                };
+
+                if (currentUnit) {
+                    currentUnit.subunits.push(currentSubunit);
+                }
+            }
+            continue;
+        }
+
+        // 3. Model detail line (indented under a subunit), or an "Attached to <Character>"
+        // backlink identifying which character leads this unit
+        if (line.startsWith(' ') || line.startsWith('\t')) {
+            // The target name may carry a "[N]" disambiguation index (e.g.
+            // "Attached to Slaughterbound[3]") when multiple characters in the
+            // list share the same name — New Recruit numbers them by order of
+            // appearance so the backlink can point at the right one.
+            const attachedToMatch = trimmed.match(/^Attached to\s+(.+?)(?:\[(\d+)\])?$/i);
+            if (attachedToMatch) {
+                if (currentUnit) {
+                    currentUnit._attachedToName = attachedToMatch[1].trim();
+                    currentUnit._attachedToOrdinal = attachedToMatch[2] ? parseInt(attachedToMatch[2], 10) : null;
+                }
+                continue;
+            }
+
+            const detailMatch = trimmed.match(/^(\d+)(?:\s+with\s+)?(.*)$/i);
+            if (detailMatch && currentSubunit) {
+                const modelQty = parseInt(detailMatch[1], 10) || 1;
+                const itemsStr = detailMatch[2].trim();
+                const items = itemsStr.split(',').map(s => s.trim()).filter(Boolean);
+
+                items.forEach(it => {
+                    const parsedWg = parseQtyAndName(it, currentUnit ? currentUnit.name : '');
+                    parsedWg.quantity = parsedWg.quantity * modelQty;
+                    addWargear(currentSubunit.wargear, parsedWg);
+                });
+            }
+            continue;
+        }
+
+        // 4. Unit Header line
+        const unitMatch = trimmed.match(/^(?:([a-zA-Z0-9]+):\s*)?(?:(\d+)x?\s+)?(.*?)\s*\((\d+)\s*(?:pts|points|pt)\)(?:\s*:\s*(.*))?$/i);
+        if (unitMatch) {
+            const idPrefix = unitMatch[1] ? unitMatch[1].trim() : '';
+            const quantity = unitMatch[2] ? parseInt(unitMatch[2], 10) : 1;
+            const name = unitMatch[3].trim();
+            const points = parseInt(unitMatch[4], 10) || 0;
+            const inlineDetails = unitMatch[5] ? unitMatch[5].trim() : '';
+
+            let category = 'Other Datasheets';
+            if (idPrefix.toLowerCase().startsWith('char')) {
+                category = 'Characters';
+            }
+
+            currentUnit = {
+                name,
+                points,
+                quantity,
+                category,
+                wargear: [],
+                enhancements: [],
+                subunits: []
+            };
+
+            // Check if is Warlord via header metadata. When the header gave a Char/Infa
+            // ID for the warlord, that ID is authoritative — matching by name alone
+            // would also flag other units sharing that name (e.g. two identically
+            // named characters where only one is the warlord). Only fall back to a
+            // name match when the header didn't supply an ID at all.
+            if (result.metadata.warlordId) {
+                if (idPrefix === result.metadata.warlordId) {
+                    currentUnit.isWarlord = true;
+                }
+            } else if (result.metadata.warlordName && name.toLowerCase() === result.metadata.warlordName.toLowerCase()) {
+                currentUnit.isWarlord = true;
+            }
+
+            if (inlineDetails) {
+                const parts = inlineDetails.split(',').map(s => s.trim()).filter(Boolean);
+                parts.forEach(p => {
+                    if (p.toLowerCase() === 'warlord') {
+                        currentUnit.isWarlord = true;
+                    } else {
+                        addWargear(currentUnit.wargear, parseQtyAndName(p, name));
+                    }
+                });
+            }
+
+            result.units.push(currentUnit);
+            currentSubunit = null; // Reset subunit context
+            continue;
+        }
+    }
+
+    // Merge each unit carrying an "Attached to <Character>" backlink into its
+    // leading character, replacing the character's slot with a combined
+    // { isAttached, attachedParts: [leader, bodyguard] } wrapper (the shape the
+    // renderers already understand from the GW App parser). This format has no
+    // explicit attachment-group section in the source, so the backlink is the
+    // only signal available; matching is done purely by character name, since
+    // it's unambiguous on its own (unlike the forward "Leading X[N]" hint on the
+    // character, which is redundant for merging and is intentionally left unparsed).
+    const consumedCharIndices = new Set();
+    const consumedSquadIndices = new Set();
+    const mergedByCharIndex = new Map();
+
+    result.units.forEach((squadUnit, squadIndex) => {
+        if (!squadUnit._attachedToName) return;
+        const targetName = squadUnit._attachedToName.toLowerCase();
+        const ordinal = squadUnit._attachedToOrdinal;
+
+        let charIndex = -1;
+        if (ordinal) {
+            // The ordinal counts the Nth same-named unit across the whole list
+            // (New Recruit's own numbering), so it must be resolved against
+            // every matching unit in original order, not just unconsumed ones.
+            let occurrence = 0;
+            for (let idx = 0; idx < result.units.length; idx++) {
+                const u = result.units[idx];
+                if (idx !== squadIndex && !u._attachedToName && u.name.toLowerCase() === targetName) {
+                    occurrence++;
+                    if (occurrence === ordinal) {
+                        charIndex = idx;
+                        break;
+                    }
+                }
+            }
+            if (charIndex !== -1 && consumedCharIndices.has(charIndex)) charIndex = -1;
+        } else {
+            charIndex = result.units.findIndex((u, idx) =>
+                idx !== squadIndex &&
+                !consumedCharIndices.has(idx) &&
+                !u._attachedToName &&
+                u.name.toLowerCase() === targetName
+            );
+        }
+        if (charIndex === -1) return;
+
+        const charUnit = result.units[charIndex];
+        delete squadUnit._attachedToName;
+        delete squadUnit._attachedToOrdinal;
+        mergedByCharIndex.set(charIndex, {
+            name: charUnit.name,
+            points: (charUnit.points || 0) + (squadUnit.points || 0),
+            category: 'Attached Units',
+            isAttached: true,
+            attachedParts: [
+                { ...charUnit, role: 'Leader' },
+                { ...squadUnit, role: 'Bodyguard' }
+            ]
+        });
+        consumedCharIndices.add(charIndex);
+        consumedSquadIndices.add(squadIndex);
+    });
+
+    if (mergedByCharIndex.size > 0) {
+        result.units = result.units
+            .map((u, idx) => mergedByCharIndex.get(idx) || u)
+            .filter((u, idx) => !consumedSquadIndices.has(idx));
+    }
+
+    // Clean up the scratch fields from any unmatched (orphaned) backlink
+    result.units.forEach(u => { delete u._attachedToName; delete u._attachedToOrdinal; });
+
+    return result;
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_detector.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_detector.js
new file mode 100644
index 0000000..7e592c4
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_detector.js
@@ -0,0 +1,111 @@
+/**
+ * 11th Edition List Format Detector
+ */
+
+export function detectV11Format(lines) {
+    if (!Array.isArray(lines) || lines.length === 0) return 'UNKNOWN';
+
+    // Check for New Recruit format header (starts with a block of pluses)
+    const firstNonEmptyIndex = lines.findIndex(l => l.trim().length > 0);
+    const hasNrHeader = firstNonEmptyIndex !== -1 && lines[firstNonEmptyIndex].trim().startsWith('+++');
+    if (hasNrHeader) {
+        let headerEndIndex = 0;
+        for (let i = firstNonEmptyIndex + 1; i < lines.length; i++) {
+            if (lines[i].trim().startsWith('+++')) {
+                headerEndIndex = i;
+                break;
+            }
+        }
+
+        const bodyLines = lines.slice(headerEndIndex + 1).map(l => l.trim()).filter(Boolean);
+
+        // Check for the Tournament export style (New Recruit's current name for
+        // what this codebase used to call "WTC-Compact"; the standalone "WTC"
+        // format this used to distinguish from ("NR_WTC") no longer exists as a
+        // New Recruit export option and has been removed).
+        const hasCompactColon = bodyLines.some(l =>
+            /^[A-Za-z0-9:\s•◦\*-]+?\(\d+\s*(?:pts|points|pt)\):\s*\S+/i.test(l)
+        );
+        if (hasCompactColon) {
+            return 'NR_TOURNAMENT';
+        }
+
+        return 'NR_GW';
+    }
+
+    // Check if any line in the file indicates a GW App export
+    const hasGwAppMarker = lines.some(l => 
+        /^Export.*(?:App.*Version|Version.*App)/i.test(l) || 
+        /Version.*D(?:onné|ata|aten|ato)/i.test(l)
+    );
+
+    if (hasGwAppMarker) {
+        return 'GW_APP_V11';
+    }
+
+    // Check if any line indicates a War Organ export
+    const hasWarOrganMarker = lines.some(l => 
+        /warorgan/i.test(l)
+    );
+    if (hasWarOrganMarker) {
+        return 'WAR_ORGAN_V11';
+    }
+
+    const first10NonEmpty = lines
+        .map(l => l.trim())
+        .filter(Boolean)
+        .slice(0, 10);
+
+    if (first10NonEmpty.length >= 3) {
+        const line0 = first10NonEmpty[0];
+        const hasPointsHeader = /^.+?\s*[\[\(]\d+\s*(?:points|pts)[\]\)]$/i.test(line0);
+        
+        const hasBattleSize = first10NonEmpty.some(l => 
+            /^(?:Battle Size:\s*)?(?:Strike Force|Incursion|Onslaught|Combat Patrol|StrikeForce)\s*\(\d+\s*(?:point limit|point|points|pts)\)$/i.test(l)
+        );
+
+        if (hasPointsHeader && hasBattleSize) {
+            return 'WAR_ORGAN_V11';
+        }
+    }
+
+    // Look at first 15 lines for generic V11 headers
+    const first15 = lines
+        .slice(0, 15)
+        .map(l => l.trim().toLowerCase())
+        .filter(Boolean);
+
+    // If it explicitly says 11th Edition or has generic V11 tags
+    const hasGenericV11 = first15.some(l => 
+        l.includes('11th edition') || 
+        l.includes('v11') || 
+        /^\[[^\]]+\]\s+.*?\(\d+\s*(?:pts|points|punkte|puntos|punti)\)$/i.test(l)
+    );
+
+    if (hasGenericV11) {
+        return 'V11_GENERIC';
+    }
+
+    // Fallback detection for GW App if the app version string was omitted
+    const hasFaction = first15.some(l => l.startsWith('faction:'));
+    const hasDetachment = first15.some(l => l.startsWith('detachment:'));
+    if (hasFaction || hasDetachment) {
+        return 'V11_GENERIC';
+    }
+
+    // Heuristics for GW App headers:
+    // e.g. third line is faction (T'au Empire, World Eaters, etc.)
+    // and fourth line is battle size like "Strike Force (2000 points)"
+    const hasBattleSize = first15.some(l => 
+        l.includes('strike force (') || 
+        l.includes('incursion (') || 
+        l.includes('onslaught (') ||
+        /^(?:strike force|incursion|onslaught|force de frappe|fuerza de combate|einsatzverband|forza d'attacco|incursione|scharmützel|assalto|embate|offensive|ansturm)\s*\(\d+\s*(?:pts|points|punkte|puntos|punti)\)/i.test(l) ||
+        (!l.includes('v11') && !l.includes('edition') && !l.includes('faction') && !l.includes('detachment') && /\(\d+\s*(?:pts|points|punkte|puntos|punti)\)/i.test(l))
+    );
+    if (hasBattleSize) {
+        return 'GW_APP_V11';
+    }
+
+    return 'UNKNOWN';
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_parser.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_parser.js
new file mode 100644
index 0000000..801f2b9
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/v11_parser.js
@@ -0,0 +1,160 @@
+import { isWargearSkippable } from '../utils.js';
+
+export function parseV11List(lines, skippableWargearMap = {}) {
+    const result = {
+        edition: '11th',
+        metadata: {
+            title: '',
+            faction: '',
+            detachment: '',
+            pointsLimit: 0,
+            pointsTotal: 0
+        },
+        units: []
+    };
+
+    if (!Array.isArray(lines)) return result;
+
+    let currentUnit = null;
+
+    // Helper to parse quantity and name: e.g. "2x Storm Bolter" -> { name: "Storm Bolter", quantity: 2 }
+    const parseQtyAndName = (str, unitName) => {
+        const cleaned = str.trim();
+        let name = cleaned;
+        let quantity = 1;
+        const match = cleaned.match(/^(\d+)x?\s+(.*)$/i);
+        if (match) {
+            name = match[2].trim();
+            quantity = parseInt(match[1], 10);
+        }
+        const skippable = isWargearSkippable(skippableWargearMap, result.metadata.faction, unitName, name);
+        return {
+            name,
+            quantity,
+            skippable
+        };
+    };
+
+    for (let line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // 1. Parse Metadata / Headers
+        if (trimmed.startsWith('===') && trimmed.endsWith('===')) {
+            result.metadata.title = trimmed.replace(/===/g, '').trim();
+            continue;
+        }
+
+        const metaMatch = trimmed.match(/^(Faction|Facci[oó]n|Fraktion|Fazione|Detachment|D[eé]tachement|Destacamento|Kontingent|Distaccamento|Points|Puntos|Punkte|Punti):\s*(.*)$/i);
+        if (metaMatch) {
+            const rawKey = metaMatch[1].toLowerCase();
+            const val = metaMatch[2].trim();
+            
+            let key = '';
+            if (/^(faction|facci[oó]n|fraktion|fazione)$/i.test(rawKey)) {
+                key = 'faction';
+            } else if (/^(detachment|d[eé]tachement|destacamento|kontingent|distaccamento)$/i.test(rawKey)) {
+                key = 'detachment';
+            } else if (/^(points|puntos|punkte|punti)$/i.test(rawKey)) {
+                key = 'points';
+            }
+
+            if (key === 'faction') {
+                result.metadata.faction = val;
+            } else if (key === 'detachment') {
+                result.metadata.detachment = val;
+            } else if (key === 'points') {
+                // e.g. "1990 / 2000" or "1990"
+                const parts = val.split('/');
+                result.metadata.pointsTotal = parseInt(parts[0].trim(), 10) || 0;
+                if (parts[1]) {
+                    result.metadata.pointsLimit = parseInt(parts[1].trim(), 10) || 0;
+                }
+            }
+            continue;
+        }
+
+        // 2. Parse Unit Header
+        // e.g. "[Leader] Captain in Terminator Armour (95 pts)" or "[Line] 5x Terminator Squad (185 pts)"
+        const unitMatch = trimmed.match(/^\[([^\]]+)\]\s+(?:(\d+)x?\s+)?(.*?)\s*\((\d+)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+        if (unitMatch) {
+            const category = unitMatch[1].trim();
+            const quantity = unitMatch[2] ? parseInt(unitMatch[2], 10) : 1;
+            const name = unitMatch[3].trim();
+            const points = parseInt(unitMatch[4], 10) || 0;
+
+            currentUnit = {
+                name,
+                points,
+                quantity,
+                category,
+                wargear: [],
+                enhancements: [],
+                subunits: []
+            };
+            result.units.push(currentUnit);
+            continue;
+        }
+
+        // If we don't have a unit context yet, skip item parsing
+        if (!currentUnit) continue;
+
+        // 3. Parse Unit Wargear
+        // e.g. "- Wargear: Relic Weapon, Storm Bolter"
+        const wargearPrefixRegex = /^-\s*(wargear|equipement|[eé]quipement|equipo|equipamiento|ausrustung|ausr[uü]stung|equipaggiamento)\s*:/i;
+        if (wargearPrefixRegex.test(trimmed)) {
+            const itemsStr = trimmed.substring(trimmed.indexOf(':') + 1).trim();
+            const items = itemsStr.split(',').map(s => s.trim()).filter(Boolean);
+            items.forEach(it => {
+                currentUnit.wargear.push(parseQtyAndName(it, currentUnit.name));
+            });
+            continue;
+        }
+
+        // 4. Parse Enhancement
+        // e.g. "- Enhancement: Artificer Armour (10 pts)"
+        const enhancementPrefixRegex = /^-\s*(enhancement|optimisation|mejora|aufwertung|verbesserung|potenziamento)\s*:/i;
+        if (enhancementPrefixRegex.test(trimmed)) {
+            const enhContent = trimmed.substring(trimmed.indexOf(':') + 1).trim();
+            const enhMatch = enhContent.match(/^(.*?)\s*\((\d+)\s*(?:pts|points|punkte|puntos|punti)\)$/i);
+            if (enhMatch) {
+                currentUnit.enhancements.push({
+                    name: enhMatch[1].trim(),
+                    points: parseInt(enhMatch[2], 10) || 0
+                });
+            } else {
+                currentUnit.enhancements.push({
+                    name: enhContent,
+                    points: 0
+                });
+            }
+            continue;
+        }
+
+        // 5. Parse Subunits / Models
+        // e.g. "* 1x Terminator Sergeant: Power Weapon, Storm Bolter"
+        // or "* 4x Terminator: 4x Power Fist, 4x Storm Bolter"
+        const subunitMatch = trimmed.match(/^\*\s+(\d+)x?\s+([^:]+):\s*(.*)$/i);
+        if (subunitMatch) {
+            const qty = parseInt(subunitMatch[1], 10) || 1;
+            const subName = subunitMatch[2].trim();
+            const itemsStr = subunitMatch[3].trim();
+            const items = itemsStr.split(',').map(s => s.trim()).filter(Boolean);
+
+            const subunit = {
+                name: subName,
+                quantity: qty,
+                wargear: []
+            };
+
+            items.forEach(it => {
+                subunit.wargear.push(parseQtyAndName(it, currentUnit.name));
+            });
+
+            currentUnit.subunits.push(subunit);
+            continue;
+        }
+    }
+
+    return result;
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/parsers/war_organ_parser.js b/sites/scouting/src/vendor/40k-compactor/modules/parsers/war_organ_parser.js
new file mode 100644
index 0000000..09ac01a
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/parsers/war_organ_parser.js
@@ -0,0 +1,395 @@
+import { isWargearSkippable } from '../utils.js';
+
+export function parseWarOrganV11(lines, skippableWargearMap = {}) {
+    const result = {
+        edition: '11th',
+        metadata: {
+            title: '',
+            armyName: '',
+            pointsTotal: 0,
+            totalPoints: 0,
+            faction: '',
+            battleSize: '',
+            pointsLimit: 0,
+            detachment: '',
+            detachments: [],
+            forceDispositions: []
+        },
+        units: []
+    };
+
+    if (!Array.isArray(lines) || lines.length === 0) return result;
+
+    const cleanLines = lines.map(l => l.trimEnd());
+    const nonEmptyLines = cleanLines.filter(l => l.trim().length > 0);
+
+    if (nonEmptyLines.length < 2) return result;
+
+    // Helper to parse quantity and name: e.g. "2x Storm Bolter" -> { name: "Storm Bolter", quantity: 2 }
+    const parseQtyAndName = (str, unitName) => {
+        const cleaned = str.trim();
+        let name = cleaned;
+        let quantity = 1;
+        const match = cleaned.match(/^(\d+)x?\s+(.*)$/i);
+        if (match) {
+            name = match[2].trim();
+            quantity = parseInt(match[1], 10);
+        }
+        const skippable = isWargearSkippable(skippableWargearMap, result.metadata.faction, unitName, name);
+        return {
+            name,
+            quantity,
+            skippable
+        };
+    };
+
+    // Helper to split wargear items by comma and 'and'
+    const splitWargearItems = (str) => {
+        const normalized = str.replace(/\s+and\s+/ig, ', ');
+        return normalized.split(',').map(s => s.trim()).filter(Boolean).map(item => {
+            // War Organ names some drones after their built-in weapon (e.g. "Gun
+            // drone with twin pulse carbine"); other formats just use the base name
+            // ("Gun Drone"). Keep only the part before "with" so names match across formats.
+            const withMatch = item.match(/^(.*?)\s+with\s+(.*)$/i);
+            return withMatch ? withMatch[1].trim() : item;
+        });
+    };
+
+    // 1. Parse Metadata Headers
+    // Title and Total Points (1st non-empty line)
+    const firstLine = nonEmptyLines[0].trim();
+    const titleMatch = firstLine.match(/^(.+?)\s*[\[\(](\d+)\s*(?:points|pts)[\]\)]$/i);
+    if (titleMatch) {
+        result.metadata.title = titleMatch[1].trim();
+        result.metadata.armyName = titleMatch[1].trim();
+        result.metadata.pointsTotal = parseInt(titleMatch[2], 10) || 0;
+        result.metadata.totalPoints = parseInt(titleMatch[2], 10) || 0;
+    } else {
+        result.metadata.title = firstLine;
+        result.metadata.armyName = firstLine;
+    }
+
+    // Faction (2nd non-empty line)
+    result.metadata.faction = nonEmptyLines[1].trim();
+
+    // Battle Size & Limit (3rd non-empty line)
+    if (nonEmptyLines[2]) {
+        const battleSizeLine = nonEmptyLines[2].trim();
+        const battleMatch = battleSizeLine.match(/^(?:Battle Size:\s*)?(.+?)\s*\((\d+)\s*(?:point limit|point|points|pts)\)$/i);
+        if (battleMatch) {
+            result.metadata.battleSize = battleMatch[1].trim();
+            result.metadata.pointsLimit = parseInt(battleMatch[2], 10) || 0;
+        } else {
+            result.metadata.battleSize = battleSizeLine;
+        }
+    }
+
+    // Detachments (4th non-empty line)
+    if (nonEmptyLines[3]) {
+        const detachmentLine = nonEmptyLines[3].trim();
+        const detMatch = detachmentLine.match(/^(?:Detachments:\s*)(.*)$/i);
+        let detStr = detMatch ? detMatch[1].trim() : detachmentLine;
+        // Strip a trailing "(N Detachment Points)" or "(N/N Detachment Points)" suffix
+        detStr = detStr.replace(/\s*\(\d+(?:\/\d+)?\s*Detachment\s*Points\)\s*$/i, '').trim();
+        result.metadata.detachment = detStr;
+        result.metadata.detachments = detStr.split(',').map(d => d.trim()).filter(Boolean);
+    }
+
+    // Determine scan start index in the original lines array
+    let nonEmptyCount = 0;
+    let scanStartIndex = 0;
+    for (let idx = 0; idx < lines.length; idx++) {
+        if (lines[idx].trim().length > 0) {
+            nonEmptyCount++;
+            if (nonEmptyCount === 4) {
+                scanStartIndex = idx + 1;
+                break;
+            }
+        }
+    }
+
+    // Force Disposition is an optional 5th metadata line (not all exports include it).
+    // Peek at the next non-empty line after Detachments; only consume it if it actually
+    // looks like a Force Disposition line, so files without one fall through to body scanning.
+    for (let idx = scanStartIndex; idx < cleanLines.length; idx++) {
+        const peekTrimmed = cleanLines[idx].trim();
+        if (peekTrimmed.length === 0) continue;
+        const fdMatch = peekTrimmed.match(/^Force\s*Disposition:\s*(.*)$/i);
+        if (fdMatch) {
+            result.metadata.forceDispositions = fdMatch[1].trim().split(',').map(d => d.trim()).filter(Boolean);
+            scanStartIndex = idx + 1;
+        }
+        break;
+    }
+
+    // Category mappings for Format 2
+    const categoryMap = {
+        'CHARACTER': 'Characters',
+        'BATTLELINE': 'Battleline',
+        'DEDICATED TRANSPORTS': 'Dedicated Transports',
+        'OTHER DATASHEETS': 'Other Datasheets',
+        'ALLY CHARACTERS': 'Characters',
+        'ALLY OTHER DATASHEETS': 'Other Datasheets'
+    };
+
+    function guessCategory(unitName) {
+        const name = unitName.toLowerCase();
+        const charKeywords = ['captain', 'canoness', 'hospitaller', 'palatine', 'commander', 'castellan', 'prime', 'lord', 'champion', 'priest', 'inquisitor', 'celestine', 'vahl'];
+        if (charKeywords.some(kw => name.includes(kw))) {
+            return 'Characters';
+        }
+        const transportKeywords = ['rhino', 'chimera', 'imprulsor', 'repulsor', 'land raider', 'drop pod', 'transport', 'devilfish', 'taurox'];
+        if (transportKeywords.some(kw => name.includes(kw))) {
+            return 'Dedicated Transports';
+        }
+        return 'Other Datasheets';
+    }
+
+    // Detect format type (Format 2 has deeper indentation or "Enhancement:" lines).
+    // The category-header check is intentionally case-sensitive (matching categoryMap's
+    // own case-sensitive lookup below): newer War Organ exports generate randomized,
+    // mixed-case "group name" headers for attached units (e.g. "Character", "Vehicle",
+    // "Khorne Trouble Team") that must not be confused with the real ALL-CAPS Format 2
+    // category headers ("CHARACTER", "BATTLELINE", "DEDICATED TRANSPORTS").
+    const isFormat2 = lines.some(l => /^\s*(?:CHARACTER|BATTLELINE|DEDICATED TRANSPORTS|OTHER DATASHEETS)\s*$/.test(l))
+        || lines.some(l => /^\s*•\s*Enhancement:/i.test(l))
+        || !lines.some(l => /^\s*Battle Size:/i.test(l));
+
+    let currentSection = 'Other Datasheets';
+    let currentUnit = null;
+
+    if (isFormat2) {
+        // --- Format 2 (Indented Tree structure) ---
+        let i = scanStartIndex;
+        while (i < cleanLines.length) {
+            const line = cleanLines[i];
+            const trimmed = line.trim();
+            if (!trimmed) {
+                i++;
+                continue;
+            }
+
+            // Check if it's a category header
+            if (categoryMap[trimmed]) {
+                currentSection = categoryMap[trimmed];
+                i++;
+                continue;
+            }
+
+            // Check for unit header, e.g. "Canoness With Jump Pack (85 points)"
+            const unitMatch = trimmed.match(/^(?:(\d+)x?\s+)?(.*?)\s*[\[\(](\d+)\s*(?:points|pts)[\]\)]$/i);
+            if (unitMatch && !trimmed.startsWith('•')) {
+                const qty = unitMatch[1] ? parseInt(unitMatch[1], 10) : 1;
+                const unitName = unitMatch[2].trim();
+                const unitPoints = parseInt(unitMatch[3], 10) || 0;
+
+                currentUnit = {
+                    name: unitName,
+                    points: unitPoints,
+                    quantity: qty,
+                    category: currentSection,
+                    wargear: [],
+                    enhancements: [],
+                    subunits: []
+                };
+                result.units.push(currentUnit);
+                i++;
+
+                // Collect block lines for this unit
+                const blockLines = [];
+                while (i < cleanLines.length) {
+                    const nextLine = cleanLines[i];
+                    const nextTrimmed = nextLine.trim();
+                    if (!nextTrimmed) {
+                        i++;
+                        continue;
+                    }
+
+                    // Stop if we hit another unit header or category header
+                    if (categoryMap[nextTrimmed] || 
+                        (!nextTrimmed.startsWith('•') && nextTrimmed.match(/^(?:(\d+)x?\s+)?(.*?)\s*[\[\(](\d+)\s*(?:points|pts)[\]\)]$/i))) {
+                        break;
+                    }
+
+                    blockLines.push(nextLine);
+                    i++;
+                }
+
+                // Process tree
+                if (blockLines.length > 0) {
+                    const root = { content: 'Root', indent: -1, children: [] };
+                    const stack = [root];
+
+                    blockLines.forEach(bl => {
+                        const leadingSpaces = bl.length - bl.trimStart().length;
+                        const blTrimmed = bl.trim();
+                        const bulletMatch = blTrimmed.match(/^([•◦\u25e6\u2022])\s*(.*)$/);
+                        const hasBullet = !!bulletMatch;
+                        const content = bulletMatch ? bulletMatch[2].trim() : blTrimmed;
+
+                        const node = {
+                            content,
+                            indent: leadingSpaces,
+                            hasBullet,
+                            children: []
+                        };
+
+                        while (stack.length > 1 && stack[stack.length - 1].indent >= node.indent) {
+                            stack.pop();
+                        }
+
+                        stack[stack.length - 1].children.push(node);
+                        stack.push(node);
+                    });
+
+                    // Helper to collect wargear recursively
+                    const collectWargearRecursive = (node, targetArray) => {
+                        const parsed = parseQtyAndName(node.content, currentUnit.name);
+                        targetArray.push(parsed);
+                        node.children.forEach(child => {
+                            collectWargearRecursive(child, targetArray);
+                        });
+                    };
+
+                    // Process Root children (level 1 indentation)
+                    root.children.forEach(node => {
+                        const content = node.content;
+                        const contentLower = content.toLowerCase();
+
+                        if (contentLower === 'warlord') {
+                            currentUnit.isWarlord = true;
+                        } else if (contentLower.startsWith('enhancement:')) {
+                            const enhName = content.substring(content.indexOf(':') + 1).trim();
+                            currentUnit.enhancements.push({
+                                name: enhName,
+                                points: 0
+                            });
+                        } else {
+                            // Subunit if it has bulleted children, otherwise unit-level wargear
+                            const hasChildren = node.children.length > 0;
+                            if (hasChildren) {
+                                const parsedSub = parseQtyAndName(content, currentUnit.name);
+                                const subunit = {
+                                    name: parsedSub.name,
+                                    quantity: parsedSub.quantity,
+                                    wargear: []
+                                };
+                                node.children.forEach(child => {
+                                    collectWargearRecursive(child, subunit.wargear);
+                                });
+                                currentUnit.subunits.push(subunit);
+                            } else {
+                                collectWargearRecursive(node, currentUnit.wargear);
+                            }
+                        }
+                    });
+                }
+                continue;
+            }
+
+            i++;
+        }
+    } else {
+        // --- Format 1 (Flat lists using "with" and "[+XX points]") ---
+        let i = scanStartIndex;
+        while (i < cleanLines.length) {
+            const line = cleanLines[i];
+            const trimmed = line.trim();
+            if (!trimmed) {
+                i++;
+                continue;
+            }
+
+            // Check for unit header
+            const unitMatch = trimmed.match(/^(?:(\d+)x?\s+)?(.*?)\s*[\[\(](\d+)\s*(?:points|pts)[\]\)]$/i);
+            if (unitMatch && !trimmed.startsWith('•')) {
+                const qty = unitMatch[1] ? parseInt(unitMatch[1], 10) : 1;
+                const unitName = unitMatch[2].trim();
+                const unitPoints = parseInt(unitMatch[3], 10) || 0;
+
+                currentUnit = {
+                    name: unitName,
+                    points: unitPoints,
+                    quantity: qty,
+                    category: guessCategory(unitName),
+                    wargear: [],
+                    enhancements: [],
+                    subunits: []
+                };
+                result.units.push(currentUnit);
+                i++;
+
+                while (i < cleanLines.length) {
+                    const nextLine = cleanLines[i];
+                    const nextTrimmed = nextLine.trim();
+                    if (!nextTrimmed) {
+                        i++;
+                        continue;
+                    }
+
+                    // Stop if we hit another unit header
+                    if (!nextTrimmed.startsWith('•') && nextTrimmed.match(/^(?:(\d+)x?\s+)?(.*?)\s*[\[\(](\d+)\s*(?:points|pts)[\]\)]$/i)) {
+                        break;
+                    }
+
+                    const bulletMatch = nextTrimmed.match(/^•\s*(.*)$/);
+                    if (bulletMatch) {
+                        const content = bulletMatch[1].trim();
+                        const contentLower = content.toLowerCase();
+
+                        if (contentLower === 'warlord') {
+                            currentUnit.isWarlord = true;
+                        } else {
+                            // Check if it's a subunit line: e.g. "1 Sacresant Superior with Plasma pistol and Spear of the faithful"
+                            const subunitMatch = content.match(/^(\d+)\s+(.+?)\s+with\s+(.+)$/i);
+                            if (subunitMatch) {
+                                const subQty = parseInt(subunitMatch[1], 10);
+                                const subName = subunitMatch[2].trim();
+                                const subWargearStr = subunitMatch[3].trim();
+
+                                const subunit = {
+                                    name: subName,
+                                    quantity: subQty,
+                                    wargear: []
+                                };
+
+                                const items = splitWargearItems(subWargearStr);
+                                items.forEach(it => {
+                                    // Format 1 wargear items carry a per-model quantity (e.g. "Bolt
+                                    // pistol" implicitly means 1 each); multiply by the subunit's
+                                    // own model count so totals match Format 2's pre-multiplied convention.
+                                    const parsedWg = parseQtyAndName(it, currentUnit.name);
+                                    parsedWg.quantity = parsedWg.quantity * subQty;
+                                    subunit.wargear.push(parsedWg);
+                                });
+
+                                currentUnit.subunits.push(subunit);
+                            } else {
+                                // Unit-level wargear and/or enhancements
+                                const items = splitWargearItems(content);
+                                items.forEach(it => {
+                                    // Check for enhancement tag [+XX points]
+                                    const enhMatch = it.match(/^(.+?)\s*[\[\(]\+(\d+)\s*(?:points|pts)[\]\)]$/i);
+                                    if (enhMatch) {
+                                        currentUnit.enhancements.push({
+                                            name: enhMatch[1].trim(),
+                                            points: parseInt(enhMatch[2], 10) || 0
+                                        });
+                                    } else {
+                                        currentUnit.wargear.push(parseQtyAndName(it, currentUnit.name));
+                                    }
+                                });
+                            }
+                        }
+                    }
+                    i++;
+                }
+                continue;
+            }
+
+            i++;
+        }
+    }
+
+    return result;
+}
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/renderers.js b/sites/scouting/src/vendor/40k-compactor/modules/renderers.js
new file mode 100644
index 0000000..5eb6d40
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/renderers.js
@@ -0,0 +1,784 @@
+// Renderers for 11th Edition JSON structure.
+import { makeAbbrevForName } from './abbreviations.js';
+import factionColors from './faction_colors.js';
+import { sortItemsByQuantityThenName, getModelsCount, getCanonicalFactionName, normalizeWargearName, shouldHideSubunitsForUnit } from './utils.js';
+
+export function abbreviateWords(str) {
+    if (!str) return '';
+    const words = str.split(/\s+/);
+    const lowercaseWords = ['the', 'of', 'in', 'on', 'at', 'for', 'a', 'an', 'to', 'by', 'with', 'and'];
+    const abbr = words.map(w => {
+        const cleaned = w.replace(/[^\w]/g, '');
+        if (!cleaned) return '';
+        const first = cleaned[0];
+        if (lowercaseWords.includes(cleaned.toLowerCase())) {
+            return first.toLowerCase();
+        }
+        return first.toUpperCase();
+    }).join('');
+    return abbr;
+}
+
+export function abbreviateDetachment(detStr) {
+    if (!detStr) return '';
+    const parts = detStr.split(/\s+and\s+/i);
+    return parts.map(p => abbreviateWords(p.trim())).join(' & ');
+}
+
+export function abbreviateForceDisposition(dispStr) {
+    if (!dispStr) return '';
+    const parts = dispStr.split(',');
+    return parts.map(p => abbreviateWords(p.trim())).join(', ');
+}
+
+export const ansiPalette = [
+    { hex: '#000000', code: 30 }, { hex: '#FF0000', code: 31 }, { hex: '#00FF00', code: 32 },
+    { hex: '#FFFF00', code: 33 }, { hex: '#0000FF', code: 34 }, { hex: '#FF00FF', code: 35 },
+    { hex: '#00FFFF', code: 36 }, { hex: '#FFFFFF', code: 37 }, { hex: '#808080', code: 90 }
+];
+
+export const colorNameToHex = {
+    black: '#000000', red: '#FF0000', green: '#00FF00', yellow: '#FFFF00', blue: '#0000FF',
+    magenta: '#FF00FF', cyan: '#00FFFF', white: '#FFFFFF', grey: '#808080'
+};
+
+const hexToRgb = (hex) => {
+    const m = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return m ? { r: parseInt(m[1], 16), g: parseInt(m[2], 16), b: parseInt(m[3], 16) } : null;
+};
+
+const findClosestAnsi = (hex) => {
+    const rgb = hexToRgb(hex);
+    if (!rgb) return 37;
+    let best = 37;
+    let bestD = Infinity;
+    for (const c of ansiPalette) {
+        const cr = hexToRgb(c.hex);
+        const d = Math.pow(rgb.r - cr.r, 2) + Math.pow(rgb.g - cr.g, 2) + Math.pow(rgb.b - cr.b, 2);
+        if (d < bestD) {
+            bestD = d;
+            best = c.code;
+        }
+    }
+    return best;
+};
+
+export function buildFactionColorMap(skippableMap) {
+    const fallback = (map) => {
+        const codes = [...new Set(ansiPalette.map(p => p.code))];
+        const out = {};
+        for (const k of Object.keys(map || {})) {
+            const fk = k || '';
+            const idx = Math.abs(Array.from(fk).reduce((a, c) => a * 31 + c.charCodeAt(0), 0)) % codes.length;
+            const unitCode = codes[idx];
+            const pickDifferent = (forbidden) => codes.find(c => !forbidden.includes(c)) || codes[0];
+            const subunitCode = pickDifferent([unitCode]);
+            const wargearCode = pickDifferent([subunitCode]);
+            const pointsCode = pickDifferent([wargearCode]);
+            const attachedCode = pickDifferent([pointsCode]);
+            const codeToHex = (code) => {
+                const e = ansiPalette.find(p => p.code === code);
+                return e ? e.hex : '#FFFFFF';
+            };
+            out[fk] = { unit: codeToHex(unitCode), subunit: codeToHex(subunitCode), wargear: codeToHex(wargearCode), points: codeToHex(pointsCode), attached: codeToHex(attachedCode) };
+        }
+        return out;
+    };
+    const explicit = factionColors || {};
+    const fromSkippable = fallback(skippableMap || {});
+    const merged = { ...fromSkippable, ...explicit };
+    const normalized = {};
+    const normalizeKey = (s) => {
+        if (!s) return '';
+        try {
+            return s.toString().normalize('NFD')
+                .replace(/\p{M}/gu, '')
+                .replace(/[\u2018\u2019\u201B\u2032]/g, "'")
+                .replace(/[^\w\s'\-]/g, '')
+                .toLowerCase().trim();
+        } catch (e) {
+            return s.toString().toLowerCase().trim();
+        }
+    };
+
+    for (const [k, v] of Object.entries(merged)) {
+        const resolved = {};
+        ['unit', 'subunit', 'wargear', 'points', 'header', 'attached'].forEach(prop => {
+            if (!v || v[prop] === undefined) return;
+            const raw = v[prop];
+            if (typeof raw === 'string' && raw.startsWith('#')) resolved[prop] = raw;
+            else if (typeof raw === 'string' && colorNameToHex[raw.toString().toLowerCase()]) resolved[prop] = colorNameToHex[raw.toString().toLowerCase()];
+            else resolved[prop] = raw;
+        });
+        normalized[k] = resolved;
+        try { normalized[k.toString().toLowerCase()] = resolved; } catch (e) {}
+        try { normalized[normalizeKey(k)] = resolved; } catch (e) {}
+    }
+    return normalized;
+}
+
+function aggregateWargear(unit, excludeSubunits = false) {
+    const aggregated = new Map();
+
+    const addItem = (wg) => {
+        const key = normalizeWargearName(wg.name);
+        const qty = parseInt(wg.quantity || 1, 10);
+        const prev = aggregated.get(key) || { name: wg.name, quantity: 0, skippable: !!wg.skippable };
+        aggregated.set(key, { name: prev.name, quantity: prev.quantity + qty, skippable: prev.skippable || !!wg.skippable });
+    };
+
+    // 1. Add unit's own wargear
+    if (Array.isArray(unit.wargear)) {
+        unit.wargear.forEach(addItem);
+    }
+
+    // 2. Add subunits' wargear
+    if (!excludeSubunits && Array.isArray(unit.subunits)) {
+        unit.subunits.forEach(sub => {
+            if (Array.isArray(sub.wargear)) {
+                sub.wargear.forEach(addItem);
+            }
+        });
+    }
+
+    const wargearList = Array.from(aggregated.values()).map(info => ({
+        name: info.name,
+        quantity: `${info.quantity}x`,
+        skippable: info.skippable,
+        type: 'wargear'
+    }));
+    sortItemsByQuantityThenName(wargearList);
+    return wargearList;
+}
+
+function findAbbreviationForItem(itemName, wargearAbbrMap, dataSummary) {
+    if (!wargearAbbrMap || !itemName) return null;
+    const key = normalizeWargearName(itemName);
+    const extractAbbr = (val) => {
+        if (!val) return null;
+        if (typeof val === 'string') return val;
+        if (typeof val === 'object') return val.abbr || val.ABBR || null;
+        return null;
+    };
+    try {
+        const flat = wargearAbbrMap.__flat_abbr;
+        if (flat && flat[key] !== undefined) return extractAbbr(flat[key]);
+    } catch (e) {}
+    return null;
+}
+
+function getInlineItemsString(unit, useAbbreviations, wargearAbbrMap, dataSummary, skippableWargearMap, showMandatoryWargear = false, hideSubunits = false, wargearShowMode = undefined, hideBrackets = false) {
+    const specials = [];
+    const wargear = [];
+
+    const showMode = wargearShowMode || (showMandatoryWargear ? 'show-all' : 'hide-mandatory');
+
+    // Process enhancements
+    if (Array.isArray(unit.enhancements)) {
+        unit.enhancements.forEach(enh => {
+            let abbr = null;
+            if (useAbbreviations) {
+                abbr = findAbbreviationForItem(enh.name, wargearAbbrMap, dataSummary);
+                if (!abbr) abbr = makeAbbrevForName(enh.name);
+            }
+            const pts = enh.points ? (hideBrackets ? ` +${enh.points}` : ` (+${enh.points})`) : '';
+            specials.push(`E: ${abbr || enh.name}${pts}`);
+        });
+    }
+
+    // Process wargear
+    const itemsToRender = aggregateWargear(unit, !hideSubunits);
+    const visible = itemsToRender.filter(i => {
+        if (showMode === 'show-all') return true;
+        if (showMode === 'hide-all') return false;
+        return !i.skippable;
+    });
+
+    visible.forEach(i => {
+        const qtyNum = parseInt((i.quantity || '1').toString().replace('x', ''), 10) || 1;
+        const qtyPrefix = qtyNum > 1 ? `${i.quantity} ` : '';
+        let abbr = null;
+        if (useAbbreviations) {
+            abbr = findAbbreviationForItem(i.name, wargearAbbrMap, dataSummary);
+            if (!abbr) abbr = makeAbbrevForName(i.name);
+        }
+        wargear.push(`${qtyPrefix}${abbr || i.name}`);
+    });
+
+    const all = [...specials, ...wargear].filter(Boolean);
+    return all.length ? (hideBrackets ? ` ${all.join(', ')}` : ` (${all.join(', ')})`) : '';
+}
+
+function canonicalUnitSignature(unit, hideSubunits) {
+    const normalize = (value) => {
+        if (value === null || typeof value !== 'object') return value;
+        if (Array.isArray(value)) return value.map(normalize);
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (k === '_parent' || k.startsWith('__')) continue;
+            if (k === 'name' && value.isAttached) continue;
+            if (k === 'quantity') {
+                const q = parseInt((v ?? '1').toString().replace('x', ''), 10);
+                out[k] = isNaN(q) ? v : q;
+                continue;
+            }
+            out[k] = normalize(v);
+        }
+        return out;
+    };
+    try {
+        return JSON.stringify(normalize(unit));
+    } catch (e) {
+        return JSON.stringify({ name: unit?.name, points: unit?.points });
+    }
+}
+
+export function maybeCombineUnits(sectionUnits, hideSubunits, enable) {
+    if (!enable || !Array.isArray(sectionUnits)) return sectionUnits;
+    const groups = new Map();
+    for (const u of sectionUnits) {
+        const sig = canonicalUnitSignature(u, hideSubunits);
+        if (!groups.has(sig)) groups.set(sig, []);
+        groups.get(sig).push(u);
+    }
+    const combined = [];
+    for (const [, group] of groups.entries()) {
+        if (group.length === 1) {
+            const single = { ...group[0] };
+            single.__groupCount = 1;
+            single.__unitSize = getModelsCount(single);
+            if (single.isAttached && Array.isArray(single.attachedParts)) {
+                single.attachedParts = single.attachedParts.map(part => {
+                    const p = { ...part };
+                    p.__groupCount = 1;
+                    p.__unitSize = getModelsCount(p);
+                    return p;
+                });
+            }
+            combined.push(single);
+            continue;
+        }
+        const template = { ...group[0] };
+        const unitSize = getModelsCount(template);
+        template.__groupCount = group.length;
+        template.__unitSize = unitSize;
+        if (template.isAttached && Array.isArray(template.attachedParts)) {
+            template.attachedParts = template.attachedParts.map(part => {
+                const p = { ...part };
+                p.__groupCount = group.length;
+                p.__unitSize = getModelsCount(p);
+                return p;
+            });
+        }
+        combined.push(template);
+    }
+    return combined;
+}
+
+function getRoleTag(part, index, hideBrackets = false) {
+    if (!part) return '';
+    const roleLower = (part.role || '').toLowerCase();
+    const attachedLower = (part.attachedAs || '').toLowerCase();
+    const suffix = index !== undefined ? index : '';
+    
+    const isLeader = (str) => /leader|meneur|l[ií]der|anfuehrer|anführer|capo|comandante/i.test(str);
+    const isBodyguard = (str) => /bodyguard|gardes?\s+du\s+corps|escolta|leibwaechter|leibwächter|guardia\s+del\s+corpo/i.test(str);
+    const isSupport = (str) => /support/i.test(str);
+
+    if (isLeader(roleLower) || isLeader(attachedLower)) return hideBrackets ? `L${suffix}` : `[L${suffix}]`;
+    if (isSupport(roleLower) || isSupport(attachedLower)) return hideBrackets ? `S${suffix}` : `[S${suffix}]`;
+    if (isBodyguard(roleLower) || isBodyguard(attachedLower)) return hideBrackets ? `B${suffix}` : `[B${suffix}]`;
+    return '';
+}
+
+export function getWarlordTag(unit, hideBrackets = false) {
+    return unit && unit.isWarlord ? (hideBrackets ? 'W' : '[W]') : '';
+}
+
+export function generateOutput(data, useAbbreviations, wargearAbbrMap, hideSubunits, skippableWargearMap, applyHeaderColor = true, combineIdenticalUnits = false, noBullets = false, hidePoints = false, abbreviateHeader = false, showMandatoryWargear = false, wargearShowMode = undefined, abbreviateUnitNames = false, hideBrackets = false) {
+    let html = '', plainText = '';
+    const showMode = wargearShowMode || (showMandatoryWargear ? 'show-all' : 'hide-mandatory');
+    const summary = data.metadata || {};
+
+    const headerParts = [];
+    const listName = summary.title || summary.armyName || '';
+    if (listName) headerParts.push(listName);
+    if (summary.faction) headerParts.push(summary.faction);
+    
+    let dets = '';
+    if (Array.isArray(summary.detachments) && summary.detachments.length > 0) {
+        if (abbreviateHeader) {
+            dets = summary.detachments.map(d => abbreviateWords(d)).join(' & ');
+        } else {
+            dets = summary.detachments.join(' and ');
+        }
+    } else if (summary.detachment) {
+        if (abbreviateHeader) {
+            dets = abbreviateDetachment(summary.detachment);
+        } else {
+            dets = summary.detachment;
+        }
+    }
+    if (dets) headerParts.push(dets);
+    
+    let disps = '';
+    if (Array.isArray(summary.forceDispositions) && summary.forceDispositions.length > 0) {
+        if (abbreviateHeader) {
+            disps = summary.forceDispositions.map(d => abbreviateWords(d)).join(', ');
+        } else {
+            disps = summary.forceDispositions.join(', ');
+        }
+    } else if (summary.forceDisposition) {
+        if (abbreviateHeader) {
+            disps = abbreviateForceDisposition(summary.forceDisposition);
+        } else {
+            disps = summary.forceDisposition;
+        }
+    }
+    if (disps) headerParts.push(disps);
+
+    const totalPts = summary.pointsTotal || summary.totalPoints || 0;
+    if (totalPts) {
+        const limit = summary.pointsLimit || 0;
+        const limitStr = limit ? ` / ${limit}pts` : 'pts';
+        headerParts.push(`${totalPts}${limitStr}`);
+    }
+
+    if (headerParts.length) {
+        const summaryText = headerParts.join(' | ');
+        let styleColor = 'color:var(--color-text-secondary);';
+        if (applyHeaderColor) {
+            let headerColor = null;
+            try {
+                const fm = buildFactionColorMap(skippableWargearMap || {});
+                const rawFaction = summary.faction || null;
+                const fk = getCanonicalFactionName(rawFaction);
+                const normalizeKeyLookup = (s) => {
+                    if (!s) return null;
+                    try { return s.toString().normalize('NFD').replace(/\p{M}/gu, '').replace(/[\u2018\u2019\u201B\u2032]/g, "'").replace(/[^\w\s'\-]/g, '').toLowerCase().trim(); } catch (e) { return s.toString().toLowerCase(); }
+                };
+                const fmEntry = fk ? (fm[fk] || fm[fk.toString().toLowerCase()] || fm[normalizeKeyLookup(fk)]) : null;
+                if (fmEntry && fmEntry.header) headerColor = fmEntry.header;
+            } catch (e) {}
+            styleColor = headerColor ? `color:${headerColor};` : 'color:var(--color-text-secondary);';
+        }
+        html += `<div style="padding-bottom:0.5rem;border-bottom:1px solid var(--color-border);"><p style="font-size:0.75rem;margin-bottom:0.25rem;${styleColor}font-weight:600;">${summaryText}</p></div>`;
+        plainText += summaryText + '\n\n';
+    }
+
+    html += `<div style="margin-top:0.5rem;">`;
+    const UNIT_BULLET = noBullets ? '' : '• ';
+
+    const rawUnits = Array.isArray(data.units) ? data.units : [];
+    const units = maybeCombineUnits(rawUnits, hideSubunits, combineIdenticalUnits);
+
+    const renderUnit = (unit, prefix = '') => {
+        let outHtml = '', outPlain = '';
+        const hideSubunitsForThisUnit = hideSubunits || shouldHideSubunitsForUnit(unit, showMode);
+        const G = (unit.__groupCount !== undefined) ? unit.__groupCount : 1;
+        const M = (unit.__unitSize !== undefined) ? unit.__unitSize : getModelsCount(unit);
+        let qtyDisplay = '';
+        if (G > 1) {
+            qtyDisplay = M > 1 ? `${G}x${M} ` : `${G}x `;
+        } else {
+            qtyDisplay = M > 1 ? `${M} ` : '';
+        }
+
+        const categorySuffix = '';
+
+        if (useAbbreviations) {
+            const itemsString = getInlineItemsString(unit, useAbbreviations, wargearAbbrMap, summary, skippableWargearMap, showMandatoryWargear, hideSubunitsForThisUnit, showMode, hideBrackets);
+            const pointsString = hidePoints ? '' : (hideBrackets ? ` ${unit.points}` : ` [${unit.points}]`);
+            const finalUnitName = abbreviateUnitNames ? (findAbbreviationForItem(unit.name, wargearAbbrMap, summary) || makeAbbrevForName(unit.name)) : unit.name;
+            const unitText = `${prefix}${qtyDisplay}${finalUnitName}${categorySuffix}${itemsString}${pointsString}`;
+            outHtml += `<div><p style="color:var(--color-text-primary);font-weight:600;font-size:0.875rem;margin-bottom:0.25rem;">${unitText}</p>`;
+            outPlain += `${UNIT_BULLET}${unitText}\n`;
+
+            if (!hideSubunitsForThisUnit && Array.isArray(unit.subunits) && unit.subunits.length > 0) {
+                outHtml += `<div style="padding-left:1rem;font-size:0.75rem;color:var(--color-text-secondary);font-weight:400;">`;
+                unit.subunits.forEach(sub => {
+                    const subQty = parseInt((sub.quantity || '1').toString().replace('x', ''), 10) || 1;
+                    const subQtyDisplay = subQty > 1 ? `${subQty} ` : '';
+                    
+                    const filteredItems = (sub.wargear || []).filter(wg => {
+                        if (showMode === 'show-all') return true;
+                        if (showMode === 'hide-all') return false;
+                        return !wg.skippable;
+                    });
+                    
+                    let subItemsText = '';
+                    if (filteredItems.length > 0) {
+                        const subItemsArr = filteredItems.map(wg => {
+                            const wgQty = parseInt(wg.quantity || 1, 10);
+                            const qtyStr = wgQty > 1 ? `${wgQty}x ` : '';
+                            let abbr = null;
+                            abbr = findAbbreviationForItem(wg.name, wargearAbbrMap, summary);
+                            if (!abbr) abbr = makeAbbrevForName(wg.name);
+                            return `${qtyStr}${abbr || wg.name}`;
+                        });
+                        subItemsText = hideBrackets ? ` ${subItemsArr.join(', ')}` : ` (${subItemsArr.join(', ')})`;
+                    }
+                    
+                    const finalSubName = abbreviateUnitNames ? (findAbbreviationForItem(sub.name, wargearAbbrMap, summary) || makeAbbrevForName(sub.name)) : sub.name;
+                    outHtml += `<p style="font-weight:500;color:var(--color-text-primary);margin:0;">${subQtyDisplay}${finalSubName}${subItemsText}</p>`;
+                    outPlain += `  * ${subQtyDisplay}${finalSubName}${subItemsText}\n`;
+                });
+                outHtml += `</div>`;
+            }
+            outHtml += `</div>`;
+            return { html: outHtml, plainText: outPlain };
+        }
+
+        const pointsString = hidePoints ? '' : (hideBrackets ? ` ${unit.points}` : ` [${unit.points}]`);
+        const finalUnitName = (useAbbreviations && abbreviateUnitNames) ? (findAbbreviationForItem(unit.name, wargearAbbrMap, summary) || makeAbbrevForName(unit.name)) : unit.name;
+        const unitText = `${prefix}${qtyDisplay}${finalUnitName}${categorySuffix}${pointsString}`;
+        outHtml += `<div><p style="color:var(--color-text-primary);font-weight:600;font-size:0.875rem;margin-bottom:0.25rem;">${unitText}</p>`;
+        outPlain += `${UNIT_BULLET}${unitText}\n`;
+
+        if (hideSubunitsForThisUnit) {
+            const aggregated = aggregateWargear(unit);
+            const visibleAggregated = aggregated.filter(it => {
+                if (showMode === 'show-all') return true;
+                if (showMode === 'hide-all') return false;
+                return !it.skippable;
+            });
+            if (visibleAggregated.length > 0) {
+                outHtml += `<div style="padding-left:1rem;font-size:0.75rem;color:var(--color-text-secondary);font-weight:400;">`;
+                visibleAggregated.forEach(it => {
+                    outHtml += `<p style="margin:0;">${it.quantity} ${it.name}</p>`;
+                    outPlain += `  - ${it.quantity} ${it.name}\n`;
+                });
+                outHtml += `</div>`;
+            }
+        } else {
+            // Render enhancements
+            if (Array.isArray(unit.enhancements) && unit.enhancements.length > 0) {
+                outHtml += `<div style="padding-left:1rem;font-size:0.75rem;color:var(--color-text-secondary);font-weight:400;">`;
+                unit.enhancements.forEach(enh => {
+                    const ptsStr = enh.points ? ` (+${enh.points})` : '';
+                    outHtml += `<p style="margin:0;">Enhancement: ${enh.name}${ptsStr}</p>`;
+                    outPlain += `  - Enhancement: ${enh.name}${ptsStr}\n`;
+                });
+                outHtml += `</div>`;
+            }
+
+            // Render top-level wargear
+            if (Array.isArray(unit.wargear) && unit.wargear.length > 0) {
+                const visibleWargear = unit.wargear.filter(wg => {
+                    if (showMode === 'show-all') return true;
+                    if (showMode === 'hide-all') return false;
+                    return !wg.skippable;
+                });
+                if (visibleWargear.length > 0) {
+                    outHtml += `<div style="padding-left:1rem;font-size:0.75rem;color:var(--color-text-secondary);font-weight:400;">`;
+                    visibleWargear.forEach(wg => {
+                        const wgQty = parseInt(wg.quantity || 1, 10);
+                        const qtyStr = wgQty > 1 ? `${wgQty}x ` : '';
+                        outHtml += `<p style="margin:0;">${qtyStr}${wg.name}</p>`;
+                        outPlain += `  - ${qtyStr}${wg.name}\n`;
+                    });
+                    outHtml += `</div>`;
+                }
+            }
+
+            // Render subunits
+            if (Array.isArray(unit.subunits) && unit.subunits.length > 0) {
+                outHtml += `<div style="padding-left:1rem;font-size:0.75rem;color:var(--color-text-secondary);font-weight:400;">`;
+                unit.subunits.forEach(sub => {
+                    const subQty = parseInt(sub.quantity || 1, 10);
+                    const qtyStr = subQty > 1 ? `${subQty}x ` : '';
+                    
+                    const visibleWargear = (sub.wargear || []).filter(wg => {
+                        if (showMode === 'show-all') return true;
+                        if (showMode === 'hide-all') return false;
+                        return !wg.skippable;
+                    });
+                    
+                    const finalSubName = (useAbbreviations && abbreviateUnitNames) ? (findAbbreviationForItem(sub.name, wargearAbbrMap, summary) || makeAbbrevForName(sub.name)) : sub.name;
+                    outHtml += `<p style="font-weight:500;color:var(--color-text-primary);margin:0;">${qtyStr}${finalSubName}</p>`;
+                    outPlain += `  * ${qtyStr}${finalSubName}\n`;
+
+                    visibleWargear.forEach(wg => {
+                        const wgQty = parseInt(wg.quantity || 1, 10);
+                        const wqtyStr = wgQty > 1 ? `${wgQty}x ` : '';
+                        outHtml += `<p style="margin:0 0 0.125rem 1rem;">${wqtyStr}${wg.name}</p>`;
+                        outPlain += `    - ${wqtyStr}${wg.name}\n`;
+                    });
+                });
+                outHtml += `</div>`;
+            }
+        }
+        outHtml += `</div>`;
+        return { html: outHtml, plainText: outPlain };
+    };
+
+    let attachedIndex = 0;
+    units.forEach(unit => {
+        if (unit.isAttached) {
+            attachedIndex++;
+            unit.attachedParts.forEach(part => {
+                const tag = getRoleTag(part, attachedIndex, hideBrackets);
+                const wTag = getWarlordTag(part, hideBrackets);
+                const tags = [tag, wTag].filter(Boolean).join('');
+                const prefix = tags ? `${tags} ` : '';
+                const rendered = renderUnit(part, prefix);
+                html += rendered.html;
+                plainText += rendered.plainText;
+            });
+        } else {
+            const wTag = getWarlordTag(unit, hideBrackets);
+            const prefix = wTag ? `${wTag} ` : '';
+            const rendered = renderUnit(unit, prefix);
+            html += rendered.html;
+            plainText += rendered.plainText;
+        }
+    });
+
+
+
+    html += `</div>`;
+    return { html, plainText };
+}
+
+export function generateDiscordText(data, plain, useAbbreviations = true, wargearAbbrMap, hideSubunits, skippableWargearMap, combineIdenticalUnits = false, options, noBullets = false, hidePoints = false) {
+    const hasDOM = (typeof document !== 'undefined' && document.querySelector);
+    let useColor = false;
+    const defaultColors = { unit: '#FFFFFF', subunit: '#808080', wargear: '#FFFFFF', points: '#FFFF00', header: '#FFFF00', attached: '#FFFF00' };
+    const colors = { ...defaultColors };
+    const summary = data.metadata || {};
+    const hideBrackets = !!(options && options.hideBrackets);
+
+    if (!plain) {
+        const mode = (options && options.colorMode) || (hasDOM ? ((document.querySelector('input[name="colorMode"]:checked') || {}).value || 'none') : 'none');
+        useColor = mode && mode !== 'none';
+        if (useColor && mode === 'custom') {
+            if (options && options.colors) {
+                const src = options.colors || {};
+                if (src.unit) colors.unit = src.unit;
+                if (src.subunit) colors.subunit = src.subunit;
+                if (src.wargear) colors.wargear = src.wargear;
+                if (src.points) colors.points = src.points;
+                if (src.header) colors.header = src.header;
+                if (src.attached) colors.attached = src.attached;
+            } else if (hasDOM) {
+                const u = document.getElementById('unitColor');
+                const s = document.getElementById('subunitColor');
+                const w = document.getElementById('wargearColor');
+                const p = document.getElementById('pointsColor');
+                const h = document.getElementById('headerColor');
+                const a = document.getElementById('attachedColor');
+                if (u && u.value) colors.unit = u.value;
+                if (s && s.value) colors.subunit = s.value;
+                if (w && w.value) colors.wargear = w.value;
+                if (p && p.value) colors.points = p.value;
+                if (h && h.value) colors.header = h.value;
+                if (a && a.value) colors.attached = a.value;
+            }
+        }
+        if (useColor && mode === 'faction') {
+            const factionMap = buildFactionColorMap(skippableWargearMap || {});
+            const rawFaction = summary.faction || null;
+            const factionKey = getCanonicalFactionName(rawFaction);
+            const normalizeKeyLookup = (s) => {
+                if (!s) return null;
+                try { return s.toString().normalize('NFD').replace(/\p{M}/gu, '').replace(/[\u2018\u2019\u201B\u2032]/g, "'").replace(/[^\w\s'\-]/g, '').toLowerCase().trim(); } catch (e) { return s.toString().toLowerCase(); }
+            };
+            const nfk = factionKey ? normalizeKeyLookup(factionKey) : null;
+            if (factionKey && (factionMap[factionKey] || factionMap[factionKey.toString().toLowerCase()] || (nfk && factionMap[nfk]))) {
+                const fm = factionMap[factionKey] || factionMap[factionKey.toString().toLowerCase()] || factionMap[nfk];
+                if (fm.unit) colors.unit = fm.unit;
+                if (fm.subunit) colors.subunit = fm.subunit;
+                if (fm.wargear) colors.wargear = fm.wargear;
+                if (fm.points) colors.points = fm.points;
+                if (fm.header) colors.header = fm.header;
+                if (fm.attached) colors.attached = fm.attached;
+            }
+        }
+    }
+
+    const toAnsi = (txt, hex, bold = false) => {
+        if (!useColor || !hex) return txt;
+        if (typeof hex === 'number' || (typeof hex === 'string' && /^\d+$/.test(hex))) {
+             const boldPart = bold ? '1;' : '';
+             return `\u001b[${boldPart}${hex}m${txt}\u001b[0m`;
+        }
+        const forcePalette = !!(options && options.forcePalette);
+        if (hasDOM && !forcePalette) {
+            const rgb = hexToRgb(hex);
+            if (!rgb) return txt;
+            const boldPart = bold ? '1;' : '';
+            return `\u001b[${boldPart}38;2;${rgb.r};${rgb.g};${rgb.b}m${txt}\u001b[0m`;
+        }
+        const code = findClosestAnsi(hex);
+        const boldPart = bold ? '1;' : '';
+        return `\u001b[${boldPart}${code}m${txt}\u001b[0m`;
+    };
+
+    const UNIT_BULLET = noBullets ? '' : (plain ? '• ' : '* ');
+    const SUB_BULLET = noBullets ? '  ' : (plain ? '  ◦ ' : '  + ');
+
+    const abbreviateHeader = !!(options && options.abbreviateHeader);
+    const showMandatoryWargear = !!(options && options.showMandatoryWargear);
+    const showMode = (options && options.wargearShowMode) || (showMandatoryWargear ? 'show-all' : 'hide-mandatory');
+    let out = '';
+    if (!plain) out += useColor ? '```ansi\n' : '```\n';
+
+    const headerParts = [];
+    const listName = summary.title || summary.armyName || '';
+    if (listName) headerParts.push(listName);
+    if (summary.faction) headerParts.push(summary.faction);
+    
+    let dets = '';
+    if (Array.isArray(summary.detachments) && summary.detachments.length > 0) {
+        if (abbreviateHeader) {
+            dets = summary.detachments.map(d => abbreviateWords(d)).join(' & ');
+        } else {
+            dets = summary.detachments.join(' and ');
+        }
+    } else if (summary.detachment) {
+        if (abbreviateHeader) {
+            dets = abbreviateDetachment(summary.detachment);
+        } else {
+            dets = summary.detachment;
+        }
+    }
+    if (dets) headerParts.push(dets);
+    
+    let disps = '';
+    if (Array.isArray(summary.forceDispositions) && summary.forceDispositions.length > 0) {
+        if (abbreviateHeader) {
+            disps = summary.forceDispositions.map(d => abbreviateWords(d)).join(', ');
+        } else {
+            disps = summary.forceDispositions.join(', ');
+        }
+    } else if (summary.forceDisposition) {
+        if (abbreviateHeader) {
+            disps = abbreviateForceDisposition(summary.forceDisposition);
+        } else {
+            disps = summary.forceDisposition;
+        }
+    }
+    if (disps) headerParts.push(disps);
+
+    const totalPts = summary.pointsTotal || summary.totalPoints || 0;
+    if (totalPts) {
+        const limit = summary.pointsLimit || 0;
+        const limitStr = limit ? ` / ${limit}pts` : 'pts';
+        headerParts.push(`${totalPts}${limitStr}`);
+    }
+
+    if (headerParts.length) {
+        const multiline = (options && options.multilineHeader !== undefined) ? options.multilineHeader : false;
+        const header = headerParts.join(multiline ? '\n' : ' | ');
+        out += useColor ? toAnsi(header, colors.header, true) + '\n\n' : header + '\n\n';
+    }
+
+    const rawUnits = Array.isArray(data.units) ? data.units : [];
+    const units = maybeCombineUnits(rawUnits, hideSubunits, combineIdenticalUnits);
+
+    const renderDiscordUnit = (unit, prefixText = '') => {
+        const hideSubunitsForThisUnit = hideSubunits || shouldHideSubunitsForUnit(unit, showMode);
+        const G = (unit.__groupCount !== undefined) ? unit.__groupCount : 1;
+        const M = (unit.__unitSize !== undefined) ? unit.__unitSize : getModelsCount(unit);
+        let qtyDisplay = '';
+        if (G > 1) {
+            qtyDisplay = M > 1 ? `${G}x${M} ` : `${G}x `;
+        } else {
+            qtyDisplay = M > 1 ? `${M} ` : '';
+        }
+
+        const categorySuffix = '';
+
+        const itemsString = getInlineItemsString(unit, useAbbreviations, wargearAbbrMap, summary, skippableWargearMap, showMandatoryWargear, hideSubunitsForThisUnit, showMode, hideBrackets);
+
+        const abbreviateUnitNames = !!(options && options.abbreviateUnitNames);
+        const finalUnitName = (useAbbreviations && abbreviateUnitNames) ? (findAbbreviationForItem(unit.name, wargearAbbrMap, summary) || makeAbbrevForName(unit.name)) : unit.name;
+
+        const unitNameText = useColor ? toAnsi(finalUnitName, colors.unit, true) : finalUnitName;
+        const unitText = `${prefixText}${qtyDisplay}${unitNameText}${categorySuffix}`;
+        const itemsText = (useColor && itemsString) ? toAnsi(itemsString, colors.wargear, false) : itemsString;
+        const pointsRaw = hideBrackets ? `${unit.points}` : `[${unit.points}]`;
+        const pointsText = useColor ? toAnsi(pointsRaw, colors.points, true) : pointsRaw;
+
+        let line = `${UNIT_BULLET}${unitText}${itemsText}`;
+        if (!hidePoints) {
+            line += ` ${pointsText}`;
+        }
+        out += `${line}\n`;
+
+        if (!hideSubunitsForThisUnit && Array.isArray(unit.subunits)) {
+            unit.subunits.forEach(sub => {
+                const subQty = parseInt((sub.quantity || '1').toString().replace('x', ''), 10) || 1;
+                const subQtyDisplay = subQty > 1 ? `${subQty} ` : '';
+                const finalSubName = (useAbbreviations && abbreviateUnitNames) ? (findAbbreviationForItem(sub.name, wargearAbbrMap, summary) || makeAbbrevForName(sub.name)) : sub.name;
+                const subRaw = `${subQtyDisplay}${finalSubName}`;
+                const subName = useColor ? toAnsi(subRaw, colors.subunit, false) : subRaw;
+
+                const filteredItems = (sub.wargear || []).filter(wg => {
+                    if (showMode === 'show-all') return true;
+                    if (showMode === 'hide-all') return false;
+                    return !wg.skippable;
+                });
+
+                if (filteredItems.length === 0) {
+                    out += `${SUB_BULLET}${subName}\n`;
+                    return;
+                }
+
+                // Format subunit wargear
+                const subItemsArr = filteredItems.map(wg => {
+                    const wgQty = parseInt(wg.quantity || 1, 10);
+                    const qtyStr = wgQty > 1 ? `${wgQty}x ` : '';
+                    let abbr = null;
+                    if (useAbbreviations) {
+                        abbr = findAbbreviationForItem(wg.name, wargearAbbrMap, summary);
+                        if (!abbr) abbr = makeAbbrevForName(wg.name);
+                    }
+                    return `${qtyStr}${abbr || wg.name}`;
+                });
+                const subItems = hideBrackets ? ` ${subItemsArr.join(', ')}` : ` (${subItemsArr.join(', ')})`;
+                const subItemsText = (useColor && subItems) ? toAnsi(subItems, colors.wargear, false) : subItems;
+                out += `${SUB_BULLET}${subName}${subItemsText}\n`;
+            });
+        }
+    };
+
+    let attachedIndex = 0;
+    units.forEach(unit => {
+        if (unit.isAttached) {
+            attachedIndex++;
+            unit.attachedParts.forEach(part => {
+                const tag = getRoleTag(part, attachedIndex, hideBrackets);
+                const wTag = getWarlordTag(part, hideBrackets);
+                const tagText = useColor ? toAnsi(tag, colors.attached, true) : tag;
+                const wTagText = useColor && wTag ? toAnsi(wTag, colors.attached, true) : wTag;
+                const parts = [tagText, wTagText].filter(Boolean);
+                const prefixText = parts.length ? `${parts.join('')} ` : '';
+                renderDiscordUnit(part, prefixText);
+            });
+        } else {
+            const wTag = getWarlordTag(unit, hideBrackets);
+            const wTagText = useColor && wTag ? toAnsi(wTag, colors.attached, true) : wTag;
+            const prefixText = wTag ? `${wTagText} ` : '';
+            renderDiscordUnit(unit, prefixText);
+        }
+    });
+
+    if (!plain) out += '```';
+    return out;
+}
+
+export function resolveFactionColors(data, skippableWargearMap) {
+    const factionMap = buildFactionColorMap(skippableWargearMap || {});
+    const summary = data.metadata || {};
+    const rawFaction = summary.faction || null;
+    const factionKey = getCanonicalFactionName(rawFaction);
+    if (!factionKey) return null;
+    const normalizeKeyLookup = (s) => {
+        if (!s) return null;
+        try { return s.toString().normalize('NFD').replace(/\p{M}/gu, '').replace(/[\u2018\u2019\u201B\u2032]/g, "'").replace(/[^\w\s'\-]/g, '').toLowerCase().trim(); } catch (e) { return s.toString().toLowerCase(); }
+    };
+    const nfk = normalizeKeyLookup(factionKey);
+    const fm = factionMap[factionKey] || factionMap[factionKey.toString().toLowerCase()] || (nfk && factionMap[nfk]);
+    return fm || null;
+}
\ No newline at end of file
diff --git a/sites/scouting/src/vendor/40k-compactor/modules/utils.js b/sites/scouting/src/vendor/40k-compactor/modules/utils.js
new file mode 100644
index 0000000..3f9610a
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/modules/utils.js
@@ -0,0 +1,524 @@
+// Normalize a wargear name for comparison/grouping purposes. Treats hyphens the same
+// as spaces so inconsistent source formatting (e.g. "Close Combat Weapon" vs
+// "Close-Combat Weapon") is recognized as the same item.
+export function normalizeWargearName(name) {
+    if (!name) return '';
+    let normalized = name.toString().replace(/[\u2018\u2019\u201B\u2032]/g, "'");
+    try {
+        normalized = normalized.normalize('NFD').replace(/\p{M}/gu, '');
+    } catch (e) {}
+    return normalized
+        .replace(/-/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+
+// Sort wargear/special item arrays in-place: descending numeric quantity, then by name (A-Z)
+export function sortItemsByQuantityThenName(items) {
+    if (!Array.isArray(items)) return items;
+    items.sort((a, b) => {
+        const aq = parseInt(String((a && a.quantity) || '1x').replace(/x/i, ''), 10) || 1;
+        const bq = parseInt(String((b && b.quantity) || '1x').replace(/x/i, ''), 10) || 1;
+        // descending quantity
+        if (aq !== bq) return bq - aq;
+        const an = (a && a.name) ? a.name.toString().toLowerCase() : '';
+        const bn = (b && b.name) ? b.name.toString().toLowerCase() : '';
+        if (an < bn) return -1;
+        if (an > bn) return 1;
+        return 0;
+    });
+    return items;
+}
+
+export function getCanonicalFactionName(faction) {
+    if (!faction) return faction;
+
+    // Combined "Parent - Subfaction" strings (e.g. "Space Marines - Dark Angels")
+    // should resolve off the subfaction segment, since that's the more specific
+    // identity for coloring/skippable-wargear lookups.
+    const combinedMatch = faction.toString().match(/^(.+?)\s+-\s+(.+)$/);
+    if (combinedMatch) {
+        return getCanonicalFactionName(combinedMatch[2].trim());
+    }
+
+    // Normalize curly apostrophes to straight ones
+    let normalized = faction.toString()
+        .replace(/[\u2018\u2019\u201B\u2032]/g, "'");
+    
+    // Normalize text (remove accents/diacritics)
+    try {
+        normalized = normalized.normalize('NFD').replace(/\p{M}/gu, '');
+    } catch (e) {
+        // Fallback
+    }
+    
+    normalized = normalized.toLowerCase().trim();
+    
+    const mapping = {
+        // T'au Empire
+        "empire t'au": "T'au Empire",
+        "imperio t'au": "T'au Empire",
+        "t'au-imperium": "T'au Empire",
+        "tau-imperium": "T'au Empire",
+        "tau imperium": "T'au Empire",
+        "impero t'au": "T'au Empire",
+        "sternenreich der t'au": "T'au Empire",
+        "sternenreich der tau": "T'au Empire",
+        "t'au empire": "T'au Empire",
+        "tau empire": "T'au Empire",
+        "imperio tau": "T'au Empire",
+        "impero tau": "T'au Empire",
+
+        // Chaos Daemons
+        "demons du chaos": "Chaos Daemons",
+        "demonios del caos": "Chaos Daemons",
+        "chaosdaemonen": "Chaos Daemons",
+        "chaos-daemonen": "Chaos Daemons",
+        "chaosdämonen": "Chaos Daemons",
+        "chaos-dämonen": "Chaos Daemons",
+        "demoni del caos": "Chaos Daemons",
+        "chaos daemons": "Chaos Daemons",
+
+        // Genestealer Cults
+        "cultes genestealers": "Genestealer Cults",
+        "culte genestealers": "Genestealer Cults",
+        "cultos genestealer": "Genestealer Cults",
+        "culto genestealer": "Genestealer Cults",
+        "symbiontenkulte": "Genestealer Cults",
+        "symbiontenkult": "Genestealer Cults",
+        "culti di genestealer": "Genestealer Cults",
+        "culto dei genestealer": "Genestealer Cults",
+        "culti dei genestealer": "Genestealer Cults",
+        "genestealer cults": "Genestealer Cults",
+
+        // Grey Knights
+        "chevaliers gris": "Grey Knights",
+        "caballeros grises": "Grey Knights",
+        "graue ritter": "Grey Knights",
+        "cavalieri grigi": "Grey Knights",
+        "grey knights": "Grey Knights",
+
+        // Imperial Knights
+        "chevaliers imperiaux": "Imperial Knights",
+        "caballeros imperiales": "Imperial Knights",
+        "imperiale ritter": "Imperial Knights",
+        "cavalieri imperiali": "Imperial Knights",
+        "imperial knights": "Imperial Knights",
+
+        // Leagues of Votann
+        "ligues de votann": "Leagues of Votann",
+        "ligas de votann": "Leagues of Votann",
+        "ligen von votann": "Leagues of Votann",
+        "leghe di votann": "Leagues of Votann",
+        "leagues of votann": "Leagues of Votann",
+
+        // Necrons
+        "necrons": "Necrons",
+        "necrones": "Necrons",
+        "necroni": "Necrons",
+        "necron": "Necrons",
+
+        // Salamanders
+        "salamandres": "Salamanders",
+        "salamandras": "Salamanders",
+        "salamandre": "Salamanders",
+        "salamanders": "Salamanders",
+
+        // Tyranids
+        "tyranides": "Tyranids",
+        "tiranidos": "Tyranids",
+        "tyraniden": "Tyranids",
+        "tiranidi": "Tyranids",
+        "tyranids": "Tyranids",
+
+        // Agents of the Imperium
+        "agents de l'imperium": "Agents of the Imperium",
+        "agentes del imperio": "Agents of the Imperium",
+        "agenten des imperiums": "Agents of the Imperium",
+        "agenti dell'imperium": "Agents of the Imperium",
+        "agents of the imperium": "Agents of the Imperium",
+        "agents imperiaux": "Agents of the Imperium",
+        "agentes imperiales": "Agents of the Imperium",
+        "imperiale agenten": "Agents of the Imperium",
+        "agenti imperiali": "Agents of the Imperium",
+        "imperial agents": "Agents of the Imperium",
+
+        // Space Marines
+        "marines espaciales": "Space Marines",
+        "marines spaziali": "Space Marines",
+        "space marines": "Space Marines",
+        "weltraummarines": "Space Marines",
+
+        // World Eaters
+        "devoradores de mundos": "World Eaters",
+        "divoratori di mondi": "World Eaters",
+        "mangeurs de mondes": "World Eaters",
+        "weltenfresser": "World Eaters",
+        "world eaters": "World Eaters",
+
+        // Death Guard
+        "guardia de la muerte": "Death Guard",
+        "guardia della morte": "Death Guard",
+        "garde de la mort": "Death Guard",
+        "todesgarde": "Death Guard",
+        "death guard": "Death Guard",
+
+        // Thousand Sons
+        "mil hijos": "Thousand Sons",
+        "mille figli": "Thousand Sons",
+        "mille fils": "Thousand Sons",
+        "tausend sohne": "Thousand Sons",
+        "thousand sons": "Thousand Sons",
+
+        // Chaos Space Marines
+        "marines espaciales del caos": "Chaos Space Marines",
+        "space marines del caos": "Chaos Space Marines",
+        "space marines du chaos": "Chaos Space Marines",
+        "chaos space marines": "Chaos Space Marines",
+
+        // Chaos Knights
+        "caballeros del caos": "Chaos Knights",
+        "cavalieri del caos": "Chaos Knights",
+        "chevaliers du chaos": "Chaos Knights",
+        "chaosritter": "Chaos Knights",
+        "chaos knights": "Chaos Knights",
+
+        // Dark Angels
+        "angeles oscuros": "Dark Angels",
+        "angeli oscuri": "Dark Angels",
+        "anges sombres": "Dark Angels",
+        "dunkle engel": "Dark Angels",
+        "dark angels": "Dark Angels",
+
+        // Blood Angels
+        "angeles sangrientos": "Blood Angels",
+        "angeli sanguinari": "Blood Angels",
+        "anges sanguins": "Blood Angels",
+        "blutengel": "Blood Angels",
+        "blood angels": "Blood Angels",
+
+        // Black Templars
+        "templarios negros": "Black Templars",
+        "templari neri": "Black Templars",
+        "templiers noirs": "Black Templars",
+        "schwarze templer": "Black Templars",
+        "black templars": "Black Templars",
+
+        // Space Wolves
+        "lobos espaciales": "Space Wolves",
+        "lupi spaziali": "Space Wolves",
+        "loups spatiaux": "Space Wolves",
+        "weltraumwolfe": "Space Wolves",
+        "space wolves": "Space Wolves",
+
+        // Adepta Sororitas
+        "sisters of battle": "Adepta Sororitas",
+        "soeurs de bataille": "Adepta Sororitas",
+        "hermanas de batalla": "Adepta Sororitas",
+        "schwestern des kampfes": "Adepta Sororitas",
+        "sororitas": "Adepta Sororitas",
+        "sorelle della battaglia": "Adepta Sororitas",
+        "adepta sororitas": "Adepta Sororitas",
+
+        // Astra Militarum
+        "imperial guard": "Astra Militarum",
+        "garde imperiale": "Astra Militarum",
+        "guardia imperial": "Astra Militarum",
+        "imperiale armee": "Astra Militarum",
+        "imperiale garde": "Astra Militarum",
+        "guardia imperiale": "Astra Militarum",
+        "astra militarum": "Astra Militarum",
+
+        // Deathwatch
+        "todeswache": "Deathwatch",
+        "guet de la mort": "Deathwatch",
+        "guardianes de la muerte": "Deathwatch",
+        "veglia della morte": "Deathwatch",
+        "deathwatch": "Deathwatch",
+
+        // Drukhari
+        "dark eldar": "Drukhari",
+        "eldars noirs": "Drukhari",
+        "eldar noirs": "Drukhari",
+        "eldars oscuros": "Drukhari",
+        "eldar oscuros": "Drukhari",
+        "dunkle eldar": "Drukhari",
+        "eldar oscuri": "Drukhari",
+        "drukhari": "Drukhari",
+
+        // Emperor's Children
+        "enfants de l'empereur": "Emperor's Children",
+        "hijos del emperador": "Emperor's Children",
+        "kinder des imperators": "Emperor's Children",
+        "figli dell'imperatore": "Emperor's Children",
+        "emperor's children": "Emperor's Children",
+
+        // Imperial Fists
+        "poings imperiaux": "Imperial Fists",
+        "punos imperiales": "Imperial Fists",
+        "imperiale fauste": "Imperial Fists",
+        "magli imperiali": "Imperial Fists",
+        "pugni imperiali": "Imperial Fists",
+        "imperial fists": "Imperial Fists",
+
+        // Iron Hands
+        "mains de fer": "Iron Hands",
+        "manos de hierro": "Iron Hands",
+        "eiserne hande": "Iron Hands",
+        "mani di ferro": "Iron Hands",
+        "iron hands": "Iron Hands",
+
+        // Orks
+        "orcs": "Orks",
+        "orkos": "Orks",
+        "orki": "Orks",
+        "orks": "Orks",
+
+        // Raven Guard
+        "garde du corbeau": "Raven Guard",
+        "guardia del cuervo": "Raven Guard",
+        "rabengarde": "Raven Guard",
+        "guardia del corvo": "Raven Guard",
+        "raven guard": "Raven Guard",
+
+        // White Scars
+        "cicatrices blanches": "White Scars",
+        "cicatrices blancas": "White Scars",
+        "weisse narben": "White Scars",
+        "cicatrici bianche": "White Scars",
+        "white scars": "White Scars"
+    };
+    
+    if (mapping[normalized]) {
+        return mapping[normalized];
+    }
+    
+    return faction;
+}
+
+export function isWargearSkippable(skippableWargearMap, faction, unitName, wargearName) {
+    if (!skippableWargearMap || !faction || !unitName || !wargearName) return false;
+
+    const normalizeKey = (s) => {
+        if (!s) return '';
+        try {
+            return s.toString().normalize('NFD')
+                .replace(/\p{M}/gu, '')
+                .replace(/[\u2018\u2019\u201B\u2032]/g, "'")
+                .replace(/[^\w\s'\-]/g, '')
+                .toLowerCase().trim();
+        } catch (e) {
+            return s.toString().toLowerCase().trim();
+        }
+    };
+
+    const unitKey = normalizeKey(unitName);
+    const unitAlt = unitKey.endsWith('s') ? unitKey.slice(0, -1) : unitKey + 's';
+    const wargearKey = normalizeWargearName(wargearName);
+
+    // A combined "Parent - Subfaction" faction (e.g. "Space Marines - Dark Angels")
+    // resolves to the subfaction for coloring, but skippable-wargear rules are often
+    // only defined once at the parent level. Try the subfaction first so any
+    // chapter-specific overrides win, then fall back to the parent when the
+    // subfaction's data has no entry at all for this unit.
+    const rawFaction = faction.toString();
+    const combinedMatch = rawFaction.match(/^(.+?)\s+-\s+(.+)$/);
+    const candidateFactions = combinedMatch ? [combinedMatch[2].trim(), combinedMatch[1].trim()] : [rawFaction];
+
+    for (const candidateFaction of candidateFactions) {
+        const canonicalFaction = getCanonicalFactionName(candidateFaction);
+        const factionKey = normalizeKey(canonicalFaction);
+
+        // Find faction entry
+        let factionData;
+        for (const [k, v] of Object.entries(skippableWargearMap)) {
+            if (normalizeKey(k) === factionKey) {
+                factionData = v;
+                break;
+            }
+        }
+        if (!factionData) continue;
+
+        // Find unit entry
+        let unitData;
+        const tryUnitKeys = [unitName, unitKey, unitAlt];
+        for (const uk of tryUnitKeys) {
+            if (Object.prototype.hasOwnProperty.call(factionData, uk)) {
+                unitData = factionData[uk];
+                break;
+            }
+        }
+        if (unitData === undefined) {
+            for (const [k, v] of Object.entries(factionData)) {
+                if (normalizeKey(k) === unitKey || normalizeKey(k) === unitAlt) {
+                    unitData = v;
+                    break;
+                }
+            }
+        }
+        if (unitData === undefined) continue;
+
+        if (unitData === true) return true;
+        if (Array.isArray(unitData)) {
+            return unitData.map(s => normalizeWargearName(s)).includes(wargearKey);
+        }
+        return false;
+    }
+
+    return false;
+}
+
+export function shouldHideSubunitsForUnit(unit, showMode) {
+    if (!unit || !Array.isArray(unit.subunits) || unit.subunits.length === 0) return false;
+    return unit.subunits.every(sub => {
+        const visibleWargear = (sub.wargear || []).filter(wg => {
+            if (showMode === 'show-all') return true;
+            if (showMode === 'hide-all') return false;
+            return !wg.skippable;
+        });
+        return visibleWargear.length === 0;
+    });
+}
+
+export function getModelsCount(unit) {
+    if (!unit) return 1;
+    if (Array.isArray(unit.subunits) && unit.subunits.length > 0) {
+        return unit.subunits.reduce((sum, sub) => sum + (parseInt(sub.quantity, 10) || 0), 0);
+    }
+    const q = parseInt((unit.quantity || '1').toString().replace('x', ''), 10);
+    return isNaN(q) ? 1 : q;
+}
+
+export function parseNewRecruitHeader(lines) {
+    const metadata = {
+        title: '',
+        armyName: '',
+        faction: '',
+        detachment: '',
+        detachments: [],
+        pointsTotal: 0,
+        totalPoints: 0,
+        pointsLimit: 0,
+        forceDispositions: [],
+        warlordName: '',
+        warlordId: '',
+        enhancements: []
+    };
+
+    let i = 0;
+    while (i < lines.length && !lines[i].trim()) {
+        i++;
+    }
+    if (i < lines.length && lines[i].trim().startsWith('+++')) {
+        i++; // skip opening +++
+        while (i < lines.length && !lines[i].trim().startsWith('+++')) {
+            const line = lines[i].trim();
+            if (line.startsWith('+') || line.startsWith('&')) {
+                const isAmp = line.startsWith('&');
+                const content = line.substring(1).trim();
+                
+                if (isAmp) {
+                    // Continuing enhancement or other field
+                    const match = content.match(/^(.*?)\s*\(on\s+(Char\d+|Infa\d+|[A-Za-z]+\d+)?\s*:?\s*(.*)\)$/i);
+                    if (match) {
+                        metadata.enhancements.push({
+                            name: match[1].trim(),
+                            onId: match[2] ? match[2].trim() : '',
+                            onName: match[3] ? match[3].trim() : ''
+                        });
+                    } else {
+                        metadata.enhancements.push({
+                            name: content,
+                            onId: '',
+                            onName: ''
+                        });
+                    }
+                    i++;
+                    continue;
+                }
+
+                const factionMatch = content.match(/^FACTION KEYWORD:\s*(.*)$/i);
+                if (factionMatch) {
+                    let facVal = factionMatch[1].trim();
+                    const hyphenIdx = facVal.indexOf('-');
+                    if (hyphenIdx !== -1) {
+                        facVal = facVal.substring(hyphenIdx + 1).trim();
+                    }
+                    metadata.faction = facVal;
+                    i++;
+                    continue;
+                }
+
+                const detachmentMatch = content.match(/^DETACHMENT:\s*(.*)$/i);
+                if (detachmentMatch) {
+                    let detVal = detachmentMatch[1].trim();
+                    detVal = detVal.replace(/\s*\(.*?\)/g, '').trim();
+                    metadata.detachment = detVal;
+                    metadata.detachments = detVal.split(',').map(d => d.trim()).filter(Boolean);
+                    i++;
+                    continue;
+                }
+
+                const forceDispositionMatch = content.match(/^FORCE DISPOSITION:\s*(.*)$/i);
+                if (forceDispositionMatch) {
+                    const dispVal = forceDispositionMatch[1].trim();
+                    metadata.forceDispositions = dispVal.split(',').map(d => d.trim()).filter(Boolean);
+                    i++;
+                    continue;
+                }
+
+                const pointsMatch = content.match(/^TOTAL ARMY POINTS:\s*(\d+)/i);
+                if (pointsMatch) {
+                    const pts = parseInt(pointsMatch[1], 10) || 0;
+                    metadata.pointsTotal = pts;
+                    metadata.totalPoints = pts;
+                    i++;
+                    continue;
+                }
+
+                const warlordMatch = content.match(/^WARLORD:\s*(Char\d+|Infa\d+|[A-Za-z]+\d+)?\s*:?\s*(.*)$/i);
+                if (warlordMatch) {
+                    if (warlordMatch[1]) {
+                        metadata.warlordId = warlordMatch[1].trim();
+                    }
+                    metadata.warlordName = warlordMatch[2].trim();
+                    i++;
+                    continue;
+                }
+
+                const enhancementMatch = content.match(/^ENHANCEMENT:\s*(.*)$/i);
+                if (enhancementMatch) {
+                    const enhContent = enhancementMatch[1].trim();
+                    const match = enhContent.match(/^(.*?)\s*\(on\s+(Char\d+|Infa\d+|[A-Za-z]+\d+)?\s*:?\s*(.*)\)$/i);
+                    if (match) {
+                        metadata.enhancements.push({
+                            name: match[1].trim(),
+                            onId: match[2] ? match[2].trim() : '',
+                            onName: match[3] ? match[3].trim() : ''
+                        });
+                    } else {
+                        metadata.enhancements.push({
+                            name: enhContent,
+                            onId: '',
+                            onName: ''
+                        });
+                    }
+                    i++;
+                    continue;
+                }
+
+                const secondaryMatch = content.match(/^SECONDARY:\s*(.*)$/i);
+                if (secondaryMatch) {
+                    i++;
+                    continue;
+                }
+            }
+            i++;
+        }
+        if (i < lines.length && lines[i].trim().startsWith('+++')) {
+            i++;
+        }
+    }
+    return { metadata, nextIndex: i };
+}
\ No newline at end of file
diff --git a/sites/scouting/src/vendor/40k-compactor/skippable_wargear.json b/sites/scouting/src/vendor/40k-compactor/skippable_wargear.json
new file mode 100644
index 0000000..06eaa5a
--- /dev/null
+++ b/sites/scouting/src/vendor/40k-compactor/skippable_wargear.json
@@ -0,0 +1,3137 @@
+{
+    "Adepta Sororitas": {
+        "Aestred Thurga and Agathae Dolan": true,
+        "Arco-Flagellants": true,
+        "Battle Sisters Squad": [
+            "Close Combat Weapon"
+        ],
+        "Canoness": [],
+        "Canoness with Jump Pack": [],
+        "Castigator": [
+            "Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Celestian Sacresants": [],
+        "Daemonifuge": true,
+        "Dialogus": true,
+        "Dogmata": true,
+        "Dominion Squad": [
+            "Close Combat Weapon"
+        ],
+        "Exorcist": [
+            "Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Hospitaller": true,
+        "Imagifier": true,
+        "Immolator": [
+            "Armoured Tracks"
+        ],
+        "Intranzia Fraye": [
+            "Heavy Bolter",
+            "Melta Missile Array",
+            "Ministorum Heavy Flamer",
+            "Mace of Saint Praxedes",
+            "Throne of Blame"
+        ],
+        "Junith Eruita": true,
+        "Ministorum Priest": [],
+        "Mortifiers": [],
+        "Morvenn Vahl": true,
+        "Palatine": [
+            "Palatine Blade"
+        ],
+        "Paragon Warsuits": [
+            "Bolt Pistol"
+        ],
+        "Penitent Engines": [
+            "Penitent Flamers"
+        ],
+        "Repentia Squad": true,
+        "Retributor Squad": [
+            "Close Combat Weapon"
+        ],
+        "Saint Celestine": true,
+        "Sanctifiers": [
+            "Ministorum Flamer",
+            "Burning Hands",
+            "Death Cult Blades",
+            "Salvationist Medikit"
+        ],
+        "Seraphim Squad": [
+            "Close Combat Weapon"
+        ],
+        "Sisters Novitiate Squad": [
+            "Autopistol"
+        ],
+        "Sororitas Rhino": [
+            "Storm Bolter",
+            "Armoured Tracks"
+        ],
+        "Triumph of Saint Katherine": true,
+        "Zephyrim Squad": [
+            "Power Weapon"
+        ]
+    },
+    "Adeptus Custodes": {
+        "Agamatus Custodians": [
+            "Interceptor Lance"
+        ],
+        "Aleya": true,
+        "Allarus Custodians": [
+            "Balistus Grenade Launcher"
+        ],
+        "Anathema Psykana Rhino": [
+            "Storm Bolter",
+            "Armoured Tracks"
+        ],
+        "Aquilon Custodians": [],
+        "Ares Gunship": [
+            "Arachnus Heavy Blaze Cannon",
+            "Arachnus Magna-blaze Cannon",
+            "Armoured Hull"
+        ],
+        "Blade Champion": true,
+        "Caladius Grav-tank": [
+            "Twin Lastrum Bolt Cannon",
+            "Armoured Hull"
+        ],
+        "Contemptor-Achillus Dreadnought": [
+            "Achillus Dreadspear"
+        ],
+        "Contemptor-galatus Dreadnought": [
+            "Galatus Warblade"
+        ],
+        "Contemptor-Galatus Dreadnought": true,
+        "Coronus Grav-carrier": [
+            "Twin Arachnus Blaze Cannon",
+            "Twin Lastrum Bolt Cannon",
+            "Armoured Hull"
+        ],
+        "Custodian Guard": [],
+        "Custodian Guard with Adrasite and Pyrithite Spears": [],
+        "Custodian Wardens": [],
+        "Knight-Centura": [],
+        "Orion Assault Dropship": [
+            "Arachnus Heavy Blaze Cannon",
+            "Spiculus Heavy Bolt Launcher",
+            "Twin Lastrum Bolt Cannon",
+            "Armoured Hull"
+        ],
+        "Pallas Grav-attack": [
+            "Twin Arachnus Blaze Cannon",
+            "Armoured Hull"
+        ],
+        "Prosecutors": true,
+        "Sagittarum Custodians": [
+            "Adrastus Bolt Caliver",
+            "Misericordia"
+        ],
+        "Shield-Captain": [],
+        "Shield-captain In Allarus Terminator Armour": [
+            "Balistus Grenade Launcher"
+        ],
+        "Shield-captain on Dawneagle Jetbike": [
+            "Interceptor Lance"
+        ],
+        "Telemon Heavy Dreadnought": [
+            "Spiculus Bolt Launcher",
+            "Armoured Feet"
+        ],
+        "Trajann Valoris": true,
+        "Valerian": true,
+        "Venatari Custodians": [
+            "Tarsis Buckler"
+        ],
+        "Venerable Contemptor Dreadnought": [
+            "Combi-Bolter",
+            "Contemptor Combat Weapon"
+        ],
+        "Venerable Land Raider": [
+            "Godhammer Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Vertus Praetors": [
+            "Interceptor Lance"
+        ],
+        "Vigilators": true,
+        "Witchseekers": [
+            "Witchseeker Flamer",
+            "Close Combat Weapon"
+        ]
+    },
+    "Adeptus Mechanicus": {
+        "Archaeopter Fusilave": [
+            "Cognis Heavy Stubber Array",
+            "Armoured Hull"
+        ],
+        "Archaeopter Stratoraptor": [
+            "Cognis Heavy Stubber",
+            "Heavy phosphor blaster",
+            "Twin Cognis Lascannon",
+            "Armoured Hull"
+        ],
+        "Archaeopter Transvector": [
+            "Cognis Heavy Stubber Array",
+            "Armoured Hull"
+        ],
+        "Belisarius Cawl": true,
+        "Corpuscarii Electro-priests": true,
+        "Cybernetica Datasmith": true,
+        "Fulgurite Electro-priests": true,
+        "Hastarii Exterminators": [
+            "Hastarii Arc Blaster",
+            "Eradication Caster",
+            "Close-combat Weapon",
+            "Power Weapon"
+        ],
+        "Hastarii Fusiliers": [
+            "Neutron Fusil",
+            "Hastarii Phosphor Blaster",
+            "Close-combat Weapon",
+            "Power Weapon"
+        ],
+        "Ironstrider Ballistarii": [
+            "Ironstrider Feet"
+        ],
+        "Kastelan Robots": [],
+        "Kataphron Breachers": [],
+        "Kataphron Destroyers": [
+            "Close Combat Weapon"
+        ],
+        "Onager Dunecrawler": [
+            "Dunecrawler Legs"
+        ],
+        "Pteraxii Skystalkers": true,
+        "Pteraxii Sterylizors": true,
+        "Serberys Raiders": [
+            "Mechanicus Pistol",
+            "Galvanic Carbine",
+            "Cavalry Sabre and Clawed Limbs"
+        ],
+        "Serberys Sulphurhounds": [
+            "Mechanicus Pistol",
+            "Sulphur Breath",
+            "Cavalry Arc Maul",
+            "Clawed Limbs"
+        ],
+        "Servitor Battleclade": [
+            "Heavy Arc Rifle",
+            "Heavy Bolter",
+            "Mechanicus Pistol",
+            "Dataspikes",
+            "Servo-claw"
+        ],
+        "Sicarian Ruststalkers": [],
+        "Skitarii Marshal": true,
+        "Skitarii Rangers": [
+            "Close Combat Weapon"
+        ],
+        "Skitarii Vanguard": [
+            "Close Combat Weapon"
+        ],
+        "Skorpius Disintegrator": [
+            "Cognis Heavy Stubber",
+            "Disruptor Missile Launcher",
+            "Armoured Hull"
+        ],
+        "Skorpius Dunerider": true,
+        "Sydonian Dragoons with Radium Jezzails": true,
+        "sydonian Dragoons with Taser Lances": true,
+        "Sydonian Skatros": [
+            "Mechanicus Pistol",
+            "Sydonian Feet"
+        ],
+        "Tech-Priest Dominus": [
+            "Omnissian Axe"
+        ],
+        "Tech-Priest Enginseer": true,
+        "Tech-Priest Manipulus": [
+            "Omnissian Staff"
+        ],
+        "Technoarcheologist": true,
+        "Thulia Ghuld": true
+    },
+    "Adeptus Titanicus": {
+        "Reaver Titan": [
+            "Reaver apocalypse launcher",
+            "reaver feet"
+        ],
+        "Warbringer Nemesis Titan": [
+            "Anvillus Defence Battery",
+            "Ardex-defensor Mauler",
+            "Nemesis Feet"
+        ],
+        "Warhound Titan": [
+            "Warhound Feet"
+        ],
+        "Warlord Titan": [
+            "Ardex-defensor Mauler",
+            "Ardex-defensor Lascannon",
+            "Warlord Feet"
+        ]
+    },
+    "Aeldari": {
+        "Asurmen": true,
+        "Autarch": [],
+        "Avatar of Khaine": true,
+        "Baharroth": true,
+        "Corsair Voidreavers": [
+            "Close Combat Weapon"
+        ],
+        "Corsair Voidscarred": [
+            "Close Combat Weapon",
+            "Executioner",
+            "Paired Hekatarii Blades",
+            "Witch Staff",
+            "Channeller Stones"
+        ],
+        "Crimson Hunter": [
+            "Pulse laser",
+            "Wraithbone Hull"
+        ],
+        "D-Cannon Platform": true,
+        "Dark Reapers": [
+            "Close Combat Weapon"
+        ],
+        "Death Jester": true,
+        "Dire Avengers": [
+            "Close Combat Weapon"
+        ],
+        "Eldrad Ulthran": true,
+        "Falcon": [
+            "Pulse laser",
+            "Wraithbone Hull"
+        ],
+        "Farseer": [
+            "Eldritch Storm",
+            "Shuriken Pistol"
+        ],
+        "Farseer Skyrunner": [
+            "Eldritch Storm",
+            "Shuriken Pistol",
+            "Twin Shuriken Catapult"
+        ],
+        "Fire Dragons": [
+            "Close Combat Weapon"
+        ],
+        "Fire Prism": [
+            "Prism Cannon",
+            "Wraithbone Hull"
+        ],
+        "Fuegan": true,
+        "Guardian Defenders": [
+            "Shuriken Catapult",
+            "Close Combat Weapon"
+        ],
+        "Hemlock Wraithfighter": true,
+        "Jain Zar": true,
+        "Kharseth": [
+            "Dread of the Deep Void",
+            "Waystave"
+        ],
+        "Lhykhis": true,
+        "Maugan Ra": true,
+        "Night Spinner": [
+            "Doomweaver",
+            "Wraithbone Hull"
+        ],
+        "Phantom Titan": [
+            "Voidstorm Missile Launcher",
+            "Phantom Feet"
+        ],
+        "Prince Yriel": [
+            "Eye of Wrath",
+            "Shuriken Pistol",
+            "Spear of Twilight"
+        ],
+        "Rangers": [
+            "Long Rifle",
+            "Shuriken Pistol",
+            "Close Combat Weapon"
+        ],
+        "Revenant Titan": [
+            "Cloudburst Missile Launcher",
+            "Revenant Feet"
+        ],
+        "Shadow Weaver Platform": true,
+        "Shadowseer": [
+            "Miststave",
+            "Flip Belt"
+        ],
+        "Shining Spears": [],
+        "Shroud Runners": true,
+        "Skyweavers": [
+            "Close Combat Weapon"
+        ],
+        "Solitaire": true,
+        "Spiritseer": true,
+        "Starfangs": [
+            "Disintegrator Cannon",
+            "Starfang Grenade Launcher",
+            "Wraithbone Hull"
+        ],
+        "Starweaver": true,
+        "Storm Guardians": [
+            "Serpent Shield"
+        ],
+        "Striking Scorpions": [],
+        "Swooping Hawks": [
+            "Close Combat Weapon"
+        ],
+        "The Visarch": true,
+        "The Yncarne": true,
+        "Troupe": [
+            "Flip Belt"
+        ],
+        "Troupe Master": [
+            "Flip Belt"
+        ],
+        "Vibro Cannon Platform": true,
+        "Voidweaver": [
+            "Shuriken Cannon",
+            "Close Combat Weapon"
+        ],
+        "Vypers": [
+            "Wraithbone Hull"
+        ],
+        "War Walkers": [
+            "War Walker Feet"
+        ],
+        "Warlock": [
+            "Destructor",
+            "Shuriken Pistol"
+        ],
+        "Warlock Conclave": [
+            "Destructor",
+            "Shuriken Pistol"
+        ],
+        "Warlock Skyrunners": [
+            "Destructor",
+            "Shuriken Pistol",
+            "Twin Shuriken Catapult"
+        ],
+        "Warp Spiders": [
+            "Close Combat Weapon"
+        ],
+        "Wave Serpent": [
+            "Wraithbone Hull"
+        ],
+        "Windriders": [
+            "Close Combat Weapon"
+        ],
+        "Wraithguard": [
+            "Close Combat Weapon"
+        ],
+        "Wraithknight": [
+            "Titanic Feet"
+        ],
+        "Wraithknight with Ghostglaive": [
+            "Titanic Ghostglaive"
+        ],
+        "Wraithlord": [
+            "Wraithbone Fists"
+        ],
+        "Ynnari Archon": [
+            "Huskblade",
+            "Shadow Field"
+        ],
+        "Ynnari Incubi": [
+            "Demiklaives"
+        ],
+        "Ynnari Raider": [
+            "Bladevanes"
+        ],
+        "Ynnari Reavers": [
+            "Splinter Pistol",
+            "Bladevanes"
+        ],
+        "Ynnari Succubus": [
+            "Succubus Weapons"
+        ],
+        "Ynnari Venom": [
+            "Bladevanes"
+        ],
+        "Ynnari Wyches": [
+            "Hekatarii Blade"
+        ],
+        "Yvraine": true
+    },
+    "Agents of the Imperium": {
+        "Aquila Kill Team": [
+            "Bolt Pistol",
+            "Plasma Pistol",
+            "Special-issue Bolt Pistol",
+            "Close Combat Weapon",
+            "Xenophase Blade"
+        ],
+        "Callidus Assassin": true,
+        "Corvus Blackstar": [
+            "Armoured Hull"
+        ],
+        "Culexus Assassin": true,
+        "Deathwatch Kill Team": [],
+        "Eversor Assassin": true,
+        "Exaction Squad": [
+            "Arbites Shotpistol",
+            "Close Combat Weapon",
+            "Mechanical Bite"
+        ],
+        "Grey Knights Terminator Squad": [
+            "Nemesis Force Weapon"
+        ],
+        "Imperial Navy Breachers": [
+            "Close Combat Weapon",
+            "Endurant Shield",
+            "Navis Heavy Shotgun"
+        ],
+        "Imperial Rhino": [
+            "Storm Bolter",
+            "Armoured Tracks"
+        ],
+        "Inquisitor Coteaz": true,
+        "Inquisitor Draxus": true,
+        "Inquisitor Greyfax": true,
+        "Inquisitor Kroyle": [
+            "Jindarii Tox-cycler",
+            "Stubcarbine",
+            "Butcher Blade",
+            "Garralisk's Claws and Teeth"
+        ],
+        "Inquisitorial Agents": [
+            "Agent Firearm",
+            "Agent Melee Weapon"
+        ],
+        "Inquisitorial Chimera": [
+            "Armoured Tracks",
+            "Lasgun Array"
+        ],
+        "Ministorum Priest": [],
+        "Navigator": true,
+        "Rogue Trader Entourage": true,
+        "Sanctifiers": [
+            "Ministorum Flamer",
+            "Burning Hands",
+            "Death Cult Blades",
+            "Salvationist Medikit"
+        ],
+        "Sisters of Battle Immolator": [
+            "Armoured Tracks"
+        ],
+        "Sisters of Battle Squad": [
+            "Close Combat Weapon",
+            "Simulacrum Imperials"
+        ],
+        "Subductor Squad": [
+            "Arbites Shotpistol",
+            "Shock maul",
+            "Mechanical Bite"
+        ],
+        "Vigilant Squad": [
+            "Arbites Shotpistol",
+            "Close Combat Weapon",
+            "Mechanical Bite"
+        ],
+        "Vindicare Assassin": true,
+        "Voidsmen-at-Arms": true,
+        "Watch Captain Artemis": true,
+        "Watch Master": true
+    },
+    "Astra Militarum": {
+        "Aegis Defence Line": [],
+        "Armoured Sentinels": [
+            "Close Combat Weapon"
+        ],
+        "Artillery Team": [
+            "Lasgun",
+            "Crew Close Combat Weapons"
+        ],
+        "Attilan Rough Riders": [
+            "Steed's hooves",
+            "Lasgun",
+            "Laspistol"
+        ],
+        "Avenger Strike Fighter": [
+            "Avenger Bolt Cannon",
+            "Heavy Stubber",
+            "Lascannon",
+            "Armoured Hull"
+        ],
+        "Baneblade": [
+            "Baneblade Cannon",
+            "Coaxial Autocannon",
+            "Demolisher Cannon",
+            "Armoured Tracks",
+            "Heavy Stubber"
+        ],
+        "Banehammer": [
+            "Tremor Cannon",
+            "Armoured Tracks"
+        ],
+        "Banesword": [
+            "Quake Cannon",
+            "Armoured Tracks"
+        ],
+        "Basilisk": [
+            "Earthshaker Cannon",
+            "Armoured Tracks"
+        ],
+        "Bullgryn Squad": [
+            "Close Combat Weapon"
+        ],
+        "Cadian Command Squad": [
+            "Medi-pack",
+            "Master Vox"
+        ],
+        "Cadian Heavy Weapons Squad": [
+            "Weapons Team Close Combat Weapons",
+            "Laspistol"
+        ],
+        "Cadian Recon Squad": [
+            "Close Combat Weapon"
+        ],
+        "Catachan Command Squad": [
+            "Close Combat Weapon"
+        ],
+        "Catachan Heavy Weapons Squad": [
+            "Weapons Team Close Combat Weapons",
+            "Lasgun"
+        ],
+        "Catachan Jungle Fighters": [
+            "Laspistol",
+            "Close Combat Weapon"
+        ],
+        "Centaur RSV": [
+            "Pintle-mounted Heavy Stubber",
+            "Armoured Hull"
+        ],
+        "Chimera": [
+            "Armoured Tracks",
+            "Lasgun Array"
+        ],
+        "Commissar Graves": [
+            "Chiron Gatling Cannon",
+            "Prefectus Heavy Stubber",
+            "Armoured Hull",
+            "Enforcer Crew",
+            "Power Sword and Manus Mortis",
+            "Aquiline Prow"
+        ],
+        "Commissar Graves on Foot": [
+            "Bolt Pistol",
+            "Power Sword and Manus Mortis"
+        ],
+        "Commissar Yarrick": [
+            "Bale Eye",
+            "Laspistol",
+            "Storm Bolter",
+            "Power Klaw",
+            "Power Sword"
+        ],
+        "Cyclops Demolition Vehicle": [],
+        "Death Korps of Krieg": [
+            "Laspistol",
+            "Chainsword",
+            "Lasgun",
+            "Close Combat Weapon"
+        ],
+        "Death Riders": true,
+        "Deathstrike": [
+            "Deathstrike Missile",
+            "Armoured Tracks"
+        ],
+        "Doomhammer": [
+            "Magma Cannon",
+            "Armoured Tracks"
+        ],
+        "Field Ordnance Battery": [
+            "Battery Close Combat Weapons",
+            "Lasgun",
+            "Laspistol"
+        ],
+        "Gaunt's Ghosts": true,
+        "Hellhammer": [
+            "Coaxial Autocannon",
+            "Demolisher Cannon",
+            "Hellhammer Cannon",
+            "Armoured Tracks",
+            "Heavy Stubber"
+        ],
+        "Hellhound": [
+            "Armoured Tracks"
+        ],
+        "Hippogriff AFV": [
+            "Armoured Hull"
+        ],
+        "Hydra": [
+            "Hydra Autocannon",
+            "Armoured Tracks"
+        ],
+        "Kasrkin": [
+            "Close Combat Weapon"
+        ],
+        "Krieg Command Squad": [
+            "Servo-Scribes",
+            "Master Vox",
+            "Regimental Standard",
+            "Lasgun",
+            "Close Combat Weapon"
+        ],
+        "Krieg Heavy Weapons Squad": [
+            "Laspistol",
+            "Close Combat Weapon"
+        ],
+        "Leman Russ Battle Tank": [
+            "Leman Russ Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Commander": [
+            "Armoured Tracks"
+        ],
+        "Leman Russ Demolisher": [
+            "Demolisher Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Eradicator": [
+            "Eradicator Nova Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Executioner": [
+            "Executioner Plasma Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Exterminator": [
+            "Exterminator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Punisher": [
+            "Punisher Gatling Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Vanquisher": [
+            "Vanquisher Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Lord Marshal Dreir": true,
+        "Lord Solar Leontus": true,
+        "Manticore": [
+            "Storm Eagle Rockets",
+            "Armoured Tracks"
+        ],
+        "Militarum Tempestus Command squad": [
+            "Hot-Shot Lasgun",
+            "Tempestus Dagger"
+        ],
+        "Militarum Tempestus Command Squad": [
+            "Close Combat Weapon"
+        ],
+        "Ministorum Priest": [],
+        "Nork Deddog": true,
+        "Ogryn Bodyguard": [
+            "Close Combat Weapon"
+        ],
+        "Ogryn Squad": [
+            "Ripper Gun"
+        ],
+        "Primaris Psyker": true,
+        "Ratlings": [
+            "Close Combat Weapon"
+        ],
+        "Rogal Dorn Battle Tank": [
+            "Armoured Tracks"
+        ],
+        "Rogal Dorn Commander": [
+            "Armoured Tracks"
+        ],
+        "Scout Sentinels": [
+            "Close Combat Weapon"
+        ],
+        "Shadowsword": [
+            "Volcano Cannon",
+            "Armoured Tracks"
+        ],
+        "Sly Marbo": true,
+        "Stormlord": [
+            "Vulcan Mega-bolter",
+            "Armoured Tracks",
+            "Heavy Stubber"
+        ],
+        "StormSword": [
+            "Stormsword Siege Cannon",
+            "Armoured Tracks"
+        ],
+        "Taurox": [
+            "Twin Autocannon",
+            "Armoured Tracks"
+        ],
+        "Taurox Prime": [
+            "Armoured Tracks"
+        ],
+        "Tech-Priest Enginseer": [
+            "Mechanicus Pistol",
+            "Enginseer Axe",
+            "Servo-arm"
+        ],
+        "Tempestus Aquilons": [
+            "Close Combat Weapon"
+        ],
+        "Tempestus Scions": [
+            "Close Combat Weapon"
+        ],
+        "Ursula Creed": true,
+        "Valkyrie": [
+            "Armoured Hull"
+        ],
+        "Wyvern": [
+            "Wyvern Quad Stormshard Mortar",
+            "Armoured Tracks"
+        ]
+    },
+    "Black Templars": {
+        "Black Templars Gladiator Lancer": [
+            "Lancer Laser Destroyer",
+            "Armoured Hull"
+        ],
+        "Black Templars Gladiator Reaper": [
+            "Tempest Bolter",
+            "Twin Heavy Onslaught Gatling Cannon",
+            "Armoured Hull"
+        ],
+        "Black Templars Gladiator Valiant": [
+            "Twin Las-Talon",
+            "Armored Hull"
+        ],
+        "Black Templars Impulsor": [
+            "Armoured Hull"
+        ],
+        "Black Templars Repulsor": [
+            "Heavy Onslaught Gatling Cannon",
+            "Hunter-Slayer Missile",
+            "Repulsor Defensive Array",
+            "Armoured Hull"
+        ],
+        "Black Templars Repulsor Executioner": [
+            "Heavy Onslaught Gatling Cannon",
+            "Repulsor Executioner Defensive Array",
+            "Twin Heavy Bolter",
+            "Twin Icarus Ironhail Heavy Stubber",
+            "Armoured Hull"
+        ],
+        "Castellan": [],
+        "Chaplain Grimaldus": true,
+        "Crusade Ancient": true,
+        "Crusader Squad": [
+            "Master-crafted Power Weapon"
+        ],
+        "Emperor’s Champion": true,
+        "Execrator": [
+            "Crozius Arcanum"
+        ],
+        "Gladiator Lancer": [
+            "Lancer Laser Destroyer",
+            "Armoured Hull"
+        ],
+        "Gladiator Reaper": [
+            "Tempest Bolter",
+            "Twin Heavy Onslaught Gatling Cannon",
+            "Armoured Hull"
+        ],
+        "Gladiator Valiant": [
+            "Twin Las-talon",
+            "Armoured Hull"
+        ],
+        "High Marshal Helbrecht": [
+            "Ferocity",
+            "Sword of the High Marshals"
+        ],
+        "Impulsor": [
+            "Armoured Hull"
+        ],
+        "Land Raider Crusader": [
+            "Hurricane Bolter",
+            "Twin Assault Cannon",
+            "Armoured Tracks"
+        ],
+        "Marshal": [
+            "Master-Crafted Power Weapon"
+        ],
+        "Primaris Crusader Squad": [],
+        "Primaris Sword Bretheren": [],
+        "Repulsor": [
+            "Hunter-slayer Missile",
+            "Repulsor Defensive Array",
+            "Armoured Hull"
+        ],
+        "Repulsor Executioner": [
+            "Heavy Onslaught Gatling Cannon",
+            "Repulsor Executioner Defensive Array",
+            "Twin Heavy Bolter",
+            "Twin Icarus Ironhail Heavy Stubber",
+            "Armoured Hull"
+        ],
+        "Sternguard Veteran Squad": [
+            "Sternguard Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "The Emperor's Champion": true
+    },
+    "Blood Angels": {
+        "Astorath": true,
+        "Baal Predator": [
+            "Armoured Tracks"
+        ],
+        "Blood Angels Captain": [],
+        "Chief Librarian Mephiston": true,
+        "Commander Dante": true,
+        "Death Company Captain": [],
+        "Death Company Captain with Jump Pack": [],
+        "Death Company Dreadnought": [
+            "Twin Icarus Ironhail Heavy Stubber"
+        ],
+        "Death Company Marines": [],
+        "Death Company Marines with Bolt Rifles": [
+            "Bolt Pistol"
+        ],
+        "Death Company Marines with Jump Packs": [],
+        "Lemartes": true,
+        "Sanguinary Guard": [],
+        "Sanguinary Priest": true,
+        "The Sanguinor": true
+    },
+    "Chaos Daemons": {
+        "Accursed Cultists": true,
+        "Be'Lakor": [
+            "Betraying Shades",
+            "The Blade of Shadows"
+        ],
+        "Be’lakor": true,
+        "Beasts of Nurgle": [
+            "Putrid Appendages"
+        ],
+        "Beasts Of Nurgle": true,
+        "Bloodcrushers": [
+            "Hellblade",
+            "Juggernaut's Bladed Horn"
+        ],
+        "Bloodletters": [
+            "Hellblade"
+        ],
+        "Bloodmaster": [
+            "Blade of Blood"
+        ],
+        "Bloodthirster": [
+            "Hellfire Breath"
+        ],
+        "Blue Horrors": [
+            "Coruscating Blue Flames",
+            "Coruscating Yellow Flames",
+            "Blue Claws",
+            "Yellow Claws"
+        ],
+        "Burning Chariot": [
+            "Fire of Tzeentch",
+            "Flamer Mouths",
+            "Screamer Bites"
+        ],
+        "Changecaster": [
+            "Arcane Fireball",
+            "Herald Combat Weapon"
+        ],
+        "Chaos Lord": [
+            "Astartes Chainblade"
+        ],
+        "Contorted Epitome": [
+            "Coiled Tentacles",
+            "Ravaging Claws"
+        ],
+        "Cultist Firebrand": true,
+        "Cultist Mob": [
+            "Brutal Assault Weapon"
+        ],
+        "Daemon Prince of Chaos": [
+            "Infernal Cannon",
+            "Hellforged Weapons"
+        ],
+        "Daemon Prince of Chaos With Wings": [
+            "Hellforged Weapons",
+            "Infernal Cannon"
+        ],
+        "Daemon Prince Of Chaos With Wings": true,
+        "Daemonettes": [
+            "Slashing Claws"
+        ],
+        "Dark Apostle": true,
+        "Dark Commune": true,
+        "Epidemius": [
+            "Balesword and Nurgling Attendants"
+        ],
+        "Exalted Flamer": [
+            "Fire of Tzeentch",
+            "Flamer Mouths"
+        ],
+        "Fateskimmer": [
+            "Arcane Fireball",
+            "Herald Combat Weapon",
+            "Screamer Bites"
+        ],
+        "Fellgor Beastmen": [
+            "Autopistol",
+            "Chainsword"
+        ],
+        "Fiends": [
+            "Barbed Tail and Dissecting Claws"
+        ],
+        "Flamers": [
+            "Flickering Flames",
+            "Flamer Mouths"
+        ],
+        "Flesh Hounds": [
+            "Burning Roar",
+            "Gore-drenched Fangs",
+            "Collar of Khorne"
+        ],
+        "Fluxmaster": [
+            "Arcane Fireball",
+            "Herald Combat Weapon"
+        ],
+        "Great Unclean One": [
+            "Putrid Vomit"
+        ],
+        "Havocs": [
+            "Close Combat Weapon"
+        ],
+        "Hellflayers": [
+            "Lashes of Torment",
+            "Seeker Tongues",
+            "Slashing Claws"
+        ],
+        "Horticulous Slimux": [
+            "Acidic Maw",
+            "Lopping Shears"
+        ],
+        "Infernal Enrapturess": [
+            "Heartstring Lyre",
+            "Ravaging Claws"
+        ],
+        "Kairos Fateweaver": [
+            "Infernal Gateway",
+            "Staff of Tomorrow"
+        ],
+        "Karanak": [
+            "Scalding Roar",
+            "Soul-rending Fangs",
+            "Brass Collar of Bloody Vengeance"
+        ],
+        "Keeper of Secrets": [
+            "Phantasmagoria",
+            "Snapping Claws",
+            "Witstealer Sword"
+        ],
+        "Legionaries": [
+            "Close Combat Weapon"
+        ],
+        "Lord of Change": [
+            "Bolt of Change",
+            "Staff of Tzeentch"
+        ],
+        "Master Of Possession": true,
+        "Nurglings": [
+            "Diseased Claws and Teeth"
+        ],
+        "Pink Horrors": [
+            "Coruscating Blue Flames",
+            "Coruscating Yellow Flames",
+            "Coruscating Pink Flames",
+            "Pink Claws",
+            "Blue Claws",
+            "Yellow Claws"
+        ],
+        "Plague Drones": [
+            "Death's Heads",
+            "Foul Mouthparts",
+            "Plaguesword"
+        ],
+        "Plaguebearers": [
+            "Plaguesword"
+        ],
+        "Possessed": [
+            "Hideous Mutations"
+        ],
+        "Poxbringer": [
+            "Foul Balesword"
+        ],
+        "Rendmaster on Blood Throne": [
+            "Attendants' Hellblades",
+            "Blade of Blood"
+        ],
+        "Rendmaster On Blood Throne": true,
+        "Rotigus": [
+            "Streams of Brackish Filth",
+            "Gnarlrod"
+        ],
+        "Screamers": [
+            "Lamprey Bite"
+        ],
+        "Seekers": [
+            "Lashing Tongue",
+            "Slashing Claws"
+        ],
+        "Shalaxi Helbane": [
+            "Lash of Slaanesh",
+            "Pavane of Slaanesh",
+            "Snapping Claws",
+            "Soulpiercer"
+        ],
+        "Skarbrand": [
+            "Bellow of Endless Fury",
+            "Slaughter and Carnage"
+        ],
+        "Skull Cannon": [
+            "Skull Cannon",
+            "Attendants’ Hellblades",
+            "Biting Maw"
+        ],
+        "Skullmaster": [
+            "Blade of Blood",
+            "Juggernaut’s Bladed Horn"
+        ],
+        "Skulltaker": [
+            "The Slayer Sword"
+        ],
+        "Sloppity Bilepiper": [
+            "Marotter"
+        ],
+        "Sorcerer": true,
+        "Sorcerer In Terminator Armour": [
+            "Infernal Gaze",
+            "Force Weapon"
+        ],
+        "Soul Grinder": [
+            "Harvester Cannon",
+            "Iron Claw",
+            "Torrent of Burning Blood",
+            "Phlegm Bombardment",
+            "Scream of Despair",
+            "Warp Gaze"
+        ],
+        "Spoilpox Scrivener": [
+            "Disgusting Sneezes",
+            "Plaguesword and Distended Maw"
+        ],
+        "Syll'esske": [
+            "Cacophonic Choir",
+            "Scourging Whip",
+            "Axe of Dominion"
+        ],
+        "Syll’esske": true,
+        "The Blue Scribes": [
+            "Sharp Quills"
+        ],
+        "The Changeling": [
+            "Infernal Flames",
+            "The Trickster’s Staff"
+        ],
+        "The masque of Slaanesh": [
+            "Serrated Claws"
+        ],
+        "The Masque Of Slaanesh": true,
+        "Tormentbringer": [
+            "Lashes of Torment",
+            "Seeker Tongues",
+            "Slashing Claws"
+        ],
+        "Traitor Enforcer": [
+            "Bolt Pistol",
+            "Ogryn Weapons",
+            "Power Fist"
+        ],
+        "Tranceweaver": [
+            "Ravaging Claws"
+        ],
+        "Warp Talons": [
+            "Warp Claws"
+        ]
+    },
+    "Chaos Knights": {
+        "Accursed Cultists": true,
+        "Chaos Acastus Knight Asterius": [
+            "Asterius Volkite Culverin",
+            "Karacnos Mortar Battery",
+            "Twin Conversion Beam Cannon",
+            "Titanic Feet"
+        ],
+        "Chaos Acastus Knight Porphyrion": [
+            "Twin Magna Lascannon",
+            "Titanic Feet"
+        ],
+        "Chaos Cerastus Knight Acheron": [
+            "Acheron Flame Cannon",
+            "Twin Heavy Bolter",
+            "Reaper Chainfist"
+        ],
+        "Chaos Cerastus Knight Atrapos": [
+            "Atrapos Lascutter",
+            "Graviton Singularity Cannon"
+        ],
+        "Chaos Cerastus Knight Castigator": [
+            "Castigator Bolt Cannon",
+            "Tempest Warblade"
+        ],
+        "Chaos Cerastus Knight Lancer": [
+            "Cerastus Shock Lance"
+        ],
+        "Chaos Questoris Knight Magaera": [
+            "Lightning cannon",
+            "Phased Plasma-fusil"
+        ],
+        "Chaos Questoris Knight Styrix": [
+            "Graviton Crusher",
+            "Volkite Chierovile"
+        ],
+        "Cultist Firebrand": true,
+        "Cultist Mob": [
+            "Brutal Assault Weapon"
+        ],
+        "Dark Commune": true,
+        "Fellgor Beastmen": [
+            "Autopistol",
+            "Chainsword"
+        ],
+        "Knight Abominant": true,
+        "Knight Desecrator": [
+            "Diabolus Heavy Stubber",
+            "Desecrator Laser Destructor"
+        ],
+        "Knight Despoiler": [
+            "Titanic Feet"
+        ],
+        "Knight Rampager": true,
+        "Knight Ruinator": true,
+        "Knight Tyrant": [
+            "Titanic Feet",
+            "Twin Daemonbreath Meltagun"
+        ],
+        "Traitor Enforcer": [
+            "Bolt Pistol",
+            "Ogryn Weapons",
+            "Power Fist"
+        ],
+        "War Dog Brigand": [
+            "Avenger Chaincannon",
+            "Daemonbreath Spear",
+            "Armoured Feet"
+        ],
+        "War Dog Executioner": [
+            "War Dog Autocannon",
+            "Armoured Feet"
+        ],
+        "War Dog Huntsman": [
+            "Reaper Chaintalon",
+            "Daemonbreath Spear"
+        ],
+        "War Dog Karnivore": [
+            "Reaper Chaintalon",
+            "Slaughterclaw"
+        ],
+        "War Dog Moirax": [
+            "Armoured Feet"
+        ],
+        "War Dog Stalker": []
+    },
+    "Chaos Space Marines": {
+        "Abaddon The Despoiler": true,
+        "Abbadon the Despoiler": true,
+        "Accursed Cultists": true,
+        "Chaos Bikers": [
+            "Close Combat Weapon"
+        ],
+        "Chaos Land Raider": [
+            "Soulshatter Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Chaos Lord": [
+            "Astartes Chainblade"
+        ],
+        "Chaos Lord in Terminator Armour": [],
+        "Chaos Lord with Jump Pack": [],
+        "Chaos Predator Annihilator": [
+            "Predator Twin Lascannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Destructor": [
+            "Predator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Rhino": [
+            "Armoured Tracks"
+        ],
+        "Chaos Spawn": [
+            "Hideous Mutations"
+        ],
+        "Chaos Terminator Squad": [],
+        "Chaos Vindicator": [
+            "Demolisher Cannon",
+            "Armoured Tracks"
+        ],
+        "Chosen": [],
+        "Cultist Firebrand": true,
+        "Cultist Mob": [
+            "Brutal Assault Weapon"
+        ],
+        "Cypher": true,
+        "Dark Apostle": true,
+        "Dark Commune": true,
+        "Defiler": [
+            "Shearing Claws"
+        ],
+        "Fabius Bile": true,
+        "Fellgor Beastmen": [
+            "Chainsword",
+            "Autopistol"
+        ],
+        "Forgefiend": [],
+        "Haarken Worldclaimer": true,
+        "Havocs": [
+            "Close Combat Weapon"
+        ],
+        "Helbrute": [
+            "Close Combat Weapon"
+        ],
+        "Heldrake": [
+            "Heldrake Claws"
+        ],
+        "Heretic Astartes Daemon Prince": true,
+        "Heretic Astartes Daemon Prince With Wings": true,
+        "Huron Blackheart": [
+            "Tyrant’s Claw Heavy Flamer",
+            "Tyrant’s Claw and Exalted Power Weapon"
+        ],
+        "Khorne Berzerkers": [],
+        "Khorne Lord of Skulls": [
+            "Great Cleaver of Khorne"
+        ],
+        "Kravek Morne": [
+            "Baleflamer",
+            "Combi-bolter",
+            "Last Argument and Power Fist",
+            "Servo-harness"
+        ],
+        "Legionaries": [
+            "Close Combat Weapon"
+        ],
+        "Lord Discordant on Helstalker": [
+            "bladed limbs",
+            "impaler chainglaive"
+        ],
+        "Lord Discordant On Helstalker": [
+            "Bolt Pistol"
+        ],
+        "Master of Executions": true,
+        "Master of Posession": true,
+        "Master Of Possession": true,
+        "Masters of the Maelstrom": true,
+        "Maulerfiend": [
+            "Maulerfiend Fists"
+        ],
+        "Mutilators": [
+            "Fleshmetal Weapons"
+        ],
+        "Nemesis Claw": [
+            "Close Combat Weapon"
+        ],
+        "Noctilith Crown": true,
+        "Noise Marines": [],
+        "Obliterators": true,
+        "Plague Marines": [],
+        "Possessed": [
+            "Hideous Mutations"
+        ],
+        "Raptors": [],
+        "Red Corsairs Reave-Captain": [
+            "Bolt Pistol"
+        ],
+        "Rubric Marines": [
+            "Malefic Curse",
+            "Close Combat Weapon",
+            "Force Weapon"
+        ],
+        "Sorcerer": true,
+        "Sorcerer in Terminator Armour": [
+            "Infernal Gaze",
+            "Force Weapon"
+        ],
+        "Traitor Enforcer": [
+            "Bolt Pistol",
+            "Ogryn Weapons",
+            "Power Fist"
+        ],
+        "Traitor Guardsmen Squad": [],
+        "Vashtorr the Arkifane": true,
+        "Venomcrawler": true,
+        "Warp Talons": [
+            "Warp Claws"
+        ],
+        "Warpsmith": true
+    },
+    "Dark Angels": {
+        "Asmodai": true,
+        "Azrael": true,
+        "Belial": true,
+        "Deathwing Knights": [],
+        "Deathwing Terminator Squad": [
+            "Power Weapon"
+        ],
+        "Ezekiel": true,
+        "Inner Circle Companions": true,
+        "Land Speeder Vengeance": [
+            "Plasma Storm Battery",
+            "Close Combat Weapon"
+        ],
+        "Lazarus": true,
+        "Lion El'Jonson": true,
+        "Lion El’jonson": [
+            "Arma Luminis",
+            "Fealty"
+        ],
+        "Nephilim Jetfighter": [
+            "Blacksword Missiles",
+            "Twin Heavy Bolter",
+            "Armoured Hull"
+        ],
+        "Ravenwind Darkshroud": [
+            "Close Combat Weapon"
+        ],
+        "Ravenwing Black Knights": [
+            "Bolt Pistol",
+            "Black Knight Combat Weapon"
+        ],
+        "Ravenwing Command Squad": [
+            "Bolt Pistol",
+            "Black Knight Combat Weapon",
+            "Master-Crafted Power Weapon"
+        ],
+        "Ravenwing Dark Talon": true,
+        "Ravenwing Darkshroud": [
+            "Close Combat Weapon"
+        ],
+        "Sammael": true
+    },
+    "Death Guard": {
+        "Beasts of Nurgle": true,
+        "Biologus Putrifier": true,
+        "Chaos Land Raider": [
+            "Soulshatter Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Annihilator": [
+            "Predator Twin Lascannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Destructor": [
+            "Predator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Rhino": [
+            "Armoured Tracks"
+        ],
+        "Chaos Spawn": true,
+        "Daemon Prince of Nurgle": true,
+        "Daemon Prince of Nurgle With Wings": true,
+        "Deathshroud Terminators": [
+            "Manreaper"
+        ],
+        "Defiler": [
+            "Shearing Claws"
+        ],
+        "Foetid Bloat Drone": [
+            "Plague Probe"
+        ],
+        "Foetid Bloat Drone with Heavy Blight Launcher": true,
+        "Foul Blightspawn": true,
+        "Great Unclean One": [
+            "Putrid Vomit"
+        ],
+        "Helbrute": [
+            "Close Combat Weapon"
+        ],
+        "Icon Bearer": true,
+        "Lord of Contagion": true,
+        "Lord of Poxes": true,
+        "Lord of Virulence": true,
+        "Malignant Plaguecaster": true,
+        "Miasmic Malignifier": true,
+        "Mortarion": true,
+        "Myphitic Blight-hauler": true,
+        "Myphitic Blight-Haulers": true,
+        "Noxious Blightbringer": true,
+        "Nurglings": true,
+        "Plague Drones": [
+            "Death's Heads",
+            "Foul Mouthparts",
+            "Plaguesword"
+        ],
+        "Plague Marines": [],
+        "Plague Surgeon": true,
+        "Plaguebearers": [
+            "Plaguesword"
+        ],
+        "Plagueburst Crawler": [
+            "Plagueburst Mortar",
+            "Armoured Tracks"
+        ],
+        "Poxwalkers": true,
+        "Rotigus": true,
+        "Tallyman": true,
+        "Typhus": true
+    },
+    "Deathwatch": {
+        "Corvus Blackstar": [
+            "Armoured Hull"
+        ],
+        "Deathwatch Terminator Squad": [],
+        "Deathwatch Veterans": [],
+        "Decimus Kill Team": [
+            "Bolt Pistol",
+            "Plasma Pistol",
+            "Special-issue Bolt Pistol",
+            "Close Combat Weapon",
+            "Xenophase Blade"
+        ],
+        "Fortis Kill Team": [
+            "Castellan Launcher",
+            "Heavy Bolt Pistol",
+            "Pyreblaster"
+        ],
+        "Indomitor Kill Team": [
+            "Bolt Pistol",
+            "Close Combat Weapon",
+            "Twin Power Fists"
+        ],
+        "Spectrus Kill Team": [
+            "Bolt Pistol",
+            "Deathwatch Occulus Bolt Carbine",
+            "Special-issue Bolt Pistol",
+            "Paired Combat Blades"
+        ],
+        "Talonstrike Kill Team": [
+            "Close Combat Weapon"
+        ],
+        "Watch Captain Artemis": [
+            "Hellfire Extremis",
+            "Master-crafted Power Weapon"
+        ],
+        "Watch Master": [
+            "Vigil Spear"
+        ]
+    },
+    "Drukhari": {
+        "Archon": [
+            "Shadowfield"
+        ],
+        "Beastmaster": true,
+        "Corsair Voidreavers": [
+            "Close Combat Weapon"
+        ],
+        "Corsair Voidscarred": [
+            "Executioner",
+            "Close Combat Weapon",
+            "Paired Hekatarii Blades",
+            "Witch Staff",
+            "Channeller Stones"
+        ],
+        "Court of the Archon": true,
+        "Cronos": [
+            "Spirit Syphon",
+            "Spirit-Leech Tentacles"
+        ],
+        "Death Jester": true,
+        "Drazhar": true,
+        "Grotesques": [
+            "Monstrous Weapons"
+        ],
+        "Haemonculus": true,
+        "Hellions": [
+            "Splinter Pods"
+        ],
+        "Kharseth": [
+            "Dread of the Deep Void",
+            "Waystave"
+        ],
+        "Lady Malys": true,
+        "Lelith Hesperax": true,
+        "Mandrakes": true,
+        "Prince Yriel": [
+            "Eye of Wrath",
+            "Shuriken Pistol",
+            "Spear of Twilight"
+        ],
+        "Raider": [
+            "Bladevanes and Chainsnares"
+        ],
+        "Ravager": [
+            "Bladevanes"
+        ],
+        "Razorwing Jetfighter": [
+            "Razorwing Missiles",
+            "Bladed Wings"
+        ],
+        "Reavers": [
+            "Splinter Pistol",
+            "Bladevanes"
+        ],
+        "Scourges": [
+            "Close Combat Weapon"
+        ],
+        "Scourges with Heavy Weapons": [
+            "Close Combat Weapon"
+        ],
+        "Scourges with Shardcarbines": [
+            "Close Combat Weapon"
+        ],
+        "Shadowseer": [
+            "Miststave",
+            "Flip Belt"
+        ],
+        "Skyweavers": [
+            "Close Combat Weapon"
+        ],
+        "Solitaire": true,
+        "Starfangs": [
+            "Disintegrator Cannon",
+            "Starfang Grenade Launcher",
+            "Wraithbone Hull"
+        ],
+        "Starweaver": true,
+        "Succubus": true,
+        "Talos": [],
+        "Troupe": [
+            "Flip Belt"
+        ],
+        "Troupe Master": [
+            "Flip Belt"
+        ],
+        "Urien Rakarth": true,
+        "Venom": [
+            "Bladevanes"
+        ],
+        "Voidraven Bomber": [
+            "Bladed Wings"
+        ],
+        "Voidweaver": [
+            "Shuriken Cannon",
+            "Close Combat Weapon"
+        ]
+    },
+    "Emperor's Children": {
+        "Chaos Land Raider": [
+            "Soulshatter Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Chaos Rhino": [
+            "Armoured Tracks"
+        ],
+        "Chaos Spawn": true,
+        "Chaos Terminators": [],
+        "Daemon Prince of Slaanesh": true,
+        "Daemon Prince of Slaanesh with Wings": true,
+        "Daemonettes": [
+            "Slashing Claws"
+        ],
+        "Fiends": true,
+        "Flawless Blades": true,
+        "Fulgrim": true,
+        "Heldrake": [
+            "Heldrake Claws"
+        ],
+        "Infractors": [
+            "Duelling Sabre"
+        ],
+        "Keeper of Secrets": [
+            "Phantasmagoria",
+            "Snapping Claws",
+            "Witstealer Sword"
+        ],
+        "Lord Exultant": [],
+        "Lucius the Eternal": true,
+        "Maulerfiend": [
+            "Maulerfiend Fists"
+        ],
+        "Noise Marines": [
+            "Close Combat Weapon"
+        ],
+        "Seekers": [
+            "Lashing Tongue",
+            "Slashing Claws"
+        ],
+        "Shalaxi Helbane": true,
+        "Sorcerer": true,
+        "Tormentors": []
+    },
+    "Genestealer Cults": {
+        "Aberrants": true,
+        "Abominant": true,
+        "Achilles Ridgerunners": [
+            "Armoured Hull",
+            "Twin Heavy Stubber"
+        ],
+        "Acolyte Hybrids with Autopistols": [],
+        "Acolyte Hybrids with Hand Flamers": [],
+        "Acolyte Iconward": true,
+        "Armoured Sentinels": [
+            "Close Combat Weapon"
+        ],
+        "Artillery Team": [
+            "Lasgun",
+            "Crew Close Combat Weapons"
+        ],
+        "Attilan Rough Riders": [
+            "Lasgun",
+            "Laspistol",
+            "Steed’s Hooves"
+        ],
+        "Baneblade": [
+            "Baneblade Cannon",
+            "Coaxial Autocannon",
+            "Demolisher Cannon",
+            "Heavy Stubber",
+            "Armoured Tracks"
+        ],
+        "Banehammer": [
+            "Tremor Cannon",
+            "Armoured Tracks"
+        ],
+        "Banesword": [
+            "Quake Cannon",
+            "Armoured Tracks"
+        ],
+        "Basilisk": [
+            "Earthshaker Cannon",
+            "Armoured Tracks"
+        ],
+        "Benefictus": true,
+        "Biophagus": true,
+        "Cadian Command Squad": [
+            "Master Vox",
+            "Medi-pack"
+        ],
+        "Cadian Heavy Weapons Squad": [
+            "Laspistol",
+            "Weapons Team Close Combat Weapons"
+        ],
+        "Catachan Command Squad": [
+            "Close Combat Weapon"
+        ],
+        "Catachan Heavy Weapons Squad": [
+            "Lasgun",
+            "Weapons Team Close Combat Weapons"
+        ],
+        "Catachan Jungle Fighters": [
+            "Laspistol",
+            "Close Combat Weapon"
+        ],
+        "Centaur RSV": [
+            "Pintle-mounted Heavy Stubber",
+            "Armoured Hull"
+        ],
+        "Chimera": [
+            "Lasgun Array",
+            "Armoured Tracks"
+        ],
+        "Clamavus": true,
+        "Death Riders": true,
+        "Deathleaper": true,
+        "Deathstrike": [
+            "Deathstrike Missile",
+            "Armoured Tracks"
+        ],
+        "Doomhammer": [
+            "Magma Cannon",
+            "Armoured Tracks"
+        ],
+        "Field Ordnance Battery": [
+            "Lasgun",
+            "Laspistol",
+            "Battery Close Combat Weapons"
+        ],
+        "Gargoyles": true,
+        "Goliath Rockgrinder": [
+            "Heavy Stubber",
+            "Drilldozer blade",
+            "Demolition Charge Cache"
+        ],
+        "Goliath Truck": true,
+        "Hellhammer": [
+            "Coaxial Autocannon",
+            "Demolisher Cannon",
+            "Heavy Stubber",
+            "Hellhammer Cannon",
+            "Armoured Tracks"
+        ],
+        "Hellhound": [
+            "Armoured Tracks"
+        ],
+        "Hippogriff AFV": [
+            "Armoured Hull"
+        ],
+        "Hybrid Metamorphs": [
+            "Leader's Bio-weapons",
+            "Metamorph Mutations"
+        ],
+        "Hydra": [
+            "Hydra Autocannon",
+            "Armoured Tracks"
+        ],
+        "Hyperadapted Raveners": true,
+        "Jackal Alphus": true,
+        "Kasrkin": [
+            "Close Combat Weapon"
+        ],
+        "Kelermorph": true,
+        "Krieg Command Squad": [
+            "Lasgun",
+            "Close Combat Weapon",
+            "Master Vox",
+            "Regimental Standard",
+            "Servo-scribes"
+        ],
+        "Krieg Heavy Weapons Squad": [
+            "Laspistol",
+            "Close Combat Weapon"
+        ],
+        "Leman Russ Battle Tank": [
+            "Leman Russ Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Commander": [
+            "Armoured Tracks"
+        ],
+        "Leman Russ Demolisher": [
+            "Demolisher Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Eradicator": [
+            "Eradicator Nova Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Executioner": [
+            "Executioner Plasma Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Exterminator": [
+            "Exterminator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Punisher": [
+            "Punisher Gatling Cannon",
+            "Armoured Tracks"
+        ],
+        "Leman Russ Vanquisher": [
+            "Vanquisher Battle Cannon",
+            "Armoured Tracks"
+        ],
+        "Lictor": true,
+        "Locus": true,
+        "Magus": true,
+        "Manticore": [
+            "Storm Eagle Rockets",
+            "Armoured Tracks"
+        ],
+        "Mawloc": true,
+        "Neophyte Hybrids": [
+            "Autopistol"
+        ],
+        "Neurolictor": true,
+        "Nexos": true,
+        "Parasite Of Mortrex": true,
+        "Patriarch": true,
+        "Primaris Psyker": true,
+        "Primus": true,
+        "Purestrain Genestealers": true,
+        "Raveners": [
+            "Ravener Claws and Talons"
+        ],
+        "Reductus Saboteur": true,
+        "Rogal Dorn Battle Tank": [
+            "Armoured Tracks"
+        ],
+        "Rogal Dorn Commander": [
+            "Armoured Tracks"
+        ],
+        "Sanctus": [],
+        "Scout Sentinels": [
+            "Close Combat Weapon"
+        ],
+        "Shadowsword": [
+            "Volcano Cannon",
+            "Armoured Tracks"
+        ],
+        "Stormlord": [
+            "Heavy Stubber",
+            "Vulcan Mega-bolter",
+            "Armoured Tracks"
+        ],
+        "Stormsword": [
+            "Stormsword Siege Cannon",
+            "Armoured Tracks"
+        ],
+        "Taurox": [
+            "Twin Autocannon",
+            "Armoured Tracks"
+        ],
+        "Taurox Prime": [
+            "Armoured Tracks"
+        ],
+        "The Red Terror": [
+            "Gaping Maw",
+            "Scything Talons"
+        ],
+        "Trygon": true,
+        "Tyrannocyte": true,
+        "Von Ryan’s Leapers": true,
+        "Winged Hive Tyrant": [
+            "Tyrant Talons"
+        ],
+        "Winged Tyranid Prime": [
+            "Prime Talons"
+        ],
+        "Wyvern": [
+            "Wyvern Quad Stormshard Mortar",
+            "Armoured Tracks"
+        ]
+    },
+    "Grey Knights": {
+        "Brother-captain": [
+            "Nemesis Force Weapon"
+        ],
+        "Brother-Captain Stern": true,
+        "Brotherhood Champion": true,
+        "Brotherhood Chaplain": true,
+        "Brotherhood Librarian": [
+            "Vortex of Doom",
+            "Nemesis Force Weapon"
+        ],
+        "Brotherhood Techmarine": true,
+        "Brotherhood Terminator Squad": [
+            "Nemesis Force Weapon"
+        ],
+        "Castellan Crowe": true,
+        "Grand Master": [
+            "Nemesis Force Weapon"
+        ],
+        "Grand Master in Nemesis Dreadknight": [
+            "Fragstorm Grenade Launcher"
+        ],
+        "Grand Master Voldus": true,
+        "Grey Knights Thunderhawk Gunship": [
+            "Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Hull"
+        ],
+        "Kaldor Draigo": true,
+        "Land Raider": [
+            "Godhammer Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Land Raider Banisher": [
+            "Armoured Tracks"
+        ],
+        "Land Raider Crusader": [
+            "Hurricane Bolter",
+            "Twin Assault Cannon",
+            "Armoured Tracks"
+        ],
+        "Land Raider Redeemer": [
+            "Flamestorm Cannon",
+            "Twin Assault Cannon",
+            "Armoured Tracks"
+        ],
+        "Nemesis Dreadknight": [],
+        "Paladin Squad": [
+            "Nemesis Force Weapon"
+        ],
+        "Purifier squad": [
+            "Purifying Flame",
+            "Close Combat Weapon"
+        ],
+        "Razorback": [
+            "Armoured Tracks"
+        ],
+        "Rhino": [
+            "Armoured Tracks"
+        ],
+        "Servitors": [
+            "Servitor's Servo-arm",
+            "Servitor's Tools"
+        ],
+        "Stormhawk Interceptor": [
+            "Armoured Hull",
+            "Twin Assault Cannon"
+        ],
+        "Stormraven Gunship": [
+            "Stormstrike Missile Launcher",
+            "Armoured Hull"
+        ],
+        "Stormtalon Gunship": [
+            "Twin Assault Cannon",
+            "Armoured Hull"
+        ],
+        "Venerable Dreadnought": [
+            "Dreadnought Combat Weapon"
+        ]
+    },
+    "Imperial Fists": {
+        "Darnath Lysander": true,
+        "Pedro Kantor": true,
+        "Tor Garadon": true
+    },
+    "Imperial Knights": {
+        "Acastus Knight Asterius": [
+            "Asterius Volkite Culverin",
+            "Karacnos Mortar Battery",
+            "Twin Conversion Beam Cannon",
+            "Titanic Feet"
+        ],
+        "Acastus Knight Porphyrion": [
+            "Twin Magna Lascannon",
+            "Titanic Feet"
+        ],
+        "Armiger Helverin": [
+            "Armiger Autocannon",
+            "Armoured Feet"
+        ],
+        "Armiger Moirax": [
+            "Armoured Feet"
+        ],
+        "Armiger Warglaive": [
+            "Reaper Chain-cleaver",
+            "Thermal Spear"
+        ],
+        "Canis Rex": true,
+        "Cerastus Knight Acheron": [
+            "Acheron Flame Cannon",
+            "Twin Heavy Bolter",
+            "Reaper Chainfist"
+        ],
+        "Cerastus Knight Atrapos": [
+            "Atrapos Lascutter",
+            "Graviton Singularity Cannon"
+        ],
+        "Cerastus Knight Castigator": [
+            "Castigator Bolt Cannon",
+            "Tempest Warblade"
+        ],
+        "Cerastus Knight Lancer": [
+            "Cerastus Shock Lance"
+        ],
+        "Knight Castellan": [
+            "Plasma Decimator",
+            "Twin Meltagun",
+            "Volcano Lance",
+            "Titanic Feet"
+        ],
+        "Knight Crusader": [
+            "Avenger Gatling Cannon",
+            "Titanic Feet",
+            "Heavy Flamer"
+        ],
+        "Knight Defender": true,
+        "Knight Destrier": [
+            "Titanic Feet",
+            "Questoris Heavy Stubber"
+        ],
+        "Knight Errant": [
+            "Thermal Cannon"
+        ],
+        "Knight Gallant": [
+            "Thunderstrike Gauntlet",
+            "Reaper Chainsword"
+        ],
+        "Knight Paladin": [
+            "Rapid-Fire Battle Cannon"
+        ],
+        "Knight Preceptor": [
+            "Las-Impulsor"
+        ],
+        "Knight Valiant": [
+            "Conflagration Cannon",
+            "Thundercoil Harpoon",
+            "Twin Meltagun",
+            "Titanic Feet"
+        ],
+        "Knight Warden": [
+            "Avenger Gatling Cannon",
+            "Heavy Flamer"
+        ],
+        "Questoris Knight Magaera": [
+            "Lightning Cannon",
+            "Phased Plasma-fusil"
+        ],
+        "Questoris Knight Styrix": [
+            "Graviton Crusher",
+            "Volkite Chierovile"
+        ],
+        "Sir Hekhtur": true,
+        "Skitarii Marshal": true,
+        "Skitarii Rangers": [
+            "Close Combat Weapon"
+        ],
+        "Skitarii Vanguard": [
+            "Close Combat Weapon"
+        ],
+        "Tech-priest Dominus": [
+            "Omnissian Axe"
+        ],
+        "Tech-priest Manipulus": [
+            "Omnissian Staff"
+        ]
+    },
+    "Iron Hands": {
+        "Caanok Var": true,
+        "Iron Father Feirros": true
+    },
+    "Leagues of Votann": {
+        "Arcanyst Evaluator": true,
+        "Arkanyst Evaluator": true,
+        "Berehk Stornbröw": [
+            "Kromlôk’s Revenge",
+            "Warforge Gauntlets"
+        ],
+        "Brôkhyr Iron-master": true,
+        "Brôkhyr Thunderkyn": [
+            "Close combat weapon"
+        ],
+        "Buri Aegnirssen": true,
+        "Cthonian Earthshakers": [
+            "Autoch-pattern bolt pistol",
+            "Plasma picks"
+        ],
+        "Einhyr Champion": [
+            "Autoch-pattern combi-bolter"
+        ],
+        "Einhyr Hearthguard": [
+            "Exoarmour Grenade Launcher"
+        ],
+        "Grimnyr": true,
+        "Hearthkyn Warriors": [
+            "Weavefield crest",
+            "Autoch-pattern bolt pistol",
+            "Close combat weapon"
+        ],
+        "Hekaton Land Fortress": [
+            "Armoured wheels",
+            "MATR autocannon"
+        ],
+        "Hernkyn Pioneers": [
+            "Bolt Revolver",
+            "Bolt Shotgun",
+            "Magna-coil autocannon",
+            "Plasma knife"
+        ],
+        "Hernkyn Yaegirs": [
+            "Close combat weapon"
+        ],
+        "Ironkin Steeljacks with Heavy Volkanite Disintegrators": [
+            "Preymark crest"
+        ],
+        "Ironkin Steeljacks with Melee Weapons": [
+            "Preymark crest",
+            "Autoch-pattern bolter"
+        ],
+        "Kâhl": [
+            "Autoch-pattern Combi-bolter"
+        ],
+        "Kapricus Carrier": [
+            "Armoured hull",
+            "Magna-coil autocannon",
+            "Twin magna-coil autocannon"
+        ],
+        "Kapricus Defenders": [
+            "Armoured hull",
+            "Twin magna-coil autocannon"
+        ],
+        "Memnyr Strategist": true,
+        "Sagitaur": [
+            "Armoured wheels",
+            "Twin bolt cannon"
+        ],
+        "Ûthar the Destined": true
+    },
+    "Necrons": {
+        "Annihilation Barge": [
+            "Twin Tesla Destructor",
+            "Armoured Bulk"
+        ],
+        "C'tan Shard of the Deceiver": true,
+        "C'tan Shard of the Nightbringer": true,
+        "C'tan Shard of the Void Dragon": true,
+        "Canoptek Doomstalker": true,
+        "Canoptek Macrocytes": [
+            "Claws"
+        ],
+        "Canoptek Reanimator": true,
+        "Canoptek Scarab Swarms": true,
+        "Canoptek Spyders": [
+            "Automaton Claws"
+        ],
+        "Canoptek Tomb Crawlers": [
+            "Claws"
+        ],
+        "Canoptek Wraiths": [],
+        "Catacomb Command Barge": [],
+        "Chronomancer": true,
+        "Convergence of Dominion": true,
+        "Cryptothralls": true,
+        "Deathmarks": true,
+        "Doom Scythe": true,
+        "Doomsday Ark": true,
+        "Flayed Ones": true,
+        "Geomancer": true,
+        "Ghost Ark": true,
+        "Hexmark Destroyer": true,
+        "Illuminor Szeras": true,
+        "Immortals": [
+            "Close Combat Weapon"
+        ],
+        "Imotekh the Stormlord": true,
+        "Lokhust Destroyers": true,
+        "Lokhust Heavy Destroyers": [
+            "Close Combat Weapon"
+        ],
+        "Lychguard": [],
+        "Monolith": [
+            "Particle Whip",
+            "Portal of Exile"
+        ],
+        "Necron Warriors": [
+            "Close Combat Weapon"
+        ],
+        "Nekrosor Ammentar": true,
+        "Night Scythe": true,
+        "Obelisk": true,
+        "Ophydian Destroyers": [
+            "Ophydian Hyperphase Weapons"
+        ],
+        "Orikan the Diviner": true,
+        "Overlord": [],
+        "Overlord with Translocation Shroud": true,
+        "Plasmancer": true,
+        "Psychomancer": true,
+        "Royal Warden": true,
+        "Seraptek Heavy Construct": [
+            "Titanic Forelimbs"
+        ],
+        "Skorpekh Destroyers": [
+            "Skorpekh Hyperphase Weapons"
+        ],
+        "Skorpekh Lord": true,
+        "Technomancer": true,
+        "Tesseract Vault": true,
+        "The Silent king": true,
+        "Tomb Blades": [
+            "Close Combat Weapon"
+        ],
+        "Transcendent C'tan": true,
+        "Trazyn the Infinite": true,
+        "Triarch Praetorians": [],
+        "Triarch Stalker": [
+            "Stalker's Forelimbs"
+        ]
+    },
+    "Orks": {
+        "Battlewagon": [],
+        "Beast Snagga Boyz": [
+            "Power Snappa"
+        ],
+        "Beastboss": true,
+        "Beastboss on Squigosaur": [
+            "Slugga",
+            "Beastchoppa",
+            "Squigosaur's Jaws"
+        ],
+        "Big Mek": [],
+        "Big Mek in Mega Armour": [],
+        "Big Mek In Mega Armour": [
+            "Power Klaw"
+        ],
+        "Big Mek with Shokk Attack Gun": [
+            "Close Combat Weapon",
+            "Shokk Attack Gun"
+        ],
+        "Big'ed Bossbunka": [
+            "Gaze of Gork"
+        ],
+        "Blitza-Bommer": true,
+        "Boomdakka Snazzwagon": true,
+        "Boss Snikrot": true,
+        "Boyz": [],
+        "Breaka Boyz": [
+            "Choppa"
+        ],
+        "Burna Boyz": [
+            "Burna",
+            "Cuttin' Flames",
+            "Close Combat Weapon"
+        ],
+        "Burna-Bommer": [
+            "Twin Big Shoota",
+            "Twin Supa-Shoota",
+            "Armoured Hull"
+        ],
+        "Dakkajet": [
+            "Armoured Hull"
+        ],
+        "Deff Dread": [
+            "Stompy Feet"
+        ],
+        "Deffkilla Wartrike": true,
+        "Deffkoptas": [
+            "Slugga",
+            "Spinnin' Blades"
+        ],
+        "Flash Gitz": [
+            "Snazzgun",
+            "Choppa"
+        ],
+        "Gargantuan Squiggoth": [
+            "Huge Tusks"
+        ],
+        "Ghazghkull Thraka": true,
+        "Gorkanaut": true,
+        "Gretchin": true,
+        "Hunta Rig": true,
+        "Kill Rig": true,
+        "Killa Kans": [
+            "Kan Klaw"
+        ],
+        "Kommandos": [
+            "Bomb Squigs"
+        ],
+        "Kustom Boosta-Blasta": true,
+        "Lootas": [
+            "Close Combat Weapon",
+            "Deffgun"
+        ],
+        "Meganobz": [],
+        "Megatrakk Scrapjet": true,
+        "Mek": [
+            "Kustom-Mega Slugga"
+        ],
+        "Mek Gunz": [
+            "Grot Crew"
+        ],
+        "Morkanaut": true,
+        "Mozrog Skragbad": true,
+        "Nobz": [],
+        "Painboss": [
+            "Beast Snagga klaw"
+        ],
+        "Painboy": [
+            "Power Klaw",
+            "urty Syringe"
+        ],
+        "Rukkatrukk Squigbuggy": true,
+        "Shokkjump Dragsta": true,
+        "Squighog Boyz": [
+            "Saddlegit Weapons",
+            "Slugga",
+            "Stikka",
+            "Big Choppa",
+            "Squig Jaws",
+            "Bomb Squigs"
+        ],
+        "Stompa": true,
+        "Stormboyz": [
+            "Slugga"
+        ],
+        "Tankbustas": [
+            "Choppa",
+            "Close Combat Weapon"
+        ],
+        "Trukk": [
+            "Big Shoota",
+            "Spiked Wheels"
+        ],
+        "Warbikers": [
+            "Twin Dakkagun",
+            "Close Combat Weapon"
+        ],
+        "Warboss": [
+            "Kombi-weapon",
+            "Twin Slugga"
+        ],
+        "Warboss in Mega Armour": true,
+        "Wazbom Blastajet": [
+            "Smasha Gun",
+            "Armoured Hull"
+        ],
+        "Wazdakka Gutsmek": true,
+        "Weirdboy": true,
+        "Wurrboy": true,
+        "Zodgrod Wortsnagga": true
+    },
+    "Raven Guard": {
+        "Aethon Shaan": true,
+        "Kayvaan Shrike": true
+    },
+    "Salamanders": {
+        "Adrax Agatone": true,
+        "Vulkan He'stan": true
+    },
+    "Space Marines": {
+        "Aggressor Squad": [
+            "Twin Power Fists"
+        ],
+        "Ancient": [
+            "Bolt Pistol"
+        ],
+        "Ancient in Terminator Armour": [],
+        "Apothecary": true,
+        "Apothecary Biologis": true,
+        "Assault Intercessors with Jump Packs": [
+            "Heavy Bolt Pistol",
+            "Astartes Chainsword"
+        ],
+        "Astraeus": [
+            "Storm Bolter",
+            "Twin Macro-Accelerator Cannon",
+            "Armoured Hull"
+        ],
+        "Ballistus Dreadnought": true,
+        "Bladeguard Ancient": true,
+        "Bladeguard Veteran Squad": [
+            "Master-Crafted Power Weapon"
+        ],
+        "Brutalis Dreadnought": [
+            "Twin Icarus Ironhail Heavy Stubber"
+        ],
+        "Captain": [],
+        "Captain in Gravis Armour": [],
+        "Captain in Phobos Armour": true,
+        "Captain in Terminator Armour": [],
+        "Captain with Jump Pack": [],
+        "Centurion Assault Squad": [
+            "Siege Drills"
+        ],
+        "Centurion Devastator Squad": [
+            "Centurion Fists"
+        ],
+        "Chaplain": true,
+        "Chaplain in Terminator Armour": [
+            "Crozius Arcanum"
+        ],
+        "Chaplain Kastiel": true,
+        "Chaplain on Bike": true,
+        "Chaplain with Jump pack": [
+            "Crozius Arcanum"
+        ],
+        "Company Heroes": true,
+        "Desolation Squad": [
+            "Bolt Pistol",
+            "Castellan Launcher",
+            "Close Combat Weapon"
+        ],
+        "Devastator Squad": [
+            "Close Combat Weapon",
+            "Storm Bolter",
+            "Astartes Chainsword"
+        ],
+        "Dreadnought": [],
+        "Drop Pod": [],
+        "Eliminator Squad": [
+            "Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "Eradicator Squad": [
+            "Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "Firestrike Servo Turrets": [
+            "Close Combat Weapon"
+        ],
+        "Gladiator Lancer": [
+            "Lancer Laser Destroyer",
+            "Armoured Hull"
+        ],
+        "Gladiator Reaper": [
+            "Tempest Bolter",
+            "Twin Heavy Onslaught Gatling Cannon",
+            "Armoured Hull"
+        ],
+        "Gladiator Valiant": [
+            "Twin Las-Talon",
+            "Multi-melta",
+            "Armoured Hull"
+        ],
+        "Hammerfall Bunker": [
+            "Hammerfall Missile Launcher"
+        ],
+        "Heavy Intercessor Squad": [
+            "Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "Hellblaster Squad": [
+            "Plasma Incinerator",
+            "Close Combat Weapon"
+        ],
+        "Impulsor": [
+            "Armoured Hull"
+        ],
+        "Inceptor Squad": [
+            "Close Combat Weapon"
+        ],
+        "Incursor Squad": [
+            "Bolt Pistol",
+            "Occulus Bolt Carbine",
+            "Paired Combat Blades"
+        ],
+        "Infernus Squad": true,
+        "Infiltrator Squad": [
+            "Bolt Pistol",
+            "Marksman Bolt carbine",
+            "Close Combat Weapon"
+        ],
+        "Intercessor Squad": [
+            "Bolt Pistol"
+        ],
+        "Invader ATV": [
+            "Bolt Pistol",
+            "Twin Bolt Rifle",
+            "Close Combat Weapon"
+        ],
+        "Invictor Tactical Warsuit": [
+            "Fragstorm Grenade Launcher",
+            "Heavy Bolter",
+            "Twin Ironhail Heavy Stubber",
+            "Invictor Fist"
+        ],
+        "Judiciar": true,
+        "Judiciar Xacharus": true,
+        "Land Raider": [
+            "Godhammer Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Land Raider Crusader": [
+            "Hurricane Bolter",
+            "Twin Assault Cannon",
+            "Armoured Tracks"
+        ],
+        "Land Raider Redeemer": [
+            "Flamestorm Cannon",
+            "Twin Assault Cannon",
+            "Armoured Tracks"
+        ],
+        "Librarian": true,
+        "Librarian in Phobos Armour": true,
+        "Librarian in Terminator Armour": [
+            "Force Weapon",
+            "Smite"
+        ],
+        "Lieutenant": [],
+        "Lieutenant in Phobos Armour": true,
+        "Lieutenant in Reiver Armour": true,
+        "Lieutenant with Combi-weapon": true,
+        "Outrider Squad": [
+            "Bolt Pistol",
+            "Twin Bolt Rifle",
+            "Close Combat Weapon",
+            "Heavy Bolt Pistol",
+            "Astartes Chainsword"
+        ],
+        "Predator Annihilator": [
+            "Predator Twin Lascannon",
+            "Armoured Tracks"
+        ],
+        "Predator Destructor": [
+            "Predator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Razorback": [
+            "Armoured Tracks"
+        ],
+        "Redemptor Dreadnought": [
+            "Redemptor Fist"
+        ],
+        "Reiver Squad": [
+            "Special Issue Bolt Pistol"
+        ],
+        "Repulsor": [
+            "Hunter-Slayer Missile",
+            "Repulsor Defensive Array",
+            "Armoured Hull"
+        ],
+        "Repulsor Executioner": [
+            "Heavy Onslaught Gatling Cannon",
+            "Repulsor Executioner Defensive Array",
+            "Twin Heavy Bolter",
+            "Twin Icarus Ironhail Heavy Stubber",
+            "Armoured Hull"
+        ],
+        "Rhino": [
+            "Armoured Tracks",
+            "Storm Bolter"
+        ],
+        "Scout Squad": [
+            "Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "Sternguard Veteran Squad": [
+            "Sternguard Bolt Pistol",
+            "Close Combat Weapon"
+        ],
+        "Storm Speeder Hailstrike": true,
+        "Storm Speeder Hammerstrike": true,
+        "Storm Speeder Thunderstrike": true,
+        "Stormhawk Interceptor": [
+            "Armoured Hull",
+            "Twin Assault Cannon"
+        ],
+        "Stormraven Gunship": [
+            "Stormstrike Missile Launcher",
+            "Armoured Hull"
+        ],
+        "Stormtalon Gunship": [
+            "Twin Assault Cannon",
+            "Armoured Hull"
+        ],
+        "Suppressor Squad": true,
+        "Tactical Squad": [
+            "Close Combat Weapon"
+        ],
+        "Techmarine": true,
+        "Terminator Assault Squad": [],
+        "Terminator Squad": [],
+        "Thunderhawk Gunship": [
+            "Lascannon",
+            "Twin Heavy Bolter",
+            "Armoured Hull"
+        ],
+        "Vanguard Veteran Squad": [
+            "Bolt Pistol",
+            "Vanguard Veteran Weapon"
+        ],
+        "Vanguard Veteran Squad with Jump Packs": [
+            "Bolt Pistol",
+            "Vanguard Veteran Weapon"
+        ],
+        "Vindicator": [
+            "Demolisher Cannon",
+            "Armoured Tracks"
+        ],
+        "Whirlwind": [
+            "Whirlwind Vengeance Launcher",
+            "Armoured Tracks"
+        ]
+    },
+    "Space Wolves": {
+        "Arjac Rockfist": true,
+        "Bjorn the Fell-Handed": [
+            "Heavy Flamer",
+            "Trueclaw"
+        ],
+        "Blood Claws": [],
+        "Fenrisian Wolves": true,
+        "Grey Hunters": [
+            "Bolt Pistol"
+        ],
+        "Iron Priest": true,
+        "Logan Grimnar": true,
+        "Murderfang": true,
+        "Njal Stormcaller": true,
+        "Ragnar Blackmane": true,
+        "Thunderwolf Cavalry": [
+            "Teeth and Claws",
+            "Wolf Guard Weapon"
+        ],
+        "Ulrik the Slayer": true,
+        "Venerable Dreadnought": [],
+        "Wolf Guard Battle Leader": [],
+        "Wolf Guard Headtakers": [
+            "Heavy Bolt Pistol",
+            "Teeth and Claws"
+        ],
+        "Wolf Guard Terminators": [
+            "Power Fist"
+        ],
+        "Wolf Priest": true,
+        "Wolf Scouts": [
+            "Power Weapon",
+            "Teeth and Claws"
+        ],
+        "Wulfen": [
+            "Wulfen Weapons"
+        ],
+        "Wulfen Dreadnought": [],
+        "Wulfen with Storm Shields": [
+            "Thunder Hammer"
+        ]
+    },
+    "T'au Empire": {
+        "AX-1-0 Tiger Shark": [
+            "Twin Heavy Rail Cannon",
+            "Armoured Hull",
+            "Missile Pod"
+        ],
+        "Breacher Team": [
+            "Pulse Blaster",
+            "Pulse Pistol",
+            "Support Turret",
+            "Close Combat Weapon"
+        ],
+        "Broadside Battlesuits": [
+            "Crushing Bulk"
+        ],
+        "Cadre Fireblade": [
+            "Fireblade Pulse Rifle",
+            "Close Combat Weapon"
+        ],
+        "Commander Farsight": true,
+        "Commander in Coldstar Battlesuit": [
+            "Battlesuit fists"
+        ],
+        "Commander in Enforcer Battlesuit": [
+            "Battlesuit fists"
+        ],
+        "Commander Shadowsun": true,
+        "Crisis Fireknife Battlesuits": [
+            "Battlesuit Fists"
+        ],
+        "Crisis Starscythe Battlesuits": [
+            "Battlesuit Fists"
+        ],
+        "Crisis Sunforge Battlesuits": [
+            "Fusion Blaster",
+            "Battlesuit Fists"
+        ],
+        "Darkstrider": true,
+        "Devilfish": [
+            "Accelerator Burst Cannon",
+            "Armoured Hull"
+        ],
+        "Ethereal": [
+            "Honour Stave"
+        ],
+        "Firesight Team": [
+            "Longshot Pulse Rifles",
+            "Pulse Pistol",
+            "Close Combat Weapons"
+        ],
+        "Ghostkeel Battlesuit": [
+            "Ghostkeel Fists"
+        ],
+        "Hammerhead Gunship": [
+            "Armoured Hull"
+        ],
+        "Kroot Carnivores": [
+            "Close Combat Weapon",
+            "Kroot Pistol",
+            "Kroot Pistol",
+            "Kroot Pistol",
+            "Kroot Pistol",
+            "Kroot Pistol",
+            "Kroot Pistol",
+            "Kroot Pistol"
+        ],
+        "Kroot Farstalkers": [
+            "Ritual Blade",
+            "Close Combat Weapon",
+            "Ripping Fangs",
+            "Kroot Pistol"
+        ],
+        "Kroot Flesh Shaper": true,
+        "Kroot Hounds": true,
+        "Kroot Lone Spear": [
+            "Kalamandra's Bite",
+            "Close Combat Weapon"
+        ],
+        "Kroot Lone-Spear": [
+            "Kalamandra's Bite",
+            "Close Combat Weapon"
+        ],
+        "Kroot Trail Shaper": true,
+        "Kroot War Shaper": [
+            "Kroot Pistol",
+            "Shaper's blade",
+            "Dart-bow and Tri-blade"
+        ],
+        "Krootox rampagers": true,
+        "Krootox Riders": [
+            "Close Combat Weapon",
+            "Krootox Fists"
+        ],
+        "Manta": [
+            "Heavy Rail Cannon",
+            "Ion Cannon",
+            "Long-barrelled Burst Cannon Array",
+            "Missile Pod",
+            "Seeker Missile",
+            "Armoured Hull"
+        ],
+        "Pathfinder Team": [
+            "Pulse Pistol",
+            "Close Combat Weapon",
+            "Drone burst cannon"
+        ],
+        "Piranha": [
+            "Twin Pulse Carbine",
+            "Armoured hull"
+        ],
+        "Piranhas": [
+            "Twin Pulse Carbine",
+            "Armoured Hull"
+        ],
+        "Razorshark Strike Fighter": [
+            "Quad Ion Turret",
+            "Armoured Hull",
+            "Seeker Missile"
+        ],
+        "Riptide Battlesuit": [
+            "Riptide Fists"
+        ],
+        "Sky Ray Gunship": [
+            "Seeker missile Rack",
+            "Armoured Hull"
+        ],
+        "Stealth Battlesuits": [
+            "Battlesuit Fists"
+        ],
+        "Stormsurge": [
+            "Cluster Rocket System",
+            "Destroyer Missiles",
+            "Thunderous Footfalls",
+            "Twin Smart Missile System"
+        ],
+        "Strike Team": [
+            "Close Combat Weapon",
+            "Support turret",
+            "Pulse Pistol"
+        ],
+        "Sun Shark Bomber": [
+            "Twin Ion Rifle",
+            "Armoured Hull",
+            "Seeker Missile"
+        ],
+        "Ta'unar Supremacy Armour": [
+            "Crushing Feet",
+            "Burst Cannon",
+            "Smart Missile System"
+        ],
+        "The Twin Lance": [
+            "Fusion Eliminator",
+            "Ion Scattercannon",
+            "Shardstorm Burst System",
+            "Twin Pulse Blaster",
+            "XV Pulse Pistol",
+            "MV15 Gun Drone"
+        ],
+        "Tidewall Droneport": [
+            "Drone Defenders"
+        ],
+        "Tidewall Gunrig": [
+            "Supremacy Railgun"
+        ],
+        "Tidewall Shieldline": [],
+        "Tiger Shark": [
+            "Armoured Hull",
+            "Missile Pod"
+        ],
+        "Vespid Stingwings": [
+            "Stingwing Claws"
+        ]
+    },
+    "Thousand Sons": {
+        "Ahriman": true,
+        "Blue Horrors": true,
+        "Chaos Land Raider": [
+            "Soulshatter Lascannon",
+            "Twin Inferno Heavy Bolter",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Annihilator": [
+            "Predator Twin Lascannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Destructor": [
+            "Predator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Rhino": [
+            "Armoured Tracks"
+        ],
+        "Chaos Spawn": true,
+        "Chaos Vindicator": [
+            "Demolisher Cannon",
+            "Armoured Tracks"
+        ],
+        "Daemon Prince of Tzeentch": true,
+        "Daemon Prince of Tzeentch with Wings": true,
+        "Defiler": [
+            "Shearing Claws"
+        ],
+        "Exalted Sorcerer": [
+            "Inferno Bolt Pistol",
+            "Astral Blast",
+            "Force Weapon"
+        ],
+        "Exalted Sorcerer on Disc of Tzeentch": [
+            "Arcane Fire",
+            "Inferno Bolt Pistol",
+            "Force Weapon"
+        ],
+        "Flamers": true,
+        "Forgefiend": [],
+        "Helbrute": [
+            "Close Combat Weapon"
+        ],
+        "Heldrake": [
+            "Heldrake Claws"
+        ],
+        "Infernal Master": true,
+        "Kairos Fateweaver": true,
+        "Lord of Change": [
+            "Bolt of Change",
+            "Staff of Tzeentch"
+        ],
+        "Magnus the Red": true,
+        "Maulerfiend": [
+            "Maulerfiend Fists"
+        ],
+        "Mutalith Vortex Beast": true,
+        "Pink Horrors": [
+            "Coruscating Pink Flames",
+            "Coruscating Blue Flames",
+            "Coruscating Yellow Flames",
+            "Pink Claws",
+            "Blue Claws",
+            "Yellow Claws"
+        ],
+        "Rubric Marines": [
+            "Malefic Curse",
+            "Close Combat Weapon",
+            "Force Weapon"
+        ],
+        "Scarab Occult Terminators": [
+            "Malefic Curse",
+            "Force Weapon"
+        ],
+        "Screamers": true,
+        "Sekhetar Robots": [
+            "Heavy Warpflamer",
+            "Hellfyre Missile Rack",
+            "Close Combat Weapon"
+        ],
+        "Sorcerer": [
+            "Pandaemonic Delusion",
+            "Inferno Bolt Pistol",
+            "Force Weapon"
+        ],
+        "Sorcerer in Terminator Armour": [
+            "Gaze of Hate"
+        ],
+        "Sorcerer In Terminator Armour": [
+            "Force Weapon"
+        ],
+        "Tzaangor Enlightened": [],
+        "Tzaangor Enlightened with Fatecaster Greatbows": true,
+        "Tzaangor Shaman": true,
+        "Tzaangors": []
+    },
+    "Tyranids": {
+        "Barbgaunts": true,
+        "Biovores": true,
+        "Broodlord": true,
+        "Carnifexes": [
+            "Chitinous Claws and Teeth"
+        ],
+        "Deathleaper": true,
+        "Exocrine": true,
+        "Gargoyles": true,
+        "Genestealers": true,
+        "Harpy": [
+            "Stinger Salvoes",
+            "Scything Wings"
+        ],
+        "Harridan": [
+            "Dire Bio-cannon",
+            "Gargantuan Scything Talons"
+        ],
+        "Haruspex": true,
+        "Hierophant": [
+            "Bio-plasma Torrent",
+            "Dire Bio-cannon",
+            "Lashwhip Pods",
+            "Titanic Scything Talons"
+        ],
+        "Hive Crone": true,
+        "Hive Guard": [
+            "Chitinous Claws and Teeth"
+        ],
+        "Hive Tyrant": [],
+        "Hormagaunts": true,
+        "Hyperadapted Raveners": true,
+        "Lictor": true,
+        "Maleceptor": true,
+        "Mawloc": true,
+        "Mucolid Spores": [],
+        "Neurogaunts": true,
+        "Neurolictor": true,
+        "Neurotyrant": [
+            "Psychic Scream",
+            "Neurotyrant Claws and Lashes"
+        ],
+        "Norn Assimilator": true,
+        "Norn Emissary": true,
+        "Old One Eye": true,
+        "Parasite of Mortrex": true,
+        "Psychophage": true,
+        "Pyrovores": true,
+        "Raveners": [
+            "Ravener Claws and Talons"
+        ],
+        "Ripper Swarms": [
+            "Chitinous Claws and Teeth"
+        ],
+        "Screamer-Killer": true,
+        "Spore Mines": [],
+        "Sporocyst": true,
+        "Termagants": [
+            "Chitinous Claws and Teeth"
+        ],
+        "Tervigon": [
+            "Stinger Salvoes"
+        ],
+        "The Red Terror": [
+            "Gaping Maw",
+            "Scything Talons"
+        ],
+        "The Swarmlord": true,
+        "Toxicrene": true,
+        "Trygon": true,
+        "Tyranid Prime with Lash Whip": [
+            "Rending Claw",
+            "Lash Whip",
+            "Scything Talons"
+        ],
+        "Tyranid Warriors with Melee Bio-Weapons": true,
+        "Tyranid Warriors with Ranged Bio-weapons": [
+            "Tyranid Warrior claws and talons"
+        ],
+        "Tyrannocyte": true,
+        "Tyrannofex": [
+            "Stinger Salvoes",
+            "Powerful Limbs"
+        ],
+        "Tyrant Guard": [],
+        "Venomthropes": true,
+        "Von Ryan's Leapers": true,
+        "Winged Hive Tyrant": [
+            "Tyrant talons"
+        ],
+        "Winged Tyranid Prime": [
+            "Prime Talons"
+        ],
+        "Zoanthropes": true
+    },
+    "Ultramarines": {
+        "Captain Sicarius": true,
+        "Captain Titus": true,
+        "Cato Sicarius": true,
+        "Chief Librarian Tigurius": true,
+        "Lieutenant Titus": true,
+        "Marneus Calgar": true,
+        "Marneus Calgar in Armour of Antilochus": true,
+        "Roboute Guilliman": true,
+        "Uriel Ventris": true,
+        "Victrix Honour Guard": true,
+        "Wardens of Ultramar": true
+    },
+    "White Scars": {
+        "Kor'sarro Khan": true,
+        "Suboden Khan": true
+    },
+    "World Eaters": {
+        "Angron": true,
+        "Bloodcrushers": [
+            "Hellblade",
+            "Bladed Horn"
+        ],
+        "Bloodletters": [
+            "Hellblade"
+        ],
+        "Bloodthirster": [
+            "Hellfire Breath"
+        ],
+        "Chaos Land Raider": [
+            "Soulshatter Lascannon",
+            "Armoured Tracks",
+            "Twin Heavy Bolter"
+        ],
+        "Chaos Predator Annihilator": [
+            "Predator Twin Lascannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Predator Destructor": [
+            "Predator Autocannon",
+            "Armoured Tracks"
+        ],
+        "Chaos Rhino": [
+            "Armoured Tracks"
+        ],
+        "Chaos Spawn": true,
+        "Daemon Prince": true,
+        "Daemon Prince of Khorne": true,
+        "Daemon Prince of Khorne with Wings": true,
+        "Defiler": [
+            "Shearing Claws"
+        ],
+        "Eightbound": true,
+        "Exalted Eightbound": true,
+        "Flesh Hounds": [
+            "Burning Roar",
+            "Gore-drenched Fangs",
+            "Collar of Khorne"
+        ],
+        "Goremongers": [
+            "Close Combat Weapon"
+        ],
+        "Helbrute": [
+            "Close Combat Weapon"
+        ],
+        "Heldrake": [
+            "Heldrake Claws"
+        ],
+        "Jakhals": [
+            "Autopistol"
+        ],
+        "Khârn The Betrayer": true,
+        "Khorne Berserkers": [
+            "Bolt Pistol",
+            "Khorne Berserker",
+            "Chainblade",
+            "Berserker Chainblade"
+        ],
+        "Khorne Berzerkers": [
+            "Bolt Pistol",
+            "Khorne Berzerker",
+            "Chainblade",
+            "Berzerker Chainblade",
+            "Close Combat Weapon"
+        ],
+        "Khorne Lord of Skulls": [
+            "Great Cleaver of Khorne"
+        ],
+        "Lord Invocatus": true,
+        "Lord on Juggernaut": true,
+        "Master of Executions": true,
+        "Maulerfiend": [
+            "Maulerfiend fists"
+        ],
+        "Skarbrand": true,
+        "Slaughterbound": true
+    }
+}