The user wants a single-page web app (index.html) that uses Phaser (phser.min.js already in the current directory). Need to build a top-down alien shooter with:
- WASD movement
- Aim and fire at waves of advancing aliens
- Health, score, increasing difficulty
- Only procedurally generated graphics (no external image/audio assets)
- No external resources, CDNs, network requests
- All in one self-contained index.html (CSS in style tag, JS in script tag, inline)
- Load phaser.min.js with <script src="phaser.min.js"></script>

Need to check current directory for phaser.min.js.

Plan:
1. Verify phaser.min.js exists.
2. Create index.html with inline CSS/JS and Phaser game.

Game design:
- Scene: main game scene
- Player: top-down view, WASD movement, rotates to face mouse, shoots bullets toward mouse
- Enemies: alien sprites generated via graphics (Phaser.GameObjects.Graphics), move downward/advance toward player
- Waves: spawn waves of aliens with increasing count/speed
- Health: player has health bar, enemies damage on contact or maybe they shoot? Simpler: enemies move toward player and deal contact damage.
- Score: points per alien kill
- Increasing difficulty: each wave has more enemies, faster, maybe different types
- Procedural graphics: use Phaser.GameObjects.Graphics to draw player (e.g., a tank shape), aliens (e.g., weird shapes), bullets (small rectangles), particles for explosions
- No external assets: use generated textures from graphics (generateTexture) or just Graphics objects. However, for performance with many objects, better to generate textures via canvas or Graphics and then use Sprites.

Let's design a Phaser 3 game (phaser.min.js likely Phaser 3). I'll assume Phaser 3.

Game structure:
- Boot/Preload scene: generate textures using Graphics.generateTexture or via canvas.
  - playerTex: a tank-like shape with turret
  - alienTex: a small alien creature
  - bulletTex: small yellow rectangle
  - particleTex: small circle for explosions
- MainScene:
  - Player: sprite with velocity-based movement (WASD), rotation toward mouse pointer, shoot on click or space? User said "aim and fire", so maybe mouse click to fire, or space to fire in aim direction. Let's use mouse click or hold to fire, or space. Aim with mouse, fire with space or left click. Let's use left mouse button to fire.
  - Bullets: group, physics enabled, destroy on overlap or out of bounds
  - Enemies: group, move toward player or move downward? User says "advancing aliens". Could be top-down shooter where enemies come from top/sides and move toward player. Let's have them spawn at edges and move toward player.
  - Waves: wave manager, spawn enemies in batches, with a short delay between waves. Next wave increases count and speed.
  - Collisions: bullet vs enemy -> both destroyed, score+, spawn explosion particles. Player vs enemy -> enemy destroyed, player health--, screen shake, invulnerability briefly.
  - UI: health bar (image or graphics), score text, wave text. Health bar using a filled rectangle graphics.

Implementation details:
- Use Arcade Physics.
- Player movement: set velocity based on WASD input. Could use cursors or keyboard keys directly. Use keyboard keys (W, A, S, D).
- Aim: player rotation = angle to pointer (this.input.activePointer).
- Shoot: on pointerdown or space key. Let's use pointerdown for mouse aiming+fire, and space for fire.
- Enemy behavior: spawn at random position outside camera, move toward player with constant velocity. For waves: spawn multiple enemies, track wave number. Increase enemy count by e.g., 3 per wave, speed slightly increases.
- Procedural textures:
  - In create of MainScene, use `this.make.graphics({x:0,y:0,add:false})` to draw shapes, then `generateTexture('key', width, height)`.
  - Player: a circle body with a rectangle turret pointing up, rotated by player.angle.
  - Alien: maybe a green blob or bug shape.
  - Bullet: yellow rect.
  - Particle: white circle.

Let's write the full code.

Need to be careful with Phaser 3 syntax. Use ES5 or ES6 inside script? Since it's a single HTML file, modern JS is fine. But for safety, I'll use standard ES6.

