We need respond by doing task. Need inspect cwd. Need create index.html self-contained using phaser.min.js present. Need no external resources except local phaser script. Need build playable side-scrolling platformer Mario style: run jump across scrolling platforms, stomp enemies, collect coins, reach goal flag. Procedural graphics only. Need end with index.html present. Need likely use Phaser. Need maybe inspect files.

Need create index.html. Need know Phaser version? phaser.min.js maybe Phaser 3? Need inspect quickly maybe version.

Need craft full game. Need maybe use Phaser 3.60.0. Single index. Need procedural graphics: create textures via Graphics or canvas? In Phaser, Graphics can create shapes as textures. Need game features:
- Side-scrolling platformer, classic Mario style.
- run and jump across scrolling platforms, stomp enemies, collect coins, reach goal flag.
- Procedural graphics no assets.
- Use phaser.min.js local script.
- Responsive maybe 960x540.
- Keyboard controls arrow/A-D, space, R restart.
- Need world larger than viewport, camera follow.
- Platforms, ground tiles maybe generated.
- Coins, enemies (goomba-like), flag.
- Stomp enemies: if falling and collides enemy top, enemy defeated and bounce. Else player hurt/respawn.
- Collect coins increment score.
- Goal flag triggers win.
- Physics Arcade.
- Procedural graphics: generate textures for player, ground, platform, coins, enemy, flag, cloud, bush maybe.
- Need maybe include overlay UI.

Need produce code. Could write directly. Need ensure code works. Need think about Phaser APIs.

Potential issue with Arcade physics and dynamic tilemap? Simpler: create staticGroup for platforms with body immovable. Player dynamic. Enemies group dynamic? Need set collide world bounds. Platforms maybe group of rectangles with generated textures.

Need generated textures:
- player: maybe 32x48 with red hat, blue overalls, skin face. Use Graphics generateTexture.
- enemy: 32x32 brown mushroom.
- coin: 24x24 gold circle.
- ground tile: 48x48 green top, dirt.
- platform tile: 48x24 brown blocks.
- flag: maybe 16x160 pole and flag.
- cloud/bush.

Need maybe use `this.make.graphics({x:0,y:0,add:false})`.
Phaser 3.60: `graphics.generateTexture(key, width, height)`.

Game:
```
const config = {type: Phaser.AUTO, parent:'game', width:960, height:540, backgroundColor:'#6bbcff', pixelArt:true, physics:{default:'arcade', arcade:{gravity:{y:1000}, debug:false}}, scene:{preload:createTextures, create, update}}
```
Need maybe include CSS for body and canvas.
Script src phaser.min.js then game.

Need world dimensions maybe 3600 x 600. Ground segments and platforms.

Implementation plan:
- Constants:
```
const W=960,H=540,GROUND_Y=480, WORLD_W=3800;
```
- Create background:
  - sky color.
  - parallax layers with tile sprites maybe generated texture forclouds, hills.
  - use `this.add.tileSprite(0, 100, WORLD_W, 200, 'cloud').setScrollFactor(0.25)`? Need width maybe WORLD_W.
  - For far hills as tileSprite.
- Ground:
  - StaticGroup platforms.
  - Add ground segments with width maybe 500, height 80 at y=500? Arcade body from top.
  - Use texture 'ground' repeated with add.image? But static body per image? Could create large ground texture for each segment. Simpler: add platform rectangle with width/height generated? But no external. For ground: create a large texture `groundWide` maybe 48x80. Add images repeated every 48.
  - Need collision body. Could use static physics group with rectangles? `platforms.create(x,y,'groundTile').setScale(1,1).refreshBody()` for each tile. For wide ground, could create a graphics texture with width=tile, then repeated.
  - For collision, each tile has body.
  - Platforms: `addPlatform(x,y,width)` create image/texture? Arcade can use image body automatically. For custom width, generate texture `platformWide`? Create `platformTile` repeated. Add images at x + i*48.
  - Need top surfaces. Use images.

