Let's build a complete raycasting maze shooter in a single index.html. Key features:

- Raycasting engine (DDA algorithm) on canvas
- Procedural textures (brick, stone, wood, etc.) generated on offscreen canvas
- WASD movement, arrow keys for turning, mouse look with pointer lock
- Enemies as billboarded sprites, simple AI (move toward player, attack), shootable
- Weapon with shooting (hitscan), muzzle flash, crosshair
- Minimap, HUD (health, ammo), damage flash
- Procedurally generated maze or hand-crafted map

Write it carefully. Map: grid-based, 0 = empty, 1..N = wall type. Enemies rendered with painter's algorithm (depth sort) using z-buffer.

Enemies: sprites drawn procedurally (simple demon-like figure) — draw them onto offscreen canvas. Maybe make it a hit/flash frame.

Shooting: hitscan ray along view direction. Check enemies within angular threshold and not occluded by walls.

Enemy AI: if line of sight is clear, move toward player, attack when close (damage), or ranged attack? Keep it melee contact damage with cooldown.

Let's write the code.

Textures: generate 64x64 canvas: brick (red brick pattern), stone block, mossy stone, wood, door-like. Floor/ceiling: simple gradient fill (or textured floor casting — more costly. Gradient is enough, but a simple shaded floor cast looks better. Do a solid color with vertical gradient shading for performance).

Weapon: pistol/sprite drawn procedurally at bottom center with bobbing, muzzle flash.

Game loop: requestAnimationFrame with dt.

Map: build maze procedurally with recursive backtracker on odd cells, then knock down some walls to add loops, and mark cells with different wall types. Player starts at cell (1,1). Enemies spawn at random empty cells far from the player.

Collision: circle vs grid, slide along walls.

Minimap in top-left corner.

HUD: health bar, ammo, score/kills, wave system? Simple: kill all enemies, and when done, a new wave spawns (regenerate the maze, or just respawn enemies). Show messages.

Mouse turning: canvas click for pointer lock, movementX for turning. Click to shoot. Space also fires.

Write compact but complete code (~700 lines). Let's write.

Enemy sprite: drawn on offscreen 64x64: demon — red body, eyes, arms. Maybe 2 frames (idle, attack flash when hit: white overlay). Death: fade/collapse — simpler: death animation with scaling shrink and fade, then remove.

Sprite rendering: standard billboard transform:
```
dx = ex - px; dy = ey - py;
invDet = 1/(planeX*dirY - dirX*planeY);
transformX = invDet*(dirY*dx - dirX*dy);
transformY = invDet*(-planeY*dx + planeX*dy);
```
screenX = (w/2)*(1+transformX/transformY). Size = h/transformY. Draw per-column with z-buffer check: draw sprite column by column with ctx.drawImage from sprite texture, clipping by zbuffer. That's the classic approach. 64-column sprite per enemy is fine.

Weapon firing: hitscan — check each enemy: compute transform. If transformY>0, compute screenX. If |screenX - w/2| < spriteHalfWidth and not occluded by zbuffer at center column (zbuffer[mid] > transformY). Damage with distance falloff.

Muzzle flash + weapon recoil animation.

Sound: use WebAudio oscillators for gunfire/hit — allowed (no external assets). Nice touch, keep it short.

Damage overlay red flash. Death screen with restart.

Let's write the file.

Performance: render width maybe internal resolution 480x300 upscaled with image-rendering pixelated. Use ImageData? Simpler: use 1px-wide column drawImage from texture canvas. 480 columns * drawImage is fine.

Floor: paint gradient. Skip textured floor for simplicity/perf.

Let's write the code.

Map generation: grid W=24, H=24 (odd dimensions). Recursive backtracker on cells where walls are cells. Then randomly remove some walls to create loops. Assign wall textures by region/random. Border walls.

Enemy spawn: pick empty cells with distance > X from player.

AI: if LOS clear (raycast between enemy and player) and within range, chase. Move with collision. If dist < 0.7 attack with cooldown, dealing damage.

Wave system: when all dead, wave++, spawn more/faster enemies. Show message.

Also add key: Shift = run? Keep simple. Add E to open doors? Skip doors.

Write code.

Texture generation details:

```js
function makeTex(fn){ const c=document.createElement('canvas'); c.width=c.height=64; const g=c.getContext('2d'); fn(g); return c; }
```

Brick: fill with #6b2f2f base, draw rows of bricks with offsets, mortar lines darker, add noise speckle.

Stone: big blocks, gray with noise.

Moss: stone base with green blotches.

Tech/metal: dark blue panels with rivets.

Wood: vertical planks.

Add per-pixel noise on all textures via random alpha rects.

Darkening by side: when drawing columns, apply shading with fillRect black alpha over the column after drawImage (NS vs EW, and distance fog).