Steps in code:
- HTML boilerplate, meta, style for body margin 0, overflow hidden, canvas block.
- Script src="phaser.min.js"
- Inline script:
  - Define game config: type Phaser.AUTO, width window.innerWidth, height window.innerHeight, parent none, transparent? maybe black background. Physics: arcade. Scene: [MainScene].
  - MainScene class:
    - init(data): nothing
    - preload(): nothing (no external assets)
    - create():
      - Generate textures:
        - `generatePlayerTexture()`: draw player body (circle) and turret (rect) pointing up. Size maybe 40x40. Save as 'player'.
        - `generateAlienTexture()`: draw alien shape (maybe a bug with eyes). Size 30x30. Save as 'alien'.
        - `generateBulletTexture()`: draw 4x8 yellow rect. Save as 'bullet'.
        - `generateParticleTexture()`: draw 4x4 white circle. Save as 'particle'.
      - Setup physics groups:
        - `this.bullets = this.physics.add.group({defaultKey: 'bullet', maxSize: 100, runChildUpdate: false})` or manually manage.
        - `this.enemies = this.physics.add.group()`
        - `this.explosions = this.add.group()` for particles? Actually particles can be a group of images or use particle emitter. Let's use a simple group of sprites for explosion effects.
      - Create player:
        - `this.player = this.physics.add.sprite(centerX, centerY, 'player')`
        - Set collider world bounds
        - Set drag for smooth movement
        - `this.playerHealth = 100`
        - `this.maxHealth = 100`
        - `this.isInvulnerable = false`
      - Create health bar:
        - Background bar (dark gray), foreground bar (red), maybe as graphics or images. Use graphics for simplicity: draw rectangles, but for updating we can redraw or scale a sprite. Use a sprite for health fill: `this.healthFill = this.add.rectangle(barX, barY, barWidth, barHeight, 0xff0000).setOrigin(0, 0.5)`; actually we can just use a graphics object and redraw on damage. Simpler: use a rectangle image generated as texture, then scaleX. Let's generate 'healthBar' and 'healthBg' textures.
      - Create score text: `this.scoreText = this.add.text(20, 20, 'Score: 0', {fontSize: '24px', fill: '#fff'})`
      - Create wave text: `this.waveText = this.add.text(centerX, 20, 'Wave 1', {fontSize: '20px', fill: '#ff0'}).setOrigin(0.5)`
      - Input:
        - `this.cursors = this.input.keyboard.addKeys({w: 'W', a: 'A', s: 'S', d: 'D', space: 'SPACE'})` (Phaser 3.60+). Or use `this.input.keyboard.addKey('W')` etc. Let's use `this.keys = this.input.keyboard.addKeys('W,A,S,D,SPACE')`.
        - `this.input.on('pointerdown', this.fireBullet, this)`
      - Wave state:
        - `this.wave = 1`
        - `this.enemiesRemaining = 0`
        - `this.isSpawning = false`
        - `this.waveDelay = 3000`
      - Collisions:
        - `this.physics.add.overlap(this.bullets, this.enemies, this.hitEnemy, null, this)`
        - `this.physics.add.overlap(this.player, this.enemies, this.playerHit, null, this)`
    - update(time, delta):
      - Player movement: check keys, set velocity. e.g., `this.player.setVelocity(0)` then if W set negative Y, S positive Y, etc. Normalize? For simplicity, diagonal speed sqrt(2) but fine.
      - Player rotation: `this.player.rotation = Phaser.Math.Angle.Between(this.player.x, this.player.y, this.input.activePointer.x, this.input.activePointer.y)`
      - Auto-fire if space held? Let's allow auto-fire with space. Or only on click. Let's do: on pointerdown fire once, and if space is held, auto-fire every 200ms. Use `this.time.now`. Simpler: on pointerdown fire once. Space can also fire. For simplicity: if space key is down and enough time passed, fire. But we need to track lastFireTime.
      - Enemy movement: enemies have velocity towards player. But if we set velocity on spawn, they will move straight. Better: in update, for each enemy, set velocity towards player. Or use `moveToObject` physics. But that's expensive per frame? Could use in update: `this.enemies.getChildren().forEach(enemy => { this.physics.moveToObject(enemy, this.player, enemy.speed) })`. Or set initial velocity towards player and maybe update if player moves. Let's just update velocity in update for all enemies.
      - Check wave: if no enemies and not spawning, start next wave after delay.
      - Update UI: health bar, score.
    - Helper functions:
      - generatePlayerTexture(): use graphics, fill circle body, fill rect turret pointing up (so rotation works). Since texture is static, turret points up. Player rotation rotates whole sprite.
      - generateAlienTexture(): draw a green shape, maybe a circle with antennae.
      - generateBulletTexture(): yellow rect.
      - generateParticleTexture(): white circle.
      - fireBullet(): spawn bullet at player tip. Calculate position in front of player based on rotation and offset. Set velocity toward rotation. Add to bullets group.
      - hitEnemy(bullet, enemy): bullet.disableBody(true, true); enemy.disableBody(true, true); add explosion at enemy position; score += 10; updateScore.
      - playerHit(player, enemy): if invulnerable return; enemy.disableBody(true, true); playerHealth -= 20; update health bar; screen shake; invulnerable for 1s (tint player, blink).
      - spawnWave(waveNum): calculate enemy count = 3 + waveNum * 3. Spawn them at random edges. Set enemy speed = 100 + waveNum * 20. Add to enemies group.
      - startNextWave(): wave++, waveText.setText, spawnWave.
      - updateHealthBar(): adjust healthFill width/scale or redraw.