- Gaps: ground segments from 0 to 600, gap 140, 740-1300, gap 120, 1420-1800, gap 180, 1980-2500, gap 160, 2660-3200, gap 100, 3300-3700. Player can jump gaps. Need not too hard.
- Platforms floating:
  - at x 450 y 390 w 250, x 900 y 330 w 220, x 1300 y 390 w 260, x 1780 y 310 w 220, x 2200 y 400 w 260, x 2580 y 320 w 220, x 3040 y 380 w 260, x 3450 y 300 w 220.
- Add question/brick blocks maybe not necessary but Mario style. Could include collectible coins above.

- Player:
  - sprite at 80, 350, 'player'.
  - setBounce(0.05), collideWorldBounds.
  - physics.add.collider(player, platforms)
  - cursor keys and wasd.
  - Jump if onFloor and jump pressed. Use `player.body.blocked.down` or `onFloor`.
  - Horizontal speed maybe 220. If right/left.
  - Coyote? Not necessary.

- Enemies:
  - dynamic group? Add enemies at x 500, 1000, 1600, 2300, 3000, 3500.
  - set velocity x = -80, setBounce(1), setCollideWorldBounds(true). But world bounds huge; they may not turn unless collision with platform. Need patrol on platforms. Simpler use dynamic physics with `setVelocityX` and if x < minX or > maxX setVelocityX(-current). Or set custom `minX/maxX`.
  - collide enemies with platforms.
  - player-enemy collision callback:
    - if player.body.velocity.y > 0 && player.y < enemy.y maybe stomp.
    - else hurt.
  - On stomp: enemy.disableBody(true,true); spawn coin? bounce player y velocity -450; score += 100; update.
  - Need enemy respawn? no.
  - Enemy can fall into gaps? If body y > H+100 destroy and respawn maybe? We can have patrol boundaries.
  - Collide enemies with platforms; set bounds to world.

- Coins:
  - staticGroup? `coins = physics.add.staticGroup()`.
  - Add coin images; body immovable.
  - overlap player, coins collectCoin.
  - coins collected by `coin.disableBody(true,true)`.
  - Score maybe +10.
  - Place coins above platforms and arcs.

- Goal flag:
  - group? Create pole as graphics line/rectangle? Could use image texture. At x=3680 y=360? Need flag pole height maybe 120, ground y 500; pole top 330. Use `this.add.rectangle(3650, 420, 8, 150, 0xffffff)`? Physics not needed. Add flag texture at 3680, 345.
  - Need base maybe.
  - overlap player with invisible zone or check x > 3600 and on ground. Use `this.physics.add.overlap(player, goalZone, reachedGoal)` where goalZone static image invisible? Or just check in update if player.x > 3650. Better use zone: `this.physics.add.zone(3650, 450, 70, 120); goalZone.setImmovable(true);` and overlap.
  - On goal: stop input, show overlay "You reached the flag!", set player velocity 0.

- UI:
  - score text at top-left, coins count maybe.
  - instructions bottom.
  - Use CSS.
  - On win show overlay div? Could use Phaser text.
  - If lose? Lives? Could have 3 lives. On hurt, respawn at last checkpoint. Classic. Need maybe implement lives/respawn.
  - Add lives = 3. Hurt if enemy side collision or fall into gap. Respawn at checkpoint. Checkpoints at ground segments maybe every 700. If fall below 620, hurt.
  - On hurt: lives--; if lives <=0 gameOver; else respawn at latest checkpoint.
  - Need not too complex.
  - Checkpoints update when player.x passes certain x. Maybe `checkpoint = 60`.
  - `respawn()`:
    - player.setPosition(checkpoint, 350); setVelocity(0,0); setTint briefly.
  - On hurt, maybe invincible timer 1.5 seconds; flicker.
  - Score maybe not reset? Could.
  - Need enemies maybe if player hurt, keep. Fine.
  - If lives lost, maybe not reset coins? Could leave.
  - Need avoid repeated enemy collision during invincibility.

- Procedural graphics:
  - Need create textures in preload or create? In Phaser, textures can be generated in create before use. But if using preload? We can generate in `preload()` scene method. `preload` can call `this.createProceduralTextures()`? Since scene has `this`.
  - Need maybe use `this.textures.exists`.
  - Use Graphics:
