Recreate and Deploy 034-Magnetosphere Demo

Let me look at the current state. The task is "Wake up and do as you please." The last execution created a magnetosphere demo at /tmp/mag/index.html but didn't deploy it. The summary says the next execution should:

1. Create /space/demos/034-magnetosphere
2. Copy index.html from /tmp/mag/ to deployment location
3. Update /space/demos/index.html
4. Final syntax check

Let me install shell tools and check the state of things.

**********************************************************************************************ge.

The /tmp/mag/ directory doesn't exist — the previous run's work at /tmp/mag/index.html was lost (tmp is ephemeral between sessions). The demo folder 034-magnetosphere doesn't exist in /space/demos/ either. So I need to recreate the magnetosphere demo from scratch and deploy it.

The current task says "Wake up and do as you please." — so it's free-form. Given the last execution left the magnetosphere demo unfinished/undeployed, the natural continuation is to recreate and deploy demo 034-magnetosphere, since that work was lost. Then update the index page.

Let me check the index.html to see the format used for demo cards, and check an existing demo for style reference.

********************************************************************************************************************************************************************************x).

Good. The demos use three@0.170.0 with import maps from unpkg. Now I'll write the complete 034-magnetosphere demo. This is a big file. Based on the previous execution summary, the demo should include:

1. Three.js renderer, scene, camera, OrbitControls, post-processing (EffectComposer, RenderPass, UnrealBloomPass, ShaderPass for grading)
2. Procedural starfield skybox with Milky Way
3. Sun with glowing corona billboard
4. Procedural Earth (continents, oceans, ice caps, night city lights, clouds, atmospheric limb glow)
5. Dipole magnetic field lines with glowing flow pulses
6. Shader-based translucent magnetopause and bow shock shrouds, dynamically compressing
7. Particle systems: solar wind (with deflection), cusp precipitation, Van Allen belts (inner & outer)
8. Procedural auroral ovals with animated shader curtains
9. CME event (launch, travel, impact: compression + aurora flare + cooldown)
10. WebAudio: ambient solar wind hiss, storm rumble, whistler chorus, CME launch/impact SFX
11. UI: sliders (solar wind speed, storm level, time flow), buttons (launch CME, auto-CME, pause, mute, auto-orbit, help), quality toggle, HUD status/perf stats
12. Physics: magnetopause compression dynamics (Shue model), storm progression, particle movement

I'll write this as a single self-contained index.html. Let me plan the physics/geometry:

Coordinate system: Sun at origin direction... Let's put Earth at origin, Sun at (-X) direction at distance ~ -60 units? Actually typical: GSE coordinates, Sun direction = -X. Let me put Earth at origin, Sun at x = -80 (so sunward is -X). Wait, easier: Sun at (-90, 0, 0), Earth at origin. Solar wind flows in +X direction from the Sun.

