Frostline Demo Creation

Hmm, the search text wasn't found. There might be whitespace differences. Let me check the exact text around "New demos are added here".

*****************************************************************************************************02.

The indentation is 8 spaces before the comment, not matching. Let me use the exact text with 8 spaces. Actually the line is <!-- New demos are added here --> (8 spaces). My search had 8 spaces too... wait, let me count: in my search I used " " — 8 spaces. Hmm, but the replacement failed. Maybe there was a difference in the second line — <a class="demo-card" href="./021-terraforge/index.html"> with 10 spaces. My search had 10 spaces too. Let me try replacing just the comment line.

The search text isn't found even though grep found it. Maybe there are special characters or the file has Windows line endings? Let me check with cat -A on that specific line. Earlier grep -n "New demos" ... | cat -A showed 99: <!-- New demos are added here -->$ — wait, that shows 6 spaces before <!-- (after the "99:" prefix). Let me count: "99:" then spaces... The output was '99: <!-- New demos are added here -->$'. After "99:" there are 6 spaces? Actually grep -n output format is lineno:content. So content starts after "99:". The content appears to be " " — hmm, hard to count from that. Let me get exact byte content.

************************************************************************************************************************************es.

*************************************************************************************************************************************************************************************************es.

The index page is now updated with the Cloudsea demo card. Now the remaining question: what should this run accomplish? The task says "Wake up and do as you please." The last execution summary indicated the next step was updating the index page — that's done now.

Since I have time, I could create a brand-new demo (023). The style guidelines say to go advanced. Let me check how much time I might have — I don't have a strict signal, but each run typically has a time limit (~15 min based on the previous run). The Cloudsea demo creation took ~15 minutes. Creating a whole new advanced demo is a big job, but that's my purpose. Let me first quickly validate the Cloudsea demo HTML exists and is well-formed, then decide.

Actually, the task instructions for this run are just "Wake up and do as you please." The natural continuation: finish the pending index update (done) and then create a new demo #023. Let me verify the cloudsea demo file is complete first.

The Cloudsea demo file is 24KB and ends with </html>. But 24KB seems small for the described complexity — the previous summary described many features (UI panel, audio engine, adaptive quality, loading screen, lightning, etc.). 24KB is plausible for compact code, but the summary mentioned a lot. Let me check whether the file is actually complete and functional — e.g., does it include the full script with UI wiring, render loop? Let me scan the structure quickly.

The Cloudsea demo looks well-structured and complete. The index page is now updated. The pending work from the last run is finished.

Now, per my purpose, I should create a new demo. The task says "Wake up and do as you please" — so I can create demo 023. But I need to be mindful of time limits. The previous run took ~15 minutes for a complex demo. I don't know how much time I have in this run, but the checkpoint system will notify. Let me plan a new demo that's impressive but that I can write efficiently in one go.

Let me think of a concept for demo 023. Previous demos:

1. Spinning cube
2. Nebula galaxy (particles)
3. Mandelbulb (ray-marching)
4. Fluid dynamics (GPU Navier-Stokes)
5. Gravity sandbox (N-body)
6. Event horizon (black hole lensing)
7. Sonic reactor (audio visualizer)
8. Void 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 gears)
14. Neon rain (cyberpunk city)
15. Aurora borealis
16. Skitter (creatures)
17. Coral resonance (cymatics)
18. Threshold (portals)
19. Attractorium (strange attractors)
20. Murmuration (boids flocking)
21. Terraforge (terrain erosion)
22. Cloudsea (volumetric clouds)

Ideas for 023:

• Reaction-diffusion 3D / Gray-Scott on a surface
• Cloth simulation playground
• Ray-traced (real raytracing in fragment shader) scene — sphere tracing with reflections/refractions
• Lava lamp / metaballs ray-marched
• Fractal flames
• Double pendulum chaos gallery
• Water caustics pool
• WFC procedural city
• Snow globe diorama
• Volumetric fire / campfire
• Space elevator / orbital ring
• Hyperbolic geometry explorer
• Caustics / underwater light
• Crystal growth (dendrites) — diffusion-limited aggregation
• Firefly swarm in a forest
• Origami / paper folding
• SPH fluid in a glass (3D particle fluid)

A strong candidate: "Emberwild" — a volumetric campfire with GPU particles, sparks, smoke ray-marching, procedural night forest... but fire might overlap with existing.

Another: "Kinetic Sand" — no.

"Prismatix" — ray-marched scene of glass/SDF objects with real reflection/refraction/dispersion... A "glass cat" or caustics. Could be heavy.

"Dendrite" — crystal growth lab: diffusion-limited aggregation / snowflake growth on GPU. Snowflake simulation with phase-field could be gorgeous and unique. Gray-Scott reaction-diffusion in 3D on GPU is classic but very impressive — "Coral Garden"... overlaps with physarum somewhat.

Snowflake / dendritic crystal growth: A WebGL snowflake lab — you can grow real-looking snowflakes via the Gravner-Griffeath algorithm on GPU, freeze them onto a 3D ornament... That's unique, seasonal-agnostic, beautiful with bloom. Interactivity: paint seed sites, temperature/humidity sliders, melt, grow multiple flakes on a frosted window with bokeh lights behind.

Actually, an even more striking idea: "Frostfall / Frostbound" — an interactive winter window: frost patterns creep across glass (phase-field frost growth simulated on GPU), you can wipe the frost with your pointer to reveal a snowy night scene beyond (instanced falling snow, aurora?). But aurora overlaps demo 015.

Alternatively: "Pendulum Waves / Chaos Gallery" — less wow.

"Supernova" — ray-marched volumetric explosion... overlaps nebula.

"Kintsugi" — breaking and repairing? Physics fracture is complex.

"Tessellate" — M.C. Escher style hyperbolic tessellation explorer (Poincaré disk) rendered in shader, animated. Very cool: ray-marched hyperbolic tiling with animated patterns, user can change {p,q} tilings, fly through. Unique and mathematically impressive. "Hyperloom" — a hyperbolic geometry playground. Rendered via fragment shader doing hyperbolic ray-marching or via the Poincaré disk with geodesic tiling. Could do a first-person fly-through of H³ space with a {5,3,4} honeycomb... that's advanced but doable in a fragment shader with repeated reflections in fundamental domain (like "Hypernom"). That's quite involved but I can do a 2D Poincaré disk version that's still gorgeous: animated {7,3} tiling with swirling colors, fish swimming along geodesics (Escher's Circle Limit), interactive p/q sliders, zoom into the boundary. Plus bloom and grain. That's very achievable in a single pass shader and unique.

Hmm, but let me pick something with more "physics + gameplay" maybe. The user likes interactive experiences.

"Circuit Bonsai"? "Lantern Drift"?

Let me go with "Frostline" — an interactive frost-on-glass demo:

• GPU simulation of frost crystal growth (phase-field / cellular automaton, Gravner-Griffeath snow crystal model or simpler dendritic CA with neighborhood rules) on a 2D texture at high res (1024²).
• The frost texture is used as an alpha/roughness mask over a beautiful "beyond the window" scene: a snowy 3D night scene with falling snow particles, warm lit cottage, moon, trees — or simpler: the scene is rendered, then frost accumulates on the "camera lens/window" plane, and where frost grows, the scene gets blurred/frosted with sparkle normals.
• Interactivity: drag to wipe frost away (warm touch), breathe to regrow (click?), temperature slider (colder = faster, more branching), humidity slider, wind.
• Visual polish: frost sparkles with anisotropic glints, bloom, vignette.
• Audio: wind, soft chimes, creak.

This is unique among demos, achievable, and can look stunning. The Gravner-Griffeath algorithm: each cell has vapor + ice; receptive cells accumulate; diffusion for non-receptive. Implementation in fragment shader ping-pong is well documented. Growth produces dendritic snowflake-like patterns.

Simpler robust approach: DLA-like growth via a cellular automaton — cells near ice freeze with probability depending on neighborhood count, plus vapor diffusion. Actually Gravner-Griffeath is quite implementable:

• State per cell: (a = quasi-liquid mass, b = boundary mass, c = crystal mass, d = vapor mass). Receptive if frozen or has frozen neighbor... Rules:
  1. Diffusion: vapor diffuses (average with neighbors) on non-frozen sites.
  2. Freezing: receptive sites convert vapor to ice: a += κ d, d *= (1-κ).
  3. Attachment: boundary mass melts/attaches... Full GG: each cell has (ice flag, quasi-liquid, ice mass, vapor). At each step: (1) diffusion of vapor for non-ice cells; (2) freezing: fraction κ of vapor becomes ice for receptive cells; (3) attachment: receptive cells' quasi-liquid+boundary attaches with probability based on neighbor count; (4) melting: fraction μ of boundary mass melts back.

This is well within a fragment shader ping-pong with RGBA16F texture: R = ice mass (crystal), G = boundary/quasi-liquid, B = vapor, A = frozen flag.

Growth rate parameters: α (attachment), β (attachment threshold), γ (vapor background), κ, μ, ρ (initial vapor density). These map to "temperature" and "humidity" sliders.

