fix(drink-detail): harden inline note autosave and undo flows

Review fixes on top of the inline-capture implementation:
- Skip tasting analytics when addTasting restores a pour via Undo,
  matching removeTasting's removal-conditioned logging
- Flush a cleared note on dispose (pending-edit flag instead of a
  text cache that treated empty as nothing-to-save)
- Render the optimistic note value in display mode so the just-typed
  text does not flash back while the save is in flight
- Keep a failed note save pending for retry instead of reporting it
  as saved
- Extract the shared Undo SnackBar builder in the detail screen
- Add a semantic test for the inline field's text-field node

Refs #487

Author: claude

lib/providers/beer_provider.dart

@@ -807,7 +807,9 @@ class BeerProvider extends ChangeNotifier {
   /// Record a new tasting event for a drink, returning the timestamp of the
   /// pour that was logged. The provider owns the timestamp (rather than letting
   /// the store generate it) so callers can offer a precise Undo that removes
-  /// exactly this pour, not merely the newest one.
+  /// exactly this pour, not merely the newest one. Pass [at] to restore a
+  /// previously removed pour with its original timestamp (an Undo), which is
+  /// not counted as a new tasting in analytics.
   Future<DateTime> addTasting(Drink drink, {DateTime? at}) async {
     final event = at ?? DateTime.now();
     if (_drinkRepository == null) return event;
@@ -824,11 +826,17 @@ class BeerProvider extends ChangeNotifier {
 
     notifyListeners();
 
-    // Log analytics event
-    unawaited(_analyticsService.logFestivalLogMarkTasted(drink));
-    final count = newState?.tastingCount ?? 0;
-    if (count > 1) {
-      unawaited(_analyticsService.logFestivalLogMultipleTasting(drink, count));
+    // Only a genuinely new pour is an analytics event — restoring a deleted
+    // one via Undo (at != null) would double-count tastings that already
+    // happened.
+    if (at == null) {
+      unawaited(_analyticsService.logFestivalLogMarkTasted(drink));
+      final count = newState?.tastingCount ?? 0;
+      if (count > 1) {
+        unawaited(
+          _analyticsService.logFestivalLogMultipleTasting(drink, count),
+        );
+      }
     }
     return event;
   }

lib/screens/drink_detail_screen.dart

@@ -108,6 +108,20 @@ class _DrinkDetailScreenState extends State<DrinkDetailScreen>
         ? 'Logged your first tasting'
         : 'Logged — $count tastings';
 
+    _showUndoSnackBar(
+      messenger,
+      message: message,
+      onUndo: () => unawaited(provider.removeTasting(updated, event)),
+    );
+  }
+
+  /// The shared confirmation shape for reversible tasting mutations: a
+  /// floating SnackBar whose message dismisses on tap, with an Undo action.
+  void _showUndoSnackBar(
+    ScaffoldMessengerState messenger, {
+    required String message,
+    required VoidCallback onUndo,
+  }) {
     messenger
       ..hideCurrentSnackBar()
       ..showSnackBar(
@@ -128,10 +142,7 @@ class _DrinkDetailScreenState extends State<DrinkDetailScreen>
               child: Text(message),
             ),
           ),
-          action: SnackBarAction(
-            label: 'Undo',
-            onPressed: () => unawaited(provider.removeTasting(updated, event)),
-          ),
+          action: SnackBarAction(label: 'Undo', onPressed: onUndo),
         ),
       );
   }
@@ -332,30 +343,11 @@ class _DrinkDetailScreenState extends State<DrinkDetailScreen>
     await provider.removeTasting(drink, event);
     if (!mounted || messenger == null) return;
 
