A turn back against a flying feed brakes first: that notch eases the coast to a stop, the next is the gentle start back, the ones after wind up.

The gentle half push straight away from a flight still overshot (Adam, 2026-10-16: "the first click of the wheel should just stop the coasting/flying maybe with a quick easing rather than a sudden stop and then the next notch should start going slowly in reverse and the next ones should start speeding up"). Now, when the page is flying (over 1.2 px/ms — a notch from rest peaks near 0.9), the first notch back only brakes: the coast's decay is shortened to 40 ms from that moment (the frames a busy thread missed don't travel first), so a flight at 8 px/ms stops within ~300 px, eased. The notch after it, up to 2.5 s later, is the gentle start — half a notch's travel at half the speed — and the ones after wind up as usual. Against a stroll or a coast that only just died there is nothing worth braking: the turn back is the gentle start itself, as before.

feed-wheel-reverse-test: the brake moves nothing by itself and eases out within a short way, never the other way; the next notch creeps back half a notch; the ones after wind up; a notch back a second and a half later is still gentle, three seconds later a full push; a stroll turned back starts gently at once.

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_01J1Kon8bxJoHRpJdSzshCkp

1 files changed, 31 insertions, 33 deletions

diff --git a/tools/feed-wheel-reverse-test.js b/tools/feed-wheel-reverse-test.js
index be5ad54..352bc0e 100644
--- a/tools/feed-wheel-reverse-test.js
+++ b/tools/feed-wheel-reverse-test.js
@@ -34,45 +34,43 @@ for (const dir of [1, -1]) {
   const f = fixture();
   f.wheel(dir); f.advance(17); f.frame();
   f.wheel(dir); f.advance(17); f.frame();
-  // A busy main thread has missed several frames when the reverse arrives.
+  // A busy main thread has missed several frames when the turn back arrives.
   f.advance(120);
   const before = f.y;
+  // [flying: the first turn back is a brake]
   f.wheel(-dir);
-  assert((f.y - before) * dir < 0, 'first reverse notch responds immediately');
-  assert(Math.abs(f.y - before) < 20, 'reverse starts with a small bounded step');
-  const reversed = f.y;
+  assert.equal(f.y, before, 'the brake notch moves nothing by itself');
   f.frame(0); // a queued animation frame can carry an older timestamp
-  assert.equal(f.y, reversed, 'old frame time cannot revive the previous direction');
-  f.advance(17); f.frame();
-  assert((f.y - reversed) * dir < 0, 'next frame continues in the new direction');
-  assert(Math.abs(f.y - reversed) < 20, 'new velocity is not applied to the old frame delay');
+  assert.equal(f.y, before, 'old frame time moves nothing');
+  settle(f, 30);
+  const over = (f.y - before) * dir;
+  assert(over >= 0 && over < 120, 'the brake eases the flight out within a short way, never the other way: ' + over);
+  // [the next notch back: the gentle start]
+  const stopped = f.y;
+  f.wheel(-dir);
+  assert((stopped - f.y) * dir > 0 && (stopped - f.y) * dir < 20, 'the gentle start responds at once with a small step');
   settle(f);
-  // The turn back is a gentler push than a notch: half a notch's travel, so
-  // a reader who overshot settles back rather than flying the other way.
-  const back = (before - f.y) * dir;
-  assert(back > 130 && back < 170, 'a reverse notch against a coast travels half a notch: ' + back);
-  // The next notch the same way is a plain one again, winding up from the
-  // half push's speed: a reversal and a quick second notch travel about a
-  // notch and a half.
-  let pair;
-  { f.wheel(-dir); f.advance(17); f.frame(); f.wheel(-dir); f.advance(120); f.frame(); // coasting again, the other way
-    const y = f.y; f.wheel(dir); f.advance(60); f.frame(); f.wheel(dir); settle(f); pair = (f.y - y) * dir;
-    assert(pair > 440 && pair < 560, 'a reversal and a quick second notch: about a notch and a half: ' + pair); }
-  // From rest the same two quick notches go further: a full first push, and the wind-up.
-  { f.advance(2500); const y = f.y; f.wheel(dir); f.advance(60); f.frame(); f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > pair + 100, 'two quick notches from rest go further: ' + s + ' vs ' + pair); }
-  // A spin that keeps going after a reversal winds up from its second
-  // notch: a reversal plus four quick notches goes well past four plain ones.
-  let spin;
-  { f.wheel(-dir); f.advance(17); f.frame(); f.wheel(-dir); f.advance(120); f.frame();
-    const y = f.y; f.wheel(dir); for (let i = 0; i < 4; i++) { f.advance(60); f.frame(); f.wheel(dir); } settle(f); spin = (f.y - y) * dir;
-    assert(spin > 4 * 300 + 150, 'a spin on after a reversal winds up again: ' + spin); }
-  // ...and the same five quick notches from rest go about as far (the half push costs little).
-  { f.advance(2500); const y = f.y; f.wheel(dir); for (let i = 0; i < 4; i++) { f.advance(60); f.frame(); f.wheel(dir); } settle(f); const s = (f.y - y) * dir;
-    assert(s < spin * 1.3, 'five from rest vs five after a reversal: ' + s + ' vs ' + spin); settle(f, 200); }
+  const back = (stopped - f.y) * dir;
+  assert(back > 130 && back < 170, 'the notch after the brake creeps back half a notch: ' + back);
+  // [then the wind-up]
+  { const y = f.y; f.wheel(-dir); f.advance(60); f.frame(); f.wheel(-dir); settle(f);
+    const on = (y - f.y) * dir; assert(on > 600, 'the notches after wind up: ' + on); }
+  // The gentle start waits a while for its notch: a second and a half after the brake, still gentle.
+  { f.advance(2500); f.wheel(dir); f.advance(17); f.frame(); f.wheel(dir); f.advance(120); f.frame();
+    f.wheel(-dir); settle(f, 30); f.advance(1500); const y = f.y; f.wheel(-dir); settle(f);
+    const s = (y - f.y) * dir; assert(s > 130 && s < 170, 'a notch back a while after the brake is still the gentle start: ' + s); }
+  // ...but long after, the brake forgotten, a notch back is a plain push from rest.
+  { f.advance(2500); f.wheel(dir); f.advance(17); f.frame(); f.wheel(dir); f.advance(120); f.frame();
+    f.wheel(-dir); settle(f, 30); f.advance(3000); const y = f.y; f.wheel(-dir); settle(f);
+    const s = (y - f.y) * dir; assert(s > 280 && s < 330, 'long after the brake, a notch back is a full push: ' + s); }
+  // A stroll (one notch) turned back has nothing worth braking: the gentle start at once.
+  { f.advance(2500); f.wheel(dir); f.advance(100); f.frame(); const y = f.y; f.wheel(-dir);
+    assert((y - f.y) * dir > 0 && (y - f.y) * dir < 20, 'against a stroll the turn back starts at once, with a small step');
+    settle(f); const s = (y - f.y) * dir; assert(s > 130 && s < 170, 'against a stroll the turn back is the gentle start: ' + s); }
   // From rest a notch either way is a full push.
   { f.advance(2500); const y = f.y; f.wheel(dir); settle(f); const s = (f.y - y) * dir; assert(s > 280 && s < 330, 'from rest a notch either way is a full push: ' + s); }
