mapspinner 0.1.33 → 0.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapspinner",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "WebGL2 Earth-scale terrain rendering SDK for interactive globe applications",
   "main": "src/index.js",
   "exports": {

package/planet.html

@@ -102,11 +102,11 @@ function jsSnoise3(px,py,pz){
 }
 function jsBroadShape(dx,dy,dz){
   const r=Math.hypot(dx,dy,dz)||1; dx/=r; dy/=r; dz/=r;
-  let amp=6500.0, freq=3.0, sum=0.0;   // A0=6500, off=-900: matches GLSL broadShapeM (one-fractal collapse)
+  let amp=6500.0, freq=0.75, sum=0.0;   // A0=6500, off=-500: matches GLSL broadShapeM (one-fractal collapse)
   // hi-freq elevation noise 4x cut (user 2026-06-06): the GPU broadShapeM scales the o>=6 fine band by
   // uHiFreqCut (0.25); mirror it here so the collision FALLBACK height tracks the rendered surface.
-  for(let o=0;o<14;o++){ let nn=jsSnoise3(dx*freq,dy*freq,dz*freq); if(o>=6) nn*=0.25; sum+=amp*nn; amp*=(o<6?0.6:0.82); freq*=2.0; }
-  return sum-900.0;   // metres, neutral relief (reliefMul=1, ridgeMul=0)
+  for(let o=0;o<14;o++){ let nn=jsSnoise3(dx*freq,dy*freq,dz*freq); if(o>=6) nn*=0.25; sum+=amp*nn; amp*=(o<6?0.66:0.80); freq*=2.0; }
+  return sum-500.0;   // metres, neutral relief (reliefMul=1, ridgeMul=0)
 }
 
 // ---- Vector helpers (used by the free-fly camera + WebGL2 sun/orientation math).
@@ -372,8 +372,18 @@ function frameLoop(){
       // The orchestrator works in METERS (its producer generates meter-scale elevation).
       // We drive it in meter-space and scale the km-unit camera into meters via
       // WEBGL2_M_PER_UNIT below.
+      // SPLITFACTOR PIN (user 2026-06-14): set 0.28 BEFORE orch init so the FIRST quadtree build uses
+      // it -- otherwise window.__splitFactor is undefined for the first frames and the orchestrator's
+      // altitude ramp (planet-orchestrator.js:445, taken when __splitFactor==null) overrides any opts
+      // default. gen-controls re-affirms the same 0.28 on apply(). 0.28 lands ~500-600 quads at the
+      // deck; splitDist floors at 1.1 so this is near the coarse limit.
+      if (window.__splitFactor == null) window.__splitFactor = 0.28;
       import('./src/planet-orchestrator.js')
-        .then(m => m.initMapspinnerPlanet(glw, { radius: WEBGL2_TERRAIN_R_M, frustumCull: false }))
+        .then(m => m.initMapspinnerPlanet(glw, { radius: WEBGL2_TERRAIN_R_M, frustumCull: false,
+          // FPS lever (2026-06-14): mesh GRID is overridable via ?grid=N for live triangle-count
+          // A/B (the bottleneck is triangle/vertex throughput, not the broadShapeM ALU -- octMax
+          // 12->3 left frame time flat). Absent param falls through to gl-render's 16 default.
+          gridMeshSize: ((new URLSearchParams(location.search).get('grid')|0) || undefined) }))
         .then(orch => { window.__planetOrch = orch; window.__planetOrchGL = glw; window.__planetOrchStatus='ready';
           import('./src/terrain-gen-controls.js').then(()=>{ try{ window.__gen && window.__gen.apply(); }catch(_){} }).catch(e=>console.warn('gen-controls',e)); })
         .catch(e => { window.__planetOrchStatus='error:'+(e.message||e); console.error('orch init',e); });
@@ -522,7 +532,7 @@ function frameLoop(){
   // a height above an inflated reference -> the eye was really ground+margin+2m, not 2m.) The mirror
   // fallback keeps a small +3m only because the CPU jsBroadShape can under-predict vs the GPU.
   if (gpuM != null && isFinite(gpuM)) {
-    renderedM = gpuM;   // GPU-exact rendered height (may be negative = seabed)
+    renderedM = gpuM + 1.0;   // +1m margin for sub-vertex micro-relief (vtxDisplace peaks exceed 2m in rugged terrain)
   } else {
     renderedM = jsBroadShape(cam.pos[0], cam.pos[1], cam.pos[2]) + 3.0;  // mirror fallback (CPU under-predicts)
   }
@@ -569,7 +579,7 @@ function frameLoop(){
     // at 2 by a diagnostic turned a dropdown pick of 1 into 2|1=3 (invalid mode -> silent lit) = the
     // 'render menu does nothing' report. Explicit precedence: override wins when set, else the menu.
     const _dmEff = (window.__displayMode != null ? window.__displayMode : cam.displayMode) | 0;
-    const fr = window.__planetOrch.frame(eyeM, tgtM, 45*Math.PI/180, _dmEff, _sun, oceanTime, cam.up);
+    const fr = window.__planetOrch.frame(eyeM, tgtM, 45*Math.PI/180, _dmEff, _sun, oceanTime, cam.up, surfElev);
     window.__webglFrame = fr;
     // First rendered frame: tear down the loading overlay (compile finished, terrain is on screen).
     if (window.__loadOverlay !== false) { const ov=document.getElementById('__loadOverlay');

package/server.js

@@ -1,6 +1,8 @@
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const PORT = process.env.PORT ? parseInt(process.env.PORT) : 8080;
 // Static file server for the GPU one-fractal planet (planet.html + src/*.js + shaders/*.glsl).

package/src/gl-render.js

@@ -49,7 +49,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
   // (-52%) and tris/quad 1152->512 (-55%), so the per-vertex 14-oct broadShapeM VS (browser-9: 95% of
   // the low-alt frame) runs on ~half the vertices. median scales ~24/16 -> ~3.6px, far closer to the
   // band; the fine relief is carried per-pixel by the FS dFdx normal, not the mesh tessellation.
-  const GRID = opts.gridMeshSize || 16;    // mesh quads per edge
+  const GRID = opts.gridMeshSize || 11;    // mesh quads per edge. 16->11 (user 2026-06-14): FPS is TRIANGLE-THROUGHPUT bound, not broadShapeM ALU (octMax 12->3 left frame time flat; GRID is ~linear). GRID 8 was faster (-50%) but made BIOME CROSSOVER LINES JAGGED (climate varying interpolated across coarse triangles steps along edges) -- reverted to 11 (-37%). Proper fix to reclaim GRID 8 = per-pixel biome sampling in the FS. Override via ?grid=N.
   // Expose the LIVE mesh grid so screen-space-error diagnostics (planet.html __diag.pxPerPoly)
   // divide by the real polys/tile instead of a stale literal. Any future GRID change self-corrects
   // the metric (the 24->16 lever left pxPerPoly defaulting to 24 = 1.5x wrong band fraction).
@@ -286,6 +286,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     gl.uniform1f(loc('uDetailOverlay'), g('detailOverlay', 6.0));  // perlin-everywhere ELEVATION term in composeHeight -- probe must match the VS or collision diverges
     gl.uniform1f(loc('vtxDetail'),      g('vtxDetail', 1.0));    // DECISIVE: vtxDisplace strength (early-return on 0)
     gl.uniform1f(loc('canyonDepthMul'), g('canyonDepth', 1.0));
+    gl.uniform1f(loc('uBeachShelfM'),   g('beachShelf', 2400.0));   // land coastal shelf (geometry); probe MUST match render
     gl.uniform1f(loc('cliffAmt'),       g('cliffAmt', 1.0));
     gl.uniform1i(loc('uFloatLinearOK'), _halfFloatLinearOK ? 1 : 0);
     // FXC unroll-defeat (2026-06-12 AMD d3d11 fix): runtime octave bound for broadShapeM; the shader
@@ -300,7 +301,8 @@ export async function initMapspinnerRender(gl, opts = {}) {
     gl.uniform1i(loc('uFSDetailOcts'),    (typeof window!=='undefined' && window.__fsDetailOcts!=null) ? (window.__fsDetailOcts|0) : 3);
     // FXC fold-defeat (2026-06-12, the rock-on-flat patches): the lit-normal FD step is uniform-fed
     // so d3d11/FXC cannot constant-fold the 150/R offset. Live dial: window.__nrmStepM.
-    gl.uniform1f(loc('uNrmStepM'),      g('nrmStepM', 150.0));
+    gl.uniform1f(loc('uNrmStepM'),      g('nrmStepM', 300.0));
+    gl.uniform1f(loc('uGrid'),          GRID);
     gl.uniform1f(loc('uHpfInset'),      (typeof window!=='undefined' && window.__hpfInset === false) ? 0.0 : 1.0);   // SEAM FIX: inset sampler is the permanent default (matches bakeFace fu=x/(RES-1)); window.__hpfInset===false rolls back
     // ANCHOR-STEP A/B TOGGLES (per-area stairstep, wrxo0rr7a). Default 0 = current; set window.__<name>=1
     // to widen that anchor-keyed band. Set HERE so BOTH render and the _PROBE_ collision see them (parity).
@@ -474,6 +476,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     uniform vec3 skyCamWorld;   // camera world pos (meters)
     uniform vec3 skySunDir;     // world sun dir (normalized)
     uniform float skyR;         // sphere radius (meters)
+    uniform float uSkyFade;     // 1 at surface, 0 at 100km
     void main(){
       // Reconstruct the world-space view ray from NDC, like the WebGPU skyFs: undo the
       // projection (divide by the proj diagonal) to get a view-space dir, then rotate
@@ -519,7 +522,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
       // glow + daylit sky read as an atmosphere without blowing out.
       vec3 c = radiance * 120.0;
       vec3 mapped = clamp((c*(2.51*c+0.03))/(c*(2.43*c+0.59)+0.14), 0.0, 1.0); // ACES
-      fragColor = vec4(pow(mapped, vec3(1.0/2.2)), 1.0);
+      fragColor = vec4(pow(mapped, vec3(1.0/2.2)) * uSkyFade, 1.0);
     }`;
   function rawShader(type, source){ const s=gl.createShader(type); gl.shaderSource(s, source); gl.compileShader(s);
     if(!gl.getShaderParameter(s,gl.COMPILE_STATUS)) throw new Error('sky '+type+': '+gl.getShaderInfoLog(s)); return s; }
@@ -566,6 +569,13 @@ export async function initMapspinnerRender(gl, opts = {}) {
   const vbo=gl.createBuffer(); gl.bindBuffer(gl.ARRAY_BUFFER,vbo); gl.bufferData(gl.ARRAY_BUFFER,verts,gl.STATIC_DRAW);
   const ibo=gl.createBuffer(); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER,ibo); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER,indices,gl.STATIC_DRAW);
   const instBuf=gl.createBuffer();   // per-instance [ox,oy,l,level,face] (filled per frame in render())
+  // DATA-CONTINUITY CACHE (2026-06-14): terrain + water get their OWN persistent instance buffers so
+  // neither clobbers the other (the shared-buffer clobber forced a re-upload every frame and was the
+  // root of the prior 'water drawn as terrain' regression). On a STATIC frame (same quads array object)
+  // the instance data is identical -> skip the Float32Array build + bufferData + water dedup Set-loop
+  // and just rebind+draw. Pure CPU/GC win (GPU is vertex-bound, the upload is off the critical path).
+  const instBufWater=gl.createBuffer();
+  let _instQuadsRef=null, _instWaterRef=null, _instWaterN=0;
 
   // per-face local->world (cube face -> sphere local frame). Column-major mat3 packed
   // into a Float32Array(9). Matches localToWorld3 convention:
@@ -630,9 +640,17 @@ export async function initMapspinnerRender(gl, opts = {}) {
     const aspect = gl.drawingBufferWidth / gl.drawingBufferHeight;
     const camDist = Math.hypot(cam.eye[0], cam.eye[1], cam.eye[2]);
     const alt = Math.max(0.0, camDist - R);
+    const altAboveTerrain = Math.max(0.001, alt - R * (cam.surfElev || 0));
     const horizon = Math.sqrt(Math.max(0.0, camDist*camDist - R*R));
-    const near = Math.max(1.0, alt * 0.1);
-    const far  = Math.max(horizon * 1.5, alt * 8.0) + R * 0.25;
+    // MATCH render()'s near exactly (2026-06-14 jank fix): the cull frustum must use the SAME near
+    // as the draw frustum, else behind-limb/screen-AABB culling diverges from what is actually drawn
+    // at the deck (cull near was max(*0.1,0.1) while render used the <2m 0.05 branch).
+    const near = altAboveTerrain < 2.0 ? 0.05 : Math.max(altAboveTerrain * 0.1, 0.05);
+    // FAR PLANE: horizon distance tracks the visible ground edge; blends toward camDist
+    // above 500km for orbital views so the full planet is visible.
+    const _fBlend = Math.min(1.0, Math.max(0.0, (alt - 500000.0) / 4500000.0));
+    const farGround = Math.max(horizon, alt * 8.0);
+    const far = farGround * (1.0 - _fBlend) + camDist * _fBlend;
     const proj = M4.perspective(cam.fovy||0.785, aspect, near, far);
     const eye = cam.eye;
     const viewRel = M4.lookAt([0,0,0], [cam.center[0]-eye[0], cam.center[1]-eye[1], cam.center[2]-eye[2]], cam.up||[0,1,0]);
@@ -643,7 +661,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // fp32 cancellation at ground level (eye~=world), garbaging the projection and blanking the
     // footprint. Subtracting in JS doubles first keeps the cull's projection precise near ground.
     const viewProjNoEye = M4.mul(proj, viewRel);
-    return { viewProjRel, viewProjNoEye, eye, near, far, proj };
+    return { viewProjRel, viewProjNoEye, eye, near, far, proj, viewRel };
   }
 
   // Render a set of quads. quads: [{quad, face, elevLayer, normalLayer}], cam: {eye, center, up, fovy}
@@ -652,16 +670,18 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // ADAPTIVE near/far (altitude-tied). A fixed near=1 / far=R*8 (~5e7) at a 50km eye
     // pushed ALL near-surface geometry to NDC z~=1 (the far-plane limit), collapsing depth
     // precision so most near quads z-fought / clamped off -> only one screen rectangle
-    // survived. Tie the planes to altitude: near ~= alt*0.1 (a few km up high, meters near
-    // the ground), far ~= the visible horizon distance (so the whole near surface fits the
-    // [near,far] range with usable z precision) plus a margin to keep the far hemisphere /
-    // limb. From space (alt >> R) this widens back out to ~R*8, preserving the full-globe
+    // survived. Tie the planes to altitude: near = alt*0.1 (naturally scales from 1m at
+    // deck to 1200km at orbit), far = horizon distance blended toward camDist above 500km
+    // for orbital views. From space the far widens out to ~R*8, preserving the full-globe
     // view. Clamped so near>=1 and far>near.
     const camDist = Math.hypot(cam.eye[0], cam.eye[1], cam.eye[2]);
     const alt = Math.max(0.0, camDist - R);
+    const altAboveTerrain = Math.max(0.001, alt - R * (cam.surfElev || 0));
     const horizon = Math.sqrt(Math.max(0.0, camDist*camDist - R*R));
-    const near = Math.max(1.0, alt * 0.1);
-    const far  = Math.max(horizon * 1.5, alt * 8.0) + R * 0.25;
+    const near = altAboveTerrain < 2.0 ? 0.05 : Math.max(altAboveTerrain * 0.1, 0.05);
+    const _fBlend = Math.min(1.0, Math.max(0.0, (alt - 500000.0) / 4500000.0));
+    const farGround = Math.max(horizon, alt * 8.0);
+    const far = farGround * (1.0 - _fBlend) + camDist * _fBlend;
     const proj = M4.perspective(cam.fovy||0.785, aspect, near, far);
     const view = M4.lookAt(cam.eye, cam.center, cam.up||[0,1,0]);
     const viewProj = M4.mul(proj, view);
@@ -696,8 +716,28 @@ export async function initMapspinnerRender(gl, opts = {}) {
     gl.viewport(0,0,gl.drawingBufferWidth,gl.drawingBufferHeight);
     gl.clearColor(0.0,0.0,0.0,1); gl.clear(gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT);
 
-    // SKY/ATMOSPHERE PASS REMOVED (user: 'get rid of all non-terrain material for now like haze').
-    // The background stays the plain clear color; only the terrain (lit by the sun) is drawn.
+    // SKY/ATMOSPHERE PASS: atmospheric limb/halo behind the terrain. Fades in below
+    // 100km (full at surface, transparent above 100km). Depth off so terrain overdraws.
+    {
+      const skyFade = Math.max(0.0, 1.0 - camAlt / 100000.0);
+      if (skyFade > 0.001) {
+        gl.useProgram(skyProg);
+        gl.uniformMatrix3fv(SU('camRot'), false, new Float32Array([
+          _cm.viewRel[0], _cm.viewRel[4], _cm.viewRel[8],
+          _cm.viewRel[1], _cm.viewRel[5], _cm.viewRel[9],
+          _cm.viewRel[2], _cm.viewRel[6], _cm.viewRel[10]
+        ]));
+        gl.uniform2f(SU('projDiag'), _cm.proj[0], _cm.proj[5]);
+        gl.uniform3f(SU('skyCamWorld'), eye[0], eye[1], eye[2]);
+        gl.uniform3f(SU('skySunDir'), sunDir[0], sunDir[1], sunDir[2]);
+        gl.uniform1f(SU('skyR'), R);
+        gl.uniform1f(SU('uSkyFade'), skyFade);
+        gl.disable(gl.DEPTH_TEST);
+        gl.bindVertexArray(skyVao);
+        gl.drawArrays(gl.TRIANGLES, 0, 3);
+        gl.enable(gl.DEPTH_TEST);
+      }
+    }
 
     gl.enable(gl.DEPTH_TEST);
     // Back-face culling: the globe's FAR (back) hemisphere quads were drawing over the
@@ -766,6 +806,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // literals so the look is unchanged until the user dials a window global.
     const _g = (n,d)=> (typeof window!=='undefined' && window['__'+n]!=null) ? +window['__'+n] : d;
     gl.uniform1f(U('canyonDepthMul'), _g('canyonDepth', 1.0));
+    gl.uniform1f(U('uBeachShelfM'),   _g('beachShelf', 2400.0));   // land coastal shelf (geometry): h<S eased h*h/S = wide beach
     gl.uniform1f(U('uHiFreqCut'),     _g('hiFreqCut', 0.25));   // 0.5->0.25 (2026-06-10 'blotchy' -- see setComposeHeightUniforms)
     gl.uniform1f(U('uVertexAO'),      _g('vertexAO', 1.0));    // per-vertex shading/AO strength (DEFECT 2, 2026-06-06)
     gl.uniform1f(U('cliffAmt'),       _g('cliffAmt', 1.0));
@@ -844,7 +885,7 @@ export async function initMapspinnerRender(gl, opts = {}) {
     gl.uniform1f(U('oceanAmp'), (oc.oceanAmplitude != null) ? oc.oceanAmplitude : 1.0);
     gl.uniform1f(U('oceanChoppy'), (oc.oceanChoppiness != null) ? oc.oceanChoppiness : 0.5);
     gl.uniform1f(U('oceanFoam'), (oc.oceanFoam != null) ? oc.oceanFoam : 0.5);
-    gl.uniform1f(U('uBeachTopM'), _g('beachTop', 30.0));   // beach ceiling: grass stops, sand to the waterline + under it
+    gl.uniform1f(U('uBeachTopM'), _g('beachTop', 140.0));   // beach ceiling: grass stops, sand to the waterline + under it. 30->90 (user 2026-06-14: 3x beach width)
 
     // SINGLE INSTANCED DRAW: the deform params that were per-quad uniforms (ox,oy,l,level + face)
     // are now PER-INSTANCE attributes. Build one interleaved instance buffer [ox,oy,l,level,face]
@@ -858,14 +899,19 @@ export async function initMapspinnerRender(gl, opts = {}) {
     // h = composeHeight(dir) for each vertex.
     const FLOATS = 5;   // [ox,oy,l,level,face]
     if (n > 0) {
-      const inst = new Float32Array(n * FLOATS);
-      for (let i = 0; i < n; i++) {
-        const q = quads[i].quad;
-        inst[i*FLOATS+0] = q.ox; inst[i*FLOATS+1] = q.oy; inst[i*FLOATS+2] = q.l; inst[i*FLOATS+3] = q.level;
-        inst[i*FLOATS+4] = quads[i].face;
-      }
+      // STATIC-FRAME SKIP: only rebuild + re-upload the instance data when the quad SET changed (the
+      // orchestrator passes the SAME quads array object on a static camera, a fresh array on rebuild).
+      const _dirty = (quads !== _instQuadsRef);
       gl.bindBuffer(gl.ARRAY_BUFFER, instBuf);
-      gl.bufferData(gl.ARRAY_BUFFER, inst, gl.DYNAMIC_DRAW);
+      if (_dirty) {
+        const inst = new Float32Array(n * FLOATS);
+        for (let i = 0; i < n; i++) {
+          const q = quads[i].quad;
+          inst[i*FLOATS+0] = q.ox; inst[i*FLOATS+1] = q.oy; inst[i*FLOATS+2] = q.l; inst[i*FLOATS+3] = q.level;
+          inst[i*FLOATS+4] = quads[i].face;
+        }
+        gl.bufferData(gl.ARRAY_BUFFER, inst, gl.DYNAMIC_DRAW);
+      }
       const STRIDE = FLOATS * 4;
       gl.enableVertexAttribArray(1); gl.vertexAttribPointer(1, 4, gl.FLOAT, false, STRIDE, 0);          gl.vertexAttribDivisor(1, 1);  // iOffset
       gl.enableVertexAttribArray(2); gl.vertexAttribPointer(2, 1, gl.FLOAT, false, STRIDE, 4 * 4);      gl.vertexAttribDivisor(2, 1);  // iFace
@@ -892,17 +938,24 @@ export async function initMapspinnerRender(gl, opts = {}) {
         // (~1.6km) sag ~5cm, far under any visible bathymetry, still ~16-64x fewer water verts
         // than the deep terrain leaves.
         const WCAP = 9;
-        const seen = new Set(); const wl = [];
-        for (let i = 0; i < n; i++) {
-          const q = quads[i].quad; let ox = q.ox, oy = q.oy, l = q.l, lv = q.level;
-          if (lv > WCAP) { const A = l * Math.pow(2, lv - WCAP); ox = Math.floor(ox / A) * A; oy = Math.floor(oy / A) * A; l = A; lv = WCAP; }
-          const key = quads[i].face + ':' + ox + ':' + oy + ':' + l;
-          if (seen.has(key)) continue; seen.add(key);
-          wl.push(ox, oy, l, lv, quads[i].face);
+        // OWN persistent buffer (instBufWater) + static-frame skip: on an unchanged quad set, reuse the
+        // cached water instances (skip the dedup Set-loop + Float32Array + bufferData). Separate buffer
+        // means the terrain pass never clobbers it (the prior water-as-terrain regression root).
+        gl.bindBuffer(gl.ARRAY_BUFFER, instBufWater);
+        if (_dirty || quads !== _instWaterRef) {
+          const seen = new Set(); const wl = [];
+          for (let i = 0; i < n; i++) {
+            const q = quads[i].quad; let ox = q.ox, oy = q.oy, l = q.l, lv = q.level;
+            if (lv > WCAP) { const A = l * Math.pow(2, lv - WCAP); ox = Math.floor(ox / A) * A; oy = Math.floor(oy / A) * A; l = A; lv = WCAP; }
+            const key = quads[i].face + ':' + ox + ':' + oy + ':' + l;
+            if (seen.has(key)) continue; seen.add(key);
+            wl.push(ox, oy, l, lv, quads[i].face);
+          }
+          _instWaterN = wl.length / FLOATS;
+          gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(wl), gl.DYNAMIC_DRAW);
+          _instWaterRef = quads;
         }
-        const wn = wl.length / FLOATS;
-        gl.bindBuffer(gl.ARRAY_BUFFER, instBuf);
-        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(wl), gl.DYNAMIC_DRAW);
+        const wn = _instWaterN;
         gl.enableVertexAttribArray(1); gl.vertexAttribPointer(1, 4, gl.FLOAT, false, STRIDE, 0);     gl.vertexAttribDivisor(1, 1);
         gl.enableVertexAttribArray(2); gl.vertexAttribPointer(2, 1, gl.FLOAT, false, STRIDE, 4 * 4); gl.vertexAttribDivisor(2, 1);
         if (_uw) {
@@ -920,11 +973,15 @@ export async function initMapspinnerRender(gl, opts = {}) {
         gl.disable(gl.BLEND);
         if (typeof window !== 'undefined') window.__lastWaterQuads = wn;
       }
+      _instQuadsRef = quads;   // mark this quad set uploaded; next frame with the same array skips the rebuild
+      if (typeof window !== 'undefined') window.__instUploads = (window.__instUploads | 0) + (_dirty ? 1 : 0);
     }
     if (typeof window !== 'undefined') window.__lastDrawCalls = (n > 0) ? 2 : 0;
-    return gl.getError();
+    return 0;   // glError is checked via checkGlError() once per frame after quadtree (CPU/GPU pipelining)
   }
 
+  function checkGlError() { return gl.getError(); }
+
   // ---- DEBUG PROBE: replicate the VS clip-space transform on the CPU for a quad's 4
   // corners (vertex.xy in {0,1}^2) so we can see which quads project off-screen.
   function probe(quads, cam) {
@@ -956,5 +1013,5 @@ export async function initMapspinnerRender(gl, opts = {}) {
     return out;
   }
   function setHpf(tex, res, tex2) { _hpfTex = tex; _hpfRes = res|0; _hpfTex2 = tex2 || null; }   // tex2 = RG8(temp,humid) pack (W12)
-  return { get prog(){ return prog; }, render, probe, sampleGroundM, cullMatrix, recompile, setHpf, GRID, indexCount: indices.length, M4 };
+  return { get prog(){ return prog; }, render, checkGlError, probe, sampleGroundM, cullMatrix, recompile, setHpf, GRID, indexCount: indices.length, M4 };
 }

package/src/planet-orchestrator.js

@@ -177,7 +177,7 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
   // count (orbit 860->20, lowalt 1272->328). 1.0 is the calibrated default; override live
   // via window.__splitFactor.
   const splitFactor = opts.splitFactor ?? 1.0;
-  const gridMeshSize = opts.gridMeshSize || 16;   // 24->16 FPS lever (sub-pixel over-tessellation; see gl-render.js GRID)
+  const gridMeshSize = opts.gridMeshSize || 11;   // 16->11 FPS lever (triangle-throughput bound, not ALU; GRID 8 jagged biome crossovers, see gl-render.js GRID)
 
   gl.getExtension('EXT_color_buffer_float');   // RGBA32F atlas render targets
   // OES_texture_float_linear lets the driver LINEAR-filter the RGBA32F HPF/elevation textures. When
@@ -360,13 +360,15 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
   // there are no tiles to make resident, generate, or evict. _frameCache stays for the
   // static-camera re-render PERF path. frameStart kept (the render loop still references it).
   let _frameCache = null;
+  let _pipelineQuads = null;   // pre-computed quads from last frame for draw-before-compute pipelining
+  let _glCheckTick = 0;        // throttle the gl.getError() hard-sync to 1-in-30 frames (pipeline stall)
   let frameStart = 0;
 
   // ---- per-frame quadtree drive --------------------------------------------------
   // camWorldPos: [x,y,z] world meters (sphere centered at origin).
   // camTarget:   [x,y,z] world look-at point. fovy in radians. displayMode int.
   // Returns { quadCount, glError, face }.
-  function frame(camWorldPos, camTarget, fovy = 0.7, displayMode = 0, sunDir, time = 0, up) {
+  function frame(camWorldPos, camTarget, fovy = 0.7, displayMode = 0, sunDir, time = 0, up, surfElev = 0) {
     const sun = sunDir || (() => { const s = [0.4, 0.5, 0.75]; const sl = Math.hypot(...s); return [s[0]/sl, s[1]/sl, s[2]/sl]; })();
     // Use the caller's up if given (planet.html keeps an orthonormal free-fly up); only
     // fall back to [0,1,0] when none supplied. Hardcoding [0,1,0] broke the +Y pole view
@@ -399,8 +401,9 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
       || (fwd[0]*c.fwd[0]+fwd[1]*c.fwd[1]+fwd[2]*c.fwd[2]) < c.fwdLen2*0.99999
       || displayMode !== c.displayMode;
     if (!moved) {
-      const cam2 = { eye: camWorldPos, center: camTarget, up: camUp, fovy, displayMode };
-      const glError = render.render(c.quads, cam2, sun, time);
+      const cam2 = { eye: camWorldPos, center: camTarget, up: camUp, fovy, displayMode, surfElev };
+      render.render(c.quads, cam2, sun, time);
+      const glError = render.checkGlError();
       // Phase 2 fix: also re-draw vegetation on STATIC frames (the GPU instance buffer is
       // still valid from the last rebuild). Without this, trees vanished whenever the
       // camera held still (the static branch returned before the veg draw).
@@ -497,7 +500,7 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
     // ONLY to splitDist (NOT distF below): distF = sf*8.0 is the altitude-weighting term, and scaling sf
     // into BOTH compounds into ~2 levels at altitude (witnessed: base sf*2 gave mx 5->7 at 8000km). Keep
     // distF on the original sf so the push is a clean ONE step. maxLevel (16) is untouched -- no new LOD.
-    const LOD_STEP = 2.3;   // push ALL LODs ~0.6 step (reduced from 3.0 to target ~600 quads at all alts):
+    const LOD_STEP = 3.6;   // 2.3->3.6; tightens the far-ring by reducing LOD near the horizon. NOTE: splitDist floors at 1.1 so deck quad count is set by splitFactor (0.28 ~= 500 quads), not this.
     qt.computeSplitDist(sf * LOD_STEP, gl.drawingBufferHeight || 480, fovy);
     // DETAIL-FARTHER (user 2026-06-01h: each LOD pop should happen ~3x farther out -- 6km detail at
     // 24km, etc.). A quad subdivides when camAlt < l * splitDist * distFactor, so tripling distFactor
@@ -646,7 +649,7 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
     let _cullDbgOnScreen = 0;
     // Use viewProjNoEye (proj*viewRel, NO translate) + pass the eye so quadOutsideFrustum can make
     // each corner camera-relative in JS doubles (fp32-precision fix for the ground-nadir blank).
-    const _cm = cullActive ? render.cullMatrix({ eye: camWorldPos, center: camTarget, up: camUp, fovy }) : null;
+    const _cm = cullActive ? render.cullMatrix({ eye: camWorldPos, center: camTarget, up: camUp, fovy, surfElev }) : null;
     const vpr = _cm ? _cm.viewProjNoEye : null;
     // BEHIND-LIMB CULL (the dominant bottleneck fix). The baseline measured ~80% of all
     // generated quads sitting BEHIND the planet's horizon -- they are geometrically
@@ -671,8 +674,22 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
     // (5km), leaving 1968 quads with wastedFrac 0.87 (browser-5). Lower the guard to a tiny
     // epsilon above the surface; the slack term already keeps any limb-straddling quad.
     // (Eye exactly at/under the surface is degenerate -- cosHorizon would be >=1 -- so skip.)
+    // SCALED SLACK (2026-06-13): at low altitude the fixed CULL_MAX_ELEV=12km slack let all
+    // back-face quads through when the limb cull was disabled by the 127m guard; scale the
+    // elevation slack by altitude so the cull tightens naturally near the ground.
+    const altM = Math.max(0.0, camDist - R);
+    const elSlack = Math.min(CULL_MAX_ELEV, 200.0 + altM * 0.5);
     const limbCullActive = (typeof window !== 'undefined' && window.__limbCull != null ? !!window.__limbCull : true)
-      && camDist > R * 1.00002;
+      && altM > 0.5;
+    // CPU/GPU PIPELINING (real overlap, 2026-06-14): issue LAST frame's cached quads to the GPU
+    // NOW, BEFORE the 6-face quadtree build below runs, so the GPU draw and this frame's CPU
+    // build actually overlap. Previously this draw sat AFTER the build loop (no overlap -- the
+    // CPU work had already finished before the draw was issued). cam carries THIS frame's view
+    // (1-frame geometry latency, standard pipelining). First frame (no cache) draws after build.
+    const cam = { eye: camWorldPos, center: camTarget, up: camUp, fovy, displayMode, surfElev };
+    if (_pipelineQuads) {
+      render.render(_pipelineQuads, cam, sun, time);
+    }
     for (let face = 0; face < 6; face++) {
       // LOD drive uses lodRefPos (aim-shifted, altitude preserved) so deepest LOD follows the
       // look point; the quad record keeps the TRUE-camera localCam (for the VS geomorph
@@ -711,7 +728,7 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
           // (browser-4726 wastedFrac 0.55) = the close-approach FPS sink. A quad above this tight
           // horizon is genuinely visible (kept); a quad below it is kept ONLY by the forward-cone
           // rescue, so sideways/backside near-horizon rings are culled.
-          const slack = CULL_MAX_ELEV / R + (l / R);
+          const slack = elSlack / R + (l / R);
           if (dotOut < cosHorizon - slack) {
             // FRUSTUM RESCUE (user 2026-06-05: 'culling nearby quads unnecessarily making land
             // disappear'). The old forward-CONE rescue used a fixed ~53deg half-angle cone
@@ -759,9 +776,25 @@ export async function initMapspinnerPlanet(gl, opts = {}) {
       }
     }
 
-    // render the combined visible leaf set across all faces.
-    const cam = { eye: camWorldPos, center: camTarget, up: camUp, fovy, displayMode };
-    const glError = render.render(quads, cam, sun, time);
+    // ===== CPU/GPU PIPELINING: draw-before-compute =====
+    // Phase 1 (GPU): draw cached quads from LAST frame's camera IMMEDIATELY so the GPU
+    // starts processing while the CPU computes THIS frame's quadtree. render.render()
+    // issues draw commands without gl.getError() so the GPU pipeline is not stalled.
+    // Phase 2 (CPU): the 6-face loop above already populated `quads` — this overlaps
+    // with GPU rendering of Phase 1. Phase 3: first frame (no cache) draws after compute.
+    // glError is checked via render.checkGlError() after Phase 2 for diagnostics.
+    // cam + the _pipelineQuads draw were HOISTED above the 6-face loop (real CPU/GPU overlap).
+    // First frame (no cache) has nothing to pre-draw, so it draws THIS frame's quads here.
+    if (!_pipelineQuads) {
+      render.render(quads, cam, sun, time);
+    }
+    // THROTTLED glError: gl.getError() is a hard client/server SYNC that drains the GL pipeline
+    // (the exact stall the draw-before-compute pattern exists to avoid). Probe once every 30
+    // frames (or when window.__glCheck forces it); assume 0 between probes. 2026-06-14.
+    _glCheckTick = (_glCheckTick + 1) % 30;
+    const _forceGlCheck = (typeof window !== 'undefined' && window.__glCheck);
+    const glError = (_glCheckTick === 0 || _forceGlCheck) ? render.checkGlError() : 0;
+    _pipelineQuads = quads;
     // CULL DEBUG stats for the live HUD: kept/culled counts + the false-cull signature
     // (culledOnScreen = frustum-culled quads that actually project inside the screen) + whether
     // this was a REBUILD frame (cull ran) vs a cached re-render. Read by planet.html's __cullHud.

package/src/shaders/terrain.glsl

@@ -147,10 +147,10 @@ const float LAKE_CARVE_DEPTH = 90.0;   // metres of bowl depth at basin centre
 float lakeBasinField(vec3 dir){ return 0.5 + 0.5 * snoise3(dir * 55.0 + vec3(4.0, 9.0, 1.0)); }
 float lakeCarveM(vec3 dir, out float wet){
     float basin = lakeBasinField(dir);
-    float shoulder = smoothstep(0.50, 0.74, basin);     // eroded outwash apron (blends into terrain)
-    float bowl     = smoothstep(0.62, 0.80, basin);     // deeper water body
-    wet = smoothstep(0.64, 0.70, basin);                // crisp shoreline of the open water
-    return -LAKE_CARVE_DEPTH * (0.45 * shoulder + 0.55 * bowl);
+    float shoulder = smoothstep(0.30, 0.74, basin);     // gentle outwash apron (blends far into terrain)
+    float bowl     = smoothstep(0.50, 0.80, basin);     // deeper basin starts earlier
+    wet = smoothstep(0.50, 0.70, basin);                // softer shoreline transition
+    return -LAKE_CARVE_DEPTH * (0.65 * shoulder + 0.35 * bowl);   // more apron, gentler banks
 }
 float lakeCarveM(vec3 dir){ float w; return lakeCarveM(dir, w); }
 // River and canyon are the SAME incision algorithm (a 4-octave ridged 1-abs(snoise3) network),
@@ -187,13 +187,13 @@ float inciseRidgeField(vec3 d, float baseFreq, float freqMul){
     return sum / norm;                                         // ->1 on the channel network
 }
 const float RIVER_INCISE_DEPTH = 120.0;   // metres at the channel thalweg
-float riverRidgeField(vec3 dir){ return inciseRidgeField(normalize(dir), 320.0, 2.03); }
+float riverRidgeField(vec3 dir){ return inciseRidgeField(normalize(dir), 40.0, 2.03); }
 float riverCarveM(vec3 dir, out float wet){
     float ridge = riverRidgeField(dir);
-    float valley  = smoothstep(0.78, 0.94, ridge);             // wide eroded valley sides
-    float thalweg = smoothstep(0.88, 0.96, ridge);             // deep channel core
-    wet = smoothstep(0.90, 0.94, ridge);                       // flowing-water line
-    return -RIVER_INCISE_DEPTH * (0.5 * valley + 0.5 * thalweg);
+    float valley  = smoothstep(0.30, 0.94, ridge);             // gentle eroded valley sides, start wider
+    float thalweg = smoothstep(0.75, 0.96, ridge);             // deep channel core
+    wet = smoothstep(0.78, 0.94, ridge);                       // flowing-water line
+    return -RIVER_INCISE_DEPTH * (0.7 * valley + 0.3 * thalweg);   // more valley, gentler banking
 }
 float riverCarveM(vec3 dir){ float w; return riverCarveM(dir, w); }
 const float CANYON_INCISE_DEPTH = 1400.0;  // metres at the gorge floor (user 2026-06-02: deepen+widen so canyons visibly sculpt the elevation; was 480m = invisible vs multi-km relief)
@@ -208,6 +208,7 @@ uniform float uVertexAO;                   // per-vertex shading/AO strength lev
 uniform float uIsWater;                    // 0 = terrain pass, 1 = water-surface pass
 uniform float uUnderwater;                 // 0 = camera above water, 1 = camera below sea level
 uniform float uBeachTopM;                  // beach ceiling (m): below this, grass/snow yield to sand (window.__beachTop; 30 default)
+uniform float uBeachShelfM;                // land coastal-shelf top (m): h<this is eased (h*h/S) so the coast rises gently from the waterline = wide beach (window.__beachShelf; 300 default). GEOMETRY (composeHeight+vH).
 uniform float uHiFreqCut;                  // hi-freq elevation-noise attenuation, applied to ALL hi-freq sources:
                                            // broadShapeM/MD fine octaves (o>=6) + vtxDisplace micro-relief
                                            // (window.__hiFreqCut; default 0.25 = the user's 4x reduction, 2026-06-06)
@@ -220,7 +221,7 @@ uniform float uMtnBandWide;                // widen mtn=smoothstep(16.8,18.6,ele
 uniform float uClimateRelief;              // widen wetLowFlat(0.66,0.9,humid) + coldFlat(0.18,0.34,temp) reliefMul gates
 uniform float uIsleWide;                    // widen isleZone seaBias gates (50,350)+(900,1600) -> (30,600)+(600,2200)
 uniform float uCarveWide;                   // widen the river/canyon/lake/dune CLIMATE gates so carve depth fades in over a wide span
-float canyonRidgeField(vec3 dir){ return inciseRidgeField(normalize(dir) + vec3(13.7, -4.2, 8.9), 380.0, 2.07); }  // phase offset matches FS canyonMask
+float canyonRidgeField(vec3 dir){ return inciseRidgeField(normalize(dir) + vec3(13.7, -4.2, 8.9), 96.0, 2.07); }  // phase offset matches FS canyonMask. baseFreq 48->96 (user 2026-06-14: double canyon frequency = 2x finer/denser gorge network, more visible at the deck). Shared VS carve + FS mask -> congruent by construction.
 // CANYON cross-section now reads as a CANYON, not a V-notch: STEEP WALLS + a FLAT FLOOR.
 //   wall = a sharp smoothstep band -> the carve drops fast over a narrow ridge interval (the cliff
 //          walls), instead of the old gentle bench+gorge blend that made shallow V-troughs.
@@ -233,8 +234,8 @@ float canyonCarveM(vec3 dir, out float depth){
     // narrow ridge slice -> thin hairline gorges. Widen so the canyon reads as a BROAD gorge: a wide
     // eroded rim shoulder, a steep but visible wall, and a wide flat floor that the gorge bottoms out on.
     float bench = smoothstep(0.62, 0.78, ridge);               // wide eroded rim shoulder
-    float wall  = smoothstep(0.78, 0.86, ridge);               // STEEP cliff wall (wider band)
-    float floorF= smoothstep(0.86, 0.93, ridge);               // reach the flat gorge floor, then clamp
+    float wall  = smoothstep(0.70, 0.86, ridge);               // STEEP cliff wall (wider band)
+    float floorF= smoothstep(0.80, 0.93, ridge);               // reach the flat gorge floor, then clamp
     depth = max(wall, floorF);
     // 0.18 rim shoulder + 0.82 wall-to-floor; floorF clamps so the bottom is flat (no infinite V).
     float profile = 0.18 * bench + 0.82 * max(wall, floorF);
@@ -247,13 +248,16 @@ float canyonCarveM(vec3 dir, out float depth){
     // 100m scale the low-altitude camera sees. Pure world-dir (LOD-invariant); the mesh resolves them
     // at maxLevel 16 (~7m cells). Each gully octave = a thinned ridged field, depth scaled to its wl.
     vec3 dn = normalize(dir);
-    float g1 = inciseRidgeField(dn + vec3(5.1, 8.3, -2.7), 3500.0, 2.11);   // ~10km tributaries
-    float g2 = inciseRidgeField(dn + vec3(-7.4, 1.9, 6.2), 14000.0, 2.05);  // ~2.5km gullies
-    // HIGH-FREQ fractal depth x0.65 (user 2026-06-11 'leave the low frequency canyons deep, only
-    // reduce the high frequency fractals, bring it back 30%' -- halved, then +30% restored): the
-    // main 100km gorge network keeps full CANYON_INCISE_DEPTH; only these tributary octaves shrink.
-    carve += -104.0 * dmul * smoothstep(0.78, 0.93, g1);   // ~10km tributaries (160m * 0.65)
-    carve += -39.0  * dmul * smoothstep(0.80, 0.95, g2);   // ~2.5km gullies (60m * 0.65)
+    float g1 = inciseRidgeField(dn + vec3(5.1, 8.3, -2.7), 219.0, 2.11);   // ~40km tributaries (was 875->438)
+    float g2 = inciseRidgeField(dn + vec3(-7.4, 1.9, 6.2), 875.0, 2.05);  // ~10km gullies (was 3500->1750)
+    float g3 = inciseRidgeField(dn + vec3(2.2, -4.1, 8.8), 1750.0, 2.02); // ~1.2km branching ravines (deck scale)
+    // HIGH-FREQ fractal depth (user 2026-06-11 'leave the low frequency canyons deep, only reduce the
+    // high frequency fractals'). DEEPENED + sharpened 2026-06-14 (user: mountains need visible canyons):
+    // the main 100km gorge network keeps full CANYON_INCISE_DEPTH; the tributary octaves incise deeper
+    // with narrower walls so ravines read at the deck. g3 subdivides the bigger gullies at maxLevel.
+    carve += -450.0 * dmul * smoothstep(0.66, 0.90, g1);   // ~10km tributaries (deeper, narrower)
+    carve += -200.0 * dmul * smoothstep(0.70, 0.92, g2);   // ~2.5km gullies
+    carve +=  -90.0 * dmul * smoothstep(0.72, 0.93, g3);   // ~1.2km branching ravines
     return carve;
 }
 float canyonCarveM(vec3 dir){ float dd; return canyonCarveM(dir, dd); }
@@ -339,10 +343,10 @@ float duneFieldM(vec3 dir, out float crest){
 highp float broadShapeLowM(vec3 dir){   // W7: metres (~13000) + freq (~49152) accumulators are highp islands
   if (hasHpf == 0) return 0.0;
   vec3 d = normalize(dir);
-  highp float amp = 6500.0, freq = 3.0, sum = 0.0;
+  highp float amp = 6500.0, freq = 0.75, sum = 0.0;
   int blOcts = (uBroadLowOcts > 0) ? uBroadLowOcts : 8;
   for (int o=0; o<blOcts; o++){ sum += amp * snoise3(d*freq); amp *= (o < 6 ? 0.66 : 0.82); freq *= 2.0; }
-  return sum - 900.0;
+  return sum - 500.0;
 }
 // ---- SHARED micro-relief helpers (MOVED to the common preamble, THC-Normal W1, so composeHeight()
 // in the VS/PROBE region can call them). vtxDetail = the micro-relief A/B global; vnoise2
@@ -383,13 +387,14 @@ highp vec2 faceWarp(highp vec2 p){ return defRadius * tan((p / defRadius) * 0.78
 // PERLIN-EVERYWHERE lever -- shared by the composeHeight elevation term (VS/PROBE) and the FS albedo
 // overlay, so it must be declared in ALL stages (outside the VS/PROBE guard below).
 uniform float uDetailOverlay;   // amplitude lever (user-tuned 6; 0 = off; __detailOverlay)
+uniform float uGrid;             // interior cells per tile edge (GRID=16); for mesh-based vertex normals
 uniform float uNrmStepM;        // lit-normal FD step in metres (150); uniform-fed to defeat FXC constant folding
 #if defined(_VERTEX_) || defined(_PROBE_)
 highp float broadShapeM(vec3 dir, float reliefMul, float ridgeMul){   // W7: returns metres (~13000) -> highp
   if (hasHpf == 0) return 0.0;
   float mtnAmp = 1.0;   // mountain-amplitude (was a window.__mtnAmp uniform; inlined at neutral 1.0)
   vec3 d = normalize(dir);
-  highp float amp = 6500.0, freq = 3.0, sum = 0.0;   // W7 highp ISLAND: amp/freq(~49152)/sum(~13000) overflow fp16
+  highp float amp = 6500.0, freq = 0.75, sum = 0.0;   // W7 highp ISLAND: amp/freq(~49152)/sum(~13000) overflow fp16
   int octMax = (uOctMax > 0) ? uOctMax : 12;   // runtime bound (FXC unroll-defeat); 12 when unset
   for (int o=0; o<octMax; o++){   // W9: 14->12 octaves, drop the finest 2 (wavelengths <2km) UNCONDITIONALLY
     // FINE-OCTAVE 5x FREQ (user 2026-06-06: the high-freq normals-affecting GROUND bump should be 5x
@@ -418,19 +423,8 @@ highp float broadShapeM(vec3 dir, float reliefMul, float ridgeMul){   // W7: ret
     sum += amp * nn;
     amp *= (o < 6 ? 0.66 : 0.80); freq *= 2.0;   // macro decay 0.66; fine-octave decay 0.74->0.80 (widen, 2026-06-08)
   }
-  // LOW-ELEVATION COMPRESSION CURVE (gamma 2.5): power-curve the positive land height only so
-  // low/mid land sinks toward a flatter base while peaks keep their range; sea sign untouched.
-  {
-    const float HREF = 6500.0, GAMMA = 2.5;
-    highp float e0 = sum - 900.0;                    // W7: metres
-    if (e0 > 0.0) {
-      highp float ec = HREF * pow(min(e0, HREF) / HREF, GAMMA);
-      if (e0 > HREF) ec += (e0 - HREF);
-      sum = 900.0 + ec;
-    }
-  }
   // PEAK-LIFT, MOUNTAIN-BELT GATED: lift the high end so ridges become tall peaks; plains flat.
-  highp float hi = max(sum - 900.0, 0.0);            // W7: metres
+  highp float hi = max(sum - 500.0, 0.0);            // W7: metres
   float peak = smoothstep(1200.0, 5000.0, hi);
   float liftK = 0.06 + 0.16 * clamp(reliefMul, 0.0, 1.7);   // 2x LESS elevated (user 2026-06-10: halved 0.12+0.32 -> 0.06+0.16)
   sum += hi * peak * liftK;
@@ -440,8 +434,8 @@ highp float broadShapeM(vec3 dir, float reliefMul, float ridgeMul){   // W7: ret
   if (belt > 0.0 && hi > 0.0) {
     // (massif envelope freqs restored to 4.0/7.0 -- they set continental belt PLACEMENT, not the visible
     // ridge spacing; the 3x-wider knob is the o>=6 fine band above, not this envelope.)
-    float e0 = snoise3(d * 4.0 + vec3(11.0, 3.0, 7.0)) * 0.5 + 0.5;
-    float e1 = snoise3(d * 7.0 + vec3(2.0, 9.0, 4.0)) * 0.5 + 0.5;
+    float e0 = snoise3(d * 2.0 + vec3(11.0, 3.0, 7.0)) * 0.5 + 0.5;
+    float e1 = snoise3(d * 3.5 + vec3(2.0, 9.0, 4.0)) * 0.5 + 0.5;
     float modu = 0.7 + 0.3 * clamp(e0 * 0.7 + e1 * 0.3, 0.0, 1.0);
     float landGate = smoothstep(0.0, 800.0, hi);
     float base = belt * landGate * modu;
@@ -453,14 +447,14 @@ highp float broadShapeM(vec3 dir, float reliefMul, float ridgeMul){   // W7: ret
       // conflated the braided TEXTURE patches (rockSlope breakup noise, since deleted) with real slope;
       // with the braids, the dark raw-photo far field, and the UDN normal-frame bug all fixed, the
       // original steep terrain stands.
-      highp float pf = 200.0; float pa = 1.0, ps = 0.0, pn = 0.0;   // W7: pf (~4100) feeds the noise lattice -> highp
+      highp float pf = 50.0; float pa = 1.0, ps = 0.0, pn = 0.0;   // W7: pf feeds the noise lattice -> highp. pf 100->50 (user 2026-06-14: halve the mountain frequency = 2x wider peak massifs)
       int pkOcts = (uPeakOcts > 0) ? uPeakOcts : 3;
       for (int o = 0; o < pkOcts; o++) {
         ps += pa * (1.0 - abs(snoise3(d * pf + vec3(3.3, 7.7, 1.1))));
         pn += pa; pa *= 0.65; pf *= 2.13;
       }
       float crest = ps / pn;
-      sum += base * pow(crest, 4.5) * 8400.0 * mtnAmp;   // 2x LESS elevated (user 2026-06-10: halved 16800 -> 8400); sharper eroded tips (pow 4.5) kept
+      sum += base * pow(crest, 4.5) * 8400.0 * mtnAmp;   // pow 4.5: sharp steep peaks that engage the rock-face slope gate (3.5 rounded them flat -- user 2026-06-14 regression revert)
     }
   }
   // SOFT ELEVATION CEILING (mob-w8-ceiling 2026-06-08: 'peaks come to points, no flat plateau'). Even at
@@ -470,13 +464,13 @@ highp float broadShapeM(vec3 dir, float reliefMul, float ridgeMul){   // W7: ret
   // asymptoting to a ceiling -- and lift CMAX to 15000 so the asymptote sits well above any real peak. With
   // the wider knee the high band no longer collapses, so the *1.15 scale-up crutch is DROPPED.
   {
-    highp float e = sum - 900.0;                     // W7: metres
-    // GLOBAL ELEVATION SCALE 0.65 (user 2026-06-10). 0.343 over-squashed the field (45.9% land <500m, p50
+    highp float e = sum - 500.0;                     // W7: metres
+    // GLOBAL ELEVATION SCALE 0.85 (user 2026-06-13).
     // 723m, relief only ~4km -> mountains invisible/clamped-looking, NOT a top clip). 0.65 expands the
     // range so mountains stand out: p50 ~1370m, p99 ~8920m, MAX ~11600m, relief ~7.5km. Scales the WHOLE
     // relief uniformly (base octaves + belt massif + peaks) on the excess-over-900. Max 11.6km still well
     // under the ceiling (CK 6500 / CMAX 42000, knee /26000) so no clip.
-    e *= 0.65;
+    e *= 0.85;
     // CEILING RAISED + KNEE WIDENED for the 4x mountaintops (user 2026-06-09: 'must not hit the ceiling
     // anywhere, run under the normal max + elevate the maximum'). MEASURED 4x-hf+4x-mtn pre-ceiling max
     // = 28550m (p99.9 21457m); CMAX 42000 sits 1.47x above it = no peak ever approaches the asymptote, and
@@ -549,9 +543,10 @@ float vtxDisplace(highp vec2 fp, float tileM, float rugged){   // W7: fp = face-
   // amplitude than the base bump (ea0 5m vs 8m) per 'a little less intensity'. 4-octave ridged-leaning fBm
   // for erosive gully/ridgeline shape. Added INSIDE vtxDisplace so it shares the LOD-invariant, seam-safe,
   // face-local path (no per-patch step) and is picked up by the composeHeight central-diff lit normal.
-  float mtnGate = smoothstep(0.55, 1.0, rugged);   // ramps in over the mountain belt (rugged ~ elevAmp)
+  float mtnGate = smoothstep(0.30, 0.70, rugged);   // ramps in as soon as the massif lifts so ALL mountains get erosive perlin (user 2026-06-14); was (0.40,0.85)
+  float eros = 0.0;   // mountain erosive relief, kept SEPARATE from the uHiFreqCut trim (see return)
   if (mtnGate > 0.0) {
-    float ea = 2.5, ewl = 2880.0, esumF = 0.0, esumR = 0.0;   // user 2026-06-09: HALF the erosion elevation (5->2.5m) + 3x WIDER again (960->2880m)
+    float ea = 8.0, ewl = 1440.0, esumF = 0.0, esumR = 0.0;   // ea 4->8 + ewl 1920->1440: stronger, sharper rugged ravine relief so mountains read ROCKY (engage the rockSlope gate), not round/smooth (user 2026-06-14). Decoupled from uHiFreqCut so it lands full-strength.
     int veOcts = (uVtxErodeOcts > 0) ? uVtxErodeOcts : 4;
     for (int o = 0; o < veOcts; o++) {
       float en = vnoise2(fp / ewl);
@@ -560,10 +555,13 @@ float vtxDisplace(highp vec2 fp, float tileM, float rugged){   // W7: fp = face-
       esumR += ea * (er * 2.0 - 1.0);
       ea *= 0.55; ewl *= 0.5;
     }
-    sum += mix(esumF, esumR * 0.9, 0.6) * mtnGate;   // ridged-leaning erosive relief, mountain-gated
+    eros = mix(esumF, esumR * 0.9, 0.6) * mtnGate;   // ridged-leaning erosive relief, mountain-gated
   }
   float ruggedAmp = clamp(rugged, 0.4, 1.15);
-  return sum * vtxDetail * ruggedAmp * uHiFreqCut;   // 4x high-freq cut (uHiFreqCut default 0.25)
+  // DECOUPLE (user 2026-06-14, workflow-found root cause): the everywhere-bump `sum` still rides the
+  // uHiFreqCut altitude-blotch trim (0.25), but the mountain `eros` does NOT -- it was being silently
+  // quartered (6.0->1.5m), which is why mountains read as smooth grass. eros now lands full-strength.
+  return (sum * uHiFreqCut + eros) * vtxDetail * ruggedAmp;
 }
 
 // PERLIN-EVERYWHERE detail fbm (user 2026-06-10): ONE 3-octave value fbm shared by the FS albedo
@@ -571,7 +569,7 @@ float vtxDisplace(highp vec2 fp, float tileM, float rugged){   // W7: fp = face-
 // relief variation correlate, reading as one landform). World-dir keyed, seam-safe.
 highp float detailFbm(vec3 dir) {
     float ov = 0.0, oa = 0.0;
-    float fq = 150.0, am = 1.0;
+    float fq = 75.0, am = 1.0;
     int dfOcts = (uDetailFbmOcts > 0) ? uDetailFbmOcts : 3;
     for (int o = 0; o < dfOcts; o++) {
         ov += am * snoise3(dir * fq + vec3(float(o) * 7.3));
@@ -602,7 +600,7 @@ highp float composeHeight(vec3 dir0, highp vec2 faceLocal, float tileM){   // W7
   // latitude/moisture gradients instead of a per-cell contour (wrxo0rr7a coldFlat/wetLowFlat 80m+).
   float wetLowFlat = smoothstep(mix(0.66, 0.50, uClimateRelief), mix(0.9, 1.0, uClimateRelief), bHum) * (1.0 - mtn);
   float coldFlat = (1.0 - smoothstep(mix(0.18, 0.05, uClimateRelief), mix(0.34, 0.45, uClimateRelief), bTemp));
-  float reliefMul = clamp(0.45 + 1.25 * mtn - 0.30 * wetLowFlat - 0.25 * coldFlat, 0.15, 1.7);
+  float reliefMul = clamp(0.45 + 1.25 * mtn - 0.30 * wetLowFlat - 0.25 * coldFlat, 0.40, 1.7);
   float ridgeMul  = clamp(mtn * 1.1, 0.0, 1.0);
   // ISLAND-TYPE VARIETY (pure fn of world dir) -- mirror of the VS main isle block.
   // uIsleWide=1 spreads the seaBias double-gate so the volcanic/atoll remix ramps in (wrxo0rr7a 2000m).
@@ -626,6 +624,16 @@ highp float composeHeight(vec3 dir0, highp vec2 faceLocal, float tileM){   // W7
   if (h < 0.0) {
       highp float d = -h;
       h = -(min(d, 500.0) * 0.24 + max(d - 500.0, 0.0) * 1.19);
+      h = max(h, -11000.0);   // cap depth at Mariana Trench (~11km)
+  } else {
+      // LAND COASTAL SHELF (user 2026-06-14: 'beaches not wide enough'): the underwater shelf above
+      // gives a gentle seabed; mirror it on the LAND side so the coast rises GENTLY from the waterline
+      // = a wide beach. h*h/S is flat at the waterline (derivative 0) and identity at h=S, so high land
+      // is unchanged (no drowning) and only the low coastal band is stretched horizontally. Pure fn of
+      // the field -> seam-safe + the collision probe shares it. GUARD: a stale/unset uniform (0) would
+      // disable the shelf -> default 600 so it always applies. window.__beachShelf dials S live.
+      highp float bShelf = uBeachShelfM > 1.0 ? uBeachShelfM : 600.0;
+      if (h < bShelf) h = h * h / bShelf;
   }
   // displacement now continues UNDERWATER (the old land-only gate served the flat-clamped ocean,
   // gone since 026d530): the seabed carries the same micro-relief as land = realistic continuation.
@@ -634,17 +642,19 @@ highp float composeHeight(vec3 dir0, highp vec2 faceLocal, float tileM){   // W7
   // the FS albedo overlay shows, as real relief (~30m per lever unit -> ~180m at the user-tuned 6).
   // Shore-gated (fades in over the first 250m of land) so the coastline and the flat water planes are
   // untouched and no noise islets pop offshore. The VS FD lit-normal picks it up automatically.
-  h += detailFbm(dir0) * uDetailOverlay * 30.0 * smoothstep(0.0, 250.0, h);
-  // FLAT-AREA INTEREST NOISE (user 2026-06-12): gentle rolling relief on the least noisy
-  // anchorpoints (low reliefMul = flat plains, non-mtn, non-wet, non-cold). Fades to zero
-  // by reliefMul ~0.5 so mountains are unaffected.
+  h += detailFbm(dir0) * uDetailOverlay * 30.0 * step(0.0, h);
+  // FLAT-AREA VALLEY NETWORKS + LAKES (user 2026-06-13): incised valley systems in low-relief
+  // plains. Replaces the old noise bumps with a ridge-field valley network for connected
+  // linear depressions and lakes that fill the valley bottoms. Fades to zero by reliefMul ~0.5.
   float flatGate = max(0.0, 1.0 - reliefMul * 2.0);
-  h += snoise3(dir0 * 1400.0) * flatGate * uDetailOverlay * 35.0;
+  float valleyV = 1.0 - inciseRidgeField(dir0, 31.0, 2.0);
+  float valleyVal = smoothstep(0.25, 0.80, valleyV) * flatGate * uDetailOverlay * 24.0;
+  h -= valleyVal;
   // LAKE CARVE + flat-water plane
   float lakeWetV; float lakeCarveRaw = lakeCarveM(dir0, lakeWetV);
-  // uCarveWide=1 widens the carve CLIMATE gates so the gorge/lake/dune depth fades in over a wide
-  // anchor span instead of snapping along a thin climate contour (wrxo0rr7a carve cluster 90-1400m).
-  float lakeGate = smoothstep(mix(0.60, 0.50, uCarveWide), mix(0.85, 0.95, uCarveWide), hpf0.a) * step(0.0, h);
+  // Flat-area lakes: lower humidity gate so plains valleys fill with lakes
+  float lakeGateLo = mix(0.60, 0.50, uCarveWide) - 0.12 * flatGate;
+  float lakeGate = smoothstep(lakeGateLo, mix(0.85, 0.95, uCarveWide), hpf0.a) * step(0.0, h);
   float lakeCarveV = lakeCarveRaw * lakeGate;
   h += lakeCarveV;
   float lakeWet = lakeWetV * lakeGate;
@@ -652,8 +662,7 @@ highp float composeHeight(vec3 dir0, highp vec2 faceLocal, float tileM){   // W7
   // RIVER + CANYON incision (clamped so coastal gorges never punch fake inland seas)
   float riverWet   = smoothstep(mix(0.30, 0.20, uCarveWide), mix(0.55, 0.65, uCarveWide), hpf0.a) * smoothstep(mix(0.20, 0.12, uCarveWide), mix(0.34, 0.46, uCarveWide), hpf0.b);
   float riverWetMask; float riverCarveV = riverCarveM(dir0, riverWetMask) * riverWet * step(0.0, h);
-  float canyonArid = (1.0 - smoothstep(mix(0.40, 0.30, uCarveWide), mix(0.58, 0.68, uCarveWide), hpf0.a)) * smoothstep(mix(0.38, 0.28, uCarveWide), mix(0.56, 0.66, uCarveWide), hpf0.b) * smoothstep(60.0, 200.0, h);
-  float canyonDepMask; float canyonCarveV = canyonCarveM(dir0, canyonDepMask) * canyonArid * step(0.0, h);
+  float canyonDepMask; float canyonCarveV = canyonCarveM(dir0, canyonDepMask) * step(0.0, h);
   float inciseTot = riverCarveV + canyonCarveV;
   // min(...,0): the floor term goes POSITIVE for any h below -60 and was LIFTING the entire ocean
   // floor to exactly -60m -- the whole seabed was a uniform pan (root of 'depth under the water
@@ -662,7 +671,7 @@ highp float composeHeight(vec3 dir0, highp vec2 faceLocal, float tileM){   // W7
   inciseTot = max(inciseTot, min(-60.0 - h, 0.0));           // land: h + inciseTot >= -60m; ocean: untouched
   h += inciseTot;
   // CLIFF TERRACING (mesa/butte benches) -- after carves so canyon walls + risers compose
-  float cliffFaceMask; float cliffCarveV = cliffTerraceM(dir0, h, cliffFaceMask) * canyonArid * step(0.0, h);
+  float cliffFaceMask; float cliffCarveV = cliffTerraceM(dir0, h, cliffFaceMask) * step(0.0, h);
   h += cliffCarveV;
   // FLAT RIVER WATER
   float riverWetLine = riverWetMask * riverWet * step(0.0, h);
@@ -794,7 +803,7 @@ void main() {
     float mtn = smoothstep(16.8, 18.6, bAmp);                     // mountain-belt weight 0..1
     float wetLowFlat = smoothstep(0.66, 0.9, bHum) * (1.0 - mtn); // swamp/wetland -> flat
     float coldFlat = (1.0 - smoothstep(0.18, 0.34, bTemp));       // tundra/ice -> flat
-    float reliefMul = clamp(0.45 + 1.25 * mtn - 0.30 * wetLowFlat - 0.25 * coldFlat, 0.15, 1.7);
+    float reliefMul = clamp(0.45 + 1.25 * mtn - 0.30 * wetLowFlat - 0.25 * coldFlat, 0.40, 1.7);
     float ridgeMul  = clamp(mtn * 1.1, 0.0, 1.0);                 // ridged crests only in mountain belts
     // ISLAND-TYPE VARIETY: small offshore swells get a per-region type (volcanic cone / low atoll)
     // from a world-dir noise so islands are not all scaled continents. Pure fn of world dir.
@@ -817,13 +826,24 @@ void main() {
     if (vH < 0.0) {
         highp float dSea = -vH;
         vH = -(min(dSea, 500.0) * 0.24 + max(dSea - 500.0, 0.0) * 1.19);
+        vH = max(vH, -11000.0);   // cap depth at Mariana Trench (~11km)
+    } else {
+        highp float bShelf = uBeachShelfM > 1.0 ? uBeachShelfM : 600.0;   // LAND COASTAL SHELF -- mirror composeHeight exactly (wide beach, user 2026-06-14); guard stale/unset uniform
+        if (vH < bShelf) vH = vH * vH / bShelf;
     }
     vH += vDisp;
+    vH += detailFbm(dir0) * uDetailOverlay * 30.0 * step(0.0, vH);
+    // FLAT-AREA VALLEY NETWORKS + LAKES (user 2026-06-13): incised valley systems in low-relief
+    // plains -- must mirror composeHeight for FS material consistency.
+    float flatGate = max(0.0, 1.0 - reliefMul * 2.0);
+    float valleyV = 1.0 - inciseRidgeField(dir0, 31.0, 2.0);
+  float valleyVal = smoothstep(0.25, 0.80, valleyV) * flatGate * uDetailOverlay * 24.0;
+    vH -= valleyVal;
     // LAKE CARVE: carve a real basin into the elevation on WET LAND so lakes are part of the
-    // fractal (no fade-in). Gated to land (vH>0) + wet regions (humid) so it does not pit deserts
-    // or deepen the ocean. World-dir field -> identical at every LOD.
+    // fractal (no fade-in). Flat-area gate widened so plains valleys fill with lakes.
     float lakeWetV; float lakeCarveRaw = lakeCarveM(dir0, lakeWetV);
-    float lakeGate = smoothstep(0.60, 0.85, hpf0.a) * step(0.0, vH);
+    float lakeGateLo = 0.60 - 0.12 * flatGate;
+    float lakeGate = smoothstep(lakeGateLo, 0.85, hpf0.a) * step(0.0, vH);
     float lakeCarveV = lakeCarveRaw * lakeGate;
     vH += lakeCarveV;
     // FLAT WATER: inside the wet core the surface must read as flat water (user: 'water should be
@@ -847,8 +867,7 @@ void main() {
     // by the small depths + land gate; coastline hypso re-witnessed in incision-hypso-landfrac-gate).
     float riverWet   = smoothstep(0.30, 0.55, hpf0.a) * smoothstep(0.20, 0.34, hpf0.b);   // moist, not frozen
     float riverWetMask; float riverCarveV = riverCarveM(dir0, riverWetMask) * riverWet * step(0.0, vH);
-    float canyonArid = (1.0 - smoothstep(0.40, 0.58, hpf0.a)) * smoothstep(0.38, 0.56, hpf0.b) * smoothstep(60.0, 200.0, vH);
-    float canyonDepMask; float canyonCarveV = canyonCarveM(dir0, canyonDepMask) * canyonArid * step(0.0, vH);
+    float canyonDepMask; float canyonCarveV = canyonCarveM(dir0, canyonDepMask) * step(0.0, vH);
     // NO-SUB-SEA-COAST GUARD (user 2026-06-02 deepen+widen): with the deepened canyon (-1400m + gullies)
     // a gorge on 200m coastal land would punch vH to ~-1200m = fake inland seas. Clamp the TOTAL incision
     // so post-carve land bottoms out at a small floor (-60m: a gorge may reach near sea level but never
@@ -862,7 +881,7 @@ void main() {
     // arid badlands look). The snap delta is added to vH; cliffFaceMask (->1 on a riser face) goes to
     // the FS for strata banding + steep-rock material. Applied AFTER carves so canyon walls + cliff
     // risers compose. step(0,vH) keeps it on land.
-    float cliffFaceMask; float cliffCarveV = cliffTerraceM(dir0, vH, cliffFaceMask) * canyonArid * step(0.0, vH);
+    float cliffFaceMask; float cliffCarveV = cliffTerraceM(dir0, vH, cliffFaceMask) * step(0.0, vH);
     vH += cliffCarveV;
     // FLAT RIVER WATER (user: 'rivers/lakes should NOT be bumpy'): like lakes, the river thalweg
     // surface must read as flat water, not the bumpy micro-relief floor. Pin vH down to the channel
@@ -920,22 +939,48 @@ void main() {
     // ALL THREE taps through ONE runtime-bounded loop forces FXC to emit a SINGLE composeHeight instance,
     // so whatever approximations it picks cancel exactly in the differences. uNrmStepM>0.0 keeps the
     // bound non-constant (same defeat class as uOctMax).
-    highp vec3 uzFD = dir0;
-    vec3 refAxisFD = (abs(uzFD.y) < 0.99) ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
-    vec3 uxFD = normalize(cross(refAxisFD, uzFD));
-    vec3 uyFD = cross(uzFD, uxFD);
-    highp float nStepFD = (uNrmStepM > 0.0) ? uNrmStepM : 150.0;
-    highp float hFD0 = 0.0, hFD1 = 0.0, hFD2 = 0.0;
+    // VERTEX NORMALS: interior vertices use the mesh-based edge cross product (ordinary
+    // face normals). Tile-edge vertices use the tangent-frame finite difference so both
+    // sides of a seam share the same dir0/tangent frame -> consistent normals, no row artifact.
+    highp float hN0 = 0.0;
+    highp vec3 vN = dir0;
     if (uIsWater < 0.5) {
-        int fdIters = (uNrmStepM >= 0.0) ? 3 : 1;   // always 3; non-constant so FXC cannot unroll/split
+        hN0 = composeHeight(dir0, faceLocal, defOffset.z);   // center = the geometry height h
+        // VERTEX NORMAL = CENTRAL DIFFERENCE in PARAMETRIC MESH SPACE over the FULL composeHeight (2026-06-14
+        // jagged-normal fix). Two earlier methods both jagged: (a) interior FORWARD mesh-cell cross product
+        // = each vertex got its forward triangle's FACE normal (faceted) at a vertex-spacing step (noisy);
+        // (b) the tangent-frame FD passed the SAME faceLocal to every tap, so vtxDisplace CANCELLED in the
+        // differences -> the normal ignored the bumps the geometry has -> smooth normal on a bumpy mesh =
+        // facets show through. THIS evaluates the full field (incl vtxDisplace) at +/-du/+/-dv in parametric
+        // space (faceWarp gives BOTH the dir and faceLocal at each offset, so vtxDisplace varies correctly)
+        // and takes a CENTRAL (symmetric) world-space cross product = smooth AND matches the displaced
+        // surface. ONE formula for every vert (no interior/edge split = no discontinuity); seam-safe because
+        // adjacent same-LOD tiles sample the identical world offsets (the field is a pure fn of world pos).
+        // NORMAL SMOOTHING (user 2026-06-14: 'angular normals = no vertex smoothing'): low-pass the
+        // per-vertex normal by taking the central difference over a fixed ~METRIC step (uNrmStepM, ~300m)
+        // instead of ~1 mesh cell. A cell-sized step samples the high-freq erosion/canyon relief so the
+        // normal swings sharply vertex-to-vertex = angular; a fixed larger step averages it = adjacent
+        // verts vary smoothly = smooth shading, at any GRID. duP = stepM / tile-span (defOffset.z), clamped
+        // so it never drops below the mesh cell (would re-alias) nor exceeds ~1/3 the tile.
+        highp float nStepM = (uNrmStepM > 0.0) ? uNrmStepM : 300.0;
+        highp float duP = clamp(nStepM / max(defOffset.z, 1.0), 1.0 / ((uGrid > 0.0) ? uGrid : 16.0), 0.34);
+        highp float hPU = 0.0, hMU = 0.0, hPV = 0.0, hMV = 0.0;
+        highp vec3 dPU = dir0, dMU = dir0, dPV = dir0, dMV = dir0;
+        int fdIters = (uGrid >= 0.0) ? 4 : 1;   // 4 offset taps; runtime-bounded (FXC unroll-defeat, see uOctMax)
         for (int i = 0; i < fdIters; i++) {
-            highp vec3 dd = (i == 0) ? dir0
-                          : normalize(uzFD + ((i == 1) ? uxFD : uyFD) * (nStepFD / defRadius));
-            highp float hi = composeHeight(dd, faceLocal, defOffset.z);
-            if (i == 0) hFD0 = hi; else if (i == 1) hFD1 = hi; else hFD2 = hi;
+            highp vec2 off = (i == 0) ? vec2(duP, 0.0) : (i == 1) ? vec2(-duP, 0.0) : (i == 2) ? vec2(0.0, duP) : vec2(0.0, -duP);
+            highp vec2 fl = faceWarp((vertex.xy + off) * defOffset.z + defOffset.xy);
+            highp vec3 dd = normalize(defLocalToWorld * vec3(fl, defRadius));
+            highp float hh = composeHeight(dd, fl, defOffset.z);
+            if (i == 0) { hPU = hh; dPU = dd; } else if (i == 1) { hMU = hh; dMU = dd; }
+            else if (i == 2) { hPV = hh; dPV = dd; } else { hMV = hh; dMV = dd; }
         }
+        highp vec3 wPU = dPU * (defRadius + hPU), wMU = dMU * (defRadius + hMU);
+        highp vec3 wPV = dPV * (defRadius + hPV), wMV = dMV * (defRadius + hMV);
+        vN = normalize(cross(wPU - wMU, wPV - wMV));
+        if (dot(vN, dir0) < 0.0) vN = -vN;   // keep it outward (terrain has no overhangs)
     }
-    highp float h = hFD0;
+    highp float h = hN0;
     // OCEAN TOP = A SEPARATE, ELEVATION-BASED SURFACE (user 2026-06-10: 'terrain should extend into
     // the ocean, the ocean top separate and elevation based'). composeHeight keeps carrying the TRUE
     // signed bathymetry (vH -> the FS depth tint/Beer-Lambert keys on it), but the RENDERED surface
@@ -949,34 +994,8 @@ void main() {
     // and shades it as the animated ocean, alpha-blended over the seabed (depth test keeps it
     // behind land).
     highp float hR = (uIsWater > 0.5) ? 0.0 : h;
-    // W8 ANALYTIC LIT NORMAL (P1 data-first): the normal is a property of the height FIELD, so derive it
-    // from the field, not from per-pixel screen derivatives. FIXED-WORLD-STEP central difference of
-    // composeHeight in the radial tangent frame -- STABLE (does NOT shrink with distance/per-cell -> no
-    // shimmer, see :769), full landform relief at ALL distances, no fade. Mirror of the proven nBand
-    // pattern but the FULL composeHeight (not macro-only broadShapeLowM). Offset ONLY dir0 (the world-dir
-    // gradient = the seam-safe landform relief); hold faceLocal/tileM fixed so the tile-local vtxDisplace
-    // term cancels in the difference (it carries no world-continuous gradient and would only add jitter).
-    vec3 uzN = dir0;   // dir0 is already normalized; radial up
-    vec3 refAxisN = (abs(uzN.y) < 0.99) ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
-    vec3 uxN = normalize(cross(refAxisN, uzN));
-    vec3 uyN = cross(uzN, uxN);
-    // FXC FOLD-DEFEAT (2026-06-12, same disease as the uOctMax unroll fix): with a LITERAL 150.0 the
-    // d3d11/FXC translator constant-folds/reassociates the tiny FD offset (150/R = 2.4e-5) feeding
-    // normalize(uzN + uxN*eps) -- the perturbed-direction taps then diverge wildly from h on FLAT
-    // ground (witnessed: probe slope 0.000 + flat wireframe mesh under whole regions the FS painted
-    // as rock; the FD normal claimed steep in noise-keyed PATCHES = 'rock without slope angle').
-    // A uniform-fed step denies FXC the constant, exactly like uOctMax denies it the loop bound.
-    highp float nStep = (uNrmStepM > 0.0) ? uNrmStepM : 150.0;   // STABLE world step (m): > finest vtxDisplace octave (~20m, no alias),
-                                 // < carve band (~100m+, resolves canyons/cliffs). NOT pxWorld-scaled.
-    if (uIsWater > 0.5) {
-        vNrm = uzN;   // water surface: radial normal; waves perturb it per-pixel in the FS (skips 2 composeHeight taps)
-    } else {
-    // taps come from the SINGLE-INSTANCE FD loop above (hFD0/1/2) -- never call composeHeight at
-    // separate call sites for the FD again; per-callsite FXC codegen divergence was the AMD root.
-    float dHduN = float(hFD1 - h) / nStep;
-    float dHdvN = float(hFD2 - h) / nStep;
-    vNrm = normalize(uxN * (-dHduN) + uyN * (-dHdvN) + uzN);   // n = normalize([-dz/du,-dz/dv,1]) in the (ux,uy,uz) frame
-    }
+    // VERTEX NORMAL: central-difference (computed above) for land; radial for water.
+    vNrm = (uIsWater > 0.5) ? dir0 : vN;
     // DIRECT per-vertex sphere projection (replaces the old corner-blend deform, which
     // bilinearly interpolated 4 deformed corners -> FLAT quad interior -> faceted at high GRID).
     // dir0 is THIS vertex's world direction (faceWarp'd, defLocalToWorld-mapped); place it on the
@@ -1016,8 +1035,8 @@ void main() {
     // = metres the water plane sits above the pre-flatten carved floor, >0 ONLY inside the true open
     // water; the FS gates ALL inland-water shading on this so blue == the flat water, banks stay land.
     vWaterDepth = max(waterPlane - floorBefore, 0.0) * step(0.001, haveWater);
-    vCanyonDep = canyonDepMask * canyonArid * step(0.0, vH);
-    vCliffFace = cliffFaceMask * canyonArid * step(0.0, vH);
+    vCanyonDep = canyonDepMask * step(0.0, vH);
+    vCliffFace = cliffFaceMask * step(0.0, vH);
     vDuneCrest = duneCrest * duneSand;
     vGrid = vertex.xy;   // parametric mesh-cell coord for the wireframe overlay
     vLevel = defOffset.w;   // quad LOD level -> FS patches view
@@ -1157,13 +1176,9 @@ vec3 terrainAlbedo(float h, float slope, float rockSlope, highp vec3 worldPos) {
     } else {
         c = mix(bcShore, bcLowland, smoothstep(0.0, bandEdgesLo.x, h));
         c = mix(c, bcGrass, smoothstep(bandEdgesLo.x, bandEdgesLo.y, h));
-        // ROCK IS VERTICALITY-DRIVEN, NOT HEIGHT-SPLATTED (user 2026-06-03: 'rock face based on
-        // verticality not splatted directly on albedo'). The old height-band rock mix
-        // (bcRock by bandEdgesHi) painted tan rock flat across every high plateau/summit regardless
-        // of slope, so flat high ground read as rock. REMOVED. High flat ground now keeps its biome
-        // (and snow by height below); ONLY the slope/verticality term and the steep cliff term turn
-        // rock. Snow still bands by altitude (a flat snowfield is physically correct).
-        c = mix(c, bcSnow,  smoothstep(snowEdges.x, snowEdges.y, h));
+        float bandWarp = snoise3(normalize(worldPos) * 400.0) * 500.0;
+        c = mix(c, bcRock, smoothstep(bandEdgesHi.x + bandWarp, bandEdgesHi.y + bandWarp, h));
+        c = mix(c, bcSnow, smoothstep(snowEdges.x + bandWarp, snowEdges.y + bandWarp, h));
         c = mix(c, bcRock, smoothstep(slopeRock.x, slopeRock.y, rockSlope) * step(0.0, h));
         // OLD PROCEDURAL GREY ROCKFACE DELETED (max-speed sweep 2026-06-10, user 'replace the original
         // rock completely'): the photo-rock splat owns steep faces; the 3-tap grey fBm fallback is gone.
@@ -1281,8 +1296,6 @@ float canyonMask(vec3 worldPos, float h, float temp, float humid, float px, out
     depth = 0.0;
     // gentle elevation gate: canyons want SOME relief above the lowland, not only rare high
     // plateaus (h>250 made them NEVER appear -- witnessed canyonFieldFrac 0). Fade in over 60..200m.
-    float elevGate = smoothstep(60.0, 200.0, h);
-    if (elevGate <= 0.0) return 0.0;
     // ONE FRACTAL (user 2026-06-02: 'canyon field shows two different resolutions, expected the same
     // fractal'). The FS used its OWN inline loop over worldPos/terrainR (= dir*(1+h/R), elevation-
     // SHIFTED off the VS sample) -> a different field/position/resolution than the VS carve. Now call
@@ -1292,11 +1305,9 @@ float canyonMask(vec3 worldPos, float h, float temp, float humid, float px, out
     float wid = clamp(px * 0.0006, 0.0, 0.03);                 // narrower than rivers
     float line = smoothstep(0.875 - wid, 0.94, ridge);        // ~river-density threshold so they appear
     depth = smoothstep(0.875, 0.95, ridge);                   // deeper toward the channel centre
-    float aridGate = (1.0 - smoothstep(0.40, 0.58, humid));   // DRY (deserts/steppe), opposite of rivers
-    float warmGate = smoothstep(0.38, 0.56, temp);            // warm arid plateaus
     // NO altFade (user: canyon field fading instead of integrated). wid grows with px -> >=1px AA at
     // every distance without vanishing; the canyon network is permanent, not a distance overlay.
-    return line * aridGate * warmGate * elevGate;
+    return line * step(0.0, h);
 }
 #endif   // biomeClassColor/riverMask/canyonMask: DEBUGVIEW-only (called solely from displayMode blocks) -- excluded from render FS cold-compile (FS-2, workflow w4y1bnrqc)
 
@@ -1339,7 +1350,8 @@ vec3 terrainAlbedoClimate(float h, float slope, float rockSlope, float temp, flo
     // must stop and become sand, which continues under the water'): below uBeachTopM the biome/
     // grass/snow color yields to shore sand (the same bcShore the underwater bed starts from, so the
     // material is continuous through the waterline). Steep coastal cliffs keep their rock.
-    float beachM = (1.0 - smoothstep(uBeachTopM * 0.6, uBeachTopM, h))
+    // WIDENED TRANSITION (2026-06-13): 0.6->0.3 softens the grass-sand boundary from 12m to 21m.
+    float beachM = (1.0 - smoothstep(uBeachTopM * 0.3, uBeachTopM, h))
                  * (1.0 - smoothstep(slopeRock.x, slopeRock.y, rockSlope));
     c = mix(c, bcShore, beachM);
     // INLAND WATER -- COLOUR GATED BY THE CARVE FIELD (alignment + no-fade fix, browser-2705/2699).
@@ -1381,7 +1393,7 @@ vec3 terrainAlbedoClimate(float h, float slope, float rockSlope, float temp, flo
     {
         highp vec3 od = normalize(worldPos);
         float ov = 0.0, oa = 0.0;
-        float fq = 150.0, am = 1.0;                 // octaves: ~42km / 8.5km / 1.7km features
+        float fq = 75.0, am = 1.0;                 // octaves: ~84km / 17km / 3.4km features (halved to match VS detailFbm)
         int fdOcts = (uFSDetailOcts > 0) ? uFSDetailOcts : 3;
         for (int o = 0; o < fdOcts; o++) {
             float wl = 40000000.0 / fq;             // feature wavelength (m) ~ 2*pi*R / fq
@@ -1540,7 +1552,7 @@ void main() {
     // (which made fine relief go missing). It is a continuous function of dir0 only -- adjacent fragments
     // get the linearly-interpolated VS value, so it is smooth by construction (no dFdx/dFdy, no fwidth).
     // uFlatNormal kept as a cheap escape hatch: pure sphere normal (uz) for A/B isolation.
-    vec3 n = (uFlatNormal > 0.5) ? uz : normalize(vNrm);
+    vec3 n = (uFlatNormal > 0.5) ? uz : normalize(mix(vNrm, uz, 0.05));
 
     // GPU-TIMER VS-ISOLATION: a cheap measurement frame short-circuits the whole per-pixel shade
     // here (uses vNrmPV + vWorld so the VS outputs are not dead-code-eliminated) -> the timed cheap
@@ -1662,21 +1674,50 @@ void main() {
         float dryHot = smoothstep(0.60, 0.85, 1.0 - climate.w) * smoothstep(0.42, 0.62, climate.z);
         // BEACH (user 2026-06-10 'the beaches should be sand'): the shore profile eases over the
         // first ~60m of elevation, so low gentle land near sea level splats sand regardless of climate.
-        float beach = (1.0 - smoothstep(10.0, 80.0, vH)) * (1.0 - smoothstep(0.22, 0.42, slope));
+        // NOISE-VARIED THRESHOLDS (2026-06-13): vTexWarp.x adds an irregular wavy line so the sand
+        // doesn't follow a strict elevation contour — reads as a natural beach, not a cut.
+        // SHARED biome-band warp pattern (user 2026-06-14: the SAME warping on snow/rock bands AND the
+        // beach->land crossover). 2-oct world-dir noise, 1/4 freq (~13km + ~5km waves). Computed once
+        // here; the snow/rock bandWarp below reuses warpN. highp dir for the lattice precision.
+        highp vec3 bwDir = normalize(vWorld);
+        float warpN = snoise3(bwDir * 3325.0) + 0.5 * snoise3(bwDir * 7750.0);   // ~ +/-1.5
+        // BEACH sand gate tied to uBeachTopM (so the sand TEXTURE scales with the wide beach, not a
+        // hardcoded 80m strip) + the shared warp on its LAND edge so the beach->grass line is irregular.
+        float beachW = warpN * uBeachTopM * 0.30;   // warp amplitude scales with the beach band height
+        float beach = (1.0 - smoothstep(uBeachTopM * 0.12 + beachW, uBeachTopM + beachW, vH))
+                    * (1.0 - smoothstep(0.15, 0.42, slope));
+        // SAND BLEED (2026-06-13): patchy sand spills above the main beach line, modulated by VS
+        // warp noise so the edge reads as wind-blown pockets, not a strict elevation cut. At peak it
+        // adds ~0.3 sand weight far above the beach, creating a natural dappled transition.
+        float sandBleed = max(0.0, vTexWarp.y) * 0.35 * max(0.0, 1.0 - smoothstep(30.0, 200.0, vH));
         // SAND REGIONS SUPPRESS ROCK (user 2026-06-10 'rock being used instead of sand'): in
         // deserts/dunes/beaches sand drapes moderate slopes; rock only wins on genuinely steep faces
         // there (gate shifted toward 0.5-0.7 inside sand regions instead of slopeRock 0.28-0.55).
-        float sandRegion = clamp(max(max(dryHot, beach), smoothstep(0.0, 0.25, vDuneCrest)), 0.0, 1.0);
+        float sandRegion = clamp(max(max(dryHot, max(beach, sandBleed)), smoothstep(0.0, 0.25, vDuneCrest)), 0.0, 1.0);
         // SPLAT ROCK GATE DECOUPLED from the macro slopeRock (user 2026-06-11 'a lot of grass turning
         // into rocky patches again'): the user-calibrated global soft blend slopeRock [-0.6,1] puts
         // ~37% ROCK LAYER weight on perfectly flat ground, and the displacement-sharpened top-2
         // crossfade then flips whole displacement blobs to the rock PHOTO on grassland. The macro
         // color blend keeps the calibrated tone; the rock TEXTURE layer needs real slope: floor the
         // splat gate at 0.18 so flat/gentle land splats grass, rock starts on genuine slopes.
-        float srLo = max(slopeRock.x, 0.18), srHi = max(slopeRock.y, srLo + 0.2);
-        float wRock = smoothstep(mix(srLo, 0.50, sandRegion), mix(srHi, 0.70, sandRegion), rockSlope);
-        float snowHi   = smoothstep(snowEdges.x, snowEdges.y, vH);
-        float snowCold = (1.0 - smoothstep(0.30, 0.75, climate.z)) * smoothstep(snowEdges.x * 0.5, snowEdges.x, vH);
+        // WIDENED TRANSITION (2026-06-13): srLo+0.2 -> srLo+0.4 so rock/grass and rock/sand/snow
+        // boundaries have a wider blend band — the slope gradient between materials is no longer
+        // a ~0.2-unit hard step but a ~0.4-unit gradual fade.
+        float srLo = max(slopeRock.x, 0.05), srHi = max(slopeRock.y, srLo + 0.35);   // 0.18->0.10->0.05: rock slope gate MORE SENSITIVE so even gentle slopes (~18deg+) pick up as rock (user 2026-06-14, repeated). Stays above truly-flat (rockSlope~0).
+        float wRockSlope = smoothstep(mix(srLo, 0.50, sandRegion), mix(srHi, 0.70, sandRegion), rockSlope);
+        // WARPED BIOME BAND EDGES (user 2026-06-14: the snow/rock lines were STRAIGHT horizontal contours
+        // viewed side-on; the vTexWarp domain warp was too low-freq (>1.8km waves = ~constant over one
+        // mountain) so it had no visible effect). Use a dedicated 2-octave WORLD-DIR noise at mountain
+        // scale (~1.3-3km waves) so EVERY elevation-keyed band wobbles +/-~700m vertically over a few km
+        // = irregular natural lines, not level contours. World-dir keyed (seam-safe). Applied to snow,
+        // the rock band, snowCold, and the beach below. highp dir (high-freq lattice needs the precision).
+        float bandWarp = warpN * 450.0;   // reuse the shared warpN (defined at the beach gate above); +/-~700m undulation
+        float snowHi   = smoothstep(snowEdges.x + bandWarp, snowEdges.y + bandWarp, vH);
+        // ROCK BAND leading up to the snow (user 2026-06-14): a rocky belt ~0.4-2.2km below the snow
+        // line so high mountains show rock between alpine grass and snow, not grass straight to snow.
+        float rockBand = smoothstep(snowEdges.x - 2200.0 + bandWarp, snowEdges.x - 400.0 + bandWarp, vH) * (1.0 - snowHi);
+        float wRock = max(wRockSlope, rockBand);
+        float snowCold = (1.0 - smoothstep(0.30, 0.75, climate.z)) * smoothstep(snowEdges.x * 0.5 + bandWarp, snowEdges.x + bandWarp, vH);
         // POLAR/ICE-BIOME SNOW (user 2026-06-10 'put the snow texture on the snow'): the ICE biome
         // whitens cold lowland (biomeColor gate 1-smoothstep(0.10,0.18,tempEff)) at ANY elevation, but
         // wSnow was elevation-gated only -- polar snowfields were splatting the GRASS layer. Match the
@@ -1686,13 +1727,14 @@ void main() {
                                         - 0.18 * (abs(lat2) / 1.5708) * uBiomeBandBias, 0.0, 1.0);
         float iceClimate = (1.0 - smoothstep(0.10, 0.20, tempEff2)) * step(0.0, vH);   // no snow layer on the seabed
         float wSnow = clamp(snowHi + 0.7 * snowCold + iceClimate, 0.0, 1.0) * (1.0 - 0.6 * wRock);
-        float wSand = sandRegion * (1.0 - wRock) * (1.0 - wSnow) * (1.0 - smoothstep(0.40, 0.60, slope));
+        float wSand = sandRegion * (1.0 - wRock) * (1.0 - wSnow) * (1.0 - smoothstep(0.30, 0.70, slope));
         float wGrass = max(1.0 - wRock - wSnow - wSand, 0.0);
         vec4 w4 = vec4(wGrass, wRock, wSand, wSnow);   // layers 0..3 = grass,rock,sand,snow
         // BEACH BAND + UNDERWATER in one mask (user 2026-06-11): sand owns everything below the
         // beach ceiling uBeachTopM -- grass/snow weight folds into sand continuously through h=0 to
         // the seabed, so no vegetation can ever splat at or below the waterline (structural).
-        float uwM = 1.0 - smoothstep(uBeachTopM * 0.6, uBeachTopM, vH);
+        // WIDENED (2026-06-13): 0.6->0.3 to match the macro beach transition, softer fade-out.
+        float uwM = 1.0 - smoothstep(uBeachTopM * 0.3, uBeachTopM, vH);
         w4.z += (w4.x + w4.w) * uwM; w4.x *= 1.0 - uwM; w4.w *= 1.0 - uwM;
         w4 /= (w4.x + w4.y + w4.z + w4.w + 1e-4);
         // top-2 layer pick: 4-way blending would cost 24 taps; the gates are spatially near-exclusive,
@@ -1734,7 +1776,10 @@ void main() {
             // displacement term 0.8 -> 0.3 (user 2026-06-11 'still see bowls of rock texture'):
             // 0.8 still let the displacement photo's bowl-shaped blobs flip whole patches to rock
             // inside the transition band; 0.3 only feathers the seam edge.
-            float bSharp = clamp((bAB * 2.0 - 1.0) * 3.0 + (albA.a - albB.a) * 0.3 + 0.5, 0.0, 1.0);
+            // SOFTENED (2026-06-13): transition sharpening reduced 3->1 so grass/rock/sand/snow
+            // boundaries hold a natural blend band instead of a hard die-cut line. The 1.0 slope
+            // still prefers the dominant layer but leaves a visible transition zone.
+            float bSharp = clamp((bAB * 2.0 - 1.0) * 1.0 + (albA.a - albB.a) * 0.3 + 0.5, 0.0, 1.0);
             texAlb = mix(albB, albA, bSharp);
             texNrm = mix(nrmB, nrmA, bSharp);
         }
@@ -1850,7 +1895,16 @@ void main() {
     // GENTLE-SLOPE RELIEF SHADING (user 2026-06-10 'even gentle slopes shaded so terrain elevation
     // is obvious'): exaggerate the tangential tilt of the LIT normal only -- the material gates keep
     // the true geometric n, so placement is unchanged; lighting contrast on rolling ground increases.
-    if (vH > -2.0 && uReliefShade > 1.0) nLit = normalize(uz + (nLit - uz) * uReliefShade);
+    if (vH > -2.0 && uReliefShade > 1.0) {
+      // Relief exaggeration of the LIT normal's tangential tilt. The old SCREEN-SPACE dFdx(vH) term was
+      // REMOVED (user 2026-06-14 'jagged normals, still there on the normals view'): dFdx/dFdy of the
+      // INTERPOLATED vH varying is CONSTANT PER TRIANGLE and discontinuous at every triangle edge =
+      // hard facets baked straight into the lit normal -- the jaggedness root, not the vertex normal.
+      // It was a workaround for when vNrm ~= uz on gentle ground; the central-difference vNrm now
+      // captures gentle slopes (real gradient), so (nLit-uz) is non-zero on real slopes and the plain
+      // exaggeration is legible without the faceted screen-space hack.
+      nLit = normalize(uz + (nLit - uz) * uReliefShade);
+    }
     // photo-texture detail normal at its calibrated amplitude, OUTSIDE the relief exaggeration.
     // ADDED in world space (the old `- ux*dn.x - uy*dn.y` subtracted an already-negated Sobel
     // normal in a frame the triplanar RG was never expressed in -- the fundamental both-at-once

package/src/terrain-gen-controls.js

@@ -26,7 +26,7 @@ const DEFAULTS = {
     fsNormal: 0,           // window.__fsNormal (cross-dFdx FS normal, diagnostic, default off)
   },
   lod: {
-    splitFactor: null,     // window.__splitFactor (null = orchestrator altitude ramp)
+    splitFactor: 0.28,    // window.__splitFactor (null = orchestrator altitude ramp). 0.4->0.28 (user 2026-06-14: ~600 quads at the deck)
   },
   geometry: {
     elevEdgeInset: 0.5,    // window.__elevEdgeInset (mesh-edge elevation sample inset; gl-render)