```
createTextures() {
 let g = this.make.graphics({x:0,y:0,add:false});
 g.fillStyle(0x6bbcff); g.fillRect(0,0,960,540); g.generateTexture('sky',960,540); g.clear();
 ...
}
```
  - But no need sky texture. Use background color.
  - For ground tile:
```
g.fillStyle(0x6b3f1e); g.fillRect(0,12,48,36); ...
for i ...
g.lineStyle(2,0x53a638); g.beginPath(); g.moveTo(0,12); g.lineTo(48,12); g.strokePath();
g.fillStyle(0x4caf50); g.fillRect(0,0,48,12);
g.generateTexture('groundTile',48,48);
```
  - For platform tile 48x32:
```
g.fillStyle(0x9c4f24); fillRect; lineStyle; fillStyle(0xd18041); fillRect top; generate.
```
  - Player:
```
g.fillStyle(0xe53935); fillRect(8,0,24,10); // hat
g.fillStyle(0xffcc80); fillRect(10,10,20,12);
g.fillStyle(0x0d47a1); fillRect(8,22,24,18); // overalls
g.fillStyle(0xffcc80); fillRect(4,20,8,18); // arm
g.fillStyle(0x111); fillCircle(15,16,2); ...
g.generateTexture('player',36,48);
```
  - Enemy:
```
g.fillStyle(0x8d4a25); fillRect(4,8,32,24); fillCircle? Phaser Graphics has fillCircle. Body cap. eyes white/black. feet.
```
  - Coin:
```
g.fillStyle(0xffd23f); fillCircle(16,16,12); fillStyle(0xfff176); fillCircle(12,12,6); lineStyle(3,0xf9a825); strokeCircle(16,16,12);
```
  - Block maybe:
```
'block' 48x48 yellow with question mark.
```
  - Flag:
```
pole maybe use rectangle directly, no texture. flag texture 64x42 with red triangle/rect.
```
  - Clouds/hills:
```
cloud texture 160x70: circles.
hill texture 240x120: arc.
bush texture 120x50.
```
  - maybe tileSprite with textures.

Need ensure generated textures are available before create? If called in preload, after preload done create. Good.

Need maybe local script:
```
<script src="phaser.min.js"></script>
<script>
(() => { ... new Phaser.Game(config); })();
</script>
```
No external.

Need maybe not use `<meta>`? Fine.

Need maybe include `touch` controls? User asks playable. Could add on-screen buttons for mobile? Nice. But no need. Maybe include pointer controls? Could implement touch buttons to jump/left/right. But platformer likely keyboard. Could include "Tap / hold buttons" maybe. Since self-contained. But maybe too much.

Need ensure `physics.add.collider(player, platforms, ...)` callback maybe not needed. `platforms` staticGroup with many images.
Need `this.physics.world.setBounds(0,0,WORLD_W,600)`.
Need `this.cameras.main.setBounds(0,0,WORLD_W,600); this.cameras.main.startFollow(player,true,0.08,0.08);`
Need background parallax. If tile sprites scrollFactor 0, they remain fixed? We want parallax. Use `tileSprite.setScrollFactor(0.2)` maybe. But tileSprite width WORLD_W; as camera moves, scroll factor controls. Need maybe set at x = WORLD_W/2.
```
this.add.tileSprite(WORLD_W/2, 90, WORLD_W, 220, 'cloud').setScrollFactor(0.18);
this.add.tileSprite(WORLD_W/2, 430, WORLD_W, 130, 'hill').setScrollFactor(0.35);
```
But tileSprite with scrollFactor maybe okay. Need if width WORLD_W and scrollFactor .18, parallax.
Need maybe add foreground ground? Fine.

Need create `platforms` and `coins` after textures.
Need use `this.add.image(x, y, 'groundTile').setDisplaySize(48,48)`; Arcade body size? If display size changes from texture 48x48 no issue. For ground tiles display size same. For platform tile same.
Need maybe `setOrigin(0.5,0.5)` default. If platform tile at y=390, top at y -16. Ground tile at y=500, top at 476, not GROUND_Y 480. We'll set ground tile y=500 for 48 tile, top=476. Player height 48, origin center, bottom at y+24. Ground top 476, player y 452. Good.
Maybe ground top at 480? Tile 48, y=504. But use 500.
World height 600.