Rendering: frost texture → normal from gradient, sparkle via noise + view angle, scene behind gets blurred where frost is dense. For blur without a mip-chain of scene... We can sample the scene texture with a poisson disk of radius proportional to frost density (using a low-res mip of the scene render — we can generate mipmaps of the rendered scene texture since it's a render target; we can set generateMipmaps). Simpler: render scene to RT with mipmaps enabled, sample with textureLod bias proportional to frost. Frost = refraction-ish offset + sparkle + white scatter.

This is a solid, unique, beautiful demo. Name: "Frostfall" — "An interactive winter window: GPU-grown frost crystals". Number 023.

Features list:

• GPU frost growth sim (Gravner-Griffeath snow crystal) at 768² or 1024², multiple sim steps per frame (speed control).
• Multiple seed flakes growing across the pane; click to plant a new seed; drag wipes frost (melts it with a warm hand print).
• Behind the glass: procedural night scene — snowy forest silhouettes (instanced), warm cottage windows, moon, falling GPU snow particles, drifting mist. Rendered in 3D with slight parallax; or as a single fragment shader scene with depth-based blur. To keep scope manageable: render the outside scene procedurally in a fragment shader (2D painterly scene: gradient night sky, stars, moon with glow, tree-line silhouettes via FBM ridging, cottage with glowing windows, falling snow in layers with parallax based on camera/pointer). That avoids a full 3D scene and keeps quality high in limited time. Actually a small 3D scene could be more "three.js"... but a procedural painterly shader scene behind a frost sim still uses three.js for the pipeline and is gorgeous.

Hmm, but demos should showcase Three.js. The pipeline: frost sim on GPU (two RTs), scene rendered as a full-screen procedural shader into an RT with mipmaps, then composite pass: blurred scene + frost scattering + sparkle + vignette/grain/bloom. All Three.js WebGL. Good.

Add some 3D: tilt the window slightly with pointer parallax (scene UV shifts), snow particles as real Points? Could integrate snow in the shader scene. Keep it shader-based.

Controls:

• Temperature slider (−30..0°C): colder → faster branching, sharper dendrites.
• Humidity: initial vapor + replenishment.
• Wind: drift the growth / snow.
• Buttons: New seeds (scatter), Clear pane (re-frost), Wipe mode toggle?, Snapshot, sound toggle, quality.
• Keyboard: N new seeds, C clear, P snapshot, M mute, H hide UI.
• Audio: wind noise (filtered), occasional distant owl? chime sparkle on frost sparkle? Keep: wind + soft pad; wiping makes a soft squeak sound? Maybe subtle. Frost growth tinkle: tiny random crystalline pings at low rate while growing — nice touch.

Time budget: I need to write this efficiently, one big file. The last run hit time limits at ~15 min with a 24KB file. I should aim for a file maybe 30-40KB and write it in 1-2 chunks quickly. Actually time constraints: I don't know how much time has passed. Writing a large file in one write call is fine. Let me be efficient: draft the whole HTML in one go, then quickly sanity check syntax (node --check on extracted JS? The JS is a module embedded; I can extract and parse with node --input-type=module check). Let me do that.

Let me design the frost sim shader carefully (Gravner-Griffeath, simplified but functional):

State texture RGBA float:

• R: ice mass m (attached crystal)
• G: boundary mass b (quasi-liquid at boundary)
• B: vapor mass v (diffusible)
• A: frozen flag (1 if receptive/ice site)

Per step (single fragment shader pass): For cell s:

1. If frozen (A=1) → cell stays frozen; vapor at frozen cells is 0 (vapor only on non-frozen). Ice doesn't diffuse.
2. Diffusion: for non-frozen cells, B_new = average of own + neighbors' vapor (von Neumann or Moore). To conserve and be stable: v' = v + 0.5*(avgNeighbors - v)? GG uses discrete diffusion: v' = v/2 + avg(neighbors)/2.
3. Freezing (receptive sites): receptive = frozen OR has any frozen neighbor. For receptive sites: b += (1-κ)v, m += κv, v = 0.
4. Attachment: for receptive sites (non-frozen with frozen neighbor): combined = m + b; attach if: neighborCount==1||2 → combined >= β; neighborCount==3 → combined>=1 OR ... GG rule: attach if (m+b >= 1) or (neighbors<=2 and m+b>=α) etc. Simplified: if (m+b >= β) OR (m+b >= α*neighborFactor). Let me simplify: attachProb threshold: t = (count<=2)? β_low : 1.0; if m+b >= t → frozen=1, m stays, b=0.
5. Melting: b += μm0? Actually melting: v += γ1 * b; b *= (1-μ); and m *= (1-σ) slight sublimation for non-... To keep it simple and stable: no melting except the wipe tool directly modifies texture.

Classic GG parameters: κ∈[0,1] freezing fraction, μ melting, γ vapor addition constant, β attachment threshold, α thresholds by neighbor count. Initial: all cells v=ρ (0.5-0.8), seeds frozen m=1.

The pattern emerges: dendrites for high ρ. This sim produces fern-like growth that looks convincingly frosty, especially when grown from multiple seeds and edges (window edges are receptive → frost creeps from edges inward — realistic!). Edge cells: treat border as frozen-seed when "edge frost" enabled: cells at border have frozen neighbors → receptive. Nice: frost creeps in from window frame + from seed specks (dust motes).

Simplification for stability and speed: do 2-6 sim iterations per frame at 512² or 1024² — each iteration is one fullscreen pass reading the previous texture. With RGBA16F ping-pong. Fine.

Wipe tool: a separate "brush" pass: stamp a Gaussian blob into state where pointer is down: set frozen=0, m=0, b=0, v=ρ (restore vapor) → creates clear circle that will slowly refrost. Also add "warmth": we could keep wiped area's v lower so it refrosts slowly. Good enough: restore v=ρ; growth re-creeps from edges of the wiped circle.

Also add subtle permanent "streaks"? Skip.

Rendering frost (composite shader inputs: scene RT with mips, frost state RT):

• frostDensity f = clamp(m + b*0.6, 0..1) smoothed.
• Where f>0: scene blurred: color = mix(sharpScene, blurLodScene, f^0.7).
• Frost whiteness: add white-blue scatter: mix toward frostColor by f * 0.35 * sparkleMask.
• Sparkle: normal from m gradient; N = normalize(vec3(-dFdx, -dFdy, k))... compute gradient via texture taps; glint = pow(max(0, dot(N, halfVec)), 200) * glitterNoise(pixel, time*slow) → twinkling. Multiply by moonlight color.
• Edge lighting: frost edges slightly bright.
• Wiped areas: slight wet streak — darken+refract? Add faint droplet noise where recently wiped? Skip for scope; maybe simple: wiped cells have v≈ρ and no frost → just clear.

Scene shader (procedural winter night outside):

• Sky: deep gradient (navy → indigo), stars (hash-based twinkle), big soft moon with halo (upper right), faint horizon glow from a village.
• Far mountains: ridged FBM silhouette dark blue.
• Tree line: jagged FBM spires (conifer silhouettes) two layers.
• Cottage: simple shapes — rectangle body with snow roof, warm glowing windows (bloom picks up), chimney smoke? maybe faint rising FBM wisp. Place cottage left-of-center.
• Ground: snow field with moonlit gradient, sparse sparkles.
• Falling snow: 3 parallax layers of hash-based drifting flakes, plus near big bokeh flakes (out of focus discs).
• Slight parallax: pointer/camera offsets UV by layer depth.

The scene shader + frost sim + composite + UI + audio: total maybe 700-900 lines. Doable.

Audio (WebAudio):

• Wind: filtered noise (bandpass ~ 300-800Hz w/ slow LFO on freq/gain).
• Pad: two detuned sine/triangle oscillators through slow filter, very quiet, minor chord.
• Frost tinkles: tiny high sine pings w/ fast decay, triggered randomly proportional to frost growth rate, panned.
• Wipe squeak: short filtered noise sweep when wiping.

UI: panel with sliders (Temperature, Humidity, Growth speed, Wind), buttons (Scatter seeds, Clear & refrost, Snapshot, Sound), stats (frost coverage %, FPS), hints. Style consistent with previous demos: dark glass panel top-left presumably; check what cloudsea used? I don't need to match exactly; use my established style: glassy panel, small caps, etc. I'll craft a clean one.

Post: UnrealBloomPass? The whole pipeline: I'm doing custom composite as final ShaderPass... Simplest: render everything via my own composite to screen with bloom via EffectComposer: RenderPass of an orthographic quad scene? For post-processing chain with three's EffectComposer, easiest: use a fullscreen quad approach with my own passes as ShaderPasses reading uniforms. I'll structure:

• simScene/quad: not via composer; manual RT ping-pong for sim (WebGLRenderTarget pair).
• sceneRT: render outside-scene shader to RT with generateMipmaps true (LinearMipmapLinear).
• Composite: EffectComposer with a custom "CompositeShader" as first ShaderPass (uniforms: sceneRT texture, frost texture, time, pointer) → then UnrealBloomPass → OutputPass. Use a dummy RenderPass? ShaderPass with tDiffuse unused is fine; composer needs at least one pass; make compositePass the first pass with clear — fine.

Actually to keep it simpler and avoid composer pitfalls, I could do bloom manually... no — use EffectComposer, it's standard in previous demos.

One more feature: "breathe" — hold B or button: warm breath fog spreads from bottom center (wipes frost in a growing blob) — cute. Maybe skip; wipe drag is enough. Actually pointer drag wipes; add double-click to plant seed. Keep controls: drag = wipe, click (no drag) = plant seed? Better: drag wipes (since wiping along is natural); Shift+drag or right-click plants seed; button to scatter seeds. Also on touch: drag wipes; two-finger tap seeds? Keep: tap = seed, drag = wipe. Implement: on pointerdown record; on pointerup, if moved < 6px → seed else wipe along path.

Keyboard: C clear, S scatter seeds, P snapshot, M sound, H hide UI, 1/2/3 presets (Deep Freeze, First Frost, Thaw).

Presets:

• "First Frost": temp −4, humidity .45, slow.
• "Deep Freeze": temp −22, humidity .8, fast, edgy dendrites.
• "Thaw": temp −0.5: growth near-stops, melting? Implement melt slider? Thaw preset could reduce κ... Without melting rule, thaw = no growth + sparkle. Hmm, add melting parameter μ applied to boundary b each step and small sublimation of m for edge cells when temp high: implement "melt" uniform: b = (1-meltneighborFactor), m = (1-melt0.02) for cells with empty neighbors → frost recedes slowly. Nice for Thaw preset.

Coverage stat: read back? Use a small downsample pass... simpler: compute on GPU into 1x1 via multiple reductions — skip; estimate coverage by counting? Could do periodic gl.readPixels on a 64x64 downsampled copy (render sim texture to tiny RT, read 64*64 floats every second). That's easy: a reduction shader sampling 8x8 grid → 64x64 RT, readPixels RGBA float 64x64 = fine every 500ms. Good for UI % and audio tinkle rate.

Adaptive quality: sim res fixed 768; render scale adjust by FPS (renderer pixel ratio scaling between 0.5-1 of devicePixelRatio), bloom toggle at low FPS. Simple auto: measure avg frame time; adjust renderScale steps.

Snapshot: canvas.toBlob → download link. Note preserveDrawingBuffer false — must render before capture: call composer.render() then immediately toDataURL in same task. Standard trick works.

Now — time. I've already used a few minutes. Let me write the file in one large write (maybe ~1000 lines). I must be careful with GLSL correctness since I can't visually test. I'll keep shaders moderately simple and syntax-check JS with node.

Let me check available node:

Good, node is available for syntax checking. Now let me create the demo directory and write the file. I'll write it in two parts (part 1: HTML/CSS + start of script; part 2: rest) to keep each write manageable — actually a single write might be ~40KB, which is fine. Let me carefully compose.

Plan the code structure:

HTML:

• #c canvas container? renderer appends canvas to body.
• #ui panel: title "FROSTLINE", subtitle, stats row (coverage, fps), sliders: Temperature (temp −30..2), Humidity (0..1), Growth (steps 0..12), Wind (−1..1), Melt maybe implied by temp.
• Buttons row: Scatter Seeds (S), Wipe All / Refrost (C), Snapshot (P), Sound (M).
• Preset buttons: First Frost / Deep Freeze / Thaw (keys 1,2,3).
• #hints bar, #toast.

JS modules:

1. Imports.
2. Boot: renderer, orthographic camera + quad scenes (simScene, sceneScene, composite via composer).
3. Sim: RTs (RGBA16F? need linear filtering? use HalfFloatType, LinearFilter), init shader (vapor + seeds from edges), sim update shader, brush shader (wipe/seed stamps), reduce shader for coverage.
4. Scene shader → sceneRT with mipmaps.
5. Composite shader pass in EffectComposer + UnrealBloom + OutputPass.
6. Pointer handling, keys, UI wiring, audio engine, quality autoscaler, resize, snapshot.

Sim shader details (GG simplified):

State channels: R=ice m, G=boundary b, B=vapor v, A=frozen flag f.

Per pass (Moore neighborhood, 8 taps):

Rules:

Hmm wait — I mixed: for receptive, freezing converts ALL vapor to b/m (GG: yes, receptive sites freeze their vapor). Attachment: if m+b ≥ threshold → becomes ice (f=1), and b merges into m? On attachment: m' = m + b, b' = 0. Yes.

Vapor replenishment: each step, non-frozen v = max(v, rho)? GG: v clamped to background ρ: v = max(v, ρ). Wait GG: after diffusion, v at non-receptive... they add γ constant to boundary cells. Simplified: each step v = max(v, rho) for non-frozen cells — acts as humidity source, keeps growth going near the front. That's a common simplification and works (gives constant supply). Actually if v=max(v,ρ) everywhere, receptive boundary always has v≈ρ → constant growth rate → dense frost. Fine for frost (we want pane coverage, dendritic texture from diffusion instability). The instability: tips have more neighbor-vapor access. Hmm, with max(v,ρ) supply everywhere, growth front advances uniformly-ish; dendrite structure comes from noise in initial vapor + grid anisotropy. To get ferny dendrites, keep ρ moderate and DON'T replenish fully: replenish only slightly: v = min(1, v + rho0.02). Then diffusion from far field feeds tips → dendrites. Let me use: v = min(v + supply, 1.0) where supply = humidity0.03 per step. Frozen cells v=0. This gives depletion halos → dendritic.

Edge seeding: init pass sets cells within N px of border as frozen with m=1 when edgeFrost enabled (temperature low → edges first). Also scattered seed points (passed as uniform array? simpler: seeds baked via brush stamps at init and via scatter button — the brush shader stamps frozen dots).

Growth speed UI = sim iterations per frame (0..10).

Temperature mapping: colder → lower attachment threshold (more branching: betaLow lower, κ higher). tempNorm = (−T)/30 → kappa = mix(0.05, 0.4, tN), betaLow = mix(1.6, 0.4, tN)? And attach threshold for ≥3 neighbors = 1.0 fixed. Melt = smoothstep(> -2°C) up to 1 at +2.

Actually keep uniforms: uKappa, uBeta, uMelt, uSupply, uEdge (0/1).

Wipe brush: stamp: for cells within radius r of uv: f=0,m=0,b=0, v=ρ0 (reset vapor). Also write a "wet" channel? No channel left (A used by f). Wetness visual: skip or reuse: after wipe, v=ρ0 with m=b=0 → clear. Good.

Seed brush: stamp f=1, m=1, b=0, v=0 within tiny radius (2px) plus slight vapor bump around.

Sim at 768×768 (fits window aspect; the pane is full screen; use full-res sim matching aspect? Sim texture square 768; composite samples with aspect-corrected uv (cover). Fine — frost cells slightly stretched on wide screens; acceptable, or sim at 1024×576-ish fixed 16:9 and crop on tall screens. I'll do simW=896, simH=504 (16:9) and "cover" fit. Phones portrait → crop sides. OK.

Coverage reduction: shader renders 48×27 grid sampling sim (R channel) → small RGBA float RT; readPixels every 600ms → coverage = avg(m>0.05). readPixels on HalfFloat RT may not be supported; use UnsignedByteType RT for reduction (encode m in R*255). readPixels RGBA/UNSIGNED_BYTE always supported.

Scene shader ("outside"): I'll write painterly:

• uv with parallax offset by pointer (uParallax).
• Sky gradient: mix(#060a18, #101c3a, uv.y) + horizon warm glow (#2a1e3f) near y~0.32? Cottage light pollution.
• Stars: hash grid, twinkle by time; only above horizon; fade near moon.
• Moon: pos (0.72, 0.78) radius 0.05, disc with crater noise, halo = exp falloff (bloom will glow).
• Mountains: y < 0.34 + ridge(uv.x*3)*0.06 → dark #0b1226 silhouette; second ridge layer.
• Forest: conifer spikes: y < 0.30 + tri(noise) ... two layers with parallax; color #060a16 w/ snow dusting on spike edges? subtle.
• Cottage at x≈0.30: body rect (0.055h), snow roof triangle, two windows glowing #ffb45c with flicker; chimney with smoke: fbm swirl rising, alpha low; door warm slit.
• Ground snow: below y=0.16 gradient #9fb4d8→#31405f, moonlit sparkle: hash glints.
• Falling snow: 3 layers: flakes = smoothstep on hash cells drifting with time*speed + wind + sin wobble; layer scales: far small/dim, near big/blurred (draw soft disc).
• Slight vignette handled in composite.

Composite shader:

• sharp = texture(sceneRT, uv)
• frost f from sim texture (cover-fit uv): f = clamp(m1.2 + b0.5, 0, 1)
• blurred = textureLod(sceneRT, uv, mix(0., maxLod, pow(f, .8))) (maxLod ~ 4-5)
• color = mix(sharp, blurred, smoothstep(0.03,0.25,f))
• frost normal: gradient of f (2 taps) → N; light from moon dir (screen-space, matches moon pos) → sheen = pow(max(dot(N,L),0),8)
• frost body color: mix(color, frostCol( #cfe0ff), f*0.55 + sparkle)
• sparkle: n = hash(uvbig + floor(time3)) → glint = step(0.997, n) * f edge… better: glint = pow(hash, 40)* f * 4. Additive, cool white.
• breath/wet? skip.
• grade: vignette, grain, slight chromatic aberration on edges (cheap: sample R/B shifted at screen edges × small).
• Also frost "thickness" pseudo-AO near frame edges: darker frame border (window frame): draw subtle frame bevel: border 12px darker + inner glow. Nice: a window frame! Add simple frame: inset rectangle border dark wood color + glass edge highlight. That sells "window" strongly. Do in composite: frame mask via smoothstep on min distance to edges; frame color #14100c with slight gradient; inner bevel highlight where frame meets glass.

Actually a frame also gives frost a natural origin (edges).

Audio: wind noise buffer → bandpass; gain by wind slider; pad: osc sine 110+110.5 & 165 → LP filter, gain 0.05; tinkles: schedule tiny pings: every ~120-350ms if growing, freq 1800-4200Hz, decay 0.08s, gain scaled by coverage growth delta; wipe squeak: on pointermove while wiping, short noise burst HP filtered with random playbackRate, throttled.

Quality: renderScale in {1, .85, .7, .55} × devicePixelRatio (cap 2); bloom half res always (UnrealBloomPass handles). Auto: frame time EMA; every 2s adjust.

Snapshot: render composite, then canvas.toBlob → a.download 'frostline.png'.

Alright — also need "toast" messages and hints, consistent with prior demos.

One risk: EffectComposer first pass being ShaderPass — composer.render passes readBuffer to ShaderPass; our composite ignores tDiffuse and uses own uniforms — fine. Need composer.addPass(compositePass) then bloom then OutputPass. OutputPass handles tone mapping/color space. Use renderer.toneMapping = ACESFilmic, outputColorSpace default sRGB (OutputPass applies). My shaders write linear-ish colors; ACES will shape nicely. Note: with ShaderPass writing to buffer, tone mapping applied at OutputPass — fine.

HalfFloat RTs: sim RTs type HalfFloatType, format RGBA, LinearFilter, no depth. sceneRT: HalfFloatType with mipmaps (generateMipmaps true, minFilter LinearMipmapLinearFilter). After rendering scene each frame, mipmaps auto-generate (WebGL2 generateMipmap on half float color-renderable... EXT_color_buffer_float covers RGBA16F renderable; generateMipmap on RGBA16F is allowed in WebGL2 if color-renderable & filterable — RGBA16F is filterable by default? OES_texture_half_float_linear is core in WebGL2 (float16 linear filtering is NOT core — needs EXT? Actually in WebGL2, float16 textures are filterable (linear) without extension; float32 linear needs OES_texture_float_linear. generateMipmap requires color-renderable + filterable → RGBA16F OK with EXT_color_buffer_float (widely available; three.js WebGLRenderer with WebGL2 enables it). Good. Fallback: if EXT_color_buffer_float missing, use UnsignedByteType RTs. I'll add try/fallback by checking renderer.extensions.has('EXT_color_buffer_float') — three r160+: renderer.extensions.has or capabilities. Simpler: attempt HalfFloat, catch context issues? Can't easily catch. Use renderer.extensions.get('EXT_color_buffer_float') → if null, use UnsignedByteType for sim (works: values 0..1 quantized — fine!) and scene (LDR-ish, fine). I'll code a RTType variable.

Sim precision with bytes: m accumulates up to ~2-3; clamp. OK clamp all outputs to [0,4] for float, [0,1] for bytes. Keep values ≤1 mostly: m up to ~1.2 fine; clamp to 1 for byte fallback — slight loss, acceptable.

textureLod in GLSL1 (three default) with WebGL2 → three compiles GLSL1 to 300 es automatically; textureLod available in 300 es. With ShaderMaterial default glslVersion, three prepends #version 300 es when running WebGL2 and converts texture2D calls? No — three only auto-converts built-ins; my raw textureLod in a GLSL1-authored shader... Actually three.js WebGL2: shaders authored in GLSL1 style are compiled as GLSL 300 es? No. three.js always compiles with #version 300 es for WebGL2 and includes compatibility defines: #define texture2D texture etc. Yes! In WebGL2, three prepends version 300 es plus defines mapping texture2D→texture, and texture2DLodEXT? For textureLod I should write textureLod(...) — is there a define? three's prefix includes: #define texture2D texture (for fragment) and in GLSL3-converted shaders textureLod exists natively in 300 es. So calling textureLod(tex, uv, lod) in a fragment shader compiled as 300 es works natively. Great (previous demos likely did this). To sample scene RT with explicit LOD for blur — needs the texture bound with mipmaps; fine.

But wait: UnrealBloomPass + OutputPass between — composer passes receive readBuffer; our composite pass needs material.uniforms.tScene.value = sceneRT.texture and after rendering scene to sceneRT, mipmaps regenerate automatically (generateMipmaps=true → renderer calls generateMipmap after render? Actually WebGLRenderer updates mipmaps on textures used with generateMipmaps when texture.needsUpdate... For render targets, three auto-generates mipmaps after rendering to it if texture.generateMipmaps is true (in WebGL2 it calls generateMipmap in setRenderTarget/unbind flow — yes, updateRenderTargetMipmap is called when texture.generateMipmaps && minFilter needs mips, after rendering. Confirmed behavior in r150+.

Sim texture sampling in composite: LinearFilter ok.

Pointer parallax: uv offsets in scene shader; also composite frost stationary (frost is on the glass — no parallax) while scene shifts — perfect physical sell.

Now write the code. Also handle pointer events: pointermove → wipe stamps along segment (interpolate between last & current, stamp every ~8px sim-space). Use sim-resolution brush passes (render 1 quad per stamp? Better: brush shader takes two points (from,to) + radius and stamps capsule — one pass per pointermove event). Also throttle: accumulate into "pending stroke" and apply once per frame (from last applied pos to current pos). Wipe radius ~ 5% of height.

Seed on tap: pointerup with small movement & short duration → seed stamp (radius 2px).

Also idle "dust seeds": when starting, scatter ~7 seeds + edges on. Clear button: re-run init (vapor reset, keep nothing) then optional auto-scatter.

Presets: 1 First Frost: temp −6, humidity .5, growth 3, wind .2, edge on. 2 Deep Freeze: temp −24, humidity .85, growth 6, wind .5. 3 Thaw: temp +1 → melt .8, growth 1? melt only acts if implemented: exposed ice loses mass; when m < .05 → defrost → frost recedes. Add refreeze later. Good showpiece.

Temperature→params mapping (JS each frame): tN = clamp((−temp)/28, 0..1) (temp in °C, from +2 down to −30). kappa = .06 + .35tN beta = 1.5 − 1.1tN (colder→lower threshold→easier attach→denser/faster) supply = humidity * (0.015 + 0.03*tN) melt = smoothstep(−1.5, 2, temp) (0 below −1.5°) edge = 1 (always, but edge seeding only at init) — also continuous edge receptivity handled by frozen edge cells themselves.

Hmm — with edge cells frozen permanently (they're ice m=1), frost always creeps from frame inward — nice. When user wipes near edge, edge cells get wiped too (refreeze eventually). OK.

Wind: affects snow scene drift + slight anisotropic growth? Sim wind: offset sampling? Could bias diffusion: sample neighbors with uv shifted by windtexel → advection of vapor. Simple: when computing diffusion, sample vapor field shifted upwind by (wind2px). Pass uWindShift. Cheap, gives directional frost leaning.

Init shader: v = ρ0 (humidity0.55+0.25) with noise variation; edges (within 3px): frozen m=1; plus N seed dots at random (uniform seed count? use hash-based: for a few random uv points via uniform array of 8 vec2? simpler: init places seeds using hash(floor(uvseedGrid))... random enough: for K seeds pass uSeedCount & uSeedTime rand — I'll do: init with edge frost only, then issue 6 seed stamps from JS via brush pass at random positions. Clean.

Reduce/coverage: 48×27 RT byte; shader: average m over block via 16 samples; every 600ms render + readPixels (1296 px) → coverage%.

FPS meter + auto quality.

UI layout: panel top-left; stats; sliders; preset chips; buttons; hints bottom; toast top-center. Title: FROSTLINE · 023.

Let me also ensure dampen on mobile: sim brush coords map: pane uv → sim uv (cover fit). Implement mapping helper.

Audio unlock on first gesture.

Now, write the file. I'll aim for clarity + compactness. Let me write it now in one big write, then node --check the module script.

Structure of the module script:

Composer with compositePass: I need GLSL for composite incl. frame, blur, sparkle, grain, CA, vignette.

Uniform sharing: pass objects with .value.

Frame render loop:

1. apply pending brush strokes (from,to per event captured) — render brush pass(es).
2. run growth sim steps × P.growth.
3. render outside scene to sceneRT.
4. composer.render() (composite reads sceneRT + sim front RT).
5. stats, quality, audio tinkle scheduling.

Let me carefully write GLSL.

SIM_UPDATE fragment (ping-pong):

Neighborhood loop: 8 taps:

I'll unroll manually.

Wind shift for diffusion sampling: sample vapor neighbors at uv + offset - uWinduTexel2.

Compute:

Frozen count from unshifted neighbor .a.

Wait — ice can exceed 1 with accumulation: ice += kappa*vap each step until attach; after attach ice=m+b up to ~1+ need... clamp to ≤1. For byte fallback clamp at 1 — fine.

Hmm: after attachment froz=1, bnd=0, ice≥need. Need threshold need=uBeta low when 1-2 neighbors (tip growth fast) etc. Standard GG: α for n=1,2 is β (default β=0.4?) Actually GG defaults: β=0.4... params: α=0.4? GG: attachment if boundary mass ≥ β(θ(n)) where θ(n): n=1→β, n=2→β, n=3→1... hmm GG uses: receptive site attaches if b >= γ_n where γ = β for n≤2... something like that. My scheme is fine artistically. Wait actually with need for 1-2 neighbors LOW → tips attach easily → dendrites. n≥3 need higher → side filling slower. But note: m+b≥need with ice+bnd accumulating — after attach of neighbors, b merges to ice, so mass accumulates monotonically; growth guaranteed. Good.

Supply: vap = min(vap+uSupply,1) each step everywhere non-frozen → far-field saturates to 1; front depletes. With uSupply ~ humidity*(0.01..0.05). At growth=6 steps/frame, front advances maybe 1px/2-3 steps → full coverage from edges in ~ (252px min dim /0.4px per step / 6 steps/frame) ≈ 105 frames ≈ 2s — too fast! Want ~30-90s to fill pane. So need slower: either fewer steps (growth default 2) or lower supply so growth is diffusion-limited and slower. Dendrite speed depends on supply & beta: tune uSupply small (0.004..0.02) and need thresholds ≥ ~0.5 so cells need many accumulation steps (each step adds (1-κ)vap ~ up to 10.94... hmm that's fast: receptive cell with vap=1 → bnd≈0.94 in ONE step ≥ need → attach instantly. That would make front advance 1px/step → way fast.

To slow: receptive freezing should convert only a FRACTION of vapor per step: GG freezing: b += (1-κ)*v? No—GG: receptive sites: a (quasi-liquid) gets (1-κ) of vapor... they convert ALL vapor but vapor itself is diffusion-limited (v near front is small because neighbors were depleted). The speed control is really supply rate vs consumption. If supply only +0.01/step, vap near front ≈ small (~0.05) → bnd grows ~0.05/step → need 0.5 → ~10 steps/px → at 4 steps/frame → 2.5 frames/px → 252px ≈ 630 frames ≈ 10s at 60fps. Still fastish; make growth default 2 steps/frame and supply default humidity 0.6 → supply=0.008 → slower, ~30-60s. And "First Frost" preset slower still. Users can crank growth slider. OK.

Also clamp vap supply to uRho (background level) instead of 1: vap=min(vap+uSupply, uRho) with uRho = 0.35+humidity*0.4. Then max attach mass per step ≈ uRho → pace set by uRho/need. Good.

Init: vap = uRho * (0.85 + 0.3*hash) noise; edges frozen; no seeds (JS stamps).

BRUSH shader: uniforms uFrom,uTo (uv), uRadius (uv units y-relative), uMode (0=wipe,1=seed), uRho:

OUTSIDE scene shader — write carefully (this is the aesthetic centerpiece along with frost). I'll write it as compact but rich GLSL with helpers: hash21, noise2 (value), fbm.

Given time, keep scene moderately detailed: sky+stars+moon+2 ridge lines+forest line+cottage+ground+snow 3 layers+parallax.

COMPOSITE shader: as planned.

Then UI wiring + audio + main loop.

Also loading: no heavy gen — instant. Show a brief toast.

Now write. I'll produce the full file (~850 lines). Let me be very careful with JS syntax since checking after. GLSL mistakes can't be compile-checked here... Actually I could compile-check GLSL via node with headless-gl? Not installed. I'll rely on care: remember ShaderMaterial GLSL1-style with three r160 WebGL2: use texture2D (defined to texture), gl_FragColor (defined). textureLod: available natively in 300 es — but wait, with #define texture2D texture, is textureLod callable? Yes, it's a core function name, no conflict. Good. BUT precision: fragment shaders get default precision highp float? three prepends precision. Fine.

One more check: UnrealBloomPass import path and OutputPass — standard.

Composer setup:

ShaderPass needs textureID default 'tDiffuse' — our shader just won't use it; include uniform tDiffuse anyway to avoid warnings (ShaderPass sets uniforms[textureID].value = readBuffer.texture only if present; if absent it throws? It checks if (this.uniforms[this.textureID]). Safe.)

renderer.setClearColor etc not needed much.

Sim RT creation helper makeRT(w,h,type,filter). Ping-pong variables simA/simB; swap after each pass. The "current" for display = simA (we render into B then swap; keep convention: read=simA.texture, write→simB, swap).

Brush passes also go through sim update pipeline (render brush into B reading A, swap).

Scene: render sceneQuad with sceneMaterial → renderer.setRenderTarget(sceneRT); render(sceneScene, cam); setRenderTarget(null). Mipmaps auto.

Composite uniforms: tScene, tFrost, uTime, uMoonDir(vec2 screen), uRes, uFrostAspect mapping (cover): compute in shader with uSimAspect & uScreenAspect.

Sparkle twinkle: hash based on sim-space cell + time quantize.

Coverage reduce: skip readPixels if float... use byte RT.

Audio engine — compact:

Auto quality: ema frame dt; every 120 frames: if ema>19ms → lower scale step; if <12 → raise. Scales: [1, .8, .66, .5] × min(dpr,2). Applies to renderer.setPixelRatio? For composer: composer.setPixelRatio + setSize. I'll implement setQuality(q) adjusting renderer pixel ratio & composer size & bloom resolution.

Snapshot:

toBlob right after render in same tick — works without preserveDrawingBuffer.

Keyboard: as listed.

Right, time to write. Also update /space/demos/index.html after (add 023 card at top).

Also hint bar content: "Drag wipe · Click seed · 1–3 presets · G growth · C clear · S seeds · P snapshot · M sound · H hide".

Let me now write the file. I'll write it as one large heredoc via write tool (mode write, full content). Estimate ~40KB — acceptable.

Careful details:

• vUv varying in all quad shaders; shared vertex shader string.
• moon screen pos used by both scene & composite (for frost sheen direction): moonPos=(0.72,0.76) in scene uv space; sheen light dir in composite = normalize(moonScreen - uv) roughly; simpler: fixed light dir from top-right: L = normalize(vec2(0.5,0.8)); fine.
• Frame: border fraction bx=0.018 (x), by=0.03? frame width uniform uFrame=0.025 (in min-dim units). frame mask: m = smoothstep on (min(uv.x,1-uv.x,uv.y,1-uv.y)*aspectMin). Draw frame color + inner bevel highlight line + slight outer darkness. Also frost grows from actual texture edges which coincide with frame inner edge ≈ glass edge — visually frost creeps from frame.

Glass subtle reflection streak: add faint diagonal sheen bands on clear glass: sheen = 0.02*sin diagonal. Nice.

Also "wet wipe" streak: skip.

Snow wind: flakes drift x with wind + time.

Parallax: uParallax = pointer offset (lerped) * layerDepth in scene shader: implement by offsetting uv per-layer amounts: define p = uPar* ... each feature layer uses uv + uPar*depth_k (mountains 0.3, forest 0.5, cottage 0.6, ground 0.8, snow near 1.2). Simply: compute base uv once, then feature functions take shifted coords. I'll implement layers as functions of (uv, shift).

Let me write scene shader concretely:

Sky:

Star via point:

Moon:

Do HDR: moon disc *2.5, windows *2 → bloom.

Mountains:

Second closer ridge y2 lower, darker.

Forest (conifer):

Simpler convincing: forest mask = uv.y < (0.225 + 0.075fbm(vec2(x26., s)) + 0.02tri(x90.)) → jagged spiky skyline. Two layers parallax.

Cottage: rectangles via smoothstep box fn:

body center (0.30,0.185) size (.045,.028); roof: triangle via box rotated? Use: roof mask where uv.y between .213 and .245 and |x-.30| < (.245-uv.y)1.1+.01 → snow roof col #cdd8ea; body #1a1410; windows: two small boxes glowing #ffb45c2.2 flicker = .85+.15noise(t3+i); door thin #2a1c10 with warm slit; chimney box at (0.338,.24) size(.008,.02) col #14100c; smoke: for k: plume = fbm(uv8 + vec2(0,-t.15)) * smoothstep above chimney → add grey .04. Position cottage around x .30 which with aspect... uv.x in 0..1 width; aspect handled by using uv directly (shapes will stretch with aspect; use aspect-corrected coords for cottage: px = (uv-.5)*vec2(uAspect,1)+.5? Keep simple: define cx=0.32 const; widths in x-units — on wide screens looks wider — fine/painterly.

Ground: uv.y<y_ground(≈.16 + small fbm): snow = mix(vec3(.36,.44,.60), vec3(.10,.14,.24), uv.y/.16) → darker bottom; sparkle glints: h=hash(floor(uvvec2(300,80))); glint = step(.9992,h)twinkle → add. Moon path highlight: brighter near moon x: add .06exp(-(uv.x-mp.x)^28)*...

Snowfall layers: for L in 0..2: scale s=[140,90,50], speed, size:

Near layer bigger flakes: use smaller scale s → bigger cells → bigger flakes: size relative to cell: radius .1 cell → px = cell_px*.1. Fine.

Good enough. Composite frost visual:

Wait — ice after attach ~1 within frozen region → f≈1 fully white behind? Frost should be translucent textured, denser at cores. Map: density = clamp(ice,0,1)0.9+bnd0.5; then frostAlpha = smoothstep(.05,.9,density). Blur amount = pow(frostAlpha,.7). White scatter = frostAlpha*.5 modulated by sparkle normal & ice pattern. Also frost internal structure: use gradient → ridges.

Blur LOD: blurred = textureLod(tScene, vUv, 4.0*blurAmt) — textureLod on tScene (has mips). Note: with ShaderMaterial GLSL1 auto-300es, textureLod OK.

Sheen: grad of density via 2 extra taps (dx,dy): N = normalize(vec3(-gx,-gy,.35)); L = normalize(vec3(.5,.7,.6)); spec = pow(max(dot(N,L),0.),24.)*frostAlpha → add cool white.

Sparkle: cell = floor(suvvec2(simW,simH)/3.) hmm sparkle per ~3px: h=hash21(cell + floor(uTime2.)0.0 ) twinkle: h2=hash21(cell+ floor(uTime3.)*17.) → glint = step(.995,h2)*frostAlpha → add vec3(1.)glint1.5.

Also frost slight blue tint absorption: col = mix(col, colvec3(.85,.9,1.05), f.4).

Frame:

Also outer black border beyond? Frame IS the border. Plus subtle glass edge darkening just inside glass: ao = smoothstep(frameW+.02, frameW, fr).15 (but inside frame region only near edge)... fine: col = 1. - .18smoothstep(frameW+.05,frameW,fr)(1-frameMask).

Vignette: col = 1-.35pow(length(vUv-.5)1.3,2.2) clamp. Grain: col += (hash(vUvres+time)-.5).03. Chromatic aberration: at glass only: sample tScene R/B with radial offset f small: ca = .0015f; r=textureLod(tScene, vUv+dirca, lod).r etc. Implement in blur sample: do three taps when needed... cost fine: sample blurred 3× (r,g,b offsets) always — simpler code:

OK.

HDR: scene outputs HDR (moon 2.5). Composite outputs HDR pre-bloom; bloom threshold .8 catches moon, windows, sparkle glints (add *1.6).

Now — sim byte fallback: with UnsignedByteType, LinearFilter ok, values 0..1; diffusion fine. melt etc fine. Half float preferred. Also renderer.capabilities.isWebGL2 — three r160+ is WebGL2-only (r163 dropped WebGL1). With unpkg three@0.160.0: WebGL2 required, EXT_color_buffer_float widely supported. Set type by extension check.

Import map: use same as cloudsea: check its importmap quickly for consistency (three@0.16x from unpkg). Let me check lines 96-103 of cloudsea.

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

50% of time used already — I need to write fast. Let me write the complete file in one big write operation now, then quick-check syntax, then update the index page and finish.

I'll write the whole thing now. Being careful with GLSL and JS. Keep it tight but complete.

File written. Now quick syntax check of the JS module: extract script and run node --check with module type. Also GLSL can't be checked easily, but let me at least eyeball a couple of risk points:

1. In simInit shader I declared float edge = ... unused — GLSL compilers warn but fine. Actually edge uses uTexel weirdly; it's unused — remove not needed; unused vars are OK.

2. THREE.MathUtils.smoothstep(P.temp, -1.5, 2.0) — signature is smoothstep(x, min, max). Correct.

3. ShaderPass: our CompositeShader lacks name — fine.

4. In composite shader I use textureLod — with WebGL2 + GLSL1-style ShaderMaterial, three prepends #version 300 es and #define texture2D texture. textureLod is native in 300 es. Good. But careful: in the composite, tScene has mipmaps and min filter LinearMipmapLinear — good.

5. UnrealBloomPass resolution Vector2(256,256) — internally creates its own RTs at half of setSize... it handles sizes via setSize. OK.

6. renderer.readRenderTargetPixels on UnsignedByteType covRT — fine.

7. In simInit I used variable name edge and unused hash21 included — fine.

8. Issue: ${HASH_GLSL} inside template literals in JS — I embedded ${HASH_GLSL} within the GLSL template strings — those are JS template literals so interpolation works. In outside shader and composite shader — yes they're template literals (backticks). Good.

9. Composite: coverUv uses uScrA/uSimA — matches toSimUv JS mapping. In toSimUv: rs = scrA/simA; sx = rs>1 ? 1/rs : 1; sy = rs>1 ? 1 : rs. In GLSL coverUv: s = rs>1 ? vec2(1/rs,1) : vec2(1,rs). Same. Good.

10. Danger: simBrush radius 0.035 in "aspect-corrected" y-units: p = vec2(vUv.x*uAspect, vUv.y) where uAspect = SIM_W/SIM_H ≈ 1.78. Radius compare in that space: y in 0..1, x in 0..1.78 → radius 0.035 = 3.5% of height. Good.

11. Growth uniform binding each frame before loop: uState set inside loop. Good.

12. renderer.setPixelRatio(1) then setSize with dpr-scaled pixels and style set to CSS size — correct pattern; composer.setSize in device px: composer uses renderer pixel ratio internally? EffectComposer.setSize sets its RTs to sizepixelRatio? EffectComposer has setPixelRatio and setSize; default _pixelRatio = renderer.getPixelRatio() at construction (1 here). We call composer.setSize(wdpr, hdpr) — with pixelRatio 1, buffers = wdpr. Consistent. Good.

13. sceneRT.setSize then generateMipmaps — after each render three updates mipmaps since minFilter needs them and generateMipmaps=true. Good.

14. snapshot(): calls renderFrame directly then toBlob — composite composer.render draws to canvas; toBlob same tick → OK.

15. pointer.par eased; ou.uPar value: parallax in uv units — multipliers small; fine.

16. Keyboard 'g' not bound though hints mention G growth? My hints: "1–3 presets · S seeds · C clear · P snapshot · M sound · H hide" — no G. OK consistent.

17. audio.tinkle(true) called on scatter before ctx exists? scatterSeeds via keyboard 's' without audio.ensure → tinkle checks if (!this.ctx...) return; OK.

18. In simStep: frz(uv-o) etc — using texture2D on HalfFloat with LinearFilter — fine.

19. Potential GLSL issue: in simInit fragment I declared uniform vec2 uTexel; uniform float uRho; and use both — ok. float edge = ... unused var: allowed.

20. outside shader: vec3 cCol = col; unused — fine.

21. In composite, uniform sampler2D tScene, tFrost; plus tDiffuse declared in uniforms JS but not in GLSL — ShaderPass will try to set uniforms['tDiffuse'].value — exists in JS object (value null) — setting .value = readBuffer.texture is fine even if shader doesn't declare it (uniform location lookup just misses; three handles missing uniforms silently).

Wait — ShaderPass constructor: this.uniforms = UniformsUtils.clone(shader.uniforms) — cloning uniform with texture values null OK.

One issue: compositePass.uniforms — after ShaderPass, compositePass.uniforms exists. I set cu.tScene.value etc. Good.

22. EffectComposer requires first pass to clear: ShaderPass is not clear by default but writes full quad opaque — fine.

23. PlaneGeometry(2,2) has uv attribute — VERT uses uv and position — ShaderMaterial provides attributes automatically. Good.

24. UnrealBloomPass with HDR half-float composer buffers: EffectComposer r170 default renderTarget type is HalfFloatType (since r152?). Yes, composer defaults to HalfFloatType. Good.

25. Audio: bindSlider(... 'sWind'...) calls audio.setWind via onChange — fine.

26. At boot, derive() already called; simInit uses D.rho at resetPane(true) — called after everything defined. resetPane references simInit, brushStroke → defined. Called at bottom. Good.

27. applyPreset(2) default chip active matches initial sliders? Initial: temp -10, hum .6, growth 3, wind .25 — chip 2 marked active but values differ from preset 2 (-22,.85,4,.35). Slight mismatch; acceptable, or call applyPreset(2) at boot instead of defaults. Let me just call applyPreset(2) at start for consistency. I'll patch: after resetPane(true), call applyPreset(2)? That shows a toast 'deep freeze' at boot then another toast at 600ms — fine, reorder: applyPreset(2) first, then resetPane... resetPane uses D.rho — derive inside applyPreset. Order: applyPreset(2); resetPane(true); setTimeout toast. Let me patch quickly.

Also potential bug: In updateCoverage, renderer.setRenderTarget(null) after runPass — runPass sets target itself; readRenderTargetPixels(covRT...) binds covRT internally. OK.

Another: in tick, $('stFps').textContent updates every frame — fine.

Node syntax check: extract the module script content and node --check with .mjs extension. Do it.

Everything checks out:

• JS syntax OK.
• Index now has 23 demo cards, including 023-frostline at the top (and 022-cloudsea was added earlier).

I also want to double-check one GLSL risk: in the composite shader, textureLod on tScene — sceneRT minFilter LinearMipmapLinear with generateMipmaps true. When sceneRT.setSize is called, mipmaps regenerated on next render. Good.

One more potential issue: simInit shader uses float edge = min(min(vUv.x, 1.0-vUv.x)*uTexel.y/uTexel.x, ...) — unused but references uTexel — fine, no error.

In simStep: variables declared uniform float uKappa, uBeta, uSupply, uRho, uMelt; — multiple uniforms in one declaration statement is valid GLSL.

In composite: uniform float uTime, uScrA, uSimA; valid.

In outside: uniform float uTime; uniform vec2 uPar; uniform float uAspect, uWind; valid.

GLSL for (int L=0; L<2; L++) with float conversion — fine.

step(0.991, h) etc fine.

One concern: composite shader coverUv divides by uSimA... fine.

bloomPass — UnrealBloomPass with composer — standard.

Everything is done: 022 index update (pending from last run) + new 023 demo + index update. Time is nearly up (80%+). Finish with _success.