fix(marquee): reject a degenerate drag before touching any state

A perfectly axis-aligned drag (dy == 0) clears the gesture layer's travel
threshold, so select(inAXRect:) really does receive a zero-height rect in
normal use. Rejecting it after the per-selection clears silently stripped
an open frame selection's anchor -- re-anchoring a composer mid-typing --
and did so without assigning selected, so the @published change driving
the re-render never fired and the overlay kept stale geometry.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: angusbezzina

Sources/AnnotKit/Overlay/AnnotationSession.swift

@@ -318,6 +318,31 @@ public final class AnnotationSession: ObservableObject {
     @discardableResult
     public func select(inAXRect rect: CGRect) -> Element? {
         guard mode == .annotating else { return nil }
+
+        // Normalize and reject a degenerate rect BEFORE touching any state, so a
+        // drag that framed nothing is a TRUE no-op.
+        //
+        // A zero-width or zero-height rect is a click that never moved, not a
+        // marquee. Returning nil is a DELIBERATE divergence from "fall back to the
+        // region path when resolution yields nothing": that fallback is for a drag
+        // that framed nothing annotatable, whereas this is not a drag at all.
+        // Falling through would anchor a zero-area frame to whatever sits near the
+        // press and plant a note the user never asked for — worse than nothing,
+        // because it looks deliberate. This also bails BEFORE consulting the
+        // source, so a degenerate rect never reaches `MarqueeTargetRule.resolve`
+        // or `regionAnchor(at:)`.
+        //
+        // Bailing FIRST is load-bearing, not tidiness. A perfectly axis-aligned
+        // drag (dy == 0) clears the gesture layer's travel threshold and arrives
+        // here with zero height, so this branch IS reachable in normal use. Clear
+        // per-selection state before the guard and such a drag would silently strip
+        // an open frame selection's anchor — re-anchoring a composer the user was
+        // still typing into, and doing it WITHOUT assigning `selected`, so the
+        // @Published change that drives the re-render never fires and the overlay
+        // is left rendering stale geometry.
+        let normalized = rect.standardized
+        guard normalized.width > 0, normalized.height > 0 else { return nil }
+
         // A drag on the catcher dismisses an open pin editor for the same reason a
         // tap does: the composer is about to take the stage.
         editingNoteID = nil
@@ -334,23 +359,6 @@ public final class AnnotationSession: ObservableObject {
         // rect keeps one definition of "the centre of what was drawn".
         resetNavigation(hint: nil)
 
-        // Normalize once: a right-to-left or bottom-to-top drag arrives with
-        // negative extents.
-        //
-        // A zero-width or zero-height rect is a click that never moved, not a
-        // marquee. Returning nil here is a DELIBERATE divergence from "the caller
-        // falls back to the region path when resolution yields nothing": that
-        // fallback is for a drag that framed nothing annotatable, whereas this is
-        // not a drag at all. Falling through would anchor a zero-area frame to
-        // whatever happens to sit near the press and plant a note the user never
-        // asked for — worse than nothing, because it looks deliberate. The gesture
-        // recognizer routes this case to ``select(atAXPoint:)`` instead (see the
-        // caller contract above). Note this also bails BEFORE consulting the
-        // source, so a degenerate rect never reaches `MarqueeTargetRule.resolve`
-        // or `regionAnchor(at:)`.
-        let normalized = rect.standardized
-        guard normalized.width > 0, normalized.height > 0 else { return nil }
-
         if let marqueeSource = source as? MarqueeTargetSource {
             let ladder = marqueeSource.marqueeLadder(in: normalized)
             if let target = ladder.first {

Tests/AnnotKitTests/AnnotationSessionTests.swift

@@ -427,6 +427,32 @@ final class AnnotationSessionTests: XCTestCase {
         XCTAssertEqual(session.selectedMarqueeRect, CGRect(x: 110, y: 120, width: 40, height: 20))
     }
 
+    /// A degenerate drag must be a TRUE no-op, not a partial one.
+    ///
+    /// A perfectly axis-aligned drag (dy == 0) clears the gesture layer's travel
+    /// threshold, so it really does arrive here with zero height — this is normal
+    /// use, not a synthetic edge case. Rejecting it AFTER the per-selection clears
+    /// would silently strip an open frame selection's anchor, re-anchoring a
+    /// composer the user was still typing into, and would do it without assigning
+    /// `selected`, so the @Published change that drives the re-render never fires
+    /// and the overlay keeps rendering the old geometry.
+    func testDegenerateDragLeavesAnOpenFrameSelectionUntouched() {
+        let card = makeLadderElement("Card", frame: CGRect(x: 100, y: 100, width: 60, height: 40))
+        let source = MarqueeSource(ladder: [card])
+        let session = AnnotationSession(source: source, sink: NotesFileSink(path: "/dev/null"))
+        session.start()
+        let drawn = CGRect(x: 110, y: 120, width: 40, height: 20)
+        session.select(inAXRect: drawn)
+        XCTAssertEqual(session.selectionAnchorFrame, drawn, "the frame is the anchor before the stray drag")
+
+        // A long, perfectly horizontal drag: passes the travel threshold, zero height.
+        XCTAssertNil(session.select(inAXRect: CGRect(x: 200, y: 300, width: 80, height: 0)))
+
+        XCTAssertEqual(session.selected?.id, "Card", "the open selection survives")
+        XCTAssertEqual(session.selectionAnchorFrame, drawn, "and so does its frame anchor")
+        XCTAssertEqual(session.selectedMarqueeRect, drawn, "the note's record of the drag is intact")
+    }
+
     func testMarqueeThenClickDropsTheStaleFrame() {
         // The 7993a67 hazard, marquee edition: the catcher stays live behind an
         // open composer, so drag-then-click WITHOUT capturing is a supported flow.