@gisatcz/deckgl-geolib 2.6.0-dev.4 → 2.6.0-dev.6

package/dist/esm/index.js

@@ -4969,6 +4969,7 @@ const DefaultGeoImageOptions = {
     disableLighting: false,
     // --- Animation / Caching ---
     cacheAllBands: false,
+    disableWorkerPool: false,
 };
 
 class Martini {
@@ -6329,7 +6330,8 @@ class ReliefCompositor {
 }
 
 class TerrainGenerator {
-    static async generate(input, options, meshMaxError) {
+    static async generate(input, options, meshMaxError, workerPool, // TerrainWorkerPool (optional for flexibility)
+    signal) {
         const { width, height } = input;
         const isKernel = width === 258;
         // 1. Compute Terrain Data (Extract Elevation)
@@ -6337,27 +6339,47 @@ class TerrainGenerator {
         // For kernel tiles, the mesh uses the inner 257×257 sub-grid (rows 1–257, cols 1–257)
         // so that row 0 / col 0 (kernel padding) is dropped while the bottom/right stitching
         // overlap is preserved.
-        const meshTerrain = isKernel ? this.extractMeshRaster(terrain) : terrain;
+        let meshTerrain = isKernel ? this.extractMeshRaster(terrain) : terrain;
         const meshWidth = isKernel ? 257 : width;
         const meshHeight = isKernel ? 257 : height;
         // 2. Tesselate (Generate Mesh)
         const { terrainSkirtHeight, verticalExaggeration = 1.0 } = options;
         let mesh;
-        switch (options.tesselator) {
-            case 'martini':
-                mesh = this.getMartiniTileMesh(meshMaxError, meshWidth, meshTerrain);
-                break;
-            case 'delatin':
-                mesh = this.getDelatinTileMesh(meshMaxError, meshWidth, meshHeight, meshTerrain);
-                break;
-            default:
-                // Intentional: default to Martini for any unspecified or unrecognized tesselator.
-                mesh = this.getMartiniTileMesh(meshMaxError, meshWidth, meshTerrain);
-                break;
+        let meshTerrainForAttributes; // ← Will hold terrain for getMeshAttributes()
+        if (workerPool) {
+            // ✅ NEW: Offload to Web Worker with ZERO-COPY ROUNDTRIP
+            // Transfer meshTerrain to worker; worker transfers it back alongside mesh
+            // This avoids meshTerrain.slice() allocation on main thread
+            const result = await workerPool.computeMesh({
+                terrain: meshTerrain, // ← Transferred to worker (detached here)
+                meshMaxError,
+                tesselator: options.tesselator || 'martini',
+                width: meshWidth,
+                height: meshHeight,
+                signal, // ← Thread cancellation signal to worker
+            });
+            mesh = { vertices: result.vertices, triangles: result.triangles };
+            meshTerrainForAttributes = result.terrain; // ← Transferred back from worker
+            meshTerrain = result.terrain; // ← Reassign for downstream use (tileResult.raw, etc.)
+        }
+        else {
+            // ❌ FALLBACK: Synchronous (old behavior, kept for safety)
+            switch (options.tesselator) {
+                case 'martini':
+                    mesh = this.getMartiniTileMesh(meshMaxError, meshWidth, meshTerrain);
+                    break;
+                case 'delatin':
+                    mesh = this.getDelatinTileMesh(meshMaxError, meshWidth, meshHeight, meshTerrain);
+                    break;
+                default:
+                    mesh = this.getMartiniTileMesh(meshMaxError, meshWidth, meshTerrain);
+                    break;
+            }
+            meshTerrainForAttributes = meshTerrain; // ← Use original
         }
         const { vertices } = mesh;
         let { triangles } = mesh;
-        let attributes = this.getMeshAttributes(vertices, meshTerrain, meshWidth, meshHeight, input.bounds, verticalExaggeration);
+        let attributes = this.getMeshAttributes(vertices, meshTerrainForAttributes, meshWidth, meshHeight, input.bounds, verticalExaggeration);
         // Compute bounding box before adding skirt so that z values are not skewed
         const boundingBox = getMeshBoundingBox(attributes);
         if (terrainSkirtHeight) {
@@ -6624,13 +6646,14 @@ class GeoImage {
         const data = await tiff.getImage(0);
         this.data = data;
     }
-    async getMap(input, options, meshMaxError) {
+    async getMap(input, options, meshMaxError, workerPool, // TerrainWorkerPool (optional)
+    signal) {
         const mergedOptions = GeoImage.resolveVisualizationMode({ ...DefaultGeoImageOptions, ...options }, options);
         switch (mergedOptions.type) {
             case 'image':
                 return this.getBitmap(input, mergedOptions);
             case 'terrain':
-                return this.getHeightmap(input, mergedOptions, meshMaxError);
+                return this.getHeightmap(input, mergedOptions, meshMaxError, workerPool, signal);
             default:
                 return null;
         }
@@ -6687,7 +6710,8 @@ class GeoImage {
         return resolved;
     }
     // GetHeightmap uses only "useChannel" and "multiplier" options
-    async getHeightmap(input, options, meshMaxError) {
+    async getHeightmap(input, options, meshMaxError, workerPool, // TerrainWorkerPool (optional)
+    signal) {
         let rasters = [];
         let width;
         let height;
@@ -6709,8 +6733,8 @@ class GeoImage {
             bounds = input.bounds;
             cellSizeMeters = input.cellSizeMeters;
         }
-        // Delegate to TerrainGenerator
-        return await TerrainGenerator.generate({ width, height, rasters, bounds, cellSizeMeters }, options, meshMaxError);
+        // Delegate to TerrainGenerator with worker pool and cancellation signal
+        return await TerrainGenerator.generate({ width, height, rasters, bounds, cellSizeMeters }, options, meshMaxError, workerPool, signal);
     }
     async getBitmap(input, options) {
         let rasters = [];
@@ -6734,6 +6758,218 @@ class GeoImage {
     }
 }
 
+function decodeBase64(base64, enableUnicode) {
+    var binaryString = atob(base64);
+    return binaryString;
+}
+
+function createURL(base64, sourcemapArg, enableUnicodeArg) {
+    var source = decodeBase64(base64);
+    var start = source.indexOf('\n', 10) + 1;
+    var body = source.substring(start) + ('');
+    var blob = new Blob([body], { type: 'application/javascript' });
+    return URL.createObjectURL(blob);
+}
+
+function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
+    var url;
+    return function WorkerFactory(options) {
+        url = url || createURL(base64);
+        return new Worker(url, options);
+    };
+}
+
+var WorkerFactory = /*#__PURE__*/createBase64WorkerFactory('/* rollup-plugin-web-worker-loader */
(function () {
    'use strict';

    class Martini {
        constructor(gridSize = 257) {
            this.gridSize = gridSize;
            const tileSize = gridSize - 1;
            if (tileSize & (tileSize - 1)) throw new Error(
                `Expected grid size to be 2^n+1, got ${gridSize}.`);

            this.numTriangles = tileSize * tileSize * 2 - 2;
            this.numParentTriangles = this.numTriangles - tileSize * tileSize;

            this.indices = new Uint32Array(this.gridSize * this.gridSize);

            // coordinates for all possible triangles in an RTIN tile
            this.coords = new Uint16Array(this.numTriangles * 4);

            // get triangle coordinates from its index in an implicit binary tree
            for (let i = 0; i < this.numTriangles; i++) {
                let id = i + 2;
                let ax = 0, ay = 0, bx = 0, by = 0, cx = 0, cy = 0;
                if (id & 1) {
                    bx = by = cx = tileSize; // bottom-left triangle
                } else {
                    ax = ay = cy = tileSize; // top-right triangle
                }
                while ((id >>= 1) > 1) {
                    const mx = (ax + bx) >> 1;
                    const my = (ay + by) >> 1;

                    if (id & 1) { // left half
                        bx = ax; by = ay;
                        ax = cx; ay = cy;
                    } else { // right half
                        ax = bx; ay = by;
                        bx = cx; by = cy;
                    }
                    cx = mx; cy = my;
                }
                const k = i * 4;
                this.coords[k + 0] = ax;
                this.coords[k + 1] = ay;
                this.coords[k + 2] = bx;
                this.coords[k + 3] = by;
            }
        }

        createTile(terrain) {
            return new Tile(terrain, this);
        }
    }

    class Tile {
        constructor(terrain, martini) {
            const size = martini.gridSize;
            if (terrain.length !== size * size) throw new Error(
                `Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`);

            this.terrain = terrain;
            this.martini = martini;
            this.errors = new Float32Array(terrain.length);
            this.update();
        }

        update() {
            const {numTriangles, numParentTriangles, coords, gridSize: size} = this.martini;
            const {terrain, errors} = this;

            // iterate over all possible triangles, starting from the smallest level
            for (let i = numTriangles - 1; i >= 0; i--) {
                const k = i * 4;
                const ax = coords[k + 0];
                const ay = coords[k + 1];
                const bx = coords[k + 2];
                const by = coords[k + 3];
                const mx = (ax + bx) >> 1;
                const my = (ay + by) >> 1;
                const cx = mx + my - ay;
                const cy = my + ax - mx;

                // calculate error in the middle of the long edge of the triangle
                const interpolatedHeight = (terrain[ay * size + ax] + terrain[by * size + bx]) / 2;
                const middleIndex = my * size + mx;
                const middleError = Math.abs(interpolatedHeight - terrain[middleIndex]);

                errors[middleIndex] = Math.max(errors[middleIndex], middleError);

                if (i < numParentTriangles) { // bigger triangles; accumulate error with children
                    const leftChildIndex = ((ay + cy) >> 1) * size + ((ax + cx) >> 1);
                    const rightChildIndex = ((by + cy) >> 1) * size + ((bx + cx) >> 1);
                    errors[middleIndex] = Math.max(errors[middleIndex], errors[leftChildIndex], errors[rightChildIndex]);
                }
            }
        }

        getMesh(maxError = 0) {
            const {gridSize: size, indices} = this.martini;
            const {errors} = this;
            let numVertices = 0;
            let numTriangles = 0;
            const max = size - 1;

            // use an index grid to keep track of vertices that were already used to avoid duplication
            indices.fill(0);

            // retrieve mesh in two stages that both traverse the error map:
            // - countElements: find used vertices (and assign each an index), and count triangles (for minimum allocation)
            // - processTriangle: fill the allocated vertices & triangles typed arrays

            function countElements(ax, ay, bx, by, cx, cy) {
                const mx = (ax + bx) >> 1;
                const my = (ay + by) >> 1;

                if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
                    countElements(cx, cy, ax, ay, mx, my);
                    countElements(bx, by, cx, cy, mx, my);
                } else {
                    indices[ay * size + ax] = indices[ay * size + ax] || ++numVertices;
                    indices[by * size + bx] = indices[by * size + bx] || ++numVertices;
                    indices[cy * size + cx] = indices[cy * size + cx] || ++numVertices;
                    numTriangles++;
                }
            }
            countElements(0, 0, max, max, max, 0);
            countElements(max, max, 0, 0, 0, max);

            const vertices = new Uint16Array(numVertices * 2);
            const triangles = new Uint32Array(numTriangles * 3);
            let triIndex = 0;

            function processTriangle(ax, ay, bx, by, cx, cy) {
                const mx = (ax + bx) >> 1;
                const my = (ay + by) >> 1;

                if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
                    // triangle doesn't approximate the surface well enough; drill down further
                    processTriangle(cx, cy, ax, ay, mx, my);
                    processTriangle(bx, by, cx, cy, mx, my);

                } else {
                    // add a triangle
                    const a = indices[ay * size + ax] - 1;
                    const b = indices[by * size + bx] - 1;
                    const c = indices[cy * size + cx] - 1;

                    vertices[2 * a] = ax;
                    vertices[2 * a + 1] = ay;

                    vertices[2 * b] = bx;
                    vertices[2 * b + 1] = by;

                    vertices[2 * c] = cx;
                    vertices[2 * c + 1] = cy;

                    triangles[triIndex++] = a;
                    triangles[triIndex++] = b;
                    triangles[triIndex++] = c;
                }
            }
            processTriangle(0, 0, max, max, max, 0);
            processTriangle(max, max, 0, 0, 0, max);

            return {vertices, triangles};
        }
    }

    // loaders.gl
    // SPDX-License-Identifier: MIT
    // Copyright (c) vis.gl contributors
    // ISC License
    // Copyright(c) 2019, Michael Fogleman, Vladimir Agafonkin
    /* eslint-disable @typescript-eslint/ban-ts-comment */
    // @ts-nocheck
    /* eslint-enable @typescript-eslint/ban-ts-comment */
    function orient(ax, ay, bx, by, cx, cy) {
        return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
    }
    class Delatin {
        constructor(data, width, height = width) {
            this.data = data; // height data
            this.width = width;
            this.height = height;
            this.coords = []; // vertex coordinates (x, y)
            this.triangles = []; // mesh triangle indices
            // additional triangle data
            this._halfedges = [];
            this._candidates = [];
            this._queueIndices = [];
            this._queue = []; // queue of added triangles
            this._errors = [];
            this._rms = [];
            this._pending = []; // triangles pending addition to queue
            this._pendingLen = 0;
            this._rmsSum = 0;
            const x1 = width - 1;
            const y1 = height - 1;
            const p0 = this._addPoint(0, 0);
            const p1 = this._addPoint(x1, 0);
            const p2 = this._addPoint(0, y1);
            const p3 = this._addPoint(x1, y1);
            // add initial two triangles
            const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
            this._addTriangle(p0, p3, p1, t0, -1, -1);
            this._flush();
        }
        // refine the mesh until its maximum error gets below the given one
        run(maxError = 1) {
            while (this.getMaxError() > maxError) {
                this.refine();
            }
        }
        // refine the mesh with a single point
        refine() {
            this._step();
            this._flush();
        }
        // max error of the current mesh
        getMaxError() {
            return this._errors[0];
        }
        // root-mean-square deviation of the current mesh
        getRMSD() {
            return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
        }
        // height value at a given position
        heightAt(x, y) {
            return this.data[this.width * y + x];
        }
        // rasterize and queue all triangles that got added or updated in _step
        _flush() {
            const { coords } = this;
            for (let i = 0; i < this._pendingLen; i++) {
                const t = this._pending[i];
                // rasterize triangle to find maximum pixel error
                const a = 2 * this.triangles[t * 3 + 0];
                const b = 2 * this.triangles[t * 3 + 1];
                const c = 2 * this.triangles[t * 3 + 2];
                this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
            }
            this._pendingLen = 0;
        }
        // rasterize a triangle, find its max error, and queue it for processing
        _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
            // triangle bounding box
            const minX = Math.min(p0x, p1x, p2x);
            const minY = Math.min(p0y, p1y, p2y);
            const maxX = Math.max(p0x, p1x, p2x);
            const maxY = Math.max(p0y, p1y, p2y);
            // forward differencing variables
            let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
            let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
            let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
            const a01 = p1y - p0y;
            const b01 = p0x - p1x;
            const a12 = p2y - p1y;
            const b12 = p1x - p2x;
            const a20 = p0y - p2y;
            const b20 = p2x - p0x;
            // pre-multiplied z values at vertices
            const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
            const z0 = this.heightAt(p0x, p0y) / a;
            const z1 = this.heightAt(p1x, p1y) / a;
            const z2 = this.heightAt(p2x, p2y) / a;
            // iterate over pixels in bounding box
            let maxError = 0;
            let mx = 0;
            let my = 0;
            let rms = 0;
            for (let y = minY; y <= maxY; y++) {
                // compute starting offset
                let dx = 0;
                if (w00 < 0 && a12 !== 0) {
                    dx = Math.max(dx, Math.floor(-w00 / a12));
                }
                if (w01 < 0 && a20 !== 0) {
                    dx = Math.max(dx, Math.floor(-w01 / a20));
                }
                if (w02 < 0 && a01 !== 0) {
                    dx = Math.max(dx, Math.floor(-w02 / a01));
                }
                let w0 = w00 + a12 * dx;
                let w1 = w01 + a20 * dx;
                let w2 = w02 + a01 * dx;
                let wasInside = false;
                for (let x = minX + dx; x <= maxX; x++) {
                    // check if inside triangle
                    if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
                        wasInside = true;
                        // compute z using barycentric coordinates
                        const z = z0 * w0 + z1 * w1 + z2 * w2;
                        const dz = Math.abs(z - this.heightAt(x, y));
                        rms += dz * dz;
                        if (dz > maxError) {
                            maxError = dz;
                            mx = x;
                            my = y;
                        }
                    }
                    else if (wasInside) {
                        break;
                    }
                    w0 += a12;
                    w1 += a20;
                    w2 += a01;
                }
                w00 += b12;
                w01 += b20;
                w02 += b01;
            }
            if ((mx === p0x && my === p0y) || (mx === p1x && my === p1y) || (mx === p2x && my === p2y)) {
                maxError = 0;
            }
            // update triangle metadata
            this._candidates[2 * t] = mx;
            this._candidates[2 * t + 1] = my;
            this._rms[t] = rms;
            // add triangle to priority queue
            this._queuePush(t, maxError, rms);
        }
        // process the next triangle in the queue, splitting it with a new point
        _step() {
            // pop triangle with highest error from priority queue
            const t = this._queuePop();
            const e0 = t * 3 + 0;
            const e1 = t * 3 + 1;
            const e2 = t * 3 + 2;
            const p0 = this.triangles[e0];
            const p1 = this.triangles[e1];
            const p2 = this.triangles[e2];
            const ax = this.coords[2 * p0];
            const ay = this.coords[2 * p0 + 1];
            const bx = this.coords[2 * p1];
            const by = this.coords[2 * p1 + 1];
            const cx = this.coords[2 * p2];
            const cy = this.coords[2 * p2 + 1];
            const px = this._candidates[2 * t];
            const py = this._candidates[2 * t + 1];
            const pn = this._addPoint(px, py);
            if (orient(ax, ay, bx, by, px, py) === 0) {
                this._handleCollinear(pn, e0);
            }
            else if (orient(bx, by, cx, cy, px, py) === 0) {
                this._handleCollinear(pn, e1);
            }
            else if (orient(cx, cy, ax, ay, px, py) === 0) {
                this._handleCollinear(pn, e2);
            }
            else {
                const h0 = this._halfedges[e0];
                const h1 = this._halfedges[e1];
                const h2 = this._halfedges[e2];
                const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
                const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
                const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
                this._legalize(t0);
                this._legalize(t1);
                this._legalize(t2);
            }
        }
        // add coordinates for a new vertex
        _addPoint(x, y) {
            const i = this.coords.length >> 1;
            this.coords.push(x, y);
            return i;
        }
        // add or update a triangle in the mesh
        _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
            const t = e / 3; // new triangle index
            // add triangle vertices
            this.triangles[e + 0] = a;
            this.triangles[e + 1] = b;
            this.triangles[e + 2] = c;
            // add triangle halfedges
            this._halfedges[e + 0] = ab;
            this._halfedges[e + 1] = bc;
            this._halfedges[e + 2] = ca;
            // link neighboring halfedges
            if (ab >= 0) {
                this._halfedges[ab] = e + 0;
            }
            if (bc >= 0) {
                this._halfedges[bc] = e + 1;
            }
            if (ca >= 0) {
                this._halfedges[ca] = e + 2;
            }
            // init triangle metadata
            this._candidates[2 * t + 0] = 0;
            this._candidates[2 * t + 1] = 0;
            this._queueIndices[t] = -1;
            this._rms[t] = 0;
            // add triangle to pending queue for later rasterization
            this._pending[this._pendingLen++] = t;
            // return first halfedge index
            return e;
        }
        _legalize(a) {
            // if the pair of triangles doesn't satisfy the Delaunay condition
            // (p1 is inside the circumcircle of [p0, pl, pr]), flip them,
            // then do the same check/flip recursively for the new pair of triangles
            //
            //           pl                    pl
            //          /||\                  /  \
            //       al/ || \bl            al/    \a
            //        /  ||  \              /      \
            //       /  a||b  \    flip    /___ar___\
            //     p0\   ||   /p1   =>   p0\---bl---/p1
            //        \  ||  /              \      /
            //       ar\ || /br             b\    /br
            //          \||/                  \  /
            //           pr                    pr
            const b = this._halfedges[a];
            if (b < 0) {
                return;
            }
            const a0 = a - (a % 3);
            const b0 = b - (b % 3);
            const al = a0 + ((a + 1) % 3);
            const ar = a0 + ((a + 2) % 3);
            const bl = b0 + ((b + 2) % 3);
            const br = b0 + ((b + 1) % 3);
            const p0 = this.triangles[ar];
            const pr = this.triangles[a];
            const pl = this.triangles[al];
            const p1 = this.triangles[bl];
            const { coords } = this;
            if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
                return;
            }
            const hal = this._halfedges[al];
            const har = this._halfedges[ar];
            const hbl = this._halfedges[bl];
            const hbr = this._halfedges[br];
            this._queueRemove(a0 / 3);
            this._queueRemove(b0 / 3);
            const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
            const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
            this._legalize(t0 + 1);
            this._legalize(t1 + 2);
        }
        // handle a case where new vertex is on the edge of a triangle
        _handleCollinear(pn, a) {
            const a0 = a - (a % 3);
            const al = a0 + ((a + 1) % 3);
            const ar = a0 + ((a + 2) % 3);
            const p0 = this.triangles[ar];
            const pr = this.triangles[a];
            const pl = this.triangles[al];
            const hal = this._halfedges[al];
            const har = this._halfedges[ar];
            const b = this._halfedges[a];
            if (b < 0) {
                const t0 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
                const t1 = this._addTriangle(p0, pn, pl, t0, -1, hal);
                this._legalize(t0 + 1);
                this._legalize(t1 + 2);
                return;
            }
            const b0 = b - (b % 3);
            const bl = b0 + ((b + 2) % 3);
            const br = b0 + ((b + 1) % 3);
            const p1 = this.triangles[bl];
            const hbl = this._halfedges[bl];
            const hbr = this._halfedges[br];
            this._queueRemove(b0 / 3);
            const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
            const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
            const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
            const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
            this._legalize(t0);
            this._legalize(t1);
            this._legalize(t2);
            this._legalize(t3);
        }
        // priority queue methods
        _queuePush(t, error, rms) {
            const i = this._queue.length;
            this._queueIndices[t] = i;
            this._queue.push(t);
            this._errors.push(error);
            this._rmsSum += rms;
            this._queueUp(i);
        }
        _queuePop() {
            const n = this._queue.length - 1;
            this._queueSwap(0, n);
            this._queueDown(0, n);
            return this._queuePopBack();
        }
        _queuePopBack() {
            const t = this._queue.pop();
            this._errors.pop();
            this._rmsSum -= this._rms[t];
            this._queueIndices[t] = -1;
            return t;
        }
        _queueRemove(t) {
            const i = this._queueIndices[t];
            if (i < 0) {
                const it = this._pending.indexOf(t);
                if (it !== -1) {
                    this._pending[it] = this._pending[--this._pendingLen];
                }
                else {
                    throw new Error('Broken triangulation (something went wrong).');
                }
                return;
            }
            const n = this._queue.length - 1;
            if (n !== i) {
                this._queueSwap(i, n);
                if (!this._queueDown(i, n)) {
                    this._queueUp(i);
                }
            }
            this._queuePopBack();
        }
        _queueLess(i, j) {
            return this._errors[i] > this._errors[j];
        }
        _queueSwap(i, j) {
            const pi = this._queue[i];
            const pj = this._queue[j];
            this._queue[i] = pj;
            this._queue[j] = pi;
            this._queueIndices[pi] = j;
            this._queueIndices[pj] = i;
            const e = this._errors[i];
            this._errors[i] = this._errors[j];
            this._errors[j] = e;
        }
        _queueUp(j0) {
            let j = j0;
            while (true) {
                const i = (j - 1) >> 1;
                if (i === j || !this._queueLess(j, i)) {
                    break;
                }
                this._queueSwap(i, j);
                j = i;
            }
        }
        _queueDown(i0, n) {
            let i = i0;
            while (true) {
                const j1 = 2 * i + 1;
                if (j1 >= n || j1 < 0) {
                    break;
                }
                const j2 = j1 + 1;
                let j = j1;
                if (j2 < n && this._queueLess(j2, j1)) {
                    j = j2;
                }
                if (!this._queueLess(j, i)) {
                    break;
                }
                this._queueSwap(i, j);
                i = j;
            }
            return i > i0;
        }
    }
    function inCircle(ax, ay, bx, by, cx, cy, px, py) {
        const dx = ax - px;
        const dy = ay - py;
        const ex = bx - px;
        const ey = by - py;
        const fx = cx - px;
        const fy = cy - py;
        const ap = dx * dx + dy * dy;
        const bp = ex * ex + ey * ey;
        const cp = fx * fx + fy * fy;
        return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
    }

    /**
     * Web Worker for terrain mesh tessellation.
     * Runs Martini/Delatin algorithms on a background thread to avoid blocking the main thread.
     */
    // Track aborted tasks to avoid sending results for cancelled work
    const abortedTasks = new Map();
    self.onmessage = (e) => {
        const data = e.data;
        if (data.type === 'abort') {
            // Mark task as aborted; if it's still computing, we'll skip the response
            abortedTasks.set(data.taskId, true);
            return;
        }
        if (data.type === 'computeMesh') {
            const { taskId, terrain, meshMaxError, tesselator, width, height } = data;
            let mesh;
            try {
                if (tesselator === 'delatin') {
                    // Delatin tessellation
                    const widthPlus = width === 257 ? 257 : width + 1;
                    const heightPlus = height === 257 ? 257 : height + 1;
                    const tin = new Delatin(terrain, widthPlus, heightPlus);
                    tin.run(meshMaxError);
                    // @ts-expect-error: Delatin instance properties 'coords' and 'triangles' are not explicitly typed in the library port
                    const { coords, triangles } = tin;
                    // coords is a plain array — convert to Float64Array so it has .buffer for transfer
                    const verticesTyped = Float64Array.from(coords);
                    const trianglesTyped = Uint32Array.from(triangles);
                    mesh = {
                        vertices: verticesTyped,
                        triangles: trianglesTyped,
                    };
                }
                else {
                    // Martini tessellation (default)
                    const gridSize = width === 257 ? 257 : width + 1; // Only add 1 if width is not already 2^n+1
                    const martini = new Martini(gridSize);
                    const tile = martini.createTile(terrain);
                    mesh = tile.getMesh(meshMaxError);
                }
                // Only send result if not aborted
                if (!abortedTasks.get(taskId)) {
                    const response = {
                        type: 'meshResult',
                        taskId,
                        result: mesh,
                        terrain, // ← CRITICAL: Return terrain buffer to main thread
                    };
                    // Transfer ownership of ALL buffers back to main thread (zero-copy roundtrip)
                    // This avoids meshTerrain.slice() allocation on main thread
                    self.postMessage(response, {
                        transfer: [
                            mesh.vertices.buffer,
                            mesh.triangles.buffer,
                            terrain.buffer, // ← Transfer terrain back
                        ],
                    });
                }
            }
            catch (error) {
                // Only report errors for non-aborted tasks
                if (!abortedTasks.get(taskId)) {
                    self.postMessage({
                        type: 'error',
                        taskId,
                        error: error instanceof Error ? error.message : String(error),
                    });
                }
            }
            finally {
                // Clean up abort tracking
                abortedTasks.delete(taskId);
            }
        }
    };
    // Signal that worker is ready
    self.postMessage({ type: 'ready' });

})();
//# sourceMappingURL=terrain.worker.js.map

');
+/* eslint-enable */
+
+/**
+ * Pool of Web Workers for parallel terrain tessellation.
+ * Distributes work across multiple workers based on CPU core count.
+ *
+ * SINGLETON PATTERN: One global pool is shared across all CogTiles instances
+ * to avoid expensive worker creation/destruction during deck.gl layer recreations.
+ */
+// @ts-expect-error - The import statement will be handled by both Rollup (web-worker: prefix)
+// and our Vite plugin (web-worker: → ?worker conversion)
+/**
+ * Manages a pool of terrain tessellation workers.
+ * Automatically scales to CPU core count (capped at 8 for memory safety).
+ */
+class TerrainWorkerPool {
+    workers = [];
+    pendingTasks = new Map();
+    taskCounter = 0;
+    roundRobinIndex = 0;
+    constructor(poolSize) {
+        // Detect browser environment; default to 1 worker in non-browser contexts (SSR/Node/tests)
+        let defaultSize = 1;
+        if (typeof navigator !== 'undefined') {
+            // Default to CPU core count, fallback to 4, cap at 8 to prevent memory exhaustion
+            defaultSize = Math.min(navigator.hardwareConcurrency || 4, 8);
+            // On low-memory devices (<4GB), use only 2 workers to avoid OOM
+            if (navigator.deviceMemory && navigator.deviceMemory < 4) {
+                defaultSize = 2;
+            }
+        }
+        const size = Math.max(1, poolSize ?? defaultSize);
+        for (let i = 0; i < size; i++) {
+            const worker = new WorkerFactory();
+            worker.onmessage = this.handleWorkerMessage.bind(this);
+            worker.onerror = this.handleWorkerError.bind(this);
+            this.workers.push(worker);
+        }
+    }
+    /**
+     * Compute terrain mesh using the worker pool.
+     * Returns a Promise that resolves with the mesh data.
+     * Supports cancellation via AbortSignal.
+     */
+    async computeMesh(options) {
+        const { terrain, meshMaxError, tesselator, width, height, signal } = options;
+        // Check if already aborted
+        if (signal?.aborted) {
+            throw new DOMException('Aborted', 'AbortError');
+        }
+        const taskId = `task_${++this.taskCounter}`;
+        return new Promise((resolve, reject) => {
+            // Pick worker once — used for both dispatch and abort to ensure correct routing
+            const worker = this.getNextWorker();
+            const task = { resolve, reject, aborted: false, worker };
+            this.pendingTasks.set(taskId, task);
+            // Handle abort signal
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    // Guard against late aborts: only process if task still exists
+                    if (!this.pendingTasks.has(taskId)) {
+                        return;
+                    }
+                    task.aborted = true;
+                    this.pendingTasks.delete(taskId);
+                    // Send abort to the same worker that owns this task
+                    worker.postMessage({ type: 'abort', taskId });
+                    reject(new DOMException('Aborted', 'AbortError'));
+                }, { once: true });
+            }
+            // Transfer terrain buffer ownership to avoid copy
+            // NOTE: After this, `terrain` becomes detached on main thread
+            worker.postMessage({
+                type: 'computeMesh',
+                taskId,
+                terrain,
+                meshMaxError,
+                tesselator,
+                width,
+                height,
+            }, [terrain.buffer] // ← Transferable
+            );
+        });
+    }
+    getNextWorker() {
+        const worker = this.workers[this.roundRobinIndex];
+        this.roundRobinIndex = (this.roundRobinIndex + 1) % this.workers.length;
+        return worker;
+    }
+    handleWorkerMessage(e) {
+        const { type, taskId, result, terrain, error } = e.data;
+        if (type === 'ready') {
+            // Worker initialization complete (can be ignored)
+            return;
+        }
+        const task = this.pendingTasks.get(taskId);
+        if (!task) {
+            // Task was aborted or already resolved
+            return;
+        }
+        this.pendingTasks.delete(taskId);
+        if (task.aborted) {
+            // Ignore result for aborted task
+            return;
+        }
+        if (type === 'meshResult') {
+            // Combine result with terrain that was transferred back
+            task.resolve({
+                vertices: result.vertices,
+                triangles: result.triangles,
+                terrain, // ← Include terrain from message
+            });
+        }
+        else if (type === 'error') {
+            task.reject(new Error(`Worker error: ${error}`));
+        }
+    }
+    handleWorkerError(e) {
+        // Find which worker failed (e.target is the Worker instance)
+        const failedWorker = e.target;
+        // Find all pending tasks assigned to this worker
+        const failedTaskIds = [];
+        this.pendingTasks.forEach((task, taskId) => {
+            if (task.worker === failedWorker) {
+                failedTaskIds.push(taskId);
+            }
+        });
+        // Reject all tasks for the failed worker
+        for (const taskId of failedTaskIds) {
+            const task = this.pendingTasks.get(taskId);
+            if (task) {
+                this.pendingTasks.delete(taskId);
+                task.reject(new Error(`Worker crashed: ${e.message || 'Unknown error'}`));
+            }
+        }
+        // Respawn the failed worker to maintain pool capacity
+        const workerIndex = this.workers.indexOf(failedWorker);
+        if (workerIndex !== -1) {
+            try {
+                const newWorker = new WorkerFactory();
+                newWorker.onmessage = this.handleWorkerMessage.bind(this);
+                newWorker.onerror = this.handleWorkerError.bind(this);
+                this.workers[workerIndex] = newWorker;
+            }
+            catch (spawnError) {
+                // eslint-disable-next-line no-console
+                console.error('[TerrainWorkerPool] Failed to respawn worker:', spawnError);
+            }
+        }
+    }
+    /**
+     * Terminate all workers.
+     * ⚠️ NOTE: Because this is a singleton, terminate() should only be called
+     * on app shutdown, not on individual layer unmount.
+     */
+    terminate() {
+        // Reject all pending tasks before terminating workers
+        this.pendingTasks.forEach(task => {
+            task.reject(new DOMException('Worker pool terminated', 'AbortError'));
+        });
+        this.pendingTasks.clear();
+        this.workers.forEach(w => w.terminate());
+        this.workers = [];
+    }
+}
+// ─── SINGLETON INSTANCE ───
+// Lazily initialized on first use; shared across all CogTiles instances
+let globalWorkerPool = null;
+/**
+ * Gets the global terrain worker pool, creating it on first use.
+ * All CogTiles instances share this pool to avoid expensive worker churn
+ * during deck.gl layer recreations.
+ */
+function getGlobalTerrainWorkerPool() {
+    if (!globalWorkerPool) {
+        globalWorkerPool = new TerrainWorkerPool();
+    }
+    return globalWorkerPool;
+}
+/**
+ * Terminates the global worker pool.
+ * Only call this on app shutdown, not on layer unmount.
+ */
+function terminateGlobalTerrainWorkerPool() {
+    if (globalWorkerPool) {
+        globalWorkerPool.terminate();
+        globalWorkerPool = null;
+    }
+}
+
 const EARTH_CIRCUMFERENCE = 2 * Math.PI * 6378137;
 const EARTH_HALF_CIRCUMFERENCE = EARTH_CIRCUMFERENCE / 2;
 const webMercatorOrigin = [-20037508.342789244, 20037508.342789244];
@@ -7087,12 +7323,19 @@ class CogTiles {
     // future cache hits just await the already-resolved promise directly.
     cache = new TileCacheManager();
     tileReader;
+    workerPool; // TerrainWorkerPool (for terrain tiles)
     // Store initialization promise to prevent concurrent duplicate initializations
     initializePromise;
     // Track the last successfully initialized URL to detect URL changes
     lastInitializedUrl;
     constructor(options) {
         this.options = { ...CogTilesGeoImageOptionsDefaults, ...options };
+        // Get reference to global worker pool for terrain tiles
+        // Do NOT create a new pool per instance — reuse the singleton
+        // Skip if disableWorkerPool is true (e.g., for smooth animation during rapid band changes)
+        if (options.type === 'terrain' && typeof Worker !== 'undefined' && !options.disableWorkerPool) {
+            this.workerPool = getGlobalTerrainWorkerPool();
+        }
     }
     async initializeCog(url) {
         // Reuse existing initialization while it is in progress, or when the same URL
@@ -7624,7 +7867,7 @@ class CogTiles {
                 height: requiredSize,
                 bounds: bounds ?? [0, 0, 0, 0],
                 cellSizeMeters,
-            }, generatorOptions, resolvedMeshMaxError);
+            }, generatorOptions, resolvedMeshMaxError, this.workerPool, controller.signal);
         })();
         const entry = {
             promise: pipeline,
@@ -7678,7 +7921,7 @@ class CogTiles {
             height: this.tileSize,
             bounds: bounds ?? [0, 0, 0, 0],
             cellSizeMeters,
-        }, this.options, meshMaxError ?? 4.0);
+        }, this.options, meshMaxError ?? 4.0, this.workerPool, signal);
     }
     async getBitmapTile(x, y, z, bounds, cellSizeMeters, meshMaxError, signal) {
         const rasterKey = this.cache.getTileCacheKey(x, y, z);
@@ -7700,7 +7943,7 @@ class CogTiles {
             height: this.tileSize,
             bounds: bounds ?? [0, 0, 0, 0],
             cellSizeMeters,
-        }, this.options, meshMaxError ?? 4.0);
+        }, this.options, meshMaxError ?? 4.0, this.workerPool);
     }
     async getTileAllBands(x, y, z, meshMaxError, signal, bounds) {
         if (!this.cog) {
@@ -7797,7 +8040,7 @@ class CogTiles {
                     height: FETCH_SIZE,
                     bounds: bounds ?? [0, 0, 0, 0],
                     cellSizeMeters,
-                }, generatorOptions, resolvedMeshMaxError);
+                }, generatorOptions, resolvedMeshMaxError, this.workerPool, signal);
                 if (tileResult)
                     results.push(tileResult);
             }