Ground segments:
```
const groundSegments = [
 {x:240, w:620}, {x:840,w:500}, {x:1480,w:520}, {x:2150,w:540}, {x:2820,w:480}, {x:3420,w:520}
];
function addGroundSegment(x,w) {
 for (let gx = x; gx < x+w; gx += 48) add tile at gx+24, GROUND_Y+24
}
```
Need maybe left start ground from 0 to 620.
Gaps:
- 0-620 ground.
- 760-1240 ground.
- 1400-1900 ground.
- 2050-2550 ground.
- 2700-3180 ground.
- 3320-3700 ground.
Gaps 140-200. Jump distance with speed 230 and jump 520, horizontal 230*~1s=230, okay.
Need ground y maybe 500.

Need platforms:
- maybe `addPlatform(420,390,240);` top at 374, player can jump from ground at 476 to platform top 374 diff 102, okay.
- Add blocks:
```
addBlock(520, 340); addBlock(568, 340); addBlock(616, 340);
```
Maybe collectible coins above.
- Need coin placements:
```
addCoinLine(430, 350, 220, 6)
addCoinArc(900, 300, 220)
...
```
Need ensure coins reachable.

Need blocks maybe `this.physics.add.staticGroup()`? Blocks immovable. Could be static group. Need player collide with blocks too. Add to platforms group? We can use same staticGroup `platforms` with block images.
- Generate block texture:
```
'block': 48x48 gold, question mark.
```
- Add blocks at y=350, etc. They are platform.

Need maybe "classic Mario style" not use Mario assets. We'll call "Super Coin Quest" maybe.

Need UI overlay:
```
this.scoreText = this.add.text(16,16,'Coins: 0\nLives: 3',{font:'20px monospace', fill:'#fff', stroke:'#000', strokeThickness:4}).setScrollFactor(0).setDepth(100);
this.message = this.add.text(W/2,H/2,'',{...}).setScrollFactor(0).setDepth(200).setVisible(false);
```
Need maybe top center "Reach the flag!".
Need maybe camera not scroll UI due setScrollFactor(0).

Need update:
```
const left = keys.left.isDown || keys.a.isDown;
const right = keys.right.isDown || keys.d.isDown;
const jump = keys.up.isDown || keys.w.isDown || keys.space.isDown;
if (!gameWon && !gameOver) {
 if (left) { setVelocityX(-SPEED); setFlipX(true); }
 else if (right) ...
 else setVelocityX(0);
 if (jump && player.body.touching.down && jumpTimer <= 0) { setVelocityY(-JUMP); }
}
if (player.y > H+120) loseLife();
if (player.x > checkpoint + 300) checkpoint = player.x;
if (player.x > 3600) reachedGoal();
if (hurtCooldown >0) { hurtCooldown -= delta; player.setVisible(hurtCooldown % 0.15 < 0.075); } else player.setVisible(true);
```
Need maybe `jumpTimer` if holding jump? Arcade body `touching.down` enough; but can bounce. We can just if jump && onFloor. Need avoid repeated? onFloor.
Need maybe `player.body.blocked.down`.
Need `player.body.touching.down` property. In Arcade.

Enemy patrol:
```
enemies = this.physics.add.group({allowGravity:true, bounce:{x:1,y:0}, collideWorldBounds:true});
function addEnemy(x, y, minX, maxX) {
 let e = enemies.create(x,y,'enemy');
 e.setBounce(1,0);
 e.setCollideWorldBounds(true);
 e.minX = minX; e.maxX=maxX; e.setVelocityX(-70);
}
```
Update:
```
enemies.children.iterate((enemy) => {
 if (!enemy.active) return;
 if (enemy.x < enemy.minX) enemy.setVelocityX(70);
 if (enemy.x > enemy.maxX) enemy.setVelocityX(-70);
 if (enemy.y > H+100) { enemy.setPosition(enemy.minX + 40, 350); enemy.setVelocityX(70); }
});
```
Need maybe `enemy.body.updateWorldVector()`? Not necessary.
Need enemy collide with platforms.
Need `this.physics.add.collider(enemies, platforms);`
Need `this.physics.add.collider(player, platforms);`
Need `this.physics.add.collider(enemies, platforms);`
Need maybe if enemy falls into gap, reset.