Need to handle physics bodies and textures correctly.

Phaser generateTexture:
```
const gfx = this.make.graphics({x:0,y:0, add:false});
gfx.fillStyle(0x00ff00);
gfx.fillCircle(15,15,15);
gfx.generateTexture('alien', 30, 30);
gfx.destroy();
```
Works.

For player, maybe a tank shape: body circle 40x40, turret rect 10x20 centered on top half.
```
gfx.fillStyle(0x3366ff);
gfx.fillCircle(20,20,20);
gfx.fillStyle(0x99ccff);
gfx.fillRect(15, 5, 10, 15); // turret
```
But turret pointing up (negative Y). Actually fillRect x=15, y=0, w=10, h=20.

For alien, draw a bug:
```
gfx.fillStyle(0x00ff00);
gfx.fillCircle(15,15,12);
gfx.fillStyle(0x008800);
gfx.fillCircle(10,10,3); // eye
gfx.fillCircle(20,10,3);
gfx.fillStyle(0x00aa00);
gfx.fillRect(14, 22, 2, 8); // legs? maybe not needed.
```

For bullet: yellow rect 4x8.
For particle: white circle 4x4.

Health bar: generate two textures: healthBarBg (gray) and healthBar (red). Or just use add.rectangle. Let's use a graphics object and redraw in update? Or generate a texture and scaleX. Let's generate a 'health' texture: red rect width 200 height 20. Then healthFill = this.add.sprite(x,y,'health').setOrigin(0,0.5). Then scaleX based on healthPercent. Also add a 'healthBg' sprite behind it (dark gray same size). That works.

Let's also add a game over state: if player health <= 0, show game over text and stop updating.

Let's write the code carefully.

Game config: scale mode to fit window. Use `scale: { mode: Phaser.Scale.RESIZE }` maybe, but we need to handle resize or just set to window size. Let's use `width: window.innerWidth, height: window.innerHeight, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH }`? Actually with no external assets and single page, we can set fixed size or full window. Let's use `scale: { mode: Phaser.Scale.RESIZE }` so canvas fills window. But then positions need to update? Or we can just set width and height to window.innerWidth/Height and let it be fixed. Simpler: `width: 800, height: 600`? But user might want full screen. Let's use full window. Use `scale: { mode: Phaser.Scale.RESIZE }` and in create set positions relative to width/height. But when resizing, camera and UI may need update. For simplicity, set width/height to window.innerWidth/innerHeight and `autoCenter: Phaser.Scale.CENTER_BOTH`. Not using resize mode. So initial size is window size, and canvas stays that size. Good.

Physics: arcade gravity y=0.

Let's draft MainScene.

