fix: resolve runtime issues with game loop, tabs, and error handling

- Fix game loop store mismatch (page.tsx now uses modular stores matching gameHooks.ts)
- Fix StatsTab.tsx type errors (signedPacts now from usePrestigeStore)
- Fix React hooks violations (all hooks called before conditional returns)
- Add ErrorBoundary to page.tsx for better error handling
- Fix getStudySpeedMultiplier called with correct arguments
- Build succeeds consistently

src/app/page.tsx

@@ -107,70 +107,60 @@ function GrimoireTab() {
 // ============================================================================
 
 export default function ManaLoopGame() {
-  // Disable prerendering - this is a client-only game
-  if (typeof window === 'undefined') {
-    return <div>Loading...</div>;
-  }
-  
   const [selectedManaType, setSelectedManaType] = useState<string>('');
   const [activeTab, setActiveTab] = useState('spire');
 
-  // Game stores - using new modular stores
+  // ALL hooks must be called before any conditional returns
   const day = useGameStore((s) => s.day);
   const hour = useGameStore((s) => s.hour);
   const initGame = useGameStore((s) => s.initGame);
-  
   const gameLoop = useGameLoop();
 
-  // Get state from modular stores for computed values
   const skills = useSkillStore((s) => s.skills);
   const skillTiers = useSkillStore((s) => s.skillTiers);
   const skillUpgrades = useSkillStore((s) => s.skillUpgrades);
+
   const prestigeUpgrades = usePrestigeStore((s) => s.prestigeUpgrades);
-  const meditateTicks = useManaStore((s) => s.meditateTicks);
+  const insight = usePrestigeStore((s) => s.insight);
+
   const rawMana = useManaStore((s) => s.rawMana);
-  const totalManaGathered = useManaStore((s) => s.totalManaGathered);
+  const meditateTicks = useManaStore((s) => s.meditateTicks);
-  const elements = useManaStore((s) => s.elements);
 
   const maxFloorReached = useCombatStore((s) => s.maxFloorReached);
-  const signedPacts = useCombatStore((s) => s.signedPacts);
   const spells = useCombatStore((s) => s.spells);
 
-  const loopCount = usePrestigeStore((s) => s.loopCount);
+  const gameOver = useUIStore((s) => s.gameOver);
-  const insight = usePrestigeStore((s) => s.insight);
-  const totalInsight = usePrestigeStore((s) => s.totalInsight);
-  const memorySlots = usePrestigeStore((s) => s.memorySlots);
 
   // Computed effects from upgrades and equipment
-  const upgradeEffects = getUnifiedEffects({ 
+  const upgradeEffects = getUnifiedEffects({
-    skillUpgrades, 
+    skillUpgrades,
-    skillTiers, 
+    skillTiers,
-    equippedInstances: {}, 
+    equippedInstances: {},
-    equipmentInstances: {} 
+    equipmentInstances: {}
   });
 
   // Derived stats
-  const maxMana = computeMaxMana({ 
+  const maxMana = computeMaxMana({
-    skills, 
+    skills,
-    prestigeUpgrades, 
+    prestigeUpgrades,
-    skillUpgrades, 
+    skillUpgrades,
-    skillTiers 
+    skillTiers
   }, upgradeEffects);
-  
+
-  const baseRegen = computeRegen({ 
+  const baseRegen = computeRegen({
-    skills, 
+    skills,
-    prestigeUpgrades, 
+    prestigeUpgrades,
-    skillUpgrades, 
+    skillUpgrades,
-    skillTiers 
+    skillTiers
   }, upgradeEffects);
-  
+
-  const clickMana = computeClickMana({ 
+  const clickMana = computeClickMana({
-    skills, 
+    skills,
-    prestigeUpgrades, 
+    prestigeUpgrades,
-    skillUpgrades, 
+    skillUpgrades,
-    skillTiers 
+    skillTiers
   });
-    
+
   const meditationMultiplier = getMeditationBonus(meditateTicks, skills, upgradeEffects.meditationEfficiency);
   const incursionStrength = getIncursionStrength(day, hour);
 
@@ -190,25 +180,26 @@ export default function ManaLoopGame() {
   // Effective regen
   const effectiveRegen = (effectiveRegenWithSpecials + manaCascadeBonus + manaWaterfallBonus) * meditationMultiplier;
 
-  // Game Over check from UI store
-  const gameOver = useUIStore((s) => s.gameOver);
-  
   // Initialize game on mount
   useEffect(() => {
     initGame();
   }, [initGame]);
 
-  // Game Over Screen
-  if (gameOver) {
-    return <GameOverScreen store={{ day, hour, insight }} />;
-  }
-
   // Start game loop
   useEffect(() => {
     const cleanup = gameLoop.start();
     return cleanup;
   }, [gameLoop]);
 
+  // Conditional returns AFTER all hooks
+  if (typeof window === 'undefined') {
+    return <div>Loading...</div>;
+  }
+
+  if (gameOver) {
+    return <GameOverScreen store={{ day, hour, insight }} />;
+  }
+
   return (
     <ErrorBoundary>
       <TooltipProvider>
@@ -225,10 +216,10 @@ export default function ManaLoopGame() {
 
           {/* Main Content */}
           <main className="flex-1 flex flex-col md:flex-row gap-4 p-4">
-            <LeftPanel 
+            <LeftPanel
-              store={{ rawMana, maxMana, day, hour }} 
+              store={{ rawMana, maxMana, day, hour }}
-              effectiveRegen={effectiveRegen} 
+              effectiveRegen={effectiveRegen}
-              incursionStrength={incursionStrength} 
+              incursionStrength={incursionStrength}
             />
 
             <div className="flex-1 min-w-0">
@@ -257,13 +248,13 @@ export default function ManaLoopGame() {
 
                 <TabsContent value="attunements">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <AttunementsTab store={{}} />
+                    <AttunementsTab />
                   </Suspense>
                 </TabsContent>
 
                 <TabsContent value="golemancy">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <GolemancyTab store={{}} />
+                    <GolemancyTab />
                   </Suspense>
                 </TabsContent>
 
@@ -287,25 +278,25 @@ export default function ManaLoopGame() {
 
                 <TabsContent value="crafting">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <CraftingTab store={{}} />
+                    <CraftingTab />
                   </Suspense>
                 </TabsContent>
 
                 <TabsContent value="loot">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <LootTab store={{}} />
+                    <LootTab />
                   </Suspense>
                 </TabsContent>
 
                 <TabsContent value="achievements">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <AchievementsTab store={{}} />
+                    <AchievementsTab />
                   </Suspense>
                 </TabsContent>
 
                 <TabsContent value="lab">
                   <Suspense fallback={<TabLoadingFallback />}>
-                    <LabTab store={{}} />
+                    <LabTab />
                   </Suspense>
                 </TabsContent>
 

src/components/game/tabs/StatsTab.tsx

@@ -5,7 +5,6 @@ import { getTierMultiplier } from '@/lib/game/skill-evolution';
 import { hasSpecial, SPECIAL_EFFECTS } from '@/lib/game/effects';
 import { getUnifiedEffects } from '@/lib/game/effects';
 import { fmt, fmtDec, computeMaxMana, computeRegen, computeClickMana, getMeditationBonus, getIncursionStrength, getStudySpeedMultiplier, getStudyCostMultiplier } from '@/lib/game/stores';
-import type { UnifiedEffects } from '@/lib/game/types';
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
 import { Badge } from '@/components/ui/badge';
 import { Separator } from '@/components/ui/separator';
@@ -30,13 +29,13 @@ export function StatsTab() {
   const insight = usePrestigeStore((s) => s.insight);
   const totalInsight = usePrestigeStore((s) => s.totalInsight);
   const memorySlots = usePrestigeStore((s) => s.memorySlots);
+  const signedPacts = usePrestigeStore((s) => s.signedPacts);
   
   const elements = useManaStore((s) => s.elements);
   const totalManaGathered = useManaStore((s) => s.totalManaGathered);
   const rawMana = useManaStore((s) => s.rawMana);
   const meditateTicks = useManaStore((s) => s.meditateTicks);
   
-  const signedPacts = useCombatStore((s) => s.signedPacts);
   const maxFloorReached = useCombatStore((s) => s.maxFloorReached);
   const spells = useCombatStore((s) => s.spells);
 
@@ -46,8 +45,8 @@ export function StatsTab() {
     skillTiers, 
     equippedInstances: {}, 
     equipmentInstances: {} 
-  }) as UnifiedEffects;
+  });
-  
+
   // Compute derived stats
   const maxMana = computeMaxMana({ 
     skills, 
@@ -70,17 +69,15 @@ export function StatsTab() {
     skillTiers 
   });
   
-  // Get meditation multiplier
   const meditationMultiplier = getMeditationBonus(meditateTicks, skills, upgradeEffects.meditationEfficiency);
   
-  // Get incursion strength
   const day = useGameStore((s) => s.day);
   const hour = useGameStore((s) => s.hour);
   const incursionStrength = getIncursionStrength(day, hour);
-  
+
   // Effective regen with incursion penalty
   const effectiveRegenWithSpecials = baseRegen * (1 - incursionStrength);
-  
+
   // Mana Cascade bonus
   const manaCascadeBonus = hasSpecial(upgradeEffects, SPECIAL_EFFECTS.MANA_CASCADE)
     ? Math.floor(maxMana / 100) * 0.1
@@ -93,11 +90,11 @@ export function StatsTab() {
 
   // Effective regen
   const effectiveRegen = (effectiveRegenWithSpecials + manaCascadeBonus + manaWaterfallBonus) * meditationMultiplier;
-  
+
   // Get study speed/cost multipliers
   const studySpeedMult = getStudySpeedMultiplier(skills);
   const studyCostMult = getStudyCostMultiplier(skills);
-  
+
   // Check special effects
   const hasManaWaterfall = hasSpecial(upgradeEffects, SPECIAL_EFFECTS.MANA_WATERFALL);
   const hasFlowSurge = hasSpecial(upgradeEffects, SPECIAL_EFFECTS.FLOW_SURGE);