maplibre-gl 6.0.0 → 6.2.0

package/src/geo/projection/mercator_transform.ts

@@ -218,7 +218,7 @@ export class MercatorTransform implements ITransform {
     public get autoCalculateNearFarZ(): boolean {
         return this._helper.autoCalculateNearFarZ;
     }
-    setTransitionState(_value: number, _error: number): void {
+    setTransitionState(_value: number): void {
         // Do nothing
     }
     //
@@ -748,6 +748,7 @@ export class MercatorTransform implements ITransform {
             clippingPlane: [0, 0, 0, 0],
             projectionTransition: 0.0, // Range 0..1, where 0 is mercator, 1 is another projection, mostly globe.
             fallbackMatrix: mainMatrix,
+            clipAntimeridian: false,
         };
     }
 

package/src/geo/projection/mercator_utils.test.ts

@@ -58,25 +58,25 @@ describe('mercator utils', () => {
     describe('tileCoordinatesToMercatorCoordinates', () => {
         const precisionDigits = 10;
 
-        test('Test 0,0', () => {
+        test('0,0', () => {
             const result = tileCoordinatesToMercatorCoordinates(0, 0, new CanonicalTileID(0, 0, 0));
             expect(result.x).toBe(0);
             expect(result.y).toBe(0);
         });
 
-        test('Test tile center', () => {
+        test('tile center', () => {
             const result = tileCoordinatesToMercatorCoordinates(EXTENT / 2, EXTENT / 2, new CanonicalTileID(0, 0, 0));
             expect(result.x).toBeCloseTo(0.5, precisionDigits);
             expect(result.y).toBeCloseTo(0.5, precisionDigits);
         });
 
-        test('Test higher zoom 0,0', () => {
+        test('higher zoom 0,0', () => {
             const result = tileCoordinatesToMercatorCoordinates(0, 0, new CanonicalTileID(3, 0, 0));
             expect(result.x).toBe(0);
             expect(result.y).toBe(0);
         });
 
-        test('Test higher zoom tile center', () => {
+        test('higher zoom tile center', () => {
             const result = tileCoordinatesToMercatorCoordinates(EXTENT / 2, EXTENT / 2, new CanonicalTileID(3, 0, 0));
             expect(result.x).toBeCloseTo(1 / 16, precisionDigits);
             expect(result.y).toBeCloseTo(1 / 16, precisionDigits);
@@ -86,25 +86,25 @@ describe('mercator utils', () => {
     describe('tileCoordinatesToLocation', () => {
         const precisionDigits = 5;
 
-        test('Test 0,0', () => {
+        test('0,0', () => {
             const result = tileCoordinatesToLocation(0, 0, new CanonicalTileID(0, 0, 0));
             expect(result.lng).toBeCloseTo(-180, precisionDigits);
             expect(result.lat).toBeCloseTo(MAX_VALID_LATITUDE, precisionDigits);
         });
 
-        test('Test tile center', () => {
+        test('tile center', () => {
             const result = tileCoordinatesToLocation(EXTENT / 2, EXTENT / 2, new CanonicalTileID(0, 0, 0));
             expect(result.lng).toBeCloseTo(0, precisionDigits);
             expect(result.lat).toBeCloseTo(0, precisionDigits);
         });
 
-        test('Test higher zoom 0,0', () => {
+        test('higher zoom 0,0', () => {
             const result = tileCoordinatesToLocation(0, 0, new CanonicalTileID(3, 0, 0));
             expect(result.lng).toBeCloseTo(-180, precisionDigits);
             expect(result.lat).toBeCloseTo(MAX_VALID_LATITUDE, precisionDigits);
         });
 
-        test('Test higher zoom mercator center', () => {
+        test('higher zoom mercator center', () => {
             const result = tileCoordinatesToLocation(EXTENT, EXTENT, new CanonicalTileID(3, 3, 3));
             expect(result.lng).toBeCloseTo(0, precisionDigits);
             expect(result.lat).toBeCloseTo(0, precisionDigits);

package/src/geo/projection/projection.ts

@@ -2,7 +2,6 @@ import type {CanonicalTileID} from '../../tile/tile_id.ts';
 import type {PreparedShader} from '../../shaders/shaders.ts';
 import type {Context} from '../../webgl/context.ts';
 import type {Mesh} from '../../render/mesh.ts';
-import type {Program} from '../../webgl/program.ts';
 import type {SubdivisionGranularitySetting} from '../../render/subdivision_granularity_settings.ts';
 import type {ProjectionSpecification} from '@maplibre/maplibre-gl-style-spec';
 import type {EvaluationParameters} from '../../style/evaluation_parameters.ts';
@@ -23,14 +22,6 @@ import type {EvaluationParameters} from '../../style/evaluation_parameters.ts';
  * - must be explicitly disposed of after usage using the `destroy` function - this allows the implementing class to free any allocated resources
  */
 
-/**
- * @internal
- */
-export type ProjectionGPUContext = {
-    context: Context;
-    useProgram: (name: string) => Program<any>;
-};
-
 /**
  * @internal
  * Specifies the usage for a square tile mesh:
@@ -99,24 +90,12 @@ export interface Projection {
      */
     get transitionState(): number;
 
-    /**
-     * @internal
-     * Gets the error correction latitude in radians.
-     */
-    get latitudeErrorCorrectionRadians(): number;
-
     /**
      * @internal
      * Cleans up any resources the projection created, especially GPU buffers.
      */
     destroy(): void;
 
-    /**
-     * @internal
-     * Runs any GPU-side tasks this projection required. Called at the beginning of every frame.
-     */
-    updateGPUdependent(renderContext: ProjectionGPUContext): void;
-
     /**
      * @internal
      * Returns a subdivided mesh for a given tile ID, covering 0..EXTENT range.
@@ -140,10 +119,4 @@ export interface Projection {
      * Returns true if the projection is currently transitioning between two states.
      */
     hasTransition(): boolean;
-
-    /**
-     * @internal
-     * Sets the error query latidude in degrees
-     */
-    setErrorQueryLatitudeDegrees(value: number): void;
 }

package/src/geo/projection/projection_data.ts

@@ -60,6 +60,14 @@ export type ProjectionData<MainMatrix extends mat4 = mat4, FallbackMatrix extend
      * Uniform name: `u_projection_fallback_matrix`.
      */
     fallbackMatrix: FallbackMatrix;
+    /**
+     * Whether line fragments outside the tile's X extent should be discarded: true for the zoom 0 tile under globe projection, false otherwise.
+     * The z0 tile covers the whole world, so its buffer wraps around the planet onto the tile itself,
+     * drawing geometry near the antimeridian twice. Stencil clipping cannot remove this same-pixel overlap,
+     * so lines are clipped in the fragment shader instead (fills are clipped during subdivision).
+     * Uniform name: `u_projection_clip_antimeridian`.
+     */
+    clipAntimeridian: boolean;
 };
 
 /**

package/src/geo/projection/projection_factory.ts

@@ -14,14 +14,14 @@ import type {Projection} from './projection.ts';
 import type {ITransform, TransformConstrainFunction} from '../transform_interface.ts';
 import type {ICameraHelper} from './camera_helper.ts';
 
-export function createProjectionFromName(name: ProjectionSpecification['type'], transformConstrain?: TransformConstrainFunction): {
+export function createProjectionFromName(name: ProjectionSpecification['type'], transformConstrain: TransformConstrainFunction | undefined, globalState: Record<string, any>): {
     projection: Projection;
     transform: ITransform;
     cameraHelper: ICameraHelper;
 } {
     const transformOptions = {constrainOverride: transformConstrain};
     if (Array.isArray(name)) {
-        const globeProjection = new GlobeProjection({type: name});
+        const globeProjection = new GlobeProjection({type: name}, globalState);
         return {
             projection: globeProjection,
             transform: new GlobeTransform(transformOptions),
@@ -47,7 +47,7 @@ export function createProjectionFromName(name: ProjectionSpecification['type'],
                 'vertical-perspective',
                 12,
                 'mercator'
-            ]});
+            ]}, {});
             return {
                 projection: globeProjection,
                 transform: new GlobeTransform(transformOptions),

package/src/geo/projection/vertical_perspective_projection.ts

@@ -1,23 +1,15 @@
 import type {Context} from '../../webgl/context.ts';
 import type {CanonicalTileID} from '../../tile/tile_id.ts';
 import {type Mesh} from '../../render/mesh.ts';
-import {now} from '../../util/time_control.ts';
-import {easeCubicInOut, lerp} from '../../util/util.ts';
-import {mercatorYfromLat} from '../mercator_coordinate.ts';
 import {SubdivisionGranularityExpression, SubdivisionGranularitySetting} from '../../render/subdivision_granularity_settings.ts';
-import type {Projection, ProjectionGPUContext, TileMeshUsage} from './projection.ts';
+import type {Projection, TileMeshUsage} from './projection.ts';
 import {type PreparedShader, shaders} from '../../shaders/shaders.ts';
-import {ProjectionErrorMeasurement} from './globe_projection_error_measurement.ts';
 import {createTileMeshWithBuffers, type CreateTileMeshOptions} from '../../util/create_tile_mesh.ts';
 import {type EvaluationParameters} from '../../style/evaluation_parameters.ts';
 
 export const VerticalPerspectiveShaderDefine = '#define GLOBE';
 export const VerticalPerspectiveShaderVariantKey = 'globe';
 
-export const globeConstants = {
-    errorTransitionTimeSeconds: 0.5
-};
-
 const granularitySettingsGlobe: SubdivisionGranularitySetting = new SubdivisionGranularitySetting({
     fill: new SubdivisionGranularityExpression(128, 2),
     line: new SubdivisionGranularityExpression(512, 0),
@@ -36,14 +28,6 @@ const granularitySettingsGlobe: SubdivisionGranularitySetting = new SubdivisionG
 export class VerticalPerspectiveProjection implements Projection {
     private _tileMeshCache: {[_: string]: Mesh} = {};
 
-    // GPU atan() error correction
-    private _errorMeasurement: ProjectionErrorMeasurement;
-    private _errorQueryLatitudeDegrees: number;
-    private _errorCorrectionUsable: number = 0.0;
-    private _errorMeasurementLastValue: number = 0.0;
-    private _errorCorrectionPreviousValue: number = 0.0;
-    private _errorMeasurementLastChangeTime: number = -1000.0;
-
     get name(): 'vertical-perspective' {
         return 'vertical-perspective';
     }
@@ -80,39 +64,8 @@ export class VerticalPerspectiveProjection implements Projection {
         return true;
     }
 
-    /**
-     * @internal
-     * Globe projection periodically measures the error of the GPU's
-     * projection from mercator to globe and computes how much to correct
-     * the globe's latitude alignment.
-     * This stores the correction that should be applied to the projection matrix.
-     */
-    get latitudeErrorCorrectionRadians(): number { return this._errorCorrectionUsable; }
-
     public destroy(): void {
-        if (this._errorMeasurement) {
-            this._errorMeasurement.destroy();
-        }
-    }
-
-    public updateGPUdependent(renderContext: ProjectionGPUContext): void {
-        this._errorMeasurement ||= new ProjectionErrorMeasurement(renderContext);
-        const mercatorY = mercatorYfromLat(this._errorQueryLatitudeDegrees);
-        const expectedResult = 2.0 * Math.atan(Math.exp(Math.PI - (mercatorY * Math.PI * 2.0))) - Math.PI * 0.5;
-        const newValue = this._errorMeasurement.updateErrorLoop(mercatorY, expectedResult);
-
-        const currentTime = now();
-
-        if (newValue !== this._errorMeasurementLastValue) {
-            this._errorCorrectionPreviousValue = this._errorCorrectionUsable; // store the interpolated value
-            this._errorMeasurementLastValue = newValue;
-            this._errorMeasurementLastChangeTime = currentTime;
-        }
-
-        const sinceUpdateSeconds = (currentTime - this._errorMeasurementLastChangeTime) / 1000.0;
-        const mix = Math.min(Math.max(sinceUpdateSeconds / globeConstants.errorTransitionTimeSeconds, 0.0), 1.0);
-        const newCorrection = -this._errorMeasurementLastValue; // Note the negation
-        this._errorCorrectionUsable = lerp(this._errorCorrectionPreviousValue, newCorrection, easeCubicInOut(mix));
+        // Do nothing.
     }
 
     private _getMeshKey(options: CreateTileMeshOptions): string {
@@ -150,16 +103,6 @@ export class VerticalPerspectiveProjection implements Projection {
     }
 
     hasTransition(): boolean {
-        const currentTime = now();
-        let dirty = false;
-        // Error correction transition
-        dirty ||= (currentTime - this._errorMeasurementLastChangeTime) / 1000.0 < (globeConstants.errorTransitionTimeSeconds + 0.2);
-        // Error correction query in flight
-        dirty ||= (this._errorMeasurement?.awaitingQuery);
-        return dirty;
-    }
-
-    setErrorQueryLatitudeDegrees(value: number): void {
-        this._errorQueryLatitudeDegrees = value;
+        return false;
     }
 }

package/src/geo/projection/vertical_perspective_transform.ts

@@ -245,12 +245,11 @@ export class VerticalPerspectiveTransform implements ITransform {
     private _cachedFrustum: Frustum;
     private _projectionMatrix: mat4 = createIdentityMat4f64();
     private _globeViewProjMatrix32f: Mat4f32 = createIdentityMat4f32(); // Must be 32 bit floats, otherwise WebGL calls in Chrome get very slow.
-    private _globeViewProjMatrixNoCorrection: mat4 = createIdentityMat4f64();
-    private _globeViewProjMatrixNoCorrectionInverted: mat4 = createIdentityMat4f64();
+    private _globeViewProjMatrixF64: mat4 = createIdentityMat4f64();
+    private _globeViewProjMatrixF64Inverted: mat4 = createIdentityMat4f64();
     private _globeProjMatrixInverted: mat4 = createIdentityMat4f64();
 
     private _cameraPosition: vec3 = createVec3f64();
-    private _globeLatitudeErrorCorrectionRadians: number = 0;
     /**
      * Globe projection can smoothly interpolate between globe view and mercator. This variable controls this interpolation.
      * Value 0 is mercator, value 1 is globe, anything between is an interpolation between the two projections.
@@ -272,14 +271,13 @@ export class VerticalPerspectiveTransform implements ITransform {
         return clone;
     }
 
-    public apply(that: IReadonlyTransform, constrain: boolean, globeLatitudeErrorCorrectionRadians?: number): void {
-        this._globeLatitudeErrorCorrectionRadians = globeLatitudeErrorCorrectionRadians || 0;
+    public apply(that: IReadonlyTransform, constrain: boolean): void {
         this._helper.apply(that, constrain);
     }
 
     public get projectionMatrix(): mat4 { return this._projectionMatrix; }
 
-    public get modelViewProjectionMatrix(): mat4 { return this._globeViewProjMatrixNoCorrection; }
+    public get modelViewProjectionMatrix(): mat4 { return this._globeViewProjMatrixF64; }
 
     public get inverseProjectionMatrix(): mat4 { return this._globeProjMatrixInverted; }
 
@@ -306,6 +304,7 @@ export class VerticalPerspectiveTransform implements ITransform {
             clippingPlane: this._cachedClippingPlane as [number, number, number, number],
             projectionTransition: applyGlobeMatrix ? 1 : 0,
             fallbackMatrix: this._globeViewProjMatrix32f,
+            clipAntimeridian: overscaledTileID?.canonical.z === 0,
         };
     }
 
@@ -427,7 +426,7 @@ export class VerticalPerspectiveTransform implements ITransform {
         const elevation = getElevation ? getElevation(x, y) : 0.0;
         const vectorMultiplier = 1.0 + elevation / earthRadius;
         const pos: vec4 = [spherePos[0] * vectorMultiplier, spherePos[1] * vectorMultiplier, spherePos[2] * vectorMultiplier, 1];
-        vec4.transformMat4(pos, pos, this._globeViewProjMatrixNoCorrection);
+        vec4.transformMat4(pos, pos, this._globeViewProjMatrixF64);
 
         // Also check whether the point projects to the backfacing side of the sphere.
         const plane = this._cachedClippingPlane;
@@ -451,7 +450,6 @@ export class VerticalPerspectiveTransform implements ITransform {
 
         // Construct a completely separate matrix for globe view
         const globeMatrix = createMat4f64();
-        const globeMatrixUncorrected = createMat4f64();
         if (this._helper.autoCalculateNearFarZ) {
             this._helper._nearZ = 0.5;
             this._helper._farZ = this.cameraToCenterDistance + globeRadiusPixels * 2.0; // just set the far plane far enough - we will calculate our own z in the vertex shader anyway
@@ -478,19 +476,14 @@ export class VerticalPerspectiveTransform implements ITransform {
         scaleVec[1] = globeRadiusPixels;
         scaleVec[2] = globeRadiusPixels;
 
-        // Keep a atan-correction-free matrix for transformations done on the CPU with accurate math
-        mat4.rotateX(globeMatrixUncorrected, globeMatrix, this.center.lat * Math.PI / 180.0);
-        mat4.rotateY(globeMatrixUncorrected, globeMatrixUncorrected, -this.center.lng * Math.PI / 180.0);
-        mat4.scale(globeMatrixUncorrected, globeMatrixUncorrected, scaleVec); // Scale the unit sphere to a sphere with diameter of 1
-        this._globeViewProjMatrixNoCorrection = globeMatrixUncorrected;
-
-        mat4.rotateX(globeMatrix, globeMatrix, this.center.lat * Math.PI / 180.0 - this._globeLatitudeErrorCorrectionRadians);
+        mat4.rotateX(globeMatrix, globeMatrix, this.center.lat * Math.PI / 180.0);
         mat4.rotateY(globeMatrix, globeMatrix, -this.center.lng * Math.PI / 180.0);
         mat4.scale(globeMatrix, globeMatrix, scaleVec); // Scale the unit sphere to a sphere with diameter of 1
+        this._globeViewProjMatrixF64 = globeMatrix;
         this._globeViewProjMatrix32f = new Float32Array(globeMatrix);
 
-        this._globeViewProjMatrixNoCorrectionInverted = createMat4f64();
-        mat4.invert(this._globeViewProjMatrixNoCorrectionInverted, globeMatrixUncorrected);
+        this._globeViewProjMatrixF64Inverted = createMat4f64();
+        mat4.invert(this._globeViewProjMatrixF64Inverted, globeMatrix);
 
         const zero = createVec3f64();
         this._cameraPosition = createVec3f64();
@@ -504,7 +497,7 @@ export class VerticalPerspectiveTransform implements ITransform {
 
         this._cachedClippingPlane = this._computeClippingPlane(globeRadiusPixels);
 
-        const matrix = mat4.clone(this._globeViewProjMatrixNoCorrectionInverted);
+        const matrix = mat4.clone(this._globeViewProjMatrixF64Inverted);
         mat4.scale(matrix, matrix, [1, 1, -1]);
         this._cachedFrustum = Frustum.fromInvProjectionMatrix(matrix, 1, 0, this._cachedClippingPlane, true);
     }
@@ -557,13 +550,13 @@ export class VerticalPerspectiveTransform implements ITransform {
     }
 
     lngLatToCameraDepth(lngLat: LngLat, elevation: number): number {
-        if (!this._globeViewProjMatrixNoCorrection) {
+        if (!this._globeViewProjMatrixF64) {
             return 1.0; // _calcMatrices hasn't run yet
         }
         const vec = angularCoordinatesToSurfaceVector(lngLat);
         vec3.scale(vec, vec, (1.0 + elevation / earthRadius));
         const result = createVec4f64();
-        vec4.transformMat4(result, [vec[0], vec[1], vec[2], 1], this._globeViewProjMatrixNoCorrection);
+        vec4.transformMat4(result, [vec[0], vec[1], vec[2], 1], this._globeViewProjMatrixF64);
         return result[2] / result[3];
     }
 
@@ -783,7 +776,7 @@ export class VerticalPerspectiveTransform implements ITransform {
      */
     private _projectSurfacePointToScreen(pos: vec3): Point {
         const projected = createVec4f64();
-        vec4.transformMat4(projected, [...pos, 1] as vec4, this._globeViewProjMatrixNoCorrection);
+        vec4.transformMat4(projected, [...pos, 1] as vec4, this._globeViewProjMatrixF64);
         projected[0] /= projected[3];
         projected[1] /= projected[3];
         return new Point(
@@ -826,7 +819,7 @@ export class VerticalPerspectiveTransform implements ITransform {
         pos[1] = ((p.y / this.height) * 2.0 - 1.0) * -1.0;
         pos[2] = 1;
         pos[3] = 1;
-        vec4.transformMat4(pos, pos, this._globeViewProjMatrixNoCorrectionInverted);
+        vec4.transformMat4(pos, pos, this._globeViewProjMatrixF64Inverted);
         pos[0] /= pos[3];
         pos[1] /= pos[3];
         pos[2] /= pos[3];
@@ -860,7 +853,7 @@ export class VerticalPerspectiveTransform implements ITransform {
         }
 
         const projected = createVec4f64();
-        vec4.transformMat4(projected, [...vec, 1] as vec4, this._globeViewProjMatrixNoCorrection);
+        vec4.transformMat4(projected, [...vec, 1] as vec4, this._globeViewProjMatrixF64);
         projected[0] /= projected[3];
         projected[1] /= projected[3];
         projected[2] /= projected[3];

package/src/geo/transform_interface.ts

@@ -232,9 +232,8 @@ interface ITransformMutators {
      * @internal
      * Sets the transform's transition state from one projection to another.
      * @param value - The transition state value.
-     * @param error - The error value.
      */
-    setTransitionState(value: number, error: number): void;
+    setTransitionState(value: number): void;
 }
 
 /**

package/src/index.test.ts

@@ -3,7 +3,6 @@ import {config} from './util/config.ts';
 import {addProtocol, getWorkerCount, removeProtocol, getVersion} from './index.ts';
 import {getJSON, getArrayBuffer} from './util/ajax.ts';
 import {ImageRequest} from './util/image_request.ts';
-import {isAbortError} from './util/abort_error.ts';
 
 describe('maplibre', () => {
     beforeEach(() => {
@@ -37,7 +36,7 @@ describe('maplibre', () => {
     });
 
     test('addProtocol - getJSON', async () => {
-        const mockProtocol = vi.fn().mockReturnValue(Promise.resolve({data: {'foo': 'bar'}}));
+        const mockProtocol = vi.fn().mockResolvedValue({data: {'foo': 'bar'}});
         addProtocol('custom', mockProtocol);
 
         const response = await getJSON({url: 'custom://test/url/json'}, new AbortController());
@@ -46,7 +45,7 @@ describe('maplibre', () => {
     });
 
     test('addProtocol - getArrayBuffer', async () => {
-        const mockProtocol = vi.fn().mockReturnValue(Promise.resolve({data: new ArrayBuffer(1), cacheControl: 'cache-control', expires: 'expires'}));
+        const mockProtocol = vi.fn().mockResolvedValue({data: new ArrayBuffer(1), cacheControl: 'cache-control', expires: 'expires'});
         addProtocol('custom', mockProtocol);
 
         const response = await getArrayBuffer({url: 'custom://test/url/getArrayBuffer'}, new AbortController());
@@ -57,7 +56,7 @@ describe('maplibre', () => {
     });
 
     test('addProtocol - null response for getArrayBuffer results in empty array buffer', async () => {
-        const mockProtocol = vi.fn().mockReturnValue(Promise.resolve({data: null, cacheControl: 'cache-control', expires: 'expires'}));
+        const mockProtocol = vi.fn().mockResolvedValue({data: null, cacheControl: 'cache-control', expires: 'expires'});
         addProtocol('custom', mockProtocol);
 
         const response = await getArrayBuffer({url: 'custom://test/url/getArrayBuffer'}, new AbortController());
@@ -69,7 +68,7 @@ describe('maplibre', () => {
     });
 
     test('addProtocol - returning ImageBitmap for getImage', async () => {
-        const mockProtocol = vi.fn().mockReturnValue(Promise.resolve({data: new ImageBitmap()}));
+        const mockProtocol = vi.fn().mockResolvedValue({data: new ImageBitmap()});
         addProtocol('custom', mockProtocol);
 
         const img = await ImageRequest.getImage({url: 'custom://test/url/getImage'}, new AbortController());
@@ -78,7 +77,7 @@ describe('maplibre', () => {
     });
 
     test('addProtocol - returning HTMLImageElement for getImage', async () => {
-        const mockProtocol = vi.fn().mockReturnValue(Promise.resolve({data: new Image()}));
+        const mockProtocol = vi.fn().mockResolvedValue({data: new Image()});
         addProtocol('custom', mockProtocol);
 
         const img = await ImageRequest.getImage({url: 'custom://test/url/getImage'}, new AbortController());
@@ -88,7 +87,7 @@ describe('maplibre', () => {
 
     test('addProtocol - error', async () => {
         const mockError = new Error('test error');
-        const mockProtocol = vi.fn().mockReturnValue(Promise.reject(mockError));
+        const mockProtocol = vi.fn().mockRejectedValue(mockError);
         addProtocol('custom', mockProtocol);
 
         const successCallback = vi.fn();
@@ -110,11 +109,7 @@ describe('maplibre', () => {
         const abortController = new AbortController();
         const promise = getJSON({url: 'custom://test/url/json'}, abortController);
         abortController.abort();
-        try {
-            await promise;
-        } catch (err) {
-            expect(isAbortError(err)).toBeTruthy();
-        }
+        await promise;
 
         expect(cancelCalled).toBeTruthy();
     });

package/src/index.ts

@@ -22,9 +22,9 @@ import {now, setNow, restoreNow, isTimeFrozen} from './util/time_control.ts';
 import {WorkerPool} from './util/worker_pool.ts';
 import {prewarm, clearPrewarmedResources} from './util/global_worker_pool.ts';
 import {AJAXError, type ExpiryData, type GetResourceResponse, type RequestParameters} from './util/ajax.ts';
-import {GeoJSONSource, type SetClusterOptions} from './source/geojson_source.ts';
+import {GeoJSONSource, type GetClusterOptions, type SetClusterOptions} from './source/geojson_source.ts';
 import {CanvasSource, type CanvasSourceSpecification} from './source/canvas_source.ts';
-import {type CanonicalTileRange, type Coordinates, ImageSource, type UpdateImageOptions} from './source/image_source.ts';
+import {type CanonicalTileRange, type Coordinates, type ImageSourceImage, ImageSource, type UpdateImageOptions} from './source/image_source.ts';
 import {RasterDEMTileSource} from './source/raster_dem_tile_source.ts';
 import {RasterTileSource} from './source/raster_tile_source.ts';
 import {VectorTileSource, type LoadTileResult} from './source/vector_tile_source.ts';
@@ -298,9 +298,11 @@ export {
     type Tile,
     type Listener,
     type Coordinates,
+    type ImageSourceImage,
     type UpdateImageOptions,
     type DragPanOptions,
     type FullscreenControlOptions,
+    type GetClusterOptions,
     type SetClusterOptions,
     type GeoJSONSourceDiff,
     type GeolocateControlOptions,

package/src/render/glyph_manager.test.ts

@@ -208,9 +208,7 @@ describe('GlyphManager', () => {
     test('GlyphManager caches locally generated glyphs', async () => {
 
         const manager = createGlyphManager(true, 'sans-serif');
-        const drawSpy = GlyphManager.TinySDF.prototype.draw = vi.fn().mockImplementation(() => {
-            return {data: new Uint8ClampedArray(60 * 60)} as any;
-        });
+        const drawSpy = vi.spyOn(GlyphManager.TinySDF.prototype, 'draw').mockReturnValue({data: new Uint8ClampedArray(60 * 60)} as any);
 
         // Katakana letter te
         const returnedGlyphs = await manager.getGlyphs({'Arial Unicode MS': [0x30c6]});
@@ -220,22 +218,14 @@ describe('GlyphManager', () => {
     });
 
     test('GlyphManager passes no language to TinySDF by default', async () => {
-        const langSpy = GlyphManager.TinySDF = vi.fn().mockImplementation(function () {
-            return {
-                draw: () => GLYPHS[0]
-            };
-        });
+        const langSpy = vi.spyOn(GlyphManager, 'TinySDF').mockImplementation(class { draw = () => GLYPHS[0]; });
         const manager = createGlyphManager(true, 'sans-serif');
         await manager.getGlyphs({'Arial Unicode MS': [0x30c6]});
         expect(langSpy).toHaveBeenCalledWith(expect.not.objectContaining({lang: expect.anything()}));
     });
 
     test('GlyphManager sets the language on TinySDF', async () => {
-        const langSpy = GlyphManager.TinySDF = vi.fn().mockImplementation(function () {
-            return {
-                draw: () => GLYPHS[0]
-            };
-        });
+        const langSpy = vi.spyOn(GlyphManager, 'TinySDF').mockImplementation(class { draw = () => GLYPHS[0]; });
         const manager = createGlyphManager(true, 'sans-serif', 'zh');
         await manager.getGlyphs({'Arial Unicode MS': [0x30c6]});
         expect(langSpy).toHaveBeenCalledWith(expect.objectContaining({lang: 'zh'}));
@@ -244,9 +234,7 @@ describe('GlyphManager', () => {
     test('awaits document.fonts.load before instantiating TinySDF', async () => {
         const loadSpy = vi.fn(() => Promise.resolve([]));
         Object.defineProperty(document, 'fonts', {configurable: true, value: {load: loadSpy}});
-        const tinySdfSpy = GlyphManager.TinySDF = vi.fn().mockImplementation(function () {
-            return {draw: () => GLYPHS[0]};
-        });
+        const tinySdfSpy = vi.spyOn(GlyphManager, 'TinySDF').mockImplementation(class { draw = () => GLYPHS[0]; });
 
         const manager = createGlyphManager(false, 'sans-serif');
         await manager.getGlyphs({'Arial Unicode MS': [0x41]});
@@ -257,11 +245,10 @@ describe('GlyphManager', () => {
     });
 
     test('still instantiates TinySDF when document.fonts.load rejects', async () => {
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
         const loadSpy = vi.fn(() => Promise.reject(new Error('font not found')));
         Object.defineProperty(document, 'fonts', {configurable: true, value: {load: loadSpy}});
-        const tinySdfSpy = GlyphManager.TinySDF = vi.fn().mockImplementation(function () {
-            return {draw: () => GLYPHS[0]};
-        });
+        const tinySdfSpy = vi.spyOn(GlyphManager, 'TinySDF').mockImplementation(class { draw = () => GLYPHS[0]; });
 
         const manager = createGlyphManager(false, 'sans-serif');
         const result = await manager.getGlyphs({'Arial Unicode MS': [0x41]});
@@ -274,9 +261,7 @@ describe('GlyphManager', () => {
     test('memoizes document.fonts.load per fontstack', async () => {
         const loadSpy = vi.fn(() => Promise.resolve([]));
         Object.defineProperty(document, 'fonts', {configurable: true, value: {load: loadSpy}});
-        GlyphManager.TinySDF = vi.fn().mockImplementation(function () {
-            return {draw: () => GLYPHS[0]};
-        });
+        vi.spyOn(GlyphManager, 'TinySDF').mockImplementation(class { draw = () => GLYPHS[0]; });
 
         const manager = createGlyphManager(false, 'sans-serif');
         await manager.getGlyphs({'Arial Unicode MS': [0x41]});

package/src/render/painter.test.ts

@@ -46,6 +46,8 @@ describe('render', () => {
 
     test('must not fail with incompletely loaded style', () => {
         painter.render(style, renderOptions);
+
+        expect(painter.renderPass).toBe('translucent');
     });
 
     test('calls terrainDepth but not terrainCoords', () => {

package/src/render/painter.ts

@@ -284,6 +284,7 @@ export class Painter {
             clippingPlane: [0, 0, 0, 0],
             projectionTransition: 0.0,
             fallbackMatrix: matrix,
+            clipAntimeridian: false,
         };
 
         // Note: we force a simple mercator projection for the shader, since we want to draw a fullscreen quad.
@@ -317,12 +318,14 @@ export class Painter {
             stencilRefs[tileID.key] = this.nextStencilID++;
         }
 
-        // A two-pass approach is needed. See comment in draw_raster.ts for more details.
-        // However, we use a simpler approach because we don't care about overdraw here.
+        // A two-pass approach is needed for subdivided projections. See comment in draw_raster.ts
+        // for more details. In non-subdivided projections the border flag does not change the mesh,
+        // so one pass produces the same stencil mask.
+        if (this.style.projection.useSubdivision) {
+            this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, true);
+        }
 
-        // First pass - draw tiles with borders and with GL_ALWAYS
-        this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, true);
-        // Second pass - draw borderless tiles with GL_ALWAYS
+        // Final pass - draw borderless tiles with GL_ALWAYS
         this._renderTileMasks(stencilRefs, tileIDs, renderToTexture, false);
 
         this._tileClippingMaskIDs = stencilRefs;
@@ -573,12 +576,6 @@ export class Painter {
             this.renderLayer(this, tileManagers[layer.source], layer, coords, renderOptions);
         }
 
-        // Execute offscreen GPU tasks of the projection manager
-        this.style.projection?.updateGPUdependent({
-            context: this.context,
-            useProgram: (name: string) => this.useProgram(name)
-        });
-
         // Rebind the main framebuffer now that all offscreen layers have been rendered:
         this.context.viewport.set([0, 0, this.width, this.height]);
         this.context.bindFramebuffer.set(null);