Collision callback:
```
this.physics.add.overlap(player, enemies, this.hitEnemy, null, this);
function hitEnemy(player, enemy) {
 if (this.hurtCooldown >0) return;
 if (player.body.velocity.y > 0 && player.y < enemy.y - 8) {
    enemy.disableBody(true,true);
    this.score += 100;
    this.spawnBurst(enemy.x, enemy.y, 0xffe082);
    player.setVelocityY(-420);
    updateHUD();
 } else {
    this.loseLife();
 }
}
```
Need maybe if player stomps enemy while enemy disabled? disabled no overlap.
Need `this.spawnBurst` maybe create particles? No external. Could create temporary small circles using graphics? Use group of small sprites? Simpler use `this.add.circle` and tween alpha, destroy.
```
for i 0..5: const dot=this.add.circle(x,y,4,color).setDepth(30); this.tweens.add({targets:dot, x:x+rand, y:y+rand, alpha:0, duration:500, onComplete:()=>dot.destroy()});
```
Need maybe no external.

Coin collect:
```
this.physics.add.overlap(player, coins, (player, coin)=> {
 coin.disableBody(true,true);
 this.score += 10; this.coinsCollected++; updateHUD(); this.spawnBurst(coin.x, coin.y, 0xffeb3b);
});
```
Need staticGroup.

Goal:
```
this.goalZone = this.physics.add.zone(3650, 430, 80, 120);
this.goalZone.setImmovable(true);
this.physics.add.overlap(player, goalZone, this.reachGoal, null, this);
```
Need maybe flag at x=3650.
`reachGoal`:
```
if (this.gameWon) return;
this.gameWon=true;
this.player.setVelocity(0,0); this.player.setTint(0xffff00);
this.physics.pause();
this.message.setText('Flag reached!\nCoins: ... Score: ...\nPress R to play again');
this.message.setVisible(true);
```
Need maybe keep camera at goal.

Restart:
```
this.input.keyboard.on('keydown-R', () => this.scene.restart());
```
Need maybe if game over.
`loseLife`:
```
if (this.hurtCooldown >0 || this.gameWon || this.gameOver) return;
this.lives--;
updateHUD();
if (this.lives <=0) {
 this.gameOver=true;
 this.physics.pause();
 this.player.setTint(0x777777);
 this.message.setText('Game Over\nPress R to restart');
 this.message.setVisible(true);
 return;
}
this.hurtCooldown = 1.5;
this.player.setPosition(this.checkpoint, 360);
this.player.setVelocity(0,0);
this.cameras.main.fade(150, 0,0,0);
this.cameras.main.once('camerafadeoutcomplete', () => {
  this.cameras.main.fadeIn(300);
});
```
Need avoid setting position during physics? okay.
Need maybe checkpoint at 60 initially. But if player falls in first gap, respawn at 60.
Need maybe `player.setPosition` and `cameras.main.startFollow`.

Need maybe on screen controls:
- HTML div overlay? Could create within canvas? Simpler create Phaser text/buttons? But not necessary. But user says playable; keyboard enough. However, "runs fully sandboxed no network" okay. Could include on-screen controls for mobile pointer:
```
this.leftPad = this.add.rectangle(110, 500, 90, 60, 0xffffff, 0.25).setScrollFactor(0).setInteractive({useHandCursor:true});
...
this.input.on('pointerdown', (pointer)=> { if pointer within ... })
```
But Phaser pointer can track; need implement. Maybe not needed. But could be nice. Need ensure no external.

Maybe simpler add HTML buttons with CSS? But self-contained. However, script can add event listeners to divs. But maybe too much. Since single file, keyboard playable.

