We need respond by creating index.html. Need inspect current dir maybe phaser.min.js present. Need build single-page app all in index.html with CSS/JS inline, script src phaser.min.js exact filename. No external. Need likely create Phaser game. Need ensure file. We need maybe read? Let's inspect.

Need write index.html. Need design game. Need no external image/audio. Procedural graphics via Phaser Graphics. Need top-down alien shooter: WASD movement, aim and fire at waves of advancing aliens, health, score, increasing difficulty. Single file. Need maybe use Phaser 3? phaser.min.js likely Phaser 3. Need robust. Need include UI perhaps HTML overlay or Phaser text. We can use Phaser only. Need self-contained. Need no external assets. Use inline script after phaser. Need maybe no network.

Need craft game. Need perhaps use Arcade physics. Need procedurally generated graphics: create textures via graphics? Or use shapes. We can create player as Phaser.GameObjects.Graphics with custom draw each update, aliens as graphics. Or use textures generated with graphics. Need top-down.

Need implement:
- Canvas 960x600 maybe fit.
- Background grid/stars procedurally.
- Player at center, WASD, mouse aim, click fire. Bullets move toward pointer. Cooldown.
- Health, score, wave, difficulty.
- Waves of aliens advancing, spawn from edges moving toward player, maybe zigzag.
- Increasing difficulty: wave number increases spawn count, speed, fire rate? Aliens maybe shoot? User says aim and fire at waves of advancing aliens. Could include alien projectiles. Need health.
- Game over screen, restart.
- Procedural graphics only.

Need maybe use HTML UI overlay? "CSS in style tag, JS script tag inline". Could include minimal HTML overlay for instructions and maybe use Phaser for game. CSS can style body.

Need ensure script src phaser.min.js. If phaser not loaded? Need maybe fallback? But file exists. Use global Phaser.

Need write index.html.

Need think Phaser version. Let's inspect phaser? Could be Phaser 3. Need code compatible. Maybe use new Phaser.Game(config). Use Arcade physics. Need no external.

Potential issues:
- If using this.physics.add.image? Need textures. But we can use graphics objects not physics? Arcade can add to group with custom shapes? We can use add.rectangle with physics enabled? Better use this.physics.add.image and generate textures via Graphics. That is procedural. But "graphics only" okay. We can generate textures:
  - player texture: create graphics, fill triangle/circle etc, generateTexture('player', 48,48)
  - bullet texture, alien texture, alien projectile.
Then use sprites. This is procedural. Or use Graphics for dynamic aiming. Sprites can rotate.

Need use physics. Spawn aliens with add.sprite. Set velocity. Need collisions bullets vs aliens. Need overlap player vs aliens/projectiles.

Need maybe use Arcade physics. Use this.physics.add.group.

Need game scene.

Need top-down.

Need include "WASD move" and "aim/fire" maybe mouse/touch. Fire on pointer down and hold? "aim and fire" Could support mouse move aim and left button hold fire. Use pointer.isDown.

Need score increasing difficulty. Wave system:
- Wave starts with spawnCount = 8 + wave*3, interval = max(250, 1200 - wave*80). Spawn alien every interval until wave remaining.
- difficulty increases: aliens speed = 35 + wave*5, health = 1 + floor(wave/4), maybe projectile speed.
- Boss? Not necessary.

Need "waves of advancing aliens": spawn at edges, move toward player. Some aliens shoot projectiles. To add challenge.

Need health: player health 100. Alien contact damage, alien bullets damage. Invulnerability maybe 0.5s.

Need game states: 'ready', 'playing', 'gameover'? Phaser Scene can have state variable. On gameover, show overlay text. Restart with R.

Need UI: top bar text. Health bar maybe Graphics drawn each update. Score, wave, remaining.

Need background: tile grid, stars. Use Graphics. Maybe create background texture with stars and grid? Procedural.

Need maybe "no external image or audio assets" okay.

Need maybe "library files already present load with script src NAME" exact. Need include `<script src="phaser.min.js"></script>`.

Need maybe no external resources. Fine.

Need ensure "single-page web app" maybe include title and instructions. Good.

Need maybe responsive? Could fit window. Phaser config width/height maybe 960x600; scale FIT center. Use parent game. CSS.