```javascript
class MainScene extends Phaser.Scene {
    constructor() {
        super('MainScene');
    }
    init() {}
    preload() {}
    create() {
        this.generateTextures();
        this.cameras.main.setBackgroundColor('#111122');
        
        // Player
        this.player = this.physics.add.sprite(this.cameras.main.width/2, this.cameras.main.height/2, 'player');
        this.player.setCollideWorldBounds(true);
        this.player.setDrag(100);
        this.playerHealth = 100;
        this.maxHealth = 100;
        this.invulnerable = false;
        
        // Groups
        this.bullets = this.physics.add.group({ defaultKey: 'bullet', maxSize: 200, runChildUpdate: false });
        this.enemies = this.physics.add.group({ defaultKey: 'alien', runChildUpdate: false });
        this.explosions = this.add.group();
        
        // Health bar
        this.healthBg = this.add.sprite(20, this.cameras.main.height - 30, 'healthBg').setOrigin(0,0.5);
        this.healthFill = this.add.sprite(20, this.cameras.main.height - 30, 'health').setOrigin(0,0.5);
        this.healthFill.setCrop(0, 0, 200, 20); // or scaleX
        this.updateHealthBar();
        
        // UI Text
        this.scoreText = this.add.text(20, 20, 'Score: 0', { fontSize: '24px', fill: '#fff', fontFamily: 'Arial' });
        this.waveText = this.add.text(this.cameras.main.width/2, 20, 'Wave 1', { fontSize: '20px', fill: '#ff0', fontFamily: 'Arial' }).setOrigin(0.5, 0);
        this.gameOverText = this.add.text(this.cameras.main.width/2, this.cameras.main.height/2, '', { fontSize: '48px', fill: '#f00', fontFamily: 'Arial', backgroundColor: '#000', padding: {x:20,y:10} }).setOrigin(0.5).setDepth(10);
        
        // Input
        this.keys = this.input.keyboard.addKeys('W,A,S,D,SPACE');
        this.input.on('pointerdown', () => this.fireBullet(), this);
        
        this.lastFireTime = 0;
        this.fireRate = 150; // ms
        this.score = 0;
        this.wave = 1;
        this.enemiesToSpawn = 0;
        this.spawnTimer = 0;
        this.isSpawning = false;
        this.gameOver = false;
        
        // Start first wave
        this.startWave(this.wave);
        
        // Collisions
        this.physics.add.overlap(this.bullets, this.enemies, this.hitEnemy, null, this);
        this.physics.add.overlap(this.player, this.enemies, this.playerHit, null, this);
    }
    
    generateTextures() {
        // Player
        let g = this.make.graphics({ add: false });
        g.fillStyle(0x3366ff);
        g.fillCircle(20, 20, 18);
        g.fillStyle(0x99ccff);
        g.fillRect(14, 0, 12, 16); // turret pointing up
        g.fillStyle(0x223366);
        g.fillRect(8, 24, 24, 6); // tracks
        g.generateTexture('player', 40, 40);
        g.destroy();
        
        // Alien
        g = this.make.graphics({ add: false });
        g.fillStyle(0x00ff00);
        g.fillCircle(15, 15, 12);
        g.fillStyle(0x008800);
        g.fillCircle(10, 10, 3);
        g.fillCircle(20, 10, 3);
        g.fillStyle(0x00aa00);
        g.fillRect(12, 22, 6, 4);
        g.generateTexture('alien', 30, 30);
        g.destroy();
        
        // Bullet
        g = this.make.graphics({ add: false });
        g.fillStyle(0xffff00);
        g.fillRect(0, 0, 4, 8);
        g.generateTexture('bullet', 4, 8);
        g.destroy();
        
        // Particle
        g = this.make.graphics({ add: false });
        g.fillStyle(0xffffff);
        g.fillCircle(2, 2, 2);
        g.generateTexture('particle', 4, 4);
        g.destroy();
        
        // Health bar
        g = this.make.graphics({ add: false });
        g.fillStyle(0x333333);
        g.fillRect(0, 0, 200, 20);
        g.generateTexture('healthBg', 200, 20);
        g.destroy();
        g = this.make.graphics({ add: false });
        g.fillStyle(0xff0000);
        g.fillRect(0, 0, 200, 20);
        g.generateTexture('health', 200, 20);
        g.destroy();
    }
    
    startWave(wave) {
        this.wave = wave;
        this.enemiesToSpawn = 3 + wave * 3;
        this.spawnTimer = 0;
        this.isSpawning = true;
        this.waveText.setText('Wave ' + wave);
    }
    
    spawnEnemy() {
        const cam = this.cameras.main;
        // spawn at random edge
        let x, y;
        const side = Phaser.Math.Between(0, 3);
        const margin = 30;
        switch(side) {
            case 0: x = Phaser.Math.Between(0, cam.width); y = -margin; break;
            case 1: x = cam.width + margin; y = Phaser.Math.Between(0, cam.height); break;
            case 2: x = Phaser.Math.Between(0, cam.width); y = cam.height + margin; break;
            case 3: x = -margin; y = Phaser.Math.Between(0, cam.height); break;
        }
        const enemy = this.enemies.create(x, y, 'alien');
        enemy.setSpeed(100 + this.wave * 20 + Phaser.Math.Between(-10, 10));
        enemy.setVelocity(0,0);
        // We'll set velocity in update via moveToObject
        // Alternatively store speed: enemy.setData('speed', 150 + this.wave * 20);
        enemy.setData('speed', 120 + this.wave * 25);
    }
    
    fireBullet() {
        if (this.gameOver) return;
        const now = this.time.now;
        if (now - this.lastFireTime < this.fireRate) return;
        this.lastFireTime = now;
        
        const bullet = this.bullets.create(this.player.x, this.player.y, 'bullet');
        if (!bullet) return;
        bullet.setActive(true).setVisible(true);
        const angle = this.player.rotation;
        // offset to tip of turret
        const offset = 24; // distance from center to tip
        bullet.x = this.player.x + Math.cos(angle) * offset;
        bullet.y = this.player.y + Math.sin(angle) * offset;
        const speed = 500;
        bullet.setVelocity(Math.cos(angle) * speed, Math.sin(angle) * speed);
        // bullet lifespan? Let's destroy after 2 seconds
        this.time.delayedCall(2000, () => { if (bullet.active) bullet.destroy(); });
    }
    
    hitEnemy(bullet, enemy) {
        bullet.disableBody(true, true);
        enemy.disableBody(true, true);
        this.createExplosion(enemy.x, enemy.y);
        this.score += 10 * this.wave;
        this.scoreText.setText('Score: ' + this.score);
    }
    
    playerHit(player, enemy) {
        if (this.invulnerable || this.gameOver) return;
        enemy.disableBody(true, true);
        this.playerHealth -= 20;
        this.updateHealthBar();
        this.cameras.main.shake(200, 0.01);
        if (this.playerHealth <= 0) {
            this.playerHealth = 0;
            this.createExplosion(this.player.x, this.player.y);
            this.player.setVisible(false);
            this.player.disableBody(true, true);
            this.gameOver = true;
            this.gameOverText.setText('GAME OVER\nScore: ' + this.score + '\nClick to restart');
            this.input.once('pointerdown', () => this.scene.restart(), this);
        } else {
            this.invulnerable = true;
            this.player.setAlpha(0.5);
            this.time.delayedCall(1000, () => {
                this.invulnerable = false;
                this.player.setAlpha(1);
            });
        }
    }
    
    updateHealthBar() {
        const pct = Math.max(0, this.playerHealth) / this.maxHealth;
        this.healthFill.setScale(pct, 1);
    }
    
    createExplosion(x, y) {
        const count = 8;
        for (let i = 0; i < count; i++) {
            const p = this.add.image(x, y, 'particle').setTintFill(0xffaa00);
            const angle = Phaser.Math.FloatBetween(0, Math.PI * 2);
            const speed = Phaser.Math.Between(50, 150);
            this.tweens.add({
                targets: p,
                x: x + Math.cos(angle) * 30,
                y: y + Math.sin(angle) * 30,
                alpha: 0,
                scaleX: 0.1,
                scaleY: 0.1,
                duration: 400,
                onComplete: () => p.destroy()
            });
            // optional physics? tween is fine.
        }
    }
    
    update(time, delta) {
        if (this.gameOver) return;
        
        // Movement
        const speed = 300;
        this.player.setVelocity(0, 0);
        if (this.keys.A.isDown) this.player.setVelocityX(-speed);
        else if (this.keys.D.isDown) this.player.setVelocityX(speed);
        if (this.keys.W.isDown) this.player.setVelocityY(-speed);
        else if (this.keys.S.isDown) this.player.setVelocityY(speed);
        // Normalize if diagonal? Could, but not critical.
        
        // Rotation towards pointer
        this.player.rotation = Phaser.Math.Angle.Between(this.player.x, this.player.y, this.input.activePointer.x, this.input.activePointer.y);
        
        // Auto fire with space
        if (this.keys.SPACE.isDown) {
            this.fireBullet();
        }
        
        // Enemy movement toward player
        this.enemies.getChildren().forEach(enemy => {
            if (!enemy.active) return;
            const spd = enemy.getData('speed') || 120;
            this.physics.moveToObject(enemy, this.player, spd);
        });
        
        // Wave spawning
        if (this.isSpawning) {
            this.spawnTimer += delta;
            if (this.spawnTimer > 400 && this.enemiesToSpawn > 0) {
                this.spawnEnemy();
                this.enemiesToSpawn--;
                this.spawnTimer = 0;
            } else if (this.enemiesToSpawn === 0 && this.enemies.countActive() === 0) {
                this.isSpawning = false;
                // Next wave after delay
                this.time.delayedCall(2000, () => {
                    if (!this.gameOver) this.startWave(this.wave + 1);
                });
            }
        }
    }
}
```