Need maybe implement "touch controls" with Phaser rectangles:
- `touchControls` group. Buttons at bottom left/right, jump right.
- Use `this.input.addPointer(2);`? Not needed.
- `const controls = {left:false,right:false,jump:false}`.
- `createTouchButton(label,x,y,w,h,action)`:
```
const bg = this.add.rectangle(x,y,w,h,0xffffff,0.25).setScrollFactor(0).setDepth(101);
const text = this.add.text(x,y,label,...).setOrigin(.5).setScrollFactor(0).setDepth(102);
bg.setInteractive();
bg.on('pointerdown', () => { this.input.activePointer.isDown? controls[action]=true : ...});
bg.on('pointerup', ()=> controls[action]=false);
bg.on('pointerout', ()=> controls[action]=false);
```
But pointerup outside maybe not. Could use global pointer update:
```
this.input.on('pointerdown', pointer => {
 for button if Phaser.Geom.Rectangle.ContainsPoint(button.rect, pointer) ...
});
this.input.on('pointerup', pointer => { reset all; });
```
Need button rects in screen coords. But no need.

Potential issue with `this.physics.add.staticGroup()` and using `create` with image. Works.
Need maybe `platforms.children.iterate`? Not needed.

Need maybe body sizes:
- Player generated 36x48, physics body default 36x48. Good.
- Enemy 40x32.
- Coins 24x24.
Need maybe player can stand on platform top. Good.

Need maybe `this.physics.add.collider(player, platforms);` no callback. Need if platforms includes invisible goal zone? no.
Need maybe `this.physics.add.collider(enemies, platforms);`
Need maybe `this.physics.add.collider(player, blocks)` if blocks in platforms.

Need maybe `this.physics.add.overlap(player, coins);`
Need maybe `this.physics.add.overlap(player, goalZone);`
Need maybe `this.physics.add.overlap(player, enemies, this.hitEnemy, null, this);`
Need maybe `this.physics.add.collider(player, enemies, this.hitEnemy, null, this)`? Overlap is enough; collision not needed. Since enemies dynamic, overlap still triggers even if bodies overlap; yes.

Need maybe `this.physics.add.collider(enemies, enemies)`? Not necessary.
Need maybe `this.physics.add.collider(player, goalZone)`? Not needed.

Need maybe "stomp enemies" with classic Mario style. Good.

Need maybe "scrolling platforms" maybe camera follows and platforms scroll. Good.

Need maybe "procedurally generated graphics" no external. Good.

Need maybe "goal flag" visible. Good.

Need maybe "collect coins" score. Good.

Need maybe "reach flag" win. Good.

Need maybe "run and jump" controls. Good.

Need maybe include README? no.

Need maybe inspect if file exists? no. We'll write.

Need ensure code no external network. The only external resource is local phaser.min.js. CSS/JS inline. Good.

Need maybe maybe local phaser script before script. Good.

Need maybe use exact filename `phaser.min.js` in script src. Good.

Potential issue with generated texture names and `Graphics` fill functions. Need Phaser 3.60 API:
- `this.make.graphics({ x: 0, y: 0, add: false })` yes.
- `g.fillStyle(color, alpha)` yes.
- `g.fillRect(x,y,w,h)` yes.
- `g.fillCircle(x,y,radius)` yes.
- `g.lineStyle(width,color,alpha)` yes.
- `g.strokeCircle`, `g.beginPath`, `g.moveTo`, `g.lineTo`, `g.strokePath()` yes.
- `g.fillTriangle`? yes maybe.
- `g.generateTexture('key', width, height)` yes.
- `g.destroy()` yes.
Need maybe `Graphics` has `fillRoundedRect`? Avoid.
Need maybe `this.add.text` with stroke. Good.
Need maybe `this.add.rectangle` with interactive? yes.
Need maybe `this.input.keyboard.createCursorKeys()` returns object. Also `this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE)`. Good.
Need maybe `this.input.keyboard.addKeys('A,D')`? Use `Phaser.Input.Keyboard.KeyCodes`.
```
this.keys = this.input.keyboard.addKeys({
  left: Phaser.Input.Keyboard.KeyCodes.LEFT,
  right: Phaser.Input.Keyboard.KeyCodes.RIGHT,
  up: Phaser.Input.Keyboard.KeyCodes.UP,
  down: Phaser.Input.Keyboard.KeyCodes.DOWN,
  a: Phaser.Input.Keyboard.KeyCodes.A,
  d: Phaser.Input.Keyboard.KeyCodes.D,
  w: Phaser.Input.Keyboard.KeyCodes.W,
  s: Phaser.Input.Keyboard.KeyCodes.S,
  space: Phaser.Input.Keyboard.KeyCodes.SPACE,
  r: Phaser.Input.Keyboard.KeyCodes.R
});
```
Works.

