{"version":3,"sources":["geology.mjs"],"sourcesContent":["// GEOLOGY (WG-11): WORLD GENERATION VERSION 4'S GROUND, SIMULATED.\n//\n// The owner's call (Sep 29): rewrite the terrain from scratch, keep the biomes, and make it computationally efficient,\n// attractive and physically accurate. So a world's ground is not drawn from noise and placed landforms any more; it is\n// the outcome of a short history, run on a coarse grid of the cube's surface (six faces of N x N nodes, one connected\n// grid across the edges, N at most 32):\n//   * THE CRUST starts as a fractal roughness whose height falls with gravity (relief ~ 1/g, and g grows with size):\n//     a small world is rugged, a big one smooth.\n//   * HEAT, from the world's size, age and tides, drives plates (ranges where they meet, rifts where they part) and\n//     hotspots (broad shield volcanoes); a molten world floods its basins with lava plains.\n//   * IMPACTS arrive through the world's history by a size law (many small, few large); air stops the small ones, and\n//     later history wears the old ones down.\n//   * EROSION: rivers cut in proportion to the square root of the area draining through them and the slope (the\n//     stream-power law, solved implicitly in linear time per pass in drainage order), slopes relax by diffusion, and\n//     nothing stands steeper than its talus. Liquid worlds erode most, dry worlds with air a little, airless ones not\n//     at all. Water drains to the seas where there are seas, and closed basins are recorded (lakes, salt pans).\n// The result is sampled at every column by interpolation, which is why version 4 is gentle by design: a slope the\n// grid holds to talus stays under a kube a column when it is spread over the columns between two nodes.\n//\n// EXACT ARITHMETIC ONLY. This file is copied byte for byte to Cloud Functions and the zone server (generate-version-\n// hash.js checks the twins), and all three must build the same world: addition, multiplication, division, square\n// root and floor only, integer hashes for chance, a fixed order everywhere with ties broken by index. No power, exp,\n// log, sine or random call.\nimport { starClassOf, placeOf, rotationOf } from './climate.mjs';\n\n// ---- CHANCE: a seed from a name (FNV-1a) and a small exact generator (mulberry32) ----\nfunction seedOf(s) {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 0x01000193); }\n    return h >>> 0;\n}\nfunction rngOf(s) {\n    let a = seedOf(s);\n    return () => {\n        a = (a + 0x6D2B79F5) | 0;\n        let t = Math.imul(a ^ (a >>> 15), 1 | a);\n        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n    };\n}\nconst clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);\nconst smooth = (x) => { const t = clamp01(x); return t * t * (3 - 2 * t); };\n\n// ---- THE GRID: six faces of N x N nodes, one surface ----\n// A node's position in doubled units on its face: T[ax] = +-N on its own axis, the other two odd numbers inside\n// (-N, N). A step off a face folds onto the next face over the edge: the coordinate that ran over becomes that face's\n// axis (+-N), and the old axis steps in by one (+-(N - 1)), so the two nodes across an edge are neighbours at one step,\n// as two on a face are. Diagonals fold the same way; the one diagonal round a corner (both coordinates over) has no\n// node and is left out. Face order and tangents are the height table's (transient-shape.js rawAt): face fi = 2 * axis\n// + (negative ? 1 : 0), u along (axis + 1) % 3, v along (axis + 2) % 3.\nconst DIRS = [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]];\nconst GRIDS = new Map();\nfunction gridOf(N) {\n    const hit = GRIDS.get(N);\n    if (hit) return hit;\n    const NN = N * N, n = 6 * NN;\n    const cx = new Float64Array(n), cy = new Float64Array(n), cz = new Float64Array(n);\n    const dx = new Float64Array(n), dy = new Float64Array(n), dz = new Float64Array(n);   // the unit direction\n    const nb = new Int32Array(n * 8).fill(-1), nd = new Float64Array(n * 8);\n    const indexOf = (T) => {\n        const ax = (T[0] === N || T[0] === -N) ? 0 : (T[1] === N || T[1] === -N) ? 1 : 2;\n        const ua = (ax + 1) % 3, va = (ax + 2) % 3;\n        return (ax * 2 + (T[ax] < 0 ? 1 : 0)) * NN + ((T[ua] + N - 1) / 2) * N + (T[va] + N - 1) / 2;\n    };\n    for (let f = 0; f < 6; f++) {\n        const ax = f >> 1, s = (f & 1) ? -1 : 1, ua = (ax + 1) % 3, va = (ax + 2) % 3;\n        for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) {\n            const k = f * NN + i * N + j, T = [0, 0, 0];\n            T[ax] = s * N; T[ua] = 2 * i + 1 - N; T[va] = 2 * j + 1 - N;\n            const c = [T[0] / N, T[1] / N, T[2] / N];\n            cx[k] = c[0]; cy[k] = c[1]; cz[k] = c[2];\n            const l = Math.sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);\n            dx[k] = c[0] / l; dy[k] = c[1] / l; dz[k] = c[2] / l;\n            for (let d = 0; d < 8; d++) {\n                const U = [T[0], T[1], T[2]];\n                U[ua] += 2 * DIRS[d][0]; U[va] += 2 * DIRS[d][1];\n                const overU = U[ua] > N - 1 || U[ua] < 1 - N, overV = U[va] > N - 1 || U[va] < 1 - N;\n                if (overU && overV) continue;\n                if (overU || overV) {\n                    const t = overU ? ua : va;\n                    U[t] = U[t] > 0 ? N : -N;\n                    U[ax] = s * (N - 1);\n                }\n                nb[k * 8 + d] = indexOf(U);\n                nd[k * 8 + d] = d < 4 ? 1 : Math.SQRT2;\n            }\n        }\n    }\n    const g = { N, NN, n, cx, cy, cz, dx, dy, dz, nb, nd };\n    GRIDS.set(N, g);\n    return g;\n}\n\n// ---- A PRIORITY QUEUE of nodes by level, ties broken by index, so every side pops them in one order ----\nfunction makeHeap(n) {\n    const node = new Int32Array(n), key = new Float64Array(n);\n    let size = 0;\n    const less = (a, b) => key[a] < key[b] || (key[a] === key[b] && node[a] < node[b]);\n    const swap = (a, b) => { const tn = node[a]; node[a] = node[b]; node[b] = tn; const tk = key[a]; key[a] = key[b]; key[b] = tk; };\n    return {\n        get size() { return size; },\n        clear() { size = 0; },\n        push(v, k) {\n            let i = size++; node[i] = v; key[i] = k;\n            while (i > 0) { const p = (i - 1) >> 1; if (!less(i, p)) break; swap(i, p); i = p; }\n        },\n        pop() {\n            const top = node[0];\n            size--;\n            if (size > 0) {\n                node[0] = node[size]; key[0] = key[size];\n                let i = 0;\n                for (;;) {\n                    const l = 2 * i + 1, r = l + 1;\n                    let m = i;\n                    if (l < size && less(l, m)) m = l;\n                    if (r < size && less(r, m)) m = r;\n                    if (m === i) break;\n                    swap(i, m); i = m;\n                }\n            }\n            return top;\n        },\n    };\n}\n\n// ---- A WORLD'S AGE, from its system and star: young stars keep young worlds ----\nconst AGE_GYR = { O: [0.01, 0.05], B: [0.05, 0.3], A: [0.3, 1.5], F: [1, 4], G: [2, 9], K: [3, 11], M: [3, 12] };\nexport function worldAgeGyr(addr, star) {\n    const p = String(addr || '').split('.'), range = AGE_GYR[starClassOf(star)] || [5, 12];\n    const r = rngOf(p[0] + '.' + p[1] + '#age4');\n    return range[0] + (range[1] - range[0]) * r();\n}\n\n// The quantile q of a set of heights, to a thousandth of their range: counted into 1,024 bins between the lowest and\n// the highest (linear, and the same arithmetic everywhere), then read at the bin where the count passes q.\nconst QBINS = 1024, qCount = new Int32Array(QBINS);\nfunction quantile(h, q) {\n    let lo = h[0], hi = h[0];\n    for (let k = 1; k < h.length; k++) { const v = h[k]; if (v < lo) lo = v; else if (v > hi) hi = v; }\n    if (hi <= lo) return lo;\n    const sc = QBINS / (hi - lo);\n    qCount.fill(0);\n    for (let k = 0; k < h.length; k++) { let b = Math.floor((h[k] - lo) * sc); if (b >= QBINS) b = QBINS - 1; qCount[b]++; }\n    const want = q * h.length;\n    let acc = 0;\n    for (let b = 0; b < QBINS; b++) { acc += qCount[b]; if (acc >= want) return lo + (b + 1) / sc; }\n    return hi;\n}\n\n// ---- THE SIMULATION ----\n// `R` the world's radius in kubes, `world` its facts ({ addr, star, tempC, pressureMbar, airless, sea: { kind, name } }\n// or null), `noise` the world's own value noise (transient-shape.js voxDraws), `seaShare` the share of the surface its\n// sea will cover (0 for none), decided by the generator before this runs so that the rivers drain to that sea, and\n// `oceanShare` the share an OCEAN of any kind (liquid or ice) covers, 0 for lakes or none: it splits the crust into\n// continents and ocean floor.\nexport function geologyOf(addr, R, world, noise, seaShare, oceanShare) {\n    const refR = Math.max(1, R - 2), cols = 2 * refR;\n    const N = cols < 12 ? 12 : cols > 32 ? 32 : cols;\n    const G = gridOf(N), { n, nb, nd } = G;\n    const L = cols / N;                                        // kubes between neighbouring nodes\n    const rnd = rngOf(String(addr || '') + '#geology4');\n\n    // THE WORLD'S FACTS\n    const cls = starClassOf(world && world.star), place = placeOf(addr);\n    const age = worldAgeGyr(addr, world && world.star);\n    const air = !world || world.airless ? 0 : (+world.pressureMbar || 0);\n    const tempC = world ? (+world.tempC || 0) : 0;\n    const seaKind = world && world.sea ? world.sea.kind : null;\n    const liquid = seaKind === 'liquid', iced = seaKind === 'ice', molten = seaKind === 'lava' || tempC >= 700;\n    const locked = !!(world && world.addr && rotationOf(world).regime === 'locked');\n    // GRAVITY SETS THE RELIEF. A crust holds features up to a height that falls as 1/g, and g grows with size; the\n    // game's worlds (radius 12 to 48) are all small bodies, so the law is softened to the fourth root, which still makes\n    // a small world's relief half its radius and a big one's a tenth.\n    const relief = 16 / Math.sqrt(Math.sqrt(R));\n    // HEAT: kept by size (a body under radius 14 is long cold), added by tides (moons; worlds locked to their star),\n    // spent with age; a molten world is all heat.\n    let Q = clamp01((R - 14) / 26) + (place.moon ? 0.35 * rnd() : 0) + (locked ? 0.15 : 0) + (age < 1 ? 0.3 : 0) + (molten ? 0.5 : 0);\n    const ageFade = 1.3 - age / 12;\n    Q *= ageFade < 0.4 ? 0.4 : ageFade > 1.3 ? 1.3 : ageFade;\n    // What wears the ground: liquid most (rivers), ice next (glaciers), air a little (wind and weathering), nothing on an\n    // airless world but the slow settling of its slopes.\n    const Kf = liquid ? 0.012 : iced ? 0.006 : air > 50 ? 0.0015 : 0;\n    const Kd = liquid ? 0.06 : iced ? 0.08 : air > 50 ? 0.035 : 0.01;\n    const TALUS = 0.85;                                        // the steepest a slope stands: kubes per kube\n\n    // ---- THE CRUST, before any history ----\n    const o = () => rnd() * 1000;\n    const O1 = [o(), o(), o()], O2 = [o(), o(), o()], O3 = [o(), o(), o()];\n    const h = new Float64Array(n);\n    for (let k = 0; k < n; k++) {\n        const x = G.cx[k], y = G.cy[k], z = G.cz[k];\n        h[k] = relief * (0.6 * noise(x * 1.1 + O1[0], y * 1.1 + O1[1], z * 1.1 + O1[2])\n                       + 0.4 * noise(x * 2.6 + O2[0], y * 2.6 + O2[1], z * 2.6 + O2[2]));\n    }\n\n    // ---- HEAT: plates and hotspots, as uplift over the world's history ----\n    const U = new Float64Array(n), vol = new Float64Array(n);\n    // As many plates as the world has room for: a Ø24 world three at most, a Ø96 world eight.\n    const plateRoom = 2 + Math.floor(R / 8), plateWant = 3 + Math.floor(Q * 4);\n    const nPlates = Q > 0.35 ? (plateWant < plateRoom ? plateWant : plateRoom) : 0;\n    const plateOf = new Int32Array(n);\n    const sd = [], sv = [];\n    if (nPlates) {\n        for (let p = 0; p < nPlates; p++) {\n            let a = rnd() * 2 - 1, b = rnd() * 2 - 1, c = rnd() * 2 - 1;\n            const l = Math.sqrt(a * a + b * b + c * c) || 1; a /= l; b /= l; c /= l;\n            sd.push(a, b, c);\n            // A motion along the surface: a random vector less its part along the seed's direction.\n            let va = rnd() * 2 - 1, vb = rnd() * 2 - 1, vc = rnd() * 2 - 1;\n            const dp = va * a + vb * b + vc * c; va -= dp * a; vb -= dp * b; vc -= dp * c;\n            sv.push(va, vb, vc);\n        }\n        // Nearest seed, from a WARPED direction: plates meet along winding lines, not great circles, so a range bends\n        // and a coast that follows a plate's edge is not ruled straight.\n        const OW = [o(), o(), o(), o(), o(), o(), o(), o(), o()], WARP = 0.75;\n        const warp = (x, y, z, a, b, c) => noise(x * 1.5 + a, y * 1.5 + b, z * 1.5 + c);\n        for (let k = 0; k < n; k++) {\n            const x = G.dx[k], y = G.dy[k], z = G.dz[k];\n            const wx = x + WARP * warp(x, y, z, OW[0], OW[1], OW[2]);\n            const wy = y + WARP * warp(x, y, z, OW[3], OW[4], OW[5]);\n            const wz = z + WARP * warp(x, y, z, OW[6], OW[7], OW[8]);\n            let best = 0, bd = -1e9;\n            for (let p = 0; p < nPlates; p++) {\n                const d = wx * sd[3 * p] + wy * sd[3 * p + 1] + wz * sd[3 * p + 2];\n                if (d > bd) { bd = d; best = p; }\n            }\n            plateOf[k] = best;\n        }\n    }\n\n    // ---- CONTINENTS AND OCEAN FLOOR (round 2, the owner's pick): two kinds of crust. Light continental crust rides\n    // high and dense ocean floor sits deep (isostasy), so a sea has a floor well under its surface, and its edges drown\n    // the continents' margins (shelves) before they fall away. The ocean floor is a little less than the sea's share,\n    // so the rest of the sea is shelf. A plate is all one kind; a world without plates gets a few broad basins from a\n    // slow field instead (a crustal dichotomy, as Mars has). A dry world with plates keeps a milder split: basins for\n    // its dust and salt, uplands for its rock. ----\n    const cont = new Float64Array(n).fill(1), plateOcean = new Uint8Array(nPlates > 0 ? nPlates : 1);\n    const floorShare = oceanShare > 0 ? oceanShare * 0.85 : nPlates && air > 0 ? 0.3 : 0;\n    const crustStep = oceanShare > 0 ? (relief * 1.1 > 4 ? relief * 1.1 : 4) : relief * 0.5;\n    if (floorShare > 0) {\n        if (nPlates) {\n            // Plates go to the ocean floor in a drawn order until it holds its share (the last one may overshoot).\n            const area = new Float64Array(nPlates);\n            for (let k = 0; k < n; k++) area[plateOf[k]]++;\n            const ord = [];\n            for (let p = 0; p < nPlates; p++) ord.push([rnd(), p]);\n            ord.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n            let got = 0;\n            for (const [, p] of ord) { if (got >= floorShare * n) break; if (got + area[p] * 0.5 <= floorShare * n || got === 0) { plateOcean[p] = 1; got += area[p]; } }\n            for (let k = 0; k < n; k++) cont[k] = plateOcean[plateOf[k]] ? 0 : 1;\n        } else {\n            const OB = [o(), o(), o()], f = new Float64Array(n);\n            for (let k = 0; k < n; k++) {\n                const x = G.dx[k], y = G.dy[k], z = G.dz[k];\n                f[k] = noise(x * 1.3 + OB[0], y * 1.3 + OB[1], z * 1.3 + OB[2]) + 0.4 * noise(x * 2.7 + OB[1], y * 2.7 + OB[2], z * 2.7 + OB[0]);\n            }\n            const thr = quantile(f, floorShare);\n            for (let k = 0; k < n; k++) cont[k] = f[k] > thr ? 1 : 0;\n        }\n        // The margins: the step spread over a few nodes, the continental slope.\n        for (let pass = 0; pass < 3; pass++) {\n            const next = new Float64Array(n);\n            for (let k = 0; k < n; k++) {\n                let sum = cont[k] * 2, w = 2;\n                for (let d = 0; d < 4; d++) { const j = nb[k * 8 + d]; if (j >= 0) { sum += cont[j]; w++; } }\n                next[k] = sum / w;\n            }\n            cont.set(next);\n        }\n        // …and ragged: on the slope only (where the crust is neither kind), a finer field of its own, so the shelf edge\n        // and the coast it makes have bays and headlands instead of the smooth line of a blurred boundary.\n        const OR = [o(), o(), o()];\n        for (let k = 0; k < n; k++) {\n            const x = G.dx[k], y = G.dy[k], z = G.dz[k], m = 1 - (cont[k] * 2 - 1) * (cont[k] * 2 - 1);\n            const rag = m > 0 ? m * (noise(x * 5.3 + OR[0], y * 5.3 + OR[1], z * 5.3 + OR[2]) + 0.5 * noise(x * 11 + OR[1], y * 11 + OR[2], z * 11 + OR[0])) : 0;\n            h[k] += (cont[k] - 0.5 + 0.45 * rag) * crustStep;\n        }\n    }\n    // ---- WHERE PLATES MEET (round 2, the owner's pick: ranges with structure) ----\n    // Each node finds the nearest edge of its own plate (a flood from the boundary, inside the plate), and how the two\n    // plates meet there: closing (their motions converge across it) or parting. Its ground takes the shape of that kind\n    // of boundary, measured from it:\n    //   two continents closing   a broad high range, a plateau falling to foothills (the Himalaya);\n    //   ocean under continent    on the continent a narrower range set back from the coast (the Andes), on the ocean\n    //                            a deep trench along the boundary;\n    //   ocean against ocean      an island arc on one side (the overriding plate), a trench on the other;\n    //   continents parting       a rift valley with raised shoulders (East Africa);\n    //   ocean floor parting      a broad ridge on the sea floor.\n    // Along a boundary the height rises and falls (peaks and passes), from a field read at the boundary node, and the\n    // strength of the meeting (how fast the plates close) scales it all. `rng` keeps how mountainous each node is, for\n    // the spurs and valleys cut at column scale (transient-shape.js relief).\n    const rng = new Float64Array(n);\n    if (nPlates) {\n        const conv = new Float64Array(n), other = new Int32Array(n).fill(-1);\n        for (let k = 0; k < n; k++) for (let d = 0; d < 4; d++) {\n            const j = nb[k * 8 + d];\n            if (j < 0 || plateOf[j] === plateOf[k]) continue;\n            const pk = plateOf[k], pj = plateOf[j];\n            let bx = G.dx[j] - G.dx[k], by = G.dy[j] - G.dy[k], bz = G.dz[j] - G.dz[k];\n            const bl = Math.sqrt(bx * bx + by * by + bz * bz) || 1; bx /= bl; by /= bl; bz /= bl;\n            const c = (sv[3 * pk] - sv[3 * pj]) * bx + (sv[3 * pk + 1] - sv[3 * pj + 1]) * by + (sv[3 * pk + 2] - sv[3 * pj + 2]) * bz;\n            if (other[k] < 0 || (c < 0 ? -c : c) > (conv[k] < 0 ? -conv[k] : conv[k])) { conv[k] = c; other[k] = pj; }\n        }\n        // The flood: distance in node steps to the plate's own edge, and which edge node it is.\n        const dist = new Float64Array(n).fill(1e9), src = new Int32Array(n).fill(-1), fh = makeHeap(n);\n        for (let k = 0; k < n; k++) if (other[k] >= 0) { dist[k] = 0; src[k] = k; fh.push(k, 0); }\n        while (fh.size) {\n            const k = fh.pop();\n            for (let d = 0; d < 8; d++) {\n                const j = nb[k * 8 + d];\n                if (j < 0 || plateOf[j] !== plateOf[k]) continue;\n                const nd2 = dist[k] + nd[k * 8 + d];\n                if (nd2 < dist[j]) { dist[j] = nd2; src[j] = src[k]; fh.push(j, nd2); }\n            }\n        }\n        const OV = [o(), o(), o()], WN = N / 32;\n        const bump = (t, c, w) => { const q = (t - c) / w; return q <= -1 || q >= 1 ? 0 : (1 - q * q) * (1 - q * q); };\n        const amp0 = (0.5 + Q) * relief;\n        for (let k = 0; k < n; k++) {\n            const b = src[k];\n            if (b < 0) continue;\n            const pk = plateOf[k], pj = other[b], c0 = conv[b], cn = c0 > 1.5 ? 1.5 : c0 < -1.5 ? -1.5 : c0;\n            const meOcean = !!plateOcean[pk], youOcean = !!plateOcean[pj], d = dist[k];\n            // peaks and passes along the boundary\n            const bx = G.dx[b], by = G.dy[b], bz = G.dz[b];\n            const vary = 0.45 + 1.1 * smooth(noise(bx * 3.3 + OV[0], by * 3.3 + OV[1], bz * 3.3 + OV[2]) + 0.5);\n            let v = 0, mtn = 0;\n            if (cn > 0.05) {\n                const a = cn * amp0 * vary;\n                if (!meOcean && !youOcean) {                       // two continents: a broad range and its foothills\n                    const W = 1.2 + 2.9 * WN, t = d / W;\n                    v = a * 1.4 * ((1 - smooth((t - 0.25) / 0.9)) + 0.22 * (1 - smooth((t - 1.1) / 0.9)));\n                    mtn = v;\n                } else if (!meOcean) {                             // continent over ocean: the range set back inland\n                    const W = 0.9 + 2.0 * WN;\n                    v = a * 1.2 * (bump(d / W, 0.55, 0.75) + 0.2 * bump(d / W, 1.3, 0.7));\n                    mtn = v;\n                } else if (!youOcean) {                            // ocean under a continent: the trench\n                    const W = 0.6 + 0.8 * WN;\n                    v = -a * 1.1 * (1 - smooth(d / W));\n                } else if (pk > pj) {                              // ocean over ocean: the island arc\n                    const W = 0.6 + 1.3 * WN;\n                    v = a * 1.1 * bump(d / W, 0.6, 0.6);\n                    mtn = v;\n                } else {                                           // …and its trench\n                    const W = 0.6 + 0.8 * WN;\n                    v = -a * 0.9 * (1 - smooth(d / W));\n                }\n            } else if (cn < -0.05) {\n                const a = -cn * amp0 * vary;\n                if (!meOcean && !youOcean) {                       // a rift: a valley with raised shoulders\n                    const W = 0.6 + 1.0 * WN, t = d / W;\n                    v = a * (-0.9 * (1 - smooth(t)) + 0.35 * bump(t, 1.4, 0.6));\n                } else if (meOcean && youOcean) {                  // a spreading ridge on the sea floor\n                    const W = 1.0 + 2.2 * WN;\n                    v = a * 0.6 * (1 - smooth(d / W));\n                }\n            }\n            U[k] += v;\n            rng[k] = mtn > 0 ? mtn : 0;\n        }\n        let rMax = 0;\n        for (let k = 0; k < n; k++) if (rng[k] > rMax) rMax = rng[k];\n        const rs = relief * 1.5 > rMax ? relief * 1.5 : rMax;\n        for (let k = 0; k < n; k++) rng[k] = rng[k] / rs;\n    }\n    const nHot = Math.floor(Q * 2.5 * rnd() + (molten ? 2 : 0) + (Q > 0.6 ? 1 : 0));\n    const hot = [];\n    for (let p = 0; p < nHot; p++) {\n        let a = rnd() * 2 - 1, b = rnd() * 2 - 1, c = rnd() * 2 - 1;\n        const l = Math.sqrt(a * a + b * b + c * c) || 1;\n        const rad = 0.18 + 0.2 * rnd();                          // on the unit sphere of directions\n        hot.push(a / l, b / l, c / l, rad);\n        for (let k = 0; k < n; k++) {\n            const d = 1 - (G.dx[k] * a + G.dy[k] * b + G.dz[k] * c) / l;   // 1 - cos: about half the angle squared\n            const q = d / (rad * rad * 0.5);\n            if (q >= 1) continue;\n            const w = (1 - q) * (1 - q);\n            U[k] += w * relief * 0.8 * (0.5 + Q);\n            if (w > vol[k]) vol[k] = w;\n        }\n    }\n\n    // ---- IMPACTS, by a size law, through the world's history (round 2, the owner's pick: craters you can see) ----\n    // Candidates arrive at radius R_VIS / sqrt(u), the power law N(>r) ~ r^-2, as many as saturate an old airless\n    // surface (every part of it struck, craters on craters), in proportion to the world's age. Air stops those under a\n    // radius that grows with its pressure (a bar leaves only the big ones). Each keeps its arrival time t (0 the world's\n    // birth, 1 now): what wears the world down softens the old ones (rims first), and lava plains bury those older\n    // than the plains. They are all drawn on the columns themselves (cratersAt), where a rim a kube high still reads.\n    const R_VIS = 2;                                           // the smallest crater that reads as one in whole kubes\n    const rMinAir = 0.8 + air / 160;\n    const rMaxC = R * 0.45;\n    const perArea = 0.52 - 0.34 * (R - 12) / 36;               // the saturated count per R^2, falling a little with size\n    const nCand = Math.floor(R * R * perArea * (age / 12) * (0.8 + 0.4 * rnd()));\n    const craters = [];                                        // [x, y, z, r, t] per crater, unit direction\n    for (let c = 0; c < nCand; c++) {\n        const u = rnd(), r = R_VIS / Math.sqrt(u < 1e-6 ? 1e-6 : u);\n        let a = rnd() * 2 - 1, b = rnd() * 2 - 1, cc = rnd() * 2 - 1;\n        const t = rnd();\n        if (r < rMinAir || r > rMaxC) continue;\n        const l = Math.sqrt(a * a + b * b + cc * cc) || 1;\n        craters.push(a / l, b / l, cc / l, r, t);\n    }\n    // What wears a crater down, per billion years: next to nothing without air, more with thicker air, most with a\n    // liquid sea (rain and rivers) or ice.\n    const wear = air === 0 ? 0 : (0.05 + (air > 1100 ? 0.55 : air / 2000)) + (liquid ? 0.5 : iced ? 0.25 : 0);\n    // A crater's profile in kubes at distance d from its middle, `keep` how much of it is left: a bowl a sixth as deep as\n    // it is wide, as a crater settles (a big one's floor flat, with a central peak), a low raised rim, ejecta beyond it.\n    const craterAt = (d, r, keep) => {\n        const q = d / r;\n        if (q >= 1.7) return 0;\n        const dMax = relief, depth = (0.3 * r > dMax ? dMax : 0.3 * r) * keep;   // a bowl a sixth as deep as it is wide:\n        const rim = (0.09 * r > 0.5 ? 0.09 * r : 0.5) * keep * keep;              // walls a kube a column, rims low\n        if (q < 1) {\n            let v;\n            if (r > 6) {                                       // complex: a flat floor, then the wall\n                const w = q < 0.45 ? 0 : (q - 0.45) / 0.55;\n                v = -depth * (1 - w * w) + rim * q * q * q * q;\n                if (r > 7 && q < 0.2) { const pk = 1 - q / 0.2; v += depth * 0.5 * pk * pk; }\n            } else v = -depth * (1 - q * q) + rim * q * q * q * q;\n            return v;\n        }\n        const e = (1.7 - q) / 0.7;\n        return rim * e * e;\n    };\n\n    // ---- EROSION, in epochs ----\n    const EPOCHS = 6, PASSES = 5;\n    const rcv = new Int32Array(n), rdist = new Float64Array(n), order = new Int32Array(n), A = new Float64Array(n), fill = new Float64Array(n);\n    const heap = makeHeap(n), seen = new Uint8Array(n);\n    let seaLevel = -1e9;\n    // Route every node to an outlet by priority flood: the seas (or the lowest node) first, then outward by level, so\n    // each node's receiver is popped before it and a closed basin fills to its spill point (`fill` over `h` there).\n    function route() {\n        heap.clear(); seen.fill(0);\n        let m = 0;\n        let any = false;\n        for (let k = 0; k < n; k++) if (seaShare > 0 && h[k] <= seaLevel) { heap.push(k, h[k]); seen[k] = 1; rcv[k] = -1; fill[k] = h[k]; any = true; }\n        if (!any) {\n            let lo = 0;\n            for (let k = 1; k < n; k++) if (h[k] < h[lo]) lo = k;\n            heap.push(lo, h[lo]); seen[lo] = 1; rcv[lo] = -1; fill[lo] = h[lo];\n        }\n        while (heap.size) {\n            const k = heap.pop(), lv = fill[k];\n            order[m++] = k;\n            for (let d = 0; d < 8; d++) {\n                const j = nb[k * 8 + d];\n                if (j < 0 || seen[j]) continue;\n                seen[j] = 1; rcv[j] = k; rdist[j] = nd[k * 8 + d];\n                const f = h[j] > lv + 1e-7 ? h[j] : lv + 1e-7;\n                fill[j] = f;\n                heap.push(j, f);\n            }\n        }\n        // Drainage area, in nodes: every node sends what reaches it on to its receiver, highest first.\n        A.fill(1);\n        for (let i = n - 1; i > 0; i--) { const k = order[i], r = rcv[k]; if (r >= 0) A[r] += A[k]; }\n    }\n    const lap = new Float64Array(n);\n    // Diffusion over the four neighbours (explicit, and stable at these rates).\n    function diffuse() {\n        for (let k = 0; k < n; k++) {\n            const b = k * 8;\n            lap[k] = (h[nb[b]] + h[nb[b + 1]] + h[nb[b + 2]] + h[nb[b + 3]]) * 0.25 - h[k];\n        }\n        for (let k = 0; k < n; k++) h[k] += Kd * lap[k];\n    }\n    // Talus: no step steeper than it, the excess shared between the two nodes.\n    function talus() {\n        for (let k = 0; k < n; k++) for (let d = 0; d < 8; d++) {\n            const j = nb[k * 8 + d];\n            if (j < 0) continue;\n            const lim = TALUS * L * nd[k * 8 + d], ex = h[k] - h[j] - lim;\n            if (ex > 0) { h[k] -= ex * 0.5; h[j] += ex * 0.5; }\n        }\n    }\n    // The drainage is routed once an epoch and its receivers kept for the epoch's passes (the land moves little in a\n    // pass), which is most of what keeps this inside its budget.\n    for (let e = 0; e < EPOCHS; e++) {\n        if (seaShare > 0) seaLevel = quantile(h, seaShare);\n        if (Kf > 0) route();\n        for (let p = 0; p < PASSES; p++) {\n            const du = 1 / (EPOCHS * PASSES);\n            for (let k = 0; k < n; k++) h[k] += U[k] * du;\n            if (Kf > 0) {\n                // The stream-power law, implicit: each node in drainage order, against its receiver's new height.\n                for (let i = 0; i < n; i++) {\n                    const k = order[i], r = rcv[k];\n                    if (r < 0) continue;\n                    if (fill[k] > h[k] + 1e-6) { const f = fill[k] - h[k]; h[k] += f < 0.05 ? f : 0.05; continue; }   // a lake fills with sediment\n                    const F = Kf * Math.sqrt(A[k]) / rdist[k];           // K A^0.5 dt / dx, with A and dx in node units\n                    h[k] = (h[k] + F * h[r]) / (1 + F);\n                }\n            }\n            diffuse();\n        }\n        talus();\n    }\n    // A molten world floods its low ground with lava plains toward the level of its lowest third, once: they keep some\n    // of the ground's relief, so the lava lakes (transient-shape.js surfaceSea) can find a level that holds their share\n    // instead of choosing between a plain drowned whole and a puddle.\n    if (molten) {\n        const lv = quantile(h, 0.35);\n        for (let k = 0; k < n; k++) if (h[k] < lv) { h[k] += (lv - h[k]) * 0.55; if (vol[k] < 0.5) vol[k] = 0.5; }\n    }\n    for (let p = 0; p < 3; p++) { diffuse(); talus(); }\n    // The ground within the generator's bounds first, then the final drainage over the ground as it will stand, so a\n    // lake's level is read from the heights the columns get.\n    const up = Math.max(3, Math.round(R * 0.36)), down = Math.max(4, Math.round(R * 0.28));   // ranges stand to 0.36 R\n    for (let k = 0; k < n; k++) h[k] = h[k] > up - 1 ? up - 1 : h[k] < 1 - down ? 1 - down : h[k];\n    if (seaShare > 0) seaLevel = quantile(h, seaShare);\n    route();                                                   // the final drainage: rivers and closed basins\n\n    // ---- WHAT THE GROUND IS MADE OF, and what it is ----\n    // cover: loose ground (1: sediment, soil or regolith) or bare rock (0). Airless worlds are regolith over everything\n    // but their steep walls; elsewhere sediment lies where water gathered (closed basins, and the flat floors big rivers\n    // drain through) and rock shows on the heights and steep slopes.\n    const cover = new Float64Array(n), low = new Float64Array(n), lake = new Float64Array(n), river = new Float64Array(n);\n    const p40 = quantile(h, 0.4), p75 = quantile(h, 0.75), span = p75 - p40 > 0.5 ? p75 - p40 : 0.5;\n    for (let k = 0; k < n; k++) {\n        let slope = 0;\n        for (let d = 0; d < 8; d++) {\n            const j = nb[k * 8 + d];\n            if (j < 0) continue;\n            const s = (h[k] > h[j] ? h[k] - h[j] : h[j] - h[k]) / (nd[k * 8 + d] * L);\n            if (s > slope) slope = s;\n        }\n        const flat = 1 - smooth(slope / 0.55), lw = 1 - smooth((h[k] - p40) / span);\n        low[k] = lw;\n        lake[k] = fill[k] - h[k] > 0.25 ? fill[k] - h[k] : 0;\n        river[k] = Kf > 0 ? smooth((Math.sqrt(A[k]) - 4) / 10) : 0;\n        cover[k] = air === 0 ? 1 - smooth(slope / 0.65)\n            : clamp01(flat * (0.35 + 0.45 * lw + 0.5 * river[k]) + (lake[k] > 0 ? 0.6 : 0));\n    }\n\n    // ---- RIVERS AND LAKES (round 2, the owner's pick: still water, not flowing) ----\n    // The final drainage made rivers: every node draining at least A_MIN nodes sends a segment to its receiver. At the\n    // columns (riversAt) each cuts a valley, and down its middle a channel a kube deep that holds still water on a world\n    // with a liquid (the generator fills it: transient-shape.js makeSea). A closed basin holds a lake at its spill level\n    // (lakeLevelAt). Only where a liquid or air wears the ground are there rivers; a dry world's are dry valleys.\n    const segs = [];\n    // Rivers need a liquid to run or air to carry the weather: none on an airless world, even an icy one (its ice\n    // creeps, but cuts no channels).\n    if (Kf > 0 && (liquid || air > 50)) {\n        const A_MIN = 60 * (N / 32) * (N / 32) + 8;         // the trunks: a river drains a sizeable piece of its world\n        for (let k = 0; k < n; k++) {\n            const r = rcv[k];\n            if (r < 0 || A[k] < A_MIN) continue;\n            if (seaShare > 0 && h[k] <= seaLevel) continue;        // already the sea\n            // …or a lake, or its shore: a river runs into a lake and out over its rim, but no channel is cut in or\n            // beside one, or it would drain the lake it feeds.\n            let wet = fill[k] - h[k] > 0.05 || fill[r] - h[r] > 0.05;\n            for (let d = 0; d < 8 && !wet; d++) { const j = nb[k * 8 + d]; if (j >= 0 && fill[j] - h[j] > 0.25) wet = true; }\n            if (wet) continue;\n            const sa = Math.sqrt(A[k]);\n            const w0 = 0.35 + 0.035 * sa * (32 / N), w = w0 > 1.3 ? 1.3 : w0;                 // the channel's half-width, kubes\n            const dv0 = 0.5 + 0.07 * sa, dv = dv0 > 1.8 ? 1.8 : dv0;                           // the valley's depth, kubes\n            segs.push(G.dx[k], G.dy[k], G.dz[k], G.dx[r], G.dy[r], G.dz[r], w, dv);\n        }\n    }\n    const SB = 8, SBS = SB + 1, segBins = new Array(SBS * SBS * SBS);\n    const segBinOf = (x, y, z) => { const bx = Math.floor((x + 1) * SB / 2), by = Math.floor((y + 1) * SB / 2), bz = Math.floor((z + 1) * SB / 2);\n        return bx < 0 || by < 0 || bz < 0 || bx > SB || by > SB || bz > SB ? -1 : (bx * SBS + by) * SBS + bz; };\n    for (let i = 0; i < segs.length; i += 8) {\n        const reach = (segs[i + 6] * 2 + 2 + 1.5) / refR;\n        const lo = [Math.min(segs[i], segs[i + 3]) - reach, Math.min(segs[i + 1], segs[i + 4]) - reach, Math.min(segs[i + 2], segs[i + 5]) - reach];\n        const hiP = [Math.max(segs[i], segs[i + 3]) + reach, Math.max(segs[i + 1], segs[i + 4]) + reach, Math.max(segs[i + 2], segs[i + 5]) + reach];\n        for (let bx = Math.floor((lo[0] + 1) * SB / 2); bx <= Math.floor((hiP[0] + 1) * SB / 2); bx++)\n            for (let by = Math.floor((lo[1] + 1) * SB / 2); by <= Math.floor((hiP[1] + 1) * SB / 2); by++)\n                for (let bz = Math.floor((lo[2] + 1) * SB / 2); bz <= Math.floor((hiP[2] + 1) * SB / 2); bz++) {\n                    if (bx < 0 || by < 0 || bz < 0 || bx > SB || by > SB || bz > SB) continue;\n                    const key = (bx * SBS + by) * SBS + bz;\n                    (segBins[key] || (segBins[key] = [])).push(i);\n                }\n    }\n    // At a direction (a unit vector, already wandered by the caller so the rivers meander): how deep the valley cuts,\n    // in kubes (out.cut), and whether the column is in the channel (out.chan).\n    const OM = [o(), o(), o()];\n    function riversAt(x, y, z, out) {\n        out.cut = 0; out.chan = false;\n        if (!segs.length) return out;\n        // no river near (the bins reach a kube and a half past every valley, more than the wander): no work\n        { const b0 = segBinOf(x, y, z); if (b0 < 0 || !segBins[b0]) return out; }\n        // meander: the direction wanders by about a kube and a half, slowly\n        const m = 1.5 / refR, f = refR * 0.09;\n        x += m * noise(x * f + OM[0], y * f + OM[1], z * f + OM[2]);\n        y += m * noise(x * f + OM[1], y * f + OM[2], z * f + OM[0]);\n        z += m * noise(x * f + OM[2], y * f + OM[0], z * f + OM[1]);\n        const b1 = segBinOf(x, y, z), list = b1 >= 0 ? segBins[b1] : null;\n        if (!list) return out;\n        let cut = 0, chan = false;\n        for (let q = 0; q < list.length; q++) {\n            const i = list[q];\n            const ax = segs[i], ay = segs[i + 1], az = segs[i + 2], bx = segs[i + 3] - ax, by = segs[i + 4] - ay, bz = segs[i + 5] - az;\n            const px = x - ax, py = y - ay, pz = z - az, bb = bx * bx + by * by + bz * bz;\n            let t = bb > 0 ? (px * bx + py * by + pz * bz) / bb : 0;\n            t = t < 0 ? 0 : t > 1 ? 1 : t;\n            const ex = px - bx * t, ey = py - by * t, ez = pz - bz * t;\n            const d = Math.sqrt(ex * ex + ey * ey + ez * ez) * refR, w = segs[i + 6], wv = w * 2 + 2;\n            if (d >= wv) continue;\n            const q2 = d / wv, c = segs[i + 7] * (1 - q2 * q2);\n            if (c > cut) cut = c;\n            if (d < w) chan = true;\n        }\n        out.cut = cut; out.chan = chan;\n        return out;\n    }\n    // A lake's surface where a closed basin holds one (its spill level), and well under the ground elsewhere, so read\n    // between the nodes the level falls away at a shore: water stands only where the ground is under it.\n    // A lake stands a third of the way from its basin's floor to the spill point: water leaves a closed basin by\n    // evaporation as well as over its lip, so few basins brim, and a basin under a kube deep holds none. A basin is the nodes flooded to one spill level (fill, to a thousandth).\n    const lakeLv = new Float64Array(n), lakeIn = new Float64Array(n), basinMin = new Map();\n    for (let k = 0; k < n; k++) {\n        if (!(lake[k] > 0.25) || (seaShare > 0 && h[k] <= seaLevel)) continue;\n        const key = Math.round(fill[k] * 1000), m = basinMin.get(key);\n        if (m === undefined || h[k] < m) basinMin.set(key, h[k]);\n    }\n    for (let k = 0; k < n; k++) {\n        const m = lake[k] > 0.25 ? basinMin.get(Math.round(fill[k] * 1000)) : undefined;\n        lakeLv[k] = m === undefined || fill[k] - m < 1 ? h[k] - 4 : m + 0.35 * (fill[k] - m);\n        lakeIn[k] = lakeLv[k] > h[k] ? 1 : 0;\n    }\n\n    // ---- SAMPLING, between the nodes ----\n    // A point on the unit cube's surface (one coordinate +-1) reads the four nodes round it on its face, a node off the\n    // face's edge taken from the next face (the grid's own fold), so the field runs on over an edge without a seam.\n    const NN = N * N;\n    function nodeAt(f, i, j) {\n        const inI = i >= 0 && i < N, inJ = j >= 0 && j < N;\n        if (inI && inJ) return f * NN + i * N + j;\n        if (!inI && !inJ) return -1;\n        const ci = i < 0 ? 0 : i >= N ? N - 1 : i, cj = j < 0 ? 0 : j >= N ? N - 1 : j;\n        const d = i < 0 ? 1 : i >= N ? 0 : j < 0 ? 3 : 2;\n        return nb[(f * NN + ci * N + cj) * 8 + d];\n    }\n    function valueAt(field, f, i, j) {\n        const k = nodeAt(f, i, j);\n        if (k >= 0) return field[k];\n        // round a corner: the mean of the two nodes beside it\n        const ci = i < 0 ? 0 : N - 1, cj = j < 0 ? 0 : N - 1;\n        return (field[nodeAt(f, i, cj)] + field[nodeAt(f, ci, j)]) * 0.5;\n    }\n    // The highest of the four nodes round a point: for a field that is flat where it holds (a lake's level), so read\n    // between the nodes it stays flat out to the shore instead of sagging toward the land's value.\n    function samplerMax(field) {\n        return (ux, uy, uz) => {\n            const ax = (ux < 0 ? -ux : ux) >= (uy < 0 ? -uy : uy) && (ux < 0 ? -ux : ux) >= (uz < 0 ? -uz : uz) ? 0\n                : (uy < 0 ? -uy : uy) >= (uz < 0 ? -uz : uz) ? 1 : 2;\n            const p = [ux, uy, uz], s = p[ax] < 0 ? 1 : 0, f = ax * 2 + s;\n            const u = p[(ax + 1) % 3] / (p[ax] < 0 ? -p[ax] : p[ax]), v = p[(ax + 2) % 3] / (p[ax] < 0 ? -p[ax] : p[ax]);\n            const x = (u + 1) * 0.5 * N - 0.5, y = (v + 1) * 0.5 * N - 0.5;\n            const i0 = Math.floor(x), j0 = Math.floor(y);\n            const a = valueAt(field, f, i0, j0), b = valueAt(field, f, i0 + 1, j0);\n            const c = valueAt(field, f, i0, j0 + 1), dd = valueAt(field, f, i0 + 1, j0 + 1);\n            const m1 = a > b ? a : b, m2 = c > dd ? c : dd;\n            return m1 > m2 ? m1 : m2;\n        };\n    }\n    function sampler(field) {\n        return (ux, uy, uz) => {\n            const ax = (ux < 0 ? -ux : ux) >= (uy < 0 ? -uy : uy) && (ux < 0 ? -ux : ux) >= (uz < 0 ? -uz : uz) ? 0\n                : (uy < 0 ? -uy : uy) >= (uz < 0 ? -uz : uz) ? 1 : 2;\n            const p = [ux, uy, uz], s = p[ax] < 0 ? 1 : 0, f = ax * 2 + s;\n            const u = p[(ax + 1) % 3] / (p[ax] < 0 ? -p[ax] : p[ax]), v = p[(ax + 2) % 3] / (p[ax] < 0 ? -p[ax] : p[ax]);\n            const x = (u + 1) * 0.5 * N - 0.5, y = (v + 1) * 0.5 * N - 0.5;\n            const i0 = Math.floor(x), j0 = Math.floor(y), fx = x - i0, fy = y - j0;\n            const a = valueAt(field, f, i0, j0), b = valueAt(field, f, i0 + 1, j0);\n            const c = valueAt(field, f, i0, j0 + 1), dd = valueAt(field, f, i0 + 1, j0 + 1);\n            return (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + dd * fx) * fy;\n        };\n    }\n\n    // THE CRATERS, on the columns: each with what is left of it (keep), binned by a coarse cell of the unit cube for\n    // the column's search. Worn to under a sixth, a crater is gone.\n    const vAt = sampler(vol);\n    const kept = [];\n    for (let i = 0; i < craters.length; i += 5) {\n        const x = craters[i], y = craters[i + 1], z = craters[i + 2], r = craters[i + 3], t = craters[i + 4];\n        const ageC = (1 - t) * age;\n        let keep = (air === 0 ? 1 - 0.45 * (1 - t) : 1) - wear * ageC * 0.5;\n        if (molten && t < 0.8) keep *= 0.15;                   // older than a molten world's plains: buried\n        else if (t < 0.6) { const vv = vAt(x, y, z); if (vv > 0.3) keep *= 1 - smooth((vv - 0.3) / 0.3); }   // under later lava\n        if (keep > 0.16) kept.push(x, y, z, r, keep);\n    }\n    // Bins: a flat array of lists over the unit cube's [-1, 1]^3, BIN a side (and one more for the far face).\n    const BIN = 8, BS = BIN + 1, bins = new Array(BS * BS * BS);\n    const binOf = (x, y, z) => { const bx = Math.floor((x + 1) * BIN / 2), by = Math.floor((y + 1) * BIN / 2), bz = Math.floor((z + 1) * BIN / 2);\n        return bx < 0 || by < 0 || bz < 0 || bx > BIN || by > BIN || bz > BIN ? -1 : (bx * BS + by) * BS + bz; };\n    for (let i = 0; i < kept.length; i += 5) {\n        const reach = (kept[i + 3] * 1.7) / refR;\n        const lo = [kept[i] - reach, kept[i + 1] - reach, kept[i + 2] - reach];\n        const hiP = [kept[i] + reach, kept[i + 1] + reach, kept[i + 2] + reach];\n        for (let bx = Math.floor((lo[0] + 1) * BIN / 2); bx <= Math.floor((hiP[0] + 1) * BIN / 2); bx++)\n            for (let by = Math.floor((lo[1] + 1) * BIN / 2); by <= Math.floor((hiP[1] + 1) * BIN / 2); by++)\n                for (let bz = Math.floor((lo[2] + 1) * BIN / 2); bz <= Math.floor((hiP[2] + 1) * BIN / 2); bz++) {\n                    if (bx < 0 || by < 0 || bz < 0 || bx > BIN || by > BIN || bz > BIN) continue;\n                    const key = (bx * BS + by) * BS + bz;\n                    (bins[key] || (bins[key] = [])).push(i);\n                }\n    }\n    // Their height at a direction (a unit vector), in kubes.\n    function cratersAt(x, y, z) {\n        const b = binOf(x, y, z), list = b >= 0 ? bins[b] : null;\n        if (!list) return 0;\n        let v = 0;\n        for (let q = 0; q < list.length; q++) {\n            const i = list[q], ex = x - kept[i], ey = y - kept[i + 1], ez = z - kept[i + 2];\n            const d2 = ex * ex + ey * ey + ez * ez, r = kept[i + 3], rr = (r * 1.7) / refR;\n            if (d2 < rr * rr) v += craterAt(Math.sqrt(d2) * refR, r, kept[i + 4]);\n        }\n        return v;\n    }\n\n    // EVERY FIELD AT ONCE, for the generator's columns: the four nodes round a point found once and every field read\n    // from them (bilinear; the lake's level the highest of the four), into `out`, with nothing allocated.\n    const cn = new Int32Array(4);\n    function fieldsAt(ux, uy, uz, out) {\n        const aX = ux < 0 ? -ux : ux, aY = uy < 0 ? -uy : uy, aZ = uz < 0 ? -uz : uz;\n        let f, u, v;\n        if (aX >= aY && aX >= aZ) { f = ux < 0 ? 1 : 0; u = uy / aX; v = uz / aX; }\n        else if (aY >= aZ) { f = uy < 0 ? 3 : 2; u = uz / aY; v = ux / aY; }\n        else { f = uz < 0 ? 5 : 4; u = ux / aZ; v = uy / aZ; }\n        const x = (u + 1) * 0.5 * N - 0.5, y = (v + 1) * 0.5 * N - 0.5;\n        const i0 = Math.floor(x), j0 = Math.floor(y), fx = x - i0, fy = y - j0;\n        cn[0] = nodeAt(f, i0, j0); cn[1] = nodeAt(f, i0 + 1, j0); cn[2] = nodeAt(f, i0, j0 + 1); cn[3] = nodeAt(f, i0 + 1, j0 + 1);\n        const w0 = (1 - fx) * (1 - fy), w1 = fx * (1 - fy), w2 = (1 - fx) * fy, w3 = fx * fy;\n        if (cn[0] >= 0 && cn[1] >= 0 && cn[2] >= 0 && cn[3] >= 0) {\n            const a = cn[0], b = cn[1], c = cn[2], d = cn[3];\n            out.h = h[a] * w0 + h[b] * w1 + h[c] * w2 + h[d] * w3;\n            out.cover = cover[a] * w0 + cover[b] * w1 + cover[c] * w2 + cover[d] * w3;\n            out.low = low[a] * w0 + low[b] * w1 + low[c] * w2 + low[d] * w3;\n            out.vol = vol[a] * w0 + vol[b] * w1 + vol[c] * w2 + vol[d] * w3;\n            out.river = river[a] * w0 + river[b] * w1 + river[c] * w2 + river[d] * w3;\n            out.lake = lake[a] * w0 + lake[b] * w1 + lake[c] * w2 + lake[d] * w3;\n            out.range = rng[a] * w0 + rng[b] * w1 + rng[c] * w2 + rng[d] * w3;\n            out.lakeIn = lakeIn[a] * w0 + lakeIn[b] * w1 + lakeIn[c] * w2 + lakeIn[d] * w3;\n            const m1 = lakeLv[a] > lakeLv[b] ? lakeLv[a] : lakeLv[b], m2 = lakeLv[c] > lakeLv[d] ? lakeLv[c] : lakeLv[d];\n            out.lakeLv = m1 > m2 ? m1 : m2;\n        } else {                                               // round a corner: the samplers' own way\n            out.h = hAt(ux, uy, uz); out.cover = coverAt(ux, uy, uz); out.low = lowAt(ux, uy, uz); out.vol = volAt(ux, uy, uz);\n            out.river = riverAt(ux, uy, uz); out.lake = lakeAt(ux, uy, uz); out.range = rangeAt(ux, uy, uz);\n            out.lakeIn = lakeInAt(ux, uy, uz); out.lakeLv = lakeLevelAt(ux, uy, uz);\n        }\n        return out;\n    }\n    const hAt = sampler(h), coverAt = sampler(cover), lowAt = sampler(low), volAt = sampler(vol), riverAt = sampler(river);\n    const lakeAt = sampler(lake), rangeAt = sampler(rng), lakeInAt = sampler(lakeIn), lakeLevelAt = samplerMax(lakeLv);\n\n    return {\n        N, L, age, heat: Q, air, relief, seaLevel: seaShare > 0 ? seaLevel : null,\n        plates: nPlates, hotspots: nHot, craters: kept.length / 5,\n        heightAt: hAt, coverAt, lowAt, volcanicAt: volAt, riverAt, lakeAt, rangeAt, cratersAt, riversAt, lakeLevelAt, lakeInAt,\n        fieldsAt, rivers: segs.length / 8,\n        hot: hot.slice(),\n        // the raw fields, for tests and the review page\n        fields: { h, cover, low, vol, river, lake, A, plateOf, cont, rng },\n    };\n}\n"],"mappings":"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","names":["cn"],"file":"geology.mjs"}