We need respond by building file index.html in current dir. Need inspect? Need create single-page web app. Need be concise but likely need implement. We can use tools. Need final mention. Need maybe create index.html. Need think through requirements: playable tile-based platformer on canvas in Dangerous Dave style. Need navigate level to grab trophy then reach exit, avoid fire and water, jumping and simple enemies. Procedural graphics only, no external assets. Single self-contained index.html in /tmp/ws. Need include CSS JS inline, no external resources. Need probably make robust. Need maybe write file. We need maybe inspect current dir.

Need write index.html. Need implement platformer.

Let's plan thoroughly. Need deliver a complete HTML file. Need canvas. Controls maybe WASD/arrow/A/D jump. Need level tile-based. Need trophy required then exit. Hazards fire/water. Simple enemies. Procedural graphics. No assets.

Need maybe write a decent game. Need ensure playable. Need perhaps use canvas 960x540, tile size 32. Game loop with fixed delta. Physics: tile collision, gravity, movement. Level maybe 20x12. Need hazards water/fire as tiles. Enemies patrol platforms. Player collects trophy, then exit opens. Win when has trophy and in exit. Lose on hazards/enemies. Need restart.

Need design level:
tile grid 24 columns x 14 rows? tile 32 => 768x448. Need canvas with maybe 768x448 and UI overlay. Tile-based.
Ground platforms. Fire tiles maybe small tiles on ground. Water pits? Tile hazards.
Enemies on platforms.
Need draw procedural graphics: blocks, lava, water, trophy, exit, Dave.

Need implement robust collision:
- map is array of strings rows, chars:
'#' solid
'.' empty
'W' water hazard? tile
'F' fire hazard? tile
'E' enemy spawn
'T' trophy
'X' exit
'P' player spawn
'-' maybe spike? But avoid hazards like fire/water only.
Need place solid ground and platforms. Could use strings with #. Need 2D char map.
Need tile sizes.

Potential issue with tile hazards inside solid? Fire on floor? For water as pits? If water tile at floor replacing solid, player can fall into water and lose. But if no solid underneath, falling into water; collision if player intersects. We can treat water/fire as hazard tile if player's AABB overlaps, regardless solid. Fire tiles as hazard.

Need collision detection:
- Move player by dx then dy.
- Check collision against solid tiles. For x: set x += dx, compute tiles overlapped, if any solid, resolve x to side based dx. For y: set y += dy, if any solid, resolve y to ground or ceiling.
- Player size maybe 20x26, spawn x=1.5? Tile coordinate.
- Use pixel coords with tileSize.
- Physics: vx, vy. Acceleration: left/right, jump. friction, max speed, gravity. Jump if on ground.
- On ground detection by collision resolution.
- Water hazard maybe tile with y rows 11-12? Need pits. If water tile replaces ground, player falls. But if we use water hazard tile, it is not solid; if player intersects, lose. Need ensure not possible to walk through.
- Fire hazard: tile(s) on floor or platform. If player intersects, lose.
- Enemies: spawn object at tile coordinates. Move horizontally with speed, bounce at solid tile boundaries or reversals. Enemy radius/rect maybe 22x22. Collision if intersects player.

Need procedural graphics: draw map, tiles, hazards, trophy, exit, enemies, player, particles maybe. Need no external assets. Need maybe use canvas shapes.

Need maybe include instructions overlay. Need "Dangerous Dave style" maybe retro pixel-ish, colorful, blocks, red-haired Dave, trophy, exit. Need maybe no copyrighted exact? "Dave style" is okay. Need maybe use ASCII? Fine.

Need ensure final file present. Could write full HTML. Need maybe use write. We'll craft.

Need maybe test by serving? We can inspect syntax with node? Browser features maybe. We can run maybe no external. Need maybe use js syntax. We can maybe use `node --check index.html`? HTML not JS. Could extract script? But can use browser? no. We'll just write.

Need design map. Let's define constants:
const TILE=32, COLS=24, ROWS=14. Canvas 768x448. CSS background black, etc.
Map rows:
0: "########################"
1: "......................#."
2: "....................#..."
3: "............###........."
4: "..............#........."
5: "....###.........###....."
6: "....#.#..P....#..#..T... #"? Need no spaces? Use string length 24. Need careful.
Let's define rows with 24 chars. Use helper? Need no spaces? String can include spaces as empty? Better use `.` for empty, `#` solid, hazards. Need all length 24. Let's build.

