@@ -1,3 +1,13 @@
+## Unreleased
+
+- New `wheel` (mouse wheel / trackpad scroll, with deltas, pointer position
+  and modifiers), `pinch` (two-finger zoom, with step and total scale and
+  the focal point) and `keyUp` (screen key releases) triggers, for pan and
+  zoom canvases and held keys.
+- `VarianceProperties.tabletMinWidth` and `desktopMinWidth` move where a
+  responsive layout switches layouts (600 and 1024 by default);
+  `ScreenBreakpoint.forWidth` takes them.
+
 ## 6.3.0
 
 This candidate includes the changes documented below for 6.2.0, which has
 
@@ -71,10 +71,15 @@ enum ScreenBreakpoint {
     required this.defaultWidth,
   });
 
-  /// The breakpoint a screen or canvas [width] wide falls in.
-  static ScreenBreakpoint forWidth(double width) {
-    if (width >= desktop.minWidth) return desktop;
-    if (width >= tablet.minWidth) return tablet;
+  /// The breakpoint a screen or canvas [width] wide falls in; a responsive
+  /// layout may move where tablet and desktop start.
+  static ScreenBreakpoint forWidth(
+    double width, {
+    double? tabletMinWidth,
+    double? desktopMinWidth,
+  }) {
+    if (width >= (desktopMinWidth ?? desktop.minWidth)) return desktop;
+    if (width >= (tabletMinWidth ?? tablet.minWidth)) return tablet;
     return mobile;
   }
 }
 
