We need respond by doing task. Need inspect current dir. Need use phaser.min.js present. Need create index.html self-contained, no external resources. Need ensure uses plain script src="phaser.min.js". Build playable brick breaker game with paddle arrow/mouse, ball, bricks score. Procedural graphics via Phaser Graphics API/generated textures no external assets. Need likely Phaser 3 global. Need check phaser version maybe. Need create file. We can inspect.

Need create index. Could use Phaser 3. Need maybe test? We can write HTML. Need no external image/audio. Use generated textures via Graphics. Need maybe use matter or arcade physics. Simpler Arcade physics. Need no external resources. Need use script src="phaser.min.js". Need maybe include CSS.

Need design robust. Single page. Should be playable. Need maybe use Phaser Game with canvas. Need use generated textures for paddle, ball, bricks, particles maybe. Need avoid external assets. Use Graphics API to create textures.

Need consider Phaser version. phaser.min.js likely 3.80? Need global Phaser. Use Phaser.AUTO, config with type? global Phaser. Need code.

Need maybe use CSS centered, responsive. Use JS.

Need implement:
- HTML meta, style.
- body black, container, instructions.
- script src phaser.min.js.
- script:
const config = {
type: Phaser.AUTO,
parent:'game',
width: 960,
height: 640,
backgroundColor:'#050713',
physics:{ default:'arcade', arcade:{ debug:false, gravity:{y:0} } },
scene:{ preload, create, update }
}
new Phaser.Game(config)

Preload:
generateTextures(this)
create textures:
- paddle: graphics.fillStyle colors, fillRoundedRect, line etc. generateTexture('paddle', 120, 18)
- ball: radial gradient? Phaser Graphics doesn't support gradients maybe. Use generated texture with circles.
- brick: 70x28 rounded rect with highlights.
- heart? Maybe not.
- star maybe.

Create:
score=0, lives=3, level=1, state='ready'
background: stars maybe Graphics
walls? invisible boundaries.
paddle sprite at width/2, height-45, physics enabled.
ball sprite with physics circle.
bricks group static.
score text, lives text, state text, high score maybe.
input:
cursors = this.input.keyboard.createCursorKeys();
this.input.on('pointermove', pointer => if active paddle.x = pointer.x)
this.input.on('pointerdown', launch if ready)
space launches.
Update:
if state ready: ball follows paddle; paddle movement arrow keys; if pointer dragging? We'll allow pointer move always.
if playing: move paddle via arrow keys (left/right) and mouse? Need avoid mouse always overriding. Maybe pointermove sets paddle x only if pointer inside game. Fine.
ball bounce walls and top. If ball falls below height+20: lives--; reset ball to paddle; if lives <=0 state gameover; else ready.
Bricks collision with ball:
this.physics.add.collider(ball, bricks, hitBrick, null, this)
hitBrick: if ball.body.touching.up/down then velocityY *= -1; if left/right velocityX *= -1. But after collision velocity maybe already inverted by arcade; we can just if touching.up/down invert y, if touching.left/right invert x. If neither, invert y maybe.
brick.tint? We can destroy. Score += 10. Add floating text.
Maybe brick health? breakable one hit.

Need restart: R key or click state text. Buttons? Could include UI in DOM? But no external. Use Phaser text.

Need maybe add particles? Use generated texture.

Need ensure generated textures not external.

Need maybe "wall of breakable bricks" with rows.

Need maybe use Phaser.Graphics API. Need generate background? Use this.add.graphics and draw.

Need maybe use only procedural graphics. Text is okay? It is rendered.

Need maybe use no network.

Need maybe "pre-provided phaser.min.js global Phaser" load with script src.

Need perhaps include fallback if Phaser undefined? But script order okay.

Need maybe code syntax correct.

Potential issue: Phaser 3 Sprite generated texture with body setCircle. For ball generated texture size 24x24, setCircle(10). Paddle generated texture 120x18.

Potential issue: this.physics.add.collider(ball, bricks, hitBrick, null, this) with ball as Sprite and bricks as group. Good.

Potential issue: Brick collision after destroying brick. We destroy inside callback. Need use brick.body.touching? It exists. But if destroy immediately, okay. Need get dx, dy before.

