Wake up

The task is "Wake up" - "Wake up and do as you please." Based on my purpose, I should create cool Three.js demos in my space under /space/demos/. The last execution created Demo 055 (Phantom Jam — Traffic Wave Laboratory). So I should create Demo 056 with a new, original, impressive concept.

Let me start by exploring the existing demos to avoid duplicating concepts, then create a new advanced demo.

Let me install shell tools first.

Let me look at the existing demos to see what's been done already.

***********************************************************************************************************ed.

****************************************************************************************************************************************56.

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

Now I have the full picture. 55 demos exist. Let me think about what concepts have been covered:

1. Spinning cube
2. Nebula galaxy (particles)
3. Mandelbulb (raymarched fractal)
4. Fluid dynamics (Navier-Stokes)
5. Gravity sandbox (N-body)
6. Event horizon (black hole lensing)
7. Sonic reactor (audio visualizer)
8. Void runner (endless runner game)
9. Azure odyssey (sailing)
10. Abyssal bloom (deep sea boids)
11. Physarum garden (slime mold)
12. Powder alchemy (falling sand)
13. Clockwork nebula (orrery/steampunk)
14. Neon rain (cyberpunk city)
15. Aurora borealis
16. Skitter (creature locomotion)
17. Coral resonance (cymatics lagoon)
18. Threshold (portal walker)
19. Attractorium (strange attractors)
20. Murmuration (GPU boids)
21. Terraforge (erosion)
22. Cloudsea (volumetric clouds)
23. Frostline (frost simulation)
24. Koi pond
25. Ferrofluid
26. Synchrony (fireflies/Kuramoto)
27. Cymatics (Chladni plate)
28. Teslasphere (plasma globe)
29. PyroSymphony (fireworks)
30. Morphogenesis (Gray-Scott)
31. Galton cascade
32. Wavefront (ripple tank)
33. Gossamer (spiderweb)
34. Magnetosphere
35. Cloud chamber (particle physics)
36. Wavefunction (hydrogen orbitals)
37. Epicycle (Fourier drawing)
38. Sandpile (self-organized criticality)
39. Kinetic theory (Maxwell-Boltzmann gas)
40. Lumen lab (ray optics)
41. Squish lab (soft body)
42. Neon tilt (pinball)
43. Hyperfold (4D polytopes)
44. Photon garden (path tracing)
45. Critical point (Ising model)
46. Bridge works (bridge building physics)
47. Primordial (Lenia)
48. Coasterworks (roller coaster)
49. Sakura grove (cherry blossom)
50. Voxelia (voxel world)
51. Neon district (cyberpunk city driving)
52. Supercell (tornado chase)
53. Caldera (volcano)
54. Domino rally
55. Phantom jam (traffic)

What has NOT been covered that would be a great "wow" demo? Let me brainstorm:

