@deck.gl/carto 9.4.0-beta.1 → 9.4.0-beta.3

package/dist/index.cjs

@@ -17,15 +17,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
 // dist/index.js
 var index_exports = {};
@@ -790,7 +790,7 @@ fn project_mercator_(lnglat: vec2<f32>) -> vec2<f32> {
   let y = clamp(lnglat.y, -89.9, 89.9);
   return vec2<f32>(
     radians(x) + PI,
-    PI + log(tan(PI * 0.25 + radians(y) * 0.5))
+    PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))
   ) * WORLD_SCALE;
 }
 
@@ -2012,6 +2012,10 @@ var import_core2 = require("@math.gl/core");
 function createMat4() {
   return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 }
+function mod(value, divisor) {
+  const modulus = value % divisor;
+  return modulus < 0 ? divisor + modulus : modulus;
+}
 function getCameraPosition(viewMatrixInverse) {
   return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]];
 }
@@ -2179,8 +2183,8 @@ var _Viewport = class _Viewport {
     }
     return PROJECTION_MODE.IDENTITY;
   }
-  // Two viewports are equal if width and height are identical, and if
-  // their view and projection matrices are (approximately) equal.
+  // Two viewports are equal if their dimensions, common-space scale, and
+  // view and projection matrices are (approximately) equal.
   equals(viewport) {
     if (!(viewport instanceof _Viewport)) {
       return false;
@@ -2188,7 +2192,7 @@ var _Viewport = class _Viewport {
     if (this === viewport) {
       return true;
     }
-    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && (0, import_core3.equals)(viewport.projectionMatrix, this.projectionMatrix) && (0, import_core3.equals)(viewport.viewMatrix, this.viewMatrix);
+    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && viewport.projectionMode === this.projectionMode && viewport.resolution === this.resolution && (0, import_core3.equals)(viewport.distanceScales.unitsPerMeter, this.distanceScales.unitsPerMeter) && (0, import_core3.equals)(viewport.projectionMatrix, this.projectionMatrix) && (0, import_core3.equals)(viewport.viewMatrix, this.viewMatrix);
   }
   /**
    * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
@@ -2525,6 +2529,10 @@ var _WebMercatorViewport = class _WebMercatorViewport extends Viewport {
     }
     return this._subViewports;
   }
+  /** Returns whether two Web Mercator viewports use the same projection settings. */
+  equals(viewport) {
+    return viewport instanceof _WebMercatorViewport && viewport._pseudoMeters === this._pseudoMeters && super.equals(viewport);
+  }
   projectPosition(xyz) {
     if (this._pseudoMeters) {
       return super.projectPosition(xyz);
@@ -3046,182 +3054,6 @@ function assert(condition, message) {
   }
 }
 
-// ../core/src/viewports/globe-viewport.ts
-var import_core6 = require("@math.gl/core");
-var import_web_mercator4 = require("@math.gl/web-mercator");
-var import_core7 = require("@math.gl/core");
-var import_web_mercator5 = require("@math.gl/web-mercator");
-var DEGREES_TO_RADIANS2 = Math.PI / 180;
-var RADIANS_TO_DEGREES = 180 / Math.PI;
-var EARTH_RADIUS = 6370972;
-var GLOBE_RADIUS = 256;
-function getDistanceScales2() {
-  const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
-  const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
-  return {
-    unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
-    unitsPerMeter2: [0, 0, 0],
-    metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
-    unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
-    unitsPerDegree2: [0, 0, 0],
-    degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
-  };
-}
-var GlobeViewport = class extends Viewport {
-  constructor(opts = {}) {
-    const {
-      longitude = 0,
-      bearing = 0,
-      pitch = 0,
-      zoom = 0,
-      // Matches Maplibre defaults
-      // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
-      nearZMultiplier = 0.5,
-      farZMultiplier = 1,
-      resolution = 10
-    } = opts;
-    let { latitude = 0, height, altitude = 1.5, fovy } = opts;
-    latitude = Math.max(Math.min(latitude, 90), -90);
-    height = height || 1;
-    if (fovy) {
-      altitude = (0, import_web_mercator4.fovyToAltitude)(fovy);
-    } else {
-      fovy = (0, import_web_mercator4.altitudeToFovy)(altitude);
-    }
-    const scaleLatitude = Math.max(Math.min(latitude, import_web_mercator5.MAX_LATITUDE), -import_web_mercator5.MAX_LATITUDE);
-    const scale = Math.pow(2, zoom - zoomAdjust(scaleLatitude));
-    const pitchRadians = pitch * DEGREES_TO_RADIANS2;
-    const nearZ = opts.nearZ ?? nearZMultiplier;
-    const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale / height / Math.max(Math.cos(pitchRadians), 0.1)) * farZMultiplier;
-    const viewMatrix = new import_core6.Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }).rotateX(-pitchRadians).rotateY(-bearing * DEGREES_TO_RADIANS2).rotateX(latitude * DEGREES_TO_RADIANS2).rotateZ(-longitude * DEGREES_TO_RADIANS2).scale(scale / height);
-    super({
-      ...opts,
-      // x, y, width,
-      height,
-      // view matrix
-      viewMatrix,
-      longitude,
-      latitude,
-      zoom,
-      // projection matrix parameters
-      distanceScales: getDistanceScales2(),
-      fovy,
-      focalDistance: altitude,
-      near: nearZ,
-      far: farZ
-    });
-    this.scale = scale;
-    this.latitude = latitude;
-    this.longitude = longitude;
-    this.bearing = bearing;
-    this.pitch = pitch;
-    this.fovy = fovy;
-    this.resolution = resolution;
-  }
-  get projectionMode() {
-    return PROJECTION_MODE.GLOBE;
-  }
-  getDistanceScales() {
-    return this.distanceScales;
-  }
-  getBounds(options = {}) {
-    const unprojectOption = { targetZ: options.z || 0 };
-    const left = this.unproject([0, this.height / 2], unprojectOption);
-    const top = this.unproject([this.width / 2, 0], unprojectOption);
-    const right = this.unproject([this.width, this.height / 2], unprojectOption);
-    const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
-    if (right[0] < this.longitude) right[0] += 360;
-    if (left[0] > this.longitude) left[0] -= 360;
-    return [
-      Math.min(left[0], right[0], top[0], bottom[0]),
-      Math.min(left[1], right[1], top[1], bottom[1]),
-      Math.max(left[0], right[0], top[0], bottom[0]),
-      Math.max(left[1], right[1], top[1], bottom[1])
-    ];
-  }
-  unproject(xyz, { topLeft = true, targetZ } = {}) {
-    const [x, y, z] = xyz;
-    const y2 = topLeft ? y : this.height - y;
-    const { pixelUnprojectionMatrix } = this;
-    let coord;
-    if (Number.isFinite(z)) {
-      coord = transformVector(pixelUnprojectionMatrix, [x, y2, z, 1]);
-    } else {
-      const coord0 = transformVector(pixelUnprojectionMatrix, [x, y2, -1, 1]);
-      const coord1 = transformVector(pixelUnprojectionMatrix, [x, y2, 1, 1]);
-      const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-      const lSqr = import_core7.vec3.sqrLen(import_core7.vec3.sub([], coord0, coord1));
-      const l0Sqr = import_core7.vec3.sqrLen(coord0);
-      const l1Sqr = import_core7.vec3.sqrLen(coord1);
-      const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;
-      const dSqr = 4 * sSqr / lSqr;
-      const r0 = Math.sqrt(l0Sqr - dSqr);
-      const dr = Math.sqrt(Math.max(0, lt * lt - dSqr));
-      const t = (r0 - dr) / Math.sqrt(lSqr);
-      coord = import_core7.vec3.lerp([], coord0, coord1, t);
-    }
-    const [X, Y, Z] = this.unprojectPosition(coord);
-    if (Number.isFinite(z)) {
-      return [X, Y, Z];
-    }
-    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
-  }
-  projectPosition(xyz) {
-    const [lng, lat, Z = 0] = xyz;
-    const lambda = lng * DEGREES_TO_RADIANS2;
-    const phi = lat * DEGREES_TO_RADIANS2;
-    const cosPhi = Math.cos(phi);
-    const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-    return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];
-  }
-  unprojectPosition(xyz) {
-    const [x, y, z] = xyz;
-    const D = import_core7.vec3.len(xyz);
-    const phi = Math.asin(z / D);
-    const lambda = Math.atan2(x, -y);
-    const lng = lambda * RADIANS_TO_DEGREES;
-    const lat = phi * RADIANS_TO_DEGREES;
-    const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;
-    return [lng, lat, Z];
-  }
-  projectFlat(xyz) {
-    return xyz;
-  }
-  unprojectFlat(xyz) {
-    return xyz;
-  }
-  /**
-   * Pan the globe using delta-based movement
-   * @param coords - the geographic coordinates where the pan started
-   * @param pixel - the current screen position
-   * @param startPixel - the screen position where the pan started
-   * @returns updated viewport options with new longitude/latitude
-   */
-  panByPosition([startLng, startLat, startZoom], pixel, startPixel) {
-    const scale = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
-    const rotationSpeed = 0.25 / scale;
-    const longitude = startLng + rotationSpeed * (startPixel[0] - pixel[0]);
-    let latitude = startLat - rotationSpeed * (startPixel[1] - pixel[1]);
-    latitude = Math.max(Math.min(latitude, 90), -90);
-    const out = { longitude, latitude, zoom: startZoom - zoomAdjust(startLat) };
-    out.zoom += zoomAdjust(out.latitude);
-    return out;
-  }
-};
-GlobeViewport.displayName = "GlobeViewport";
-function zoomAdjust(latitude, clampToPoles) {
-  if (clampToPoles) {
-    latitude = Math.max(Math.min(latitude, import_web_mercator5.MAX_LATITUDE), -import_web_mercator5.MAX_LATITUDE);
-  }
-  const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
-  return Math.log2(scaleAdjust);
-}
-function transformVector(matrix, vector) {
-  const result = import_core7.vec4.transformMat4([], vector, matrix);
-  import_core7.vec4.scale(result, result, 1 / result[3]);
-  return result;
-}
-
 // ../../node_modules/@luma.gl/webgl/dist/constants/webgl-constants.js
 var GLEnum;
 (function(GLEnum2) {
@@ -3874,10 +3706,10 @@ var GLEnum;
 })(GLEnum || (GLEnum = {}));
 
 // ../core/src/lib/attribute/data-column.ts