Need maybe use Phaser.Scale.FIT. Need require phaser. If Phaser.Scale undefined? Phaser 3. Need check version? Could inspect quickly? But likely. Need maybe use Phaser.AUTO.

Potential issue: `this.scale.setGameSize(window.innerWidth, window.innerHeight)` if responsive. Simpler fixed canvas with CSS center.

Need maybe use `Phaser.Math.Between`.

Need maybe create textures:
```
function createPlayerTexture(scene) {
 const g = scene.make.graphics({x:0,y:0,add:false});
 g.clear();
 g.fillStyle(0x23f0ff,1); g.fillCircle(24,24,16);
 ...
 g.generateTexture('player',48,48);
}
```
But for top-down player, draw triangle nose toward +y? Sprite rotation. If draw with nose at top? In Phaser, rotation 0 points to right? Actually for images, 0 rotation means image as generated, not directional. For velocity direction, set angle = velocity.angle + 90 if nose at top. If texture nose upward (toward -y), then angle = velocity.angle + 90 (because Phaser angle 0 is +x, 90 is +y? Need coordinate y down; Math.AngleBetween returns angle from +x clockwise? Phaser uses radians where 0 east, PI/2 south. If sprite texture nose up (towards -y), rotation 0 means nose up. To point to angle θ, rotation = θ + Math.PI/2? At θ=0 (east), need rotate nose up clockwise 90 deg -> +PI/2. At θ=PI/2 (south), rotation=PI (nose down). Good.
For bullets, texture maybe circle/tri pointing up; rotation = bullet.angle.
Aliens maybe texture has front toward +y? But no need.

Need maybe use `sprite.rotation = Phaser.Math.Angle.Between(sprite.x, sprite.y, player.x, player.y) + Math.PI/2` if front down? Maybe alien texture nose down? Doesn't matter.

Need maybe collisions:
- bullet group vs alien group:
```
this.physics.add.overlap(this.bullets, this.aliens, this.hitAlien, null, this);
```
`hitAlien(bullet, alien)` check bullet.active? In overlap callback both active. Set bullet.destroy? Actually Arcade GameObjects have active false after disableBody(true,true). Need if bullet.destroy() okay. In Phaser 3 `destroy()` removes.
`alien.hp -= bullet.damage;` if <=0 destroy, score += ...
- `this.physics.add.overlap(this.player, this.aliens, this.damagePlayerFromAlien, ...)`
- `this.physics.add.overlap(this.player, this.alienBullets, ...)`

Need collision with world bounds? Bullets destroyed if outside. Aliens maybe if reach player? They move to player, contact.

Need maybe spawn logic:
```
startWave() {
 this.wave++;
 this.remaining = 8 + this.wave*4;
 this.spawnTimer = this.time.addEvent({delay: 300, loop:true, callback: this.spawnAlien, callbackScope:this});
 this.time.delayedCall(500, () => this.spawnTimer.remove());
}
```
But remove after remaining? Better:
```
this.spawnTimer = this.time.addEvent({delay: 0, loop: true, callback: () => {
 if (this.remaining > 0 && this.waveActive) { spawn; this.remaining--; }
 else { this.spawnTimer.remove(); this.spawnTimer=null; }
}, repeat: this.remaining?});
```
But `repeat` needs known. Use `repeat: this.waveSpawnCount - 1`.
```
this.spawnTimer = this.time.addEvent({ delay: spawnDelay, repeat: this.spawnTotal-1, callback: () => this.spawnAlien()});
```
After spawn count. Need wave complete when aliens count 0 and remaining 0.
```
if (!this.spawnTimer && this.aliens.countActive(true) === 0) next wave after 2 sec.
```
Need update.

Need spawn aliens from edges:
```
const side = Phaser.Math.Between(0,3);
if side 0 x=-30 y=random; etc.
const alien = this.aliens.get(x,y);
if (alien) {
 alien.setActive(true).setVisible(true).setVelocity(0,0);
 alien.hp = 1 + Math.floor(this.wave/4);
 alien.maxHp = ...
 alien.speed = 45 + this.wave*5 + random
 alien.fireChance = Math.min(0.006 + wave*0.0005,0.015)
 alien.shootTimer = random
 alien.setScale(0.8 + random*0.4)
 alien.setTint? Maybe tint based on type.
}
```
Group `this.aliens = this.physics.add.group({ classType: Phaser.GameObjects.Sprite, runChildUpdate: true });` But need update child update to move toward player and shoot. Could use `this.aliens.children.each`.
Need `get(x,y)` if none create new with texture. In Phaser group get creates via classType with x,y? likely.
Set velocity in update:
```
this.aliens.children.iterate(alien => {
 if (!alien.active) return;
 const angle = Phaser.Math.Angle.Between(alien.x, alien.y, player.x, player.y);
 alien.setVelocity(Math.cos(angle)*alien.speed, Math.sin(angle)*alien.speed);
 alien.rotation = angle + Math.PI/2; // if nose down? 
 alien.shootTimer -= delta;
 if (alien.shootTimer <=0 && this.physics.world.overlapRect? maybe) { shoot; alien.shootTimer = Phaser.Math.Between(1200,2400)/Math.max(1,this.wave*0.2) }
});
```
Need `iterate` returns. Use `this.aliens.children.each(alien => { ... });`.

Need alien shooting:
```
shootAlien(alien) {
 const angle = Math.Atan2(player.y-alien.y, player.x-alien.x);
 const b = this.alienBullets.get(alien.x, alien.y);
 if (b) {
  b.setActive(true).setVisible(true);
  b.rotation = angle;
  b.setVelocity(Math.cos(angle)*160, Math.sin(angle)*160);
  b.damage = 10 + wave*2;
  this.time.delayedCall(2500, () => { if (b.active) b.disableBody(true,true); });
 }
}
```
Need bullet lifetime for player bullets too. Use `this.time.delayedCall(1500, () => { if (b.active) b.disableBody(true,true); });`

Need maybe spawn pickups? Not necessary. But maybe health packs? Could add procedural graphics. But user didn't ask. Health maybe can regenerate slowly? Top-down shooter with health. Maybe add occasional medpack drop. But keep.

Need score and difficulty:
- kill score 100 * wave.
- UI displays wave, score, health, aliens left.
- Increasing difficulty: wave number, spawn count, speed, hp, alien fire rate.
Need maybe show "Wave X" and "Aliens: Y".

Need maybe game over:
- If health <=0: state='gameover'; physics.pause(); show overlay "Game Over", score, wave. Press R.
- If win? Infinite waves; difficulty increasing. No win.

Need maybe pause? Space? Not necessary. Could include P pause. But user only asks.

Need maybe instructions: "WASD move • Mouse aim • Hold left click to fire • R restart". Good.

Need maybe no audio assets. Could synthesize sound? User says no external audio assets; maybe not necessary. Could include procedural Web Audio beeps? But "no external image or audio assets" doesn't prohibit generated audio. But to avoid complexity and browser autoplay issues, no audio.

Need maybe ensure code not use external fonts. Use system.

Need maybe handle "phaser.min.js" exact. Good.

Need maybe include `defer`? If script src before inline script, okay.

Need maybe use `DOMContentLoaded`? Inline after script in body, so Phaser loaded. Use config.

Potential issue with `this.scale` config and parent:
```
const config = {
 type: Phaser.AUTO,
 parent: 'game',
 width: 960,
 height: 600,
 backgroundColor: '#050712',
 physics: { default: 'arcade', arcade: { debug: false } },
 scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH },
 scene: GameScene
};
new Phaser.Game(config);
```
CSS body.

Need maybe handle mobile? Not necessary.

Need maybe `this.cameras.main.setBounds(0,0,960,600);`

Need maybe procedural graphics:
- `createBackground()` with `this.add.tileSprite(480,300,960,600, 'space')` texture generated with stars and grid. But tileSprite with texture. Procedural.
- For grid lines maybe easier draw background every update? Use static graphics:
```
const bg = this.add.graphics();
bg.fillStyle(0x050712); bg.fillRect...
for lines...
```
But static. For scrolling starfield, use tileSprite. Need create texture:
```
createSpaceTexture(scene) {
 const g = scene.make.graphics({x:0,y:0,add:false});
 g.fillStyle(0x050712,1); g.fillRect(0,0,128,128);
 for (i=0;i<20;i++) { fillStyle random; fillCircle random; }
 g.lineStyle(1,0x12304a,0.25); for lines ...
 g.generateTexture('space',128,128);
}
```
Then tileSprite.

Need maybe draw health bar in UI:
```
this.healthBar = this.add.graphics();
drawHealth() {
 this.healthBar.clear();
 this.healthBar.fillStyle(0x101726); fillRoundedRect? Phaser Graphics has fillRoundedRect? In Phaser 3 yes maybe. To be safe use fillRect.
 this.healthBar.fillStyle(0x2cff7a); fillRect(18,18,180*(health/max),12);
 ...
}
```
Need UI text.

Need maybe "procedurally generated graphics" includes UI? Fine.

Need maybe no external image/audio.

Potential Phaser group creation:
```
this.bullets = this.physics.add.group();
...
const bullet = this.bullets.get(x,y,'bullet');
```
If group classType not set, `get` with texture? I think `get(x,y,key,frame,active)` works. Or use `this.physics.add.sprite(x,y,'bullet')` and add to group? Simpler:
```
const bullet = this.bullets.get(x,y);
if (bullet) { bullet.enableBody(true, x,y,true,true); bullet.setTexture('bullet'); ...}
else { bullet = this.physics.add.sprite(x,y,'bullet'); this.bullets.add(bullet);}
```
But `get` can accept texture if group has `classType: Phaser.Physics.Arcade.Image`. Need maybe:
```
this.bullets = this.physics.add.group({
 classType: Phaser.Physics.Arcade.Image,
 runChildUpdate: false
});
```
Then `get(x,y,'bullet')`.
Need if `get` returns null? It creates if maxSize not set. Good.

For aliens:
```
this.aliens = this.physics.add.group({
 classType: Phaser.Physics.Arcade.Sprite,
 runChildUpdate: false
});
this.aliens.createMultiple({ key:'alien', active:false, visible:false });
```
Not necessary; `get` creates new.

Need maybe `setDepth` for sprites.

Need maybe `this.physics.add.overlap(this.bullets, this.aliens, this.handleBulletAlien, undefined, this);`

Need issue with `this.bullets.getChildren().filter(b=>b.active)` maybe okay.

Need maybe if bullet and alien overlap multiple times before bullet disabled? In callback, `bullet.disableBody(true,true);` so no multiple.

Need maybe if alien killed, disableBody true true. Score. Spawn particles? Could create procedural particles? Not necessary. Maybe use small explosion graphics:
```
this.createExplosion(x,y,color) {
 for i=0..8:
  const spark = this.explosions.get(x,y);
  spark.setActive(true).setVisible(true);
  spark.setTint(color)
  spark.setVelocity(cos*speed, sin*speed);
  this.time.delayedCall(250, () => spark.disableBody(true,true));
}
```
Need explosion group with small circles. Procedural. Nice.

Need maybe draw player as sprite with generated texture. Could use `this.player = this.physics.add.sprite(480,300,'player')`.
Need maybe player's body size:
```
this.player.body.setSize(24,24);
```
Need `player.setCollideWorldBounds(true);`
Need movement:
```
const speed=220;
this.keys = this.input.keyboard.addKeys({w:Phaser.Input.Keyboard.KeyCodes.W,...});
this.cursors = this.input.keyboard.createCursorKeys();
...
const ax = (D?1:0)-(A?1:0), ay = ...
if (ax || ay) {
 const len = Math.hypot(ax,ay);
 this.player.setVelocity(ax/len*speed, ay/len*speed);
 this.player.rotation = Math.atan2(ay, ax)+Math.PI/2;
} else this.player.setVelocity(0,0);
```
Need maybe aim at mouse:
```
this.pointer = this.input.activePointer;
this.aimAngle = Phaser.Math.Angle.Between(this.player.x, this.player.y, this.pointer.worldX, this.pointer.worldY);
```
If pointer outside canvas, worldX clamped? Use `Phaser.Math.Clamp`.
```
this.aimX = Phaser.Math.Clamp(pointer.worldX,0,960); ...
```
Need maybe draw crosshair with Graphics each update:
```
this.crosshair.clear();
this.crosshair.lineStyle(2,0xffffff,0.7);
this.crosshair.strokeCircle(aimX,aimY,10);
this.crosshair.lineBetween(aimX-16,aimY,...)
```
Need maybe aim reticle.

Need fire:
```
this.fireCooldown = 0;
const cooldown = 130; // ms
if (pointer.isDown && fireCooldown <=0) { fireBullet(); fireCooldown = cooldown; }
this.fireCooldown -= delta;
```
Need maybe bullets spread? Not necessary.
```
fireBullet() {
 const angle = aimAngle;
 const bullet = this.bullets.get(player.x + cos*24, player.y + sin*24);
 if (bullet) { enable, setVelocity, rotation, damage=25+wave*2; }
}
```
Need maybe bullet speed 650.

Need maybe player health and invuln:
```
this.invulnerable = 0;
...
this.invulnerable -= delta;
if (this.invulnerable <=0) this.player.setVisible(true); else flicker.
```
Need maybe alien contact damage only once:
```
damagePlayer(amount, x,y) {
 if (this.state !== 'playing' || this.invulnerable >0) return;
 this.health -= amount; this.invulnerable = 700; updateUI; createExplosion...
 if (this.health <=0) endGame();
}
```
Need if invulnerable and overlapping, no damage.

Need maybe alien bullets damage:
```
if (bullet.active) bullet.disableBody(true,true); damagePlayer(bullet.damage, bullet.x, bullet.y)
```
Need maybe aliens colliding:
```
alien.disableBody(true,true); createExplosion; damagePlayer(18,alien.x,alien.y)
```
Need maybe player contact with alien should kill alien? Could damage player and alien maybe explode. Fine.

Need maybe alien projectiles can collide with player; no collision with aliens.

Need maybe alien spawn at edges and move toward player; if too many, okay.

Need maybe wave spawn intervals:
```
startWave() {
 this.wave++;
 this.spawnCount = 8 + this.wave*3;
 this.spawnRemaining = this.spawnCount;
 this.spawnDelay = Math.max(250, 1100 - this.wave*55);
 this.spawnTimer = this.time.addEvent({
   delay: this.spawnDelay,
   repeat: this.spawnCount -1,
   callback: () => { this.spawnAlien(); this.spawnRemaining--; },
   callbackScope: this
 });
 this.statusText.setText('Wave ' + this.wave + ': ' + this.spawnCount + ' aliens incoming');
 this.time.delayedCall(1500, () => { if (this.state==='playing') this.statusText.setText('');});
}
```
Need if state gameover, remove timer.

Need wave complete:
```
if (this.spawnTimer && this.spawnTimer.getRemainingEvents? Hmm)
```
Simpler in update:
```
if (this.spawnTimer && this.spawnTimer.getRepeatCount? no. Maybe use `this.spawnRemaining`.
if (this.spawnTimer && this.spawnRemaining <=0 && this.aliens.countActive(true) === 0) {
 this.spawnTimer.remove(false);
 this.spawnTimer = null;
 this.time.delayedCall(1000, () => { if (state==='playing') startWave();});
}
```
But `spawnRemaining` decremented after spawn; after last spawn it's 0. Good. Need avoid scheduling multiple next wave. Use `this.nextWaveScheduled` flag.
```
this.nextWaveScheduled = false;
...
if (!this.nextWaveScheduled && this.spawnRemaining <=0 && this.aliens.countActive(true)===0 && this.state==='playing') {
 this.nextWaveScheduled=true;
 this.time.delayedCall(1200, () => { if (this.state==='playing') { this.nextWaveScheduled=false; this.startWave(); }});
}
```
Need if aliens active after spawn.

Need maybe spawn alien count active includes inactive in group. `countActive(true)` good.

Need maybe aliens group `setAll('drag', 0)`? no.

Need maybe alien movement update:
```
const dx = player.x - alien.x; const dy=...
alien.setVelocity(dx/dist*alien.speed, dy/dist*alien.speed);
```
Need maybe if dist < 2, set velocity 0.

Need maybe alien shoot:
```
alien.shootDelay -= delta;
if (alien.shootDelay <= 0) { this.shootAlien(alien); alien.shootDelay = Phaser.Math.Between(1200,2200) / (1 + this.wave*0.05); }
```
Need avoid too many alien bullets. Maybe cap:
```
if (this.alienBullets.countActive(true) < 35)
```
Need maybe alien bullets can be destroyed on world bounds. Use update:
```
this.alienBullets.children.each(b => { if (b.active && (b.x< -30 || ...)) b.disableBody(true,true); });
```
Need maybe player bullets too.

Need maybe `this.time.now`? We'll use delta.

Need maybe "increasing difficulty" visible:
- wave text.
- alien color maybe changes with wave? tint.
- maybe difficulty meter.

Need maybe code clarity.

Need maybe if Phaser not loaded, display error? Could include:
```
if (!window.Phaser) { document.getElementById('game').innerHTML = 'Phaser failed to load'; } else new Phaser.Game...
```
But if script src fails, inline still executes. Could show. But no need. Yet robust. Need no network.

Need maybe include "phaser.min.js" script exactly. Good.

Need maybe ensure no external resources: no font imports. Good.

Need maybe maybe if phaser.min.js is v2? phaser.min.js could be Phaser 3? Need check? phaser.min.js 1.18MB likely Phaser 3.68. Need code with Phaser 3.

Need maybe use `Phaser.Math.Clamp` etc.

Need maybe include `scene.make.graphics` after scene created. Good.

Need maybe create textures before using. In `preload`? Since generated, use `create`.

Potential issue: `generateTexture` can be called in `create` after scene has graphics. Good.

Need maybe if game uses `tileSprite` with generated texture, `this.add.tileSprite(480,300,960,600,'space')`. It will repeat. Good.

Need maybe `this.cameras.main.setViewport(0,0,960,600)`. Not necessary.

Need maybe `this.input.on('pointerdown', () => { if (this.state==='gameover') restart(); });` But if click gameover restart? Maybe. But also pointerdown starts firing. Could conflict. Better not. Use R.

Need maybe `this.input.keyboard.on('keydown-R', () => { if (this.state !== 'playing') this.restartGame(); });`
Need maybe `keydown-SPACE` pause? Not necessary.

Need maybe "current directory" /tmp/ws. We'll write file.

Let's draft index.html. Need maybe include comments? Fine.

Need maybe use Unicode "×"? Fine.

Need maybe `fillRoundedRect`? To avoid compatibility, use fillRect. But Phaser 3 has `fillRoundedRect`; okay but no need.

Need maybe `this.add.text` with style. Fine.

Need maybe `this.cameras.main.setBackgroundColor`.

Need maybe `this.physics.world.setBounds(0,0,960,600)`.

Need maybe create "scanner" circle around player? Could use graphics.

Need maybe "procedural graphics" maybe all objects generated. Good.

Need maybe maybe use `this.add.graphics` for background grid and stars. Need if using tileSprite generated with random, okay.

Need maybe `make.graphics` texture with random stars; every reload different.

Need maybe `createExplosion` uses `this.explosions` group. Need create group after textures.

Need maybe `this.explosions = this.physics.add.group({ classType: Phaser.Physics.Arcade.Image });`
Then in explosion:
```
const spark = this.explosions.get(x,y,'spark');
if (spark) {
 spark.enableBody(true,x,y,true,true);
 spark.setActive(true).setVisible(true);
 spark.setTint(color);
 spark.setScale(Phaser.Math.FloatBetween(0.5,1.2));
 const a = Phaser.Math.FloatBetween(0, Math.PI*2);
 const s = Phaser.Math.Between(80,220);
 spark.setVelocity(Math.cos(a)*s, Math.sin(a)*s);
 spark.setDrag(120);
 this.time.delayedCall(280, () => { if (spark.active) spark.disableBody(true,true); });
}
```
Need if `get` returns inactive and body disabled, `enableBody` needed. Does `setActive(true).setVisible(true)` not enable body. Use `spark.enableBody(true, x, y, true, true);`.
Need maybe `spark.body.reset(x,y)`. `enableBody` okay.

Need maybe if group `get` returns active? If no, okay. If returns null? group maxSize not set. Fine.

Need maybe bullet group:
```
this.bullets = this.physics.add.group({ classType: Phaser.Physics.Arcade.Image, defaultKey:'bullet' });
```
Need `defaultKey` property? I think group config has `defaultKey`, `defaultFrame`. But not sure. Simpler no default. `this.bullets.get(x,y,'bullet')`.

Need maybe `this.bullets.getChildren().forEach` okay.

Need maybe `this.physics.add.overlap(this.bullets, this.aliens, this.hitAlien, null, this);`
Need `this.physics.add.overlap(this.player, this.aliens, this.hitPlayerAlien, null, this);`
Need `this.physics.add.overlap(this.player, this.alienBullets, this.hitPlayerBullet, null, this);`

Need maybe `this.aliens.children.iterate` signature: `iterate(callback, context, ...args)`. It returns null? Use:
```
this.aliens.children.iterate((alien) => { ... });
```
In Phaser 3, `Group.children.iterate(callback, context, ...args)` yes.

Need maybe if `alien.active` false but body disabled, no velocity. Good.

Need maybe `alien.setDepth(8);`.
Need maybe `alien.setCircle(16);` Is `setCircle` on Arcade Sprite? Yes `body.setCircle` or `alien.body.setCircle(16)`. For sprite, `alien.body.setSize(24,24); alien.body.setOffset(12,12);`
Need maybe alien texture size 48. Set body:
```
alien.body.setSize(24,24);
alien.body.setOffset(12,12);
```
Maybe after `setActive` and `enableBody`.

Need maybe player body:
```
this.player.body.setSize(24,24);
this.player.body.setOffset(12,12);
```

Need maybe bullet body:
```
bullet.body.setSize(10,10); bullet.body.setOffset(3,3);
```

Need maybe alien bullets body:
```
bullet.body.setSize(8,8); bullet.body.setOffset(4,4);
```

Need maybe "waves of advancing aliens" maybe aliens should spawn in waves and advance. Good.

Need maybe "health, score, increasing difficulty" UI. Good.

Need maybe "top-down alien shooter" maybe all top-down.

Need maybe "aim and fire" maybe mouse. Good.

Need maybe "WASD" exactly. Good.

Need maybe "R restart" optional.

Need maybe no external audio. Good.

Need maybe "procedurally generated graphics" maybe no image files. Good.

Need maybe maybe if user opens file from local, browser allows script src local. Good.

Need maybe write.

Need verify file present and maybe run basic grep? Could use maybe no syntax check? We can run maybe `ls -l index.html`, maybe maybe use node? Phaser browser not available. Could run grep for external URLs. Need maybe ensure no accidental `http`. Use `rg "https?|src="`.

rg regex error but ls okay. Need maybe run better.

Need maybe final concise. But before final maybe inspect? Could there be a bug in `make` texture: g.width and g.height set after drawing? In Phaser Graphics, setting width/height after drawing maybe okay? Need ensure generated texture dimensions. In Phaser 3, `Graphics.width` and `.height` properties can be set, but maybe should set before drawing. It might be okay. But I want to avoid potential issues. In Phaser, `generateTexture(key, width, height)` can take explicit width/height. We can call `g.generateTexture(name, 128, 128)`, etc. Better edit to use explicit dimensions. Current code:
```
const make = (name, drawer) => {
 const g = ...
 drawer(g);
 g.generateTexture(name, g.width, g.height);
 g.destroy();
};
make("space", (g) => { g.width=128; g.height=128; ...});
```
In drawer, set width after create before drawing. `generateTexture(name, g.width, g.height)` should work. For "player" width 54 etc. Fine.

Potential issue: `g.fillStyle(c, c === 255 ? 0x65ffffff : 0x35ffffff, 0.42);` Wait Phaser Graphics `fillStyle(color, alpha)` takes color number and alpha. Here second arg is weird: if c=255, `0x65ffffff` > 0xffffff? It expects color (32-bit maybe alpha included?) Actually Phaser display color can include alpha in high bits? 0x65ffffff = alpha 101/255 and RGB white. Then third arg 0.42. This might be accepted? Phaser.Color.ValueToColor handles 0x65ffffff maybe alpha? Hmm. It might be okay but maybe weird. Simpler:
```
g.fillStyle(0xffffff, Phaser.Math.FloatBetween(0.25,0.75));
```
Better. Need edit? Not necessary but safe. Could adjust.

Potential issue: `this.healthBar.fillRect(22, 22, 182 * hpPct, 8);` If hpPct 0, width 0 okay. Good.

Potential issue: `this.statusText.alpha = 0.45 + Math.sin(...) * 0.35 + 0.35;` range 0.45-1.15? Actually 0.45 + sin*0.35 + 0.35 = 0.8 to 1.15, alpha >1 clamped? Phaser alpha property maybe clamps? Could be >1. Better set 0.65+sin*0.3. Need edit. Not critical.

Potential issue: `this.spawnTimer.remove(false);` In Phaser 3, `TimerEvent.remove(loop?)`? I think `remove(false)` maybe okay? Let's check Phaser 3 TimerEvent.remove(repeat?)? I recall `remove(loop)` where loop optional. It sets removed. Good.

Potential issue: `this.spawnTimer.getRemainingEvents` not used. Good.

Potential issue: `this.aliens.countActive(true)` counts active true. Good.

Potential issue: `this.time.now * 0.0018` okay.

Potential issue: `this.input.activePointer.worldX` when pointer outside canvas may be world coordinates (can be negative/outside), clamp. Good.

Potential issue: `this.input.activePointer.isDown` true on touch, but WASD. Good.

Potential issue: `this.gameOverPanel.setVisible(true);` but physics.pause() doesn't stop update? update still called, but state gameover prevents. Good.

Potential issue: `endGame` createExplosion after physics.pause? Explosions group uses physics but no update? Since state gameover, updateProjectiles not called, so explosion sparks won't animate. But okay. Could call before pause? Not important. But if physics.pause, velocities don't update. If want explosion animation, call before pause. Not necessary.

Potential issue: `this.physics.add.group({ classType: Phaser.Physics.Arcade.Image })`; if `get(x,y,'bullet')` creates image with physics? I think yes. Need maybe classType is not Arcade.Image? Actually `Phaser.Physics.Arcade.Image` is a class. Good.

Potential issue: `alien.setTint(Phaser.Math.Between(0,1) ? COLORS.alien : COLORS.alienHot);` Phaser.Math.Between inclusive. If returns 0, tint hot. Good.

Potential issue: `alien.tint` property? In Phaser 3, tint is not a simple property? `alien.tint` maybe `tintTopLeft`? There is no `tint` property? Actually `GameObject.tint` may not exist. We use `alien.tint || COLORS.alien` in createExplosion. If `alien.tint` is undefined, okay. But if property exists maybe not. Fine.

Potential issue: `this.cameras.main.shake(110, 0.006);` Signature shake(duration, intensity) yes.

Potential issue: `this.time.delayedCall(90, () => { if (alien.active) alien.setTint(...); });` If alien disabled before callback, active false. Good.

Potential issue: `this.input.keyboard.on("keydown-R", () => { if (this.state !== "playing") this.restartGame(); });` If state playing, R no effect. Good.

Potential issue: `this.statusTextValue` not cleared when statusFlashMs 0? It remains, but setText empty. Good.

Potential issue: `this.updateHud()` in update every frame; okay.

Potential issue: `this.createProceduralTextures()` uses `g.generateTexture(name, g.width, g.height)` after g.destroy? Wait generate before destroy. Good.

Potential issue: `make("space", (g) => { g.width = 128; g.height=128; ...})`; In Phaser Graphics, setting width and height maybe only after drawing? It might not render? Let's maybe inspect Phaser docs? `Graphics.generateTexture(key, width, height)` takes explicit. Better edit to call explicit dims to avoid g.width issues. We can edit. Need exact.

Need maybe run syntax check? Could use node with acorn? Not installed. Could use `node --check` on script? index.html not JS. We can extract script maybe using perl? Could run `node --check <(sed -n '/<script>/,/<\\/script>/p' ...)` but includes HTML? Need not. We can maybe use `python` parse? Not. Maybe use `node --check` on JS extracted between `<script>` and `</script>` maybe. But first script is phaser external, second inline. We can extract second. Use python.

python3 not found. Use node to extract? Need maybe no matter. Could use perl? Use awk. But not necessary. Let's use node script to extract and check.

Need maybe verify rg.