• Double pendulum / chaos pendulum gallery — nice but maybe too simple; but a chaos pendulum with trails and multiple pendulums could be great. Hmm.
• Flocking already done.
• Ocean/ship already done.
• Cloth simulation — flag or cloth tearing? Squish lab is soft-body jelly; cloth verlet was used in Gossamer spider web but not a dedicated cloth demo.
• Marble run / machine (Rube Goldberg) — Domino rally is close-ish.
• Electric field / charges sandbox — electrostatics: place charges, field lines, potential heatmap, test particles tracing field lines, Gauss's law flux meter. Not done! Lumen lab is optics; ferrofluid is magnetic dipoles; magnetosphere is planetary. A full electrostatics "field painter" lab could be cool: charges, conductors, field lines traced in real-time, equipotential contours, particle motion.
• Special relativity visualizer — Terrell rotation / relativistic flight through a lattice? Very advanced, hard to do well.
• Wave-particle duality / quantum double slit — 032 Wavefront does double-slit classical; 036 does hydrogen.
• Solar system formation / accretion disk / planet formation — gravity sandbox exists.
• Pendulum wave machine — the classic "pendulum wave" (15 pendulums with slightly different periods creating mesmerizing patterns). Not done! Could be a beautiful 3D pendulum wave with glow trails, bloom, audio. But is it "advanced" enough? It's a classic visualization. Could combine with double pendulums.
• Ant colony / swarm intelligence — physarum is close.
• Reaction-diffusion done.
• Sonic levitation / acoustic standing waves — cymatics done twice (027, 017).
• Tides / orbital resonances / Kepler orrery with real ephemeris — Clockwork nebula is orrery-ish.
• Bouncing droplets / pilot wave (walking droplets hydrodynamic quantum analog) — VERY cool and unique! Coupled particle-wave simulation where droplets bounce on a vibrating bath and interact with their own waves (Couder's walking droplets, "hydrodynamic quantum analogs"). GPU wave field + droplet dynamics on top. That would be original and impressive: single-particle diffraction analog, tunneling analog, orbital quantization. Complex though.
• Musical / harmonic oscillator — done-ish.
• Forest fire / DLA / lightning growth — Diffusion-limited aggregation: grow beautiful dendrites. Not done explicitly! DLA crystal growth with millions of particles. Could be "Dendrite" — lightning bolts growth, frost is related but Gravner-Griffeath is different. DLA would be cool but maybe visually limited.
• L-system fractal trees 3D — Sakura grove has procedural trees.
• Turing patterns done.
• Game of life 3D? — Lenia done.
• Spring-mass cloth / jello — squish lab.
• Rope/hair simulation — not notable.
• Boids done multiple.
• Voronoi / Delaunay / fracturing / shattering — a glass shattering demo with Voronoi fracture physics! Smash objects, slow-mo, chunks fly. Not done. Could be fun: "Shatter Lab".
• Planetary collision / SPH smoothed particle hydrodynamics — SPH water sloshing in 3D! A liquid slosh tank with thousands of SPH particles — "Aqua Lab". Fluid dynamics 004 is 2D Eulerian dye. A 3D SPH particle water in a glass tank with splashing would be quite impressive and different.
• Tesseract done (Hyperfold).
• Knot theory / flowing knots — not notable.
• Maze generation + solving — meh.
• Ray marching done (Mandelbulb, Cloudsea).
• Caustics / water caustics — part of others.
• Double pendulum art / harmonograph — harmonograph! A harmonograph drawing machine (like Epicycle but pendulum-based). Epicycle covered Fourier drawing though.
• Origami / folding — hard.
• Time crystals — too abstract.
• Granular materials / hourglass — sandpile done (but that's cellular), a real granular DEM hourglass with thousands of grains flowing could be nice. Powder alchemy is falling sand cells. A 3D granular flow (DEM) hourglass / silo discharge with clogging arches... niche physics, visually nice but maybe heavy.
• Aerodynamics / wind tunnel / lift visualizer — airflow over airfoil, streamlines, smoke particles, angle of attack stall! Not done. A wind tunnel lab with lattice-Boltzmann or potential-flow around shapes (airfoil, car, cylinder, Kármán vortex street). Lattice Boltzmann on GPU in 2D rendered in 3D space. Kármán vortex shedding behind a cylinder is gorgeous. Interactive: change shapes, angle of attack, Reynolds number, smoke injection, lift/drag readouts. That's a great "laboratory" demo in the style of the series. Name: "Slipstream — Wind Tunnel Laboratory" or "Aerolab".
• Soap film / bubbles (Plateau's laws, minimal surfaces) — soap bubble clusters with thin-film interference shaders, minimal surface solver. Beautiful! Could be "Soapworks": blow bubbles, they merge into clusters with Plateau borders, thin-film interference colors (iridescence), pop dynamics. Advanced: dynamic bubble cluster physics (Surface Evolver-lite is hard, but can fake with spring foam like Brakke). Might be too hard to make robust.
• Light echoes / gravitational waves / LIGO interferometer — gravitational wave ripples through spacetime grid with merging black holes, chirp audio! That's a cool one: "Ripples in spacetime" — visualize a binary black hole merger: spacetime mesh deforming, plus polarization modes (plus/cross) on a ring of test masses, matched-filter chirp sound. Original and topical! Could be "Chirp — Gravitational Wave Observatory". Mesh grid deforming is visually straightforward (custom shader on a grid), BH orbits with trails, strain readout like LIGO. Hmm, but black holes visual similar to event horizon? Different enough (focus on waves).
• Foucault pendulum — too simple alone.
• Spring lattice / wave on membranes — wavefront done.
• Projectile / ballistic / siege physics game — meh.
• Ecology / predator-prey Lotka-Volterra with agents — could be a nice "biosphere" sim but physarum/boids adjacent.
• Antikythera / astronomy — clockwork nebula adjacent.
• Procedural marble races — domino rally adjacent.
• Rope bridge / procedural animation done.
• Electrostatics field lab — I mentioned. Place positive/negative charges, watch field lines in real time (integrate along E), equipotentials, dipole, conductors (image charges approx), particle accelerator with test charges, "ion cannon". Very visual with glow lines + particles + bloom. Name: "Voltaic — Electrostatic Field Lab". Not covered (ferrofluid uses analytic dipole magnets; lumen is light). This is a solid candidate.
• Superconductivity / magnetic levitation / flux pinning — niche.
• Relativistic Doppler / starship — hard.
• Star cluster dynamics / globular cluster — gravity sandbox adjacent.
• Seismic waves / earthquake through layered earth — niche.
• Plate tectonics — hard.
• Snowflake studio — frostline adjacent.
• Ink in water / marbling — fluid done.
• Musical instruments physics: drum modes, guitar string, wind — cymatics adjacent.
• Chladni done.
• Bokeh/photography simulator — meh.
• Robotics / kinematic arm playground — meh.
• Space elevator / tether dynamics — niche.
• Combustion / fire spread sim — caldera/pyro adjacent.
• Buoyancy / ships sinking — azure odyssey adjacent.
• Crowd dynamics / pedestrian flows (social force model) — phantom jam is traffic; a pedestrian crowd crossing, lane formation, evacuation through doors with "faster-is-slower" effect. Helbing social force model! Visually: top-down people agents with nice rendering. It's adjacent to phantom jam but different phenomenon (lane formation, arching/clogging at exits, oscillating flows at bottleneck). Might feel too similar to 055 though.
• Ecological "rock-paper-scissors" spiral patterns — nice but niche.
• Quantum tunneling / wave packet lab — 036 is quantum; a wave-packet time evolution (TDSE) with barriers showing tunneling could be gorgeous: probability density evolution, split-step FFT on GPU. Nice lab: "Tunnel — Quantum Wave Packet Lab". Hmm, quantum already has a showcase (036) but that's eigenstates; time evolution/tunneling is a different phenomenon. Possible.
• Orbital mechanics game (Kerbal-lite) — gravity sandbox adjacent.
• Diffusion-limited aggregation (DLA) "Dendrite Lab" — grow copper dendrites electroplating-style: millions of particles random walking, sticking into fractal trees; render as glowing 3D dendrites. GPU-friendly? DLA is sequential-ish; can do with many walkers in parallel in fragment shader (walker positions in texture). Could be visually stunning with bloom. Combine with electrodeposition story: anode/cathode, "electroplating bath". Name: "Dendrite — Electroplating Lab". Unique! But risky performance/impl complexity.
• Brownian tree / dielectric breakdown model (DBM) lightning growth — Lichtenberg figures! Grow lightning through insulating material toward ground plane, fractal branching (η parameter). Rendered as glowing fractal trees etched in acrylic block. Beautiful and quite unique. "Lichtenberg — Fractal Lightning Lab". DBM growth on grid: candidates grow with probability ∝ φ^η, solve Laplace each step — expensive on CPU but can be done with iterative relaxation on GPU (Jacobi iterations for Laplace equation). That's a real GPGPU Laplace solver demo. Very cool but implementation-heavy.
• Wind tunnel (Lattice Boltzmann) — I keep coming back to this. It's a classic "wow" computational physics demo (cf. daniel-schroeder's LBM wind tunnel). Implementation: D2Q9 LBM on GPU ping-pong textures, 256x96 or 384x128 grid, obstacles (cylinder, airfoil, flat plate), velocity/curl visualization with smoke streamlines (advected particles on GPU), lift/drag integration, Reynolds slider, angle of attack. Rendered in 3D perspective as a glowing tunnel with OrbitControls, HUD gauges. This fits the series' "laboratory" style (like 032 Wavefront, 040 Lumen Lab). It's technically impressive and not yet covered. Risk: LBM stability with BGK at moderate Reynolds is OK (keep velocity ~0.08-0.12 lu, tau ~0.56). Interactive draw obstacles.

Given the series, the wind tunnel demo would be a great addition: "Slipstream — Lattice-Boltzmann Wind Tunnel". It's a well-understood algorithm (D2Q9), I can write it carefully, and test numerically in Node (CPU reference implementation for physics sanity, e.g., drag coefficient of cylinder 1.0-1.2 at Re100... Actually for LBM D2Q9 at Re≈100 drag coefficient ≈ 1.4? The classical value: Cd ≈ 1.2-1.4 for cylinder at Re=100. Also Strouhal number ≈ 0.16-0.17 for vortex shedding at Re=100 — I can validate shedding frequency in headless tests!). That's testable physics — great.

Alternative: Walking droplets (pilot-wave hydrodynamics) — gorgeous and mind-blowing ("bouncing droplet quantum analog"). Implementation: wave field via wave equation memory (like wavefront but with exponential memory kernel), droplets bounce and get kicked by local wave slope (gradient), velocity Verlet with damping. Show: free walker, double-slit diffraction histogram analog, tunneling over barrier, corral confinement with eigenmode statistics. That's VERY unique — nothing like it in the list (032 Wavefront is the closest but it's a static-source ripple tank). The physics model is well documented (Moláček & Bush model with logarithmic spring memory, or simplified Milewski/Galeano-Rios). A simplified "walker + memory wave field" works well in 2D on GPU. Rendering: 3D bath surface deformed by waves (like koi pond/wavefront), droplets as glossy spheres casting ripples, bouncing with shadows. HUD: speed, bouncing phase, histogram. This could be the most original "wow" demo — hydrodynamic quantum analogs are a hot topic. But there's risk the simplified model fails to produce stable walkers; needs careful tuning. The Milewski 2015 model: vertical dynamics log-spring with bath memory; horizontal: wave kick ∝ gradient at impact. I've seen convincing 2D walkers with the "stroboscopic" model: droplet impacts add a Bessel J0 bump to wave field with exponential decay; droplet velocity relaxes toward wave-prescribed kick. Actually the Durey/Moláček-Bush stroboscopic model: x¨ + D x˙ = -F ∇h(x, t_n) sampled at bouncing times — continuous version: m x¨ = -D x˙ + F·(-∇h(x,t)). Wave field: h_t + γh = wave equation with droplet impact sources J0(k_F r). That can run on GPU: wave field texture, droplets few in number (CPU), impacts splat bumps into field. This is doable and I can tune until walkers walk (validate in Node headless with CPU grid).

Both are strong. Let me decide:

• Wind tunnel LBM: robust, well-understood, guaranteed to work, beautiful (vortex streets), but "another fluid demo" (004 exists though that's Navier-Stokes dye Eulerian; LBM with obstacles + lift/drag + smoke is different flavor). Kármán vortex streets are iconic.
• Walking droplets: unique phenomenon, "quantum analog" story is a great hook, includes double-slit analog which pairs with 032's theme. Higher tuning risk but manageable, and I have time to tune via headless Node tests.

I think the walking-droplet pilot-wave demo is more original and magical: droplets that walk, diffract, tunnel, and orbit. Let me design "WALKER'S MILL — Pilot-Wave Hydrodynamics Laboratory"? Name ideas: "Pilot Wave", "Droplet Walkers — Hydrodynamic Quantum Analog", "Walk on Water". Let me go with "Promenade — Pilot-Wave Droplet Lab"? Hmm. Maybe "Rainwalkers"? "Striders"? The series uses evocative one-word titles: Gossamer, Synchrony, Threshold, Caldera, Primordial. I'll name it "Promenade — Walking Droplet Laboratory"... Actually "promenade" fits (walking). Or "Wavewalker". I like "Wavewalker — Pilot-Wave Droplet Lab".

Plan for Demo 056: Wavewalker — Pilot-Wave Droplet Laboratory

Physics (based on published hydrodynamic pilot-wave models):

• Bath: 2D GPU wave field h(x,y,t) on a grid (e.g., 384×384 or 512×512 float texture), evolved with a damped wave equation with exponential memory: Approach A (discrete memory, Milewski/Durey): each droplet impact at time t_n adds a localized bump φ(r)=A·J0(k_F r) (Bessel) to the field; field decays with memory time τ = T_F·M_e/(1-Γ/Γ_F)... Simplified: h_t = -γ h + impacts; plus wave propagation? In the real model, each impact wave is a standing Bessel oscillation decaying — the field is the superposition of decaying Bessel bumps centered at past impact points. The key: field = convolution over past impacts. GPU-friendly approximation: maintain two textures (field H and velocity V) of a strongly damped wave equation: ∂²h/∂t² = c²∇²h - 2γ ∂h/∂t - ω_d... Actually many simplified implementations (e.g., "hydrodynamic pilot-wave" web demos by MIT group) use: each impact deposits a Bessel bump into a field that then propagates outward and decays — implemented as damped wave equation (telegraph equation): h_tt = c²∇²h - γ h_t, with impact splats. With γ tuned (memory parameter): high damping = short memory = slow walking; low damping (near Faraday threshold) = long memory = chaos/quantization. I'll use the telegraph/damped-wave equation on GPU with splats from impacts — same machinery as Wavefront (ping-pong float buffers), so the GPU part is proven. Droplets (1–40) live on CPU, cheap.
• Droplet vertical dynamics (stroboscopic): droplet bounces periodically at the Faraday frequency (period T_F). Model bounce: droplet has vertical state; each bounce samples the local field height h at its position → kick direction. Simplified "stroboscopic model" (Moláček & Bush 2013, Durey): m x¨ = -D x˙ - m g_eff? The standard stroboscopic horizontal equation: m ẍ + D ẋ = -F(t)·∇h(x, t) with F(t) = periodic delta at bounces → in continuous approximation: m ẍ = -D ẋ - C·∇h(x,t) where C couples to local slope. The wave field h includes the droplet's own past bumps (self-interaction!) which is what makes it walk: the droplet is pushed by the slope of the waves it created at previous bounces, which are behind it. Impact splat: at each bounce (every T_F seconds), add bump to wave field: A·J0(k_F·r)/something, at droplet position. Also the bounce phase can be modulated by local field height (bouncing on a crest vs trough changes impact timing/force) — crucial feedback for wave-driven speed variations; simplified: kick coefficient modulated by (1 - h(x)/h_s)... The Moláček model: the horizontal force during contact ∝ (impact force)·∇h, and impact force depends on phase. In the stroboscopic model of Durey & Milewski: x_{n+1} dynamics with kick K·∇h_n. Simplest robust scheme (used in many interactive demos): v' = v + dt·(-k_d·v - K_h·∇h(x)) (overdamped-ish with small mass for stability) x' = x + dt·v' with K_h modulated: K_h = K0·(1 + β·cos phase)? Keep it simple: K_h constant; walking emerges because field behind droplet is higher (recent bumps), creating net slope pushing it forward; direction selected spontaneously (symmetry breaking) and perturbed by boundaries/other droplets. Add small noise to trigger symmetry breaking. Speed regulation: droplet speed settles when drag balances wave force — free walkers reach ~ steady speed. Good.
• Boundaries: reflecting walls (damped sponge for waves; droplets reflect with some loss or specular bounce). Geometry presets:
  1. Open pool (corral): circular dish, free walking, watch emergence of orbiting quantized states in a corral! Famous result (Harris & Bush 2013): droplet in circular corral walks in quantized circular orbits. I can include a corral preset: circular cavity, wave damping high outside cavity.
  2. Double slit: two barriers with slits; a source fires droplets one at a time toward the slits; record landing positions on a far "detector screen" → build the histogram showing wavelike diffraction/interference (Fourier transform of slit geometry — single-particle diffraction, Couder & Fort 2006). The histogram accumulates live! This is the money shot.
  3. Tunneling: a submerged barrier (shallow region = wave-damping strip) that walkers cross with probability depending on memory and width (Tucci/Couder tunneling analog). Count crossings → tunneling probability readout.
  4. Orbital pair / promenade modes: two droplets bind into orbiting pairs (droplet-droplet wave-mediated interaction). Sprinkle several droplets → they form pairs, orbit states.
  5. Lattice/peg scattering? maybe skip.
• Controls/HUD: memory slider (Γ/Γ_F, the "vibration forcing"), droplet count, preset scenes, play/pause, speed control, add droplet by clicking (splash!), detector histogram reset, tunneling counter, live wave field rendering as a 3D deformed surface (vertex displacement from field texture) with emissive crest/trough coloring, droplets as glossy metallic spheres with squash-stretch on bounce and ripple rings, soft shadows, bloom, grade pass. Camera: orbit + top view toggle. Audio: generative plinks on each bounce (pitch by droplet index/position), ambient pad tied to field energy, whoosh on tunneling event, soft thump on slit hit. Histogram shown as 3D bar strip on the detector screen + canvas overlay? Better: accumulate landing positions into an array, render histogram bars as instanced boxes on the detector wall + 2D canvas readout.

Wave field GPU update (telegraph equation): H and H_prev textures; update: H_next = c²·dt²·lap(H) + 2H - H_prev - γ(H - H_prev) + splats Standard: u_next = (c²dt²/dx²)·lap + 2u - u_prev·(1-γdt) ... plus sponge borders and damping-mask (shallow regions higher damping). Also a damping mask texture: encodes geometry (walls, slits, shallow barrier, corral): R = wave speed multiplier, G = damping multiplier, B = wall (reflect droplets). Generated on CPU per preset into a DataTexture.

Droplet bounce timing: each droplet has a phase timer; bounce period T_F (e.g., 0.09s sim time). On bounce: splat bump into wave field via an additive splat quad (render small radial bump (Bessel-ish profile approximated by cos-ring shader) into H at position, amplitude A). Also droplet gets squash animation trigger and plink sound. Between bounces: integrate horizontal motion with force -K∇h (sample field gradient from texture via CPU readback? No! CPU can't read GPU texture cheaply each frame... but few droplets — gl.readPixels of a small region? That's slow-ish but for a 512² float texture, reading a 5×5 region per droplet per frame is okay (WebGL readPixels stalls pipeline though). Alternative: run the wave field on CPU? 512² = 262k cells × maybe 2-3 substeps — 1M+ ops per frame in JS: feasible at 256² (65k cells) definitely. Hmm.

Actually simplest robust architecture: run the wave field on CPU (Float32Array 256×256 or 320×320), upload to texture each frame for rendering (texSubImage2D/upload via THREE.DataTexture, needsUpdate = true — 256×256×4 bytes = 262KB upload/frame, fine). This avoids readback entirely and makes droplet-field coupling trivial and tunable, plus headless-testable in Node (identical code!). The series did similar for Lenia? Lenia was GPU. Sandpile CPU. Kinetic theory CPU. Fine — CPU wave field at 256² with telegraph equation ≈ 65k cells × ~10 flops ≈ trivial. Even 384² = 147k cells fine. I'll do 320×320 or 384² with typed arrays, fixed grid. Upload as float texture (or half float / byte-encoded). Use THREE.DataTexture with FloatType, LinearFilter — displacement in vertex shader + coloring in fragment shader, need OES_texture_float_linear (universal on desktop; fallback nearest). Good.

Splat bumps: droplet bounces up to ~11 times/sec each; 40 droplets → 440 splats/sec, each splat touches ~(2R)² cells with R≈7 cells → ~60×60=3600 cells ×440/s ≈ 1.6M cell-writes/s — fine.

Wave equation parameters: grid dx, c (wave speed), damping γ, memory control = γ slider (labeled Γ/Γ_F vibration forcing mapped inversely to damping). Telegraph: h_tt = c²∇²h − 2γ h_t. Discrete with dt: h_next = 2h − h_prev + (c dt/dx)² lap(h) − 2γ dt (h − h_prev) Stable if c·dt/dx ≤ 1/√2 (2D). Choose dx=1 cell, c=0.35 cells/step? Want wavelength λ_F ≈ maybe 12-16 cells (droplet radius ~5 cells, Faraday wavelength few mm vs droplet 0.8mm: ratio ~5-6). Bessel bump J0(k_F r) with k_F = 2π/λ_F.

Droplet horizontal dynamics (per droplet), integrate with dt_sim: ẍ = (−D·v − K(t)·∇h(x))/m ... use semi-implicit Euler with small mass: v += dt·(F_wave − D v)/m; x += dt·v F_wave = −K·∇h sampled with central differences, K>0 pushes toward crests? Sign: droplet is kicked up the local slope? Physically the droplet bounces on an inclined surface → horizontal kick proportional to slope, directed downhill of the surface at impact: if surface slopes up ahead (∇h>0 ahead?), the droplet rebounds moving away from higher side — kick = −k·∇h (accelerates toward lower field). Combined with its own trail (higher behind), it gets pushed forward. I'll implement F = −K·∇h and tune; if walkers don't walk, flip sign. Headless tests will decide empirically: free walker should reach steady speed ~ c·(0.2–0.5)·(λ_F/T_F)? Real walkers move ~ 0.2–0.5 × wave phase speed. I'll tune K, D, m so steady speed ≈ 0.25·λ_F/T_F in cells/sec and walking emerges robustly from noise. Also modulate splat amplitude/kick by bounce "phase": droplet's vertical bounce timer with period T_F; impact force larger if field at position is rising? Simplify: constant amplitude, but K modulated by (1 − clip(h(x)/h_c)) so bouncing on crest weakens kick (gives speed regulation and orbital stability). I'll experiment in Node headless tests.

Vertical bounce animation: droplet z(t) = parabola between bounces, peak height scaled; squash at impact. Shadow blob.

Corral orbiting test: in circular cavity, droplet should settle into circular orbit with radius among preferred set — headless test: measure angular momentum sign persistence & radius histogram peaks. Maybe too strict; I'll just check it orbits (radius stabilizes, angle progresses monotonically) rather than quantization.

Double-slit histogram: source launches droplets sequentially from left with slight lateral jitter toward slits; when droplet reaches detector line x > x_det, record y into bins, recycle droplet to source. Histogram bins shown as bars. Expect multi-peak interference-ish pattern (for point source through double slit, Couder got wavelike histogram). Validate roughly: histogram has multiple peaks (≥3 local maxima above threshold) — hopefully. At least diffraction envelope. I'll tune.

Tunneling: barrier strip with high damping; walkers hit it repeatedly; crossing probability ~ 5-15% per approach (Couder 2009 ~ few %). Count crosses per bounce-off. Validate crossing occurs occasionally (0 < p < 0.5).

Pair formation: two nearby droplets → bound pair orbiting (promenading). Validate distance stays bounded & < threshold for a while.

This is a rich lab. Presets:

1. Open Pool — free walkers; click to splash droplets; watch them walk, self-organize, avoid/collide.
2. Corral Orbits — circular corral, one droplet → quantized-ish orbits; radius histogram optional.
3. Double Slit — the quantum-analog experiment with live histogram & detector screen bars.
4. Tunnel Barrier — shallow strip; tunneling counter & probability.
5. Promenade — two+ droplets binding into orbiting pairs / trios. Maybe 6. Lattice crystal? skip; 5 presets enough.

Extra features:

• Memory (Γ/Γ_F) slider 0.5–0.99 → maps to damping γ = γ0·(1−Γ) → dramatic behavioral change: low memory: sluggish walkers; high memory: fast, chaotic, quantized.
• Trails for droplets (ribbon or line trails) — with fading (use THREE.Line with vertex colors alpha fading, or Points trail buffer per droplet; simple: each droplet has a trail of last N positions rendered as a Line with additive blending; 40 droplets × 120 points = fine).
• Field rendering: plane geometry (256×256 segments? heavy: 65k verts fine) displaced in vertex shader by field texture; fragment shader colors crest cyan / trough violet / emissive, plus geometry mask (walls dark, shallow amber tint) — combine mask texture. Add subtle specular. Under bloom, gorgeous.
• 3D chrome droplets: spheres with env-ish shader (fake studio), squash & stretch, glow rim; small point light? Skip dynamic lights; fake with emissive.
• Detector screen: vertical wall at right in double-slit preset; instanced bars showing histogram; also count display.
• HUD: top-left title/instructions; top-right stats (walkers, avg speed in "mm/s", memory %, tunneling probability, histogram count); bottom-left preset buttons + memory slider + droplet slider; bottom-right buttons (pause, reset, snapshot, audio mute, trails toggle, top view).
• Keyboard: Space pause, 1-5 presets, T trails, V top view, M mute, R reset, S snapshot, click = splash droplet.
• Audio: WebAudio generative: plink per bounce (sine/triangle blip with pitch depending on droplet index & field amplitude), soft pad (field-energy driven), splash on click, chime on slit pass / tunneling event. Master mute, starts on first gesture.
• Post: UnrealBloom + custom grade (vignette, grain, chromatic aberration) — reuse pattern from other demos. Adaptive quality: reduce grid res / disable bloom if FPS low.
• Snapshot PNG button.
• Touch support: tap = splash, UI buttons large enough.

Physics time-stepping: sim dt fixed (e.g., 1/240 s) with accumulator, up to N substeps per frame; wave field 2 steps per droplet step? Keep CFL safe: choose dt relative to cell units.

Let me also confirm naming/numbering: 056-wavewalker. Title: "Wavewalker — Pilot-Wave Droplet Lab".

Alright — significant build. Let me be methodical:

1. Write the core simulation as a standalone JS module used both by the HTML demo and Node tests (put physics in a separate file sim.js (ES module) imported by index.html via <script type="module"> and by node test). Self-contained requirement says single-page HTML "plus any assets" — a local sim.js module file in the same folder is fine (it's part of the demo folder). Previous demos like 055 likely did similar. Check how 055 structured (they said tested via Node — maybe inline copy). I'll check 055 folder.

2. Headless Node tests: a. Wave field sanity: splat → ring propagates & decays; no NaN. b. Walker emergence: single droplet in open pool, Γ=0.9, after t seconds speed in [v_min, v_max], direction persists (dot(v(t), v(t+Δ))>0.7). c. Corral orbit: radius stabilizes, mean angular speed nonzero. d. Double slit: after N detections, histogram has ≥3 peaks; symmetric-ish. e. Tunneling: 0<p<0.6 over enough approaches. f. Pair binding: two droplets distance bounded. g. Long stress: 120s sim with 20 droplets → no NaN, positions in bounds, speeds bounded.

   Tune parameters until tests pass.

3. Build index.html with full rendering/UI/audio/post; import sim.js.

4. Validate HTML/JS syntax (node --check for module, maybe quick jsdom-less DOM ref check by grep), update index page.

5. Done.

Let me look at an existing recent demo for conventions (import map, post shader pattern, UI structure) to stay consistent and reuse proven code patterns. Check 055-phantom-jam and maybe 032-wavefront for the wave machinery and 026/030 for UI patterns.

The demos are single-file HTML. The task description says "self-contained single-page HTML files using Three.js from a CDN". Demo 055 was tested in Node — maybe by extracting JS. Let me check how the import map is set up in 055, and how the physics is organized (to see if I can extract it for testing).

Single-file with import map using three@0.160.0 from unpkg. Physics is inline in the module script. For testability, I'll write the physics in a separate sim.js ES module (pure JS, no THREE imports) in the demo folder, import it from index.html, and test it directly in Node. That keeps index.html self-contained-ish (the demo folder contains both files, which is fine per instructions: "containing an index.html (self-contained demo) plus any assets").

Now, the plan: Demo 056 — "Wavewalker — Pilot-Wave Droplet Laboratory".

Let me design the simulation carefully.

Physics design

Units

• Grid: N×N cells, N=384 for quality (or 320). Cell size dx = 1 (sim units).
• Droplet radius r_d ≈ 5 cells? Faraday wavelength λ_F ≈ 4.7mm real, droplet ~0.7mm diameter. Ratio λ_F/r_d ≈ 13. Let me pick droplet visual radius 4 cells, λ_F = 28 cells? For a 384 grid: pool of 384 cells wide ≈ 13.7 λ_F. Real corrals ~ 4-6 cm ≈ 10 λ_F. OK.
• Bessel bump J0(k_F r): first zero at r ≈ 0.38 λ_F ≈ 10.7 cells. Bump support cut at r ≈ 0.6-0.8 λ_F.

Wave field (telegraph equation)

h_tt = c²∇²h − 2γ h_t (+ splat sources as velocity impulses or direct h additions)

Discrete: h_new = 2h − h_old + C²·lap(h) − G·(h − h_old), where C = c·dt/dx, G = 2γdt. Stability: C ≤ 1/√2 ≈ 0.707. Choose C = 0.5 (fast propagation). λ_F = 28 cells → wave period T_wave = λ_F/(C cells per step) = 56 steps.

Bounce period T_F should be ≈ 2× wave period? Physically the Faraday waves oscillate at f_F/2 and the droplet bounces at f_F/2 too (period doubled). For the model, the emitted wave needs to persist and interfere. Let me just say bounce period T_B = 24 steps (droplet bounces 2-3 times per wave period — that's fine, the superposition creates a standing-ish pattern).

Actually in the successful stroboscopic models, the field is a sum of Bessel bumps each decaying exponentially with memory time, NOT propagating waves. The Durey-Milewski "stroboscopic" field: h(x,t) = Σ_n A·J0(k_F|x−x_n|)·exp(−(t−t_n)/τ)·H(t−t_n)·cos(ω_F(t−t_n)). Bumps do NOT propagate; they oscillate in place and decay. This is crucial for stable walking — the walker rides the "slope" of its past bumps.

Two implementation options:

1. Propagating damped wave equation (telegraph): bumps radiate outward as rings and decay. Walkers still emerge (many web demos show walking with propagating fields; e.g., the "hydrodynamic quantum analogs" interactive demos). Propagation disperses the trail behind the droplet, still giving net forward push. Simpler: single pass update, no history list. Risk: less stable walking, more "surfing" on own ring.
2. Static decaying Bessel bumps: each bounce adds a bump to a "height" texture; update each step: h *= exp(−dt/τ) (pure decay, no propagation). The gradient at droplet position from the superposition of recent bumps gives the kick. This is the Moláček-Bush logarithmic-spring/stroboscopic approximation. Extremely stable walkers — this is literally the published model. Update: h_new = h·decay + splats. One multiply per cell + splats. Trivial, fast, robust. The memory parameter τ controls everything: τ small → short memory → slow walk; τ → critical → fast walking, chaos.

But pure decay without propagation looks less "watery". Hybrid: damped wave equation with strong damping — with γ large, propagation is negligible and it approximates decaying bumps; with γ smaller, rings propagate a bit before dying. The telegraph equation with spatially-varying damping handles "shallow" regions (barriers) elegantly — higher damping under barrier = wave attenuation = tunneling analog. And for rendering, propagating ripples are prettier.

I'll go with the telegraph/damped-wave field and tune damping so walking works (validate in Node). If walking fails, fall back to pure-decay model. Actually, let me implement the field update with BOTH: h_new = 2h − h_old + C²·lap(h) − G(h − h_old) — with G reasonably large this IS approximately exponential decay with mild propagation. Tune C and G via tests.

Hmm, but there's a subtlety: the oscillation. In the stroboscopic model the wave force is sampled at bounce times only (stroboscopic averaging removes the fast oscillation). If my field doesn't oscillate (telegraph eq with splats as positive bumps only, no oscillation), then continuous gradient sampling is fine and cleaner. Splats always positive bumps (each bounce "dents" the bath... actually a bounce creates a wave trough? sign matters little; use positive).

So model per droplet i:

• Bounce timer: phase φ_i advances; when φ_i wraps (period T_B steps), splat: add A_b·B(r) to h at (x_i), where B(r) = J0(k_F r) windowed (cut at second zero, smooth edge). Trigger plink + squash anim.
• Horizontal: v̇ = (F_wave − D·v)/m, with F_wave = −K·∇h(x_i)·g(phase?) — In stroboscopic models the kick is applied only at bounces: v += −k·∇h at each bounce. Between bounces: drag only: v̇ = −(D/m) v. That gives cleaner dynamics (no continuous surfing). I'll do impulsive kicks at bounces + continuous drag. This is the Durey-Milewski model exactly:
  • kick at bounce n: v → v − (C_k/m)·∇h(x_n)
  • flight: v → v·exp(−(D/m)dt)

Walking analysis (1D, from Durey): with bumps decaying exp(−t/τ), kick strength k, drag D... steady walking speed exists above a memory threshold. Noise breaks symmetry. This model is proven to walk, orbit in corrals, diffract through slits, tunnel.

Additionally modulate kick amplitude by local wave height at bounce (phase adaptation): in reality, if the droplet lands on a crest, the bounce timing shifts (the "bouncing phase" locks). A common refinement: kick ∝ (1 − h(x_n)/h_sat) clipped to [0.2, 1]. Hmm, or make the splat amplitude constant and kick ∝ ∇h only. Let me include gentle saturation to prevent blowup at high memory: kick_k = C_k·∇h/(1 + |∇h|/g_sat)? Simpler: clamp |kick| to max. Also cap field amplitude.

• Collisions droplet-droplet: soft repulsion when closer than ~2 r_d (spring push), so pairs don't overlap; the wave-mediated attraction emerges naturally from fields (each droplet attracted up-gradient of the other's bumps — actually kick is −k∇h so toward lower h... the neighbor's bump raises h → gradient points away → −k∇h pushes away from the bump peak. Hmm wait: ∇h points uphill (toward bump center). −k∇h points away from bump center → repelled from neighbor's bump?! But walkers bind...

Let me think again. In the real physics: droplet bounces on a surface with local slope; it receives horizontal impulse proportional to slope, directed down-slope (the bounced droplet shoots toward the lower side)? Physically: the droplet lands on a tilted surface, the reaction force has a horizontal component pushing it toward the uphill direction? Consider surface h(x) with slope dh/dx > 0 (rising to the right). The droplet lands and rebounds; the surface normal tilts to the left (normal = (−dh/dx, 1)/norm → horizontal component negative → pushes left = downhill). So kick = −k∇h: pushed downhill. ✓.

Now self-trail: droplet moving right leaves bumps behind (to its left). Field higher to the left → ∇h points left → kick pushes right → keeps moving right. ✓ Self-sustained walking.

Neighbor interaction: droplet B sits in the bump field of A. Near A's latest bump, h peaks at A's position; B located to the right of A feels ∇h pointing left (toward A) → kick pushes right, away from A: repulsion. But B also feels A's older bumps... In practice stroboscopic models show bound states and orbiting pairs due to the oscillatory Bessel profile (J0 has negative ring: the first trough of J0 creates attraction at that radius — droplets sit in each other's first minimum). With damped-wave propagation the rings spread... The J0 bump has a negative ring at r ∈ (0.38λ_F, 0.6λ_F): there ∇h points outward (from peak descending into trough) → kick pushes inward → attraction shell at that radius! That's how bound pairs form with equilibrium spacing ≈ 0.45 λ_F. Nice — as long as my splat profile resembles J0 (with negative ring) and damping isn't too high.

For the corral: walls reflect waves imperfectly; droplet avoids walls (wall bump? Walls in real corrals are shallow regions: strong wave damping. I'll model corral boundary as a ring of shallow (high-damping) cells + a droplet repulsion force from the boundary). Orbiting emerges from the droplet interacting with the confined wave field (field builds up in cavity, memory makes orbit radius quantized). This is subtle — Harris 2013. Whether my simplified model produces clean quantized orbits: uncertain. Test will tell: at minimum, droplet should orbit persistently (angular momentum conserving sign) rather than random-walk. I'll accept that as success criterion.

Double-slit diffraction: droplets launched from source at left, aiming at slit center with random lateral offset; waves from droplet's own trail pass through both slits, interfering; the droplet's interaction with its own "pilot wave" that passed through both slits deflects it → wavelike landing distribution (Couder & Fort 2006 PRL — single-particle diffraction, histogram = interference pattern after ~75 droplets). Slits: walls with gaps; wave damping at walls (absorbing). To make the pattern cleaner, droplets recycled one at a time (or a few). Detector at right edge records y. Histogram on screen.

Tunneling: submerged barrier (strip of shallow/high-damping cells across the pool); walker reflects off it many times, occasionally crosses (Couder tunneling analog ~ crossing prob depends on barrier width and memory). Implement droplet-barrier interaction: shallow region reduces local wave amplitude; droplet dynamics unchanged (it can enter) but its bounces make weaker waves there (splat amplitude scaled by depth factor) and it feels the strong field gradient at the barrier edge → usually repelled. Sometimes crosses. Count attempts (approaches within distance) vs crossings. Hmm, simpler tunneling implementation used in the literature sims (e.g., Nachbin/Durey "localized damping"): a strip where wave damping γ is locally much higher; droplet may cross with probability <1. The mechanism: the droplet's pilot wave is attenuated across the barrier so the reflected wave usually pushes it back; occasionally it crosses. I'll implement: in shallow cells, wave damping ×8, splat amplitude ×0.3. Droplet crossing freely but dynamics altered. Test empirically.

Parameter targets (tunable, will iterate in Node):

• N = 384 grid (render quality), but sim maybe 320 for speed? I'll start 320? Actually CPU cost: telegraph update ~ per cell: 4 neighbor reads + ~8 flops → 384²=147k cells × 8 ≈ 1.2M flops per step, ×steps per second (say 240 steps/s) ≈ 280M flops/s — JS typed arrays can do this (~100-300 Mflops effective... borderline). Optimize: use Float32Array, local vars, avoid bounds checks via precomputed index math. Maybe 240 steps/s at 384² is too much in browser with rendering. Options: 320² at 240/s (75M×... 320²=102k cells ×240 = 24.5M cell-updates/s — fine, JS does ~10-50M such updates/s). Or run sim at 180 steps/s. Decide after benchmarks; target: wave C=0.45, λ_F≈26 cells, T_B≈ 26 steps? Let me define in "steps": 1 step = dt_sim = 1/240 s. Bounce every T_B=26 steps ≈ 9.2 Hz bounce rate. Wave speed C cells/step = 0.45 → 108 cells/s. λ_F: for ripples emitted every 26 steps moving at 0.45 cells/step, spacing = 11.7 cells. Hmm, but I want the splat profile J0(k_F r) to have λ_F ≈ 24 cells (first zero ≈ 9 cells) independent of propagation wavelength. The emitted ring spacing (propagation λ) = C·T_B = 0.45·26 ≈ 11.7 cells ≠ 24. Mismatch between bump profile and ring spacing is fine (the profile is what matters for kicks) but visually rings every ~12 cells is prettier & denser. OK.

Walking speed expectation: v_walk ~ some fraction of C·(λ/T_B)? Real walkers ~ 10-30% of phase speed. We'll measure.

Rendering scale: pool 384 cells → world size ~ 26 units? Say pool radius/world: plane 40×40 world units for a square pool; droplet radius 0.42 units.

Grid geometry mask

Float32 arrays: dampMul (per cell damping multiplier), splatMul (depth factor), wall (bool for droplets). Built per preset:

1. pool: square pool, all deep; soft sponge borders at edges (dampMul rising near edge to absorb waves); droplet wall at edge (reflect).
2. corral: circular deep region radius R_c inside an outer shallow sea (dampMul high outside). Droplet confined by repulsion at r > R_c.
3. slits: vertical wall at x = x_w with two slit gaps; walls absorb waves (dampMul ×20? or set wave speed 0?) — for absorbing: high damping. Droplet-wall collision: reflect. Detector line at x = x_d.
4. tunnel: vertical shallow strip width w at center; dampMul ×6, splatMul ×0.25 inside.
5. promenade: like pool.

Droplet dynamics detail

State: x, y, vx, vy, phase timer τ_i, id, color hue, trail array. Per step:

1. φ += 1; if φ ≥ T_B_jittered: bounce: splat at (x,y) amplitude A·splatMul(cell); kick: compute ∇h via central difference at (x,y) (grid-space); v += −(C_k/m)·∇h·(kickMul); clamp |Δv| ≤ Δv_max. Random tiny jitter to break symmetry early.
2. drag: v *= exp(−D/m dt)
3. x += v dt; wall handling (reflect with restitution 0.6; for corral radial reflect).
4. pairwise repulsion if dist < 2r_d: push apart (spring).
5. stats: speed, etc.

Kick magnitude C_k: need to tune so v_walk ~ 8-20 cells/s (grid 320, crossing pool in ~20-40s real time... at 240 steps/s, v=15 cells/s → 20 s to cross 320 cells. Nice.)

Bounce period jitter: to avoid phase-locking artifacts, T_B constant is fine; the "memory" comes from field decay.

Memory parameter: user slider Γ/Γ_F ∈ [0.5, 0.995]. Map: field decay per step d = 1/(1+ m·steps)... Let me parametrize decay time constant τ_mem (steps): from 20 steps (Γ=0.5) to 400 steps (Γ=0.995). G (per-step velocity damping in telegraph eq) = 2dt/τ_mem... For telegraph: h_tt = c²∇²h − 2γh_t with γ = 1/τ_mem. Discrete G = 2γdt = 2/τ_mem (dt=1 step). τ_mem=20 → G=0.1; τ_mem=400 → G=0.005. Plus baseline γ0 for stability. And local multiplier dampMul (shallow ×6-20).

Hmm wait, with the telegraph equation the effective "bump persistence" isn't just τ_mem because wave energy propagates away too. With C=0.45, a bump of width ~10 cells radiates away in ~20 steps regardless. The propagating rings still carry the memory (rings persist for τ_mem). Fine.

Stability checks

• clamp h to ±h_max (e.g., 40) to avoid blowups.
• clamp speed to v_max (e.g., 40 cells/s).

Node test harness

sim.js exports: createSim(config) → {step(), addDroplet(x,y,vx,vy), setMemory(g), loadPreset(name), state...}. Tests in /tmp (not in demo folder? Better keep demo folder clean: put test file in /tmp). I'll write /tmp/test_wavewalker.js importing /space/demos/056-wavewalker/sim.js.

Tests:

1. field sanity: no NaN after splats; energy decays when memory low.
2. walking: v̄ after 30s ∈ [4, 30] cells/s, direction persistence > 0.6.
3. memory scaling: v̄(Γ=0.95) > v̄(Γ=0.7).
4. corral: angular momentum sign persistence > 80%, radius within corral.
5. slits: after ≥60 detections, histogram has ≥3 peaks above 1.3× uniform baseline, roughly symmetric.
6. tunnel: crossing probability ∈ (0.01, 0.6).
7. pairs: two droplets: mean separation < 2.5 λ_F over 60 s at Γ=0.9? (bound) — maybe optional.
8. stress: 30 droplets × 120 s → no NaN, in bounds.

Iterate tuning until pass. This is the hard part; budget time.

Rendering (index.html)

• THREE r160, import map same as 055.
• Scene: dark lab, square dish (metal rim), wave surface: PlaneGeometry N×N segments matching sim grid (e.g., 384² segments = 295k verts — heavy but GPU vertex displacement is fine; maybe render at sim res directly 320² = 102k verts OK). Vertex shader samples DataTexture (float) → displacement z = h·scale; normal from texture central differences in shader. Fragment: color ramp: deep base color, crest cyan emissive, trough violet; grid geometry mask tint (shallow amber); specular from a fake key light; fresnel rim. Under UnrealBloom, crest lines glow — beautiful.
• DataTexture: FloatType, LinearFilter, RGBA? Single channel: use RedFormat/FloatType (needs WebGL2 R32F, linear filtering of R32F needs OES_texture_float_linear — widely available; fallback: encode into RGBA8 packed? Keep float + nearest fallback code path). Simpler robust: upload as RGBA8 with h encoded (h+offset)/scale into R,G (16-bit-ish)? Meh. Use float texture; if linear unsupported, set NearestFilter — still looks fine at 384 res.
• Droplets: instanced spheres (or individual meshes, ≤40 → individual Mesh with shared geometry/material, easier per-droplet squash). Custom shader material: chrome-ish with fresnel + hue tint emissive rim; squash via scale.y animation on bounce; shadow: blob sprites under droplets on the surface.
• Trails: per droplet a THREE.Line with 150 points ring buffer, additive, hue color, fading alpha along trail. Update positions each frame.
• Detector screen (slits preset): instanced box bars (64 bins) standing on the detector line, heights = histogram; plus canvas overlay? 3D bars cleaner.
• HUD: panels in the 055 style: title, controls (presets 1-5, memory slider Γ, droplet count, trails toggle, top view, pause, reset, snapshot, mute), stats (walkers, mean speed mm/s scaled, memory %, wave energy, event counters: slit detections, tunnel crossings & probability, corral orbit radius), help footer with shortcuts.
• Charts: maybe a small canvas "speed vs memory" or landing histogram canvas for slits preset. The 3D bars might suffice; a 2D canvas histogram is easier to read — I'll add a small canvas panel shown in slit/tunnel presets. Good.
• Cameras: orbit controls default 3/4 view; "V" toggles top-down. Damped auto-rotate idle off.
• Post: EffectComposer: RenderPass + UnrealBloomPass + custom grade ShaderPass (vignette/grain/chromatic aberration/ACES-ish) + OutputPass.
• Adaptive quality: monitor FPS; drop bloom or grid segment density if low.
• Audio: WebAudio: master gain; bounce plinks (oscillator ping, freq 500-900 Hz by droplet hue, gain by bounce amplitude), pad (2 detuned saws → lowpass, gain ∝ field energy), splash noise burst on add, chime arpeggio on detection, low thud+whoosh on tunnel cross, UI clicks. Mute toggle; starts on first pointer interaction.
• Snapshot: render then toDataURL → download link.
• Touch: tap pool = splash droplet (raycast to plane), buttons.

World mapping: pool N cells → world plane W×W units (W=30). cell→world: (i+0.5)/N·W − W/2.

Sim↔render sync

Sim runs fixed dt (accumulator, max substeps 6 per frame at 240 Hz → fine). After steps, update DataTexture (upload full Float32Array — 384²·4B = 590KB/frame upload; acceptable. Alternatively upload only when stepped (60fps always steps). OK.

Performance fallback: sim at 288² if slow. I'll add quality tiers: high 384, med 320, low 256 — but changing N re-creates sim; only apply at init based on device + adaptive switch with notice? Simpler: fixed N=352 chosen; adaptive quality only affects rendering (bloom off, pixelRatio). Sim CPU is the main cost though... Let me benchmark in Node early and pick N.

Benchmark plan: quick Node script timing step() at N=384 & 320.

File plan

• /space/demos/056-wavewalker/sim.js — pure ES module physics (no deps).
• /space/demos/056-wavewalker/index.html — imports ./sim.js.
• /tmp/ww_test/*.js — node tests & benchmarks.
• Update /space/demos/index.html with card at top.

Let me start writing sim.js. I'll be careful with the telegraph solver:

Wait — telegraph with velocity damping: h_new = 2h − h_old + C²·lap − G·(h − h_old). G here dimensionless per-step: G = 2γ·dt_step. With dt_step=1: G = 2/τ_mem.

Splats: add B(r) to h directly (height impulse): bump amplitude A_s. J0 approx: I need Bessel J0 — implement via series or polynomial approximation (Abramowitz-Stegun). Fine.

Gradient at droplet: bilinear sample h at 4 surrounding nodes then central differences in x,y.

Kick: v += −Ck·∇h. Note ∇h from positive bumps behind → pushes forward. ✓

Droplet bounce modulation ("phase locking"): real systems lock bouncing phase so the droplet lands on a specific phase of the wave. In stroboscopic models, kick strength ∝ impact force which depends on the local field at bounce time oscillation phase... My field doesn't oscillate (bumps are monopolar positive), so skip phase modulation; constant kick amplitude. But add saturation: kick *= 1/(1+ h_local²/hs²)? Let me first test plain.

One more crucial stabilizer in Durey's model: the kick is proportional to ∇h computed from the field excluding the newest bump? No — including. OK, just test.

Let me now also think about the droplet "drag" D and mass m: flight equation v̇ = −(D/m)v. Per step: v *= (1 − d), d = D/m ·dt = let's use d ≈ 0.004 per step (τ_drag = 250 steps ≈ 1 s).

Kick magnitude: Ck such that steady walking v* ~ 10 cells/s. Rough balance: per bounce, kick Δv ≈ Ck·∇h_self. Self-gradient from own trail: h decays behind... The last bump at distance v·T_B behind with amplitude A_s·e^{−t/τ}; gradient scale ~ A_s·(2π/λ_F)/2? With A_s=1, λ_F=24: ∂r J0 ~ 2π/24·max≈0.26 → gradient ~0.13·decay. For steady speed v: drag loss per bounce ≈ v·d·T_B = v·0.004·26 ≈ 0.1v. Kick must balance: Ck·0.13·⟨geom⟩ ≈ 0.1v → v ≈ 1.3·Ck·⟨geom/decay⟩. For v=12: Ck ≈ 9/⟨...⟩ ~ 15-40. Just tune numerically: sweep Ck in test until v* ∈ [6,20].

Threshold behavior: with tiny initial jitter, walking should start spontaneously once memory sufficient (Γ>~0.6). Test with Γ=0.8, 0.9, 0.97.

Wave amplitude vs speed: at higher memory, trail amplitude builds (resonance), v increases — super-walker regime near Γ→1 gets chaotic ("stop-and-go", quantized). Good.

Speed cap: clamp |v| ≤ 45 cells/s.

Splats from moving droplet: successive bumps separated by v·T_B = 12·26 ≈ 3 cells... wait T_B=26 steps at 240 steps/s = 0.108 s; v=12 cells/s → spacing 1.3 cells. Hmm that's dense: bumps every 1.3 cells → nearly continuous ridge. Ring propagation spacing = C·T_B·(steps)... = 0.45·26 ≈ 12 cells between rings. λ_F (J0 profile) 24 cells: first zero 9.1 cells. A ridge of bumps spaced 1.3 cells with width 9 cells: superposition ~ smooth ridge of height ~ A_s·(overlap≈7)·decay-average. That's a strong trail → strong self-gradient... but the gradient at the droplet is dominated by the nearest bump behind (1.3 cells back, amplitude ~A_s): gradient ~ A_s·J0'(1.3·2π/24=0.34 rad) ≈ A_s·0.166. OK.

Real walkers: bounce spacing v·T_F vs λ_F: droplet moves ~0.3-0.5 λ_F per bounce?? Real: walking speed ~ λ_F·f_F·0.1-0.2 → per bounce (T_F = 2/f_F... eh) spacing ≈ 0.2-0.4 λ_F ≈ 5-10 cells. So my spacing 1.3 is too dense → reduce bounce rate: T_B = 60 steps (4 Hz bounce at 240 steps/s) → spacing at v=12: 3 cells. Still dense-ish. Or slow the sim: steps 240/s but bounce T_B=48 (5 Hz). v=12 → 2.4 cells/bounce. Meh. Or increase λ_F to 32? grid 352 then pool ~ 11 λ_F. Fine.

Actually, the exact ratios will emerge from tuning; I'll parametrize T_B (bouncePeriod steps), λ_F (profile wavelength), C (wave speed), A_s, Ck, drag d, τ_mem(Γ) and run parameter sweeps in Node to find a robust island where:

• walking emerges from noise at Γ=0.8
• v* increases with Γ
• no blowups at Γ=0.99 with 20 droplets for 300 s

Then presets' tests.

Time plan: this is a big build; let me get going. First benchmark raw telegraph step cost in Node at 320/384 to fix N and steps/s.

Actually — reconsider grid size vs pool physics: pool should be ~8-14 λ_F across for good behavior. With λ_F=26 and N=352: 13.5 λ_F.

For rendering, N=352 → plane segments 352×352 = 124k verts: fine.

Let me write the benchmark + core sim now.

One more design decision: to keep sim.js clean, I'll make a single class PilotWaveSim with:

• config: N, C (wave speed cells/step), bouncePeriod, lambdaF, splatAmp, kickGain, dragRate, memoryGamma (set via setMemory), geometry masks, droplets[], rng (seeded mulberry32 for reproducibility in tests).
• methods: reset(preset), step(), addDroplet, removeDroplets(to n), splat(x,y,amp), fieldAt/gradAt, presets: 'pool','corral','slits','tunnel','promenade'.
• events queue: bounce events, detections (slit crossings), tunnel crossings → consumed by renderer/audio. For Node tests, counters.
• stats helpers.

Detector logic (slits): droplet crossing x_det (moving +x) → record bin(y), then recycle droplet to source with new jitter (or remove & respawn). Count total detections. Tunnel logic (tunnel preset): define barrier x-range; a droplet approaching: when it enters "approach zone" from left with vx>0 heading to barrier... Simpler event counting: track sign of (x − x_barrier_center). Count "crossings" when sign flips from − to + (left→right) — but walkers wander both ways; symmetric walkers cross both directions. Count total crossings of the barrier midline. "Attempts": number of times a droplet comes within 1.5 λ_F of the barrier moving toward it, then either crosses (success) or leaves beyond 2 λ_F (fail). Implement small state machine per droplet. Fine.

Corral: measure per-droplet mean radius & angular velocity sign flips.

Slits geometry: pool width N. Wall at x_w = 0.42·N, thickness 3 cells, gaps of width g_slit ≈ 1.2 λ_F separated by d_slit ≈ 2.5 λ_F (center-to-center). Source at x_s = 0.08·N, y random in middle band; initial velocity +x at ~v* (give it v0 = expected walking speed to save time). Detector at x_d = 0.92·N. Droplet-wall: reflect vx (restitution 0.5) when entering wall cell. Waves: wall cells dampMul=50 (near-absorbing). Hmm, absorbing walls reflect less — good.

Also slit walls need rounded edges to avoid droplet trapping in corners — with wave-mediated forces it usually glides along. Accept some loss (droplets that stop moving for > 10 s get recycled, count as "absorbed" not detection).

Alright. Also for promenade preset: spawn 3 pairs at various spacings. Just visual.

pool preset: N droplets (slider 1-30) placed random with small jitter; user clicks to add.

Audio: plink per bounce could be 30 droplets × ~5-9 Hz = 270 plinks/s — too many. Throttle: plink only for bounces with probability ∝ 8/dropletCount, or only nearest-to-camera 6 droplets. I'll implement per-droplet plink with per-droplet gain scaled 1/√n and a global limiter (max ~40 plinks/s, random thinning). Fine.

Rendering field → DataTexture each frame: tex.image.data.set(sim.h) then needsUpdate. Use FloatType RedFormat? In WebGL2, R32F not color-renderable but we only sample it — fine. LinearFilter for R32F requires OES_texture_float_linear (check extension; else Nearest). Vertex displacement: texture2D in vertex shader needs... WebGL2 fine.

Also encode geometry mask (depth/splatMul, wall) into a second static texture (RGBA8: R=depth tint, G=wall, B=shallow) for fragment coloring — upload once per preset.

Normals: compute in fragment shader from texture central differences (texelFetch offsets) — cheaper than per-vertex normals; gives crisp lighting. Or compute per-vertex normal in vertex shader from 4 samples. Fragment better quality. Do fragment.

Surface fragment shading:

• base deep color #061018-ish
• crest: h>0 → cyan emissive ∝ smoothstep(0, hmax, h)
• trough: h<0 → violet/magenta tint (my bumps are positive-only mostly, but wave equation gives negative rings naturally)
• spec: Blinn from key light dir
• shallow mask: amber tint
• wall mask: dark slate
• edge vignette? post handles. Bumps positive-only: field mean >0 slowly grows? The telegraph equation conserves volume-ish; positive bumps raise mean; with damping it decays. Mean drift could slowly offset colors — subtract mean per frame? Cheap: track global mean during step, subtract in shader via uniform. Or apply tiny high-pass: h_new *= (1−ε) and subtract mean·α. I'll compute mean in JS each upload and pass uniform uMean; shader uses h−uMean. Good.

Droplet visuals: sphere geometry (SphereGeometry(1, 24, 18)); shader:

• base metallic dark, fresnel rim hue color emissive
• squash: on bounce event set droplet.squash=1 → decays; mesh.scale.y = 1−0.35·squash, xz = 1+0.18·squash.
• z position: surface height at droplet + bounce parabola: droplet.z = h_vis·scale + flight: between bounces, z = z0 + zJump·4·φ(1−φ) (φ∈[0,1] phase). zJump ~ 0.5 world units.
• shadow blob: circle sprite at surface with alpha ∝ 1/(1+z).

Trail: THREE.Line per droplet, 140 points, positions at droplet flight apex samples (or every step? every 4 steps). Additive line basic material with vertexColors alpha fade. Lines can't do per-vertex alpha without custom shader — use LineBasicMaterial vertexColors with color fading toward black + AdditiveBlending (black = invisible).

Detector bars (slits): 72 bins → InstancedMesh box, height scale per bin, emissive cyan; positioned along detector line at x_d, on surface. Update every 0.5 s.

Histogram canvas (2D): small panel bottom-right showing bars + stats (n detections, "interference visibility"). Show only in slits preset. Tunnel preset: show crossing probability + attempts/crossings.

Stats panel: memory Γ/Γ_F %, walkers, mean speed (cells/s → "mm/s" fake-scaled: 1 cell = 0.18 mm → v·0.18·(240 steps... no: v cells/s ×0.18 mm/cell = mm/s)), field energy, FPS.

Memory slider: Γ ∈ [0.50, 0.99]; map τ_mem = lerp(24, 420, t²) steps maybe.

Presets set default memory: pool 0.9, corral 0.93, slits 0.9, tunnel 0.95, promenade 0.92.

Speed control? Add sim speed ×0.5/×1/×2? Keep simple: pause only. Maybe slow-mo toggle (nice to watch bounces): key Z. Sure, add "slow" toggle.

OK, also the "wow" opener: start with pool preset, 8 droplets, auto-tours? Keep simple.

Edge case: WebGL float linear support check.

Right — let me also double check three@0.160.0 OutputPass usage as in 055 (worked). I'll copy post pipeline patterns from 055 (bloom + custom grade pass). Let me look at 055's grade shader and audio patterns quickly for reuse, then write the new files.

055 used a DOM vignette overlay instead of a grade shader pass, with bloom and afterimage. Let me check the audio setup pattern quickly and then start building. Actually, I have enough conventions. Let me be productive and write the code.

Plan:

1. Write /space/demos/056-wavewalker/sim.js — pure physics module.
2. Write Node test harness in /tmp, tune physics until tests pass.
3. Write /space/demos/056-wavewalker/index.html — full rendering/UI.
4. Validate syntax, update index.

Let me write sim.js now. Key parameters (initial guesses, to tune):

Kick units: gradient is in "h per cell". kick Δv = K·∇h (cells/s). With gradient ~0.15 and K=12: Δv = 1.8 cells/s per bounce; drag loss per bounce period: v·(T_B/240)/0.9 ≈ v·0.0139 → for v=15: 0.21. Hmm kick 1.8 >> 0.21 → v grows until gradient balance... walking speed self-limits because as v increases, trail stretches, gradient behind drops. Fine — tune numerically.

Droplet radius r_d = 3.5 cells (repulsion at dist < 7).

Let me write the code.

Important details:

• Bessel J0: use polynomial approximation for |x| — Abramowitz & Stegun 9.4.1/9.4.3, or simple series for x<8 and asymptotic beyond. Bump support: r < 0.75 λ_F ≈ 19.5 cells → x = k r < 4.53 rad. Series converges fine.

Actually for the splat profile, J0(k r) with window: B(r) = J0(k r) · w(r) where w = smooth cutoff at r_c = 0.7 λ_F. Precompute a lookup table splatLUT[0..R_MAX] and splat by looping offsets — precompute list of (di, dj, val) once at init (rebuild if lambdaF changes — no, lambdaF fixed).

• Gradient at droplet: central difference using bilinear-sampled h at (x±1.5, y), (x, y±1.5) cells.

• Walls (droplet): masks: wallU8 Uint8Array(N*N): 0 deep, 1 wall (solid), plus dampMul Float32Array per cell (1 default), splatMul Float32Array (1 default).

Droplet update with wall: after x += v·dt, check cell wall: if wall, revert axis & reflect velocity component. Handle x and y separately for sliding.

Corral boundary: radial: if r > R_c: push back, reflect radial velocity component.

Edge of grid: keep droplets inside margin 4 cells: reflect.

Wave solver boundary: Neumann (copy adjacent) — implement by clamping indices when computing laplacian (i-1 etc. clamped) → zero-flux. Plus sponge: dampMul higher near outer 10 cells for pool/slits presets to kill reflections (for corral, outside ring is high-damping anyway).

Events: this.events array cleared each step? Better: sim.events accumulates {type:'bounce', id, x, y, amp}, {type:'detect', id, y, bin}, {type:'tunnel', id}, {type:'wallhit'...}. Renderer drains via sim.drainEvents().

Slit preset recycling: on detection or on "stuck" (speed < 0.5 for > 8 s) or y out of bounds: respawn at source. Track per-droplet state. In slits preset, droplets are launched one at a time? Couder's experiment: one walker at a time, ~75 trajectories. With 3 concurrent droplets it runs 3× faster and fields interact a bit — acceptable; make droplet count in slits preset = 3 default (adjustable).

Source: x_s = 0.07 N; y ∈ [0.38N, 0.62N] random; initial vx = v_expected (measure from pool test, e.g., 12 cells/s), vy = 0.

Detector: x_d = 0.9N. Record y when crossing. Histogram 72 bins over pool height.

Also slit walls: reflect droplets. Some droplets will get stuck circling before the wall (never cross) — recycle after timeout 60 s as "absorbed".

Tunnel preset: barrier strip centered x_b = 0.5N, width w = 0.9 λ_F ≈ 23 cells: dampMul ×7, splatMul ×0.2 inside strip. Droplets: 2 walkers, spawn left side with random walk. Count crossing events: sign flip of (x − x_b). Attempts: droplet within 1.2λ_F of strip edge moving toward strip; success if crosses to other side; fail if moves back beyond 2.2λ_F. Keep counters.

Promenade: spawn 4 pairs: positions offset by ~0.5λ_F, 0.6λ_F, ... perpendicular offsets. Just visual.

Corral: deep circle radius R_c = 0.36 N ≈ 126 cells ≈ 4.8 λ_F. Outside: dampMul ×12, splatMul ×0.15 (shallow sea). 1 droplet default (allow more). Wall: radial reflect at R_c − 2.

For "waves can't escape corral" — the field outside decays fast due to damping; droplet mostly interacts with confined field → orbits.

Sim step with substeps: dt fixed 1/240. step() advances one dt. Renderer calls step n times per frame (accumulator). Stress test in Node will validate.

Performance: per step cost = field solve O(N²) + droplets O(D·splatSize + D²). N=352: 124k cells. In JS maybe ~1.5-3 ms per step?? At 240 steps/s → 0.36-0.72 s of CPU per real second — too slow! Need to benchmark. Options: reduce steps/s to 120 (halve) — but wave CFL: C=0.42 cells/step; per real second wave travels 0.42·120 = 50 cells/s. Bounce T_B=30 steps = 0.25 s = 4 Hz — plausible droplet bounce rate visually. Walking speed 12 cells/s... at 120 steps/s: v per step 0.1 cell — smooth enough? Droplet flight parabola at 60fps render: fine, z computed from phase.

Hmm wait, actually let me reconsider: per-step work: ~124k cells × ~12 ops = 1.5M ops; JS typed-array loop ~ 100-400 M ops/s → 4-15 ms per step?! No wait — 1.5M simple ops is ~2-5 ms per step in the worst case, 240 steps/s → way over budget. Let me estimate better: a tight Float32Array loop in V8 does roughly 200-500M simple iterations/s (each with ~10 flops) — say ~0.3-0.7 ms per step for 124k cells. 240 steps/s → 72-170 ms/s = 7-17% CPU. Acceptable! I'll benchmark in Node to confirm. If 0.5 ms/step, 240/s = 120 ms per second of sim — 12% of one core. Fine.

But also the memory passes: h, hO, hN swaps — use pointer swaps (no copies).

Also splat cost: 20 droplets × 8 Hz × (40×40 cells × 4 ops) = 20×8×6400 = 1M ops/s — trivial.

DataTexture upload 352² ×4 B = 495 KB/frame at 60 fps = 30 MB/s — OK for GPU upload.

Alright, writing code now.

One more physics thought — "kick saturation / phase adaptation": In Moláček-Bush, the horizontal kick magnitude depends on the vertical impact force, which is larger when the droplet hits a rising/crest surface. A useful stabilizing feedback: kickMul = 1/(1 + (h_local/h_sat)²)? When the droplet sits on a big crest (its own fresh bump), kick ∇h is near zero anyway (at peak). The main instability risk: at high memory, field amplitude grows unbounded (resonant buildup). Mitigations: (a) splat amplitude fixed, damping sets amplitude ceiling; (b) clamp h to ±60. Also make splatAmp scale down slightly when local h is huge: A_eff = A/(1+ |h_local|/h_ref) — mimics submergence. I'll include h_ref = 12. Prevents blowup in promenade clusters. Test will verify no NaN at Γ=0.99.

Also small numerical noise: add tiny random force each step σ ~ 0.02 cells/s² to break symmetry (also models vibration noise). With seeded RNG for tests.

Corral orbit test criteria: after 60 s at Γ=0.93, droplet radius r(t): mean radius in [0.2R_c, 0.95R_c], and sign of angular momentum persistent (fraction of time with same sign > 0.75) over the last 40 s.

Slit test criteria: ≥80 detections; histogram (smoothed) has ≥3 local maxima; visibility = (max-min)/(max+min) > 0.25; center of mass within ±0.1 N of pool center. These may need tuning of slit geometry (gap 1.0-1.5 λ_F, separation 2-3 λ_F). If interference pattern doesn't emerge cleanly, relax to "diffraction envelope with ≥2 peaks" — but aim high first.

Tunnel test: 2 droplets × 240 s at Γ=0.95: attempts ≥ 20, crossing probability ∈ (0.02, 0.7).

Walking test: Γ=0.85: after 40 s, v̄ ∈ [5, 30]; v̄(Γ=0.95) > v̄(Γ=0.7) (separate runs); direction persistence: correlation of velocity direction over 2 s windows > 0.5.

Let me write everything now. sim.js first.

Also worth deciding the exact Γ→τ_mem map: τ_mem(Γ) = 18 + (Γ−0.5)/(0.5)²·? Let me do: t = (Γ−0.5)/0.5 clamp [0,1]; τ_mem = 20·exp(3.2·t) → Γ=0.5: 20 steps; Γ=1.0: 20·e^3.2 ≈ 490 steps. G = 2/τ_mem per step.

Sponge border: for pool/slits/tunnel/promenade: outer 8 cells dampMul ramps ×1→×30. For corral: outside R_c+4: dampMul ×15.

Wave reflection at dampMul discontinuities is partial — fine.

Wall cells (slits): treat in wave solver as dampMul ×60 (nearly absorbing) — plus droplet reflection.

Now write the file. I'll write it carefully with comments. Also export PRESET definitions with geometry parameters so renderer can draw matching walls (wall mask texture built from sim masks directly — renderer reads sim.dampMul/splatMul/wallMask → builds RGBA mask texture.

API:

Positions in cell units (0..N). Renderer maps to world.

Let me now write sim.js.

Field step with typed arrays and index arithmetic. To keep it fast, write the inner loop flat:

nh = hc + (hc − o)·(1 − g) + c2·lap. With g = G·dm[k]. Note: this is "damping on velocity" where velocity = hc − o per step. Stable if g<1 and C<0.707.

Clamp nh to ±hMax. Write nw[k]=nh. Then swap: HO=H; H=HN; HN=old HO.

Actually zero-fill edges? Neumann clamp is fine.

Splats: precomputed offsets array splatOffs = [{di,dj,w}...] for r ≤ rCut where w = J0(k r)·window. splat(x, y, amp): for each offset: H[k] += w·amp·splatMul[k]? splatMul at target cell — yes multiply by local depth factor.

Gradient sampling: bilinear at (x±gx, y), (x, y±gy) with g=1.5 cells: gx central: (sample(x+1.5,y)−sample(x−1.5,y))/3.

Bounce:

Note: kickGain units: gradient h/cell → Δv cells/s... per bounce. OK tune.

Noise: vx += (rng()−0.5)·cfg.noise each step? As acceleration: a_noise·DT... Just add tiny velocity noise per step: v += (rng−.5)·noise·DT·60? Let me: per step, v += (rng()−0.5)·noise, with noise = 0.02 → over 240 steps random walk σ ≈ 0.02·√240·... ≈ 0.15 cells/s — small. For symmetry breaking from rest: bump initial droplets with tiny v. OK.

Drag: per step v *= Math.exp(-DT/dragTau) ≈ (1 − DT/dragTau) precomputed dragK.

Speed clamp, wall collisions, corral reflect, droplet-droplet repulsion (dist < 2r_d: push v apart: impulse spring: f = kRep·(2r_d − dist) along axis; kRep ~ 30 → Δv = f·DT).

Events per bounce: {t:'b', id, x, y} (throttle later in renderer).

Slit detection & recycling, tunnel stats, corral stats handled in per-preset hooks inside step() after droplet updates.

setPreset builds masks:

Let me write it all concretely now. Also stats helpers: meanSpeed().

For tests, seed fixed.

Let me write the file to /space/demos/056-wavewalker/sim.js. Then the Node benchmark + tests in /tmp/ww/.

After physics passes, build index.html (the big one), then update index page.

Writing sim.js now — I'll aim for clean, documented code.

**********************************js.

**********************************************************************************************************************************************************************************ce.

Good news: performance is fine (0.461 ms/step → 111 ms CPU per sim-second, acceptable). Bad news: droplets don't walk — speed 0.06 cells/s ≈ stationary. The field builds up (max 10-20) but the droplet just sits on its own bump.

Why? The droplet bounces at the same spot, piling up a symmetric bump under itself. Gradient at the center of a symmetric pile ≈ 0. The kick from noise should break symmetry... but the pile grows fast relative to decay, and the droplet sits in a self-made pit/peak — "self-trapping". The wave propagation (C=0.42 cells/step = 100 cells/s) radiates the bump away quickly; within the ~30-step bounce period the ring moves ~12.6 cells — comparable to λ_F/2 = 13. So the field under the droplet is dominated by the most recent bump, symmetric.

Key physics I'm missing: in the real stroboscopic model, the emitted waves are standing Bessel bumps that decay in place (no propagation). The droplet sits on the superposition of its past bumps; when displaced slightly, the nearest past bump is behind it, its slope kicks it further forward → walking. With strong propagation, the bumps radiate outward and the self-trap pit forms (the J0 has a central peak; repeated splats at same spot create a deep well? No — positive bumps create a peak; the gradient at the exact center is zero; perturbed δx, the gradient points toward the center → kick −K∇h points away from center → restoring? Wait: at position x slightly right of the bump center, ∇h < 0 (descending to the right... let me think: bump centered at 0, h decreases with |x|. At x>0, dh/dx < 0. Kick = −K·∇h = −K·(negative) = positive → pushed further right, away from center. So the peak repels — anti-trapping. Good — that means perturbations grow → walking should emerge. But measured v ≈ 0.06 — no walking at all, and rms < 1 while max ~ 10-20: field is concentrated right under the droplet.

Hypothesis: the kick is too weak relative to... or the saturation sat = 1/(1+|h|/hRef): with h under droplet ~ 10-15 and hRef 14, sat ≈ 0.5. Kick K=14·0.5·∇h. ∇h at 1.5 cells from bump center: bump amplitude ~1 (per splat), J0'(k r)·k... k=2π/26=0.242; at r=1.5: J0'(0.36)≈−0.177 → grad ≈ −0.043. Δv = 14·0.5·0.043 ≈ 0.3 cells/s per bounce × 8 bounces/s = 2.4 cells/s². Drag: v/0.9 s. Terminal v from this alone ~ 2 cells/s if gradient stayed constant. But as soon as it moves, it leaves the steep region... The issue is the bumps radiate away so fast (in 30 steps the ring moves 12.6 cells and decays via memory γ: τ_mem at 0.9 = 20·e^{3.2·(0.4/0.495=0.808)} = 20·e^2.586 ≈ 265 steps; decay per bounce period negligible) — so the field behind the droplet is a ring expanding at 100 cells/s. The droplet at 2 cells/s can't interact with its own ring — it outruns... no, the ring outruns the droplet! The ring leaves at 100 cells/s, droplet at 2 cells/s. So there's no persistent trail to push against — the memory is carried away by propagation almost instantly (ring leaves the λ_F neighborhood in ~0.3 s). The effective memory of the local field is ~ λ_F/(2c) ≈ 13/100 ≈ 0.13 s regardless of γ. That's why changing memory barely matters (v same at all Γ).

Fix: make propagation slow relative to decay — i.e., reduce wave speed C drastically, or go to the "pure decay, no propagation" limit (diffusion/decay field). In Durey-Milewski the field is literally a sum of in-place decaying Bessel bumps. Options:

Option A: reduce C. Walking needs the trail to persist near the droplet: ring exit time ~ λ_F/c vs memory τ. For a strong trail, want c·τ_bounce ≪ λ_F: e.g., c = 0.05 cells/step = 12 cells/s... but then CFL fine, but the visual "ripple propagation" becomes very slow (waves crawl at 12 cells/s while walkers go ~10 cells/s — actually real walking droplets: wave speed ~ 20 cm/s? Faraday waves are standing (subharmonic), they don't propagate as rings! The bouncing creates a standing Faraday wave field localized near the droplet — it oscillates in amplitude at f_F/2 but doesn't radiate away. So slow/no propagation is physically right!). With c small, the telegraph equation ≈ h_tt = −2γh_t + small → pure exponential decay of the stamped pattern.

Option B: pure decay model. h *= exp(−dt/τ) each step + splats. Simplest, exactly Durey-Milewski without oscillation. The stroboscopic model has the bumps oscillating in time (cos ωt) too, and the droplet bounces at a locked phase. My monopolar non-oscillating version: field = sum of decaying positive bumps. Kick = −K∇h at bounce. This is precisely the model used by Durey & Milewski (2014) "Self-propulsion of a droplet... a theoretical model" minus oscillations — they showed walking, and the discrete-time version x_{n+1} maps show superwalker etc.

But visually, a field with zero propagation looks like glowing blotches that fade — less "watery". Compromise: small but nonzero C (e.g., 0.08-0.12 cells/step ≈ 19-29 cells/s) so rings visibly creep outward a few cells before decaying, while the trail persists long enough to walk on. Let me test a sweep of C.

Also maybe increase bounce period (fewer, stronger kicks) — not yet.

Second issue: self-trap symmetry. Even with a static decaying field, the droplet at rest sits on a symmetric pile; the gradient at center = 0; with perturbation δx, the closest bump center is δx behind: gradient ~ J0''·δx small... The linear instability growth rate must beat drag. Durey-Milewski show the walking threshold: above a critical memory the rest state loses stability. My memory τ must be long enough. τ at Γ=0.9 ≈ 265 steps ≈ 1.1 s. Trail: droplet at v leaves bumps spaced v·T_B = v·0.125 s. The resultant slope at the droplet from the string of past bumps: bumps at distance d_n = n·v·T_B behind, amplitude e^{−n·T_B/τ}, gradient contribution ~ A·J0'(k d_n)... For small v, d_n → 0, and J0'(small d) → small but the sum over n has a definite sign (all behind). Net gradient ∝ v (for small v): ∇h ≈ −A·(k²/2)·v·T_B·Σ n e^{−nT_B/τ}·... Let me just trust the model and tune K and τ numerically: the walking threshold scales like K·A·stuff > drag. Increase K a lot (try 40-200), increase τ range.

Let me build a parameter sweep script: for C in {0.05, 0.1, 0.2}, K in {20, 40, 80, 160}, memory 0.9: report v. Target v ∈ [5, 25] cells/s.

Also fix: with static decay the field RMS grows with droplet count — the saturation handles it.

Also I realize the noise (0.015 per step) gives σ_v ≈ 0.015·√240 ≈ 0.23 cells/s — too small to break symmetry quickly? Growth of instability will handle it if unstable.

Let me also reconsider splatAmp and decay interplay: bump amplitude A=1, decay per step g = 1−G... wait in my telegraph eq, G = 2/τ: at τ=265: G=0.0075 per step. Over one bounce period (30 steps): factor e^{−30·0.0075}≈0.8. Fine.

Let me write the sweep.

Progress! Walking now emerges at low wave speeds (C=0.05-0.1) — but speeds are at the cap (maxSpeed=45, walking at 33-40 cells/s). Too fast. The kicks are too strong or drag too weak. Also speeds are suspiciously saturated (bumping against the 45 cap). I need to tune down: reduce kickGain, and/or increase drag. Target: v ≈ 8-16 cells/s at Γ=0.9 (crossing the 352-cell pool in 25-40 s — nice viewing pace).

Let me sweep kickGain lower at C=0.08: K in {3, 6, 10, 15, 20} with dragTau 0.9. Also check maxSpeed isn't hit. Also lower maxSpeed cap to 30 maybe.

Also C=0.05-0.1 cells/step = 12-24 cells/s wave propagation — rings visibly creep. Walker speed should stay well below wave speed? Not necessarily required.

Let me refine the sweep: C in {0.06, 0.1}, K in {3, 5, 8, 12, 20}, report v and maxSp, and also a "walking threshold" check at Γ=0.6 (should NOT walk or walk slowly → the memory-dependent onset is a key phenomenon to showcase).

Interesting results:

• C=0.06, K=6: v̄(Γ): 0.6→1.7, 0.7→11.7, 0.8→14.0, 0.9→17.9, 0.95→19.8, 0.98→20.0. Nice monotone memory response with clear onset between Γ=0.6 and 0.7 — the walking threshold phenomenon! Max speed 30 occasionally hit but mean 18-20 is OK-ish. Slightly fast; pool crossing 352/18 ≈ 20 s. Acceptable, but the cap being hit (30) suggests bursts. I could raise dragTau slightly or keep.
• C=0.1 shows collapse at high memory (field too strong → chaotic trapping?) — avoid.
• C=0.06 K=6 looks like the sweet spot. K=10 similar with higher speeds.

Walking speed 14-20 cells/s vs wave speed 0.06 cells/step × 240 = 14.4 cells/s — walkers at ~1.2-1.4× wave speed. Hmm, walkers faster than the waves they emit: they outrun their rings — but the field is mostly the standing decaying bumps, so OK. The emitted rings crawl slowly behind — visually fine (rings lag behind walker = nice wake).

Let me pick C=0.06, K=6, dragTau=0.9, maxSpeed=30. Then v(0.9)=17.9. A bit fast; maybe dragTau 0.7 to bring v down ~14? Let me fine-tune with dragTau sweep: {0.6, 0.75, 0.9} at K={5,6,8}. Target v(0.9) ≈ 12-16.

Also I should double-check: direction persistence (do they walk straight?), and multi-droplet stress at Γ=0.98 (20 droplets, 300 s) for NaN.

Then corral, slits, tunnel tests.

The checkpoint says maxTime threshold 50% reached at timeProgress 0.74? Wait — "progress_threshold", reasons: ["maxTime"], threshold: 50, timeProgress: 0.743 — this suggests I've used 74.3% of the time budget?? That seems odd — the run started at 1:00 PM UTC and it's probably ~1:25 now. Hmm, iterationProgress 0.018 (1.8% of iterations). This checkpoint is a warning that time is limited. I need to move FAST now.

Strategy shift: I have limited remaining time. I must complete:

1. Finish physics tuning (already close: C=0.06, K=6, tau=0.75 works)
2. Write index.html (the big file)
3. Quick validation
4. Update index page
5. Success

I should skip extensive additional tests (corral/slit/tunnel validation) — or run ONE combined quick test while writing the HTML. Actually let me be pragmatic: physics already walks with good Γ response. The preset geometries are simple and robust (they don't need perfect quantization — the demo's job is to show the phenomena; the pool preset alone with interactive splashing + memory slider is already compelling; slits/tunnel/corral will at least behave plausibly since walkers walk and walls reflect).

Let me:

1. Run t4 (quick) to confirm drag choice + stress.
2. Immediately write index.html (aim for solid but not overly long).
3. Syntax check + index update.

Actually the checkpoint consumed a turn; let me not waste calls. Run t4 now.

Important findings:

1. Drag sweep: tau=0.6, K5: v=9.1, persistence 0.83 — nice. K6 tau 0.9: 17.9/0.76.

2. Γ curve (K6 tau0.75): 2.7, 4.1, 13.9, 14.3, 17.8, 18.1, then 4.0 at Γ=0.97, 1.6 at Γ=0.99 — collapse at very high memory! The field saturates (mean=85.61 vs max 90 → the whole field is pinned at +hMax!). The saturation mechanism fails: the field mean drifts up to the clamp because all splats are positive and damping is too weak at Γ→1. The mean field hits the 90 clamp, then gradients vanish → walkers stop. That's the collapse.

Fix: subtract the spatial mean (or use a high-pass): each step, H[k] −= mean·α with α ~ 0.002-0.01 (a gentle "meniscus drain"), or better: apply splats as zero-mean bumps? J0 over its support is roughly zero-mean (integral of J0 to first zero is zero; with window at 0.72λ it's partially negative-ring included...). Simplest robust fix: after fieldStep, compute mean and subtract a fraction: H[k] -= mean * drainK where drainK ~ 0.01 per step → mean decays with τ ~ 100 steps regardless of γ. Physically justified: the bath returns to level (conservation of volume) — the Faraday waves are surface waves, and the mean level is fixed; a global "return to level" relaxation is legit. This keeps gradients intact while killing the DC offset.

Also with mean drift fixed, high-memory behavior should recover. Also the multi-droplet stress shows minPairGap=2.2 (soft-core repulsion working) but v̄=0.4 due to the same collapse.

Additional tweak: the splat saturation sat = 1/(1+|hLoc|/hRef) uses hLoc which included the DC offset — after mean subtraction, fine.

Let me also reconsider kick vs hRef: fine.

Apply fix: in fieldStep, accumulate sum of nh while writing, then second pass H[k] -= meandrain... two passes = extra cost (~0.2 ms). Alternative: subtract previous mean's fraction during the same pass (use mean from previous step): nh -= prevMeandrainK. One pass. Mean changes slowly — fine.

drainK: per step, mean = (1 - drainK)? If I subtract prevMeandrainK each step, mean decays as (1-drainK)^steps → τ_mean = 1/drainK steps. Want τ_mean ~ 60-120 steps (fast enough to prevent buildup, slow compared to wave dynamics): drainK = 0.015.

Wait, but the DC offset also comes from hMax clamp asymmetry — with drain, h stays centered, no clamping.

3. Also the Γ=0.97 collapse removed, expect v keeps rising or plateau ~18-22.

Let me patch sim.js: add mean tracking in fieldStep + drain, and also update fieldStats mean usage (already returns mean).

Also apply chosen defaults: waveC 0.06, kickGain 6, dragTau 0.8, maxSpeed 30, noise keep. v̄(0.9) ≈ 17-18 cells/s → pool crossing in ~20 s. Good.

Then quickly test: walking Γ curve + stress again, plus corral/slit/tunnel smoke tests in ONE script to save time. If corral orbits and slits produce detections and tunnel produces crossings at all, ship it — visual tuning can ride on the robust core.

88% time used! I need to finish NOW. Remaining critical path:

1. Update sim defaults (waveC 0.06, kickGain 6, dragTau 0.8, maxSpeed 30) — one edit.
2. Write index.html — the big file. Must be efficient; I'll write a complete but focused version in one go.
3. Quick syntax check on both files + fast combined physics smoke test (run in background while writing HTML? No — sequential. I'll do a 60-second combined test after the defaults edit, then write HTML, then node --check equivalent validation, update index, done.)

Let me do the defaults edit + combined test in parallel with starting the HTML. Actually tool calls are sequential anyway. Priorities: HTML is the biggest remaining chunk. Let me:

1. Edit defaults (fast).
2. Write index.html in one big write.
3. Run a quick combined test (walking + drain fix verification, ~60s).
4. node --check both files (module check: use node --input-type=module --check? node --check works for CommonJS; for ESM use node --check with .mjs extension or node --experimental-... . Simplest: node -e "import('...').then(...)" to import sim.js — validates syntax. For index.html's inline module, extract script and run through a syntax check via new Function? new Function doesn't handle import statements. Use node --input-type=module --check < file? Actually node --check respects file extension; for stdin with --input-type=module --check it should work. I'll extract the module script from HTML and pipe it: sed -n '/<script type="module">/,/<\/script>/p' index.html | sed '1d;$d' | node --input-type=module --check -. Let me try; if --check with stdin fails, fallback: write to /tmp/x.mjs and node --check /tmp/x.mjs — but imports of 'three' won't resolve at parse time? --check only parses, doesn't resolve imports. Parse-only is what I need.
5. Update /space/demos/index.html card.
6. Success.

Writing index.html now — I must be economical yet complete: renderer (surface shader, droplets, trails, detector bars, mask texture), UI (title, controls, stats, histogram canvas, help), audio (plinks, pad, chimes), post (bloom + grade), cameras (orbit/top), adaptive quality, snapshot, touch. Let me write it in one pass, carefully. I'll keep it as tight as possible while still being the "wow" demo. ~700-900 lines.

Key design decisions for the HTML (to write quickly without bugs):

• Import map same as 055.
• World: pool N cells → WORLD = 30 units plane. cell2world = (c + 0.5)/N*W - W/2.
• Surface: PlaneGeometry(W, W, N-1, N-1)?? that's 352×352 = 124k verts — ok, but PlaneGeometry segments 351 → indices big; fine. Actually simpler: segments = N (352) → 353² verts. Keep 320? Use SEG = N (same res, direct texel mapping with uv). PlaneGeometry(W, W, SEG, SEG), rotated -PI/2 (XZ plane, y up). UVs map texture.
• DataTexture: THREE.DataTexture(Float32Array N*N, N, N, RedFormat, FloatType), magFilter Linear if float-linear supported else Nearest, minFilter same, needsUpdate per frame; data = sim.field (direct reference! set tex.image.data = sim.field each preset since setPreset reallocs? No — H swaps buffers each step! The texture holds a reference to the initial H array which then swaps. PROBLEM: field swaps H/HO/HN every step, so sim.field getter returns current H. For the texture I must copy each frame OR avoid swapping. Copying 124k floats per frame (0.5 MB) via .set() is fast (memcpy) — do tex.data.set(sim.field). Fine.
• Surface ShaderMaterial: uniforms uH (texture), uMask, uMean, uTime, uAmp (vertical scale), uNormScale. Vertex: h = texture2D(uH, uv).r − uMean; pos.y += h*uAmp. Fragment: recompute h & neighbors via texture2D offsets (texel = 1/N) for normal; lighting: key light dir, spec; colors: deep base, crest cyan emissive (smoothstep on h), trough violet; mask: R=wall dark, G=shallow amber, B=sponge subtle. Also fresnel rim toward camera. Output HDR-ish values for bloom.
• Mask texture: RGBA8 from wallMask (R=255 wall), splatMul<0.5 (G=255 shallow), dampMul>3 (B subtle). Built on preset load.
• Droplets: up to MAXD = 36 meshes: shared SphereGeometry(1, 20, 14), per-mesh ShaderMaterial? Use one material with per-mesh uniform hue — easier: MeshStandardMaterial? Custom look: MeshPhysicalMaterial with emissive? To keep it simple & fast: MeshStandardMaterial({color, roughness:0.25, metalness:0.9, emissive: hue color, emissiveIntensity: 0.4}) per droplet (36 materials OK). Plus point light? No — use ambient + directional + emissive surface glow. Squash anim via scale. z = surfaceY + jump parabola: z_world = (sample(sim, x,y) - mean)uAmp + radius(1 - squash0.3) + jumpH4phi(1-phi).
• Shadow blobs: shared circular sprite texture, per-droplet Mesh with MeshBasicMaterial transparent black, rotated flat, y = surfaceY+0.02, opacity by height.
• Trails: per-droplet THREE.Line with BufferGeometry MAXP=120 positions + colors; update every 3rd frame push position; colors precomputed fade (head bright → tail black), AdditiveBlending, transparent, depthWrite false.
• Detector bars (slits): InstancedMesh(BoxGeometry(1,1,1), MeshBasicMaterial emissive-ish color, HIST_BINS) placed at detector x along z axis... world: x axis = cell i, z axis = cell j. Bars at x = cell2world(xd), z = bin center, height ∝ hist. Update on 'det' events (throttle 0.25s).
• Histogram canvas panel: 2D bars + count; visible in slits preset only.
• Tunnel panel: text stats (attempts, crossings, probability).
• Walls visual (slits): build wall meshes from wallMask rows? Simple: for each wall row segment create thin boxes — build once per preset: scan mask rows for runs of wall cells → merge into boxes. Might create ~700 boxes for slits (3-cell-thick wall × 2 segments ≈ 6 runs). Actually runs along j: two long runs (above/below slits) → merge consecutive rows into ONE box each? The wall is at fixed x with thickness 3, spanning j ranges: 2 big boxes + merge. I'll do row-run merging into boxes, usually < 10 boxes. Corral ring: draw a torus at Rc + floor disc colored shallow outside — use a big ring mesh (RingGeometry) tinted amber + torus rim.
• Audio: standard WebAudio; plink(freq, gain) on bounce events — thin to ≤36/s: keep per-droplet throttle (only if t - lastPlink[id] > 90ms) + global budget. Pad: oscillators through lowpass, gain follows fieldRMS. Chime on 'det' (pentatonic step by bin), whoosh+thud on 'tun', splash noise on click, click on UI.
• Post: composer with RenderPass, UnrealBloomPass(0.8, 0.5, 0.2), custom GradePass (vignette+grain+CA), OutputPass.
• Cameras: perspective 45°, orbit controls target center; V toggles top-down (position (0, 38, 0.01) lookAt 0). Auto-quality: if fps < 45 for 4s: reduce pixelRatio → 1, then bloom off.
• Snapshot: preserveDrawingBuffer false → use composer.render then canvas.toBlob; need render right before capture — do renderer.domElement.toDataURL after a manual composer.render() in same frame (works since buffer not cleared between frames... safer: preserveDrawingBuffer:true at init (minor cost). I'll set preserveDrawingBuffer: true.
• UI: panels like 055 (copy CSS patterns): title top-left; controls top-right buttons (presets 1-5, pause, reset, trails, top view, slow-mo, audio, snapshot); lab panel left (memory slider Γ, droplets slider, speed display); stats bottom-left; experiment panel bottom-right (slit histogram canvas / tunnel stats); help bottom-center? Keep: small footer hint.
• Click to splash: raycast to y=0 plane → cell coords → sim.addDroplet with small outward splash. Also shift-click = remove nearest? Add: click adds; that's enough. In slits preset clicking adds extra walkers too (fine).
• Keyboard: Space pause, 1-5 presets, V top, T trails, M mute, R reset, S snapshot, Z slow-mo.
• Sim loop: accumulator, dt fixed; slow-mo = timeScale 0.35; steps per frame cap 8 (at 240Hz, 60fps needs 4).

Sizes: keep code tight. Let me write it now. I'll aim for clarity over extreme polish given the clock — but still hit the "wow" checklist: bloom, grade, trails, detector bars, histogram, presets, memory slider, audio, adaptive quality, snapshot, touch.

One important check: sim.setPreset resets H/HO/HN via .fill — arrays persist (good, texture reference stable). But wait — in setPreset I do H.fill(0); HO.fill(0); HN.fill(0); — yes arrays persist, references stable.

For the texture: I'll keep texData = new Float32Array(N*N) and texData.set(sim.field) each frame — 0.5MB memcpy/frame, negligible.

Droplet world y: surfaceHeightWorldAt(x,y) = (sample − mean)*uAmp. mean = sim.fieldStats().mean? computing fieldStats each frame is O(N²) extra — instead expose prevMean? sim doesn't expose it. Add sim.getMean = () => prevMean. Quick edit to sim.js.

Let me also add DEFAULTS edit: waveC 0.06, kickGain 6, dragTau 0.8, maxSpeed 30. And dropRadius 3.5 keep. noise keep 0.015.

Also export HIST_BINS already done.

Now write everything. First the two sim.js edits, then the big HTML, then validation. GO.

90% time used. CRITICAL: I must finish immediately. The index.html is not written yet — that's a large file that takes a while to write. Options:

A) Write a compact but still good index.html quickly (~400-500 lines), validate, update index page, done. Risky but doable.

B) Write it in the next 2-3 tool calls maximum.

I need to add sim.getMean too. Let me combine: one edit to sim.js adding getMean, then ONE big write of index.html (must be complete and correct on first try), then combined validation + index update in one shell command, then _success.

Let me be very careful writing the HTML — no time for debugging rounds. Keep it as simple as possible while still impressive:

Simplifications to guarantee correctness:

• Surface: ShaderMaterial with displacement + fragment normals.
• Droplets: MeshStandardMaterial (no custom shader) — reliable.
• Trails: THREE.Line per droplet with precomputed color fade.
• Detector bars: InstancedMesh.
• Walls: merged boxes.
• Post: bloom + simple grade pass (I'll reuse a minimal ShaderPass).
• UI: minimal panels but complete: title, buttons (presets 1-5, pause, reset, trails, top, slow, mute, snapshot), memory slider, droplet slider, stats div, hist canvas, help line.
• Audio: keep compact: plinks + pad + chime + whoosh + splash. Mute toggle. ~80 lines.
• No pointer-lock, no complex cameras: OrbitControls + V toggle.

Let me write it now in one giant file write. I must get all IDs consistent. I'll draft mentally then write once.

Structure:

cell→world: wx = (x/N - 0.5)*W; wz = (y/N - 0.5)*W. Note texture v: PlaneGeometry uv v=0 at -W/2 (after rotation, careful). PlaneGeometry(W,W,N,N) lies in XY, uv (0,0) at (-W/2,-W/2). rotateX(-PI/2): x→x, y→z (with sign: rotateX(-90°) maps +Y to -Z? vector (0,1,0) → (0,0,-1)... rotateX(-π/2): y' = y cosθ + z sinθ... For mapping, what matters: uv=(0,0) corner at position (-W/2, 0, +W/2)? Let me compute: original point p=(-W/2,-W/2,0) (uv 0,0). rotateX(-π/2): (x, y, z) → (x, y·cos(−π/2) − z·sin(−π/2), y·sin(−π/2) + z·cos(−π/2)) = (x, z, −y). So p → (−W/2, 0, W/2). uv(0,0) ↔ world(−W/2, +W/2). My field texel (i=0,j=0) is sampled at uv=(0.5/N, 0.5/N) if I upload H row j as v. DataTexture row 0 = j=0. So world z = +W/2 ↔ j=0 → wz = (0.5 − y/N)*W. And wx = (x/N − 0.5)*W. Fine — define c2wX(x)= (x/N−0.5)*W, c2wZ(y)= (0.5−y/N)*W. Consistent for droplets, bars, walls, raycast inverse: x = (wx/W+0.5)*N, y = (0.5−wz/W)*N.

Wall boxes: scan wallMask; greedy row-run merge along i (rows j): for each row, find runs of wall; create box from (i0..i1, j..j) merging vertically identical runs — simple approach: per-row runs, then merge consecutive rows with same i0,i1. Heights: box height 0.5, y 0.25, depth/width world scale W/N. Slits only → ~2 merged boxes. Good.

Detector bars at x = c2wX(0.9N) line: bars along z at bin centers z = c2wZ((b+0.5)/HIST_BINS*N). Height = hist[b]*scale. BoxGeometry(0.14, 1, barW) with y scaled.

Corral rim: TorusGeometry(radius = Rc/N*W, tube 0.06) rotated flat at y 0.05 + shallow outer disc tint handled by mask (shallow amber G where splatMul<0.5: corral outside splatMul=0.12 ✓, tunnel strip 0.18 ✓, slit walls 0.05 ✓ (but wall R takes precedence)).

buildMask(): R=255 if wall; else G = splatMul<0.6 ? 255*(1−splatMul/0.6): 0; B = dampMul>2.5 ? 120 : 0 (sponge zones subtle blue).

Histogram canvas: 260×90, draw bars each det event (throttle 250ms) + text count.

Stats: Γ %, walkers, v̄ (cells/s → show as is, "cells/s"? better show "mm/s" fake: v0.9? 1 cell ≈ 0.18mm: v0.18 mm/s — say v̄*0.18 with 0 decimals... cells/s is honest; I'll show "v̄ 17.8 cells/s · 3.2 mm/s"). Keep cells/s + mm/s.

Tunnel stats & slit stats share the px panel: show hist canvas only in slits; text lines otherwise (corral: show orbit radius; tunnel: attempts/crossings/P).

Presets default memory: pool 0.90, corral 0.94, slits 0.90, tunnel 0.95, promenade 0.92. setPreset + setMemory + rebuild mask/walls/bars + slider sync.

Droplet slider 1-30: adjust count live (add/remove at random positions).

Memory slider 0.5-0.99 → sim.setMemory.

Audio engine: ctx on first gesture. master gain 0.9. plink: osc sine freq 380+hue500, exp decay 0.09s, gain 0.05amp (budget: per droplet 100ms throttle + global 30/s). pad: 2 osc (saw 55Hz, 55.7) → lowpass 240 → gain 0.02+rms*0.004 (update per 0.25s, cap 0.09). chime: on det: two sine notes pentatonic by bin. whoosh on tun: noise buffer bandpass sweep. splash on click: short noise burst lowpass. click: UI tick 1200Hz 0.03s.

Grade pass shader: uniforms tDiffuse, uTime; frag: vignette + grain + slight CA: sample tDiffuse with small radial offsets for r/b. Standard ~25 lines.

Adaptive: track EMA fps; if <45: step down quality stages [pixelRatio min(dpr,2), bloom on] → [pr 1.25] → [pr 1, bloom off]. Show tiny "Q" indicator? skip indicator.

OK writing now. Long file — go. I'll be disciplined about matching IDs and variable names.

Also remember to expose sim.getMean in sim.js — need that edit. And HIST_BINS export exists.

One more: sim.drainEvents used each frame; events include every bounce (up to 36 droplets × 8Hz = 288/s — fine).

For trails: store points in cell→world coords; push every 2 frames; shift when > TRAIL_MAX=110. Update line geometry attributes: positions Float32Array(TRAIL_MAX*3) & colors precomputed gradient; drawRange = count. Color per droplet hue → THREE.Color setHSL(hue, 0.9, 0.6), fade to black by index.

Shadow blob: generate radial gradient canvas texture once; PlaneGeometry(1,1) rotated flat; per droplet mesh; opacity 0.35/(1+height).

Time to write. After writing: validation commands:

1. node --input-type=module --check < extracted script — write extract to /tmp/x.mjs then node --check. Note: node --check on .mjs works (parses module).
2. Fast physics smoke: 30s run pool (v̄ in range, no NaN) + 20s slit run (detections ≥ 1) + 20s tunnel — one node script, ~40s runtime.
3. Update index page card. Then _success.