@@ -248,6 +248,20 @@ class MotionModel with Equatable, SerializableMixin {
   /// Uniform scale; 1 is the node's own size.
   final double scale;
 
+  /// Horizontal offset in multiples of the node's own width, added to
+  /// [translateX]: 1 moves it one width right. Lets a layout move by its
+  /// own size whatever size it gets, e.g. a chess piece moved `file` squares
+  /// across a board that stretches to the screen.
+  ///
+  /// Like [translateX] it moves what is painted, not the layout: taps still
+  /// go to the place the node was laid out, so a node that must be tapped
+  /// where it shows (a list or grid item moved off its own cell) has to be
+  /// laid out there instead.
+  final double shiftX;
+
+  /// Vertical offset in multiples of the node's own height; see [shiftX].
+  final double shiftY;
+
   /// Horizontal scale on top of [scale]: a bar growing from its left edge
   /// (origin -1, 0) from 0 to 1.
   final double scaleX;
@@ -311,6 +325,11 @@ class MotionModel with Equatable, SerializableMixin {
   /// pulse, a blinking cursor.
   final MotionLoop loop;
 
+  /// How many times a [loop] runs before the node comes to rest; 0 repeats
+  /// forever. A wrong move's shake: three runs of a reversing loop, replayed
+  /// with [replayKey].
+  final int repeat;
+
   /// Animates from rest (or from [enterFrom]) to these values when the node
   /// first appears, over [durationMs], instead of starting there: a record
   /// sliding out of its sleeve when the screen opens.
@@ -375,6 +394,8 @@ class MotionModel with Equatable, SerializableMixin {
     this.translateX = 0,
     this.translateY = 0,
     this.scale = 1,
+    this.shiftX = 0,
+    this.shiftY = 0,
     this.scaleX = 1,
     this.scaleY = 1,
     this.opacity = 1,
@@ -391,6 +412,7 @@ class MotionModel with Equatable, SerializableMixin {
     this.spin = 0,
     this.spinRampMs = 800,
     this.loop = MotionLoop.none,
+    this.repeat = 0,
     this.enter = false,
     this.enterFrom,
     this.replayKey,
@@ -412,6 +434,8 @@ class MotionModel with Equatable, SerializableMixin {
     'translateX',
     'translateY',
     'scale',
+    'shiftX',
+    'shiftY',
     'scaleX',
     'scaleY',
     'opacity',
@@ -455,6 +479,8 @@ class MotionModel with Equatable, SerializableMixin {
       translateX != 0 ||
       translateY != 0 ||
       scale != 1 ||
+      shiftX != 0 ||
+      shiftY != 0 ||
       scaleX != 1 ||
       scaleY != 1 ||
       opacity != 1 ||
@@ -503,6 +529,8 @@ class MotionModel with Equatable, SerializableMixin {
     'translateX' => translateX,
     'translateY' => translateY,
     'scale' => scale,
+    'shiftX' => shiftX,
+    'shiftY' => shiftY,
     'scaleX' => scaleX,
     'scaleY' => scaleY,
     'opacity' => opacity,
@@ -519,6 +547,8 @@ class MotionModel with Equatable, SerializableMixin {
     double? translateX,
     double? translateY,
     double? scale,
+    double? shiftX,
+    double? shiftY,
     double? scaleX,
     double? scaleY,
     double? opacity,
@@ -535,6 +565,7 @@ class MotionModel with Equatable, SerializableMixin {
     double? spin,
     int? spinRampMs,
     MotionLoop? loop,
+    int? repeat,
     bool? enter,
     MotionModel? enterFrom,
     bool clearEnterFrom = false,
@@ -553,6 +584,8 @@ class MotionModel with Equatable, SerializableMixin {
     translateX: translateX ?? this.translateX,
     translateY: translateY ?? this.translateY,
     scale: scale ?? this.scale,
+    shiftX: shiftX ?? this.shiftX,
+    shiftY: shiftY ?? this.shiftY,
     scaleX: scaleX ?? this.scaleX,
     scaleY: scaleY ?? this.scaleY,
     opacity: opacity ?? this.opacity,
@@ -569,6 +602,7 @@ class MotionModel with Equatable, SerializableMixin {
     spin: spin ?? this.spin,
     spinRampMs: spinRampMs ?? this.spinRampMs,
     loop: loop ?? this.loop,
+    repeat: repeat ?? this.repeat,
     enter: enter ?? this.enter,
     enterFrom: clearEnterFrom ? null : enterFrom ?? this.enterFrom,
     replayKey: clearReplayKey ? null : replayKey ?? this.replayKey,
@@ -586,6 +620,8 @@ class MotionModel with Equatable, SerializableMixin {
     translateX: 0,
     translateY: 0,
     scale: 1,
+    shiftX: 0,
+    shiftY: 0,
     scaleX: 1,
     scaleY: 1,
     opacity: 1,
@@ -600,6 +636,8 @@ class MotionModel with Equatable, SerializableMixin {
     'translateX' => copyWith(translateX: value),
     'translateY' => copyWith(translateY: value),
     'scale' => copyWith(scale: value),
+    'shiftX' => copyWith(shiftX: value),
+    'shiftY' => copyWith(shiftY: value),
     'scaleX' => copyWith(scaleX: value),
     'scaleY' => copyWith(scaleY: value),
     'opacity' => copyWith(opacity: value.clamp(0, 1).toDouble()),
@@ -740,6 +778,8 @@ class MotionModel with Equatable, SerializableMixin {
     translateX,
     translateY,
     scale,
+    shiftX,
+    shiftY,
     scaleX,
     scaleY,
     opacity,
@@ -756,6 +796,7 @@ class MotionModel with Equatable, SerializableMixin {
     spin,
     spinRampMs,
     loop,
+    repeat,
     enter,
     enterFrom,
     replayKey,
 
@@ -170,7 +170,30 @@ enum TriggerType {
   /// in logical pixels), `${result.max}` (how far it can scroll) and
   /// `${result.fraction}` (0 at the start, 1 at the end), so a header can
   /// collapse, a bar fade in or a button appear as the content scrolls.
-  scroll;
+  scroll,
+
+  /// Triggered when the mouse wheel or a trackpad scrolls over the target.
+  /// The actions read `${result.deltaX}` and `${result.deltaY}` (how far it
+  /// scrolled, positive down and right), `${result.x}` and `${result.y}`
+  /// (the pointer, relative to the target's top-left) and
+  /// `${result.ctrl}` (Control or Command held: browsers send trackpad
+  /// pinches as Control + wheel), `${result.shift}` and `${result.trackpad}`.
+  /// The scroll doesn't also scroll the page.
+  wheel,
+
+  /// Triggered on every step of a two-finger pinch (or trackpad pinch) on
+  /// the target. The actions read `${result.scale}` (the zoom since the
+  /// previous step: above 1 spreads, below 1 pinches), `${result.totalScale}`
+  /// (since the pinch started), `${result.x}`, `${result.y}` (the point
+  /// between the fingers, relative to the target) and `${result.deltaX}`,
+  /// `${result.deltaY}` (how far that point moved). A one-finger drag on a
+  /// target with pinch reactions still runs its [drag] reactions.
+  pinch,
+
+  /// Triggered when a key is released while the screen it is set on shows
+  /// and no text field has focus, with the same `${result}` as [keyDown]:
+  /// together they track a held key (Space to pan).
+  keyUp;
 
   /// The triggers for the mouse cursor entering and leaving the target.
   static const List<TriggerType> hovers = [
@@ -285,6 +308,12 @@ enum TriggerType {
         return 'Reorder';
       case TriggerType.scroll:
         return 'Scroll';
+      case TriggerType.wheel:
+        return 'Wheel';
+      case TriggerType.pinch:
+        return 'Pinch';
+      case TriggerType.keyUp:
+        return 'Key Up';
     }
   }
 }
@@ -311,7 +340,8 @@ class TriggerModel with Equatable, SerializableMixin {
   /// How often a [TriggerType.timer] fires, in milliseconds.
   final int? intervalMs;
 
-  /// The key a [TriggerType.keyPress] or [TriggerType.keyDown] listens for.
+  /// The key a [TriggerType.keyPress], [TriggerType.keyDown] or
+  /// [TriggerType.keyUp] listens for.
   /// Key down labels (e.g. `ArrowLeft`) are case-insensitive; null listens
   /// for every key.
   final String? key;