feat(core): tame pinch zoom inertia on touch lift

The post-pinch inertia projection is intact but no longer kicks the
camera past the user's gesture when the final frame is noisy:

- Cap the velocity that drives the projection (0.005 log2(scale)/ms).
  A spike on the lift frame can't translate into a runaway zoom.
- Halve both the forward-projected distance and the inertia transition
  duration so the post-lift glide is soft instead of abrupt. This is
  most noticeable on touch where the last frame is usually the noisiest.

Behavior unchanged for slow/steady pinches whose velocity stays below
the cap; faster pinches still get inertia, just gentler.

Author: charlieforward9

modules/core/src/controllers/controller.ts

@@ -20,6 +20,14 @@ const NO_TRANSITION_PROPS = {
 
 const DEFAULT_INERTIA = 300;
 const INERTIA_EASING = t => 1 - (1 - t) * (1 - t);
+// Cap the velocity that drives pinch-zoom inertia (in log2(scale) per ms).
+// A noisy last frame can produce a runaway projection — without a cap, lift
+// "kicks" the camera further than the gesture intended.
+const PINCH_INERTIA_VELOCITY_LOG2_CAP = 0.005;
+// Scale both the forward-projected distance and the inertia transition
+// duration. 0.5 keeps a sense of momentum without overshoot, especially on
+// touch where the pinch end frame is often the noisiest one.
+const PINCH_INERTIA_DAMPING = 0.5;
 
 const EVENT_TYPES = {
   WHEEL: ['wheel'],
@@ -696,16 +704,24 @@ export default abstract class Controller<ControllerState extends IViewState<Cont
       const pos = this.getCenter(event);
       let newControllerState = this.controllerState.rotateEnd();
       const z = Math.log2(event.scale);
-      const velocityZ =
-        (z - Math.log2(_lastPinchEvent.scale)) / (event.deltaTime - _lastPinchEvent.deltaTime);
-      const endScale = Math.pow(2, z + (velocityZ * inertia) / 2);
+      const dt = Math.max(1, event.deltaTime - _lastPinchEvent.deltaTime);
+      const rawVelocityZ = (z - Math.log2(_lastPinchEvent.scale)) / dt;
+      // Cap the velocity so a noisy last frame can't kick the camera, and
+      // halve the forward projection so inertia feels like a soft glide
+      // instead of an abrupt extra zoom past the user's gesture.
+      const velocityZ = Math.max(
+        -PINCH_INERTIA_VELOCITY_LOG2_CAP,
+        Math.min(PINCH_INERTIA_VELOCITY_LOG2_CAP, rawVelocityZ)
+      );
+      const dampedInertia = inertia * PINCH_INERTIA_DAMPING;
+      const endScale = Math.pow(2, z + (velocityZ * dampedInertia) / 2);
       newControllerState = newControllerState.zoom({pos, scale: endScale}).zoomEnd();
 
       this.updateViewport(
         newControllerState,
         {
           ...this._getTransitionProps({around: pos}),
-          transitionDuration: inertia,
+          transitionDuration: dampedInertia,
           transitionEasing: INERTIA_EASING
         },
         {
@@ -715,7 +731,7 @@ export default abstract class Controller<ControllerState extends IViewState<Cont
           isRotating: false
         }
       );
-      this.blockEvents(inertia);
+      this.blockEvents(dampedInertia);
     } else {
       const newControllerState = this.controllerState.zoomEnd().rotateEnd();
       this.updateViewport(newControllerState, null, {

test/modules/core/controllers/controllers.spec.ts

@@ -35,6 +35,43 @@ test('MapController#inertia', async () => {
   });
 });
 
+test('MapController caps pinch zoom inertia from a spike on touch lift', () => {
+  // A noisy final pinch frame produces a much higher velocity than the live
+  // gesture. The post-end inertia projection should be bounded to a soft
+  // glide, not a hard kick.
+  const makePinchEvent = (type: string, scale: number, deltaTime: number) => ({
+    type,
+    offsetCenter: {x: 50, y: 50},
+    scale,
+    rotation: 0,
+    deltaTime,
+    srcEvent: {preventDefault() {}},
+    stopPropagation() {}
+  });
+
+  const controller = createTestController({
+    view: new MapView({controller: true}),
+    initialViewState: {
+      longitude: -122.45,
+      latitude: 37.78,
+      zoom: 10,
+      pitch: 30,
+      bearing: -45,
+      inertia: 300
+    }
+  });
+
+  controller.handleEvent(makePinchEvent('pinchstart', 1, 0) as any);
+  controller.handleEvent(makePinchEvent('pinchmove', 1.1, 16) as any);
+  const zoomAfterMove = controller.props.zoom as number;
+  // Simulate a 100x spike on the very last frame.
+  controller.handleEvent(makePinchEvent('pinchend', 100, 17) as any);
+
+  const overshoot = (controller.props.zoom as number) - zoomAfterMove;
+  // velocity cap (0.005 log2/ms) * inertia (300) * damping (0.5) / 2 = 0.375
+  expect(overshoot, 'inertia overshoot is bounded by the velocity cap and damping').toBeLessThan(1);
+});
+
 test('GlobeController', async () => {
   await testController(
     GlobeView,