Build a Mario-style platformer with Phaser 3 and procedurally-generated textures (Graphics → generateTexture). Single index.html. Let's write a complete game: player physics, platforms, enemies (Goombas), coins, goal flag, camera scrolling, score/lives HUD, restart.

First check whether phaser.min.js exists, then write the file.

Design:
- Create textures with Graphics: player (simple character), enemy, coin, ground tile, brick, flag, cloud, hill backgrounds.
- Level defined as tilemap strings or arrays.
- Phaser arcade physics: static bodies for platforms, enemies patrol, stomping detection, overlap for coin collection, flag for victory.
- Controls: arrows/WASD + space to jump.
- Camera follows the player.
- HUD: coins, score, lives, timer (maybe).
- Death → lose a life and respawn; game over screen; victory screen; R key to restart.

Write everything in one file. Keep it robust. Alright, let's write it.

Level layout: use a tilemap string with characters: '#' ground, 'B' brick, '?' coin block (maybe) — simpler: 'C' coin, 'E' enemy, 'P' player start position, 'F' flag, '=' platform. Build the level from the string grid, TILE size 32.

Physics: gravity ~2000. Player speed 220, jump velocity -700. Enemies walk, reverse direction at walls/edges (edge detection via tile check, or just reverse at walls; use body.blocked).

Stomping: player overlap with enemy; if player body is falling (velocity.y>0) and player's bottom is above enemy's center → destroy enemy, bounce.

Coins: overlap → collect, +100.

Flag: overlap → victory state.

Death: fall off the bottom of the world, or hit by enemy from the side → lose life, respawn.

Add particles? Simple: score popups can probably be skipped. Background: parallax clouds/hills via tileSprite or scrollFactor.

Phaser version: global Phaser from phaser.min.js. Use Phaser.Game with scene.

Let's carefully write the code.

Texture generation:
- 'player': 24x30 red cap, blue overalls, skin-colored face.
- 'enemy': 28x24 brown mushroom-like blob with eyes.
- 'coin': 20x20 yellow circle with shine, maybe use animation frames — generate 4 frames with different widths for rotation.
- 'ground': 32x32 brown with grass on top.
- 'brick': 32x32 brick pattern.
- 'block': question block? Maybe add '?' blocks that spit out coins when hit from below — nice but optional. Keep it: '?' block gives coin once when hit from below. Adds fun. Implement: block is static; in physics world overlap, or check for player's head collision: use body.blocked.up and check the tile above. Simpler: when player is blocked.up, find qblocks overlapping above player's head. Loop through qblock group and check distance.

- 'flag': pole + flag: make pole tile and flag sprite.
- 'cloud', 'hill', 'bush' for background.

Coin animation: 4 textures coin0..coin3 with different ellipse widths.

Scene structure: Boot scene generates textures, Game scene.

HUD: score text, coins, lives, fixed to camera.

Camera: startFollow, setBounds. World bounds from level width.

Timer probably skipped; keep it simple with score/lives/coins.

Let's write the level map as an array of strings, each row same length. Height ~15 rows, width ~200 columns.

Let's design the level (15 rows, index 0 at top). Tile 32px, game 960x540. Rows: 540/32 ≈ 16.9, use 17 rows; ground is rows 14-16.

Legend:
- 'X' ground block (grass top on row 14, dirt below)
- 'B' brick
- '?' qblock
- 'C' coin
- 'E' enemy spawn
- 'P' player start
- 'F' flag base position (pole is from there upward)
- 'G' goal flag (place pole tiles)
- '.' empty

Let me write ~220 columns of rows. Write it programmatically but hand-design it. Actually easier: build the rows via code as strings; hand-craft it. To avoid errors, make a helper: pad rows to equal length.

Let me write rows (17 rows). Write with gaps: ground with gaps (holes), bricks/coin platform rows, floating coin arcs, enemies on ground.

Craft it carefully but not too long (~200 chars per row). Write the string.

Row indices 0..16. Ground rows: 14, 15, 16 = 'X'. Holes: omit X at some columns.

Plan column ranges:
- 0-15: flat start, P at column 2 row 13.
- 16-19: '?B?B?' structure at row 10, coins above.
- Enemy around col 20.
- 24-27: hole (gap in ground).
- 28-35: ground, brick platform at row 10 col 30-33 with coins.
- Enemy at 32.
- 36-38: hole, with floating platform 'B' at row 12 col 37? Let's have 'B' bricks at row 12 spanning 36-38.
- 40-55 ground; stairs up: X step pyramid at 46-49 (heights 1,2,3,4); enemy at 43, 52. Coins.
- 56-58 hole.
- 59-75: ground; qblock at row 10 col 62; bricks at row 7 col 65-67, coins above; enemies 63, 70.
- 76-78 hole with platform at row 11.
- 80-100: ground; arc of coins; enemies at 85, 88, 92.
- Stairs at 95-99.
- 100-102 hole.
- 103-120: ground, brick platforms at row 9 and row 6 with coins, enemies 108, 114.
- 121-124 hole with stepping platforms at row 12, row 10.
- 125-145 ground; enemies 128,132,136; pyramid stairs 140-143.
- 146-148 hole.
- 150-200: flat home stretch, enemies 155, 160; flag at col 170: pole rows 4-13 col 170 ('F' marker to place pole), flag sprite. Castle? Skip, or a simple castle decoration maybe.
- Level width 210, with wall at end.

Hand-writing the exact strings for 17 rows × 210 columns is error-prone but doable if we build it by segments. Alternative: build the level in code: a function addGround(c0,c1), addBrick(c,r), etc. Cleaner and less error-prone. Let's go with programmatic level construction.

Implementation:

```js
const T=32, ROWS=17, LEVEL_W=210;
const solids = []; // {c,r,type}
function ground(c0,c1){ for(let c=c0;c<=c1;c++){ for(let r=14;r<=16;r++) setTile(c,r,'X'); } }
function tile(c,r,t){ map[r][c]=t; }
```

Use a 2D array of characters, then iterate to create static sprites.

Enemy group: spawn at specified columns on ground row 13 (y = 13*32 + 16).

Code plan:

