Release Healer Man 0.1.19

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "healer-man",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "healer-man",
-      "version": "0.1.16",
+      "version": "0.1.19",
       "dependencies": {
         "@capacitor/android": "8.4.1",
         "@capacitor/core": "8.4.1",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "healer-man",
   "private": true,
-  "version": "0.1.16",
+  "version": "0.1.19",
   "type": "module",
   "scripts": {
     "dev": "vite --host 0.0.0.0",

release-version.json

@@ -1,4 +1,4 @@
 {
-  "versionName": "0.1.16",
+  "versionName": "0.1.19",
-  "versionCode": 1016
+  "versionCode": 1019
 }

scripts/content/prepare-android-bootstrap.mjs

@@ -32,6 +32,10 @@ const sources = [
     directory: path.join(PROJECT_ROOT, "public", "assets", "creatures", "wailing-caverns"),
     logicalPrefix: "assets/creatures/wailing-caverns",
   },
+  {
+    directory: path.join(PROJECT_ROOT, "public", "assets", "game", "arenas"),
+    logicalPrefix: "assets/game/arenas",
+  },
   {
     directory: path.join(PROJECT_ROOT, "src", "assets", "game", "dungeons", "wailing-caverns"),
     logicalPrefix: "assets/game/dungeons/wailing-caverns",

scripts/content/prepare-web-bootstrap.mjs

@@ -33,6 +33,10 @@ const sources = [
     directory: path.join(PROJECT_ROOT, "public", "assets", "creatures", "wailing-caverns"),
     logicalPrefix: "assets/creatures/wailing-caverns",
   },
+  {
+    directory: path.join(PROJECT_ROOT, "public", "assets", "game", "arenas"),
+    logicalPrefix: "assets/game/arenas",
+  },
   {
     directory: path.join(PROJECT_ROOT, "src", "assets", "game", "dungeons", "wailing-caverns"),
     logicalPrefix: "assets/game/dungeons/wailing-caverns",

scripts/content/publish-content.mjs

@@ -20,6 +20,7 @@ export const BUNDLED_ANDROID_PACKS = Object.freeze([
   "core:equipment",
   "core:character-basic",
   "core:runtime",
+  "core:arenas",
   "dungeon:wailing-caverns",
 ]);
 
@@ -79,6 +80,7 @@ function packLabel(packId) {
   if (packId === "core:equipment") return "Starter Equipment";
   if (packId === "core:character-basic") return "Basic Human Character Model";
   if (packId === "core:runtime") return "Game Runtime";
+  if (packId === "core:arenas") return "Rated Arenas";
   if (packId === "core:combat-media") return "Original Spell Effects & Sounds";
   return name;
 }
@@ -105,6 +107,7 @@ export function contentPackForPath(logicalPath) {
   if (segments[1] === "game" && segments[2] === "dungeons" && segments[3]) {
     return `dungeon:${segments[3]}`;
   }
+  if (segments[1] === "game" && segments[2] === "arenas") return "core:arenas";
   if (segments[1] === "game" && segments[2] === "manastorm" && segments[3]) {
     return `manastorm:${segments[3]}`;
   }

scripts/content/publish-content.test.mjs

@@ -20,6 +20,8 @@ test("assigns stable player-facing packs from logical asset paths", () => {
   assert.equal(contentPackForPath("assets/characters/wow335a-v1/textures/character/human/male/humanmaleskin00_01.webp"), "characters:wow335a-v1");
   assert.equal(contentPackForPath("assets/characters/wow335a-v1/orc/male/rig.glb"), "characters:wow335a-v1");
   assert.equal(contentPackForPath("assets/game/manastorm/stage-1/visual.glb"), "manastorm:stage-1");
+  assert.equal(contentPackForPath("assets/game/arenas/nagrand-arena/visual.glb"), "core:arenas");
+  assert.equal(BUNDLED_ANDROID_PACKS.includes("core:arenas"), true);
   assert.equal(contentPackForPath("assets/game/combat-effects/audio/smite.wav"), "core:combat-media");
   assert.equal(
     contentPackForPath("assets/game/combat-effects/audio/manastorm/Manastorm_BossKill_GenericPortalsReady.wav"),

server/arena-simulation.d.mts

@@ -39,6 +39,7 @@ export declare const ARENA_TICK_MS: 50;
 export declare class ArenaSimulation {
   constructor(options: ArenaSimulationOptions);
   start(): this;
+  resetPreparationClock(startedAt?: number): boolean;
   stop(): void;
   step(): void;
   snapshot(): ArenaAuthoritativeSnapshot;

server/arena-simulation.mjs

@@ -156,6 +156,13 @@ export class ArenaSimulation {
     return this;
   }
 
+  resetPreparationClock(startedAt = Date.now()) {
+    if (this.interval || this.tickNumber !== 0 || this.phase !== "preparation" || this.finished) return false;
+    this.startedAt = Number(startedAt);
+    this.phaseEndsAt = this.startedAt + 10_000;
+    return true;
+  }
+
   stop() {
     if (this.interval) clearInterval(this.interval);
     this.interval = null;

server/arena-simulation.test.mjs

@@ -26,6 +26,14 @@ test("authoritative simulation seals ten seconds, runs 20 Hz, and rejects duplic
   assert.ok(simulation.actor("left-healer").position[0] > before);
 });
 
+test("a deferred practice start receives a fresh preparation clock", () => {
+  const stage = ARENA_STAGES.find((entry) => entry.id === "warnorken-arena");
+  const simulation = new ArenaSimulation({ id: "deferred", stage, bracket: "2v2", mode: "practice", ruleset: "wow", participants: participants(), startedAt: 1_000 });
+  assert.equal(simulation.resetPreparationClock(20_000), true);
+  assert.equal(simulation.snapshot().serverTime, 20_000);
+  assert.equal(simulation.snapshot().phaseEndsAt, 30_000);
+});
+
 test("Dalaran and Ring of Valor mechanics synchronize collision state", () => {
   const dalaran = ARENA_STAGES.find((entry) => entry.id === "dalaran-sewers");
   const warning = arenaDynamicObjectState(dalaran, 27_000).find((entry) => entry.id === "waterfall");

src/ArenaRuntime.tsx

@@ -1,56 +1,104 @@
-import { Clone } from "@react-three/drei";
+import { Clone, useProgress } from "@react-three/drei";
 import { Canvas, useFrame } from "@react-three/fiber";
-import { Suspense, useEffect, useMemo, useRef, type RefObject } from "react";
+import { Component, Suspense, useCallback, useEffect, useMemo, useRef, useState, type ReactNode, type RefObject } from "react";
-import { FrontSide, Group, Mesh, Vector3 } from "three";
+import { Group, Vector3 } from "three";
 import { selectedCharacter, useShellStore } from "./app/shellStore";
 import { CharacterModel } from "./avatar/CharacterModel";
 import { ProceduralAvatar } from "./avatar/ProceduralAvatar";
 import { classById } from "./app/characterCatalog";
 import { equipmentItemsForOwner, PLAYER_EQUIPMENT_OWNER_ID } from "./game/equipment";
 import { useArenaStore } from "./game/arenaStore";
+import { arenaCameraPose } from "./game/arenaCamera";
 import { arenaStageById } from "./game/arenaStages";
 import type { ArenaActorSnapshot, ArenaDynamicObjectSnapshot, ArenaStageManifest } from "./game/arenaTypes";
 import { GameGltfLoaderLifecycle, useGameGLTF } from "./scene/useGameGLTF";
 
-function StageEnvironment({ stage }: { stage: ArenaStageManifest }) {
+class ArenaStageErrorBoundary extends Component<{
-  const visual = stage.assets.find((asset) => asset.id === "visual")?.url;
+  readonly children: ReactNode;
-  return visual ? <LoadedStage url={visual} /> : <ProceduralStage stage={stage} />;
+  readonly fallback: ReactNode;
+  readonly onError: (error: unknown) => void;
+}, { readonly failed: boolean }> {
+  state = { failed: false };
+
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+
+  componentDidCatch(error: unknown) {
+    this.props.onError(error);
+  }
+
+  render() {
+    return this.state.failed ? this.props.fallback : this.props.children;
+  }
 }
 
-function LoadedStage({ url }: { url: string }) {
+function StageEnvironment({ stage, onReady }: { stage: ArenaStageManifest; onReady: () => void }) {
+  const visual = stage.assets.find((asset) => asset.id === "visual")?.url;
+  return (
+    <>
+      <ProceduralStage stage={stage} floorOnly />
+      {visual ? <LoadedStage url={visual} onReady={onReady} /> : <StageReady onReady={onReady} />}
+    </>
+  );
+}
+
+function StageReady({ onReady }: { readonly onReady: () => void }) {
+  useEffect(onReady, [onReady]);
+  return null;
+}
+
+function LoadedStage({ url, onReady }: { url: string; onReady: () => void }) {
   const gltf = useGameGLTF(`${url}?arena-runtime=1`);
   useEffect(() => {
-    gltf.scene.traverse((object) => {
+    onReady();
-      if (!(object instanceof Mesh)) return;
+  }, [gltf.scene, onReady]);
-      const materials = Array.isArray(object.material) ? object.material : [object.material];
-      for (const material of materials) {
-        material.side = FrontSide;
-        material.needsUpdate = true;
-      }
-    });
-  }, [gltf.scene]);
   return <Clone object={gltf.scene} />;
 }
 
-function ProceduralStage({ stage }: { stage: ArenaStageManifest }) {
+function ProceduralStage({ stage, floorOnly = false }: { stage: ArenaStageManifest; floorOnly?: boolean }) {
   const width = stage.bounds.max[0] - stage.bounds.min[0];
   const depth = stage.bounds.max[2] - stage.bounds.min[2];
   const centerX = (stage.bounds.max[0] + stage.bounds.min[0]) / 2;
   const centerZ = (stage.bounds.max[2] + stage.bounds.min[2]) / 2;
+  const floorY = Math.min(...stage.teamSpawns.map((spawn) => spawn[1])) - 0.175;
+  const wallHeight = 2.4;
   return (
     <group>
-      <mesh position={[centerX, stage.bounds.min[1], centerZ]} receiveShadow>
+      <mesh position={[centerX, floorY, centerZ]} receiveShadow>
-        <boxGeometry args={[width, 0.5, depth]} />
+        <boxGeometry args={[width, 0.25, depth]} />
-        <meshStandardMaterial color="#252b27" roughness={0.9} />
+        <meshStandardMaterial color={floorOnly ? "#364038" : "#3d4d43"} roughness={0.92} />
       </mesh>
-      {stage.lineOfSight.map((object) => (
+      {!floorOnly && (
-        <mesh key={object.id} position={object.position as [number, number, number]} castShadow receiveShadow>
+        <>
-          {object.shape === "cylinder"
+          <gridHelper args={[Math.max(width, depth), 24, "#c8aa5c", "#596c5f"]} position={[centerX, floorY + 0.14, centerZ]} />
-            ? <cylinderGeometry args={[object.size[0] / 2, object.size[0] / 2, object.size[1], 16]} />
+          {[
-            : <boxGeometry args={object.size as [number, number, number]} />}
+            [centerX, floorY + wallHeight / 2, stage.bounds.min[2], width, wallHeight, 0.6],
-          <meshStandardMaterial color="#4e5146" roughness={0.78} />
+            [centerX, floorY + wallHeight / 2, stage.bounds.max[2], width, wallHeight, 0.6],
-        </mesh>
+            [stage.bounds.min[0], floorY + wallHeight / 2, centerZ, 0.6, wallHeight, depth],
-      ))}
+            [stage.bounds.max[0], floorY + wallHeight / 2, centerZ, 0.6, wallHeight, depth],
+          ].map(([x, y, z, sizeX, sizeY, sizeZ], index) => (
+            <mesh key={`boundary-${index}`} position={[x, y, z]} receiveShadow>
+              <boxGeometry args={[sizeX, sizeY, sizeZ]} />
+              <meshStandardMaterial color="#26342d" roughness={0.88} />
+            </mesh>
+          ))}
+          {stage.teamSpawns.map((spawn, index) => (
+            <mesh key={`spawn-${index}`} position={[spawn[0], floorY + 0.2, spawn[2]]} receiveShadow>
+              <cylinderGeometry args={[3.4, 3.4, 0.18, 32]} />
+              <meshStandardMaterial color={index === 0 ? "#338dcc" : "#bd4944"} emissive={index === 0 ? "#123d5b" : "#541c1a"} emissiveIntensity={0.7} />
+            </mesh>
+          ))}
+          {stage.lineOfSight.map((object) => (
+            <mesh key={object.id} position={object.position as [number, number, number]} castShadow receiveShadow>
+              {object.shape === "cylinder"
+                ? <cylinderGeometry args={[object.size[0] / 2, object.size[0] / 2, object.size[1], 16]} />
+                : <boxGeometry args={object.size as [number, number, number]} />}
+              <meshStandardMaterial color="#6a6f5e" roughness={0.78} />
+            </mesh>
+          ))}
+        </>
+      )}
     </group>
   );
 }
@@ -141,31 +189,35 @@ function ArenaActor({ actor, local, character, movement, stage }: { actor: Arena
 function ArenaCamera({ actor, stage }: { actor: ArenaActorSnapshot | null; stage: ArenaStageManifest }) {
   const target = useMemo(() => new Vector3(), []);
   const desired = useMemo(() => new Vector3(), []);
+  const pose = useMemo(() => arenaCameraPose(stage, actor?.team ?? 0), [actor?.team, stage]);
   useFrame(({ camera }, delta) => {
     if (!actor) return;
-    const spawn = stage.teamSpawns[actor.team];
+    target.set(...pose.target);
-    const centerX = (stage.bounds.min[0] + stage.bounds.max[0]) / 2;
+    desired.set(...pose.position);
-    const centerZ = (stage.bounds.min[2] + stage.bounds.max[2]) / 2;
-    const directionX = centerX - spawn[0];
-    const directionZ = centerZ - spawn[2];
-    const length = Math.max(0.001, Math.hypot(directionX, directionZ));
-    target.set(actor.position[0], actor.position[1] + 1.2, actor.position[2]);
-    desired.set(actor.position[0] - directionX / length * 5, actor.position[1] + 7.5, actor.position[2] - directionZ / length * 5);
     camera.position.lerp(desired, Math.min(1, delta * 5));
     camera.lookAt(target);
   });
   return null;
 }
 
-function ArenaWorld({ stage, actors, dynamicObjects, localActor, character, movement }: { stage: ArenaStageManifest; actors: readonly ArenaActorSnapshot[]; dynamicObjects: readonly ArenaDynamicObjectSnapshot[]; localActor: ArenaActorSnapshot | null; character: ReturnType<typeof selectedCharacter>; movement: RefObject<[number, number]> }) {
+function ArenaWorld({ stage, actors, dynamicObjects, localActor, character, movement, detailedAsset, onStageReady, onStageError }: { stage: ArenaStageManifest; actors: readonly ArenaActorSnapshot[]; dynamicObjects: readonly ArenaDynamicObjectSnapshot[]; localActor: ArenaActorSnapshot | null; character: ReturnType<typeof selectedCharacter>; movement: RefObject<[number, number]>; detailedAsset: boolean; onStageReady: () => void; onStageError: (error: unknown) => void }) {
   return (
-    <Canvas shadows dpr={[1, 1.35]} camera={{ fov: 52, near: 0.1, far: 1200, position: [0, 16, 24] }}>
+    <Canvas
+      shadows
+      dpr={[1, 1.35]}
+      camera={{ fov: 52, near: 0.1, far: 1200, position: [0, 16, 24] }}
+      fallback={<div className="arena-render-fallback"><strong>3D arena unavailable</strong><small>This device could not start WebGL. Return to Arena Command and try another renderer.</small></div>}
+    >
       <color attach="background" args={["#111815"]} />
       <fog attach="fog" args={["#111815", 55, 240]} />
       <hemisphereLight args={["#c9d8cd", "#101713", 1.55]} />
       <directionalLight castShadow position={[24, 42, 18]} intensity={2.2} color="#f1d6a2" />
       <GameGltfLoaderLifecycle>
-        <Suspense fallback={null}><StageEnvironment stage={stage} /></Suspense>
+        {detailedAsset ? (
+          <ArenaStageErrorBoundary key={stage.id} fallback={null} onError={onStageError}>
+            <Suspense fallback={<ProceduralStage stage={stage} />}><StageEnvironment stage={stage} onReady={onStageReady} /></Suspense>
+          </ArenaStageErrorBoundary>
+        ) : <ProceduralStage stage={stage} />}
         <DynamicStageObjects stage={stage} objects={dynamicObjects} />
         {actors.map((actor) => <ArenaActor key={actor.id} actor={actor} local={actor.id === localActor?.id} character={character} movement={movement} stage={stage} />)}
         <ArenaCamera actor={localActor} stage={stage} />
@@ -174,6 +226,25 @@ function ArenaWorld({ stage, actors, dynamicObjects, localActor, character, move
   );
 }
 
+function ArenaAssetStatus({ stage, ready, fallbackReason }: { readonly stage: ArenaStageManifest; readonly ready: boolean; readonly fallbackReason: string | null }) {
+  const { active, progress } = useProgress();
+  if (ready && !active && !fallbackReason) return null;
+  const value = Math.max(3, Math.min(100, Math.round(progress)));
+  return (
+    <section className={`arena-asset-status${fallbackReason ? " arena-asset-status--fallback" : ""}`} role="status" aria-live="polite">
+      <strong>{fallbackReason ? "Arena ready with safe geometry" : `Loading ${stage.name}`}</strong>
+      {fallbackReason ? (
+        <small>The detailed arena asset could not be decoded, so a collision-matched fallback is active.</small>
+      ) : (
+        <>
+          <span><i style={{ width: `${value}%` }} /></span>
+          <small>Streaming arena geometry · {value}%</small>
+        </>
+      )}
+    </section>
+  );
+}
+
 function TeamFrames({ actors, team }: { actors: readonly ArenaActorSnapshot[]; team: 0 | 1 }) {
   return (
     <div className={`arena-team-frames arena-team-frames--${team}`}>
@@ -194,11 +265,36 @@ export default function ArenaRuntime() {
   const intent = useArenaStore((state) => state.intent);
   const leave = useArenaStore((state) => state.leave);
   const load = useArenaStore((state) => state.load);
+  const startPractice = useArenaStore((state) => state.startPractice);
   const session = useShellStore((state) => state.session);
   const character = useShellStore(selectedCharacter);
   const stage = snapshot ? arenaStageById(snapshot.stageId) : null;
   const localActor = snapshot?.actors.find((actor) => actor.id === (snapshot.controlledActorId ?? "practice-player")) ?? null;
   const movementRef = useRef<[number, number]>([0, 0]);
+  const [loadedStageId, setLoadedStageId] = useState<string | null>(null);
+  const [stageFailure, setStageFailure] = useState<{ readonly stageId: string; readonly reason: string } | null>(null);
+  const handleStageReady = useCallback(() => {
+    if (!stage) return;
+    setLoadedStageId(stage.id);
+    setStageFailure((current) => current?.stageId === stage.id ? null : current);
+    startPractice();
+  }, [stage, startPractice]);
+  const handleStageError = useCallback((error: unknown) => {
+    if (!stage) return;
+    setLoadedStageId(stage.id);
+    setStageFailure({ stageId: stage.id, reason: error instanceof Error ? error.message : "Arena asset failed to load" });
+    startPractice();
+  }, [stage, startPractice]);
+
+  useEffect(() => {
+    if (!stage || loadedStageId === stage.id) return;
+    const timeout = window.setTimeout(() => {
+      setLoadedStageId(stage.id);
+      setStageFailure({ stageId: stage.id, reason: "Arena asset loading timed out" });
+      startPractice();
+    }, 30_000);
+    return () => window.clearTimeout(timeout);
+  }, [loadedStageId, stage, startPractice]);
 
   useEffect(() => {
     if (snapshot || !character) return;
@@ -252,9 +348,11 @@ export default function ArenaRuntime() {
 
   if (!snapshot || !stage) return <div className="world-transition"><span>HM</span><strong>Entering arena</strong><small>Waiting for the authoritative match snapshot...</small></div>;
   const seconds = snapshot.phaseEndsAt ? Math.max(0, Math.ceil((snapshot.phaseEndsAt - snapshot.serverTime) / 1000)) : null;
+  const detailedAsset = stageFailure?.stageId !== stage.id;
   return (
     <main className="arena-runtime">
-      <div className="arena-world"><ArenaWorld stage={stage} actors={snapshot.actors} dynamicObjects={snapshot.dynamicObjects} localActor={localActor} character={character} movement={movementRef} /></div>
+      <div className="arena-world" key={`${stage.id}:${detailedAsset ? "detailed" : "fallback"}`}><ArenaWorld stage={stage} actors={snapshot.actors} dynamicObjects={snapshot.dynamicObjects} localActor={localActor} character={character} movement={movementRef} detailedAsset={detailedAsset} onStageReady={handleStageReady} onStageError={handleStageError} /></div>
+      <ArenaAssetStatus stage={stage} ready={loadedStageId === stage.id} fallbackReason={stageFailure?.stageId === stage.id ? stageFailure.reason : null} />
       <header className="arena-match-header">
         <span>{stage.name}</span><strong>{snapshot.bracket} · {snapshot.ruleset.toUpperCase()}</strong><em>Dampening {Math.round(snapshot.dampening * 100)}%</em>
       </header>

src/content/contentManager.ts

@@ -16,6 +16,7 @@ const STATIC_ANDROID_BUNDLED_PACKS = new Set([
   "core:equipment",
   "core:character-basic",
   "core:runtime",
+  "core:arenas",
   "dungeon:wailing-caverns",
 ]);
 const STATIC_BROWSER_BUNDLED_PACKS = new Set([
@@ -23,6 +24,7 @@ const STATIC_BROWSER_BUNDLED_PACKS = new Set([
   "core:equipment",
   "core:character-basic",
   "core:runtime",
+  "core:arenas",
   "dungeon:wailing-caverns",
 ]);
 

src/game/PartyBridge.tsx

@@ -36,6 +36,8 @@ export function PartyBridge() {
       character.categoryId ?? "wow",
     );
     usePartyStore.getState().syncEquipment(combat.equipment, combat.inventory);
+    combat.synchronizeActors();
+    combat.applyDefaultPartyBuffs();
     resetPartyRuntimeClock();
   }, [character?.id, gameMode, manastormPartySize, onlineActivity?.id, playerRole]);
 
@@ -44,6 +46,8 @@ export function PartyBridge() {
     const combat = useCombatStore.getState();
     party.syncLevel(level);
     usePartyStore.getState().syncEquipment(combat.equipment, combat.inventory);
+    combat.synchronizeActors();
+    combat.applyDefaultPartyBuffs();
   }, [level]);
 
   useEffect(() => {
@@ -52,6 +56,8 @@ export function PartyBridge() {
     const combat = useCombatStore.getState();
     usePartyStore.getState().resetCombat(combat.level, combat.health);
     usePartyStore.getState().syncEquipment(combat.equipment, combat.inventory);
+    combat.synchronizeActors();
+    combat.applyDefaultPartyBuffs();
     resetPartyRuntimeClock();
   }, [resetRevision]);
 

src/game/arenaCamera.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { arenaCameraPose } from "./arenaCamera";
+import { ARENA_STAGES } from "./arenaStages";
+
+describe("arena camera placement", () => {
+  it("uses a finite overview anchor aimed at the playable center of every arena", () => {
+    for (const stage of ARENA_STAGES) {
+      for (const team of [0, 1] as const) {
+        const { position, target } = arenaCameraPose(stage, team);
+        expect(position).toEqual(stage.spectatorPositions[team]);
+        expect(position[0], `${stage.id} team ${team} x`).toBeGreaterThan(stage.bounds.min[0]);
+        expect(position[0], `${stage.id} team ${team} x`).toBeLessThan(stage.bounds.max[0]);
+        expect(position[2], `${stage.id} team ${team} z`).toBeGreaterThan(stage.bounds.min[2]);
+        expect(position[2], `${stage.id} team ${team} z`).toBeLessThan(stage.bounds.max[2]);
+        expect(target.every(Number.isFinite)).toBe(true);
+      }
+    }
+  });
+});

src/game/arenaCamera.ts

@@ -0,0 +1,16 @@
+import type { ArenaStageManifest } from "./arenaTypes";
+
+export interface ArenaCameraPose {
+  readonly position: [number, number, number];
+  readonly target: [number, number, number];
+}
+
+export function arenaCameraPose(stage: ArenaStageManifest, team: 0 | 1): ArenaCameraPose {
+  const centerX = (stage.bounds.min[0] + stage.bounds.max[0]) / 2;
+  const centerZ = (stage.bounds.min[2] + stage.bounds.max[2]) / 2;
+  const floorY = Math.min(...stage.teamSpawns.map((spawn) => spawn[1]));
+  return {
+    position: [...stage.spectatorPositions[team]],
+    target: [centerX, floorY + 1.2, centerZ],
+  };
+}

src/game/arenaPractice.ts

@@ -55,9 +55,15 @@ export function createArenaPractice(options: PracticeOptions) {
     onSnapshot: (snapshot) => options.onSnapshot({ ...snapshot, controlledActorId: "practice-player" }),
     onResult: (result) => options.onResult({ ...result, ratingUpdates: [] }),
   });
-  simulation.start();
   options.onSnapshot({ ...simulation.snapshot(), controlledActorId: "practice-player" });
+  let started = false;
   return {
+    start() {
+      if (started) return;
+      started = true;
+      simulation.resetPreparationClock();
+      simulation.start();
+    },
     intent(intent: ArenaCombatIntent) {
       return simulation.receiveIntent("practice-player", intent);
     },

src/game/arenaStore.ts

@@ -41,6 +41,7 @@ interface ArenaStoreState {
   deleteLoadout: (session: PlayerSession, characterId: string, slot: number) => Promise<boolean>;
   queueMatch: (session: PlayerSession | null, character: CharacterProfile) => Promise<boolean>;
   ready: (session: PlayerSession) => Promise<void>;
+  startPractice: () => void;
   leave: (session: PlayerSession | null) => Promise<void>;
   intent: (intent: Omit<ArenaCombatIntent, "sequence">) => void;
   resetResult: () => void;
@@ -221,6 +222,8 @@ export const useArenaStore = create<ArenaStoreState>((set, get) => ({
     catch (error) { set({ error: messageFor(error) }); }
   },
 
+  startPractice: () => get().practice?.start(),
+
   leave: async (session) => {
     get().practice?.stop();
     get().socket?.close();

src/game/combatAuraRuntime.test.ts

@@ -24,6 +24,8 @@ describe("named aura combat runtime", () => {
 
   it("applies and expires an imported named player buff", () => {
     const now = 10_000;
+    const baseHealth = useCombatStore.getState().health;
+    const baseMaxHealth = useCombatStore.getState().maxHealth;
     const result = useCombatStore.getState().castAbility(
       "wow335-priest-power-word-fortitude",
       undefined,
@@ -46,9 +48,49 @@ describe("named aura combat runtime", () => {
         ))?.icon,
       },
     });
+    expect(useCombatStore.getState().maxHealth).toBeGreaterThan(baseMaxHealth);
+    expect(useCombatStore.getState().health - baseHealth).toBe(
+      useCombatStore.getState().maxHealth - baseMaxHealth,
+    );
 
     useCombatStore.getState().tick(0, now + 1_800_000);
     expect(useCombatStore.getState().auras.some((aura) => aura.definition.id === fortitude?.definition.id)).toBe(false);
+    expect(useCombatStore.getState()).toMatchObject({ health: baseHealth, maxHealth: baseMaxHealth });
+  });
+
+  it("grants learned long-term stat buffs to the full party on load", () => {
+    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 8 });
+    usePartyStore.getState().initializeParty("default-party-buffs", 8, useCombatStore.getState().health);
+    useCombatStore.getState().synchronizeActors();
+    const playerMaxHealth = useCombatStore.getState().maxHealth;
+    const memberMaxHealth = new Map(usePartyStore.getState().members.map((member) => [member.id, member.maxHealth]));
+
+    useCombatStore.getState().applyDefaultPartyBuffs(20_000);
+
+    const state = useCombatStore.getState();
+    const targetIds = [PLAYER_AGGRO_ID, ...usePartyStore.getState().members.map((member) => member.id)];
+    for (const targetId of targetIds) {
+      expect(state.auras).toContainEqual(expect.objectContaining({
+        targetId,
+        definition: expect.objectContaining({ exclusiveGroup: "default-party-buff:fortitude" }),
+      }));
+    }
+    expect(state.maxHealth).toBeGreaterThan(playerMaxHealth);
+    for (const member of usePartyStore.getState().members) {
+      expect(member.maxHealth).toBeGreaterThan(memberMaxHealth.get(member.id)!);
+    }
+
+    const buffedPlayerMaxHealth = state.maxHealth;
+    expect(state.auras.filter((aura) => (
+      aura.targetId === PLAYER_AGGRO_ID
+      && aura.definition.exclusiveGroup === "default-party-buff:fortitude"
+    ))).toHaveLength(1);
+    expect(state.castAbility("wow335-priest-power-word-fortitude", undefined, 21_000).ok).toBe(true);
+    expect(useCombatStore.getState().maxHealth).toBe(buffedPlayerMaxHealth);
+    expect(useCombatStore.getState().auras.filter((aura) => (
+      aura.targetId === PLAYER_AGGRO_ID
+      && aura.definition.exclusiveGroup === "default-party-buff:fortitude"
+    ))).toHaveLength(1);
   });
 
   it("consumes a named absorb before player health", () => {

src/game/combatResources.test.ts

@@ -27,6 +27,18 @@ describe("authentic combat resources", () => {
     expect(outsideRule.current).toBe(62);
   });
 
+  it("regenerates at least fifteen percent mana per five seconds out of combat", () => {
+    const mana = normalizeActorResourcePool("mana", 1_000, 3_000, 4, 9_000);
+    const regenerated = advanceCombatResourcePool(mana, {
+      inCombat: false,
+      actorLevel: 8,
+      now: 10_000,
+      deltaSeconds: 1,
+      manaSpiritRegenerationPerSecond: 3,
+    });
+    expect(regenerated.current).toBe(1_090);
+  });
+
   it("decays rage and runic power only out of combat", () => {
     const rage = normalizeActorResourcePool("rage", 20, 100);
     const runic = normalizeActorResourcePool("runic-power", 20, 100);

src/game/combatResources.ts

@@ -6,6 +6,7 @@ import {
 } from "./combatActors";
 
 export const MANA_FIVE_SECOND_RULE_MS = 5_000;
+export const OUT_OF_COMBAT_MANA_REGEN_PER_FIVE_SECONDS = 0.15;
 export const DEATH_KNIGHT_RUNE_RECHARGE_MS = 10_000;
 
 export interface CombatResourceAdvanceRules {
@@ -24,6 +25,9 @@ export function advanceCombatResourcePool(
   if (pool.id === "mana" && rules.now - pool.lastSpentAt < MANA_FIVE_SECOND_RULE_MS) {
     rate = Math.max(0, rate - Math.max(0, rules.manaSpiritRegenerationPerSecond ?? 0));
   }
+  if (pool.id === "mana" && !rules.inCombat) {
+    rate = Math.max(rate, pool.maximum * OUT_OF_COMBAT_MANA_REGEN_PER_FIVE_SECONDS / 5);
+  }
   if ((pool.id === "rage" || pool.id === "runic-power") && !rules.inCombat) {
     rate = pool.id === "rage" ? -3 : -2.5;
   }

src/game/combatStore.test.ts

@@ -13,6 +13,7 @@ import {
   MINIMUM_CORPSE_VISIBLE_MS,
   MOB_WOUND_ANIMATION_COOLDOWN_MS,
   PLAYER_AURA_ENTITY_ID,
+  resolvedAbilityCosts,
   selectedMob,
   useCombatStore,
 } from "./combatStore";
@@ -20,7 +21,7 @@ import { TALENT_NODES, talentNodesForTree } from "./talentCatalog";
 import { EMPTY_ITEM_STATS } from "./itemStats";
 import { abilitiesForClass, defaultActionBarForClass } from "./abilityCatalog";
 import { defaultActionBindings } from "./actionBindings";
-import { deriveCharacterStats } from "./wotlkStats";
+import { deriveCharacterStats, MANA_POOL_MULTIPLIER } from "./wotlkStats";
 import { subscribeCombatPresentation, type CombatPresentationEvent } from "./combatPresentation";
 import { loadCanonicalBenchmarkBuilds } from "./benchmark/benchmarkBuilds";
 
@@ -82,7 +83,7 @@ describe("combat store", () => {
     const first = useCombatStore.getState().castSlot(0, undefined, 1000);
     expect(first).toMatchObject({ ok: true, abilityId: "mage-frostbolt", damage: 0 });
     expect(useCombatStore.getState().mobs.ravager.health).toBe(100);
-    expect(startingResource).toBe(165);
+    expect(startingResource).toBe(165 * MANA_POOL_MULTIPLIER);
     expect(useCombatStore.getState().resource).toBe(startingResource);
     expect(useCombatStore.getState().activeCast).toMatchObject({ completesAt: 2500, mode: "cast" });
 
@@ -92,11 +93,42 @@ describe("combat store", () => {
     expect(useCombatStore.getState().mobs.ravager.health).toBe(100);
     useCombatStore.getState().tick(0.1, 2500);
     expect(useCombatStore.getState().mobs.ravager.health).toBeLessThan(100);
-    expect(useCombatStore.getState().resource).toBe(startingResource - Math.round(startingResource * 0.14));
+    expect(useCombatStore.getState().resource).toBe(
+      startingResource - Math.round(startingResource / MANA_POOL_MULTIPLIER * 0.14),
+    );
     expect(useCombatStore.getState().activeCast).toBeNull();
     expect(useCombatStore.getState().mobs.ravager.engaged).toBe(true);
   });
 
+  it("uses the displayed primary mana and resolved percentage cost for affordability", () => {
+    useCombatStore.getState().initializeCharacter({ classId: "mage", level: 1 });
+    const initial = useCombatStore.getState();
+    const frostbolt = initial.abilities.find((ability) => ability.id === "mage-frostbolt");
+    expect(frostbolt).toBeDefined();
+    const [cost] = resolvedAbilityCosts(frostbolt!, initial.talentModifiers, initial);
+    expect(cost).toEqual({
+      resource: "mana",
+      amount: Math.round(initial.maxResource / MANA_POOL_MULTIPLIER * 0.14),
+    });
+    registerTarget("mana-target", [10, 0, 0]);
+
+    useCombatStore.setState({
+      resource: cost.amount,
+      resourcePools: { ...initial.resourcePools, mana: 0 },
+    });
+    expect(useCombatStore.getState().castAbility(frostbolt!.id, [0, 0, 0], 1_000)).toMatchObject({ ok: true });
+    useCombatStore.getState().cancelCast();
+
+    useCombatStore.setState({
+      resource: cost.amount - 1,
+      resourcePools: { ...initial.resourcePools, mana: initial.maxResource },
+    });
+    expect(useCombatStore.getState().castAbility(frostbolt!.id, [0, 0, 0], 3_000)).toMatchObject({
+      ok: false,
+      reason: "not-enough-resource",
+    });
+  });
+
   it("emits exactly one cast and release event and cancels presentation with the cast", () => {
     useCombatStore.getState().initializeCharacter({ classId: "mage", level: 1 });
     registerTarget("presentation-target", [10, 0, 0]);
@@ -181,8 +213,8 @@ describe("combat store", () => {
     const chronomancerBase = deriveCharacterStats("chronomancer", 1, EMPTY_ITEM_STATS, "human");
     useCombatStore.getState().initializeCharacter({ classId: "chronomancer", level: 1 });
     expect(useCombatStore.getState()).toMatchObject({
-      resource: Math.round(chronomancerBase.mana * 1.12),
+      resource: Math.round(chronomancerBase.mana / MANA_POOL_MULTIPLIER * 1.12) * MANA_POOL_MULTIPLIER,
-      maxResource: Math.round(chronomancerBase.mana * 1.12),
+      maxResource: Math.round(chronomancerBase.mana / MANA_POOL_MULTIPLIER * 1.12) * MANA_POOL_MULTIPLIER,
     });
 
     useCombatStore.getState().initializeCharacter({ classId: "barbarian", level: 10 });
@@ -1038,7 +1070,9 @@ describe("combat store", () => {
     expect(useCombatStore.getState().castSlot(0, undefined, 10_000).ok).toBe(true);
     const boltCompletion = useCombatStore.getState().activeCast!.completesAt;
     useCombatStore.getState().tick(0.1, boltCompletion);
-    expect(useCombatStore.getState().resource).toBe(startingMana - Math.round(startingMana * 0.1 * 0.85));
+    expect(useCombatStore.getState().resource).toBe(
+      startingMana - Math.round(startingMana / MANA_POOL_MULTIPLIER * 0.1 * 0.85),
+    );
   });
 
   it("routes a cast-time direct heal to the selected living party member", () => {

src/game/combatStore.ts

@@ -155,6 +155,8 @@ import {
   deriveCharacterStats,
   equipmentAttackPower,
   hastedDuration,
+  healthFromTotalStamina,
+  MANA_POOL_MULTIPLIER,
   ratingPercent,
   type CharacterStats,
   type WotlkAttackKind,
@@ -673,6 +675,8 @@ export interface CombatState {
   confirmGroundTarget: (position?: CombatPosition, now?: number) => CastResult;
   cancelGroundTarget: () => void;
   synchronizeActors: () => void;
+  /** Grants learned long-term class stat buffs to the full party without setup casts. */
+  applyDefaultPartyBuffs: (now?: number) => void;
   /** Commits companion simulation results to authoritative actors and mirrors party frames. */
   commitCompanionActors: (members: readonly import("./partyStore").PartyMember[]) => void;
   castSlot: (index: number, origin?: CombatPosition, now?: number) => CastResult;
@@ -1504,17 +1508,23 @@ function initialResourcePools(
   return { pools, maximums };
 }
 
-function abilityCosts(
+export function resolvedAbilityCosts(
   ability: AbilityDefinition,
   modifiers: readonly TalentModifier[],
-  state: Pick<CombatState, "maxHealth" | "maxResourcePools"> & Partial<Pick<CombatState, "auras">>,
+  state: Pick<CombatState, "classId" | "maxHealth" | "maxResource" | "maxResourcePools"> & Partial<Pick<CombatState, "auras">>,
 ): readonly { resource: ResourceType; amount: number }[] {
   const aggregated = new Map<ResourceType, number>();
+  const activeResourceType = resourceProfileForClass(state.classId).type;
   for (const cost of ability.costs?.length ? ability.costs : [ability.cost]) {
     const maximum = cost.resource === "health"
       ? state.maxHealth
-      : state.maxResourcePools[cost.resource] ?? defaultResourceMaximum(cost.resource);
+      : cost.resource === activeResourceType
-    const baseAmount = cost.percentage ? maximum * cost.amount / 100 : cost.amount;
+        ? state.maxResource
+        : state.maxResourcePools[cost.resource] ?? defaultResourceMaximum(cost.resource);
+    const percentageMaximum = cost.resource === "mana" && ability.source === "wow335-progression"
+      ? maximum / MANA_POOL_MULTIPLIER
+      : maximum;
+    const baseAmount = cost.percentage ? percentageMaximum * cost.amount / 100 : cost.amount;
     const rawAmount = Math.max(0, Math.round(applyTalentModifierValue(
       baseAmount,
       modifiers,
@@ -1886,11 +1896,16 @@ function auraDefinitionForAbility(
   ability: AbilityDefinition,
   durationMs = definition.durationMs,
 ): AuraDefinition {
+  const defaultPartyBuffFamily = DEFAULT_PARTY_BUFF_FAMILY.get(ability.name.toLowerCase());
   return {
     ...definition,
     description: definition.description ?? ability.description,
     icon: definition.icon ?? ability.icon,
     durationMs,
+    ...(defaultPartyBuffFamily ? {
+      uniqueBySource: false,
+      exclusiveGroup: `default-party-buff:${defaultPartyBuffFamily}`,
+    } : {}),
   };
 }
 
@@ -1913,14 +1928,16 @@ function applyAuraStats(base: CharacterStats, auras: readonly ActiveAura[]): Cha
     "all-resistance",
     "magical-defense",
   );
+  const stamina = primary(base.stamina, "stamina");
+  const staminaHealth = healthFromTotalStamina(stamina) - healthFromTotalStamina(base.stamina);
   return {
     ...base,
     strength: primary(base.strength, "strength"),
     agility: primary(base.agility, "agility", "dexterity"),
-    stamina: primary(base.stamina, "stamina"),
+    stamina,
     intellect: primary(base.intellect, "intellect"),
     spirit: primary(base.spirit, "spirit", "wisdom"),
-    health: stat(base.health, "maximum-health"),
+    health: stat(base.health + staminaHealth, "maximum-health"),
     mana: stat(base.mana, "maximum-mana"),
     attackPower: stat(base.attackPower, "attack-power", "physical-attack"),
     rangedAttackPower: stat(base.rangedAttackPower, "ranged-attack-power", "physical-attack"),
@@ -1948,6 +1965,53 @@ function applyAuraStats(base: CharacterStats, auras: readonly ActiveAura[]): Cha
   };
 }
 
+function auraMaximumHealthBonus(
+  base: CharacterStats,
+  auras: readonly ActiveAura[],
+  targetId: string,
+): number {
+  return Math.round(applyAuraStats(base, aurasForEntity(auras, targetId)).health - base.health);
+}
+
+function auraAdjustedPlayerMaxHealth(
+  classId: ClassId,
+  level: number,
+  modifiers: readonly TalentModifier[],
+  gearStats: ItemStats,
+  raceId: RaceId,
+  secondaryClassId: ClassId | null | undefined,
+  auras: readonly ActiveAura[],
+): number {
+  const baseStats = playerCharacterStats(classId, level, gearStats, raceId, secondaryClassId ?? null, modifiers);
+  return Math.max(
+    1,
+    talentAdjustedMaxHealth(classId, level, modifiers, gearStats, raceId, secondaryClassId)
+      + auraMaximumHealthBonus(baseStats, auras, PLAYER_AURA_ENTITY_ID),
+  );
+}
+
+const DEFAULT_PARTY_BUFF_FAMILY = Object.freeze(new Map<string, string>([
+  ["power word: fortitude", "fortitude"],
+  ["prayer of fortitude", "fortitude"],
+  ["divine spirit", "spirit"],
+  ["prayer of spirit", "spirit"],
+  ["shadow protection", "shadow-protection"],
+  ["prayer of shadow protection", "shadow-protection"],
+  ["arcane intellect", "arcane-intellect"],
+  ["arcane brilliance", "arcane-intellect"],
+  ["mark of the wild", "mark-of-the-wild"],
+  ["gift of the wild", "mark-of-the-wild"],
+]));
+
+function defaultPartyBuffPotency(
+  effects: readonly Extract<AbilityEffect, { kind: "apply-aura" }>[],
+): number {
+  return effects.reduce((total, effect) => total + (effect.aura.modifiers ?? []).reduce(
+    (subtotal, modifier) => subtotal + Math.abs(modifier.value) * (modifier.operation === "percent" ? 1_000 : 1),
+    0,
+  ), 0);
+}
+
 function syncPassiveAuras(
   current: readonly ActiveAura[],
   abilities: readonly AbilityDefinition[],
@@ -2196,13 +2260,15 @@ function grantMobExperience(
   progression.levelsGained += result.levelsGained;
   if (result.levelsGained > 0) {
     work.talentModifiers = characterStatModifiers(classId, result.level, work.talentRanks);
-    progression.maxHealth = talentAdjustedMaxHealth(
+    work.auras = syncPassiveAuras(work.auras, work.abilities, result.level, work.talentRanks, combatNow());
+    progression.maxHealth = auraAdjustedPlayerMaxHealth(
       classId,
       result.level,
       work.talentModifiers,
       work.gearStats,
       work.raceId,
       work.secondaryClassId,
+      work.auras,
     );
     progression.health = progression.maxHealth;
     work.health = progression.health;
@@ -2215,7 +2281,6 @@ function grantMobExperience(
       work.raceId,
       work.secondaryClassId,
     );
-    work.auras = syncPassiveAuras(work.auras, work.abilities, result.level, work.talentRanks, combatNow());
   }
   return scaledAward;
 }
@@ -2719,12 +2784,14 @@ function executeTriggeredSpellInWork(
       const recipient = effect.recipient === "caster"
         ? sourceId
         : targetId ?? sourceId;
-      work.auras = [...applyCombatAura(work.auras, {
+      const previousAuras = work.auras;
+      work.auras = [...applyCombatAura(previousAuras, {
         definition: auraDefinitionForAbility(effect.aura, ability),
         sourceId,
         targetId: recipient,
         now,
       }).auras];
+      applyAuraHealthTransitionInWork(work, recipient, previousAuras, work.auras);
       if (effect.control && work.mobs[recipient]) {
         work.mobs[recipient] = applyStatus(work.mobs[recipient], {
           kind: "status",
@@ -2963,6 +3030,47 @@ function mirrorCompanionActor(actor: CombatActorState): void {
   });
 }
 
+function applyAuraHealthTransitionInWork(
+  work: MutableCastWork,
+  targetId: string,
+  previousAuras: readonly ActiveAura[],
+  nextAuras: readonly ActiveAura[],
+): void {
+  if (targetId === PLAYER_AURA_ENTITY_ID) {
+    const maxHealth = auraAdjustedPlayerMaxHealth(
+      work.classId,
+      work.progression.level,
+      work.talentModifiers,
+      work.gearStats,
+      work.raceId,
+      work.secondaryClassId,
+      nextAuras,
+    );
+    const delta = maxHealth - work.maxHealth;
+    if (!delta) return;
+    work.maxHealth = maxHealth;
+    work.health = work.health <= 0 ? 0 : clamp(work.health + delta, 1, work.maxHealth);
+    work.progression.maxHealth = work.maxHealth;
+    work.progression.health = work.health;
+    const actor = work.actors[targetId];
+    if (actor) work.actors[targetId] = { ...actor, health: work.health, maxHealth: work.maxHealth };
+    return;
+  }
+
+  const member = usePartyStore.getState().members.find((candidate) => candidate.id === targetId);
+  const actor = ensureCompanionActorInWork(work, targetId);
+  if (!member || !actor) return;
+  const base = deriveCharacterStats(member.classId, member.level, member.gearStats, member.raceId);
+  const delta = auraMaximumHealthBonus(base, nextAuras, targetId)
+    - auraMaximumHealthBonus(base, previousAuras, targetId);
+  if (!delta) return;
+  const maxHealth = Math.max(1, actor.maxHealth + delta);
+  const health = actor.health <= 0 ? 0 : clamp(actor.health + delta, 1, maxHealth);
+  const nextActor = Object.freeze({ ...actor, health, maxHealth });
+  work.actors[targetId] = nextActor;
+  mirrorCompanionActor(nextActor);
+}
+
 function healCompanionActorInWork(work: MutableCastWork, id: string, amount: number): number {
   const actor = ensureCompanionActorInWork(work, id);
   const requested = Math.max(0, Math.round(Number.isFinite(amount) ? amount : 0));
@@ -3265,13 +3373,14 @@ export const useCombatStore = create<CombatState>((set, get) => ({
     const gearStats = state.specializationId !== null || state.classId.startsWith("rom-")
       ? resolvedEquipmentStats(state.equipment, state.inventory, context)
       : activeEquipmentStatsForClass(state.equipment, state.inventory, PLAYER_EQUIPMENT_OWNER_ID, state.classId);
-    const maxHealth = talentAdjustedMaxHealth(
+    const maxHealth = auraAdjustedPlayerMaxHealth(
       state.classId,
       state.level,
       state.talentModifiers,
       gearStats,
       state.raceId,
       state.secondaryClassId,
+      state.auras,
     );
     const maxResource = talentAdjustedMaxResource(
       state.classId,
@@ -3539,13 +3648,14 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       role: state.gearRole,
       level: state.level,
     }) : activeEquipmentStatsForClass(change.assignments, state.inventory, PLAYER_EQUIPMENT_OWNER_ID, state.classId);
-    const maxHealth = talentAdjustedMaxHealth(
+    const maxHealth = auraAdjustedPlayerMaxHealth(
       state.classId,
       state.level,
       state.talentModifiers,
       gearStats,
       state.raceId,
       state.secondaryClassId,
+      state.auras,
     );
     const maxResource = talentAdjustedMaxResource(
       state.classId,
@@ -3588,13 +3698,14 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       role: state.gearRole,
       level: state.level,
     }) : activeEquipmentStatsForClass(next, state.inventory, PLAYER_EQUIPMENT_OWNER_ID, state.classId);
-    const maxHealth = talentAdjustedMaxHealth(
+    const maxHealth = auraAdjustedPlayerMaxHealth(
       state.classId,
       state.level,
       state.talentModifiers,
       gearStats,
       state.raceId,
       state.secondaryClassId,
+      state.auras,
     );
     const maxResource = talentAdjustedMaxResource(
       state.classId,
@@ -3811,6 +3922,59 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       members: party.members.map((member) => memberFromCompanionActor(member, actors[member.id])),
     }));
   },
+  applyDefaultPartyBuffs: (now = combatNow()) => {
+    get().synchronizeActors();
+    const state = get();
+    const partyMembers = usePartyStore.getState().members;
+    const sources = [
+      {
+        id: PLAYER_AURA_ENTITY_ID,
+        level: state.level,
+        abilities: state.abilities,
+      },
+      ...partyMembers.filter((member) => member.health > 0).map((member) => ({
+        id: member.id,
+        level: member.level,
+        abilities: abilitiesForClass(member.classId),
+      })),
+    ];
+    const selected = new Map<string, {
+      sourceId: string;
+      ability: AbilityDefinition;
+      effects: readonly Extract<AbilityEffect, { kind: "apply-aura" }>[];
+      potency: number;
+    }>();
+    for (const source of sources) {
+      for (const catalogAbility of source.abilities) {
+        const family = DEFAULT_PARTY_BUFF_FAMILY.get(catalogAbility.name.toLowerCase());
+        if (!family || catalogAbility.passive || !isAbilityUnlocked(catalogAbility, source.level)) continue;
+        const ability = abilityAtLevel(catalogAbility, source.level);
+        const effects = ability.effects.filter((effect): effect is Extract<AbilityEffect, { kind: "apply-aura" }> => (
+          effect.kind === "apply-aura" && effect.aura.disposition === "buff"
+        ));
+        if (!effects.length) continue;
+        const potency = defaultPartyBuffPotency(effects);
+        if ((selected.get(family)?.potency ?? Number.NEGATIVE_INFINITY) >= potency) continue;
+        selected.set(family, { sourceId: source.id, ability, effects, potency });
+      }
+    }
+    const recipients = [PLAYER_AURA_ENTITY_ID, ...partyMembers.filter((member) => member.health > 0).map((member) => member.id)];
+    for (const [family, buff] of selected) {
+      for (const recipientId of recipients) {
+        for (const effect of buff.effects) {
+          get().applyActorAura(buff.sourceId, recipientId, buff.ability, {
+            ...effect,
+            aura: {
+              ...effect.aura,
+              uniqueBySource: false,
+              exclusiveGroup: `default-party-buff:${family}`,
+            },
+          }, now);
+        }
+      }
+    }
+    get().synchronizeActors();
+  },
   commitCompanionActors: (members) => {
     let actors: Readonly<Record<string, CombatActorState>> = {};
     set((state) => {
@@ -3866,7 +4030,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
         : ability?.target;
     const modifiers = state.talentModifiers;
     const resourceCost = ability ? talentAdjustedResourceCost(ability, modifiers) : 0;
-    const costs = ability ? abilityCosts(ability, modifiers, state) : [];
+    const costs = ability ? resolvedAbilityCosts(ability, modifiers, state) : [];
     const costsToSpend = completingCast?.mode === "channel" ? [] : costs;
     const targeting = ability ? targetingRulesForAbility(ability) : null;
     const spellSchool = ability ? ability.castRules?.school ?? abilityDamageSchool(state.classId, ability) : "physical";
@@ -3895,7 +4059,9 @@ export const useCombatStore = create<CombatState>((set, get) => ({
     else if (ability.id === "rom-mage-primary-56" && !hasRuneWakerState("rom-static-field-charge")) failure = "condition-not-met";
     else if (costs.some((cost) => cost.resource === "health"
       ? state.health <= cost.amount
-      : (state.resourcePools[cost.resource] ?? (cost.resource === resourceProfileForClass(state.classId).type ? state.resource : 0)) < cost.amount)) failure = "not-enough-resource";
+      : (cost.resource === resourceProfileForClass(state.classId).type
+          ? state.resource
+          : state.resourcePools[cost.resource] ?? 0) < cost.amount)) failure = "not-enough-resource";
     else if (runeCost && !spendDeathKnightRunes(state.deathKnightRunes, runeCost, now)) failure = "not-enough-runes";
 
     const playerOrigin = currentOrigin(state, origin);
@@ -4060,7 +4226,11 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       state.classId,
     );
     const cooldownMs = talentAdjustedCooldown(ability, modifiers);
-    const spentPools = { ...state.resourcePools };
+    const activeResourceType = resourceProfileForClass(state.classId).type;
+    const spentPools: Partial<Record<ResourceType, number>> = {
+      ...state.resourcePools,
+      [activeResourceType]: state.resource,
+    };
     const lastResourceSpentAt = { ...state.lastResourceSpentAt };
     let healthAfterCosts = state.health;
     for (const cost of costsToSpend) {
@@ -4073,7 +4243,6 @@ export const useCombatStore = create<CombatState>((set, get) => ({
     const spentRunes = runeCost && completingCast?.mode !== "channel"
       ? spendDeathKnightRunes(state.deathKnightRunes, runeCost, now)
       : state.deathKnightRunes;
-    const activeResourceType = resourceProfileForClass(state.classId).type;
     const activeResourceAfterCosts = spentPools[activeResourceType] ?? state.resource - resourceCost;
     if (!completingCast && castTimeMs > 0) {
       castSequence += 1;
@@ -4752,12 +4921,14 @@ export const useCombatStore = create<CombatState>((set, get) => ({
             ? affectedMobIds
             : [targetId ?? PLAYER_AURA_ENTITY_ID];
         for (const recipientId of recipients) {
-          work.auras = [...applyCombatAura(work.auras, {
+          const previousAuras = work.auras;
+          work.auras = [...applyCombatAura(previousAuras, {
             definition: auraDefinition,
             sourceId: PLAYER_AURA_ENTITY_ID,
             targetId: recipientId,
             now,
           }).auras];
+          applyAuraHealthTransitionInWork(work, recipientId, previousAuras, work.auras);
           if (auraDefinition.controlImmunities?.length) {
             if (
               recipientId === PLAYER_AURA_ENTITY_ID
@@ -5725,8 +5896,49 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       targetId: targetActorId,
       now,
     });
+    let health = state.health;
+    let maxHealth = state.maxHealth;
+    const actors = { ...state.actors };
+    let companionActor: CombatActorState | null = null;
+    if (targetActorId === PLAYER_AURA_ENTITY_ID) {
+      const nextMaxHealth = auraAdjustedPlayerMaxHealth(
+        state.classId,
+        state.level,
+        state.talentModifiers,
+        state.gearStats,
+        state.raceId,
+        state.secondaryClassId,
+        result.auras,
+      );
+      const delta = nextMaxHealth - maxHealth;
+      maxHealth = nextMaxHealth;
+      health = health <= 0 ? 0 : clamp(health + delta, 1, maxHealth);
+      const actor = actors[targetActorId];
+      if (actor) actors[targetActorId] = { ...actor, health, maxHealth };
+    } else {
+      const member = usePartyStore.getState().members.find((candidate) => candidate.id === targetActorId);
+      const actor = member ? companionActorFromMember(
+        member,
+        entityAbsorbAmount(state.auras, targetActorId),
+        state.actors[targetActorId],
+      ) : null;
+      if (member && actor) {
+        const base = deriveCharacterStats(member.classId, member.level, member.gearStats, member.raceId);
+        const delta = auraMaximumHealthBonus(base, result.auras, targetActorId)
+          - auraMaximumHealthBonus(base, state.auras, targetActorId);
+        if (delta) {
+          const actorMaxHealth = Math.max(1, actor.maxHealth + delta);
+          const actorHealth = actor.health <= 0 ? 0 : clamp(actor.health + delta, 1, actorMaxHealth);
+          companionActor = Object.freeze({ ...actor, health: actorHealth, maxHealth: actorMaxHealth });
+          actors[targetActorId] = companionActor;
+        }
+      }
+    }
     set({
       auras: result.auras,
+      health,
+      maxHealth,
+      actors,
       combatEvents: recordCombatEvent(state.combatEvents, {
         occurredAt: now,
         kind: "aura",
@@ -5741,6 +5953,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
         critical: false,
       }),
     });
+    if (companionActor) mirrorCompanionActor(companionActor);
     return true;
   },
 
@@ -7020,6 +7233,8 @@ export const useCombatStore = create<CombatState>((set, get) => ({
     const delta = clamp(Number.isFinite(deltaSeconds) ? deltaSeconds : 0, 0, 1);
     const resourceProfile = resourceProfileForClass(state.classId);
     const inCombat = Object.values(state.mobs).some((mob) => mob.engaged && !mob.dead);
+    const auraExpiration = expireAuras(state.auras, now);
+    const activeAuras = [...auraExpiration.active];
     const baseRegeneration = applyTalentModifierValue(
       (resourceProfile.type === "rage" || resourceProfile.type === "runic-power")
         ? 0
@@ -7029,7 +7244,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       state.talentModifiers,
       "resource-regeneration-percent",
     );
-    const playerAuras = aurasForEntity(state.auras, PLAYER_AURA_ENTITY_ID);
+    const playerAuras = aurasForEntity(activeAuras, PLAYER_AURA_ENTITY_ID);
     const regeneration = resolveAuraResourceValue(
       resolveAuraResourceValue(baseRegeneration, playerAuras, resourceProfile.type, "regeneration"),
       playerAuras,
@@ -7089,7 +7304,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       abilities: state.abilities,
       mobs: { ...state.mobs },
       effects: [],
-      auras: [...expireAuras(state.auras, now).active],
+      auras: activeAuras,
       summons: state.summons.filter((summon) => summon.expiresAt > now),
       areaEffects: state.areaEffects.filter((effect) => effect.expiresAt > now),
       combatEvents: [...state.combatEvents],
@@ -7124,6 +7339,9 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       raceId: state.raceId,
       secondaryClassId: state.secondaryClassId,
     };
+    for (const targetId of new Set(auraExpiration.expired.map((aura) => aura.targetId))) {
+      applyAuraHealthTransitionInWork(work, targetId, state.auras, activeAuras);
+    }
 
     let autoAttackTargetId = state.autoAttackTargetId;
     let nextAutoAttackAt = state.nextAutoAttackAt;
@@ -7839,9 +8057,20 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       activeCast: null,
       schoolLockedUntil: {},
       nextWoundAnimationAt: 0,
-      }]));
+    }]));
+    const auras = syncPassiveAuras([], state.abilities, state.level, state.talentRanks, combatNow());
+    const maxHealth = auraAdjustedPlayerMaxHealth(
+      state.classId,
+      state.level,
+      state.talentModifiers,
+      state.gearStats,
+      state.raceId,
+      state.secondaryClassId,
+      auras,
+    );
     return {
-      health: state.maxHealth,
+      health: maxHealth,
+      maxHealth,
       controlledUntil: 0,
       controlMechanic: null,
       shield: 0,
@@ -7868,7 +8097,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       selectedTargetId: null,
       selectedFriendlyActorId: null,
       effects: [],
-      auras: syncPassiveAuras([], state.abilities, state.level, state.talentRanks, combatNow()),
+      auras,
       summons: [],
       areaEffects: [],
       pendingGroundTarget: null,
@@ -7904,13 +8133,15 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       return false;
     }
     const talentModifiers = characterStatModifiers(state.classId, state.level, result.ranks);
-    const maxHealth = talentAdjustedMaxHealth(
+    const auras = syncPassiveAuras(state.auras, state.abilities, state.level, result.ranks, combatNow());
+    const maxHealth = auraAdjustedPlayerMaxHealth(
       state.classId,
       state.level,
       talentModifiers,
       state.gearStats,
       state.raceId,
       state.secondaryClassId,
+      auras,
     );
     const maxResource = talentAdjustedMaxResource(
       state.classId,
@@ -7927,7 +8158,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       health: clamp(state.maxHealth > 0 ? state.health / state.maxHealth * maxHealth : maxHealth, 0, maxHealth),
       maxResource,
       resource: clamp(state.maxResource > 0 ? state.resource / state.maxResource * maxResource : 0, 0, maxResource),
-      auras: syncPassiveAuras(state.auras, state.abilities, state.level, result.ranks, combatNow()),
+      auras,
       feedback: nextFeedback("talent", "Conquest node rank allocated."),
     });
     return true;
@@ -7936,13 +8167,15 @@ export const useCombatStore = create<CombatState>((set, get) => ({
   resetTalents: () => set((state) => {
     const talentRanks = resetTalentRanks(state.talentRanks, state.classId);
     const talentModifiers = characterStatModifiers(state.classId, state.level, talentRanks);
-    const maxHealth = talentAdjustedMaxHealth(
+    const auras = syncPassiveAuras(state.auras, state.abilities, state.level, talentRanks, combatNow());
+    const maxHealth = auraAdjustedPlayerMaxHealth(
       state.classId,
       state.level,
       talentModifiers,
       state.gearStats,
       state.raceId,
       state.secondaryClassId,
+      auras,
     );
     const maxResource = talentAdjustedMaxResource(
       state.classId,
@@ -7959,7 +8192,7 @@ export const useCombatStore = create<CombatState>((set, get) => ({
       health: clamp(state.maxHealth > 0 ? state.health / state.maxHealth * maxHealth : maxHealth, 0, maxHealth),
       maxResource,
       resource: clamp(state.maxResource > 0 ? state.resource / state.maxResource * maxResource : 0, 0, maxResource),
-      auras: syncPassiveAuras(state.auras, state.abilities, state.level, talentRanks, combatNow()),
+      auras,
       feedback: nextFeedback("talent", "Talent points reset."),
     };
   }),

src/game/deathRespawn.test.ts

@@ -5,6 +5,7 @@ import { useCombatStore } from "./combatStore";
 import { respawnDefeatedPlayer } from "./deathRespawn";
 import { useGameStore } from "./store";
 import { useWailingEncounterStore } from "./wailingCavernsEncounter";
+import { MANA_POOL_MULTIPLIER } from "./wotlkStats";
 
 describe("death respawn", () => {
   beforeEach(() => {
@@ -24,7 +25,9 @@ describe("death respawn", () => {
     useCombatStore.getState().selectMob("respawn-pack:a");
     useCombatStore.getState().damageMob("respawn-pack:a", 1, 1000);
     expect(useCombatStore.getState().castAbility("priest-psychic-scream", [10, -50, 20], 2000).ok).toBe(true);
-    expect(useCombatStore.getState().resource).toBe(startingResource - Math.round(startingResource * 0.15));
+    expect(useCombatStore.getState().resource).toBe(
+      startingResource - Math.round(startingResource / MANA_POOL_MULTIPLIER * 0.15),
+    );
 
     const revisionBefore = useGameStore.getState().resetRevision;
     useWailingEncounterStore.setState({ phase: "mutanus", phaseStartedAt: 5_000 });

src/game/romPlayerCatalog.test.ts

@@ -9,7 +9,7 @@ import {
 import { ROM_ALL_ABILITIES, ROM_ELITE_ABILITIES } from "./romAbilityCatalog";
 import { romDualClassBaseStats, romNativeClassBaseStats } from "./romStats";
 import { EMPTY_ITEM_STATS } from "./itemStats";
-import { deriveCharacterStats } from "./wotlkStats";
+import { deriveCharacterStats, MANA_POOL_MULTIPLIER } from "./wotlkStats";
 
 const RACE_MATRIX = {
   "rom-human": ["rom-warrior", "rom-scout", "rom-rogue", "rom-mage", "rom-priest", "rom-knight"],
@@ -118,8 +118,12 @@ describe("generated RuneWaker player catalog", () => {
   });
 
   it("gives level-one healers native mana pools and imports their real spell costs", () => {
-    expect(deriveCharacterStats("rom-priest", 1, EMPTY_ITEM_STATS, "rom-human").mana).toBe(103);
+    expect(deriveCharacterStats("rom-priest", 1, EMPTY_ITEM_STATS, "rom-human").mana).toBe(
-    expect(deriveCharacterStats("rom-druid", 1, EMPTY_ITEM_STATS, "rom-elf").mana).toBe(86);
+      103 * MANA_POOL_MULTIPLIER,
+    );
+    expect(deriveCharacterStats("rom-druid", 1, EMPTY_ITEM_STATS, "rom-elf").mana).toBe(
+      86 * MANA_POOL_MULTIPLIER,
+    );
     expect(generated.skills.find((ability) => ability.id === "rom-priest-general-1")?.costs).toEqual([
       { resource: "mana", amount: 12, percentage: false },
     ]);

src/game/wotlkStats.test.ts

@@ -7,6 +7,7 @@ import {
   deriveCharacterStats,
   hastedDuration,
   healthFromTotalStamina,
+  MANA_POOL_MULTIPLIER,
   ratingMultiplier,
   ratingPerPercent,
 } from "./wotlkStats";
@@ -50,7 +51,7 @@ describe("WoW 3.3.5a character stats", () => {
       spellPower: 7,
       mp5: 4,
     });
-    expect(mageGeared.mana - mageBase.mana).toBe(150);
+    expect(mageGeared.mana - mageBase.mana).toBe(150 * MANA_POOL_MULTIPLIER);
     expect(mageGeared.spellPower).toBe(7);
     expect(mageGeared.spellCritPercent).toBeGreaterThan(mageBase.spellCritPercent);
     expect(mageGeared.manaPer5).toBeGreaterThan(mageBase.manaPer5 + 4);

src/game/wotlkStats.ts

@@ -105,6 +105,8 @@ interface CombatRatingsData {
 
 const BASE_STATS = baseStatsData as BaseStatsData;
 const COMBAT_RATINGS = combatRatingsData as CombatRatingsData;
+/** Healer Man's larger combat pool; imported Wrath costs keep their pre-boost baseline. */
+export const MANA_POOL_MULTIPLIER = 3;
 const CLASS_DBC = Object.fromEntries(
   CLASSES.map((entry) => [entry.id, classById(baseClassFor(entry.id)).dbcId]),
 ) as Record<ClassId, number>;
@@ -279,7 +281,7 @@ export function deriveCharacterStats(
     modifiers.maxHealth,
   );
   const mana = classUsesMana(classId)
-    ? percentAdjusted(
+    ? MANA_POOL_MULTIPLIER * percentAdjusted(
       resources.mana
         + (romBase ? intellect + spirit * 5 : manaFromTotalIntellect(intellect))
         + gear.mana,

src/scene/useGameGLTF.ts

@@ -1,6 +1,6 @@
 import { useGLTF } from "@react-three/drei";
 import { useThree } from "@react-three/fiber";
-import { useCallback, useEffect, type ReactNode } from "react";
+import { useCallback, type ReactNode } from "react";
 import type { WebGLRenderer } from "three";
 import { KTX2Loader, type GLTFLoader } from "three-stdlib";
 import { resolveContentUrl } from "../content/contentManager";
@@ -20,15 +20,12 @@ function ktx2LoaderFor(renderer: WebGLRenderer): KTX2Loader {
   return loader;
 }
 
-/** Owns the decoder worker pool for one Canvas and releases it on renderer teardown. */
+/**
+ * Marks the part of a Canvas that shares its GLTF decoder. KTX2Loader instances
+ * intentionally live with their weakly referenced renderer: disposing one from
+ * React cleanup can abort a GLB that is still decoding or cached by useGLTF.
+ */
 export function GameGltfLoaderLifecycle({ children }: { readonly children: ReactNode }) {
-  const renderer = useThree((state) => state.gl);
-  useEffect(() => () => {
-    const loader = ktx2Loaders.get(renderer);
-    if (!loader) return;
-    loader.dispose();
-    ktx2Loaders.delete(renderer);
-  }, [renderer]);
   return children;
 }
 

src/styles.css

@@ -3327,6 +3327,51 @@ button.equipment-slot:hover { background: rgba(174,191,131,.1); }
 .arena-world,
 .arena-world > div { position: absolute; inset: 0; }
 
+.arena-render-fallback {
+  display: grid;
+  place-content: center;
+  gap: .4rem;
+  padding: 2rem;
+  color: #e8eee4;
+  text-align: center;
+  background: radial-gradient(circle at center, #17251f, #07100d 68%);
+}
+
+.arena-render-fallback small { max-width: 32rem; color: #b9c4b6; }
+
+.arena-asset-status {
+  position: absolute;
+  z-index: 3;
+  top: 50%;
+  left: 50%;
+  display: grid;
+  width: min(24rem, calc(100vw - 2rem));
+  gap: .45rem;
+  padding: .85rem 1rem;
+  border: 1px solid rgba(220, 190, 99, .5);
+  text-align: center;
+  background: rgba(6, 13, 10, .92);
+  transform: translate(-50%, -50%);
+  box-shadow: 0 1rem 4rem rgba(0, 0, 0, .45);
+  pointer-events: none;
+}
+
+.arena-asset-status > span {
+  overflow: hidden;
+  height: .32rem;
+  background: rgba(216, 185, 98, .16);
+}
+
+.arena-asset-status > span i {
+  display: block;
+  height: 100%;
+  background: #d8b962;
+  transition: width .15s ease-out;
+}
+
+.arena-asset-status small { color: #b9c4b6; }
+.arena-asset-status--fallback { top: auto; bottom: 5.3rem; transform: translateX(-50%); }
+
 .arena-match-header {
   position: absolute;
   top: .7rem;

src/ui/Hud.tsx

@@ -4,7 +4,7 @@ import { classById, raceById } from "../app/characterCatalog";
 import { useShellStore } from "../app/shellStore";
 import { abilityAtLevel, resourceProfileForClass } from "../game/abilityCatalog";
 import { ACTION_CONTROLS, actionBindingId } from "../game/actionBindings";
-import { useCombatStore } from "../game/combatStore";
+import { resolvedAbilityCosts, useCombatStore } from "../game/combatStore";
 import { respawnDefeatedPlayer } from "../game/deathRespawn";
 import { requireDungeonDefinition } from "../game/dungeonRegistry";
 import { resurrectManastormSession } from "../game/manastormSession";
@@ -137,9 +137,12 @@ export function Hud() {
   const resource = useCombatStore((state) => state.resource);
   const maxResource = useCombatStore((state) => state.maxResource);
   const resourcePools = useCombatStore((state) => state.resourcePools);
+  const maxResourcePools = useCombatStore((state) => state.maxResourcePools);
   const resourceName = useCombatStore((state) => state.resourceName);
   const abilities = useCombatStore((state) => state.abilities);
   const talentRanks = useCombatStore((state) => state.talentRanks);
+  const talentModifiers = useCombatStore((state) => state.talentModifiers);
+  const auras = useCombatStore((state) => state.auras);
   const actionBindings = useCombatStore((state) => state.actionBindings);
   const cooldowns = useCombatStore((state) => state.cooldowns);
   const globalCooldownEndsAt = useCombatStore((state) => state.globalCooldownEndsAt);
@@ -190,11 +193,17 @@ export function Hud() {
     const personalRemaining = Math.max(0, (cooldowns[ability.id] ?? 0) - clock);
     const globalRemaining = Math.max(0, globalCooldownEndsAt - clock);
     const remaining = Math.max(personalRemaining, globalRemaining);
-    const abilityCosts = ability.costs?.length ? ability.costs : [ability.cost];
+    const abilityCosts = resolvedAbilityCosts(ability, talentModifiers, {
+      classId,
+      maxHealth,
+      maxResource,
+      maxResourcePools,
+      auras,
+    });
     const cannotPay = abilityCosts.some((cost) => cost.resource === "health"
       ? health <= cost.amount
-      : (resourcePools[cost.resource] ?? (cost.resource === resourceTone ? resource : 0)) < cost.amount);
+      : (cost.resource === resourceTone ? resource : resourcePools[cost.resource] ?? 0) < cost.amount);
-    const displayCost = abilityCosts[0] ?? ability.cost;
+    const displayCost = abilityCosts[0] ?? { resource: ability.cost.resource, amount: 0 };
     const item: ActionBarItem = {
       id: ability.id,
       name: ability.name,
@@ -211,7 +220,7 @@ export function Hud() {
       target: ability.target,
     };
     return [control, item];
-  })) as ActionBarItems, [abilities, actionBindings, actionLayer, activeCast, classColor, clock, cooldowns, globalCooldownEndsAt, health, level, resource, resourceName, resourcePools, resourceTone, talentRanks]);
+  })) as ActionBarItems, [abilities, actionBindings, actionLayer, activeCast, auras, classColor, classId, clock, cooldowns, globalCooldownEndsAt, health, level, maxHealth, maxResource, maxResourcePools, resource, resourceName, resourcePools, resourceTone, talentModifiers, talentRanks]);
 
   const castBinding = (control: (typeof ACTION_CONTROLS)[number]) => useCombatStore.getState().castActionBinding(
     useGameStore.getState().actionLayer,