-    final message = 'Removed — ${_tastingRowFormat.format(event)}';
-
-    messenger
-      ..hideCurrentSnackBar()
-      ..showSnackBar(
-        SnackBar(
-          behavior: SnackBarBehavior.floating,
-          margin: const EdgeInsets.only(bottom: 12, left: 16, right: 16),
-          duration: const Duration(seconds: 3),
-          content: Semantics(
-            label: message,
-            button: true,
-            hint: 'Double tap to dismiss',
-            child: GestureDetector(
-              onTap: messenger.hideCurrentSnackBar,
-              child: Text(message),
-            ),
-          ),
-          action: SnackBarAction(
-            label: 'Undo',
-            onPressed: () => unawaited(provider.addTasting(drink, at: event)),
-          ),
-        ),
-      );
+    _showUndoSnackBar(
+      messenger,
+      message: 'Removed — ${_tastingRowFormat.format(event)}',
+      onUndo: () => unawaited(provider.addTasting(drink, at: event)),
+    );
   }
 
   List<Widget> _buildSimilarDrinksSlivers(

lib/widgets/your_take_card.dart

@@ -57,7 +57,7 @@ class _YourTakeCardState extends State<YourTakeCard> {
   bool _isEditing = false;
   bool _showSaved = false;
   String? _lastSavedNotes;
-  String? _pendingNotes;
+  bool _hasPendingEdit = false;
 
   @override
   void initState() {
@@ -82,10 +82,12 @@ class _YourTakeCardState extends State<YourTakeCard> {
   void dispose() {
     _debounceTimer?.cancel();
     _savedIndicatorTimer?.cancel();
-    // Best-effort flush: if there's a debounced save that hasn't landed yet,
-    // fire it now rather than silently dropping the user's last edit.
-    if (_pendingNotes != null && _pendingNotes != _lastSavedNotes) {
-      unawaited(widget.onNotesChanged(_pendingNotes));
+    // Best-effort flush: if there's an edit whose save hasn't landed yet
+    // (including clearing the note to empty), fire it now rather than
+    // silently dropping the user's last edit.
+    final normalized = _normalizedControllerText;
+    if (_hasPendingEdit && normalized != _lastSavedNotes) {
+      unawaited(widget.onNotesChanged(normalized));
     }
     _notesFocusNode
       ..removeListener(_handleFocusChange)
@@ -94,6 +96,12 @@ class _YourTakeCardState extends State<YourTakeCard> {
     super.dispose();
   }
 
+  /// The controller text as it would be persisted: trimmed, empty → null.
+  String? get _normalizedControllerText {
+    final trimmed = _notesController.text.trim();
+    return trimmed.isEmpty ? null : trimmed;
+  }
+
   void _handleFocusChange() {
     if (!_notesFocusNode.hasFocus && _isEditing) {
       unawaited(_flushSave());
@@ -107,8 +115,7 @@ class _YourTakeCardState extends State<YourTakeCard> {
   }
 
   void _onFieldChanged(String value) {
-    final trimmed = value.trim();
-    _pendingNotes = trimmed.isEmpty ? null : trimmed;
+    _hasPendingEdit = true;
     _debounceTimer?.cancel();
     _debounceTimer = Timer(
       YourTakeCard.notesDebounceDuration,
@@ -119,12 +126,20 @@ class _YourTakeCardState extends State<YourTakeCard> {
   Future<void> _flushSave() async {
     _debounceTimer?.cancel();
     _debounceTimer = null;
-    final trimmed = _notesController.text.trim();
-    final normalized = trimmed.isEmpty ? null : trimmed;
-    _pendingNotes = null;
+    final normalized = _normalizedControllerText;
+    _hasPendingEdit = false;
     if (normalized == _lastSavedNotes) return;
+    final previous = _lastSavedNotes;
     _lastSavedNotes = normalized;
-    await widget.onNotesChanged(normalized);
+    try {
+      await widget.onNotesChanged(normalized);
+    } catch (_) {
+      // The write failed — keep the edit pending so the next flush (debounce,
+      // blur, or dispose) retries it, and don't claim "Saved".
+      _lastSavedNotes = previous;
+      _hasPendingEdit = true;
+      return;
+    }
     if (!mounted) return;
     _savedIndicatorTimer?.cancel();
     setState(() => _showSaved = true);
@@ -296,7 +311,11 @@ class _YourTakeCardState extends State<YourTakeCard> {
       );
     }
 
-    final notes = widget.drink.userNotes;
+    // Render the optimistic local value, not widget.drink.userNotes — on blur
+    // the card returns to display mode before the async save (and the
+    // provider rebuild it triggers) has landed, and the note the user just
+    // typed must not flash back to its previous state in that window.
+    final notes = _lastSavedNotes;
     final hasNotes = notes != null && notes.isNotEmpty;
 
     return Semantics(

test/beer_provider_test.dart

@@ -3018,6 +3018,12 @@ void main() {
           verify(
             mockDrinkRepository.addTasting(any, any, now: original),
           ).called(1);
+          // Restoring a removed pour is not a new tasting — it must not
+          // inflate the tasting analytics.
+          verifyNever(mockAnalyticsService.logFestivalLogMarkTasted(any));
+          verifyNever(
+            mockAnalyticsService.logFestivalLogMultipleTasting(any, any),
+          );
         },
       );
 

test/widgets/your_take_card_test.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:flutter/semantics.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -170,6 +172,110 @@ void main() {
       expect(calls, ['Quick save']);
     });
 
+    testWidgets(
+      'clearing an existing note is persisted even when the widget is '
+      'disposed before the debounce fires',
+      (tester) async {
+        final calls = <String?>[];
+        await tester.pumpWidget(
+          buildWidget(
+            drink: createSampleDrink(notes: 'Existing'),
+            onNotesChanged: (notes) async => calls.add(notes),
+          ),
+        );
+
+        await tester.tap(find.byKey(const ValueKey('user-notes-editor')));
+        await tester.pump();
+        await tester.enterText(
+          find.byKey(const ValueKey('user-notes-field')),
+          '',
+        );
+
+        // Dispose the card before the debounce window elapses — the cleared
+        // note must still be flushed exactly once, not silently dropped.
+        await tester.pumpWidget(const MaterialApp(home: SizedBox.shrink()));
+
+        expect(calls, [null]);
+      },
+    );
+
+    testWidgets('a failed save is not reported as Saved and is retried', (
+      tester,
+    ) async {
+      var shouldFail = true;
+      var attempts = 0;
+      final saved = <String?>[];
+      await tester.pumpWidget(
+        buildWidget(
+          onNotesChanged: (notes) async {
+            attempts++;
+            if (shouldFail) throw Exception('write failed');
+            saved.add(notes);
+          },
+        ),
+      );
+
+      await tester.tap(find.byKey(const ValueKey('user-notes-editor')));
+      await tester.pump();
+      await tester.enterText(
+        find.byKey(const ValueKey('user-notes-field')),
+        'Nice IPA',
+      );
+      await tester.pump(
+        YourTakeCard.notesDebounceDuration + const Duration(milliseconds: 50),
+      );
+      await tester.pump();
+
+      expect(attempts, 1);
+      expect(find.text('Saved'), findsNothing);
+
+      // The edit stays pending: the next keystroke's flush retries it.
+      shouldFail = false;
+      await tester.enterText(
+        find.byKey(const ValueKey('user-notes-field')),
+        'Nice IPA indeed',
+      );
+      await tester.pump(
+        YourTakeCard.notesDebounceDuration + const Duration(milliseconds: 50),
+      );
+      await tester.pump();
+
+      expect(saved, ['Nice IPA indeed']);
+      expect(find.text('Saved'), findsOneWidget);
+
+      await tester.pump(YourTakeCard.savedIndicatorDuration);
+    });
+
+    testWidgets(
+      'the note just typed stays visible after blur while the save is '
+      'still in flight',
+      (tester) async {
+        final completer = Completer<void>();
+        await tester.pumpWidget(
+          buildWidget(onNotesChanged: (_) => completer.future),
+        );
+
+        await tester.tap(find.byKey(const ValueKey('user-notes-editor')));
+        await tester.pump();
+        await tester.enterText(
+          find.byKey(const ValueKey('user-notes-field')),
+          'Great beer',
+        );
+        FocusManager.instance.primaryFocus?.unfocus();
+        await tester.pump();
+
+        // Back in display mode with the save unresolved — the new text must
+        // not flash back to the placeholder while the write is in flight.
+        expect(find.byKey(const ValueKey('user-notes-field')), findsNothing);
+        expect(find.text('Great beer'), findsOneWidget);
+        expect(find.text('Tap to add your notes'), findsNothing);
+
+        completer.complete();
+        await tester.pump();
+        await tester.pump(YourTakeCard.savedIndicatorDuration);
+      },
+    );
+
     testWidgets('the Saved indicator appears after a save and clears itself', (
       tester,
     ) async {
@@ -230,6 +336,22 @@ void main() {
       );
     });
 
+    testWidgets('the inline note field exposes a text-field semantics node', (
+      tester,
+    ) async {
+      final handle = tester.ensureSemantics();
+      try {
+        await tester.pumpWidget(buildWidget());
+
+        await tester.tap(find.byKey(const ValueKey('user-notes-editor')));
+        await tester.pump();
+
+        expect(find.semantics.byFlag(SemanticsFlag.isTextField), findsOne);
+      } finally {
+        handle.dispose();
+      }
+    });
+
     testWidgets('the Saved indicator is announced as a live region', (
       tester,
     ) async {