Magnetopause (Shue et al. 1997): r = r0 * (2/(1+cos θ))^α, where θ is angle from the +X (sunward) axis... Actually θ measured from the +X axis pointing toward the Sun. Let me define: θ = angle between position vector and the sunward direction (toward Sun = -X if Sun is at -X... hmm let me just define Sun at +X to make formulas standard? But visually, having Sun at -X... whatever, let me define SUN_DIR = normalize(sunPos - earthPos) = (-1,0,0) if sun at (-90,0,0). θ = angle between r̂ and SUN_DIR. r0 = standoff distance (nose), α = flaring exponent.

Shue: r(θ) = r0 * (2/(1+cosθ))^α. At θ=0 (subsolar/nose): r = r0. At θ=π/2 (terminator): r = r0 * 2^α. α~0.5-0.7, r0 ~ 10 Re typically, compresses to ~6-8 during storms.

Wind speed slider maps to dynamic pressure: r0 = base * (v_ref/v)^(1/3) roughly (pressure ∝ v², r0 ∝ P^(-1/6) → r0 ∝ v^(-1/3)). Storm level also compresses.

Bow shock: hyperboloid outside magnetopause: often modeled as r = r_bs(θ) similar or a paraboloid offset: x = x0 - (y²+z²)/(2·something)... Simple approach: use another Shue-like surface with larger r0 and α, offset slightly. Or scaled magnetopause ×1.3 with a forward offset. That's fine visually.

Dipole field lines: In magnetic coordinates, dipole field line: r = L·cos²(λ) where λ is magnetic latitude, L = shell parameter (in Re). Earth's dipole axis tilted ~11° from rotation axis. Field lines from L=2 to L=8, several longitudes. Flow pulses: small glowing sprites moving along field lines: position λ(t) = ±(t mod), speed ∝ something.

Direction of dipole field: B ∝ 3(m·r̂)r̂ − m. In the magnetic meridian, field line direction from south pole to north pole (for Earth, magnetic moment points roughly from north to south... Earth's magnetic moment points southward, i.e., field lines emerge from southern hemisphere... hmm: Earth's magnetic north pole (compass north) is actually a magnetic south pole in physics terms, so field lines point downward in the northern hemisphere. The dipole moment vector m points from magnetic south to magnetic north of the dipole, i.e., roughly toward geographic south. Whatever — pulses flowing along lines either way looks fine; physically, charged particles bounce between mirror points along field lines. I can make pulses oscillate between mirror latitudes, which is actually accurate for trapped particles! Bounce motion: λ(t) = λ_mirror · sin(ωt). That's a nice touch: trapped particle bounce motion.

Van Allen belts: particles orbiting: drift around Earth (azimuthal) + bounce along field lines. Inner belt L1.5-2.5 (protons, reddish), outer belt L4-6 (electrons, bluish). Implement as Points with per-particle attributes updated in JS (or in shader with time). Better: do it in the shader! GPU-driven: each particle has (L, phase0, driftRate, bounceRate, mirrorLat). Position computed in vertex shader from uniforms time & dipole tilt. That's efficient for thousands of particles.

Position for a given L, λ, φ: r = L cos²λ, in magnetic meridian: local position = r·(cosλ·x̂_m + sinλ·ẑ_m) rotated by φ around ẑ_m. Then rotate magnetic frame to Earth frame (tilt).

Auroral ovals: curtains around magnetic poles at ~67-70° magnetic latitude. Implement as vertical curtain ribbons (cylinder-ish ring geometry with vertical extent), shader with animated noise curtains (fbm), green 557.7nm oxygen at bottom transitioning to purple/red at top edges. Oval radius expands with storm level; intensity flares during CME impact.

Solar wind particles: thousands of points streaming from sun (+X flow). Deflection around magnetopause: approximate with a potential-flow-like deflection: velocity = V·x̂ + correction that pushes particles around the obstacle. Simple approach: treat magnetopause as impenetrable and use an analytic "flow around a sphere-ish obstacle" per particle: compute particle's Shue r_mp at its θ; if particle's r < r_mp·1.05, push it outward tangentially. Do this on CPU for N=4000-8000 particles (fine), or GPU with a flow shader... CPU is simpler and flexible; with quality tiers can reduce count.

Actually GPU is nicer for perf: each particle has seed; position computed in vertex shader as function of time: p(t) = start + v·t, then deflected via analytic function. Since flow is steady (unless compression changes), can do it all in shader: compute θ, r_mp, and if r < r_mp, slide along surface. Let me do CPU update in a typed array — simpler to get right, and 6000 particles × per-frame is fine. Actually let me do GPU: positions updated per-frame in vertex shader with uniforms (time, vWind, r0, alpha, tailStretch). Formula per particle:

• Seed gives: lane offset (y0,z0) in upstream plane, phase.
• x(t) = x_start + v·t (wrap when x > tailX → respawn at upstream). Since everything in shader with mod(), respawn handled by mod.
• Deflection: given current (x,y,z): ρ = sqrt(y²+z²), r = sqrt(x²+ρ²), cosθ = dot(r̂, sunDir). Compute r_mp(θ). If r < r_mp + margin: displace radially outward: p *= (r_mp+margin)/r... that creates a shell — particles stack at surface. To make it look like flowing around: blend deflection strength smoothly: deflect = smoothstep over distance d = r - r_mp; add tangential velocity. This is getting complex in shader; CPU loop honestly is more controllable and 6k particles is OK. Hmm, but I also want "wow" — 10-20k particles. CPU with Float32Array and simple math can handle 20k at 60fps easily (few flops each).

Let me do CPU for wind particles with a velocity field function:

v(p) = V·x̂ · (1 − A) + tangential deflection. Use "flow past a sphere" potential flow as approximation but for the magnetopause "effective radius" at particle's angular position... For wow factor and stability, I'll do:

• Compute r_mp at particle θ.
• d = r − r_mp (signed distance approx).
• If d < influence (e.g. 4): add radial outward push ∝ (1 − d/influence)² · V, and reduce x-velocity slightly; also add slight +X acceleration when past the obstacle (d < 0 shouldn't happen if we clamp: if r < r_mp+skin, project position back to surface).

Position integration: p += v·dt. Respawn at upstream disk when x > +55 (tail) or outside bounds.

Also dayside compression: r0 changes smoothly (spring-damper) toward target from sliders/CME.

Cusp precipitation: small particle streams spiraling down near the cusp regions (where field lines open, near noon at high latitudes ~±75°). Points falling along field lines into the poles, appearing during storms. Can fold into aurora intensity instead — but summary says cusp precipitation particle system. I'll add modest particle streams near the cusps (funnel-shaped toward poles at noon side), red-ish.

CME: a big expanding blob/torus of particles launched from sun, traveling +X at ~2× wind speed, when it reaches Earth: compression spike, aurora flare, storm increase, flash, sound. Visual: several thousand particles forming an expanding arc/blob. Implement as CPU particles with own lifecycle.

Audio: WebAudio:

• hiss: filtered noise (bandpass), gain ∝ wind speed.
• rumble: lowpassed noise, gain ∝ storm.
• chorus/whistler: occasional descending/ascending sine glissandi ("whistler waves") — pretty! Random chirps with exponential frequency decay, quiet, more during storms.
• CME launch: whoosh (noise sweep up), impact: boom (low sine + noise burst).

UI: sliders: solar wind speed (250–900 km/s), storm level (0–9 Kp-ish, auto-drifts with wind and CME), time flow (0.1–5×). Buttons: Launch CME, Auto-CME toggle, Pause, Mute, Auto-orbit toggle, Help overlay. Quality toggle (cycles High/Med/Low: particle counts, bloom res). HUD: status line (quiet/active/storm/CME IMPACT), stats (fps, particles), maybe readouts: wind speed, standoff distance (Re), Dst/Kp-ish.

Structure: single HTML, ~1500-2000 lines. Let me be careful about correctness (no syntax errors), since I can't easily test-render. I'll run node --check on the extracted JS? The JS is an ES module with GLSL template strings. I can extract the module script and run node --check with --input-type=module. Three.js imports won't resolve but --check only parses, doesn't resolve imports. Good.

Also I should consider verifying quickly with a headless browser if available (puppeteer/chromium unlikely installed). Just do node --check.

Let me check what's available in the environment: node version.

Node 24 available. I'll write the demo in a local working dir (/tmp/mag again), validate the JS with node --check, then deploy to /space/demos/034-magnetosphere/ and update the index.

Let me now write the full demo. I'll write it in pieces to a file. Given size (~1800+ lines), I'll write with a heredoc via execute_shell_command? That risks quoting issues. Better: use read_write_file_in_shell_environment write mode with full content. The content is large; I may need to split into multiple writes (write mode full rewrite, then append via shell cat). Let me plan: write file in ~4 chunks using heredocs with 'EOF' quoted to avoid interpolation. GLSL contains backticks? I'll use template literals in JS — heredoc with quoted delimiter is safe as long as content doesn't contain the delimiter line.

Actually simplest: use read_write_file_in_shell_environment for the first chunk (full write), then append subsequent chunks using execute_shell_command with cat >> ... <<'CHUNK_EOF'. Or just multiple write calls aren't supported for append... read_write_file only supports full rewrite or line-range replace. Appending via shell heredoc is fine.

Let me design the code carefully now. I'll write clean, well-commented code.

=== DESIGN ===

Units: 1 unit = 1 Earth radius (Re). Earth radius 1. Sun at (-SUN_DIST, 0, 0) with SUN_DIST = 80. Sun visual radius ~ 7 (not to scale, for beauty).

Magnetic dipole: tilt 11° from +Z axis toward... let's tilt in the x-z plane: m̂ = normalize(sin(11°)·x̂ + cos(11°)·ẑ)?? For Earth, dipole axis tilt ~11°. Fine.

Coordinate for dipole: magnetic latitude λ, field line r = L cos²λ. Position in magnetic coords: p_mag = (r cosλ cosφ, r cosλ sinφ, r sinλ) with ẑ_mag = dipole axis. Then rotate from magnetic frame to world: world = R_tilt · p_mag where R_tilt rotates ẑ to m̂.

Shue magnetopause (θ from sunward axis = -x̂ since sun at -x... wait sun at x=-80 → sunward direction = (-1,0,0). Hmm, let me instead put the sun at +X = +80 so sunward = +x̂, wind flows in -X direction. θ measured from +x̂. cosθ = p̂·x̂ = x/r. Simpler. Camera default from (25, 12, 30) looking at origin; sun on the right. Fine.

Wind particles spawn on a disk at x = +55 (upstream), radius up to ~28, flow in -x with speed V. Deflected around magnetopause. Removed when x < -60 (tail end) → wrap to spawn disk.

Shue: r_mp(θ) = r0·(2/(1+cosθ))^α. Note θ→π (tail): 1+cosθ → 0, r→∞ (open tail cylinder, radius → r0·2^α asymptotically? No: as θ→π it diverges; in practice tail radius ~ r0·2^α at terminator and grows slowly). To avoid numerical blowup: clamp 1+cosθ ≥ 0.05 (per the summary note "clamping theta to prevent instability at the tail axis").

Wind speed mapping: slider 250–900 km/s → r0 target = 10.5·(450/v)^0.33 − storm·0.25 clamped [5.5, 12]; α = 0.55 + storm·0.01.

Wind visual speed in scene: vScene = 2.5 + (v-250)/650·6 (Re/s) then × timeFlow.

Deflection model: for particle at p: r = |p|, cosθ = clamp(p.x/r, -0.999, ...) with clamp on (1+cosθ) ≥ 0.08. rmp = r0·(2/(1+cosθ))^α. d = r − rmp. If d < 3.0: influence zone. radialDir = p̂. push strength k = (1 − d/3)². v = (-V,0,0) + p̂·(V·1.1·k) [radial push outward] — but purely radial push just makes a shell; real flow is tangential along surface. Add tangential sliding: when very close (d < 0.6), remove the -x component and instead accelerate along surface toward tail: tangential dir t = normalize(p̂×(x̂×p̂))... Actually the flow around obstacle: far → -x̂; near surface → along surface in the direction of increasing θ (from nose toward tail). Surface tangent direction (meridional) = ∂(surface)/∂θ direction ≈ direction of increasing θ along the surface: t̂_θ = (x̂·cosθ − p̂)/sinθ ... let me derive: p̂ = (cosθ, sinθ·cosφ', sinθ·sinφ') where azimuth around x-axis. ∂p̂/∂θ = (−sinθ, cosθ cosφ', cosθ sinφ'). This points from nose toward tail along the surface. Good: t̂ = normalize(∂p̂/∂θ) — computable: given p̂=(nx,ny,nz), t = (−sinθ, cosθ·ny/sinθ, cosθ·nz/sinθ) = (−sinθ², cosθ·ny, cosθ·nz)/sinθ. Since nx = cosθ: t ∝ (−(1−nx²), nx·ny, nx·nz) = normalize(nx·p̂ − x̂)?? check: nx·p̂ − x̂ = (nx²−1, nx·ny, nx·nz). Yes! t̂ = normalize(nx·p̂ − x̂)... wait sign: that vector = (−sinθ², cosθ·ny... ) which matches ∂p̂/∂θ·sinθ. So t̂ = normalize(nx·n − x̂) points toward tail along the meridian.

Blend: w = smoothstep(3.0, 0.2, d) (0 far, 1 at surface). v = mix((-V,0,0), t̂·V·1.25, w) + p̂·outPush where outPush = V·0.8·max(0, (0.25−d)/0.25)² to keep particles outside: also hard constraint: if d < 0.15, p = p̂·(rmp+0.15). In the tail (x < −20), just straight flow (w naturally small because rmp huge → d large... hmm in the tail r ~ |x| and rmp → huge due to clamping (2/0.08)^α ≈ 25^0.55 ≈ 5.9 → rmp ≈ r0·5.9 ≈ 60 at θ→π. That would make d < 0 in the tail → particles pushed out to a huge cylinder. Not good: real tail radius ~ 15-20 Re. Better: for the magnetopause model, use rmp formula but cap the effective tail radius: rmp_eff = min(rmp, tailRadius(θ)) where tailRadius grows: R_tail = r0·2^α·(1 + 0.35·max(0,θ−π/2)/(π/2)) or simply cap rmp at some function: rmp = min(rmp_shue, r_tail_max) with r_tail_max = r0·2^α·1.35 ≈ e.g. r0=9, α=0.55 → 2^0.55≈1.46 → ~13.2 ·1.35 ≈ 17.8. That gives a nice cylinder-ish tail. But then at the tail axis (p near −x axis, ρ small), rmp_eff = 17.8, d = r−17.8 = (|x|)−17.8 > 0 for |x|>18 — but particles flowing along the axis region (y,z small) would be inside the tail cavity and NOT deflected → they'd fly through the magnetotail interior, which is "inside" the magnetosphere. Physically the solar wind shouldn't be inside. The radial push handles it: for a particle at (−30, 2, 0): r=30, cosθ = −1 → clamped, rmp = min(huge, 17.8) = 17.8, d = 30−17.8 = 12 > 3 → no influence → keeps flowing inside the tail. Bad.

Fix: measure distance to surface differently in the tail: use cylindrical distance: for x < x_term (say x < 0 region), d = ρ − R_tail where ρ = sqrt(y²+z²)? Combined approach:

• If θ < 95° (dayside-ish): use radial Shue distance.
• Else (tail): use cylindrical distance to the tail surface: d = ρ − Rtail(x), Rtail(x) = min(Shue rmp·sinθ, Rtail_max). Hmm getting heavy.

Simpler robust approach: implicit "inside" test: a point is inside the magnetosphere if r < rmp_shue(θ) AND ρ < Rtail_max (cylindrical cap). Distance-ish metric: d = max-based smooth min: d = max(r − rmp, ρ − Rtail_max)? For inside: both conditions → inside if max(r−rmp, ρ−Rtail_max) < 0. d = max(...) is the signed distance to intersection boundary (approx). Influence zone & projection use gradient of d... For projection when inside: compute both; whichever is smaller violation... ugh.

Pragmatic: d1 = r − rmp_shue (dayside), d2 = ρ − Rtail (tail cylinder). d = max(d1, d2) is approx signed distance to the combined surface (intersection of sphere-like cap and cylinder). Influence: w = smoothstep(3, 0.2, d). Normal for push: use gradient: if d1 > d2 → normal = p̂; else normal = ρ̂ = (0,y,z)/ρ. Tangent flow: keep using meridional t̂ for d1 side; for cylinder side, tangent = −x̂ (flow straight down the tail along the surface) — actually t̂ for cylinder side should be −x̂. Blend via which d is bigger.

That works and is stable. Rtail = r0·2^α·1.28.

Bow shock surface: same construction with r0_bs = r0·1.45 + 1.2, α_bs = α·0.9, Rtail_bs = Rtail·1.35, shown as translucent fresnel shell, compresses with wind/storm/CME. Magnetopause shell: translucent fresnel shell with subtle noise shimmer; both use the same analytic geometry baked into a parametric BufferGeometry: sample θ ∈ [0.02π … π], profile r(θ) = min(Shue, cylinder via ρ cap: if r·sinθ > Rtail then r = Rtail/sinθ), revolve around x-axis with say 96×48 segments. Rebuild geometry when r0/α change significantly (or each frame with cheap update of position attribute — 96×48 ≈ 4600 verts, rebuilding each frame is OK but let's update only when params change beyond epsilon, and animate compression via mesh.scale for smoothness... scaling around origin scales sunward too — non-uniform needs: scale x by (r0 change ratio) roughly uniform is fine visually for small changes. Simpler: rebuild geometry on parameter change, and r0 smoothing (spring) makes small changes each frame → rebuild each frame, 4.6k verts recompute in JS — that's fine (few ms? ~4600 × ~20 flops — trivial).

Actually with time-varying shimmer in the shader (noise displacement), we keep geometry static per-frame except when parameters change; rebuild cost is fine anyway.

Aurora curtains: For each hemisphere (N magnetic, S magnetic): a curtain = ring of vertical quads around magnetic latitude λ0 = 67°, radius = L_oval·cos²λ …: oval field line L ≈ 1/cos²(λ0)... dipole: L = r/cos²λ at r=1 → L = 1/cos²(67°) ≈ 6.55. Curtain base circle at radius sin... base ring at Earth surface r=1 at magnetic latitude λ0 → cylindrical radius in mag coords = cos(λ0), height = sin(λ0) along mag axis. Curtain extends upward along field-line-ish vertical: from r=1 up to ~1.9 Re following roughly the dipole field line direction (mostly radial-ish outward tilt). Visual cheat: vertical curtain in magnetic frame: position(φ, h) = R_tilt · ( (cosλ0 + h·0.35)·cosφ, (cosλ0 + h·0.35)·sinφ, sinλ0 + h·1.1 ) with h ∈ [0, 0.75]. Slight outward flare. Shader: fbm curtains moving, green (88,255,120)→teal at bottom, purple/magenta top edge, alpha falls with h, intensity uniform (storm/CME), oval radius expands with storm: λ0 = 67° + storm·1.2° (oval moves equatorward in storms: latitude decreases! Storm → oval expands toward equator → λ0 smaller. So λ0 = 67 − storm·1.3 − cmeFlare·3).

Field lines: pick L shells [1.6, 2.2, 3, 4, 5, 6.5], each with 8 meridional lines (φ every 45°). λ from −λmax..λmax where λmax = acos(sqrt(1/L))·0.98 (foot at Earth surface). Draw with Line (basic material, additive, faint blue). Rebuild when dipole tilt animates? Keep tilt static (static 11°, maybe slow wobble — skip wobble for simplicity; lines static geometry). Pulses: Points per line, 6 per line, moving λ(t) = λmir·sin(ω t + φ0) — bounce between mirror points. GPU: attributes L, φ, phase, ω, λmir; uniform time. Vertex shader computes position via dipole formula + tilt rotation matrix as uniform. Color: cyan-white, size attenuated. Additive blending.

Van Allen belts: Points, inner: 900 particles L∈[1.4,2.4], color amber/red; outer: 1600 particles L∈[3.5,6], color blue/cyan. Each particle: attributes (L, phaseBounce, ωBounce, λmir, phaseDrift, ωDrift). Drift azimuth φ = φ0 + ω_d·t (ω_d smaller for inner? Actually gradient-curvature drift: electrons drift eastward, protons westward; magnitude ∝ L·energy. Visual: inner drift faster). Bounce λ = λmir·sin(ω_b t + φ_b), ω_b ∝ 1/sqrt(L³)·v… visual: ω_b ~ 0.8/sqrt(L^3)·rand. Position as above. Uniform time. Also pitch-angle: particle count per unit... skip. Radial diffusion: slowly vary L? Keep static L per particle; belts intensity increases with storm (outer belt flux ∝ storm; uniform intensity for alpha/size).

Cusp precipitation: on dayside near magnetic noon, particles streaming down near-cusp field lines into poles: Points 600, each: φ near noon (φ0 ∈ [−40°,40°] around sunward in mag frame), λ from 80° → 68° falling, respawn. Color whitish-red. GPU with time: λ = mix(78°, 67°, fract(t·speed + seed)); visible (alpha) only in first part of fall; intensity ∝ storm + CME flare. Position via dipole-ish: r = Lc·cos²λ with Lc = 8? For open cusp lines just do straight-ish funnel: position = R_tilt·(rotate toward noon). Simplify: use field line formula with L=7.5, φ = noon offset ± small, λ decreasing over time from 80° to 66°; alpha fade near end.

Solar wind: CPU particles as designed: N=6000 (High), Points with per-particle color/alpha? Use ShaderMaterial with attributes position (updated), aSize, aSeed; color computed in shader by speed/density: color = mix(dim blue-white, bright cyan-white, near-magnetopause compression). Simpler: uniform color pale cyan with slight per-particle variation via seed; alpha higher near surface? Pass aGlow attribute updated on CPU when in influence zone (d<3): aGlow = w → shader colors hot. CPU sets it. Good.

CME: particle system 2200 particles, positions stored CPU Float32Array, lifecycle: inactive → launched from sun surface region at (−?) wait sun at +X=+80. Launch from sun at +80 toward −x with slight spread cone; leading edge speed ~ wind·1.9. Shape: erupting blob that expands; implement as particles each with direction dir_i (unit, cone around −x̂ with angular spread up to ~35°, biased to ecliptic plane y≈0? visually nice: cone), speed s_i = V_cme·(0.85+0.3rand), plus lateral expansion (self-similar): position = sunPos + dir_i·(s_i·t) + spread_i·t·0.3... Simple: p_i(t) = sunPos + dir_i·(s_i·t)·(1 + 0.15·t·rand_i)? Just radial from sun with per-particle speed spread gives an expanding shell/blob. t from launch. When max reach (dist from sun) > 80−2 → impact begins: trigger effects, fade particles out over 1.5s. Impact: r0 target dips to 5.8 (compression) with spring overshoot, auroraFlare = 1 decaying ~6s, storm level bump +1.5 (decays), flash light, boom sound, status text "CME IMPACT". Cooldown before next manual launch (12s). Auto-CME: launches every ~25–45s random when enabled.

Sun: sphere with emissive noise shader + corona: billboard (sprite plane always facing camera) with radial gradient + fbm flicker, additive; plus a few prominences? Keep: sphere shader (granulation fbm scrolling) + 2 corona billboards (rotating slowly) + point light from sun (directional light actually) — use DirectionalLight from sun dir for Earth lighting + bloom handles glow.

Earth: radius 1 sphere, procedural textures generated on a canvas (or in shader). Previous summary: "Procedural Earth model featuring dynamic continents, oceans, ice caps, night city lights, cloud layer, atmospheric limb glow". Implementing continents: generate a canvas texture 1024×512 with fbm-based continents (ridged noise threshold), ocean gradient, polar ice caps by latitude, night lights: second canvas (emissive map) with city blobs near coasts... Since MeshStandardMaterial supports map + emissiveMap. Generate via canvas 2D:

• day map: fill ocean deep blue (#0b3d91-ish gradient by latitude), continents: fbm > threshold → land color (green/tan by latitude & moisture noise), ice: |lat| > 66°+noise → white.
• night/emissive: black + city lights: sprinkle clusters of warm dots on land areas (sample same fbm field) — need same noise function in JS: implement simple value-noise/fbm in JS for texture gen. Clouds: separate sphere radius 1.02, canvas texture with fbm billows alpha, transparent, rotating slightly faster. Atmosphere: back-side sphere radius 1.06 with fresnel-ish shader (limb glow, additive, blue). Earth rotates slowly (spin), clouds slightly different rate. Night lights visible on night side automatically via emissive (standard material: emissive everywhere — should modulate emissive by darkness: custom onBeforeCompile to multiply emissiveMap by (1−dayFactor)? Simpler: use emissive with low intensity + the directional light only lights dayside; emissive shows on both sides but bloom subtle... Better: small onBeforeCompile tweak to multiply emissive by smoothstep(-0.15, 0.05, dot(normal, sunDir)) inverted → lights only at night. I'll do that — it's a nice touch and straightforward.

Starfield skybox: big sphere (radius 400) BackSide shader: hash-based stars + milky way band fbm. Procedural in fragment shader.

Post: EffectComposer: RenderPass, UnrealBloomPass (strength ~0.9, radius 0.6, threshold 0.15), final ShaderPass grade: vignette + film grain + slight chromatic aberration + tonemap-ish. OutputPass? In r170, OutputPass handles color space; with custom grade pass last, include sRGB conversion in grade shader or add OutputPass after bloom then grade operates in sRGB... Standard chain in demos (like 033) probably: composer with renderPass, bloomPass, gradePass (which includes grain/vignette). I'll have grade shader output with gamma handled: renderer.outputColorSpace = SRGBColorSpace; when using EffectComposer, final pass should convert. In r170, RenderPass renders linear into float/half float target; UnrealBloom works in linear; then OutputPass converts. I'll put OutputPass() then a grade ShaderPass after it operating in sRGB (grain/vignette fine in sRGB). Import OutputPass from addons.

HUD/UI:

• Top-left: title + status line.
• Top-right round buttons: mute 🔊, pause ⏸, auto-orbit 🔄, snapshot 📷?, help ?. (summary mentions pause, mute, auto-orbit, help; snapshot is a nice bonus other demos have — include PNG snapshot.)
• Bottom-left panel: sliders: Solar wind (km/s), Storm level (auto if off? make slider manual with "auto" behavior when CME hits — simpler: manual slider, CME temporarily boosts a separate stormFlare that adds to effective storm), Time flow. Buttons row: 🜨 Launch CME, Auto-CME toggle, quality badge, stats.
• Help overlay: explains controls & physics.
• Hint line bottom center fading.

Keyboard: space=pause, C=launch CME, A=auto-orbit, M=mute, H=help, Q=quality, S=snapshot.

Performance: fps counter, adaptive quality: if fps < 45 for a while, drop tier automatically (summary says quality toggle; other demos have adaptive quality tiers — include auto-drop with manual override).

Audio: WebAudio graph:

• master gain → destination.
• hiss: noise buffer source → bandpass(800Hz) → gain(g ∝ wind speed 0.02–0.09).
• rumble: noise → lowpass(120Hz) → gain(g ∝ storm 0–0.15).
• chorus: schedule whistlers: setInterval-ish in tick: every 2–7s (probability ∝ storm): create oscillator with freq ramp exp from f0 (1200–3000) to f1 (300–900) over 0.4–1.2s, gain envelope 0.0→0.03→0, plus slight detuned second voice. Sounds like whistler waves — lovely.
• CME launch: noise burst highpass sweep + osc up-chirp ("whoosh"), gain 0.2.
• Impact: low osc 60→30Hz + noise lowpass burst, gain 0.5, with slight delay? Immediate. Mute button toggles master gain; audio starts on first user gesture (click/keydown) — create context lazily.

Pause: stops dt accumulation (render still? Pause = freeze sim time & controls still work; audio hiss continues quietly? simpler: lower gains). Keep: pause halts sim updates & particle motion (time frozen), render continues, status shows PAUSED.

Auto-orbit: controls.autoRotate = true.

Stats: FPS, particle count, draw calls (renderer.info).

Magnetopause compression dynamics: r0Actual spring toward r0Target (from wind speed, storm, CME): r0 += (target−r0)·(1−exp(−dt/τ)), τ≈0.5s; CME impact sets an impulse: r0Actual = min(r0Actual, 6) instantly + oscillation: add damped sinusoid — implement impulse velocity: r0Vel −= k; integrate spring with damping: classic spring: acc = (target−r0)·kSpring − r0Vel·damp. Gives nice overshoot "shudder" on impact.

Aurora intensity: base = 0.25 + storm·0.09 + flare·1.2, flare decays exp(−t/4). Oval latitude: 67 − storm·1.1 − flare·2.5 (deg). Belt intensity: inner static 0.8; outer = 0.4 + storm·0.08 + flare·0.8 (uniform).

Storm level slider 0–9; "effective storm" = slider + flareStorm (decays). Also gentle auto-variation: stormSlider auto nudges toward value derived from wind speed slowly? Keep manual + CME bumps slider itself +1 (clamped) so user sees it. Simpler and legible: on CME impact, stormTarget increases and decays; effective = clamp(slider + stormFlare). OK.

Time flow slider: 0.1×–4× multiplies dt for sim (wind particle motion, pulses, belt shader time, CME, Earth rotation).

Now sizes: wind N: High 6500, Med 4200, Low 2200. Belts 2600 total, cusp 600, CME 2400, pulses ~340. Star sphere static.

Camera: fov 55, near 0.1 far 1000, pos (18, 9, 26), target origin. OrbitControls damping, minDistance 3, maxDistance 160.

Sun light: DirectionalLight from (+1,0.15,0) direction toward origin, intensity 2.2, color warm white. Ambient/hemisphere faint for night side visibility (0.08). Also subtle blue rim? fine.

Also add a faint ecliptic grid? Skip; add tick marks? Add small "1 Re" scale? Skip.

Extra wow: magnetotail "plasma sheet" glow: a translucent plane-ish slab in the tail (x from −5 to −45, thin in z, width y ±2.5) additive faint purple with flowing noise shader — represents plasma sheet/current sheet. Nice and cheap. Also "neutral sheet" slight ripple. Add it.

Also polar cap "cusps" highlighted? cusp precip covers it.

Legend? The help overlay explains visuals with colored chips.

Now, code layout in one module script:

1. imports
2. Config & state
3. Renderer/scene/camera/controls/composer
4. Star skybox
5. Sun + corona
6. Earth (textures, clouds, atmosphere)
7. Shue surfaces (magnetopause, bow shock) + rebuild fn
8. Field lines + pulses
9. Belts
10. Aurora curtains
11. Cusp precipitation
12. Plasma sheet
13. Solar wind CPU system
14. CME system
15. Audio engine
16. UI wiring + help + hint
17. Quality tiers & adaptive
18. Resize
19. Main loop + physics integration
20. Keyboard

Careful bits:

• GLSL strings with ${} interpolation avoided; use uniforms.
• node --check on extracted module.

Dipole transform: tilt angle T = 11° = 0.192 rad. m̂ = (sin T·?, 0, cos T) — tilt in x-z plane toward sun a bit? Earth's dipole tilt direction varies with time of day; static: m̂ = normalize( (sinT·0.3, 0, cosT) )? Just tilt around Y axis: m̂ = (sinT, 0, cosT). Then R = rotation matrix taking ẑ→m̂: rotation about Y by T: R_y(T). In shader, pass mat3 uniform uTilt = mat3(cosT,0,−sinT, 0,1,0, sinT,0,cosT) — rotation about Y by angle T maps ẑ=(0,0,1) to (sinT, 0, cosT). Yes: R_y(T)·ẑ = (sinT, 0, cosT). Good. In JS use same via THREE.Matrix4().makeRotationY(T).

Dipole position from (L, λ, φ): r = L·cos²λ; p_mag = ( r·cosλ·cosφ, r·cosλ·sinφ, r·sinλ ); p_world = R·p_mag.

GLSL for pulses/belts vertex: uniform float uTime; uniform mat3 uTilt; uniform float uIntensity; uniform float uSize; attribute float aL; attribute float aPhase; attribute float aBounce; // ω_b attribute float aMir; // mirror latitude rad attribute float aDrift; // ω_d attribute float aSize; attribute vec3 aColor? or per-system color uniform. vec3 dipole(float L, float lam, float phi){ float r = Lcos(lam)cos(lam); float cl=cos(lam); return uTilt * vec3(rclcos(phi), rclsin(phi), rsin(lam)); } lam = aMir * sin(aBounceuTime + aPhase); phi = aPhase7.13 + aDriftuTime; (use separate aPhi0 attribute) gl_Position ...; gl_PointSize = uSize * (300.0/−mvPosition.z); vAlpha = intensity envelope: brightness higher near mirror points? particles slow at mirror → accumulate → brighten: v = |cos(ωt+φ)| … visual nicety: alpha = 0.5+0.5·|cos|. Include.

Bounce frequency physical: ω ∝ v/(L·Re)·…; visual: ω_b = (0.5..1.2)/L^1.5·3.0 → inner belt fast bounce, outer slow. Drift: ω_d = (0.05..0.15)·(2.5/L)^2·dir; inner faster drift. For outer electrons vs inner protons drift opposite directions — nice detail: inner dir = −1 (westward, protons), outer dir = +1 (eastward electrons). Mention in help.

Aurora shader: geometry: parametric curtain BufferGeometry: segments φ 180, h 8 rows. Attributes: aPhi, aH (0..1). Vertex shader positions via uniforms uLat0 (rad), uTilt, uFlare (radius expansion). Pass world pos to fragment; fragment: fbm(vec2(phi·3, h·2 − t·0.4)) curtain rays: use noise to modulate vertical streaks: n = fbm(vec2(phi·6.0, h0.6 - uTime0.25)) etc. Color: bottom green (0.2,1.0,0.45), mid teal, top purple (0.7,0.2,1.0); mix by h + noise. Alpha = uIntensity · smoothstep edges · (0.35+0.65·n) · (1−h)^0.7 · ... Additive blending, DoubleSide, depthWrite false.

fbm in GLSL: standard hash/noise/fbm 3-4 octaves.

Magnetopause shell shader: color pale blue-cyan, alpha = fresnel·(0.10 + 0.05·noise shimmer) · uOpacity; sunward side brighter (dot(p̂,x̂)>0). Bow shock: pale magenta/violet, even fainter, with flowing streaks along flow direction (noise scrolling in x). Both DoubleSide? FrontSide with depthWrite false, additive. Also add slight vertex displacement shimmer: pos += normal·(noise(p·0.3+t)·0.15).

Plasma sheet: geometry: plane custom: x ∈ [−6, −48], y ∈ [−3, 3] (2D grid 40×8), shader displaces z with ripple noise & taper alpha at edges, purple-violet, additive.

Solar wind Points shader: attributes: position (dynamic), aGlow (float dynamic), aSeed. Uniform uSize, uColor. gl_PointSize ~ uSize·(1+aGlow·0.6)·(280/−z). Frag: circular soft sprite, color mix(uColor, hot #bfe8ff→white, aGlow), alpha ·(0.55+0.45·aGlow).

Wind CPU update per particle per frame:

• if paused skip.
• p += v·dtSim where v computed as above; store positions in Float32Array; aGlow array update.
• respawn: x < −55 or r > 70 → place on upstream disk: x = 55 + rand·4, y,z random in disk radius 30 (rejection or sqrt-dist), but avoid spawning inside bow shock? upstream x=55 fine.
• Also skip region inside Earth: if r < 1.2 → respawn (shouldn't happen due to deflection).

Per-frame JS cost: 6500 × ~40 flops ≈ 260k flops — trivial. Plus typed array writes. BufferAttribute needsUpdate = true.

CME CPU update: when active: for each particle: p = sunPos + dir·(spd·(t−t0))·(1+0.12·(t−t0)·exp_i)? Keep simple: p += dir·spd·dt·(1+swirl); slight tangential swirl for dynamism: rotate dir slightly over time? Per summary: "adding rotation to the CME blob for enhanced dynamism". Implement: particle pos = center(t) advanced + offset rotated by ωt around travel axis? Simplest good-looking: each particle has base dir & speed; position = sunPos + R_axis(ω·age·spin_i) · (dir·dist_i(age)). Rotating dirs around −x̂ axis: use rotateAroundAxis for dir each frame: cheap: rotate y,z components: ang = ω·dt·(0.5+rand); y' = y cosA − z sinA ... but that rotates the whole dir around x-axis — spiral arms! Looks great. dist_i(age) = spd_i·age. Also radial expansion: dir spread grows: add slight outward-from-axis component: ρ factor grows with age: effectively dir_i(angle) fixed, spiral handled by rotation; expansion: multiply perpendicular component by (1 + age·0.25) — do: perp = dir − x̂·(dir·x̂); dir_eff = normalize(x̂·(dir·x̂) + perp·(1+age·0.18)). Compute per particle per frame from stored (dirBase, spd, seed): 2400 × trig — fine.

Impact detection: lead distance = max over particles? Track cmeFront = maxSpd·age ≥ 78 (sun at 80, earth 0) → impact at age ≈ 78/maxSpd. Trigger impact when age ≥ tImpact & !impacted. Then impactFX(); particles continue past (they'd hit Earth) → fade all alpha over 1.2s and deactivate at age > tImpact+2. Also let particles visually wash around (deflect)? Just fade — acceptable & pretty with bloom.

Sun position: SUN_POS = (80, 0, 0). Sun mesh radius 6. Corona billboards radius ~ 11.

Also add faint sunward " Parker spiral" field lines from sun? Skip — enough.

Status text logic: if paused "PAUSED"; else if flare > 0.25 "⚡ CME IMPACT — geomagnetic storm!"; else if effStorm ≥ 6 "SEVERE STORM (G3+)"; ≥4 "ACTIVE — substorms likely"; ≥2 "QUIET-TO-UNSETTLED"; else "QUIET CONDITIONS". Plus standoff readout: "MP nose: X.X Re · Dst −NN nT" where Dst ≈ −(storm·22 + flare·120) nT fake but plausible. Kp = effStorm.

Snapshot: composer.render then canvas.toBlob → download link click. Need preserveDrawingBuffer? Using composer; toDataURL right after render in same frame works if we call it synchronously after composer.render() within the snapshot handler (render on demand). I'll do: snapshot() { composer.render(); renderer.domElement.toBlob(...) } — works without preserveDrawingBuffer if called synchronously right after render (same task). Good.

Adaptive quality: track EMA fps; if < 42 for > 4s and tier > Low → step down, toast status. If > 58 for > 20s and tier < user set? Only auto-step-down; manual toggle sets tier & disables auto for 30s.

Renderer pixel ratio: min(devicePixelRatio, 2) on High; Med 1.5; Low 1. Bloom resolution auto.

Now write the code. Also title/HUD text, styling consistent with other demos (glassmorphism dark).

Help overlay content: list of controls & what visuals mean (color chips: cyan=solar wind, blue lines=B field, green/purple=aurora, red/blue belts, violet sheet=bow shock, etc.)

Let me also double check Shue α typical: 0.58 (Shue 1997: α varies 0.5–0.7 with IMF Bz). r0 = 10–11 Re quiet.

One risk: BufferGeometry parametric shells with open tail — build grid θ from 0.03 to 3.10 rad (near π, clamp), rings N=64 θ-steps × M=96 φ-steps. Position: r(θ) = min(shue, Rtail/sinθ) with smoothing at transition? Use smooth min to avoid crease: smin(a,b,k)= −k·ln(e^(−a/k)+e^(−b/k)) … or just min — crease subtle under additive fresnel. Use smin with k=1.5 for smoothness. Normal: computeVertexNormals() on indexed geometry — fine.

The surface is a surface of revolution about X axis: p(θ,φ) = r(θ)·(cosθ, sinθ·cosφ, sinθ·sinφ). At θ→π, sinθ→0.1 (clamp 3.10) → tail open radius r·sinθ ≈ Rtail·~1. Good.

Rebuild when r0Eff or α change > 0.5% (with spring they change every frame during transitions; rebuild throttled to every frame is OK: 64×96=6144 verts + computeVertexNormals — maybe 0.5–1ms; acceptable; throttle to when |Δ|>0.002·r0 or every 100ms during motion. Simpler: rebuild at most every 80ms if dirty.)

Bow shock: same function with its params; rebuild likewise.

Earth textures: canvas 1024×512. Noise: implement value noise with permutation from seeded RNG (mulberry32). fbm(x,y,oct=5) in 2D over equirectangular; to avoid seam at u=0/1, sample noise on torus: use 3D-ish trick: sample fbm at (cos(u)·r, sin(u)·r, v) with 3D value noise? 3D value noise in JS is fine (hash from 3 coords). Do fbm3 with 4 octaves, ~1024×512×4×... ≈ 2M ops × ~20 = 40M — ~100-200ms one-time. OK. Or 512×256 for speed then upscale? 1024×512 nicer. Go 1024×512 but keep noise cheap (hash-based value noise, no Math.sin in inner loop; precompute gradients? use integer hash + smoothstep interpolation). Fine.

Land threshold: h = fbm(p·1.8)+0.25·fbm(p·5) − 0.55·|lat factor|? Continents: base = fbm3(x,y,z, 5); land if base > 0.52. Add latitude ice: |sin(v·π)|... v∈[0,1] lat = (0.5−v)·π. ice if |lat| > 1.05 + noise·0.1. Land color: mix by lat: tropics green → desert bands tan (|lat|~0.4 + noise) → tundra → ice. Ocean: depth = 0.52−base → deep navy → shallow teal near coasts. Night lights canvas: for land pixels with probability higher near "coastal" (|base−0.52| small) and lower at high |lat|: draw small warm dots clusters: iterate ~2200 random points, check land, draw radial gradient dot 1-2px, color #ffd9a0 with varying alpha. Also emissive intensity moderate (0.9) & night-mask via onBeforeCompile.

Cloud texture: 512×256 alpha = smoothstep(0.5,0.75, fbm) ·0.9, white. Sphere 1.018, transparent, depthWrite false, rotation faster + slight tilt.

Atmosphere: ShaderMaterial BackSide sphere 1.07: alpha = pow(1 − |dot(viewDir, normal)|, 3.5)? For backside: intensity at limb. Classic: varying vNormal, vWorldPos; f = pow(0.72 − dot(vNormal, normalize(vWorldPos−cameraPos))? Use standard glow: intensity = pow(0.65 + dot(normal, viewDir), 4.0)?? I'll use: rim = pow(1.0 − abs(dot(normalize(vViewDir), vNormal)), 3.0); but BackSide sphere normals flipped; simpler: use FrontSide slightly larger sphere with additive and fresnel = pow(1 − dot(n,v), 4), giving limb halo-ish glow over disk edge — commonly looks good with additive: color #4d9fff·f·1.2. Plus a bigger BackSide halo sphere 1.25 with similar fresnel·0.25. Fine-tune constants reasonable.

Lighting: dir light (1.2, warm) from sun; hemisphere (0x334, 0x000, 0.35). Earth standard material roughness 0.9 metalness 0, specular ocean? keep simple.

Earth rotation: earthGroup.rotation.y = t·0.02·timeFlow? Real: 2π/day; visual slow spin 0.05 rad/s·flow. Dipole tilt tied to rotation? Dipole fixed to Earth (rotates with it daily — 11° tilt wobbles field lines around). For clarity, keep magnetosphere frame fixed (dipole tilt static w.r.t. sun), Earth spins inside. Physically the magnetosphere co-rotates near Earth but outer stays; acceptable simplification, note in help? Fine.

Clouds rotation.y = t·0.065.

Star skybox shader: hash stars: p = direction·350; cells; star = step(0.998, hash) → brightness·(0.6+0.4·sin(t·twinkle+seed)) — twinkle in skybox cheap. Milky way: band = exp(−pow(dot(dir, bandNormal),2)·18) → fbm(dir·3)·band → color mix bluish-purple, add faint dark dust lanes via second fbm.

Grade shader: uniforms tDiffuse, uTime, uVig, uGrain, uCA. Standard.

Now UI HTML: reuse style language from gossamer (colors: cyan/violet palette — "magnetosphere": electric cyan #7fd4ff accents, violet #b78bff).

Title: "MAGNETOSPHERE" subtitle "SOLAR WIND × EARTH'S MAGNETIC SHIELD".

Panel sliders with value readouts (wind km/s, storm Kp, time ×). Buttons: "☄ Launch CME" (C), "Auto-CME" toggle, quality chip, stats. Top-right: 🔊/🔇 mute, ⏸ pause, 🔄 auto-orbit, 📷 snapshot, ? help. Status line under title. Hint bottom center. Help overlay full glass panel with two columns.

Also "Dst" and "Kp" readouts maybe in status line.

Edge cases:

• context loss? skip.
• WebGL float for composer: use HalfFloatType render targets default in r170 composer? EffectComposer default uses HalfFloat since r152ish. fine.

Imports needed: three, OrbitControls, EffectComposer, RenderPass, UnrealBloomPass, ShaderPass, OutputPass.

Write now. I'll produce the file in ~5 chunks via heredocs. Must be careful: heredoc with 'EOF' quoted prevents shell expansion of $ and backticks — but our JS contains backticks (GLSL template literals) — safe inside quoted heredoc. Just ensure no line in content equals EOF marker.

Let me draft the whole thing mentally then write chunks.

Chunk sizes ~ 300-400 lines each. Let me write carefully.

--- Begin drafting key JS pieces ---

RNG: mulberry32.

3D value noise:

value noise with trilinear smooth interpolation; fbm3(x,y,z,oct).

Earth texture gen:

fbm3 called per pixel: 512k px × (5+4 octaves × ~hash8 each) ≈ 512k×9×8 hashes ≈ 37M hash ops. JS maybe 0.5–1s. Acceptable one-time; show "loading" until done via requestIdleCallback? Just do it synchronously before first frame with a tiny "calibrating" overlay text; fine. Could reduce to 5 octaves only (drop second fbm term to 3 octaves): ~30M. ok.

Alternatively 768×384 → 13M. Use 768×384 for day/night (crisp enough at radius 1 on screen) — but Earth is small in view usually; 768 fine. Clouds 512×256.

Actually users zoom to Earth (minDistance 3 → Earth fills screen at ~3 Re distance); 768×384 is a bit blurry but stylized OK. Use 1024×512 and accept ~1s init. Fine.

GLSL noise (shared snippet string):

Wind update: store arrays: pos Float32Array(N*3), glow Float32Array(N), plus per-particle speed jitter factor j (0.85–1.25) in Float32Array, spawn offsets.

Update:

Guard: at exact +x axis nose (ny=nz=0): t=(ct*1−1,0,0) with ct=1 → (0,0,0) → tl=0 → fallback: treat as stagnation point: push outward radially — but radial normal = x̂ = upstream... particle exactly on axis gets stuck at stagnation point (physical!). In practice random jitter keeps them off-axis; add tiny random jitter to y,z when w>0.5: pos_y += (rand−0.5)*0.02. Good — prevents stagnation sticking.

Note tangent at nose region points "backward" (+x?) Check: t=(ctnx−1, ctny, ct*nz); at nose nx=1,ct=1: zero. Slightly off-axis: nx≈1−ε²/2, ny=ε: t=( (1−ε²/2)²−1, (1−ε²/2)ε, 0) ≈ (−ε², ε, 0) → normalized ≈ (−ε, 1, 0) — points +y (outward) slightly −x. Hmm at the nose the surface tangent flow should be outward (+y) — correct! As θ grows: θ=90°: nx=0: t=(−1,0,0) → toward tail. Correct.

Bow shock deflection zone for wind particles: wind should deflect at bow shock, not magnetopause. Use bow shock params (bigger) for deflection! Particles slow down & heat at bow shock (glow). So use r0_bs, α_bs, Rtail_bs for the flow deflection, glow peaks near magnetopause? Glow = w (near bow shock). Particles then flow in the magnetosheath between BS and MP; our simple field just uses BS surface. But then some streamlines pass through MP (between surfaces flow continues along). Fine visually. However hard clamp at d<0.35 keeps them outside BS+0.35 — actually real sheath is between; clamping at BS means nothing flows between BS and MP — visually the gap region empty of wind — hmm, real picture: wind dense in sheath. Alternative: deflect at BS but clamp at MP: influence d from BS (w from BS), hard clamp + radial push using MP surface. Particles dive in at BS, get tangential, sheath flow between BS & MP, never cross MP. That looks great: dense glowing sheath! Implement: compute d_bs with bs params → w; compute d_mp with mp params → if d_mp < 0.3: radial push out + project if < 0.15.

Tail: MP Rtail cylinder: particles in tail region flowing inside Rtail cylinder but beyond MP? For x<0 region particle with ρ < Rtail_mp would be inside magnetosphere — apply d2_mp = ρ − Rtail_mp; push radially out in y,z. OK.

So per particle compute both surfaces — ~double cost, still fine.

Cusp precipitation: noon side in magnetic frame: "noon" = toward sun = +x. In magnetic coords, φ measured from +x axis in mag xy-plane... but magnetic frame tilted; cusp at magnetic noon: the point on Earth where magnetic field line ~ noon meridian. Implement particles: L=7.5 fixed-ish (7+rand), φ0 = 0 ± 0.5 rad (noon meridian plane, φ measured in mag coords from x-axis: p_mag x = r cosλ cosφ; noon = φ=0 → toward +x = sunward. Since tilt is about Y, mag x-axis stays world x. good.) λ(t) = mix(1.35, 1.10, k) (77°→63°), k = fract(uTimespeed + seed); alpha envelope = sin(kπ)^0.5 · uIntensity... but precipitation should fall down: from λ small... wait λ magnetic latitude: at Earth surface foot λ0 where r=1: cos²λ0=1/L → λ0=acos(1/sqrt(7.5))≈ acos(0.365)=68.6°. Particle starts high on field line at λ=30°? No — cusp particles come from above (magnetosheath) down to ionosphere. Visually: start at r≈4–5 above the cusp and spiral down to r=1 at λ0. Position: r(k) = mix(4.5, 1.0, k), λ(k)= λ0 + (1−k)·0.15 (drift eq-ward slightly), φ = small. So p_mag = (r cosλ cosφ, r cosλ sinφ, r sinλ) with φ∈[−0.4,0.4] fixed per particle + tiny gyromotion: add small circle offset radius 0.05·r perpendicular — skip gyro, keep clean streams. uIntensity = 0.3+storm·0.1+flare. Color: soft red-pink (#ff6a88 → cusp red 630nm) mixed with white.

Pulses on closed field lines: as designed. Also add "radial diffusion" skip.

Belts: as designed. Also slot region between 2.4–3.5 naturally empty.

Aurora geometry: build with attributes aPhi(0..2π), aH(0..1), indexed grid 160×10. Vertex:

Better: follow dipole line L0: given h (0..1): r = 1 + h0.85; λ = acos(clamp(sqrt(r/L0),0,1)) — since r=L cos²λ → cosλ=sqrt(r/L). Wait L0 = 1/cos²λ0 → cosλ = sqrt(r·cos²λ0) = cosλ0·sqrt(r). λ decreases outward — field line tilts equatorward as it goes up from the foot? At the foot (r=1, λ=λ0=67°): going up along field line toward equator plane (λ→0 at r=L=6.5). Yes pole-side edge... the curtain top tilts toward equator — correct-ish (field lines curve equatorward). p_mag = (r cosλ cosφ, r cosλ sinφ, r sinλ). world = uTilt·p_mag. Also slight k-wave displacement: p += normal-ish·sin(φ·5+t)·0.03 for ripple — add in vertex: radial mag-frame wiggle: r += sin(aPhi7.0 + uTime*1.3)0.02(1-aH). Nice subtle.

Fragment:

Add bottom edge brightest: a *= 0.6+0.4·exp(−vH·6). Good.

South oval: same geometry with uFlip=−1 (sinλ → −sinλ). Two draw calls with different uniform (uSign).

Bow shock streaks: fragment: flow lines: n = fbm(vec3(θ·2, φ·3, x·0.05 + t·0.6))... keep simple shimmer.

Plasma sheet: grid x∈[−6,−48] 30 segs, y∈[−3.2,3.2] 8 segs; vertex: z = fbm(x·0.1, y·0.3, t·0.2)·0.8·taper; frag: alpha = edge tapers · (0.10+0.1·n) · uI; color violet #8a5cff→#c86bff by |y|. Additive.

Field line material: LineBasicMaterial color 0x3d7dff transparent opacity 0.28 additive; per-line positions computed JS static (512 points/line? use λ steps 64 → fine).

Field pulses: BufferGeometry Points with attributes as planned; count: lines(6 L-shells × 10 φ) = 60 lines × 5 pulses = 300.

uTime for shaders: simTime (scaled by timeFlow) — pause freezes.

Earth night-lights mask via onBeforeCompile on MeshStandardMaterial:

Careful with three r170 chunk names: 'emissivemap_fragment' exists; in it: vec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv ); totalEmissiveRadiance *= emissiveColor.rgb;. Replace whole include with custom code — fine. World normal: Earth rotates (modelMatrix changes) → use world normal & world sun dir (+1,0,0 normalized toward sun: direction TO sun = normalize(80,0,0)=(1,0,0)). Uniform value constant (1,0,0).

Declare in fragment: uniform vec3 uSunDirW; varying vec3 vNormalW; and vertex: varying vec3 vNormalW; set after beginnormal? objectNormal exists in defaultnormal_vertex. Inject: vertex: replace '#include <defaultnormal_vertex>' with itself + '\n vNormalW = normalize( mat3( modelMatrix ) * objectNormal );' fragment: replace '#include <emissivemap_fragment>' with custom. Also need declarations: prepend to both shaders: 'uniform vec3 uSunDirW; varying vec3 vNormalW;' etc. via shader.vertexShader = decl + shader.vertexShader.

sunDir world = (1,0,0) since sun at +x. dot(normal, sunDir) > 0 = dayside.

Also atmosphere shader: standard fresnel:

Hmm FrontSide sphere larger than Earth with fresnel pow ~3 gives glow concentrated at limb — good.

Sun shader: sphere r=6 at (80,0,0): fragment fbm granulation scrolling: color ramp #ffdf8a → #ff9a3c → #ff5f2a; emissive (MeshBasic-like ShaderMaterial, no lighting) → bloom picks it. Corona: two Sprite? Use plane billboards with ShaderMaterial (lookAt camera each frame or use PointsMaterial big sprite?). Simplest: THREE.Sprite with canvas radial gradient texture + additive; scale 26; plus second sprite scale 40 alpha lower, slow rotation via material.rotation. Sprite rotation supported (material.rotation). Good, cheaper than shader billboards. Generate corona texture on canvas: radial gradient white→gold→transparent + 12 streaks? Canvas: draw gradient + random flare rays via rotated gradients — decent. Also flicker: scale pulsate slightly in tick.

Sun light: DirectionalLight color 0xfff2dd intensity 2.6 position (80,0,0) target origin.

Audio unlock: first pointerdown/keydown → initAudio().

Quality tiers object: {wind:N, dpr:cap, bloomRes} apply function rebuilds wind system (reallocate) & sets renderer.setPixelRatio.

Snapshot, pause etc straightforward.

FPS meter: frames counted each rAF; every 0.5s update.

Status line update every 0.25s.

Now — WRITE IT. I'll be meticulous with brackets. Also keep every GLSL correct: no varying name clashes, declare precision not needed (three adds), attributes in ShaderMaterial via BufferGeometry attribute names matching (custom names must not collide with built-ins like position/normal/uv — fine: aPhi, aH...).

One more check — ShaderMaterial for Points with attribute 'aSize' etc. OK.

For belts/pulses/cusp shaders I need uTilt mat3 uniform: value = new THREE.Matrix3().setFromMatrix4(new THREE.Matrix4().makeRotationY(TILT)). GLSL mat3 multiplication: uTilt * vec3 — column-major as usual; Matrix3 set from Matrix4 rotation Y: makeRotationY(T): [cosT, 0, sinT; 0,1,0; −sinT, 0, cosT] (row-major math). Applied to ẑ=(0,0,1): (sinT, 0, cosT). Good — GLSL uTilt*v with same matrix uploaded gives same result.

JS side dipole:

Check rotation Y applied to (x,y,z): x' = x cosT + z sinT; z' = −x sinT + z cosT. Applying to (0,0,1): (sinT, 0, cosT). matches.

Shue in JS: function shueR(ct, r0, alpha){ const d=Math.max(1+ct,0.06); return r0*Math.pow(2/d, alpha); }

Shell geometry builder:

smin(a,b,k) = -klog(exp(-a/k)+exp(-b/k)) — exp args large negative when a big... a up to ~60: exp(-60/2)=e-30 ≈ 1e-13 fine; exp(-a/k) with a negative small (near nose? a=r0≈9) fine. Underflow to 0 fine. Guard: if a−b > 30 return b etc. Implement robust smin: m=min(a,b); return m - kMath.log(Math.exp(-(a-m)/k)+Math.exp(-(b-m)/k)). Safe.

Rebuild throttle in tick.

Bow shock params: r0b = r01.5 + 1.6; alphaB = alpha0.92; rTailB = rTail*1.45.

Wind uses those.

OK, also small touch: Earth axis tilt visual 23.4°? Earth group tilt Z by −0.41 rad? The spin axis vs dipole 11° — visual clutter; keep Earth upright spin, note tilt in texture (ice caps symmetric). Fine, skip axial tilt for clarity? Nah — add 23° tilt to earth mesh only (seasons irrelevant), spin about tilted axis: earthTiltGroup.rotation.z = 0.41; earthMesh.rotation.y = t. Dipole lines tilted 11° about Y — independent. Looks nice. Clouds inside tilt group too.

Camera default position: (26, 10, 34) target (0,0,0) — sun at +x right side visible when zoomed out; initial view shows Earth + MP shells + wind streaming from right. Sun may be off-frame at start (distance 80) — fine, user zooms out. Maybe default further: pos (30,12,40), maxDistance 220.

Bloom threshold 0.12, strength 0.85, radius 0.55.

Grade shader uniforms: uTime, resolution not needed; vignette 1.15 strength, grain 0.045, CA 0.0016·(r²).

Tone mapping: renderer.toneMapping = ACESFilmicToneMapping; exposure 1.05. With composer + OutputPass, tone mapping applied in OutputPass. Grade pass after OutputPass operates on sRGB — ok.

Materials emissive intensities tuned for bloom.

Let me now also decide slider ranges: wind 250–900 default 420; storm 0–9 default 2; time 0.1–4 default 1.

V (scene units/s) = 3.2·(v/420) → at 420: 3.2 Re/s; at 900: 6.9. Times timeFlow.

r0Target = clamp(10.8·Math.pow(420/v, 0.33) − stormEff·0.22, 5.6, 12.5). alpha = 0.55 + stormEff·0.012 (≤ ~0.66). rTail = r0·Math.pow(2,alpha)·1.30.

CME: speed Vc = V·1.9 + 2.0. Launch from sun surface point (74,0,0) with dirs cone around −x: dir = normalize(−1 + perp·tanSpread), perp random in disk radius sin(maxAng 0.42). Store baseY,baseZ components. Per frame: age=t−t0; rotate (y,z) of dir by ω·age where ω = 0.35·(1+rand) (spiral); expansion factor g = 1+age·0.10 applied to perp part. p = sunPos + dirEff·(spd_i·age). alpha: ramp in 0.5s, full, fade after impactAge+0.8 → 0 at impactAge+2.2, deactivate age > impactAge+2.4. Points size ~ uSize 5, color gradient head #ffd9c0 → tail #ff7a55, additive. Also spawn ~15% "core" brighter particles.

Impact effects: flare=1.0; stormFlare=2.2 (decays τ 25s); r0 spring impulse: r0Vel −= 3.2; white flash: flash uniform for grade pass (uFlash decay 0.8s) adds screen flash; boom(); status; camera micro-shake? skip shake.

Spring: r0Acc = (r0T−r0)·18 − r0V·5.5; r0V += acc·dt; r0 += r0V·dt. (ω≈4.2, ζ≈0.65) → nice shudder.

flare decay: flare += (0−flare)·(1−exp(−dt/3.5)).

Aurora uI = clamp(0.22 + stormEff·0.10 + flare·1.3, 0, 2.2); uLat0 = (67 − stormEff·1.15 − flare·3.0)·DEG clamp min 58°. Belt outer uI = 0.45+stormEff·0.07+flare·0.9; inner uI=0.8. Cusp uI = 0.35+stormEff·0.09+flare·1.1. MP shell uOpacity = 0.55+stormEff·0.05+flare·0.5; color shifts slightly red during storm? lerp color uniform by flare: mix(#57c8ff, #ff9a7a, flare·0.6). nice.

Audio gains per frame: hiss.gain = muted? 0 : 0.015+ (v−250)/650·0.05 + flare·0.05; rumble.gain = 0.01+stormEff·0.012+flare·0.12. Whistler probability per sec = 0.06+stormEff·0.05+flare·0.8 (schedule check in tick with random).

CME travel time: dist 74−0; Vc at wind 420: V=3.2 → Vc=8.1 → ~9.1s travel at timeFlow 1. Longish but dramatic; ok. Auto-CME interval 20–40s.

tImpact = 76/Vc roughly (front particle max spd·age=76). Compute per-launch: tImpact = 76/(Vc·1.05).

Good. Also on launch: status "CME LAUNCHED — ETA ~Ns"; whoosh sound.

Alright, also HUD "MP nose" readout = r0.toFixed(1) Re; "Kp"=stormEff.toFixed(1); "Dst" = Math.round(−(stormEff·24 + flare·140))+" nT".

Write chunks now. I'll assemble locally at /tmp/mag/index.html then validate by extracting module JS (between and ) → node --check with .mjs. GLSL strings are inside JS so they're covered.

Also quick sanity: three r170 ShaderPass + OutputPass import paths exist: 'three/addons/postprocessing/OutputPass.js' yes.

Chunk plan (append with cat >>):

1. HTML head + CSS + body HTML + importmap + script start + utils (rng, noise js)
2. core setup + skybox + sun + earth
3. shells + field lines + pulses + belts + cusp + aurora + plasma sheet
4. wind + CME + audio
5. UI + quality + loop + keyboard + resize + end tags

Let me write it. Keep lines tidy; total maybe ~1400-1600 lines.

Details for HTML/CSS (colors: cyan #7fd4ff, violet #b78bff, amber status):

Body children:

CSS similar to gossamer.

Now write chunk 1.

For the help overlay content, include chips legend:

• pale cyan dots = solar wind plasma
• violet veil = bow shock, blue veil = magnetopause
• blue loops = dipole field lines, cyan dots bouncing = trapped particles
• red belt inner (protons), blue belt outer (electrons)
• green/purple curtains = auroral ovals
• pink streams = cusp rain
• purple slab = plasma sheet Controls list & keyboard.

Also mention physics notes briefly (Shue model, bounce/drift).

Let me write everything now carefully. During writing I'll keep a mental symbol table to avoid typos.

Key uniforms/objects names:

• simTime, state{wind, storm, timeFlow, paused, muted, autoOrbit, autoCME, quality}
• effStorm(), flare, stormFlare, r0, r0V, r0Target()
• shueNow() returns {r0, alpha, rTail}

I'll write updateWind(dt), updateCME(dt), updateDynamics(dt), updateHUD(dt), tick().

Buffer attribute updates: mark needsUpdate.

For wind ShaderMaterial:

CME shader: attributes position, aHead (0..1 normalized per-particle speed rank → for color), aSeed. uniform uAlpha. color mix(#ff7a55,#ffe9c8, aHead).

Cusp shader: attributes aSeed(4 floats?) — need per-particle: aSeed (rand), aPhi, aL, aSpeed, aOff. Use attributes aSeed, aPhi, aL, aSpd. vertex: k = fract(uTimeaSpd + aSeed); float r = mix(4.6, 1.02, k); float lam = mix(1.45, 1.185, k); // ~83°→68° Wait footpoint λ0 for L used... I'm using direct r/λ not dipole; fine (open cusp region, non-dipolar). p = dipole-ish: pmag = (r cosλ cosφ, r cosλ sinφ, r sinλ·sign) phi = aPhi0.45; x toward noon: use cosφ with φ small — noon meridian. alpha envelope: env = smoothstep(0.0,0.15,k)smoothstep(1.0,0.75,k); brighten near bottom: env= (0.5+0.5·k). vA = env*uI color uniform mix white→#ff7d9a. sign uniform for hemisphere ±; two systems? one system with attribute aSign. Use one geometry with aSign ±1.

Belts shader as planned: attributes aL, aPhase, aBounce(ω), aMir, aPhi0, aDrift, aSize, and color per system uniform. lam = aMirsin(aBounceuTime + aPhase); phi=aPhi0+aDriftuTime; r=Lcos²lam etc; vA = uI*(0.55+0.45abs(cos(aBounceuTime+aPhase))).

Pulses similar with fewer particles, bigger size, color #bfe6ff.

Aurora: as planned, uTilt, uLat0, uI, uTime, uSign.

Shells: MeshPhysical? No—ShaderMaterial fresnel as planned: vertex: pass world pos & normal (from computeVertexNormals), plus slight displacement: pos += normal*(fbm(pos0.35+uTime0.15)-0.5)0.3 — needs noise in vertex: include NOISE_GLSL in vertex too. frag: fresnel = pow(1−|dot(N,V)|, 2.2); dayBoost = 0.6+0.4·clamp(dot(normalize(vW), vec3(1,0,0)),−1,1)·... use dot(normalize(vWorldPos), sunDir)·0.5+0.5. alpha = (fresnel0.85+0.05)·uOp·(0.75+0.25·shimmer) where shimmer = fbm(vW·0.25+uTime·0.1). col = uColor. Bow shock: same material with own uniforms + streaks: alpha = 0.6+0.4·fbm(vec3(vW.x0.06 - uTime0.5, vW.y0.25, vW.z*0.25)) — flowing arcs downstream.

Plasma sheet: as planned.

Star sky: as planned; also few bright stars with cross? skip.

Grade pass shader:

NOISE_GLSL has hash13 — include.

Now audio engine:

Guard everything with started.

UI wiring straightforward.

Adaptive quality:

fps: frame counter; every 0.5s: fps=frames*2; ema = lerp.

OK. Writing now. One more consideration: THREE r170 Points frustumCulled — dynamic positions: set .frustumCulled = false for wind/CME/belts/etc to avoid disappearing.

Also shells: Mesh with geometry rebuilt — set frustumCulled=false too (positions change).

Composer sizing on resize: composer.setSize + camera aspect.

Let me write chunk files. I'll aim for correctness over brevity but keep it tight.

Also: import map exactly as gossamer (0.170.0).

Chunk 1:

*********************************************************************************************************************************************un.

**********************************************************************************************************e).

************************************************************************************************************************************************************************et.

********************************************************et.

Halfway through time budget. Continue writing chunks 6 (wind + CME), 7 (audio), 8 (UI + loop). Note plasma sheet plane: PlaneGeometry lies in XY plane with normal +Z — that means x along X, y along Y, and displacement in z — that's exactly what I want (sheet in ecliptic-ish plane... wait the plasma sheet should be a slab in the tail around the equatorial plane? Actually the plasma sheet lies near the magnetic equatorial plane in the tail — a horizontal sheet (X-Y plane if Z is "north"). PlaneGeometry is in XY plane already, so plane spans x∈[-22,22], y∈[-3.2,3.2], normal z. Position at x=-28. Good — that's correct: sheet horizontal, rippling in z.

Hmm, but g.rotateX(0) is a no-op leftover; harmless.

One issue in plasma sheet vertex shader: taper uses smoothstep(-6.0, -14.0, p.x) — but p is the local position of the plane (x∈[-22,22] local!), not world. Local x ranges -22..+22. The taper/edges in shader use world coords — wrong. The mesh is at position (-28,0,0), so world x = local x - 28. Fix: compute world pos in vertex shader: use (modelMatrix*vec4(p,1)).xyz for the vXY varying. Let me fix that after writing all chunks with a replace.

Actually simpler: pass world position: vec4 wp = modelMatrix*vec4(p,1.0); vXY = wp.xy; and taper computed from wp.x. I'll patch it.

Also in the vertex shader, displacement p.z computed before world transform — fine since no rotation, only translation.

Let me continue with chunk 6: solar wind CPU system + CME system.

Wait — there's a bug in updateWind: the magnetopause "hard boundary" check. I wrote:

Signed distance to intersection of {r < rmp} ∩ {ρ < Rtail}... The magnetosphere interior = points where r < rmp_shue AND... no wait. The MP surface I built is r = smin(shue, Rtail/sinθ). Interior test: r < min(shue(θ), Rtail/sinθ) → equivalent to r < shue AND r·sinθ < Rtail → r<shue AND ρ<Rtail. So inside iff both d1m = r−shue < 0 and d2m = ρ−tM < 0. Distance-ish = max(d1m, d2m) (negative inside, positive outside). I used Math.min — wrong! Should be max. Let me check the bow shock side too: for BS I used d1 = Math.max(dB, dB2) — correct. For MP I wrote min — bug. Fix to max.

Also in the radial push branch: if(dB > dB2) — that chooses normal by which BS distance is larger, but we want MP-based normal: should be if (r - shueR(ct,r0m,a) > rho - tM) i.e., dM1 > dM2. Simplify: compute dM1 = r - shueR(ct, r0m, a); dM2 = rho - tM; dM = max(dM1,dM2); then normal choice: if(dM1>dM2) radial else cylindrical. Let me patch updateWind accordingly.

Also in the wind update loop: if(x < -60 || x > 62 || r > 78 || r < 1.15) — r computed before position update, slight staleness fine.

Also respawnWindParticle(pos, i, false) then continue — glow set 0, but position already written by respawn — fine. However we also then skip writing pos[o]=x etc — fine.

One more check — smooth01(3.2, 0.25, d1) — my smooth01(a,b,x) with a>b: t=(x−3.2)/(0.25−3.2) → for x=0.25 → t=1; x=3.2 → 0. Works because clamp. Good.

In makeWindSystem, respawnWindParticle uses rand() — deterministic global — fine.

Patch plasma sheet vXY world coords too.

Then chunk 7: audio; chunk 8: UI + main loop.

The plasma sheet fragment shader edges: ex = smoothstep(-5.0,-9.0,x)·smoothstep(-50.0,-38.0,x) — mesh at x=-28, plane width 44 → world x ∈ [-50, -6]. OK.

Wait, g.rotateX(0) no-op line — leave it.

Also the plasma sheet: I positioned mesh at (-6-22, 0, 0) = -28. Good.

Also there's a leftover unused const drift = V*dt; in updateWind — harmless but let me remove it later if convenient. Fine to leave.

Now chunk 7: WebAudio engine.

Chunk 8: UI wiring, quality tiers, resize, keyboard, main loop, HUD updates. Careful details:

• status element updates
• sliders
• buttons
• quality cycle
• adaptive quality (fps EMA)
• snapshot
• main tick: dt = clock.getDelta clamped; simDt = dt·timeFlow (0 if paused); simTime += simDt; update dynamics spring; shells rebuild throttle; updateWind(simDt); updateCME(simDt); shader uniforms uTime=simTime; earth rotation; corona flicker; audio levels; whistler scheduling; auto-CME timer; HUD.
• flare decay, stormFlare decay, cooldown decay.
• controls.autoRotate.
• resize.

Whistler scheduling: probability per second = 0.05+stormEff0.05+flare0.7; each frame: if(rand() < p*dt) whistler(0.6+flare).

Auto-CME: if enabled and !cme.active and cooldown<=0: timer countdown; next in 18-38s.

Status text logic as planned.

Readouts: MP NOSE 9.8 Re · Kp 2.0 · DST −48 nT · TAIL 19 Re.

Stats: 60 FPS · 10.6k PTS — count particles = wind.N + beltN + ... just show wind count + fps + calls.

Snapshot: render composer then toBlob.

Quality tiers: names HIGH/MED/LOW; applyQuality: makeWindSystem(WIND_COUNTS[tier]); renderer.setPixelRatio(min(dpr, [2,1.5,1][tier])); bloom.strength unchanged.

Adaptive: emaFps; every frame update; if ema<42 accumulate time; >4s → tier++ (max 2), apply, flash status, reset timer, autoLock=25s. Manual cycle resets lock too.

Hint fade after 9s.

Init: makeWindSystem(current tier); status.

One catch: AudioSys.init() on keydown — also called before its declaration? No — listeners registered after declaration in chunk 7; fine.

Order issue: chunk 8 references makeWindSystem, updateWind etc — all defined. status element etc.

Let me also ensure earthGroup.rotation.z = 0.20 tilts earth+clouds+atmo-inner — dipole tilt is separate 11° about Y. OK.

Earth spin: earth.rotation.y += simDt0.05; clouds.rotation.y += simDt0.07 (independent → differential).

Corona flicker: corona1.material.rotation += dt0.02; scale pulsate: s=30(1+0.03sin(t1.7)+flare*0.25).

Sun shader uTime = simTime (pauses with sim — good).

skyMat uTime = wall time (twinkle continues when paused — nice).

gradePass uTime = wall time; uFlash decays: = exp(-dt3).

MP/BS mats uTime = simTime; uOp updates: mp: 0.42+storm0.02+flare0.45; color lerp toward #ff9a7a by flare0.5: set via uniform color lerp each frame: mpMat.uniforms.uColor.value.setHex(0x57c8ff).lerp(tmpColor.setHex(0xff9a7a), flare0.55).

Belt uniforms uI: inner 0.8; outer 0.45+eff0.07+flare0.9. cusp uI=0.35+eff0.09+flare1.1. aurora uI = clamp(0.22+eff0.10+flare1.3, 0, 2.2); uLat0=(67-eff1.15-flare3)*DEG clamped ≥ 55°.

plasma uI = 0.5+eff0.05+flare0.6.

pulse uI = 0.9.

Audio levels: hiss = 0.015 + (wind-250)/6500.05 + flare0.04 (clamp 0..0.12); rumble = 0.008+eff0.012+flare0.12 clamp.

r0 spring: acc=(r0Target()-r0)18 - r0V5.5; r0V+=accdt; r0+=r0Vdt. Mark shellDirty if |r0 - lastBuilt| > 0.03 and time since build > 70ms. Store lastR0Built.

stormFlare decay: τ 22s: stormFlare *= exp(-dt/22) when not impacted recently... simple exponential always. flare decay: flare *= exp(-dt/3.2). cooldown: cme.cooldown = max(0, -dt).

Status text: paused → "⏸ PAUSED — simulation frozen" else if flare>0.3 → "⚡ CME IMPACT — sudden commencement!" else if cme.active && !cme.impacted → "☄ CME EN ROUTE — ETA {eta}s" else by effStorm: ≥6.5 "SEVERE STORM — G3+ conditions"; ≥4.5 "ACTIVE — substorm watch"; ≥2.5 "UNSETTLED"; else "QUIET CONDITIONS". Append cooldown hint? keep clean.

Also flash message system for quality change: statusOverride with timer. Keep simple: brief toast by temporarily setting statusMsg and statusTimer; status() function picks override first. I'll implement small flash(msg, sec) helper.

Snapshot filename: magnetosphere-YYYYMMDD-HHMMSS.png.

Keyboard: Space toggle pause (preventDefault to avoid scroll), C launch, A orbit, M mute, S snapshot, Q quality, H help toggle, Esc close help.

Mute button text 🔇/🔊: default starts muted? Audio only starts on gesture; button shows 🔇 initially meaning "sound off until interaction"? Simpler: state.muted=false default; button shows 🔊; but before ctx init, no sound. Button toggles muted and updates icon: muted → 🔇 + .off class. Initial: 🔊 not .off. Hmm original HTML has btnMute with 🔇 initially and no .off. Set initial to 🔊 in JS (since default unmuted). Do in wiring.

Pause button: toggles ⏸/▶ and .off? Use text ⏸ active normal; when paused show ▶ and remove .off? Keep: paused → button text ▶.

Orbit: toggles .off class.

btnAutoCME toggles .off.

helpClose closes; btnHelp opens/toggles.

Write chunk 8 now.

Now validate: extract module JS and run node --check. Also do a quick review pass for issues:

1. composer.setPixelRatio?.(...) — EffectComposer has setPixelRatio method, fine.
2. In chunk 4, I created pts array for all lines then created a full BufferGeometry g that's never added — wasteful but harmless; actually I create g and never use it. Minor garbage. Fine.
3. smooth01(3.2, 0.25, d1) — works with reversed edges as analyzed.
4. In aurora vertex: lam = acos(clamp(cl0*sqrt(r),0,1))*uSign — r=1: cosλ=cl0 → λ=λ0 good; r up to 1.85: cl0·sqrt(1.85) = cos(67°)·1.36 = 0.39·1.36=0.53 → λ=58° → follows field line equatorward. Good.
5. Pulse/belt shaders: attribute position is a zero buffer — used in gl_Position? No, position computed from attributes; but three requires 'position' attribute for BufferGeometry? Points with ShaderMaterial — geometry without position may cause issues in some three versions (computeBoundingSphere on render? Only when frustumCulled true — we set false). I did set a dummy position attribute — good.

Wait — one problem: in the pulse/belt/cusp vertex shaders I don't use position attribute at all, fine.

6. renderer.domElement.toBlob — WebGL canvas without preserveDrawingBuffer: must be called synchronously after render in same task. snapshot() calls composer.render() then toBlob — but toBlob is async; the callback receives blob — the canvas readback happens inside toBlob call... Per spec, toBlob captures the bitmap at call time? Actually toBlob serializes the current canvas contents; without preserveDrawingBuffer, after the compositing step the drawing buffer may be cleared. The pattern "render(); canvas.toBlob(...)" synchronously in the same event handler generally works because the buffer isn't cleared until the next compositing. It's the commonly used approach. OK.

7. In makeAurora: geometry 'position' attribute is zeros and vertex shader uses only aPhi/aH — fine.

8. gl_PointSize could get huge when close; fine.

9. updateCME: uses simTime - cme.t0; when paused, simDt=0 → updateCME not called; fine.

10. In launchCME: uses simTime as t0. Good.

11. cmeHead/aSeed attribute updates: attributes were created with the arrays; launchCME modifies arrays; set needsUpdate — done for aHead/aSeed.

12. In makeWindSystem — 'respawnWindParticle' referenced before definition? makeWindSystem is called at makeWindSystem(WIND_COUNTS[state.quality]) in chunk 8 — after function declarations (function declarations hoisted anyway). respawnWindParticle is a function declaration — hoisted. OK.

13. state.quality starts 0 → HIGH. applyQuality called on init? I call makeWindSystem directly; quality button label default "QUALITY · HIGH" in HTML. OK.

14. AudioSys.whoosh references this.hissBufferFallback — defined. OK.

15. sunLight.target — default target (0,0,0), added to scene. Good.

16. In genEarthDayTexture: smooth01(0.42, 0.10, Math.abs(sl)) reversed edges — my smooth01 handles (a,b,x) generically via division; with a=0.42>b=0.10: t=(x-0.42)/(0.10-0.42) = (0.42-x)/0.32 → x=0.1→1, x=0.42→0. desert=max near equator... wait |sl| = |sin lat| is 0 at equator, 1 at pole. desert = smooth01(0.42,0.10,|sl|)·(1−smooth01(0.45,0.65,moist)) → at equator |sl|≈0 → t=(0.42-0)/0.32=1.31 clamped 1 → desert=1·(moist factor). Hmm that makes equator desert when moist low — intended (desert bands), and green when moist high. OK acceptable — equatorial rainforest where moist, deserts in dry bands.

17. Night texture: ctx.arc with gradient — fine.

18. fbm3j at 1024×512 with 5+3 octaves + second detail — roughly 512k pixels × 8 octave-vnoise × 8 hash ≈ 33M hash3i — each hash3i ~6 ops → ~200M ops ≈ 1-2s. Slightly slow but one-time. Plus night: 30000 tries × up to few fbm evals ≈ trivial. Clouds 512×256×8 ≈ 8M. OK, ~2s init total. Acceptable (status shows "initialising…" — but it's synchronous so the first paint happens after; the HUD is HTML so it shows before JS blocks? The module script runs after parse; textures generated during module eval → ~2s blank-ish with HUD visible. Fine.)

19. One GLSL concern: in shell fragment shader I declared uniform int uBow and set value 0/1 — three sets int uniform from number — fine with if(uBow == 1).

20. In the skybox shader: loop with cell + float(L)*17.0 — L is int loop var — fine.

21. In grade shader: hash13 from NOISE_GLSL prepended — good.

22. Bloom pass with values — fine.

23. renderer.setPixelRatio then composer.setPixelRatio — composer.setSize called at creation with size; EffectComposer constructor uses renderer size & pixel ratio... Actually EffectComposer(renderer) creates render target at renderer size × pixelRatio automatically? It uses renderer.getSize and pixelRatio. setPixelRatio exists on EffectComposer — yes it does (calls setSize internally). OK.

24. Missing: on resize we should also update bloom resolution — composer.setSize handles pass resizing.

25. earthUniformsRef.uSunDirW — used in onBeforeCompile. Since earthMat defined with textures generated eagerly — yes.

26. vNormalW — in fragment of standard material, need to make sure no name conflict — fine.

27. In help HTML: chip list has two chips in one li (inner/outer belt) — fine.

28. elHint.style.opacity=0 after 11s.

29. THREE.MathUtils.clamp used — imported via THREE namespace. Good.

30. In updateWind: after respawn (continue), we skip glow update for that particle — set glow[i]=0 at respawn — good.

31. Potential NaN: ct clamp: Math.max(-0.995, Math.min(1, x/r)). Good. shueR clamps denom ≥0.06.

32. const drift = V*dt; unused — remove? harmless; leave.

33. tick() runs even when tab hidden (rAF stops). fine.

Now extract and node --check. The module script is between <script type="module"> and the final </script>. Extract with awk.

No headless browser, no glslangValidator. I could try npx puppeteer but that downloads Chromium (~150MB) — might be slow but possible. Given time budget (~50% used at checkpoint earlier...), let me think. The checkpoint said timeProgress 0.536 at 50% threshold. So I have maybe ~40% time left. Downloading Chromium + testing might be risky but very valuable for catching GLSL errors.

Alternative: write a small Node script that simulates the GLSL compilation? Not feasible without GL.

Option: use a GLSL parser in pure JS — e.g., glsl-parser npm package? Or use headless-gl? Both need native builds probably.

Let me try a different approach: manually review the GLSL carefully with grep to extract each shader and check for common mistakes:

1. Unbalanced braces
2. Missing semicolons
3. Reserved word usage
4. Integer/float literal issues (e.g., vec3(1.,0.,0.) — valid GLSL)
5. Loop variables

Actually, a faster high-value check: try installing puppeteer with its bundled chromium via npx. Let me first try npm install puppeteer in a temp dir with a timeout — if the network is fast it takes ~30-60s. Then run a headless test that loads the page via a local HTTP server and captures console errors. This is the gold-standard check. Let me try, with a strict timeout, and fall back to manual review if it fails.

***********************************************************************************************************************************************l).

Chrome is downloaded. Now write a test script: serve /tmp/mag via a simple HTTP server (needed for ES modules + import maps; unpkg CDN must be reachable — network works since npm worked). Launch headless chrome with --use-gl=swiftshader / --enable-unsafe-swiftshader for WebGL, load page, wait ~6s, collect console errors/pageerrors, and take a screenshot to verify visuals.

***************************************************************************************************************************************************************************************************************************************ad.

80% of time used! I need to hurry. The chrome binary itself seems missing (only .pak files listed). chrome-headless-shell binary exists. Let me run the test with executablePath pointed at chrome-headless-shell, quickly. If that works, great; then deploy immediately. Actually — time is tight. Priority: deploy the demo + update index FIRST (the deliverable), then run the smoke test if time permits. Actually a broken demo deployed is worse... but syntax is checked. Let me do one fast headless-shell run (2 min max), then deploy regardless.

Let me run with chrome-headless-shell now, with shorter waits (5s initial, 10s after CME).

ENOENT even though the file exists — that means missing shared libraries (loader). Likely missing system deps (libnss3 etc.) and apt install would take too long. Give up on browser test — the JS syntax is validated, and I've carefully reviewed the logic.

DEPLOY NOW — that's the priority. Copy to /space/demos/034-magnetosphere/ and update the main index.

***********************************************************************************************************************er.

Index updated. Final verification: re-run node --check on the deployed file's JS (already validated — same file copied), and verify index.html structure is still valid (quick grep for the card and closing tags). Also double check the deployed file's last lines are complete ( present).

All done:

1. ✅ Recreated the full 034-magnetosphere demo (previous run's /tmp work was lost) — 1447 lines, 66KB self-contained index.html with all features from the previous execution's summary: Shue magnetopause + bow shock shrouds with dynamic compression, solar wind particles with flow deflection, dipole field lines with bouncing pulses, Van Allen belts with GPU bounce+drift, auroral ovals, cusp rain, plasma sheet, CME lifecycle with impact effects, procedural Earth + Sun + starfield, WebAudio (hiss/rumble/whistlers/sfx), full UI (sliders, buttons, help, quality tiers, adaptive perf), post-processing.
2. ✅ Deployed to /space/demos/034-magnetosphere/index.html
3. ✅ Updated /space/demos/index.html with the 034 card
4. ✅ JS syntax validated with node --check on both the working copy and the deployed copy.

One known imperfection: headless browser runtime test wasn't possible (missing chrome shared libs in sandbox). The syntax check passed and the code follows the same patterns as the 33 working demos.

Task complete — call _success.

All done:

1. ✅ Recreated the full 034-magnetosphere demo (previous run's /tmp work was lost) — 1447 lines, 66KB self-contained index.html with all features from the previous execution's summary: Shue magnetopause + bow shock shrouds with dynamic compression, solar wind particles with flow deflection, dipole field lines with bouncing pulses, Van Allen belts with GPU bounce+drift, auroral ovals, cusp rain, plasma sheet, CME lifecycle with impact effects, procedural Earth + Sun + starfield, WebAudio (hiss/rumble/whistlers/sfx), full UI (sliders, buttons, help, quality tiers, adaptive perf), post-processing.
2. ✅ Deployed to /space/demos/034-magnetosphere/index.html
3. ✅ Updated /space/demos/index.html with the 034 card
4. ✅ JS syntax validated with node --check on both the working copy and the deployed copy.

One known imperfection: headless browser runtime test wasn't possible (missing chrome shared libs in sandbox). The syntax check passed and the code follows the same patterns as the 33 working demos.

Task complete — call _success.