Lumen Lab Physics Core Debugging

Let me look at the current state of the demos folder to understand what exists already, then decide what to create. The task says "Wake up and do as you please." — so I have freedom to create a new cool Three.js demo.

Let me first check the current state of the space.

Let me check the current state of the demos folder.

I have a rich history of demos. Let me look at the list of existing demos to avoid duplicating concepts:

1. 001-spinning-cube
2. 002-nebula-galaxy
3. 003-mandelbulb-explorer
4. 004-fluid-dynamics
5. 005-gravity-sandbox
6. 006-event-horizon
7. 007-sonic-reactor
8. 008-void-runner
9. 009-azure-odyssey
10. 010-abyssal-bloom
11. 011-physarum-garden
12. 012-powder-alchemy
13. 013-clockwork-nebula
14. 014-neon-rain
15. 015-aurora-borealis
16. 016-skitter
17. 017-coral-resonance
18. 018-threshold
19. 019-attractorium
20. 020-murmuration
21. 021-terraforge
22. 022-cloudsea
23. 023-frostline
24. 024-koi-pond
25. 025-ferrofluid
26. 026-synchrony
27. 027-cymatics
28. 028-teslasphere
29. 029-pyrosymphony
30. 030-morphogenesis
31. 031-galton-cascade
32. 032-wavefront
33. 033-gossamer
34. 034-magnetosphere
35. 035-cloud-chamber
36. 036-wavefunction
37. 037-epicycle
38. 038-sandpile
39. 039-kinetic-theory

So the next demo would be 040. I need a fresh concept. Let me think about what hasn't been done:

• Fluid dynamics ✓
• Gravity ✓
• Black hole ✓
• Audio ✓ (sonic reactor, pyrosymphony)
• Fractals ✓ (mandelbulb)
• Physarum ✓
• Falling sand ✓ (powder alchemy)
• Clockwork ✓
• Rain ✓
• Aurora ✓
• Creatures/ants ✓ (skitter)
• Coral ✓
• Strange attractors ✓
• Boids/murmuration ✓
• Terrain ✓ (terraforge)
• Clouds ✓ (cloudsea)
• Frost/ice ✓ (frostline)
• Koi pond ✓
• Ferrofluid/magnetism ✓
• Synchronization (fireflies?) ✓
• Cymatics ✓
• Tesla/lightning ✓
• Fire ✓
• Morphogenesis (reaction-diffusion probably) ✓
• Galton board ✓
• Waves ✓ (wavefront)
• Spider webs ✓ (gossamer)
• Magnetosphere ✓
• Cloud chamber (particle physics) ✓
• Quantum wavefunction ✓
• Epicycles/Fourier ✓
• Sandpile (self-organized criticality) ✓
• Kinetic theory / ideal gas ✓

New ideas for 040:

• Reaction-diffusion is likely covered by morphogenesis.
• Optics playground — lens/prism refraction simulation, chromatic dispersion through prisms (Pink Floyd style), with real ray tracing of many light rays through lenses/mirrors. That's a cool physics demo! Interactive optics bench: place lenses, mirrors, prisms; simulate thousands of rays with wavelength-dependent refraction (dispersion), total internal reflection, Fresnel effects. That would be beautiful with bloom.
• Double pendulum chaos — maybe too simple but could do a chaos gallery. But epicycle/attractorium might cover chaos.
• Turing patterns covered.
• Ising model — statistical mechanics; could be cool but visually less wow.
• L-systems / procedural plants — 3D growing trees. Hmm, coral-resonance might be growth-ish.
• Wave interference / ripple tank — partially covered by wavefront probably.
• DLA (diffusion-limited aggregation) — nice crystal growth. Morphogenesis may cover growth patterns.
• Spring-mass cloth / softbody — jelly physics, fun interactive.
• Rubik's cube solver — game.
• Mandelbrot/Julia 2D explorer — mandelbulb was 3D.
• Cellular automata 3D — Game of Life 3D.
• Procedural city — nice.
• Solar system formation — accretion disk.
• Pendulum wave machine — the classic pendulum wave demo in 3D. Beautiful but simple.
• Elastic collisions / billiards chaos.
• Laser ray optics — I really like the optics bench idea: interactive 2D ray optics with prisms, lenses, mirrors, dispersion, glow effects. Very visually appealing with bloom post-processing. It's educational, interactive (drag lenses around), and physically accurate (Snell's law, Fresnel reflectance, wavelength-dependent IOR via Cauchy equation).

Let me check what "threshold" and "wavefront" were, to make sure optics isn't covered. Let me peek at a few index.html descriptions quickly.

Actually, let me look at the demo descriptions in the index page to see the concepts.

Now I know all 39 demos. Number 040 is next. The task says "Wake up and do as you please" — so I should create a new advanced Three.js demo, numbered 040.

Let me pick a concept that hasn't been done. Considering the list:

• Optics: NOT done. Wavefront was a ripple tank (scalar waves, double-slit etc.) but ray optics with prisms/lenses/dispersion is distinct. An interactive optics bench with:
  • Ray tracing through lenses (spherical surfaces), mirrors (flat, concave), prisms (dispersion with Cauchy's equation — splitting white light into spectrum)
  • Draggable/rotatable optical elements
  • White light vs laser sources (mono vs spectrum)
  • Fresnel reflections, total internal reflection
  • Beautiful glow/bloom rendering

That would be gorgeous and educational. "Prism" or "Optics Lab" — call it "040-lumen-lab" or "040-optica" or "040-prismatique". Let me think of a good name: "Lumen Lab — Geometric Optics Bench" or "Chromatic Bench". Maybe "040-lightlab"? I'd go with 040-optics-bench... Actually something more evocative: "040-dispersion" — "Dispersion — a geometric optics laboratory". Or "040-lumen". Let me go with "040-lumen-lab" with title "Lumen Lab" and subtitle about geometric optics.

Alternative ideas:

1. Double pendulum chaos gallery — covered partially by attractorium.
2. Ising model — statistical mechanics, phase transitions, critical slowing. Could be cool: 3D lattice of spins flipping, heatmap. But kinetic-theory just covered stat mech.
3. Turing... done.
4. Optics bench — YES. Distinct, visual, interactive, educational, "wow" with dispersion.

The optics bench will feature:

• 2D ray tracing in a 3D-presented scene (top-down view of a glowing optical table, but rendered with nice 3D perspective, slight tilt, bloom).
• Light sources: laser pointers (single wavelength — red/green/blue/violet), white-light beam (spectral bundle), ray fan/burst emitter.
• Optical elements: convex/concave lenses (spherical), prisms (triangular, with dispersion), flat/concave mirrors, beam splitters, glass slabs, maybe a fiber-optic TIR demo, a water droplet (rainbow! primary/secondary bows!).
• Interactions: drag elements, rotate them (scroll or shift-drag), drag sources.
• Physics: exact Snell refraction with Cauchy dispersion n(λ), Fresnel amplitude coefficients for partial reflection at each interface, total internal reflection, absorption (Beer-Lambert in glass), ray intensity attenuation.
• Rendering: additive line segments with glow via UnrealBloom; spectral colors computed from wavelength (approximate RGB from λ). Batched geometry: one BufferGeometry with vertex colors, draw as LineSegments. Maybe fat lines via LineSegments2 for glow quality... Using plain lines with additive blending + bloom looks great already.
• Extras:
  • Detector screen showing where rays land (light spots accumulation)? Could add "screen" element that shows illuminated points.
  • "Rainbow room": a water droplet that produces the classic double rainbow with Alexander's dark band — that would be a beautiful preset showing off dispersion.
  • "Fiber coil": total internal reflection through a bent light guide.
  • HUD: readout of element under cursor, wavelength, n(λ).
  • Audio: soft glassy tones when rays interact? Maybe a gentle ambient pad + glass "ping" when a ray hits a new element... could be noisy; make subtle: a soft shimmer proportional to light energy hitting detectors. Hmm. Previous demos have WebAudio generative ambience; I can add a light ambient pad with subtle plucks when placing elements, and a hum whose brightness follows total dispersion energy. Keep it subtle.
  • Presets: 1) Prism dispersion (white light → spectrum fan), 2) Double rainbow droplet, 3) Lens bench (convex lens focusing, ray tracing diagram style), 4) Mirror maze / periscope or kaleidoscope, 5) Fiber optic TIR bend, 6) Beam splitter interferometer-ish (Mach-Zehnder layout, though no phase — just split paths), 7) "Black glass" absorption?
  • Free edit: add elements from a palette: convex lens, concave lens, prism, mirror, glass slab, beam splitter, screen; delete element; rotate with wheel or Q/E.
  • Performance: iterative ray tracer up to ~64 bounces, ~2000 rays per frame — CPU is fine. Spatial: only handful of elements, brute force intersection tests OK.

Rendering approach: The scene is a 3D scene viewed mostly top-down at a slight angle (like the ferrofluid/kinetic demos). Elements extruded as 3D shapes (glass with transmission-like fake shader: semi-transparent with fresnel rim; mirrors metallic). Rays as additive glowing lines slightly above the table. Detector screens as thin boxes with a small canvas texture showing accumulated hits? Simpler: screens glow at hit points via a shader that takes hit positions as uniforms... simpler: draw hit "dots" as additive points on the screen plane.

Also a "spectral strip" panel? Might be overkill.

Rainbow droplet: For a circular water droplet with parallel incoming rays (ray fan), compute deviation angles for p=1 (primary, one internal reflection) and p=2 (secondary). With dispersion, rays of different wavelengths emerge at different angles forming rainbow fans. The ray tracer handles this naturally: send a fan of parallel rays across the circle, each ray splits at interfaces (Fresnel). The emergent p=1 rays cluster near the rainbow angle ~42° — a caustic concentration! With additive accumulation the rainbow angle shows up as a bright band. That's physically gorgeous: the "rainbow caustic" emerges naturally from the simulation. To capture faint caustics, accumulate rays over frames in an accumulation buffer? Rays are static if nothing moves, so brightness saturates... With additive lines drawn once per frame, brightness is consistent. The caustic clustering will be visible as brighter lines overlapping. Good enough, especially with bloom.

