@developmentseed/deck.gl-raster 0.7.0 → 0.8.0-beta.1

package/dist/fp64.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Split a Float64Array into the high + low Float32 component arrays used for
+ * fp64-emulated positions on the GPU.
+ *
+ * For each element `v`, the high part is `Math.fround(v)` (the nearest
+ * float32) and the low part is the residual `v - Math.fround(v)` (also exactly
+ * representable as a float32, since `|residual| <= ulp_f32(v) / 2`). Summed in
+ * the shader, the pair carries float64-equivalent precision — deck.gl's
+ * projection shader takes both via its `position64Low` parameter and adds
+ * `modelMatrix * low` back after the main computation.
+ *
+ * @returns `[low, high]` — both `Float32Array`s the same length as `values`.
+ *
+ * See `dev-docs/coordinate-systems.md` and
+ * `dev-docs/specs/2026-05-19-high-zoom-precision-design.md`.
+ */
+export declare function splitFloat64Array(values: Float64Array): [low: Float32Array, high: Float32Array];
+//# sourceMappingURL=fp64.d.ts.map

package/dist/fp64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64.d.ts","sourceRoot":"","sources":["../src/fp64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,GACnB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,CAAC,CAUzC"}

package/dist/fp64.js

@@ -0,0 +1,28 @@
+/**
+ * Split a Float64Array into the high + low Float32 component arrays used for
+ * fp64-emulated positions on the GPU.
+ *
+ * For each element `v`, the high part is `Math.fround(v)` (the nearest
+ * float32) and the low part is the residual `v - Math.fround(v)` (also exactly
+ * representable as a float32, since `|residual| <= ulp_f32(v) / 2`). Summed in
+ * the shader, the pair carries float64-equivalent precision — deck.gl's
+ * projection shader takes both via its `position64Low` parameter and adds
+ * `modelMatrix * low` back after the main computation.
+ *
+ * @returns `[low, high]` — both `Float32Array`s the same length as `values`.
+ *
+ * See `dev-docs/coordinate-systems.md` and
+ * `dev-docs/specs/2026-05-19-high-zoom-precision-design.md`.
+ */
+export function splitFloat64Array(values) {
+    const low = new Float32Array(values.length);
+    const high = new Float32Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+        const v = values[i];
+        const hi = Math.fround(v);
+        high[i] = hi;
+        low[i] = v - hi;
+    }
+    return [low, high];
+}
+//# sourceMappingURL=fp64.js.map

package/dist/fp64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64.js","sourceRoot":"","sources":["../src/fp64.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAoB;IAEpB,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;QACrB,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACrB,CAAC"}

package/dist/globe-grid-mesh.d.ts

@@ -0,0 +1,30 @@
+import type { ReprojectionFns } from "@developmentseed/raster-reproject";
+/**
+ * Default per-tile grid resolution for the globe scaffold. An `n × n` grid of
+ * cells (so `(n+1)²` vertices). 32 keeps low-zoom tiles smooth on the sphere
+ * while staying cheap (≈1089 verts / 2048 triangles per tile).
+ */
+export declare const GLOBE_GRID_SIZE = 32;
+/**
+ * THROWAWAY globe scaffold. Builds a uniform `gridSize × gridSize` triangle
+ * grid over a tile in UV space and reprojects each vertex through the same
+ * `forwardTransform` → `forwardReproject` chain {@link RasterReprojector} uses,
+ * producing output positions in the layer's output CRS (lng/lat in globe mode).
+ *
+ * Why this exists: the adaptive Delatin mesh subdivides on *reprojection*
+ * error, which is ~0 for an EPSG:4326 source, so it emits 2 triangles that
+ * chord straight through the sphere and visibly facet at low zoom. A uniform
+ * grid is a stopgap so the prototype is legible. It is NOT the real fix —
+ * remove it once sphere-aware reprojection lands. See
+ * `dev-docs/specs/2026-05-21-globe-view-design.md`.
+ *
+ * `width`/`height` match {@link RasterReprojector}'s convention (pass the
+ * image dimensions + 1); pixel coordinates span `[0, width-1] × [0, height-1]`.
+ */
+export declare function buildUniformGridMesh(reprojectionFns: ReprojectionFns, width: number, height: number, gridSize?: number): {
+    indices: Uint32Array;
+    positions64High: Float32Array;
+    positions64Low: Float32Array;
+    texCoords: Float32Array;
+};
+//# sourceMappingURL=globe-grid-mesh.d.ts.map

package/dist/globe-grid-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globe-grid-mesh.d.ts","sourceRoot":"","sources":["../src/globe-grid-mesh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAGzE;;;;GAIG;AACH,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,eAAe,EAChC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAwB,GACjC;IACD,OAAO,EAAE,WAAW,CAAC;IACrB,eAAe,EAAE,YAAY,CAAC;IAC9B,cAAc,EAAE,YAAY,CAAC;IAC7B,SAAS,EAAE,YAAY,CAAC;CACzB,CA+CA"}

package/dist/globe-grid-mesh.js

