@deck.gl/carto 9.0.40 → 9.1.0-beta.3

package/dist/index.cjs

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __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
 ));
@@ -29,16 +33,16 @@ __export(dist_exports, {
   BASEMAP: () => basemap_default,
   CARTO_LAYERS: () => CARTO_LAYERS,
   CARTO_SOURCES: () => CARTO_SOURCES,
-  CartoAPIError: () => CartoAPIError,
+  CartoAPIError: () => import_api_client4.CartoAPIError,
   ClusterTileLayer: () => cluster_tile_layer_default,
   H3TileLayer: () => h3_tile_layer_default,
   HeatmapTileLayer: () => heatmap_tile_layer_default,
+  PointLabelLayer: () => point_label_layer_default,
   QuadbinTileLayer: () => quadbin_tile_layer_default,
   RasterTileLayer: () => raster_tile_layer_default,
-  SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
+  SOURCE_DEFAULTS: () => import_api_client4.SOURCE_DEFAULTS,
   VectorTileLayer: () => vector_tile_layer_default,
   _GOOGLE_BASEMAPS: () => GOOGLE_BASEMAPS,
-  _PointLabelLayer: () => point_label_layer_default,
   _QuadbinLayer: () => quadbin_layer_default,
   _RasterLayer: () => raster_layer_default,
   _STYLE_LAYER_GROUPS: () => STYLE_LAYER_GROUPS,
@@ -46,24 +50,24 @@ __export(dist_exports, {
   _applyLayerGroupFilters: () => applyLayerGroupFilters,
   _fetchStyle: () => fetchStyle,
   _getStyleUrl: () => getStyleUrl,
-  boundaryQuerySource: () => boundaryQuerySource,
-  boundaryTableSource: () => boundaryTableSource,
+  boundaryQuerySource: () => import_api_client4.boundaryQuerySource,
+  boundaryTableSource: () => import_api_client4.boundaryTableSource,
   colorBins: () => colorBins,
   colorCategories: () => colorCategories,
   colorContinuous: () => colorContinuous,
   fetchBasemapProps: () => fetchBasemapProps,
   fetchMap: () => fetchMap,
-  h3QuerySource: () => h3QuerySource,
-  h3TableSource: () => h3TableSource,
-  h3TilesetSource: () => h3TilesetSource,
-  quadbinQuerySource: () => quadbinQuerySource,
-  quadbinTableSource: () => quadbinTableSource,
-  quadbinTilesetSource: () => quadbinTilesetSource,
-  query: () => query,
-  rasterSource: () => rasterSource,
-  vectorQuerySource: () => vectorQuerySource,
-  vectorTableSource: () => vectorTableSource,
-  vectorTilesetSource: () => vectorTilesetSource
+  h3QuerySource: () => import_api_client4.h3QuerySource,
+  h3TableSource: () => import_api_client4.h3TableSource,
+  h3TilesetSource: () => import_api_client4.h3TilesetSource,
+  quadbinQuerySource: () => import_api_client4.quadbinQuerySource,
+  quadbinTableSource: () => import_api_client4.quadbinTableSource,
+  quadbinTilesetSource: () => import_api_client4.quadbinTilesetSource,
+  query: () => import_api_client4.query,
+  rasterSource: () => import_api_client4.rasterSource,
+  vectorQuerySource: () => import_api_client4.vectorQuerySource,
+  vectorTableSource: () => import_api_client4.vectorTableSource,
+  vectorTilesetSource: () => import_api_client4.vectorTilesetSource
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -198,26 +202,28 @@ function clustersToBinary(data) {
 
 // dist/constants.js
 var DEFAULT_TILE_SIZE = 512;
-var DEFAULT_TILE_RESOLUTION = 0.5;
-var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
 
 // dist/layers/quadbin-tileset-2d.js
 var import_geo_layers = require("@deck.gl/geo-layers");
 var import_quadbin2 = require("quadbin");
 var QuadbinTileset2D = class extends import_geo_layers._Tileset2D {
+  // @ts-expect-error for spatial indices, TileSet2d should be parametrized by TileIndexT
   getTileIndices(opts) {
     return super.getTileIndices(opts).map(import_quadbin2.tileToCell).map((q) => ({ q, i: (0, import_quadbin2.bigIntToHex)(q) }));
   }
+  // @ts-expect-error TileIndex must be generic
   getTileId({ q, i }) {
     return i || (0, import_quadbin2.bigIntToHex)(q);
   }
+  // @ts-expect-error TileIndex must be generic
   getTileMetadata({ q }) {
     return super.getTileMetadata((0, import_quadbin2.cellToTile)(q));
   }
+  // @ts-expect-error TileIndex must be generic
   getTileZoom({ q }) {
     return Number((0, import_quadbin2.getResolution)(q));
   }
+  // @ts-expect-error TileIndex must be generic
   getParentIndex({ q }) {
     return { q: (0, import_quadbin2.cellToParent)(q) };
   }
@@ -538,8 +544,6 @@ function scaleIdentity() {
   };
   return scale;
 }
-var isObject = (x) => x !== null && typeof x === "object";
-var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
 
 // dist/layers/schema/spatialjson-utils.js
 var import_quadbin4 = require("quadbin");
@@ -559,7 +563,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION = true ? "9.0.40" : "latest";
+var VERSION = true ? "9.1.0-beta.3" : "latest";
 var id = "cartoSpatialTile";
 var DEFAULT_OPTIONS = {
   cartoSpatialTile: {
@@ -676,6 +680,7 @@ var ClusterGeoJsonLayer = class extends import_geo_layers2.TileLayer {
     super.initializeState();
     this.state.aggregationCache = /* @__PURE__ */ new WeakMap();
   }
+  // eslint-disable-next-line max-statements
   renderLayers() {
     var _a;
     const visibleTiles = (_a = this.state.tileset) == null ? void 0 : _a.tiles.filter((tile) => {
@@ -761,9 +766,11 @@ var ClusterTileLayer = class extends import_core6.CompositeLayer {
       return null;
     const { tiles: data, maxresolution: maxZoom } = tileJSON;
     return [
+      // @ts-ignore
       new ClusterGeoJsonLayer(this.props, {
         id: `cluster-geojson-layer-${this.props.id}`,
         data,
+        // TODO: Tileset2D should be generic over TileIndex type
         TilesetClass: QuadbinTileset2D,
         maxZoom,
         loadOptions: this.getLoadOptions()
@@ -840,6 +847,12 @@ function getHexagonResolution(viewport, tileSize) {
   return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
 }
 var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
+  /**
+   * Returns all tile indices in the current viewport. If the current zoom level is smaller
+   * than minZoom, return an empty array. If the current zoom level is greater than maxZoom,
+   * return tiles that are on maxZoom.
+   */
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileIndices({ viewport, minZoom, maxZoom }) {
     if (viewport.latitude === void 0)
       return [];
@@ -860,15 +873,19 @@ var H3Tileset2D = class extends import_geo_layers3._Tileset2D {
     }
     return indices.map((i) => ({ i }));
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileId({ i }) {
     return i;
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileMetadata({ i }) {
     return { bbox: tileToBoundingBox(i) };
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getTileZoom({ i }) {
     return (0, import_h3_js.getResolution)(i);
   }
+  // @ts-expect-error Tileset2D should be generic over TileIndex
   getParentIndex(index) {
     const resolution = (0, import_h3_js.getResolution)(index.i);
     const i = (0, import_h3_js.cellToParent)(index.i, resolution - 1);
@@ -925,7 +942,7 @@ var TileReader3 = class {
 };
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION2 = true ? "9.0.40" : "latest";
+var VERSION2 = true ? "9.1.0-beta.3" : "latest";
 var id2 = "cartoRasterTile";
 var DEFAULT_OPTIONS2 = {
   cartoRasterTile: {
@@ -1001,7 +1018,8 @@ var SpatialIndexTileLayer = class extends import_geo_layers4.TileLayer {
     const { hoveredFeatureId } = this.state;
     const data = tile.content;
     const isFeatureIdPresent = isFeatureIdDefined(hoveredFeatureId);
-    if (!isFeatureIdPresent || !Array.isArray(data) || !this._featureInTile(tile, hoveredFeatureId)) {
+    if (!isFeatureIdPresent || !Array.isArray(data) || // Quick check for whether id is within tile. data.findIndex is expensive
+    !this._featureInTile(tile, hoveredFeatureId)) {
       return -1;
     }
     return data.findIndex((feature) => feature.id === hoveredFeatureId);
@@ -1066,8 +1084,10 @@ var H3TileLayer = class extends import_core8.CompositeLayer {
     return new SubLayerClass(this.props, {
       id: `h3-tile-layer-${this.props.id}`,
       data,
+      // TODO: Tileset2D should be generic over TileIndex type
       TilesetClass: H3Tileset2D,
       renderSubLayers,
+      // minZoom and maxZoom are H3 resolutions, however we must use this naming as that is what the Tileset2D class expects
       minZoom: minresolution,
       maxZoom: maxresolution,
       loadOptions: this.getLoadOptions()
@@ -1084,55 +1104,86 @@ var import_core11 = require("@deck.gl/core");
 var import_layers2 = require("@deck.gl/layers");
 
 // dist/layers/heatmap.js
-var fs = `uniform heatmapUniforms {
-vec2 colorDomain;
-vec2 delta;
-float intensity;
-float opacity;
-float radiusPixels;
+var fs = (
+  /* glsl */
+  `uniform heatmapUniforms {
+  vec2 colorDomain;
+  vec2 delta;
+  float intensity;
+  float opacity;
+  float radiusPixels;
 } heatmap;
+
 uniform sampler2D colorTexture;
+
 vec3 colorGradient(float value) {
-return texture(colorTexture, vec2(value, 0.5)).rgb;
+  return texture(colorTexture, vec2(value, 0.5)).rgb;
 }
+
 const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
 const float MAX_VAL = SHIFT.z * 255.0;
 const float SCALE = MAX_VAL / 8.0;
 vec4 pack(float value) {
-return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
+  return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
 }
 float unpack(vec3 color) {
-return 255.0 * dot(color, SHIFT);
+  return 255.0 * dot(color, SHIFT);
 }
+
 vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-bool firstPass = (heatmap.delta.y < 0.5);
-float accumulator = 0.0;
-float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
-float sigma = SUPPORT / 3.0;
-float a = -0.5 / (sigma * sigma);
-float w0 = 0.3989422804014327 / sigma;
-for (float t = -SUPPORT; t <= SUPPORT; t++) {
-vec2 percent = (t * heatmap.delta - 0.5) / SUPPORT;
-vec2 delta = percent * heatmap.radiusPixels / texSize;
-vec4 offsetColor = texture(source, texCoord + delta);
-float value = unpack(offsetColor.rgb);
-float weight = w0 * exp(a * t * t);
-accumulator += value * weight;
-}
-if (firstPass) {
-return pack(accumulator);
-}
-float density = 10.0 * heatmap.intensity * accumulator / SCALE;
-vec2 domain = heatmap.colorDomain;
-float f = (density - domain[0]) / (domain[1] - domain[0]);
-vec4 color = vec4(0.0);
-color.rgb = colorGradient(f);
-color.a = smoothstep(0.0, 0.1, f);
-color.a = pow(color.a, 1.0 / 2.2);
-color.a *= heatmap.opacity;
-return color;
+  bool firstPass = (heatmap.delta.y < 0.5);
+  float accumulator = 0.0;
+
+  // Controls quality of heatmap, larger values increase quality at expense of performance
+  float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
+
+  // Gaussian normalization parameters
+  float sigma = SUPPORT / 3.0;
+  float a = -0.5 / (sigma * sigma);
+  float w0 = 0.3989422804014327 / sigma; // 1D normalization
+  for (float t = -SUPPORT; t <= SUPPORT; t++) {
+    vec2 percent = (t * heatmap.delta - 0.5) / SUPPORT;
+    vec2 delta = percent * heatmap.radiusPixels / texSize;
+    vec4 offsetColor = texture(source, texCoord + delta);
+
+    // Unpack float
+    float value = unpack(offsetColor.rgb);
+
+    // Gaussian
+    float weight = w0 * exp(a * t * t);
+    
+    accumulator += value * weight;
+  }
+
+  if (firstPass) {
+    return pack(accumulator);
+  }
+
+  // Undo scaling to obtain normalized density
+  float density = 10.0 * heatmap.intensity * accumulator / SCALE;
+ 
+  // Domain also in normalized density units
+  vec2 domain = heatmap.colorDomain;
+
+  // Apply domain
+  float f = (density - domain[0]) / (domain[1] - domain[0]);
+
+  // sqrt/log scaling??
+  // float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));
+  // f = sqrt(f);
+
+  // Color map
+  vec4 color = vec4(0.0);
+  color.rgb = colorGradient(f);
+
+  color.a = smoothstep(0.0, 0.1, f);
+  color.a = pow(color.a, 1.0 / 2.2);
+  color.a *= heatmap.opacity;
+
+  return color;
 }
-`;
+`
+);
 var heatmap = {
   name: "heatmap",
   uniformPropTypes: {
@@ -1149,6 +1200,7 @@ var heatmap = {
     opacity: "f32",
     radiusPixels: "f32"
   },
+  // @ts-ignore TODO v9.1
   getUniforms: (opts) => {
     if (!opts)
       return {};
@@ -1164,7 +1216,9 @@ var heatmap = {
   },
   fs,
   passes: [
+    // @ts-expect-error Seems typing in luma.gl should be Partial<>
     { sampler: true, uniforms: { delta: [1, 0] } },
+    // @ts-expect-error Seems typing in luma.gl should be Partial<>
     { sampler: true, uniforms: { delta: [0, 1] } }
   ]
 };
@@ -1200,8 +1254,8 @@ function RTTModifier(BaseLayer) {
   var _a;
   return _a = class RTTLayer extends BaseLayer {
     draw(opts) {
-      const { moduleParameters } = opts;
-      const { picking } = moduleParameters;
+      const { shaderModuleProps } = opts;
+      const { picking } = shaderModuleProps;
       const postProcessLayer = getPostProcessLayer(this);
       if (!picking.isActive) {
         postProcessLayer.enableRTT(opts);
@@ -1211,7 +1265,8 @@ function RTTModifier(BaseLayer) {
         postProcessLayer.disableRTT();
       }
     }
-  }, _a.layerName = `RTT-${BaseLayer.layerName}`, _a;
+  }, // @ts-expect-error typescript doesn't see static property
+  _a.layerName = `RTT-${BaseLayer.layerName}`, _a;
 }
 function PostProcessModifier(BaseLayer, effect) {
   var _a;
@@ -1245,10 +1300,11 @@ function PostProcessModifier(BaseLayer, effect) {
       });
     }
     _resizeBuffers(opts) {
-      const { moduleParameters } = opts;
+      const { shaderModuleProps } = opts;
       const { viewport } = this.context;
-      const width = moduleParameters.devicePixelRatio * viewport.width;
-      const height = moduleParameters.devicePixelRatio * viewport.height;
+      const { devicePixelRatio } = shaderModuleProps.project;
+      const width = devicePixelRatio * viewport.width;
+      const height = devicePixelRatio * viewport.height;
       this.internalState.renderBuffers.forEach((fbo) => fbo.resize({ width, height }));
     }
     enableRTT(opts) {
@@ -1258,6 +1314,7 @@ function PostProcessModifier(BaseLayer, effect) {
       this.internalState.internalRenderPass = this.context.device.beginRenderPass({
         framebuffer,
         parameters: { viewport: [0, 0, framebuffer.width, framebuffer.height] },
+        // Only clear on first render
         clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
       });
       this.internalState.renderInProgress = true;
@@ -1289,10 +1346,13 @@ function PostProcessModifier(BaseLayer, effect) {
     }
   }, _a.layerName = `PostProcess${BaseLayer.layerName}`, _a;
 }
-var fs2 = `vec4 copy_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
+var fs2 = (
+  /* glsl */
+  `vec4 copy_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
   return color;
 }
-`;
+`
+);
 var copy = {
   name: "copy",
   fs: fs2,
@@ -1357,6 +1417,7 @@ var QuadbinTileLayer = class extends import_core10.CompositeLayer {
     return new SubLayerClass(this.props, {
       id: `quadbin-tile-layer-${this.props.id}`,
       data,
+      // TODO: Tileset2D should be generic over TileIndex type
       TilesetClass: QuadbinTileset2D,
       renderSubLayers: renderSubLayers2,
       maxZoom,
@@ -1403,20 +1464,28 @@ function colorRangeToFlatArray(colorRange) {
   }
   return flatArray;
 }
+var uniformBlock = `uniform densityUniforms {
+  float factor;
+} density;
+`;
+var densityUniforms = {
+  name: "density",
+  vs: uniformBlock,
+  uniformTypes: {
+    factor: "f32"
+  }
+};
 var RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
   getShaders(type) {
     const shaders = super.getShaders(type);
     shaders.inject = {
-      "vs:#decl": `
-uniform float densityFactor;
-`,
       "vs:#main-end": `
       // Value from getWeight accessor
   float weight = elevations;
 
   // Keep "power" delivered to screen constant when tiles update
-  // by outputting normalized density 
-  weight *= densityFactor;
+  // by outputting normalized density
+  weight *= density.factor;
 
   // Pack float into 3 channels to pass to heatmap shader
   // SCALE value important, as we don't want to saturate
@@ -1429,14 +1498,17 @@ uniform float densityFactor;
   vColor = vec4(mod(vec3(weight, floor(weight / SHIFT.yz)), 256.0), 255.0) / 255.0;
 `
     };
+    shaders.modules = [...shaders.modules, densityUniforms];
     return shaders;
   }
   draw(opts) {
     const cell = this.props.data[0];
     const maxDensity = this.props.elevationScale;
-    const densityFactor = unitDensityForCell(cell.id) / maxDensity;
+    const densityProps = {
+      factor: unitDensityForCell(cell.id) / maxDensity
+    };
     for (const model of this.state.models) {
-      model.setUniforms({ densityFactor });
+      model.shaderInputs.setProps({ density: densityProps });
     }
     super.draw(opts);
   }
@@ -1506,6 +1578,8 @@ var HeatmapTileLayer = class extends import_core11.CompositeLayer {
     return new PostProcessQuadbinTileLayer(tileLayerProps, this.getSubLayerProps({
       id: "heatmap",
       data,
+      // Re-use existing props to pass down values to sublayer
+      // TODO replace with custom layer
       getFillColor: 0,
       getElevation: getWeight,
       elevationScale: maxDensity,
@@ -1515,11 +1589,13 @@ var HeatmapTileLayer = class extends import_core11.CompositeLayer {
       _subLayerProps: subLayerProps,
       refinementStrategy: "no-overlap",
       colorTexture: this.state.colorTexture,
+      // Disable line rendering
       extruded: false,
       stroked: false,
       updateTriggers: {
         getElevation: updateTriggers.getWeight
       },
+      // Tile stats
       onViewportLoad: (tiles2) => {
         this.setState({ isLoaded: true });
         if (typeof onViewportLoad === "function") {
@@ -1580,8 +1656,8 @@ var EnhancedTextBackgroundLayer = class extends import_layers3._TextBackgroundLa
   getShaders() {
     const shaders = super.getShaders();
     let vs = shaders.vs;
-    vs = vs.replaceAll("padding.", "_padding.");
-    vs = vs.replace("void main(void) {", "void main(void) {\n  vec4 _padding = padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);");
+    vs = vs.replaceAll("textBackground.padding.", "_padding.");
+    vs = vs.replace("void main(void) {", "void main(void) {\n  vec4 _padding = textBackground.padding + instancePixelOffsets.xyxy * vec4(1.0, 1.0, -1.0, -1.0);");
     return { ...shaders, vs };
   }
 };
@@ -1684,16 +1760,20 @@ var PointLabelLayer = class extends import_core12.CompositeLayer {
     const getPixelOffset = this.calculatePixelOffset(false);
     const backgroundPadding = this.calculateBackgroundPadding();
     const out = [
+      // Text doesn't update via updateTrigger for some reason
       this.renderTextLayer(`${updateTriggers.getText}-primary`, {
         backgroundPadding,
         getText,
         getPixelOffset,
         background: true
+        // Only use background for primary label for faster collisions
       }),
       Boolean(getSecondaryText) && this.renderTextLayer(`${updateTriggers.getSecondaryText}-secondary`, {
         getText: getSecondaryText,
         getPixelOffset: this.calculatePixelOffset(true),
         getAlignmentBaseline: "top",
+        // updateTriggers: {getText: updateTriggers.getSecondaryText},
+        // Optional overrides
         ...getSecondaryColor && { getColor: getSecondaryColor },
         ...secondarySizeScale && { sizeScale: secondarySizeScale },
         ...secondaryOutlineColor && { outlineColor: secondaryOutlineColor }
@@ -1722,61 +1802,53 @@ in float instanceElevations;
 in vec4 instanceFillColors;
 in vec4 instanceLineColors;
 in vec3 instancePickingColors;
-uniform float opacity;
-uniform bool extruded;
-uniform bool stroked;
-uniform bool isStroke;
-uniform float coverage;
-uniform float elevationScale;
-uniform float widthScale;
-uniform vec3 offset;
 out vec4 vColor;
 #ifdef FLAT_SHADING
 out vec4 position_commonspace;
 #endif
 void main(void) {
-vec2 tileOrigin = offset.xy;
-float scale = offset.z;
+vec2 tileOrigin = column.offset.xy;
+float scale = column.widthScale;
 int yIndex = - (gl_InstanceID / BLOCK_WIDTH);
 int xIndex = gl_InstanceID + (yIndex * BLOCK_WIDTH);
 vec2 cellCenter = scale * vec2(float(xIndex) + 0.5, float(yIndex) - 0.5);
-vec4 color = isStroke ? instanceLineColors : instanceFillColors;
+vec4 color = column.isStroke ? instanceLineColors : instanceFillColors;
 float shouldRender = float(color.a > 0.0 && instanceElevations >= 0.0);
-float cellWidth = coverage * scale;
+float cellWidth = column.coverage * scale;
 geometry.position = vec4(tileOrigin + cellCenter, 0.0, 1.0);
-if (project_uProjectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-geometry.position.xyz -= project_uCommonOrigin;
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+geometry.position.xyz -= project.commonOrigin;
 }
 float elevation = 0.0;
 float strokeOffsetRatio = 1.0;
-if (extruded) {
-elevation = instanceElevations * (positions.z + 1.0) / 2.0 * elevationScale;
-} else if (stroked) {
-float halfOffset = project_pixel_size(widthScale) / cellWidth;
-if (isStroke) {
+if (column.extruded) {
+elevation = instanceElevations * (positions.z + 1.0) / 2.0 * column.elevationScale;
+} else if (column.stroked) {
+float halfOffset = project_pixel_size(column.widthScale) / cellWidth;
+if (column.isStroke) {
 strokeOffsetRatio -= sign(positions.z) * halfOffset;
 } else {
 strokeOffsetRatio -= halfOffset;
 }
 }
 geometry.pickingColor = instancePickingColors;
-vec2 base = positions.xy * scale * strokeOffsetRatio * coverage * shouldRender;
+vec2 base = positions.xy * scale * strokeOffsetRatio * column.coverage * shouldRender;
 vec3 cell = vec3(base, project_size(elevation));
 DECKGL_FILTER_SIZE(cell, geometry);
 geometry.position.xyz += cell;
 gl_Position = project_common_position_to_clipspace(geometry.position);
 geometry.normal = project_normal(normals);
 DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
-if (extruded && !isStroke) {
+if (column.extruded && !column.isStroke) {
 #ifdef FLAT_SHADING
 position_commonspace = geometry.position;
-vColor = vec4(color.rgb, color.a * opacity);
+vColor = vec4(color.rgb, color.a * layer.opacity);
 #else
-vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, geometry.normal);
-vColor = vec4(lightColor, color.a * opacity);
+vec3 lightColor = lighting_getLightColor(color.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+vColor = vec4(lightColor, color.a * layer.opacity);
 #endif
 } else {
-vColor = vec4(color.rgb, color.a * opacity);
+vColor = vec4(color.rgb, color.a * layer.opacity);
 }
 DECKGL_FILTER_COLOR(vColor, geometry);
 }
@@ -1837,7 +1909,8 @@ var RasterLayer = class extends import_core13.CompositeLayer {
       return null;
     const blockSize = data.blockSize ?? 0;
     const [xOffset, yOffset, scale] = quadbinToOffset(tileIndex);
-    const offset = [xOffset, yOffset, scale / blockSize];
+    const offset = [xOffset, yOffset];
+    const lineWidthScale = scale / blockSize;
     const CellLayer = this.getSubLayerClass("column", RasterColumnLayer);
     const { highlightedObjectIndex, highlightColor } = this.state;
     return new CellLayer(this.props, this.getSubLayerProps({
@@ -1850,12 +1923,17 @@ var RasterLayer = class extends import_core13.CompositeLayer {
     }), {
       data: {
         data,
+        // Pass through data for getSubLayerAccessor()
         length: blockSize * blockSize
       },
       dataComparator: wrappedDataComparator,
       offset,
+      lineWidthScale,
+      // Re-use widthScale prop to pass cell scale,
       highlightedObjectIndex,
       highlightColor,
+      // RTT requires blending otherwise opacity < 1 blends with black
+      // render target
       parameters: {
         blendColorSrcFactor: "one",
         blendAlphaSrcFactor: "one",
@@ -1947,6 +2025,7 @@ var RasterTileLayer = class extends import_core14.CompositeLayer {
     return new SubLayerClass(this.props, {
       id: `raster-tile-layer-${this.props.id}`,
       data,
+      // TODO: Tileset2D should be generic over TileIndex type
       TilesetClass: QuadbinTileset2D,
       renderSubLayers: renderSubLayers3,
       minZoom,
@@ -2003,7 +2082,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION3 = true ? "9.0.40" : "latest";
+var VERSION3 = true ? "9.1.0-beta.3" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -2094,6 +2173,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
     loadOptions.gis = { format: "binary" };
     return loadOptions;
   }
+  /* eslint-disable camelcase */
   async getTileData(tile) {
     const tileJSON = this.props.data;
     const { tiles, properties_tiles } = tileJSON;
@@ -2123,6 +2203,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
       return null;
     return attributes ? mergeBoundaryData(geometry, attributes) : geometry;
   }
+  /* eslint-enable camelcase */
   renderSubLayers(props) {
     if (props.data === null) {
       return null;
@@ -2149,6 +2230,7 @@ var VectorTileLayer = class extends import_geo_layers8.MVTLayer {
     const subLayerProps = {
       ...props,
       autoHighlight: false,
+      // Do not perform clipping on points (#9059)
       _subLayerProps: {
         ...props._subLayerProps,
         ...applyClipExtensionToSublayerProps("polygons-fill"),
@@ -2169,47 +2251,8 @@ VectorTileLayer.layerName = "VectorTileLayer";
 VectorTileLayer.defaultProps = defaultProps10;
 var vector_tile_layer_default = VectorTileLayer;
 
-// dist/api/carto-api-error.js
-var CartoAPIError = class extends Error {
-  constructor(error, errorContext, response, responseJson) {
-    let responseString = "Failed to connect";
-    if (response) {
-      responseString = "Server returned: ";
-      if (response.status === 400) {
-        responseString += "Bad request";
-      } else if (response.status === 401 || response.status === 403) {
-        responseString += "Unauthorized access";
-      } else if (response.status === 404) {
-        responseString += "Not found";
-      } else {
-        responseString += "Error";
-      }
-      responseString += ` (${response.status}):`;
-    }
-    responseString += ` ${error.message || error}`;
-    let message = `${errorContext.requestType} API request failed`;
-    message += `
-${responseString}`;
-    for (const key of Object.keys(errorContext)) {
-      if (key === "requestType")
-        continue;
-      message += `
-${formatErrorKey(key)}: ${errorContext[key]}`;
-    }
-    message += "\n";
-    super(message);
-    this.name = "CartoAPIError";
-    this.response = response;
-    this.responseJson = responseJson;
-    this.error = error;
-    this.errorContext = errorContext;
-  }
-};
-function formatErrorKey(key) {
-  return key.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
-}
-
 // dist/basemap.js
+var import_api_client = require("@carto/api-client");
 var cartoStyleUrlTemplate = "https://basemaps.cartocdn.com/gl/{basemap}-gl-style/style.json";
 var CARTO_MAP_STYLES = ["positron", "dark-matter", "voyager"];
 var GOOGLE_BASEMAPS = {
@@ -2294,7 +2337,7 @@ async function fetchStyle({ styleUrl, errorContext }) {
     response = res;
     return res.json();
   }).catch((error) => {
-    throw new CartoAPIError(error, { ...errorContext, requestType: "Basemap style" }, response);
+    throw new import_api_client.CartoAPIError(error, { ...errorContext, requestType: "Basemap style" }, response);
   });
 }
 var basemap_default = {
@@ -2414,343 +2457,11 @@ function colorContinuous({ attr, domain, colors = DEFAULT_PALETTE, nullColor = N
   };
 }
 
-// dist/api/common.js
-var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
-var DEFAULT_CLIENT = "deck-gl-carto";
-var V3_MINOR_VERSION = "3.4";
-var DEFAULT_MAX_LENGTH_URL = 7e3;
-
-// dist/api/endpoints.js
-function joinPath(...args) {
-  return args.map((part) => part.endsWith("/") ? part.slice(0, -1) : part).join("/");
-}
-function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
-  return joinPath(apiBaseUrl, version, endpoint, ...rest);
-}
-function buildPublicMapUrl({ apiBaseUrl, cartoMapId }) {
-  return buildV3Path(apiBaseUrl, "v3", "maps", "public", cartoMapId);
-}
-function buildStatsUrl({ attribute, apiBaseUrl, connectionName, source, type }) {
-  if (type === "query") {
-    return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, attribute);
-  }
-  return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, source, attribute);
-}
-function buildSourceUrl({ apiBaseUrl, connectionName, endpoint }) {
-  return buildV3Path(apiBaseUrl, "v3", "maps", connectionName, endpoint);
-}
-function buildQueryUrl({ apiBaseUrl, connectionName }) {
-  return buildV3Path(apiBaseUrl, "v3", "sql", connectionName, "query");
-}
-
-// dist/api/request-with-parameters.js
-var import_core16 = require("@deck.gl/core");
-var DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: import_core16.VERSION
-};
-var DEFAULT_HEADERS = {
-  Accept: "application/json",
-  "Content-Type": "application/json"
-};
-var REQUEST_CACHE = /* @__PURE__ */ new Map();
-async function requestWithParameters({ baseUrl, parameters = {}, headers: customHeaders = {}, errorContext, maxLengthURL = DEFAULT_MAX_LENGTH_URL }) {
-  parameters = { ...DEFAULT_PARAMETERS, ...parameters };
-  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
-  const key = createCacheKey(baseUrl, parameters, customHeaders);
-  if (REQUEST_CACHE.has(key)) {
-    return REQUEST_CACHE.get(key);
-  }
-  const url = createURLWithParameters(baseUrl, parameters);
-  const headers = { ...DEFAULT_HEADERS, ...customHeaders };
-  const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, { method: "POST", body: JSON.stringify(parameters), headers }) : fetch(url, { headers });
-  let response;
-  let responseJson;
-  const jsonPromise = fetchPromise.then((_response) => {
-    response = _response;
-    return response.json();
-  }).then((json) => {
-    responseJson = json;
-    if (!response || !response.ok) {
-      throw new Error(json.error);
-    }
-    return json;
-  }).catch((error) => {
-    REQUEST_CACHE.delete(key);
-    throw new CartoAPIError(error, errorContext, response, responseJson);
-  });
-  REQUEST_CACHE.set(key, jsonPromise);
-  return jsonPromise;
-}
-function createCacheKey(baseUrl, parameters, headers) {
-  const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
-  const headerEntries = Object.entries(headers).sort(([a], [b]) => a > b ? 1 : -1);
-  return JSON.stringify({ baseUrl, parameters: parameterEntries, headers: headerEntries });
-}
-function createURLWithParameters(baseUrlString, parameters) {
-  const baseUrl = new URL(baseUrlString);
-  for (const [key, value] of Object.entries(parameters)) {
-    if (isPureObject(value) || Array.isArray(value)) {
-      baseUrl.searchParams.set(key, JSON.stringify(value));
-    } else {
-      baseUrl.searchParams.set(key, value.toString());
-    }
-  }
-  return baseUrl.toString();
-}
-function excludeURLParameters(baseUrlString, parameters) {
-  const baseUrl = new URL(baseUrlString);
-  for (const param of parameters) {
-    if (baseUrl.searchParams.has(param)) {
-      baseUrl.searchParams.delete(param);
-    }
-  }
-  return baseUrl.toString();
-}
-
-// dist/sources/base-source.js
-var SOURCE_DEFAULTS = {
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: DEFAULT_CLIENT,
-  format: "tilejson",
-  headers: {},
-  maxLengthURL: DEFAULT_MAX_LENGTH_URL
-};
-async function baseSource(endpoint, options, urlParameters) {
-  const { accessToken, connectionName, cache, ...optionalOptions } = options;
-  const mergedOptions = { ...SOURCE_DEFAULTS, accessToken, connectionName, endpoint };
-  for (const key in optionalOptions) {
-    if (optionalOptions[key]) {
-      mergedOptions[key] = optionalOptions[key];
-    }
-  }
-  const baseUrl = buildSourceUrl(mergedOptions);
-  const { clientId, maxLengthURL, format } = mergedOptions;
-  const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
-  const parameters = { client: clientId, ...urlParameters };
-  const errorContext = {
-    requestType: "Map instantiation",
-    connection: options.connectionName,
-    type: endpoint,
-    source: JSON.stringify(parameters, void 0, 2)
-  };
-  const mapInstantiation = await requestWithParameters({
-    baseUrl,
-    parameters,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-  const dataUrl = mapInstantiation[format].url[0];
-  if (cache) {
-    cache.value = parseInt(new URL(dataUrl).searchParams.get("cache") || "", 10);
-  }
-  errorContext.requestType = "Map data";
-  if (format === "tilejson") {
-    const json = await requestWithParameters({
-      baseUrl: dataUrl,
-      headers,
-      errorContext,
-      maxLengthURL
-    });
-    if (accessToken) {
-      json.accessToken = accessToken;
-    }
-    return json;
-  }
-  return await requestWithParameters({
-    baseUrl: dataUrl,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-}
-
-// dist/sources/boundary-query-source.js
-var boundaryQuerySource = async function(options) {
-  const { columns, filters, tilesetTableName, propertiesSqlQuery, queryParameters } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesSqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource("boundary", options, urlParameters);
-};
-
-// dist/sources/boundary-table-source.js
-var boundaryTableSource = async function(options) {
-  const { filters, tilesetTableName, columns, propertiesTableName } = options;
-  const urlParameters = {
-    tilesetTableName,
-    propertiesTableName
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("boundary", options, urlParameters);
-};
-
-// dist/sources/h3-query-source.js
-var h3QuerySource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3, sqlQuery, spatialDataColumn = "h3", queryParameters, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    spatialDataColumn,
-    spatialDataType: "h3",
-    q: sqlQuery
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/h3-table-source.js
-var h3TableSource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3, spatialDataColumn = "h3", tableName, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "h3"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/h3-tileset-source.js
-var h3TilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
-
-// dist/sources/raster-source.js
-var rasterSource = async function(options) {
-  const { tableName, filters } = options;
-  const urlParameters = { name: tableName };
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("raster", options, urlParameters);
-};
-
-// dist/sources/quadbin-query-source.js
-var quadbinQuerySource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN, sqlQuery, spatialDataColumn = "quadbin", queryParameters, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    q: sqlQuery,
-    spatialDataColumn,
-    spatialDataType: "quadbin"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/quadbin-table-source.js
-var quadbinTableSource = async function(options) {
-  const { aggregationExp, aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN, spatialDataColumn = "quadbin", tableName, filters } = options;
-  const urlParameters = {
-    aggregationExp,
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "quadbin"
-  };
-  if (aggregationResLevel) {
-    urlParameters.aggregationResLevel = String(aggregationResLevel);
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/quadbin-tileset-source.js
-var quadbinTilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
-
-// dist/sources/vector-query-source.js
-var vectorQuerySource = async function(options) {
-  const { columns, filters, spatialDataColumn = "geom", sqlQuery, tileResolution = DEFAULT_TILE_RESOLUTION, queryParameters } = options;
-  const urlParameters = {
-    spatialDataColumn,
-    spatialDataType: "geo",
-    tileResolution: tileResolution.toString(),
-    q: sqlQuery
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  if (queryParameters) {
-    urlParameters.queryParameters = queryParameters;
-  }
-  return baseSource("query", options, urlParameters);
-};
-
-// dist/sources/vector-table-source.js
-var vectorTableSource = async function(options) {
-  const { columns, filters, spatialDataColumn = "geom", tableName, tileResolution = DEFAULT_TILE_RESOLUTION } = options;
-  const urlParameters = {
-    name: tableName,
-    spatialDataColumn,
-    spatialDataType: "geo",
-    tileResolution: tileResolution.toString()
-  };
-  if (columns) {
-    urlParameters.columns = columns.join(",");
-  }
-  if (filters) {
-    urlParameters.filters = filters;
-  }
-  return baseSource("table", options, urlParameters);
-};
-
-// dist/sources/vector-tileset-source.js
-var vectorTilesetSource = async function(options) {
-  const { tableName } = options;
-  const urlParameters = { name: tableName };
-  return baseSource("tileset", options, urlParameters);
-};
+// dist/api/fetch-map.js
+var import_api_client2 = require("@carto/api-client");
 
 // dist/api/parse-map.js
-var import_core17 = require("@deck.gl/core");
+var import_core16 = require("@deck.gl/core");
 
 // dist/api/layer-map.js
 var import_d3_array = require("d3-array");
@@ -2790,6 +2501,7 @@ var OPACITY_MAP = {
 var AGGREGATION_FUNC = {
   "count unique": (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).length,
   median: import_d3_array.median,
+  // Unfortunately mode() is only available in d3-array@3+ which is ESM only
   mode: (values, accessor) => (0, import_d3_array.groupSort)(values, (v) => v.length, accessor).pop(),
   stddev: import_d3_array.deviation,
   variance: import_d3_array.variance
@@ -2808,12 +2520,14 @@ var hexToRGBA = (c) => {
   return [r, g, b, 255 * opacity];
 };
 var sharedPropMap = {
+  // Apply the value of Kepler `color` prop to the deck `getFillColor` prop
   color: "getFillColor",
   isVisible: "visible",
   label: "cartoLabel",
   textLabel: {
     alignment: "getTextAlignmentBaseline",
     anchor: "getTextAnchor",
+    // Apply the value of Kepler `textLabel.color` prop to the deck `getTextColor` prop
     color: "getTextColor",
     size: "getTextSize"
   },
@@ -2877,7 +2591,7 @@ function getLayer(type, config, dataset) {
       Layer: import_layers6.GeoJsonLayer,
       propMap: {
         columns: {
-          altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
+          altitude: (x) => ({ parameters: { depthWriteEnabled: Boolean(x) } })
         },
         visConfig: { outline: "stroked" }
       }
@@ -2886,7 +2600,7 @@ function getLayer(type, config, dataset) {
       Layer: import_layers6.GeoJsonLayer
     },
     grid: {
-      Layer: import_aggregation_layers.CPUGridLayer,
+      Layer: import_aggregation_layers.GridLayer,
       propMap: { visConfig: { ...aggregationVisConfig, worldUnitSize: (x) => ({ cellSize: 1e3 * x }) } },
       defaultProps: { getPosition }
     },
@@ -3125,6 +2839,7 @@ function parseMap(json) {
     createdAt: json.createdAt,
     updatedAt: json.updatedAt,
     initialViewState: mapState,
+    /** @deprecated Use `basemap`. */
     mapStyle,
     token,
     layers: layers.reverse().map(({ id: id4, type, config, visualChannels }) => {
@@ -3143,11 +2858,13 @@ function parseMap(json) {
           ...createInteractionProps(interactionConfig),
           ...styleProps,
           ...createChannelProps(id4, type, config, visualChannels, data),
+          // Must come after style
           ...createParametersProp(layerBlending, styleProps.parameters || {}),
+          // Must come after style
           ...createLoadOptions(token)
         });
       } catch (e) {
-        import_core17.log.error(e.message)();
+        import_core16.log.error(e.message)();
         return void 0;
       }
     })
@@ -3234,6 +2951,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
     const { colorAggregation: aggregation, colorRange: range } = visConfig;
     result.getFillColor = getColorAccessor(
       colorField,
+      // @ts-ignore
       colorScale,
       { aggregation, range },
       visConfig.opacity,
@@ -3256,7 +2974,9 @@ function createChannelProps(id4, type, config, visualChannels, data) {
   }
   if (radiusField || sizeField) {
     result.getPointRadius = getSizeAccessor(
+      // @ts-ignore
       radiusField || sizeField,
+      // @ts-ignore
       radiusScale || sizeScale,
       visConfig.sizeAggregation,
       visConfig.radiusRange || visConfig.sizeRange,
@@ -3269,7 +2989,9 @@ function createChannelProps(id4, type, config, visualChannels, data) {
     const { strokeColorAggregation: aggregation, strokeColorRange: range } = visConfig;
     result.getLineColor = getColorAccessor(
       strokeColorField,
+      // @ts-ignore
       strokeColorScale,
+      // @ts-ignore
       { aggregation, range },
       opacity,
       data
@@ -3278,6 +3000,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
   if (heightField && visConfig.enable3d) {
     result.getElevation = getSizeAccessor(
       heightField,
+      // @ts-ignore
       heightScale,
       visConfig.heightAggregation,
       visConfig.heightRange || visConfig.sizeRange,
@@ -3345,6 +3068,7 @@ function createChannelProps(id4, type, config, visualChannels, data) {
         extensions: [collisionFilterExtension],
         collisionEnabled: true,
         collisionGroup,
+        // getPointRadius already has radiusScale baked in, so only pass one or the other
         ...result.getPointRadius ? { getRadius: result.getPointRadius } : { radiusScale: visConfig.radius },
         ...secondaryField && {
           getSecondaryText,
@@ -3433,29 +3157,25 @@ async function fetchBasemapProps({ config, errorContext, applyLayerFilters = tru
 }
 
 // dist/api/fetch-map.js
-async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, headers, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function _fetchMapDataset(dataset, context) {
   const { aggregationExp, aggregationResLevel, connectionName, columns, format, geoColumn, source, type, queryParameters } = dataset;
   const cache = {};
   const globalOptions = {
-    accessToken,
-    apiBaseUrl,
+    ...context,
     cache,
-    clientId,
     connectionName,
-    format,
-    headers,
-    maxLengthURL
+    format
   };
   if (type === "tileset") {
-    dataset.data = await vectorTilesetSource({ ...globalOptions, tableName: source });
+    dataset.data = await (0, import_api_client2.vectorTilesetSource)({ ...globalOptions, tableName: source });
   } else {
     const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(":") : ["geom"];
     if (spatialDataType === "geom") {
       const options = { ...globalOptions, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await vectorTableSource({ ...options, columns, tableName: source });
+        dataset.data = await (0, import_api_client2.vectorTableSource)({ ...options, columns, tableName: source });
       } else if (type === "query") {
-        dataset.data = await vectorQuerySource({
+        dataset.data = await (0, import_api_client2.vectorQuerySource)({
           ...options,
           columns,
           sqlQuery: source,
@@ -3465,16 +3185,16 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
     } else if (spatialDataType === "h3") {
       const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await h3TableSource({ ...options, tableName: source });
+        dataset.data = await (0, import_api_client2.h3TableSource)({ ...options, tableName: source });
       } else if (type === "query") {
-        dataset.data = await h3QuerySource({ ...options, sqlQuery: source, queryParameters });
+        dataset.data = await (0, import_api_client2.h3QuerySource)({ ...options, sqlQuery: source, queryParameters });
       }
     } else if (spatialDataType === "quadbin") {
       const options = { ...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn };
       if (type === "table") {
-        dataset.data = await quadbinTableSource({ ...options, tableName: source });
+        dataset.data = await (0, import_api_client2.quadbinTableSource)({ ...options, tableName: source });
       } else if (type === "query") {
-        dataset.data = await quadbinQuerySource({ ...options, sqlQuery: source, queryParameters });
+        dataset.data = await (0, import_api_client2.quadbinQuerySource)({ ...options, sqlQuery: source, queryParameters });
       }
     }
   }
@@ -3485,8 +3205,9 @@ async function _fetchMapDataset(dataset, accessToken, apiBaseUrl, clientId, head
   }
   return cacheChanged;
 }
-async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function _fetchTilestats(attribute, dataset, context) {
   const { connectionName, data, id: id4, source, type, queryParameters } = dataset;
+  const { apiBaseUrl } = context;
   const errorContext = {
     requestType: "Tile stats",
     connection: connectionName,
@@ -3494,11 +3215,11 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
     source
   };
   if (!("tilestats" in data)) {
-    throw new CartoAPIError(new Error(`Invalid dataset for tilestats: ${id4}`), errorContext);
+    throw new import_api_client2.CartoAPIError(new Error(`Invalid dataset for tilestats: ${id4}`), errorContext);
   }
-  const baseUrl = buildStatsUrl({ attribute, apiBaseUrl, ...dataset });
+  const baseUrl = (0, import_api_client2.buildStatsUrl)({ attribute, apiBaseUrl, ...dataset });
   const client = new URLSearchParams(data.tiles[0]).get("client");
-  const headers = { Authorization: `Bearer ${accessToken}` };
+  const headers = { Authorization: `Bearer ${context.accessToken}` };
   const parameters = {};
   if (client) {
     parameters.client = client;
@@ -3509,23 +3230,23 @@ async function _fetchTilestats(attribute, dataset, accessToken, apiBaseUrl, maxL
       parameters.queryParameters = JSON.stringify(queryParameters);
     }
   }
-  const stats = await requestWithParameters({
+  const stats = await (0, import_api_client2.requestWithParameters)({
     baseUrl,
     headers,
     parameters,
     errorContext,
-    maxLengthURL
+    maxLengthURL: context.maxLengthURL
   });
   const { attributes } = data.tilestats.layers[0];
   const index = attributes.findIndex((d) => d.attribute === attribute);
   attributes[index] = stats;
   return true;
 }
-async function fillInMapDatasets({ datasets, token }, clientId, apiBaseUrl, headers, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
-  const promises = datasets.map((dataset) => _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers, maxLengthURL));
+async function fillInMapDatasets({ datasets }, context) {
+  const promises = datasets.map((dataset) => _fetchMapDataset(dataset, context));
   return await Promise.all(promises);
 }
-async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl, maxLengthURL = DEFAULT_MAX_LENGTH_URL) {
+async function fillInTileStats({ datasets, keplerMapConfig }, context) {
   var _a;
   const attributes = [];
   const { layers } = keplerMapConfig.config.visState;
@@ -3546,12 +3267,11 @@ async function fillInTileStats({ datasets, keplerMapConfig, token }, apiBaseUrl,
       filteredAttributes.push(a);
     }
   }
-  const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, token, apiBaseUrl, maxLengthURL));
+  const promises = filteredAttributes.map(({ attribute, dataset }) => _fetchTilestats(attribute, dataset, context));
   return await Promise.all(promises);
 }
-async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoMapId, clientId = DEFAULT_CLIENT, headers = {}, autoRefresh, onNewData, maxLengthURL = DEFAULT_MAX_LENGTH_URL }) {
+async function fetchMap({ accessToken, apiBaseUrl = import_api_client2.DEFAULT_API_BASE_URL, cartoMapId, clientId, headers, autoRefresh, onNewData, maxLengthURL }) {
   assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
-  assert(apiBaseUrl, "Must define apiBaseUrl");
   if (accessToken) {
     headers = { Authorization: `Bearer ${accessToken}`, ...headers };
   }
@@ -3560,16 +3280,26 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
     assert(typeof onNewData === "function", "`onNewData` must be a function");
     assert(typeof autoRefresh === "number" && autoRefresh > 0, "`autoRefresh` must be a positive number");
   }
-  const baseUrl = buildPublicMapUrl({ apiBaseUrl, cartoMapId });
+  const baseUrl = (0, import_api_client2.buildPublicMapUrl)({ apiBaseUrl, cartoMapId });
   const errorContext = { requestType: "Public map", mapId: cartoMapId };
-  const map = await requestWithParameters({ baseUrl, headers, errorContext, maxLengthURL });
+  const map = await (0, import_api_client2.requestWithParameters)({ baseUrl, headers, errorContext, maxLengthURL });
+  const context = {
+    accessToken: map.token || accessToken,
+    apiBaseUrl,
+    clientId,
+    headers,
+    maxLengthURL
+  };
   let stopAutoRefresh;
   if (autoRefresh) {
     const intervalId = setInterval(async () => {
-      const changed = await fillInMapDatasets(map, clientId, apiBaseUrl, {
-        ...headers,
-        "If-Modified-Since": new Date().toUTCString()
-      }, maxLengthURL);
+      const changed = await fillInMapDatasets(map, {
+        ...context,
+        headers: {
+          ...headers,
+          "If-Modified-Since": new Date().toUTCString()
+        }
+      });
       if (onNewData && changed.some((v) => v === true)) {
         onNewData(parseMap(map));
       }
@@ -3591,9 +3321,10 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
   });
   const [basemap] = await Promise.all([
     fetchBasemapProps({ config: map.keplerMapConfig.config, errorContext }),
-    fillInMapDatasets(map, clientId, apiBaseUrl, headers, maxLengthURL)
+    // Mutates map.datasets so that dataset.data contains data
+    fillInMapDatasets(map, context)
   ]);
-  await fillInTileStats(map, apiBaseUrl, maxLengthURL);
+  await fillInTileStats(map, context);
   const out = { ...parseMap(map), basemap, ...{ stopAutoRefresh } };
   const textLayers = out.layers.filter((layer) => {
     const pointType = layer.props.pointType || "";
@@ -3606,53 +3337,30 @@ async function fetchMap({ accessToken, apiBaseUrl = DEFAULT_API_BASE_URL, cartoM
   return out;
 }
 
-// dist/api/query.js
-var query = async function(options) {
-  const { apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl, clientId = SOURCE_DEFAULTS.clientId, maxLengthURL = SOURCE_DEFAULTS.maxLengthURL, connectionName, sqlQuery, queryParameters } = options;
-  const urlParameters = { q: sqlQuery };
-  if (queryParameters) {
-    urlParameters.queryParameters = JSON.stringify(queryParameters);
-  }
-  const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
-  const headers = { Authorization: `Bearer ${options.accessToken}`, ...options.headers };
-  const parameters = { client: clientId, ...urlParameters };
-  const errorContext = {
-    requestType: "SQL",
-    connection: options.connectionName,
-    type: "query",
-    source: JSON.stringify(parameters, void 0, 2)
-  };
-  return await requestWithParameters({
-    baseUrl,
-    parameters,
-    headers,
-    errorContext,
-    maxLengthURL
-  });
-};
-
 // dist/index.js
+var import_api_client3 = require("@carto/api-client");
+var import_api_client4 = require("@carto/api-client");
 var CARTO_LAYERS = {
   ClusterTileLayer: cluster_tile_layer_default,
   H3TileLayer: h3_tile_layer_default,
   HeatmapTileLayer: heatmap_tile_layer_default,
-  _PointLabelLayer: point_label_layer_default,
+  PointLabelLayer: point_label_layer_default,
   QuadbinTileLayer: quadbin_tile_layer_default,
   RasterTileLayer: raster_tile_layer_default,
   VectorTileLayer: vector_tile_layer_default
 };
 var CARTO_SOURCES = {
-  boundaryQuerySource,
-  boundaryTableSource,
-  h3QuerySource,
-  h3TableSource,
-  h3TilesetSource,
-  rasterSource,
-  quadbinQuerySource,
-  quadbinTableSource,
-  quadbinTilesetSource,
-  vectorQuerySource,
-  vectorTableSource,
-  vectorTilesetSource
+  boundaryQuerySource: import_api_client3.boundaryQuerySource,
+  boundaryTableSource: import_api_client3.boundaryTableSource,
+  h3QuerySource: import_api_client3.h3QuerySource,
+  h3TableSource: import_api_client3.h3TableSource,
+  h3TilesetSource: import_api_client3.h3TilesetSource,
+  rasterSource: import_api_client3.rasterSource,
+  quadbinQuerySource: import_api_client3.quadbinQuerySource,
+  quadbinTableSource: import_api_client3.quadbinTableSource,
+  quadbinTilesetSource: import_api_client3.quadbinTilesetSource,
+  vectorQuerySource: import_api_client3.vectorQuerySource,
+  vectorTableSource: import_api_client3.vectorTableSource,
+  vectorTilesetSource: import_api_client3.vectorTilesetSource
 };
 //# sourceMappingURL=index.cjs.map