Fix bugs across app + server, optimize UI/UX, add Gitea CI

Bug fixes (Flutter):
- Wrap multi-statement DB writes (insert/update/delete note, deleteDocument,
  deletePageData, OCR FTS merge, migrations) in transactions to prevent data
  loss on interruption and a read-modify-write FTS race.
- Fix PdfDocument leaks on exception (try/finally dispose) and preserve image
  aspect ratio when stamping images onto PDF pages.
- Guard file-picker against empty selection (was .single -> crash).
- Fix eraser ConcurrentModificationError and unmodifiable-list crash on PDF
  pages; capture page synchronously on save to stop wrong-page data loss.
- Fix Riverpod DB-not-ready races, broken pull-to-refresh, settings load race,
  and search N+1; transform stored annotations on PDF page rotation.
- Normalize pen pressure for devices without a pressure range.
- PPT: single source of truth for slide strokes so ink displays and exports.

UI/UX:
- Material 3 typography, theme-aware colors (dark-mode fixes), hover cursors
  and right-click/visible actions on desktop, keyboard shortcuts (undo/redo/
  save/find), toolbar overflow handling, friendlier empty states, semantic OCR
  status badges, relative timestamps, 1-based page indicators, large-deck PPT
  navigation, and a scratchpad-scope label in split view.

Server (optional backend):
- Persist JWT secret (was per-process random), block path traversal in storage,
  fix CORS '*'+credentials, add OCR job ownership checks, last-writer-wins sync
  guard, constant-time login, and split out heavy OCR deps so the API/tests run
  without them.

CI: Gitea workflows for format+analyze+test (Linux, system sqlite) and a
Windows release build; pristine `flutter analyze`, all Flutter and server tests
green.

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

lib/screens/ppt_annotator_screen.dart