@@ -0,0 +1,67 @@
+import { splitFloat64Array } from "./fp64.js";
+/**
+ * Default per-tile grid resolution for the globe scaffold. An `n × n` grid of
+ * cells (so `(n+1)²` vertices). 32 keeps low-zoom tiles smooth on the sphere
+ * while staying cheap (≈1089 verts / 2048 triangles per tile).
+ */
+export const GLOBE_GRID_SIZE = 32;
+/**
+ * THROWAWAY globe scaffold. Builds a uniform `gridSize × gridSize` triangle
+ * grid over a tile in UV space and reprojects each vertex through the same
+ * `forwardTransform` → `forwardReproject` chain {@link RasterReprojector} uses,
+ * producing output positions in the layer's output CRS (lng/lat in globe mode).
+ *
+ * Why this exists: the adaptive Delatin mesh subdivides on *reprojection*
+ * error, which is ~0 for an EPSG:4326 source, so it emits 2 triangles that
+ * chord straight through the sphere and visibly facet at low zoom. A uniform
+ * grid is a stopgap so the prototype is legible. It is NOT the real fix —
+ * remove it once sphere-aware reprojection lands. See
+ * `dev-docs/specs/2026-05-21-globe-view-design.md`.
+ *
+ * `width`/`height` match {@link RasterReprojector}'s convention (pass the
+ * image dimensions + 1); pixel coordinates span `[0, width-1] × [0, height-1]`.
+ */
+export function buildUniformGridMesh(reprojectionFns, width, height, gridSize = GLOBE_GRID_SIZE) {
+    const { forwardTransform, forwardReproject } = reprojectionFns;
+    const cols = gridSize;
+    const rows = gridSize;
+    const numVerts = (cols + 1) * (rows + 1);
+    const positions = new Float64Array(numVerts * 3);
+    const texCoords = new Float32Array(numVerts * 2);
+    let vi = 0;
+    for (let r = 0; r <= rows; r++) {
+        for (let c = 0; c <= cols; c++) {
+            const u = c / cols;
+            const v = r / rows;
+            const pixelX = u * (width - 1);
+            const pixelY = v * (height - 1);
+            const [inputX, inputY] = forwardTransform(pixelX, pixelY);
+            const [outX, outY] = forwardReproject(inputX, inputY);
+            positions[vi * 3] = outX;
+            positions[vi * 3 + 1] = outY;
+            positions[vi * 3 + 2] = 0;
+            texCoords[vi * 2] = u;
+            texCoords[vi * 2 + 1] = v;
+            vi++;
+        }
+    }
+    const [positions64Low, positions64High] = splitFloat64Array(positions);
+    const indices = new Uint32Array(cols * rows * 6);
+    let ii = 0;
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < cols; c++) {
+            const i0 = r * (cols + 1) + c;
+            const i1 = i0 + 1;
+            const i2 = i0 + (cols + 1);
+            const i3 = i2 + 1;
+            indices[ii++] = i0;
+            indices[ii++] = i2;
+            indices[ii++] = i1;
+            indices[ii++] = i1;
+            indices[ii++] = i2;
+            indices[ii++] = i3;
+        }
+    }
+    return { indices, positions64High, positions64Low, texCoords };
+}
+//# sourceMappingURL=globe-grid-mesh.js.map

package/dist/globe-grid-mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globe-grid-mesh.js","sourceRoot":"","sources":["../src/globe-grid-mesh.ts"],"names":[],"mappings":"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"}

package/dist/gpu-modules/cutline-bbox.d.ts