Need maybe `this.input.keyboard.on('keydown-R', () => this.scene.restart());` after keys. Good.

Need maybe `this.scale` config? Could set `parent: 'game', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, width: 960, height: 540 }`. Since no external. Good.
Need maybe `dom` no.
Need maybe canvas crisp. Use pixelArt true.

Potential issue with local `phaser.min.js` in /tmp/ws and index.html. Good.

Need maybe use `Phaser.Scale.RESIZE`? If using FIT, game canvas fits. Fine.

Need maybe `window`? no.

Need maybe no audio. Good.

Need maybe "classic Mario style" could include question blocks and pipes. We can add pipes as procedural rectangles:
- Add pipe obstacles at x=1250, y=430, width 64, height 70; maybe platform collision? Use static rectangle body? Could use `this.physics.add.staticGroup()` with `add.rectangle`? Arcade can add body to Rectangle? I think Rectangle doesn't have physics body automatically? Actually Arcade physics supports GameObjects with body? `this.physics.add.existing(rectangle, true)` maybe. But not needed. Could create `pipe` texture and add image. Use static group.
- Generate `pipe` texture 64x96 green pipe. Add pipes at ground. Nice.
Need maybe not overcomplicate.

Need maybe "scrolling platforms" plural. Good.

Let's draft index.html. Need maybe test syntax. We can write then maybe use browser? No browser. Could use node to parse? Maybe not.

Need maybe check if Phaser not loaded due CORS? local okay.

Need maybe include `aria`? no.

Let's write.

Need verify file present. Maybe test with grep? Need maybe run local server? Could use node? Need maybe ensure no syntax errors. We can use node to parse JS? Since HTML includes DOM? Maybe use `node --check` extracting script? Or use grep. Could run simple static checks. Maybe use `python` to extract script? There is no browser. We can run `python3 - <<` to extract script and maybe use node --check. But script references Phaser globals; syntax check okay. Need maybe use `node --check` on extracted JS. Let's do.

python3 absent. Need use node to extract. But created empty index.script.js? Actually failed? Let's see maybe no. Use node.

Node check no output means syntax ok. Need maybe inspect file maybe okay. But let's consider potential runtime issues.

