demo-062-echodeep-creation

Let me understand the task. The task says "Wake up and do as you please." The last execution created demo 061 "Klangwerk". So my job is to continue the pattern: create a new Three.js demo, which should be demo 062.

Let me first install shell tools and inspect the current state of the demos folder.

***********************************************************************************************************************62.

***************************************************************************************************************************************************re.

Now I understand the structure. I need to create demo 062. Let me think about what concepts have been used to avoid overlap:

001-spinning-cube, 002-nebula-galaxy, 003-mandelbulb-explorer, 004-fluid-dynamics, 005-gravity-sandbox, 006-event-horizon, 007-sonic-reactor, 008-void-runner, 009-azure-odyssey, 010-abyssal-bloom, 011-physarum-garden, 012-powder-alchemy, 013-clockwork-nebula, 014-neon-rain, 015-aurora-borealis, 016-skitter, 017-coral-resonance, 018-threshold, 019-attractorium, 020-murmuration, 021-terraforge, 022-cloudsea, 023-frostline, 024-koi-pond, 025-ferrofluid, 026-synchrony, 027-cymatics, 028-teslasphere, 029-pyrosymphony, 030-morphogenesis, 031-galton-cascade, 032-wavefront, 033-gossamer, 034-magnetosphere, 035-cloud-chamber, 036-wavefunction, 037-epicycle, 038-sandpile, 039-kinetic-theory, 040-lumen-lab, 041-squish-lab, 042-neon-tilt, 043-hyperfold, 044-photon-garden, 045-critical-point, 046-bridge-works, 047-primordial, 048-coasterworks, 049-sakura-grove, 050-voxelia, 051-neon-district, 052-supercell, 053-caldera, 054-domino-rally, 055-phantom-jam, 056-wavewalker, 057-basin, 058-microcosm, 059-zoetrope, 060-spume, 061-klangwerk.

Let me think of a fresh concept that hasn't been covered. Some ideas:

1. Kaleidoscope / mirror tunnel — probably too basic, hyperfold might cover folds.
2. Möbius strip / Klein bottle geometry playground — non-orientable surfaces. Could be interesting but maybe too static.
3. Watercolor / ink simulation — flow.
4. Ant colony / termite simulation — agent based. Microcosm covered particle life.
5. Solar system / orbital mechanics — probably covered by gravity sandbox.
6. Light refraction / prism playground — lumen-lab covered light lab.
7. Cloth / hair simulation — gossamer probably covers silk.
8. Fire simulation — pyrosymphony probably fireworks.
9. Circuit / signal flow — synth?
10. 3D maze generator with raycasting — a game.
11. Pinball — the summary said pinball was already covered (maybe in neon-tilt?).
12. Tornado / storm — supercell.
13. Volcano — caldera.
14. Ocean — cloudsea/wavefront probably.
15. Crystal growth / dendrites — frostline probably.
16. Boids — murmuration.
17. Reaction-diffusion — morphogenesis / physarum.
18. Voronoi / cellular — voxelia?
19. Fractal trees / L-systems — photon garden?
20. Rube Goldberg machine — domino rally covers it.
21. Soft body physics — squish-lab.
22. Rope / bridge physics — bridge-works.

New ideas not yet covered:

• Caustics — light through water rendered with caustic patterns.

• N-body gravitational choreography — figure-8 orbits, etc. Gravity sandbox may cover.

• Double pendulum chaos wall — many double pendulums. Basin is a magnetic pendulum fractal; synchrony is metronomes. A "chaos pendulum array" could still be distinct but feels adjacent.

• Slime mold 3D — done (physarum).

• Ray marching signed distance functions showcase — mandelbulb is raymarched. Hyperfold is probably raymarched fractals too.

• Topology: Klein bottle / Boy's surface / Roman surface morphing — a "surface gallery" with parametric math surfaces morphing into each other with nice shading. Could be beautiful: "Manifold" — morphing mathematical surfaces (Boy surface, Klein bottle, Enneper, Roman, trefoil knots...). Could add wireframe + normals + bloom. Interesting but may feel like a static gallery.

• A 3D snake game on a sphere/cube — gameplay. Void-runner was a runner game maybe. Neon-tilt is pinball-like. A playable 3D game could be fun.

• "Inklight" — light painting in 3D with ribbon trails — interactive drawing. Hmm.

• "Tidepool" ecosystem sim — predator/prey agents with procedural creatures. Abyssal bloom, primordial may cover.

• "Strandbeest" — Theo Jansen walking mechanism — skitter was insect locomotion. Overlap.

• "Orrery" — mechanical solar system — epicycle is probably that.

• "Ripple/echo" — echolocation visualization — a dark cave where you emit sonar pings and the cave geometry is revealed by expanding wavefronts that paint points where they hit. This is cool! Sonar/lidar visualization. Point cloud revealed by pulses. Like the game "Scanner Sombre". A dark cavern, you click to send sonar pulses, points of the environment get painted with distance-based colors, fading over time. Could add a drone that flies through procedurally generated cave. That's a strong concept: "Echovault / Sonar Drift" — procedurally generated cave, sonar pulses reveal millions of points, you fly through on rails or free-fly. Points colored by distance/normal, persistent fading memory. Very atmospheric with bloom.

• "Loom" — thread/weaving simulation — weaving strings between pegs (string art) with tension. String art generator: threads stretched between pins forming portraits/patterns in 3D layers. Could be pretty: circular loom with hundreds of strings forming emergent curves (cardioids, epicycloids), interactive, animated weaving machine. "String theory" art. Hmm, might be visually nice but modest.

• "Tesseract / 4D playground" — hyperfold probably covers 4D.

• "Avalanche / snow" — sandpile covers avalanches.

• "Mycelium network" — physarum adjacent.

• "Paper folding / origami" — hyperfold adjacent.

• "Chladni" — cymatics covers.

• "Spirograph / harmonograph" — epicycle adjacent.

• "Traffic flow / city simulation" — neon-district is a city.

• "Machinery / clockwork" — clockwork-nebula covers.

• "Voronoi shatter / destruction" — could be fun: breakable objects. But heavy.

• "Diffusion limited aggregation (DLA)" — crystal growth. Frostline is probably frost = DLA-like.

• "Black hole" — event horizon covers.

• "Quantum" — wavefunction covers.

• "Flocking fish + sharks" — murmuration covers flocking.

• "Lightning / plasma" — teslasphere covers.

• "Ink in water (smoke/dye advection)" — fluid-dynamics covers.

• "Spring lattice jelly" — squish-lab.

• "Sailing / buoyancy" — wavewalker is droplets. Hmm, a buoyancy demo with floating objects in waves could be nice: "Flotsam" — procedural waves, floating boats/buoys with real buoyancy physics (submerged volume calculation), you can drop crates, barrels, plank rafts, toggle storms. That's physics-rich and distinct! Buoyancy simulation: Gerstner waves + multi-point buoyancy sampling, objects bobbing, tilting, capsizing. Interactive: click to drop objects, drag wind, time of day. Very doable and visually appealing. Ocean rendering with nice shader (depth-based color, foam). Cloudsea was clouds, wavefront was waves (maybe a wave tank). Let me check what wavefront is to avoid overlap.

Let me quickly check a few demo descriptions from index.html to be safe: wavefront, cloudsea, spume (bubbles), wavewalker (droplets), abyssal-bloom (underwater?), azure-odyssey (???).

Actually the sonar cave idea (Scanner Sombre-like) is quite distinct from everything. Let me check "threshold" and "035-cloud-chamber" too. Cloud chamber is particle detection visualization. Threshold — unknown, maybe portals (summary said portals already covered... that was threshold maybe).

Let me grep the index.html for titles and descriptions to be thorough.

******************************************************************************************************************************************************************************************ns.

Azure Odyssey already covered sailing with Gerstner-wave ocean + CPU buoyancy. So a buoyancy demo would overlap somewhat.

The sonar cave concept (Scanner Sombre style) is fresh — nothing like it in the list. Threshold is a portal walker but with lit worlds, not sonar. Cloud chamber is particle tracks. Let me go with the sonar cave: "Echovault" or "Lumen Echo"... something like "062-echosphere" / "062-sonar-drift".

Concept: "Echodeep — Sonar Cavern Drift":

• A vast procedurally generated 3D cave system (or sunken ruins?) built from signed distance noise → marching cubes? That's heavy but doable. Alternative: generate the cave as a series of connected tunnels using a 3D noise field sampled on a grid, then extract points? Actually for the sonar aesthetic, we don't need a mesh at all — we need a point cloud! The whole world is invisible; sonar pulses reveal points on surfaces. So:

1. Define the world by an implicit SDF function (cave tunnels via 3D noise, plus pillars, stalactites, crystals, maybe ruins structures).

2. When a pulse expands from the emitter, we need to find where the pulse sphere intersects surfaces. Approach used in such demos: precompute a dense point cloud of the world's surfaces offline at startup (sample the SDF via marching cubes or random surface sampling), store in a big buffer (e.g., 500k–1M points). At render time, points are colored by when the last pulse wavefront passed them: brightness = pulse intensity based on |dist(point, pulseOrigin) - pulseRadius| < width, and color by distance. Points fade over time (memory). This is efficient: one big THREE.Points with custom shader, each frame pass array of active pulses (up to ~8) as uniforms, compute glow in shader. No per-frame CPU work.

3. The reveal effect: points light up when a wavefront crosses them, then slowly fade. "Memory" fade over ~10-20 s. Implemented fully in shader with per-point attribute storing... hmm, fading needs state: a point hit at time t with intensity i. With multiple pulses, state = max over pulses. Trick: each pulse has origin and startTime; for a point at distance d from origin, hitTime = startTime + d/speed; brightness = decay(now - hitTime). Taking max over N pulses in shader analytically — no storage needed! Since brightness contribution of each pulse is a deterministic function of (point distance, pulse start time, now). So pass uniform array of pulses: vec4(origin.xyz, startTime) + color. For each of up to 8 active pulses compute b_i = pulse envelope: brightness ramps up quickly when wavefront passes, then decays with tau. Sum/max them. Multiply by base color gradient by distance from pulse origin (near=white/cyan → far=deep blue/magenta). This is exactly how Scanner Sombre-like effects can be done cheaply.

4. World generation: SDF-based cave. fBm noise tunnels: cave(x,y,z) = |noise|... Typical approach: "swiss cheese" via 3D fBm threshold, or winding tunnels via noise-based worms. Simpler robust approach: sample points: rejection-sample a lot of candidate points in a big volume, keep those near the isosurface of the SDF (|sdf| < eps), then project them exactly onto the surface via Newton iterations using SDF gradient. That gives a uniform-ish surface point cloud. 500k points × Newton iteration on CPU at load — might take a few seconds; do it in chunks with a loading progress bar. Alternatively generate via marching-cubes-ish grid sampling: for each grid cell crossing the isosurface, spawn k points. Grid 128³ = 2M cells × 8 corner evaluations = heavy but in JS maybe ~2-4s. Hmm. Random sampling: candidate random points in bounding volume: acceptance near surface is low for thin tunnels... Could be slow too.

Better approach: build the cave as an explicit union of primitive shapes whose surfaces we can sample directly and analytically! E.g.:

• Tunnel network: a graph of connected segments (random walk / L-system), each segment is a capsule with noisy radius. Sample points along capsule surfaces directly (parametric!), jitter with noise displacement for rock look.
• Caverns: spheres/ellipsoids at junctions, sampled parametrically.
• Stalactites/stalagmites/columns: cones from cavern floors/ceilings.
• Crystal clusters: elongated octahedra sticking from walls — sample their faces; give them different color (crystals glow magenta).
• Maybe a subterranean "ruin": fallen columns, arches, a broken dome — primitives (cylinders, torus arcs, boxes) sampled parametrically, colored amber/gold when revealed — an "awe" moment.

All surfaces are parametric → direct uniform sampling → perfect point cloud without any SDF solve! And for the drone/camera path, we can use the tunnel graph itself as the flight path (smooth Catmull-Rom through tunnel nodes). Collision avoidance trivially handled: fly along tunnel centerline.

To make the rock look organic, displace sampled points along their normal by fBm noise (both geometric jitter and color variation). Point size attenuation by distance.

5. Flight: an auto-drone flies along the tunnel graph (Catmull-Rom spline), emitting pulses periodically (every ~1.2s) plus auto-echo at junctions. User can click/tap/space to emit a pulse from the camera position. Free-look orbit around drone? Better: first-person-ish camera riding the drone path with mouse look offset, or third-person follow. Simplest engaging: cinematic follow-cam slightly behind and above the drone, mouse moves parallax look; or OrbitControls around drone when paused. Let me do: camera follows behind drone on the spline with smoothed orientation; pointer position steers slight offset/look; space/click = ping. Keys 1-3 quality, P pause, C camera mode (follow / free orbit), R regenerate cave, H help, S snapshot.

6. Ambience: generative WebAudio — deep drone pad, dripping water sounds (random short plinks with long reverb), the sonar "ping" itself (sine sweep ~2kHz with echo), pulse-reveal shimmer tied to wavefront passing through dense regions? Simpler: ping + convolved echo tail. Also low rumble. Water drips with random pitch. When big chamber revealed, a soft choir swell. Doable with simple synth.

7. Post: UnrealBloom + film pass (vignette, grain, chromatic aberration subtle). Pure black background — perfect for the aesthetic.

8. HUD: title, depth meter (based on spline progress / y), pulse count, points revealed counter (estimate), compass? A small sonar "sweep" radial indicator that flashes on ping. Controls hint. Quality tiers (point count 250k/500k/1M — regenerate buffers; or pre-generate max and use draw range... draw range changes point distribution density — fine!). Use geometry.setDrawRange for quality without regenerating.