@@ -1,19 +1,23 @@
 /** Props for the {@link CutlineBbox} shader module. */
 export type CutlineBboxProps = {
     /**
-     * Axis-aligned bbox in **EPSG:3857 meters**, packed as
-     * `[minX, minY, maxX, maxY]`. This must be in the same coordinate space
-     * as the layer's mesh `positions` attribute — for `COGLayer` /
-     * `RasterLayer`'s Web Mercator rendering path, that is raw 3857 meters.
+     * Axis-aligned clip region in deck.gl **common space** (world units),
+     * packed as `[minX, minY, maxX, maxY]`. This must be in the same coordinate
+     * space as the layer's mesh `positions` attribute — for `COGLayer` /
+     * `RasterLayer`'s Web Mercator rendering path, that is deck.gl common space.
      *
-     * Use {@link lngLatToMercator} to project a WGS84 lng/lat bbox once
-     * at bbox definition time.
+     * Project a WGS84 lng/lat bbox to common space **once at bbox definition
+     * time** with deck.gl's `WebMercatorViewport.projectPosition` (or
+     * `@math.gl/web-mercator`'s `lngLatToWorld`). Do *not* convert per frame:
+     * `getUniforms` here is a pass-through, but luma.gl calls it on every
+     * `setProps` (i.e. every draw), so any projection placed in it would run
+     * each animation frame.
      */
-    bbox: [number, number, number, number];
+    bbox: [minX: number, minY: number, maxX: number, maxY: number];
 };
 /**
- * A shader module that discards fragments whose position falls outside a
- * Web Mercator (EPSG:3857) axis-aligned bbox.
+ * A shader module that discards fragments whose position falls outside an
+ * axis-aligned common-space bbox.
  *
  * Intended for rendering rasters with a "map collar" (e.g. USGS historical
  * topographic maps) where the valid data area is described as a bbox but
@@ -23,49 +27,31 @@ export type CutlineBboxProps = {
  * responsible for enforcing this in application code; the module itself
  * does not have viewport access.
  *
- * This module assumes the layer's mesh `positions` attribute is in EPSG:3857
- * meters — the convention used by `COGLayer` / `RasterLayer` in Web Mercator
- * rendering mode. It injects a vertex shader varying that passes each
- * vertex's 3857 meters through to the fragment shader, and compares against
- * a uniform bbox also in 3857 meters. This avoids deck.gl's common space and
- * its viewport-anchored precision translation, which would otherwise cause
- * the test to drift at higher zoom levels.
+ * The module assumes the layer's mesh `positions` attribute is in deck.gl
+ * **common space** (world units) — the convention used by `COGLayer` /
+ * `RasterLayer` in the Web Mercator rendering path. It injects a vertex
+ * shader varying that passes each vertex's common-space position through to
+ * the fragment shader, and compares against a uniform bbox also in common
+ * space. Capturing the raw `positions` attribute (rather than deck.gl's
+ * viewport-anchored, camera-relative `position_commonspace`) keeps the test
+ * stable across zoom levels.
  */
 export declare const CutlineBbox: {
     readonly name: "cutlineBbox";
     readonly fs: "uniform cutlineBboxUniforms {\n  vec4 bbox;\n} cutlineBbox;\n";
     readonly inject: {
-        readonly "vs:#decl": "out vec2 v_cutlineBboxMercator;";
-        readonly "vs:#main-start": "\n      v_cutlineBboxMercator = positions.xy;\n    ";
-        readonly "fs:#decl": "in vec2 v_cutlineBboxMercator;";
-        readonly "fs:#main-start": "\n      {\n        if (v_cutlineBboxMercator.x < cutlineBbox.bbox.x ||\n            v_cutlineBboxMercator.x > cutlineBbox.bbox.z ||\n            v_cutlineBboxMercator.y < cutlineBbox.bbox.y ||\n            v_cutlineBboxMercator.y > cutlineBbox.bbox.w) {\n          discard;\n        }\n      }\n    ";
+        readonly "vs:#decl": "out vec2 v_cutlineBboxCommon;";
+        readonly "vs:#main-start": "\n      v_cutlineBboxCommon = positions.xy;\n    ";
+        readonly "fs:#decl": "in vec2 v_cutlineBboxCommon;";
+        readonly "fs:#main-start": "\n      {\n        if (v_cutlineBboxCommon.x < cutlineBbox.bbox.x ||\n            v_cutlineBboxCommon.x > cutlineBbox.bbox.z ||\n            v_cutlineBboxCommon.y < cutlineBbox.bbox.y ||\n            v_cutlineBboxCommon.y > cutlineBbox.bbox.w) {\n          discard;\n        }\n      }\n    ";
     };
     readonly uniformTypes: {
         readonly bbox: "vec4<f32>";
     };
     readonly getUniforms: (props: Partial<CutlineBboxProps>) => {
-        bbox: [number, number, number, number];
+        bbox: [minX: number, minY: number, maxX: number, maxY: number];
     } | {
         bbox?: undefined;
     };
 };
-/**
- * Project a single WGS84 lng/lat point (degrees) to EPSG:3857 meters.
- *
- * Throws if the latitude falls outside the Web Mercator projection's valid
- * range (±85.051129°).
- *
- * This is intended to be used with the {@link CutlineBbox} module, which
- * expects a bbox in 3857 meters. The conversion from WGS84 to 3857 is a
- * one-time cost that can be done at bbox definition time, rather than per frame
- * in the shader.
- *
- * @example
- * ```ts
- * const [west, south] = lngLatToMercator(-120.75, 39.25);
- * const [east, north] = lngLatToMercator(-120.5, 39.5);
- * const bbox = [west, south, east, north];
- * ```
- */
-export declare function lngLatToMercator(lng: number, lat: number): [number, number];
 //# sourceMappingURL=cutline-bbox.d.ts.map

package/dist/gpu-modules/cutline-bbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cutline-bbox.d.ts","sourceRoot":"","sources":["../../src/gpu-modules/cutline-bbox.ts"],"names":[],"mappings":"AAQA,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;;OAQG;IACH,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC,CAAC;AAUF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;kCAyCD,OAAO,CAAC,gBAAgB,CAAC;;;;;CAEG,CAAC;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAU3E"}
+{"version":3,"file":"cutline-bbox.d.ts","sourceRoot":"","sources":["../../src/gpu-modules/cutline-bbox.ts"],"names":[],"mappings":"AAEA,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;;;;;;OAYG;IACH,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;CAChE,CAAC;AAUF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;kCAyCD,OAAO,CAAC,gBAAgB,CAAC;;;;;CAEG,CAAC"}

package/dist/gpu-modules/cutline-bbox.js