Sprite z-buffer array of length W.

OK, writing now. Also handle keydown on Space to shoot, prevent context menu.

Pointer lock: click canvas to lock. Mousemove to turn. Mousedown to shoot. Esc releases lock (browser handles it).

HUD drawn as DOM overlay or on canvas — canvas is easier to keep self-contained. Draw HUD to canvas.

Let's write the full file.

Shooting logic details: ammo with ammo pickup? Keep ammo infinite with reload/heat? Simpler: fire rate limited, ammo count with pickups dropped by enemies? Let's do this: enemies drop ammo/health pickups occasionally, drawn as sprites (small). Adds nice gameplay. Pickups: medkit (+25 hp), ammo (+15). Rendered as sprites at lower height.

Starting ammo 24. Each shot consumes 1. No fire if 0. Pickups from kills (50% chance): ammo box or health.

Sprite types: enemy, medkit, ammo. Sort all sprites by distance.

Enemy frames: walking animation with 2 frames? Keep to 1 frame + hit flash + death. Slight bob maybe.

Writing now. Target ~600-800 lines.

Code sketch:

```html
<!DOCTYPE html><html><head><meta charset=utf-8><title>...</title><style>...</style></head>
<body>
<div id="wrap"><canvas id="c"></canvas><div id="overlay">...start screen...</div></div>
<script>...</script>
</body></html>
```

Start overlay with instructions, click to begin (needed for pointer lock and audio context anyway).

Now the JS:

```js
const W=480,H=300; canvas c width=W height=H, CSS scale to fit window with pixelated.
```

Rendering:

```js
const FOV plane length = 0.66.
for x in 0..W: cameraX=2*x/W-1; rayDir=dir+plane*cameraX; DDA; perpDist; lineHeight=H/perpDist; texX from wallX; drawImage(tex,texX,0,1,64, x, drawStart, 1, lineH); shade.
```

Texture column sampling: texX = floor(wallX*64). drawImage(texCanvas, texX,0,1,64, x,drawStart,1,lineHeight).

Shading: after drawing column, fillStyle rgba(0,0,0,shade), shade = min(0.85, dist*0.06 + (side? 0.15:0)). Fog distance about 14.

Draw floor first: ceiling dark gray gradient, floor brownish gradient. Simple.

Sprite drawing per column:

```js
for stripe in range: if transformY < zbuffer[stripe], draw 1px column from sprite canvas.
```

Compute vMove for floor-placed items: vertical offset via vMoveScreen = (something)/transformY. For enemies: full height 0.9 of wall. For pickups smaller and on the floor: use standard trick: drawStartY = -spriteH/2 + vMoveScreen + H/2 where vMoveScreen = vMove/transformY. vMove for pickups is like 0.32*H? Actually vMove is in wall units: pickup sits at floor with height 0.3: spriteH = H/transformY * scale; screenY offset = (0.5 - scale/2 ... ) hmm. Simpler: for pickups vMoveScreen = (H*0.5)/transformY * (1-scale)... let's just compute: wall's bottom on screen at that depth is H/2 + (H/transformY)/2. Sprite of height s=scale*H/transformY should have bottom there: centerY = H/2 + (H/transformY)/2 - s/2. That works assuming no pitch. For enemies scale ~0.85: centerY = H/2 + halfWall - s/2 + small lift. Good.

Weapon draw: draw procedurally each frame: pistol shape — draw with rects/paths at bottom center with bob and recoil. Muzzle flash radial gradient star when fireFlash>0.

HUD: health bar bottom-left, ammo bottom-right, wave & kills top-right, crosshair center, message in center.

Death: overlay text "YOU DIED — press R".

Damage flash: red overlay alpha decaying.

Audio: function beep(freq,dur,type,vol). Gunshot: noise burst — use buffer of random samples. Hit: short square wave. Keep simple: create AudioContext on start.

Let me just write everything now. Be careful with DDA code correctness (standard lodev algorithm).

Enemy LOS check: DDA raycast from enemy to player, if reaches player distance without wall hit, clear.

Movement collision: check cells around new position with radius 0.25, resolve axis-separated (move x, check, move y, check).

Enemy-enemy collision: skip, allow overlap, or simple separation — skip.

Enemy speed increases per wave. Enemy hp 3 hits (pistol damage 34, hp 100). Enemy contact damage 10, cooldown 0.8s.

Wave spawns: count = 4 + wave*2, capped.

Player hp 100, regen? No.

Writing the file now.

Weapon render: draw gun as simple pixel art using fillRect scaled. Create offscreen gun canvas 64x64 and drawImage at bottom center with bob. Muzzle flash separately.

Gun image: gray pistol: barrel, body, grip. Drawn once.

Crosshair: lines at center.

Minimap: draw scaled grid 4px cells in top-left, enemies as red dots, player as arrow.