-  // A turn back against a coast that only just died is a reversal too: the half push.
-  { f.wheel(dir); settle(f, 40); f.advance(100); const y = f.y; f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 130 && s < 170, 'reversing right after the coast dies is the half push: ' + s); }
+  // A turn back against a coast that only just died is the gentle start too.
+  { f.wheel(dir); settle(f, 40); f.advance(100); const y = f.y; f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 130 && s < 170, 'reversing right after the coast dies is the gentle start: ' + s); }
   // Well after the coast died it is a plain notch from rest, whichever way.
   { f.advance(2500); const y = f.y; f.wheel(-dir); settle(f); const s = (y - f.y) * dir; assert(s > 280 && s < 330, 'a notch the other way from rest is a full push: ' + s); }
 }
@@ -90,4 +88,4 @@ for (const sel of ['textarea', '.media-pager']) {
   const y = f.y; f.wheel(1); settle(f);
   assert.equal(f.y, y, 'a notch in ' + sel + ' is not ours');
 }
-console.log('✓ immediate reversal both ways, stale frame timestamps, busy frame recovery, a reversal is a half push that winds up again from the next notch, videos and threads coast');
+console.log('✓ a turn back against a flight brakes, the next notch is the gentle start, then the wind-up; against a stroll or a dead coast the gentle start at once; stale frames; videos and threads coast');