@@ -1,7 +1,3 @@
-/** Earth equatorial radius used by Web Mercator (WGS84 / EPSG:3857). */
-const EARTH_RADIUS = 6378137.0;
-/** Web Mercator latitude limit in degrees. */
-const MERCATOR_LAT_LIMIT = 85.051129;
 const MODULE_NAME = "cutlineBbox";
 const uniformBlock = `\
 uniform ${MODULE_NAME}Uniforms {
@@ -9,8 +5,8 @@ uniform ${MODULE_NAME}Uniforms {
 } ${MODULE_NAME};
 `;
 /**
- * A shader module that discards fragments whose position falls outside a
- * Web Mercator (EPSG:3857) axis-aligned bbox.
+ * A shader module that discards fragments whose position falls outside an
+ * axis-aligned common-space bbox.
  *
  * Intended for rendering rasters with a "map collar" (e.g. USGS historical
  * topographic maps) where the valid data area is described as a bbox but
@@ -20,28 +16,29 @@ uniform ${MODULE_NAME}Uniforms {
  * responsible for enforcing this in application code; the module itself
  * does not have viewport access.
  *
- * This module assumes the layer's mesh `positions` attribute is in EPSG:3857
- * meters — the convention used by `COGLayer` / `RasterLayer` in Web Mercator
- * rendering mode. It injects a vertex shader varying that passes each
- * vertex's 3857 meters through to the fragment shader, and compares against
- * a uniform bbox also in 3857 meters. This avoids deck.gl's common space and
- * its viewport-anchored precision translation, which would otherwise cause
- * the test to drift at higher zoom levels.
+ * The module assumes the layer's mesh `positions` attribute is in deck.gl
+ * **common space** (world units) — the convention used by `COGLayer` /
+ * `RasterLayer` in the Web Mercator rendering path. It injects a vertex
+ * shader varying that passes each vertex's common-space position through to
+ * the fragment shader, and compares against a uniform bbox also in common
+ * space. Capturing the raw `positions` attribute (rather than deck.gl's
+ * viewport-anchored, camera-relative `position_commonspace`) keeps the test
+ * stable across zoom levels.
  */
 export const CutlineBbox = {
     name: MODULE_NAME,
     fs: uniformBlock,
     inject: {
-        // Declare the mercator-meters varying on both sides of the pipeline.
-        "vs:#decl": `out vec2 v_cutlineBboxMercator;`,
+        // Declare the common-space varying on both sides of the pipeline.
+        "vs:#decl": `out vec2 v_cutlineBboxCommon;`,
         // `positions` is the per-vertex attribute the SimpleMeshLayer vertex
         // shader reads (see @deck.gl/mesh-layers simple-mesh-layer-vertex.glsl).
-        // In COGLayer's CARTESIAN + web-mercator path this attribute is already
-        // in EPSG:3857 meters. We capture it before any projection is applied.
+        // In COGLayer's CARTESIAN + web-mercator path this attribute is in deck.gl
+        // common space. We capture it before any projection is applied.
         "vs:#main-start": /* glsl */ `
-      v_cutlineBboxMercator = positions.xy;
+      v_cutlineBboxCommon = positions.xy;
     `,
-        "fs:#decl": `in vec2 v_cutlineBboxMercator;`,
+        "fs:#decl": `in vec2 v_cutlineBboxCommon;`,
         // Injects at fs:#main-start (not fs:DECKGL_FILTER_COLOR). The
         // DECKGL_FILTER_COLOR hook is a generated function whose body is assembled
         // before the main FS source; top-level FS varyings declared in the main
@@ -49,15 +46,15 @@ export const CutlineBbox = {
         // inside main() where the varying is visible and discard still works.
         //
         // Globe support: when rendering in a GlobeView, the mesh positions are in
-        // 4326 lng/lat rather than 3857 meters, so this exact varying is no
+        // 4326 lng/lat rather than common space, so this exact varying is no
         // longer meaningful. A future globe code path would need a different
         // varying (e.g. lng/lat pair) and matching uniform layout.
         "fs:#main-start": /* glsl */ `
       {
-        if (v_cutlineBboxMercator.x < ${MODULE_NAME}.bbox.x ||
-            v_cutlineBboxMercator.x > ${MODULE_NAME}.bbox.z ||
-            v_cutlineBboxMercator.y < ${MODULE_NAME}.bbox.y ||
-            v_cutlineBboxMercator.y > ${MODULE_NAME}.bbox.w) {
+        if (v_cutlineBboxCommon.x < ${MODULE_NAME}.bbox.x ||
+            v_cutlineBboxCommon.x > ${MODULE_NAME}.bbox.z ||
+            v_cutlineBboxCommon.y < ${MODULE_NAME}.bbox.y ||
+            v_cutlineBboxCommon.y > ${MODULE_NAME}.bbox.w) {
           discard;
         }
       }
@@ -66,35 +63,9 @@ export const CutlineBbox = {
     uniformTypes: {
         bbox: "vec4<f32>",
     },
-    // Pass-through: the bbox is expected to already be in 3857 meters. The
-    // conversion from WGS84 is done by `lngLatBboxToMercator` at bbox
-    // definition time so it does not run in the per-frame render loop.
+    // Pass-through: the bbox is expected to already be in common space. Projection
+    // from WGS84 is done once at bbox definition time (see the prop docs), not
+    // here — luma.gl calls getUniforms on every setProps / draw.
     getUniforms: (props) => props.bbox ? { bbox: props.bbox } : {},
 };
-/**
- * Project a single WGS84 lng/lat point (degrees) to EPSG:3857 meters.
- *
- * Throws if the latitude falls outside the Web Mercator projection's valid
- * range (±85.051129°).
- *
- * This is intended to be used with the {@link CutlineBbox} module, which
- * expects a bbox in 3857 meters. The conversion from WGS84 to 3857 is a
- * one-time cost that can be done at bbox definition time, rather than per frame
- * in the shader.
- *
- * @example
- * ```ts
- * const [west, south] = lngLatToMercator(-120.75, 39.25);
- * const [east, north] = lngLatToMercator(-120.5, 39.5);
- * const bbox = [west, south, east, north];
- * ```
- */
-export function lngLatToMercator(lng, lat) {
-    if (lat < -MERCATOR_LAT_LIMIT || lat > MERCATOR_LAT_LIMIT) {
-        throw new Error(`lngLatToMercator: latitude must be within Web Mercator limits (±${MERCATOR_LAT_LIMIT}°); got lat=${lat}`);
-    }
-    const x = (EARTH_RADIUS * lng * Math.PI) / 180;
-    const y = EARTH_RADIUS * Math.log(Math.tan(Math.PI / 4 + (lat * Math.PI) / 360));
-    return [x, y];
-}
 //# sourceMappingURL=cutline-bbox.js.map

package/dist/gpu-modules/cutline-bbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"cutline-bbox.js","sourceRoot":"","sources":["../../src/gpu-modules/cutline-bbox.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,MAAM,YAAY,GAAG,SAAS,CAAC;AAE/B,8CAA8C;AAC9C,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAgBrC,MAAM,WAAW,GAAG,aAAa,CAAC;AAElC,MAAM,YAAY,GAAG;UACX,WAAW;;IAEjB,WAAW;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,WAAW;IACjB,EAAE,EAAE,YAAY;IAChB,MAAM,EAAE;QACN,qEAAqE;QACrE,UAAU,EAAE,iCAAiC;QAC7C,qEAAqE;QACrE,yEAAyE;QACzE,wEAAwE;QACxE,uEAAuE;QACvE,gBAAgB,EAAE,UAAU,CAAC;;KAE5B;QACD,UAAU,EAAE,gCAAgC;QAC5C,8DAA8D;QAC9D,2EAA2E;QAC3E,wEAAwE;QACxE,yEAAyE;QACzE,sEAAsE;QACtE,EAAE;QACF,0EAA0E;QAC1E,oEAAoE;QACpE,qEAAqE;QACrE,2DAA2D;QAC3D,gBAAgB,EAAE,UAAU,CAAC;;wCAEO,WAAW;wCACX,WAAW;wCACX,WAAW;wCACX,WAAW;;;;KAI9C;KACF;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,WAAW;KAClB;IACD,uEAAuE;IACvE,kEAAkE;IAClE,mEAAmE;IACnE,WAAW,EAAE,CAAC,KAAgC,EAAE,EAAE,CAChD,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE;CACS,CAAC;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAW,EAAE,GAAW;IACvD,IAAI,GAAG,GAAG,CAAC,kBAAkB,IAAI,GAAG,GAAG,kBAAkB,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,mEAAmE,kBAAkB,eAAe,GAAG,EAAE,CAC1G,CAAC;IACJ,CAAC;IACD,MAAM,CAAC,GAAG,CAAC,YAAY,GAAG,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;IAC/C,MAAM,CAAC,GACL,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACzE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChB,CAAC"}
+{"version":3,"file":"cutline-bbox.js","sourceRoot":"","sources":["../../src/gpu-modules/cutline-bbox.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,GAAG,aAAa,CAAC;AAElC,MAAM,YAAY,GAAG;UACX,WAAW;;IAEjB,WAAW;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,WAAW;IACjB,EAAE,EAAE,YAAY;IAChB,MAAM,EAAE;QACN,kEAAkE;QAClE,UAAU,EAAE,+BAA+B;QAC3C,qEAAqE;QACrE,yEAAyE;QACzE,2EAA2E;QAC3E,gEAAgE;QAChE,gBAAgB,EAAE,UAAU,CAAC;;KAE5B;QACD,UAAU,EAAE,8BAA8B;QAC1C,8DAA8D;QAC9D,2EAA2E;QAC3E,wEAAwE;QACxE,yEAAyE;QACzE,sEAAsE;QACtE,EAAE;QACF,0EAA0E;QAC1E,qEAAqE;QACrE,qEAAqE;QACrE,2DAA2D;QAC3D,gBAAgB,EAAE,UAAU,CAAC;;sCAEK,WAAW;sCACX,WAAW;sCACX,WAAW;sCACX,WAAW;;;;KAI5C;KACF;IACD,YAAY,EAAE;QACZ,IAAI,EAAE,WAAW;KAClB;IACD,+EAA+E;IAC/E,2EAA2E;IAC3E,6DAA6D;IAC7D,WAAW,EAAE,CAAC,KAAgC,EAAE,EAAE,CAChD,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE;CACS,CAAC"}

package/dist/gpu-modules/index.d.ts

@@ -7,7 +7,7 @@ export { buildCompositeBandsProps, CompositeBands, } from "./composite-bands.js"
 export { createColormapTexture } from "./create-colormap-texture.js";
 export { CreateTexture } from "./create-texture.js";
 export type { CutlineBboxProps } from "./cutline-bbox.js";
-export { CutlineBbox, lngLatToMercator } from "./cutline-bbox.js";
+export { CutlineBbox } from "./cutline-bbox.js";
 export type { ColormapSpriteSource } from "./decode-colormap-sprite.js";
 export { decodeColormapSprite } from "./decode-colormap-sprite.js";
 export { FilterNoDataVal } from "./filter-nodata.js";

package/dist/gpu-modules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gpu-modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,GACX,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,EACd,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EACL,wBAAwB,EACxB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAClE,YAAY,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gpu-modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,GACX,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,EACd,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EACL,wBAAwB,EACxB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/gpu-modules/index.js

@@ -4,7 +4,7 @@ export { COLORMAP_INDEX, } from "./colormap-names.js";
 export { buildCompositeBandsProps, CompositeBands, } from "./composite-bands.js";
 export { createColormapTexture } from "./create-colormap-texture.js";
 export { CreateTexture } from "./create-texture.js";
-export { CutlineBbox, lngLatToMercator } from "./cutline-bbox.js";
+export { CutlineBbox } from "./cutline-bbox.js";
 export { decodeColormapSprite } from "./decode-colormap-sprite.js";
 export { FilterNoDataVal } from "./filter-nodata.js";
 export { LinearRescale } from "./linear-rescale.js";

package/dist/gpu-modules/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/gpu-modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,GACX,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,GAEf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,wBAAwB,EACxB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/gpu-modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,GACX,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,GAEf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,wBAAwB,EACxB,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/mesh-layer/mesh-layer-fragment.glsl.d.ts

@@ -7,6 +7,6 @@
  * support integer and signed integer textures, not only normalized unsigned
  * textures.
  */
-declare const _default: "#version 300 es\n#define SHADER_NAME simple-mesh-layer-fs\n\nprecision highp float;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  geometry.uv = vTexCoord;\n\n  vec3 normal;\n  if (simpleMesh.flatShading) {\n\n  normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n  } else {\n    normal = normals_commonspace;\n  }\n\n  // We initialize color here before passing into DECKGL_FILTER_COLOR\n  vec4 color;\n  DECKGL_FILTER_COLOR(color, geometry);\n\n  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n  fragColor = vec4(lightColor, color.a * layer.opacity);\n}\n";
+declare const _default: "#version 300 es\n#define SHADER_NAME mesh-texture-layer-fs\n\nprecision highp float;\n\nin vec2 vTexCoord;\nin vec3 cameraPosition;\nin vec3 normals_commonspace;\nin vec4 position_commonspace;\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  geometry.uv = vTexCoord;\n\n  vec3 normal;\n  if (simpleMesh.flatShading) {\n\n  normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));\n  } else {\n    normal = normals_commonspace;\n  }\n\n  // We initialize color here before passing into DECKGL_FILTER_COLOR\n  vec4 color;\n  DECKGL_FILTER_COLOR(color, geometry);\n\n  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);\n  fragColor = vec4(lightColor, color.a * layer.opacity);\n}\n";
 export default _default;
 //# sourceMappingURL=mesh-layer-fragment.glsl.d.ts.map

package/dist/mesh-layer/mesh-layer-fragment.glsl.js

@@ -8,7 +8,7 @@
  * textures.
  */
 export default /* glsl */ `#version 300 es
-#define SHADER_NAME simple-mesh-layer-fs
+#define SHADER_NAME mesh-texture-layer-fs
 
 precision highp float;
 

package/dist/mesh-layer/mesh-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "#version 300 es\n#define SHADER_NAME mesh-texture-layer-vs\n\n// Primitive attributes\nin vec3 positions;\nin vec3 positions64Low;\nin vec3 normals;\nin vec3 colors;\nin vec2 texCoords;\n\n// Instance attributes\nin vec3 instancePositions;\nin vec3 instancePositions64Low;\nin vec4 instanceColors;\nin vec3 instancePickingColors;\nin vec3 instanceModelMatrixCol0;\nin vec3 instanceModelMatrixCol1;\nin vec3 instanceModelMatrixCol2;\nin vec3 instanceTranslation;\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\n\nvoid main(void) {\n  geometry.worldPosition = instancePositions;\n  geometry.uv = texCoords;\n  geometry.pickingColor = instancePickingColors;\n\n  vTexCoord = texCoords;\n  cameraPosition = project.cameraPosition;\n  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);\n\n  mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);\n  vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale + instanceTranslation;\n\n  DECKGL_FILTER_SIZE(pos, geometry);\n  // Call project_normal before project_position so the normal isn't affected by\n  // a position offset (unused for unlit raster, kept for parity with upstream).\n  normals_commonspace = project_normal(instanceModelMatrix * normals);\n  geometry.worldPosition += pos;\n\n  // No composeModelMatrix branch: that flag only matters when placing an\n  // instanced model offset from an anchor. MeshTextureLayer always draws one\n  // mesh at instancePositions = [0,0,0] with identity transforms, so we project\n  // the mesh vertex directly (with its fp64 low part). This is correct for both\n  // cartesian (common-space, Web Mercator) and lnglat (degrees, GlobeView) \u2014\n  // project_position_to_clipspace handles each coordinate system.\n  gl_Position = project_position_to_clipspace(pos + instancePositions, positions64Low + instancePositions64Low, vec3(0.0), position_commonspace);\n  geometry.position = position_commonspace;\n\n  geometry.normal = normals_commonspace;\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=mesh-layer-vertex.glsl.d.ts.map

package/dist/mesh-layer/mesh-layer-vertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-vertex.glsl.ts"],"names":[],"mappings":";AA8BA,wBA2DE"}

package/dist/mesh-layer/mesh-layer-vertex.glsl.js

@@ -0,0 +1,90 @@
+// Vertex shader for MeshTextureLayer. Override of upstream's
+// simple-mesh-layer-vertex.glsl.ts (deck.gl 9.3 @
+// 09af8de8d18a9cb9a31d064cae8f9e7239df7f53):
+// https://github.com/visgl/deck.gl/blob/09af8de8d18a9cb9a31d064cae8f9e7239df7f53/modules/mesh-layers/src/simple-mesh-layer/simple-mesh-layer-vertex.glsl.ts
+//
+// Differences from upstream:
+//   1. Adds `in vec3 positions64Low;` — per-vertex low part of the
+//      fp64-split mesh position. Supplied by MeshTextureLayer via
+//      attributeManager.add (non-instanced).
+//   2. Passes `positions64Low + instancePositions64Low` to
+//      project_position_to_clipspace, so the shader's fp64 path recovers the
+//      mesh-vertex precision lost by the float32 attribute pipeline.
+//   3. Collapses upstream's `composeModelMatrix` branch to a single
+//      direct-projection path. MeshTextureLayer always draws ONE
+//      non-instanced, identity-transform mesh anchored at the origin
+//      (instancePositions = [0,0,0], identity instanceModelMatrix, sizeScale =
+//      1), so the instanced / meters-offset (upstream's `else`) branch never
+//      applied. Projecting `pos` directly is correct for BOTH cartesian
+//      (common-space mesh, Web Mercator) and lnglat (degrees, GlobeView):
+//      project_position_to_clipspace handles each coordinate system. This is
+//      what makes GlobeView render correctly — upstream's `else` branch ran
+//      project_size(pos) on lng/lat degrees, which is meaningless. See
+//      dev-docs/specs/2026-05-21-globe-view-design.md.
+//
+// The fp64 correction is only valid when the per-instance transforms are
+// identity. MeshTextureLayer enforces that by fixing those props and omitting
+// them from its public prop type (see MeshTextureLayer's class doc). See
+// dev-docs/specs/2026-05-19-high-zoom-precision-design.md and
+// dev-docs/coordinate-systems.md.
+export default /* glsl */ `#version 300 es
+#define SHADER_NAME mesh-texture-layer-vs
+
+// Primitive attributes
+in vec3 positions;
+in vec3 positions64Low;
+in vec3 normals;
+in vec3 colors;
+in vec2 texCoords;
+
+// Instance attributes
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in vec4 instanceColors;
+in vec3 instancePickingColors;
+in vec3 instanceModelMatrixCol0;
+in vec3 instanceModelMatrixCol1;
+in vec3 instanceModelMatrixCol2;
+in vec3 instanceTranslation;
+
+// Outputs to fragment shader
+out vec2 vTexCoord;
+out vec3 cameraPosition;
+out vec3 normals_commonspace;
+out vec4 position_commonspace;
+out vec4 vColor;
+
+void main(void) {
+  geometry.worldPosition = instancePositions;
+  geometry.uv = texCoords;
+  geometry.pickingColor = instancePickingColors;
+
+  vTexCoord = texCoords;
+  cameraPosition = project.cameraPosition;
+  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);
+
+  mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
+  vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale + instanceTranslation;
+
+  DECKGL_FILTER_SIZE(pos, geometry);
+  // Call project_normal before project_position so the normal isn't affected by
+  // a position offset (unused for unlit raster, kept for parity with upstream).
+  normals_commonspace = project_normal(instanceModelMatrix * normals);
+  geometry.worldPosition += pos;
+
+  // No composeModelMatrix branch: that flag only matters when placing an
+  // instanced model offset from an anchor. MeshTextureLayer always draws one
+  // mesh at instancePositions = [0,0,0] with identity transforms, so we project
+  // the mesh vertex directly (with its fp64 low part). This is correct for both
+  // cartesian (common-space, Web Mercator) and lnglat (degrees, GlobeView) —
+  // project_position_to_clipspace handles each coordinate system.
+  gl_Position = project_position_to_clipspace(pos + instancePositions, positions64Low + instancePositions64Low, vec3(0.0), position_commonspace);
+  geometry.position = position_commonspace;
+
+  geometry.normal = normals_commonspace;
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+//# sourceMappingURL=mesh-layer-vertex.glsl.js.map

package/dist/mesh-layer/mesh-layer-vertex.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-vertex.glsl.js","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,kDAAkD;AAClD,6CAA6C;AAC7C,4JAA4J;AAC5J,EAAE;AACF,6BAA6B;AAC7B,mEAAmE;AACnE,kEAAkE;AAClE,6CAA6C;AAC7C,2DAA2D;AAC3D,6EAA6E;AAC7E,qEAAqE;AACrE,oEAAoE;AACpE,iEAAiE;AACjE,qEAAqE;AACrE,+EAA+E;AAC/E,6EAA6E;AAC7E,wEAAwE;AACxE,0EAA0E;AAC1E,6EAA6E;AAC7E,4EAA4E;AAC5E,uEAAuE;AACvE,uDAAuD;AACvD,EAAE;AACF,yEAAyE;AACzE,8EAA8E;AAC9E,yEAAyE;AACzE,8DAA8D;AAC9D,kCAAkC;AAElC,eAAe,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DzB,CAAC"}

package/dist/mesh-layer/mesh-layer.d.ts

@@ -2,6 +2,16 @@ import type { DefaultProps, TextureSource, UpdateParameters } from "@deck.gl/cor
 import type { SimpleMeshLayerProps } from "@deck.gl/mesh-layers";
 import { SimpleMeshLayer } from "@deck.gl/mesh-layers";
 import type { RasterModule } from "../gpu-modules/types.js";
+/**
+ * `SimpleMeshLayer` props that `MeshTextureLayer` deliberately does not
+ * support. They configure per-instance 3D-model placement, which is
+ * meaningless for our single-mesh-at-the-origin use case — and a non-identity
+ * value would silently break the fp64 mesh-vertex precision correction (the
+ * `positions64Low` low part is the residual of `positions`, not of a
+ * transformed `pos`). They are fixed internally (see `defaultProps`) and
+ * omitted from the public prop type so they can't be set.
+ */
+type ExcludedSimpleMeshProps = "_instanced" | "getPosition" | "getOrientation" | "getScale" | "getTranslation" | "getTransformMatrix" | "sizeScale";
 type _MeshTextureLayerProps = {
     image: TextureSource;
     renderPipeline?: RasterModule[];
@@ -9,20 +19,33 @@ type _MeshTextureLayerProps = {
     renderPipeline: RasterModule[];
     image?: TextureSource;
 };
-export type MeshTextureLayerProps = SimpleMeshLayerProps & _MeshTextureLayerProps;
+export type MeshTextureLayerProps = Omit<SimpleMeshLayerProps, ExcludedSimpleMeshProps> & _MeshTextureLayerProps;
 declare const defaultProps: DefaultProps<SimpleMeshLayerProps & {
     image: TextureSource | null;
     renderPipeline: RasterModule[];
 }>;
 /**
- * A small subclass of the SimpleMeshLayer to allow dynamic shader injections.
+ * A specialized raster-rendering layer, spiritually based on deck.gl's
+ * `SimpleMeshLayer` but with a narrower purpose: it draws **one** texture-mapped
+ * mesh anchored at the coordinate origin, not instanced 3D models.
  *
- * In the future this may expand to diverge more from the SimpleMeshLayer, such
- * as allowing the texture to be a 2D _array_.
+ * Differences from `SimpleMeshLayer`:
+ * - Allows dynamic shader injection (a render pipeline of `RasterModule`s) and
+ *   overrides the vertex/fragment shaders.
+ * - Provides fp64 mesh-vertex precision via a `positions64Low` attribute paired
+ *   with the geometry's `positions` (supplied by the caller through
+ *   `data.attributes.positions64Low`).
+ * - The per-instance placement props (`_instanced`, `getPosition`,
+ *   `getOrientation`, `getScale`, `getTranslation`, `getTransformMatrix`,
+ *   `sizeScale`) are intentionally unsupported and fixed at identity — see
+ *   {@link ExcludedSimpleMeshProps}. This is what keeps the fp64 correction
+ *   valid (the low part is the residual of `positions`, not of a transformed
+ *   vertex).
  */
 export declare class MeshTextureLayer extends SimpleMeshLayer<null, MeshTextureLayerProps> {
     static layerName: string;
     static defaultProps: typeof defaultProps;
+    initializeState(): void;
     _resolveRenderPipeline(): RasterModule[];
     updateState(params: UpdateParameters<this>): void;
     /** Returns true if the render pipeline has changed between the old and new props. */