Need to ensure group pooling works. `this.bullets.create` will create or reuse. Need to set velocity and active. For enemy group, we use create and disable on hit.

Potential issues: `this.physics.moveToObject(enemy, this.player, spd)` will set velocity each frame. It's okay.

For health bar using a sprite with texture 'health' of width 200, we scaleX on the sprite. But setScale affects anchor? origin 0,0.5 means scaling x from left. Works.

For texture generation, ensure `generateTexture` uses correct width/height.

For health bar background, we could just use a graphics object drawn once. But generating texture is fine.

For screen shake, `this.cameras.main.shake(200, 0.01)` works.

Need to add some particles for explosion with color tint.

Make sure `this.input.keyboard.addKeys('W,A,S,D,SPACE')` works in Phaser 3. It does in 3.60+. If older, `this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W)` etc. But using string codes is common in Phaser 3.60. Since phaser.min.js version unknown, but likely recent. However to be safe, I can use KeyCodes. Phaser 3.60 supports addKeys with string. I'll use that.

Check if `bullet.disableBody(true, true)` is correct. It disables body and hides? Actually `disableBody(disableGameObject, hideGameObject)`. We want to hide and disable. `disableBody(true, true)` works.

For player bullet spawn offset: tip of turret is at y=0 relative to center (since turret drawn from y=0 to y=16). Actually center of player sprite is at (20,20). Turret extends from y=0 to y=16 (since width 12, height 16). The tip is at y=0. So offset from center (20,20) to tip (20,0) is -20 in y. But because player rotates, we need to use rotation. Since turret points up (negative Y in sprite), offset angle = player.rotation - PI/2? Wait, player.rotation is angle to mouse. Turret drawn pointing up (toward -Y). So the tip direction in world is player.rotation + (-Math.PI/2) if 0 is right? In Phaser, 0 rotation is right (positive X), positive rotation clockwise. Up is -PI/2. So if player.rotation is angle to mouse, the turret points in that direction? Actually if we draw turret pointing up (negative Y), then sprite rotation 0 has turret up. If we set player.rotation = angle to mouse, then turret rotates to point at mouse. So the tip offset direction is same as rotation (since up is -90°, but rotation is measured from +X). Let's check: if mouse is directly above player, angle = -PI/2. The turret drawn up corresponds to angle -PI/2, which matches. So tip offset is `(cos(angle) * 20, sin(angle) * 20)`? Actually tip is at (20,0) in sprite local coordinates. Relative to center (20,20), vector is (0,-20). Rotating that vector by player.rotation gives direction. Using `angle = this.player.rotation`, tip position = center + `{x: Math.cos(angle) * 20, y: Math.sin(angle) * 20}`? Let's test: angle = -PI/2 => cos=0, sin=-1 => y = -20 => correct (tip above center). angle = 0 => cos=1, sin=0 => x=20, y=0 => tip to right. That matches sprite drawn pointing right? Wait sprite drawn pointing up. If we rotate sprite by 0, turret points up, not right. Hmm confusion. In Phaser, default rotation 0 means sprite not rotated. If we draw turret pointing up (toward negative Y), then at rotation 0, turret points up. But if mouse is directly above, angle = -PI/2. If we set player.rotation = -PI/2, then the sprite rotates -90° so turret points right. That's wrong. Actually we need to set player.rotation = angle to mouse, but since turret drawn up, we need to offset by +PI/2? Let's derive:

Sprite local up direction is vector (0, -1). If we want sprite to face mouse direction, we need sprite.rotation = mouseAngle + PI/2 (since local up rotated by PI/2 points to angle 0? Let's compute: local up (0,-1) at rotation 0. If we rotate sprite by +PI/2 (90° clockwise), (0,-1) rotates to (1,0) which is right. So to make sprite face direction θ, set rotation = θ - (-PI/2)? Actually we need rotation such that local up aligns with θ. In Phaser, local up (0,-1) is rotated by sprite.rotation. The resulting vector is `(cos(rotation + PI/2), sin(rotation + PI/2))`? Wait rotation matrix: vector (x,y) rotated by α gives (x cosα - y sinα, x sinα + y cosα). For (0,-1): ( -(-sinα), 0 + (-1)cosα ) = ( sinα, -cosα ). We want this equal to (cosθ, sinθ). So sinα = cosθ, -cosα = sinθ => α = -θ + PI/2? Let's test θ=0 (right): α should be? sinα = 1 => α=PI/2. Check -cos(PI/2)=0, sin0=0 => works. So α = PI/2 - θ. Thus sprite.rotation = Math.PI/2 - angle. If mouse directly above (θ = -PI/2), rotation = PI/2 - (-PI/2) = PI. That rotates sprite 180°, so local up points up? Let's see: rotation PI: sin(PI)=0, -cos(PI)=1 => (0,1) down. Hmm not right.

Let's do simpler: just draw turret pointing right (positive X). Then at rotation 0, turret points right. Then angle to mouse = Phaser.Math.Angle.Between(...). If mouse is right, angle=0, turret points right. So we should draw turret pointing right. So draw turret rect from x=16 to x=32 (since width 12) or x=24, y=16, w=16, h=8. Actually if body circle center at (20,20), turret pointing right: rect x=20, y=14, w=18, h=12. Let's adjust: fillRect(20, 14, 18, 12). That points right. Then offset for bullet: tip at x=38, y=20 relative to center (20,20) => offset (18,0). So tip offset = (18,0). Rotate with player.rotation.

So let's change player texture: body circle at (20,20) radius 18, turret rect at (20, 12, 20, 16). That points right.

Then bullet spawn: `bullet.x = this.player.x + Math.cos(this.player.rotation) * 18; bullet.y = this.player.y + Math.sin(this.player.rotation) * 18;` Wait turret length 20, center at x=20+10=30? Actually body center is (20,20). Turret drawn from x=20 to x=40 (width 20). The tip is at x=40, relative to center is +20. So offset length 20. So bullet spawn at `player.x + Math.cos(angle)*20`, same for Y.

Thus: `const angle = this.player.rotation; bullet.x = this.player.x + Math.cos(angle) * 20; bullet.y = this.player.y + Math.sin(angle) * 20;`

Set bullet velocity `Math.cos(angle)*speed, Math.sin(angle)*speed`.

Great.

Now for health bar: using generateTexture 'health' (200x20 red). `this.healthFill = this.add.sprite(20, height-30, 'health').setOrigin(0,0.5);`. Then `this.healthFill.setScale(pct, 1);`. That works because scaling from origin 0.

Also need to ensure healthFill doesn't scale negative. pct max 1.

Game over: we show text and restart on click.

Wave transition: after wave cleared, delay 2s then startWave(wave+1).

Now check potential bugs: `this.enemies.countActive()` counts active children. After we disable bodies, they are not active. Good.

`this.enemiesToSpawn === 0 && this.enemies.countActive() === 0` triggers next wave. But we also need to ensure we only trigger once; setting `this.isSpawning = false` before delayed call.

Spawning: `this.enemies.create(x,y,'alien')` creates and adds to world. Need to set velocity. We'll set speed in data and move in update.

For auto-fire with space, we call fireBullet which checks time.

We need to handle pointerdown firing as well. Already done.

One more: `this.time.delayedCall(2000, ...)` inside update or startWave? In update we call `this.time.delayedCall` if wave finished. But if scene restarts, delayed calls are cleaned? They should be.

Let's wrap the code in a single HTML.

Also add some CSS: `body { margin: 0; overflow: hidden; background: #000; } canvas { display: block; }`

Now let's write the full file.

One concern: `this.physics.add.group({ defaultKey: 'bullet', maxSize: 200, runChildUpdate: false })` - I need to set `classType`? Not needed. When using create, it will use the default key. But we need to set velocity manually.

Also need to ensure bullets don't collide with world bounds but just keep going. `setCollideWorldBounds(false)` is default.

We also want to destroy bullets that go off screen to free pool. Could check bounds in update, but delayed destroy works. Or use `bullet.checkWorldBounds = true; bullet.outOfBoundsKill = true;`? For arcade sprite: `bullet.setCollideWorldBounds(false)` and `bullet.body.onWorldBounds = true` not simple. Simpler: in update, if bullet out of camera bounds, kill. But for now delayed destroy is fine.

Let's also add a simple starfield background using graphics? Not necessary.

Now for enemy spawning: `this.enemies.create(x,y,'alien')` returns a sprite. We set `enemy.setData('speed', 120 + this.wave * 25)`. Ensure `setData` works on ArcadeSprite? Yes.

In update, move enemies: `this.physics.moveToObject(enemy, this.player, spd)`. Note: `moveToObject` expects a GameObject with physics body. `this.player` is a sprite, fine.

For player health bar, we need to update `this.healthFill.setScale(pct, 1)`. Since origin 0,0.5, it scales left.

Also, we should maybe add some UI for health text? Not needed.

Now write the full index.html.

We need to check current directory for phaser.min.js. Let's run ls.

Phaser.min.js exists. Now write index.html.

The user asked to build a top-down alien shooter using phaser.min.js and write it into index.html. I wrote index.html with a full Phaser 3 game. Let's verify the file exists and check if there are any obvious issues.

Potential issues:
- The phaser.min.js file path: used `phaser.min.js` relative to HTML, which is correct.
- All graphics are procedurally generated.
- No external assets or CDNs.
- The file is self-contained.

I should verify the file content is complete and correct. Also maybe test if the HTML is valid (no syntax errors). Since I can't run a browser, I'll read back the file and do a quick review.

Also, need to ensure that `this.physics.moveToObject` is called correctly. In Phaser 3, `moveToObject` is a method of the Physics.Arcade.World or available via `this.physics.moveToObject`. Actually in Phaser 3, `moveToObject` is on the ArcadePhysics plugin: `this.physics.moveToObject(source, destination, speed)`. That should work.

One issue: In `fireBullet`, I used `bullet.disableBody(true, true)` for cleanup. That's correct.

In `playerHit`, `enemy.disableBody(true, true)` disables body and hides.

The `createExplosion` uses `this.add.image` which is fine.

`this.healthFill.setScale(pct, 1)` works because origin 0,0.5.

`this.player.setDrag(200)` so player slides a bit.

`this.keys.SPACE` - addKeys('W,A,S,D,SPACE') should work.

I think it's good. Let's just quickly read back to confirm no truncated closing tags.

The file is complete and properly closed. I should present the result to the user, summarizing what was built and confirming the file is present.