@@ -8060,6 +8303,8 @@ const defaultProps = {
     // Same as SimpleMeshLayer wireframe
     wireframe: false,
     material: true,
+    // Enable progressive loading by default (overview tiles first, then detail)
+    enableProgressiveLoading: true,
     // loaders: [TerrainLoader],
 };
 // Turns array of templates into a single string to work around shallow change
@@ -8077,12 +8322,15 @@ class CogTerrainLayer extends CompositeLayer {
     static layerName = 'CogTerrainLayer';
     // terrainCogTiles: CogTiles;
     terrainUrl = '';
+    zRangeUpdateTimeoutId = null;
+    lastZRangeValue = null;
     async initializeState(context) {
         super.initializeState(context);
         const terrainCogTiles = this.props.cogTiles || new CogTiles(this.props.terrainOptions);
         this.setState({
             terrainCogTiles,
             initialized: false,
+            overviewLoaded: false,
         });
         // Only initialize if not already done (e.g., provided cogTiles instance may be pre-initialized)
         if (!terrainCogTiles.cog) {
@@ -8128,6 +8376,26 @@ class CogTerrainLayer extends CompositeLayer {
             this.state.terrainCogTiles.options.useChannelIndex = null; // Clear derived channel index
             this.state.terrainCogTiles.clearTileResultCache(); // Invalidate cached tiles from previous channel
         }
+        // Update kernel visualization options when hillshade/slope/relief settings change.
+        // These affect tile texture generation — the cache must be cleared and options synced
+        // so the next getTileData call uses the updated kernel settings.
+        const kernelOptionsChanged = props?.terrainOptions?.useHillshade !== oldProps.terrainOptions?.useHillshade ||
+            props?.terrainOptions?.useSlope !== oldProps.terrainOptions?.useSlope ||
+            props?.terrainOptions?.useSwissRelief !== oldProps.terrainOptions?.useSwissRelief ||
+            props?.terrainOptions?.hillshadeAzimuth !== oldProps.terrainOptions?.hillshadeAzimuth ||
+            props?.terrainOptions?.hillshadeAltitude !== oldProps.terrainOptions?.hillshadeAltitude ||
+            props?.terrainOptions?.zFactor !== oldProps.terrainOptions?.zFactor;
+        if (kernelOptionsChanged && this.state.terrainCogTiles) {
+            // Sync updated options into the shared CogTiles instance
+            this.state.terrainCogTiles.options.useHillshade = props.terrainOptions?.useHillshade;
+            this.state.terrainCogTiles.options.useSlope = props.terrainOptions?.useSlope;
+            this.state.terrainCogTiles.options.useSwissRelief = props.terrainOptions?.useSwissRelief;
+            this.state.terrainCogTiles.options.hillshadeAzimuth = props.terrainOptions?.hillshadeAzimuth;
+            this.state.terrainCogTiles.options.hillshadeAltitude = props.terrainOptions?.hillshadeAltitude;
+            this.state.terrainCogTiles.options.zFactor = props.terrainOptions?.zFactor;
+            // Invalidate cached tiles — kernel output is baked into the texture
+            this.state.terrainCogTiles.clearTileResultCache();
+        }
         // Update skipTexture when wireframe/operation/disableTexture changes so cache keys are correct
         const newSkipTexture = !!(props?.wireframe || props?.operation === 'terrain' || props?.disableTexture);
         const oldSkipTexture = !!(oldProps?.wireframe || oldProps?.operation === 'terrain' || oldProps?.disableTexture);
@@ -8138,8 +8406,20 @@ class CogTerrainLayer extends CompositeLayer {
         // When the external cogTiles instance is swapped (e.g. mode switch), update state so
         // renderLayers picks up the new reference and the TileLayer updateTrigger fires a refetch
         // while keeping old tile content visible until new tiles are ready.
+        // Also reset progressive loading state for the new dataset.
         if (props.cogTiles && props.cogTiles !== oldProps.cogTiles) {
-            this.setState({ terrainCogTiles: props.cogTiles });
+            const newState = { terrainCogTiles: props.cogTiles };
+            // Only reset progressive loading state if it's actually enabled
+            if (this.props.enableProgressiveLoading) {
+                newState.overviewLoaded = false;
+            }
+            this.setState(newState);
+        }
+        else if (elevationDataChanged) {
+            // Reset progressive loading state when dataset URL changes
+            if (this.props.enableProgressiveLoading) {
+                this.setState({ overviewLoaded: false });
+            }
         }
         if (props.workerUrl) {
             log.removed('workerUrl', 'loadOptions.terrain.workerUrl')();
@@ -8231,9 +8511,21 @@ class CogTerrainLayer extends CompositeLayer {
             _instanced: false,
             pickable: props.pickable,
             coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+            // Dynamic polygon offset: pull higher zoom levels closer to camera to depth-test in front.
+            // Uses tile.index.z from closure to avoid Z-fighting between ancestor tiles and high-res detail.
+            // Formula: zoom 0 = offset 0, zoom 9 = offset -9000, zoom 12 = offset -12000, etc.
+            // getPolygonOffset must be a function (deck.gl calls it as getPolygonOffset(uniforms)).
+            // If the user supplied a custom override on the CogTerrainLayer, respect it;
+            // otherwise apply the tile-zoom-based dynamic offset.
+            getPolygonOffset: (this.props.getPolygonOffset != null
+                && this.props.getPolygonOffset !== ((CogTerrainLayer.defaultProps.getPolygonOffset?.value) ?? CogTerrainLayer.defaultProps.getPolygonOffset))
+                ? this.props.getPolygonOffset
+                : () => [0, -((props.tile?.index?.z ?? 0) * 1000)],
             // getPosition: (d) => [0, 0, 0],
             getColor: tileTexture ? [255, 255, 255] : color,
             wireframe,
+            // ADDED: Forward parameters prop down to the SimpleMeshLayer for depthRange to work
+            parameters: this.props.parameters,
         });
     }
     // Update zRange of viewport
@@ -8255,60 +8547,121 @@ class CogTerrainLayer extends CompositeLayer {
         if (ranges.length === 0) {
             return;
         }
-        const minZ = Math.min(...ranges.map((x) => x?.[0] ?? 0).filter((n) => Number.isFinite(n)));
-        const maxZ = Math.max(...ranges.map((x) => x?.[1] ?? 0).filter((n) => Number.isFinite(n)));
+        const minValues = ranges
+            .map((x) => x?.[0])
+            .filter((n) => n !== undefined && Number.isFinite(n));
+        const maxValues = ranges
+            .map((x) => x?.[1])
+            .filter((n) => n !== undefined && Number.isFinite(n));
+        if (minValues.length === 0 || maxValues.length === 0) {
+            return;
+        }
+        const minZ = Math.min(...minValues);
+        const maxZ = Math.max(...maxValues);
         if (!zRange || minZ < zRange[0] || maxZ > zRange[1]) {
             const newZRange = [Number.isFinite(minZ) ? minZ : 0, Number.isFinite(maxZ) ? maxZ : 0];
             this.setState({ zRange: newZRange });
-            this.props.onZRangeUpdate?.(newZRange);
+            // Debounce onZRangeUpdate callback to avoid excessive React re-renders during rapid updates
+            // (e.g., slider scrubbing in animation use cases). Wait 200ms of stable zRange before firing.
+            if (this.zRangeUpdateTimeoutId !== null) {
+                clearTimeout(this.zRangeUpdateTimeoutId);
+            }
+            this.lastZRangeValue = newZRange;
+            this.zRangeUpdateTimeoutId = setTimeout(() => {
+                this.props.onZRangeUpdate?.(this.lastZRangeValue);
+                this.zRangeUpdateTimeoutId = null;
+            }, 200);
         }
     }
     renderLayers() {
-        const { 
-        // color,
-        // material,
-        elevationData, 
-        // texture,
-        // wireframe,
-        meshMaxError, elevationDecoder, tileSize, extent, maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, } = this.props;
-        if (this.state.isTiled && this.state.initialized) {
-            return new TileLayer(this.getSubLayerProps({
-                id: 'tiles',
-            }), {
-                getTileData: this.getTiledTerrainData.bind(this),
-                renderSubLayers: this.renderSubLayers.bind(this),
-                pickable: this.props.pickable,
-                onClick: this.props.onClick,
-                updateTriggers: {
-                    getTileData: {
-                        elevationData: urlTemplateToUpdateTrigger(elevationData),
-                        meshMaxError,
-                        elevationDecoder,
-                        terrainCogTiles: this.state.terrainCogTiles,
-                        skipTexture: !!(this.props.wireframe || this.props.operation === 'terrain' || this.props.disableTexture),
-                        useChannel: this.props.terrainOptions?.useChannel,
-                    },
-                    renderSubLayers: {
-                        disableTexture: this.props.disableTexture,
-                        terrainOptions: this.props.terrainOptions,
-                    },
+        const { elevationData, meshMaxError, elevationDecoder, tileSize, extent, maxRequests, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, } = this.props;
+        if (!this.state.isTiled || !this.state.initialized) {
+            return null;
+        }
+        // Auto-enable LOD gate: lock at minZoom until overview tile loads, then release to full range.
+        // User's explicit zoomOverride takes precedence over auto-gate.
+        let effectiveMinZoom = this.state.minZoom;
+        let effectiveMaxZoom = this.state.maxZoom;
+        if (this.props.zoomOverride !== undefined) {
+            effectiveMinZoom = this.props.zoomOverride;
+            effectiveMaxZoom = this.props.zoomOverride;
+        }
+        else if (this.props.enableProgressiveLoading && !this.state.overviewLoaded) {
+            // Gate: lock at minZoom until the overview viewport is fully covered
+            effectiveMinZoom = this.state.minZoom;
+            effectiveMaxZoom = this.state.minZoom;
+        }
+        return new TileLayer(this.getSubLayerProps({ id: 'tiles' }), {
+            getTileData: this.getTiledTerrainData.bind(this),
+            renderSubLayers: this.renderSubLayers.bind(this),
+            pickable: this.props.pickable,
+            onClick: this.props.onClick,
+            updateTriggers: {
+                getTileData: {
+                    elevationData: urlTemplateToUpdateTrigger(elevationData),
+                    meshMaxError,
+                    elevationDecoder,
+                    terrainCogTiles: this.state.terrainCogTiles,
+                    skipTexture: !!(this.props.wireframe || this.props.operation === 'terrain' || this.props.disableTexture),
+                    useChannel: this.props.terrainOptions?.useChannel,
+                    // Only include kernel visualization triggers if they're explicitly set to avoid false positives
+                    // when animating with different useChannel values
+                    ...(this.props.terrainOptions?.useHillshade !== undefined && {
+                        useHillshade: this.props.terrainOptions.useHillshade,
+                    }),
+                    ...(this.props.terrainOptions?.useSlope !== undefined && {
+                        useSlope: this.props.terrainOptions.useSlope,
+                    }),
+                    ...(this.props.terrainOptions?.useSwissRelief !== undefined && {
+                        useSwissRelief: this.props.terrainOptions.useSwissRelief,
+                    }),
+                    ...(this.props.terrainOptions?.hillshadeAzimuth !== undefined && {
+                        hillshadeAzimuth: this.props.terrainOptions.hillshadeAzimuth,
+                    }),
+                    ...(this.props.terrainOptions?.hillshadeAltitude !== undefined && {
+                        hillshadeAltitude: this.props.terrainOptions.hillshadeAltitude,
+                    }),
+                    ...(this.props.terrainOptions?.zFactor !== undefined && {
+                        zFactor: this.props.terrainOptions.zFactor,
+                    }),
                 },
-                onViewportLoad: this.onViewportLoad.bind(this),
-                zRange: this.state.zRange || null,
-                tileSize,
-                minZoom: this.state.minZoom,
-                maxZoom: this.state.maxZoom,
-                extent,
-                maxRequests,
-                onTileLoad,
-                onTileUnload,
-                onTileError,
-                maxCacheSize,
-                maxCacheByteSize,
-                refinementStrategy,
-            });
+                renderSubLayers: {
+                    disableTexture: this.props.disableTexture,
+                    terrainOptions: this.props.terrainOptions,
+                },
+            },
+            onViewportLoad: this.onViewportLoad.bind(this),
+            zRange: this.state.zRange || null,
+            tileSize,
+            minZoom: effectiveMinZoom,
+            maxZoom: effectiveMaxZoom,
+            extent,
+            maxRequests,
+            onTileLoad: (tile) => {
+                // Release progressive loading gate as soon as any minZoom tile finishes loading.
+                // This fires mid-cycle so the TileLayer immediately re-selects high-res tiles
+                // for the current viewport without requiring a zoom/pan interaction.
+                if (this.props.enableProgressiveLoading &&
+                    tile.index.z === this.state.minZoom &&
+                    !this.state.overviewLoaded) {
+                    this.setState({ overviewLoaded: true });
+                }
+                this.props.onTileLoad?.(tile);
+            },
+            onTileUnload,
+            onTileError,
+            maxCacheSize,
+            maxCacheByteSize,
+            refinementStrategy,
+        });
+    }
+    _finalize() {
+        // Clean up pending zRangeUpdate callback timer on layer unmount
+        if (this.zRangeUpdateTimeoutId !== null) {
+            clearTimeout(this.zRangeUpdateTimeoutId);
+            this.zRangeUpdateTimeoutId = null;
         }
-        return null;
+        super._finalize?.();
     }
 }
 
@@ -15670,5 +16023,5 @@ var webimage = /*#__PURE__*/Object.freeze({
     default: WebImageDecoder
 });
 
-export { CogBitmapLayer, CogTerrainLayer, CogTiles, GeoImage, extractTerrainCoordinate, sampleTerrainTileCoordinates, suppressGlobalAbortErrors };
+export { CogBitmapLayer, CogTerrainLayer, CogTiles, GeoImage, extractTerrainCoordinate, sampleTerrainTileCoordinates, suppressGlobalAbortErrors, terminateGlobalTerrainWorkerPool };
 //# sourceMappingURL=index.js.map