Game scene create():
- Generate textures in init/boot (either call createTextures() in preload, or with graphics inside create before adding; do it in a Boot scene's create, then start Game).
- Build map, create static layer via individual images? For performance, use one static group with 32px images — a few hundred sprites; fine. Use Phaser.Physics.Arcade.StaticGroup with 'ground'/'brick'/'qblock' keys.
- Coins: physics group with bodies setAllowGravity false, static? Use static group for coins with overlap.
- Enemies: physics group, each velocity.x = -60; collides with solids; reverse direction on blocked.
- Player: sprite, body 20x28, maxVelocity, drag.
- Camera bounds, world bounds.
- Background: tileSprite sky gradient as camera bg? Add clouds with scrollFactor 0.3, hills with scrollFactor 0.6, generated textures, placed repeatedly.
- Input cursors + WASD + space.
- HUD text with setScrollFactor(0).

update():
- Player controls; flip sprite; jump with coyote/buffer optional — keep simple but allow a bit of jump buffering.
- Enemy patrol: if body.blocked.left/right reverse; also if touching world edge.
- Colliders: player vs solids, enemies vs solids, player vs enemies (stomp check), player vs coins, player vs qblocks handled via blocked.up: when player.body.blocked.up, loop qblocks for blocks whose x within player x± and bottom near block top... Actually blocked.up occurs on collision; easier: in update, if player.body.blocked.up, loop qblock group and find ones whose x is within player x ± and bottom near block top. Hit: change texture to 'usedblock', add 200 score, spawn floating coin text.
- Fall death: player.y > ROWS*32 + 100.
- Flag overlap → victory.
- Camera follow with look-ahead? Just follow.

Death handling: lives--, if >0 respawn (reset position, reset enemies? just reset player pos and velocity), else game over overlay. Restart via R key or click button → scene.restart().

Victory overlay with score, R to restart.

Extra juice: squash scale on player on landing, spinning coin animation, enemy stomp → flatten then destroy, score popup text.

Sound: no audio assets; could use WebAudio oscillator beeps — allowed (procedural, no assets). Add a small helper with AudioContext for jump/coin/stomp sounds. Wrap in try/catch. Good.

Let's write it.

Coin animation frames: generate 'coin0'..'coin3': ellipse widths 20, 14, 6, 14.

Textures via this.make.graphics({add:false}) then generateTexture.

Player texture draw (26x30):
- Red cap: top rectangle
- Skin face
- Blue overalls body
- Boots.

Enemy (28x26): brown dome, darker feet, white eyes.

Ground tile: fill #8a5a2b, top strip grass #3faa43, dark speckles, border.

Brick: #b5651d with dark lines.

qblock: yellow with '?' text? Graphics text not easy; draw '?' as shapes, or use fillText? Graphics doesn't do text. Use this.add.text separately? For texture, draw '?' via lines/arc — approximated with a circle + tail rectangle + dot. Or simpler: draw a rounded square with 4 dots rivets and a white square in middle? Draw a '?' style: arc (partial circle) + vertical stub + dot. graphics.arc exists. Use graphics.arc(x,y,r,start,end) then strokePath. Good enough.

Used block: brown, dull.

Flag: pole = thin grey tile of height 10; flag texture: green triangle. Build pole as multiple small images, or one tall generated texture (12 wide, 320 tall) — generateTexture supports any size.

Cloud: white blob, ellipse.
Hill: green triangle-ish, use fillTriangle with big size.
Bush: few green circles.

Sky: gradient background via graphics 2x540 generated as 'sky' texture with gradient fill? Graphics supports gradientFill? fillGradientStyle exists. Use that: g.fillGradientStyle(top, top, bottom, bottom). Generate a 4x540 texture, add image at fixed position with scrollFactor 0, displayWidth = width. Or set scene backgroundColor and skip gradient; but gradient is nicer. Use camera.setBackgroundColor? Simpler: add sky image with scrollFactor 0, sized to game, fixed. Camera moves but scrollFactor 0 keeps it fixed. Good.

Parallax clouds: create images at random positions in world with scrollFactor 0.4; but fixed with scrollFactor <1 so positions scale; place them covering range 0..worldWidth*0.4. Fine.

OK now let's write the whole thing. Also handle pause? Skip.

Death respawn: also respawn enemies? Classic: reset level. Reposition enemies to initial positions and coins stay collected? Simpler: save enemies initial positions and reset. Keep it: store spawn data and reset function that repositions enemies (revives destroyed ones? enemies removed from group via destroy). Alternative: recreate group on respawn. Structure Game scene with buildLevel() that clears groups and rebuilds, called on start and respawn (death resets coins too? Mario keeps coins). Simplify: on death, rebuild everything but keep score/coins/lives. On full restart (R) reset score.

So scene.create: reset score/coins/lives, then buildWorld(). die() → lives--; if lives>0 rebuildWorld() else showGameOver.

buildWorld(): destroy existing groups if any, rebuild tiles/coins/enemies/flag/player position.

HUD updated via function.

Let's now write out code fully, watching Phaser API:

- this.physics.add.staticGroup? Use this.physics.add.staticGroup({classType: Phaser.Physics.Arcade.Sprite}) — easier: create group `this.solids = this.physics.add.staticGroup();` then `this.solids.create(x,y,'ground')`. Static body size = texture size. Good.

- Coins: staticGroup too, with animation 'spin'.

- Enemies: this.physics.add.group({allowGravity:true}) with create, body.setSize probably not needed.

- Player: this.physics.add.sprite.

Collisions:
```
this.physics.add.collider(this.player, this.solids);
this.physics.add.collider(this.enemies, this.solids);
this.physics.add.collider(this.enemies, this.enemies); // optional
this.physics.add.overlap(this.player, this.coins, collectCoin);
this.physics.add.overlap(this.player, this.enemies, hitEnemy);
this.physics.add.overlap(this.player, this.flagZone, winGame);
```
Flag zone: invisible sprite with body.

hitEnemy(player, enemy):
```
if (player.body.velocity.y > 100 && player.body.bottom - enemy.body.top < 20) stomp
else die();
```
Better: player.body.touching.down? Standard check: player.body.velocity.y > 0 && player.body.y + player.body.height - enemy.body.y < 16.

Stomp: disable enemy body, setScale y to 0.4, tween alpha, destroy after 300ms; player.body.velocity.y = -350 bounce; score += 100; popup.

qblock hit: in update after physics step:
```
if (this.player.body.blocked.up) {
  for (const b of this.qblocks.getChildren()) {
    if (!b.getData('used') && Math.abs(b.x - player.x) < 24 && (player.body.top - b.body.bottom) < 6 && player.body.top - b.body.bottom > -10) hit
  }
}
```
Hmm, blocked.up means player's top touches block bottom. Condition: b.body.bottom ≈ player.body.top, and horizontal overlap. b.y - block is above player so player.body.top <= b.body.bottom. Check: Math.abs((b.body.bottom) - player.body.top) < 8 and horizontal overlap. Then set used, change texture to 'usedblock', spawn coin pop animation + score 200, coins++.

Also allow hitting brick from below? Skip, or small bump animation. Skip.

Enemy edge turn: just turn at walls; place enemies carefully so they stay on platforms; if falling edge, let them fall into hole and die (destroy if y > world). Also reverse randomly? Fine.

Timer: add elapsed time? Skip.

Camera: this.cameras.main.setBounds(0,0,W,H*...); startFollow(player, true, 0.1, 0.1); setDeadzone(200,100)?

Player physics numbers: gravity 1800, jump -650, move speed 240, accel 1200, drag 1000, maxVel y 1000.

Variable jump: release jump → if velocity.y < -200, set to -200. Nice feel.

Input: cursors, keys WASD, space/up/W = jump.

Jump only when on ground (body.blocked.down or touching.down).

Death: falling y > 17*32+64 → die (no stomp).

Flag: pole at column FC; flag zone around pole. On win: freeze controls, player walks? Simple: show overlay text "COURSE CLEAR!", score bonus +1000, R to restart.

HUD: top-left "SCORE 000000", "COINS ×NN", "LIVES ×N". Retro font via CSS font family monospace.

Add title/instructions overlay at start: "Press any key / arrow to start"? Just show instruction text at bottom: "←→/AD move  SPACE/↑ jump  R restart".

Sound: simple beep function:
```js
let actx;
function beep(freq, dur=0.08, type='square', vol=0.04, slide=0){
  try{
    actx = actx || new (window.AudioContext||window.webkitAudioContext)();
    const o=actx.createOscillator(), g=actx.createGain();
    o.type=type;o.frequency.value=freq;
    if(slide) o.frequency.linearRampToValueAtTime(freq+slide, actx.currentTime+dur);
    g.gain.value=vol; g.gain.exponentialRampToValueAtTime(0.0001, actx.currentTime+dur);
    o.connect(g).connect(actx.destination);
    o.start(); o.stop(actx.currentTime+dur);
  }catch(e){}
}
```
AudioContext needs user gesture; create on first keydown. Fine.

Now write the whole file. Let's also make the level build list:

```js
const T=32, ROWS=17, GROUND=14, LEVEL_W=214;
let grid;
function setT(c,r,ch){ if(c>=0&&c<LEVEL_W&&r>=0&&r<ROWS) grid[r][c]=ch; }
function fillRow(c0,c1,r,ch){for(let c=c0;c<=c1;c++)setT(c,r,ch);}
function ground(c0,c1){fillRow(c0,c1,14,'X');fillRow(c0,c1,15,'X');fillRow(c0,c1,16,'X');}
function stairs(c,h,dir){ // pyramid steps of dir asc
}
```

Level plan (columns):
- ground(0,25)
- P at (2,12)
- qblock row: '?' at (16,10), 'B' at (17,10), '?' at (18,10), 'B' at (19,10), '?' at (20,10); coins above at row 8? maybe no coins above. Add coin at (18,7).
- Enemy 22.
- ground(29,55) → hole 26-28 (3-wide).
- Bricks row 10 cols 32-35 'BBBB', coins row 7 cols 32-35? Coins at (33,7), (34,7).
- '?' at (37,10).
- Enemies 34, 40.
- Pyramid stairs up at 46-49: heights 1..4: set X above ground: col 46 row 13; col 47 rows 12-13; col 48 rows 11-13; col 49 rows 10-13.
- Hole 56-58. ground(59,84).
- '?' at (61,10); bricks at row 7 (64-67): 'BBBB'; coins above at row 5 (64-67)? Coins at row 4? Reachable from bricks (row 7, standing on top of row 6). Jump height ~3-4 tiles. Coin at (65,4), (66,4)? Hmm, let's place at row 4 above bricks: coin y row 4. ok coins (64,4), (65,4), (66,4), (67,4).
- Enemies 63, 69, 74.
- Platform: 'B' at (77-79, row 11)? Hole 85-88. Let's do: ground(59,84); hole 85-88, 4-wide; floating bricks row 12 at cols 86-87. ground(89,118).
- Coin arc over hole: (85,10), (86,9), (87,9), (88,10).
- Enemies 93, 97, 101.
- qblocks at (95,10), (97,10)? Add '?' at 95 r10, 'B' at 96 r10, '?' at 97 r10.
- Pyramid at 106-109 heights 4..1 (descending)? Stairs up then gap: col 106 rows 10-13, 107 11-13, ... Let's do descending: heights 4,3,2,1.
- Hole 119-122; platforms at row 11 col 120, row 12? Use 'B': (120,11), (121,12)? Just single brick at (120,12) and (121,10)? Keep one platform at (120,12), (121,12).
- ground(123,150).
- Brick platforms: row 10 126-128, row 7 131-133, coins above each.
- Enemies 127, 135, 140, 143 (a bunch).
- Big stairs at 145-148: heights 1..4 ascending; then hole 149-151; ground(152,213).
- After hole, descending stairs 152-155 heights 4..1? Classic. ok.
- Enemies 160, 164.
- Coin row at (166-170, r10)?? Coins at row 10, 166-170? Place 5 coins in a row at row 11.
- Flag at col 180: pole rows 4..13, base 'X' at (180,13)? Ground is from row 14; put a block base at row 13: setT(180,13,'B')? Flag marker 'F' = pole. Set pole at col 180 rows 4-12 with 'F', base at (180,13) with 'X'. Flag sprite attached at row 5.
- End wall: col 190-194 castle decoration (drawn as bricks?): build a small castle with 'B' at rows 11-13 cols 190-194 and top 12-13? Just make a simple brick structure with a decorative image; simpler: brick tiles at rows 12-13 cols 190-194, rows 10-11 cols 191-193, row 9 cols 192. And 'X' wall at end col 208-213? Just level bound.

Level width 214 → world 6848 px.

Coins placed: define list as we go via setT(c,r,'C').

Coin list: (18,7); (33,7), (34,7); (32,10)? no, bricks at 32-35 r10, coins above at row 7: (32,7),(33,7),(34,7),(35,7)? standing on bricks (top r10, stand on r9) jump to reach r7 coin ok.
(64,4)..(67,4).
Arc (85,10), (86,9), (87,9), (88,10).
(95,7), (97,7)? above qblocks.
(126,7), (127,7), (128,7)? above bricks row 10: coins at r7. Hmm, stand on bricks at r10 (feet at r9, head at r8) so coin at r7 reachable.
(131,4), (132,4), (133,4) above bricks r7.
Row (166..170, 11).
(146,8)? coins above staircase tops: (148,8).
Total ~30 coins.

Enemy spawn list: cols on ground: y = 13*T+? Enemy is 26 tall; spawn at y = GROUND*T - 13 (center), so feet on ground: y = 14*32 - 13 = 435. Just spawn at (c*T+16, 13*T+16) and let gravity settle. Fine.

Flag zone at (180*T, rows 4..13): create invisible sprite at x=180*T+16, y from 4*T to 14*T, width 24, height 10*T.

Now write everything. Watch out: static group's create returns sprite; set body immovable (statics are immovable by default).

Enemies collide with solids; enemies also collide with each other so they reverse: on collision both reverse. Use collider enemies-enemies and enemies-solids, check blocked each frame in update.

Enemy update:
```
enemies.children.each(e => {
 if(e.getData('dead'))return;
 if(e.body.blocked.left || e.body.blocked.right) e.setVelocityX(-Math.sign(e.body.velocity.x)*60 || 60);
 else if(!e.body.velocity.x) e.setVelocityX(e.getData('dir')*60);
 if(e.y > ROWS*T+100) e.destroy();
});
```
Simpler: keep dir data; on blocked, dir*=-1, save, setVelocityX(dir*60).

Also initial direction -1 (walk left toward player).

Player animation: just flipX and slight rotation on jump? Add squash/stretch via scale tween on jump/land.

Coin collect: coin.disableBody, popup "+100", score, coins++, beep.

Respawn on death: implement resetWorld() that rebuilds everything (also recreate player). Structure Game scene with buildLevel() that clears groups and rebuilds, called on start and respawn.

buildWorld(): destroy existing groups if any, rebuild.

HUD updated via function.

Text style: fontFamily 'Courier New', bold, with shadow.

Overlay states: use this.state = 'play' | 'dead' | 'over' | 'win'. When not play, ignore inputs (maybe except R).

Restart key R: full scene restart via this.scene.restart().

Now let's write the file. Watch for template literals inside — fine.

One concern: Phaser staticGroup with generateTexture keys — ok.

Cloud placement: create N clouds with scrollFactor 0.35: x in 0..LEVEL_W*T*0.35+960, y 40..180. Hills scrollFactor 0.6, on ground line: y = 14*T, origin bottom. Bush scrollFactor 0.8.

Sky image scrollFactor 0, 960x540.

Draw order: sky, hills, clouds, bushes, then solids etc.

Now let's write the code.

Also handle window blur pause? Skip.

Let's write index.html.

Edge case: on flag, winGame sets state 'win', show overlay text, bonus score, play. Player stops moving (set velocity 0), slide down pole maybe? Keep simple: freeze.

Game over: overlay + "Press R".

Also display coin count and lives on HUD with icons? Text is fine.

Time bonus? Skip.

Code:

```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Super Pixel Bros</title>
<style>
html,body{margin:0;padding:0;background:#111;height:100%;overflow:hidden}
#game{display:flex;align-items:center;justify-content:center;height:100%}
canvas{image-rendering:pixelated}
</style>
</head>
<body>
<div id="game"></div>
<script src="phaser.min.js"></script>
<script>
...
</script>
</body>
</html>
```

Scale: Phaser.Scale.FIT, autoCenter, width 960 height 540.

Write the full JS. Physics config: arcade gravity y 1800? Set per-scene with this.physics.world.gravity.y=1800.

Texture generation details:

```js
function makeTextures(scene){
 let g = scene.make.graphics({add:false});
 // ground
 g.clear();
 g.fillStyle(0x9c5a24); g.fillRect(0,0,32,32);
 g.fillStyle(0x7a4418); g.fillRect(2,10,8,6); g.fillRect(18,18,10,6); g.fillRect(10,24,6,5);
 g.fillStyle(0x46c94d); g.fillRect(0,0,32,7);
 g.fillStyle(0x2f9e3a); g.fillRect(0,5,32,3); // edge
 g.lineStyle(1,0x5e3413); g.strokeRect(0,0,32,32);
 g.generateTexture('ground',32,32);
 ...
}
```

Bricks:
```
g.fillStyle(0xc9622f); fillRect(0,0,32,32);
g.lineStyle(2,0x7e3410);
horizontal lines at y=8,16,24; alternating vertical lines.
strokeRect border.
```

qblock:
```
fillStyle 0xf8b800 fillRect; border 0x8a5a00 2px; rivets at corners 4 dots;
'?' via arc: g.lineStyle(3,0xffffff); g.strokeCircle? draw arc from -60° to 200°? then stem down + dot.
```
Arc: g.beginPath(); g.arc(16,13,5, -2.2, 1.6); g.strokePath(); then vertical line from (16+?, ) hmm approximation: line from (18,17) to (17,20)? and dot at (17,24). Let's do: arc centered (16,12) radius 5 from angle 5.5 to 2.6 (clockwise?) — Phaser's arc angles are standard math but y is down. Fine — it'll look like a partial circle and a stem + dot reads as '?'. Good enough; or draw '?' with two rects and a dot: top bar rect(12,8,8,4)? not great. Use arc approach.

Actually simpler: overlay a Phaser text? generateTexture from graphics only. Alternative: draw texture to canvas via scene.add.text? Overkill. Arc is fine.

Used block: 0x8a6a3a fill, dark border, 4 rivets.

Coin frames coin0-3:
```
for(i=0..3){ widths=[20,14,6,14]; w=widths[i];
 g.clear(); g.fillStyle(0xffd800); g.fillEllipse(16,16,w,22);
 g.lineStyle(2,0xc79a00); g.strokeEllipse(16,16,w,22);
 if(w>10){g.fillStyle(0xfff3a0); g.fillEllipse(16- w*0.15,12,w*0.3,8);}
 g.generateTexture('coin'+i,32,32);
}
```
Hmm, frame texture size 32 but display at 32? Body is smaller. ok, set coin sprite body setSize(16,20) offset. Actually static body from texture is 32x32; overlap only so fine.

Player 26x30:
```
Cap: fillStyle 0xe52521 fillRect(5,0,16,6); fillRect(3,4,22,4)? brim: fillRect(3,5,20,3)
Face: 0xffc9a3 fillRect(6,7,14,8)
Eye: 0x222 fillRect(15,9,3,4) (facing right)
Mustache? skip
Body overalls: 0x2a6df4 fillRect(5,15,16,10)
Arms red: fillRect(2,15,4,7) right fillRect(20,15,4,7)
Hands skin: fillRect(2,21,4,3) etc
Boots: 0x6b3b12 fillRect(3,25,9,5) fillRect(14,25,9,5)
Shirt between arms: red fillRect(5,13,16,4)?
```
Order: torso red shirt rows 14-17, blue overall 16-25, straps. Fine — simple blocky hero.

Enemy 28x26:
```
Dome: 0xa05a20 fillEllipse(14,12,26,20)? Phaser fillEllipse(x,y,w,h).
Feet: 0x5a2d0c fillEllipse(7,23,10,6), fillEllipse(21,23,10,6)
Eyes white: fillEllipse(9,10,6,8), (19,10,6,8); pupils black fillRect(8,11,2,4), (18,11,2,4)
Angry brow lines? skip
```

Flattened enemy texture 'enemyFlat': dome squashed.

Flag pole texture: width 8? Let's draw width 12, height T*10=320:
```
Pole: fillStyle 0x9adf6a? classic green pole: 0x2fae3a? Actually SMB flagpole is greenish grey with a ball on top. Use 0xbfbfbf? Green: 0x3aae4a vertical rect x=4 w=4, ball on top yellow circle at (6,4) r 5.
```
Flag cloth texture 'flagcloth': green triangle pointing left 24x20: fillTriangle(0,0, 0,20, 24,10)? attached on left side of pole, apex on pole. Draw triangle (24,0)-(24,20)-(0,10).

Cloud: white: fillEllipse combos, size 120x60.
Hill: 0x2e9e41 fillTriangle(0,120, 160,120, 80,0) with darker spots. Size 160x120.
Bush: 3 green ellipses, size 100x40, color 0x37b24a.

Sky: gradient from 0x63a5ff to 0xbfe3ff? fillGradientStyle(0x5aa0ff,0x5aa0ff,0xcfeaff,0xcfeaff); fillRect(0,0,4,540); generateTexture('sky',4,540), image stretched to 960.

Now scene code.

```js
class GameScene extends Phaser.Scene {
 constructor(){super('game');}
 create(){
   this.physics.world.gravity.y=1900;
   makeTextures(this);
   this.anims.create({key:'spin',frames:[{key:'coin0'},{key:'coin1'},{key:'coin2'},{key:'coin3'}],frameRate:8,repeat:-1});
   this.score=0; this.coinCount=0; this.lives=3; this.state='play';
   this.cameras.main.setBounds(0,0,LEVEL_W*T,ROWS*T+200);
   this.physics.world.setBounds(0,0,LEVEL_W*T,ROWS*T+400);
   buildWorld();
   hud();
   input keys...
 }
}
```

Keys: this.input.keyboard.addKeys('LEFT,RIGHT,UP,SPACE,A,D,W,R,ENTER').

buildWorld destroys previous groups: if this.solids exists destroy etc. Player too. Then build.

Grid construction function buildGrid() as above.

Create tiles: loop grid:
- 'X': texture 'ground'
- 'B': 'brick'
- '?': 'qblock' (track in qblocks array)
- 'C': coin sprite (group coins), not solid.
- 'F': pole texture segment? Instead draw whole pole as single image: find flag col, place pole image at (c*T+6, topR*T) with height covering rows 4-13. Simpler: when we encounter 'F' in top row of flag col, place pole. Compute FLAG_COL constant and just add pole and flag cloth directly, don't use grid 'F'.

Base block under pole: setT(FLAG_COL,13,'X').

Flag sprite: pole image (origin 0), flag cloth image at (FLAG_COL*T+6-24, 5*T).
Flag zone: invisible: this.flagZone = this.physics.add.staticImage? Use this.add.zone with arcade body:
```
const z=this.add.zone(FLAG_COL*T+4, 4*T, 40, 10*T);
this.physics.add.existing(z,true);
```
Zone origin 0.5 — watch centering. Use this.add.rectangle? Use zone with setOrigin(0).

Win overlap: this.physics.add.overlap(this.player, this.flagZone, ...) — overlap with zone works if it has body.

After building groups, setup colliders.

Player creation: this.player=this.physics.add.sprite(2*T+16, 12*T, 'player'); body setSize(20,28) offset(3,1); setCollideWorldBounds(true).

Camera follow.

HUD text fixed.

Update loop:

```js
update(time, delta){
 if(this.state==='play'){ handleInput(); }
 else { player.setVelocityX(0); }
 updateEnemies();
 checkQblocks();
 if(this.player.y > ROWS*T+120 && this.state==='play') this.die();
 if(this.cursors...R pressed) restart;
}
```

handleInput:
```
const left=k.LEFT.isDown||k.A.isDown; right=...;
if(left){p.setVelocityX(-RUN); p.setFlipX(true);} else if(right){...} else p.setVelocityX(0);
const jumpPressed = Phaser.Input.Keyboard.JustDown(k.SPACE)||JustDown(k.UP)||JustDown(k.W);
if(jumpPressed && (p.body.blocked.down||p.body.touching.down)){ p.setVelocityY(-680); squash; beep; }
// variable jump
if(!(k.SPACE.isDown||k.UP.isDown||k.W.isDown) && p.body.velocity.y < -240) p.setVelocityY(-240);
```

Land squash: track wasFalling.

updateEnemies:
```
this.enemies.children.each(e=>{
  if(e.getData('squashed')) return;
  if(e.body.blocked.left){e.setData('dir',1);} else if(e.body.blocked.right){e.setData('dir',-1);}
  e.setVelocityX(e.getData('dir')*SPEED);
  e.setFlipX(e.getData('dir')>0);
  if(e.y>ROWS*T+100) e.destroy();
});
```
Note: children.each during destroy — destroy inside each may modify iteration; use getChildren().slice().

Stomp:
```
hitEnemy(p,e){
 if(this.state!=='play'||e.getData('squashed'))return;
 if(p.body.velocity.y>0 && p.body.bottom < e.body.top+e.body.height*0.6){
   squashed: e.setData('squashed',true); e.setVelocity(0,0); e.body.enable=false? keep body off. e.setTexture('enemyFlat')? generate flat texture; tween scale y; destroy after 400ms via time.delayedCall.
   p.setVelocityY(-420); score+=100; popup; beep stomp.
 } else this.die();
}
```

die(): state='dead'; beep; player death anim: body.enable=false, tween y up then down, then delayedCall 1000 → lives--; if lives<=0 gameOver else rebuildWorld().
Simplify: set state='dead', disable player body, tween scaleY? Mario's spin. Then respawn.

gameOver(): state='over'; overlay text "GAME OVER — press R".

win(): state='win'; bonus 1000; overlay "COURSE CLEAR!  press R"; stop player.

R handler: if state is over/win or anytime: this.scene.restart().

popup(x,y,txt): floating text tween.

HUD update function refreshes text contents.

OK — also add this.time.delayedCall; fine.

One more: enemy group with gravity; enemies spawn on platforms and fall to ground on spawn. Fine.

qblocks check: qblocks stored in array of static sprites. When player.body.blocked.up:
```
const pb=this.player.body;
for(const b of this.qblocks){
  if(b.getData('used'))continue;
  const bb=b.body;
  if(Math.abs(pb.top - bb.bottom) < 6 && pb.right > bb.left+4 && pb.left < bb.right-4){
    b.setData('used',true); b.setTexture('usedblock');
    score+=200; coinCount++; popup; coin pop anim: little coin sprite tweens up from block then destroyed; beep coin.
    bump anim: tween b y down/up? static body move: use setY to tween? Just visual skip, or small: b.y -=4 then tween back — but body won't follow statics unless updateFromGameObject... Actually for static body, body position syncs with game object each frame? For static bodies, Phaser syncs body with game object each frame? Static bodies update when object moves via updateFromGameObject — yeah arcade static bodies auto-sync in preUpdate (static bodies check for position change). Yeah safe.
  }
}
```

Edge case: hitting block with head also bumps player down — fine.

Also bricks 'B' could bounce, skip.

Also enemies shouldn't be pushed weirdly by player — no player vs enemy collider, just overlap. Fine.

Let me write it all now. Double-check Phaser API details:
- this.make.graphics({add:false}) ok (or {x:0,y:0,add:false}).
- g.fillGradientStyle(c1,c2,c3,c4,alpha) then fillRect.
- g.strokeEllipse(x,y,w,h), g.fillEllipse.
- g.fillTriangle(x1,y1,x2,y2,x3,y3), strokeTriangle.
- g.arc(x,y,r,startAngle,endAngle,anticlockwise) then strokePath. Angles in radians, 0 at positive x, clockwise on screen coords... fine.
- generateTexture(key,w,h).
- staticGroup: this.physics.add.staticGroup(); g.create(x,y,'key').
- sprite.body.setSize(w,h,true) centers. Use setSize(20,28).setOffset(3,2).
- scene.restart via this.scene.restart().
- Keyboard: this.input.keyboard.addKeys(...) returns object with Key objects; JustDown(key).
- Zone: this.add.zone(x,y,w,h).setOrigin(0,0); this.physics.add.existing(zone,true) → static body.

Camera: this.cameras.main.startFollow(this.player,true,0.12,0.12); setDeadzone maybe not since follow with lerp is fine.

Parallax: create bgGroup before solids.

HUD depth: setDepth(100), setScrollFactor(0).

Also add ground edge texture variation: 'ground' used for all; fine.

Now let me write it.

Enemy count ~14. Lives 3.

Death tween:
```
this.player.body.enable=false;
this.tweens.add({targets:this.player,y:this.player.y-120,duration:250,ease:'Quad.easeOut',yoyo:true,onComplete:()=>{...respawn}});
```
But yoyo brings it down; then delay and respawn anyway. Simpler: tween up then delayedCall 800 → finishDeath().

Also prevent double die: guard with state.

Now let me write the final file. Careful with grid build — write the functions:

```js
function buildGrid(){
 grid=Array.from({length:ROWS},()=>Array(LEVEL_W).fill('.'));
 const T_= (c,r,ch)=>setT(c,r,ch);
 const ground=(a,b)=>{for(let c=a;c<=b;c++)for(let r=14;r<ROWS;r++)setT(c,r,'X');};
 const row=(a,b,r,ch)=>{for(let c=a;c<=b;c++)setT(c,r,ch);};
 ground(0,25);
 row(16,20,10,'?'); // wait, alternate
 ...
}
```
qblocks 16,18,20 and bricks 17,19: setT individually: setT(16,10,'?'); setT(17,10,'B'); setT(18,10,'?'); setT(19,10,'B'); setT(20,10,'?');
Coin at (18,7).
Enemies: this.enemySpawns=[22,34,40,63,69,74,93,97,101,127,135,140,143,160,164].

Wait, enemy at 34 is under bricks row 10 cols 32-35 — walking under bricks, fine (bricks are at row 10, enemy is at ground 13, space is rows 11-12 which is open). ok.

ground(29,55); row(32,35,10,'B'); coins (32..35,7)? Let's do coins (33,7), (34,7). setT(37,10,'?').
Pyramid: c=46..49 h=c-45: for h 1..4 rows 14-h ..13: setT(46,13,'X'); setT(47,12..13); setT(48,11..13); setT(49,10..13).
Wait, ground(0,25) then hole 26-28, ground(29,55) then hole 56-58, ground(59,84), hole 85-88, ground(89,118), hole 119-122, ground(123,148)? Then stairs at 145-148 ascending height 4 at 148, then hole 149-151, ground(152,213), stairs descending 152-155? Overlap: ground(152,213) plus stairs at 152-155 heights 4..1: setT(152, 10..13), 153 11..13, 154 12..13, 155 13.

ground(59,84):
setT(61,10,'?'); row(64,67,7,'B'); coins (64..67,4).
Enemies 63, 69, 74.
Hole 85-88: platform bricks row(86,87,12,'B'); arc coins setT(85,10,'C'), (86,9,'C'), (87,9,'C'), (88,10,'C').
ground(89,118):
setT(95,10,'?'); setT(96,10,'B'); setT(97,10,'?'); coins (95,7), (97,7).
Enemies 93, 97 (under qblock? move to 98), 101. Use 93, 99, 103.
Pyramid descending at 106-109: heights 4,3,2,1.
Hole 119-122: bricks (120,12), (121,11)? step-up: setT(120,12,'B'); setT(121,11,'B')? Jump from ground r14 standing r13 up to r12 top ok, then r11 ok. Coins above hole (120,9), (121,8)?
ground(123,148):
row(126,128,10,'B'); coins (126..128,7).
row(131,133,7,'B'); coins (131..133,4).
Enemies 127? under bricks — fine (rows 11-12 open). Enemies 127, 136, 140, 143.
Ascending stairs 145-148 heights 1..4. Coin at (148,8)? on top.
Hole 149-151.
ground(152,213); descending stairs 152-155.
Enemies 160, 164.
Coin row row(166,170,11,'C').
FLAG_COL=180: setT(180,13,'X') base; pole rows 4-12 (image).
Castle: col 190-194: rows 12-13: row(190,194,12,'B'); row(190,194,13,'B'); row(191,193,10,'B'); row(191,193,11,'B'); setT(192,9,'B'); door: leave (192,12), (192,13) as '.'? Then hole — no, keep solid. Fine.
```
End wall: col LEVEL_W-1, setT 213 rows 10-13 'X'? World bounds stop anyway.

Wait, row 13 at FLAG_COL: base block at row 13 sits above ground row 14. Pole from row 4 to 13 (ball on top). Pole image height: (13-4+1)*32=320. Place at x=180*T+12, y=4*T.

Flag cloth at (180*T+12-22, 5*T+6).

Flag zone: x from 180*T-8 width 40, y=4*T height 10*T.

OK. Also add some coins on pyramid tops etc. Enough.

Now let's write final code. Keep the functions clean. Estimated ~600 lines. Go.

Also HUD styling with fontFamily 'monospace' and stroke via textStyle stroke.

Phaser text: this.add.text(x,y,str,{fontFamily:'"Press Start 2P", monospace'...}) — no external font; use 'bold 18px monospace' and stroke.

Now write the file.

Phaser is already in place. Next, I'll create index.html.

Next, let's do a sanity check of the JS syntax. I'll extract the script and run node --check. Also, I'll verify whether the Phaser global loads in the headless environment. Alright, let's extract it and lint it.

No python3. Use node for extraction.

The syntax is fine. Now, can we run a smoke test using Phaser in Node? Phaser requires the DOM. If jsdom is available, maybe we could simulate a headless run, but... it's probably not installed. Alternative: check the Phaser version, and check for obvious API misuse.

Let's verify the Phaser version string.

Also, let me review a few potential bugs:

1. There's a paused tween `this.tweens.add({ targets: cloth, y: 11 * T, duration: 0, paused: true })` — pointless leftover cruft, but harmless? A paused tween with duration 0 — no problem, but should we delete it to keep things clean? No harm. Actually, let's delete it.

2. In `hitEnemy`, we check `pb.velocity.y > 60`. Arcade body's `velocity` — `body.velocity` is valid.

3. Zone overlap: `this.physics.add.overlap(this.player, this.flagZone, ...)` — flagZone has a static body via `this.physics.add.existing(zone, true)`. overlap works with zone bodies. OK.

4. `this.solids.destroy(true)` destroys children including bodies. buildWorld is called from create — first call: this.solids is undefined so it's skipped. OK. But fxLayer group — created first in buildWorld. However, the overlay text in showOverlay is also added to fxLayer, and... fxLayer gets destroyed on restart via buildWorld — but buildWorld is only called on respawn (buildWorld inside die()), and the overlay only shows on gameOver (no buildWorld). scene.restart() calls create again and everything is reset. OK.

Wait — the die() flow: after the tween's yoyo complete, delayedCall 500 → buildWorld. But if the scene restarts during that time (R key), the delayedCall could fire after the restart. scene.restart() recreates the scene — will old timers on the previous scene instance be cleared? On restart the scene's systems reset, and the Time clock is cleared. Should be fine.

5. Fall-into-pit path: state set to 'falling' — after respawn, state='play'. Good. But if during 'falling' lives<=0 → gameOver() sets state to 'over'. Good.

6. update() when state==='dead': player body is disabled; p.body.enable check is fine.

7. Enemy body.setSize(26,24) — the texture is 28x26 so OK.

8. `this.cameras.main.setFollowOffset(140, 60)` — this makes the camera target ahead of the player. When moving left, the camera stays offset to the right and the look-ahead feels off, but it's within acceptable range.

9. qblock bump tween: tweening y on a static body — arcade's static body is updated via `updateFromGameObject` when the game object moves. Yes, static bodies sync position every frame in ArcadeWorld.update? Static bodies are updated via `updateFromGameObject` when the game object moves. Yes, Phaser's Arcade static body has updateFromGameObject called during the static tree's update. No problem.

10. The ground row uses rows 14, 15, 16 — ROWS=17 so rows go up to index 16. Good.

11. Pit at 26-28: player starts on ground(0,25) at column 2. Enemy at column 22 walks left, reaches the edge at column 25, and walks off into the pit? Walks left from 22 toward 0, hits the world boundary on the left, turns around. Walks right and eventually falls into the pit at column 26 — no problem, destroyed when y > WORLD_H+80. OK.

12. Enemy at column 173 — final stretch, no problem. Flag at column 180. Zone x = 180*32-10, width 44, y from 4*32 with height 320 — covers up to row 14. Player touches it and wins. Good.

13. The castle's bricks are solid at rows 10-13, columns 190-194 — the player can jump on top. No problem.

14. Coins at (166..170, row 11) — floating at row 11 above the ground; reachable with a jump. Good.

15. `this.add.zone(...).setOrigin(0,0)` — zones have setOrigin. OK.

16. HUD coin text uses '\u25CF x' — the filled-circle character as a coin icon. OK.

17. Phaser version check: staticGroup().create returns a sprite; setting data works. `q.setData('used', false)` no problem.

18. `this.make.graphics({add:false})` — Phaser's GameObjectFactory.make signature: make(options) with options.add. OK.

19. Potential issue: `this.enemies.getChildren().slice()` and then calling `e.destroy()` inside the loop — no problem since it's a copy.

20. In the enemies-enemies collider callback, setData is called on both — could trigger repeatedly every frame while they're touching; the direction flickers while overlapping, but each collision flips both, so they stay pushed apart. Minor jitter is within acceptable range.

21. hitQblocks runs every frame while blocked.up; the used flag prevents repeats.

22. Death on touching an enemy while the player is invincible? No invincibility frames — die() guards with state.

One more check: does Phaser's `zone` work with physics overlap? A zone is a GameObject without rendering, but with an arcade body; overlap works between bodies. Yes.

Also, `this.flagZone.destroy()` inside buildWorld — zones are destroyed without issue.

Sky image display size is 960x540, scrollFactor 0, depth -100. Parallax hills at depth -80 etc. Solids default depth 0. Player depth 10. Good.

Camera bounds height is WORLD_H+200, world physics bounds y starts at -100, height WORLD_H+300. Player can fall to WORLD_H+90 before dying — inside the bounds. Good.

Let me check the Phaser version to confirm API compatibility (e.g., fillGradientStyle exists in v3.12+, zones in 3.12+). Let's grep the version.

Also, maybe I can run a headless smoke test: install jsdom? Probably no network. Let me check whether jsdom exists in node_modules. Probably not. At minimum I can verify that the Phaser file exposes a version.

Phaser 3.80.1 — all the APIs being used are compatible. No jsdom available for a headless DOM test. Should I try a minimal smoke test with a fake DOM? Phaser 3.80 demands quite a lot of DOM (document.createElement, canvas). If there's no network to install jsdom, it's likely to fail. Let me quickly check whether jsdom is anywhere: `node -e "require('jsdom')"` — will probably fail. Skip that, and instead do a careful static review of the risky spots.

Actually, I could try a smoke test with a lightweight DOM shim — Phaser's HEADLESS renderer (type: Phaser.HEADLESS) avoids the canvas, but Phaser still needs `document`/`window` at boot time for scale management etc. Building a shim is risky, and even if it errors out that doesn't necessarily mean it would fail in a browser. Skip the heavy emulation.

One real bug to fix: a leftover paused tween for cloth. Let's delete it. Also double-check the `this.anims.create` frame keys — no problem.

Another consideration: inside `buildWorld`, before creating, if it exists, `this.fxLayer.destroy(true)`; in create, buildWorld is called before the HUD is created — the HUD isn't included in fxLayer. Good.

Also: gameOver is called from a delayedCall inside die's onComplete — buildWorld is not called; overlay is shown. Restart with R works.

Edge case: `winGame` → flagZone overlap is triggered; the player may still be moving; set velocity to 0, but after that update() sets velocityX to 0 when state!=play — but gravity still applies, so the player might land/slide; no problem.

Note: in update, when state==='win', p.body.enable is true so it enters the `else if (p.body.enable)` branch → setVelocityX(0). OK.

Delete the extraneous tween and do a final listing.

Now, should I try a headless smoke test with a minimal DOM shim? Let's give it a shot — create a minimal window/document shim and run Phaser in HEADLESS mode. Phaser 3.80's HEADLESS renderer avoids canvas rendering, but DOM APIs are still needed: document.createElement('canvas') is used for texture generation (CanvasRenderer), but... in HEADLESS mode does Phaser use CanvasRenderer? Phaser.HEADLESS uses a HeadlessRenderer that doesn't draw, but texture generation via Graphics.generateTexture may still require a canvas context. Since my game procedurally generates textures via Graphics → generateTexture, the canvas 2D context is needed. It's possible to shim a fake canvas with a 2D context stubbed out (make all methods no-ops, getImageData returns a buffer) — considerable effort, but it might let me catch runtime errors in my own game logic (level construction, scene creation, update loop).

Let's give it a try: create a shim equipped with a Proxy-based 2D context that returns sensible default values (measureText, getImageData). Phaser also needs window.addEventListener, requestAnimationFrame, performance, navigator, devicePixelRatio, innerWidth/innerHeight, document.body.appendChild, document.documentElement, and so on. It's risky, but worth a shot. If errors related to Phaser internals come up, I can evaluate whether they're shim-related or game-related.

Let me write /tmp/shim-test.js:

```js
// Minimal DOM shim
const noop = () => {};
function makeCtx() {
  return new Proxy({}, {
    get(t, prop) {
      if (prop === 'getImageData') return () => ({ data: new Uint8ClampedArray(4) });
      if (prop === 'measureText') return () => ({ width: 0 });
      if (prop === 'createLinearGradient' || prop==='createRadialGradient' || prop==='createPattern') return () => ({ addColorStop: noop });
      if (prop === 'canvas') return null;
      return typeof prop === 'string' ? noop : undefined;
    },
    set() { return true; }
  });
}
```
Hmm, the Proxy's get returns a function for everything, but property reads like ctx.globalAlpha return a function — if Phaser reads and writes, that's fine, but if it does arithmetic it becomes NaN. Phaser does reads like `ctx.fillStyle`... it's mostly set-only. There's risk, but let's give it a shot.

Canvas element stub:
```js
function makeCanvas() {
  const c = {
    width: 0, height: 0, style: {},
    getContext: (t) => makeCtx(),
    addEventListener: noop, removeEventListener: noop,
    getBoundingClientRect: () => ({ left:0, top:0, width:960, height:540, right:960, bottom:540, x:0,y:0 }),
    setAttribute: noop, toDataURL: () => '',
  };
  return c;
}
global.window = global;
global.document = {
  createElement: (t) => t === 'canvas' ? makeCanvas() : ({ style: {}, appendChild: noop, addEventListener: noop, setAttribute: noop }),
  createElementNS: (ns,t) => makeCanvas(),
  body: { appendChild: noop, removeChild: noop },
  documentElement: { style: {} },
  getElementById: () => ({ appendChild: noop, style:{} }),
  addEventListener: noop, removeEventListener: noop,
  hidden: false, visibilityState: 'visible',
  readyState: 'complete',
};
global.navigator = { userAgent: 'node', maxTouchPoints: 0, getGamepads: () => [] };
global.requestAnimationFrame = (cb) => setTimeout(() => cb(performance.now()), 16);
global.cancelAnimationFrame = clearTimeout;
global.addEventListener = noop; global.removeEventListener = noop;
global.performance = require('perf_hooks').performance;
global.devicePixelRatio = 1;
global.innerWidth = 960; global.innerHeight = 540;
global.Image = class { set src(v){ setTimeout(()=>this.onerror&&this.onerror(),0);} };
global.HTMLCanvasElement = function(){};
global.AudioContext = undefined; // game guards this
```

After that, load phaser.min.js with require (since it's UMD, in node it should set module.exports via the "object"==typeof exports branch). Then extract the game script and eval it with Phaser in scope. However, my game script calls `new Phaser.Game(config)` — config's type: Phaser.AUTO → in headless environments AUTO picks... it checks device support, but with the shim it will probably pick Canvas. I could temporarily patch it to Phaser.HEADLESS for the test. I'll eval the script but override the config type after extraction — easier: eval the script in a context where Phaser is defined, and let it run. Then pump frames: setTimeout loop, run for about 3 seconds to simulate key input? Simulate input via game.scene.keys... maybe I can call scene methods directly: after boot, verify that scene.create has run, that solids/coins/enemies counts are nonzero, simulate update ticks, call collectCoin, stomp, etc.

This could turn into a quagmire. Time-boxed: give it a try, and if Phaser's boot fails with shim-related errors, log it and fall back to static review.

Actually, Phaser 3.80's HEADLESS renderer: Phaser.Game with type HEADLESS completely skips canvas creation for rendering, but the CanvasTexture/graphics generateTexture path uses CanvasRenderer... even in HEADLESS, textures are generated via CanvasTexture which creates a canvas element and 2d context. My shim provides those as no-ops — generateTexture should "work" (pixel content is empty). Physics doesn't need canvas. ScaleManager uses window listeners, document, getBoundingClientRect — shimmed.

Let's give it a try.

Note: eval(src) uses `game` and `FLAG_COL` from the script — eval within the same scope, so variables should be accessible afterward (eval in non-strict scope creates bindings in the enclosing function scope… `const config` and `new Phaser.Game` — `game` is not stored! My game script doesn't assign the Phaser.Game instance to anything: `new Phaser.Game(config);` — need a reference. Let me modify the smoke test to capture it: replace `new Phaser.Game(config);` with `global.game = new Phaser.Game(config);` and `FLAG_COL` is a const within eval scope — is a top-level const accessible within the same eval'd code? In non-strict eval, const/let are confined to the eval's own scope block and are not exposed. But `grid` etc. are also const/let. However, the GameScene class is also within that scope; the smoke test needs scene access — this is possible via the game instance. FLAG_COL can just be hardcoded as 180*32. Let me patch the smoke test: replace 'new Phaser.Game(config);' with 'global.game = new Phaser.Game(config);' and use 180*32.

The output is flooded with source text from phaser.min.js — probably a stack trace containing minified sources, meaning an error was thrown at require/boot time. Exit code 1. The output got cut off midway. The error message itself might be in the part that was truncated earlier. Let me rerun while saving the output to a file, and check the top portion of the output.

The error is `HTMLVideoElement is not defined` — it's a shim problem, not a game problem. Add global HTMLVideoElement, and there's probably also HTMLImageElement, HTMLAudioElement, and so on. Let's add the classes and retry.

Progress: Phaser starts up, but the renderer fails with a null reading of 'blendModes'. Probably because of HEADLESS... hmm, "Cannot read properties of null (reading 'blendModes')" — this is probably the CanvasRenderer referencing something. Might be related to my Proxy 2D context stub returning functions where Phaser expects objects, or maybe the texture manager's __DEFAULT / __MISSING texture creation is failing.

Let me grab the stack trace to pinpoint the location. The stack is minified, but I can search for function context. Let me output more lines of the UNCAUGHT stack from out.log.

The error occurs in Graphics.renderCanvas → generateTexture. Is the canvas context being used null? Is "Cannot read properties of null (reading 'blendModes')" reading `.blendModes` on null? Is it actually `renderer.blendModes`, with renderer being null? Inside renderCanvas: `pipelineUtils...`? Let me look at the minified code at position 802949 and check what's being read.

`t.blendModes` — t is renderer... `e.globalCompositeOperation = t.blendModes[i.blendMode]` where t is null → renderer is null. In Graphics.renderCanvas(src, renderer/camera...)? When called from generateTexture of CanvasTexture in the HEADLESS renderer, the renderer passed is possibly the game's renderer. In HEADLESS mode, is game.renderer ... HeadlessRenderer with canvas null? The error indicates the first arg `t` is null. In Graphics.renderCanvas: `var renderer = src.scene.sys.renderer`? In headless, game.renderer exists (HeadlessRenderer) but... maybe it's calling with `this.scene.sys.game.renderer`? Hmm, `t` is null → maybe the scene's sys isn't fully up because create was being called during the make? No — I'm calling makeTextures inside create, and the scene's sys should be fine.

Wait: this is `t.exports=function(t,e,i,n,r)` — SetTransformStyle or similar, called from renderCanvas of a shape with args (renderer, ctx, ...). renderer being null is probably because the Graphics object was created with `scene.make.graphics({add:false})` and the scene's `sys.renderer` in HEADLESS is... does HeadlessRenderer set `this.canvas = null; this.type = HEADLESS`? Maybe HeadlessRenderer doesn't have blendModes. But the error says reading 'blendModes' of null — so t is null, not that t.blendModes is undefined. So the renderer argument was null.

In Graphics.generateTexture: uses CanvasTexture + renderCanvas(this, ...). Actually the generateTexture code around position 232746: `initialize.generateTexture` is probably Graphics.generateTexture → calls this.renderCanvas? Let me check that snippet. Actually the stack is: generateTexture → renderCanvas → SetTransform(t=null). Graphics.renderCanvas signature is (src, renderer, camera, calcMatrix) and is it called as `this.renderCanvas(this, renderer...)`? Hmm, Graphics.renderCanvas is `renderCanvas(src, renderer, camera, calcMatrix)`; does generateTexture call `GraphicsPipeline...`? Let me look at the code around 232746.

generateTexture is calling `this.renderCanvas(o, this, f.TargetCamera, null, n, !1)`. Here `o` is probably `this.scene.sys.renderer` or `this.renderer`. `renderCanvas(src, renderer, camera, ...)`: the first argument `o` = null → renderer is null. In a scene under the HEADLESS renderer, does `scene.sys.renderer` become null? In Phaser, is System.renderer a reference to game.renderer? Actually it's `sys.renderer = game.renderer`. HeadlessRenderer… probably exists. But `o` was null — maybe I defined `o` earlier in generateTexture: probably `var o = this.scene.sys.renderer` — under HEADLESS, is sys.renderer null? Hmm.

Actually, is HeadlessRenderer inheriting from CanvasRenderer? Let me check: Phaser.HEADLESS uses HeadlessRenderer, which does almost nothing. There's a possibility that game.renderer exists. But in generateTexture, `o` is probably defined like `var o=this.systems.renderer`, maybe… the scene here is `r` (scene systems). The code: `var r=this.scene.sys`, and then afterwards `this.renderCanvas(o,this,f.TargetCamera,null,n,!1)` — o was defined earlier (cut off part). Probably `var o=r.renderer`.

In HEADLESS, is game.renderer created after the scene boots? It should be created though. Hmm, but maybe under HEADLESS, `sys.renderer` becomes null. This is a limitation of Phaser's HEADLESS — Graphics.generateTexture requires the Canvas/WebGL renderer.

Workaround: force `type: Phaser.CANVAS` in the test. The CanvasRenderer will work with my shimmed 2D context (all methods are no-ops). CanvasTexture generation uses canvas 2D — no problem. Rendering: the CanvasRenderer draws images to the main canvas via drawImage — no-op. Also CanvasRenderer calls ctx.getImageData in some places for snapshot only. Should be OK.

Change the replacement to Phaser.CANVAS.

The CanvasRenderer boot is failing: "Cannot create Canvas context, aborting." Phaser's CanvasRenderer.createCanvas calls CanvasPool.create, then does getContext('2d') to check the context. My shim is returning a Proxy, so that should be truthy... The check might be `if (!this.context)`. Let's look for where this message is being thrown — it's probably inside the CanvasRenderer constructor, and maybe it's checking `document.createElement('canvas').getContext('2d', options)`. My makeCanvas's getContext returns a Proxy. Hmm.

Maybe CanvasPool.create is using `document.createElement('canvas')` — in my shim that returns makeCanvas(). Then `canvas.getContext('2d', {willReadFrequently:false})` returns a Proxy. It should be fine but...

Could the issue be that `getContext` is being called on the same canvas with '2d', and then Phaser is checking `context instanceof CanvasRenderingContext2D`? That seems unlikely.

Let me search for the string "Cannot create Canvas context" within phaser and check the surrounding logic.

`o.canvas` — feature detection: `o.canvas=!!window.CanvasRenderingContext2D`. I had set `global.HTMLCanvasElement` but hadn't set `CanvasRenderingContext2D`. Add `global.CanvasRenderingContext2D = function(){}`.

The scene boots up, and the level builds: 677 solid objects, 28 coins, 16 enemies, 7 Q-blocks. The player spawns at the correct position. But during auto-run, state became 'dead' at x=512 (col 16, the '?' block zone) — pos 512,376. Hmm, state 'dead' but lives is still 3? So did die() get called but lives only gets decremented after a delayed call (which is 380*2+500ms later)? Actually, the tween is 380 with yoyo followed by a 500 delay → about 1260ms; we sampled at 2500ms so respawn should have occurred… but state is 'dead' and lives is 3. Wait — did respawn happen? state 'dead' at the 2.5s mark. Hmm, the death tween's onComplete yoyo: the tween with yoyo has duration 380, total 760, then delayedCall 500 → respawn at about 1260ms after death. If death occurred at about 1.2s, respawn should be around 2.5s — borderline. Or maybe the 'dead' state is lingering because… let me think about why the player died at x=512.

x=512 = col 16. That's exactly where the '?' block at row 10 starts. Player runs along the ground and… what kills them there? Enemies at col 22 (x=704+). Player at 512, y=376 — ground level (ground top surface is 14*32=448; player center when standing is 448-15=433). y=376 is above the ground — maybe mid-death-tween (tween moves y -130 then yoyos back: 433→303→433; 376 is mid-tween).

Cause of death: the auto-jump every 420ms sets SPACE.isDown=true for 30ms. But JustDown detection requires the key event machinery — manually setting isDown might make JustDown always return true. Since I'm not resetting the internal state… I set `k.SPACE._justDown = false` — but Phaser's JustDown uses keyCode state on `Key.justDown` that's set on the keydown event; manually setting isDown may not trigger JustDown (justDown is only set within the OnKeyDown handler). So the player probably never jumped, just ran straight ahead… into an enemy? An enemy at col 22 walks left toward the player. Player runs right, meets the enemy around cols 10–20 → side collision → die. That's plausible: enemy walks from 704 leftward to meet player around col 14. Player position at death is 512 (col 16). Makes sense! The player never jumped (JustDown didn't fire), got hit by an enemy from the side and correctly died. So the game logic is behaving correctly — this is actually good validation of enemy AI + die().

But then why didn't respawn occur? Death at some time t, respawn t+1260ms. The auto-run script sampled at 2500ms after boot. When did the player die? Enemy at col 22 (x≈720) walks left at 62px/s from boot, player runs right at 240px/s from x=80. Meeting time ≈ (720-80)/(240+62) ≈ 2.1s. Hmm, that's close to the 2.5s sampling. So death was around 2.1s, respawn around 3.4s — we just sampled before respawn.

Also, 'lives: 3' is consistent: lives get decremented on respawn.

So everything is working. Let me improve the test: simulate jump via a dispatchKeyEvent-style call to make JustDown work? Simpler: call scene's methods directly to verify stomp/win. The test exited at the 'player died' branch. Let me change the flow: after 2.5s, if state is dead, wait for respawn (poll until state is play), then do the teleport stomp test and flag test. Let me patch the tail of smoke.js: replace the else branch with a wait-until-play, then continue testing.

Actually, more simply: modify the test to wait for respawn first: poll every 200ms, when state==='play' run the stomp test. Let me edit smoke.js accordingly — replace the else-branch block.

Interesting results:
1. Respawn works (lives 3→2). ✓
2. However, UNCAUGHT: "Cannot read properties of undefined (reading 'entries')" — need to track down the cause. This occurred around stomp (score 0, not stomped). Probably caused by my teleports: setPosition onto an enemy then setVelocity — or maybe the enemy was already destroyed (squashed in the meantime?). Actually 'enemy squashed? false', score 0 — stomp did not occur. Maybe the selected enemy was far off-screen and… no, physics runs everywhere. Player is teleported on top of the enemy, falling at velocity 300 — overlap should trigger hitEnemy → stomp. But nothing happened. Perhaps that enemy fell into a hole and got destroyed and `e` was stale? find returned an active enemy; setPosition onto it; 400ms later state play, no stomp. Hmm — perhaps the enemy moved (walking at 62px/s, ~25px in 400ms) and the player fell next to it, triggering… no, no death, score 0.

Wait — the 'entries' error: "Cannot read properties of undefined (reading 'entries')" — could be Phaser's group add? fxLayer = this.add.group(); and then this.fxLayer.add(t) (t is a Text) — no problem. Or `Phaser.Utils.Array.GetRandom` in winGame — no, I didn't reach win. Maybe the error comes from a tween targeting a destroyed object?

Where is 'entries' used? Map? `body.blocked`? Let me grab the stack.

3. qblock bump didn't trigger — I teleported the player under the qblock and gave it an upward velocity of -900; but I set position to q.y+64 — block is at row 10 y=336, +64 → 400, player in the air… rises and hits the block? Player's top needs to touch the block's bottom edge. From y=400 (center), rising at -900 with gravity 1900… reaches block in about 0.15s, blocked.up should trigger. Then hitQblocks checks Math.abs(pb.top - bb.bottom) < 8. Should hit. Unless the player's position got pushed out. Or the qblock found was far away (the first unused one = the one at col 16) but the player had already… hmm 'qblock used? false'.

Also coins are still 0 — I teleported to the coin's position, and overlap should trigger collectCoin. Didn't happen.

And the flag: teleported to 180*32, 12*32 — should overlap with flagZone… didn't win.

Suspicious pattern: after respawn, teleport/overlap events are not triggering. Maybe… after buildWorld, new colliders/overlaps were added but old ones were destroyed along with the groups. Hmm, but physics.add.overlap using this.player — new player. Should work.

But wait — maybe the issue is: after respawn via buildWorld() inside a delayedCall, the scene's physics world is… no, no.

Another suspicion: the 'entries' UNCAUGHT error is breaking something. "reading 'entries'" — could it be from `this.anims`? Or inside ArcadeWorld after destroying a group with bodies? Let me get the full stack from the log.

`getChildren` failed inside collideGroupVsGroup — one of the groups was destroyed, but the collider referencing it was left behind. This is because buildWorld() destroys the groups (solids/coins/enemies), but the old colliders/overlaps from the previous buildWorld are still registered with the physics world and reference the destroyed groups. Destroying a Phaser Group by default doesn't remove colliders... Actually, destroying a GameObject with a body removes the body and the Collider should also be automatically removed (when a body is destroyed, World removes colliders that involve that body?). Colliders are tied to bodies; ArcadeWorld automatically removes colliders referencing a destroyed body (inside removeBody... via `this.colliders` check?). Apparently it's not fully removed here — collideGroupVsGroup calls object2.getChildren(), and object2 is a destroyed group (its children property has become undefined? Group.destroy sets children to undefined).

Fix: track and destroy colliders/overlaps in buildWorld. Save them into an array `this.colliders = []`, push each one, and call `this.colliders.forEach(c => c.destroy())` before rebuilding.

This is the real bug in my game — after death/respawn, all collisions stop working (player falls through the floor? no wait — player vs solids collider was also destroyed... but in the test, the player was standing normally after respawn, qblock check etc. Hmm, but if the collider is dead, the player should fall through the floor. In the test, after respawn, the player was in play state — but teleporting hides the physics. Actually, if the collider is broken, the player would immediately fall into the ground and die again. In the test, state remained 'play' because I immediately teleported. Either way — the fix is essential.

Does Phaser remove the Collider when the body is destroyed? ArcadeWorld.removeCollider exists; is a Collider destroyed when either object is destroyed? For groups, group.destroy(true) destroys the children and their bodies; World's `removeBody` is... inside World.update, colliders check `collider.active`. Hmm, Collider has both a `destroy` method and a `shouldBeRemoved` logic. Apparently group-level colliders survive — a known Phaser behavior: colliders must be destroyed manually.

Fix in index.html: add this.colliders array; wrap each physics.add.collider/overlap: `this.colliders.push(this.physics.add.collider(...))`. In buildWorld, destroy them first.

Wait — one detail: in `buildWorld`, `this.colliders` is destroyed after the group. It's better to destroy the collider before the group, but since we're destroying everything before reconstruction, the order doesn't matter that much. In fact, the collider's destroy only removes it from the world — safe even after the group's destroy. No problem.

Alright, let's rerun the smoke test.

Currently, everything passes with zero runtime errors:

- Level construction ✓
- Side contact with enemy → death + respawn, remaining lives decrement ✓
- Stomp → enemy crushed, +200 score, bounce ✓
- Coin overlap → collection, +100, coin count ✓
- Flag → victory, +1000 bonus ✓
- No runtime errors ✓

The qblock bump test didn't trigger (`used? false`) — probably my synthetic teleport velocity didn't make actual head contact under headless physics timing (blocked.up requires a collision resolution; with a 500ms wait after -900 velocity, it should have hit, but... maybe the player hit the side of the block, or the head check window of <8px was missed at that exact sample moment — blocked.up is only true on the frame of collision). The hitQblocks logic only fires while `pb.blocked.up` is true, which lasts only 1–2 frames; the teleport test can't guarantee timing. The logic itself is standard and correct; in actual gameplay, when the head hits the block, blocked.up is true on the same frame.

Hmm, but there's a subtle issue: `blocked.up` is set during the collision step, and update() runs after physics (in Phaser's arcade, the scene's update is... actually physics runs during the scene update cycle: the Physics world updates on the PRE_UPDATE event, and the scene update comes after). So blocked.up from this frame's collision is readable in the scene's update. ✓

Let me do a slightly more direct verification of the qblock path: directly simulate the conditions — manually set pb.blocked.up to true and place the player right below the block. Actually even simpler: call scene.hitQblocks with the player positioned to align, and manually set player.body.blocked.up = true. Patch a small test... can be done quickly with a node one-liner after boot. Add to the smoke test before the win test: align the player to the qblock, set blocked.up = true, call hitQblocks. But it's a hassle to re-edit the smoke file again; the logic is deterministic (the conditions are pure computation), so a targeted check is enough. Let me quickly write a small dedicated test that reuses the shim.

Actually even simpler: modify smoke.js with sed? The helper function area... I'll just write a second small test file that requires the same shim. Let me create smoke2.js that imports the shim part... it's easier to copy smoke.js's shim by extracting from smoke.js up to the eval. Or just sed-copy: reuse the whole file with a different inspection. Quick approach: write smoke2.js that reads smoke.js's source up to "let it boot" to reuse the shim... this is getting silly.

Alternative: run a modified smoke that, after respawn, places the player with their head exactly at the block's bottom edge and forces blocked.up. Let me just do that with node -e against a copy.

Direct check also fails. That means my alignment calculation is wrong. Player body: setSize(20,28) offset(3,2), sprite origin 0.5, texture 26x30. Body top = sprite.y - 30*0.5 + 2 = y - 13. Block bottom = q.y + 16.

The condition in hitQblocks: |pb.top - bb.bottom| < 8 and horizontally: pb.right > bb.left+4 && pb.left < bb.right-4.

I set p.setPosition(q2.x, q2.y + 16 + p.displayHeight/2 + 0.01) → y = q.y+16+15 = q.y+31 → body top = q.y+31-13 = q.y+18, block bottom = q.y+16 → diff 2 < 8. Horizontally they're aligned. Should pass...

Unless pb.top uses body position, and after setPosition, it's... body.position only updates during the physics step! After setPosition, body.top is still stale until preUpdate sync. In actual gameplay, this is fine (blocked.up implies collision in the same frame → body position is fresh). But in my direct test, the body position was stale (the player had been teleported but the body hadn't synced). So the test's false negative is due to stale body sync, not a game bug.

Fix the test: call p.body.update(p.gameObject...) or set p.body.position manually? Simplest is: after setPosition, manually set `p.body.position.set(p.x - p.body.halfWidth... )` or call `p.body.reset(p.x, p.y)` — Arcade Body has reset(x,y), which syncs position. Use p.body.reset(q2.x, y). Update smoke2 to use body.reset.

Two things:
1. This run timed out (124) and a new error occurred: `this.add.image(...).play is not a function` — this is the coin pop-out from the qblock inside hitQblocks: `const c = this.add.image(b.x, b.y - 30, 'coin0').play('spin')` — Image doesn't have .play; you need a Sprite. This is an actual bug I introduced (in the case of Image, `.play` only exists on Sprite). Fix: use this.add.sprite(...).

2. The qblock's 'used?' result wasn't output because the error occurred first during hitQblocks (after setting used, it crashed on coin pop → so used? was actually true, but the error swallowed the output... actually an uncaught error inside the hitQblocks call within the test → caught by uncaughtException, the script continues but subsequent console.log inside that block? The error was thrown on the `.play` line → the rest of the block was aborted; the subsequent lines of the test were aborted → timeout).

Fix for index.html: change the coin pop-out image to a sprite.

Coins inside the coins group use this.coins.create(...) — for a staticGroup, what create() returns is... in the case of physics' staticGroup, create returns a Phaser.Physics.Arcade.Sprite (the default classType of a physics group is Sprite). I've already called coin.play('spin') there — staticGroup's default classType: does Phaser.Physics.Arcade.StaticGroup inherit from Group with classType = ArcadeSprite? Let me check: PhysicsGroup sets classType to ArcadeSprite (both dynamic and static). Yes — the default classType for `PhysicsGroup` is ArcadeSprite, and Sprite has play(). The boot test passed with coins being created and animated (no errors), so no problem there.

Re-run smoke2.

All checks passed:
- ?block bump → used=true, +200, coin +1 ✓
- Stomp ✓ (score 400 = stomp 200 + block 200)
- Coin pickup ✓
- Flag victory + bonus ✓
- No runtime errors ✓

Finally, run the original full smoke test (with the auto-run death + respawn path) one more time to verify everything end-to-end, and verify the final syntax of index.html. After that, wrap up.

Everything's done. Passed all the tests with zero runtime errors. Let me do a quick summary.