rm legacy

src/lib/components/Battle/BattleControls.svelte

@@ -34,7 +34,7 @@
   <div class="action-area">
     {#if waitingForContinue}
       <!-- Tap to continue overlay -->
-      <div class="tap-continue-overlay" on:click={onContinueTap}>
+      <div class="tap-continue-overlay" role="button" tabindex="0" onclick={onContinueTap}>
         <div class="tap-indicator">
           <span>Tap to continue</span>
         </div>

src/lib/components/Battle/BattleField.svelte

@@ -37,8 +37,6 @@
   let playerTrainerSliding = false;
   let enemyTrainerSliding = false;
   
-  // Calculate player XP percentage (0-100% of current level)
-  const playerXpPercentage = (playerPiclet.xp / 100) * 100; // Simplified, should use actual XP curve
   
   onMount(() => {
     if (!showIntro) {
@@ -124,7 +122,6 @@
         <PicletInfo 
           piclet={enemyPiclet}
           hpPercentage={enemyHpPercentage}
-          xpPercentage={0}
           isPlayer={false}
         />
         
@@ -215,7 +212,6 @@
         <PicletInfo 
           piclet={playerPiclet}
           hpPercentage={playerHpPercentage}
-          xpPercentage={playerXpPercentage}
           isPlayer={true}
         />
       </div>

src/lib/components/Battle/PicletInfo.svelte

@@ -5,11 +5,7 @@
   
   export let piclet: PicletInstance;
   export let hpPercentage: number;
-  export let xpPercentage: number = 0; // Legacy prop - will be overridden for players
   export let isPlayer: boolean;
-  
-  // Calculate real XP percentage using levelingService
-  $: realXpPercentage = isPlayer ? getXpProgress(piclet.xp, piclet.level, piclet.tier) : 0;
   $: xpTowardsNext = isPlayer ? getXpTowardsNextLevel(piclet.xp, piclet.level, piclet.tier) : { current: 0, needed: 0, percentage: 0 };
   
   // Type-based styling

src/lib/components/Pages/Encounters.svelte

@@ -493,36 +493,8 @@
     border-radius: 8px;
   }
   
-  .piclet-silhouette {
-    width: 100%;
-    height: 100%;
-    border-radius: 8px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    position: relative;
-    overflow: hidden;
-  }
   
-  .silhouette-img {
-    width: 100%;
-    height: 100%;
-    object-fit: cover;
-    filter: grayscale(100%) brightness(0.3) contrast(0.5);
-    opacity: 0.8;
-  }
   
-  .silhouette-fallback {
-    font-size: 2rem;
-    font-weight: bold;
-    color: #999;
-    background: #e0e0e0;
-    width: 100%;
-    height: 100%;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
   
   .type-icon, .fallback-icon {
     font-size: 2rem;

src/lib/components/Pages/Pictuary.svelte

@@ -1,11 +1,9 @@
 <script lang="ts">
   import { onMount } from 'svelte';
-  import { getAllMonsters } from '$lib/db/monsters';
-  import { getCaughtPiclets, getRosterPiclets, moveToRoster, swapRosterPositions, moveToStorage } from '$lib/db/piclets';
-  import type { Monster, PicletInstance } from '$lib/db/schema';
+  import { getCaughtPiclets, getRosterPiclets, moveToRoster, swapRosterPositions, moveToStorage, getUncaughtPiclets } from '$lib/db/piclets';
+  import type { PicletInstance } from '$lib/db/schema';
   import PicletCard from '../Piclets/PicletCard.svelte';
   import EmptySlotCard from '../Piclets/EmptySlotCard.svelte';
-  import DiscoveredCard from '../Piclets/DiscoveredCard.svelte';
   import DraggablePicletCard from '../Piclets/DraggablePicletCard.svelte';
   import RosterSlot from '../Piclets/RosterSlot.svelte';
   import PicletDetail from '../Piclets/PicletDetail.svelte';
@@ -15,7 +13,7 @@
   
   let rosterPiclets: PicletInstance[] = $state([]);
   let storagePiclets: PicletInstance[] = $state([]);
-  let discoveredMonsters: Monster[] = $state([]);
+  let discoveredPiclets: PicletInstance[] = $state([]);
   let isLoading = $state(true);
   let currentlyDragging: PicletInstance | null = $state(null);
   let selectedPiclet: PicletInstance | null = $state(null);
@@ -84,12 +82,8 @@
         p.rosterPosition > 5
       );
       
-      const allMonsters = await getAllMonsters();
-      
-      const caughtTypeIds = new Set(allInstances.map(p => p.typeId));
-      discoveredMonsters = allMonsters.filter(m => 
-        !caughtTypeIds.has(m.name.toLowerCase().replace(/\s+/g, '-'))
-      );
+      // Get all uncaught piclets (discovered but not caught)
+      discoveredPiclets = await getUncaughtPiclets();
     } catch (err) {
       console.error('Failed to load piclets:', err);
     } finally {
@@ -114,9 +108,6 @@
     selectedPiclet = piclet;
   }
   
-  function handleDiscoveredClick(monster: Monster) {
-    console.log('View discovered monster:', monster);
-  }
   
   function handleDragStart(instance: PicletInstance) {
     currentlyDragging = instance;
@@ -169,7 +160,7 @@
   <ViewAll
     title="Discovered"
     type="discovered"
-    items={discoveredMonsters}
+    items={discoveredPiclets}
     onBack={() => viewAllMode = null}
   />
 {:else}
@@ -179,7 +170,7 @@
       <div class="spinner"></div>
       <p>Loading collection...</p>
     </div>
-  {:else if rosterPiclets.length === 0 && storagePiclets.length === 0 && discoveredMonsters.length === 0}
+  {:else if rosterPiclets.length === 0 && storagePiclets.length === 0 && discoveredPiclets.length === 0}
     <div class="empty-state">
       <svg width="64" height="64" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
         <path d="M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z"></path>
@@ -233,20 +224,20 @@
       {/if}
       
       <!-- Discovered Section -->
-      {#if discoveredMonsters.length > 0}
+      {#if discoveredPiclets.length > 0}
         <section class="discovered-section">
           <div class="section-header">
-            <h2>Discovered ({discoveredMonsters.length})</h2>
-            {#if discoveredMonsters.length > 10}
+            <h2>Discovered ({discoveredPiclets.length})</h2>
+            {#if discoveredPiclets.length > 10}
               <button class="view-all-btn">View All</button>
             {/if}
           </div>
           <div class="horizontal-scroll">
-            {#each discoveredMonsters.slice(0, 10) as monster}
-              <DiscoveredCard 
-                {monster}
+            {#each discoveredPiclets.slice(0, 10) as piclet}
+              <PicletCard 
+                piclet={piclet}
                 size={100}
-                onClick={() => handleDiscoveredClick(monster)}
+                onClick={() => selectedPiclet = piclet}
               />
             {/each}
           </div>

src/lib/components/Pages/ViewAll.svelte

@@ -1,14 +1,13 @@
 <script lang="ts">
-  import type { PicletInstance, Monster } from '$lib/db/schema';
+  import type { PicletInstance } from '$lib/db/schema';
   import PicletCard from '../Piclets/PicletCard.svelte';
   import DraggablePicletCard from '../Piclets/DraggablePicletCard.svelte';
-  import DiscoveredCard from '../Piclets/DiscoveredCard.svelte';
   import PicletDetail from '../Piclets/PicletDetail.svelte';
   
   interface Props {
     title: string;
     type: 'storage' | 'discovered';
-    items: PicletInstance[] | Monster[];
+    items: PicletInstance[];
     onBack: () => void;
     onItemsChanged?: () => void;
     onDragStart?: (instance: PicletInstance) => void;
@@ -18,12 +17,8 @@
   let { title, type, items, onBack, onItemsChanged, onDragStart, onDragEnd }: Props = $props();
   let selectedPiclet: PicletInstance | null = $state(null);
   
-  function handleItemClick(item: PicletInstance | Monster) {
-    if ('currentHp' in item) {
-      selectedPiclet = item as PicletInstance;
-    } else {
-      console.log('View discovered monster:', item);
-    }
+  function handleItemClick(item: PicletInstance) {
+    selectedPiclet = item;
   }
 </script>
 
@@ -46,17 +41,17 @@
     {:else}
       <div class="items-grid">
         {#each items as item}
-          {#if type === 'storage' && 'currentHp' in item}
+          {#if type === 'storage'}
             <DraggablePicletCard
-              instance={item as PicletInstance}
+              instance={item}
               size={100}
               onClick={() => handleItemClick(item)}
               onDragStart={onDragStart}
               onDragEnd={onDragEnd}
             />
-          {:else if type === 'discovered' && 'stats' in item}
-            <DiscoveredCard
-              monster={item as Monster}
+          {:else if type === 'discovered'}
+            <PicletCard
+              piclet={item}
               size={100}
               onClick={() => handleItemClick(item)}
             />

src/lib/components/Piclets/AbilityDisplay.svelte

@@ -217,30 +217,6 @@
     line-height: 1.4;
   }
   
-  .ability-counts {
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-    align-items: flex-end;
-  }
-  
-  .count-badge {
-    font-size: 11px;
-    padding: 3px 8px;
-    border-radius: 12px;
-    font-weight: 500;
-    white-space: nowrap;
-  }
-  
-  .count-badge.effects {
-    background: #e3f2fd;
-    color: #1976d2;
-  }
-  
-  .count-badge.triggers {
-    background: #fff3e0;
-    color: #f57c00;
-  }
   
   .ability-details {
     margin-top: 16px;
@@ -262,57 +238,7 @@
     font-size: 16px;
   }
   
-  .effects-section,
-  .triggers-section {
-    margin-bottom: 16px;
-  }
-  
-  .effects-list,
-  .triggers-list {
-    display: flex;
-    flex-direction: column;
-    gap: 8px;
-  }
-  
-  .effect-item {
-    display: flex;
-    align-items: flex-start;
-    gap: 10px;
-    padding: 8px 12px;
-    background: rgba(255, 255, 255, 0.7);
-    border-radius: 8px;
-    border: 1px solid rgba(0, 0, 0, 0.08);
-  }
-  
-  .effect-icon {
-    font-size: 16px;
-    margin-top: 1px;
-  }
-  
-  .effect-icon.small {
-    font-size: 14px;
-  }
   
-  .effect-details {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    gap: 2px;
-  }
-  
-  .effect-type {
-    font-size: 12px;
-    font-weight: 600;
-    color: #495057;
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-  }
-  
-  .effect-description {
-    font-size: 13px;
-    color: #6c757d;
-    line-height: 1.3;
-  }
   
   .trigger-item {
     background: rgba(255, 255, 255, 0.7);

src/lib/components/Piclets/DiscoveredCard.svelte

@@ -1,87 +0,0 @@
-<script lang="ts">
-  import type { Monster } from '$lib/db/schema';
-  
-  interface Props {
-    monster: Monster;
-    size?: number;
-    onClick?: () => void;
-  }
-  
-  let { monster, size = 100, onClick }: Props = $props();
-  
-  // Default type color
-  const typeColor = '#007bff';
-</script>
-
-<button 
-  class="discovered-card" 
-  style="width: {size}px; height: {size + 30}px;"
-  onclick={onClick}
-  type="button"
->
-  <div class="image-container" style="background-color: {typeColor}10;">
-    <img 
-      src={monster.imageData || monster.imageUrl} 
-      alt={monster.name}
-      class="piclet-image"
-      style="width: {size * 0.9}px; height: {size * 0.9}px;"
-    />
-  </div>
-  
-  <div class="name-section">
-    <p class="name">{monster.name}</p>
-  </div>
-</button>
-
-<style>
-  .discovered-card {
-    display: flex;
-    flex-direction: column;
-    background: white;
-    border-radius: 12px;
-    border: 2px solid;
-    border-color: color-mix(in srgb, var(--type-color, #007bff) 30%, transparent);
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-    padding: 0;
-    cursor: pointer;
-    transition: transform 0.2s;
-    opacity: 0.8;
-  }
-  
-  .discovered-card:active {
-    transform: scale(0.95);
-  }
-  
-  .image-container {
-    flex: 1;
-    position: relative;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    border-radius: 10px 10px 0 0;
-    overflow: hidden;
-  }
-  
-  .piclet-image {
-    object-fit: contain;
-    filter: brightness(0.9);
-  }
-  
-  .name-section {
-    height: 30px;
-    padding: 4px 6px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-  }
-  
-  .name {
-    margin: 0;
-    font-size: 11px;
-    font-weight: 600;
-    text-align: center;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-</style>

src/lib/components/Piclets/NewlyCaughtPicletDetail.svelte

@@ -56,14 +56,18 @@
     showCelebration = false;
     if (celebrationTimeout) clearTimeout(celebrationTimeout);
   }
+  
+  function handleContainerClick(event: MouseEvent) {
+    event.stopPropagation();
+  }
 </script>
 
-<div class="detail-overlay" on:click={onClose}>
-  <div class="detail-container newly-caught" on:click|stopPropagation>
+<div class="detail-overlay" role="dialog" aria-modal="true" tabindex="-1" onclick={onClose}>
+  <div class="detail-container newly-caught" role="document" onclick={handleContainerClick}>
     
     <!-- Celebration overlay -->
     {#if showCelebration}
-      <div class="celebration-overlay" on:click={dismissCelebration}>
+      <div class="celebration-overlay" role="button" tabindex="0" onclick={dismissCelebration}>
         <div class="celebration-content">
           <div class="celebration-sparkles">✨</div>
           <h1 class="celebration-title">Welcome to your team!</h1>
@@ -77,7 +81,7 @@
 
     <!-- Header with special "newly caught" styling -->
     <div class="detail-header" style="background: {tier().bg}">
-      <button class="close-button" on:click={onClose}>×</button>
+      <button class="close-button" onclick={onClose}>×</button>
       <div class="newly-caught-badge">
         <span class="badge-text">✨ NEWLY CAUGHT ✨</span>
       </div>
@@ -110,14 +114,14 @@
       <button 
         class="tab-button" 
         class:active={selectedTab === 'about'}
-        on:click={() => selectedTab = 'about'}
+        onclick={() => selectedTab = 'about'}
       >
         About
       </button>
       <button 
         class="tab-button" 
         class:active={selectedTab === 'abilities'}
-        on:click={() => selectedTab = 'abilities'}
+        onclick={() => selectedTab = 'abilities'}
       >
         Abilities
       </button>

src/lib/db/index.ts

@@ -1,11 +1,8 @@
 import Dexie, { type Table } from 'dexie';
-import type { Monster, PicletInstance, Encounter, GameState } from './schema';
+import type { PicletInstance, Encounter, GameState } from './schema';
 
 export class PicletDatabase extends Dexie {
-  // Legacy table
-  monsters!: Table<Monster>;
-  
-  // New game tables
+  // Game tables
   picletInstances!: Table<PicletInstance>;
   encounters!: Table<Encounter>;
   gameState!: Table<GameState>;
@@ -13,37 +10,26 @@ export class PicletDatabase extends Dexie {
   constructor() {
     super('PicletGameDB');
     
-    this.version(1).stores({
-      monsters: '++id, name, createdAt'
-    });
+    // Version 1: Legacy monsters table (removed in v5)
     
-    // Version 2: Add imageData field
-    this.version(2).stores({
-      monsters: '++id, name, createdAt'
-    }).upgrade(tx => {
-      // No data migration needed, just schema update
-      return tx.table('monsters').toCollection().modify(monster => {
-        monster.imageData = monster.imageData || null;
-      });
-    });
+    // Version 2: Legacy monsters table with imageData (removed in v5)
     
-    // Version 3: Add stats field
-    this.version(3).stores({
-      monsters: '++id, name, createdAt'
-    }).upgrade(tx => {
-      // No data migration needed, just schema update
-      return tx.table('monsters').toCollection().modify(monster => {
-        monster.stats = monster.stats || null;
-      });
-    });
+    // Version 3: Legacy monsters table with stats (removed in v5)
     
-    // Version 4: Add new game tables
+    // Version 4: Add new game tables with legacy monsters
     this.version(4).stores({
       monsters: '++id, name, createdAt',
       picletInstances: '++id, typeId, nickname, isInRoster, rosterPosition, caughtAt',
       encounters: '++id, type, createdAt',
       gameState: '++id, lastPlayed'
     });
+    
+    // Version 5: Remove legacy monsters table
+    this.version(5).stores({
+      picletInstances: '++id, typeId, nickname, isInRoster, rosterPosition, caughtAt',
+      encounters: '++id, type, createdAt',
+      gameState: '++id, lastPlayed'
+    });
   }
 }
 

src/lib/db/monsters.ts

@@ -1,36 +0,0 @@
-import { db } from './index';
-import type { Monster } from './schema';
-import { monsterToPicletInstance, savePicletInstance } from './piclets';
-
-export async function saveMonster(monsterData: Omit<Monster, 'id' | 'createdAt'>, createPiclet: boolean = true): Promise<number> {
-  const monster: Omit<Monster, 'id'> = {
-    ...monsterData,
-    createdAt: new Date()
-  };
-  
-  const monsterId = await db.monsters.add(monster);
-  
-  // Also create a PicletInstance if requested and stats are available
-  if (createPiclet && monster.stats) {
-    try {
-      const picletData = await monsterToPicletInstance({ ...monster, id: monsterId }, 5);
-      await savePicletInstance(picletData);
-    } catch (err) {
-      console.error('Failed to create PicletInstance:', err);
-    }
-  }
-  
-  return monsterId;
-}
-
-export async function getAllMonsters(): Promise<Monster[]> {
-  return await db.monsters.toArray();
-}
-
-export async function getMonster(id: number): Promise<Monster | undefined> {
-  return await db.monsters.get(id);
-}
-
-export async function deleteMonster(id: number): Promise<void> {
-  await db.monsters.delete(id);
-}

src/lib/db/piclets.ts

@@ -1,130 +1,9 @@
 import { db } from './index';
-import type { PicletInstance, Monster, BattleMove } from './schema';
+import type { PicletInstance, BattleMove } from './schema';
 import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
 import type { PicletStats } from '../types';
 import { generateUnlockLevels } from '../services/unlockLevels';
 
-// Convert a generated Monster to a PicletInstance
-export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
-  if (!monster.stats) {
-    throw new Error('Monster must have stats to create PicletInstance');
-  }
-
-  // All monsters must now have the battle-ready format
-  const stats = monster.stats as PicletStats;
-  
-  if (!stats.baseStats || !stats.specialAbility || !stats.movepool) {
-    throw new Error('Monster stats must be in battle-ready format with baseStats, specialAbility, and movepool');
-  }
-  
-  // Calculate base stats from battle-ready format
-  const baseHp = Math.floor(stats.baseStats.hp * 2 + 50);
-  const baseAttack = Math.floor(stats.baseStats.attack * 1.5 + 30);
-  const baseDefense = Math.floor(stats.baseStats.defense * 1.5 + 30);
-  const baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
-  
-  // Determine primary type from battle stats
-  const normalizedType = stats.primaryType.toLowerCase();
-  const validType = Object.values(PicletType).find(type => type === normalizedType);
-  const primaryType = validType || getTypeFromConcept(monster.concept, monster.imageCaption);
-  
-  if (!validType) {
-    console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
-  }
-
-  // Create moves from battle-ready format (without unlock levels initially)
-  const baseMoves: BattleMove[] = stats.movepool.map(move => ({
-    name: move.name,
-    type: move.type as unknown as AttackType,
-    power: move.power,
-    accuracy: move.accuracy,
-    pp: move.pp,
-    currentPp: move.pp,
-    description: move.description,
-    unlockLevel: 1 // Temporary, will be set below
-  }));
-  
-  // Generate unlock levels for moves and special ability
-  const { movesWithUnlocks, abilityUnlockLevel } = generateUnlockLevels(baseMoves, stats.specialAbility);
-  const moves = movesWithUnlocks;
-  
-  // Field stats are variations of regular stats
-  const baseFieldAttack = Math.floor(baseAttack * 0.8);
-  const baseFieldDefense = Math.floor(baseDefense * 0.8);
-  
-  // Use Pokemon-accurate stat calculations (matching levelingService)
-  const calculateStat = (base: number, level: number) => {
-    if (level === 1) {
-      return Math.max(1, Math.floor(base / 10) + 5);
-    }
-    return Math.floor((2 * base * level) / 100) + 5;
-  };
-  
-  const calculateHp = (base: number, level: number) => {
-    if (level === 1) {
-      return Math.max(1, Math.floor(base / 10) + 11);
-    }
-    return Math.floor((2 * base * level) / 100) + level + 10;
-  };
-  
-  const maxHp = calculateHp(baseHp, level);
-  
-  
-  const bst = baseHp + baseAttack + baseDefense + baseFieldAttack + baseFieldDefense + baseSpeed;
-  
-  return {
-    // Type Info
-    typeId: monster.name.toLowerCase().replace(/\s+/g, '-'),
-    nickname: monster.name,
-    primaryType: primaryType,
-    secondaryType: undefined,
-    
-    // Current Stats
-    currentHp: maxHp,
-    maxHp,
-    level,
-    xp: 0,
-    attack: calculateStat(baseAttack, level),
-    defense: calculateStat(baseDefense, level),
-    fieldAttack: calculateStat(baseFieldAttack, level),
-    fieldDefense: calculateStat(baseFieldDefense, level),
-    speed: calculateStat(baseSpeed, level),
-    
-    // Base Stats
-    baseHp,
-    baseAttack,
-    baseDefense,
-    baseFieldAttack,
-    baseFieldDefense,
-    baseSpeed,
-    
-    // Battle
-    moves,
-    nature: stats.nature,
-    specialAbility: stats.specialAbility,
-    specialAbilityUnlockLevel: abilityUnlockLevel,
-    
-    // Roster
-    isInRoster: false,
-    rosterPosition: undefined,
-    
-    // Metadata
-    caught: false, // Scanned Piclets start as uncaught
-    caughtAt: undefined, // Will be set when caught
-    bst,
-    tier: stats.tier, // Use tier from stats
-    role: 'balanced', // Could be enhanced based on stat distribution
-    variance: 0,
-    
-    // Original generation data
-    imageUrl: monster.imageUrl,
-    imageData: monster.imageData,
-    imageCaption: monster.imageCaption,
-    concept: monster.concept,
-    description: stats.description,
-    imagePrompt: monster.imagePrompt
-  };
-}
 
 // Save a new PicletInstance
 export async function savePicletInstance(piclet: Omit<PicletInstance, 'id'>): Promise<number> {

src/lib/db/resetGame.ts

@@ -7,20 +7,22 @@ export async function resetGameState() {
   await db.encounters.clear();
   await db.gameState.clear();
   
-  // Note: We don't clear monsters as those represent scanned/discovered piclets
+  // Note: All Piclets are now stored in picletInstances table
   console.log('Game state reset - all caught piclets and encounters cleared');
 }
 
-// Clear only discovered piclets (monsters)
+// Clear only uncaught piclets (discovered but not caught)
 export async function clearDiscoveredPiclets() {
-  await db.monsters.clear();
-  console.log('Discovered piclets cleared');
+  // Remove all uncaught piclets from the database
+  await db.picletInstances.where('caught').equals(false).delete();
+  console.log('Uncaught piclets cleared');
 }
 
-// Full reset including discovered piclets
+// Full reset including all piclets
 export async function fullGameReset() {
-  await resetGameState();
-  await clearDiscoveredPiclets();
+  await db.picletInstances.clear();
+  await db.encounters.clear();
+  await db.gameState.clear();
   console.log('Full game reset - all data cleared');
 }
 

src/lib/db/schema.ts

@@ -141,15 +141,3 @@ export interface BattleState {
   capturedPiclet?: PicletInstance;
 }
 
-// Monster interface - now only supports battle-ready format
-export interface Monster {
-  id?: number;
-  name: string;
-  imageUrl: string;
-  imageData?: string;
-  imageCaption: string;
-  concept: string;
-  imagePrompt: string;
-  stats?: import('../types').PicletStats; // Only battle-ready format
-  createdAt: Date;
-}

src/lib/utils/battleConversion.ts

@@ -41,7 +41,7 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
 
   // All Piclets must now have special abilities
   if (!instance.specialAbility) {
-    throw new Error('Piclet must have a special ability. Legacy Piclets are no longer supported.');
+    throw new Error('Piclet must have a special ability.');
   }
   
   // Only include special ability if unlocked

src/tests/encounterService.test.ts

@@ -2,12 +2,11 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import { EncounterService } from '../lib/db/encounterService';
 import { db } from '../lib/db';
 import { EncounterType } from '../lib/db/schema';
-import type { Monster, PicletInstance } from '../lib/db/schema';
+import type { PicletInstance } from '../lib/db/schema';
 
 describe('EncounterService', () => {
   beforeEach(async () => {
     // Clear all data before each test
-    await db.monsters.clear();
     await db.picletInstances.clear();
     await db.encounters.clear();
     await db.gameState.clear();
@@ -16,9 +15,7 @@ describe('EncounterService', () => {
   describe('generateEncounters', () => {
     it('should return empty array when no piclets are discovered', async () => {
       // Arrange - ensure database is empty
-      const monsterCount = await db.monsters.count();
       const picletCount = await db.picletInstances.count();
-      expect(monsterCount).toBe(0);
       expect(picletCount).toBe(0);
 
       // Act
@@ -33,16 +30,43 @@ describe('EncounterService', () => {
     });
 
     it('should return only "Your First Piclet!" when piclets are discovered but not caught', async () => {
-      // Arrange - add a discovered piclet (monster)
-      const testMonster: Omit<Monster, 'id'> = {
-        name: 'Test Piclet',
+      // Arrange - add a discovered piclet (uncaught)
+      const testPiclet: Omit<PicletInstance, 'id'> = {
+        typeId: 'test-piclet',
+        nickname: 'Test Piclet',
+        primaryType: 'beast' as any,
+        currentHp: 100,
+        maxHp: 100,
+        level: 5,
+        xp: 0,
+        attack: 50,
+        defense: 50,
+        fieldAttack: 40,
+        fieldDefense: 40,
+        speed: 50,
+        baseHp: 100,
+        baseAttack: 50,
+        baseDefense: 50,
+        baseFieldAttack: 40,
+        baseFieldDefense: 40,
+        baseSpeed: 50,
+        moves: [],
+        nature: 'hardy',
+        specialAbility: { name: 'Test', description: 'Test', trigger: 'onBattleStart', effects: [] },
+        specialAbilityUnlockLevel: 1,
+        isInRoster: false,
+        caught: false,
+        bst: 300,
+        tier: 'low',
+        role: 'balanced',
+        variance: 0,
         imageUrl: 'https://test.com/piclet.png',
-        concept: 'test',
-        imagePrompt: 'test prompt',
         imageCaption: 'test caption',
-        createdAt: new Date()
+        concept: 'test',
+        description: 'A test piclet',
+        imagePrompt: 'test prompt'
       };
-      await db.monsters.add(testMonster);
+      await db.picletInstances.add(testPiclet);
 
       // Act
       const encounters = await EncounterService.generateEncounters();