To make the rainbow pop, I can use an offscreen accumulation: render lines into a low-res float RT additively each frame WITHOUT clearing, then display that texture — persistent glow accumulation. But then moving elements would smear. Could fade the accumulation slowly (multiply 0.98). Hmm, that's a nice "phosphor" look but trails. Attractorium/murmuration did trails. For optics bench, crisp lines are better; caustics still visible via density. I'll do crisp lines but draw with additive blending and a modest alpha so overlaps brighten. To enhance caustics, I can also accumulate a "light field" texture: splat ray segments into a low-res RT each frame (additive), display as a soft glow underlay, cleared each frame. This gives beautiful volumetric-ish glow showing intensity build-up at focal points and caustics — that would look fantastic and costs little (a fullscreen quad with additive splatting of segments as expanded quads? Actually splatting segments into an RT requires drawing the segments as geometry into that RT — easy: same line segments drawn with thicker LineBasicMaterial? Line width is limited to 1px on most platforms. Better: build quads for each segment (2 triangles per segment) — with ~50k segments that's 100k tris per frame, fine on GPU. Hmm, but we rebuild geometry each frame anyway.

Simpler and proven: Draw rays as camera-facing ribbon quads (like teslasphere did) — the scene is essentially 2D (top-down), so "ribbons" are just quads lying flat on the table plane (or slightly above), no camera-facing math needed! Each ray segment = a quad with width w, alpha ∝ intensity, additive blending. Plus bloom. Overlaps at foci brighten naturally. This is straightforward and fast: positions array built in JS each frame; use DynamicDrawUsage. Width tapering by intensity.

That's the plan:

• Rays: flat quads on the table, additive, vertex colors (spectral), alpha = intensity; with soft edge falloff in fragment shader (custom ShaderMaterial) so lines have glow profile (bright core, soft falloff).
• Bloom on top (UnrealBloomPass), plus grade pass (vignette/grain/chromatic) consistent with other demos.

Elements (2D shapes on the table, extruded ~1 unit tall for 3D look):

1. Convex lens (biconvex): intersection of two circles. Param: radius r (aperture), curvature R, thickness.
2. Concave lens (biconcave).
3. Prism: equilateral or adjustable triangle.
4. Glass slab (rectangle with rounded ends?) — rectangle.
5. Mirror: line segment (thin box), reflective on both sides or one side; make double-sided.
6. Concave mirror: arc of a circle (reflective inside) — cool for focusing.
7. Beam splitter: 50/50 plate at 45° typically; implement as glass slab with fixed 50% reflectance coating on one face? Simpler: implement as a "mirror" with transmittance 0.5/reflectance 0.5 and no refraction (thin film). Good enough for Mach-Zehnder.
8. Screen: a wall segment that absorbs rays and records hit positions → displays a bright spot (and maybe a spectrum when white light disperses onto it). Implement hit glow as additive point sprites at hit location, plus optional per-screen strip canvas. Simple: small glowing dot quad at each hit point on the screen surface; overlapping dots → bright spots. For the prism → screen preset, the spectrum will paint a rainbow band on the screen.

Sources:

1. Laser (monochromatic; selectable color/wavelength: 650 red, 532 green, 450 blue, 405 violet).
2. White beam (bundle of N wavelengths 400–700, e.g., 12–24 discrete λs, narrow beam, parallel rays — maybe 3–5 parallel rays per λ for slight thickness).
3. Ray fan (point source emitting a fan of rays across an angular spread — classic textbook diagrams).
4. Beam (parallel rays across aperture — for droplet rainbow and slab).

Physics core:

• Ray as {origin, dir, λ (nm), intensity, depth}.
• For each ray: find nearest intersection among all elements (analytic: circle arcs, line segments; shape = CSG combination of primitives for lenses: biconvex = inside both circles; entry/exit determined by inside test).
• At each interface with glass (n2(λ) from Cauchy: n(λ) = A + B/λ² (λ in μm), e.g., BK7: A=1.5046, B=0.00420 μm², or denser flint A=1.72, B=0.0134 — use crown ~1.52 and flint ~1.62 options per element? Keep single "glass" type with slider for dispersion strength maybe. Simpler: each glass element gets material index preset: BK7 crown (low dispersion), SF10 flint (high dispersion), water (for droplet: n=1.333, low dispersion with proper dn/dλ). Cauchy coefficients:
  • BK7: n = 1.5046 + 0.00420/λ²(μm)
  • SF10: n ≈ 1.7280 + 0.01342/λ² — let me get decent numbers: SF10 at 656nm n=1.708... Using Cauchy n = A + B/λ² + C/λ⁴. I'll just use two-term approximations that roughly match: BK7: A=1.496, B=0.0106? Hmm let me just compute: BK7: n_d=1.5168 @588nm, n_F=1.5224 @486, n_C=1.5143 @656. Fit A + B/λ²: n_C = A + B/(0.656²) = A + B/0.4303 = 1.5143 n_F = A + B/(0.486²) = A + B/0.2362 = 1.5224 Subtract: B(1/0.2362 − 1/0.4303) = 0.0081 → B(4.2338 − 2.3240) = 0.0081 → B = 0.00424, A = 1.5143 − 0.00424/0.4303 = 1.5143 − 0.00985 = 1.5045. So BK7: A=1.5045, B=0.00424 (λ in μm). n(400nm)=1.5045+0.00424/0.16=1.5310. Good.
  • SF10 flint: n_C=1.72028 @656? Actually SF10 n_d=1.72828. n_C(656)=1.7203, n_F(486)=1.7464? Approx: n_F−n_C ≈ 0.029 (SF10 Abbe ~28.4, V=(n_d−1)/(n_F−n_C) → n_F−n_C = (1.72828−1)/28.41 = 0.02563). Fit: B = 0.02563/1.9098 = 0.01342, A = 1.7203 − 0.01342/0.4303 = 1.7203 − 0.0312 = 1.6891. So SF10: A=1.6891, B=0.01342. n(400) = 1.6891+0.0839=1.773.
  • Water: n_d=1.333, V≈55.7 → n_F−n_C = 0.333/55.7=0.00598. B=0.00598/1.9098=0.00313, A=1.3310−0.00727... n_C=1.3311: A = 1.3311 − 0.00313/0.4303 = 1.3311−0.00728=1.3238. Water: A=1.3238, B=0.00313.
• Fresnel (unpolarized): Rs = ((n1cosθi − n2cosθt)/(n1cosθi + n2cosθt))², Rp similarly, R = (Rs+Rp)/2. Spawn reflected ray with intensity·R and transmitted with ·(1−R), if intensity > threshold (e.g., 0.005) and depth < maxDepth.
• Mirrors: reflect with 0.96 reflectivity (silver).
• Beer absorption in glass: multiply by exp(−k·pathLength), small k.
• Screens: terminate, record hit.

Sources emit rays each frame; trace iteratively (stack/queue) — collect segments into arrays. Cap total segments.

Interactions:

• Drag elements to move (pointer raycast onto table plane; hit test element shapes in 2D).
• Selected element outline glow; rotate with mouse wheel over element or Q/E keys; delete with Del/right-click? Keep: wheel rotates hovered element, shift slows. Double-click removes element? Provide toolbar to add elements.
• Drag sources similarly; wheel rotates source direction.
• Toolbar (DOM): buttons to add Convex Lens, Concave Lens, Prism, Slab, Mirror, Curved Mirror, Splitter, Screen, Droplet; source type buttons: Laser λ cycles color, White beam, Fan. Clear button. Preset buttons (1–7). Play/pause? Rays are instant; maybe animate nothing except subtle shimmering? To make scene alive: slight animated jitter? No — physical optics is static; but we can animate: sources could pulse gently (intensity breathing) — yes subtle. Also "wavefront" dashes? Add optional "wavefront ticks" — moving dash pulses along rays to convey propagation (animated in shader via uniform time, distance attribute). That looks great: segments carry a dist attribute (distance from source); shader draws moving pulse marks (small dashes traveling). Toggleable.
• GUI: lil-gui? Previous demos seem to use custom HUDs; I'll make a clean custom HUD with DOM controls: element palette, source controls, presets, toggles (wavefront pulses, intensity, Fresnel on/off maybe), readouts (hovered element info: n(λ) at 589nm, focal length estimate, deviation angle for prism).
• Audio: generative ambient pad + soft glass pings when rays strike elements (rate-limited, pitch by wavelength?), a shimmer tied to light energy. Keep subtle; toggle with A, starts muted until user gesture (standard).

Presets:

1. Prism / Dark Side — white beam through flint prism onto a screen: spectrum fan. Classic.
2. Double Rainbow — water droplet (circle) + broad parallel white beam: primary & secondary rainbow caustics, Alexander's dark band.
3. Lens Bench — ray fan through biconvex lens showing focal point; maybe object arrow? Keep: fan + parallel beam preset toggle; show focal point caustic.
4. Telescope — two lenses (Keplerian afocal): parallel beam in, narrower parallel out. Or microscope? Kepler: nice.
5. Mirror Maze / Kaleidoscope — two mirrors at angle with a fan: multiple reflections. Or "periscope". Maybe "concave mirror focusing" showing spherical aberration + caustic (bright curve — looks gorgeous). Choose concave mirror with parallel beam → caustic curve.
6. Fiber Bend — curved light guide? A curved rod is hard with CSG circles... Actually a "bent fiber" can be approximated by an annulus sector (between two concentric circles) — glass between radius r1 and r2 for a 90° arc, plus straight entry/exit sections. Ray enters, TIRs around the bend if radius generous. Implement shape as intersection/union of primitives: my shape system is "a set of analytic boundary primitives + inside test". Let me design shape model:

Shape model: each element defines inside(p) boolean and a list of boundary primitives for intersection: segments (lines) and arcs (circles). For intersection: compute ray-circle and ray-line-segment intersections, keep those where the hit point is on the element boundary (i.e., crossing inside/outside). Simplest robust approach: gather all candidate hits from all primitives of the element; for each candidate t>eps, test inside just before (t−δ) and just after (t+δ); boundary crossing if differs; the nearest valid crossing is the hit. Normal from the primitive (radial for circle, perpendicular for line). This generic approach handles lens (2 circle arcs), prism (3 lines), slab (4 lines), droplet (1 circle), fiber (2 arcs + 2 lines, with inside = within annulus sector... plus entry/exit caps). Mirrors: line segment (or arc for concave) with mirror flag — reflect, no refraction. Screen: line segment absorbing. Beam splitter: line with 50/50 split.

Fresnel: compute R per event; if R·I < threshold skip reflected spawn to save budget. With white beam: 16 λs × few rays... Each reflection split doubles rays; depth cap 16, intensity cutoff 0.004.

Rainbow brightness: the beam across droplet: use, say, 24 parallel rays × 12 wavelengths = 288 rays, each splits a few times → few thousand segments. OK.

Perf: elements ≤ ~20, rays few thousand, each tests all elements (~20 primitives each → 100 primitives). 3000 rays × 16 bounces × 100 primitives = 4.8M intersection tests worst case per frame in JS — too much? Intersection tests are cheap arithmetic; 4.8M might be ~30–60ms. Need optimization: per-element AABB/bounding circle test first (cheap reject). Bounding circle test: ray-circle quick. Most elements rejected immediately. Fine: typically ray hits within a small region; bounding-sphere rejects most. Also adaptive: fewer rays on low quality.

Alternatively trace at interaction changes only and cache? But animated pulses need only shader time; segments static when scene static. Optimization: only re-trace when scene dirty (element moved, source changed) OR every frame cheap enough. Better: re-trace on change; geometry persists; shader animates pulses. Also subtle source breathing would require re-trace... skip breathing, or modulate material uniform intensity instead of re-tracing.

Plan: dirty-flag re-trace + buffer reuse. Interaction (drag) → dirty each frame while dragging, fine.

Also mouse hover "virtual ray preview"? Extra; skip.

HUD readouts: total segments traced, rays/sec when active; element info on hover.

Wavefront pulses: in shader, attribute aDist (cumulative distance along ray from source) — for split rays, accumulate parent dist. vDist varying; fragment: alpha *= 0.75 + 0.25·pulse(sin( (vDist − time·c)·k ))? Or traveling wavefront dashes: smoothstep bands. Toggle "Photon pulses". Nice.

Also draw small glow dots at interaction points (vertices where ray hits surfaces): additive points with size attenuation — sparkle where light strikes glass. Adds life. Points geometry built per trace.

Elements rendering (3D): extruded shapes with custom glass shader: transparent, fresnel rim glow, slight edge emissive; outline top rim with bright line to read shape clearly. Use THREE.Mesh with MeshPhysicalMaterial (transmission won't work well without env... RoomEnvironment could work). Previous demos used RoomEnvironment (teslasphere). Glass: MeshPhysicalMaterial({transmission: 0.9, roughness: 0.05, thickness: 1, ior: 1.5}) with scene.environment = RoomEnvironment — gives believable glass. Plus a glowing rim line (THREE.Line loop) additive. That'll look classy. Mirrors: metallic silver box, slight roughness. Screens: matte white bar with glow at hit points.

Table: dark reflective disc/rounded-rect optical bench with subtle grid ("breadboard" holes pattern shader), vignette.

Camera: OrbitControls, default tilted top-down (polar ~55°), pan/zoom enabled; limit polar angle to avoid going under table.

Audio: generative pad (2 detuned saws through lowpass + slow LFO), occasional glass "ting" (sine+harmonic, exponential decay) when segments count changes a lot or when user places element; hover tick. Light-energy-driven shimmer: noise through bandpass with gain ∝ total light throughput. Toggle A; off by default until first gesture? Standard: create AudioContext on first pointerdown; start pad quietly.

Snapshot (P key): renderer.domElement.toBlob → download PNG. Need preserveDrawingBuffer or render-on-demand capture: render then immediately toDataURL in same frame — do renderer.render() then capture in same tick (works without preserveDrawingBuffer if done synchronously after render).

Quality tiers: pixelRatio scaling, ray count scaling (white beam ray counts), auto-degrade on low FPS.

Keyboard shortcuts: 1–7 presets, A audio, S snapshot, W wavefront pulses toggle, H help overlay, Del remove hovered, Q/E rotate hovered, G quality cycle, Space pause pulses? etc.

Preset list final (7):

1. Dark Side (prism + white beam + screen)
2. Rainbow Drop (water droplet + wide white parallel beam) — show primary/secondary bows; annotate angle readout? Maybe draw faint protractor arcs at 42°/51°? Could add togglable "rainbow angle guides". Nice educational touch: dashed circles labeled ~42° & ~51°.
3. Lens Bench (fan + biconvex lens + parallel beam toggle?) — fan from point at 2f → focuses. Add second lens for telescope? Keep separate preset.
4. Refractor (Keplerian telescope: objective long-f + eyepiece short-f, parallel beam)
5. Mirror Cauldron (concave mirror + parallel beam → caustic; plus a fan)
6. Fiber Bend (annular light guide with TIR + laser)
7. Interferometer (Mach–Zehnder: 2 beam splitters + 2 mirrors + laser, showing two output ports) — note: no phase/wave interference in ray model; label honestly: "paths & energy split 50/50 — ray optics can't show fringes". Still a cool layout demo.

Add/delete workflow: toolbar buttons append element at a free spot near center with slight offset; user drags into place. Delete: hover + X/Del or drag onto trash zone? Keep X key + a small ✕ button when hovered (DOM chip near cursor?) — simpler: press X to remove hovered element. Also Right-click drag rotates hovered element (nice!) — rotate around its center following pointer angle. Wheel over element = fine rotate. Wheel over source = rotate beam.

Implementation detail — shape definitions. I'll write each element as an object:

Methods (functions in module): buildPrimitives(el) → array of primitives in world space:

• {type:'circle', c:Vec2, r} (arc restrictions? For lenses the circles extend beyond the lens body; the generic inside/outside crossing test handles it: candidate intersections on full circle are filtered by testing inside(p−ε·d) vs inside(p+ε·d) — only true boundary crossings count. So arcs don't need explicit angular ranges! The inside test does CSG.)
• {type:'line', a:Vec2, b:Vec2} similarly candidates filtered by segment bounds + crossing test. inside(p): per kind:
• lens biconvex: |p−c1|<R1 && |p−c2|<R2 (two circle centers offset along axis) — circles radius R, centers at ±(R − t/2 + ...)? For biconvex with thickness t and radius R: centers at ±(R − t/2)? Let's define: lens half-thickness h = t/2; surface sag s = R − sqrt(R² − a²) where a = aperture radius; centers at ∓(R − h) along axis? Standard: center of left sphere at x = −(R − h)?? Let me set: left sphere center at (−d, 0), right sphere center at (+d, 0), d = R − h. Lens region = intersection of two disks. Aperture half-height a = sqrt(R² − d²) = sqrt(R² − (R−h)²) = sqrt(2Rh − h²). Given desired aperture a and thickness t (h=t/2): R = (a² + h²)/(2h). Compute R from a & h. Concave: region = disk of radius a (aperture circle) minus intersection... biconcave: |p| < a AND |p−c1| > R AND |p−c2| > R with d = R − h where h = edge half-thickness minus center? For biconcave define center thickness t_c small, edge thickness larger. Let: d = R + h_c where h_c = half center thickness; region: |p_x| < extent? Biconcave boundary consists of two arcs; the "rim" at |y| = a. Inside test: |p − (−d,0)| > R && |p − (d,0)| > R && |p| < rimR? The rim connects the two arcs at |y|=a: region = (plane |x| < x_rim) minus two disks, where x_rim = sqrt(R² − a²) − d? Hmm: arcs intersect at x = 0? For biconcave, the two sphere surfaces intersect on the y-axis at y=±a where a² + d² = R² → d = sqrt(R² − a²). Given R and aperture a: d = sqrt(R²−a²); center half-thickness h_c = d − (R − 0)... at x=0, surface x positions: sphere centered at (−d,0) radius R crosses x-axis at x = −d + R = R − d >0. So center half-thickness h_c = R − d = R − sqrt(R² − a²) (sag). Wait that means center thickness = 2(R − sqrt(R²−a²)) which grows with R... that's the sag of each surface; for concave the CENTER is thin: 2·h_c should be small → R slightly > sqrt... For concave: surface at center x=0: x_surf = −d + R (left sphere). h_c = R − d. Choose R big → d=sqrt(R²−a²) ≈ R − a²/2R → h_c ≈ a²/2R → small. Good: concave lens: choose R (large for weak lens) and a; region: |p−(−d,0)|>R && |p−(d,0)|>R && |x| < ... the arcs bound left/right but top/bottom open! Need rim closure: region additionally |y| < a. The inside test: |y|<a && outside both spheres... but then the top/bottom boundaries (|y|=a lines) would show as glass-air interfaces — rays could pass through the rim. Textbook lenses don't have rays through rims usually; acceptable: treat rim as absorbing (or just let it refract — fine, it's glass edge). I'll include the |y|<a line boundaries as primitive lines; crossing test handles them. OK.
• prism: convex polygon (3 verts) — inside = point-in-polygon (half-plane tests). Verts from radius r, rotated. Equilateral.
• slab: rotated rect (w,h) — 4 lines, inside = |x'|<w/2 && |y'|<h/2 (local coords).
• droplet: |p−c|<r.
• fiber: annulus sector: r1<|p−c|<r2 and angular range. Entry/exit radial edges as lines (they'll refract — fine, they're glass edges). inside: (r1<d<r2) && angleWithin.
• mirror: line segment, no inside. Represent as element with boundary list only, kind 'mirror' → reflect.
• cmirror: circle arc (radius R, angular half-span θ). Reflection side: inner side (concave). Need to reflect for rays hitting from inside the arc region; use normal radial; reflect regardless of side? A real concave mirror reflects from concave side; from behind it'd be the back of the coating — still reflects (or absorb). Reflect both sides: fine.
• splitter: line segment: 50/50: spawn reflected and transmitted, both intensity·0.5, no bending (thin film approx). Maybe slight tint.
• screen: line segment absorbing + record hit point & wavelength (accumulate brightness per λ for optional spectrum display).

Generic tracer:

Medium tracking: a ray inside glass must exit. Track current element containing the ray (or null). When ray starts inside an element? Only if source placed inside — clamp: treat source in air; if inside glass, treat medium as that element (n2). Handle robustly: at hit, determine n1 (medium on incident side) via inside test at p−ε·d across elements; n2 at p+ε·d. Then if incident element == target element... Standard approach: determine containing element before and after by sampling points p±εn? Use directional sampling: elemBefore = element containing p − d·1e-4; elemAfter = containing p + d·1e-4. n1 = n(elemBefore or air), n2 = n(elemAfter or air). If elemBefore === elemAfter → crossing test would have filtered this out (not a crossing). This handles nested/adjacent glass too.

Reflect/refract with Fresnel; if n1>n2 and TIR → reflect only. Push children with dist + t, depth+1.

Mirrors/screens/splitters: treat as boundaries with priority at their t if nearest.

Epsilon care to avoid self-intersection loops: offset child origins by ±ε along dir; also ignore hits with t < 1e-5.

Intensity cutoff 0.004 (of initial), depth ≤ 24, segment cap ~60000 per frame? For buffer sizing, preallocate maxSegments (e.g., 65536 quads? too big). Preallocate 32768 quads = 131072 verts... position buffer 131072×3 floats = 1.5MB fine. Usually far fewer.

Also element "screen" hit recording: store array of {pos along screen, λ, I} → draw as additive points on screen top edge + optionally a mini spectrum strip? Just glow dots.

Now, visual details for wow:

• Table: large rounded-square "optical breadboard", dark navy with subtle grid of holes (shader: dots pattern), metallic edge rim, four small legs? Simple.
• Backdrop: fog, soft radial gradient, floating dust motes (points drifting) — consistent with other demos.
• Post: UnrealBloomPass (strength ~0.9, radius 0.6, threshold 0.55?), custom grade pass (vignette + grain + slight chromatic aberration) — copy pattern from previous demos.
• Rays shader: flat quads (2 tris) per segment with attributes: aT (0..1 across width) for soft edges, aDist, color, alpha. Fragment: alpha ×= smooth core profile (cos falloff), pulses option, slight dithering. Additive blending, depthWrite off. Place at y = table + 0.02 (glass height ~1.2 extruded, rays at mid-height 0.6? To read clearly, put rays slightly above table and glass extruded to ~0.9; rays at 0.5 passing through glass visually. Top-down tilt view: rays will appear "inside" glass — good.
• Interaction-point sparkle points: at each surface hit, small dot, additive, size ∝ intensity.
• Source gizmos: little 3D devices: laser = small metal cylinder with glowing tip; white beam = prism-ish box with white tip; fan = small arc emitter. Build from boxes/cylinders + emissive tip. Rotate with source angle.
• Element hover highlight: rim line brightens; cursor pointer.

HUD: top-left title & description; top-right buttons (audio, snapshot, help, quality); left-bottom: element palette buttons; right-bottom: stats (segments, hovered info); bottom-center: preset chips 1–7. Help overlay listing shortcuts. Keep consistent styling with previous demos (dark glassmorphism).

File: single index.html (~2000 lines with shaders inline). Previous demos ~ similar size. Let me be careful to write clean, complete, working code — it's long; I'll write it in chunks to a file then syntax-check the JS by extracting script.

Risk areas:

1. Ray tracer edge cases (epsilon loops) — mitigate with depth/intensity caps and careful crossing tests.
2. Shader compile errors — test by... can't run WebGL headless easily. Could do a node-based syntax check of GLSL? I'll be careful; maybe run a minimal check with glslangValidator if available? Probably not installed. I'll try installing? No network guarantee... We have internet (import_url tool). Could npm install headless-gl — heavy native build, risky. I'll rely on careful shader writing. The physics core I CAN test in node (pure JS math): write the tracer as a separate module file optics-core.mjs imported by the HTML? Self-contained single HTML preferred... I can develop the tracer as an ES module in the HTML's script, but ALSO extract to a temp file for node testing (like previous run did with gassim.mjs). Plan: write full index.html with a <script type="module"> that imports three from CDN via import map; the physics functions defined inline but written so I can extract them via sed for node testing (they're pure JS, no THREE dependency — use plain {x,y} objects or my own tiny vec helpers in that section). I'll structure: /* ===== OPTICS CORE (pure JS) ===== */ ... /* ===== END CORE ===== */ markers, extract with sed, run tests in node: test refraction angle through slab (no deviation shift, parallel displacement), prism deviation matches theory, TIR, droplet rainbow angle ~42°: compute average exit angle for p=1 rays weighted by intensity near caustic... simpler: check minimum deviation angle for water ~ 180+2·42? Actually measure: take emergent rays that had exactly 1 internal reflection (tag rays with internalReflection count!), compute deviation vs impact parameter, find caustic angle ≈ 137.97° scattering? For rainbows: deviation D(i) = 2(i − r) + (180 − 2r) for p=1; minimum D ≈ 137.97° for water → rainbow angle 180 − 137.97 = 42.03°. Test: numerical min deviation ≈ 138°.

Let me also verify: lens focal point: parallel rays through biconvex lens converge near f = R/(2(n−1)) for thin lens with equal radii: 1/f = (n−1)(2/R) → f = R/(2(n−1)). Check numerically within a few % (thick lens correction fine).

3. Performance — bounding circles + dirty-flag.

Alright, naming: 040-lumen-lab? The demos use kebab names. Title: "Lumen Lab". Description: geometric optics bench with real Snell/Fresnel/dispersion physics, rainbow caustics, etc.

Alternatively "040-refraction" — nah. "040-lumen-lab" good.

Let me check how previous demos structured their index.html to stay consistent (import map version, grade pass pattern). Let me peek at 039 briefly for conventions (CDN URLs etc.).

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

Good. I have all the conventions. Now let me design and write demo 040-lumen-lab — a geometric optics laboratory.

I'll write the file in parts due to its size. Let me structure:

1. HTML head + CSS (panels, toolbar, help overlay).
2. Import map.
3. Module script:
   • Imports.
   • OPTICS CORE (pure JS, marked with //=OPTICS-BEGIN= / //=OPTICS-END= for node extraction & testing):
     • wavelength→RGB conversion
     • materials (Cauchy)
     • shape definitions & intersection
     • tracer
   • Scene setup: renderer, camera, controls, environment.
   • Table, dust, backdrop.
   • Element meshes (glass, mirrors, screens) + rim lines.
   • Ray rendering: ribbon quads + sparkle points + shader with pulses.
   • Sources + gizmos.
   • Presets.
   • UI: toolbar, stats, help, hover info.
   • Audio engine.
   • Post-processing: bloom + grade.
   • Main loop with dirty-flag tracing.
   • Resize, quality tiers, snapshot, shortcuts, touch.

Let me carefully write the physics core first, test it in Node, then write the whole HTML.

Core design (plain JS, no THREE):

Check: bk7 @ 400: 1.5045 + 0.00424/0.16 = 1.5310 ✓. @700: 1.5045+0.00865=1.5132 ✓ (real 1.5131).

sf10 @ 486: 1.6891 + 0.01342/0.2362 = 1.6891+0.0568=1.7459 (real 1.7463 ✓). @656: 1.6891+0.0312=1.7203 (real 1.7203 ✓).

water @ 400: 1.3238+0.0196=1.3434 (real 1.3433 ✓), @700: 1.3302 (real 1.3305 ✓).

acrylic (PMMA): n_d=1.4914, V=58. n_F−n_C=0.4914/58=0.00847; B=0.00847/1.9098=0.004435; n_C=1.4886: A=1.4886−0.004435/0.4303=1.4886−0.01031=1.4783. So acrylic A=1.4783, B=0.00444.

Element kinds and inside(x, y) in local frame. I'll keep element state: {id, kind, x, y, angle, mat, params...}. For intersection testing in world space, I'll transform the ray into the element's local frame instead of transforming primitives — much easier! For each element: local ray origin/direction (rotate by −angle around element center). Then all primitive tests are in local coords; hit point transformed back to world; normal too. Bounding test in local frame as well (bounding circle at origin of local frame with radius rb).

Primitives per kind (local coords):

• 'lens' (biconvex): circles at (±d, 0) radius R. inside: dist to both < R. rb = d + R... tighter: aperture a. Bounding radius: sqrt((h)²+a²) ~ use d+R for safety? d+R could be much bigger than actual lens (R big). Compute rb = Math.hypot(h, a) + small where h = half-thickness = R − d... biconvex: at x=0 surfaces at x=±(R−d)... define d = R − h → surface at x=0? Let me parametrize by aperture a and half-thickness h: R = (a² + h²)/(2h) ≥ ... d = R − h. Surface at center: x = ±(R − d) = ±h ✓. At rim |y| = a: |p−c|² = h? Point (0, a): dist² to (−d,0): d² + a² = (R−h)² + a²; R² = ((a²+h²)/2h)²; check: (R−h)² + a² = R² − 2Rh + h² + a²; 2Rh = a² + h² → = R² ✓. So rim at (0, ±a) where the two arcs meet. Lens region = intersection of disks. Bounding circle radius: hypot(h, a)? Farthest point of region from origin: (0, ±a) → |p| = a; or (±h, 0) → h. rb = max(a, h) basically; use hypot(a,h)? points of region: any point with |x|≤h, |y|≤a·(stuff) — max radius = hypot(h, a)? Point (h, 0): |p|=h. Point (0,a): a. A corner estimate hypot(h,a) is a safe bound (region ⊆ [−h,h]×[−a,a]). rb = hypot(h, a).
  • Focal length thin approx: f = R / (2(n−1)).
• 'lensc' (biconcave): circles at (±d,0) radius R with d = sqrt(R² − a²) (parametrize by R and a directly; h_c = R − d). inside: outside both disks && |y| < a && |x| < x_rim where x_rim = ... the arcs: left sphere's surface spans x from −d−R to −d+R... For biconcave, region at |y|<a lies between the two surfaces: left surface x_L(y) = −d + sqrt(R² − y²) (positive-ish), right x_R(y) = d − sqrt(R² − y²). inside ⟺ x_L(y) < x < x_R(y) ⟺ (x + d)² + y² > R² && (x − d)² + y² > R²... wait outside the left disk means dist(p, (−d,0)) > R, i.e., x > x_L or x < −d − sqrt(...). Combined with right constraint gives the lens. Plus |y| ≤ a to close rim. So inside: dist² to (−d,0) > R² && dist² to (d,0) > R² && |y| < a. At |y| slightly < a, x ranges between surfaces ✓. Rim lines at y=±a from x_L to x_R — as line primitives; crossing test handles.
  • Parametrize: aperture a, edge half-thickness h_e: h_c = h_e − sag? Choose: given a and center half-thickness h_c: need R and d with R − d = h_c and R² = d² + a² → (d + h_c)² = d² + a² → 2dh_c + h_c² = a² → d = (a² − h_c²)/(2h_c), R = d + h_c. Valid for a > h_c. E.g. a=2, h_c=0.25 → d = (4−0.0625)/0.5 = 7.875, R = 8.125. ✓ f = −R/(2(n−1)).
• 'prism': equilateral triangle, circumradius r (center at centroid). verts at angles 90°, 210°, 330° + rotation. inside: 3 half-plane tests. rb = r.
• 'slab': rect w × h centered. inside |x|<w/2 && |y|<h/2. rb = hypot(w,h)/2.
• 'drop': circle radius r. rb = r.
• 'fiber': annulus arc: center at local origin, r1<r<r2, angle from −span/2 to +span/2 (span e.g. 100°), plus two radial edge lines closing the annulus at ends. inside: r1<|p|<r2 && ang in range. rb = r2. Hmm — bounding circle rejects nothing (origin-centered) but fine.
• 'mirror': line from (−L/2, 0) to (L/2, 0) local. Boundary-only. rb = L/2.
• 'cmirror': arc radius R, half-angle φ (e.g., 40°), circle center at local origin, arc on +x side: points R·(cosθ, sinθ) for θ ∈ [−φ, φ]. Concave side faces +x (toward incoming light from +x? The mirror dish opens toward +x). Reflection: any hit reflects. rb = R.
• 'splitter': line segment length L: reflect 50%, transmit 50% (no bending). rb = L/2.
• 'screen': line segment length L: absorbs; record. rb = L/2.

Intersection approach (per ray, world frame):

The crossing test uses local δ = 1e-4 (units ~ table is ~60 wide, elements ~2-6). Use δ = 1e-3.

One concern: a ray exactly at a rim joint could double-count; negligible visually.

After nearest hit found (world): determine n1 = ior of medium at p − dir·δ_w (find containing element among glass elements), n2 similarly at p + dir·δ_w. Note: if hit element is mirror/cmirror → reflect (R=0.965). If splitter → spawn both (0.5/0.5) with slight tint for reflection? Keep white. If screen → record & terminate.

Else glass boundary: n1/n2 from sampling (handles entering & exiting). Fresnel unpolarized. Schlick? No — full Fresnel.

cosI = −dot(d, n) with n chosen to oppose d (flip normal if dot > 0). eta = n1/n2. sinT² = eta²(1−cosI²). TIR if > 1. R via Fresnel. Spawn reflected if R·I > cutoff; transmitted (1−R)·I if > cutoff. Absorption: transmitted inside glass gets absorb per unit length applied over its travel distance when the NEXT hit happens... simpler: apply Beer factor at segment completion if the segment medium is glass: I_out = I·exp(−k·t). Apply when pushing the child ray? We know the length only after tracing the child. Alternative: apply absorption when computing segment color alpha (at render build time we know each segment's length & medium). Do that: segment stores I (start intensity) and medium k; rendered alpha = I·(1−exp(−k·len))·something... simpler: alpha = I·exp(−k·len/2). Fine.

Ray bookkeeping: each queued ray: {ox, oy, dx, dy, lam, I, dist, depth, medK (absorb of current medium), intRefs (count of internal reflections — for rainbow tagging)}. When a ray reflects internally (glass→air boundary but stays in glass), increment intRefs (passed to child). Segments pushed to output array: {x1,y1,x2,y2, lam, I, distStart, distEnd, intRefs}.

Sources:

• laser: single ray, λ chosen (650/532/450/405), maybe 1 ray — visually thin. Draw 1.
• white: Nλ wavelengths × M parallel rays across aperture w, all same dir.
• fan: point source, N rays across angular spread φ, single λ or white-ish (use 550nm? or RGB mix?). Fan with white: too many rays; fan uses single λ (green 532 default? or selectable). Let's allow fan to use laser λ too.
• beam: parallel rays, single λ or white.

I'll unify: source = {kind: 'laser'|'white'|'fan', x, y, angle, lam, spread, width, nRays}. Emit list of primary rays.

Perf target: total segments ≲ 20k. white: 12 λ × 5 rays = 60 primaries; each may split ~10-30× in prism+screen... fine. Rainbow: 20 rays × 12 λ = 240 primaries; droplet splits: each gives reflected + refracted; refracted gives internal reflect (p=1) + exit; p=1 gives internal reflect (p=2) + exit; etc. depth cap ~12; cutoff 0.004. Estimate ~240 × 15 = 3600 segments ✓.

Trace-on-dirty: maintain traceDirty. While dragging, set dirty each frame. Otherwise trace once. Pulses animate via shader time only.

Wavefront pulses: In fragment shader: pulse = smoothstep(0.5, 1.0, sin((vDist − uTime·speed)·2π/λ_spatial)·0.5+0.5)? That gives moving bright bands (like wavefronts). With toggle uniform uPulses: alpha *= mix(1.0, pulse, uPulseAmt). Distance in world units; spatial period ~2 units; speed ~6 units/s.

Also add small animated "breathing" of alpha via sin(time0.8 + dist0.01)? Skip — pulses suffice.

Now rendering geometry: BufferGeometry, non-indexed? Use indexed quads: positions (4 verts/quad), aAcross (−1/+1 per side... actually per vertex: −1 or +1), aDist (per vertex = dist at segment endpoint), color rgb + alpha per vertex (start/end intensity can differ? same per quad: use start intensity and end intensity via aDist interpolation... intensity constant along segment except Beer absorb — incorporate into per-vertex alpha: alphaStart = I, alphaEnd = I·exp(−k·len)). So attributes: position(3), aColor(3), aAlpha(1), aDist(1), aAcross(1). Index buffer: 2 tris per quad. Max quads Q=24000 → 96k verts, 144k indices. Preallocate Float32Arrays, setDrawRange.

Quad construction (2D): segment dir u (normalized), normal n = (−uy, ux)·w where w = width(I)? constant width 0.09 world units + slight I scaling. 4 corners: p1±n, p2±n. Y up in 3D: rays lie in XZ plane? I'll map 2D (x,y) → 3D (x, rayY, y) — table is XZ ground plane, y up = 3D y. Rays at height RAY_Y = 0.55 (glass height 1.1).

Element meshes:

• Glass: ExtrudeGeometry from Shape (2D outline in local coords), depth = 1.1, centered. MeshPhysicalMaterial: transmission 0.92, roughness 0.06, ior 1.5, thickness 1.2, clearcoat 0.5, transparent true... Transmission with bloom & additive lines inside — transmission pass can be heavy but ok. Alternatively cheaper: MeshPhysicalMaterial with transparent + opacity 0.22 + fresnel-ish... RoomEnvironment reflections need envMap; transmission needs transmissionRenderTarget — EffectComposer handles? Transmission works with WebGLRenderer automatically. It renders a transmission pass — cost OK for a few elements. Hmm, but transmitted rays through glass will be distorted by real refraction in the material — double effect, could look odd. Simpler & reliable: fake glass: MeshPhysicalMaterial({color: tint, transparent: true, opacity: 0.16, roughness: 0.08, metalness: 0, envMapIntensity: 1.2, clearcoat: 1}) + additive rim outline. With RoomEnvironment it looks like lucite. Good enough, and cheap. Depth sorting: transparent glass vs additive lines — lines depthWrite off, renderOrder set: table 0, glass 1, rays 2, sparkle 3.
• Mirror: metallic box 0.12 thick, height 1.1, metalness 1, roughness 0.12, envMap. cmirror: extruded arc segment (annulus sector shape with thickness) metallic.
• Screen: white matte bar (MeshStandardMaterial white, slight emissive 0.06) with a thin top edge where hit-dots render as additive points clustered at surface... place dots at RAY_Y on the screen inner face, small quads pointing up; additive; since screen is white, dots show as colored glow. Also a subtle bloom from them.
• Splitter: glass plate with one edge tinted; simple semi-transparent slab + diagonal line marker.

Rim outlines: THREE.LineLoop with LineBasicMaterial (additive, transparent, color per element type: glass cyan-white, mirror silver, screen warm). Build from outline points (sampled arcs / polygon verts).

Source gizmos: small assembly: cylinder body (metal) + emissive lens tip cone; group rotated to angle; laser thin emissive line at tip. Fan source: small arc horn. White: box with white emissive tip. Hover ring under element (circle line, additive) shown when hovered/selected.

Dust motes: 400 points slowly drifting in a volume above the table; subtle.

Table: CircleGeometry radius ~46? Rect 90×70 rounded. Use Shape rounded rect, MeshStandardMaterial color #0b0e15, roughness 0.55, metalness 0.35, envMap subtle. Plus shader grid? Add a second mesh: plane with custom shader drawing dotted breadboard grid faintly. Simpler: CanvasTexture with dot grid, repeat — easy & cheap. Generate 128px canvas with one dot, repeat 45×35, anisotropy.

Edge rim: torus-ish frame — use a slightly larger rounded-rect extruded thin frame, metallic.

Backdrop: scene.background = new THREE.Color(0x04060c); fog for depth.

Camera: PerspectiveCamera fov 42, pos ~ (0, 46, 34) looking at origin; OrbitControls with damping, maxPolarAngle ~ 75°, minDistance 18, maxDistance 120, panning limited to table area via target clamp.

Raycaster for interaction: intersect invisible plane y=RAY_Y → world (x,z) → 2D (x,y=z). Hit test elements via inside-test with small radius (or dist to boundary primitives for mirrors/screens — distance point-to-segment < 0.5).

Drag: pointerdown on element → dragging; move → update pos; dirty. pointerdown on empty → orbit (OrbitControls enabled only when not dragging element: set controls.enabled=false while dragging). Right-drag on element → rotate toward pointer. Wheel over hovered element → rotate by 2° (shift 0.25°). Wheel over source → rotate.

Toolbar DOM: buttons with emoji/text: ⌁ Laser, ▭ White, ⋔ Fan, ── then ○ Lens, ◍ Lens−? Use text labels: "+ Convex Lens", "+ Concave", "+ Prism", "+ Slab", "+ Droplet", "+ Fiber", "+ Mirror", "+ Curved", "+ Splitter", "+ Screen". Two rows compact. Selected source editing: when a source is hovered, show mini panel (wavelength select buttons R G B V, remove). Keep simpler: hover any object: bottom-right stats show info; keys Q/E rotate, X delete, C cycle laser color when source hovered.

Presets as chips 1..7 with names. Also "Clear bench" button.

Audio: WebAudio: master gain; pad = 2 oscillators (saw detune ±4 cents) → lowpass 400Hz + slow LFO on cutoff, gain 0.05; shimmer: noise buffer → bandpass 2000 + gain tied to light throughput (smoothed); interactions: glassTing(freq) on element place/move end / rotate; laserHum? Keep: ting on placements, soft click on buttons, whoosh on preset change. Light-driven: each trace, compute throughputEnergy = total segment intensity → set shimmer gain target. Nice reactive touch. Audio starts on first user gesture; 'A' toggles mute.

Stats panel: segments count, rays traced, trace ms, hovered element info (type, n at 589nm, focal/deviation), FPS, quality.

Help overlay: table of shortcuts; toggled with H or ? button.

Quality tiers: HIGH (dpr ≤ 2, full ray counts, bloom on), MED (dpr 1.5, rays ×0.7), LOW (dpr 1.25, rays ×0.5, bloom strength lower). Auto: monitor FPS over 3s, step down/up; G cycles manually.

Snapshot: press P → render composer, canvas.toBlob → a.download. Flash effect div.

Touch: single finger drag elements (hit test), two-finger orbit handled by OrbitControls... conflict: I'll make: touch on element → drag; touch elsewhere → orbit. Buttons big enough.

Now — the crucial part: write robust core code and TEST in node:

1. Slab: ray enters/exits parallel, displaced; no net deviation.
2. Prism: deviation for 589nm ~ match analytic δ_min? Just check exit direction sane + dispersion: blue deviates more than red.
3. TIR: 45° inside glass → all energy reflected.
4. Fresnel at normal incidence: R = ((n−1)/(n+1))² = 0.0434 for bk7@550.
5. Lens focus: parallel rays → crossing near f = R/(2(n−1)) within 10%.
6. Droplet rainbow: min deviation for p=1 rays ≈ 137.97° → scattering angle 180−137.97=42.03°... For the emergent ray direction relative to incoming direction: deviation D = 2(i−r) + (π − 2r) for one internal reflection; min over i. Numerically find rays with intRefs==1 exiting; compute angle between in-dir and out-dir; find min over dense impact params; expect ≈ 2.408 rad (137.97°). And p=2: D₂ = 2(i−r) + 2(π−2r); stationary max ~ 230.9° → rainbow at 360−230.9 = 129.1°? The secondary appears at ~51° from antisolar: scattering angle = 180−51=129°. Check numerically.
7. Energy conservation: sum of all segment-end intensities + terminated ≤ input (approx with absorption).
8. Screen hit recording.

Then assemble full HTML. Length ~1800-2200 lines. Let me get going. I'll write the core to a file first, test it, then embed.

Let me write /tmp/optics-core.mjs with the pure core + tests. Then build the full index.html embedding the tested core verbatim between markers.

Core code plan:

Element factory:

I'll compute derived quantities in functions, not stored.

Core functions (all pure):

intersectElement implementation:

• transform ray to local.
• bounding: circle at origin radius rb(el): solve |o + t d|² = rb²; if no real roots or both t < 0 → null. Also earliest possible t0 = max(root1, tMin)... For candidate filtering, we just need quick reject.
• gather candidates: for each primitive: circle → up to 2 t values; line → segment intersection t. For each candidate t in (tMin, tMax): p = o + t d; crossing check:
  • glass kinds: in1 = insideLocal(p − d·EPS), in2 = insideLocal(p + d·EPS); if in1 === in2 → reject.
  • boundary kinds (mirror/cmirror/splitter/screen): accept if within segment/arc param bounds (line t in [0,1] via u param; arc via angle test).
• track min t; normal: circle → normalize(p − center) (outward from circle); for lens exit faces normal must point away from material: our convention: normal returned = geometric normal flipped later to oppose ray dir — so any normal direction works since we flip to face the ray. But refraction needs the interface normal orientation only up to sign (we flip to oppose d). ✓. line → perpendicular (ny = dx stuff): n = (−dy_l, dx_l) of the line direction normalized.

EPS for crossing test: 1e-3 in local units (element sizes ~1-6, table 90). δ sampling fine.

Tracer:

Segment record: {x1,y1,x2,y2, lam, I0, I1, d0, d1, refs}.

Queue as simple array used as stack; cap total spawned rays (e.g., 40000) to avoid pathological mirror rooms; intensity cutoff 0.004; depth 24.

Mirror room with two parallel mirrors: intensity decays 0.965^depth → depth needed ~ 200 for cutoff... 0.965^200 ≈ e^{200·ln0.965} = e^{−7.1} ≈ 8e-4 < 0.004 → ~140 depth. Depth cap 24 would cut visibly infinite reflections — bump depth cap to 60 for mirrors? Each reflection adds one segment — 60 segments for a single laser in mirror tunnel: fine. Set depth cap 64, cutoff 0.006. 0.965^64 = e^{64·(−0.0356)} = e^{−2.28} = 0.10 — visible still. Hmm, mirror tunnel: rays bouncing forever at 10% after 64 bounces — cut looks abrupt-ish but with additive fading it's ok. Better: mirrors reflectivity 0.94 → 0.94^64 = e^{64·(−0.0619)} = e^{−3.96} = 0.019 — dim enough. Use 0.94 and depth 72. Actually make mirrors 0.955, depth cap 72 → 0.955^72 = e^{72·(−0.046)}=e^{−3.31}=0.036. OK ~dim. Fine.

White beam wavelengths: sample λ at 12 values 405→680 with per-λ intensity weighting to look white (equal energy). Colors via wavelengthToRGB linear, intensity 1 each — additive mixing gives whitish. 14 samples maybe.

Fan: 25 rays across spread.

Sources emit rays with I=1 (white: each λ I = weight).

For performance stats, count.

Now intensity threshold & sparkle: spark at each surface interaction point with I·0.5.

Screen hits: record u coordinate along screen line (−L/2..L/2) and λ, I. Render as glow dots + also accumulate into a per-screen 1D histogram for a tiny spectrum strip in HUD? Keep: glow dots only.

Now let me also think about "guides" for rainbow preset: dashed rings at 42° and 51° around droplet center? The rainbow is formed by emergent light at those angles relative to the sunlight direction; drawing a protractor circle with tick labels "42°" / "51°" arcs helps interpretation. Implement: two thin ring line loops (dashed via LineDashedMaterial) centered on droplet, only in that preset (part of preset creation: a 'decor' element). Skip labels (3D text heavy) — HUD note instead. Or draw angles as two cones... Keep simple: skip decor; instead stats panel shows measured caustic angles! I can compute, from traced segments exiting droplet with refs==1, intensity-weighted histogram of scattering angle, find peak → display "Primary bow: 41.9° ✓". That's a killer educational feature: measured vs theory readout. Compute in tracer when droplet present: collect (angleDeg, I) for exit-from-water segments with refs 1 and 2 (only those crossing water→air with refs>0), histogram 0–180 in 0.5° bins weighted by I·(colorless), find max near expected windows. Display in stats.

Also prism preset: measure deviation angle of the main beam vs theory δ = ... just display measured deviation. Nice.

Detector: screen total power readout (sum I on screens) — "Screen: 0.83 W·nm" whatever. Show "light captured".

OK. Also laser-through-slit diffraction? NO — ray optics can't. Honest note in help: "Geometric optics: no interference/diffraction (see Wavefront demo for that)".

Let me now write the core file and tests. I'll be very careful with the math.

Refraction function:

Fresnel unpolarized:

For TIR: R=1, cost=0.

Reflection: r = d − 2 dot(d,n) n.

Edge case: ray starting inside glass — sources always placed in air; children born at boundary offset ±EPS2 along dir, so medElem determined by sampling: elemAt(x,y) returns first glass element containing point. Fine.

For the droplet rainbow measurement: when a ray crosses from water to air (n1>n2 boundary) and transmits (not TIR): if ray.refs >= 1: angle = angleBetween(incomingDir, outgoingDir) in degrees [0,180]; record {ang, I: I_t, refs}. Note: refs counts INTERNAL reflections before this exit. p=1: refs==1 → primary; refs==2 → secondary. Also record scattering "orientation" (sign of cross product) — not needed.

Deviation measurement for prism: compare final beam centroid direction vs initial. Compute: weighted average of directions of segments with depth>0 beyond prism? Simpler: measure angle between first segment dir and the last segment dir of the dominant chain... skip exact; measure: for rays that exited the prism (water→air... glass→air crossing with elem mat glass), angle between original primary dir and exit dir weighted by I — that's the deviation. Record {ang,I} for prism elements → histogram peak → "Deviation 52°". Only meaningful for single prism; fine, only show in preset 1 (flag on element: el.measure='deviation'? I'll tag by kind==='prism').

Let me write it now. I'll write the core as a standalone module with markers so the same text gets embedded into HTML. Actually simpler: develop core + tests in /tmp; then copy the core into the HTML file. Keep a build script to do the embedding to avoid manual copy errors: build.sh that splices core.mjs into a template. Hmm — final deliverable must be a self-contained index.html; I'll generate it via a small script: write template-head, core, template-tail. That's manageable: write 3 files then cat. Let me do:

• /tmp/lumen/core.mjs — pure JS core (no THREE) with exported functions, but in the HTML it will be inlined (strip export ).
• /tmp/lumen/test.mjs — node tests.
• /tmp/lumen/app.mjs — the THREE app code (template literal safe).
• /tmp/lumen/head.html — doctype/CSS/body markup/import map + <script type="module"> + imports.
• Build: cat head + core(no exports) + app + </script></body></html> → /space/demos/040-lumen-lab/index.html.

Node --check on app.mjs (needs THREE imports — node --check only parses, imports unresolved is fine for --check? node --check file.mjs parses without executing — imports fine). Good: syntax check app.mjs and core.mjs; run tests for core.

One more design decision: units. Table 90×70 world units (xz). Elements ~2–8. Camera at ~55 height. Fine.

Let me also plan the glass shape outlines for ExtrudeGeometry:

• lens: outline sampled: arc of circle1 from −a..? Build THREE.Shape: moveTo(0, a)... For biconvex: right arc from (h·? ) Points: right surface = circle centered (d,0) radius R from angle π−α to π+α where α = asin(a/R)? The right arc passes (h, 0) and (0, ±a). Circle centered (d,0): point (0,a): angle = atan2(a, −d) ≈ π − a/d... Let me param: θmax = atan2(a, h−d)?? Point (0,a) rel center (d,0): (−d, a) → angle π − atan(a/d). Point (h,0) rel: (h−d, 0) → h−d = h − (R−h) = 2h − R <0 → angle π. So right arc: angles from π−β to π+β where β = atan(a/d) measured... I'll just sample: for θ from π−β to π+β (β=atan2(a,d)): x = d + R cos θ, y = R sin θ → at θ=π: (d−R, 0) = (−h, 0). Hmm that's the LEFT surface. Right surface: center (−d, 0): angles −β..+β: x = −d + R cosθ, y = R sinθ → θ=0: (−d+R, 0) = (h, 0) ✓; θ=β: (−d + R cosβ, R sinβ) = (−d + R·d/R, R·a/R) = (0, a) ✓. So outline: right arc θ: −β→β (center −d), then left arc: center (+d,0), θ from π−β to π+β → at π−β: (d + R cos(π−β), R sin(π−β)) = (d − d, a) = (0,a) ✓ continuing to (0,−a). Shape via absarc — THREE.Shape.absarc(x, y, radius, startAngle, endAngle, clockwise).
• prism: polygon 3 verts. slab: rect rounded (use quadratic corners or plain). droplet: circle. fiber: annulus sector: absarc outer then inner reversed + closing lines. cmirror: annulus sector thin (R to R+0.18). mirror/splitter/screen: thin rect boxes — use BoxGeometry for those instead of extrude. Screen: box white. Mirror: box metal. Splitter: box glass-ish with diagonal emissive line? Box + thin emissive stripe on top face showing 45°? Keep box + rim.

For all extruded glass: ExtrudeGeometry(shape, {depth: H, bevelEnabled: true, bevelThickness: 0.04, bevelSize: 0.04, bevelSegments: 2, curveSegments: 48}) then rotateX(−90°)? Extrude is along +z; to stand on table: geometry.rotateX(-Math.PI/2) → extrudes downward in y? rotateX(π/2)? Test mentally: shape in xy-plane, extrude z∈[0,H]. rotateX(-90°): (x,y,z)→(x, z→? ) rotateX(-90): y' = y cos(−90) − z sin(−90) = z; z' = y sin(−90)+ z cos(−90) = −y. So (x, y, z) → (x, z, −y): shape y becomes −z (fine, mirror), extrude z becomes +y: height upward ✓. So local 2D point (x, y) maps to 3D (x, z=−y). Since my sim 2D y maps to 3D z as (x3 = x2, z3 = y2) — sign mismatch: shape built with y flipped: build Shape using (x, −y)?? Simplest: when building Shape use shapeY = −simY; i.e., Shape coordinates (x, −y) then after rotateX(−90°) z3 = −shapeY = simY ✓. OK just remember: shape points use (x, −y).

Rim lines: THREE.LineLoop from outline points (x, H+0.02, y) plus maybe a second at y=0.02? Just top rim + bottom rim? One rim at top + faint bottom. Use additive LineBasicMaterial.

Glass material: MeshPhysicalMaterial({ color: matColor (slight tint per material: crown #cfe8ff, flint #d8dcff, water #bfe4d8?, acrylic #e8f4ff), metalness:0, roughness:0.06, transparent:true, opacity:0.14, clearcoat:1, clearcoatRoughness:0.08, envMapIntensity:1.4, side:DoubleSide? FrontSide fine, depthWrite:false }) — depthWrite false to avoid sorting artifacts with rays; renderOrder: glass 2, rays 4, sparks 5, rims 3, table 1.

Scene.environment via RoomEnvironment with PMREMGenerator.

Bloom threshold: rays are additive HDR (color values up to ~2-3 intensity), threshold 0.5, strength 0.75, radius 0.55.

Grade pass shader — I'll reuse pattern: uniforms tDiffuse, uTime, uVignette, uGrain, uCA; standard.

Audio module: class AudioEngine {init on gesture; padOsc; shimmer noise; ting(freq); click(); setEnergy(e); toggle()}.

OK. Time to write files. Start with core.

Also decide exact preset layouts (coordinates). Table interior ~ x∈[−42,42], z∈[−32,32].

Preset 1 "Dark Side": white beam source at (−30, 0) pointing +x, width 0.9 (narrow), prism (flint) at (−6, 0) angle 0 rotated so beam hits left face; rotate prism to near minimum deviation ( −12°?), screen at (26, 8) angled to catch spectrum. I'll tune: prism equilateral r=7 (side ~12). Apex angle 60°, flint n_d=1.728 → δ_min = 2 asin(n sin(A/2)) − A = 2 asin(1.728·0.5) − 60 = 2·asin(0.864)=2·59.78−60=59.6°... asin(0.864)=59.77°. δ_min≈59.5°. Steep bend. With equilateral flint the beam bends ~60° — screen placement: beam +x enters at (−6,0); exits deviated by ~55-65° → heading up-left? deviation rotates direction by δ toward base. If prism apex up (+y) base down, deviation toward base = downward −y... Let me orient: apex angle at top vertex (90° default verts at 90°,210°,330°): vertices: top (0,7), bottom-left (−6.06,−3.5), bottom-right (6.06,−3.5). Beam from left hits left face (top-left edge between (0,7) and (−6.06,−3.5)). Deviation bends toward base (downward): exit direction rotated clockwise (toward −y) by ~59°? For symmetric passage rotate prism so incidence ≈ exit ≈ (A+δ)/2 = (60+59.5)/2 ≈ 59.8° from normal... I'll just rotate prism angle ≈ 25° and place screen accordingly; fine-tune visually via the tracer in node! I can run the tracer headless to print exit beam direction — great, do that during testing: place preset, compute centroid exit dir, then position screen programmatically: screen placed along exit centroid at distance 28, perpendicular. Actually that's robust: in the preset loader, after placing elements, run one trace, find exit beam dir (weighted), position screen automatically! I'll implement preset 1 screen auto-aim: compute from trace. Nice.

Preset 2 "Rainbow Drop": droplet water r=6 at (8,0); white beam wide: source at (−26,0) width 11 (covers droplet), 16 rays × 12 λ. Rays enter droplet; primary bow exits backward-ish at ~138° deviation = 42° from incoming reversed... Emergent direction relative to +x: deviation 138° means ray heads back toward source tilted 42° above/below the −x axis... The "rainbow" appears around the antisolar point looking away from sun. Visually: fans of colored rays exit the droplet upward-left and downward-left at ~42° half-angle cones. Also forward rainbow (p=0) focusing. Beautiful. Screen? No screen — airborne rays. Add stats: measured primary/secondary angles.

Preset 3 "Lens Bench": fan source (green 532, spread 40°, 19 rays) at (−26,0) → biconvex lens bk7 a=6, h=1.4 → R=(36+1.96)/2.8=13.56 → f=R/(2(n−1)) = 13.56/(2·0.5145) = 13.18 (thin). Lens at (0,0): rays from −26 converge past f≈13+ thick correction. Also screen at image? Point at 26 → image at 1/f=1/13.18 → 1/s' = 1/f − 1/s = 1/13.18 − 1/26 → s' = 26.3. Screen at (26.5, 0)! Shows focused point.

Preset 4 "Refractor": parallel white beam width 8 at x=−30 → objective lens a=7? Table only 84 wide... objective f1 long: a=6,h=0.9 → R=(36+0.81)/1.8=20.45, f=20.45/1.029=19.9; eyepiece a=2.5, h=1.2 → R=(6.25+1.44)/2.4=3.2, f=3.2/1.029=3.11. Keplerian: separation = f1+f2 ≈ 23 → objective at (−10,0), eyepiece at (13,0), beam exits parallel narrow at +x. Show magnified... M = f1/f2 ≈ 6.4. Add screen far right showing exit beam width ratio ≈ 8/6.4=1.25. Measure & display beam ratio in stats ("Magnification ≈ …")? Nice touch: display measured exit beam half-width vs entrance.

Preset 5 "Mirror Cauldron": cmirror R=22, half-angle 32° at (16,0) opening −x (concave side faces −x toward incoming beam). Arc center at (16,0)?? Let me define cmirror local: circle center at origin, arc on −x side: points (Rcosθ, Rsinθ), θ ∈ [π−φ, π+φ] → arc bulges toward −x with dish opening toward +x?? Circle center O, arc at angle π side: point (−R,0) leftmost; concave side faces +x (toward center). Incoming parallel beam from left (−x) traveling +x would hit the arc's CONVEX back. So orient: arc on +x side (θ∈[−φ,φ]), concave faces −x; beam from left traveling +x hits concave face ✓, focuses at f=R/2=11 in front: focus at (16+? ) mirror at right side: vertex at (x_c + R? ...) Let me place circle center at (2,0), R=20, φ=30° → vertex at (22, 0), focus at (2 + ? focus at distance R/2 from vertex along axis toward center: vertex (22,0), focus (12,0). Parallel white beam from (−30,0) width 14 → reflects to focus ~ (12,0) with spherical aberration caustic. Gorgeous bright caustic curve. Then rays cross and spread to the right? After focus they diverge back toward mirror side... They pass focus and continue left-down... they diverge continuing −x? No: after reflection rays travel −x generally, converge at focus (12,0) then diverge continuing toward −x. Lovely X caustic.

Preset 6 "Fiber Bend": fiber annulus r1=8, r2=11, span 100° centered at (10, 4) with opening... entry face at one radial end. Laser red 650 aimed into entry annulus end. Rays TIR along bend (critical angle glass-air = asin(1/1.51) ≈ 41.5°; bend incidence ~ depends). With r2/r1 = 11/8 = 1.375, max angle... TIR around bend condition: sin θ ≥ r1/r2? For meridional rays in bent guide: incidence at outer wall ~ ... it works if bend radius generous. r1=8, r2=11: radial thickness 3; a straight ray across the guide hits outer wall at sinθ = ... chord across: impact param ~ between 8 and 11. sin(incidence at outer wall) = b/r2 where b ~ within [r1, r2]: for b=10: sinθ=10/11=0.909 → θ=65° > 41.5 ✓ TIR. At inner wall: sinθ = b/r1... ray bouncing between walls alternately: always OK if b > r1·sin(41.5°) = 8·0.662=5.3 — always since b≥r1=8? Not exactly but mostly TIRs. Some loss at inner wall adds realism (Fresnel leakage glow).

Preset 7 "Interferometer" (Mach–Zehnder): laser green at (−32,−12) → +x; splitter1 at (−14,−12) at 45°; mirror1 at (−14,12) at −45°?? Layout: BS1 at (−14,−12) splits: transmitted continues +x to mirror B at (12,−12) angled 45° → up to BS2 at (12,12); reflected goes +y up to mirror A at (−14,12) angled 45° → +x to BS2 at (12,12) at 45°; BS2 outputs: two ports → two screens at (28,12) and (12,28)? Table z only ±32 ok. Screens catch both ports. Readout shows 50/50 each port (ray model: each photon path splits; energy: port1 gets |T·R + ...| without phase both paths contribute 25% each → each port 50%? Compute: path A: R at BS1 (0.5), M (0.94), at BS2: T (0.5) → port2; R(0.5) → port1. path B: T(0.5), M(0.94), BS2: R→port2? Geometry: both ports get 0.5·0.94·0.5 + 0.5·0.94·0.5 = 0.47 total each ≈ 47% (mirror loss). Display "Port powers: 47% / 47%" measured. Honest caption: "No fringes — rays carry no phase; try Wavefront for interference." Good.

Source kinds: 'laser' (λ selectable: 650/632?/532/450/405), 'white' (parallel, width, λset), 'fan' (λ single, spread, count). Actually make 'white' = parallel white beam; also allow fan white? too many rays: fan×12λ... allow fan laser-only; beam white or mono.

Editing sources: hover + C cycles wavelength for laser/fan; white beam: C toggles... keep C cycles λ for mono sources. Q/E rotate; X delete; drag move.

Also allow dragging the source's aim: drag source body = move; drag its glowing tip handle = rotate aim! Nice: tip handle at distance 2 in front. Implement: pointerdown near tip (dist < 0.9) → aim-drag.

Element creation buttons add at "free spot": scan a few candidate positions near center for overlap-free placement: try (0,−14), spiral offsets until no within-5 of existing. Simple.

Default view preset on load: Preset 1 (Dark Side) — instant wow with spectrum on screen.

Stats: right panel rows: Rays, Segments, Trace ms, Hovered info, Screen power, Measurement (deviation / rainbow / magnification depending), FPS + quality badge.

Now, big consideration: code size. This is a LOT. But previous demos were similar scale (039 ~1400+ lines). I'll aim ~1900 lines total. Let me write efficiently but carefully.

Write order:

1. /tmp/lumen/core.mjs + test.mjs; run tests; iterate.
2. head.html (CSS/HUD markup).
3. app.mjs (scene, rendering, UI, audio, loop).
4. build into /space/demos/040-lumen-lab/index.html; node --check both parts; verify IDs referenced exist.
5. Update /space/demos/index.html with new card at top.
6. Cleanup tmp files (optional; they're in /tmp anyway).

Let me write the core now. Careful details:

insideLocal(el, x, y):

lensc: store derived d and R at creation: d=(a²−h_c²)/(2h_c)?? Wait earlier: d = (a² − h_c²)/(2 h_c) — check: h_c = R − d, R² = d² + a² → (d+h_c)² = d² + a² → 2 d h_c + h_c² = a² → d = (a² − h_c²)/(2 h_c) ✓, R = d + h_c. lens: R = (a² + h²)/(2h), d = R − h.

prism verts (local): v_i = r·(cos θ_i, sin θ_i), θ = π/2, 7π/6, 11π/6. inside: for each edge (vi→vj ccw), cross = (vx?) Let me just do sign consistency: compute cross products of (p−vi)×(vj−vi) — with ccw verts all crosses ≥ 0 inside. Verts at 90°,210°,330° going ccw: 90 → 210 → 330 ✓ ccw.

Boundary primitive enumeration per kind (local):

Intersection candidates:

• circle: standard quadratic; both roots.
• line: solve o + t d = a + u (b−a); t, u; u∈[0,1]. For glass kinds validate crossing; for boundary kinds validate arc/segment bounds (and for cmirror angle within φ).

Normal at hit: circle: n = (p − c)/r (local), for lines: n = perp(b−a) normalized. Transform normal to world (rotate by angle).

Boundary kinds priority: a ray could hit a mirror and a glass surface at same t — rare; pick min t overall.

Fresnel needs n1, n2: sample medium before/after across ALL glass elements (not just the hit one): mediumAt(x, y) → first glass element whose insideLocal true (transform point into each el frame). Air if none. Use EPS2 = 2e-3 along dir.

Edge case: ray hitting rim lines of lensc: normal from line perp; media: inside/outside via sampling — fine.

Spark recording: at each boundary interaction (glass or mirror or splitter): push spark (world pos, λ, I·0.6). Cap sparks count (e.g., 4000).

Screens: record hit (u along segment, λ, I). Also total power per screen.

Measurements:

• prismDeviation: for each ray child that transmits OUT of a prism (n1=prism mat → air): angle between that ray's ORIGINAL primary direction (store baseDir in ray) and new dir; weighted histogram 0–180 bins 0.25°; peak with parabolic refine → measured deviation. (Only when exactly 1 prism exists.)
• rainbow: for exits from 'drop' elements with refs≥1: scatter angle vs baseDir; two histograms (refs==1, refs==2), peaks → measured angles (report as 180−dev for primary: rainbow angle = 180 − D... display "Primary bow 41.9° (theory 42.0°)": measured = 180 − peakD for refs1; for refs2: D₂ stationary ≈ 230° → rainbow at 180−(360−D₂)?? Let me define: deviation D = total turning (angle between incoming dir and outgoing dir, in [0,180] via acos(dot) — loses winding; for p=2 D ∈ ~[129?..] acos gives the unsigned angle between dirs: for secondary, outgoing vs incoming unsigned ≈ 129° → rainbow angle 51° = 180 − 129. So both: rainbowAngle = 180 − acosAngle? For primary acos gives 138 → 180−138=42 ✓; secondary acos gives ~129.5 → 180−129.5=50.5≈51 ✓.
• telescope: measure beam width before first lens & after last lens: collect segments crossing plane x = lens1.x − 6 (entry) and x = lens2.x + 6 (exit): spread of y positions weighted → ratio → magnification. Simplify: preset stores measurement config; generic engine: measures = [{type:'beamRatio', x0, x1, axis:'x'}]. Implement minimally: function measureBeamWidth(segs, x) → RMS spread of y for segments crossing vertical plane x. Then ratio = w0/w1.
• screen power: total I per screen.

I'll implement measurements in the app from tracer outputs (tracer returns segs array + structured exits list + screenHits).

Tracer outputs:

exits: any transmission out of glass into air records {elId of glass, refs, dirx, diry, basex, basey, I}. App computes deviation/rainbow peaks.

Ray budget: cap segs at MAXSEG (e.g., 26000); if exceeded, stop spawning (drop). Stats flag overflow.

Determinism: no randomness in tracer. Preset initial jitter none. Good for node tests.

Let me now write core.mjs.

Element creation: makeElement(kind, o) returns normalized object with derived params computed by deriveElement(el):

rb (bounding radius): lens: hypot(h, a); lensc: hypot(he, a)+0.1; prism: r; slab: hypot(w,h2)/2; drop: r; fiber: r2; mirror/splitter/screen: L/2; cmirror: R.

GLASS_KINDS = set('lens','lensc','prism','slab','drop','fiber').

Functions:

intersectElement(el, wox, woy, wdx, wdy, tMin, tMax) — world ray in, returns {t, nx, ny(world)} | null:

then per-kind candidate gathering:

circle candidate(cx, cy, r):

line candidate(ax,ay,bx,by):

Solve: p = o + t d = a + u e. → t·d − u·e = a − o → [dx, −ex; dy, −ey]·(t,u) = (ax−ox, ay−oy). det = dx·(−ey) − (−ex)·dy = −dx·ey + ex·dy = ex·dy − dx·ey. t = ((ax−ox)(−ey) − (−ex)(ay−oy))/det = (ex·(ay−oy) − ey·(ax−ox))/det... let me: t = (rhs1·(−ey) − (−ex)·rhs2)/det = (−ey·rhs1 + ex·rhs2)/det where rhs=(ax−ox, ay−oy). u = (dx·rhs2 − dy·rhs1)/det. u ∈ [0,1] check (with tiny tolerance −1e-9).

For arc (cmirror): after circle candidate, check angle: atan2(py, px) within [−φ, φ] (arc on +x side local).

Candidate acceptance:

• glass kinds: in1 = insideLocal(el, px − ldxEPS, py − ldyEPS), in2 = insideLocal(+EPS); accept if in1 !== in2.
• boundary kinds: accept (already bounds-checked); for cmirror angle check.

Track best (min t). Compute local normal; world normal: rotate by +angle: nwx = canx − sany? Local→world rotation R(a): wx = calx − saly, wy = salx + caly. ✓ (consistent with world→local above: R(−a): lx = cawx + sawy, ly = −sawx + cawy ✓).

traceScene(elements, sources, opts={}):

pushSeg(r, t): segs.push({x1:r.x, y1:r.y, x2:r.x+r.dxt, y2:..., lam:r.lam, I0:r.I, I1:r.IMath.exp(-(r.medK||0)*t), d0:r.dist, d1:r.dist+t, refs:r.refs}) — refs not needed per seg after exits recorded; keep for possible styling (rainbow segments tint?) — could color internal droplet rays differently; skip.

I0 vs I1: alpha fades along absorbing segment ✓.

Child ray creation: {x: px + dir·BIRTH_EPS? — no: children start AT px,py and tracer ignores hits t<1e-4; but the same surface may re-intersect at t≈0 for circle (the other root tiny). tMin=1e-4 handles: re-hitting same surface at t < 1e-4 ignored; but crossing test: for transmitted ray just inside glass, the same surface candidate t≈0 → skipped since t≤1e-4 ✓. So no origin offset needed. Use tMin = 5e-4 to be safe with δ sampling EPS=1e-3?? crossing test uses EPS=1e-3 > tMin... crossing test samples p±d·1e-3 which for t≈0 candidates would sample across the surface — but those candidates are skipped by tMin. For legitimate close hits (adjacent elements touching), could cause issues — acceptable.

MED_EPS = 2e-3.

tableClip: compute t to exit rect [-48,48]×[-38,38] (slightly beyond table); if origin outside rect, t = 4. Standard slab method; if parallel, large t.

Emitters:

SPECTRUM: [404, 436, 460, 486, 510, 532, 556, 580, 605, 630, 656, 680] (12). wavelengthToRGB handles 380–700.

wavelengthToRGB (Bruton, linear-ish):

Also need colorOfλ for CSS (stats readout): rgb() string from same function with clamp.

Tests (test.mjs):

1. fresnel normal incidence: single slab; incident I=1; sum of exit segment I ≈ (1−R)² + ... complicated; simpler test: call internal fresnel? Not exported. Instead: prism TIR test: ray inside glass at 45°: construct: laser aimed into a slab oriented so that inside ray hits back face at 45°: slab from x∈[-3,3], y∈[-3,3]; source at (−10, −0.75)?? Let me do direct unit tests via traceScene on crafted scenes:
   • Test A (slab displacement & zero deviation): slab 6×6 at origin; laser 589 at (−10, 1) dir (cos20°, sin20°). Expect: final exit dir == initial dir (angle within 1e-6); net energy: sum of I of segments beyond slab (x>4) ≈ (1−R1)(1−R2)/(1−R1R2)... multiple internal reflections complicate: total transmitted = (1−R)²·Σ(R²)^k = (1−R)²/(1−R²) = (1−R)/(1+R). With R(589, θ=20°→ inside 12.8°?) compute expected numeric in test independently? Simply assert transmitted total ∈ (0.85, 0.95) and reflected total > 0.05 and sum ≈ 1 minus absorption (absorb 0.012·~6 → ~7%) → sum ∈ (0.9, 1.0).
   • Test B (TIR): fiber-free: droplet? Use slab as prism: better: a prism with ray entering normal to one face (no bend), hitting second face at 60° > critical (41.5°) → must TIR: all energy continues as internal reflected (minus nothing) → check: no transmitted exit segments crossing face 2 (exits list empty for that face... exits record ALL glass→air transmissions; TIR ray then exits elsewhere). Assert: at least one internal reflection happened (some exit with refs ≥ 1? or check segment count). Simpler assertion: ray path: laser 589 at prism... I'll instead directly verify with droplet: ray at impact param b=0.95r → incidence ~72° > critical at EXIT attempt... In droplet, incidence at inner surface = r (refraction angle ~29° for n=1.33 at b/r... sin i = 0.95, i=71.8°, sin r = 0.95/1.333=0.7127, r=45.5° — inside incidence 45.5° vs critical asin(1/1.333)=48.6° → 45.5 < 48.6 transmits! For b=0.99: i=81.9°, sin r=0.7427→ r=47.97 <48.6 still transmits (droplet can't TIR at first inner bounce: r ≤ critical always when entering from air — right: r_max = critical exactly at grazing). So droplet p=1 always transmits (true rainbow!). TIR test: use slab: laser enters slab at near-normal (θ1≈0) then... slab faces parallel — no TIR. Use prism: equilateral; enter face 1 at near-normal; inside hits face 2 at 60° > 41.5° (crown) → TIR ✓ then hits face 3? At some angle, exits. Assert: exits.length ≥ 1 AND there exists a segment after the TIR point AND total internal-reflection occurred: I'll tag exits with refs — assert exits.some(e=>e.refs≥1). And no exit with refs==0 from face 2?? The TIR face: refs counts increments only when reflection keeps ray in same glass — at TIR R=1 → reflected child refs+1 ✓. But partial Fresnel reflection at entry also creates reflected (external, refs+0 since elB null). So assert exits.some(e => e.refs >= 1) ✓ and total energy conserved: sum over exits weighted... let me just assert TIR happened and energy: total I of segments that escape to air + absorption ≈ 1 within 15%.
   • Test C (rainbow angle): droplet water r=5 at origin; 61 parallel rays 589nm covering b∈[−4.9, 4.9]; collect exits refs==1: D = acos(−(dx·bdx+dy·bdy))? baseDir = (1,0); D = acos(clamp(dx·1+dy·0))... acos gives [0,π]; D_expected ≈ 137.97° = 2.4086 rad. Find min D over exits (D(i) stationary min): assert minD ∈ [136°, 140°]. Also assert the pileup: count exits with D within [minD, minD+1°] ≥ 3 (caustic concentration).
   • Wait: min deviation: for b from 0..r, D decreases then increases? D(b=0)=180° (straight back). At grazing D→? As i→90°, D = 2(90−r_c) + (180−2 r_c)·? = 360 − 4 r_c = 360−194.5=165.5°? Hmm: at grazing: i=90, r=r_c=48.75: D = 2(i−r) + (180 − 2r) = 2·41.25 + 82.5 = 165°. And D(0)=180. Min somewhere between: 137.97 ✓. So D ranges [137.97, 180]. minD test ✓.
   • Secondary: refs==2: D₂ = 2(i−r) + 2(180−2r) → D₂(0) = 360 → acos gives 0... careful with acos wrap: at b=0 ray retraces → D=360 → outgoing dir = +x?? p=2 at b=0: two internal reflections — ray exits forward?? Actually at b=0: enters, reflects at back, reflects at front, exits backward?? p=2 b=0: path: in along +x diameter, reflect at inner back (−x), reflect at inner front (+x), transmit out the back continuing +x → outgoing dir +x same as incoming → D=0 by acos but geometric winding 360°. So for p=2, acos(dot) ∈ [0, ...]: stationary point at D_acos ≈ 129.1°? At b small: D_acos ~ 0; at b→r: D₂ = 0 + 2(180−2·48.75)=165 → acos 165. So acosD ranges 0..165 with MAX at ~129.1?? The rainbow is a maximum of... hmm p=2 deviation D₂ = 2(i−r) + 2(π−2r); dD₂/di = 2 − 8 dr/di; dr/di = cos i/(n cos r); zero when cos i = 4?? For n=1.333: cos i = (n cos r)/4 → with sin: cos i = (4/3 cos r)/4 = cos r/3: i ≈ 71.9°?? known result: secondary bow at 51°: D₂,max = 180+2·51−... The secondary rainbow: total deviation ≈ 230.9° → measured "foldback" angle = 230.9 − 180 = 50.9° on the other side; acos(dot) = |360 − 230.9| = 129.1 ✓. So for p=2: D_acos MAX ≈ 129.1° (stationary). Test: maxD ∈ [127°, 131°] for refs==2 ✓.
   • Test D (lens focus): lens a=6, h=1.4 → R=13.557, f_thin=13.19; 21 parallel 550 rays at y∈[−5.5,5.5] from x=−20 → after lens, segments cross axis; find crossings of segment with y=0 for x>5: mean x_focus; thick-lens: f_eff slightly > f_thin? For biconvex thick: power Φ=(n−1)(1/R1 − 1/R2 + ((n−1)d)/(n R1 R2))... with R1=R, R2=−R: Φ = (n−1)(2/R + (n−1)·(2h)/(n R²)) → 1/f = 0.5145·(2/13.557 + 0.5145·2.8/(1.5145·184)) = 0.5145·(0.14753 + 0.00780) = 0.5145·0.15533 = 0.07992 → f = 12.51. Focus measured from principal plane; H2 at ~ −(f (n−1) d)/(n R2)... eh. Just assert crossing centroid x ∈ [9, 16].
   • Test E (energy conservation): white beam through prism: total exiting energy + absorbed ≈ input (within 5%): compute sum of I1 of final segments (segments with no children...) simpler: sum of I of all "escape to infinity" segments + screenHits I + (lost to cutoff) — cutoff loses some; assert escape+screen ≥ 0.75·input and ≤ 1.05·input.
   • Test F (fiber): laser into fiber entry: assert some TIR (exits none or small energy), most energy exits at fiber far end: compute: energy crossing plane at fiber exit radial edge vs input ∈ [0.6, 1.0]? Depends geometry; simpler assert: at least 3 sparks inside fiber region (bounces) and escape energy > 0.5.

Good. Then app code.

One more: mediumAt — for sampling before/after, check ALL glass elements: transform point to local & insideLocal. ~fine.

Perf per ray-bounce: elements loop (say 15) × primitive tests. With bounding reject cheap. White beam 60 primaries, avg ~6 bounces → 360 ray-traces × 15 el... trivial. Rainbow: 240 primaries × ~10 = 2400 × elements(2) → trivial. Mirror maze laser: 72 depth → 72×N. All fine. Even dragging at 60fps re-trace: fine.

Now the app structure (~1200 lines). Let me draft key pieces:

Buffers & ray mesh:

fillFromTrace(trace): for each seg: quad corners: dir (dx,dy) normalized (seg could be zero-length: skip), n = perp·w; w = 0.055 + 0.05·min(I,1)? constant 0.07 fine. y = RAY_Y both ends... slight taper? constant. color: [r,g,b]·? intensity in alpha; color pure spectral. alpha0 = I0·0.85, alpha1 = I1·0.85. Also HDR: to feed bloom, multiply color by (0.4 + 0.6·I)? Keep alpha blending; bloom picks bright overlaps. Use additive: AdditiveBlending, transparent true, depthWrite false, depthTest true (rays should be occluded by... glass opacity low, fine; keep depthTest false so rays always visible above table? If camera orbits low, table edge could hide rays incorrectly. depthTest true is more correct; glass depthWrite off so no occlusion issue; table is below rays → no occlusion from normal angles. depthTest true.

Shader:

Now write the test suite for the physics core.

Good, the run is progressing. The droplet tests pass (circle primitive works), but flat-faced elements (slab, prism, fiber edges) fail — that points to the line-segment intersection math. Let me debug the line intersection.

In line(ax, ay, bx2, by2):

Let me solve properly. Ray: p = o + t·d. Segment: p = a + u·e. o + t d = a + u e → t d − u e = a − o = rhs. In components: t·dx − u·ex = rhx t·dy − u·ey = rhy

Matrix form: [dx, −ex; dy, −ey] [t; u] = [rhx; rhy]. det(M) = dx·(−ey) − (−ex)·dy = −dx·ey + ex·dy = ex·dy − dx·ey. ✓ matches my det.

t = (rhx·(−ey) − (−ex)·rhy) / det = (−rhx·ey + ex·rhy) / det = (ex·rhy − ey·rhx)/det.

In my code I divided by −det. That's the bug! t = (exrhy − eyrhx)/det, not /(−det).

u = (dx·rhy − dy·rhx)/det. My code: /(−det) — also wrong sign. Since u sign flips would reject valid hits (u<0) — explains failures.

Let me verify with a quick example: ray o=(−10,0), d=(1,0); segment a=(0,−1), b=(0,1) (vertical line x=0). ex=0, ey=2. det = ex·dy − dx·ey = 0·0 − 1·2 = −2. rhx = 10, rhy = −1. t = (ex·rhy − ey·rhx)/det = (0·(−1) − 2·10)/(−2) = (−20)/(−2) = 10 ✓. u = (dx·rhy − dy·rhx)/det = (1·(−1) − 0)/(−2) = (−1)/(−2) = 0.5 ✓.

So fix: divide by det instead of −det.

Then C2: secondary bow rays few (12 > 30 expected) — with correct energy maybe more; but 12 exists... the check expected >30 with 121 rays; the intensity cutoff 0.005: p=2 rays: I after entry (1−R)... at high impact params R grows; p=2 rays lose energy through two transmissions + two internal reflections partially... At the caustic (i≈72°): R at entry ≈ Fresnel s+p... could be ~0.1. Then transmitted 0.9; internal reflections at 40° (below critical 48.6) R0.05-0.1?? wait at inner surface incidence = r ≈ 41°; Fresnel at n=1.333→1 at 41°: R small (~0.07?) → p=2 intensity ~ 0.9·0.07·0.07·... ≈ 0.0044 < 0.005 cutoff → culled! That explains few p2 rays. But test C found 12 exits with refs==2 — from near-grazing rays with higher reflectance. Lower I_CUT to 0.003? The secondary bow in nature is indeed much fainter. For the demo I want it visible: options: lower cutoff (0.0025) — more segments everywhere; or boost: for the droplet preset it's fine. Let me set I_CUT default 0.0035. p=2 at caustic: entry R at i≈72°: unpolarized R maybe ~0.08 → T=0.92. Inner incidence r = asin(sin72/1.333)= asin(0.951/1.333=0.7134) = 45.5°?? hmm at caustic i≈71.9°, r = asin(sin(71.9°)/1.333) = asin(0.9507/1.333)=45.47°. Critical 48.75°. Fresnel R at 45.5° glass→water... n1=1.333 n2=1: close to critical: cosi=0.7006, cost: sin t = 1.333·0.7136=0.9513 → cost=0.3083. rs = (1.333·0.7006 − 0.3083)/(1.333·0.7006+0.3083) = (0.9339−0.3083)/(1.2422)=0.5036 → rs²=0.2536. rp = (1.333·0.3083 − 0.7006)/(1.333·0.3083+0.7006) = (0.4110−0.7006)/(1.1116) = −0.2605 → rp²=0.0679. R=0.161. Two internal reflections: I = 0.92·0.161·0.161 ≈ 0.0238, then exit transmission (1−R)≈0.84 → ≈0.02 > 0.005 ✓. So at the caustic p2 rays survive — the 12 found may be exactly near caustic. My test expectation >30 was too strict with 121 rays: rays at b evenly spaced; near caustic many rays... exit intensity also near 0.02·(weights). Hmm 12 < 30 but they exist. I'll relax the test to ≥8 and keep cutoff 0.005. Actually for visual richness I might lower cutoff to 0.004 for droplet preset via opts. Fine.

Also F: fiber guiding — 2 internal segments only. With the line fix, radial entry edge will intersect properly. Let me fix the sign and re-run.

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

Progress: fiber works now, and G found the reflected segment (R=0.0389 vs 0.0424 — hmm, slightly off; that's suspicious. R=0.0389 vs expected 0.0424. Wait, absorption? The reflected segment is born with I·R... at first surface entry: R = 0.0424 expected. Measured 0.0389. Hmm — maybe the segment found by my filter isn't the first-surface reflection but something else. Filter: s.x2 < s.x1 && Math.abs(s.x1 - (-4)) < 0.1 — reflection at x=−4 face. Its I0 should be exactly R=0.04238. Got 0.0389 — 8% lower. Hmm — 0.0389/0.0424 = 0.917. Not absorption (reflected never entered glass). Wait — actually let me reconsider: at entry face the ray transmits (1−R), hits back face, reflects R, transmits out front face (1−R): the ray traveling −x starting at x=−4 would be the multiple-bounce exit: I = (1−R)·R·(1−R)·exp(−absorb·16)... = 0.9576·0.0424·0.9576·e^(−0.192) = 0.0390·0.825 = 0.0322. Not it either. Hmm, 0.0389... What about first-face reflection: R=0.04238 exactly. 0.0389 ≠ that.

Hmm wait — maybe my test filter caught the multiple-reflection contribution which is at x≈−4 traveling −x... Actually maybe the test caught the second segment: reflection off the back face then transmitting out the front face starts at x=+4 traveling −x... no, x1=+4 not −4.

Actually let me think again about A failing: slab 6×6 at origin, laser at (−12, 0.8), angle 20°. Ray: d=(cos20, sin20)=(0.9397, 0.3420). Slab spans x∈[−3,3], y∈[−3,3]. Ray enters the left face x=−3 at t=(−3+12)/0.9397=9.577, y=0.8+9.577·0.342=4.08 — that's ABOVE the slab (y>3)! The ray misses the slab?? At 20° from x-axis starting y=0.8: at x=−3, y=0.8+9·tan20=0.8+3.28=4.08 > 3. Yes — misses! My test geometry is wrong, not the core. For G: laser at (−10,0) angle 0 → hits left face at x=−4... wait slab w=8 → hw=4. Slab spans x∈[−4,4]. Ray travels +x hits x=−4 face at y=0 ✓. Reflect R=0.0424. The filter found R=0.0389?? Hmm. Let me recompute n at 550: iorOf('crown',550): A=1.5045, B=0.00424, um=0.55, um²=0.3025, B/um²=0.014017, n=1.51852. R=((0.51852)/(2.51852))²=(0.20588)²=0.042387. Measured 0.0389.

Hmm... is it possible the found segment is the one from the internal reflection exiting the front face? That ray: enters (I=1−R=0.9576), reflects at back face (I·R... internal reflection R2 = same 0.0424 → 0.9576·0.0424=0.04058), travels back through glass (absorb e^{−0.012·8}=0.908), transmits out front (×(1−R)=0.9576): 0.04058·0.908·0.9576=0.03527. Not 0.0389 either.

Or the segment with x1=−4 traveling −x could be the FIRST surface reflection with... hmm what if cosi computed with non-unit... no.

Wait — maybe two segments match the filter and back[0] isn't the direct one? Both start at x≈−4 going −x: the direct reflection (I=0.0424) and the multiple-bounce one (I=0.0353). back[0] = whichever pushed first. 0.0389 is neither... Average? No averaging in segs.

Hmm, actually — absorption! The direct reflection: does my code apply absorption to the incident segment... The reflected CHILD has I = r.I·0.94?? No wait — that's mirror. For glass: IR = r.I·R = 1·0.0424. Unless... hold on, maybe the ray enters the slab top?? No, y=0.

Let me just debug directly in node rather than guess. Also A: fix test geometry (aim at slab: use angle 10° or y offset 0). D: lens crossing filter s.x1 < lens.R — R=13.557! Segments beyond the lens start at x≈1.4 (surface) — less than R=13.557 → filtered out. Bug in test filter: should be s.x1 < 2 (physical half-thickness) — use 3. E: prism white beam: source at (−20,0) angle 0; prism at origin r=7 angle 25°: does the beam hit? width 1.2 at y=0... prism rotated 25°, spans roughly |x|<7: yes should hit. exits kind==='prism' && refs===0 — zero found?? With line fix, prism lines now work (B failed though — B1 exits=0!). Let me debug B directly: prism r=8 at origin; laser from (−14, 2) horizontal +x. Left face is edge from (0,8) to (−6.928,−4): at y=2, the left edge x = interpolate: edge from v0(0,8) to v1(−6.928,−4): param u where y = 8 + u(−12) = 2 → u=0.5 → x = 0 + 0.5·(−6.928) = −3.464. Ray hits at (−3.464, 2). Should refract in. Then inside hits which face? Direction inside: normal of left face... incident angle vs face normal: face direction e = v1−v0 = (−6.928, −12)/|..| → normal n = −perp... incidence ≈ 30°−something; refracted toward normal, travels down-right, hits bottom face or right face at ~60° incidence > critical 41.5° → TIR → internal reflection → exits somewhere. B expects exits.some(refs>=1). Got exits=0 at all → the ray never even entered?? Or it entered and TIR'd forever until depth cap with no exit — possible: TIR at face2, then hits face... eventually must exit (unless trapped — impossible in 2D triangle? Actually a ray can in principle bounce repeatedly; but after TIR at face 2 at 60°, it goes to face 3 at some angle... Let's compute: classic prism: enter face AB near normal, TIR at AC, exit... For equilateral with entry near normal to left face: inside ray at ~ asin(sin(30°)/1.52)... incidence at first face 30° (face at 60° to horizontal)... refracted r = asin(sin30/1.5185) = asin(0.3292) = 19.2°. Ray inside deviates toward normal by 10.8°. Normal of left face points... ugh, easier to debug numerically.

Wait, exits=0 AND in test A segs=1 — A traced only 1 segment: the ray missed the slab entirely (geometry), explains A1/A3. E: input accounted 0: exits empty — prism didn't refract? B: exits=0 too. Common factor: prism. Maybe prism inside test fails: verts at 90/210/330: v0=(0,r), v1=(−0.866r, −0.5r), v2=(0.866r, −0.5r). Cross products: c0 = (p−v0)×(v1−v0)... sign convention: for ccw polygon, inside → all cross(edge, p−v) ≥ 0 where cross((p−vi),(vj−vi)) = (px−vix)(vjy−viy) − (py−viy)(vjx−vix) — hmm this is cross(p−vi, edge) = −cross(edge, p−vi). For ccw polygon, interior is to the LEFT of each edge: cross(edge, p−vi) > 0, i.e., (ex)(py−viy) − (ey)(px−vix) > 0. My formula: c0 = (x−v0x)(v1y−v0y) − (y−v0y)(v1x−v0x) = cross(p−v0, e0) = −cross(e0, p−v0). So my c ≥ 0 test checks RIGHT side → inside test is inverted or the winding... Are the verts ccw? v0=(0,8), v1=(−6.93,−4), v2=(6.93,−4). Shoelace: sum (x_i·y_{i+1} − x_{i+1}·y_i): (0·(−4) − (−6.93)·8) = 55.4; ((−6.93)(−4) − 6.93·(−4)) = 27.7+27.7=55.4; (6.93·8 − 0·(−4))=55.4 → positive → ccw ✓. So interior left of each edge, my c uses cross(p−v, e) = −cross(e, p−v) → negative inside → c0>=0 test fails for interior points! Prism inside is inverted → entry crossing test fails... but wait — entry crossing: in1=false(air ✓), in2=... just past surface inside prism → insideLocal returns false (inverted) → in1===in2 → rejected! But then how did E trace get anything... it didn't (0 exits).

But B produced no exits at all — consistent with prism never being entered.

So fix: flip comparison to <= 0, or reorder verts cw. Test point: centroid (0, 0): c0 = (0−0)(−4−8) − (0−8)(−6.928−0) = 0 − (−8)(−6.928) = −55.4 → c0 = −55.4 < 0. So with c <= 0 interior ✓. Flip all three to <= 0.

Now G's odd 0.0389: hmm, with prism aside, G's slab: it did find a reflected segment with R=0.0389. Let me recheck: maybe absorb applied to child creation... IR = r.I * R — r.I=1, R=? At 550nm crown... the code computes Fresnel with n1=1, n2=1.5185, cosi=1 (normal): rs = (1−1.5185)/(1+1.5185) = −0.20588 → rs²=0.0424; rp = (1·1 − 1.5185·1)... rp = (n1·cost − n2·cosi)/(n1·cost + n2·cosi) = (1−1.5185)/(1+1.5185) = same at normal → R=0.0424. So IR=0.0424. Measured segment I0=0.0389? Filter: back = segs where x2<x1 and |x1+4|<0.1. Could the FIRST such segment be the double-bounce exit (I=0.0353)? No, 0.0389 ≠ 0.0353.

Hmm wait, maybe I should check whether the direct reflection segment starts exactly at x=−4: yes, born at px=−4. Its I0 = 0.0424. Unless... back[0] picks first in segs order: segments pushed in trace order: seg1: incident (−10→−4). Then children processed (stack LIFO): transmitted pushed last? Order: reflected pushed first, then transmitted pushed → stack: [reflected, transmitted] → pop transmitted first! Transmitted goes through, hits back face x=+4, its reflected child (I=0.9576·0.0424=0.0406) travels −x from x=+4, transmit... The segment x1=+4 → not matching |x1+4|<0.1? x1=+4 → |4+4|=8 no. The internal ray traveling −x exits front face at x=−4: THAT segment spans x=+4→−4 traveling −x: x1=+4 (start), x2=−4. My filter requires x2 < x1 ✓ (but x1=+4 → fails |x1+4|<0.1). Then the exit child: born at x=−4 traveling −x with I=0.0406·0.908·0.9576=0.0353: x1=−4 ✓ x2<x1 ✓ → matches! And the DIRECT reflection also matches (born at −4, I=0.0424). Order: direct reflection is processed LAST (LIFO) → pushed later. So back[0] = the double-bounce exit 0.0353?? But measured 0.0389...

Hmm let me compute more carefully with absorb 0.012 over path 8+8=16: e^−0.192=0.8253. 0.9576·0.0424=0.04061 (after internal reflection); ×0.8253=0.03351; ×0.9576 (exit transmission)=0.03209. Not 0.0389.

What about I1 vs I0? back[0].I0 — segment START intensity (before absorption over that segment). The exit child born at x=−4 heading −x: I0 = 0.0321. Still not 0.0389.

Hmm 0.0389... Let me see: (1−R)²R/(1−...)... Or maybe the ray hits the slab's TOP edge? At y=0 the ray goes straight along the middle — no.

Wait, maybe the issue: my slab is 8×8: w=8 → hw=4, h2=8 → hh=4. Ray at y=0 hits left face ✓. Hmm.

Let me just debug in node quickly instead of guessing. I'll write a small debug script printing all segments for the slab scene.

Also A: fix geometry (aim at the slab properly: angle 20° from (−12, −2)? ensure y at x=−3 within ±3: y = −2 + 9·tan20 = −2+3.28=1.28 ✓). Then inside slab, exit face x=+3: should be parallel displaced ✓.

D: fix filter s.x1 < 2 (half-thickness h=1.4; exit surface at x≈1.4 → segments start ~1.4) and crossing test.

Also B: after prism inside fix, verify TIR behavior.

Let me debug G with a script.

The physics is perfect: the direct front-face reflection has I0=0.04239 exactly matching R=0.04239 ✓. The 0.03887 segment is the double-bounce ghost reflection (correct physics too: 0.04059·e^{−0.012·8}·... wait: internal reflection 0.04059 → travels back absorbing 8 units: I1 = 0.03688 → transmits out front: 0.03688·... hmm the exit child: at the front face, transmitted fraction (1−R)=0.9576: 0.03688·0.9576 = 0.03532? But shown 0.03887. Hmm: 0.04059/0.9576... Actually the exit at the front face: the internal ray arrives with I=0.03688 (after absorption over 8 units). Transmit (1−R): 0.03688×0.95761=0.03531. But the segment shows 0.03887. Let me recompute: 0.04059 = 0.95761·R(0.04239)=0.040590 ✓ (internal reflection birth intensity at back face). Travels 8 units in glass: ×e^{−0.096}=0.90846 → 0.036878 ✓ = I1 of that segment. Then exit: ×0.95761 = 0.035317. But segment 5 shows 0.03887. Discrepancy!

0.03887 / 0.036878 = 1.054. Hmm — the transmitted child I = r.I·(1−R) — but r.I here is the intensity at BIRTH of the parent (0.04059), not at the interface! Bug: absorption is only applied when PUSHING segments (pushSeg I1), but child rays spawned at the interface use r.I (start-of-segment intensity), ignoring absorption along the parent segment. So energy isn't absorbed correctly for children. Fix: compute the intensity at the interface: Ihit = r.I·exp(−medK·bestT) and use Ihit for all children/sparks/hits.

That's why G's first matching segment (double-bounce exit) was 0.0389 instead of 0.0353. After fix, G's filter will find both segments: the direct one (0.04239) and ghost (0.0353). Test picks back[0]; make the test pick the MAX intensity one (direct reflection).

So core bug #2: children must inherit attenuated intensity. Fix in traceScene: after computing bestT: const Ih = r.I * Math.exp(-(r.medK||0)*bestT); and use Ih in place of r.I for sparks, children (IR = Ih·R, IT = Ih·(1−R)), screenHits, exits. Also mirror: I2 = Ih·0.94; splitter: Ih·0.5·0.985.

Now fix prism inside orientation (c <= 0). Fix test A geometry. Fix test D filter (s.x1 < 2). Fix G to take max-intensity matching segment. Re-run.