-var import_core9 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 
 // ../core/src/lib/attribute/gl-utils.ts
-var import_core8 = require("@luma.gl/core");
+var import_core6 = require("@luma.gl/core");
 function typedArrayFromDataType(type) {
   switch (type) {
     case "float64":
@@ -3886,10 +3718,10 @@ function typedArrayFromDataType(type) {
     case "unorm8":
       return Uint8ClampedArray;
     default:
-      return (0, import_core8.getTypedArrayConstructor)(type);
+      return (0, import_core6.getTypedArrayConstructor)(type);
   }
 }
-var dataTypeFromTypedArray = import_core8.dataTypeDecoder.getDataType.bind(import_core8.dataTypeDecoder);
+var dataTypeFromTypedArray = import_core6.dataTypeDecoder.getDataType.bind(import_core6.dataTypeDecoder);
 function getBufferAttributeLayout(name, accessor, deviceType) {
   if (accessor.size > 4) {
     return null;
@@ -4020,6 +3852,7 @@ var DataColumn = class {
       this._buffer = null;
     }
     typed_array_manager_default.release(this.state.allocatedValue);
+    this.state.allocatedValue = null;
   }
   getBuffer() {
     if (this.state.constant && this.device.type !== "webgpu") {
@@ -4139,7 +3972,7 @@ var DataColumn = class {
     let opts;
     if (ArrayBuffer.isView(data)) {
       opts = { value: data };
-    } else if (data instanceof import_core9.Buffer) {
+    } else if (data instanceof import_core7.Buffer) {
       opts = { buffer: data };
     } else {
       opts = data;
@@ -4339,7 +4172,7 @@ var DataColumn = class {
       this._buffer.destroy();
     }
     const { isIndexed, type } = this.settings;
-    const usage = this.device.type === "webgpu" && !isIndexed ? import_core9.Buffer.VERTEX | import_core9.Buffer.STORAGE | import_core9.Buffer.COPY_DST | import_core9.Buffer.COPY_SRC : (isIndexed ? import_core9.Buffer.INDEX : import_core9.Buffer.VERTEX) | import_core9.Buffer.COPY_DST;
+    const usage = this.device.type === "webgpu" && !isIndexed ? import_core7.Buffer.VERTEX | import_core7.Buffer.STORAGE | import_core7.Buffer.COPY_DST | import_core7.Buffer.COPY_SRC : (isIndexed ? import_core7.Buffer.INDEX : import_core7.Buffer.VERTEX) | import_core7.Buffer.COPY_DST;
     this._buffer = this.device.createBuffer({
       ...(_a = this._buffer) == null ? void 0 : _a.props,
       id: this.id,
@@ -4969,6 +4802,7 @@ ${getComputeBlock(module2.name, inputEntries, output, elementWise, expression)}
   );
   const computation = new import_engine2.Computation(outputBuffer.device, {
     source: source4,
+    modules: module2.dependencies,
     shaderAssembler: GPGPU_SHADER_ASSEMBLER,
     shaderLayout: {
       bindings: [
@@ -6360,11 +6194,11 @@ var AttributeManager = class {
 };
 
 // ../core/src/lib/layer.ts
-var import_core12 = require("@luma.gl/core");
+var import_core10 = require("@luma.gl/core");
 var import_webgl = require("@luma.gl/webgl");
 
 // ../core/src/transitions/cpu-interpolation-transition.ts
-var import_core10 = require("@math.gl/core");
+var import_core8 = require("@math.gl/core");
 var CPUInterpolationTransition = class extends Transition {
   get value() {
     return this._value;
@@ -6375,7 +6209,7 @@ var CPUInterpolationTransition = class extends Transition {
       settings: { fromValue, toValue, duration, easing }
     } = this;
     const t = easing(time / duration);
-    this._value = (0, import_core10.lerp)(fromValue, toValue, t);
+    this._value = (0, import_core8.lerp)(fromValue, toValue, t);
   }
 };
 
@@ -6735,7 +6569,7 @@ function mergeShaders(target, source4) {
 }
 
 // ../core/src/utils/texture.ts
-var import_core11 = require("@luma.gl/core");
+var import_core9 = require("@luma.gl/core");
 var DEFAULT_TEXTURE_PARAMETERS = {
   minFilter: "linear",
   mipmapFilter: "linear",
@@ -6745,7 +6579,7 @@ var DEFAULT_TEXTURE_PARAMETERS = {
 };
 var internalTextures = {};
 function createTexture(owner, device, image, sampler) {
-  if (image instanceof import_core11.Texture) {
+  if (image instanceof import_core9.Texture) {
     return image;
   } else if (image.constructor && image.constructor.name !== "Object") {
     image = { data: image };
@@ -6776,7 +6610,7 @@ function createTexture(owner, device, image, sampler) {
   return texture;
 }
 function destroyTexture(owner, texture) {
-  if (!texture || !(texture instanceof import_core11.Texture)) {
+  if (!texture || !(texture instanceof import_core9.Texture)) {
     return;
   }
   if (internalTextures[texture.id] === owner) {
@@ -7404,8 +7238,8 @@ var LayerState = class extends ComponentState {
 };
 
 // ../core/src/lib/layer.ts
-var import_web_mercator6 = require("@math.gl/web-mercator");
-var import_core13 = require("@loaders.gl/core");
+var import_web_mercator4 = require("@math.gl/web-mercator");
+var import_core11 = require("@loaders.gl/core");
 var TRACE_CHANGE_FLAG = "layer.changeFlag";
 var TRACE_INITIALIZE = "layer.initialize";
 var TRACE_UPDATE = "layer.update";
@@ -7468,7 +7302,7 @@ var defaultProps = {
       }
       let inResourceManager = resourceManager.contains(url);
       if (!inResourceManager && !loadOptions) {
-        resourceManager.add({ resourceId: url, data: (0, import_core13.load)(url, loaders), persistent: false });
+        resourceManager.add({ resourceId: url, data: (0, import_core11.load)(url, loaders), persistent: false });
         inResourceManager = true;
       }
       if (inResourceManager) {
@@ -7482,7 +7316,7 @@ var defaultProps = {
           requestId: propName
         });
       }
-      return (0, import_core13.load)(url, loaders, loadOptions);
+      return (0, import_core11.load)(url, loaders, loadOptions);
     }
   },
   updateTriggers: {},
@@ -7552,7 +7386,7 @@ var Layer = class extends Component {
       coordinateOrigin: this.props.coordinateOrigin,
       coordinateSystem: this.props.coordinateSystem
     });
-    const [x, y, z] = (0, import_web_mercator6.worldToPixels)(worldPosition, viewport.pixelProjectionMatrix);
+    const [x, y, z] = (0, import_web_mercator4.worldToPixels)(worldPosition, viewport.pixelProjectionMatrix);
     return xyz.length === 2 ? [x, y] : [x, y, z];
   }
   /** Unprojects a screen pixel to the current view's default coordinate system
@@ -7963,7 +7797,7 @@ var Layer = class extends Component {
       const values = changedAttributes[name].getValue();
       for (const attributeName in values) {
         const value = values[attributeName];
-        if (value instanceof import_core12.Buffer) {
+        if (value instanceof import_core10.Buffer) {
           if (changedAttributes[name].settings.isIndexed) {
             model.setIndexBuffer(value);
           } else {
@@ -7998,7 +7832,7 @@ var Layer = class extends Component {
       const values = attribute.getValue();
       for (const attributeName in values) {
         const value = values[attributeName];
-        if (value instanceof import_core12.Buffer) {
+        if (value instanceof import_core10.Buffer) {
           if (attribute.settings.isIndexed) {
             model.setIndexBuffer(value);
           } else {
@@ -8650,6 +8484,275 @@ var CompositeLayer = class extends Layer {
 };
 CompositeLayer.layerName = "CompositeLayer";
 
+// ../core/src/viewports/globe-viewport.ts
+var import_core12 = require("@math.gl/core");
+var import_web_mercator5 = require("@math.gl/web-mercator");
+var DEGREES_TO_RADIANS2 = Math.PI / 180;
+var RADIANS_TO_DEGREES = 180 / Math.PI;
+var NORTH_UP_BEARING_THRESHOLD = 1;
+var EARTH_RADIUS = 6370972;
+var GLOBE_RADIUS = 256;
+var GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO = 0.75;
+var GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO = 1.15;
+function isGlobeNorthUp(bearing) {
+  const normalizedBearing = mod(bearing + 180, 360) - 180;
+  return Math.abs(normalizedBearing) < NORTH_UP_BEARING_THRESHOLD;
+}
+function getDistanceScales2() {
+  const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
+  const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
+  return {
+    unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
+    unitsPerMeter2: [0, 0, 0],
+    metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
+    unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
+    unitsPerDegree2: [0, 0, 0],
+    degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
+  };
+}
+var GlobeViewport = class extends Viewport {
+  constructor(opts = {}) {
+    const {
+      longitude = 0,
+      bearing = 0,
+      pitch = 0,
+      zoom = 0,
+      // Matches Maplibre defaults
+      // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
+      nearZMultiplier = 0.5,
+      farZMultiplier = 1,
+      resolution = 10
+    } = opts;
+    let { latitude = 0, height, altitude = 1.5, fovy } = opts;
+    latitude = Math.max(Math.min(latitude, 90), -90);
+    height = height || 1;
+    if (fovy) {
+      altitude = (0, import_web_mercator5.fovyToAltitude)(fovy);
+    } else {
+      fovy = (0, import_web_mercator5.altitudeToFovy)(altitude);
+    }
+    const scaleLatitude = Math.max(Math.min(latitude, import_web_mercator5.MAX_LATITUDE), -import_web_mercator5.MAX_LATITUDE);
+    const scale = Math.pow(2, zoom - zoomAdjust(scaleLatitude));
+    const pitchRadians = pitch * DEGREES_TO_RADIANS2;
+    const nearZ = opts.nearZ ?? nearZMultiplier;
+    const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale / height / Math.max(Math.cos(pitchRadians), 0.1)) * farZMultiplier;
+    const viewMatrix = new import_core12.Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }).rotateX(-pitchRadians).rotateY(-bearing * DEGREES_TO_RADIANS2).rotateX(latitude * DEGREES_TO_RADIANS2).rotateZ(-longitude * DEGREES_TO_RADIANS2).scale(scale / height);
+    super({
+      ...opts,
+      // x, y, width,
+      height,
+      // view matrix
+      viewMatrix,
+      longitude,
+      latitude,
+      zoom,
+      // projection matrix parameters
+      distanceScales: getDistanceScales2(),
+      fovy,
+      focalDistance: altitude,
+      near: nearZ,
+      far: farZ
+    });
+    this.scale = scale;
+    this.latitude = latitude;
+    this.longitude = longitude;
+    this.bearing = bearing;
+    this.pitch = pitch;
+    this.fovy = fovy;
+    this.resolution = resolution;
+  }
+  get projectionMode() {
+    return PROJECTION_MODE.GLOBE;
+  }
+  getDistanceScales() {
+    return this.distanceScales;
+  }
+  getBounds(options = {}) {
+    const unprojectOption = { targetZ: options.z || 0 };
+    const left = this.unproject([0, this.height / 2], unprojectOption);
+    const top = this.unproject([this.width / 2, 0], unprojectOption);
+    const right = this.unproject([this.width, this.height / 2], unprojectOption);
+    const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
+    if (right[0] < this.longitude) right[0] += 360;
+    if (left[0] > this.longitude) left[0] -= 360;
+    return [
+      Math.min(left[0], right[0], top[0], bottom[0]),
+      Math.min(left[1], right[1], top[1], bottom[1]),
+      Math.max(left[0], right[0], top[0], bottom[0]),
+      Math.max(left[1], right[1], top[1], bottom[1])
+    ];
+  }
+  /**
+   * Builds the screen-pixel → globe-center ray and the intermediate ray/sphere
+   * math reused by `unproject` and anchored zoom. One function so the same
+   * pixelUnprojectionMatrix work isn't duplicated.
+   */
+  _getRayToGlobe(screenPosition, { topLeft = true, targetZ } = {}) {
+    const [screenX, screenY] = screenPosition;
+    const adjustedScreenY = topLeft ? screenY : this.height - screenY;
+    const { pixelUnprojectionMatrix } = this;
+    const rayStartPosition = transformVector(pixelUnprojectionMatrix, [
+      screenX,
+      adjustedScreenY,
+      -1,
+      1
+    ]);
+    const rayEndPosition = transformVector(pixelUnprojectionMatrix, [
+      screenX,
+      adjustedScreenY,
+      1,
+      1
+    ]);
+    const radius = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
+    const rayLengthSquared = import_core12.vec3.sqrLen(import_core12.vec3.sub([], rayStartPosition, rayEndPosition));
+    const rayStartDistanceSquared = import_core12.vec3.sqrLen(rayStartPosition);
+    const rayEndDistanceSquared = import_core12.vec3.sqrLen(rayEndPosition);
+    const triangleAreaSquared = (4 * rayStartDistanceSquared * rayEndDistanceSquared - (rayLengthSquared - rayStartDistanceSquared - rayEndDistanceSquared) ** 2) / 16;
+    const distanceToCenterSquared = 4 * triangleAreaSquared / rayLengthSquared;
+    return {
+      rayStartPosition,
+      rayEndPosition,
+      radius,
+      rayLengthSquared,
+      rayStartDistanceSquared,
+      distanceToCenterSquared
+    };
+  }
+  _getRayDistanceToGlobeCenterRatio(screenPosition, options) {
+    const { distanceToCenterSquared, radius } = this._getRayToGlobe(screenPosition, options);
+    return Math.sqrt(Math.max(0, distanceToCenterSquared)) / radius;
+  }
+  /**
+   * Returns how strongly a screen position should anchor zoom on the visible globe.
+   * A value of `0` means that the controller should fall back to center zoom.
+   * @param screenPosition - Screen position to evaluate.
+   * @returns Anchor strength from `0` to `1`.
+   */
+  getZoomAnchorStrength(screenPosition) {
+    const distanceRatio = this._getRayDistanceToGlobeCenterRatio(screenPosition);
+    if (distanceRatio >= GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO) {
+      return 0;
+    }
+    const edgeProgress = Math.max(
+      0,
+      Math.min(
+        1,
+        (distanceRatio - GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO) / (GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO - GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO)
+      )
+    );
+    const smoothProgress = edgeProgress * edgeProgress * (3 - 2 * edgeProgress);
+    return 1 - smoothProgress;
+  }
+  unproject(xyz, { topLeft = true, targetZ } = {}) {
+    const [x, y, z] = xyz;
+    const y2 = topLeft ? y : this.height - y;
+    const { pixelUnprojectionMatrix } = this;
+    let coord;
+    if (Number.isFinite(z)) {
+      coord = transformVector(pixelUnprojectionMatrix, [x, y2, z, 1]);
+    } else {
+      const {
+        rayStartPosition,
+        rayEndPosition,
+        radius,
+        rayLengthSquared,
+        rayStartDistanceSquared,
+        distanceToCenterSquared
+      } = this._getRayToGlobe(xyz, { topLeft, targetZ });
+      const rayStartToClosestApproach = Math.sqrt(
+        rayStartDistanceSquared - distanceToCenterSquared
+      );
+      const closestApproachToIntersection = Math.sqrt(
+        Math.max(0, radius * radius - distanceToCenterSquared)
+      );
+      const intersectionRatio = (rayStartToClosestApproach - closestApproachToIntersection) / Math.sqrt(rayLengthSquared);
+      coord = import_core12.vec3.lerp([], rayStartPosition, rayEndPosition, intersectionRatio);
+    }
+    const [X, Y, Z] = this.unprojectPosition(coord);
+    if (Number.isFinite(z)) {
+      return [X, Y, Z];
+    }
+    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
+  }
+  projectPosition(xyz) {
+    const [lng, lat, Z = 0] = xyz;
+    const lambda = lng * DEGREES_TO_RADIANS2;
+    const phi = lat * DEGREES_TO_RADIANS2;
+    const cosPhi = Math.cos(phi);
+    const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;
+    return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];
+  }
+  unprojectPosition(xyz) {
+    const [x, y, z] = xyz;
+    const D = import_core12.vec3.len(xyz);
+    const phi = Math.asin(z / D);
+    const lambda = Math.atan2(x, -y);
+    const lng = lambda * RADIANS_TO_DEGREES;
+    const lat = phi * RADIANS_TO_DEGREES;
+    const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;
+    return [lng, lat, Z];
+  }
+  projectFlat(xyz) {
+    return xyz;
+  }
+  unprojectFlat(xyz) {
+    return xyz;
+  }
+  /**
+   * Pan the globe to place geographic coordinates at a screen pixel.
+   * When `dragStartPosition` is supplied, applies the delta-based movement used by globe dragging.
+   * @param coordinates - Geographic anchor, or the starting longitude, latitude and zoom.
+   * @param screenPosition - Current screen position.
+   * @param dragStartPosition - Screen position where a drag started.
+   * @returns Updated viewport options.
+   */
+  panByPosition(coordinates, screenPosition, dragStartPosition) {
+    if (!dragStartPosition) {
+      let anchorStrength = this.getZoomAnchorStrength(screenPosition);
+      if (anchorStrength === 0) {
+        return { longitude: this.longitude, latitude: this.latitude };
+      }
+      const currentCoordinates = this.unproject(screenPosition);
+      const longitudeDelta = mod(coordinates[0] - currentCoordinates[0] + 180, 360) - 180;
+      const latitudeDelta = coordinates[1] - currentCoordinates[1];
+      const crossesPole = Math.abs(currentCoordinates[1]) > import_web_mercator5.MAX_LATITUDE || Math.abs(longitudeDelta) > 90;
+      if (isGlobeNorthUp(this.bearing) && crossesPole) {
+        return { longitude: this.longitude, latitude: this.latitude };
+      }
+      if (isGlobeNorthUp(this.bearing) && latitudeDelta !== 0) {
+        const latitudeLimit = latitudeDelta > 0 ? import_web_mercator5.MAX_LATITUDE : -import_web_mercator5.MAX_LATITUDE;
+        const latitudeConstraintStrength = (latitudeLimit - this.latitude) / latitudeDelta;
+        anchorStrength = Math.min(anchorStrength, Math.max(0, latitudeConstraintStrength));
+      }
+      const longitude2 = this.longitude + longitudeDelta * anchorStrength;
+      const latitude2 = Math.max(Math.min(this.latitude + latitudeDelta * anchorStrength, 90), -90);
+      return { longitude: longitude2, latitude: latitude2 };
+    }
+    const [startLongitude, startLatitude, startZoom] = coordinates;
+    const scale = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
+    const rotationSpeed = 0.25 / scale;
+    const longitude = startLongitude + rotationSpeed * (dragStartPosition[0] - screenPosition[0]);
+    let latitude = startLatitude - rotationSpeed * (dragStartPosition[1] - screenPosition[1]);
+    latitude = Math.max(Math.min(latitude, 90), -90);
+    const nextViewState = { longitude, latitude, zoom: startZoom - zoomAdjust(startLatitude) };
+    nextViewState.zoom += zoomAdjust(nextViewState.latitude);
+    return nextViewState;
+  }
+};
+GlobeViewport.displayName = "GlobeViewport";
+function zoomAdjust(latitude, clampToPoles) {
+  if (clampToPoles) {
+    latitude = Math.max(Math.min(latitude, import_web_mercator5.MAX_LATITUDE), -import_web_mercator5.MAX_LATITUDE);
+  }
+  const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
+  return Math.log2(scaleAdjust);
+}
+function transformVector(matrix, vector) {
+  const result = import_core12.vec4.transformMat4([], vector, matrix);
+  import_core12.vec4.scale(result, result, 1 / result[3]);
+  return result;
+}
+
 // ../core/src/lib/layer-extension.ts
 var LayerExtension = class {
   static get componentName() {
@@ -8711,7 +8814,7 @@ LayerExtension.defaultProps = {};
 LayerExtension.extensionName = "LayerExtension";
 
 // ../core/src/utils/tesselator.ts
-var import_core14 = require("@luma.gl/core");
+var import_core13 = require("@luma.gl/core");
 var Tesselator = class {
   constructor(opts) {
     this.indexStarts = [0];
@@ -8830,7 +8933,7 @@ var Tesselator = class {
       instanceCount = vertexStarts[data.length] || 0;
       if (ArrayBuffer.isView(geometryBuffer)) {
         instanceCount = instanceCount || geometryBuffer.length / this.positionSize;
-      } else if (geometryBuffer instanceof import_core14.Buffer) {
+      } else if (geometryBuffer instanceof import_core13.Buffer) {
         const byteStride = this.positionSize * 4;
         instanceCount = instanceCount || geometryBuffer.byteLength / byteStride;
       } else if (geometryBuffer.buffer) {
@@ -9183,7 +9286,7 @@ function getShaderWGSL(useRowIndexes) {
 }
 
 // ../layers/src/icon-layer/icon-manager.ts
-var import_core15 = require("@loaders.gl/core");
+var import_core14 = require("@loaders.gl/core");
 var DEFAULT_CANVAS_WIDTH = 1024;
 var DEFAULT_BUFFER = 4;
 var noop = () => {
@@ -9442,7 +9545,7 @@ var IconManager = class {
     });
     for (const icon of icons) {
       this._pendingCount++;
-      (0, import_core15.load)(icon.url, this._loadOptions).then((imageData) => {
+      (0, import_core14.load)(icon.url, this._loadOptions).then((imageData) => {
         var _a;
         const id5 = getIconId(icon);
         const iconDef = this._mapping[id5];
@@ -11156,6 +11259,25 @@ var PathTesselator = class extends Tesselator {
   get(attributeName) {
     return this.attributes[attributeName];
   }
+  /** Get rendered segment indexes in source traversal order. */
+  getPathSegmentIndices(dataIndex) {
+    const segmentTypes = this.attributes.segmentTypes;
+    const rowStart = this.vertexStarts[dataIndex];
+    const rowEnd = Math.min(
+      this.vertexStarts[dataIndex + 1] ?? this.instanceCount,
+      this.instanceCount
+    );
+    const result = [];
+    for (let segmentIndex = rowStart; segmentIndex < rowEnd - 1; segmentIndex++) {
+      if ((segmentTypes[segmentIndex] & INVALID) === 0) {
+        result.push(segmentIndex);
+      }
+    }
+    if (result.length && (segmentTypes[rowStart] & INVALID) !== 0) {
+      result.unshift(result.pop());
+    }
+    return result;
+  }
   /* Implement base Tesselator interface */
   getGeometryFromBuffer(buffer) {
     if (this.normalize || this.opts.isWebGPU) {
@@ -11351,6 +11473,9 @@ struct Varyings {
   @location(5) vJointType: f32,
   // Location 6 is reserved for TripsLayer's injected vTime varying.
   @location(7) clipCoordinates: vec2<f32>,
+#ifdef DASH_ENABLED
+  @location(8) vPathBounds: vec2<f32>,
+#endif
 };
 
 fn flipIfTrue(flag: bool) -> f32 {
@@ -11365,11 +11490,34 @@ fn clipLine(position: vec4<f32>, refPosition: vec4<f32>) -> vec4<f32> {
   return position;
 }
 
+#ifdef DASH_ENABLED
+// Return the visible interval of the original segment before clipLine moves either endpoint.
+fn getClippedPathRange(startW: f32, endW: f32) -> vec2<f32> {
+  let startClipped = startW < EPSILON;
+  let endClipped = endW < EPSILON;
+  if (startClipped && endClipped) {
+    return vec2<f32>(0.0, 0.0);
+  }
+  if (startClipped || endClipped) {
+    let intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+    if (startClipped) {
+      return vec2<f32>(intersection, 1.0);
+    }
+    return vec2<f32>(0.0, intersection);
+  }
+  return vec2<f32>(0.0, 1.0);
+}
+#endif
+
 fn getLineJoinOffset(
   prevPoint: vec3<f32>,
   currPoint: vec3<f32>,
   nextPoint: vec3<f32>,
   width: vec2<f32>,
+#ifdef DASH_ENABLED
+  sourcePathLength: f32,
+  sourcePathRange: vec2<f32>,
+#endif
 #ifdef ANTIALIASING
   coverageScale: f32,
 #endif
@@ -11406,7 +11554,43 @@ fn getLineJoinOffset(
   let miterVec = vec2<f32>(-tangent.y, tangent.x);
   let dir = select(dirB, dirA, isEnd);
   let perp = select(perpB, perpA, isEnd);
+#ifdef DASH_ENABLED
+  let segmentLength2D = select(lenB, lenA, isEnd);
+
+  // Extrusion happens in the XY plane, so segmentLength2D is a 2D length and pathPosition.y
+  // below measures 2D distance along the segment. For a path that also moves in Z the true
+  // arc length is longer by this ratio. Scaling pathLength and pathPosition.y by it makes
+  // the coordinate measure real 3D distance while leaving the joint tests unchanged, since
+  // they compare the two against each other and both are scaled alike. Billboard mode
+  // extrudes in clip space, where the perspective divide has already reduced the segment to
+  // its screen projection, so its complete common-space length is supplied by the caller.
+  // Mirrors path-layer-vertex.glsl.ts.
+  let currDelta3 = select(deltaB3, deltaA3, isEnd);
+  let currLength2D = length(currDelta3.xy);
+  // Do not clamp a valid denominator to EPSILON: high-zoom Web Mercator deltas are often
+  // smaller than that in common space, and changing their scale corrupts even flat paths.
+  let safeLength2D = select(1.0, currLength2D, currLength2D > 0.0);
+  var arcLengthRatio = 1.0;
+  var pathPositionOffset = 0.0;
+  var pathLength = segmentLength2D;
+  if (path.billboard != 0.0) {
+    // clipLine may shorten the visible screen-space segment. Preserve the corresponding interval
+    // of the complete common-space arclength instead of compressing the full dash period into the
+    // visible span. Keep pathLength complete so justification is stable as the camera clips it.
+    let visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+    arcLengthRatio = 0.0;
+    if (segmentLength2D > 0.0) {
+      arcLengthRatio = visiblePathLength / segmentLength2D;
+    }
+    pathPositionOffset = sourcePathLength * sourcePathRange.x;
+    pathLength = sourcePathLength;
+  } else if (currLength2D > 0.0) {
+    arcLengthRatio = length(currDelta3) / safeLength2D;
+    pathLength = segmentLength2D * arcLengthRatio;
+  }
+#else
   let pathLength = select(lenB, lenA, isEnd);
+#endif
 
   let sinHalfA = abs(dot(miterVec, perp));
   let cosHalfA = abs(dot(dirA, miterVec));
@@ -11453,7 +11637,11 @@ fn getLineJoinOffset(
 #endif
   let pathPosition = vec2<f32>(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   let isValid = step(f32(instanceTypes), 3.5);
 #ifdef ANTIALIASING
@@ -11512,15 +11700,38 @@ fn vertexMain(attributes: Attributes) -> Varyings {
     ) / 2.0;
 
   if (path.billboard != 0.0) {
-    var prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    let prevProjection = project_position_to_clipspace_and_commonspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    let nextProjection = project_position_to_clipspace_and_commonspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+    let prevPositionCommon = prevProjection.commonPosition.xyz;
+    let nextPositionCommon = nextProjection.commonPosition.xyz;
+    var prevPositionScreen = prevProjection.clipPosition;
+    var nextPositionScreen = nextProjection.clipPosition;
+#else
+    var prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    var nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+#endif
     let currProjection = project_position_to_clipspace_and_commonspace(
-      currPosition,
-      currPosition64Low,
-      ZERO_OFFSET
+      currPosition, currPosition64Low, ZERO_OFFSET
     );
     geometry.position = currProjection.commonPosition;
     var currPositionScreen = currProjection.clipPosition;
-    var nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    let currPositionCommon = currProjection.commonPosition.xyz;
+    let sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+    let sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+    let billboardPathRange = getClippedPathRange(
+      sourcePathStartScreen.w, sourcePathEndScreen.w
+    );
+#endif
 
     prevPositionScreen = clipLine(prevPositionScreen, currPositionScreen);
     nextPositionScreen = clipLine(nextPositionScreen, currPositionScreen);
@@ -11532,18 +11743,39 @@ fn vertexMain(attributes: Attributes) -> Varyings {
       (widthPixels + 0.5 / project.devicePixelRatio) / max(widthPixels, 1e-6),
       widthPixels > 0.0
     );
+#endif
+#ifdef DASH_ENABLED
+    let currentDeltaCommon = select(
+      nextPositionCommon - currPositionCommon,
+      currPositionCommon - prevPositionCommon,
+      isEnd > 0.0
+    );
+    let billboardPathLength = select(
+      0.0,
+      length(currentDeltaCommon) * project.scale / (widthPixels * project.focalDistance),
+      widthPixels > 0.0
+    );
 #endif
     let join = getLineJoinOffset(
       prevPositionScreen.xyz / prevPositionScreen.w,
       currPositionScreen.xyz / currPositionScreen.w,
       nextPositionScreen.xyz / nextPositionScreen.w,
       project_pixel_size_to_clipspace(vec2<f32>(widthPixels, widthPixels)),
+#ifdef DASH_ENABLED
+      billboardPathLength,
+      billboardPathRange,
+#endif
 #ifdef ANTIALIASING
       coverageScale,
 #endif
       attributes.positions,
       attributes.instanceTypes
     );
+#ifdef DASH_ENABLED
+    // Phase and justification use the complete source segment, while cap and joint coverage
+    // must still recognize the endpoints moved by clipLine.
+    varyings.vPathBounds = billboardPathLength * billboardPathRange;
+#endif
 
     geometry.uv = join.pathPosition;
     varyings.position = vec4<f32>(
@@ -11576,12 +11808,19 @@ fn vertexMain(attributes: Attributes) -> Varyings {
       currPositionCommon,
       nextPositionCommon,
       width,
+#ifdef DASH_ENABLED
+      1.0,
+      vec2<f32>(0.0, 1.0),
+#endif
 #ifdef ANTIALIASING
       coverageScale,
 #endif
       attributes.positions,
       attributes.instanceTypes
     );
+#ifdef DASH_ENABLED
+    varyings.vPathBounds = vec2<f32>(0.0, join.pathLength);
+#endif
 
     geometry.position = vec4<f32>(currPositionCommon + join.offset, 1.0);
     geometry.uv = join.pathPosition;
@@ -11612,7 +11851,13 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // bounded by the corner offset, everywhere else by the edge of the stroke. Dividing by the
   // screen-space derivative converts the distance to the boundary into device pixels, which stays
   // correct under perspective foreshortening and under extensions that rescale the stroke.
+#ifdef DASH_ENABLED
+  let isCorner =
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y;
+#else
   let isCorner = varyings.vPathPosition.y < 0.0 || varyings.vPathPosition.y > varyings.vPathLength;
+#endif
   let isRound = varyings.vJointType > 0.5;
 
   // Distance to the silhouette in device pixels, from the derivative of the coordinate that
@@ -11623,7 +11868,13 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // Both evaluated so each derivative stays on one field across the corner/body boundary
   let bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
   let cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+  // Rounded corners still intersect the stroke-width envelope. Extensions may remap
+  // vPathPosition.x independently of vCornerOffset, as PathStyleExtension does for offsets.
+  let edgePixels = select(bodyPixels, min(cornerPixels, bodyPixels), isRound && isCorner);
+#else
   let edgePixels = select(bodyPixels, cornerPixels, isRound && isCorner);
+#endif
 
   // Fragments outside the coverage ramp must not write depth or picking colors.
   if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
@@ -11641,11 +11892,18 @@ fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
   // Feather one device pixel across the width only, before premultiplication. edgePixels is a
   // signed device-pixel distance and SMOOTH_EDGE_RADIUS is 0.5, so this ramps across one pixel.
   color.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+  if (
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y
+  ) {
 #else
   if (
     varyings.vPathPosition.y < 0.0 ||
     varyings.vPathPosition.y > varyings.vPathLength
   ) {
+#endif
     if (varyings.vJointType > 0.5 && length(varyings.vCornerOffset) > 1.0) {
       discard;
     }
@@ -11698,6 +11956,9 @@ out float vMiterLength;
 out vec2 vPathPosition;
 out float vPathLength;
 out float vJointType;
+#ifdef DASH_ENABLED
+out vec2 vPathBounds;
+#endif
 
 const float EPSILON = 0.001;
 const vec3 ZERO_OFFSET = vec3(0.0);
@@ -11710,6 +11971,9 @@ float flipIfTrue(bool flag) {
 vec3 getLineJoinOffset(
   vec3 prevPoint, vec3 currPoint, vec3 nextPoint,
   vec2 width
+#ifdef DASH_ENABLED
+  , float sourcePathLength, vec2 sourcePathRange
+#endif
 #ifdef ANTIALIASING
   , float coverageScale
 #endif
@@ -11752,6 +12016,37 @@ vec3 getLineJoinOffset(
   // length of the segment
   float L = isEnd ? lenA : lenB;
 
+#ifdef DASH_ENABLED
+  // Extrusion happens in the XY plane, so L above is a 2D length and vPathPosition.y below
+  // measures 2D distance along the segment. For a path that also moves in Z the true arc
+  // length is longer by this ratio. Scaling vPathLength and vPathPosition.y by it makes the
+  // coordinate measure real 3D distance - which is what CPU-side dash offsets accumulate -
+  // while leaving the joint tests in the fragment shader unchanged, since they compare the
+  // two against each other and both are scaled alike.
+  // Billboard mode extrudes in clip space, where the perspective divide has already reduced
+  // the segment to its screen projection, so its complete common-space length is supplied by
+  // the caller.
+  vec3 currDelta3 = isEnd ? deltaA3 : deltaB3;
+  float currLength2D = length(currDelta3.xy);
+  float arcLengthRatio = 1.0;
+  float pathPositionOffset = 0.0;
+  float pathLength = L;
+  if (path.billboard) {
+    // clipLine may shorten the visible screen-space segment. Preserve the corresponding interval
+    // of the complete common-space arclength instead of compressing the full dash period into the
+    // visible span. Keep pathLength complete so justification is stable as the camera clips it.
+    float visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+    arcLengthRatio = L > 0.0 ? visiblePathLength / L : 0.0;
+    pathPositionOffset = sourcePathLength * sourcePathRange.x;
+    pathLength = sourcePathLength;
+  } else if (currLength2D > 0.0) {
+    // Do not clamp a valid denominator to EPSILON: high-zoom Web Mercator deltas are often
+    // smaller than that in common space, and changing their scale corrupts even flat paths.
+    arcLengthRatio = length(currDelta3) / currLength2D;
+    pathLength = L * arcLengthRatio;
+  }
+#endif
+
   // A = angle of the corner
   float sinHalfA = abs(dot(miterVec, perp));
   float cosHalfA = abs(dot(dirA, miterVec));
@@ -11793,7 +12088,11 @@ vec3 getLineJoinOffset(
   // The physical stroke still ends at offsetVec; the scaled coordinates and vertices only extend
   // its rasterized envelope to include the outer half of the centered coverage ramp.
   vec2 coverageOffsetVec = offsetVec * coverageScale;
+#ifdef DASH_ENABLED
+  vPathLength = pathLength;
+#else
   vPathLength = L;
+#endif
   vCornerOffset = coverageOffsetVec;
   vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
   vMiterLength = isCap ? isJoint : vMiterLength;
@@ -11801,7 +12100,11 @@ vec3 getLineJoinOffset(
   vec2 offsetFromStartOfPath = coverageOffsetVec + deltaA * float(isEnd);
   vPathPosition = vec2(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   geometry.uv = vPathPosition;
 
@@ -11809,7 +12112,11 @@ vec3 getLineJoinOffset(
   vec3 offset = vec3(coverageOffsetVec * width * isValid, 0.0);
 #else
   // Generate variables for fragment shader
+#ifdef DASH_ENABLED
+  vPathLength = pathLength;
+#else
   vPathLength = L;
+#endif
   vCornerOffset = offsetVec;
   vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
   vMiterLength = isCap ? isJoint : vMiterLength;
@@ -11817,7 +12124,11 @@ vec3 getLineJoinOffset(
   vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);
   vPathPosition = vec2(
     dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
     dot(offsetFromStartOfPath, dir)
+#endif
   );
   geometry.uv = vPathPosition;
 
@@ -11839,6 +12150,22 @@ void clipLine(inout vec4 position, vec4 refPosition) {
   }
 }
 
+#ifdef DASH_ENABLED
+// Return the visible interval of the original segment before clipLine moves either endpoint.
+vec2 getClippedPathRange(float startW, float endW) {
+  bool startClipped = startW < EPSILON;
+  bool endClipped = endW < EPSILON;
+  if (startClipped && endClipped) {
+    return vec2(0.0);
+  }
+  if (startClipped || endClipped) {
+    float intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+    return startClipped ? vec2(intersection, 1.0) : vec2(0.0, intersection);
+  }
+  return vec2(0.0, 1.0);
+}
+#endif
+
 void main() {
   geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
 
@@ -11863,9 +12190,35 @@ void main() {
 
   if (path.billboard) {
     // Extrude in clipspace
-    vec4 prevPositionScreen = project_position_to_clipspace(prevPosition, prevPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    vec4 prevPositionCommon;
+    vec4 nextPositionCommon;
+    vec4 prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET, prevPositionCommon
+    );
+#else
+    vec4 prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+#endif
     vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);
-    vec4 nextPositionScreen = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);
+#ifdef DASH_ENABLED
+    vec4 nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET, nextPositionCommon
+    );
+#else
+    vec4 nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+#endif
+
+#ifdef DASH_ENABLED
+    vec4 sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+    vec4 sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+    vec2 billboardPathRange = getClippedPathRange(
+      sourcePathStartScreen.w, sourcePathEndScreen.w
+    );
+#endif
 
     clipLine(prevPositionScreen, currPositionScreen);
     clipLine(nextPositionScreen, currPositionScreen);
@@ -11880,16 +12233,34 @@ void main() {
       : 1.0;
 #endif
 
+#ifdef DASH_ENABLED
+    vec3 currentDeltaCommon = isEnd > 0.0
+      ? geometry.position.xyz - prevPositionCommon.xyz
+      : nextPositionCommon.xyz - geometry.position.xyz;
+    float billboardPathLength = width.x > 0.0
+      ? length(currentDeltaCommon) * project.scale / (width.x * project.focalDistance)
+      : 0.0;
+#endif
+
     vec3 offset = getLineJoinOffset(
       prevPositionScreen.xyz / prevPositionScreen.w,
       currPositionScreen.xyz / currPositionScreen.w,
       nextPositionScreen.xyz / nextPositionScreen.w,
       project_pixel_size_to_clipspace(width.xy)
+#ifdef DASH_ENABLED
+      ,
+      billboardPathLength, billboardPathRange
+#endif
 #ifdef ANTIALIASING
       ,
       coverageScale
 #endif
     );
+#ifdef DASH_ENABLED
+    // Phase and justification use the complete source segment, while cap and joint coverage
+    // must still recognize the endpoints moved by clipLine.
+    vPathBounds = billboardPathLength * billboardPathRange;
+#endif
 
     DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);
     gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);
@@ -11910,10 +12281,16 @@ void main() {
 
     vec3 offset = getLineJoinOffset(
       prevPosition, currPosition, nextPosition, width.xy
+#ifdef DASH_ENABLED
+      , 1.0, vec2(0.0, 1.0)
+#endif
 #ifdef ANTIALIASING
       , coverageScale
 #endif
     );
+#ifdef DASH_ENABLED
+    vPathBounds = vec2(0.0, vPathLength);
+#endif
     geometry.position = vec4(currPosition + offset, 1.0);
     gl_Position = project_common_position_to_clipspace(geometry.position);
     DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
@@ -11939,6 +12316,9 @@ in float vMiterLength;
 in vec2 vPathPosition;
 in float vPathLength;
 in float vJointType;
+#ifdef DASH_ENABLED
+in vec2 vPathBounds;
+#endif
 
 out vec4 fragColor;
 
@@ -11946,7 +12326,11 @@ void main(void) {
   geometry.uv = vPathPosition;
 
 #ifdef ANTIALIASING
+#ifdef DASH_ENABLED
+  bool isCorner = vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y;
+#else
   bool isCorner = vPathPosition.y < 0.0 || vPathPosition.y > vPathLength;
+#endif
   bool isRound = vJointType > 0.5;
 
   // Distance to the silhouette in device pixels, from the derivative of the coordinate that
@@ -11957,7 +12341,13 @@ void main(void) {
   // Both evaluated so each derivative stays on one field across the corner/body boundary
   float bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
   float cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+  // Rounded corners still intersect the stroke-width envelope. Extensions may remap
+  // vPathPosition.x independently of vCornerOffset, as PathStyleExtension does for offsets.
+  float edgePixels = isRound && isCorner ? min(cornerPixels, bodyPixels) : bodyPixels;
+#else
   float edgePixels = isRound && isCorner ? cornerPixels : bodyPixels;
+#endif
 
   // Fragments outside the coverage ramp must not write depth or picking colors.
   if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
@@ -11976,8 +12366,12 @@ void main(void) {
   // edgePixels is a signed device-pixel distance, and SMOOTH_EDGE_RADIUS is 0.5, so smoothedge
   // ramps across exactly one pixel centered on the edge.
   fragColor.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+  if (vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y) {
 #else
   if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {
+#endif
     // if joint is rounded, test distance from the corner
     if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {
       discard;
@@ -12018,6 +12412,18 @@ var ATTRIBUTE_TRANSITION = {
     return chunk.length ? chunk.subarray(chunk.length - value.length) : value;
   }
 };
+function getPathProjectionScale(viewport) {
+  if (viewport.isGeospatial) {
+    return null;
+  }
+  const { unitsPerMeter: unitsPerMeter2 } = viewport.distanceScales;
+  return [unitsPerMeter2[0], unitsPerMeter2[1], unitsPerMeter2[2]];
+}
+function pathProjectionScalesEqual(left, right) {
+  return left === right || Boolean(
+    left && right && left.length === right.length && left.every((value, index) => value === right[index])
+  );
+}
 var PathLayer = class extends Layer {
   getShaders() {
     const { antialiasing } = this.props;
@@ -12045,6 +12451,43 @@ var PathLayer = class extends Layer {
     }
     return (_a = this.getAttributeManager()) == null ? void 0 : _a.getBounds(["vertexPositions"]);
   }
+  getPathProjectionScale(viewport) {
+    var _a;
+    const coordinateSystem = this.props.coordinateSystem;
+    const hasDashMetrics = Boolean((_a = this.getAttributeManager()) == null ? void 0 : _a.getAttributes().instanceDashOffsets);
+    if (!hasDashMetrics) {
+      return null;
+    }
+    const trackViewportScale = viewport instanceof WebMercatorViewport && viewport.zoom >= 12 && // Offset coordinate systems use their fixed coordinateOrigin as the projection origin.
+    // Default/lnglat and preprojected Cartesian paths follow the viewport center instead.
+    (coordinateSystem === "default" || coordinateSystem === "lnglat" || coordinateSystem === "cartesian");
+    if (trackViewportScale) {
+      const projectUniforms = project_default.getUniforms({
+        viewport,
+        coordinateSystem,
+        coordinateOrigin: this.props.coordinateOrigin,
+        autoWrapLongitude: this.wrapLongitude
+      });
+      return [
+        viewport.projectionMode,
+        projectUniforms.coordinateOrigin[1],
+        projectUniforms.commonOrigin[1],
+        ...projectUniforms.commonUnitsPerWorldUnit,
+        ...projectUniforms.commonUnitsPerWorldUnit2,
+        projectUniforms.commonUnitsPerMeter[2]
+      ];
+    }
+    const projectionScale = getPathProjectionScale(viewport);
+    return projectionScale ? [viewport.projectionMode, ...projectionScale] : [viewport.projectionMode];
+  }
+  shouldUpdateState(params) {
+    var _a, _b;
+    const { viewport } = this.context;
+    return super.shouldUpdateState(params) || ((_a = this.state) == null ? void 0 : _a.tessellationResolution) !== viewport.resolution || !pathProjectionScalesEqual(
+      (_b = this.state) == null ? void 0 : _b.pathProjectionScale,
+      this.getPathProjectionScale(viewport)
+    );
+  }
   initializeState() {
     const noAlloc = true;
     const isWebGPU = this.context.device.type === "webgpu";
@@ -12135,7 +12578,9 @@ var PathLayer = class extends Layer {
       pathTesselator: new PathTesselator({
         fp64: this.use64bitPositions(),
         isWebGPU
-      })
+      }),
+      tessellationResolution: this.context.viewport.resolution,
+      pathProjectionScale: this.getPathProjectionScale(this.context.viewport)
     });
   }
   updateState(params) {
@@ -12143,7 +12588,16 @@ var PathLayer = class extends Layer {
     super.updateState(params);
     const { props, oldProps, changeFlags } = params;
     const attributeManager = this.getAttributeManager();
-    const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath);
+    const { viewport } = this.context;
+    const tessellationResolutionChanged = this.state.tessellationResolution !== viewport.resolution;
+    const pathProjectionScale = this.getPathProjectionScale(viewport);
+    const pathProjectionScaleChanged = !pathProjectionScalesEqual(
+      this.state.pathProjectionScale,
+      pathProjectionScale
+    );
+    const getPathChanged = changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath);
+    const geometryConfigurationChanged = getPathChanged || props._pathType !== oldProps._pathType || props.positionFormat !== oldProps.positionFormat || props.wrapLongitude !== oldProps.wrapLongitude || tessellationResolutionChanged;
+    const geometryChanged = changeFlags.dataChanged || geometryConfigurationChanged;
     if (geometryChanged) {
       const { pathTesselator } = this.state;
       const buffers = props.data.attributes || {};
@@ -12157,16 +12611,24 @@ var PathLayer = class extends Layer {
         positionFormat: props.positionFormat,
         wrapLongitude: props.wrapLongitude,
         // TODO - move the flag out of the viewport
-        resolution: this.context.viewport.resolution,
-        dataChanged: changeFlags.dataChanged
+        resolution: viewport.resolution,
+        // A partial data diff is only valid while normalization inputs remain unchanged.
+        dataChanged: geometryConfigurationChanged ? void 0 : changeFlags.dataChanged
       });
       this.setState({
         numInstances: pathTesselator.instanceCount,
-        startIndices: pathTesselator.vertexStarts
+        startIndices: pathTesselator.vertexStarts,
+        tessellationResolution: viewport.resolution,
+        pathProjectionScale
       });
-      if (!changeFlags.dataChanged) {
+      if (!changeFlags.dataChanged || geometryConfigurationChanged) {
         attributeManager.invalidateAll();
+      } else if (pathProjectionScaleChanged) {
+        attributeManager.invalidate("instanceDashOffsets");
       }
+    } else if (pathProjectionScaleChanged) {
+      this.setState({ pathProjectionScale });
+      attributeManager.invalidate("instanceDashOffsets");
     }
     if (changeFlags.extensionsChanged || props.antialiasing !== oldProps.antialiasing) {
       (_a = this.state.model) == null ? void 0 : _a.destroy();
@@ -16673,7 +17135,7 @@ GeoCellLayer.defaultProps = defaultProps12;
 
 // ../geo-layers/src/h3-layers/h3-utils.ts
 var import_h3_js = require("h3-js");
-var import_core34 = require("@math.gl/core");
+var import_core33 = require("@math.gl/core");
 function normalizeLongitudes(vertices, refLng) {
   refLng = refLng === void 0 ? vertices[0][0] : refLng;
   for (const pt of vertices) {
@@ -16691,8 +17153,8 @@ function scalePolygon(hexId, vertices, factor) {
   normalizeLongitudes(vertices, lng);
   const vertexCount = vertices[0] === vertices[actualCount - 1] ? actualCount - 1 : actualCount;
   for (let i = 0; i < vertexCount; i++) {
-    vertices[i][0] = (0, import_core34.lerp)(lng, vertices[i][0], factor);
-    vertices[i][1] = (0, import_core34.lerp)(lat, vertices[i][1], factor);
+    vertices[i][0] = (0, import_core33.lerp)(lng, vertices[i][0], factor);
+    vertices[i][1] = (0, import_core33.lerp)(lat, vertices[i][1], factor);
   }
 }
 function getHexagonCentroid(getHexagon, object, objectInfo) {
@@ -16721,7 +17183,7 @@ function flattenPolygon(vertices) {
 
 // ../geo-layers/src/tileset-2d/tileset-2d.ts
 var import_loader_utils = require("@loaders.gl/loader-utils");
-var import_core36 = require("@math.gl/core");
+var import_core35 = require("@math.gl/core");
 
 // ../geo-layers/src/tileset-2d/tile-2d-header.ts
 var Tile2DHeader = class {
@@ -16852,7 +17314,7 @@ var Tile2DHeader = class {
 
 // ../geo-layers/src/tileset-2d/tile-2d-traversal.ts
 var import_culling = require("@math.gl/culling");
-var import_web_mercator7 = require("@math.gl/web-mercator");
+var import_web_mercator6 = require("@math.gl/web-mercator");
 var TILE_SIZE = 512;
 var MAX_MAPS = 3;
 var REF_POINTS_5 = [
@@ -16998,8 +17460,8 @@ function getOSMTileIndices(viewport, maxZ, zRange, bounds) {
   const minZ = viewport instanceof WebMercatorViewport && viewport.pitch <= 60 ? maxZ : 0;
   if (bounds) {
     const [minLng, minLat, maxLng, maxLat] = bounds;
-    const topLeft = (0, import_web_mercator7.lngLatToWorld)([minLng, maxLat]);
-    const bottomRight = (0, import_web_mercator7.lngLatToWorld)([maxLng, minLat]);
+    const topLeft = (0, import_web_mercator6.lngLatToWorld)([minLng, maxLat]);
+    const bottomRight = (0, import_web_mercator6.lngLatToWorld)([maxLng, minLat]);
     bounds = [topLeft[0], TILE_SIZE - topLeft[1], bottomRight[0], TILE_SIZE - bottomRight[1]];
   }
   const root = new OSMNode(0, 0, 0);
@@ -17366,8 +17828,8 @@ var Tileset2D = class {
     this._zRange = null;
     this._selectedTiles = null;
     this._frameNumber = 0;
-    this._modelMatrix = new import_core36.Matrix4();
-    this._modelMatrixInverse = new import_core36.Matrix4();
+    this._modelMatrix = new import_core35.Matrix4();
+    this._modelMatrixInverse = new import_core35.Matrix4();
   }
   /* Public API */
   get tiles() {
@@ -17420,9 +17882,9 @@ var Tileset2D = class {
     zRange: null,
     modelMatrix: null
   }) {
-    const modelMatrixAsMatrix4 = modelMatrix ? new import_core36.Matrix4(modelMatrix) : new import_core36.Matrix4();
+    const modelMatrixAsMatrix4 = modelMatrix ? new import_core35.Matrix4(modelMatrix) : new import_core35.Matrix4();
     const isModelMatrixNew = !modelMatrixAsMatrix4.equals(this._modelMatrix);
-    if (!this._viewport || !viewport.equals(this._viewport) || !(0, import_core36.equals)(this._zRange, zRange) || isModelMatrixNew) {
+    if (!this._viewport || !viewport.equals(this._viewport) || !(0, import_core35.equals)(this._zRange, zRange) || isModelMatrixNew) {
       if (isModelMatrixNew) {
         this._modelMatrixInverse = modelMatrixAsMatrix4.clone().invert();
         this._modelMatrix = modelMatrixAsMatrix4;
@@ -17471,7 +17933,7 @@ var Tileset2D = class {
         if ("west" in bbox) {
           overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY;
         } else {
-          if (modelMatrix && !import_core36.Matrix4.IDENTITY.equals(modelMatrix)) {
+          if (modelMatrix && !import_core35.Matrix4.IDENTITY.equals(modelMatrix)) {
             const [left, top, right, bottom] = transformBox(
               [bbox.left, bbox.top, bbox.right, bbox.bottom],
               modelMatrix
@@ -17792,7 +18254,7 @@ function getPlaceholderInChildren(tile) {
 }
 
 // ../geo-layers/src/tile-layer/tile-layer.ts
-var import_core38 = require("@math.gl/core");
+var import_core37 = require("@math.gl/core");
 var defaultProps13 = {
   TilesetClass: Tileset2D,
   data: { type: "data", value: [] },
@@ -18013,7 +18475,7 @@ var TileLayer = class extends CompositeLayer {
     return this.state.tileset.isTileVisible(
       tile,
       cullRect,
-      modelMatrix ? new import_core38.Matrix4(modelMatrix) : null
+      modelMatrix ? new import_core37.Matrix4(modelMatrix) : null
     );
   }
 };
@@ -18468,7 +18930,7 @@ var shader_module_default = {
 };
 
 // ../extensions/src/collision-filter/collision-filter-effect.ts
-var import_core43 = require("@math.gl/core");
+var import_core42 = require("@math.gl/core");
 
 // ../extensions/src/collision-filter/collision-filter-pass.ts
 var CollisionFilterPass = class extends LayersPass {
@@ -18579,7 +19041,7 @@ var CollisionFilterEffect = class {
     const needsRender = viewportChanged || // If render info is new
     renderInfo === oldRenderInfo || // If sublayers have changed
     !deepEqual(oldRenderInfo.layers, renderInfo.layers, 1) || // If a sublayer's bounds have been updated
-    renderInfo.layerBounds.some((b, i) => !(0, import_core43.equals)(b, oldRenderInfo.layerBounds[i])) || // If a sublayer's isLoaded state has been updated
+    renderInfo.layerBounds.some((b, i) => !(0, import_core42.equals)(b, oldRenderInfo.layerBounds[i])) || // If a sublayer's isLoaded state has been updated
     renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || // Some prop is in transition
     renderInfo.layers.some((layer) => layer.props.transitions);
     this.channels[collisionGroup] = renderInfo;
@@ -18745,12 +19207,12 @@ CollisionFilterExtension.defaultProps = defaultProps16;
 CollisionFilterExtension.extensionName = "CollisionFilterExtension";
 
 // ../geo-layers/src/mvt-layer/mvt-layer.ts
-var import_core48 = require("@math.gl/core");
+var import_core47 = require("@math.gl/core");
 var import_mvt = require("@loaders.gl/mvt");
 var import_gis = require("@loaders.gl/gis");
 
 // ../geo-layers/src/mvt-layer/coordinate-transform.ts
-var import_core46 = require("@math.gl/core");
+var import_core45 = require("@math.gl/core");
 var availableTransformations = {
   Point,
   MultiPoint,
@@ -18760,8 +19222,8 @@ var availableTransformations = {
   MultiPolygon
 };
 function Point([pointX, pointY], [nw, se], viewport) {
-  const x = (0, import_core46.lerp)(nw[0], se[0], pointX);
-  const y = (0, import_core46.lerp)(nw[1], se[1], pointY);
+  const x = (0, import_core45.lerp)(nw[0], se[0], pointX);
+  const y = (0, import_core45.lerp)(nw[1], se[1], pointY);
   return viewport.unprojectFlat([x, y]);
 }
 function getPoints(geometry, bbox, viewport) {
@@ -19004,7 +19466,7 @@ var MVTLayer = class extends TileLayer {
     const yScale = -xScale;
     const xOffset = WORLD_SIZE * x / worldScale;
     const yOffset = WORLD_SIZE * (1 - y / worldScale);
-    const modelMatrix = new import_core48.Matrix4().scale([xScale, yScale, 1]);
+    const modelMatrix = new import_core47.Matrix4().scale([xScale, yScale, 1]);
     props.autoHighlight = false;
     if (!this.context.viewport.resolution) {
       props.modelMatrix = modelMatrix;
@@ -19180,7 +19642,7 @@ function transformTileCoordsToWGS84(object, bbox, viewport) {
 }
 
 // dist/layers/cluster-tile-layer.js
-var import_core53 = require("@loaders.gl/core");
+var import_core52 = require("@loaders.gl/core");
 var import_gis2 = require("@loaders.gl/gis");
 
 // dist/layers/cluster-utils.js
@@ -19502,7 +19964,7 @@ var H3Tileset2D = class extends Tileset2D {
 };
 
 // dist/layers/quadbin-utils.js
-var import_web_mercator8 = require("@math.gl/web-mercator");
+var import_web_mercator7 = require("@math.gl/web-mercator");
 var import_quadbin3 = require("quadbin");
 var TILE_SIZE3 = 512;
 function quadbinToOffset(quadbin) {
@@ -19519,8 +19981,8 @@ function quadbinToWorldBounds(quadbin, coverage) {
 }
 function getQuadbinPolygon(quadbin, coverage = 1) {
   const [topLeft, bottomRight] = quadbinToWorldBounds(quadbin, coverage);
-  const [w, n] = (0, import_web_mercator8.worldToLngLat)(topLeft);
-  const [e, s] = (0, import_web_mercator8.worldToLngLat)(bottomRight);
+  const [w, n] = (0, import_web_mercator7.worldToLngLat)(topLeft);
+  const [e, s] = (0, import_web_mercator7.worldToLngLat)(bottomRight);
   return [e, n, e, s, w, s, w, n, e, n];
 }
 
@@ -19789,7 +20251,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION = true ? "9.4.0-beta.1" : "latest";
+var VERSION = true ? "9.4.0-beta.3" : "latest";
 var id = "cartoSpatialTile";
 var DEFAULT_OPTIONS = {
   cartoSpatialTile: {
@@ -19902,7 +20364,7 @@ var TilejsonPropType = {
 };
 
 // dist/layers/cluster-tile-layer.js
-(0, import_core53.registerLoaders)([carto_spatial_tile_loader_default]);
+(0, import_core52.registerLoaders)([carto_spatial_tile_loader_default]);
 function getScheme(tilesetClass) {
   if (tilesetClass === H3Tileset2D)
     return "h3";
@@ -20063,8 +20525,8 @@ ClusterTileLayer.defaultProps = defaultProps18;
 var cluster_tile_layer_default = ClusterTileLayer;
 
 // dist/layers/spatial-index-tile-layer.js
-var import_core55 = require("@loaders.gl/core");
-(0, import_core55.registerLoaders)([carto_spatial_tile_loader_default]);
+var import_core54 = require("@loaders.gl/core");
+(0, import_core54.registerLoaders)([carto_spatial_tile_loader_default]);
 function isFeatureIdDefined2(value) {
   return value !== void 0 && value !== null && value !== "";
 }
@@ -21079,7 +21541,7 @@ RasterLayer.defaultProps = defaultProps25;
 var raster_layer_default = RasterLayer;
 
 // dist/layers/raster-tile-layer.js
-var import_core63 = require("@loaders.gl/core");
+var import_core62 = require("@loaders.gl/core");
 
 // dist/layers/schema/carto-raster-tile.js
 var ARRAY_TYPES = {
@@ -21127,7 +21589,7 @@ var TileReader3 = class _TileReader {
 };
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION2 = true ? "9.4.0-beta.1" : "latest";
+var VERSION2 = true ? "9.4.0-beta.3" : "latest";
 var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
   cartoRasterTile: {
@@ -21166,7 +21628,7 @@ function parseCartoRasterTile(arrayBuffer, options) {
 var carto_raster_tile_loader_default = CartoRasterTileLoader;
 
 // dist/layers/raster-tile-layer.js
-(0, import_core63.registerLoaders)([carto_raster_tile_loader_default]);
+(0, import_core62.registerLoaders)([carto_raster_tile_loader_default]);
 var renderSubLayers3 = (props) => {
   var _a, _b;
   const tileIndex = (_b = (_a = props.tile) == null ? void 0 : _a.index) == null ? void 0 : _b.q;
@@ -21222,7 +21684,7 @@ RasterTileLayer.defaultProps = defaultProps26;
 var raster_tile_layer_default = RasterTileLayer;
 
 // dist/layers/vector-tile-layer.js
-var import_core64 = require("@loaders.gl/core");
+var import_core63 = require("@loaders.gl/core");
 
 // dist/layers/schema/carto-properties-tile.js
 var TileReader4 = class _TileReader {
@@ -21240,7 +21702,7 @@ var TileReader4 = class _TileReader {
 };
 
 // dist/layers/schema/carto-properties-tile-loader.js
-var VERSION3 = true ? "9.4.0-beta.1" : "latest";
+var VERSION3 = true ? "9.4.0-beta.3" : "latest";
 var id3 = "cartoPropertiesTile";
 var DEFAULT_OPTIONS3 = {
   cartoPropertiesTile: {
@@ -21269,7 +21731,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut2 = __toESM(require("earcut"), 1);
-var VERSION4 = true ? "9.4.0-beta.1" : "latest";
+var VERSION4 = true ? "9.4.0-beta.3" : "latest";
 var id4 = "cartoVectorTile";
 var DEFAULT_OPTIONS4 = {
   cartoVectorTile: {
@@ -21569,7 +22031,7 @@ function getLineMidpoint(lines, index) {
 }
 
 // dist/layers/vector-tile-layer.js
-(0, import_core64.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+(0, import_core63.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
 var MVT_BBOX = { west: 0, east: 1, south: 0, north: 1 };
 var defaultProps27 = {
   ...MVTLayer.defaultProps,