OK, time to write code. Be careful with pointer lock and turning keys both.

Fire rate: 0.25s between shots, auto-repeat while mouse held? Semi-auto: one shot per click, or hold with rate limit. Let's allow hold-to-fire with rate limit — more fun.

Enemy hit flash: store enemy.flash timer. When rendering, if flash>0 use a white-tinted version: pre-render a white version of sprite canvas. Two canvases: enemyTex, enemyTexHit.

Death: enemy.state='dying', deathT 0→0.5s, render with shrinking/fading squash, then remove.

Also add slight player bob.

Let's write.

```js
// map gen
function genMap(){
 const MW=23, MH=23;
 map = Array MH fill rows of 1s (all walls)
 // carve with recursive backtracker on odd coords
 stack=[[1,1]]; map[1][1]=0;
 while stack: cur; neighbors = cells 2 steps away unvisited; pick random, remove wall between, push.
 // add loops: remove ~15 random interior walls where both sides floor
 // assign textures: pick base 1..4 per cell randomly by region: use noise: tex = 1 + ((x*7+y*13)%... ) or random but keep border = 1.
}
```

Map stored as 2D array of ints, 0 empty, 1..4 texture index.

Spawn: collect empty cells, filter distance > 8 from player, random pick.

Pickups also as sprites list {type:'med'|'ammo', x,y}.

Sprite sort: combine enemies alive + pickups for rendering, sorted far→near.

Alright, time to write code. Also resize handler: canvas CSS scale preserving aspect.

Finalize numbers: MOVE=3.2/s, RUN with Shift = 4.8. TURN=2.6 rad/s. MOUSE_SENS=0.0026.

Now let's write the whole thing.

Empty directory. Writing the file.

Let me do a quick sanity check of the file with node (syntax checking the script portion), and verify some of the logic.

Potential issues:
1. `wallX*TS|0` — precedence: `(wallX*TS)|0` is fine.
2. In genMap, `map = Array.from({length:MH},()=>Array(MW).fill(1))` is fine.
3. `1+Math.random()*2|0` inside noise() — precedence: `(1+Math.random()*2)|0` is fine.
4. Pointer lock is being requested on overlay click — pointer lock might require an interaction with the element, but generally is it allowed from any user gesture on the document? requestPointerLock needs to be called on an element, but a user gesture is required; click on overlay qualifies. However, if the overlay is covering the canvas when it's clicked, might Chrome refuse pointer lock? The overlay is a separate element, but pointer lock can be requested on the canvas from any gesture. Should be fine. Also, I added a re-lock handler on canvas click.
5. Mouse move handler: `if(locked && !dead) player && (player.a += ...)` — works but ugly; player is only defined after the overlay click. Actually player is defined by reset() on the first click. If mousemove fires before that, `player` is undefined → the expression short-circuits, but `player && ...` — accessing an undefined variable `player`... `player` is declared with `let player` at the top level, so it's `undefined` and not a ReferenceError. OK.
6. `enemies.filter` for dead enemies: filtering after iterating with a continue inside update — no problem.
7. Wave respawn is when enemies.length===0 — dying enemies are filtered after 0.5s so there's a slight delay, no problem.
8. shoot(): `dx*(-sa)+dy*ca` lateral — correct perpendicular component.
9. In rendering the sprite squash on death: sh gets smaller, but topY = wallBot - sh keeps the feet on the floor. Good.
10. Pickup zbuf: no problem.

Verify syntax with node.

Process substitution failed, but the initial syntax check passed. Next, run a smoke test with mocked DOM to detect runtime errors (e.g., map generation, update loop, rendering). Create a headless harness with canvas stubs.

`eval` inside node -e with "use strict" — the script starts with `"use strict";`, and because eval inherits the scope, the declarations stay inside eval's scope... Actually, direct eval in strict mode creates its own scope, so the functions can't be accessed from outside. Append code after js inside the same eval string.

Everything's working. One issue: ammo went negative. Because the test called `shoot()` directly while bypassing the ammo check (the update loop checks ammo before calling shoot). No problem in the actual game — shoot() is only called when ammo>0. But defensively, we can clamp inside shoot. Just to be safe, let's add a guard.

Also confirmed: in 1200 frames, kills = 0, but that's fine. Enemies may not have reached us (they wander and shoot() only hits enemies directly in front). No problem.

Add an ammo guard to shoot().

Wait, that edit contained weird \r characters in my parameters. Let me check what got written to the file — there's a possibility the edit got corrupted.

The edit was applied correctly, the smoke test passed again, and the ammo got properly clamped to 0 (the guard was executed). File is complete. Final check on the file structure — that there are no separate CSS/JS files, and no external references.

Wait, grep -cE returned 0 hits → so it exited with exit code 1, and "no external references" was displayed.

Done. Let me summarize.