Android build v1.1.9

AGENTS.md

@@ -1,9 +1,35 @@
 # Project Notes
 
+## Target Hardware: AYN Thor
+
 - AYN Thor main display: 6-inch AMOLED, 1920 x 1080, 120Hz.
 - AYN Thor secondary display: 3.92-inch AMOLED, 1240 x 1080, 60Hz.
 - AYN Thor UI sizing must be designed against Android CSS/layout viewport, not physical framebuffer pixels.
 - Approximate Thor CSS viewports: main display 960 x 540, secondary display 620 x 540.
 - Test top-screen UI only against the main display viewport, and bottom-screen UI only against the secondary display viewport.
-- User rebuilds app; do not rebuild APK unless explicitly requested.
+
+## Input Requirements
+
+- Every game screen, menu, dialog, overlay, and gameplay interaction must be fully navigable by controller at all times.
+- Controller navigation must not depend on touch, mouse, keyboard, or hidden developer-only shortcuts.
+- Focus state must always be visible and predictable when controller navigation is active.
+- Avoid interaction patterns that trap focus, lose focus, or require precise pointer input.
+
+## Architecture Requirements
+
+- Keep systems modular and scoped by responsibility.
+- Prefer small reusable modules/components over large files with mixed concerns.
+- Keep shared game logic independent from platform-specific web or mobile wrappers whenever practical.
 - Apply game changes to both web version and mobile app version.
+
+## Performance Requirements
+
+- Treat CPU, GPU, memory, battery, and startup cost as first-class constraints.
+- Avoid unnecessary per-frame allocations, polling, timers, layout work, and re-renders.
+- Keep assets sized appropriately for Thor displays; do not ship oversized textures, images, audio, or data blobs without need.
+- Prefer event-driven updates and cached calculations for UI and game systems.
+- Profile or measure when changing hot paths, rendering, animation, input handling, asset loading, or persistent state.
+
+## Build Requirements
+
+- User rebuilds app; do not rebuild APK unless explicitly requested.

android/app/build.gradle

@@ -7,8 +7,8 @@ android {
         applicationId "com.warren.iwanttoheal"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 84
+        versionCode 88
-        versionName "1.1.5"
+        versionName "1.1.9"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.

android/app/src/main/java/com/warren/iwanttoheal/ControllerBridgeActivity.java

@@ -7,19 +7,27 @@ import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.SystemClock;
+import android.view.InputDevice;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import com.getcapacitor.BridgeActivity;
 import java.io.File;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 public abstract class ControllerBridgeActivity extends BridgeActivity {
 
     public static final String EXTRA_INITIAL_URL = "com.warren.iwanttoheal.INITIAL_URL";
     private static final String PREFS_NAME = "com.warren.iwanttoheal.performance";
     private static final String CACHE_CLEARED_VERSION_KEY = "webview_cache_cleared_version";
-    private static final long DPAD_THROTTLE_MS = 220;
+    private static final float AXIS_DEAD_ZONE = 0.45f;
-    private long lastDpadDispatchAt = 0;
+    private static final long DPAD_THROTTLE_MS = 55;
+    private final long[] lastDpadDispatchAt = new long[16];
+    private final Set<String> activeMotionTokens = new HashSet<>();
+    private final Map<String, Long> lastMotionDispatchAt = new HashMap<>();
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
@@ -139,7 +147,88 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
 
         if (event.getAction() == KeyEvent.ACTION_DOWN) {
             boolean repeat = event.getRepeatCount() > 0;
-            if (isDpadToken(token) && shouldThrottleDpad()) return true;
+            if (isDpadToken(token) && shouldThrottleDpad(token)) return true;
+            dispatchNativeControllerToken(token, repeat);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean dispatchGenericMotionEvent(MotionEvent event) {
+        if (
+            bridge == null
+                || event.getActionMasked() != MotionEvent.ACTION_MOVE
+                || !isControllerMotionEvent(event)
+        ) {
+            return super.dispatchGenericMotionEvent(event);
+        }
+
+        Set<String> currentTokens = new HashSet<>();
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_HAT_X),
+            "Button14",
+            "Button15"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_HAT_Y),
+            "Button12",
+            "Button13"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_X),
+            "Axis0-",
+            "Axis0+"
+        );
+        addAxisTokens(
+            currentTokens,
+            event.getAxisValue(MotionEvent.AXIS_Y),
+            "Axis1-",
+            "Axis1+"
+        );
+
+        boolean hadMotionTokens = !activeMotionTokens.isEmpty();
+        long now = SystemClock.uptimeMillis();
+        for (String token : currentTokens) {
+            boolean repeat = activeMotionTokens.contains(token);
+            long lastDispatchAt = lastMotionDispatchAt.containsKey(token)
+                ? lastMotionDispatchAt.get(token)
+                : 0L;
+            if (!repeat || now - lastDispatchAt >= DPAD_THROTTLE_MS) {
+                dispatchNativeControllerToken(token, repeat);
+                lastMotionDispatchAt.put(token, now);
+            }
+        }
+        activeMotionTokens.clear();
+        activeMotionTokens.addAll(currentTokens);
+
+        if (currentTokens.isEmpty() && !hadMotionTokens) {
+            return super.dispatchGenericMotionEvent(event);
+        }
+        return true;
+    }
+
+    private boolean isControllerMotionEvent(MotionEvent event) {
+        int source = event.getSource();
+        return (source & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK
+            || (source & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD
+            || (source & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD;
+    }
+
+    private void addAxisTokens(
+        Set<String> tokens,
+        float value,
+        String negativeToken,
+        String positiveToken
+    ) {
+        if (value <= -AXIS_DEAD_ZONE) tokens.add(negativeToken);
+        if (value >= AXIS_DEAD_ZONE) tokens.add(positiveToken);
+    }
+
+    private void dispatchNativeControllerToken(String token, boolean repeat) {
+        if (bridge == null || bridge.getWebView() == null) return;
         String script =
             "window.dispatchEvent(new CustomEvent('ashen-halls-native-controller',"
                 + "{detail:{token:'" + token + "',repeat:" + repeat + "}}));";
@@ -150,13 +239,12 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
             }
         );
     }
-        return true;
-    }
 