@@ -0,0 +1,528 @@
+import 'dart:io';
+import 'dart:math';
+import 'dart:typed_data';
+
+import 'package:flutter/material.dart';
+import 'package:path/path.dart' as p;
+import 'package:syncfusion_flutter_pdf/pdf.dart';
+
+import '../models/ink_stroke.dart';
+import '../models/pen_tool.dart';
+import '../models/pressure_curve.dart';
+import '../services/undo_manager.dart';
+import '../utils/stroke_stabilizer.dart';
+import '../widgets/annotation_toolbar.dart';
+import '../widgets/ink_canvas.dart';
+
+/// Per-slide annotation state. The [UndoManager] is the single source of
+/// truth for a slide's strokes; [strokes] reflects its current contents so
+/// the live canvas and the PDF export always render what was actually drawn.
+class _SlideAnnotations {
+  final UndoManager undoManager = UndoManager();
+  List<InkStroke> get strokes => undoManager.currentStrokes;
+}
+
+/// Screen that displays PPTX slides with an ink annotation overlay.
+///
+/// Each slide is shown as an image in a [PageView]. A transparent [InkCanvas]
+/// sits on top of each slide so the user can annotate freely. Annotations are
+/// stored per-slide and can be exported as a PDF.
+class PptAnnotatorScreen extends StatefulWidget {
+  final String filePath;
+  final List<String> slideImagePaths;
+  final String? extractedText;
+
+  const PptAnnotatorScreen({
+    super.key,
+    required this.filePath,
+    required this.slideImagePaths,
+    this.extractedText,
+  });
+
+  @override
+  State<PptAnnotatorScreen> createState() => _PptAnnotatorScreenState();
+}
+
+class _PptAnnotatorScreenState extends State<PptAnnotatorScreen> {
+  late final PageController _pageController;
+  late final Map<int, _SlideAnnotations> _annotations;
+  int _currentPage = 0;
+  bool _isDrawing = false;
+  bool _showTextPanel = false;
+  // Set to true once the unsaved-annotations warning SnackBar has been shown.
+  bool _hasShownUnsavedWarning = false;
+
+  // Toolbar state
+  PenTool _currentTool = PenTool.pen;
+  Color _currentColor = Colors.black;
+  double _currentStrokeWidth = 2.0;
+  bool _filled = false;
+  PressureCurveType _pressureCurveType = PressureCurveType.linear;
+  StabilizationLevel _stabilizationLevel = StabilizationLevel.none;
+
+  // Derived
+  late final String _fileName;
+  late final int _slideCount;
+  late final String _extractedText;
+
+  PressureCurve get _pressureCurve {
+    switch (_pressureCurveType) {
+      case PressureCurveType.linear:
+        return PressureCurve.linear;
+      case PressureCurveType.soft:
+        return PressureCurve.soft;
+      case PressureCurveType.hard:
+        return PressureCurve.hard;
+      case PressureCurveType.custom:
+        return const PressureCurve(type: PressureCurveType.custom);
+    }
+  }
+
+  UndoManager get _currentUndoManager =>
+      _annotations.putIfAbsent(_currentPage, _SlideAnnotations.new).undoManager;
+
+  @override
+  void initState() {
+    super.initState();
+    _fileName = p.basename(widget.filePath);
+    _slideCount = widget.slideImagePaths.length;
+    _extractedText = widget.extractedText ?? '';
+
+    _pageController = PageController();
+    _annotations = {};
+    for (var i = 0; i < _slideCount; i++) {
+      _annotations[i] = _SlideAnnotations();
+    }
+  }
+
+  @override
+  void dispose() {
+    _pageController.dispose();
+    super.dispose();
+  }
+
+  // -- Drawing callbacks --
+
+  void _onStrokeComplete(InkStroke stroke) {
+    setState(() {
+      _currentUndoManager.addStroke(stroke);
+    });
+    // Warn once per session that PPT annotations are not auto-saved.
+    if (!_hasShownUnsavedWarning) {
+      _hasShownUnsavedWarning = true;
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (!mounted) return;
+        ScaffoldMessenger.of(context).showSnackBar(
+          const SnackBar(
+            content: Text(
+              "PPT ink isn't saved automatically — use Export to PDF to keep your annotations.",
+            ),
+            duration: Duration(seconds: 5),
+          ),
+        );
+      });
+    }
+  }
+
+  void _onErase(String strokeId, List<InkStroke> replacements) {
+    setState(() {
+      final original = _currentUndoManager.currentStrokes
+          .where((s) => s.id == strokeId)
+          .firstOrNull;
+      if (original != null) {
+        _currentUndoManager.removeStroke(original, replacements: replacements);
+      }
+    });
+  }
+
+  // -- Export --
+
+  Future<void> _exportPdf() async {
+    if (!mounted) return;
+
+    ScaffoldMessenger.of(
+      context,
+    ).showSnackBar(const SnackBar(content: Text('Exporting PDF...')));
+
+    try {
+      final bytes = await _buildPdfBytes();
+      if (!mounted) return;
+
+      final dir = await _getExportDir();
+      final baseName = p.basenameWithoutExtension(_fileName);
+      final outPath = p.join(dir.path, '${baseName}_annotated.pdf');
+      await File(outPath).writeAsBytes(bytes);
+
+      if (!mounted) return;
+      ScaffoldMessenger.of(
+        context,
+      ).showSnackBar(SnackBar(content: Text('PDF saved: $outPath')));
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(
+        context,
+      ).showSnackBar(SnackBar(content: Text('Export failed: $e')));
+    }
+  }
+
+  Future<Directory> _getExportDir() async {
+    try {
+      final home = Platform.environment['HOME'];
+      if (home != null) {
+        final dir = Directory(p.join(home, 'Documents', 'BadNote'));
+        if (!await dir.exists()) {
+          await dir.create(recursive: true);
+        }
+        return dir;
+      }
+    } catch (_) {}
+    return Directory.current;
+  }
+
+  Future<Uint8List> _buildPdfBytes() async {
+    final doc = PdfDocument();
+    doc.pageSettings.margins.all = 0;
+
+    for (var i = 0; i < _slideCount; i++) {
+      final page = doc.pages.add();
+      final pageSize = page.getClientSize();
+
+      // Draw slide image
+      final imgPath = widget.slideImagePaths[i];
+      try {
+        final imgBytes = await File(imgPath).readAsBytes();
+        final bitmap = PdfBitmap(imgBytes);
+
+        final imgW = bitmap.width.toDouble();
+        final imgH = bitmap.height.toDouble();
+        final scale = min(pageSize.width / imgW, pageSize.height / imgH);
+        final drawW = imgW * scale;
+        final drawH = imgH * scale;
+        final offX = (pageSize.width - drawW) / 2;
+        final offY = (pageSize.height - drawH) / 2;
+        final imgRect = Rect.fromLTWH(offX, offY, drawW, drawH);
+
+        page.graphics.drawImage(bitmap, imgRect);
+
+        // Draw ink strokes
+        final annots = _annotations[i];
+        if (annots != null && annots.strokes.isNotEmpty) {
+          // KNOWN LIMITATION: strokes are captured in the live viewer's
+          // full-fill pixel space (the InkCanvas is Positioned.fill over the
+          // whole slide area, while the slide image is BoxFit.contain inside
+          // it). The scale below is derived from the PDF page layout, not the
+          // live widget size, so exported ink can be misaligned/scaled wrong.
+          // A correct fix normalizes strokes to [0,1] of the *rendered image
+          // rect* at capture time (mirroring PdfAnnotationLayer) and maps that
+          // to the PDF draw rect here. Requires on-device visual verification.
+          final imgAspect = imgW / imgH;
+          final pageAspect = pageSize.width / pageSize.height;
+          double widgetW, widgetH;
+          if (imgAspect > pageAspect) {
+            widgetW = pageSize.width;
+            widgetH = pageSize.width / imgAspect;
+          } else {
+            widgetH = pageSize.height;
+            widgetW = pageSize.height * imgAspect;
+          }
+          final scaleX = drawW / widgetW;
+          final scaleY = drawH / widgetH;
+
+          for (final stroke in annots.strokes) {
+            if (stroke.tool == PenTool.eraser) continue;
+            if (stroke.points.length < 2) continue;
+
+            final r = (stroke.color >> 16) & 0xFF;
+            final g = (stroke.color >> 8) & 0xFF;
+            final b = stroke.color & 0xFF;
+            final pdfColor = PdfColor(r, g, b);
+
+            final path = PdfPath();
+            path.startFigure();
+            for (var j = 0; j < stroke.points.length - 1; j++) {
+              final pt1 = stroke.points[j];
+              final pt2 = stroke.points[j + 1];
+              path.addLine(
+                Offset(offX + pt1.x * scaleX, offY + pt1.y * scaleY),
+                Offset(offX + pt2.x * scaleX, offY + pt2.y * scaleY),
+              );
+            }
+
+            page.graphics.drawPath(
+              path,
+              pen: PdfPen(pdfColor, width: stroke.strokeWidth),
+            );
+          }
+        }
+      } catch (_) {
+        page.graphics.drawRectangle(
+          brush: PdfSolidBrush(PdfColor(230, 230, 230)),
+          bounds: Rect.fromLTWH(0, 0, pageSize.width, pageSize.height),
+        );
+      }
+    }
+
+    final bytes = await doc.save();
+    doc.dispose();
+    return Uint8List.fromList(bytes);
+  }
+
+  // -- UI --
+
+  @override
+  Widget build(BuildContext context) {
+    // No slides to annotate: show an empty state and skip the toolbar, which
+    // would otherwise dereference a non-existent slide's annotation state.
+    if (_slideCount == 0) {
+      return Scaffold(
+        appBar: AppBar(
+          title: Text(_fileName, style: const TextStyle(fontSize: 16)),
+        ),
+        body: const Center(child: Text('No slides to display')),
+      );
+    }
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(_fileName, style: const TextStyle(fontSize: 16)),
+        actions: [
+          if (_extractedText.isNotEmpty)
+            IconButton(
+              icon: Icon(
+                _showTextPanel
+                    ? Icons.text_snippet
+                    : Icons.text_snippet_outlined,
+              ),
+              tooltip: 'Toggle extracted text',
+              onPressed: () => setState(() => _showTextPanel = !_showTextPanel),
+            ),
+          IconButton(
+            icon: const Icon(Icons.picture_as_pdf),
+            tooltip: 'Export as PDF',
+            onPressed: _exportPdf,
+          ),
+        ],
+      ),
+      body: Column(
+        children: [
+          AnnotationToolbar(
+            currentTool: _currentTool,
+            currentColor: _currentColor,
+            currentStrokeWidth: _currentStrokeWidth,
+            filled: _filled,
+            pressureCurveType: _pressureCurveType,
+            stabilizationLevel: _stabilizationLevel,
+            canUndo: _currentUndoManager.canUndo,
+            canRedo: _currentUndoManager.canRedo,
+            onToolChanged: (tool) => setState(() => _currentTool = tool),
+            onColorChanged: (color) => setState(() => _currentColor = color),
+            onStrokeWidthChanged: (w) =>
+                setState(() => _currentStrokeWidth = w),
+            onFilledChanged: (f) => setState(() => _filled = f),
+            onPressureCurveChanged: (v) =>
+                setState(() => _pressureCurveType = v),
+            onStabilizationChanged: (v) =>
+                setState(() => _stabilizationLevel = v),
+            onUndo: _undo,
+            onRedo: _redo,
+          ),
+          Expanded(
+            child: Row(
+              children: [
+                Expanded(child: _buildSlideViewer()),
+                if (_showTextPanel) _buildTextPanel(),
+              ],
+            ),
+          ),
+          _buildPageIndicator(),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildSlideViewer() {
+    if (_slideCount == 0) {
+      return const Center(child: Text('No slides to display'));
+    }
+
+    return Listener(
+      onPointerDown: (_) => setState(() => _isDrawing = true),
+      onPointerUp: (_) => setState(() => _isDrawing = false),
+      child: PageView.builder(
+        controller: _pageController,
+        physics: _isDrawing ? const NeverScrollableScrollPhysics() : null,
+        itemCount: _slideCount,
+        onPageChanged: (page) => setState(() => _currentPage = page),
+        itemBuilder: (context, index) {
+          return Padding(
+            padding: const EdgeInsets.all(8),
+            child: Stack(
+              children: [
+                // Slide image (background)
+                Positioned.fill(
+                  child: Image.file(
+                    File(widget.slideImagePaths[index]),
+                    fit: BoxFit.contain,
+                    errorBuilder: (context, error, stackTrace) => Container(
+                      color: Colors.grey.shade200,
+                      child: Center(
+                        child: Text(
+                          'Slide ${index + 1}',
+                          style: TextStyle(
+                            fontSize: 24,
+                            color: Colors.grey.shade500,
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+                // Ink annotation overlay (foreground)
+                Positioned.fill(
+                  child: InkCanvas(
+                    strokes: _annotations[index]?.strokes ?? [],
+                    onStrokeComplete: _onStrokeComplete,
+                    onErase: _onErase,
+                    tool: _currentTool,
+                    color: _currentColor,
+                    strokeWidth: _currentStrokeWidth,
+                    pressureCurve: _pressureCurve,
+                    stabilizationLevel: _stabilizationLevel,
+                    filled: _filled,
+                  ),
+                ),
+              ],
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  Widget _buildPageIndicator() {
+    if (_slideCount == 0) return const SizedBox.shrink();
+
+    return Container(
+      padding: const EdgeInsets.symmetric(vertical: 8, horizontal: 16),
+      color: Theme.of(context).colorScheme.surface,
+      child: Row(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          // Previous button — always present for both modes.
+          IconButton(
+            icon: const Icon(Icons.chevron_left),
+            onPressed: _currentPage > 0
+                ? () => _pageController.previousPage(
+                    duration: const Duration(milliseconds: 300),
+                    curve: Curves.easeInOut,
+                  )
+                : null,
+          ),
+          // Dot row for small decks; compact text counter for large decks.
+          if (_slideCount <= 12)
+            ...List.generate(_slideCount, (i) {
+              final isActive = i == _currentPage;
+              return GestureDetector(
+                onTap: () => _pageController.animateToPage(
+                  i,
+                  duration: const Duration(milliseconds: 300),
+                  curve: Curves.easeInOut,
+                ),
+                child: Container(
+                  width: isActive ? 12 : 8,
+                  height: isActive ? 12 : 8,
+                  margin: const EdgeInsets.symmetric(horizontal: 4),
+                  decoration: BoxDecoration(
+                    shape: BoxShape.circle,
+                    color: isActive
+                        ? Theme.of(context).colorScheme.primary
+                        : Colors.grey.shade400,
+                  ),
+                ),
+              );
+            })
+          else
+            Text(
+              '${_currentPage + 1} / $_slideCount',
+              style: TextStyle(fontSize: 13, color: Colors.grey.shade600),
+            ),
+          // Next button — always present for both modes.
+          IconButton(
+            icon: const Icon(Icons.chevron_right),
+            onPressed: _currentPage < _slideCount - 1
+                ? () => _pageController.nextPage(
+                    duration: const Duration(milliseconds: 300),
+                    curve: Curves.easeInOut,
+                  )
+                : null,
+          ),
+          const Spacer(),
+          // Slide counter is always shown at the trailing end for dot mode;
+          // the compact text above already serves this role for large decks.
+          if (_slideCount <= 12)
+            Text(
+              '${_currentPage + 1} / $_slideCount',
+              style: TextStyle(fontSize: 13, color: Colors.grey.shade600),
+            ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildTextPanel() {
+    return SizedBox(
+      width: 280,
+      child: Card(
+        margin: const EdgeInsets.all(8),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            Container(
+              padding: const EdgeInsets.all(12),
+              decoration: BoxDecoration(
+                color: Theme.of(context).colorScheme.surfaceContainerHighest,
+                borderRadius: const BorderRadius.vertical(
+                  top: Radius.circular(12),
+                ),
+              ),
+              child: Row(
+                children: [
+                  const Icon(Icons.text_fields, size: 18),
+                  const SizedBox(width: 8),
+                  Text(
+                    'Extracted Text',
+                    style: Theme.of(context).textTheme.titleSmall,
+                  ),
+                  const Spacer(),
+                  IconButton(
+                    icon: const Icon(Icons.close, size: 18),
+                    onPressed: () => setState(() => _showTextPanel = false),
+                  ),
+                ],
+              ),
+            ),
+            Expanded(
+              child: SingleChildScrollView(
+                padding: const EdgeInsets.all(12),
+                child: SelectableText(
+                  _extractedText,
+                  style: Theme.of(context).textTheme.bodySmall,
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  // -- Dialogs --
+
+  void _undo() {
+    setState(() => _currentUndoManager.undo());
+  }
+
+  void _redo() {
+    setState(() => _currentUndoManager.redo());
+  }
+}