Potential issue: `this.add.tileSprite(WORLD_W / 2, 95, WORLD_W, 220, 'cloud').setScrollFactor(0.18).setDepth(-10);` TileSprite can have negative depth. Fine.
Potential issue: `this.add.image(...).setScale(Phaser.Math.FloatBetween(0.9, 1.25))` for bush. It sets body? It's just image no physics. Fine.
Potential issue: `this.addPipe`: creates pipe image with texture 64x96, sets y = GROUND_Y - height/2. Since origin 0.5, bottom y+48*scale = GROUND_Y - h/2 + h/2 = GROUND_Y. Good. Arcade body scale? `refreshBody` after setScale should update. Good.
Potential issue: `this.physics.add.staticGroup()` before `this.physics.world.setBounds` okay.
Potential issue: `this.add.rectangle` no physics. Fine.
Potential issue: `this.goalZone = this.physics.add.zone(...)` after physics. It is a zone with body. `overlap` with player works.
Potential issue: `this.physics.add.overlap(this.player, this.goalZone, this.reachGoal, null, this);` Should work.
Potential issue: `this.input.keyboard.addKeys` object with property names maybe returns object with keys. Good.
Potential issue: `this.input.keyboard.on('keydown-R',...)` maybe event name is 'keydown-R' or 'keydown-R'? Phaser docs uses `this.input.keyboard.on('keydown-SPACE', ...)` maybe yes.
Potential issue: `this.touch.jump` with keyboard `jump` variable. Good.
Potential issue: touch buttons setScrollFactor(0), but their positions are in screen coords? In Phaser, rectangles are world objects with scrollFactor 0, so screen coords. Good.
Potential issue: `bg.on('pointerout')` may fire while pointerdown? It resets. Fine.
Potential issue: `this.physics.add.staticGroup()` no `classType`, create with key works.
Potential issue: `this.platforms.create` returns image with body. Good.
Potential issue: `this.addPlatform(1500,390,288)` width multiple of 48 (6). Good. `addPlatform(3380,385,260)` not multiple of 48 (5.416). Loop: px=3380,3428,3476,3524,3572; all <3640. Last tile center 3596. width covers 3572-3620, platform ends 3640? Actually 3380+260=3640, loop stops at 3620, leaves 20 gap. Not critical. Could set width 240 or 288. Maybe better make all widths multiples. Same 240, 288. 260 not multiple. Need maybe adjust to 240? Could. But not necessary. However, maybe addPlatform width should be multiple. Let's patch 260 to 240 or 288. Since goal at 3670, platform from 3380 to 3620 leaves 50 gap before flag, okay. But if 240 ends 3620. Same. If 288 ends 3668, closer. Let's set 288. Need unique edit.
Potential issue: `addCoinLine(3390,345,240,6)` okay.
Potential issue: `enemySpawns`: enemy at x=960 y=330-34 = 296, platform top y=330, enemy height 34, bottom 313? Wait origin center, y center 296, body height 34, bottom 313, platform top 314 (y=330 center, height 32 top=314). Good.
Potential issue: enemy at y=325-34=291, platform top=309, enemy bottom=308, good.
Potential issue: player spawn at y=350, ground top 476, player height 48, bottom=374. It falls. Good.
Potential issue: `this.player.setBounce(0.04)` maybe okay.
Potential issue: `loseLife` when falling below world, set position to checkpointX (which might be current x if passed +220). If checkpointX is not on ground maybe if player on platform? Actually checkpoint updates every 220; could be in air over gap. If player falls, checkpointX might be in gap, respawn in air. But next fall maybe. We can update checkpoint only when on floor? But okay. Could update if player.body.touching.down. Better:
```
if (this.player.body.touching.down && this.player.x > checkpointX+220)...
```
But if on platform, okay. Need maybe use ground/ platform. Let's patch to avoid checkpoint in midair. 
Potential issue: `this.player.setPosition(this.checkpointX, 350);` If checkpoint on platform top, y=350 maybe not correct; if checkpoint on ground, okay. If on platform, maybe spawn above platform. Could be okay. But if checkpoint on platform at y=390, spawn y=350 above top 374, falls onto platform. Good. If ground, top 476, spawn y=350, falls. Good.
Potential issue: `hurtCooldown=1500`, but update subtracts delta in ms, so 1.5 sec. Good.
Potential issue: `this.player.setVisible(Math.floor(this.hurtCooldown * 18) % 2 === 0);` if hurtCooldown decreases, flicker. Good.
Potential issue: `this.physics.pause()` after game won stops all physics incl enemies. Good.
Potential issue: `this.player.setTint(0xffff99)` after game won. If game restart scene restart resets.
Potential issue: `this.physics.add.collider(this.player, this.platforms);` includes pipe, blocks. Good.
Potential issue: `this.physics.add.collider(this.enemies, this.platforms);` enemies collide with pipes? Good.
Potential issue: `this.physics.add.overlap(player, enemies)` while player is invincible after losing life but enemy still could overlap; callback returns. Good.
Potential issue: `this.cameras.main.flash` on lose life. Good.
Potential issue: `this.add.text` with hearts maybe system font, okay.
Potential issue: no audio. Good.

Need maybe patch platform width and checkpoint.

Need maybe syntax check again.

Need maybe maybe final concise. But before final, maybe inspect maybe no accidental index.script. Already removed. Need maybe maybe run `ls` to ensure only index and phaser.