Wavefunction ψ Demo Creation and Deployment

******************************************************************************************************************************************************************************te.

There are 35 demos. The task is "Wake up and do as you please" — so I should create demo 036. Let me look at the existing index.html structure and maybe a recent demo to match style.

Let me think about what demo to create. Recent demos:

• 034-magnetosphere
• 035-cloud-chamber (particle physics)

Ideas for 036 — something impressive, not yet covered:

• Fireworks show (029-pyrosymphony might be similar — probably fire/audio?)
• Lissajous / harmonograph 3D
• Reaction-diffusion (030-morphogenesis probably covers)
• Solar system orbital mechanics (005-gravity-sandbox covers)
• Water caustics / ocean shader (009-azure-odyssey, 022-cloudsea might cover water)
• Ray-marched fractal (003-mandelbulb covers)
• Terrain erosion simulation
• Voxel engine / voxel landscape with destructible terrain
• Double pendulum chaos visualizer
• Rope/cloth simulation (033-gossamer might be cloth/web?)
• Lightning storm / thunderhead
• Kaleidoscope shader
• Maze generation + first-person exploration
• Procedural city with traffic
• Ant colony simulation (016-skitter might be insects)
• DNA helix / molecular dynamics
• Smoke / volumetric fire
• Boids already done (020-murmuration)
• Wave interference (032-wavefront)
• Galton board (031)
• Cymatics (027)
• Ferrofluid (025)
• Koi pond (024)
• Frost (023)
• Aurora (015)

Something not yet covered: "Thunderhead" — a volumetric storm cloud with lightning bolts, rain, procedural lightning branching, thunder audio. That's visually impressive. Or a "kaleidoscope" — maybe too simple. Or "procedural city night drive" — a synthwave endless driver with procedural city, neon, rain? 014-neon-rain might already be rain/city themed. Let me check a couple of existing demos' descriptions in the index to avoid overlap.

Let me grep the index.html for titles/descriptions.

I have 35 demos. I need to create demo 036. Let me brainstorm what hasn't been covered:

Covered topics:

1. Spinning cube
2. Nebula galaxy (particles)
3. Mandelbulb (raymarched fractal)
4. Fluid dynamics (Navier-Stokes)
5. Gravity sandbox (N-body)
6. Event horizon (black hole lensing)
7. Sonic reactor (audio visualizer)
8. Void runner (synthwave game)
9. Azure odyssey (sailing ocean)
10. Abyssal bloom (deep sea boids)
11. Physarum garden (slime mold)
12. Powder alchemy (falling sand)
13. Clockwork nebula (orrery/gears)
14. Neon rain (cyberpunk city storm)
15. Aurora borealis
16. Skitter (creature locomotion)
17. Coral resonance (cymatics lagoon GPGPU sand)
18. Threshold (portals)
19. Attractorium (strange attractors)
20. Murmuration (boids starlings)
21. Terraforge (erosion/landscape)
22. Cloudsea (volumetric clouds)
23. Frostline (frost simulation)
24. Koi pond
25. Ferrofluid
26. Synchrony (fireflies)
27. Cymatics (Chladni plate)
28. Teslasphere (plasma globe)
29. Pyrosymphony (fireworks)
30. Morphogenesis (Gray-Scott)
31. Galton cascade (probability)
32. Wavefront (ripple tank)
33. Gossamer (spiderweb)
34. Magnetosphere
35. Cloud chamber

Not covered ideas:

• Double pendulum / chaos pendulum gallery — physics, trace chaos with trails. Could be cool but maybe small-scale.
• Harmonograph / spirograph 3D — maybe too simple.
• Maze / labyrinth procedural with solver — meh.
• Cloth simulation flags — partially covered by spiderweb cloth.
• Voronoi/Delaunay visualization — maybe.
• L-systems procedural plants / fractal trees growing — nice! A procedural botanical garden with L-systems, growing trees, flowers, day cycle. Could be beautiful.
• Smoke ring / vortex simulation — fluid already covered.
• Knots — torus knot morphing — meh.
• Raytraced spheres scene (path tracing) — a progressive path tracer demo! Three.js has examples. Could do a GLSL path tracer with spheres, reflections, refraction, depth of field, accumulating samples. That's impressive and not covered.
• Dithering / retro effects — meh.
• Game of Life 3D — cellular automata 3D (Life variants) in a glowing cube. Could be nice but not sure "wow".
• Ant colony — similar to physarum.
• Traffic simulation — meh.
• Mandelbox / kaleidoscopic IFS fractal raymarching — fractal covered by mandelbulb.
• Terrain raymarching — terrain covered.
• Pendulum wave machine — pendulum wave is a classic beautiful demo! Many pendulums swinging at slightly different frequencies create mesmerizing patterns. Combine with double pendulums? A "Pendulum Wave & Chaos Garden"? Hmm.
• Orbitals — hydrogen atom electron cloud visualization — quantum! Ray-marched hydrogen orbital probability clouds (|ψ|²) with live quantum numbers (n, l, m), transitions with photon emission. That's educational, beautiful, glowy, unique. Raymarching a 3D density field. Very cool — "Quantum Garden"? Actually hydrogen orbitals visualization is a great pick: volumetric raymarching of |ψ_nlm|² computed from real associated Laguerre/Legendre polynomials on the CPU into a 3D texture, then raymarched with emission. Quantum transitions between states with energy-difference photon colors (Balmer series etc.), slicing plane, auto-tour.
• Procedural planet generator — space-ish covered.
• Ballistics / artillery game — game, meh.
• Turing patterns done.
• Voxel demolition — physics fun: voxel structures + collapse. Maybe.
• Marble run / Rube Goldberg machine — procedural marble machine with physics! Fun and wow. Complex though.
• DNA / protein folding — meh.
• Neural network visualizer — maybe.
• Kaleidoscope — simple.
• Fire simulation — fireworks covered.
• Ocean waves FFT (Tessendorf) — sailing covered ocean.
• Cave / crystal cavern flythrough — procedural cave with ray marching...
• Space elevator / satellite constellation — meh.
• Rings of Saturn particle sim — pretty.
• Tidal forces / Roche limit simulation — interesting! A moon torn apart by tidal forces forming rings. N-body-ish though (005).
• Hydrogen orbitals — I like this a lot. Educational + gorgeous + not covered. Volumetric rendering is a strong wow.

Another strong candidate: progressive path tracer ("Light Studio") — spheres with glass/metal/diffuse, accumulating photons, depth of field. Impressive but slower wow factor on weaker GPUs.

Or pendulum wave: 15-24 glowing pendulums in a row, released together, forming snakes/rows/double helix patterns, with tracers. Classic mesmerizing. But maybe too simple for "advanced" bar? Could dress it up a lot: mirror polished floor, bloom, trail ribbons, audio chimes at bottom, double-pendulum chaos mode... Hmm.

I'll go with Hydrogen Atom / Quantum Orbitals — "Orbital" — 036-orbital or "036-hydrogen-orbitals". Let me name it something evocative: "036-atomcore"? "036-eigenstate"? "036-psi" — Let me call it "036-orbital-lab" or "036-hydrogen". Simple: 036-orbital.

Plan for "Orbital" demo:

• Full-screen Three.js scene with ray-marched volumetric rendering of hydrogen atom probability density |ψ_nlm(r,θ,φ)|².
• Compute 3D density grid on CPU (e.g., 96³ or 128³) using real hydrogen wavefunctions: ψ_nlm = R_nl(r)·Y_l^m(θ,φ). Real orbitals use real spherical harmonics combinations (px, py, pz etc. for m combos). Actually simpler: use complex |Y_l^m|² which depends only on θ (azimuthally symmetric) — that's the true |ψ|². Using complex Y_l^m gives |ψ|² = |R_nl|²|Y_l^m|² which is azimuthally symmetric — doughnuts and cones. Real combinations (like px, dxz) give directional lobes which are prettier/more recognizable (textbook orbitals). Textbook "hydrogen orbitals" images use real spherical harmonics for m≠0 pairs. I can support both: "complex (stationary)" states with azimuthal symmetry, and "real (directional)" orbitals. Real orbitals: for m>0: sqrt(2)(-1)^m Re(Y_l^m) etc. Since I compute on CPU, I can compute complex spherical harmonics and take real/imaginary parts.

Implementation details:

• Wavefunction: ψ = N · (2r/na0)^l · L_{n-l-1}^{2l+1}(2r/na0) · e^{-r/na0} · Y_l^m(θ,φ).
• Compute associated Laguerre polynomials via recurrence. Compute associated Legendre / spherical harmonics via recurrence.
• Build 3D grid: for each voxel compute ψ (complex), then density = |ψ|² (for complex m states) or ψ_real² (for real combinations).
• Normalize, maybe apply sqrt or power scaling for display.
• Upload as 3D texture (single channel float or half float). THREE.Data3DTexture supports this.
• Raymarch in fragment shader inside a bounding box: accumulate emission with transfer function: density → color (phase coloring maybe: color by sign of ψ for real orbitals — positive cyan, negative magenta! That's the classic chemistry coloring. Also option for monochrome gold).
• Additive-ish accumulation with Beer-like absorption maybe. Use "maximum intensity projection + emission" hybrid. Keep it glowy for bloom.
• Slice plane toggle: clip the volume with a draggable/rotatable plane to see internal structure.
• UI: quantum numbers n, l, m sliders with validity constraints (0≤l<n, -l≤m≤l), real vs complex toggle, energy level display E = -13.6/n² eV, transition mode: pick state A and B, animate "transition" with a flash and photon emission colored by wavelength (Balmer etc.) — a photon particle flies out; show spectral line on a mini spectrum strip HUD. Transition can also interpolate between two 3D textures (crossfade) — nice effect!
• Extras: nucleus with proton glow, electron "cloud" sparkle particles sampled from the density distribution (Monte Carlo sample points from |ψ|² and render as points!) — that's a killer feature: stochastic electron cloud, points appearing/disappearing at sampled positions — the classic "dot cloud" quantum visualization. I can sample e.g. 20k points on CPU per state (rejection sampling) and update a Points buffer. That's very illustrative and gorgeous with bloom. Points can slowly twinkle.
• Background: starfield? More of a lab look: dark gradient, floating dust, maybe a pedestal "quantum display" hologram look — the atom rendered as a hologram inside a glass dome / sci-fi projector. Simpler: free-floating glowing cloud in dark space with subtle grid floor and bloom.
• Audio: generative pad that shifts with energy level; transition "ping" with frequency mapped to photon energy; subtle Geiger-like shimmer for the dot cloud? Keep it tasteful.
• Post: UnrealBloom + custom grade pass (vignette, grain, chromatic aberration) consistent with previous demos.
• Presets: e.g., 1s (ground), 2p, 3d (n=3,l=2,m=0 — "doughnut ring"?), 4f complex, hybrid real 3d_{z²}, "rydberg" n=6. Auto-tour cycling.
• Controls: orbit camera, sliders for n/l/m, buttons: Transition mode, slice toggle, dot cloud density, color modes (phase/density/spectral), quality, snapshot, sound.

Let me check the structure/style of a recent demo (035) to match conventions (import map, bloom version, UI CSS). Let me read the head of 035's index.html.

Let me check the JS part for import map and postprocessing conventions.

************************************************************************************************it.

I have a good understanding of the conventions. Now let me design demo 036: Hydrogen Orbital Observatory — a quantum electron-cloud visualizer.

Name: 036-orbital — title "ORBITAL" or "EIGENSTATE"? Let me go with "036-orbital-lab"? Simpler: "036-orbitals"? I'll use 036-eigenstate... Hmm. The collection has poetic names (Gossamer, Threshold, Attractorium, Murmuration, Synchrony). Let me name it "036-wavefunction" — that's evocative and precise. Or "036-psi". I'll go with 036-wavefunction.

Concept: "A quantum observatory — the hydrogen atom's electron cloud made visible."

Key features:

1. CPU-computed hydrogen wavefunctions ψ_nlm(r,θ,φ) using:
   • Radial: R_nl(r) ∝ (2r/na)^l · L_{n-l-1}^{2l+1}(2r/na) · exp(-r/na)
   • Angular: spherical harmonics Y_l^m(θ,φ) via associated Legendre P_l^m(cosθ)·e^{imφ}
   • Modes: "complex" (stationary states, |ψ|² azimuthally symmetric) and "real" (directional orbitals like px, dz2 — textbook shapes): for m>0 use √2·Re/Im combinations.
2. 3D density texture (128³ or 112³ half-float or byte) → ray-marched volumetric rendering in a bounding box, with:
   • Color modes: "Phase" (sign of ψ: cyan/magenta — classic chemistry), "Density" (single-hue gold/cyan), "Spectral" (tinted by state's characteristic transition wavelength toward ground... simpler: hue by energy).
   • Emission-based accumulation with Beer absorption; adaptive steps based on quality.
3. Monte Carlo electron dot-cloud: rejection-sample ~30k positions from |ψ|²; render as twinkling GPU points that slowly re-scatter (classic quantum "measurement" dots). Points fade in at sampled positions and out; continuous re-sampling stream — like individual electron detections building up the probability cloud. This is the killer educational visual.
4. Transitions: pick new state → photon emitted/absorbed with ΔE → wavelength nm readout, a glowing photon streak flies out/in, flash; spectral line added to a spectrum strip HUD (canvas) showing accumulated lines in the visible range (with actual colors for 380-750nm), e.g., Balmer series red 656nm for 3→2.
   • Crossfade between 3D textures (mix in shader) for smooth morph; recompute in worker? CPU compute of 128³ with polynomial evaluation might take ~1-2s in JS — need chunked/async compute to avoid blocking. Options: compute at 96³ (~885k voxels, each with Laguerre+Legendre eval — fine, maybe 100-300ms), do it in chunks with setTimeout to keep UI responsive, show a subtle "collapsing wavefunction" progress indicator.
   • Alternatively compute in a Web Worker — but single-file demo, worker via Blob URL works. Simpler: chunked main-thread compute with progress (per-slice).
5. Slice plane: toggleable clipping plane with slice view (shows 2D cross-section density as glowing plane) — drag to move? Keep simple: Y-slice slider + toggle. Maybe skip full slice-plane dragging; offer "clip mode: none / X / Y / Z" with offset slider.
6. Bohr radius rings / radial scale: faint grid sphere or radial shells at expectation radius? Maybe subtle. Optional toggle "grid cage".
7. Nucleus: tiny glowing proton at center with subtle pulse.
8. Audio: generative pad whose pitch/harmony shifts with energy level; transition "ping" with frequency mapped to photon wavelength (visible → audible mapping); shimmer for dot sampling. Mute button, consistent.
9. UI:
   • Quantum number sliders n (1-7), l (0..n-1), m (-l..l) with auto-clamping; display orbital name (1s, 2p, 3d, 4f, 5g...) with spectroscopic letters s,p,d,f,g,h,i.
   • Buttons: Absorb/emit transitions auto via changing state (with flash + photon when Δn≠0... actually Δl=±1 selection rule — note in log when a transition is "forbidden" and show it happening via two-step? That's a nice educational touch: if |Δl|≠1, log "electric-dipole forbidden — higher-order transition (suppressed)" and use dimmer flash. Keep it simple but log it.)
   • Color mode seg: Phase / Density / Spectral.
   • Toggles: dot cloud on/off & count, slice mode, auto-tour, spin.
   • Presets: Ground 1s, "Clover" 3d (n=3 l=2 m=±1 real?), "Doughnut" 3d m=0 complex? Real d-orbitals: dz² (m=0) has doughnut; (n=4,l=3,m=0) fz³; "Chaos Rydberg" n=7 l=6 m=0? Actually high-l states are pretty circular doughnuts. Presets: 1s Ground, 2p Cloverleaf? 2p m=±1 real = px/py dumbbell; m=0 = pz. "Ring" = (n=3,l=2,|m|=2) complex → doughnut torus. "Clover" = real 3d_xy or dx2-y2 (l=2, m=2 real combos) → four-leaf clover! "F-orchid" = real 4f (l=3, m=2) → 8-lobed flower. "Rydberg" = n=6 l=5 complex m=0 → intricate concentric shells. Great preset names: Ground State, Dumbbell (2p), Cloverleaf (3d), Doughnut (3d ring), Orchid (4f), Rydberg Shells (n=6/7).
10. Post: UnrealBloom + grade pass (same as 035).
11. Stats readouts: E = -13.6/n² eV, ⟨r⟩ expectation radius in a₀, degeneracy n², nodes count (radial n-l-1, angular l).
12. Extras: PNG snapshot, pause, help overlay, keyboard shortcuts, quality autoscaling, touch support, localStorage-safe (wrap in try).

Spectral line HUD: a canvas strip at bottom showing lines accumulated (n→m transitions) with colors. Toggle/clear.

Technical details for wavefunction computation:

Radial wavefunction: R_nl(r) = sqrt((2/(na₀))³ · (n-l-1)!/(2n·(n+l)!)) · e^{-ρ/2} · ρ^l · L_{n-l-1}^{2l+1}(ρ), ρ = 2r/(na₀).

Associated Laguerre L_n^k(x): computed via recurrence: L_0^k = 1; L_1^k = 1 + k - x; n·L_n^k = (2n - 1 + k - x)·L_{n-1}^k - (n - 1 + k)·L_{n-2}^k.

Spherical harmonics: Y_l^m(θ,φ) = (-1)^m · sqrt((2l+1)/(4π) · (l-m)!/(l+m)!) · P_l^m(cosθ) · e^{imφ}.

Associated Legendre P_l^m(x) via recurrence: P_m^m = (-1)^m · (2m-1)!! · (1-x²)^{m/2}; P_{m+1}^m = x(2m+1) P_m^m; (l-m)P_l^m = x(2l-1)P_{l-1}^m - (l+m-1)P_{l-2}^m.

Normalization: I don't need exact normalization; I can normalize the final grid to max density = 1. But I DO need relative phase/sign structure correct, which recurrences give (sign conventions consistent). For sampling and density, overall scale cancels. Good — avoids factorial overflow for n=7 (factorials up to 13! fine in double anyway, but skipping normalization entirely is safer).

For real orbitals:

• m=0: ψ = R·Y_l^0 (real).
• m>0: ψ_c = R·Y_l^|m| complex; real combos: ψ_re = √2·(-1)^m·Re(ψ_c), ψ_im = √2·(-1)^m·Im(ψ_c). I'll offer for real mode: for m≠0 two buttons? Simplify: real mode with m≥0 uses Re-combination; provide "phase rotate" slider (azimuthal rotation of the orbital) — rotating a real orbital by angle γ: Re(Y·e^{iγ}). Actually simplest: in real mode use combination cos(mφ + γ) for azimuthal part: ψ ∝ R · P_l^m(cosθ) · cos(mφ + γ) with γ slider (0 or π/2 for the other combo). That's simple and correct up to normalization. For m=0, cos(0+γ)=const.

Grid extent: radius range must scale with n² (orbital size ~ n²·a₀·(1+...)). Expectation ⟨r⟩ = a₀/2·(3n² - l(l+1)). Set R_max = k·a₀·n² with k ~ 2.2 (or clamp based on n, l: R_max = a₀·(2.2n²) works; for n=7, ~108 a₀). Use world units: 1 unit = some a₀ scale; let the volume scale with the state, or keep world size fixed and vary a₀... Simplest: fix the bounding box in world space (e.g., half-size 10 units), and compute the wavefunction with an effective a₀ chosen so the cloud fits: R_max_world = 10 → a₀_effective = 10/(2.2n²). Fine — scale readout can say "box = X a₀".

Compute cost: 112³ = 1.4M voxels. Per voxel: spherical harmonics evaluation. To speed: separate computation! ψ = R(r)·P(θ)·Φ(φ) — fully separable! Compute three 1D arrays:

• For each voxel, r = sqrt(x²+y²+z²) — need per voxel anyway. Hmm separable into arrays indexed by i (x), j (y), k (z)? r isn't separable additively. But we can compute per-voxel with cached radial samples: precompute R(r) on a fine 1D radial table (e.g., 2048 entries) and P(cosθ) table too (cosθ = z/r → table on [-1,1], 1024 entries), and φ = atan2(y,x) → compute cos(mφ+γ) per voxel via trig recurrence: from cos φ, sin φ (x/r_xy, y/r_xy) compute cos(mφ), sin(mφ) via Chebyshev. Per voxel cost then: sqrt, divisions, two table lookups, a few mults. ~1.4M voxels → fast (<150ms).

Density grid stored as Float32Array; then convert to Uint8 (0-255) for Data3DTexture (UnsignedByteType, RedFormat? For 3D texture in Three r170: THREE.Data3DTexture(data, w, h, d); texture.format = THREE.RedFormat; type = UnsignedByteType; works in WebGL2). Or half float for better gradients — byte with sqrt/gamma scaling is fine (256 levels, dithered by grain). I'll apply perceptual scaling: d' = pow(d, 0.35) before quantization to preserve faint outer structure.

Two textures (current & next) + crossfade uniform uMix for transitions. Compute next async in slices, then upload & animate mix 0→1.

Dot cloud sampling: rejection sampling from density: keep maxDensity; sample random point in box, accept if rand < d/maxD (use the perceptual or linear density? linear). For n=7, acceptance is lowish but fine. Generate in chunks (e.g., 2k per frame until 40k). Render as THREE.Points with custom shader: each dot has birth time, lifetime (e.g., 4-9s), fade in/out, slight jitter; recycle dead dots by resampling. Color: mode-dependent (phase sign → cyan/magenta; else gold). Points count adaptive by quality tier.

Photon streak: on transition with ΔE≠0, spawn a photon: a small glowing sphere + trail (line) flying from center outward in a random direction, colored by wavelength (nmToRGB). Also screen flash tinted. Emission (higher n→lower n) flies outward; absorption flies inward. Photon wavelength: λ = 1240 eV·nm / ΔE. ΔE = 13.6·(1/n₂² - 1/n₁²). E.g., 3→2: ΔE=1.89eV → 656nm red (H-alpha!). 2→1: 10.2eV → 121.6nm UV (invisible → show as violet-ish glow, log "Lyman-α 121.6nm ultraviolet"). Nice educational readouts.

Spectrum strip: canvas 2D, wavelength 380-780nm visible band as faint gradient background, lines drawn at λ positions with their colors, accumulating (toggle persist). Also UV/IR lines marked at edges with labels.

Audio: WebAudio generative: drone pad (two detuned oscillators + slow filter LFO) whose base frequency rises with excitation level (n). Transition ping: sine with frequency mapped 380-780nm → e.g., 220-880Hz log scale; UV → higher shimmer. Dot sampling subtle shimmer noise? Keep minimal: pad + pings + soft click on UI. Sound toggle button. Audio context resume on first gesture.

Camera: OrbitControls, auto-rotate optional.

Scene extras:

• bounding wireframe box (subtle)
• radial grid rings on floor plane? A circular "lab" pedestal hologram ring — nice: glowing rings at a₀ multiples on the XZ plane (toggle "scale rings" showing a₀, 4a₀, 9a₀... n²·a₀).
• dust motes particles ambient (like previous demos).
• background gradient sphere + vignette.

Performance: quality tiers: High (128 steps, 40k dots, 112³ grid), Medium (96 steps, 24k dots, 96³), Low (64 steps, 12k dots, 80³). Auto-degrade on low FPS.

Keyboard shortcuts: H help, M mute, P pause, A auto-orbit, S snapshot, D dots toggle, C color mode, T tour, Space = random transition ("excite/decay"?). Let me define: Space = quantum jump to random allowed... Actually "Space" fires a random transition (photon!). R = decay cascade: step down toward ground with emitted photons chain — "cascade to ground state" — cool! Auto cascade: repeatedly pick random lower state with Δl=±1 until n=1, emitting photons each step — beautiful and educational (de-excitation cascade).

That cascade feature is a wow: press C "Cascade" → sequence of quantum jumps with photon streaks and spectral lines accumulating.

UI layout (match 035 style): header top-left, top-right round buttons, panel bottom-left with sections: QUANTUM STATE (n, l, m sliders + orbital name big), MODE seg (Real/Complex), COLOR seg (Phase/Density/Spectral), buttons row (Cascade, Random Jump), VIEW (dots toggle, rings, slice...), presets seg grid, bottom row: quality + stats. Bottom-center hint. Help overlay. Log feed top-left under header.

Slice plane: implement as u_clipMode (0 off, 1 X, 2 Y, 3 Z) + u_clipOffset; in raymarcher discard samples beyond plane... Actually for a "reveal the inside" effect, clip one side of the volume (half-space). Simple: if clipMode>0, samples with coord[axis] > offset are discarded. Add slider for offset. Nice to see inner shells of high-n states.

Now, photon streak rendering: use a small pool (8) of photons: each has position, velocity dir, life; rendered as additive sprite (Points or Sprite) + short fading trail (THREE.Line with vertex colors fading). Simple: THREE.Points with per-particle size/color/alpha updated per frame, plus a stretched line from previous positions (store short history per photon, draw with LineSegments updated). Keep it simple: glowing head sprite + trail via per-frame updated line strip (history length ~14).

Nucleus: small icosahedron with emissive material + pulsing point light; maybe "proton" label? Keep subtle glow sprite.

Spectral color function nmToRGB (approx): standard approximation (380-780). Implement in JS.

Orbital naming: letters s p d f g h i for l=0..6. Name like "3d" + real-orientation suffix? For real combos: m=0 → e.g. "dz²"-ish (proper names: pz, dz², fz³); m≠0 real cos combo → e.g. "dxz-like (m=±1 cos)" — getting precise names right for all combos is complex. I'll name: ${n}${letter} + (real&&m!=0 ? (γ==0? ' ·cos' : ' ·sin') : m!=0 ? m=${m} : ''). Keep readout of (n, l, m) numeric which is unambiguous.

Also degeneracy & nodes readout: radial nodes = n-l-1, angular nodes = l; E = -13.6/n² eV; ⟨r⟩ = (a₀/2)(3n²-l(l+1)).

Selection rule logging: when changing state via UI, if |Δl|==1 && Δm∈{0,±1} → "allowed (electric dipole)"; else "dipole-forbidden (metastable — shown anyway)". Cascade picks only allowed transitions (Δl=±1, random Δm in range, and requires l≥1 of target etc.).

Cascade algorithm: from current (n,l,m), if n==1 → done. Pick random n' in [1, n-1] weighted toward smaller Δn? And l' = l±1 clamped to [0, n'-1], if l=0 → l'=1 (requires n'≥2), if l=n-1... l' = l-1. m' = m + Δ where Δ∈{-1,0,1} clamped to [-l', l']. Delay ~900ms between jumps. Emit photon each jump with correct λ. At end log "ground state reached".

Random jump: pick random allowed state with bias to nearby n? Simple: random n in [1,7], l in [0,n-1], m in [-l,l], ensure different from current; apply.

Auto-tour (T): cycles through preset list every ~8s with transitions.

Wavefunction crossfade: uMix uniform mixing texA/texB in raymarch; dots: during transition, resample progressively — sample from interpolated density? Simpler: sample from target state's density (precomputed CPU grid) — fine, visually OK: old dots fade out, new dots appear at new-state positions.

Edge cases: WebGL2 required for Data3DTexture — three r170 uses WebGL2 by default. OK.

Volumetric raymarch shader plan:

• Box mesh (side: BackSide), shader computes ray from camera through fragment in object space (box local coords [-1,1]). Entry/exit: since rendering BackSide, fragment position is exit point; entry = camera position in object space (if inside) or ray-box intersection. Standard approach: compute t0, t1 via slab method in shader with uCamPosOS; march fixed N steps between max(t0,0) and t1.
• Sample density: mix(texture(texA,p).r, texture(texB,p).r, uMix) — note Data3DTexture RedFormat single channel .r.
• Transfer: color by mode:
  • Phase: need sign info! Density texture alone loses sign. Store sign in second channel? Use RG texture: R = |ψ| scaled, G = sign. Or two textures? Simpler: store in one texture R = density (|ψ|² processed), G = sign flag (0/1). Data3DTexture with RGFormat + UnsignedByteType. For complex states, sign meaningless → use arg(ψ)? No — complex mode color by |ψ| only (single hue) or by m-rotation phase e^{imφ} coloring hue by phase angle? Beautiful: complex states colored by phase of ψ (arg) — shows the rotating phase structure of m≠0 states! Actually that's a gorgeous and physically meaningful coloring: hue = arg(ψ). For real orbitals hue = sign (two colors). So: store R = processed density, G = phase encoded 0..1 (for real: sign 0/0.5/1 mapping; complex: (arg+π)/2π). Shader: phase mode → real: two-color; complex: rainbow-ish hue wheel by G. Density mode: single hue (gold). Spectral mode: color = color of strongest emission line from this state to lower states? Simplify: color by energy n (map n to palette: red low → violet high) — "Energy" mode. Let me name color modes: "Phase", "Gold", "Energy".
• Accumulate: emission-absorption: col += (1-a)·densityColor·d; a += (1-a)·d·densityScale. With ~100-160 steps, front-to-back, early exit when a>0.98.
• Add subtle rim/fresnel glow on box? Not needed.
• Lighting: fake shading via gradient of density? Skip (emission look is fine) or cheap 1-tap toward center for depth cue. Maybe compute simple gradient via 3 extra taps for pseudo-normal → soft shading adds depth perception. Optional at High quality. Let me include a cheap gradient shading (6 taps → expensive; use 3-tap forward differences along axes... 3 extra samples × 160 steps = heavy). Alternative: shade by local density itself + distance-based attenuation. I'll add optional gradient with 3 taps at half rate... Hmm keep performance: emission-only, but modulate emission by a "shell glow" using d² term. Fine.

Also add MIP mode? Skip.

Point dots shader: attributes: position (vec3), aBirth, aLife, aSeed, aSign. Uniform uTime. Alpha = smoothstep in/out, size attenuated, twinkle by seed. Additive blending, depthWrite false, depthTest true (occluded by nothing much — box is transparent; OK).

Grid/rings: circles on XZ plane at r = n²·a₀ multiples... in world units with the current a₀ scale: ring at ⟨r⟩(n,l) maybe. Toggle "Bohr ring": single ring at expectation radius + label? Simple glowing ring on floor plane + vertical projection? Keep: toggle rings at a₀·(3n²-l(l+1))/2 on XZ plane (flat circle line) — faint.

Also add axis triad? Skip.

Dust motes: ~300 points drifting, subtle (consistent with other demos).

Now — panel "STATS": show E eV, ⟨r⟩ a₀, nodes, fps. Quality button cycles High/Med/Low/Auto.

Snapshot: composer.render then toDataURL — need preserveDrawingBuffer or render on demand before capture. Use approach: render once then canvas.toBlob. Previous demos did it — copy approach: render frame then renderer.domElement.toDataURL right after composer.render() within same task. I'll implement snapshot() { composer.render(); const url = renderer.domElement.toDataURL('image/png'); ... download link }.

Hint text at bottom center: "drag to orbit · scroll to zoom · space = quantum jump".

Help overlay: describe physics & controls.

Log feed: reuse style.

Status line: "state 3d · n=3 l=2 m=0 · E=-1.51 eV".

Let me now think about real-orbital azimuthal: ψ_real ∝ P_l^m(cosθ)·cos(mφ+γ) — but proper real orbitals include (-1)^m √2 factors; irrelevant due to normalization. For complex: ψ ∝ P_l^{|m|}(cosθ)·e^{i m φ} — use m (signed). For m negative in complex mode, e^{imφ} phase rotates opposite — fine.

For the G texture (phase): real mode: sign(ψ): G = ψ>0 ? 1 : 0. Complex: arg(ψ) = mφ (plus sign flips of P which multiply phase by π). Compute per voxel: phase = m·φ + (P<0 ? π : 0) + (R<0? π:0) → encode (phase mod 2π)/2π. Since R sign matters for phase too — include. In shader, hue = G; color = hsv2rgb(hue). For real mode, G=1 or 0 → cyan (hue .52) vs magenta (hue .85)? Better distinct: positive → cyan #46e0ff, negative → #ff5fb0 (pink). In shader for real: mix(pink, cyan, step(0.5,G)).

Data layout: RG bytes: R = pow(density/max, 0.32)*255, G as above *255.

For performance of grid compute, per voxel ops:

• precompute per-slice (z): z², then per row (y): r_xy² = x²+y²... Let me structure: for iz: z; for iy: y; compute zr = sqrt(y²+z²)... hmm φ = atan2(y,x) in plane. Approach per voxel: x,y,z → r = sqrt(x²+y²+z²); if r<eps → handle. cosθ = z/r; P = table lookup P(cosθ) via linear interp (table 2048 over [-1,1]). ρ = 2r/(n a₀); R = radial table lookup over [0, Rmax] (table 4096). φ: cosφ = x/sqrt(x²+y²), sinφ = y/sqrt(x²+y²); compute cos(mφ), sin(mφ) via De Moivre recurrence (m≤6: cheap). real: ψ = R·P·cos(mφ+γ) — need cos(mφ+γ) = cosmφ cosγ - sinmφ sinγ. complex: re = R·P·cosmφ, im = R·P·sinmφ; density = re²+im²; phase = atan2(im,re) — or cheap: phase = mφ + π·(sign flip of P·R). Use fast: signP = P<0.

Radial table: R(ρ) needs exp and Laguerre eval at 4096 points — trivial. Legendre table: P_l^m(cosθ) at 2048 points — trivial. Great, per-voxel cost ~20 flops → 1.4M voxels → ~30M flops → <100ms. Chunk by slices with setTimeout(0) every slice to keep UI alive; show "recomputing…" progress in status.

Wait — one subtlety: box half-size = 10 world units maps to R_max physical = extent. Choose extent = max(2.4·n², something·...) Let me use extent_a0 = Math.max(12, 2.15nn) a₀? For n=1: extent 12 a₀ (1s radius peak at 1 a₀, tail to ~6; 12 gives airy margin). For n=7: 2.15·49 ≈ 105 a₀. Also ensure l-based: ⟨r⟩ max = (3n²)/2 ≈ 1.5n²; tails extend ~2× that for high n. 2.15n² fine, min 12.

Actually better: extent = max(10, 1.9nn + 2.5) a₀? For n=7 → 95.6. Tails beyond contribute negligibly after exp decay. OK: extent = max(10, 2.0nn) a₀.

Hmm but for fixed n, all l states share extent — fine.

Also dot cloud uses same box; dots outside |p|>1 in normalized box? Samples come from grid coords so inside by construction.

World mapping: normalized [-1,1]³ box scaled by uScale = 10 world units → mesh Box(2,2,2) scaled 10. Dots positions in normalized coords × 10.

Photon colors nmToRGB — implement standard piecewise approx.

Transition flash: fullscreen quad overlay div with CSS transition? Simple: a fixed div #flash with background = photon color, animate opacity 0.5→0 via JS. Cheap & effective.

Now audio design:

• master gain, compressor.
• Pad: 2 detuned sawtooth → lowpass (cutoff ~ 300-1200 by n) + slow LFO on filter + gain envelope; base freq: note by n (n=1 → low A 110Hz, higher n → higher). Crossfade on state change.
• Ping on transition: sine osc freq = map λ(380..780) → (660..330)? Higher energy → higher freq: f = 1400·(λ_ref/λ)... use f = 3e8/λ scaled: map 121nm-656nm log range to 220-1760Hz. Plus harmonics, exponential decay 1.2s, convolver reverb? Simple feedback delay for space. Keep light: gain env + biquad.
• Shimmer: tiny filtered noise clicks when dots sampled? Might get noisy; add subtle "quantum rain" — very quiet random band-passed ticks at rate ∝ dot sampling, only when sound on and dots on, volume 0.05. Could be nice texture. I'll add with low rate.
• Cascade: pings sequence naturally.

Write the code carefully. File will be ~1300-1500 lines. Build in /tmp then deploy to /space/demos/036-wavefunction/index.html...

Wait, name. "Wavefunction" — folder 036-wavefunction, title "WAVEFUNCTION" or "Ψ · WAVEFUNCTION". Header h1: "WAVEFUNCTION ψ". Subtitle: "HYDROGEN EIGENSTATES · QUANTUM CLOUD OBSERVATORY".

Let me also double check index.html demo card format to insert. Let me view the card markup in index.html.

I understand the format. Now let me build the demo. I'll write it in chunks to /tmp/036/index.html using cat >> operations, then validate the JS, then deploy.

Let me carefully plan the code structure:

Spectrum strip placement: bottom-right corner, above hint maybe. Position fixed right:20px bottom:20px width:min(340px, 40vw). Canvas height ~54px. Title "EMISSION SPECTRUM".

Now the JS. Let me write it methodically.

Quality tiers:

grid recompute on tier change — expensive-ish but OK.

Renderer/scene/camera standard.

Volume shader material:

Vertex: vPos = position; gl_Position standard. Box geometry side length 2 → positions in [-1,1].

Fragment:

Set material transparent, depthWrite false. Background shows through. Bloom catches bright cores.

Density scaling: grid normalized so max=1. To make faint structures visible while core not blown out, transfer uses pow already applied at CPU (d^0.32). Then uDensity ~ 6-10.

Energy color: map n 1..7 → gradient red(1s)→...→violet; uEnergyCol = nmToRGB-like from palette: use HSL hue = lerp(0.02, 0.78, (n-1)/6). Plus l? Keep by n only.

CPU field computation:

Grid compute (async chunked):

For negative m in complex mode: e^{i m φ} with m negative = conjugate of e^{i|m|φ}: cm same, sm negated. Handle sign.

Texture upload: texB.data = data... Create new Data3DTexture each time? Reuse: texB.image={data,width,height,depth}; texB.needsUpdate=true. Then animate uMix 0→1 over ~1.2s; on complete, swap A/B textures (copy reference) and reset uMix=0. Swap: set uTexA.value=texB object; simplest: keep two texture objects tex0,tex1 and ping-pong indices: uniforms.uTexA.value=tex[cur], uTexB.value=tex[next]; when done, cur=next.

Dot cloud:

Sampling: maintain cursor; each frame sample up to K new dots (e.g., 300) from current density grid (Float32Array kept + max) via rejection sampling: random voxel coordinate uniform in box, look up density via trilinear? nearest voxel is fine; accept if rand()<d/maxD... acceptance ∝ average density which for high n with small max is low but pow-perceptual? Use linear density for correctness; for n=7 acceptance maybe 1-3% → 300 attempts yields ~6 dots/frame → too slow to reach 42k. Improve: precompute an alias/sample list? Simpler: rejection sample from the perceptual grid (d^0.32) then accept — that's sampling from wrong distribution (flatter). Compromise: sample from d^γ with γ=0.5 (compromise between uniform and true) — visually fine, denser coverage. The classic dot-cloud look tolerates mild flattening. Use γ=0.5 for sampling distribution. Acceptance ~ sqrt boosts a lot. Fine. Also keep dots until life expires (4-10s), then resample into same slot — continuous shimmering measurement stream. On state change: keep dots but gradually resample: set all aLife *= 0.25 so they recycle fast.

Points draw range = quality dots count. Buffer allocated at max (42k).

Photons: pool 10; each: active, dir, pos, speed ~ 14 u/s, life, color, λ nm, absorb bool (fly inward? for absorption start far → toward center). Render: Points (one per photon) with big soft sprite + trail: LineSegments history ring buffer per photon 12 pts. Simpler: trail as THREE.Line with dynamic positions array, updated each frame (few photons OK). Flash overlay tinted by color. Audio ping. Add spectrum line at λ if 380-780 visible (draw colored vertical line), else mark "UV"/"IR" edge markers with label. Log: "3d → 2p · photon 656.3 nm (H-α, red)". Named lines: Lyman/Balmer series names — compute: if n2=1: Lyman; n2=2: Balmer; n2=3: Paschen. Greek letter by Δn: α(1),β(2),γ(3),δ(4). Nice: "Balmer-α 656.5 nm". Actual: 3→2 ΔE=13.6(1/4−1/9)=1.889eV → λ=1240/1.889=656.5nm ✓.

Selection rules: when user changes state arbitrarily via sliders, just morph (it's "preparation" not transition). Only Random/Cascade/preset jumps produce photons if Δn≠0. Hmm — but slider change of n also changes energy; physically a transition. Decide: any state change with ΔE≠0 emits/absorbs a photon + spectrum line (that's the fun!). Selection rule: if |Δl|≠1 → log "dipole-forbidden — metastable, via higher-order process" and dimmer photon; still show. Cascade uses only allowed ones.

Allowed random jump: pick n'≠, l' = l±1 within [0,n'-1] — always dipole-allowed. Random jump does that: pick random valid target with Δl=±1. Actually more fun: random jump picks random n' (1..7), then l' = clamp(l±1 random) valid for n', m' random valid. Ensures allowed.

Cascade: repeatedly: if n==1 → done; choose n' < n (weighted: n-1 most likely? or any lower). l' must be l±1 AND ≤ n'-1 AND ≥0. If l==0 → l'=1 (n'≥2 required; if n==2,l=0 → n'=2? no n'<n=2 → n'=1 → l'=1 invalid (l'<n'=1). Then 2s→1s is forbidden! Real: 2s is metastable (two-photon decay). Handle: if no allowed target for n', try other n'; if none at all (2s state), do "two-photon decay" special: log "2s metastable — two-photon decay", emit two photons each half energy (continuous spectrum actually; just log + two streaks), go to 1s.

Audio details as planned.

Nucleus: at center: small sphere r=0.12 with emissive white-gold + PointLight subtle + glow sprite. Plus faint pulsing.

Rings: on XZ plane (y=-H-0.01?) or centered plane through origin? A "Bohr radius" ring at r=⟨r⟩ in world units (⟨r⟩_world = ⟨r⟩_a0/extentH... wait mapping: p_norm∈[-1,1] spans extent a0; world = normH. So world radius of physical r_a0 = (r_a0/extent)H.) Ring at expectation radius ⟨r⟩=(3n²−l(l+1))/2 a0 → world = that/extentH. Draw as THREE.RingGeometry line loop, faint cyan, lying in XZ plane at y=0 (through the atom, like an equatorial gauge). Plus maybe 1a₀ ring tiny. Toggle.

Also add faint wireframe box edges (EdgesGeometry Box) opacity 0.12.

Background & floor: gradient sphere + radial floor glow like 035. Dust motes points drifting.

Resize handler, DPR.

FPS auto-quality: measure over 60 frames; if <45 fps and tier>low → step down; if >58 for a while and tier<high & auto → step up? Only step down to avoid oscillation; manual quality button cycles auto→high→med→low.

Keyboard: h,m,p,a,s,d(dots),c(color cycle),r(rings),space(random jump),x(cascade),t(tour),1-6 presets.

Presets list:

Tour: cycle presets every 7s.

Transition function setState(n,l,m,{photon:true, reason}):

• clamp validity; compute ΔE, selection rule; log; spawn photon with λ; flash; audio ping; spectrum line; start field recompute (async) → crossfade; dots life-shorten; update UI sliders & readouts; pad retune.

Slider input: oninput → S.n=... clamp l,m; call setState with photon:true but debounce photons? Dragging slider fires many — use 'change' event for photon? Use oninput for live value text but apply state on 'change' (release). Good UX: apply on release.

Also clicking canvas = random jump? Previous demos had click interactions. Hint says "click = quantum jump"? But click used for orbit. Distinguish: click without drag → jump. Implement pointerdown/up distance check → if <5px and not on UI → random jump. Nice.

Status line & readouts update: state 3dₓᵧ-ish... Build name: letters=['s','p','d','f','g','h','i']; name = n+letters[l]; if basis real && m≠0 suffix = γ==0?'·cos('+m+'φ)':'·sin'; if complex && m≠0 suffix = ' m=±' ... just show m=${m}. Readouts: E, ⟨r⟩, nodes (radial/angular), degeneracy n², extent a₀.

Help overlay content: explain quantum numbers, selection rules, what colors mean, controls.

Now write the actual file. I'll write it in ~8-10 chunks with cat >> heredocs. Must be careful: the JS contains backticks and ${} template literals — heredoc with quoted delimiter 'EOF' prevents shell expansion. Use cat >> file <<'CHUNK_EOF'.

Let me carefully draft the entire JS mentally with correct GLSL.

GLSL raymarch details:

dt in world units (box spans 2 units) → dt ~ 2/150=0.0133. uGain such that d=1 over dt gives e≈? dGaindt: want core nearly opaque over ~0.3 world units: e per step at d=1: g*0.0133; cumulative 22 steps for 0.3u... set uGain≈18: d=1→e=0.21/step → strong. Faint d=0.05 → 0.012/step → over 150 steps α≈0.85 — hmm too strong for faint? (1-e) compounding: total transmittance = exp(-∫d·g dt) = exp(-g·mean_d·path). For faint regions mean_d 0.03 over path 1 → exp(-0.54)=0.58 → α 0.42 visible. Good. uAbsorb maybe 1.0 (emission==absorption strength). Add slight brightness multiplier 1.2 for bloom pickup. uGain default 16 with slider? Add "glow" slider in VIEW? Panel already full; keep fixed 16, tweak later.

Note: additive alternative — many quantum cloud renders are purely additive. Emission+absorption gives better depth. Keep.

Camera object-space: transform camera world position into box local: since box mesh scaled by H=10 and maybe rotated? Keep box static (no rotation — user orbits camera). uCamPos = worldToLocal(cam.position) = camPos/H (if mesh at origin scaled 10). Simple.

Sorting/blending: box transparent, renders after opaque; dust points also transparent. Should be fine.

Dots shader:

Color computed in vertex per aPhase: same mapping as volume modes (sign two-color / hue wheel / gold / energy).

Dot positions world = p_norm * H. aPhase stores sign (0/1) or phase hue 0..1 (same encoding as texture G channel). For sampling: after computing field float arrays, sample dots from them: rejection with sqrt distribution. Keep CPU copy of latest density grid (Float32Array) + phase array (Float32Array or derive from byte grid? derive from bytes: r byte is d^0.32 — recover d^0.5 ≈ (r/255)^(0.32/0.5)? messy. Keep float arrays around: dens Float32Array N³, phas Float32Array N³ (or Int8 sign/phase-byte). 1.4M42=11MB fine. Use the perceptual byte for sampling? Sampling distribution should be ∝ density (linear). Rejection acceptance with linear d: for structured high-n states, max d concentrated at tiny core → average density very low → acceptance <1% → slow. With sqrt: acceptance ~sqrt boost. Choose exponent 0.45 for sampling. It slightly over-samples faint regions: acceptable and actually helps dot cloud visibility.

Sampling implementation:

40 tries × ~5% = ~87% success per call; else retry next frame. Each frame: replenish dead dots: up to 400 spawn attempts/frame. With 42k dots & life ~7s, need ~6000/s = 100/frame at 60fps. Fine.

Dead dot detection: age>life → respawn in place (same index). Per frame iterate a window of indices (e.g., 1500/frame round-robin) checking expiry — cheap. Also on respawn set aBirth=uTime+small stagger.

Initial fill: spread over first seconds naturally.

On state change: multiply all lives → quick recycle: set aBirth such that age/life randomized → simplest: for all i: aLife[i]=min(aLife[i], remaining?) Set aBirth[i] = uTime - aLife[i]*rand(0.75,1.0) → they die within ~25% of remaining... simpler: aLife[i] *= 0.3 (keeps same birth) → most die soon. Then respawn naturally at new distribution. But also need aPhase updated on respawn from new field.

fieldAt uses current target field (the one being faded to). OK.

Now audio code (compact):

Ping freq: visible λ 380-780 → f = lerp(880, 330, (λ-380)/400)? Higher energy (shorter λ) → higher pitch: f = 1180Math.pow(656/λ, 1)? For λ=656 → 1180? too high; map: f = 261.6 * 656/λ → H-α → 261.6 (middle C!). Cute: Balmer-α = middle C. Lyman-α 121.6 → 1411 Hz. Paschen-α 1875nm IR → 91Hz low thump. Nice mapping f = 261.6656/λ clamp 60-2400.

Pad: base osc freq by n: f=55Math.pow(1.335,n-1)? n=1 →55Hz A1, n=7→ 551.335^6≈310. Two detuned saws + lowpass; gain 0.05. Retune on state change with smooth ramp.

Spectrum canvas: draw once bg gradient (380-780), lines array persisted; line drawn as 1-2px colored with glow (shadowBlur). Labels for named lines on hover? skip hover; small legend text listing last line. UV lines: mark at left edge purple dashed; IR: right edge red dashed.

Now the "flash" div: position fixed inset 0 pointer-events none background radial-gradient with color, opacity animated via JS (set opacity 0.35 then CSS transition to 0).

Also photon pool visuals:

Simplify: single THREE.Points (10 heads, size attenuated, per-vert color/alpha) + single LineSegments geometry where each photon contributes a polyline history (12 segments × 2 verts). Update positions each frame for active photons. Manageable.

Direction: random unit vector (or along +z?). Emission: from center outward, speed 9 u/s, kill at r>34. Absorption: start at r=30 toward center with slight offset, kill at r<0.3. Trail history stores past positions each frame (shift).

Screen flash + nucleus pulse on photon.

OK — also "two-photon decay" for 2s special case in cascade only.

Tour mode: setInterval-ish in animate loop using clock; cycle presets.

Auto quality: FPS counter.

Panel "glow" slider? skip.

Clip slider: offset -1..1 (default 1.0 when enabled). When clipMode set to X/Y/Z, set slider visible. Simpler: seg buttons Off/X/Y/Z + slider "slice" always present but only active when clip on.

Hint text: "drag orbit · scroll zoom · click space = quantum jump · X = cascade".

Status initial: "superposing…" then "state prepared: 3d".

Edge: m slider range changes dynamically; rebuild slider min/max on n/l change.

Now write all code. Careful with GLSL string containing backticks? No backticks inside GLSL; JS template literals use backticks — in heredoc quoted 'EOF' no shell issue. In HTML file, <script> inside template strings? Avoid "" sequence in JS strings — my spectrum/hud uses DOM, no script strings. OK.

One more: Data3DTexture import — part of THREE core (r170 yes: THREE.Data3DTexture). Set:

WebGL2 RG8 texture — fine. In GLSL sampler3D returns vec4; .r density .g phase ✓.

texture() with sampler3D in WebGL2 GLSL (three injects #version 300 es? For ShaderMaterial, three r170 compiles as GLSL3 only if material.glslVersion=THREE.GLSL3 set; otherwise it auto-converts texture2D→texture? For WebGL2, three prepends #version 300 es only when glslVersion set. Default ShaderMaterial is GLSL1-style with compatibility defines: three defines texture2D → texture automatically in WebGL2 via #define texture2D texture when isWebGL2... Actually three does provide those defines for fragment shaders (#define texture2D texture in WebGL2). For sampler3D + texture() — if I write texture(uTexA, uvw) in GLSL1-mode shader compiled as GLSL3 by three's wrapper... Hmm. Three.js WebGL2 default: shaders get compiled with #version 300 es ALWAYS in WebGL2 renderer (r170 is WebGL2-only; WebGL1 removed). In r163+, three always uses GLSL3 for built-ins and provides compatibility defines for user ShaderMaterial: #define texture2D texture, varying→in etc. Actually in WebGL2, THREE.WebGLProgram prepends a prefix that includes #version 300 es and defines: for fragment: in/out mappings: it defines varying as in, gl_FragColor as custom out var, texture2D as texture, textureCube... Yes — three's prefixFragment in WebGL2 includes:

I recall texture2D defined; sampler3D used in examples with texture(? The webgl2_materials_texture3d example uses raw... In three example webgl2_volume_cloud (ShaderMaterial with sampler3D) the GLSL uses texture(u_data, ...)? It uses texture( u_data, ... ) with glslVersion: THREE.GLSL3? The volume example sets glslVersion: THREE.GLSL3 and writes in/out explicitly. Safest: set glslVersion: THREE.GLSL3 on my volume ShaderMaterial and write explicit in/out GLSL3 syntax:

Wait — with GLSL3, three does NOT inject out vec4 — I declare my own out. But three injects precision + uniforms for fragment? It prepends common prefix (uniforms like viewMatrix? for fragment: uniform mat4 viewMatrix; uniform vec3 cameraPosition; etc.) and I must not redeclare those. My declared precision highp sampler3D; — precision statements after three's prefix OK.

For the points ShaderMaterial also GLSL1-style is fine (texture2D not used; gl_PointSize works in both; attribute/varying keywords auto-defined). Keep points material default (no glslVersion) with attribute/varying — three's WebGL2 prefix maps those. That's what 035 did presumably. OK.

For volume material use explicit GLSL3 to be safe with sampler3D. Note: with GLSL3, in vertex shader attribute keywords are auto-... no! With glslVersion GLSL3, three does NOT define attribute→in; I must write in/out? Actually three always prepends for vertex: #define attribute in #define varying out only in non-GLSL3 path. In GLSL3 path it expects modern syntax BUT still injects attribute declarations? Three injects in vec3 position; etc.? Let me recall three r170 WebGLProgram: prefixVertex includes (when parameters.isWebGL2 && !customGlslVersion?) ... The defines attribute→in are applied when !parameters.glslVersion — i.e., legacy style gets converted. If I set glslVersion=GLSL3 I should write pure GLSL3 including declaring nothing for position — three's prefixVertex always includes:

Hmm, in GLSL3 mode prefixVertex contains in vec3 position; in vec3 normal; in vec2 uv; (three uses attribute spelling historically, and for WebGL2 the prefix used #define attribute in...). Let me check actual three r170 source behavior: In WebGLProgram.js, prefixVertex for WebGL2 includes:

I remember: versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : '#version 300 es\n' (WebGL2). And there's:

and a block:

Honestly the reliable known-good pattern from three example webgl2_materials_texture3d.html:

And three injects position attribute automatically even in GLSL3 (prefixVertex includes in vec3 position;? — the example's vertex uses position & projectionMatrix without declaring them, so yes three declares them).

So: use glslVersion: THREE.GLSL3, declare out vec3 vPos; in vertex, in vec3 vPos; out vec4 fragColor; in fragment, use texture(...), don't redeclare position/uniforms (modelViewMatrix etc. auto). Declare precision sampler3D.

For points & other ShaderMaterials (background, dust) use legacy style like 035 (works via auto-defines).

Dot texture "RGFormat" — check three r170 constant name: THREE.RGFormat exists. OK.

Also volume box must render regardless of camera inside: material side: THREE.BackSide with depthTest... If camera inside box, back faces all around — fine, ray math handles (t0=max(tt.x,0)). Keep depthWrite false, side BackSide, transparent true. Box render order after dust? dust inside box should blend; both transparent — order by distance; minor artifacts acceptable. Set box renderOrder=2, dust renderOrder=1 (dust drawn first, box accumulates over — dust visible through volume glow ✓).

Nucleus sprite additive at center renderOrder 1.

Bloom threshold 0.72 default; volume colors often < threshold — bloom picks only bright cores: good.

Snapshot: like 035 — need to check how they did it. Probably: composer.render(); renderer.domElement.toBlob. EffectComposer renders to canvas; toDataURL works if called synchronously after render in same frame (no preserveDrawingBuffer needed if same task). Implement: function snap(){ composer.render(); const a=document.createElement('a'); a.download='wavefunction.png'; a.href=renderer.domElement.toDataURL('image/png'); a.click(); }.

Audio tick shimmer: schedule tiny noise bursts via setInterval-ish in animate (throttled random). Keep rate low (Poisson λ≈3/s), gain 0.015.

Now compute readouts & naming with proper subscripts maybe: 3d plain is fine; display in status: ψ(3,2,0) “3d” · E = −1.51 eV.

Panel layout (keep scrollable): sections:

1. QUANTUM STATE: sliders n(1..7), l(0..6), m(-6..6) with clamps; value spans show numbers.
2. BASIS: seg Real | Complex ; and γ slider ("rotate") enabled when real&m≠0? Always visible, small effect — include slider "azimuth" only affects real combos... For complex states, rotating phase does nothing visible (density unchanged) — skip γ slider entirely; instead real mode m≠0 automatically uses cos combo, and a tiny "⟳ rotate" button rotates γ by π/2 (swaps cos↔sin). Simpler: skip. Auto-rotate camera gives different views anyway. SKIP γ entirely (γ=0 always) to reduce complexity.
3. COLOR: seg Phase | Gold | Energy.
4. TRANSITIONS: row buttons: "⚡ Jump" (random allowed) | "☄ Cascade" ; row: "✦ Excite" (n→n+1 keeping l if valid else l') and "▽ Decay" (n→n-1 dipole step)? Nice directed controls. 4 buttons in 2 rows. Decay = one allowed step down; Excite = absorbs photon (Δl=±1). Good physics flavor.
5. VIEW: buttons toggles: Dots (on), Rings (on), then clip seg: Slice Off/X/Y/Z + slider slice offset.
6. PRESETS: 8 seg buttons.
7. Footer row: quality btn + stats span; row: Tour btn + Clear spectrum btn.

That's a lot of panel; it's scrollable, fine.

Spectrum HUD: <div id="spectrum" class="glass"><div class="sect">EMISSION SPECTRUM</div><canvas id="specCv" width="340" height="46"></canvas></div> bottom-right.

Log entries with colored dot by photon color.

Let me now also handle the "forbidden" visual: photon spawned dimmer (alpha low) & log note "(dipole-forbidden: Δl≠1 — higher-order)".

Energy: E(n) = -13.598/n². ΔE = 13.598*(1/n_low² - 1/n_high²). λ nm = 1239.84/ΔE.

Series name: lower n = nf: 1 Lyman, 2 Balmer, 3 Paschen, 4 Brackett, 5 Pfund, 6 Humphreys; greek by n_up - n_low: 1 α, 2 β, 3 γ, 4 δ, 5 ε.

nmToRGB standard approx (380-780). For <380: deep violet #7a2bff; >780: dark red #a02000.

Alright, also the auto-tour: every 8s pick next preset; disable on manual interaction? Tour is explicit toggle — keep until toggled off; any preset/slider change turns tour off.

Initial state: start with a crowd-pleaser: n=3, l=2, m=2 real "Clover"? Or classic 1s → boring. Start "3d clover" nice. Also fire initial help overlay visible (like 035 has help shown initially — it had #help opacity 1 visible at start). I'll show help on first visit only? Simple: show help overlay at start (user closes). Consistent with 035 (visible initially). Hmm, requires click to close — fine, also enables audio gesture. Good.

Pause: stops animation loop updates (time frozen) but still render? Standard: paused → skip updates, render once. Keep simple: pause flag stops clock delta accumulation & dots/photons updates; render continues (orbit still works).

Now — write the file. I'll aim for ~1450 lines. Let me draft chunk by chunk.

Chunk 1: DOCTYPE, head, CSS (adapted, plus spectrum/flash/orbName styles). Chunk 2: body HTML (hud, panel, spectrum, help, importmap). Chunk 3-9: module JS.

Let me write CSS by adapting 035's, changing title/colors slightly (add --gold). Include #spectrum, #flash, #orbBig styles.

Panel HTML ids: slN, slL, slM (range inputs), valN, valL, valM spans; segBasis buttons data-b real/complex; segColor data-c phase/gold/energy; btnJump, btnCascade, btnExcite, btnDecay; btnDots, btnRings toggles (pbtn with .off class); segClip buttons data-k 0/1/2/3; slClip range -100..100 → /100; segPresets buttons data-i 0..7; btnQuality, stats span; btnTour, btnClearSpec.

Status/readouts ids: status, readouts, log ul id=log, spectrum canvas specCv.

Keyboard map: h help, m mute, p pause, a autorotate, s snapshot, d dots, r rings, space jump, x cascade, t tour, c color cycle, 1..8 presets.

JS structure:

1. imports, helpers, store.
2. constants: H=10 world half-size, TIERS, LETTER=['s','p','d','f','g','h','i'], PRESETS.
3. state S.
4. renderer, scene, camera, controls, composer+bloom+grade (copy 035 pattern).
5. backdrop sphere + floor glow + dust motes (compact).
6. volume box mesh + material (GLSL3).
7. Data3DTextures tex[2], texCur.
8. Field computation: radial/legendre tables, computeField async.
9. applyState visuals: crossfade manager.
10. dot cloud: geometry, material, sampler, update.
11. photons system.
12. nucleus + rings + box edges.
13. spectrum HUD canvas.
14. audio system.
15. UI wiring (sliders, segs, buttons, keyboard, pointer click).
16. transitions logic (setState, jump, cascade, excite, decay, presets, tour).
17. log, status/readouts update.
18. resize, fps/quality.
19. main loop.

Important detail — field compute & dot sampling share float arrays fieldD (Float32Array) and fieldP (Float32Array phase/sign 0..1) plus fieldMax and fieldExtent.

computeField(job): returns via callback with {bytes, dens:Float32Array, phase:Float32Array, max, extent}. To avoid double memory, fill dens/phase then convert to bytes in-place pass.

Per-voxel loop optimization: hoist per-iz/iy constants. Implementation sketch:

Wait — max tracking: better find max during voxel loop, skip separate pass (minor). Keep separate pass fine (1.4M).

radialAt with linear interp:

laguerre(n,k,x): recurrence.

legendreTable(l,m):

Condon-Shortley phase (-1)^m included via pmm sign — consistent between radial & angular (signs just flip global/lobes correctly relative). Good.

Note: For m loop complex powers: mAbs ≤ 6, inner loop up to 6 complex mults — OK.

Edge: n-l-1 = 0 → laguerre(0,k,x)=1 ✓.

Now dot sampling fieldAt:

Sampling uses sqrt-ish: accept if Math.random() < Math.pow(d*invMax,0.45). Precompute invMax.

Crossfade: uniforms uMix target 1 over 1.4s (ease). When new field ready: set texB image data & needsUpdate; uTexA.value=texA(cur); uTexB=texB; animate. On finish: curTex↔. Meanwhile fieldD/fieldP for sampling switch to new immediately.

Note Data3DTexture update: tex.image.data.set? — replace image object: tex.image = {data: bytes, width:N, height:N, depth:N}; tex.needsUpdate=true; Hmm Data3DTexture image = {data,width,height,depth} by constructor. Assigning same-size new data: can do tex.image.data.set(bytes)? If grid size constant per tier, allocate textures per tier and set data. But different tiers change N — recreate textures on tier change. I'll write makeVolumeTextures(N) returning two textures; dispose old.

Simpler robust: create fresh Data3DTexture each upload and dispose the previously-retired one. 112³×2 bytes = 2.8MB — trivial. Do that: on field ready: oldB = texB; texB = new Data3DTexture(...); uniforms.uTexB.value = texB; start fade; on fade end: uniforms.uTexA.value = texB; texA = texB; uMix=0; dispose oldA. Careful bookkeeping; implement with small manager:

Fine.

Dummy black texture 2³ to init.

Photon pool implementation:

Nucleus: Sprite with radial gradient texture (canvas) gold; scale pulsing subtly ~0.5. Plus tiny icosahedron mesh basic material.

Rings: THREE.Group; ring at ⟨r⟩ world: use THREE.LineLoop circle 128 pts, material additive faint cyan; plus smaller ring at a₀ scale = (1/extent)H? expectation radius formula ⟨r⟩=(a0/2)(3n²−l(l+1)) in a0 units (a0=1) → world r = that/extentH. Update on state change (fade in/out). Also maybe ring tilted? Keep equatorial XZ. Actually equatorial plane for orbitals with structure in XY vs Z... Rings in XZ plane (horizontal). OK.

Box edges: EdgesGeometry(Box(2,2,2)) scaled H, LineBasicMaterial 0x3a5a8a opacity 0.25 transparent. Static.

Dust motes: 260 points in 60³ region, shader drift by time (y slowly rising, wrap) — simple CPU update too costly? Use shader: position + sin offsets. Simple: PointsMaterial size 0.06 opacity 0.35 additive, CPU drift 260 pts/frame cheap. Or static + slow rotation of whole points cloud. Do: static random, rotate group slowly.

Floor glow + backdrop gradient — copy 035 (they're generic).

Audio: implement AudioSys object as planned with lazy init on first user gesture (pointerdown/keydown), mute toggle stored.

Spectrum:

Line label: last transition text under canvas via div #specLast.

Log: function addLog(html, color) — prepend li, cap 6, fade after 6s.

Readouts update fn: E=-1.51 eV · ⟨r⟩=13.1 a₀ · nodes r:0 a:2 · box ±72 a₀.

Status: ψ(3,2,2) “3d·cos2φ” — recomputing…/ready.

Orbital big name in panel? Add div #orbName in panel sect QUANTUM STATE showing e.g. "3d". Yes — nice big display.

Now transitions:

Basis changes also recompute (no photon).

emitTransition(from,to): Δn; if from.n===to.n return; emission if to.n<from.n. ΔE=13.598*|1/to.n² − 1/from.n²|; λ=1239.84/ΔE; allowed = |Δl|===1 && |Δm|<=1; spawn photon (absorb = to.n>from.n); spectrum line (strength allowed?1:0.35); flash; ping; log with series name; if !allowed log note. If !allowed && from special 2s? skip.

Cascade:

Cancel cascade on manual state change (tourOff-like): cascadeStop().

Jump (random allowed):

lps empty case: S.l=0 → lp must be 1 requires np≥2; if np===1 → lps empty → then lp=0, forbidden log. Handle: if np===1&&S.l===0 → lp=0 (forbidden 1s←?s). Fine, log handles.

Excite/Decay:

Presets:

Set basis + state. Photon emitted if n differs (fun).

Tour: every 8s next preset index.

UI wiring standard. Slider live labels: on input update valN text etc; apply on 'change'.

l/m slider min/max dynamic: after n change: slL.max=n-1; if S.l>n-1 set; slM.min=-l; max=l; rebuild.

Color seg → S.colorMode → uniform uColorMode int {phase:0,gold:1,energy:2}; energy color uniform updated by n (hue = lerp over n). uSignMode = basis==='real'?1:0.

Clip: seg sets uClipMode 0..3; slider sets uClipOff (v/100) default 100 → 1.0.

Quality button cycles ['auto','high','med','low']; on tier apply: dpr, uSteps, dot draw count, grid size → recompute current field at new grid size.

FPS auto: every 90 frames avg; if auto && fps<42 → tier down (high→med→low); recompute.

Resize: camera aspect, renderer size, composer size, bloom size.

Pointer click → jump: pointerdown record x,y,t; pointerup: if dist<6 && dt<350ms → randomJump() — but not when clicking UI (canvas only: listener on renderer.domElement) ✓. OrbitControls also uses drags — small dist clicks safe.

Now the volume shader material uniforms list finalize: uTexA,uTexB,uMix,uCamPos,uSteps(float),uGain(16),uAbsorb(1.0),uClipMode(int),uClipOff,uColorMode(int),uSignMode(float),uEnergyCol(vec3),uTime.

Also maybe uBrightness per-state to balance very peaked distributions — the pow(0.32) handles. OK.

One risk: texture() on RG8 3D texture linear filter — supported in WebGL2 ✓.

The dots' G channel: for complex phase coloring, dots aPhase from fieldP (0..1 hue) ✓; gold/energy modes ignore.

Energy color mapping: hue for n: hsl h=0.63 - (n-1)/6*0.55? n=1 → blue? Physically higher n = higher energy → toward violet. Ground deep blue?? Let me do: n=1 → #57b6ff azure (ground calm), increasing n → warmer?? Nah — map n to heat: 1=cyan, 7=red-hot? "Energy" mode: low energy = cool blue, high = hot red: h=0.58→0.0 over n=1..7. uEnergyCol = hsl(h,0.85,0.6).

Photons color = nmToRGB(λ).

Flash div: flashCol(nm) rgba gradient.

Also add subtle "measurement flash" when many dots? skip.

Spectrum clear button resets lines.

Snapshot includes HUD? No — canvas only (like others).

Check three r170 OrbitControls import path ✓.

Alright — also performance of texture upload: 2.8MB per state change fine.

One more consideration: the async compute yields with setTimeout inside while loop per slice — I wrote time-boxed 14ms chunks. During compute show status "recomputing wavefunction…" with animated ellipsis. Multiple rapid changes: cancel token.

Also initial help overlay: visible; close button; H toggles.

Let me also make sure to not leak: scheduleField debounce 120ms.

Now let me also write nmToRGB (approx):

Series naming:

OK, ready to write. Total code ~ big; let me be careful and write it fully, checking GLSL/JS syntax as I go. I'll write to /tmp/build036/index.html in chunks, then node --check the extracted module.

Let me write chunk 1 (head+css).

Chunk 2: body HTML.

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

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

Wait, there's a bug: tableAt(PT, (z/r)*0.5+0.5) — PT table is over x∈[-1,1] mapped to [0,1] via (x+1)/2 ✓. And tableAt(RT, r/RT.rmax) ✓. At r<1e-9: P at x=1 → f01=1 ✓.

Note: for mAbs>0 at rxy<1e-9 (on z-axis), cm=1, sm=0 — actually cos(mφ) undefined on axis, but P_l^m(±1)=0 for m>0, so val=0 anyway ✓.

Chunk 5: volume box + GLSL3 raymarch material + textures + crossfade manager.

Note: in uploadField, uTexA.value = volTexB (the OLD B, which was the current visible), uTexB.value = tex (new). Since initial both black it's fine.

The old.dispose() logic: old = volTexB before reassignment = currently visible texture = now assigned to uTexA — must NOT dispose it! Bug: I dispose old if old!==volTexA — but volTexA was just set to old (volTexA=volTexB before? no—order: volMat.uniforms.uTexA.value=volTexB; then volTexA=volTexB; volTexB=tex; then if(old && old!==volTexA) old.dispose() → old===volTexA → not disposed. So nothing ever gets disposed — small leak of the retired A. The retired texture is the previous volTexA which is no longer referenced: I should dispose it. Let me fix: capture retired = volTexA at top, dispose at end. I'll patch later with replace tool.

Also fade completion: when fade.t reaches 1 → set uTexA = volTexB, uMix=0? Actually mix(A,B,1)=B fully; keeping uMix=1 forever is fine and next upload sets uTexA=volTexB anyway. But uMix animates only during fade; on next upload we set uTexA=volTexB(current) and uMix=0 ✓ consistent. So no end action needed besides fade.active=false. Good — no swap needed at end. Simplify: keep.

Now chunk 6: dot cloud system.

Issues to note:

1. GLSL: uniform int uColorMode; in the dot vertex shader — with legacy GLSL1-style material (no glslVersion), three injects defines converting attribute/varying. Int uniforms are fine; setting via uniforms value int. In GLSL, comparing uColorMode==0 fine.

Wait — but in the dot vertex shader I use attribute float aBirth, aLife... — GLSL allows comma-separated attribute declarations? attribute float a, b, c; is valid GLSL ES 1.0. Yes valid.

But three's WebGL2 prefix for non-GLSL3: #define attribute in etc. Comma list with #define still works textually: in float aBirth, aLife, aSeed, aPhase; — valid GLSL3 too. ✓

2. dotMat uniform int uColorMode — three handles int uniforms by value typeof? THREE infers from GLSL declaration? Actually three's uniform upload uses the value type: for plain number it calls uniform1f. For int declared uniform with float upload → error? Three's setValueV1f vs setValueV1i: decided by GLSL type introspection (gl.getActiveUniform returns INT) — three handles it automatically via SingularUniform type. ✓ So int uniform with numeric value works.

Hmm, but I left a stray comment "wait: int uniform — set via value int" inside shader string — harmless (GLSL comment), fine.

3. In updateDots — initial dotBirth all zeros → age = simTime-0 big → respawn immediately, good for initial fill. But dotBirth[i]<0 check unused initially. OK.

4. setDrawRange every frame + full buffer needsUpdate uploads 42k×3 floats per frame (~500KB) — that's a lot of bandwidth per frame but GPUs handle it; could optimize with updateRanges. Three r170 BufferAttribute has updateRanges/addUpdateRange. To be safe performance-wise, mark needsUpdate only if any spawned or scanned... The fade animation is GPU-side (uTime), so buffer only needs upload when respawns happen. Optimize: track dirty flag when any spawn; only set needsUpdate if dirty. But scanning touches nothing unless spawning. Set dirty=spawned>0. I'll patch: only needsUpdate when spawned>0.

Also updateRange would limit upload further but needsUpdate full upload on spawn frames is acceptable (spawn frames: ~every frame since dots die continuously: 42k dots, life ~7s avg → 6000 deaths/s → 100/frame → uploads every frame ~500KB/frame → 30MB/s at 60fps. Modern GPUs fine (PCIe). OK keep simple with dirty flag.

5. dotDirty set in uploadField → should trigger scrambleDots. I'll handle in the state-change flow instead: call scrambleDots() in setState. Remove reliance on dotDirty (harmless).

6. simTime: global time accumulator (pausable) — define in main loop; used before definition — JS hoisting: let simTime declared later in file would be TDZ error if updateDots called before declaration executed. updateDots only called in animate() after everything defined — but let dotCursor=0, simTime=0; is declared here at module top-level in this chunk, before animate runs. ✓ (declared in chunk 6 — fine).

Now chunk 7: nucleus, rings, photons, spectrum.

**************************************************************************************************************************************************************************************ks.

Note: nmToRGB is used by spawnPhoton (defined before its declaration in file order, but function declarations hoist — nmToRGB is a function declaration in chunk 7, spawnPhoton also function declaration — calls happen at runtime after all defined ✓).

Chunk 8: audio system + transitions logic (setState, emitTransition, jump, cascade, excite/decay, presets, tour) + log/status/readouts.

Note: applyTier is called on init? I'll call initial setup in the final chunk. Note applyTier → scheduleField → recompute; at init I compute field once — careful not to double compute at startup.

Also stats element: update in loop with fps + dot count.

Chunk 10: main loop + init + close script/body/html.

Now apply the fixes I identified:

1. Tour bug: setState calls stopTour() → breaks tour. Fix: setState/ setBasis accept keepTour flag; applyPreset passes it; tour passes keepTour=true.

2. uploadField texture leak: dispose retired volTexA (but not the initial blackTex pair sharing? Initial: volTexA=black1, volTexB=black2. First upload: retired=volTexA(black1); uTexA=volTexB(black2); volTexA=black2... dispose black1 fine.)

3. dots needsUpdate optimization — only when spawned>0. Also note: when S.dots toggled off→on, nothing needed.

4. In updateDots: if(spawned>380) continue; — bug: should still advance cursor but skip spawn; fine as written (continue skips respawn for this i even if dead — they'll be caught next frame). OK.

5. simTime used in updateDots defined — yes chunk 6.

6. Also dotDirty variable declared but unused except assignment — harmless.

7. GLSL check: dot vertex shader uniform int uColorMode; — legacy ShaderMaterial: three converts. Comparison uColorMode==0 int literal ✓.

8. In volMat fragment: uniform sampler3D uTexA, uTexB; comma declaration of samplers — valid GLSL.

9. GLSL3 fragment out: out vec4 fragColor; ✓. Note three GLSL3 mode: does three inject its own out highp vec4 pc_fragColor;? No — only in legacy mode. With glslVersion set, three expects you to declare your own out. ✓

10. Legacy materials (gradePass, backdrop, dotMat, phHeadMat): three WebGL2 auto-defines handle varying, texture2D, gl_FragColor ✓ (same as 035 which works).

11. THREE.GLSL3 constant exists in r170 ✓.

12. In cascadeStep 2s case: spawnPhoton(243,...) — two-photon: continuum, but 243nm marker fine (total 2×~243nm? 2s→1s is 10.2eV shared; each photon continuum up to 243nm... whatever, visual only).

13. emitTransition log uses LETTERS[fromL] — fromL defined for caller contexts: setState passes pL ✓, cascadeStep passes ✓.

14. In animate: volBox.worldToLocal(_camLocal) — volBox scaled by H (uniform scale 10) → local = world/10 ✓ (box at origin, no rotation).

15. applyTier('high') at init? TIERS used directly at init (grid: TIERS[S.tier].grid). dpr set at renderer creation ✓. uSteps default TIERS.high.steps ✓ matches tier 'high' initial. OK.

16. $('btnCascade').classList.remove('off') in stopCascade — cascade button doesn't use .off class; harmless.

17. Help overlay initially visible ✓ (no .hidden). AudioSys.init on helpClose ✓.

18. syncSliders initial: slL.max=S.n-1=2 — but initial HTML slL max=6; syncSliders fixes ✓. slM min/max ±2 ✓ (S.m=2 valid).

19. keyboard: k===' ' — e.key for space is ' ' ✓; k.toLowerCase() fine. k>='1'&&k<='8' string compare ✓. ArrowUp → toLowerCase gives 'arrowup' ✓.

20. In setState — sliders 'change' handler for slN: setState(n, min(S.l,n-1), S.m...) — if S.m exceeds new l, setState clamps ✓.

21. updateEnergyColor: lerp(0.58,0.0,(S.n-1)/6) ✓.

22. Spectrum canvas width 664 (2× CSS 332) — CSS width 100% (~332 in 360 panel minus padding 28 → 332) ✓ crisp.

23. animate(): gradePass uTime uses simTime (pauses when paused — fine).

24. $('stats') update: ${dotCount/1000|0}k precedence: dotCount/1000|0 → (dotCount/1000)|0 ✓.

25. Missing: fade initial: uMix=0, texA=black, texB=black; first upload: uTexA=old black2, uTexB=new ✓.

26. phHeadMat.uniforms.uPix used in applyTier ✓ defined.

27. store muted applied to button at end of chunk 9 ✓; AudioSys.setMuted also updates.

28. Potential issue: points gl_PointSize huge when close — clamp: max? uPix*(2.6+2.4*aSeed)*(150/-mv.z): at mv.z=6 (min distance), size= (2.6..5)25dpr ≈ 65-250px — huge blobs when zoomed close. Clamp gl_PointSize: min(computed, 22.0dpr)? Add clamp: gl_PointSize=min(gl_PointSize, uPix*9.0); Hmm dots should stay small: base formula: at dist 26 (typical), size=(2.6..5)5.77dpr ≈ 15-29pxdpr — a bit big already. Let me scale: use 60/-mv.z factor and clamp to 14*dpr: at 26 → (2.6..5)*2.3 = 6-11.5px — nice. I'll patch: gl_PointSize = min(uPix*(2.2+2.0*aSeed)*(60.0/max(1.0,-mv.z)), uPix*14.0);

29. Photon heads at close range also huge: 26*(12/z) at z=30 → 10px ok; near camera z=6 → 52px flash — acceptable, clamp to 60.

30. updateDots spawn cap: if(spawned>380) continue; per frame max 380 spawns ✓.

31. One more: fieldAtNorm not needed — inline in sampleDot ✓.

32. In computeField: statusEl referenced — $('status') ✓.

33. volMat.uniforms.uClipOff.value=S.clipOff initial 1.0 → no cut when clip enabled at 100% ✓.

34. Bug: In sampleDot, field.N is res.N ✓ set in uploadField. Before first upload, field.N=0 → sampleDot returns false → no dots until field ready ✓.

35. In updateDots: scanning Math.min(dotCount,2600) indices per frame — full coverage of 42k every ~16 frames ✓.

36. applyPreset: document.querySelectorAll('#segPresets button') toggle 'on' ✓; but manual state changes leave stale highlight — acceptable (or clear in setState: remove .on from presets when manual). Minor: patch setState to clear preset highlight when !opts.fromPreset. Skip — acceptable? It might confuse: after moving sliders, preset still highlighted. Quick patch: in setState, clear preset buttons. But cascadeStep bypasses setState (also should clear). Add clearPresets() call in setState & cascadeStep & applyPreset sets. Do it: in setState add document.querySelectorAll('#segPresets button').forEach(x=>x.classList.remove('on')); unless opts.fromPreset. applyPreset calls setState with fromPreset:true and sets its own highlight. Patch.

37. stopTour also called in segColor handler ✓.

38. cascadeT?stopCascade():startCascade() — when cascade running, btnCascade shows... stopCascade removes 'off' — startCascade doesn't add. Cosmetic, fine.

Let me apply patches now:

Patch A (tour/preset flags):

• setState: function setState(n,l,m,opts={}){ ... replace stopCascade(); stopTour(); with stopCascade(); if(!opts.keepTour) stopTour(); if(!opts.fromPreset) document.querySelectorAll('#segPresets button').forEach(x=>x.classList.remove('on'));
• setBasis(b, keepTour=false): function setBasis(b){ → add param; stopTour() → if(!keepTour) stopTour();
• applyPreset(i, silent, keepTour=false): setBasis(p.basis, keepTour); setState(..., {photon:true, keepTour, fromPreset:true}).
• startTour step: applyPreset(tourIdx%PRESETS.length, true, true);

Patch B (uploadField dispose): capture retired.

Patch C (dot size clamp + needsUpdate only when spawned).

Patch D: photon head size clamp.

Then extract module script and node --check.

Also cascadeStep bypasses setState so preset highlight stays during cascade — minor; add clear in cascadeStep. Let me patch cascadeStep to clear preset highlight (it changes state directly). Insert after S.m=nm in cascadeStep.

Then uploadField dispose fix, dot size clamp, photon size clamp, dot needsUpdate optimization.

Wait — the retired logic: on first upload, retired = initial blackTex A. volTexA is reassigned to old B (black2). retired (black1) !== volTexA(black2) && !== volTexB(new) → dispose black1 ✓. On second upload: retired = black2 (current A); volTexA becomes previous new tex... consistent ✓. But disposing while it's still possibly bound as uTexA? uTexA.value is reassigned before dispose check — retired is no longer referenced by uniforms ✓ (uTexA=oldB now).

Now dot point-size clamp + photon clamp + dot needsUpdate optimization.

**********************************************************************************************************************************************>`.

JS syntax OK. Now let me do a deeper runtime sanity check on the physics computation: run the wavefunction computation headlessly in node with a small grid, verifying that:

1. 1s state has max density at center.
2. 3d m=2 real clover has 4 lobes (sign changes around φ).
3. No NaNs.

Let me write a quick node test replicating laguerre/assocLegendre and grid eval.

The physics is verified correct:

• 1s peaks at origin ✓
• 2s has its radial node at r=2 a₀ ✓
• 2p_z dumbbell ✓ (equatorial node)
• 3d clover 4-lobed ✓ (cos 2φ nodes at 45°)
• No NaNs across the full n=1..7 space ✓

Now let me do a quick performance estimate of the 112³ grid compute time in node (single-threaded JS similar to browser):

Performance is good: 64-93ms for 112³ compute, chunked with setTimeout so the UI stays smooth. 7i has huge maxD (3.96e14) but normalized — fine; float32 range handles it.

Now let me also sanity-check the full HTML for structural issues:

1. Check there are no unclosed tags.
2. Check no duplicate id.
3. Check the GLSL — I can't compile headless easily, but let me re-inspect the volume shader for GLSL3 issues:
   • uniform sampler3D uTexA, uTexB; — comma-separated sampler declaration: valid GLSL ES 3.0.
   • uniform float uMix, uSteps, uGain, uBright, uClipOff, uSignMode, uTime; ✓
   • uniform vec3 uCamPos, uEnergyCol; ✓
   • uniform int uClipMode, uColorMode; ✓ — three sets int uniforms fine via numeric values (0).
   • In fieldAt: uClipMode==1 ? p.x : (uClipMode==2 ? p.y : p.z) — int comparison ✓.
   • texture(uTexA,uvw) — GLSL3 ✓.
   • Legacy comment: no // issues.
   • discard when alpha small ✓.
   Potential issue: with GLSL3, does three auto-declare position, projectionMatrix, modelViewMatrix in the vertex shader? Yes — three's prefixVertex always includes attribute/uniform declarations (in GLSL3 mode it writes in vec3 position; etc.? Let me verify: In WebGLProgram.js (r170), prefixVertex includes: Wait that block exists for non-GLSL3. Let me actually check the r170 source to be sure. I'll fetch the three module and grep.

81% time used. Critical insight from the source I just read:

• In WebGL2 non-raw ShaderMaterial: versionString = '#version 300 es\n' ALWAYS (WebGL2 only), and #define attribute in, #define varying out, #define texture2D texture are prepended — for BOTH legacy and GLSL3 materials.
• For GLSL3 fragment: NO auto pc_fragColor out declaration — I must declare my own out vec4 fragColor ✓ (I did).
• Key question remaining: does prefixVertex (before the defines) include attribute vec3 position; etc.? Let me check quickly what prefixVertex contains before this point — earlier in the function there's the standard block with 'uniform mat4 modelMatrix;' ... 'attribute vec3 position;' etc. Since #define attribute in is prepended BEFORE prefixVertex, the attribute vec3 position; lines in prefixVertex become in vec3 position; ✓. So in GLSL3 vertex shader, I can use position, projectionMatrix, modelViewMatrix without declaring them ✓, and I write out vec3 vPos; — fine.
• In my GLSL3 fragment I declared precision highp float; precision highp sampler3D; — three also injects precision highp float; earlier in prefixFragment — duplicate precision statements are LEGAL in GLSL (later overrides). ✓
• in vec3 vPos; in fragment + #define varying in — I wrote in directly, fine.
• One catch: prefixFragment for GLSL3 still prepends '#define varying in' etc. plus uniform mat4 viewMatrix; uniform vec3 cameraPosition; — no conflicts with my declarations ✓.

Also legacy materials (dotMat etc.): #define attribute in + three's prefixVertex declares attributes → my attribute float aBirth, aLife... becomes in float aBirth, aLife, aSeed, aPhase; ✓ valid GLSL3. varying → out/in ✓. gl_FragColor → pc_fragColor define ✓. texture2D not used there.

BUT one real issue: in GLSL3-converted legacy fragment shaders, gl_PointCoord fine; and in dotMat I declared uniform int uColorMode; — fine.

Everything checks out. I'm at 81% time — must move fast now. Remaining:

1. Quick final HTML sanity (balanced tags) — do fast.
2. Deploy to /space/demos/036-wavefunction/.
3. Update /space/demos/index.html with card 036.
4. Done.

Skip further optional polish. Go.

**************************************************************************************************ow.

**********************************************************************************************************************************************************************************************************************************************************ss.

Everything deployed:

• /space/demos/036-wavefunction/index.html — complete (1338 lines, ends properly with )
• /space/demos/index.html — updated with the 036 card
• JS syntax validated with node --check
• Physics verified numerically (1s peak, 2s node, 2p dumbbell, 3d clover, no NaNs across all 7 shells)
• Performance verified (~64-93ms chunked compute)
• three.js r170 GLSL3 handling verified against source

Task complete. Call _success.