9. Color scheme: distance-based spectral map: near = warm white → cyan → blue → deep violet → far. Crystals: magenta/cyan emissive. Ruins: gold. Also give points slight per-point hue jitter. Optionally "rainbow mode" (like Scanner Sombre's colorful mode): color by surface normal direction! That was iconic: normal-based coloring (x→R, y→G, z→B) — actually Scanner Sombre colored by normal, giving psychedelic look. Offer toggle: Depth / Normal / Material color modes (key M). Nice feature!

10. Points rendering: THREE.Points with custom ShaderMaterial, additive blending, round soft sprites, size ~2-3 px with attenuation. Brightness computed from pulses. Also a faint constant ambient self-glow for nearest points? No — darkness is the point. But keep a tiny "memory floor" so revealed stuff stays very faintly visible? The decay handles it: long tail at low brightness. Good.

11. The drone: small glowing body (icosahedron core + ring), leaves faint particle trail; its light illuminates points within small radius (adds a near-field term in shader: distance to drone → faint greenish glow). That helps navigation feel.

12. Additional gameplay-ish element: "survey percentage" — count of points revealed at least once (need CPU tracking? can't easily read back GPU... Approximation: integrate over pulses analytically? Simpler: fake it — survey% = function of distance traveled along path + pings... Or actually track via CPU: keep Float32Array of last-reveal time per point? 1M points × checking each ping: a ping reveals points within shell; we'd need distance from ping origin for all points → 1M sqrt per ping is fine occasionally (at 1 ping/1.5s, 1M ops = ~1ms). Actually compute squared distances, compare with radius². With typed arrays that's OK: loop 1M simple ops ~2-4 ms, once per ping — acceptable. Or use a spatial hash to only update points near the ping. Simpler: do the full scan but chunked over a few frames. Or just fake the survey stat from coverage estimate. Let me do the honest CPU scan chunked: when ping emitted, schedule incremental scan of point array (say 100k points per frame), marking revealedCount. Fine.

Hmm — but do I want to add the reveal-by-distance coloring needing per-point distance from pulse: that's computed in shader from position attribute and pulse origin uniform — fine.

Number of active pulses as uniforms: 12 × vec4 (xyz origin, t0) + 12 × float (energy) + maybe color type. Pulse speed ~ 14 units/s, cave scale ~ 300 units long tunnels. Hmm, let me define world scale: tunnels radius ~4-8 units, total path length ~600 units, chambers up to 30 units radius. Pulse speed 16 u/s, life ~ 6s → range ~96 units. Decay after wavefront passes: brightness = E * exp(-(now - hit)/tau) with tau ~ 5s, plus wavefront flash boost: extra brightness while |d - r(t)| < 1.5 (a bright ring at the wavefront).

Also fade in: brightness should be 0 before wavefront arrives (now < hit). After passes: peak then decay. So: dt = now - (t0 + d/speed); if dt < 0 → 0; else b = exp(-dt/tau) * (1 + flashexp(-dt8)). Good.

Also add slight pulse energy decay with distance (1/(1+d*0.02)) to dim far reveals.

Point generation details:

• Tunnel graph: start at (0,0,0), do a 3D random walk downwards with momentum, branching occasionally, total ~40-70 segments; nodes spaced ~8-14 units; ensure general downward trend (depth increases). Avoid self-intersection loosely via min node distance check (not critical). Chambers at some nodes (radius 6-16, bigger deeper). The final chamber: grand "cathedral" with ruins.
• Sampling capsules: for each edge (a,b,r1,r2): sample N ∝ area points: pick t along, angle θ, radius = lerp(r1,r2,t) (+noise), pos = center + radial. Normal = radial (approx). Displace by noise along normal ±1.5 (rock roughness), plus small tangential jitter.
• Chambers: sample sphere/ellipsoid shells with noise displacement.
• Stalactites: in chambers, pick k spots on upper/lower half, cones pointing down/up, sample cone surfaces; also columns occasionally.
• Crystals: near tunnel walls in certain "geode" zones: clusters of 3-7 elongated octahedra (sample triangular faces), tagged with material flag (color override + emissive boost).
• Ruins in final chamber: broken columns (cylinders, some tilted/fallen), arch (torus arc), scattered blocks (boxes), a fallen statue? Keep to columns+arches+blocks. Tag gold material.
• Per-point attributes: position, normal (for normal color mode + rock shading variation), material (0 rock, 1 crystal, 2 ruin), seed (hue/brightness jitter).
• Count: 1M default high tier. Generation time: pure JS loop filling typed arrays with simplex noise calls... 1M points × ~3-6 noise evals ≈ 6M noise calls ≈ maybe 1.5-3 s. Show loading bar with chunked async generation (generate in slices of ~120k points with await rAF). Acceptable with a nice "Surveying the deep..." loader.

Camera path: Catmull-Rom through tunnel node centers (offset slightly). Duration ~ 4-6 minutes loop; speed ~ 3 u/s with ease; look-ahead along tangent. Pause (P) stops drone; orbit free-cam (C).

Controls summary:

• Click / Space: sonar ping
• C: camera mode (follow → chase → free orbit)
• M: color mode (depth → normal → material)
• R: regenerate cave
• 1/2/3: quality
• P: pause drone
• H: help overlay
• S / camera button: PNG snapshot
• Touch: tap = ping, drag = look offset, buttons for the rest.

Audio:

• Ping: sine blip 1800→1200 Hz sweep 0.08s + feedback-delay echo taps + conv reverb.
• Drone ambience: 2 detuned saws through lowpass at low freq (55 Hz, A1) + slow LFO — dark pad.
• Drips: random short sine plinks (1-3 kHz) with big reverb, poisson intervals.
• Reveal shimmer: when ping emitted, schedule a soft filtered noise swell following wavefront (2-3s).
• Chamber choir: entering big chamber → stacked fifths pad swell (detect chamber radius ahead). Optional but nice: tie to drone position — every chamber triggers a soft chord.
• Master mute button + volume slider.

Post chain: RenderPass → UnrealBloomPass (strength ~1.2, radius 0.6, threshold 0.0) → film grade ShaderPass (vignette, grain, chromatic aberration, slight teal-shadow grade). Since scene is just points + drone glow, bloom makes it luscious.

Extra visuals:

• Faint fog? No — black.

• Occasional "dust motes" drifting near drone (small Points cloud, always slightly visible, gives motion parallax).

• The drone's ping emitter: visible expanding wireframe-ish ring? The wavefront ring is implicit in point flash; also add a subtle expanding sphere shell mesh (very faint additive) at each ping for ~1.5s. Nice touch — a glass-like fresnel shell.

• HUD sonar gauge: circular sweep animation on ping, shows "PING" cooldown, depth readout (m), points surveyed, survey %, chamber notifications ("Cavern 7 — diameter 28 m").

Performance: 1M points = 1M vertices trivial vertex shader work — fine on most GPUs; fallback tiers 250k/500k. Adaptive: monitor fps, auto step-down. Pixel ratio clamp 1.5-2.

Let me also double-check there is no name clash: existing names don't include echo/sonar/cave. Name: "062-echodeep" — "Echodeep — Sonar Cavern Survey". Good.

File: /space/demos/062-echodeep/index.html, self-contained, importmap three@0.160.0 unpkg, OrbitControls for free-cam, EffectComposer etc. from examples/jsm.

Now, careful engineering needed:

A. Noise: implement a small simplex/value noise in JS for point generation AND we don't need noise in shader (rock displacement baked into positions). Use a compact simplex 3D implementation + fBm.

B. Chunked generation with progress bar; store into Float32Arrays; build BufferGeometry; three quality tiers via setDrawRange — but careful: drawRange takes first N points; if points are ordered by structure (tunnels first...), low tiers would cut off later parts of the cave (the cathedral!). Fix: interleave — shuffle point order or stratify sampling so any prefix is a uniform subsample of the whole cave. Easiest: generate all points into arrays per-primitive, then when writing into the big buffer, interleave round-robin across primitives... Simplest robust: after generation, do a Fisher–Yates shuffle on indices? 1M shuffles moving 8 floats each — 8M float moves, fine one-time (~50 ms). Or generate each primitive's points into strided positions: global index = localIndex * numPrimitives + primitiveSlot — interleaving primitives keeps each prefix covering all primitives uniformly; within a primitive, order is random anyway (sampling is random). Interleave via per-primitive cursors writing round-robin. That preserves full-cave coverage at any drawRange. I'll do the cursor interleave approach (no shuffle cost, deterministic).

Hmm, actually simpler: just generate points per primitive and append; then do a lightweight index shuffle only ONCE on a Uint32Array of indices and use indexed rendering! THREE.Points supports index. setDrawRange on indexed geometry draws first N indices — indices shuffled → uniform subsample. That keeps vertex arrays compact and tier switching instant. drawRange with index works (draw count refers to index count). Yes.

But wait: Uint32 index needs OES_element_index_uint — universally supported in WebGL2 (three r160 uses WebGL2 by default). Fine. Even simpler: shuffle-free approach — allocate points in interleaved manner... nah, indexed shuffle is clean and simple. Actually simplest of all: since sampling within each primitive is random order anyway, I can just interleave at generation time using per-primitive write cursors with stride = number of primitives... but primitives have wildly different counts; cursor approach: maintain list of active primitive generators, each frame of the loop take next point from each... complicates chunked async. The index shuffle is honestly the cleanest: positions stay grouped (cache-friendly enough for points), shuffle 1M Uint32 ~ fast.

Actually — do I even need order to be uniform? Quality tiers are chosen at start; switching mid-flight via keys. If order = generation order (tunnels first, cathedral last), tier "low" would hide the cathedral. Bad. So yes, shuffle indices once. Fine.

Hmm wait, one more subtlety: I want crystals to still sparkle at low tier... uniform subsample handles it proportionally. Good.

C. Pulse uniforms: MAXP = 10; uniform vec4 uPulses[10] (origin, t0); uniform float uPulseAmp[10]; ring buffer index. When exceeding, overwrite oldest. In shader loop over 10, skip amp<=0.0 ones.

D. Shader: attributes: position, normal (vec3), aMat (float), aSeed (float). uniforms: uTime, uPulses, uPulseAmp, uDrone (vec3 drone pos + glow radius), uColorMode, uSize, uPixelRatio, uFade (global brightness), uAmbient? varying vColor. Vertex: compute world pos (identity model matrix; keep points in world space, no transform). For each pulse: d = distance(position, origin); dt = uTime - t0 - d / SPEED; contrib = dt > 0 ? amp * exp(-dt/TAU) * (1.0 + FLASHexp(-dtFLASHK)) * atten(d) : 0. Sum (or max? sum looks better with overlapping pulses; clamp). brightness = min(sum, 2.5). Also drone near-glow: g = exp(-distance(pos,uDrone.xyz)*0.22) * 0.10 (subtle). Base color by mode:

• depth mode: use distance from last dominant pulse? Trickier — need per-pulse distance weighting. Simpler: color by distance from drone: spectral map near warm → far blue. Or color by depth (y) below surface: gradient white→cyan→blue→violet as y decreases. Depth-from-pulse: Scanner-Sombre-like rainbow ring effect: color by d (distance from the pulse that illuminates) → rings of hue! That's gorgeous: hue = fract(d * 0.02 + ...) mapped through palette; brightness from pulse envelope. To do properly, track dominant pulse (max contrib) and use its d for color. Loop tracks best contrib and its d. OK.
• normal mode: color = normalize(abs(n)) mapped to palette (classic RGB normal look) — actually Scanner Sombre: color = normal*0.5+0.5 → psychedelic. Use that.
• material mode: rock = cool slate, crystal = magenta/cyan (per-seed mix), ruin = warm gold. Then color *= brightness; also slight seed brightness jitter. gl_PointSize = uSize * uPixelRatio * (300 / -mvPosition.z) clamp [1, 64]? Use perspective attenuation; size ~ 2.2 base. Fragment: circular soft sprite: dist from center, alpha = smoothstep(0.5, 0.15, r) maybe squared falloff; additive blending, depthWrite false, depthTest true. Output color * alpha. With additive, overlapping points brighten — good.

Note: brightness could exceed 1 — fine with bloom (HDR-ish, use HalfFloat render target? EffectComposer default uses... in r160, default renderTarget type is HalfFloat since r152-ish? Actually EffectComposer creates UnsignedByteType by default unless specified. For bloom to glow nicely with values >1, better to pass a HalfFloatType target to composer. I'll construct composer with new THREE.WebGLRenderTarget(w,h,{type:THREE.HalfFloatType}). Reasonable.

E. Drone mesh: group with core icosahedron (emissive white-cyan), two counter-rotating rings (TorusGeometry, emissive), a small point light? No lights needed (unlit scene) — but drone model itself should be MeshBasicMaterial emissive-look (just bright colors + bloom). Plus a soft sprite halo. Add expanding pulse shells: pool of 12 spheres (SphereGeometry low-poly, custom fresnel shader additive, scale animated, fade out).

F. Camera follow: position = spline point at s - tangentdist + upheight, smoothed (lerp). LookAt = point ahead + pointer offset. Roll slight into curves. FOV 70. Free-cam mode: OrbitControls targeting drone. Chase vs follow: keep one follow mode + free orbit; toggle key C.

Also "look" with mouse in follow mode: yaw/pitch offset ±0.5 rad applied to look target. Touch drag same.

G. Auto-ping: every 1.6 s from drone (energy 1), plus stronger manual ping (energy 1.4). Rate-limit manual to 0.35 s. Auto-ping continues only when not paused? Continue while paused too (it's ambient) — maybe slower. Keep simple: auto ping always every 1.8s unless muted auto (toggle A). Fine, add key A toggle auto-ping; default on.

H. Survey %: CPU scan on ping (chunked): for i in range: dx²+dy²+dz² < R² (R = speedlifetime ~ 96) → revealed set bit. Use Uint8Array flags; count via running tally. Also update "points surveyed". Chunk 150k/frame to avoid jank. Also I realize: brightness tau ~ 5s means visually revealed even beyond? No: hit only when wavefront passes within range R; beyond R pulse dead (t capped: if dt > T_MAX=~7s treat 0 in shader via amp... actually exp(-7/5)=0.25 still visible! Need hard cutoff: contribution = step(dt, T_MAX)? In shader: if dt<0 or dt>TMAX → 0. TMAX ~ 8s, and envelope exp(-8/5)=0.2 — abrupt cutoff visible. Better: include smooth fade to zero by TMAX: envelope = exp(-dt/TAU) * (1 - smoothstep(TMAX0.6, TMAX, dt)). Clean. R = SPEEDTMAX = 16*8=128 units. CPU scan uses same R. Good.

I. HUD: minimal top-left: title + stats (depth, surveyed %, pings). Bottom-left: controls hint (toggle H). Top-right: buttons (ping, pause, camera, color, audio, quality, snapshot, help, regenerate). Style consistent with previous demos (dark glass). Chamber toast notifications center-bottom fade.

J. Loading overlay: progress bar during generation ("Charting the cavern… 42%"), then "Enter" click-to-start (needed for AudioContext anyway). On start: fade overlay, start audio, start loop.

K. Regenerate (R): rebuild world with new seed: dispose geometry, regenerate (with loader overlay quick), reset spline/pulses/flags. Reuse generation routine.

L. Adaptive quality: rolling fps avg; if < 45 for 4s → drop tier (drawRange 1M→600k→320k), if > 58 for 20s and below max → step up (only if auto). Quality keys set manual tier.

M. Snapshot: render once, canvas.toBlob → download PNG. Need preserveDrawingBuffer or render immediately before capture; simplest: renderer.preserveDrawingBuffer=true (slight perf cost, acceptable) OR do composer.render() synchronously then toDataURL in same task — standard approach: call render then immediately canvas.toBlob in same event handler — works without preserveDrawingBuffer as long as no other task clears. I'll render+toBlob synchronously in click handler.

N. World gen specifics (important to get right — cave feels good):

• RNG: mulberry32 seedable.
• Simplex3D implementation (compact, Gustavson-style) + fBm(x,y,z,oct=4).
• Tunnel walk: pos = (0, 6, 0) start "entrance", dir initial (0,-0.35,1)... Actually let me make it predominantly horizontal wandering with downward drift: dir = normalize(dir0.72 + rand0.28 + (0,-0.05,0))... nodes every 8-14 u. 64 nodes main path. Branches: 25% chance at node → side path of 6-14 nodes (shorter, can curve up). Total nodes maybe ~110. Radius: base 3.2-5.5, noise-modulated per node; chamber chance 14% → radius 8-15 (ellipsoid scale), deeper = bigger; final node: cathedral chamber r ~ 24-30.
• Ensure min distance between non-consecutive nodes > ~ (r_i+r_j)*0.6 to avoid everything collapsing into mush (allow some intersections — they're fine, caves intersect; just avoid total overlap). I'll do a light check: if new node within 5 u of an old node (not parent), accept anyway (intersections are good, create loops!). Loops are good for caves. Skip checks mostly; just avoid immediate foldback via momentum.
• Spline path for drone: main path node centers, Catmull-Rom. Branches: drone stays on main path. Fine — branches get revealed by pings (within 128 u range).
• Entrance: start chamber with a hole to "surface"? Keep it simple: drone starts inside entrance chamber; first pings reveal it. Nice moment.
• Chamber ellipsoid squash: sy = 0.7-1.0.
• Stalactites: per chamber (and along tunnels sparsely): count ∝ area; position on chamber shell upper hemisphere → cone from that point pointing down-ish length 2-7 r 0.3-1.0; stalagmites mirror. Columns 10% of pairs.
• Crystals ("geodes"): choose ~8-14 zones on tunnel/chamber walls (more in mid-depth): cluster of 3-8 octahedra: pick wall point p with inward normal n, crystals point inward-ish (dir = n + rand*0.5), length 0.8-2.6, radius 0.18-0.5. Octahedron: 8 triangular faces; sample points on triangles uniformly (sqrt trick), normal = face normal. Tag mat=1.
• Ruins (cathedral): ring of 6-10 columns (cylinder r 0.8 h 9-14) radius ~ 0.55*R around center; 2-3 fallen (rotated ~85°, offset); architrave arcs: torus arcs (arc 60-120°) atop some columns — approximate sample: torus with arc param; blocks: boxes scattered; a toppled "obelisk"? Keep: columns + arcs + blocks + a big broken sphere (dome fragment)? Simplest set: columns, arcs, blocks. Tag mat=2.
• Wall roughness: after computing base point + normal, displace p += n * (fbm(p*0.14)1.6 + fbm(p0.55)*0.45); for ruins/crystals: no displacement (crisp). Also normal jitter for rock color variety.
• Point counts: tunnels ~ 45%, chambers ~ 30%, speleothems ~ 10%, crystals ~ 7%, ruins ~ 8%. Total T = 1_000_000 (high). Per-primitive n ∝ surface area × density weight (crystals denser — they're small; boost density ×2.5 so they read clearly).

Compute counts: capsule lateral area = 2πr·len. Fine approximate with avg radius.

• Also floor "rubble" & "flowstone mounds": skip, noise does enough. Maybe add shallow "water pools"? Could add fake floor plane in chambers with slightly different color... skip — scope control. Actually one nice cheap addition: "helictite dust"... no. Scope control.

Also: a subtle grid of faint "anchors"? No.

O. Number formatting: depth = -(drone.y) * 2 → "meters" (scale fudge: 1 unit = 2 m). Display like "DEPTH 214 m".

P. Toast when entering chamber: detect drone segment index crossing nodes flagged chamber → show "CAVERN 04 · Ø 31 m". Track lastChamberIdx.

Q. Audio graph: master → compressor → destination. Reverb: convolver with generated IR (2.5s decaying stereo noise) fed by sends. Ping synth: osc sine freq 1500 exp→950 over 0.12s, gain env 0.001→0.5→0 over 0.5s; also a 2.4kHz "tick" at start; send to delay (0.31s, fb 0.35, 3 taps feel) + reverb. Drips: schedule every 0.4-2.2s: sine at 700-2400Hz pitch-drop, tiny gain, long reverb send; pan random. Pad: two saw oscillators 55Hz & 55.35Hz → lowpass 220Hz → gain 0.05 with slow LFO (0.05Hz depth 0.02) → master; plus a fifth 82.4Hz sine. Choir on chamber: when toast fires, swell: 3 sines (220, 277.2(C#), 329.6 → minor triad A-C#-E? make it A minor: 220, 261.6, 329.6) gain env 0→0.04→0 over 6s + reverb. Reveal shimmer: on ping, bandpassed noise sweep up (400→2400Hz) 1.2s, gain 0.03 — evokes wavefront passing. Keep volumes modest; master volume slider + mute.

R. Structure the code cleanly with sections & comments. Aim ~1200-1500 lines. Take care with WebGL1 fallback? r160 requires WebGL2 mostly — fine, assume WebGL2 (show message if unavailable).

S. Edge cases: tab hidden → clock delta clamp; audio context suspended until gesture; resize; devicePixelRatio; context loss? show note.

Let me also verify three r160 API specifics:

• importmap: "three": "https://unpkg.com/three@0.160.0/build/three.module.js", "three/addons/": "https://unpkg.com/three@0.160.0/examples/jsm/".
• EffectComposer with custom RT: new EffectComposer(renderer, renderTarget).
• OutputPass exists in r160 (examples/jsm/postprocessing/OutputPass.js) handling tone mapping/color space. Use RenderPass → UnrealBloomPass → ShaderPass(grade) → OutputPass. Grade pass operates in linear HDR before OutputPass — vignette/grain fine either way; chromatic aberration fine. Actually film grain after tone mapping looks better, but fine — keep grade last before OutputPass, or put grade after OutputPass (then it works in sRGB space — grain/vignette more predictable). I'll put grade AFTER OutputPass; it's a plain screen-space pass — totally fine and common.
• renderer.toneMapping = ACESFilmicToneMapping; outputColorSpace default sRGB. With OutputPass it applies renderer settings.
• Points material: ShaderMaterial with transparent:true, blending:AdditiveBlending, depthWrite:false.
• For indexed Points with setDrawRange: geometry.setDrawRange(0, count) counts indices when index exists. Yes.

One perf consideration: 1M points × vertex shader with 10-pulse loop = 10M iterations × ~20 flops — fine.

Draw range tiers: high 1M, medium 550k, low 280k. Auto-adapt.

Also add "uFadeIntro" global ramp at start.

Now about the spline: THREE.CatmullRomCurve3 through main nodes, getPointAt for arclength param. Drone speed: arcLen/… compute total length L, duration = L / 3.2 (u/s) → e.g., L=900 → 280 s ≈ 4.7 min. Loop: at end, fly back? Teleport fade? Loop smoothly: make curve closed=false; at end do a "resurface fade": fade to black 2s, reset s=0, fade in. Simple & elegant (it's a "new descent"). Actually nicer: ping range is big; just fade + restart. OK.

Also the drone should slow slightly in chambers for sightseeing: speed *= 1/(1+chamberProximity)... nice touch: param per node "dwell"; approximate: speed factor from local radius (sample node radius near s): v = 3.4 * clamp(5.5/r_local, 0.55, 1.25). Implement via precomputed lookup over samples (e.g., 512 samples of radius along curve).

Pointer look: in follow cam, target = lookAhead + rightmx8 + upmy5, with smoothing. Also on touch devices drag.

Chamber detection for toast: node flags along curve param: node index → s position via curve.getUtoTmapping? Easier: I know cumulative arc lengths since I build the spline from nodes; compute per-node u by curve.getLengths()? Use curve.getPointAt monotonic… Simplify: precompute array of {u, type, radius} by walking 2000 curve samples and finding nearest node… overkill. Alternative: track drone position; each frame check distance to unvisited chamber node < chamber.radius*0.9 → trigger toast + choir + mark visited. Simple, robust.

For "dwell" radius along curve: same — each frame find proximity to nearest node? O(nodes) per frame = ~110 — trivial. v = base * f(min over nodes of weighted influence). Fine, do that: influence = max over nodes of smoothstep… 110 × cheap ops/frame OK.

Camera collision: camera might clip through walls in tight tunnels — acceptable (dark scene, points additive, clipping barely visible). Offset camera up 1.2 & back 5.5; tunnels r≥3.2 → mostly fine.

The drone path y: nodes at tunnel center; camera at center is fine.

Now let me also design the "echo shell" visual: pool 10 shells: SphereGeometry(1, 32, 24), ShaderMaterial fresnel additive: color cyan, alpha = (1-|dot(view,normal)|)^2 * envelope * 0.35, scale = speed*(t-t0), life until TMAX. BackSide? Render both sides additive subtle. Slight wireframe? No — smooth fresnel. Cheap and pretty. Also a quick bright flash sprite at origin on ping.

HUD ping cooldown ring: CSS conic-gradient updated via JS, or SVG circle stroke-dashoffset. Simple div with radial sweep animation retriggered.

Colors/branding: cyan/teal + magenta crystals + gold ruins on black. Title: "ECHODEEP". Subtitle: "Sonar Cavern Survey · Demo 062".

Keys: Space/Click ping · A auto-ping · C camera · M color mode · P pause · R regen · 1/2/3 quality · H help · M? conflicts mute vs mode — use M=color mode, U=mute? Previous demos used M for mute commonly. Use: N = color mode ("paiNt"), M = mute. OK: N cycles color mode. And keep buttons for everything.

Let me now also plan the loading generation chunks: generate() builds arrays via async chunks; primitives list first (graph + features), compute counts, allocate, fill with per-chunk await. Progress = points filled / total. Should run ~1-3s on desktop.

I need a solid simplex noise. I'll include the standard compact 3D simplex (public domain style, Gustavson) — about 60 lines. fBm wrapper.

Detail: normals for rock after displacement — true normal changes, but for color modes approximate with base normal (fine).

Survey scan: positions Float32Array; flags Uint8; per ping compute R²; chunk scan with pointer stored in a job object {origin, R2, idx}. Each frame if job active: process 200k. revealedCount tally. survey% = revealed/total. Since flags persist per world, regen resets.

Wait — subtle: shader reveal range uses per-pulse attenuation with distance but envelope cutoff at TMAX → R=SPEED*TMAX exactly; beyond that never lit. CPU scan matches with same R.

Also "points surveyed" counts points ever lit; brightness at max range ~ exp(-0)*… at d=R the wavefront arrives at dt=0 → peak! atten(d)=1/(1+0.02d) → 0.28 at R=128… still lit. OK matches scan.

Toast also at start: "ENTRANCE SHAFT".

Free-cam (C): OrbitControls enabled, target = drone pos (update continuously? set target each frame to drone, allow user rotate/zoom around). Disable follow. Toggle back. While free-cam, drone continues.

Pause (P): stops drone + auto-ping timers freeze? Keep audio ambients. Manual ping still works (from drone pos). Time source: uTime keeps running (pulses continue) — fine.

Let me think about uTime wrap: use performance-based clock accumulated with pause of nothing... pulses store t0 = uTime at emit; uTime monotonic unbounded (float32 precision in shader after ~ hours: uTime as float minutes? precision: float32 has ~7 digits; uTime in seconds after 1h = 3600s, exp(-dt/TAU) with dt computed as uTime - t0 - d/SPEED: catastrophic cancellation when uTime ~ 3600 and dt ~ 1 → float32 precision at 3600 is ~0.00025 — fine actually (dt error ~ millisecond). OK. But pass uTime as float uniform — JS number → float32 in shader. After 10 hours = 36000s, precision ~0.004 — still OK. Fine.

Also to be safe: when a pulse is overwritten (ring buffer), its t0 replaced — old points just stop being lit by it — natural.

Antialiasing: points are tiny sprites; MSAA doesn't apply to gl_PointSize sprites well... With additive glow and bloom, aliasing acceptable. Set renderer antialias:true anyway (helps drone mesh).

Pixel ratio: min(devicePixelRatio, 1.75) high tier; med 1.5; low 1.25.

Let me now also handle "no WebGL2" message gracefully.

Snapshot: include HUD? No, just canvas.

Filename: echodeep-YYYYMMDD-HHMMSS.png.

Total scope is big but manageable. Let me write the code carefully. I'll write the full file in one go, then node-syntax-check the module script by extracting it.

Extraction for validation: sed between and → write to /tmp/app.mjs → node --check. Note: node --check works for ESM? node --check assumes CommonJS unless .mjs extension — with .mjs it parses as module. imports of 'three' won't resolve but --check only parses, doesn't resolve. Good.

Also validate logic pieces with a small node test: noise determinism, curve building, count allocation sums, interleave/shuffle correctness, pulse envelope math — quick sanity script replicating key functions. Since generation code lives inside the HTML module, I'll duplicate minimal pure functions in the test script manually... simpler: structure the JS so pure math helpers are defined in a way I can copy. I'll just write a small standalone test for RNG/simplex/spline node generation logic by importing nothing. Actually to keep effort sane: extract the module script and run node --check for syntax; plus a logic test file that re-implements... hmm, risk of divergence. Alternative: put generation logic inline but also export? Can't import from HTML. I'll copy the critical pure functions (mulberry32, simplex, buildCaveGraph, allocateCounts) into /tmp/test.mjs by hand-synchronized copy and run assertions. If I keep functions self-contained (no THREE dependency) I can extract them with sed by markers: I'll wrap pure functions between // [PURE-BEGIN] and // [PURE-END] comments, extract via awk into the test file, append test asserts.

For THREE-dependent parts (CatmullRomCurve3), mock minimal? buildCaveGraph doesn't need THREE if I use plain arrays [x,y,z]; spline uses THREE separately. Good — keep pure parts THREE-free: RNG, noise, graph build, feature placement, point sampling (writes into arrays), count computation. Sampling uses only math.

Let me structure:

PURE section:

• mulberry32(seed)
• makeSimplex(seed) → noise3 fn
• fbm(n3,x,y,z,oct)
• buildCave(rng, opts) → { nodes: [{p:[x,y,z], r, chamber, depth}], edges: [[i,j]], branches: [...], mainPath: [indices], features: {crystals:[...], ruins:[...], speleo:[...] } } — actually let me merge: buildCave returns list of primitives: primitives = [{type:'capsule', a:[..], b:[..], ra, rb}, {type:'chamber', c, r, sy}, {type:'cone', apex/base...}, {type:'crystal', ...}, {type:'column'...}, {type:'box'...}, {type:'arc'...}] each with mat. And sampling fn samplePrimitive(prim, n, rng, noise, out, offset) fills position/normal/mat/seed arrays.
• computeCounts(primitives, total) → per-prim counts.

TEST: seed determinism, counts sum ≤ total, capsule sampler produces points at ~correct radius (within noise tolerance), chamber sy scaling, no NaNs in 100k samples, envelope function test, interleave... good.

Then the THREE app uses these.

One more consideration — the entrance: first node near y=0 "surface", drone descends. Depth display = (startY - y)*2 meters.

Let me decide world visual variety along depth: shallow = cooler cyan white; deep = bluer; crystals more frequent mid; cathedral gold at end. Color handled by modes; depth mode: hue by distance-from-pulse rings; material mode distinguishes features; normal mode psychedelic. Also small emissive boost for crystal points so they bloom more (×1.8).

Point size: base 2.0 * quality scale? On low tier fewer points → increase size slightly to compensate (2.0/2.2/2.5).

Also add faint constant "bio-glow" specks: ~2% of rock points tagged seed>0.98 → slight self-illumination (glow worms!) — tiny cyan dots always faintly visible (0.05) — gorgeous in dark caves and gives spatial anchor. Add attribute or reuse aSeed: if aSeed > 0.985 && mat==0 → ambient 0.06.

Drone trail: emit small fading particles — reuse shell concept; simpler: a THREE.Points buffer of 240 trail sparks updated CPU ring-buffer each frame (pos = drone pos + jitter, life 1.2s) — trivial cost, pretty. Do it.

Dust motes: 600 points in a 40-u box around camera, wrap-around drift, faint 0.05 white — parallax cue. Update in shader by time? CPU update cheap (600). Shader-based: position = base + wind*t wrapped in box relative to camera via uniform. Simplest CPU.

Right — also OrbitControls import for free cam.

HUD layout:

• top-left: title block + stats grid (DEPTH, SURVEYED, PINGS, MODE).
• top-right: button column? Previous demos used bottom control bar. I'll do: top-right icon buttons (🔊 💥/ping ▶/⏸ 🎥 🎨 🖥 quality 📷 🔄 ❓). Bottom-center: ping button big on touch + hint bar. Keep desktop-first with touch support: bottom-right big PING button visible on touch (media query pointer:coarse).
• toast center bottom.
• loading overlay full.

Fonts: system stack + maybe 'Rajdhani'? Previous demos used Google fonts sometimes; to be safe offline, use system fonts with letterspacing. Keep system.

Now — write it. I'll aim for clean, complete code. Let me draft the JS in my head section by section and then produce the final file.

Key formulas: Pulse envelope (GLSL):

Sum with dominant tracking for ring color:

Ring color (depth mode):

Use cosine palette: pal(t) = a + bcos(6.2831(ct+d)) with a=(0.5,0.5,0.5) b=(0.5) c=(1.0) d=(0.0,0.33,0.67) rainbow-ish; but we want a curated scheme: teal-blue-violet: d=(0.25,0.45,0.65)? I'll use IQ palette with d = vec3(0.00,0.33,0.67) scaled; then tint: multiply by vec3(0.7,0.9,1.2)... Let me just define explicit gradient via mix chain: t in [0,1): c1 #eaf6ff (near white) → c2 #6ff3ff cyan → c3 #3a86ff blue → c4 #8b5cf6 violet → wrap. mix steps by t3 segment. Good, deterministic.

Normal mode: col = normalize(vNormal)*0.5+0.5; slight boost saturation: col = pow(col, vec3(1.2)).

Material mode: rock: vec3(0.45,0.62,0.78) modulated by normal.y*0.3 (floor/ceiling tint); crystal: mix(#ff4fd8, #41f0ff, seed) * 1.6; ruin: vec3(1.0,0.78,0.35)*1.15.

Glow worms: if mat==0 && seed>0.985: col = #7dffd4, brightness += 0.05 (constant).

Drone near-glow: g = 0.10 * exp(-dist(P, dronePos) * 0.30) — subtle teal.

Final color = col * (sum + ambient) + ... clamp. Brightness can reach ~3 near wavefront → bloom flare.

Vertex size: gl_PointSize = uSize * uPixelRatio * (160.0 / dist). With uSize ~2.4 & typical dist 20 → 2.41.58 = big?? Wait formula: size_px = worldSize * projFactor / dist. Standard: gl_PointSize = size * ( scale / - mvPosition.z ) where scale = drawingBufferHeight * projectionMatrix[1][1] * 0.5. For height 900, fov 70 → proj[1][1] = 1/tan(35°)=1.428; scale = 9001.4280.5 ≈ 643. worldSize ~ 0.09 → at dist 15 → 0.09643/15 ≈ 3.9 px. At dist 60 → 1 px. At dist 5 → 11.6 px clamp 22. Good: worldSize uniform uSizeWorld ≈ 0.085 (adjust per tier: low tier 0.12). Compute scale in shader from uniforms: uScale = heightproj[1][1]*0.5 passed each frame (cheap).

Also round sprite in fragment with soft edge:

Maybe a = a*a for tighter core.

Drone shells shader: fresnel = pow(1.0 - abs(dot(normal, viewDir)), 2.5); alpha = fresnel * uLife envelope; color cyan * (1+front flash). Envelope in JS per frame: set material.uniforms.uEnv, scale radius = SPEED*(t-t0). Additive, side: THREE.DoubleSide, depthWrite false. Remove/deactivate when t-t0 > TMAX (shell reaches max 128 u — huge sphere; scaling a unit sphere ×128 fine).

Trail sparks: BufferGeometry 240 pts; per-frame CPU update positions & life attribute; shader simple fade by life; size 0.05. Additive.

Dust: 500 pts within box 46³ around camera; velocity slow drift + wrap. Color faint blue-white 0.05 constant + drone proximity boost? Just constant faint — but "constant visible" breaks the pitch-black aesthetic... Dust only visible near drone (same near-glow trick in its shader: alpha = 0.14 * exp(-d*0.25)). Good.

Now audio specifics (keep compact but real):

• ctx created on start click. master = Gain(0.9) → compressor → destination.
• reverb: Convolver with IR 2.8s stereo exponential-decay noise; reverbGain 0.55.
• pingEcho: DelayNode 0.34 + feedback gain 0.42 → filter lowpass 2400 in loop... keep: ping → dry → master; ping → delay(fb) → master; ping → reverb.
• ping(): osc sine f0 1700→1150 exp over 0.10s; gain 0.0001→0.35 (attack 3ms) decay 0.45 exp; plus osc2 2×f0 gain*0.18; plus noise click 8ms highpass 3000 gain 0.06. Stereo pan slight random.
• drip(): every 0.5-2.4s random: osc sine f=900+rand*1800 → *0.55 over 0.09s (drop), gain 0.02-0.05, decay 0.3, reverb send 0.8, pan random. Also occasionally a "deep bloop" (120→70Hz) for variety.
• pad(): two saws 55 & 55.4 → lowpass(180, Q 0.7) → padGain 0.035; LFO 0.07Hz → padGain ±0.012; plus sub sine 27.5 gain 0.02; plus airy noise: buffer noise → bandpass 500 Q 8 → gain 0.004 with slow random wander (wind in caves).
• shimmer(): on ping: noise buffer → bandpass sweep 300→2600 over 1.4s → gain env 0→0.035→0 (1.8s) → reverb.
• choir(root): 3 osc (1, 1.189(♭3? make minor third 6/5=1.2), 1.5) × root(110 or 98) triangle, detune ±4 cents, gain env 4s swell 0.05, reverb 0.9.
• heartbeat rumble when very deep? skip.
• Mute toggle + volume slider.

Autoplay policy: created/resumed inside click handler on start overlay. Also first user ping resumes.

Adaptive quality: frame times ring buffer 120; every 2s evaluate: avg fps < 42 → tier down (if not manual-lock? even manual: respect manual, only auto when tier set to Auto). Provide Auto default. Buttons: quality cycles Auto/High/Med/Low display "Q: AUTO·HIGH". Keep simple: key 1/2/3 sets Low/Med/High manual, 0 or button cycles incl. Auto. I'll do button + keys.

setTier(t): drawRange count = [1M, 550k, 280k][t] (≤ total), uSizeWorld = [0.085, 0.10, 0.125], pixelRatio = [1.75, 1.5, 1.25]∩dpr, bloom strength maybe same. Auto logic separate.

Regenerate: seed = (Math.random()*2^31)>>>0; dispose old geometry/shells; show quick loader; rebuild; reset flags, survey, pulses (clear amps), drone s=0, visited set; toast "NEW DESCENT CHARTED".

Path end handling: sNorm ≥ 1 → trigger fade overlay (CSS opacity black 1.2s) → reset s=0, clear pulses, visited keep? New descent: reset visited + survey keep? Survey is per-world: keep cumulative. Just reset path & visited-chambers (so toasts refire). Fine.

Help overlay: grid of keys; toggled H or ❓; shown initially? Show briefly at start (auto-hide 9s) — with the start overlay covering instructions already, keep help hidden initially; start overlay lists controls.

Start overlay: title, subtitle, "SURVEY 001" seed display, controls list, big ENTER button (disabled until generation done with progress %).

Footer credit: "Demo 062 · ECHODEEP · three.js r160".

Edge: prevent context menu on long-press? Add touch-action none on canvas, preventDefault on touchstart for ping except on UI.

Visibility: on hidden → audio ctx suspend? Keep; clamp dt.

Right — one more feature for wow: "MEGA-PING" — hold Space/click-hold ≥0.5s charges a deep resonant ping with amp 3× and TMAX×1.5 (range 192) with deep bass whoomp + bigger shell. Charge ring UI around ping button. That's a nice interactive depth. Implementation: keydown start timer; keyup: if held>0.45 → megaping else normal. Mouse: pointerdown/up on canvas same. Add charge visual: small circular progress near crosshair? Add center dot crosshair that grows. OK moderate effort, good payoff. Manual ping cooldown 0.3s; megaping cooldown 2.5s.

Crosshair: subtle center dot (CSS) — helps aiming vibe.

Now write the code. I'll be methodical. Sections:

1. HTML head: meta, title, CSS (HUD, overlay, buttons, toast, loader, crosshair, help).
2. body: container canvas? renderer appends; HUD divs; importmap; module script.
3. JS module:
   • imports
   • PURE-BEGIN: mulberry32, Simplex class, fbm3, buildCave(seed) returning {prims, nodes, mainIdx, chambers, bounds}, primArea, computeCounts, samplers (capsule, chamber/ellipsoid, cone, octahedron, cylinder, torusArc, box), sampleAll into arrays (chunked with progress callback — async but pure aside from await), envelope JS mirror (for tests).
   • PURE-END
   • Config/constants
   • Renderer/scene/camera/composer setup
   • Points shader material + geometry build from arrays (+index shuffle)
   • Drone build + shells + trail + dust
   • Path spline from main nodes
   • Audio engine object
   • Input handlers
   • HUD/update fns
   • Main loop
   • Quality/adaptive
   • Regenerate
   • Start flow

Length ~1400+ lines. Let me write it now carefully, watching for syntax errors and r160 API correctness.

Important detail: indexed Points drawRange — geometry.setDrawRange(0, N) with index: draws first N indices. Note three r160: drawRange applies to index count when indexed. Confirmed.

Shuffling: Fisher-Yates on Uint32Array.

Buffer attributes: position (3), aNormal (3), aMat (1), aSeed (1) → 8 floats/pt × 1M = 32 MB — fine.

For survey flags: Uint8Array(total).

Now, buildCave design (pure):

Then features:

• speleothems (cones): for each chamber node: k = floor(r0.9); pick dir up-ish: point on shell: pos = c + dirShell(r*0.92) where dirShell = normalize([rx, +|ry|*sy sign, rz]) for stalactite (hang from top): apex at shell top, cone axis pointing inward-down: base center at shell point, tip = base + inward * len. For sampling a cone we need base center b, tip t, base radius rb. Stalactite: b on ceiling, tip below. Stalagmite: b on floor (y min), tip above. For tunnels: sparse cones every few edges: 30% edges get 1-2.
• crystals geodes: pick ~ 10 + rng6 spots: choose random edge, t along, wall point at radius, inward normal; cluster count 3-7; each octa: center at wallPoint + inward0.3, axis dir = inward + rand0.45 normalized, L = 0.9+rng1.9, R = L*(0.16+rng*0.1). Deeper zones → bigger.
• ruins in cathedral node (main last): columns ring n = 7+(rng4|0) at radius R0.55, height 8-13, rad 0.7-1.0, some fallen (tilt axis random, tilt 75-95°, lying on floor: base center offset); arcs: 2-3 torus arcs connecting tops of adjacent standing columns: center midway, radius = dist/2, tube 0.45, arc span ~180°? An arch between two column tops = half torus in vertical plane. Sample torus arc in its plane. blocks: 8-14 boxes random sizes 0.6-2.2 scattered on floor, random yaw/tilt.
• Also "broken ring" big: a large fallen ring (torus R 3-4, tube 0.5) half-buried — nice silhouette. Add one, tilted.

Sampling primitives — each prim: {type, mat, ...params, weight} where area computed per type:

• capsule lateral: 2π((ra+rb)/2)*len + sphere caps approx π(ra²+rb²)
• chamber ellipsoid: 4π r² * sy approx → 4π r² * (0.5+0.5*sy)
• cone: π rb * slant
• octa(crystal): 8 faces... area = 2*sqrt(3)*a² where a edge... for elongated octa approx: 4 * L * R * 1.4? I'll approximate area = 2.6 * L * R. Density boost ×3 for crystals.
• cylinder (column): 2π r h + caps
• torusArc: (2π R * arcFrac) * (2π tube)
• box: 2(ab+bc+ca)

computeCounts: weight = area * density[mat] (density: rock 1, crystal 2.6, ruin 1.15); n_i = max(minCount, round(total * w_i / Σw)). Adjust rounding drift: fine to be approximately total; drawRange tiers use fraction of actual total. Cap: ensure Σn ≤ total+ε — allocate arrays with computed sum (exact), and tiers use fractions of sum. Better: allocate exact sum; tier counts = sum * [1, 0.55, 0.3] floor. Good — no waste.

Samplers (uniform-ish):

• capsule(a,b,ra,rb): pick t (weighted by radius for area uniformity — approx t uniform fine), θ; frame: u = normalize(b-a); pick w = any perpendicular; v = u×w. radius = lerp(ra,rb,t) + noise? noise applied later globally. pos = a + u*(t*len) + (w cosθ + v sinθ)*radius; normal = radial dir.
• ellipsoid chamber(c, r, sy): dir = gaussian-ish sphere point via (u=rng2-1, θ) method; pos = c + [dxr, dyrsy, dz*r]; normal = normalize([dx, dy/sy, dz]).
• cone(b, tip, rb): h = |tip-b|; axis; pick t along (surface ∝ radius: t' = 1-sqrt(1-rng)?? radius decreases linearly from rb at base to 0 at tip: area element ∝ r(t) → sample t with pdf ∝ (1-t): t = 1 - sqrt(1 - rng)). θ; radius = rb*(1-t); pos = b + axis*(th) + radialradius; normal = normalize(radial + axis * (rb/h)) approx cone normal.
• crystal octa(center, axis, L, R): vertices: tipTop = center + axisL0.72, tipBot = center - axisL0.28 (stub in wall), equator: 4 points radius R around center at 90°: e_k = center + (f1 cos(kπ/2+φ) + f2 sin(...))*R. 8 triangular faces. Pick face weighted equal (similar areas), sample triangle with sqrt trick; normal = face normal (flat shading look — good for crystals!).
• column cylinder(b, h, r, tiltAxis, tiltAng, fallen): if standing: along +Y from base b; sample side (85%) or caps. If fallen: axis rotated; base center at b + something. Just parameterize with axis vector & start point; caps included.
• torusArc(c, R, tube, arc0, arc1, planeBasis u,v, tilt): θ ∈ [arc0, arc1] uniform, φ ∈ [0, 2π); pos = c + (u cosθ + v sinθ)(R + tube cosφ) + n(tube sinφ) where n = u×v. normal = radial tube dir: (u cosθ + v sinθ)*cosφ + n sinφ.
• box(c, size[3], yaw, tilt): pick face ∝ area, sample rect, normal = face normal rotated.

After base sampling: rock types (mat 0: capsule, chamber, cone) get noise displacement:

Crystals/ruins: tiny displacement 0.03 (worn edges) or none.

Stratification per point: also small tangential jitter 0.15 for organic feel (rock only).

Now the "uniform prefix" via shuffled index — do once after arrays filled.

Async chunked fill: prims array with counts; iterate; every ~150k points await nextFrame() and report progress = filled/totalPts.

RNG inside sampling: use the same seeded rng — fine (deterministic per seed).

Also compute: mainPathPoints = main nodes' p arrays (for spline), nodeInfo for chambers (pos, r, main, visited flag in app layer).

Bounds for fog/culling: not needed.

Entrance direction: start dir z+; camera initial s=0.

Depth stat: depth = (0 - droneY) * 2 (units→meters, start y≈0). Since downward bias mild, end depth maybe 60-120u → 120-240 m. Good.

Survey % denominator: totalPts.

Now GLSL code (points):

Wait — culling by moving offscreen: with additive blending a black point adds nothing anyway; but it still costs fragment. Culling via gl_Position w trick: position at (2,2,2) with w=1 → clipped. Points clipped entirely when center outside — fine since size small. Saves fill. But careful: bright includes worm/dg so those stay.

Hmm, but when uColorMode==0 and no pulse yet, all culled — pure black with drone glow only. Intended.

Fragment:

Gaussian-ish sprite — soft. Additive.

MAXP = 12. Loop unrolled by compiler; fine.

Uniform arrays in three: uPulses: {value: [Vector4 ×12]}, uPulseAmp: {value: Float32Array(12) or array of numbers}. three handles arrays of Vector4 for vec4[N]; for float[N] use plain array. OK.

Drone near glow uniform uDrone vec3 updated per frame.

Now drone mesh:

• group: core = Icosahedron(0.32, 1) MeshBasicMaterial color #bffcff; inner point? no lights.
• ring1 = Torus(0.55, 0.045, 10, 48) basic #37e6ff, ring2 = Torus(0.75, 0.03, 10, 48) #8b5cf6 rotated 90°.
• halo: Sprite with radial gradient canvas texture, additive, scale 3.
• Eye: small sphere front? Add direction tick: cone pointing forward (mat #ffd166)? The drone orienting along tangent: quaternion setFromUnitVectors or lookAt along tangent.
• Animate rings rotation.

Shells: class PulseShell {mesh, t0, amp, active}. sphere geo shared. material per shell (uniforms uEnv, uColor). On ping: activate. Per frame: r = SPEED*(now-t0); scale.set(r); uEnv = amp * exp(-(now-t0)/2.2) * fade near end; deactivate > TMAX? Shell visible maybe only first 3.5s (env small after) — deactivate at 4s to save fill (huge spheres fill-rate!). Yes: shellMaxT = 3.2 s. Also cap radius accordingly. Fresnel shader:

Additive, DoubleSide, depthWrite false, depthTest true? Shells should be occluded? No depth in scene (points don't write depth) → shells always visible. Keep depthTest false so it's a clean overlay ring. Fine.

Trail: 220 points ring buffer; each frame write drone pos + small random into slot i%220 with life=1; shader: alpha = life; CPU decrements life array per frame (220 ops). Simple ShaderMaterial like dust.

Dust: 500 pts positions random in 44³ box centered 0; per frame: pos += veldt; wrap around camera: if any axis diff > 22 → reposition opposite side (mod). Shader: alpha = 0.12exp(-dist(uDrone)*0.22)… compute color in vertex like main. Size 0.035 world.

Audio module — straightforward WebAudio as planned.

HUD stats update every ~0.15s.

Toast: div, queue, fade.

Chamber toast names: pick from list: ["THE VESTIBULE","ECHO GALLERY","THE ORGAN LOFT","MIRROR HALL","THE SCRIPTORIUM","HALF-LIGHT CHAPEL","THE CISTERN","PILLAR GARDEN","THE ANTECHAMBER","HOLLOW CHOIR", ...] assign per chamber index randomly; cathedral final: "THE SUNKEN CATHEDRAL".

Now sizes: total points 1M default. Generation cost: noise 4-octave fbm ≈ maybe 1.2µs ×2 calls = ~2.4µs per rock point; 800k rock pts ≈ 2s. Hmm borderline; reduce: rock displacement octaves 3 + skip second fbm for half? Use oct 3 (3 noise evals) + detail only 30% points. Or cheaper value noise? Simplex3 ~ 60ns-100ns per call in optimized JS... realistically ~150-250ns. 4 oct = 1µs. 800k × 1.3µs ≈ 1.0-1.5 s. Acceptable with progress bar. Keep oct 4 + oct 2 detail. ~1.5s. OK.

Let me now also make the JS-mirror of the envelope for tests: pulseEnvJS(dt, d, amp).

Testing plan (node):

• mulberry32 deterministic sequence equality across two instances.
• simplex: output in [-1,1] approx over 10k samples; deterministic.
• buildCave(seed): nodes count > 40; edges connect valid indices; main path length = MAIN_N; no NaN positions; cathedral node is last main with r ≥ 20; chamber count ≥ 3.
• computeCounts: sum ≈ total within 1%; each ≥ min.
• samplers: capsule sample distance from axis ≈ radius ±(noise amp 2.5): check 1000 samples no NaN, radial dist within [r-2.6, r+2.6].
• octa samples: within bounding box; no NaN.
• envelope: env(-1)=0; env(0)=~amp; env(TMAX+1)=0; monotonic decrease after 0.5.

Extract PURE section via awk '/PURE-BEGIN/,/PURE-END/' — ensure no three references inside. Samplers need no THREE (plain arrays). buildCave plain. Good. But the async chunked wrapper stays outside pure (app-level). Pure provides sampleAll(rng, noise, prims, counts, arrays, onChunk?) synchronous — chunking done in app by splitting prim list? Simpler: pure function samplePrimitive(prim, n, rng, noiseFn, out, off); app loops prims and awaits between. Test calls sampleAll convenience loop (sync) using same primitives. I'll include both samplePrimitive and sampleAll in pure.

One risk: simplex implementation bugs. I'll use a well-known compact implementation and test range/determinism.

Also gradient noise continuity not critical (rock roughness).

Time to write the file. I'll write it in one big heredoc via write tool. Then extract & node --check, write test, run, fix issues, then update index.html, then done.

Let me carefully write CSS/HUD ids:

• #hud-top-left: .title, .stats (4 stat rows: #stat-depth, #stat-survey, #stat-pings, #stat-mode)
• #hud-buttons top-right: buttons: btnPing(💥 PING), btnPause(⏸), btnCam(🎥), btnMode(🎨), btnQuality(🖥), btnMute(🔊), btnSnap(📷), btnRegen(🔄), btnHelp(❓) — with labels tooltips.
• #toast container.
• #help overlay.
• #loader overlay: title, seed, progress bar (#load-bar-fill), #load-status, #enter-btn (disabled until done).
• #crosshair center dot + #charge ring (SVG circle).
• #fade black overlay for transitions.
• ping cooldown indicator near crosshair: tiny bar.

Colors: --cyan:#59f2ff; --violet:#8b5cf6; bg #010204.

Fonts: system-ui.

Buttons style: dark glass, border cyan-ish, hover glow. Consistent w/ previous demos.

Touch: media (pointer:coarse) show big PING bottom-right (#ping-big), bottom-left small pause.

Also add user-select:none, overscroll-behavior:none.

Snapshot: on click: composer.render(); renderer.domElement.toBlob(...) — with OutputPass last, canvas holds final. Good.

Prevent OrbitControls hijack: free-cam only enabled when mode on.

Canvas pointer events: pointerdown on renderer.domElement → start charge (record time, show ring); pointerup → fire (short or mega). Also pointermove → look offsets (normalized -1..1). Disable when clicking UI (buttons stopPropagation; canvas listener only on canvas).

Keys: as mapped. Space preventDefault (scroll).

Pause state: drone frozen (s constant), auto ping paused, but uTime continues (reveal fades continue) — nice.

Camera modes: 0 follow (default), 1 free-orbit. Toggle C/button. In free mode: controls.enabled = true; target lerp to drone each frame.

Follow cam details:

Now write the big index.html. I'll write it in parts to be safe — actually a single write of ~60-70KB should be OK. Let me compose carefully.

I'll write the whole thing now. Be careful with:

• GLSL template strings (backticks) — inside a heredoc-safe write tool (the write tool takes content directly, no shell escaping issues).
• Section markers for PURE extraction.

Let me draft the complete file mentally and write it.

Key constants:

• MAXP 12
• SPEED 16, TMAX 8, TAU 4.6
• Points budget ~1M

I need to be really careful with the code. Let me write it.

Plan of the module script:

Everything pure takes/returns plain arrays & objects.

vec helpers: add3, sub3, scale3, norm3, cross3, dot3, len3, lerp.

Simplex 3D — standard Stefan Gustavson implementation:

Good.

fbm3(noise, x,y,z, oct, lac=2.02, gain=0.5).

buildCave(seed): returns {nodes, edges, prims, mainIdx, chambers, cathedral, seed}. prims get built here too (cones, crystals, ruins) — features need rng and node info. And each prim has .mat and area weight computed in computeCounts via primArea(prim).

Prim types & fields:

• {t:'capsule', a:[..], b:[..], ra, rb, mat:0}
• {t:'chamber', c:[..], r, sy, mat:0}
• {t:'cone', base:[..], tip:[..], rb, mat:0} (stalactite: base on ceiling, tip inward)
• {t:'crystal', c:[..], axis:[..], L, R, rot, mat:1}
• {t:'cyl', base:[..], axis:[..], h, r, mat:2}
• {t:'arc', c:[..], u:[..], v:[..], R, tube, a0, a1, mat:2}
• {t:'box', c:[..], s:[sx,sy,sz], rot:[ax,ang] axis-angle? Simpler: yaw+tilt small — store rotY and rotZ angles; sample faces then rotate points. Let me store a full basis: {t:'box', c, e1,e2,e3 (scaled half-extent vectors)} — build basis at creation with yaw/tilt. Sampling: choose face by area, point = c ± e_i + α e_j + β e_k.

Basis helper: basisFromYawTilt(yaw, tilt) → orthonormal e1,e2,e3 then multiply by half sizes.

For fallen columns: axis vector given.

For arcs: basis u,v define plane; normal n = cross(u,v).

primArea:

• capsule: len2π(ra+rb)/2 + π(ra²+rb²)
• chamber: 4π r² (0.6+0.4 sy)
• cone: π rb (slant = sqrt(rb²+h²))
• crystal: 2.6 L R
• cyl: 2π r h + 2πr²
• arc: (a1-a0) R * 2π tube
• box: face areas: 2(|e1||e2| + ...) with half extents → 8*(h1h2+h2h3+h3h1)? For half extents a,b,c: full area = 8(ab+bc+ca)? No: box with half extents a,b,c has faces 2*(2a2b + 2b2c + 2c*2a) = 8(ab+bc+ca). Yes.

density: mat0 1.0, mat1 3.0, mat2 1.25.

computeCounts(prims, total): weights; raw counts; ensure min 24; sum may exceed total slightly → scale down: after min assignment, normalize. Simpler: n = Math.max(24, Math.round(totalw/Σw)); then compute sum; allocate sum (≈total ± prims24 — small). Tiers use fractions of sum. Good.

Samplers (all push into out {pos, nrm, mat, seed} Float32Arrays at offset, return points written):

Each writes pos[3i], nrm, mat scalar, seed.

Rock displacement helper applied for mat 0 inside each sampler at end (or in common post pass):

rough: capsule 1.35, chamber 1.9, cone 0.35 (relative to scale... make absolute-ish: capsule rough = 0.30rAvg? Let me set rough per prim at creation: rough = 0.32avgR clamp [0.9, 2.2]; chamber rough = 0.22r clamp [1.2, 3.2]; cone 0.25rb+0.15.)

Also tangential jitter 0.12 for rock.

Crystal: no displacement; maybe 0.02 micro jitter. Ruin: 0.04 worn.

Seeds: rng() per point.

Now the app layer. Detailed pieces:

Constants:

State:

Build geometry:

Geometry: BufferGeometry, setAttribute position/aNormal/aMat/aSeed, setIndex(BufferAttribute(idx,1)), boundingSphere set manually large (avoid compute cost: compute anyway once fine — 1M iteration ok ~10ms). Set boundingSphere = new THREE.Sphere(center of nodes, radius max+150). frustumCulled = true fine with correct bounds.

Material: ShaderMaterial as designed; uniforms: uTime, uScale, uSizeWorld, uDrone(vec3), uColorMode(int), uPulses (array of 12 Vector4), uPulseAmp (Float32Array(12) — three supports {value: Float32Array} for float[12]? For uniform arrays of floats, value should be array of numbers or Float32Array — both work in three r160 (it flattens). I'll use regular Array(12).fill(0).)

Draw tier: geometry.setDrawRange(0, tierCount).

Pulse firing:

Mega: amp 2.6, and shader-side same TMAX... range extension for mega: shader uses fixed TMAX; mega just brighter (atten reaches farther effectively). CPU scan radius: R = SPEED*TMAX = 128; mega scan radius 150 (approx since brighter → visible slightly farther). OK.

surveyScan(origin, R): job = {ox,oy,oz,R2,idx:0}; in tick: process chunk 160k:

Note positions are indexed-shuffled but scan over raw array fine.

Spline: mainCurve = new THREE.CatmullRomCurve3(mainPts, false, 'centripetal', 0.5); curveLen = getLength().

Drone update:

Note: getPointAt uses arc-length mapping internally (getUtoTmapping) — needs getLengths precomputed — fine.

Camera follow:

Free mode: controls.target.lerp(dronePos); controls.update().

uDrone.value.copy(dronePos).

Auto ping timer: every 1.7s if playing && autoPing: firePing(dronePos, 1.0).

Chamber visit check each 0.2s: for unvisited chambers: if d < r*0.85 → visited, toast(name + diameter), audio.choir(depth-scaled root), if cathedral → special toast + bigger choir.

End of path: u>=0.999 → fade overlay in → reset droneS=0, pulses cleared (amps=0), visited reset, fade out. Toast "SURVEY LOOP — NEW DESCENT".

Shells pool:

Fresnel vertex: pass world normal & view dir.

Trail: as planned (240). Dust: as planned (500) in a Points with own simple shader; update CPU.

Audio engine: object with init() on user gesture; methods ping(mega), drip scheduling via setTimeout-ish in tick (use ctx time scheduling), pad start, choir(root), shimmer, setMuted, setVolume. Implement carefully with try/catch guards.

Composer:

GradeShader: uniforms tDiffuse, uTime, uRes; chromatic offset ~0.0015dist, vignette 0.32 smooth, grain hash0.05, slight lift shadows teal. OutputPass then grade: grade gets sRGB input, fine.

renderer: antialias true, toneMapping ACES, outputColorSpace default. Note: with composer + OutputPass, tone mapping applied in OutputPass using renderer.toneMapping settings. Set renderer.toneMapping = THREE.ACESFilmicToneMapping; toneMappingExposure 1.1.

Resize handler: renderer.setSize, camera aspect, composer.setSize, bloom.setSize, uScale uniform update, uRes.

uScale = (renderer.domElement.height [drawing buffer px]) * projM[1][1] * 0.5 → compute after resize & camera update: uScale = (h * pixelRatio?) — drawingBufferHeight = floor(h*pr). gl_PointSize is in device px → use drawingBufferHeight. renderer.getDrawingBufferSize(v2).

fps monitor: frames counter; every 2.5s: fps = frames/elapsed; auto tier adjust if autoQuality.

HUD update: depth, survey %, pings, mode label, quality label, mute icon.

Snapshot:

Loader flow:

Also allow regenerate from pause menu later.

Regenerate: guard if busy; show loader overlay small (reuse with "RECHARTING…"); dispose old: scene.remove(points); geo.dispose(); clear pulses; rebuild via same function; hide.

Edge: material dispose & re-create or reuse? Create new material per world is fine but uniforms refs used globally (uPulses etc.) — keep single material instance stored in variable pointsMat re-created; simpler: create material once at boot with uniform objects; geometry swapped per world. Points object: remove old Points, add new Points(geo, pointsMat). Uniform objects persist — good, since pulse uniforms stored on material.uniforms.

But uTime shared: define uniform objects in module scope and reference in material; shells read uTimeVal variable.

Careful: uColorMode int uniform {value:0}.

Help overlay content: table of shortcuts.

Let me also include and webgl fail message.

Touch look: pointermove while pointer down? For touch: drag anywhere = look; tap (short, no move) = ping. Implement: track pointerdown pos/time; on pointerup: if moved<8px and dt<400ms → ping (charge if long? on touch long-press = mega: dt>=450 → mega). Move sets look offsets from drag delta accumulated (not absolute position): lookX += dx0.005 clamp ±1. Desktop: mousemove absolute → look target = (x/w2-1, -(y/h*2-1)) * small; click-hold charge.

Unify: pointer events; if pointerType mouse → move always updates look (absolute); touch → drag updates look (delta). Down/up on canvas handle charge.

Also desktop click should not ping when clicking buttons — buttons are HTML above canvas; canvas listener only fires for canvas target. Buttons stopPropagation anyway.

Right-click: prevent context menu on canvas.

Now write the HTML/CSS.

CSS sketch:

Buttons: width auto; padding 7px 10px; font-size 11px; letter-spacing .12em; background var(--panel); border 1px solid var(--border); border-radius 8px; color #bfeef7; cursor pointer; backdrop-filter blur(6px). hover: border-color cyan, glow. active state class .on (color gold?).

Loader overlay: full, radial gradient bg (#03141b → #010204), center column: big title ECHODEEP letterspaced, sub, cave diagram? Keep: title, tagline, seed line (#seed-line), progress bar (260px), status text (#load-status), enter button hidden→shown, controls mini-grid, footer note.

Help overlay: panel centered with key table; close on H/❓/click.

Charge ring: SVG 54×54 circle r=24 stroke cyan, dasharray=2πr, offset updated; opacity 0 until charging.

Crosshair: 3px dot + 12px faint ring, mix-blend screen.

Fade: #010204 opacity 0 → transitions.

Toast: bottom center above hint: pill background panel border cyan, letter-spacing, fades (CSS class .show).

Now GLSL grade shader:

ShaderPass provides vUv via its own vertex — when using ShaderPass with custom shader object need varying vec2 vUv; in vertex: use standard copy vertex:

Shell shaders: vertex:

fragment:

uCam = camera position uniform.

Trail/dust shaders: reuse a generic "sparks" shader: vertex: attribute aLife; uniform uSize; varying vA; compute size attenuated; vA = aLife * glow proximity for dust handled via uDrone... For dust: alpha = 0.10 * exp(-dist*0.2) — compute in vertex with uDrone uniform; for trail alpha = aLife. Two small materials, fine.

Trail update CPU: arrays pos(2403), life(240); each frame: head = (head+1)%240; pos=head → drone pos + jitter 0.25; life[head]=1; then for all: life = max(0, life - dt0.8); attribute needsUpdate. 240 iterations trivial.

Actually smoother: spawn 2/frame. fine 1.

Dust: 460 points; vel per point; pos += vel*dt; wrap in box 40³ around drone: if (p < drone-20) += 40 etc. needsUpdate.

Now — audio engine code:

drip scheduling in tick: if ctx && time > nextDrip → schedule drip, nextDrip = now + 0.5+rand*2.

choir root by depth: root = 110 * pow(0.5, depth/300)? Keep root 98-146.9 range: pick from [98,110,123.5,146.8] by chamber index. Cathedral big=true root 73.4 (D2) minor → add fifth below? fine.

shimmer:

drip:

Note exponentialRamp to 0.0001 from setValueAtTime(0.0001) fine.

pad:

Wait — LFO adds ±0.011 around 0.035 fine.

Volume/mute: master.gain setTargetAtTime.

Also resume ctx on visibilitychange/gesture: ctx.resume() in start click and ping handler if suspended.

OK. Chamber names list (12-14 names) + cathedral.

Let me also add Pings count, and "SURVEY" percent = revealed/total.

Now — assemble the final HTML. I'll write it now, carefully, in one file write. Then validate.

One more detail: OrbitControls import path and usage only in free mode; create once with controls.enabled=false.

Also stats of drift: The drone look up vector: use world up (0,1,0); when tangent nearly vertical, lookAt degenerates — downward bias mild so tangent never vertical. OK.

Let me make sure the vertex shader compiles in WebGL2/GLSL1 (three default ShaderMaterial is GLSL1 unless glslVersion set; three injects #version only for RawShader with glslVersion). For ShaderMaterial, attribute/varying get auto-converted? No — ShaderMaterial in WebGL2: three compiles shaders with GLSL1 syntax accepted (WebGL2 accepts #version 100? Actually WebGL2 contexts accept ESSL 1.00 shaders — yes, WebGL2 supports both ESSL 1.00 and 3.00). three's default: shaders without #version → ESSL 1.00. gl_PointCoord available in ESSL1 fragment for points. gl_PointSize in vertex OK. texture2D OK. So GLSL1 syntax fine.

Uniform int uColorMode: declare uniform int uColorMode; value {value:0} fine. Comparisons int fine.

Loop for (int i = 0; i < 12; i++) with const MAXP via #define MAXP 12 — I'll inject define in shader string: const MAXP = 12; as GLSL const int: const int MAXP = 12; loop OK in ESSL1 (constant expression). Good.

Array uniforms: uniform vec4 uPulses[MAXP]; uniform float uPulseAmp[MAXP]; three: value = array of Vector4 (len 12) and Float32Array(12)/Array(12). OK.

Culling trick gl_Position = vec4(2,2,2,1) → NDC (2,2,2) outside clip → discarded entirely (point clipped at center). Wait: clip space: x/w=2 >1 → clipped. Good.

One concern: culling when bright<0.004 — with worm constant 0.055 stays. And drone glow near. Fine.

Additive with black = no-op; but culling saves fragment cost massively in dark phases.

Point size clamp 26 — near walls could look blobby; ok.

uScale uniform: pass drawingBufferHeight * P[1][1] * 0.5 where P = camera.projectionMatrix. el[5]. Update on resize & FOV (constant fov).

gl_PointSize = clamp(uSizeWorlduScale/dist, 1.0, 26.0). uSizeWorld ~0.085: at dist 30, uScale (h=10001.4280.5=714): 0.085714/30 ≈ 2.0px.

At high DPR drawingBufferHeight bigger → sizes scale accordingly. Good.

Now the shells' geometry — SphereGeometry(1, 48, 32) shared; 12 meshes; materials cloned with own uniforms.

For the drone orientation: use m.lookAt(pos+tan, up)... THREE.Object3D.lookAt(target) orients +Z toward target? Object3D.lookAt makes -Z point at target for cameras; for objects +Z faces target? Object3D.lookAt orients the object's +Z axis... Actually Object3D.lookAt rotates so that its internal -Z? Docs: "Rotates the object to face a point in world space" — the object's positive Z axis points toward the target for non-camera objects? Let me recall: Object3D.lookAt uses Matrix4.lookAt(eye, target, up) which builds a matrix whose -Z is direction eye→target? Matrix4.lookAt constructs a rotation where the object's +Z points from target to eye (i.e., -Z faces the target). For cameras (which look down -Z) that's correct. For regular objects, three docs note: "This method does not support objects having non-uniformly-scaled parent(s)... camera looks down -Z". For meshes, using lookAt makes -Z face target. So design drone model with forward = -Z (cone pointing -Z). Or use quaternion.setFromUnitVectors. Simplest: build drone with forward along +Z? then -Z faces tangent... I'll build the model with the "eye" cone along -Z (pointing toward travel), and call drone.lookAt(pos.clone().add(tan)). Good.

Trail & dust Points also frustumCulled=false (positions change) — set boundingSphere huge or frustumCulled false.

Main points: frustumCulled true with manual boundingSphere (compute from nodes: center = midpoint of bounds, radius = max dist + 40). Compute during world build (cheap from node list + margins).

Now the demo flow timeline: loader → enter → fade in → drone starts; auto first ping immediately at start for instant reveal (fire 2 pings staggered at enter). Nice.

Toast at start: chamber name of entrance ("THE VESTIBULE" fixed for first chamber? name pool random; entrance = "ENTRANCE SHAFT"? It's a chamber r 7.5 — call it "THE VESTIBULE" always: I'll set first chamber fixed name.)

Cathedral: name "THE SUNKEN CATHEDRAL", gold choir, big toast, auto mega-ping on entry! — epic moment: when cathedral visited → firePing(dronePos, 2.6, mega=true) automatically once.

Also ruins get revealed — beautiful payoff.

Total write-up — the index card description for demos list: craft a nice paragraph.

Edge: When user presses R mid-flight: set busy, overlay loader with "RECHARTING THE DEEP", build, swap, reset (droneS=0, clear pulses amps, flags zero, revealed=0, pings keep? reset), hide overlay, toast.

Memory: old geo.dispose(); index attribute disposed with geometry. Points removed from scene.

Also on regen, keep same material (uniforms shared) — yes.

Visibility change: clamp dt ≤ 0.05 in loop; audio continues (fine).

Also add renderer.info.autoReset default fine.

Let me now write the actual file. I'll be very careful with syntax. Roughly 1300-1500 lines. Let me go.

Also remember: comment markers for PURE extraction: // ==== [PURE-BEGIN] ==== ... // ==== [PURE-END] ====

I'll extract with sed -n '/PURE-BEGIN/,/PURE-END/p' then strip the marker lines, save to /tmp/pure.js, then create /tmp/test.mjs that imports? pure.js isn't a module... I'll append export {}? For node test: cat pure.js + test code into one file /tmp/test.mjs. Since pure functions are plain function declarations, concatenation works. The test file then has asserts.

Note: pure section must not reference THREE or DOM. Samplers use only Math & passed rng/noise. buildCave plain.

sampleAll(rng, noise, prims, counts, out) convenience for tests.

Also for app use: samplePrimitive(prim, n, rng, noise, arrays, offset).

Let me define array bundle as {pos, nrm, mat, sed}.

Now write out. Also double-check every sampler writes EXACTLY n points.

Cone sampling detail: base center B, tip T, base radius rb. axis = norm(T-B), h=|T-B|. Frame u,v ⊥ axis. t = 1 - Math.sqrt(1 - rng()) → pdf ∝ (1-t) matching radius decrease. radius here = rb*(1-t). Wait pdf for uniform area on cone side: area element dA ∝ r(s) ds where s distance from tip... r(t) = rb*(1-t) with t from base(0) to tip(1). dA ∝ r(t) dt → pdf(t) ∝ (1-t) → CDF: 1-(1-t)² → t = 1 - sqrt(1-u). ✓.

Cone normal: slant k = rb/h; normal = normalize(radial + axis*(k))·? For cone tapering toward tip, surface normal has component along +axis of rb/slantLen? The outward normal = normalize(radialslantCos + axis(rb/slant))? Let me compute: cone x = B + axiss + radial(rb*(1-s/h))... dr/ds along surface: direction along surface generators: g = axish + radial(-rb) (as s goes 0→h). Normal = radial component adjusted: n = normalize(radialh + axisrb) — cross of (g × θ̂). Take n = normalize(radial1 + axis(rb/h)) normalized — good approximation: n = norm(add(radial, scale(axis, rb/h))). ✓ (outward & slightly toward tip? sign: for cone with base at B and tip at T, side normal tilts away from tip → -axis*(rb/h)? Visualize cylinder rb→0: normal tilts toward base. Hmm: surface point at s; moving toward tip, radius shrinks; outward normal has positive dot with direction from tip to base? Think 2D: line from (rb, 0) to (0, h) in (r, s) plane. Outward normal perpendicular pointing away from axis & "up-slope": direction (dr, ds) along line going to tip: (-rb, h). Normal ⟂: (h, rb) or (-h,-rb). Outward (positive r component) → (h, rb)/|..| → radial coefficient h, axial coefficient +rb where +s is toward tip. So n = norm(radialh + axisrb). ✓ matches my formula.

Capsule normal: pure radial (cylinder part) — fine for coloring.

Chamber normal: normalize([dx, dy/(sysy)?]) — true ellipsoid normal ∝ (x/a², y/b², z/c²): use [dx/(rr), dysy... ] whatever: normal = norm([dx, dy/(sysy), dz]) approx. I'll use norm([dx, dy/(sy*sy+1e-6), dz]).

Crystal face normals: compute per-face from cross products — flat shading.

Cylinder: side normal radial in plane ⊥ axis; cap normals ±axis.

TorusArc normal: as derived.

Box: face normals = ±e_i (basis vectors are orthonormal scaled by half-extents — keep separate half-lengths h1,h2,h3 and unit axes a1,a2,a3).

Box prim: {t:'box', c, a1,a2,a3 (unit), h:[h1,h2,h3]}.

Basis from yaw/tilt: e = Euler? plain math: a1 = [cos yaw, 0, -sin yaw] then apply small tilt rotation... Keep simple: yaw around Y, then tilt around new X by ang: compute via rotation formulas. I'll write helper rotAxis(v, axis, ang).

Ruins construction (cathedral node c, R):

• floor y: approximate floor at c.y - Rsy0.75. Columns: for i in n: ang = i/n2π + jitter; ringR = R0.55*(0.9+0.2rng); pos on ring; standing: base = [x, floorY, z], axis [0,1,0], h 7-12, r 0.6-1.0. Fallen (25%): axis = horizontal random dir, base = pos, h same (lying) → cylinder lying on floor: base at pos + axis*(h*0.5) center? For sampling define cyl by base center + axis + h: standing: base at floor; fallen: base at floor point, axis horizontal — it'll stick through floor slightly, fine (buried look).
• arcs: pick 2-3 pairs of adjacent standing columns: center mid of tops, u = norm(topB-topA) horizontal, v = [0,1,0], R = dist/2, tube 0.4, a0=0, a1=π (half arch upward): sample θ∈[0,π]: pos = c + u*(R cosθ) + v*(R sinθ) + tube ring. ✓ half torus arch.
• big ring: c + offset, R 2.5-4, tube 0.35-0.55, tilt: u,v random tilted plane, arc full 2π or partial 4.5. mat 2.
• blocks: 8-12 boxes at floor random yaw, sizes 0.5-2.0, slight tilt. c at floor + sy/20.6 (half-buried: cy = floorY + h2(0.3+0.5rng)).

Floor Y estimate: cathedral chamber center c, sy: floorY = c[1] - rsy0.8. OK.

Stalactites in chambers: k = clamp(r0.8, 4, 16): pick shell dir d (|dy|>0.5 for ceiling (dy>0): base = c + [dxr, dyrsy, dz*r]0.94; tip = base + inward dir: inward = norm(c - base) + [0,-0.6,0]?? stalactite hangs down: tip = base + norm(mix(inward, down, 0.6)) * len. len 1.5-6 ∝ r. rb = len(0.12+0.1rng). Stalagmites mirror (dy<0 floor). 60/40 split. Columns (joined) 10%: base floor, tip ceiling point above.

Tunnels speleothems: 25% of edges: 1-2 cones similar with smaller sizes using edge endpoints frame.

Crystal geodes: G = 9 + floor(rng6): pick random edge (weighted?), t=0.2-0.8, frame from edge dir; θ random; wallR = lerp(ra,rb,t)1.02; wallPoint = a + u(tlen) + radialwallR; inward = -radial. Cluster at wallPoint: count 3-7; each: axis = norm(inward + rand30.55); L = 0.8+rng2.0 (+depth boost), R = L(0.15+0.12rng); rot = rng2π; center = wallPoint + axis(L*0.18).

Counts: area-based with density — crystals small area but density 3 → still decent share; also min 24/point per prim... min 40 for crystals maybe min 30. Fine min=28.

Estimate total prims: edges ~ 62 main + ~30%*58 branches avg 8 nodes ≈ 140 branch nodes/edges... wait branch nodes: for each main node 3..58 (56) with 30% chance → ~17 branches × ~7 nodes = ~120 extra nodes & edges. Total edges ~ 180, chambers ~ main 10 + branch 8 = 18, cones ~ chambers 18×10 + edges 45 = ~225, crystal clusters ~ 12 × 5 = 60, ruins ~ 30. Total prims ≈ 500+. count loop fine. Min count 28 × 500 = 14k min overhead OK.

Total points 1M: edges area: r4, len11 → 2π411 ≈ 276 ×180 edges ≈ 50k area; chambers 4π1000.8 ≈ 1000 ×18 = 18k; cones: π0.54 ≈ 6 ×225 = 1.4k; crystals 2.6LR ~ 2.620.35=1.8 ×60 = 0.11k ×3 density; ruins ~ few k. Weights: edges 50k, chambers 18k, others small → edges ~68%, chambers ~25%. Points on cones/crystals/ruins might be sparse: cones 1.4k/69k ≈ 2% = 20k points / 225 cones ≈ 90 pts/cone — sparse for a cone of length 4... At worldSize 0.085 spacing on cone surface sqrt(area/90) ≈ sqrt(12/90)=0.36u gaps — visible as constellation rather than surface. Hmm. That's actually fine aesthetically (point cloud look) but speleothems might be too faint. Boost density: cones ×2.2, crystals ×3.2, ruins ×1.6. Then cones ≈ 200 pts each — decent.

Alternatively reduce TOTAL to 850k for perf safety... 1M points vertex-bound; modern GPUs fine; integrated GPUs use LOW tier 300k. Keep 1M.

Survey scan R2 = 128² = 16384.

OK writing now. Also define smoothstep JS helper.

For the toast: div#toast; function toast(msg, long=false).

HUD mode label: color mode names: ['DEPTH RINGS','NORMAL MAP','SURVEY MATS'].

Auto-quality: start tier 0 (HIGH). auto = true. evaluate every 2.5s: if fps < 42 → tier++ (max 2), toast? Silent small note in quality label. If fps > 57 && tier>0 && stable 3 evals → tier--. Manual keys 1/2/3 set tier & auto=false; key 0/button → auto=true.

Button label: "Q:AUTO·HI" etc. Show as "QLTY AUTO/HIGH".

Snapshot key: F? Use button + key "O"? Previous demos used S or camera button. S might conflict WASD? No WASD here. S = snapshot. fine.

Keys list:

• SPACE / CLICK: ping (hold 0.45s+ = MEGA)
• A: auto-ping toggle
• C: camera follow/free
• N: color mode
• M: mute
• P: pause drone
• R: rechart (regenerate)
• 1/2/3: quality low/med/high... wait 1=LOW? natural: 1 high? I'll do 1=LOW, 2=MED, 3=HIGH (ascending quality). Hmm previous demos often did 1/2/3 = quality tiers ascending. Fine, document in help. Actually to match intuition "3 = best", keep 1 LOW 2 MED 3 HIGH.
• 0: auto quality
• S: snapshot
• H: help

Init camera at spline start behind drone.

Let me write the code. Writing carefully now — this is long; I'll keep functions compact.

One more: OrbitControls when enabled needs to not fight follow cam: in free mode skip follow positioning; controls.target = drone pos each frame (lerp 0.2), controls.update().

Also free mode maxDistance 60 minDistance 2.

Also on entering free mode set camera position to current (continuity) — already there.

Pointer look offsets applied only in follow mode.

Charge mechanic: state charging {start, active}; ring update in tick: if charging: k = min(1, (uTimeWall - start)/0.6); ring dashoffset; crosshair scale. On pointerup: if duration >= 0.45 → mega (amp 2.6, cooldown 2.5s) else normal (amp 1.35, cooldown 0.35s since manual). Manual ping origin: camera position? From DRONE feels right (it's the survey vessel). Use drone position. Hmm — player agency: ping from drone pos. Yes.

Actually wait — manual ping from drone position even when paused — fine.

Cooldowns tracked with uTime.

Also crosshair visible only in follow mode? Always fine.

Charge uses wall clock (performance.now()/1000) to be robust to pause. uTime continues during pause anyway (I chose uTime always running). Use uTime.

Hmm wait — if uTime runs during pause, pulse fades continue — good.

uTime = clock elapsed since enter, accumulate dt each frame always (even paused).

Auto-ping only when playing && autoPing && !busy.

Alright — also small detail: renderer.setClearColor(0x010204, 1).

Bloom threshold 0.0 with dark scene: bloom picks everything — strength 1.0 radius 0.5. With ACES + additive points, looks good. Maybe threshold 0.15 to keep blacks clean; points brightness often < 0.15 in decay → no bloom on dim = fine (bloom mainly on fresh reveals & drone). Set threshold 0.12, strength 1.15, radius 0.55.

Grade shader after OutputPass.

Loader generation kickoff: run on DOMContentLoaded; but renderer init needs no gesture. Start building immediately, enter button enabled when done. Audio init on enter click.

Also seed display: "DESCENT #XXXXX".

Regen: seed = new random; update seed display.

Let me finally write the file. (Being extra careful about matching braces, GLSL syntax, template literal usage — I'll use string concatenation for shaders or template literals; template literals fine.)

Note: inside the HTML, the module script contains </script>? No — avoid that string anywhere in JS. GLSL has none. OK.

Write now.

Also — index.html card for the demos list: title "Echodeep — Sonar Cavern Survey". Description summarizing features.

Length check — let me write ~1450 lines. Go.

Actually, let me reconsider the vert shader culling: setting gl_Position offscreen when bright < 0.004. But drone glow dg adds 0.12*exp(-0.28 d): at d=25 → 0.0001. fine.

Also, IMPORTANT: I use position attribute (built-in declaration in ShaderMaterial vertex) — three auto-declares attribute vec3 position; etc. for ShaderMaterial. Custom attributes aNormal/aMat/aSeed must be declared manually — name them without clashing with built-ins (normal is built-in!). Use aNrm, aMat, aSeed. aMat fine.

Vertex needs uniform mat4 modelViewMatrix... — auto-provided. Only declare custom uniforms/attributes.

For shells/dust/trail ShaderMaterials same care: use normal built-in OK (declared automatically), don't redeclare.

In ESSL1 fragment shaders from three ShaderMaterial, gl_FragColor fine, and three prepends common prologue (precision, uniforms like cameraPosition? Actually cameraPosition uniform IS auto-declared in vertex only... In fragment, three's prologue includes uniform vec3 cameraPosition;? For ShaderMaterial, three prepends a standard prefix to BOTH shaders: vertex prefix includes attributes & matrices; fragment prefix includes precision + some defines, but NOT cameraPosition (that's in the fragment prefix? Checking memory: WebGLProgram prefixFragment includes uniform mat4 viewMatrix; uniform vec3 cameraPosition; — yes! prefixFragment for ShaderMaterial includes viewMatrix and cameraPosition (it does: 'uniform mat4 viewMatrix;', 'uniform vec3 cameraPosition;', 'uniform bool isOrthographic;'). So in fragment I can use cameraPosition directly without declaring. In vertex, cameraPosition also available. I'll still pass uCam uniform for shells to be safe & explicit... simpler: use built-in cameraPosition in fragment (it's declared by three). I'm fairly confident it's included in the fragment prefix for all materials. Yes — WebGLProgram.js: prefixFragment (non-raw) includes: uniform mat4 viewMatrix; uniform vec3 cameraPosition; uniform bool isOrthographic. Good — use cameraPosition in shell fragment without declaring.

But to be extra safe (in case of version differences), I'll declare my own uniform vec3 uCamPos; in the shell fragment and update per frame. No reliance. For dust/trail I need drone pos uniform anyway.

Points vertex: no camera pos needed.

OK writing the file NOW. For real this time. I'll write it in 3 sequential writes (write then append via shell cat >>? The write tool overwrites whole file; for appending, use execute_shell_command with heredoc — risky with special chars ($ in template literals → heredoc with quoted delimiter 'EOF' prevents expansion). Safer: use read_write_file tool 3 times? It overwrites; line-range writes are discouraged. Best approach: write part 1 with the write tool (create file), then append parts using cat >> file <<'HTMLEOF' heredocs — quoted heredoc delimiter keeps $ and backticks literal. Backticks in JS template literals inside heredoc: safe with quoted delimiter. Only risk: a line in content equal to delimiter. Use unique delimiter. Let me do 3 parts.

Actually single write tool call with the entire content is also fine — the tool accepts large content. I'll do one big write; if it errors, split. Let me carefully compose the entire file.

Let me write the code with great care now.

Regarding buildCave returning also speleo — no, everything is in prims. nodes/edges/chambers returned for app (spline + toasts). mainIdx list for spline order: nodes pushed in main order first (indices 0..MAIN_N-1 in order) — wait: I push branch nodes interleaved during main loop? No: main loop first (nodes 0..MAIN_N-1 = main path in order), then branches append after. mainIdx = [0..MAIN_N-1]. ✓ (entrance = node 0.)

For chamber list: entrance node0 (chamber, name fixed "THE VESTIBULE"), main chambers, branch chambers, cathedral (last main node). Chamber objects: {p:[x,y,z], r, name, visited:false, cathedral:bool}.

Names pool (shuffle): "ECHO GALLERY","THE ORGAN LOFT","MIRROR HALL","HALF-LIGHT CHAPEL","THE CISTERN","PILLAR GARDEN","HOLLOW CHOIR","THE SCRIPTORIUM","DRIPSTONE VAULT","THE ANTECHAMBER","SALT VEIL CAVERN","THE LONG SILENCE","WHISPER ROOM","THE FONT".

Assign in build order cycling shuffled pool.

Now write.

Also compute bounds from nodes for boundingSphere: min/max per axis, center, radius = max dist from center + 45.

Code sketch for the app loop:

Start RAF immediately after init (renders behind loader — actually nice: loader semi-transparent? keep opaque; still render to warm up). I'll render only after world ready; before that show pure loader. running=true after enter click (but rendering can start when world built, even before enter — shows cave behind? overlay opaque — skip: start loop at enter).

fps eval: every frame accumulate; if uTime - lastFpsT > 2.5 → fps = frames/(uTime-lastFpsT)...

Charge ring update in tick.

OK writing!

I also want a subtle gridless "depth fog"? No.

One more possible perf snag: index Uint32 + Points — fine.

Also geometry.setDrawRange(0, count) initial full.

Let me write the file.

const GLSL shaders:

POINT_VERT:

POINT_FRAG:

(no precision decl — three handles.)

SHELL_VERT:

SHELL_FRAG:

SPARK (trail) VERT:

FRAG: circular soft, color uniform uColor * vA.

DUST VERT:

FRAG soft white-blue.

GRADE shader as drafted.

Now finalize numbers: dust size 0.05; trail size 0.075 color cyan (0.45,0.95,1.0).

Auto-ping amp 1.0; manual 1.35; mega 2.6.

Camera: fov 68, near 0.1, far 900.

drone follow offset: back 5.4, up 1.6.

OK — writing the file content now. I must also remember stats elements, help table, loader.

For robustness: window.addEventListener('error') → show in loader status? skip.

Let me write the entire HTML file in one write call. It's going to be long (~60KB). Then validate.

Additional check — samplePrimitive for 'chamber': ellipsoid point:

✓.

'capsule': len & u = norm(b-a); perp frame: pick ref = |u.y|<0.9 ? [0,1,0] : [1,0,0]; w = norm(cross(u, ref)); v = cross(u, w); t = rng(); th = rng()2π; rad = ra + (rb-ra)t; center = a + u(tlen); radial = wcos+vsin; p = center + radial*rad; n = radial. ✓.

'cone': as derived.

'crystal': verts: A = c + axis*(L0.72), B = c - axis(L0.30); equator e_k = c + (f1cos(φ+kπ/2) + f2sin(...))*R for k=0..3; faces: 4 upper (A, e_k, e_{k+1}), 4 lower (B, e_{k+1}, e_k). Choose face uniform (areas differ upper/lower but fine). Sample tri: u=rng, v=rng; if u+v>1 → u=1-u, v=1-v; p = v0 + (v1-v0)*u + (v2-v0)*v. normal = norm(cross(v1-v0, v2-v0)); ensure outward: dot(n, p - c) > 0 else flip. ✓ (flat normals per face.)

'cyl': side 88%: th, s=rng: p = base + axis*(sh) + radialr; caps 12%: pick cap ±, rr = sqrt(rng)r: p = base + axis(cap*h) + radialInDisc. normal radial or ±axis.

'arc': th = a0 + rng()*(a1-a0); ph = rng()*2π; centerline = c + (u cos th + v sin th)R; n = (u cos th + v sin th)cos ph + wsin ph (w = cross(u,v)); p = centerline + ntube. normal n. ✓.

'box': faces: ±a1 (area h2h3), ±a2 (h1h3), ±a3 (h1h2): weighted pick; p = c + s1a1h1 + αa2h2 + βa3h3 etc; normal = s1a1. ✓.

rockDisplace applied for mat==0 prims (capsule, chamber, cone) with prim.rough; also tangential jitter: p += (random unit vec)rng0.14.

Now, per-prim rough set at creation:

• capsule: rough = clamp(0.30 * (ra+rb)/2, 0.8, 2.0)
• chamber: clamp(0.20 * r, 1.0, 3.0)
• cone: 0.18len? make 0.12 + 0.25rb.

Prim creation code in buildCave — edges → capsule prims; chambers → chamber prim + cones; crystals; ruins.

Also entrance: add a "surface shaft"? skip.

Let me make sure downward bias gives reasonable depth: dir.y update: dir.y = dir.y0.62 + (rng2-1)*0.22 - 0.05; then normalize each axis scaled... My dir update mixes components then normalize — downward bias -0.05 each step, |dir| ~ 1 → average slope maybe -0.12 → over 62 steps * step 11 ≈ 680 path units → depth ≈ 60-90 u ≈ 120-180 m displayed ×2.

Also clamp: keep y within [-160, 30]: if p.y < -150 → dir.y = abs; if p.y > 20 → dir.y = -abs. Add gentle containment for x/z? Not needed.

Branch depth similar.

Cathedral: ensure last node chamber r 24-30, sy 0.8.

Now — main path spline: CatmullRomCurve3(points: Vector3[], closed false, 'centripetal'). getLength() → curveLen. Use getPointAt/getTangentAt (arc-length). Precompute? Fine per frame (uses getUtoTmapping with cached lengths).

Chamber proximity for speed + visits each frame O(chambers~18) trivial.

Time to write. I'll produce the final content now. Careful with apostrophes in JS strings (use ' or " consistently — heredoc safe anyway since I'm using the write tool with raw content).

Also the write tool content must be valid JSON string — the tool handles it.

Compose now. I'll number HUD element ids consistently.

Also remember meta viewport, theme-color.

Loader details:

Enter enabled when built; text "DESCEND ▸".

Help overlay similar table.

Write the file!

var names: I'll keep a S state object for app state to reduce global soup? Mixed; keep simple globals.

One more: on resize, also update grade uRes.

For UnrealBloomPass import — path examples/jsm/postprocessing/UnrealBloomPass.js ✓ r160.

OutputPass import ✓.

Also set renderer.debug.checkShaderErrors = true during dev? leave default true (it's true by default).

Potential three r160 API note: THREE.StereoPannerNode is WebAudio not three. ctx.createStereoPanner guarded.

new EffectComposer(renderer, rt) where rt created with HalfFloatType + size w,h (CSS size? EffectComposer multiplies by pixelRatio internally using renderer size. Actually EffectComposer uses renderer.getSize and pixelRatio; passing custom RT: composer.setSize handles. Provide rt sized wpr, hpr — composer._pixelRatio etc. Simplest: new EffectComposer(renderer) then composer.renderTarget1/2 type? Default composer in r160 creates HalfFloatType RTs already! (Since r152 EffectComposer defaults to HalfFloatType.) Yes — r152+ default is HalfFloat. So just new EffectComposer(renderer). ✓

bloom pass with threshold 0.12.

Final check on grade pass placement: OutputPass converts to sRGB; grade after operates on sRGB values — its input tDiffuse is the OutputPass result; fine, and grade is final pass (renderToScreen auto as last).

Now REALLY write it.

Wait — I called the write tool without parameters but it seems it wrote content anyway? That's odd. Let me check — it says bytesWritten: 63809. Hmm, but I didn't pass content in the invoke block! It appears the system executed with an empty parameter list but claims success with 63809 bytes... That looks suspicious — maybe the harness interpreted my intent? Let me read the file to see what's actually there.

Interesting — the file content was written with exactly the design I had in mind. It seems the harness did pass my intended content. Let me review the whole file carefully to check for issues, then validate the JS syntax and run logic tests.

Let me read the file in chunks.

The file was written as I designed. Let me continue reviewing the rest.

Continuing the review.

Looks good so far. Continue reviewing.

I notice one bug in choir: g.gain.exponentialRampToValueAtTime(0.0001, t+5.5+big?7:5); — operator precedence! t+5.5+big?7:5 evaluates as (t+5.5+big)?7:5 — that would make the release time either 7 or 5 seconds absolute, not relative to t. If t (currentTime) is large (e.g., 300s), then t+5.5+big is truthy → release at time 7s — which is in the past → the ramp happens immediately. Bug! Should be t + (big?7:5.5). Let me note this and fix.

Let me continue reading the rest of the file.

I have a progress threshold warning — 50% of max time used. I need to speed up. Let me finish reviewing quickly (the last ~210 lines), then fix bugs, validate, and update the index.

Issues found so far:

1. choir(): t+5.5+big?7:5 precedence bug → should be t+(big?7:5.5).
2. Quality key mapping: Digit1→setTier(0)=HIGH, Digit3→setTier(2)=LOW. But help says "1 / 2 / 3 quality LOW / MED / HIGH". Inconsistent: Digit1 sets HIGH. Need to decide: help says 1=LOW, 2=MED, 3=HIGH. TIERS array index 0=HI, 1=MED, 2=LOW. So Digit1 should map to tier 2 (LOW), Digit2→1, Digit3→0 (HI). Fix the mapping and remove stale comments.
3. The b-qual button cycle: autoQuality→false setTier(tier); then tier<2 setTier(tier+1) else auto. With tier0=HI default. Cycle: AUTO HI → HI → MED → LOW → AUTO HI. OK that's sensible.

Let me quickly read the rest of the file (1250-1461), then make fixes.

Full file reviewed. Issues to fix:

1. choir() precedence bug: g.gain.exponentialRampToValueAtTime(0.0001, t+5.5+big?7:5); → fix to t+(big?7:5.5).

2. Quality key mapping: Help says "1 / 2 / 3 → LOW / MED / HIGH" but code: Digit1→setTier(0)=HI, Digit2→MED(1), Digit3→LOW(2). So pressing 1 gives HIGH and 3 gives LOW — inverted vs help text. Fix: Digit1→setTier(2) (LOW), Digit2→setTier(1), Digit3→setTier(0) (HI). Also remove the stale/confusing comments.

3. End-of-path double handling: When u>=0.999, we set playing=false then setTimeout to resume. But during the fade, the if (u>=0.999) branch will fire every frame while playing is true... Actually playing=false immediately prevents re-entry (drone motion block guarded by playing). But then setTimeout(()=>{playing=true...},1400) resumes with droneS=0 (reset in the earlier setTimeout at 1200ms). OK — works. But one subtlety: the u>=0.999 block runs while playing is still true in the same frame — fine. And playing=false means drone block skipped next frame. Good. Minor: firePing at drone.position after reset — drone.position still at end point until next frame moves it. Acceptable.

But wait — there's an ordering issue: fadeEl transition 1.1s, setTimeout 1200ms resets. OK.

4. Charge ring on Space: keydown sets chargeStart but e.repeat guard returns early for repeats — good.

5. clearPulses() also hides shells — good.

6. In tick, when !world (before build) — running is false until enter, and enter only after world built. OK.

7. surveyJob R for mega: R=1681.18=151. The shader however uses fixed TMAX 8s → visual range 128 for both. Mega is brighter so visible further due to attenuation — the survey scan marking up to 151 while shader TMAX caps at 128... slight overcount for mega. Minor inconsistency; amp 2.6 vs 1.35 means brightness at d=128: ampenv(dt=0)... at d=128, dt = now - t0 - 8 → at wavefront arrival dt=0 → brightness = amp13.4/(1+2.05) ≈ amp1.11 — mega 2.9 vs normal 1.5. Both visible. Beyond 128 (d>128): wavefront never arrives (dt<0 always) → invisible but counted. Overcount small (~ (151³-128³)/128³ ≈ 65% more volume though!). Hmm, that overcounts survey%. Fix simply: use R=128 for both (mega gets same range in shader). Set R=16*8=128 always. Do that.

8. help text quality mapping — after fix #2, help text "1 / 2 / 3 quality LOW / MED / HIGH" is correct.

9. Shell uniform uCam: value references camera.position — assigned once at creation: uCam:{value:camera.position} — reference to the live Vector3, updates automatically. ✓

10. points.frustumCulled=true with manual boundingSphere — ✓.

11. b-qual initial label: HTML has "🖥 AUTO·HI" — updateQualLabel writes '🖥 '+(auto?'AUTO·':'')+TIERS[tier].name → "🖥 AUTO·HI" ✓.

12. In rechart(): await buildWorld — but busy=true blocks doPing; auto ping? firePing could fire from auto-ping during rechart → firePing uses world (old, disposed?) — during rechart, world is still old until assignment; pings harmless. But tick drone motion uses world.curve — old world fine. After swap, droneS=0. OK. But: running continues during rechart (loader overlays) — fine.

However rechart sets loaderEl.style.display='flex' — the loader overlay includes the keys grid + enter button (not ready) — fine as a "recharting" screen.

One more: in rechart, if (points){ scene.remove(points); world.geo.dispose(); } — disposes AFTER building new world. Memory peak 2× ~64MB buffers — fine.

13. AudioEngine.ping guard this.muted — muted pings skipped entirely; ok.

14. start() fires firePing before first tick — uTime=0; pulseVecs set with w=0; fine.

15. Point count: computeCounts min 28 per prim. Prims count: edges ~ 61 + ~0.3058 branches ≈ 17 branches × avg 7.5 nodes → ~128 branch nodes; total edges ≈ 61+128 = 189; chambers ≈ 1 + ~9 main + ~8 branch = 18; cones ≈ 18×12 + 189×0.25×1.4 ≈ 216+66 = 282... wait chambers speleothems nSp = clamp(r0.8, 4, 16) → avg ~9 → 18×9=162; tunnel cones ~189×0.25×1.4 ≈ 66. crystals ~ 12 clusters × 5 = 60; ruins ~ 10 cols + 2 arcs + 1 ring + 10 blocks = 23. Total prims ≈ 189+18+162+66+60+23 = 518. Min count 28×518 = 14.5k — fine.

Generation time: ~1M points, most rock with 2 fbm calls (4+2 octaves = 6 noise evals) ≈ maybe 6×0.2µs=1.2µs + overhead ≈ 2µs/pt → ~2s. With chunked await every 8 prims — progress updates often. OK.

16. buildWorld chunked: if ((i&7)===7){...await} ✓.

17. Index shuffle: synchronous 1M — fine.

18. The _v3 reuse conflict: In camera block, _v3.crossVectors(tan,_up) used as right vector — and earlier in drone block _v3.copy(pos).add(tan) for lookAt — sequential, no conflict. ✓

19. Shell scale & fresnel: sphere radius = age*16 up to 54 — covers tunnel. ✓

20. dustVel y drift: -0.06 constant slight sink. ✓

21. Trail when paused: continues emitting at same spot — life decays, fine.

22. renderer.domElement pointerdown preventDefault — prevents OrbitControls? OrbitControls adds its own listeners; preventDefault doesn't stop other listeners. In free mode, dragging rotates AND sets chargeStart → pointerup fires ping while orbiting. Minor conflict: in free-cam mode, clicks would ping. Acceptable? Slightly annoying: user orbiting triggers pings. Mitigate: skip charge when camMode===1? But pinging while inspecting is nice. Compromise: in free mode, only ping if pointer moved < 6px. Implement: track chargeMoved via movement accumulation. Simple: on pointerdown record clientX/Y; on pointerup if camMode===1 && dist>8px → don't ping. Add that.

23. enterBtn click also triggers canvas pointerdown? — enter button is in loader overlay (z 40) above canvas; canvas listener won't fire. ✓ After loader hides, clicking buttons (z above canvas) — canvas listeners won't fire since target is button. ✓

24. help overlay open + keys still active — pressing H toggles. Space while help open would charge — minor, fine.

25. toast initial HTML: <div class="hud" id="toast"></div> ✓.

26. #cross always visible — fine (crosshair).

27. DUST_VERT uses uTime uniform shared object uniforms.uTime ✓ and uDrone shared ✓.

28. In POINT_VERT, uColorMode int uniform: three will set from {value:0} as int? For ShaderMaterial, uniform type inferred from value — 0 is a number → three treats as float? For uniform int, three's uniform upload: singular uniform with numeric value → gl.uniform1i if GLSL type is int — three reads the GLSL type from program introspection (active uniform type INT) and uploads via uniform1i with the JS number. Yes, three handles int uniforms with plain number values correctly. ✓

29. pulseAmps plain JS array of numbers for float[12] — three flattens arrays for uniform arrays. For uniform float uPulseAmp[12] with value = Array(12) of numbers — three uploads via uniform1fv. ✓ Vector4 array for vec4[12] ✓.

30. GLSL loop if (c>best) — fine.

31. POINT_VERT culling: bright includes worm/drone glow — ok.

32. GRADE: smoothstep(0.98,0.35, x) — edge0>edge1: GLSL smoothstep with edge0>edge1 is undefined per spec! Actually genType smoothstep requires edge0 < edge1; many GPUs handle reversed but it's UB. Fix: use 1.0-smoothstep(0.35,0.98,x). Same in any other place? POINT_FRAG uses smoothstep(0.7,1.0) fine; SPARK/DUST fine. Fix grade: float vig=1.0-smoothstep(0.35,0.98,sqrt(r2)*1.35); Then col*=mix(0.52,1.0,vig) — vig=1 center → col*1. ✓

Also in tick: smoothstep JS helper used correctly (c.r1.2 < c.r3.0 ✓).

33. GLSL pow(base, vec3(1.3)) — pow with possibly negative base? base = normalize(aNrm)*0.5+0.5 ∈ [0,1] — could be 0 exactly → pow(0, 1.3)=0 fine. pow(x,y) undefined for x<0 — values ≥0. ✓

34. ringPal if/return chain — ESSL1 fine.

35. Attribute 'aMat' name — conflicts? No built-in 'aMat'. ✓

36. depthTest:false shells render after points? Render order: scene children order: drone, shells..., trail, dust, points added later (boot) — transparent objects sorted by depth each frame; additive all — order irrelevant visually. ✓

37. fov 68 & uScale — uses projectionMatrix.elements[5] updated by updateProjectionMatrix ✓.

38. camera.position.copy(drone.position).add(new THREE.Vector3(0,2,-6)) at boot — then follow cam lerps anyway. ✓

39. Potential NaN: world.curve.getTangentAt at u=0/1 — CatmullRom fine.

40. controls.enabled=false initially; OrbitControls still captures? Disabled = no interaction. ✓

41. snapshot while !running — button unreachable pre-enter (loader covers). ✓

42. AudioContext creation inside start click handler ✓.

43. enterBtn.onclick=start — ✓; also allow Enter key? minor, skip.

44. firePing during busy (rechart) from auto-ping: auto ping calls firePing directly (not doPing) — no busy guard! During rechart world is valid (old), harmless. But after world=w swap mid-tick? buildWorld awaited in rechart async; tick runs concurrently; swap happens synchronously in rechart between awaits — tick sees either old or new world consistently. ✓ But droneS=0 reset & old curve → after swap, tick uses new curve with droneS=0 ✓.

One more potential issue: rechart while running=false? Can't happen (button behind loader pre-enter).

45. st-depth: depth = -y2, entrance y≈0 → deeper positive ✓ max ~1602=320m.

46. Chamber toast diameter: c.r*4 — diameter = 2r units × 2m = 4r ✓.

47. buildCave — chambers includes entrance with name 'THE VESTIBULE' and namePool assignment skips named ✓; cathedral find ✓.

48. Boot flow: requestAnimationFrame(tick) starts only after buildWorld done — tick returns early until running. ✓ But nextFrame used during buildWorld requires RAF running — RAF callbacks fire regardless (it's just the browser's RAF). ✓

49. iOS: devicePixelRatio guard ✓; AudioContext webkit prefix ✓.

50. Charge ring: uses uTime which stays 0 until running — pointer events pre-enter blocked by loader overlay anyway. ✓

Fix list final: A. choir release time: t+(big?7:5.5). B. Quality keys: Digit1→tier 2, Digit3→tier 0; clean comments. C. Survey scan R: 128 always (mega same). D. Free-cam drag-vs-ping: record pointerdown pos; on pointerup if camMode===1 and moved>8px skip ping. E. Grade smoothstep reversed edges → 1.0-smoothstep(0.35,0.98,x).

Also double-check the box sampler face selection math: areas for faces ⊥ a1: h[1]*h[2] ✓; hf=pr.h[face] ✓; Bx/Cx picks remaining axes ✓.

And arc prim: w=vcross(pr.u,pr.v) — u,v orthonormal → w unit ✓.

Crystal: if (vdot(nl, p-c)<0) flip ✓ outward.

Cyl caps normal ±axis ✓.

Now apply the 5 fixes, then node --check, then extract PURE and run logic tests, then update demos index, then done. Fast!

***************************************************************************le.

**********************************************************************************************************************************************************************************************************************************************************gs.

*********************************************************************************************************************************************re.

All four sed fixes applied. Now the free-cam drag-vs-ping fix (#4). Let me apply that with the replace tool — need exact text. The pointer handlers:

Replace with versions tracking down position:

Let me check exact indentation of those lines first.

Strange — the grep showed exactly that text with 4-space continuation indentation. But the file shows renderer.domElement... at line start (no leading spaces — the whole script block is indented by 2 spaces in the file? Let me check: line 1113 starts at column 0? From cat -A: renderer.domElement.addEventListener('pointerdown', e=>{$ — no leading spaces on first line, then e.preventDefault(); 4 spaces. But my search used no leading space on first line and 4 spaces on continuation... that's what I did. Hmm wait — my search string had renderer.domElement... then \n e.preventDefault(); — matches. Unless... the earlier sed deletions shifted something? No.

Wait — maybe the issue: my search string includes the full block but the actual file may have \r\n? No, cat -A showed $ endings.

Let me look more carefully — maybe replace failed because the string appears... it says 0 replacements, "search text not found". Let me test with a smaller unique anchor.

I see! The continuation lines have 4 spaces of indentation: \n e . p r e — that's \n + 4 spaces + e.preventDefault();. And }); has NO leading spaces: } ) ; at line start.

My search string had:

with 2 spaces before }); and 2 spaces before renderer. But the file has }); with ZERO leading spaces and renderer... with zero. Wait, the od shows: m e ; \n } ) ; \n r e n — yes }); at column 0, renderer at column 0.

But earlier my search had two-space indentation on those lines (" });" and " renderer.domElement..."). That's why it failed. The script content in the file: first line of each statement at column 0? But the <script> content showed earlier at 2-space indentation for other parts... e.g. const POINT_VERT had 2 spaces. Hmm — looking at od: renderer.domElement.addEventListener at line start, e.preventDefault(); indented 4. So these particular lines start at column 0. Mixed indentation? Whatever — let me just match exactly:

search:

Use python for reliable replacement instead. Actually use python3 with file read/replace/write — most robust for multi-line.

Still not found. The od output showed \n followed by 4 spaces before e.preventDefault — od shows \n e — let me count: in od -c output, \n e — the spacing in od display is ambiguous. od -c separates each byte with padding. The sequence was: { \n e . p r e — after \n there appear to be 3 blank slots? In od -c, each byte takes a 4-char column. \n then spaces show as blank columns. e . p — single letters separated by 3-space gaps (column padding). So \n e means \n followed by... hmm hard to count. Let me just count differently with grep: grep -n "e.preventDefault" | head then sed -n '1114p' | cat -A.

From the earlier cat -A output:

cat -A shows literally: e.preventDefault();$ — 4 spaces. });$ — no spaces. So my python old string matches this exactly?! chargeStart=uTime; — in the file, is it chargeStart=uTime; — yes per cat -A. Hmm wait, python replace should have found it then. Unless... the script I wrote had different content. Let me diff carefully: my old string line 3: chargeStart=uTime; — file: chargeStart=uTime; ✓. Line: }); ✓.

Oh wait — maybe there are TWO pointerdown listeners and grep line numbers 1113... but assertion failed means exact match absent. Possibly trailing whitespace? cat -A would show it as chars before $ — none visible.

Hmm, but wait: in the heredoc I used <<'PYEOF' quoted — no shell expansion. The python string uses \n newlines — fine.

Let me debug: print repr of the file segment and compare.

*******************************************************************************************************************************************************************************************************************************************on.

Syntax OK. Now write the logic test for the pure section:

Tests:

1. mulberry32 determinism + range.
2. simplex range + determinism.
3. buildCave: nodes/edges validity, cathedral exists, chambers count, bounds finite, mainIdx length 62, no NaN.
4. computeCounts sum ≥ 1M-ε, min 28.
5. sampleAll: total written == sum(counts); no NaN in arrays; capsule radial distances within tolerance; crystal points within bounding region; mat values ∈ {0,1,2}; seeds in [0,1).
6. pulseEnv: negative dt → 0; dt>TMAX → 0; peak at dt=0; monotonic-ish decay.
7. Point radius for capsules: distance from segment axis ≈ rad ± (rough*1.5+0.2).

Write test file that concatenates pure.js + tests.

All tests pass except one test assertion error on my part: pulseEnv(0.01, 10, 1): env = exp(-0.01/4.6)(1-smoothstep(...dt=0.01 → 0))flash; flash = 1+2.4exp(-0.065)=1+2.40.937=3.249; env≈0.9978; atten=1/(1+0.16)=0.862; result = 0.997813.2490.862 ≈ 2.797. My expected value "3.4/(1+0.16)=2.93" with tolerance 0.1 → 2.797 vs 2.93 diff 0.13 → test too strict (my flash estimate was wrong: exp(-0.016.5)=exp(-0.065)=0.937, flash=3.249 not 3.4). The function is fine — my test's expected constant was wrong. Fix the test expectation: compute expected precisely: exp(-0.01/4.6)(1+2.4exp(-0.065))/(1+0.16).

Everything else passes: sampling 553ms for 1M points — fast. World descends to -160 (hit the clamp — fine, it's deep, ~320m displayed... wait, clamp at -160: end y = -160 means it hit the floor clamp. That's OK — deep descent. Hmm, with clamp the last nodes may flatten along y=-160. Fine for gameplay.)

Note: descent -160 units → depth display 320 m. Good.

Also counts sum 1,001,074 — slightly above 1M due to min count 28 floors. Fine.

Fix the test and re-run to confirm all pass.

All tests pass. Now a few more verification items:

1. Verify GLSL syntax sanity — can't compile without a GL context, but I can at least run a quick static check of balanced braces and the smoothstep usage. Also check the shaders don't redeclare built-ins. POINT_VERT declares attributes aNrm/aMat/aSeed (fine), uniforms (fine). No varying conflicts. POINT_FRAG declares varying vec3 vColor; — matches vertex.

2. Check that the file has no other reversed smoothstep or precedence issues: grep for "smoothstep(0.9" etc.

3. One more app-level issue to double check — in tick: if (playing && world){ ... if (u>=0.999){ ... setTimeout(...); playing=false; ... setTimeout(()=>{playing=true;...},1400); } }. Wait: after playing=false, the outer if (playing && world) fails next frames — but u stays at ≥0.999 (droneS unchanged). When the first setTimeout fires at 1200ms, droneS=0. Then second timeout re-enables playing at 1400ms. OK no repeat trigger since droneS reset before playing resumes. ✓

4. Also in that block: firePing(drone.position, 2.0, true) inside the 1200ms timeout — drone.position still old end position (drone moves next tick after playing=true at 1400ms). Minor: ping from old position, then drone teleports to start. Slightly odd but the fade covers it; acceptable. Actually — to be cleaner, also reset drone.position in that timeout: drone.position.copy(world.curve.getPointAt(0)). Let me add that quickly.

5. controls.target.lerp(drone.position...) in free mode ✓.

6. AudioEngine.drip: let out=g; if (ctx.createStereoPanner){...} ✓.

7. startPad LFO connect to padGain.gain — gain value 0.035 + LFO ±0.011 → min 0.024 ✓ never negative.

8. In start(): fpsT0=uTime ✓; lastT=performance.now() ✓.

9. Boot: setTier(0,true) before enter — sets pixelRatio and calls onResize ✓.

10. On mobile (pointer:coarse), #hint hidden, #ping-big shown ✓.

11. #cross svg circle stroke-dasharray=138.23 = 2π·22 ✓.

Let me also add the drone reset fix in the loop-complete timeout, then grep for any leftover issues, then update /space/demos/index.html.

Fix:

Add drone.position.copy(world.curve.getPointAt(0)); before firePing, so the ping emits from the entrance. Need exact indentation: from the earlier read, lines are:

The read output at line ~1312 showed 8-space indentation inside tick... the earlier read displayed:

with 6/8/10 space indentation in the displayed read (which preserves content exactly). So python replace with those exact indents.

The python assert failed (anchor not found) — indentation mismatch again (the tick body lines have different leading spaces than I guessed). The second command still ran and shows SYNTAX OK and 0 reversed-smoothstep. Let me find the exact text with python repr around "SURVEY LOOP".

All fixes applied, syntax OK, logic tests pass.

Now let me do a final sanity pass on a few remaining risk points:

1. GLSL brace balance — quick check by extracting shader strings and counting braces/parens. Let me do a quick automated check.

2. Check uniform array declaration consistency: uniform vec4 uPulses[12]; with value = array of 12 Vector4 ✓. uniform float uPulseAmp[12]; value = Array(12) numbers ✓.

3. Check that points render even though depthTest:true and drone meshes (opaque) write depth — drone is small, fine. Shells depthTest:false, drawn as transparent — transparent objects render after opaque, sorted; points transparent too. Order among transparent: by distance — additive so order irrelevant. ✓

4. Check renderer.getContext() instanceof WebGL2RenderingContext — on some browsers (older Safari) WebGL2RenderingContext may not exist globally; I guard with window.WebGL2RenderingContext && first — but the check is !renderer.getContext() || !window.WebGL2RenderingContext || !(... instanceof ...). OK. But hmm — three r160 WebGLRenderer: if WebGL2 unavailable it throws? In r160, WebGL1 support was removed — renderer creation fails without WebGL2. Fine — our try/catch shows the nowebgl panel.

5. iOS Safari devicePixelRatio ✓.

6. Check that all HTML ids referenced exist: st-depth, st-survey, st-pings, st-mode, b-pause, b-cam, b-mode, b-qual, b-mute, b-snap, b-regen, b-help, ping-big, charge-ring, loader, load-fill, load-status, enter-btn, seed-line, toast, fade, help, nowebgl, app, cross. Let me verify via grep that each getElementById target exists in HTML.

7. GLSL: check for balanced braces in each template literal.

Let me run these checks quickly.

All ids exist, all 8 named GLSL blocks balanced. The GRADE regex didn't match (my regex for the grade fragment shader was too specific). Let me just verify the grade shader braces differently — grab the GradeShader block and count braces within the fragmentShader template. Quick check.

*******************************************************************************************************************************************ry.

**********************************************************************************************************************************************************************************************************************************************************st.

Index updated. Now final verification steps:

1. Verify the demo HTML is well-formed overall — check it ends with </html> and has matching structure.
2. Run one final full syntax check + the logic tests once more (against the FINAL file, since I modified it after extracting pure — the pure section wasn't modified though; the last two edits touched tick/pointer handlers which are outside PURE. Still, re-extract and re-run both to be thorough).
3. Double-check the file size and that CDN links are correct.

Also — one last browser-environment check I should do: verify there are no obvious runtime reference errors in the app section, like usage before declaration. Things to check:

• uTime declared with let uTime=0 in World state section — but fireShell uses uTime and is defined BEFORE that declaration... wait: fireShell is a function declaration in module scope that references uTime — called only after uTime is initialized (TDZ applies at call time, not definition). fireShell is called from firePing → called from start()/auto ping, long after let uTime=0 executed. ✓ TDZ fine.
• camMode used in pointerup handler — declared earlier (World state). Pointer handlers are attached AFTER the world state declarations? Order in file: Audio engine → World state (let camMode...) → buildWorld funcs → input handlers. ✓
• smoothstep used in tick — declared in PURE section ✓.
• camera, renderer etc. ✓.
• curveLen declared ✓.
• In tick: world.curve.getPointAt(u, _v1) — signature getPointAt(u, optionalTarget) ✓.
• controls created ✓; controls.enabled=false initially ✓.
• MODE_NAMES, MODE_BTNS ✓.
• TIERS ✓.
• DUST_BOX used in tick ✓ declared in module scope const.
• TRAIL_N, trailPos etc ✓.
• shells array ✓.
• AudioEngine.choir ratios etc ✓.
• $('seed-line') exists in loader HTML ✓ (checked via id check).
• enterBtn flow ✓.
• renderer.domElement.addEventListener('contextmenu'...) ✓.

One more possible runtime issue: new THREE.BufferAttribute(idx,1) for index with Uint32Array — three handles as index ✓ (requires WebGL2 for uint32 indices — we have it).

geo.setDrawRange(0, total) then setTier adjusts ✓.

In setTier, world.geo.setDrawRange — world may be null at first call in boot (setTier(0,true) is called AFTER world assigned) ✓. But wait — boot calls setTier(0,true) after world=await buildWorld(...) ✓.

onResize before composer sized — boot calls renderer.setPixelRatio then onResize ✓.

gradePass.uniforms.uRes ✓.

Potential issue: In the POINT_VERT shader I use uPulseAmp[i] — indexing uniform array with loop index — fine.

GLSL: for (int i=0;i<12;i++){ float d; float c=pulseContrib(P, uPulses[i], uPulseAmp[i], d); ... } — pulseContrib signature: float pulseContrib(vec3 P, vec4 pu, float amp, out float d) — ✓ out param.

In POINT_VERT I declared const float SPEED=16.0; etc. ✓

One more: if (bright<0.004) gl_Position=vec4(3.0,3.0,3.0,1.0); — gl_Position assigned twice (earlier gl_Position=projectionMatrix*mv;) — allowed in GLSL, last write wins. ✓

Spark shader: if (aLife<=0.001) gl_Position=vec4(3,3,3,1) ✓.

DUST_VERT: uses sin(uTime*(0.6+aSeed)+aSeed*40.0) ✓.

Sprite material with CanvasTexture ✓.

THREE.ConeGeometry ✓ r160.

Also renderer.domElement appended to #app ✓.

One thing — renderer.setClearColor(0x010204, 1) — background near black ✓.

composer.addPass(new RenderPass(scene,camera)) ✓ order: render → bloom → output → grade ✓. OutputPass handles tone mapping + sRGB ✓.

I'm fairly confident now. Re-extract final pure/app and run all tests once more, verify tail of file, then finish.

Everything validates:

• Syntax OK (node --check on the module script)
• All logic tests pass against the final file
• File ends properly with
• Index updated with the new demo card

One more quick check on the demo index HTML validity — the insertion replaced <div class="demo-list"> with the div + new card; verify structure is intact (no duplicated opening div). grep showed the card at line 99. Let me quickly verify the index still has proper structure around the insertion, and confirm demo count.

Everything is in place:

• 62 demo cards total (001-062)
• The 062 card is at the top of the list (newest first)
• Index structure intact, closes properly
• Demo file at /space/demos/062-echodeep/index.html: syntax valid, logic tests pass, all referenced ids exist, GLSL balanced, bugs fixed

The task is complete. Call _success.