-    private boolean shouldThrottleDpad() {
+    private boolean shouldThrottleDpad(String token) {
+        int buttonIndex = Integer.parseInt(token.substring("Button".length()));
         long now = SystemClock.uptimeMillis();
-        if (now - lastDpadDispatchAt < DPAD_THROTTLE_MS) return true;
+        if (now - lastDpadDispatchAt[buttonIndex] < DPAD_THROTTLE_MS) return true;
-        lastDpadDispatchAt = now;
+        lastDpadDispatchAt[buttonIndex] = now;
         return false;
     }
 
@@ -170,10 +258,13 @@ public abstract class ControllerBridgeActivity extends BridgeActivity {
     private String controllerToken(int keyCode) {
         switch (keyCode) {
             case KeyEvent.KEYCODE_BUTTON_A:
+            case KeyEvent.KEYCODE_DPAD_CENTER:
             case KeyEvent.KEYCODE_ENTER:
+            case KeyEvent.KEYCODE_NUMPAD_ENTER:
                 return "Button0";
             case KeyEvent.KEYCODE_BUTTON_B:
             case KeyEvent.KEYCODE_BACK:
+            case KeyEvent.KEYCODE_ESCAPE:
                 return "Button1";
             case KeyEvent.KEYCODE_BUTTON_X:
                 return "Button2";

db/schema.sql

@@ -254,6 +254,20 @@ CREATE TABLE IF NOT EXISTS character_inventory (
   PRIMARY KEY (character_id, item_id)
 );
 
+CREATE TABLE IF NOT EXISTS character_boss_stats (
+  character_id INTEGER NOT NULL REFERENCES characters(id) ON DELETE CASCADE,
+  encounter_id INTEGER NOT NULL REFERENCES encounters(id) ON DELETE CASCADE,
+  kills INTEGER NOT NULL DEFAULT 0 CHECK (kills >= 0),
+  pet_quantity INTEGER NOT NULL DEFAULT 0 CHECK (pet_quantity >= 0),
+  PRIMARY KEY (character_id, encounter_id)
+);
+
+CREATE TABLE IF NOT EXISTS character_pvp_stats (
+  character_id INTEGER PRIMARY KEY REFERENCES characters(id) ON DELETE CASCADE,
+  matches_played INTEGER NOT NULL DEFAULT 0 CHECK (matches_played >= 0),
+  matches_won INTEGER NOT NULL DEFAULT 0 CHECK (matches_won >= 0)
+);
+
 CREATE TABLE IF NOT EXISTS action_characters (
   id INTEGER PRIMARY KEY,
   account_id INTEGER REFERENCES accounts(id) ON DELETE CASCADE,

package-lock.json

@@ -16,6 +16,7 @@
       "devDependencies": {
         "@capacitor/cli": "^8.4.0",
         "@eslint/js": "^10.0.1",
+        "@playwright/test": "^1.61.1",
         "@types/node": "^24.12.3",
         "@types/react": "^19.2.14",
         "@types/react-dom": "^19.2.3",
@@ -801,6 +802,22 @@
         "url": "https://github.com/sponsors/Boshen"
       }
     },
+    "node_modules/@playwright/test": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.61.1.tgz",
+      "integrity": "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.61.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@rolldown/binding-android-arm64": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.3.tgz",
@@ -2972,6 +2989,53 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/playwright": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.1.tgz",
+      "integrity": "sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.61.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.61.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.61.1.tgz",
+      "integrity": "sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/playwright/node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/plist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.1.tgz",

package.json

@@ -34,6 +34,7 @@
   "devDependencies": {
     "@capacitor/cli": "^8.4.0",
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.61.1",
     "@types/node": "^24.12.3",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",

server/catalog.mjs

@@ -55,6 +55,12 @@ export function normalizeCatalogProfile(profile) {
     })),
     craftingRecipes: profile.craftingRecipes.map(normalizeRecipe),
     dungeons: profile.dungeons.map(normalizeDungeon),
+    hunterStats: {
+      bossKills: {},
+      bossPets: {},
+      pvpMatchesPlayed: 0,
+      pvpMatchesWon: 0,
+    },
   }
 }
 

server/game-api.mjs

@@ -815,6 +815,21 @@ export function getProfile(database, characterId, accountId) {
       AND completed_parts >= 1
     GROUP BY dungeon_id
   `).all(characterId).map((row) => [row.dungeonId, row.count]))
+  const bossStatRows = database.prepare(`
+    SELECT
+      encounter_id AS encounterId,
+      kills,
+      pet_quantity AS petQuantity
+    FROM character_boss_stats
+    WHERE character_id = ?
+  `).all(characterId)
+  const pvpStats = database.prepare(`
+    SELECT
+      matches_played AS matchesPlayed,
+      matches_won AS matchesWon
+    FROM character_pvp_stats
+    WHERE character_id = ?
+  `).get(characterId)
 
   const settings = Object.fromEntries(
     database.prepare('SELECT key, value FROM game_settings').all()
@@ -930,6 +945,12 @@ export function getProfile(database, characterId, accountId) {
           .map((run) => ({ ...run, rank: Number(run.rank) })),
       },
     })),
+    hunterStats: {
+      bossKills: Object.fromEntries(bossStatRows.map((row) => [String(row.encounterId), row.kills])),
+      bossPets: Object.fromEntries(bossStatRows.map((row) => [String(row.encounterId), row.petQuantity])),
+      pvpMatchesPlayed: pvpStats?.matchesPlayed ?? 0,
+      pvpMatchesWon: pvpStats?.matchesWon ?? 0,
+    },
   }
 }
 
@@ -1025,8 +1046,18 @@ function buildSyncSave(database, accountId, activeCharacterId) {
   const characterName = characters.find((candidate) => candidate.id === activeCharacterId)?.name
     ?? characters[0]?.name
     ?? 'Mira'
+  const bossStats = database.prepare(`
+    SELECT encounter_id AS encounterId, kills, pet_quantity AS petQuantity
+    FROM character_boss_stats
+    WHERE character_id = ?
+  `).all(activeCharacterId)
+  const pvpStats = database.prepare(`
+    SELECT matches_played AS matchesPlayed, matches_won AS matchesWon
+    FROM character_pvp_stats
+    WHERE character_id = ?
+  `).get(activeCharacterId)
   return {
-    version: 3,
+    version: 4,
     characterName,
     activeClassId,
     completedDungeonParts: account?.completedDungeonParts ?? 0,
@@ -1038,6 +1069,10 @@ function buildSyncSave(database, accountId, activeCharacterId) {
       ]),
     ),
     lootRolls: {},
+    bossKills: Object.fromEntries(bossStats.map((row) => [String(row.encounterId), row.kills])),
+    bossPets: Object.fromEntries(bossStats.map((row) => [String(row.encounterId), row.petQuantity])),
+    pvpMatchesPlayed: pvpStats?.matchesPlayed ?? 0,
+    pvpMatchesWon: pvpStats?.matchesWon ?? 0,
   }
 }
 
@@ -1052,7 +1087,7 @@ function importSyncSave(database, accountId, activeCharacterId, payload) {
   if (
     !save
     || typeof save !== 'object'
-    || Number(save.version) !== 3
+    || (Number(save.version) !== 4 && Number(save.version) !== 3)
     || typeof save.characterName !== 'string'
     || !save.characters
     || typeof save.characters !== 'object'
@@ -1149,6 +1184,10 @@ function importSyncSave(database, accountId, activeCharacterId, payload) {
       INSERT INTO character_inventory (character_id, item_id, quantity, equipped)
       VALUES (?, ?, ?, ?)
     `)
+    const insertBossStats = database.prepare(`
+      INSERT INTO character_boss_stats (character_id, encounter_id, kills, pet_quantity)
+      VALUES (?, ?, ?, ?)
+    `)
 
     for (const classId of classIds) {
       const local = save.characters[classId]
@@ -1213,6 +1252,14 @@ function importSyncSave(database, accountId, activeCharacterId, payload) {
         DELETE FROM character_inventory
         WHERE character_id = ?
       `).run(characterId)
+      database.prepare(`
+        DELETE FROM character_boss_stats
+        WHERE character_id = ?
+      `).run(characterId)
+      database.prepare(`
+        DELETE FROM character_pvp_stats
+        WHERE character_id = ?
+      `).run(characterId)
       const inventoryByItemId = new Map()
       const equippedSlots = new Set()
       for (const item of Array.isArray(local.inventory) ? local.inventory : []) {
@@ -1235,6 +1282,34 @@ function importSyncSave(database, accountId, activeCharacterId, payload) {
       for (const [itemId, itemState] of inventoryByItemId) {
         insertInventory.run(characterId, itemId, itemState.quantity, itemState.equipped ? 1 : 0)
       }
+      if (classId === Number(save.activeClassId)) {
+        const bossKills = save.bossKills && typeof save.bossKills === 'object' ? save.bossKills : {}
+        const bossPets = save.bossPets && typeof save.bossPets === 'object' ? save.bossPets : {}
+        for (const [encounterId, rawKills] of Object.entries(bossKills)) {
+          const id = Number(encounterId)
+          if (!Number.isInteger(id)) continue
+          insertBossStats.run(
+            characterId,
+            id,
+            clampInteger(rawKills, 0, 0, 1000000),
+            clampInteger(bossPets[encounterId], 0, 0, 1000000),
+          )
+        }
+        for (const [encounterId, rawPets] of Object.entries(bossPets)) {
+          if (Object.hasOwn(bossKills, encounterId)) continue
+          const id = Number(encounterId)
+          if (!Number.isInteger(id)) continue
+          insertBossStats.run(characterId, id, 0, clampInteger(rawPets, 0, 0, 1000000))
+        }
+        database.prepare(`
+          INSERT INTO character_pvp_stats (character_id, matches_played, matches_won)
+          VALUES (?, ?, ?)
+        `).run(
+          characterId,
+          clampInteger(save.pvpMatchesPlayed, 0, 0, 1000000),
+          clampInteger(save.pvpMatchesWon, 0, 0, 1000000),
+        )
+      }
     }
 
     let syncedClassId = clampInteger(

src/App.css

@@ -1433,6 +1433,14 @@ textarea:focus-visible,
   display: none;
 }
 
+.game-shell.settings-shell {
+  padding: 6px 0;
+}
+
+.game-shell.settings-shell > .app-header {
+  display: none;
+}
+
 .auth-shell {
   align-items: center;
   display: flex;
@@ -1988,6 +1996,14 @@ h2 {
   outline-color: var(--gold);
 }
 
+.settings-nav {
+  align-items: stretch;
+  display: grid;
+  gap: 8px;
+  grid-template-columns: minmax(92px, auto) minmax(0, 1fr);
+  margin-top: 0;
+}
+
 .settings-tabs,
 .talent-page-tabs {
   display: grid;
@@ -1996,6 +2012,10 @@ h2 {
   margin-top: 14px;
 }
 
+.settings-tabs {
+  margin-top: 0;
+}
+
 .settings-tabs button,
 .talent-page-tabs button {
   background: #15161c;
@@ -2025,9 +2045,15 @@ h2 {
   height: calc(100dvh - 92px);
 }
 
+.settings-shell .settings-screen {
+  height: calc(100dvh - 12px);
+  margin-top: 0;
+}
+
 .settings-tab-panel {
   flex: 1;
   min-height: 0;
+  overflow: auto;
 }
 
 .settings-bindings-panel {
@@ -2045,6 +2071,7 @@ h2 {
 .settings-bindings-panel .binding-list {
   flex: 1;
   min-height: 0;
+  overflow-y: auto;
 }
 
 .equipment-screen .gear-summary,
@@ -6950,6 +6977,95 @@ h2 {
     font-size: 15px;
   }
 
+  .auth-shell {
+    height: 100dvh;
+    min-height: 0;
+    overflow: hidden;
+    padding: 10px;
+  }
+
+  .auth-panel {
+    gap: 12px;
+    max-height: calc(100dvh - 20px);
+  }
+
+  .auth-brand,
+  .auth-card {
+    padding: 14px;
+  }
+
+  .auth-brand {
+    min-height: 0;
+  }
+
+  .auth-brand h1 {
+    font-size: 28px;
+    line-height: 1.15;
+    margin: 6px 0 10px;
+  }
+
+  .auth-brand > p:last-child {
+    font-size: 17px;
+    line-height: 1.15;
+  }
+
+  .auth-tabs {
+    gap: 5px;
+  }
+
+  .auth-tabs button {
+    min-height: 34px;
+  }
+
+  .auth-card form {
+    gap: 8px;
+    margin-top: 10px;
+  }
+
+  .auth-card label {
+    gap: 5px;
+  }
+
+  .auth-card input {
+    font-size: 16px;
+    padding: 7px 9px;
+  }
+
+  .auth-card .primary-button {
+    min-height: 34px;
+    padding: 8px 12px;
+  }
+
+  .auth-message {
+    font-size: 13px;
+    line-height: 1.1;
+    margin-top: 8px;
+    min-height: 24px;
+  }
+
+  .offline-divider {
+    gap: 8px;
+    margin: 8px 0;
+  }
+
+  .offline-entry {
+    gap: 7px;
+    padding: 10px;
+  }
+
+  .offline-entry p:not(.eyebrow) {
+    display: none;
+  }
+
+  .offline-entry h2 {
+    font-size: 9px;
+  }
+
+  .offline-resume-button,
+  .offline-new-button {
+    min-height: 32px;
+  }
+
   .screen-heading {
     padding-bottom: 10px;
   }
@@ -6962,6 +7078,178 @@ h2 {
     font-size: 16px;
   }
 
+  .settings-screen {
+    padding: 10px;
+  }
+
+  .settings-shell .settings-screen {
+    height: calc(100dvh - 12px);
+  }
+
+  .settings-nav {
+    gap: 6px;
+    grid-template-columns: minmax(76px, auto) minmax(0, 1fr);
+  }
+
+  .settings-tabs {
+    gap: 6px;
+  }
+
+  .settings-tabs button,
+  .settings-back-button {
+    font-size: 7px;
+    min-height: 32px;
+    padding: 5px 8px;
+  }
+
+  .settings-tab-panel {
+    scrollbar-width: thin;
+  }
+
+  .dual-screen-settings,
+  .controller-preferences {
+    gap: 10px;
+    margin: 8px 0 0;
+    padding: 10px;
+  }
+
+  .dual-screen-settings.settings-tab-panel,
+  .controller-preferences.settings-tab-panel {
+    flex: 0 0 auto;
+  }
+
+  .dual-screen-settings {
+    align-items: start;
+    grid-template-columns: minmax(0, 1fr) minmax(214px, auto);
+  }
+
+  .dual-screen-settings h2,
+  .settings-heading h2 {
+    font-size: 12px;
+  }
+
+  .dual-screen-settings p:not(.eyebrow),
+  .controller-preferences p:not(.eyebrow) {
+    font-size: 14px;
+    line-height: 1.15;
+    margin-top: 4px;
+  }
+
+  .dual-screen-settings > small {
+    font-size: 13px;
+  }
+
+  .dual-screen-actions {
+    align-content: start;
+    align-self: start;
+    gap: 7px;
+    min-width: 214px;
+  }
+
+  .dual-screen-actions button,
+  .controller-preferences button {
+    min-height: 32px;
+    padding: 5px 8px;
+  }
+
+  .controller-preferences {
+    align-items: stretch;
+    align-content: start;
+    grid-template-columns: minmax(0, 1fr) repeat(2, minmax(158px, auto));
+  }
+
+  .controller-preferences h3 {
+    color: var(--ink);
+    font-family: var(--pixel-font);
+    font-size: 10px;
+    line-height: 1.35;
+    margin: 0;
+  }
+
+  .controller-icon-options {
+    gap: 6px;
+    grid-template-columns: minmax(112px, 1fr) repeat(3, minmax(104px, auto));
+    padding: 6px;
+  }
+
+  .controller-icon-options > span {
+    font-size: 7px;
+  }
+
+  .controller-icon-options button {
+    font-size: 6px;
+    gap: 5px;
+  }
+
+  .controller-style-preview .controller-face-icon {
+    height: 18px;
+    min-width: 18px;
+  }
+
+  .controller-style-preview .controller-face-playstation {
+    font-size: 19px;
+  }
+
+  .settings-bindings-panel .settings-heading {
+    padding: 4px 0 5px;
+  }
+
+  .settings-heading > p {
+    font-size: 13px;
+  }
+
+  .settings-heading .eyebrow {
+    display: none;
+  }
+
+  .binding-tabs {
+    gap: 7px;
+    margin: 6px 0;
+  }
+
+  .binding-tabs button {
+    min-height: 28px;
+  }
+
+  .binding-list {
+    gap: 4px;
+    padding-right: 4px;
+  }
+
+  .binding-list button {
+    min-height: 24px;
+    padding: 3px 8px;
+  }
+
+  .binding-list button > span {
+    font-size: 12px;
+  }
+
+  .binding-list kbd {
+    font-size: 6px;
+    min-height: 18px;
+  }
+
+  .binding-list .controller-face-icon {
+    font-size: 10px;
+    height: 17px;
+    min-width: 17px;
+  }
+
+  .binding-list .controller-face-playstation {
+    font-size: 18px;
+  }
+
+  .settings-footer {
+    font-size: 13px;
+    margin-top: 6px;
+    padding-top: 6px;
+  }
+
+  .settings-footer .text-button {
+    padding: 6px 9px;
+  }
+
   .dungeon-card {
     gap: 12px;
     grid-template-columns: 72px 1fr;
@@ -7141,6 +7429,127 @@ h2 {
   .ability-library {
     max-height: 190px;
   }
+
+  .enemy-card {
+    gap: 10px;
+    margin-top: 8px;
+    padding: 8px;
+  }
+
+  .enemy-portrait {
+    flex-basis: 48px;
+    font-size: 17px;
+    height: 48px;
+  }
+
+  .enemy-info p {
+    font-size: 14px;
+    line-height: 1;
+    margin-top: 4px;
+    max-height: 28px;
+    overflow: hidden;
+  }
+
+  .bar-label {
+    font-size: 15px;
+  }
+
+  .combat-layout {
+    gap: 8px;
+    grid-template-columns: minmax(0, 1.6fr) minmax(248px, 0.85fr);
+    margin-top: 8px;
+    min-height: 0;
+  }
+
+  .party-panel,
+  .combat-log {
+    min-height: 0;
+    padding: 8px;
+  }
+
+  .party-panel-top {
+    margin-bottom: 6px;
+  }
+
+  .party-grid {
+    gap: 7px;
+    margin-top: 8px;
+  }
+
+  .party-member {
+    min-height: 72px;
+    padding: 7px;
+  }
+
+  .member-header {
+    gap: 5px;
+  }
+
+  .member-header small {
+    font-size: 12px;
+  }
+
+  .member-health {
+    margin-top: 5px;
+  }
+
+  .member-effects {
+    gap: 3px;
+    margin-top: 4px;
+    min-height: 14px;
+  }
+
+  .member-effects span {
+    font-size: 11px;
+    padding: 0 4px;
+  }
+
+  .combat-side-rail .panel-heading .eyebrow {
+    display: none;
+  }
+
+  .combat-side-rail .panel-heading h2 {
+    font-size: 10px;
+  }
+
+  .vertical-spell-bar,
+  .vertical-spell-bar.six-slots {
+    gap: 6px;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    margin-top: 8px;
+    overflow: hidden;
+    padding-right: 0;
+  }
+
+  .vertical-spell-bar .spell {
+    min-height: 54px;
+    padding: 5px 5px 5px 36px;
+  }
+
+  .vertical-spell-bar .spell-icon {
+    font-size: 10px;
+    height: 22px;
+    left: 6px;
+    width: 22px;
+  }
+
+  .vertical-spell-bar .spell strong {
+    font-size: 11px;
+    line-height: 1.1;
+  }
+
+  .vertical-spell-bar .spell small {
+    font-size: 10px;
+    line-height: 1;
+  }
+
+  .vertical-spell-bar .spell kbd {
+    font-size: 8px;
+    min-height: 16px;
+    padding: 1px 4px;
+    right: 3px;
+    top: 3px;
+  }
 }
 
 @media (max-width: 800px) {
@@ -9260,3 +9669,300 @@ h2 {
     grid-template-columns: repeat(5, minmax(0, 1fr));
   }
 }
+
+.hunter-profile-screen {
+  gap: 14px;
+}
+
+.hunter-profile-heading {
+  align-items: center;
+}
+
+.hunter-profile-tabs {
+  align-self: auto;
+}
+
+.hunter-stat-grid {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.hunter-stat-tile {
+  display: flex;
+  min-height: 118px;
+  flex-direction: column;
+  justify-content: center;
+  gap: 8px;
+  padding: 16px;
+  border: 1px solid rgba(229, 185, 95, 0.24);
+  border-radius: 8px;
+  background: rgba(19, 24, 31, 0.84);
+  box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.03);
+}
+
+.hunter-stat-tile span,
+.hunter-stat-tile small {
+  color: rgba(238, 232, 210, 0.68);
+  font-size: 0.74rem;
+  text-transform: uppercase;
+}
+
+.hunter-stat-tile strong {
+  color: #f4df9b;
+  font-size: 1.45rem;
+  line-height: 1.08;
+}
+
+.collection-log-layout {
+  display: grid;
+  grid-template-columns: 250px minmax(0, 1fr);
+  gap: 14px;
+  min-height: 0;
+}
+
+.collection-boss-list {
+  display: flex;
+  min-height: 0;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.collection-drop-list {
+  display: grid;
+  grid-template-columns: repeat(6, minmax(0, 1fr));
+  gap: 6px;
+  min-height: 0;
+}
+
+.collection-boss-list {
+  max-height: min(58vh, 420px);
+  overflow: auto;
+  padding-right: 4px;
+}
+
+.collection-boss-button {
+  display: grid;
+  grid-template-columns: 42px minmax(0, 1fr);
+  gap: 8px 10px;
+  align-items: center;
+  min-height: 64px;
+  padding: 10px;
+  border: 1px solid rgba(238, 232, 210, 0.12);
+  border-radius: 8px;
+  background: rgba(14, 18, 24, 0.78);
+  color: #eee8d2;
+  text-align: left;
+}
+
+.collection-boss-button:hover,
+.collection-boss-button:focus-visible,
+.collection-boss-button.selected {
+  border-color: rgba(229, 185, 95, 0.62);
+  background: rgba(46, 40, 28, 0.92);
+}
+
+.collection-boss-button > span,
+.collection-boss-header > span,
+.collection-drop-row > span {
+  display: grid;
+  width: 42px;
+  height: 42px;
+  place-items: center;
+  border-radius: 8px;
+  background: rgba(229, 185, 95, 0.14);
+  color: #f4df9b;
+  font-weight: 800;
+}
+
+.collection-boss-button strong,
+.collection-boss-button small {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.collection-boss-button small {
+  grid-column: 2;
+  color: rgba(238, 232, 210, 0.66);
+  font-size: 0.76rem;
+}
+
+.collection-boss-detail {
+  display: flex;
+  min-height: 0;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px;
+  border: 1px solid rgba(229, 185, 95, 0.2);
+  border-radius: 8px;
+  background: rgba(19, 24, 31, 0.84);
+}
+
+.collection-boss-header {
+  display: grid;
+  grid-template-columns: 54px minmax(0, 1fr);
+  gap: 12px;
+  align-items: center;
+}
+
+.collection-boss-header > span {
+  width: 54px;
+  height: 54px;
+}
+
+.collection-boss-header h2 {
+  margin: 0;
+  color: #f4df9b;
+  font-size: 1.35rem;
+}
+
+.collection-boss-header small {
+  color: rgba(238, 232, 210, 0.68);
+}
+
+.collection-drop-row {
+  display: grid;
+  grid-template-columns: 1fr;
+  grid-template-rows: 24px minmax(28px, 1fr) auto auto;
+  gap: 4px;
+  align-items: center;
+  justify-items: start;
+  min-height: 84px;
+  padding: 7px;
+  border: 1px solid rgba(238, 232, 210, 0.1);
+  border-radius: 8px;
+  background: rgba(9, 12, 17, 0.52);
+  color: #eee8d2;
+  text-align: left;
+}
+
+.collection-drop-row strong {
+  align-self: center;
+  min-width: 0;
+  font-size: 0.7rem;
+  line-height: 1.08;
+}
+
+.collection-drop-row small {
+  color: rgba(238, 232, 210, 0.68);
+  font-size: 0.64rem;
+  font-weight: 700;
+}
+
+.collection-drop-row b {
+  align-self: end;
+  color: #f4df9b;
+  font-size: 0.86rem;
+  line-height: 1;
+}
+
+.collection-drop-row > span {
+  width: 24px;
+  height: 24px;
+  border-radius: 6px;
+  font-size: 0.72rem;
+}
+
+.collection-drop-row.missing {
+  border-color: rgba(238, 232, 210, 0.08);
+  background: rgba(10, 12, 16, 0.38);
+  opacity: 0.46;
+}
+
+.collection-drop-row.missing > span {
+  background: rgba(238, 232, 210, 0.08);
+  color: rgba(238, 232, 210, 0.54);
+}
+
+.collection-drop-row.missing strong,
+.collection-drop-row.missing small,
+.collection-drop-row.missing b {
+  color: rgba(238, 232, 210, 0.58);
+}
+
+.collection-drop-row.owned {
+  border-color: rgba(229, 185, 95, 0.32);
+}
+
+.collection-drop-row:focus-visible {
+  outline: 2px solid #f4df9b;
+  outline-offset: 2px;
+}
+
+.collection-drop-row.collection-rarity-common {
+  border-color: rgba(238, 232, 210, 0.28);
+}
+
+.collection-drop-row.collection-rarity-stat {
+  border-color: rgba(229, 185, 95, 0.46);
+}
+
+.collection-drop-row.collection-rarity-stat > span {
+  background: rgba(229, 185, 95, 0.16);
+  color: #f4df9b;
+}
+
+.collection-drop-row.collection-rarity-common > span {
+  background: rgba(238, 232, 210, 0.1);
+}
+
+.collection-drop-row.collection-rarity-uncommon {
+  border-color: rgba(79, 204, 126, 0.56);
+}
+
+.collection-drop-row.collection-rarity-uncommon > span {
+  background: rgba(79, 204, 126, 0.14);
+  color: #7feb9f;
+}
+
+.collection-drop-row.collection-rarity-rare {
+  border-color: rgba(113, 208, 255, 0.6);
+}
+
+.collection-drop-row.collection-rarity-rare > span {
+  background: rgba(113, 208, 255, 0.14);
+  color: #9bdcff;
+}
+
+.collection-drop-row.collection-rarity-epic {
+  border-color: rgba(193, 134, 255, 0.62);
+}
+
+.collection-drop-row.collection-rarity-epic > span {
+  background: rgba(193, 134, 255, 0.16);
+  color: #d9b6ff;
+}
+
+.collection-drop-row.collection-rarity-legendary {
+  border-color: rgba(245, 159, 75, 0.64);
+}
+
+.collection-drop-row.collection-rarity-legendary > span {
+  background: rgba(245, 159, 75, 0.16);
+  color: #ffc078;
+}
+
+@media (max-width: 760px) {
+  .collection-log-layout {
+    grid-template-columns: 1fr;
+  }
+
+  .hunter-stat-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .hunter-stat-grid {
+    gap: 8px;
+  }
+
+  .hunter-stat-tile {
+    min-height: 78px;
+    padding: 12px;
+  }
+
+  .collection-boss-list {
+    max-height: 190px;
+  }
+}

src/App.tsx

@@ -25,6 +25,7 @@ import { barFillStyle } from './components/barStyles'
 const CombatScreen = lazy(() => import('./components/CombatScreen').then((module) => ({ default: module.CombatScreen })))
 const CustomizeScreen = lazy(() => import('./components/CustomizeScreen').then((module) => ({ default: module.CustomizeScreen })))
 const EquipmentScreen = lazy(() => import('./components/EquipmentScreen').then((module) => ({ default: module.EquipmentScreen })))
+const HunterProfileScreen = lazy(() => import('./components/HunterProfileScreen').then((module) => ({ default: module.HunterProfileScreen })))
 const PvPRoguelikeScreen = lazy(() => import('./components/PvpRoguelikeScreen').then((module) => ({ default: module.PvPRoguelikeScreen })))
 const PvpStadiumScreen = lazy(() => import('./components/PvpStadiumScreen').then((module) => ({ default: module.PvpStadiumScreen })))
 const TalentScreen = lazy(() => import('./components/TalentScreen').then((module) => ({ default: module.TalentScreen })))
@@ -39,6 +40,7 @@ type Screen =
   | 'pvp'
   | 'customize'
   | 'equipment'
+  | 'hunter-profile'
   | 'talents'
   | 'settings'
 
@@ -52,6 +54,7 @@ const MENU_ITEMS: Array<{
   { screen: 'raids', label: 'Raids', glyph: 'R', description: 'Guide an eighteen-player party through three-phase challenges.' },
   { screen: 'roguelike', label: 'Roguelike', glyph: 'L', description: 'Draft upgrades through escalating random encounters.' },
   { screen: 'pvp', label: 'PvP', glyph: 'P', description: 'Race another healer through roguelike encounters with buffs and sabotage.' },
+  { screen: 'hunter-profile', label: 'Hunter Profile', glyph: 'H', description: 'Review boss kills, PvP record, drops, and pets.' },
   { screen: 'customize', label: 'Customize Character', glyph: 'C', description: 'Choose your class and prepare a six-ability loadout.' },
   { screen: 'settings', label: 'Settings', glyph: 'S', description: 'Remap PC and controller inputs.' },
 ]
@@ -456,7 +459,8 @@ function App() {
   const canShowCloudSync = account.id !== -1 && cloudSync.available
 
   return (
-    <main className={`game-shell ${screen === 'dungeons' || screen === 'raids' ? 'dungeon-shell' : ''} ${screen === 'customize' ? 'workshop-shell' : ''}`}>
+    <main className={`game-shell ${screen === 'dungeons' || screen === 'raids' ? 'dungeon-shell' : ''} ${screen === 'customize' ? 'workshop-shell' : ''} ${screen === 'settings' ? 'settings-shell' : ''}`}>
+      {screen !== 'hunter-profile' && (
         <header className="topbar app-header">
           <button
             className="brand-button"
@@ -477,6 +481,7 @@ function App() {
             </button>
           </div>
         </header>
+      )}
 
       {screen === 'menu' && (
         <section className="menu-screen">
@@ -1091,6 +1096,13 @@ function App() {
           />
         )}
 
+        {screen === 'hunter-profile' && (
+          <HunterProfileScreen
+            profile={profile}
+            onBack={() => setScreen('menu')}
+          />
+        )}
+
         {screen === 'settings' && (
           <SettingsScreen onBack={() => setScreen('menu')} />
         )}

src/admin.tsx

@@ -3,9 +3,12 @@ import { createRoot } from 'react-dom/client'
 import './index.css'
 import './App.css'
 import { AdminScreen } from './components/AdminScreen'
+import { InputProvider } from './input'
 
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
+    <InputProvider>
       <AdminScreen onBack={() => window.close()} />
+    </InputProvider>
   </StrictMode>,
 )

src/components/CombatScreen.tsx

@@ -3,6 +3,7 @@ import {
   completeDungeon,
   completeRoguelike,
   loadProfile,
+  recordBossKill,
   type DungeonReward,
   rollEncounterLoot,
   type LootRoll,
@@ -371,6 +372,7 @@ export function CombatScreen({
   const rewardClaimedRef = useRef(false)
   const profileRefreshedRef = useRef(false)
   const rolledEncounterIdsRef = useRef(new Set<string>())
+  const recordedBossKillIdsRef = useRef(new Set<string>())
   const runTokenRef = useRef(crypto.randomUUID())
   const resourceSpentRef = useRef(0)
   const runStartedAtRef = useRef(0)
@@ -516,6 +518,12 @@ export function CombatScreen({
               : `${result.encounterName} dropped no components.`,
             result.dropped ? 'loot' : 'system',
           )
+          if (result.petAwarded) {
+            addLog(
+              `${result.petAwarded.petName} awarded${result.petAwarded.duplicate ? ` (owned x${result.petAwarded.quantityAfter})` : ''}.`,
+              'loot',
+            )
+          }
         })
         .catch((reason: unknown) => {
           addLog(
@@ -527,6 +535,29 @@ export function CombatScreen({
     [addLog, difficulty.id],
   )
 
+  const recordRoguelikeBossKill = useCallback((encounter: DungeonEncounter) => {
+    if (!isRoguelike || !encounter.isBoss) return
+    const key = `${runTokenRef.current}:${encounter.id}:${encounterIndex}`
+    if (recordedBossKillIdsRef.current.has(key)) return
+    recordedBossKillIdsRef.current.add(key)
+    recordBossKill(encounter.id, { petVariant: 'purple' })
+      .then((result) => {
+        onProfileUpdated(result.profile)
+        if (result.petAwarded) {
+          addLog(
+            `${result.petAwarded.petName} awarded${result.petAwarded.duplicate ? ` (owned x${result.petAwarded.quantityAfter})` : ''}.`,
+            'loot',
+          )
+        }
+      })
+      .catch((reason: unknown) => {
+        addLog(
+          reason instanceof Error ? reason.message : 'Unable to record boss kill.',
+          'danger',
+        )
+      })
+  }, [addLog, encounterIndex, isRoguelike, onProfileUpdated])
+
   const resetRun = useCallback(() => {
     const nextRoguelikeEncounters = roguelikeMode
       ? makeRoguelikeSegment(roguelikePool, 1, difficulty, roguelikeMode)
@@ -558,6 +589,7 @@ export function CombatScreen({
     rewardClaimedRef.current = false
     profileRefreshedRef.current = false
     rolledEncounterIdsRef.current = new Set()
+    recordedBossKillIdsRef.current = new Set()
     runTokenRef.current = crypto.randomUUID()
     marathonBossesDefeatedRef.current = 0
     resourceSpentRef.current = setup.defaults.resourceSpent
@@ -991,6 +1023,7 @@ export function CombatScreen({
           requestLootRoll(encounter.id, rollIndex)
         }
       }
+      recordRoguelikeBossKill(encounter)
 
       if (isRoguelike && (upgradesEveryEncounter || encounter.isBoss)) {
         setCombat({
@@ -1100,6 +1133,7 @@ export function CombatScreen({
     maxResource,
     gameClass.resourceName,
     requestLootRoll,
+    recordRoguelikeBossKill,
     profile.character.name,
     setCombat,
     startPart,

src/components/HunterProfileScreen.tsx

@@ -0,0 +1,240 @@
+import { useMemo, useState } from 'react'
+import type { CharacterProfile, DungeonEncounter } from '../profile'
+import { useDualScreen, useDualScreenWorkshopPublisher, type DualScreenWorkshopState } from '../dualScreen'
+
+type HunterProfileScreenProps = {
+  profile: CharacterProfile
+  onBack: () => void
+}
+
+type BossEntry = {
+  encounter: DungeonEncounter
+  dungeonId: number
+  dungeonName: string
+  contentType: 'dungeon' | 'raid'
+}
+
+type CollectionItem = {
+  key: string
+  glyph: string
+  name: string
+  chance: string
+  quantity: number
+  rarity: 'stat' | 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary'
+  source: string
+}
+
+function bossInitials(name: string) {
+  return name
+    .split(/\s+/)
+    .filter(Boolean)
+    .slice(0, 2)
+    .map((part) => part[0]?.toUpperCase() ?? '')
+    .join('')
+}
+
+function dropChanceLabel(chance: number) {
+  if (chance <= 0) return 'Unavailable'
+  const denominator = Math.round(1 / chance)
+  if (denominator >= 10) return `1 in ${denominator}`
+  return `${Math.round(chance * 100)}%`
+}
+
+function purplePetKey(encounterId: number) {
+  return `purple:${encounterId}`
+}
+
+export function HunterProfileScreen({ profile, onBack }: HunterProfileScreenProps) {
+  const [activeTab, setActiveTab] = useState<'stats' | 'collection'>('stats')
+  const { enabled: dualScreenEnabled } = useDualScreen()
+  const bosses = useMemo<BossEntry[]>(() => profile.dungeons.flatMap((dungeon) =>
+    dungeon.encounters
+      .filter((encounter) => encounter.isBoss)
+      .map((encounter) => ({
+        encounter,
+        dungeonId: dungeon.id,
+        dungeonName: dungeon.name,
+        contentType: dungeon.contentType,
+      })),
+  ), [profile.dungeons])
+  const [selectedBossId, setSelectedBossId] = useState(() => bosses[0]?.encounter.id ?? 0)
+  const [focusedItemKey, setFocusedItemKey] = useState<string | null>(null)
+  const selectedBoss = bosses.find((boss) => boss.encounter.id === selectedBossId) ?? bosses[0]
+  const bossKills = profile.hunterStats?.bossKills ?? {}
+  const bossPets = profile.hunterStats?.bossPets ?? {}
+  const inventoryQuantities = useMemo(
+    () => new Map(profile.inventory.map((item) => [item.id, item.quantity])),
+    [profile.inventory],
+  )
+  const totalBossKills = bosses.reduce((total, boss) => total + (bossKills[String(boss.encounter.id)] ?? 0), 0)
+  const mostKilledBoss = bosses.reduce<BossEntry | null>((best, boss) => {
+    if (!best) return boss
+    return (bossKills[String(boss.encounter.id)] ?? 0) > (bossKills[String(best.encounter.id)] ?? 0)
+      ? boss
+      : best
+  }, null)
+  const matchesPlayed = profile.hunterStats?.pvpMatchesPlayed ?? 0
+  const matchesWon = profile.hunterStats?.pvpMatchesWon ?? 0
+  const winRate = matchesPlayed > 0 ? Math.round((matchesWon / matchesPlayed) * 100) : 0
+  const collectionItems = useMemo<CollectionItem[]>(() => {
+    if (!selectedBoss) return []
+    return [
+      {
+        key: `kills:${selectedBoss.encounter.id}`,
+        glyph: 'K',
+        name: 'Boss Kills',
+        chance: 'Defeats',
+        quantity: bossKills[String(selectedBoss.encounter.id)] ?? 0,
+        rarity: 'stat',
+        source: selectedBoss.encounter.enemyName,
+      },
+      ...selectedBoss.encounter.lootTables.map((drop) => ({
+        key: `drop:${drop.difficultyId}:${drop.id}`,
+        glyph: drop.glyph,
+        name: drop.name,
+        chance: dropChanceLabel(drop.dropChance),
+        quantity: inventoryQuantities.get(drop.id) ?? 0,
+        rarity: drop.rarity,
+        source: selectedBoss.encounter.enemyName,
+      })),
+      {
+        key: `pet:${selectedBoss.encounter.id}`,
+        glyph: '*',
+        name: `${selectedBoss.encounter.enemyName} Pet`,
+        chance: '1 in 500',
+        quantity: bossPets[String(selectedBoss.encounter.id)] ?? 0,
+        rarity: 'legendary',
+        source: selectedBoss.encounter.enemyName,
+      },
+      {
+        key: `purple-pet:${selectedBoss.encounter.id}`,
+        glyph: 'P',
+        name: `Purple ${selectedBoss.encounter.enemyName} Pet`,
+        chance: '1 in 500',
+        quantity: bossPets[purplePetKey(selectedBoss.encounter.id)] ?? 0,
+        rarity: 'epic',
+        source: `${selectedBoss.encounter.enemyName} Roguelike`,
+      },
+    ]
+  }, [bossKills, bossPets, inventoryQuantities, selectedBoss])
+  const focusedItem = collectionItems.find((item) => item.key === focusedItemKey) ?? collectionItems[0] ?? null
+  const itemDetailState = useMemo<DualScreenWorkshopState | null>(() => {
+    if (activeTab !== 'collection' || !selectedBoss || !focusedItem) return null
+    return {
+      mode: 'collection',
+      title: focusedItem.name,
+      subtitle: selectedBoss.encounter.enemyName,
+      summary: `Owned x${focusedItem.quantity}`,
+      items: [
+        {
+          glyph: focusedItem.glyph,
+          title: 'Drop Rate',
+          meta: focusedItem.chance,
+          detail: focusedItem.source,
+          status: focusedItem.quantity > 0 ? 'Collected' : 'Missing',
+        },
+        {
+          title: 'Boss Kills',
+          meta: `${bossKills[String(selectedBoss.encounter.id)] ?? 0}`,
+          detail: selectedBoss.dungeonName,
+        },
+      ],
+    }
+  }, [activeTab, bossKills, focusedItem, selectedBoss])
+  useDualScreenWorkshopPublisher(itemDetailState, dualScreenEnabled)
+
+  return (
+    <section className="content-screen hunter-profile-screen">
+      <div className="screen-heading hunter-profile-heading">
+        <div className="equipment-tabs hunter-profile-tabs" role="tablist" aria-label="Hunter profile tabs">
+          <button
+            className={`equipment-tab ${activeTab === 'stats' ? 'active' : ''}`}
+            onClick={() => setActiveTab('stats')}
+            type="button"
+            role="tab"
+            aria-selected={activeTab === 'stats'}
+          >
+            Stats
+          </button>
+          <button
+            className={`equipment-tab ${activeTab === 'collection' ? 'active' : ''}`}
+            onClick={() => setActiveTab('collection')}
+            type="button"
+            role="tab"
+            aria-selected={activeTab === 'collection'}
+          >
+            Collection Log
+          </button>
+        </div>
+        <button className="back-button" onClick={onBack} type="button">Back</button>
+      </div>
+
+      {activeTab === 'stats' && (
+        <div className="hunter-stat-grid">
+          <article className="hunter-stat-tile">
+            <span>Total Boss Kills</span>
+            <strong>{totalBossKills}</strong>
+          </article>
+          <article className="hunter-stat-tile">
+            <span>Most Killed Boss</span>
+            <strong>{totalBossKills > 0 && mostKilledBoss ? mostKilledBoss.encounter.enemyName : 'None'}</strong>
+            <small>{totalBossKills > 0 && mostKilledBoss ? `${bossKills[String(mostKilledBoss.encounter.id)] ?? 0} kills` : '0 kills'}</small>
+          </article>
+          <article className="hunter-stat-tile">
+            <span>PvP Matches</span>
+            <strong>{matchesPlayed}</strong>
+          </article>
+          <article className="hunter-stat-tile">
+            <span>PvP Wins</span>
+            <strong>{matchesWon}</strong>
+          </article>
+          <article className="hunter-stat-tile">
+            <span>PvP Win Rate</span>
+            <strong>{winRate}%</strong>
+          </article>
+        </div>
+      )}
+
+      {activeTab === 'collection' && (
+        <div className="collection-log-layout">
+          <div className="collection-boss-list" aria-label="Bosses">
+            {bosses.map((boss) => {
+              return (
+                <button
+                  className={`collection-boss-button ${selectedBoss?.encounter.id === boss.encounter.id ? 'selected' : ''}`}
+                  key={boss.encounter.id}
+                  onClick={() => setSelectedBossId(boss.encounter.id)}
+                  type="button"
+                >
+                  <span>{bossInitials(boss.encounter.enemyName)}</span>
+                  <strong>{boss.encounter.enemyName}</strong>
+                </button>
+              )
+            })}
+          </div>
+
+          {selectedBoss && (
+            <article className="collection-boss-detail">
+              <div className="collection-drop-list">
+                {collectionItems.map((item) => (
+                  <button
+                    className={`collection-drop-row collection-rarity-${item.rarity} ${item.quantity <= 0 ? 'missing' : 'owned'}`}
+                    key={item.key}
+                    onClick={() => setFocusedItemKey(item.key)}
+                    onFocus={() => setFocusedItemKey(item.key)}
+                    type="button"
+                  >
+                    <span>{item.glyph}</span>
+                    <strong>{item.name}</strong>
+                    <small>{item.chance}</small>
+                    <b>x{item.quantity}</b>
+                  </button>
+                ))}
+              </div>
+            </article>
+          )}
+        </div>
+      )}
+    </section>
+  )
+}

src/components/PvpRoguelikeScreen.tsx

@@ -9,7 +9,7 @@ import {
   type PartyMember,
   type Spell,
 } from '../game'
-import { completeRoguelike, type DungeonReward } from '../profile'
+import { completeRoguelike, recordPvpMatch, type DungeonReward } from '../profile'
 import type { CharacterProfile, DungeonEncounter } from '../profile'
 import type { GameMode } from '../gameRepository'
 import { PartyMemberFrame } from './PartyFrames'
@@ -362,6 +362,7 @@ export function PvPRoguelikeScreen({
   const nextLogId = useRef(2)
   const elapsedTicksRef = useRef(0)
   const recordedRunRef = useRef(false)
+  const matchStatsRecordedRef = useRef(false)
   const rewardClaimedRef = useRef(false)
   const matchWinRewardClaimedRef = useRef(false)
   const bossRewardClaimedRef = useRef(new Set<number>())
@@ -538,6 +539,12 @@ export function PvPRoguelikeScreen({
             'loot',
           )
         }
+        if (result.petAwarded) {
+          addLog(
+            `${result.petAwarded.petName} awarded${result.petAwarded.duplicate ? ` (owned x${result.petAwarded.quantityAfter})` : ''}.`,
+            'loot',
+          )
+        }
       })
       .catch((reason: unknown) => {
         setRewardError(
@@ -654,6 +661,7 @@ export function PvPRoguelikeScreen({
     pendingLiveUpgradeRef.current = null
     loggedOpponentDoneRef.current = false
     recordedRunRef.current = false
+    matchStatsRecordedRef.current = false
     rewardClaimedRef.current = false
     matchWinRewardClaimedRef.current = false
     cpuDefeatedRef.current = false
@@ -711,6 +719,7 @@ export function PvPRoguelikeScreen({
     pendingLiveUpgradeRef.current = null
     loggedOpponentDoneRef.current = false
     recordedRunRef.current = false
+    matchStatsRecordedRef.current = false
     rewardClaimedRef.current = false
     matchWinRewardClaimedRef.current = false
     cpuDefeatedRef.current = false
@@ -1096,6 +1105,20 @@ export function PvPRoguelikeScreen({
     })
   }, [contentType, cpuDifficulty, finalEncountersCleared, profile.character.className, profile.character.name, status])
 
+  useEffect(() => {
+    if (status !== 'won' && status !== 'lost') return
+    if (matchStatsRecordedRef.current) return
+    matchStatsRecordedRef.current = true
+    recordPvpMatch(status === 'won')
+      .then(onProfileUpdated)
+      .catch((reason: unknown) => {
+        addLog(
+          reason instanceof Error ? reason.message : 'Unable to record PvP match.',
+          'danger',
+        )
+      })
+  }, [addLog, onProfileUpdated, status])
+
   useEffect(() => {
     if (status !== 'upgrade-choice') return
     window.requestAnimationFrame(() => focusFirstControl())
@@ -1509,6 +1532,7 @@ export function PvPRoguelikeScreen({
               bindings={activeBindings}
               canCast={status === 'playing' && !playerDone && playerAlive}
               className="pvp-bottom-spell-bar"
+              focusable={false}
               iconStyle={controllerIconStyle}
               onCast={castPlayerSpell}
               resource={playerSide.resource}

src/components/PvpStadiumScreen.tsx

@@ -7,7 +7,7 @@ import {
   type PartyMember,
   type Spell,
 } from '../game'
-import { completeRoguelike } from '../profile'
+import { completeRoguelike, recordPvpMatch } from '../profile'
 import type { CharacterProfile } from '../profile'
 import type { GameMode } from '../gameRepository'
 import { PartyMemberFrame } from './PartyFrames'
@@ -391,6 +391,7 @@ export function PvpStadiumScreen({
   const nextLogId = useRef(2)
   const submittedShopRef = useRef(false)
   const awardedXpRef = useRef(new Set<string>())
+  const matchStatsRecordedRef = useRef(false)
   const queuedMatchRef = useRef(false)
   const roundResolvedRef = useRef(false)
   const loggedOpponentRoundRef = useRef('')
@@ -505,6 +506,7 @@ export function PvpStadiumScreen({
     queuedMatchRef.current = true
     nextLogId.current = 2
     awardedXpRef.current = new Set()
+    matchStatsRecordedRef.current = false
     roundResolvedRef.current = false
     setPlayerSide(setup.playerSide)
     setCpuSide(setup.opponentSide)
@@ -541,6 +543,7 @@ export function PvpStadiumScreen({
     queuedMatchRef.current = true
     nextLogId.current = 2
     awardedXpRef.current = new Set()
+    matchStatsRecordedRef.current = false
     roundResolvedRef.current = false
     setPlayerSide(setup.playerSide)
     setCpuSide(setup.opponentSide)
@@ -882,6 +885,20 @@ export function PvpStadiumScreen({
     return () => window.clearInterval(timer)
   }, [advanceBoss, cpuTakeTurn, finishRound, paused, status])
 
+  useEffect(() => {
+    if (status !== 'won' && status !== 'lost') return
+    if (matchStatsRecordedRef.current) return
+    matchStatsRecordedRef.current = true
+    recordPvpMatch(status === 'won')
+      .then(onProfileUpdated)
+      .catch((reason: unknown) => {
+        addLog(
+          reason instanceof Error ? reason.message : 'Unable to record PvP match.',
+          'danger',
+        )
+      })
+  }, [addLog, onProfileUpdated, status])
+
   const startNextRound = useCallback(() => {
     const nextRound = roundIndex + 1
     const nextPlayer = createStadiumStarterSide<StadiumBuffId>({
@@ -1289,6 +1306,7 @@ export function PvpStadiumScreen({
               bindings={activeBindings}
               canCast={status === 'playing' && playerAlive}
               className="pvp-bottom-spell-bar"
+              focusable={false}
               iconStyle={controllerIconStyle}
               onCast={castPlayerSpell}
               resource={playerSide.resource}

src/components/RewardPanels.tsx

@@ -100,14 +100,15 @@ export function LootRollList({
   return (
     <div className="run-loot-rolls">
       {rolls.map((roll) => (
-        <div className={roll.dropped ? 'dropped' : 'empty'} key={roll.encounterId}>
+        <div className={roll.dropped || roll.petAwarded ? 'dropped' : 'empty'} key={roll.encounterId}>
           <strong>{roll.encounterName}</strong>
           <span>
-            {roll.items.length > 0
+            {[
-              ? roll.items
+              ...roll.items.map((item) => `${item.glyph} ${item.name} x${item.quantity}${item.duplicate ? ` (owned x${item.quantityAfter})` : ''}`),
-                .map((item) => `${item.glyph} ${item.name} x${item.quantity}${item.duplicate ? ` (owned x${item.quantityAfter})` : ''}`)
+              ...(roll.petAwarded
-                .join(', ')
+                ? [`* ${roll.petAwarded.petName}${roll.petAwarded.duplicate ? ` (owned x${roll.petAwarded.quantityAfter})` : ''}`]
-              : 'No components dropped'}
+                : []),
+            ].join(', ') || 'No components dropped'}
           </span>
         </div>
       ))}

src/components/SettingsScreen.tsx

@@ -91,14 +91,8 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
 
   return (
     <section className="content-screen settings-screen">
-      <div className="screen-heading">
+      <div className="settings-nav">
-        <div>
+        <button className="back-button settings-back-button" onClick={onBack} type="button">Back</button>
-          <p className="eyebrow">Game Options</p>
-          <h1>Settings</h1>
-        </div>
-        <button className="back-button" onClick={onBack} type="button">Back</button>
-      </div>
-
         <nav className="settings-tabs" role="tablist" aria-label="Settings sections">
           {([
             { key: 'display', label: 'Display' },
@@ -117,6 +111,7 @@ export function SettingsScreen({ onBack }: { onBack: () => void }) {
             </button>
           ))}
         </nav>
+      </div>
 
       {settingsTab === 'display' && (
         <section className="dual-screen-settings settings-tab-panel">

src/components/SpellBars.tsx

@@ -40,6 +40,7 @@ export const SpellButton = memo(function SpellButton({
   iconStyle,
   resourceName,
   disabled,
+  focusable = true,
   onCast,
   emptyKeyPrefix = 'empty',
 }: {
@@ -48,6 +49,7 @@ export const SpellButton = memo(function SpellButton({
   iconStyle: ControllerIconStyle
   resourceName: string
   disabled?: boolean
+  focusable?: boolean
   onCast: (spell: Spell) => void
   emptyKeyPrefix?: string
 }) {
@@ -61,9 +63,11 @@ export const SpellButton = memo(function SpellButton({
   return (
     <button
       className="spell"
+      data-controller-nav={focusable ? undefined : 'skip'}
       disabled={disabled}
       key={spell.id}
       onClick={() => onCast(spell)}
+      tabIndex={focusable ? undefined : -1}
       title={spell.description}
       type="button"
     >
@@ -95,6 +99,7 @@ export const SpellBar = memo(function SpellBar({
   canCast,
   onCast,
   className = 'spell-bar six-slots vertical-spell-bar',
+  focusable = true,
 }: {
   spells: SpellSlot[]
   bindings: Record<string, string>
@@ -104,6 +109,7 @@ export const SpellBar = memo(function SpellBar({
   canCast: boolean
   onCast: (spell: Spell) => void
   className?: string
+  focusable?: boolean
 }) {
   return (
     <div className={className}>
@@ -119,6 +125,7 @@ export const SpellBar = memo(function SpellBar({
           <SpellButton
             binding={bindings[`ability${slotIndex + 1}`]}
             disabled={!canCast || resource < spell.cost || spell.remaining > 0}
+            focusable={focusable}
             iconStyle={iconStyle}
             key={spell.id}
             onCast={onCast}

src/dualScreen.tsx

@@ -19,6 +19,7 @@ import {
   dispatchExternalGameAction,
   type ControllerIconStyle,
   type InputAction,
+  useGameAction,
 } from './input'
 import { ControllerBindingLabel } from './components/ControllerIcons'
 import { PartyMemberFrame } from './components/PartyFrames'
@@ -83,7 +84,7 @@ export type DualScreenCombatState = {
 }
 
 export type DualScreenWorkshopState = {
-  mode: 'class' | 'equipment' | 'crafting' | 'talents'
+  mode: 'class' | 'equipment' | 'crafting' | 'talents' | 'collection'
   title: string
   subtitle: string
   summary?: string
@@ -149,6 +150,16 @@ function formatDualTime(seconds: number) {
   return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, '0')}`
 }
 
+function shouldRelayBottomAction(
+  action: InputAction,
+  state: DualScreenCombatState | null,
+) {
+  if (!state) return false
+  if (action === 'confirm' || action === 'toggleTouchLock') return false
+  if (state.status === 'playing') return true
+  return action === 'pause' || action === 'back'
+}
+
 export function DualScreenProvider({ children }: { children: ReactNode }) {
   const [enabled, setEnabledState] = useState(
     () => localStorage.getItem(STORAGE_KEY) === 'true',
@@ -402,6 +413,11 @@ export function DualScreenBottomDisplay() {
     channel?.close()
   }
 
+  useGameAction((action) => {
+    if (!shouldRelayBottomAction(action, state)) return
+    sendAction(action)
+  })
+
   if (!state && workshopState) {
     return (
       <main className="dual-bottom-display workshop-bottom-display">
@@ -449,7 +465,10 @@ export function DualScreenBottomDisplay() {
   }
 
   return (
-    <main className={`dual-bottom-display ${state.opponentParty ? 'pvp-opponent-bottom-display' : ''}`}>
+    <main
+      className={`dual-bottom-display ${state.opponentParty ? 'pvp-opponent-bottom-display' : ''}`}
+      data-combat-active={state.status === 'playing' && !state.paused ? 'true' : 'false'}
+    >
       <header className="dual-controls-header">
         <div>
           <p className="eyebrow">{state.opponentParty ? 'Opponent View' : `${state.difficultyName} ${state.contentName}`}</p>
@@ -649,6 +668,7 @@ export function DualScreenTopCombat({
     return (
       <button
         className="dual-top-spell"
+        data-controller-nav={state.opponentParty ? 'skip' : undefined}
         disabled={
           !state.playerIsAlive
           || state.resource < spell.cost

src/gameRepository.ts

@@ -17,6 +17,7 @@ import type {
   LootRoll,
   Item,
   EquipmentSlot,
+  PetAward,
 } from './profile'
 
 export type GameMode = 'online' | 'offline'
@@ -64,6 +65,14 @@ export interface GameRepository {
     difficultyId: number,
     runToken: string,
   ): Promise<LootRoll>
+  recordBossKill(
+    encounterId: number,
+    options?: { petVariant?: 'normal' | 'purple' },
+  ): Promise<{
+    profile: CharacterProfile
+    petAwarded: PetAward | null
+  }>
+  recordPvpMatch(won: boolean): Promise<CharacterProfile>
 }
 
 type CharacterData = {
@@ -76,7 +85,7 @@ type CharacterData = {
 }
 
 type OfflineSave = {
-  version: 3
+  version: 4
   characterName: string
   activeClassId: number
   completedDungeonParts: number
@@ -84,6 +93,10 @@ type OfflineSave = {
   dungeonCompletions?: Record<string, number>
   characters: Record<number, CharacterData>
   lootRolls: Record<string, LootRoll>
+  bossKills: Record<string, number>
+  bossPets: Record<string, number>
+  pvpMatchesPlayed: number
+  pvpMatchesWon: number
 }
 
 type OnlineCache = {
@@ -124,6 +137,7 @@ const catalogBundleKey = 'chronicle.catalog.bundleHash.v1'
 const authTokenKey = 'chronicle.authToken.v1'
 const offlineAccount = { id: -1, username: 'Offline' }
 const ABILITY_SLOT_COUNT = 6
+const BOSS_PET_DROP_RATE = 1 / 500
 let activeCatalogCache: CatalogCache | null = null
 
 function clone<T>(value: T): T {
@@ -175,7 +189,7 @@ function upgradeV1Save(v1: { profile: CharacterProfile; lootRolls: Record<string
     }
   }
   return {
-    version: 3,
+    version: 4,
     characterName: p.character.name,
     activeClassId: p.character.classId,
     completedDungeonParts: p.completedDungeonParts,
@@ -185,14 +199,33 @@ function upgradeV1Save(v1: { profile: CharacterProfile; lootRolls: Record<string
     ),
     characters,
     lootRolls: v1.lootRolls ?? {},
+    bossKills: p.hunterStats?.bossKills ?? {},
+    bossPets: p.hunterStats?.bossPets ?? {},
+    pvpMatchesPlayed: p.hunterStats?.pvpMatchesPlayed ?? 0,
+    pvpMatchesWon: p.hunterStats?.pvpMatchesWon ?? 0,
   }
 }
 
-function upgradeV2Save(v2: Omit<OfflineSave, 'version' | 'completedRaidPhases'> & { version: 2 }): OfflineSave {
+function upgradeV2Save(v2: Omit<OfflineSave, 'version' | 'completedRaidPhases' | 'bossKills' | 'bossPets' | 'pvpMatchesPlayed' | 'pvpMatchesWon'> & { version: 2 }): OfflineSave {
   return normalizeSaveAbilitySlots({
     ...v2,
-    version: 3,
+    version: 4,
     completedRaidPhases: 0,
+    bossKills: {},
+    bossPets: {},
+    pvpMatchesPlayed: 0,
+    pvpMatchesWon: 0,
+  })
+}
+
+function upgradeV3Save(v3: Omit<OfflineSave, 'version' | 'bossKills' | 'bossPets' | 'pvpMatchesPlayed' | 'pvpMatchesWon'> & { version: 3 }): OfflineSave {
+  return normalizeSaveAbilitySlots({
+    ...v3,
+    version: 4,
+    bossKills: {},
+    bossPets: {},
+    pvpMatchesPlayed: 0,
+    pvpMatchesWon: 0,
   })
 }
 
@@ -224,9 +257,12 @@ function normalizeOfflineSave(raw: unknown): OfflineSave | null {
     profile?: CharacterProfile
     lootRolls?: Record<string, LootRoll>
   }
-  if (candidate.version === 3) return normalizeSaveAbilitySlots(candidate as OfflineSave)
+  if (candidate.version === 4) return normalizeSaveAbilitySlots(candidate as OfflineSave)
+  if (candidate.version === 3) {
+    return upgradeV3Save(candidate as Omit<OfflineSave, 'version' | 'bossKills' | 'bossPets' | 'pvpMatchesPlayed' | 'pvpMatchesWon'> & { version: 3 })
+  }
   if (candidate.version === 2) {
-    return upgradeV2Save(candidate as Omit<OfflineSave, 'version' | 'completedRaidPhases'> & { version: 2 })
+    return upgradeV2Save(candidate as Omit<OfflineSave, 'version' | 'completedRaidPhases' | 'bossKills' | 'bossPets' | 'pvpMatchesPlayed' | 'pvpMatchesWon'> & { version: 2 })
   }
   if (candidate.version === 1 && candidate.profile) {
     return normalizeSaveAbilitySlots(upgradeV1Save(candidate as { profile: CharacterProfile; lootRolls: Record<string, LootRoll> }))
@@ -241,7 +277,7 @@ function readSaveKey(key: string): OfflineSave | null {
     const raw = JSON.parse(serialized)
     const save = normalizeOfflineSave(raw)
     if (!save) return null
-    if (raw.version !== 3) {
+    if (raw.version !== 4) {
       localStorage.setItem(key, JSON.stringify(save))
     }
     return save
@@ -284,7 +320,7 @@ function readOnlineCache(): OnlineCache | null {
       save,
       dirty: Boolean(raw.dirty),
     }
-    if ((raw.save as { version?: number } | undefined)?.version !== 3) {
+    if ((raw.save as { version?: number } | undefined)?.version !== 4) {
       writeOnlineCache(cache)
     }
     return cache
@@ -380,6 +416,12 @@ function buildProfile(save: OfflineSave): CharacterProfile {
     ...dungeon,
     completionCount: save.dungeonCompletions?.[String(dungeon.id)] ?? dungeon.completionCount ?? 0,
   }))
+  static_.hunterStats = {
+    bossKills: clone(save.bossKills ?? {}),
+    bossPets: clone(save.bossPets ?? {}),
+    pvpMatchesPlayed: save.pvpMatchesPlayed ?? 0,
+    pvpMatchesWon: save.pvpMatchesWon ?? 0,
+  }
 
   return static_
 }
@@ -547,7 +589,7 @@ function mergeProfileIntoSave(profile: CharacterProfile, existingSave?: OfflineS
     inventory: clone(profile.inventory),
   }
   return {
-    version: 3,
+    version: 4,
     characterName: profile.character.name,
     activeClassId: profile.character.classId,
     completedDungeonParts: profile.completedDungeonParts,
@@ -557,6 +599,10 @@ function mergeProfileIntoSave(profile: CharacterProfile, existingSave?: OfflineS
     ),
     characters,
     lootRolls: clone(existingSave?.lootRolls ?? {}),
+    bossKills: clone(profile.hunterStats?.bossKills ?? existingSave?.bossKills ?? {}),
+    bossPets: clone(profile.hunterStats?.bossPets ?? existingSave?.bossPets ?? {}),
+    pvpMatchesPlayed: profile.hunterStats?.pvpMatchesPlayed ?? existingSave?.pvpMatchesPlayed ?? 0,
+    pvpMatchesWon: profile.hunterStats?.pvpMatchesWon ?? existingSave?.pvpMatchesWon ?? 0,
   }
 }
 
@@ -570,6 +616,50 @@ function rollWeightedLootEntry<T extends { dropWeight: number }>(entries: T[]):
   return entries[entries.length - 1]
 }
 
+function bossPetName(encounterName: string) {
+  return `${encounterName} Pet`
+}
+
+function purpleBossPetName(encounterName: string) {
+  return `Purple ${encounterName} Pet`
+}
+
+function maybeAwardBossPet(
+  save: OfflineSave,
+  encounter: { id: number; enemyName: string },
+  variant: 'normal' | 'purple' = 'normal',
+): PetAward | null {
+  if (Math.random() >= BOSS_PET_DROP_RATE) return null
+  const key = variant === 'purple' ? `purple:${encounter.id}` : String(encounter.id)
+  const previousQuantity = save.bossPets?.[key] ?? 0
+  save.bossPets = {
+    ...(save.bossPets ?? {}),
+    [key]: previousQuantity + 1,
+  }
+  return {
+    encounterId: encounter.id,
+    petName: variant === 'purple'
+      ? purpleBossPetName(encounter.enemyName)
+      : bossPetName(encounter.enemyName),
+    quantity: 1,
+    duplicate: previousQuantity > 0,
+    quantityAfter: previousQuantity + 1,
+  }
+}
+
+function recordBossKillInSave(
+  save: OfflineSave,
+  encounter: { id: number; enemyName: string },
+  options?: { petVariant?: 'normal' | 'purple' },
+): PetAward | null {
+  const key = String(encounter.id)
+  save.bossKills = {
+    ...(save.bossKills ?? {}),
+    [key]: (save.bossKills?.[key] ?? 0) + 1,
+  }
+  return maybeAwardBossPet(save, encounter, options?.petVariant ?? 'normal')
+}
+
 function awardRoguelikeCoin(
   profile: CharacterProfile,
   sourceEncounterId: number | undefined,
@@ -885,6 +975,10 @@ const serverRepository: GameRepository = {
     cachedOnlineLocalRepository.upgradeItem(itemId),
   rollEncounterLoot: (encounterId, difficultyId, runToken) =>
     cachedOnlineLocalRepository.rollEncounterLoot(encounterId, difficultyId, runToken),
+  recordBossKill: (encounterId, options) =>
+    cachedOnlineLocalRepository.recordBossKill(encounterId, options),
+  recordPvpMatch: (won) =>
+    cachedOnlineLocalRepository.recordPvpMatch(won),
 }
 
 function emptyCharacterData(classId: number): CharacterData {
@@ -1172,6 +1266,17 @@ function createLocalRepository(store: LocalSaveStore): GameRepository {
       profile.maxTalentPoints,
       cd.talentPoints + levelsGained,
     )
+    let petAwarded: PetAward | null = null
+    if (options?.lootSourceEncounterId) {
+      const sourceEncounter = profile.dungeons
+        .flatMap((candidate) => candidate.encounters)
+        .find((candidate) => candidate.id === options.lootSourceEncounterId && candidate.isBoss)
+      if (sourceEncounter) {
+        petAwarded = recordBossKillInSave(save, sourceEncounter, {
+          petVariant: 'purple',
+        })
+      }
+    }
     const bonusItem = awardRoguelikeCoin(
       profile,
       options?.lootSourceEncounterId,
@@ -1196,6 +1301,7 @@ function createLocalRepository(store: LocalSaveStore): GameRepository {
       averageItemLevel: updatedProfile.gearStats.averageItemLevel,
       unlockedAbilities,
       bonusItem,
+      petAwarded,
       profile: updatedProfile,
     }
     },
@@ -1446,6 +1552,9 @@ function createLocalRepository(store: LocalSaveStore): GameRepository {
       throw new Error('This encounter has no configured loot.')
     }
     const dropChance = entries[0].dropChance
+    const petAwarded = encounter.isBoss
+      ? recordBossKillInSave(save, encounter)
+      : null
     const items: LootRoll['items'] = []
 
     const selectedQuantities = new Map<number, { entry: typeof entries[number]; quantity: number }>()
@@ -1497,12 +1606,36 @@ function createLocalRepository(store: LocalSaveStore): GameRepository {
       awarded: Boolean(item),
       duplicate: items.some((candidate) => candidate.duplicate),
       quantityAfter: item?.quantityAfter ?? 0,
+      petAwarded,
     }
     save.lootRolls[rollKey] = result
     save.characters[save.activeClassId].inventory = profile.inventory
       store.writeSave(save)
       return clone(result)
     },
+    async recordBossKill(encounterId, options) {
+      const save = requireStoredSave(store)
+      const profile = buildProfile(save)
+      const encounter = profile.dungeons
+        .flatMap((dungeon) => dungeon.encounters)
+        .find((candidate) => candidate.id === encounterId && candidate.isBoss)
+      if (!encounter) throw new Error('Boss encounter not found.')
+      const petAwarded = recordBossKillInSave(save, encounter, {
+        petVariant: options?.petVariant ?? 'normal',
+      })
+      store.writeSave(save)
+      return {
+        profile: buildProfile(save),
+        petAwarded,
+      }
+    },
+    async recordPvpMatch(won) {
+      const save = requireStoredSave(store)
+      save.pvpMatchesPlayed = (save.pvpMatchesPlayed ?? 0) + 1
+      if (won) save.pvpMatchesWon = (save.pvpMatchesWon ?? 0) + 1
+      store.writeSave(save)
+      return buildProfile(save)
+    },
   }
 }
 
@@ -1581,6 +1714,10 @@ const cachedOnlineRepository: GameRepository = {
   upgradeItem: (itemId) => cachedOnlineLocalRepository.upgradeItem(itemId),
   rollEncounterLoot: (encounterId, difficultyId, runToken) =>
     cachedOnlineLocalRepository.rollEncounterLoot(encounterId, difficultyId, runToken),
+  recordBossKill: (encounterId, options) =>
+    cachedOnlineLocalRepository.recordBossKill(encounterId, options),
+  recordPvpMatch: (won) =>
+    cachedOnlineLocalRepository.recordPvpMatch(won),
 }
 
 export function getGameMode(): GameMode {
@@ -1627,13 +1764,17 @@ export function createOfflineCharacter(characterName: string): AuthSession {
     characters[cid] = emptyCharacterData(cid)
   }
   const save: OfflineSave = {
-    version: 3,
+    version: 4,
     characterName: name,
     activeClassId: 1,
     completedDungeonParts: 0,
     completedRaidPhases: 0,
     characters,
     lootRolls: {},
+    bossKills: {},
+    bossPets: {},
+    pvpMatchesPlayed: 0,
+    pvpMatchesWon: 0,
   }
   writeOfflineSave(save)
   writeMode('offline-local')

src/input.tsx

@@ -130,10 +130,20 @@ const STORAGE_KEY = 'ashen-halls-input-bindings-v1'
 const PREFERENCES_STORAGE_KEY = 'ashen-halls-input-preferences-v1'
 const GAME_ACTION_EVENT = 'ashen-halls-game-action'
 const NATIVE_CONTROLLER_EVENT = 'ashen-halls-native-controller'
-const FOCUSABLE_SELECTOR = 'button:not(:disabled), input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])'
+const FOCUSABLE_SELECTOR = 'button:not(:disabled):not([data-controller-nav="skip"]), input:not(:disabled):not([data-controller-nav="skip"]), select:not(:disabled):not([data-controller-nav="skip"]), textarea:not(:disabled):not([data-controller-nav="skip"]), [tabindex]:not([tabindex="-1"]):not([data-controller-nav="skip"])'
+const MAIN_CONTENT_SELECTOR = '.auth-shell, .menu-screen, .content-screen, .dungeon-run-screen, .dual-bottom-display'
+const HEADER_CONTENT_SELECTOR = '.app-header'
 const GAMEPAD_COMBAT_POLL_MS = 1000 / 60
 const GAMEPAD_MENU_POLL_MS = 1000 / 30
 const GAMEPAD_BROWSER_DISCONNECTED_POLL_MS = 250
+const CONTROLLER_REPEAT_INITIAL_MS = 260
+const CONTROLLER_REPEAT_MS = 85
+const DPAD_NAV_ACTIONS: Partial<Record<string, InputAction>> = {
+  Button12: 'navigateUp',
+  Button13: 'navigateDown',
+  Button14: 'navigateLeft',
+  Button15: 'navigateRight',
+}
 
 let lastControllerFocus: HTMLElement | null = null
 
@@ -256,6 +266,16 @@ function isVisible(element: HTMLElement) {
   return element.getClientRects().length > 0
 }
 
+function focusableDescendants(scope: ParentNode) {
+  return Array.from(
+    scope.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
+  ).filter(isVisible)
+}
+
+function uniqueElements(elements: HTMLElement[]) {
+  return elements.filter((element, index) => elements.indexOf(element) === index)
+}
+
 function focusableElements() {
   const keyboard = document.querySelector<HTMLElement>('.controller-keyboard')
   const pauseMenu = document.querySelector<HTMLElement>('.pause-screen')
@@ -264,10 +284,22 @@ function focusableElements() {
       '.result-screen, .binding-capture, .dual-startup-prompt',
     ),
   ).find(isVisible)
-  const scope: ParentNode = keyboard ?? pauseMenu ?? dialog ?? document
+  const mainContent = Array.from(
-  return Array.from(
+    document.querySelectorAll<HTMLElement>(MAIN_CONTENT_SELECTOR),
-    scope.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR),
+  ).find(isVisible)
+  const overlay = keyboard ?? pauseMenu ?? dialog
+  if (overlay) return focusableDescendants(overlay)
+  const visibleHeaders = Array.from(
+    document.querySelectorAll<HTMLElement>(HEADER_CONTENT_SELECTOR),
   ).filter(isVisible)
+  if (!mainContent) return visibleHeaders.length > 0 ? [] : focusableDescendants(document)
+  const headerControls = visibleHeaders.flatMap(
+    (header) => focusableDescendants(header),
+  )
+  return uniqueElements([
+    ...focusableDescendants(mainContent),
+    ...headerControls,
+  ])
 }
 
 function rememberFocusableControl(element: HTMLElement) {
@@ -277,6 +309,7 @@ function rememberFocusableControl(element: HTMLElement) {
 function focusControl(element: HTMLElement) {
   rememberFocusableControl(element)
   element.focus({ preventScroll: true })
+  element.scrollIntoView({ block: 'nearest', inline: 'nearest' })
 }
 
 function currentFocusableControl(candidates = focusableElements()) {
@@ -291,6 +324,23 @@ function currentFocusableControl(candidates = focusableElements()) {
   return null
 }
 
+function rangeDistance(startA: number, endA: number, startB: number, endB: number) {
+  if (endA < startB) return startB - endA
+  if (endB < startA) return startA - endB
+  return 0
+}
+
+function changeSelectOption(select: HTMLSelectElement, direction: -1 | 1) {
+  const options = Array.from(select.options).filter((option) => !option.disabled)
+  const currentIndex = options.findIndex((option) => option.index === select.selectedIndex)
+  const nextOption = options[currentIndex + direction]
+  if (!nextOption) return false
+  select.selectedIndex = nextOption.index
+  select.dispatchEvent(new Event('input', { bubbles: true }))
+  select.dispatchEvent(new Event('change', { bubbles: true }))
+  return true
+}
+
 export function focusFirstControl() {
   const first = focusableElements()[0]
   if (first) focusControl(first)
@@ -311,21 +361,48 @@ function moveFocus(action: InputAction) {
   const currentY = currentRect.top + currentRect.height / 2
   const vertical = action === 'navigateUp' || action === 'navigateDown'
   const direction = action === 'navigateUp' || action === 'navigateLeft' ? -1 : 1
+  const currentIndex = candidates.indexOf(current)
+
+  const adjacent = candidates[currentIndex + direction]
+  const fallbackToAdjacent = () => {
+    if (adjacent) focusControl(adjacent)
+  }
 
   const ranked = candidates
     .filter((candidate) => candidate !== current)
-    .map((candidate) => {
+    .map((candidate, index) => {
       const rect = candidate.getBoundingClientRect()
       const x = rect.left + rect.width / 2
       const y = rect.top + rect.height / 2
-      const primary = vertical ? y - currentY : x - currentX
+      const primary = vertical
-      const secondary = vertical ? Math.abs(x - currentX) : Math.abs(y - currentY)
+        ? direction > 0
-      return { candidate, primary, score: Math.abs(primary) + secondary * 2.5 }
+          ? rect.top - currentRect.bottom
+          : currentRect.top - rect.bottom
+        : direction > 0
+          ? rect.left - currentRect.right
+          : currentRect.left - rect.right
+      const secondary = vertical
+        ? rangeDistance(currentRect.left, currentRect.right, rect.left, rect.right)
+        : rangeDistance(currentRect.top, currentRect.bottom, rect.top, rect.bottom)
+      return {
+        candidate,
+        index,
+        primary,
+        secondary,
+        score: Math.max(0, primary) + secondary * 2.5 + (vertical ? Math.abs(x - currentX) : Math.abs(y - currentY)) * 0.1,
+      }
     })
-    .filter(({ primary }) => Math.sign(primary) === direction)
+    .filter(({ primary }) => primary >= -4)
-    .sort((a, b) => a.score - b.score)
+  const sameRowHorizontal = !vertical
+    ? ranked.filter(({ secondary }) => secondary === 0)
+    : ranked
+  if (sameRowHorizontal.length === 0) {
+    fallbackToAdjacent()
+    return
+  }
+  sameRowHorizontal.sort((a, b) => a.score - b.score || a.secondary - b.secondary || a.index - b.index)
 
-  const next = ranked[0]?.candidate
+  const next = sameRowHorizontal[0]?.candidate
   if (!next) return
   focusControl(next)
 }
@@ -524,12 +601,26 @@ export function InputProvider({ children }: { children: ReactNode }) {
         setTouchLockMessage('')
       }, 1400)
     } else if (action.startsWith('navigate')) {
-      if (uiOverlay || !combatActive) moveFocus(action)
+      if (uiOverlay || !combatActive) {
+        const active = currentFocusableControl()
+        if (
+          active instanceof HTMLSelectElement
+          && (action === 'navigateUp' || action === 'navigateDown')
+          && changeSelectOption(active, action === 'navigateUp' ? -1 : 1)
+        ) {
+          return
+        }
+        moveFocus(action)
+      }
     } else if (action === 'confirm') {
       const active = currentFocusableControl()
       if (isTextInput(active)) {
         setKeyboardInput(active)
         window.requestAnimationFrame(() => focusFirstControl())
+      } else if (active instanceof HTMLSelectElement) {
+        const select = active as HTMLSelectElement & { showPicker?: () => void }
+        if (select.showPicker) select.showPicker()
+        else active.click()
       } else if (
         active
         && active.matches('button:not(:disabled), [role="button"]')
@@ -566,12 +657,6 @@ export function InputProvider({ children }: { children: ReactNode }) {
       document.querySelector('[data-combat-active="true"]'),
     )
     const uiOverlay = hasUiOverlay()
-    const menuDpadActions: Partial<Record<string, InputAction>> = {
-      Button12: 'navigateUp',
-      Button13: 'navigateDown',
-      Button14: 'navigateLeft',
-      Button15: 'navigateRight',
-    }
     const uiPriority = [
       'navigateUp',
       'navigateDown',
@@ -608,18 +693,18 @@ export function InputProvider({ children }: { children: ReactNode }) {
       'navigateLeft',
       'navigateRight',
     ] satisfies InputAction[]
-    const action = menuDpadActions[token] && (!combatActive || uiOverlay)
+    const action = DPAD_NAV_ACTIONS[token] && (!combatActive || uiOverlay)
-      ? menuDpadActions[token]
+      ? DPAD_NAV_ACTIONS[token]
       : uiOverlay
       ? uiPriority.find((candidate) => bindingsRef.current.controller[candidate] === token)
       : combatActive && preferencesRef.current.directPartyTargeting
       ? [...directTargetActions, ...combatPriority].find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
-      : combatActive && menuDpadActions[token]
+      : combatActive && DPAD_NAV_ACTIONS[token]
-        ? menuDpadActions[token]
+        ? DPAD_NAV_ACTIONS[token]
-      : !combatActive && menuDpadActions[token]
+      : !combatActive && DPAD_NAV_ACTIONS[token]
-      ? menuDpadActions[token]
+      ? DPAD_NAV_ACTIONS[token]
       : (combatActive ? combatPriority : INPUT_ACTIONS).find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
@@ -768,11 +853,11 @@ export function InputProvider({ children }: { children: ReactNode }) {
         const action = INPUT_ACTIONS.find(
           (candidate) => bindingsRef.current.controller[candidate] === token,
         )
-        const canRepeat = action?.startsWith('navigate') ?? false
+        const canRepeat = Boolean(action?.startsWith('navigate') || DPAD_NAV_ACTIONS[token])
         const nextRepeat = repeatRef.current[token] ?? 0
         if (pressed || (canRepeat && time >= nextRepeat)) {
           dispatchControllerToken(token, !pressed)
-          repeatRef.current[token] = time + (pressed ? 360 : 125)
+          repeatRef.current[token] = time + (pressed ? CONTROLLER_REPEAT_INITIAL_MS : CONTROLLER_REPEAT_MS)
         }
       })
 

src/main.tsx

@@ -9,7 +9,9 @@ import { DualScreenBottomDisplay, DualScreenProvider, DualScreenStartupPrompt }
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
     {new URLSearchParams(window.location.search).get('display') === 'bottom' ? (
+      <InputProvider>
         <DualScreenBottomDisplay />
+      </InputProvider>
     ) : (
       <DualScreenProvider>
         <DualScreenStartupPrompt />

src/offline-catalog-meta.ts

@@ -1 +1 @@
-export const bundledCatalogHash = '07506c52bab428c439f09a9b82e39e6eff2b243fb972d664da48852059bcd937'
+export const bundledCatalogHash = '2bc6b08d7c902e8f47d74cd0b8c43f5962c1a583cb1f8b42f1ece2b512ad8991'

src/offline-starter-profile.json

@@ -6905,5 +6905,11 @@
         "full_run": []
       }
     }
-  ]
+  ],
+  "hunterStats": {
+    "bossKills": {},
+    "bossPets": {},
+    "pvpMatchesPlayed": 0,
+    "pvpMatchesWon": 0
+  }
 }

src/profile.ts

@@ -145,6 +145,14 @@ export type LootRollItem = Omit<Item, 'quantity' | 'equipped'> & {
   quantityAfter: number
 }
 
+export type PetAward = {
+  encounterId: number
+  petName: string
+  quantity: number
+  duplicate: boolean
+  quantityAfter: number
+}
+
 export type LootRoll = {
   encounterId: number
   encounterName: string
@@ -157,6 +165,7 @@ export type LootRoll = {
   awarded: boolean
   duplicate: boolean
   quantityAfter: number
+  petAwarded?: PetAward | null
 }
 
 export type Dungeon = {
@@ -232,6 +241,12 @@ export type CharacterProfile = {
   craftingRecipes: CraftingRecipe[]
   gearUpgradePaths: GearUpgradePath[]
   dungeons: Dungeon[]
+  hunterStats: {
+    bossKills: Record<string, number>
+    bossPets: Record<string, number>
+    pvpMatchesPlayed: number
+    pvpMatchesWon: number
+  }
 }
 
 export type Account = {
@@ -280,6 +295,7 @@ export type DungeonReward = {
     glyph: string
   }>
   bonusItem: BonusItem | null
+  petAwarded?: PetAward | null
   profile: CharacterProfile
 }
 
@@ -365,6 +381,20 @@ export async function completeRoguelike(
   )
 }
 
+export async function recordBossKill(
+  encounterId: number,
+  options?: { petVariant?: 'normal' | 'purple' },
+): Promise<{
+  profile: CharacterProfile
+  petAwarded: PetAward | null
+}> {
+  return activeGameRepository().recordBossKill(encounterId, options)
+}
+
+export async function recordPvpMatch(won: boolean): Promise<CharacterProfile> {
+  return activeGameRepository().recordPvpMatch(won)
+}
+
 export async function allocateTalent(talentId: number): Promise<CharacterProfile> {
   return activeGameRepository().allocateTalent(talentId)
 }