Potential issue: Ball speed gradually increases. Need normalize speed. Use Phaser.Math.Clamp? We can set speed every update? For playing, maintain speed. const speed = Phaser.Math.Clamp(ball.body.speed + 3, 280, 620); ball.body.setVelocity(ball.body.velocity.x, -ball.body.velocity.y) maybe. Better:
function keepBallSpeed(speed) { const v = ball.body.velocity; const len = Math.hypot(v.x, v.y)||1; ball.body.setVelocity(v.x/len*speed, v.y/len*speed);}
Call after bounces and update.

Need handle arrow keys in ready and playing.
Paddle movement:
const speed = 520;
if (cursors.left.isDown) paddle.x -= speed * delta/1000;
if (cursors.right.isDown) paddle.x += ...
if (mouse active? pointermove already sets. Could also pointerdrag.
Clamp paddle.x between paddle.width/2+10 and width - paddle.width/2-10.
If ready, ball.x = paddle.x; ball.y = paddle.y - ball height/2 - 5.
If playing and pointer? It might let user move paddle by mouse. Good.

Need launch:
function launchBall() { if (state === 'ready') { state='playing'; ball.body.setVelocity(160,-300); stateText.setText(''); } }
Need if gameover and key R or pointerdown restart.

Need buildBricks:
const rows=6, cols=10, gap=8, brickW=72, brickH=26, startX=(width - (cols*brickW + (cols-1)*gap))/2, startY=80.
colors array.
for each row col:
const brick = bricks.create(x,y,'brick');
brick.setTint(colors[row]);
brick.setData('points', 10 + row*5)
maybe if row < 2 set health=2? But wall breakable. Simpler one hit.

Need maybe create "unbreakable" wall? no.

Need score.
Need maybe high score from localStorage? That's not external but maybe okay. User didn't ask. Avoid localStorage? Fine maybe. But "no network requests" okay. Could use localStorage but no need.

Need maybe game area in DOM.
Need maybe "Click or press Space to launch. R to restart." Use Phaser text.

Need maybe if canvas focus? Arrow keys work globally after click? Phaser keyboard listens on window. Fine.

Need maybe include "Use mouse or arrow keys to move."

Potential issue with "generated textures" and "Phaser Graphics API" are in preload. Need use graphics.generateTexture('brick', brickW, brickH). Need not use image.

Need maybe use drawLine? Phaser Graphics has lineStyle/fillStyle.

Need maybe create rounded rect support? Phaser 3 Graphics.fillRoundedRect exists. Good.

Need maybe use this.add.graphics({ pixelPerfect: true })? Not needed.

Need maybe style ensures canvas not scroll. Use #game.

Need maybe maybe phaser.min.js is Phaser 2? Need check header maybe. Use grep?

Need maybe Phaser 3. Let's grep version.

Phaser 3.60. Good.

Need create index.html. Could use write. Need maybe include enough. Let's craft robust code.

Potential issue: `Phaser.Math.Clamp` exists. Need maybe `Phaser.Math.DegToRad`. Fine.
Potential issue: `this.physics.world.setBounds` good.
Potential issue: `this.add.graphics().fillGradientStyle`? Not needed.
Potential issue: `this.textures.exists` okay.
Potential issue: `this.input.addPointer` not needed.
Potential issue: `this.input.on('pointermove', (pointer) => { if (pointer.isDown) paddle.x = pointer.x; })` Maybe mouse movement should move even not down? User says arrow keys or mouse. Let's allow pointermove always: if pointer.x in bounds.
Potential issue: On touch, pointermove. Good.

Need maybe "Paddle arrow keys or mouse" implement both.

Need maybe "bouncing ball" with no external.

Need maybe "wall of breakable bricks with score" done.

Need maybe "playable" maybe need no external assets. Good.

Need maybe if no bricks, next level. Could implement level progression. Add next level. Good but not required. Could add level.

Need maybe "win" state. After bricks destroyed, state='levelComplete'; show "Level cleared! Press R/Click to restart." Could make next level? Simpler restart. But playable. Could add "Press N for next level"? Need maybe.

Need maybe include gameover.
Need maybe reset:
function startLevel(clearScore=false) {
score = clearScore ? 0 : score; lives = clearScore ? 3 : 3; level = clearScore ? 1 : level+1; state='ready'; bricks.clear(true,true); createBricks; updateTexts; resetBall();
}
But if game over, R restarts.
Maybe after level cleared, state='levelclear', then click/R starts next level with same score/lives? We can implement.

Need maybe "level" text.

Need maybe "score text" and "lives text".

Need maybe create UI overlay as Phaser Text.
Need maybe "hint text" bottom.

Need maybe if state ready and pointerdown on canvas launches; but if gameover pointerdown restarts. Good.

Need maybe "restartBtn"? No.

Need maybe "this.scale" for responsiveness? Could use config width height. CSS scales? If canvas CSS width 100%, height auto? But Phaser canvas has internal 960x640; CSS can make max-width 100%. Need maybe not distort. We can set canvas style? CSS `#game canvas { width: min(100vw, 960px); height: auto; }` But if parent is width 960, canvas width 960. On mobile, scale. Need maybe `this.scale.setGameSize`? Not necessary. CSS might cause pointer coordinates mismatch if canvas CSS scaled? Phaser input pointer coordinates are in game coordinates if using CSS? Phaser handles? It calculates based on canvas bounding rect. Fine.
Need maybe body center.

Need maybe "phaser.min.js" exact filename. Include script src="phaser.min.js".

Need maybe no external resources. Good.

Need maybe "procedurally generated graphics via Phaser Graphics API or generated textures" - we use generated textures. Need maybe no external image/audio. Good.

Need maybe "single-page web app" in index.html.

Need maybe if phaser script failed? Not required.

Need maybe maybe `fillRoundedRect` not in 3.60? It is. `strokeRoundedRect`? yes.

Need maybe generated texture functions:
function createPaddleTexture(scene) {
const g = scene.make.graphics({ x:0, y:0, add:false });
g.fillStyle(0xffffff, 1);
g.fillRoundedRect(0,0,120,18,9);
g.fillStyle(0x45f3ff,0.95); g.fillRoundedRect(4,3,112,12,7);
g.fillStyle(0xffffff,0.5); g.fillRect(18,5,40,3);
g.lineStyle(1,0xffffff,0.5); g.strokeRoundedRect(1,1,118,16,8);
g.generateTexture('paddle',120,18); g.destroy();
}
Need maybe `fillRect` no rounded. Fine.

Ball:
g.fillStyle(0x0b1026,1); g.fillCircle(12,12,12);
g.fillStyle(0xffffff,1); g.fillCircle(12,12,10);
g.fillStyle(0x7ffcff,0.9); g.fillCircle(9,9,5);
g.fillStyle(0x1e90ff,0.7); g.fillCircle(15,16,7);
g.lineStyle(2,0xffffff,0.8); g.strokeCircle(12,12,10);
generateTexture('ball',24,24)
Need maybe no gradient but okay.

Brick:
function createBrickTexture(scene, w,h) {
g.fillStyle(0x222222,1); g.fillRoundedRect(0,0,w,h,6);
g.fillStyle(0xffffff,0.15); g.fillRoundedRect(3,3,w-6,8,5);
g.fillStyle(0x111111,0.35); g.fillRect(0,h-6,w,6);
g.lineStyle(1,0xffffff,0.35); g.strokeRoundedRect(1,1,w-2,h-2,6);
generateTexture('brick',w,h)
}
Since tint later.

Particle texture:
g.fillStyle(0xffffff); g.fillCircle(4,4,4); generateTexture('spark',8,8)

Background:
this.add.rectangle(0,0,width,height,0x050713).setOrigin(0)
graphics draw stars maybe:
for i 0..100 random positions; fillStyle with alpha; fillCircle.
Could use this.add.graphics.
Need maybe `this.add.graphics()` not `this.add.graphics({})`. Fine.

Need maybe create "walls" invisible:
this.physics.world.setBounds(0,0,gameWidth,gameHeight);
ball collides with world bounds. But bottom boundary causes ball bounce from bottom, we don't want; we can not set bottom? Arcade setBounds with bottom = height+100? But for sides/top. We need ball bounce sides/top and not bottom. `setBounds(0, 0, width, height + 100)` so bottom below screen. But if ball below height+20, lives. Good. For paddle, clamp.

Need maybe top boundary at 0, ball bounces. Good.

Need maybe bricks can be hit from top? okay.

Need maybe create "walls" visual side lines maybe.

Need maybe create paddle body immovable? `paddle.body.setImmovable(true); paddle.body.allowGravity=false;` For arcade.
Ball: `ball.setCollideWorldBounds(true, false, true, false?)` Actually setCollideWorldBounds(true, false, true, false) with left, right, up, down? Let's recall `setCollideWorldBounds(enable, left, right, up, down)`. Could use `ball.body.setCollideWorldBounds(true, false, true, false, false)`? Hmm signature maybe `setCollideWorldBounds(value, left, right, up, down)`. To avoid bottom, `ball.setCollideWorldBounds(true, false, true, false, false)` maybe. But if setBounds bottom at height+100, bottom collision after falling. We can ignore.
Maybe better set world bounds bottom = height + 80 and ball body checks bottom? If setCollideWorldBounds true with all sides, it bounces off bottom at y=height+80, but lives reset before that. Fine.

Need maybe ball.body.onWorldBounds = true? Not needed.

Need maybe if ball falls below height+50. Good.

Need maybe "paddle collision" with ball:
this.physics.add.collider(ball, paddle, () => {
if (state !== 'playing') return;
const relative = (ball.x - paddle.x) / (paddle.width/2);
const angle = relative * (Math.PI/3); // ±60
const speed = Math.max(ball.body.speed, 360);
const vx = Math.sin(angle) * speed;
const vy = -Math.cos(angle) * speed;
ball.body.setVelocity(vx, vy);
addPaddleParticles();
});
Need maybe if ball hits bottom of paddle? Collision only if moving down. Good.
Need maybe no bounce if ball collides from side? okay.

Need maybe brick collision:
function hitBrick(ball, brick) {
if (state !== 'playing') return;
const wasTouching = brick.body.touching;
const touch = ball.body.touching;
if (touch.up || touch.down) ball.body.velocity.y *= -1;
else if (touch.left || touch.right) ball.body.velocity.x *= -1;
else {
const prevY = ball.body.prev.y; // maybe
const prevX = ball.body.prev.x;
if (Math.abs(prevY - brick.y) > Math.abs(prevX - brick.x)) ball.body.velocity.y *= -1; else ball.body.velocity.x *= -1;
}
score += brick.getData('points') || 10;
const color = brick.fillColor? no.
brick.destroy();
updateHud();
spawnBrickBurst(brick.x,brick.y,brick.getData('color'));
if (bricks.countActive(true) === 0) { levelClear(); }
keepBallSpeed();
}
Need maybe if brick destroyed after collision, okay.
Need maybe `brick.fillColor` not available? Could store color.
Need maybe `bricks.countActive(true)` after destroy? Good.

Need maybe spawnBrickBurst:
this.add.particles? ParticleEmitter requires texture. Use `this.add.particles(0,0,'spark',{ speed:{min:40,max:180}, lifespan:400, quantity:1, scale:{start:0.8,end:0}, tint:color, blendMode:'ADD' })` It uses generated texture. But maybe Phaser ParticleEmitter available. Good. Could create emitter each hit and set position then emit? Simpler:
const emitter = this.add.particles(x,y,'spark',{ speed:{min:30,max:160}, angle:{min:0,max:360}, lifespan:{min:250,max:500}, quantity:8, scale:{start:0.8,end:0}, blendMode:'ADD', tint:color });
this.time.delayedCall(600, () => emitter.destroy());
Need no external. Good.
But this may create many emitters. Fine.

Need maybe floating text:
const txt = this.add.text(x,y,'+'+points,{fontStyle:'bold', fontSize:'18px', color:'#ffffff'}).setOrigin(0.5);
this.tweens.add({ targets: txt, y:y-35, alpha:0, duration:650, onComplete:()=>txt.destroy()});
Need okay.

Need maybe create paddle particles on collision:
const emitter = this.add.particles(paddle.x, paddle.y-10, 'spark', { speed:{min:20,max:120}, angle:{min:180,max:360}, lifespan:250, quantity:3, scale:{start:0.5,end:0}, tint:0x66f7ff });
destroy after 350.

Need maybe "powerups"? Not required. Avoid complexity.

Need maybe "score" in top left.

Need maybe "lives" as hearts? Text with Unicode ♥? Is that okay? It uses font; no external. Could use "Lives: 3". Fine.

Need maybe "high score" optional. Avoid localStorage.

Need maybe "wall of breakable bricks" maybe 60 bricks.

Need maybe "wall" maybe no side walls. Good.

Need maybe "game container" with header? User asked app. Could include title above canvas. But all self-contained. Good.

Need maybe if browser doesn't support WebGL, Phaser.AUTO uses WebGL then Canvas fallback. Good.

Need maybe maybe "phaser.min.js" should be loaded before script. Good.

Need maybe `this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.R)` and Space. Use `this.input.keyboard.on('keydown-SPACE', launchBall); this.input.keyboard.on('keydown-R', restartGame);` Good.
Need maybe if pointerdown launches and then also restarts if gameover. Good.

Need maybe "mouse movement" pointermove:
this.input.on('pointermove', pointer => {
if (pointer.x > 0 && pointer.x < gameWidth) movePaddleTo(pointer.x);
});
this.input.on('pointerdown', pointer => {
if (pointer.x > 0 && pointer.x < gameWidth) movePaddleTo(pointer.x);
if (state === 'ready') launchBall(); else if (state !== 'playing') restartGame();
});
Need if pointerdown on gameover resets. Good.
Need maybe if pointerdown during playing doesn't launch. Fine.
Need maybe if pointermove while gameover moves paddle? okay.

Need maybe `stateText` text. `hintText`.
Need maybe `stateText` maybe at top center.

Need maybe `this.cameras.main.setBackgroundColor('#050713')` config.

Need maybe "brick generation" use `this.add.graphics`? Already.

Need maybe "Generated textures" in preload. Need maybe after generate textures, create scene.

Potential issue: In Phaser 3, `this.make.graphics({ x:0, y:0, add:false })` returns `Phaser.GameObjects.Graphics` with `generateTexture(key, width, height)`. Good.
Potential issue: `this.add.particles` is `this.add.particles(x,y,texture,config)`. In Phaser 3.60 yes.
Potential issue: `this.tweens.add` etc.

Need maybe if `this.input.keyboard` null? Phaser config has input keyboard default true. Good.

Need maybe "score" update after hit.
Need maybe "level" update.

Need maybe if all bricks destroyed:
function levelCleared() {
state = 'levelclear';
ball.body.setVelocity(0,0);
stateText.setText(`Level ${level} cleared!`);
hintText.setText('Click or press R for the next level.');
this.time.delayedCall(600, () => {});
}
Then `startNextLevel`:
function startNextLevel() {
level++;
bricks.clear(true,true);
createBricks();
state='ready';
resetBall();
updateHud();
stateText.setText('');
hintText.setText('Click or press Space to launch.');
}
Need maybe if gameover R restarts from level 1 score 0 lives 3. If levelclear R goes next. Need distinguish.
Maybe implement `restartGame()` resets level=1, score=0, lives=3, buildBricks, state='ready'. `nextLevel()` increments level, buildBricks.
On pointerdown:
if state === 'ready' launch
else if state === 'levelclear' nextLevel()
else if state === 'gameover' restartGame()
This is okay.
Need maybe `keydown-R` always restartGame, but if levelclear maybe next? User expects restart. Could use R restart. Maybe if levelclear R should next level? Fine. But "R restart" maybe. We can set R restarts whole game. N next level maybe. Simpler: if levelclear, R starts next level? Hmm.

Need maybe "gameover" if lives 0:
state='gameover'; ball.setActive(false)? Maybe keep visible. stateText "Game Over"; hintText "Press R or click to restart".
Need maybe if ball falls and lives=0, resetBall? It may continue falling; stop.
function loseLife() {
lives--;
updateHud();
if (lives <= 0) { state='gameover'; ball.body.setVelocity(0,0); stateText...; hintText...; }
else { state='ready'; resetBall(); stateText.setText('Ready?'); hintText...; }
}
Need maybe after reset ball, ball visible at paddle. Good.

Need maybe if levelclear, ball stops. Good.

Need maybe if state ready and arrow keys move paddle. Good.

Need maybe if state playing and arrow keys move. Good.

Need maybe if state playing and pointerdown? no launch. Good.

Need maybe if pointermove always moves paddle, even during ready. Good.

Need maybe if arrow keys and mouse both: pointermove overrides. Fine.

Need maybe if keyboard left/right in update:
const deltaSeconds = delta / 1000;
if (cursors.left.isDown) paddle.x -= 520*deltaSeconds; ...
movePaddleTo(paddle.x)
Need maybe if pointermove in update? no.

Need maybe `this.physics.add.existing(paddle); paddle.body.setImmovable(true); paddle.body.allowGravity = false;` For Sprite with physics enabled? `this.physics.add.sprite` simpler.

Need maybe `ball.setCircle(10,2,2); ball.body.setBounce(1); ball.body.setCollideWorldBounds(true);` If bottom at height+100, okay.
Need maybe `ball.body.setSize(20,20)`? setCircle.

Need maybe `ball.setDrag(0);`
Need maybe `ball.body.setAllowGravity(false);`
Need maybe `ball.body.setMass(1);`
Need maybe `ball.body.setCircle(10);`
Need maybe `ball.setDepth(5); bricks depth 4; paddle depth 6; UI depth 20.
Need maybe `paddle.body.setAllowGravity(false);`

Need maybe "score" maybe 10/15/20 per row. Good.

Need maybe "score" text with shadows. Good.

Need maybe "title" inside canvas maybe.

Need maybe "wall of breakable bricks" maybe create rows with colors. Good.

Need maybe "breakable bricks" one-hit. Good.

Need maybe "generated textures" no external.

Need maybe "procedurally generated graphics via Phaser Graphics API" The generated textures are created with Graphics. Good.

Need maybe "no external image/audio assets" no audio.

Need maybe "current directory" /tmp/ws. Write index.html there.

Need maybe after write maybe read file to verify.

Need verify maybe syntax. Could use node? Browser JS has Phaser undefined if run node. Could use maybe grep. Need maybe read. Also maybe potential issue `this.physics.add.group({ classType: Phaser.Physics.Arcade.Image, allowGravity: false });` Is `allowGravity` group property? Group config accepts `classType`, `runChildUpdate`, `createIfNull`, but allowGravity maybe not. It might ignore. Fine.
Potential issue: `this.make.graphics` in preload: `make` can create graphics? yes.
Potential issue: `g.generateTexture('paddle', 120, 18)` with graphics at 0,0. Good.
Potential issue: `this.add.particles` might require texture exists and not destroyed. Good.
Potential issue: `Phaser.Math.FloatBetween` exists in 3.60? yes.
Potential issue: `this.input.keyboard.createCursorKeys()` if keyboard disabled? no.
Potential issue: `this.physics.add.collider(this.ball, this.paddle, this.hitPaddle, null, this);` In Phaser, callback signature is (object1, object2). For Sprite vs Sprite, yes.
Potential issue: `this.physics.add.collider(this.ball, this.bricks, this.hitBrick, null, this);` For Sprite vs Group, yes.
Potential issue: `ball.body.prev.x`? Arcade Body has `prev` maybe? Need check. Phaser 3.60 Arcade Body has `prev`? I think yes: `body.prev` Vector2. If not, undefined causing error. Need verify maybe. Could avoid using `body.prev` to be safe. We can compute collision side based on brick position and ball position before? Since callback after collision. We can use `ball.body.touching` mostly. Else branch can just invert y. No need prev. Use simpler to avoid unknown. Need edit.
Potential issue: `this.bricks.countActive(true)` after brick.destroy. Does `destroy()` remove from group and active false. Good.
Potential issue: `this.bricks.clear(true,true)` maybe destroys children. Good.
Potential issue: `this.paddle.width` after texture generated. Good.

Need maybe maybe `this.make.graphics({ x: 0, y: 0, add: false });` in preload: `this.make` exists? Phaser Scene has make. Yes.
Potential issue: `this.add.particles` with `quantity: 4` and no `frequency`; In Phaser 3, ParticleEmitter config quantity is number emitted per burst when `emit` called? If not auto emit? Hmm. In Phaser 3.60, `this.add.particles(x,y,'spark', config)` creates emitter with `emitCallback`? Need recall. For ParticleEmitter, `quantity` default 50, `frequency` 0 means emit all at once at start? Actually if `frequency` 0, emits once on start. Yes.
Potential issue: `this.add.particles` returns ParticleEmitter or ParticleEmitterManager? In Phaser 3, `add.particles` creates a ParticleEmitter with default manager. Good.
Potential issue: `this.time.delayedCall` destroys emitter. Good.

Need maybe inspect with maybe `node --check` impossible because Phaser undefined but syntax okay. Use `node --check index.html` no. Could extract script? We can use `python`? But not necessary. Could use `grep`? Maybe.

Need maybe run a small static check by extracting JS and using node? Since uses Phaser global but node --check doesn't execute? `node --check file.js` checks syntax only. Need extract script content. Could use python to parse? Maybe no python? likely. We can use perl. But no need. Let's use `node --check` with JS extracted to temp.

No python. Use awk/sed. Need maybe not necessary but can.

Need maybe remove check.js? It is extra file in current dir? We created /tmp/ws/check.js. User asked end with index.html present, maybe extra check.js not desired. Remove.

Need maybe inspect file around potential issue. Use read.

Read enough. Need maybe edit prev. Also maybe issue with `this.input.keyboard.createCursorKeys()` if keyboard not enabled? ok.

Need maybe think about Phaser 3.60 `this.physics.add.group({ classType: Phaser.Physics.Arcade.Image, allowGravity: false });` Does group config pass `allowGravity` to children? I think GroupConfig has `runChildUpdate`, `classType`, `createIfNull`, `addToWorld`, `key`, `texture`, `frame`, `visible`, `active`, `name`. It doesn't include allowGravity. But setting classType Image, images created with physics? `physics.add.group` creates physics enabled group with `classType` default Sprite? In Arcade World, `addGroup` creates `Phaser.Physics.Arcade.Group`, which by default classType `Phaser.Physics.Arcade.Image` maybe. The config `allowGravity: false` might be ignored. Not harmful.
Potential issue: `this.bricks.create(x, y, 'brick')` for physics group with classType Arcade.Image, okay.

Need maybe maybe `this.make.graphics` in preload before texture manager? yes.

Need maybe maybe `this.add.particles` uses texture 'spark' and no manager? okay.

Potential issue: if all bricks destroyed, `hitBrick` destroys brick while collision callback still running. Then `this.bricks.countActive(true)` after. Good.

Potential issue: `this.stateText.setText('Ready')` when lose life. It remains "Ready" while ball follows paddle. Good.

Potential issue: if restart during gameover, stateText empty. Good.

Potential issue: if R during ready resets game, maybe okay. If R during playing restarts. Good.

Potential issue: pointerdown on levelclear starts next level, but R also restartGame resets game, because keydown-R doesn't special-case levelclear. Actually `restartGame()` resets level 1 score 0. Hint says R for next level but R restarts. In pointerdown levelclear starts next. In keydown-R, restarts. Minor inconsistency. We can either change hint to "Click for next level · R restarts" or implement keydown-R if levelclear startNextLevel. Better: if state levelclear and R starts next? But help says R restarts. Hmm. Could change keydown-R to:
if (this.state === 'levelclear') this.startNextLevel(); else this.restartGame();
Then hint accurate. But R normally restarts; maybe if levelclear next. Fine. Need edit. Also topbar says R restarts; not necessarily next. Could leave. But maybe "R restarts" okay. If user presses R on level clear, restarts, but hint says next. Inconsistent. Let's edit keydown-R to handle levelclear next. Topbar maybe "R restarts/continues". But okay. Need maybe use edit.

Potential issue: `spawnFloatingText` in loseLife when gameover at ball.y maybe below screen. okay.

Potential issue: `this.keepBallSpeed` called every update, after bounce. But if ball hits bottom and loseLife, state ready, then keep not. okay.

Potential issue: `this.ball.body.setCollideWorldBounds(true)` with bounds bottom height+120. If ball goes below height+80, loseLife. But if bottom collision occurs before y>height+80? Bounds bottom = height+120, ball center at >720. lose at >720. It will trigger same update maybe before collision? Fine. It might collide at 720 and invert, but we set state ready and velocity 0. okay.

Potential issue: `ball.body.setCollideWorldBounds(true)` and bottom at height+120, if ball velocity -400 and crosses to 730, lose before bounce. Good.

Potential issue: if `this.paddle.body.setCollideWorldBounds(true)` with width 120, okay.

Need maybe maybe if pointermove outside but x negative? no.

Need maybe no external resources. Good.

Need maybe maybe `Inter` font in CSS is external? CSS font-family references Inter but doesn't load it. Browser uses fallback. Fine.
Need maybe maybe emoji in help (·) no external.
Need maybe maybe `color: '#' + color.toString(16).padStart(6, '0')`: `color` from brick data is number. Good.
Need maybe if `color.toString(16)` returns e.g. "ff4d6d". padStart supported. Good.

Need maybe maybe `this.physics.add.collider(this.ball, this.bricks, this.hitBrick, null, this);` In Phaser, callback processCallback signature for sprite vs group is (object1, object2). Good.

Need maybe edit prev branch and R.

Need syntax check again.

Need maybe maybe run with some headless browser? Not available maybe. Could use playwright? Not needed. But maybe can test if phaser loads? We can use node with jsdom? no. Could maybe use `npm`? Not needed.

Need maybe final concise. But maybe before final check ls.