Maybe 24 cols x 14:
0 "########################" (24)
1 "......................#." (23 dots + # + . =25? Need count)
Let's systematically use Python to generate level. But can write in JS manually. Better use a map array in JS and maybe a function assert length? But if length wrong maybe. We'll use Python to create rows and visualize.

No python3. Use node maybe.

Rows 6-12 too long. Need adjust. We'll create levels manually maybe with 22 cols? Need consistent. Let's use 22 columns? Top row 22. 22x14. Canvas 704x448. Fine. Need row lengths 22.

Let's craft with 22 chars:
0 "######################" (22)
1 "......................" (22)
2 "....................#." (20+? actually 20 dots + # + . =22)
3 "............###......." (12 dots + 3 # + 7 dots =22)
4 "..............#......." (14 dots + # + 7 dots =22)
5 "....###.........###..." (4+3+9+3+3=22)
6 "....#.#..P....#..#..#." (4+1+1+2+1+1+4+1+2+1+2+1+1? Let's count)
Use node.

Need trophy, exit. Row 6: `....#.#..P....#..#..#.`, no trophy/exit. Need place T and X. Could row 6: 22. Need maybe `....#.#..P....#..#..TX#.`? length? Let's craft. Need X exit on right maybe row 6 col 20, T row 6 col 17. Need row length. `....#.#..P....#..#..T.X#` count?

Too long. Need 22. Replace last `T.X#` with `T.X` maybe row 6 ends with T.X no solid? Need exit on tile col 20 maybe X, col21 empty. Row 6 length: `....#.#..P....#..#..T.X` count?

Need remove one char. `....#.#..P....#..#...T.X`?

Need shorter by remove more. Original `....#.#..P....#..#..#.` length 22. Need include T and X and maybe remove some. `....#.#..P....#..#..T#` count?

Need X exit. Use `...TX` maybe no solid. Good. Row 6 `....#.#..P....#..#..TX` length 22. Then player spawn at col7, T col19, X col20. Good. Exit at tile col20 row6, maybe no solid? It is at floor? Need row6 col20 X, col21 empty. If player reaches exit tile maybe not solid, okay.

Need hazards. Fire/water. Add F tiles. Row 7 maybe fire on platform: `....#.#.....###..F..#.`, row 8 water pit? Row 8 maybe `....###.....#...###..W.`? Need water hazard. Could have water tile in bottom row? Row 12 `.........#####...###..` no. Add water in row 11? But if not solid, player falls into water maybe. Need maybe a pit at right: row 7 col? Let's create water tiles in lower row, not solid. Row 11: `.........#..E.#...#..W.`? Row 11 length? Need count.

23 too long. Need 22. Original row 11 `.........#..E.#...#...` length 22. Need insert W and maybe remove. `.........#..E.#...W..#` count?

Good. Row 11 with water tile at col? `.........#..E.#...#..W` length 22. But W not solid, maybe adjacent to solid at col18? If player falls into water col20 row11. Need not block path. Good.

Need fire hazard maybe row 7 `....#.#.....###..F..#.` length?

Original row 7 length 22. Good. Fire at tile row7 col17? Player may cross.

Need maybe row 8 with water hazard? Water hazard tile can be in pit row 11. Good.

Need enemy spawn at row 11 col? `E` tile. Enemy can walk on tile row 11? Need solid underneath row 12. At col? Let's count: `.........#..E.#...#...`:
0-8 dots, 9 #, 10 dot,11 dot,12 E,13 dot,14 #,15-17 dots,18 #,19-21 dots. So enemy at col12, row11, under solid row12 col12? Row12 `.........#####...###..`: col9-13 #. So enemy on solid. Good.
Need maybe another enemy? Could add E at row8 col16? `....###.....#...###..E`? Need length.

Add enemy at row8 col19 maybe. Good. Need maybe fire row7. Need water row11. Need trophy row6. Good.

Need maybe collision with hazards on solid? Fire tile at row7 col? row7 `....#.#.....###..F..#.`:
0-3 dots, 4 #,5 dot,6 #,7-11 dots,12-14 #,15-16 dots,17 F,18-19 dots,20 #,21 dot. Fire on no solid? Row8 col17? row8 `....###.....#...###...`: col17? Let's count row8: 0-3 dots, 4-6 #,7-11 dots,12 #,13-15 dots,16-18 #,19-21 dots. Row7 col17 fire has no solid row8 col17, so it's hanging in air. Not useful. Need fire on solid platform. Need place F where row+1 solid. Row6 has solid at col6? row7? For row7 fire, need row8 col? solid. Row8 solid at 4-6,12,16-18. So row7 F should be at col16,17,18 maybe above row8 solid. But row7 col16 dot,17 dot,18 dot. Set F at col17. Then row7 string: dots 0-16, F at17, dots 18-19, # at20, dot21: `................F..#.` length?

`................#F..#.` length 22 but has solid at col16 and fire at col17, row8 solid at col17? row8 col17 is #. Good. But row7 col16 #, row7 col17 F, row7 col18 dot, col19 dot, col20 #. This means fire tile at row7 col17 on platform. Good. Row7 original `....#.#.....###..F..#.` replaced with `................#F..#.`? But this changes level: removes left platforms? It's okay maybe. But row7 originally had solid at col4,6,12-14,20. We only need row8? Need row7 as floor for player to reach? Let's map.

Better perhaps add fire on row8 solid? Fire tile at row8? Need row9 solid below. Row9 `..........###.#...#...` has solid at col9-11,13,17. Put F at row8 col17 maybe above row9 col17. Row8 string `....###.....#...###..F` length 22. Row8 col17 F, row9 col17 #. Good. That is a fire hazard on platform at x 17. Add. Row8 `....###.....#...###..F`. Then row7 no fire. Good.
Need water hazard maybe row11 W at col20 with row12 col20 #? Row12 `.........#####...###..`: col19-21 #? Let's count: 0-8 dots, 9-13 #,14-16 dots,17-19 #,20-21 dots. Row11 W at col20 has row12 col20 dot, not solid; it's pit water. Good. But if water tile at row11 col20, player can fall from row10? There is solid row10 col20? row10 `.........#....#...#...`: col20 #. So there's a ledge at row10, then row11 col20 water, row12 empty, so water pit under ledge. Good.
Need maybe fire at row8 col17. Need row9 col17 #. Good.
Need maybe trophy at row6 col19, exit col20. Row6 `....#.#..P....#..#..TX` length 22. There is solid at col6,12,16; T at 19, X at20. Row7 col19 dot, col20 #; exit maybe at ledge. Need if player reaches X, trophy required. Good.

Need maybe need top path. Player start row6 col7. Solid at row7 col7? row7 `....#.#.....###..#..#.`? Let's set row7 with platforms: `....#.#.....###..#..#.` length 22. Row7 solid at 4,6,12-14,17,20. Row8 solid at 4-6,12,16-18. So from start at row6 col7, player can fall to row7 col7? Wait row7 col7 is dot, row8 col7 dot, row9 col7 dot, row10 col7 dot, row11 col7 dot, row12 col7 dot. That's a gap. Need maybe row7 col7 should be solid? Original row7 had `....#.#..#.....###...#`? Need design. Player spawn at row6 col7, if row7 col7 solid then standing on floor. Need row7 col7 '#'. Row7 string `....#.#..#.....###..#.` length?

Row7 col7 solid. Good. Row8 col7? row8 `....###.....#...###..F`: col7 dot. So player stands on row7 col7, can jump to platforms. Need row7 col4 solid, col6 solid. Good.
Need row6 solid at col6,12,16. Player at col7 row6 on row7 col7 solid. Good.

Need row8 solid at 4-6,12,16-18, fire at 17. Row8 platform. From row7 col7, jump to row8 col4-6? Maybe. Need row9 solid at 9-11,13,17. Row10 solid at 9,14,17. Row11 solid at 9,12,14,17. Row12 solid at 9-13,17-19. Bottom ground.

Need path to trophy: Start row6 col7. Need reach row6 col19. There is solid at row6 col16, maybe walk to col16, then jump to row6 T at col19? From row6 col16, T at col19, X at col20, gap col18. Need jump. Good.
Need maybe left path to platforms. Not critical if direct path. Need avoid fire/water/enemy. Fire at row8 col17, enemy at row11 col12 and row8 col19. Need enemies.

Need enemy AI:
- Enemy object {x: col*TILE+8, y: row*TILE+8, w:20,h:20, vx, dir, alive}. Move by vx in pixels, if collision with solid tile at new position, reverse.
- Need update maybe dt.

Need collision with enemies:
- player AABB intersects enemy AABB and not invincible maybe lose. Need maybe if player lands on enemy? Could allow stomp? Requirement simple enemies. Could implement if falling fast and player bottom <= enemy top+8, kill enemy, bounce. But if not, lose. Maybe simpler: touch enemy loses. But maybe "simple enemies" okay. Could allow stomp for fun. But if player loses on touch, can restart. Need perhaps implement stomp? It adds gameplay. Could implement invulnerability? But avoid hazards. Dangerous Dave enemies maybe kill. Let's implement enemy collision: if AABB and player's vy > 0 and player's bottom - enemy top < 10, kill enemy, vy=-320, else die. Nice.

Need hazard collision:
- If player's AABB overlaps any F tile or W tile, die. Need water can be hazard if player in water. If falls into water, death. Need maybe after death, reset with message. But if water tile not solid, player can fall into it; hazard collision triggers. Need maybe not "instant" if just touches? Good.
- Fire tile maybe hazard.

Need win:
- if hasTrophy and intersects exit tile (or center within exit tile) then win. Could draw "You won!" overlay.

Need controls:
- Arrow keys / WASD, Space/Up/W jump. Touch buttons maybe optional. But "playable" on keyboard. Need maybe include on-screen controls for mobile? Could include buttons. Need no external. Good.
- Prevent default for keys.

Need game states:
- `state = 'ready'|'playing'|'dead'|'won'`.
- Draw title overlay if ready.
- On keydown Enter/space start/restart? Space also jump; if ready and Space start, else jump.
- On dead, show "You fell into fire/water or met a monster. Press Enter/R to restart."
- On won, show overlay.
- Reset function resets player, trophy, enemies, hasTrophy false, state playing maybe.

Need maybe if user holds jump, jump only on press; need `keys.jumpPressed` boolean. Use keydown event set `jumpQueued=true` if not already. In update if jumpQueued && onGround => vy=-JUMP. Then clear each frame.
Need handle key repeat: if keydown and keys[code] false set jumpQueued.
Need `keys` object.

Need maybe use `requestAnimationFrame` with delta. `lastTime` update. Need avoid huge delta.

Need collision functions:
```
function isSolidAt(tx,ty){
 if(tx<0||ty<0||tx>=COLS||ty>=ROWS) return true;
 return map[ty][tx]==='#';
}
function tileAt(x,y) { floor(x/TILE), floor(y/TILE) }
function playerAABB()...
function rectsOverlap(a,b)
```
For collision resolution:
```
function moveEntity(e, dx, dy, solidFn) {
 e.x += dx;
 let hitsX=false;
 for each tile overlapped by e AABB:
   if isSolidAt:
      if dx > 0: e.x = tileX*TILE - e.w; if hitsX e.x += dx? Need store previous? 
```
Simpler:
```
function resolveAxis(e, axis) {
 let min = Math.floor(e.x/TILE), max = Math.floor((e.x+e.w-0.001)/TILE); etc
 for each tile:
   if solid:
      if axis==='x':
        if dx > 0: e.x = tileX*TILE - e.w - 0.001; else e.x = (tileX+1)*TILE + 0.001;
      else:
        if dy >0: e.y = tileY*TILE - e.h; e.onGround=true;
        else: e.y = (tileY+1)*TILE; e.vy=0;
```
Need loop through all hits; if multiple, last may override. Use current. Could use previous. Better:
```
function movePlayer(dt) {
 vx += ...
 let stepX = vx*dt; let stepY = vy*dt;
 e.x += stepX; resolveX();
 e.y += stepY; resolveY();
}
```
Need if `e.x` starts as tile-based. For x collision, if dx > 0, set x to tileX*TILE - w. If dx<0, set x to (tileX+1)*TILE. If dx=0 no.
For y, if dy >0 set y=tileY*TILE - h; onGround true. If dy<0 set y=(tileY+1)*TILE; vy=0.
Need loop through tiles; if multiple solids, last maybe. But okay. Need avoid falling through due to dt. Use max speed. Could substep? dt capped 0.033, vy max maybe 900, movement 30 px < tile. Good.
Need `onGround` false at start y resolution.

Need hazard detection after movement. But if player inside fire/water, die. Need maybe `state='dead'` and `deathText`.
Need collision with enemy after hazard maybe.

Need spawn:
```
player = {x: 7*TILE+5, y:6*TILE-26, w:20,h:26, vx:0,vy:0, onGround:false}
```
Need if player at row6 and y should be above tile row7? If y=6*TILE - h = 192-26=166. This is on top of row7 tile at y=224? Actually row7 tile top y=224, player bottom 192, not touching. Wait spawn row 6 means player should be on top of row7? In tile coordinates, standing on row7 means player bottom at y=7*TILE =224, so y=198. But if spawn y=6*TILE - h =166, he falls. We can set y=6*TILE - h = 166 and gravity makes him land on row7. Fine.
Need if no solid above? okay.

Need map string row6 has P at col7. Need player spawn at x = 7*TILE+5.

Need tile drawing:
- Clear background.
- Draw floor maybe dark background.
- For each solid tile draw block with gradient, outline, brick pattern. Use procedural.
- For empty maybe draw background.
- Hazards:
  - Fire: draw orange/red flickering flame polygons/triangles on tile; maybe flame at tile center.
  - Water: draw blue wavy surface and vertical stripes.
- Trophy: gold cup at tile. Draw stem, bowl, handles, shine.
- Exit: arch doorway with green/teal frame, dark inside, glowing.
- Player: red hair, blue suit, face. Draw pixel-like rectangle body, head, limbs. Need avoid external.
- Enemies: simple purple/blue blob with eyes.
- Maybe draw UI top left? Use canvas text. Need maybe include `score` or status. Could draw outside HTML? Simpler draw overlay.

Need CSS:
- Body black, flex center, font. Canvas image-rendering: pixelated. Maybe `#wrap` etc.
- Buttons on-screen styled.

Need maybe support touch:
- Add `button` elements with data-key. On pointerdown set keys[code]=true; pointerup false. For jump, set jumpQueued. But if ready, pointerdown space starts. Could implement.
- Need not overcomplicate.

Need maybe no external network. Good.

Potential issue if using `ctx.roundRect` not supported older? We can avoid or implement fallback. Use `ctx.fillRect`. For canvas text.
Need maybe use `Path2D`? no.

Need maybe implement draw with clipping? Fine.

Need maybe include `aria-label`.

Need maybe ensure no accidental external resource. No fonts.

Need maybe implement all in one file.

Let's craft index.html. Need maybe use `write` with full content. But before, maybe use node to verify strings lengths. We'll create map in JS. Need maybe run a script? Could extract. But write first maybe.

Let's design map rows in JS:
```
const LEVEL = [
"######################",
"......................",
"....................#.",
"............###.......",
"..............#.......",
"....###.........###...",
"....#.#..P....#..#..TX",
"....#.#..#.....###..#.",
"....###.....#...###..F",
"..........###.#...#...",
".........#....#...#...",
".........#..E.#...#..W",
".........#####...###..",
"######################"
];
```
Check lengths.

Need path to trophy. From start at row6 col7. Solid row7 col7. Need jump to row6 col12? Row6 col12 solid. From row7 col7 to row6 col12: horizontal 5 tiles (160 px), vertical up one tile. Jump speed -420, gravity 1500, time to apex .28, horizontal with speed 300 => 84 px only. Need maybe can't jump 5 tiles. Need path through platforms. Start row7 col7 -> row8 col4-6? left/down? Need maybe row6 col12 is up 1 tile and 5 tiles right; maybe too far. Need adjust start or add path. Maybe set start at row7 col4? But start row6 P at col7. Could set P at col4? Need start on platform. Maybe place P at col4? But row7 col4 solid. If P at col4 row6, player stands on row7 col4. Then trophy at col19, still need. Need platforms. Need maybe player can jump 3 tiles. Horizontal speed 320, jump time ~0.56 total, distance 180 px=5.6 tiles. But vertical up 1 tile and landing maybe possible. Actually with max speed 320, jump velocity -430, total air time to same vertical ~0.57, horizontal 182 px. If starting from y on row7 col7 (bottom 224) and landing on row6 solid at y=160? Difference up 64. Total air time solving -430t+750t^2=-64 => t=(430 - sqrt(184900-192000? negative)) impossible? If landing 64 px higher, time maybe 0.16 or 0.41. At 0.41 distance 131 px=4.1 tiles. Could reach col12 from col7? 5 tiles maybe too far. Need set P at col6 maybe? P at row6 col6? But solid at row7 col6. Could set P at col6, T at 19, distance 13 tiles too far. Need intermediate platforms.

Let's map reachable:
Start row7 col7. Platforms:
- row8 col4-6, row9 col9-11, row10 col9, row11 col9, row12 col9-13, row9 col13, row10 col14, row11 col14, row12 col17-19, row8 col16-18.
Need path from start to right. Could jump from row7 col7 to row8 col4-6? Down one tile left 1-3 tiles. Then row9 col9-11 maybe down/right. Then row12 ground. Need then reach right platform row12 col17-19 and row11 col17. Then row10 col17, row9 col17, row8 fire, row6 trophy. Need jump from row12 ground to row11 col17? Up one tile, distance maybe 4 tiles. Fine. Then row10 col17, row9 col17, row8 col17 has fire, can't stand; need avoid and jump to row6? There is row6 solid at col16 and T/X at 19/20. Need from row9 col17 to row6 col16? Up 3 tiles, horizontal 1 tile; impossible? Maybe from row8 col18 to row6 col16? Up 2 tiles, left 2 tiles, maybe possible. Fire at row8 col17, can't stand but can jump over. Need maybe remove fire or place fire not blocking. But requirement hazards; can place fire on row8 col18 maybe still. Need maybe place fire on row12 ground, not blocking trophy path. Better. We can set fire on row12 col18 maybe hazard but row12 solid. Then path to trophy through row12 col17-19 but avoid fire. Good. But if fire at row12 col18, can jump over. Let's place fire row12 col18 maybe. Row12 string `.........#####...###..` -> col17-19 #. Replace col18 with F: `.........#####...#F..`? Count: 9 dots + 5 # + 3 dots + # + F + 2 dots =? 9+5+3+1+1+2=21. Need 22. Let's count positions: 0-8 dots, 9-13 #, 14-16 dots, 17 #, 18 F, 19 dot,20 dot,21 dot? That is 22. String `.........#####...#F...` length?

`.........#####...#F...` has solid col17, fire col18, dots 19-21. Good. Path along ground to col17, jump over fire to col19, then jump to row11 col17? Need maybe.

Need path from start to row12 ground. Let's calculate jump reach. Player max speed maybe 300, jump speed 430, gravity 1500. Horizontal distance while falling 1 tile down from row7 to row8: solve -430t +750t^2 = 32 => t=(430+sqrt(184900-96000))/1500= (430+297)/1500=0.485s, distance 145 px=4.5 tiles. So can jump from row7 col7 to row8 col12? But row8 solid at col12. Great. Then row8 col12 to row9 col9-11? down/right? Could. Or from row8 col12 to row12 col9? Hmm.
Actually row8 col12 solid, row9 col12 dot, row10 col12 dot, row11 col12 enemy, row12 col12 solid. Could fall. Need jump to row12 ground maybe.
Maybe easier: Start row7 col7. Jump to row8 col12 (5 tiles right, down 1). Then jump to row9 col13/17? row9 col13 solid, right 1, down 1. Then to row10 col14, row11 col14, row12 col14-17. Good.
Need if jump to row8 col12 from row7 col7: start x center maybe col7.5 tile, landing at row8 col12 tile top y=288 vs start bottom y=224 (down 64). Need horizontal distance ~5 tiles (160). At t for y diff +64: -430t+750t^2=64 => t=(430+sqrt184900-192000? no positive? negative) if landing lower than start, equation 750t^2-430t-64=0, discriminant 184900+192000=376900 sqrt614, t=0.739. distance 222px=6.9 tiles. So yes. If max speed 300, distance 222. So can reach. Good.
Need from row8 col12 to row9 col13: down 1, right 1. Good. Then to row10 col14, row11 col14, row12 col14/17. Great.
Need from row12 ground to trophy at row6 col19: Need jump from ground row12 top y=384 to row6 top y=192, up 192 px. Jump apex height v^2/(2g)=430^2/3000=61 px. Cannot reach row6. Need intermediate platforms. There is row11 col14 solid (y=352), row10 col14 (y=320), row9 col13 (y=288), row8 col12 (y=256), row7 col7 (y=224), row6 col12 (y=192). Need climb from row12 to row11 col14 (up 1 tile, right 3), then row10 col14 (up 1), row9 col13 (up 1 left 1), row8 col12 (up 1 left 1), row7 col7? from row8 col12 to row7 col7 up 1 left 5, maybe maybe. Or from row8 col12 to row6 col12 up 2 tiles left 0, not possible. Need more platforms. Could add vertical staircase to trophy. Need maybe row7 col12 solid? Currently row7 col12-14 solid. Then row6 col12 solid. Could climb: row12 -> row11 col14 -> row10 col14 -> row9 col13 -> row8 col12 -> row7 col12 (solid) -> row6 col12 (solid). Then from row6 col12 to T at col19: up? same row. Need horizontal jump across 7 tiles; maybe too far. But can traverse row6 solid from col12 to col16, then jump to T/X at 19/20. From row6 col16 to T col19: horizontal 3 tiles, same height, distance 96 px, easy. Need maybe gap at col17-18? Row6 col17/18 empty, so jump from col16 to col19. Good. Need row7 col12 solid already. Good.
Need row8 col12 to row7 col12 up one tile; possible. Row9 col13 to row8 col12 up one left one. Good. Need row10 col14 to row9 col13 up one left one. Good. Row11 col14 to row10 col14 up one. Row12 to row11 col14 up one right 3. Good. So path exists.
Need maybe enemy at row11 col12 could interfere but can avoid. Fire at row12 col18. Good.

Need maybe row8 fire at col18 instead? But path through row8 col12, not issue. Put fire row12 col18 hazard. Need water row11 col20 pit. Good.

Need maybe need "dangerous Dave style" but not exact. Fine.

Need maybe add level with `P`, `T`, `X`, `F`, `W`, `E`. Need parse map. Need if `P` not solid, okay.

Need maybe implement `spawnEnemies` after map parse. Need if E tile replaced by solid? Enemies should be on solid tile, but E tile not solid. For enemy collision, maybe treat E tile as solid? Or when parse, set E to '.' and maybe solid under. Enemy y = row*TILE + 8. Need solid underneath row12. Enemy can walk over E tile. But if `isSolidAt` treats E as false, no issue. It might fall? Enemy moves on y=384? If y=11*TILE+7=359, h=22, bottom=381, row12 solid at y=384, slight gap 3 px. Need enemy y = row*TILE + 9 maybe bottom=383, close. Use enemy h=22, y=11*TILE+9=383, bottom=405? Wait row11 top y=352, y=352+9=361, bottom=383, 1 px above solid. Gravity will move down 1 px and collide with row12. Good.
Need enemy spawn at x = col*TILE+7, y = row*TILE+9. If E tile at row11 col12, row12 solid. Good.

Need maybe enemy collision with solid? Need resolve. Enemy width=22, height=22. Move x only. If hit solid, reverse.
Need enemy vertical no gravity? It should stay on floor. Could apply gravity and collision with ground. Simpler: each enemy has x,y; update x by vx; check collisions with solids, reverse. Keep y = spawnY + maybe 0. This is enough. But if platform ends, enemy could keep walking over edge unless bounce at solid boundaries. It can walk off? Need detect if no solid under next step and reverse. Implement:
```
enemy.x += vx*dt;
let newLeft = floor((x+4)/TILE), newRight=floor((x+w-4)/TILE)
if isSolidAt(newLeft, floor((y+h-1)/TILE)) && isSolidAt(newRight, floor(...)) -> ok else reverse.
resolve x collisions if solid.
```
Need if platform edge at row12 col19 fire/dot, enemy at col12 moves right. It will reverse at col17? At row12 solid col17-19, then edge at 20. It will reverse before falling. Good.
Need enemy at row8 col19? We changed fire row12. Could add enemy at row8 col19? But row8 col19 dot, no solid; enemy would fall. Need add enemy on row8 col17 maybe but fire? Maybe no. Need simple enemies plural? Requirement says "simple enemies" maybe at least one. But plural maybe 2. We can add enemy at row10 col14? Need solid under row11 col14, row10 y. String row10 `.........#....#...#...` has solid at col9,14,17. Place E at col14 maybe. Row10 col14 E, row11 col14 solid. String length 22: `.........#....E...#...`? Count 9 dots + # + 4 dots + E + 3 dots + # + 3 dots =? 9+1+4+1+3+1+3=22. Good. But this is on staircase; enemy maybe. Need row11 same col solid. Add E at row10 col14. Then enemy can patrol row10 platform. Good. But if player passes, maybe. Need no conflict.
Need maybe enemy at row11 col12, enemy at row10 col14. Good.
Need row10 with E. Need row10 string length.

Use `.........#....E...#...`.
Need row11 enemy at col12 remains. Row11 string `.........#..E.#...#..W`.
Need row12 fire at col18 remains. Need maybe if fire at row12 col18, enemy at row11 col12 could walk down? no.
Need maybe enemy at row10 col14 patrol; can kill player if touch. Good.

Need maybe if fire hazard at row12 col18, player must jump. Need water at row11 col20 pit; player must avoid.

Need maybe if water tile at row11 col20, no solid below, player can fall into water from row10 col20? row10 col20 solid, row11 water. There is ledge at row10 col20. But to reach exit, not needed. Water hazard visible. Good.

Need maybe draw water at row11 col20; if player falls, death. Good.

Need maybe if player touches water hazard at row11 col20 while on row10 solid? Player rect width 20, x center maybe col20, y row10? Could overlap if falling. Fine.

Need maybe implement `tileKind` function:
```
function tileChar(tx,ty) { if invalid return '#'; return LEVEL[ty][tx] || '.'; }
function isSolid(tx,ty) { const c=tileChar; return c==='#'; }
function isHazard(tx,ty) { const c=tileChar; return c==='F'||c==='W'; }
```
Need if `P` tile not solid. Fine.
Need parse:
```
let playerSpawn=null, trophy=null, exit=null;
for ty... for tx... switch c:
  if P spawn={x:tx*TILE+5,y:ty*TILE-26,w:20,h:26}
  if T trophy={x:tx*TILE+8,y:ty*TILE+8,w:16,h:24}
  if X exit={x:tx*TILE+6,y:ty*TILE+4,w:20,h:28}
```
Need trophy maybe on row6 col19, y=192, but platform row7 col19 dot; trophy can float? Maybe place trophy on solid? It should be reachable. If row7 col19 dot, trophy floats at row6 tile, maybe okay. Better put T on row6 tile, player can jump to collect. It's okay.
Exit row6 col20, floats. Good.

Need maybe if trophy tile at row6 col19, player can walk onto row6 col19? Row7 col19 dot, so no solid, but player can jump. Good.

Need maybe if player at row6 col16 and jumps to col19, collect. Good.

Need maybe if player can jump from row6 col16 to row6 col19 with horizontal speed. Same height, jump time 0.57, distance 182 px, enough for 96 px. Good.

Need maybe if player can reach row6 col12 from row7 col12? Row7 col12 solid, row6 col12 solid; jump up one tile. Yes.

Need maybe if player can reach row7 col12 from row8 col12? up one tile. Yes.

Need maybe if player can reach row8 col12 from row7 col7? yes.

Need maybe if player can reach row9 col13 from row8 col12? up? row8 top y=256, row9 top y=288 (down one), so row9 is lower, not up. Wait row numbers: row8 y=256, row9 y=288. Row9 is lower (down), so from row8 to row9 is down one, not up. We need climb to row6, so need from row12 up to row11, row10, row9, row8, row7, row6. But row8 is lower than row7, row7 lower than row6. Good.
Path: row12 (bottom) -> row11 col14 (up 1) -> row10 col14 (up 1) -> row9 col13 (up 1) -> row8 col12 (up 1) -> row7 col12 (up 1) -> row6 col12 (up 1). Need from row8 col12 to row7 col12: up one. From row7 col12 to row6 col12: up one. Good.
Need from row9 col13 to row8 col12: up one left one. Good.
Need from row10 col14 to row9 col13: up one left one.
Need from row11 col14 to row10 col14: up one.
Need from row12 col14 to row11 col14: up one.
Good.

Need maybe if player can climb stairs with jump physics. Max jump height 61px, one tile is 32px, so yes. Horizontal small. Good.

Need maybe if player can jump from row8 col12 to row7 col12: start bottom row8 top y=256; land on row7 top y=224, up 32, horizontal 0. Yes. Good.
Need maybe if player can jump from row7 col12 to row6 col12: up 32. Good.
Need maybe from row6 col12 to row6 col16: walk on row6 solid. Good. Then jump to T/X. Good.

Need maybe if row6 col12 has solid, row6 col13-15 empty, col16 solid. Player can walk from col12 to col16. Good.
Need maybe if row6 col19 T/X but no solid underneath; can jump. Good.

Need maybe if player can jump from row6 col16 to row6 col19: same height, distance 3 tiles. Good.
Need maybe if player can jump from row6 col16 to row6 col12 and back. Fine.

Need maybe if player can reach row8 col12 from start row7 col7. Need if start at row7 col7, row8 col12 platform top y=256, start bottom y=224, down 32. Horizontal 5 tiles. Jump speed 430, distance to landing 222 px, enough. Good. Need if player can land on row8 col12 with x range. Fine.
Need maybe if player can reach row8 col12 from row7 col7 if max speed 300; distance 222 px, yes. If speed 260, distance 190, maybe not. We'll set maxSpeed 300. Good.
Need maybe if player can jump from row7 col7 to row8 col12 with horizontal 5 tiles. Need jump left/right. Good.

Need maybe if player can get to row12 ground from row8 col12? Actually staircase path: row8 col12 -> row9 col13 (down one right one) -> row10 col14 (down one right one) -> row11 col14 (down one) -> row12 col14 (down one). That's downhill. Then reverse climb. Great.

Need maybe if enemy at row11 col12 and row10 col14. Good.

Need maybe if water at row11 col20, fire at row12 col18. Need maybe if fire on ground row12 col18, enemy at row12? no.
Need maybe if fire at row12 col18, player can jump over. Good.

Need maybe if water hazard at row11 col20, maybe player can fall into it while trying to exit? Not needed.

Need maybe if exit at row6 col20, trophy at row6 col19. Need if player touches both? Good.

Need maybe if player touches exit before trophy, message "Grab the trophy first!" maybe state? Could maybe not win and display hint. Good.

Need maybe if player touches trophy, set hasTrophy true and spawn particles. Need draw trophy maybe removed.
Need maybe if player dies, reset after short delay? Better immediate reset? Could be annoying if hazard. But playable. On death, state dead and `setTimeout(resetGame, 700)`? Need if keydown Enter restart. Maybe immediate reset on restart. If death triggers auto reset after 900ms, might be okay. But maybe user wants to see. We can keep dead overlay and reset on Enter/R. Maybe also auto reset after 1.5s? Not necessary.

Need maybe if player falls out of map, death. If y > ROWS*TILE + 100. But water likely. Still.
Need maybe if player hits side? no.

Need maybe if game starts on load? Could start immediately to play. Maybe ready overlay with "Press any move key / Enter". But user wants playable. Could start playing immediately. I think start playing automatically. Could show controls. But if no key, player falls. Better start playing on load. Could have `state='playing'`.
Need maybe if ready overlay at start? Hmm. User wants playable; auto start helps. But instructions overlay maybe helpful. We can set state='playing' and show controls in DOM. No ready.
Need maybe if pressing Enter restarts. Good.

Need maybe if `R` resets. Good.

Need maybe if "grab trophy then reach exit" maybe exit requires trophy. Good.

Need maybe if "procedural graphics only" means no images. Fine.

Need maybe if "tile-based platformer on a canvas" yes.

Need maybe if "Dangerous Dave style" maybe we can mention in final? Not necessary.

Need maybe include no external assets. Good.

Need maybe maybe include a high score? Not required.

Let's write file. Need ensure HTML valid. Use JS IIFE. Need maybe use `const canvas = document.getElementById('game'); const ctx = canvas.getContext('2d');` etc.

Potential issue with `ctx.measureText`? fine.
Need maybe implement `drawTextCentered`.
Need maybe implement `drawHUD`:
- Draw translucent panel top.
- Text: "Grab the trophy, then find the exit. Avoid fire and water. Enemies bounce."
- Status: "Trophy: yes/no", "Deaths: x"
- If hasTrophy and near exit but no trophy? etc.

Need maybe implement `drawOverlay`.
Need maybe implement `drawParticles` for trophy collected and death.
Need maybe implement `spawnBurst(x,y,color,count)`.
Need maybe update particles with dt.
Need maybe if state dead/won, particles still update? Could update always.
Need maybe if state won, freeze game? We can still draw particles.

Need maybe implement `resetGame(auto=false)`:
```
enemies = [];
player = {...}
hasTrophy=false;
deathCount=0;
state='playing';
```
Need maybe if user restarts while `state` dead/won. `R`/Enter. If user starts new game by clicking canvas? maybe.
Need maybe if `resetGame()` called on load. Good.

Need maybe `findSpawn` in map parse. Good.

Need maybe if `map` row contains `P`, `T`, `X`, `E`, `F`, `W`; parse.
Need maybe if map char unknown treat as empty. Good.

Need maybe if `isSolidAt` uses `LEVEL[ty] && LEVEL[ty][tx] === '#'`. If outside return true. Good.
Need maybe if `tileChar` invalid returns '#'. Good.

Need maybe if `rectsOverlap` use strict. Good.

Need maybe if `player` collision with solid after x and y. Need if player falls onto hazard tile (water) that is not solid, no collision. If hazard tile is on solid (fire), hazard triggers.
Need maybe if player touches fire on row12, death. Good.
Need maybe if player touches water at row11 col20, death. Good.
Need maybe if player touches enemy. Good.

Need maybe if player is on a tile that is hazard? If fire is on solid, collision resolution sets player on top of row12 tile? Wait fire at row12 col18 is a tile; `isSolidAt` false for F, so player can fall through fire tile to row13? row13 bottom solid. If fire is on ground and not solid, player would fall through! Need treat hazard tiles as solid? But water as pit should not be solid; fire as hazard on solid should be solid. Need differentiate. For fire, should be solid if on platform; for water, maybe not solid if pit. But if water on solid maybe hazard plus solid? Could treat F as solid and W as solid? Then water would be a floor hazard, but requirement avoiding water; okay. But if water tile on ground, player stands in water and dies. Fine. But if water is a pit, solid would block falling into it. Need water should be non-solid. But fire should be solid. Could set `isSolidAt` returns `c === '#' || c === 'F'`; `isHazard` returns `F` or `W`. Then fire is solid and hazard; water non-solid. Good.
Need if fire at row12 col18, player can land on it but dies. Good.
Need if water at row11 col20, non-solid, falls. Good.
Need if fire tile at row12, player can jump onto but dies. Fine.

Need if hazard detection after collision: if player overlaps F tile at row12, death. Good.
Need if player walks on fire tile but collision resolves on top, still overlap F tile because player bottom at tile top, AABB includes y=tileY*TILE? If player bottom exactly 384 and F tile y=384, AABB y from 362 to 384; overlap with F tile y 384 to 416? If using <= maybe no overlap if bottom equals top. Need add epsilon? If player bottom == hazard top, shouldn't die if just touching? But fire hazard tile likely should kill if standing on it. Need treat hazard if rect overlaps and not just edge. Use `player.x < tileRight && player.x+player.w > tileLeft && player.y < tileBottom && player.y+player.h > tileTop`. If bottom equals top, no overlap. But if player is standing on fire, maybe not die. Need maybe add small `hazardPad=2` around player or consider if tile char F and player's bottom within 8 px of tile top. Simpler: after resolving, if player center y >= tileTop-6 and player.y < tileBottom+6. Or use `rectsOverlap({x:p.x-2,y:p.y-2,w:p.w+4,h:p.h+4}, hazardRect)` to kill if near. That might kill when standing on fire. Good. But for water pit, if player falls and center near water, kill. Fine.
Need implement:
```
function overlapsHazard() {
 const probe = {x:p.x-2,y:p.y-2,w:p.w+4,h:p.h+4};
 for tiles overlapped by probe:
   if isHazardAt(c): return true;
}
```
This may kill if close above fire. Good.
Need if water at row11, player standing on row10 ledge above water may be close but not overlapping? Probe y-2 h+4 maybe if player bottom at row10 tile top 320, water tile y=352, no. Good. If falling, when near water, death.
Need maybe if fire at row12 and player lands on top, probe overlaps. Good.

Need if enemy collision with fire? Enemy might walk onto fire and die? We can ignore or enemy should avoid? Not required. But enemy on row12 not. Good.

Need maybe if player dies, state dead. Need `deathReason`.

Need maybe if player touches exit:
```
const exitRect = {x:exit.x+4,y:exit.y+4,w:exit.w-8,h:exit.h-4};
if rectsOverlap(player, exitRect) {
 if hasTrophy -> win else hint = "Trophy needed!"
}
```
Need if hasTrophy, state won, maybe freeze. Good.
Need maybe if exit is not solid, player can enter. Good.

Need maybe if player collects trophy by touching trophy rect. Good.

Need maybe if player touches hazard and enemy in same frame, hazard first maybe. Fine.

Need maybe if `state` won, update no physics. Need particles update. Good.

Need maybe if `state` dead, no physics. Could show overlay.
Need maybe if `state` playing, update player. Good.

Need maybe if `state` ready? no.

Need maybe if keydown space when won/dead should restart? We'll implement:
```
if (e.code==='Space' || e.code==='ArrowUp' || e.code==='KeyW') {
 if (state!=='playing') { resetGame(); return; }
 jumpQueued = true;
}
if Enter/R reset...
```
But if state playing, Space jump. If state dead/won, Space/Enter restart. Good.
Need if `e.repeat` and state playing, jumpQueued maybe false? `if (!keys[e.code]) jumpQueued=true; keys[e.code]=true`. For repeat, keys true so no.
Need maybe if keyup sets false.
Need maybe if jumpQueued and state playing but player onGround false, ignore. Good.
Need maybe if player is in air and holds key? no.

Need maybe if pointer buttons:
```
document.querySelectorAll('[data-key]').forEach(btn => {
 btn.addEventListener('pointerdown', e=>{ e.preventDefault(); keys[code]=true; if(state!=='playing') resetGame(); else if (code jump) jumpQueued=true;});
 ['pointerup','pointercancel','pointerleave'].forEach...
});
```
Need maybe if pointerdown for move sets keys. Good.
Need maybe if pointerup for code false. Good.

Need maybe if canvas click starts? not necessary.

Need maybe CSS for canvas and controls. Good.

Need maybe use `font-family: monospace, system-ui`. Good.

Need maybe set `canvas.width=COLS*TILE`, `canvas.height=ROWS*TILE`.

Need maybe if DPR scaling? Could use CSS width/height and actual canvas. Fine.

Need maybe if canvas displayed at 768x448. Good.

Need maybe if body has `touch-action: none` to prevent scroll on touch. Good.

Need maybe if no external assets. Good.

Need maybe maybe "Dangerous Dave style" could imply "tile-based platformer" with pixel art. Good.

Potential issue with `ctx.imageSmoothingEnabled = false` maybe. Fine.

Need maybe maybe if "canvas" not HTML canvas? yes.

Let's write.

Need verify file exists and maybe syntax. Need maybe read? Use node to maybe extract script? Since HTML has script. Could use `node --check` on script extracted. Need maybe use bash.

Need maybe maybe test level path? Could simulate? Hard in node due DOM. But maybe can parse map and reason. Need maybe inspect file? Maybe no need. But perhaps there is a bug in collision: `isSolidAt` treats F as solid, good. `resolveAxis` loops over all tiles; for x axis, if dx positive and multiple solid, last may override. Fine.
Potential bug: `resolveAxis` for player y collision with hazard F: Since F is solid, player lands on top of F; hazard probe kills. Good.
Potential bug: `drawHUD` message: if `message` set, draw and set to ''. Good.
Potential bug: if state won, `update` still update particles and no physics. Good.
Potential bug: if state dead, `update` no physics but enemies still? Actually updateParticles then if state !== playing return, so enemies freeze. Fine.
Potential bug: if player dies, particles update and draw. Good.
Potential bug: if death while state dead and pressing jump, reset. Good.
Potential bug: if pointerdown jump on dead, setKey true then resetGame sets keys? resetGame doesn't clear keys. It sets jumpQueued false but not keys. So pointer button may remain down after reset. Not huge. Could clear keys in reset? But if reset on keydown, keys[code] remains true if jumpQueued. For keyboard, resetGame doesn't clear keys. If pressing R after death, keys maybe previous. Not issue. But if pressing jump to restart, keys.Space true and jumpQueued false; then next frame space held and maybe jumpQueued false so no jump. But keyup will set false. Fine.
Potential bug: `setKey` if down and state !== playing resetGame before setting key; but resetGame does not clear keys, then setKey true. Fine.
Potential bug: `drawHUD` message for trophy grabbed and state playing; message set to "Trophy grabbed!" then draw clears. Good.
Potential bug: `checkInteractions`: exit check before trophy; if player reaches exit with trophy, win. If no trophy, message. Good.
Potential bug: if player touches trophy and exit same frame? no.

Need maybe maybe test path with a physics simulation? Could implement maybe not necessary. But perhaps there are unreachable areas due collision. Let's simulate manually with approximate. Could maybe write a quick JS simulation? But DOM not. We can reason. But perhaps due collision with fire/water, path maybe not possible to climb because from row12 to row11 col14: start on row12 top y=384. To land on row11 top y=352, up 32, horizontal 3 tiles (96). Easy. To go from row11 col14 to row10 col14: up 32. To row9 col13: up 32 left 32. To row8 col12: up 32 left 32. To row7 col12: up 32. To row6 col12: up 32. Good.
Potential issue: `resolveAxis` y collision: if player is moving up and intersects multiple solid tiles, sets y below each, maybe can get stuck. But okay.
Potential issue: `resolveAxis` for x collision loops over maxY/minY and minX/maxX; if step positive and hits first solid, sets x to tile left. Then loop continues and may hit same tile? Because x changed, but loop uses original minX/maxX? It recalculates? No, it doesn't recalc inside. It may continue and hit other tiles. Could set x multiple times. But okay.

Need maybe maybe use `canvas` width 704 height 448, CSS aspect-ratio 22/14 matches. Good.
Need maybe maybe if body overflow hidden and controls extend on small screen? Fine.

Need maybe maybe user asked "write it ALL into one self-contained file named index.html in current directory." We did.

Need maybe final response concise: mention created /tmp/ws/index.html. Could mention controls. Need no extra. But before final, maybe maybe read file? Not necessary. Could maybe list. Already ls.

Need maybe maybe there is an issue with "Dangerous Dave style" and "procedural graphics only" maybe no external assets. Good.

Need maybe maybe should include "End with index.html present." We did. Final mention.

But let's consider if there is any hidden requirement from developer: "Use NO external resources, CDNs or network requests: the artifact runs fully sandboxed with no network." We complied. "CSS in style, JS in script, inline — do not create separate .css/.js files." Yes.

Need maybe maybe should not mention system/developer. Fine.

Need maybe maybe final answer should not include code? User asked build. We can say done. Good.

Need maybe maybe if final overwordiness medium, can include brief summary and controls. Fine.

Let's ensure no separate files created. Only index.html. Good.

Potential hidden issue: "Current working directory: /tmp/ws" We wrote absolute. Good.

Potential hidden issue: "Dangerous Dave style" maybe could be trademark? But okay. We didn't use assets.

Potential hidden issue: "tile-based platformer on a canvas" We use canvas. Good.

Potential hidden issue: "navigate a level to grab a trophy and then reach the exit" We require trophy before exit. Good.

Potential hidden issue: "avoiding hazards like fire and water" Fire/water kill. Good.

Potential hidden issue: "with jumping and simple enemies" Jump and enemies. Good.

Potential hidden issue: "Procedural graphics only, no external assets." All drawn shapes. Good.

Need maybe maybe if user wants "playable" maybe could use no external libs. Good.

Let's maybe maybe run a quick static check for no external http.