chore: Initial commit

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XPovRHpejR4zRxuhjY4Qs3

lib/screens/add_contact_screen.dart

@@ -0,0 +1,394 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:provider/provider.dart';
+
+import '../providers/connection_provider.dart';
+import '../l10n/app_localizations.dart';
+
+class AddContactScreen extends StatefulWidget {
+  final String? initialAdvert;
+
+  const AddContactScreen({super.key, this.initialAdvert});
+
+  @override
+  State<AddContactScreen> createState() => _AddContactScreenState();
+}
+
+class _AddContactScreenState extends State<AddContactScreen> {
+  final TextEditingController _advertController = TextEditingController();
+  bool _isImporting = false;
+  bool _importSucceeded = false;
+  String? _validationError;
+
+  @override
+  void initState() {
+    super.initState();
+    if (widget.initialAdvert != null &&
+        widget.initialAdvert!.trim().isNotEmpty) {
+      _advertController.text = widget.initialAdvert!.trim();
+    } else {
+      _loadClipboardIfPresent();
+    }
+  }
+
+  @override
+  void dispose() {
+    _advertController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _loadClipboardIfPresent() async {
+    final clipboardData = await Clipboard.getData(Clipboard.kTextPlain);
+    final text = clipboardData?.text?.trim();
+    if (!mounted || text == null || text.isEmpty) {
+      return;
+    }
+    if (_normalizeAdvertText(text) == null) {
+      return;
+    }
+    _advertController.text = text;
+  }
+
+  String? _normalizeAdvertText(String value) {
+    final trimmed = value.trim();
+    if (trimmed.isEmpty) {
+      return null;
+    }
+
+    var normalized = trimmed;
+    if (normalized.startsWith('meshcore://')) {
+      normalized = normalized.substring('meshcore://'.length);
+    }
+
+    normalized = normalized.replaceAll(RegExp(r'\s+'), '');
+    if (normalized.isEmpty) {
+      return null;
+    }
+
+    final isHex = RegExp(r'^[0-9a-fA-F]+$').hasMatch(normalized);
+    if (!isHex || normalized.length.isOdd) {
+      return null;
+    }
+
+    return normalized.toLowerCase();
+  }
+
+  Uint8List _hexToBytes(String hex) {
+    final bytes = <int>[];
+    for (var i = 0; i < hex.length; i += 2) {
+      bytes.add(int.parse(hex.substring(i, i + 2), radix: 16));
+    }
+    return Uint8List.fromList(bytes);
+  }
+
+  Future<void> _pasteFromClipboard() async {
+    final clipboardData = await Clipboard.getData(Clipboard.kTextPlain);
+    final text = clipboardData?.text;
+    if (text == null || text.trim().isEmpty) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(AppLocalizations.of(context)!.clipboardIsEmpty)),
+      );
+      return;
+    }
+
+    setState(() {
+      _advertController.text = text.trim();
+      _importSucceeded = false;
+      _validationError = null;
+    });
+  }
+
+  Future<void> _importContact() async {
+    final normalized = _normalizeAdvertText(_advertController.text);
+    if (normalized == null) {
+      setState(() {
+        _validationError =
+            'Enter a valid meshcore:// advert or raw hexadecimal contact advert.';
+      });
+      return;
+    }
+
+    final advertBytes = _hexToBytes(normalized);
+    if (advertBytes.length < 98) {
+      setState(() {
+        _validationError =
+            'Advert is too short. Expected exported contact data.';
+      });
+      return;
+    }
+
+    setState(() {
+      _isImporting = true;
+      _importSucceeded = false;
+      _validationError = null;
+    });
+
+    final connectionProvider = context.read<ConnectionProvider>();
+    await connectionProvider.importContactAdvert(advertBytes);
+    final importError = connectionProvider.error;
+
+    if (importError == null) {
+      await connectionProvider.getContacts();
+    }
+
+    if (!mounted) {
+      return;
+    }
+
+    setState(() {
+      _isImporting = false;
+    });
+
+    if (importError != null) {
+      ScaffoldMessenger.of(
+        context,
+      ).showSnackBar(SnackBar(content: Text(importError)));
+      return;
+    }
+
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(AppLocalizations.of(context)!.contactImported)),
+    );
+    setState(() {
+      _importSucceeded = true;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final normalized = _normalizeAdvertText(_advertController.text);
+    final colorScheme = theme.colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(title: Text(AppLocalizations.of(context)!.addContact)),
+      body: ListView(
+        padding: const EdgeInsets.all(16),
+        children: [
+          Container(
+            padding: const EdgeInsets.all(18),
+            decoration: BoxDecoration(
+              color: colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+              borderRadius: BorderRadius.circular(20),
+              border: Border.all(
+                color: colorScheme.outlineVariant.withValues(alpha: 0.6),
+              ),
+            ),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Row(
+                  children: [
+                    Container(
+                      padding: const EdgeInsets.all(10),
+                      decoration: BoxDecoration(
+                        color: colorScheme.primary.withValues(alpha: 0.12),
+                        borderRadius: BorderRadius.circular(14),
+                      ),
+                      child: Icon(
+                        Icons.person_add_alt_1_outlined,
+                        color: colorScheme.primary,
+                      ),
+                    ),
+                    const SizedBox(width: 12),
+                    Expanded(
+                      child: Text(
+                        'Import a shared contact advert',
+                        style: theme.textTheme.titleMedium?.copyWith(
+                          fontWeight: FontWeight.w700,
+                        ),
+                      ),
+                    ),
+                  ],
+                ),
+                const SizedBox(height: 14),
+                Text(
+                  'Paste a `meshcore://...` link or raw hexadecimal advert. The app will validate it and import the contact into the connected device.',
+                  style: theme.textTheme.bodyMedium?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                const SizedBox(height: 14),
+                Wrap(
+                  spacing: 8,
+                  runSpacing: 8,
+                  children: [
+                    _ImportHintChip(
+                      icon: Icons.link_outlined,
+                      label: AppLocalizations.of(context)!.acceptsShareLinks,
+                    ),
+                    _ImportHintChip(
+                      icon: Icons.code_outlined,
+                      label: AppLocalizations.of(context)!.supportsRawHex,
+                    ),
+                    _ImportHintChip(
+                      icon: Icons.content_paste_go_outlined,
+                      label: AppLocalizations.of(context)!.clipboardfriendly,
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+          const SizedBox(height: 16),
+          Container(
+            padding: const EdgeInsets.all(16),
+            decoration: BoxDecoration(
+              color: colorScheme.surface,
+              borderRadius: BorderRadius.circular(20),
+              border: Border.all(
+                color: colorScheme.outlineVariant.withValues(alpha: 0.7),
+              ),
+            ),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Text(
+                  'Advert payload',
+                  style: theme.textTheme.titleSmall?.copyWith(
+                    fontWeight: FontWeight.w700,
+                  ),
+                ),
+                const SizedBox(height: 6),
+                Text(
+                  'You can paste the full share link or only the hex payload.',
+                  style: theme.textTheme.bodySmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                const SizedBox(height: 12),
+                TextField(
+                  controller: _advertController,
+                  minLines: 5,
+                  maxLines: 9,
+                  onChanged: (_) {
+                    if (_validationError != null || _importSucceeded) {
+                      setState(() {
+                        _importSucceeded = false;
+                        _validationError = null;
+                      });
+                    }
+                  },
+                  decoration: InputDecoration(
+                    labelText: 'Contact advert',
+                    hintText: AppLocalizations.of(context)!.pasteShareLinkOrHexAdvert,
+                    alignLabelWithHint: true,
+                    border: const OutlineInputBorder(),
+                    errorText: _validationError,
+                  ),
+                ),
+                const SizedBox(height: 12),
+                Row(
+                  children: [
+                    Expanded(
+                      child: Text(
+                        normalized == null
+                            ? 'No valid advert detected yet'
+                            : 'Advert size: ${normalized.length ~/ 2} bytes',
+                        style: theme.textTheme.bodySmall?.copyWith(
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                      ),
+                    ),
+                    TextButton.icon(
+                      onPressed: _isImporting ? null : _pasteFromClipboard,
+                      icon: Icon(Icons.content_paste_go_outlined),
+                      label: Text(AppLocalizations.of(context)!.paste),
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+          const SizedBox(height: 20),
+          FilledButton.icon(
+            onPressed: (_isImporting || _importSucceeded)
+                ? null
+                : _importContact,
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(vertical: 14),
+            ),
+            icon: _isImporting
+                ? const SizedBox(
+                    width: 16,
+                    height: 16,
+                    child: CircularProgressIndicator(strokeWidth: 2),
+                  )
+                : _importSucceeded
+                ? const Icon(Icons.check_circle_outline)
+                : const Icon(Icons.person_add_alt_1_outlined),
+            label: Text(
+              _isImporting
+                  ? 'Importing...'
+                  : _importSucceeded
+                  ? 'Imported'
+                  : 'Add Contact',
+            ),
+          ),
+          const SizedBox(height: 12),
+          if (_importSucceeded)
+            Container(
+              padding: const EdgeInsets.all(14),
+              decoration: BoxDecoration(
+                color: colorScheme.primary.withValues(alpha: 0.08),
+                borderRadius: BorderRadius.circular(16),
+                border: Border.all(
+                  color: colorScheme.primary.withValues(alpha: 0.18),
+                ),
+              ),
+              child: Row(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Icon(
+                    Icons.check_circle,
+                    size: 18,
+                    color: colorScheme.primary,
+                  ),
+                  const SizedBox(width: 10),
+                  Expanded(
+                    child: Text(
+                      'Contact imported. Paste another advert or edit the current one to import again.',
+                      style: theme.textTheme.bodySmall?.copyWith(
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+}
+
+class _ImportHintChip extends StatelessWidget {
+  final IconData icon;
+  final String label;
+
+  const _ImportHintChip({required this.icon, required this.label});
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 8),
+      decoration: BoxDecoration(
+        color: theme.colorScheme.surface,
+        borderRadius: BorderRadius.circular(999),
+        border: Border.all(
+          color: theme.colorScheme.outlineVariant.withValues(alpha: 0.7),
+        ),
+      ),
+      child: Row(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          Icon(icon, size: 16, color: theme.colorScheme.onSurfaceVariant),
+          const SizedBox(width: 6),
+          Text(label, style: theme.textTheme.labelMedium),
+        ],
+      ),
+    );
+  }
+}

lib/screens/mcp.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "dart": {
+      "command": "dart",
+      "args": [
+        "mcp-server"
+      ]
+    }
+  }
+}

lib/screens/offline_map_screen.dart

@@ -0,0 +1,846 @@
+import 'package:flutter/material.dart';
+import '../l10n/app_localizations.dart';
+import 'package:flutter_map/flutter_map.dart';
+import 'package:latlong2/latlong.dart';
+import 'package:provider/provider.dart';
+
+import '../models/map_layer.dart';
+import '../providers/offline_tiles_provider.dart';
+import '../widgets/map/polygon_draw_handler.dart';
+
+/// Screen for downloading offline map tiles.
+///
+/// Allows drawing polygons/rectangles to select areas, choosing zoom levels,
+/// and downloading tiles with real-time progress visualization.
+class OfflineMapScreen extends StatefulWidget {
+  const OfflineMapScreen({super.key});
+
+  @override
+  State<OfflineMapScreen> createState() => _OfflineMapScreenState();
+}
+
+class _OfflineMapScreenState extends State<OfflineMapScreen> {
+  final MapController _mapController = MapController();
+  late OfflineTilesProvider _provider;
+  double _currentZoom = 8;
+
+  @override
+  void initState() {
+    super.initState();
+    _provider = context.read<OfflineTilesProvider>();
+    _provider.refreshCacheSize();
+    _provider.refreshLocalStyles();
+    _provider.startPeerDiscovery();
+  }
+
+  @override
+  void dispose() {
+    _provider.stopPeerDiscovery();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(AppLocalizations.of(context)!.offlineMaps),
+        actions: [
+          Consumer<OfflineTilesProvider>(
+            builder: (context, provider, _) {
+              return IconButton(
+                icon: Badge(
+                  isLabelVisible: provider.discoveredPeers.isNotEmpty,
+                  label: Text('${provider.discoveredPeers.length}'),
+                  child: Icon(
+                    provider.isServerRunning
+                        ? Icons.wifi_tethering
+                        : Icons.wifi_tethering_off,
+                  ),
+                ),
+                tooltip: provider.isServerRunning
+                    ? 'Sharing tiles'
+                    : 'Tile sharing off',
+                onPressed: () => _showSharingSheet(context, provider),
+              );
+            },
+          ),
+          Consumer<OfflineTilesProvider>(
+            builder: (context, provider, _) {
+              return PopupMenuButton<MapLayer>(
+                icon: const Icon(Icons.layers),
+                tooltip: AppLocalizations.of(context)!.mapStyle,
+                onSelected: (layer) => provider.setSelectedLayer(layer),
+                itemBuilder: (_) => [
+                  for (final layer in MapLayer.allLayers)
+                    PopupMenuItem(
+                      value: layer,
+                      child: Row(
+                        children: [
+                          if (layer.type == provider.selectedLayer.type)
+                            const Icon(Icons.check, size: 18)
+                          else
+                            const SizedBox(width: 18),
+                          const SizedBox(width: 8),
+                          Text(layer.name),
+                        ],
+                      ),
+                    ),
+                ],
+              );
+            },
+          ),
+        ],
+      ),
+      body: Stack(
+        children: [
+          Consumer<OfflineTilesProvider>(
+            builder: (context, provider, _) {
+              return FlutterMap(
+                mapController: _mapController,
+                options: MapOptions(
+                  initialCenter: const LatLng(46.05, 14.5), // Slovenia
+                  initialZoom: 8,
+                  onPositionChanged: (camera, hasGesture) {
+                    if (camera.zoom != _currentZoom) {
+                      setState(() => _currentZoom = camera.zoom);
+                    }
+                  },
+                  onTap: (tapPosition, point) {
+                    if (provider.drawingMode != DrawingMode.none) {
+                      provider.addVertex(point);
+                    }
+                  },
+                ),
+                children: [
+                  TileLayer(
+                    urlTemplate: provider.selectedLayer.urlTemplate,
+                    tileProvider: NetworkTileProvider(
+                      headers: provider.selectedLayer.headers ?? const {},
+                    ),
+                    userAgentPackageName: 'com.meshcore.sar',
+                    maxZoom: provider.selectedLayer.maxZoom,
+                  ),
+                  CoverageLayer(currentZoom: _currentZoom),
+                  const PolygonDrawLayer(),
+                  const DownloadProgressLayer(),
+                ],
+              );
+            },
+          ),
+          const DrawingToolbar(),
+          Positioned(
+            left: 16,
+            top: 16,
+            child: Container(
+              padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
+              decoration: BoxDecoration(
+                color: Theme.of(context).colorScheme.surface.withValues(alpha: 0.85),
+                borderRadius: BorderRadius.circular(8),
+                boxShadow: [
+                  BoxShadow(
+                    color: Colors.black.withValues(alpha: 0.15),
+                    blurRadius: 4,
+                  ),
+                ],
+              ),
+              child: Text(
+                'Z ${_currentZoom.toStringAsFixed(1)}',
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+              ),
+            ),
+          ),
+          _buildBottomPanel(),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildBottomPanel() {
+    return Positioned(
+      left: 0,
+      right: 0,
+      bottom: 0,
+      child: Consumer<OfflineTilesProvider>(
+        builder: (context, provider, _) {
+          return Container(
+            decoration: BoxDecoration(
+              color: Theme.of(context).colorScheme.surface,
+              borderRadius:
+                  const BorderRadius.vertical(top: Radius.circular(16)),
+              boxShadow: [
+                BoxShadow(
+                  color: Colors.black.withValues(alpha: 0.15),
+                  blurRadius: 10,
+                  offset: const Offset(0, -2),
+                ),
+              ],
+            ),
+            child: SafeArea(
+              top: false,
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  crossAxisAlignment: CrossAxisAlignment.stretch,
+                  children: [
+                    // Saved region presets dropdown
+                    if (!provider.isDownloading &&
+                        provider.localStyles
+                            .any((s) => s.region != null)) ...[
+                      DropdownButtonFormField<StyleInfo>(
+                        decoration: const InputDecoration(
+                          prefixIcon: Icon(Icons.bookmark, size: 20),
+                          labelText: 'Saved regions',
+                          isDense: true,
+                          contentPadding: EdgeInsets.symmetric(
+                              horizontal: 12, vertical: 8),
+                          border: OutlineInputBorder(),
+                        ),
+                        isExpanded: true,
+                        hint: Text(AppLocalizations.of(context)!.loadASavedRegion),
+                        items: provider.localStyles
+                            .where((s) => s.region != null)
+                            .map((style) => DropdownMenuItem(
+                                  value: style,
+                                  child: Text(
+                                    '${style.displayName} '
+                                    '(z${style.region!.minZoom}-${style.region!.maxZoom}, '
+                                    '${_formatNumber(style.tileCount)} tiles)',
+                                    overflow: TextOverflow.ellipsis,
+                                  ),
+                                ))
+                            .toList(),
+                        onChanged: (style) {
+                          if (style != null) {
+                            provider.loadPreset(style);
+                            _fitMapToPolygons(provider);
+                          }
+                        },
+                      ),
+                      const SizedBox(height: 8),
+                    ],
+
+                    // Zoom range
+                    if (!provider.isDownloading) ...[
+                      Row(
+                        children: [
+                          Expanded(
+                            child: _ZoomSelector(
+                              label: AppLocalizations.of(context)!.minZoom,
+                              value: provider.minZoom,
+                              onChanged: provider.setMinZoom,
+                            ),
+                          ),
+                          const SizedBox(width: 16),
+                          Expanded(
+                            child: _ZoomSelector(
+                              label: AppLocalizations.of(context)!.maxZoom,
+                              value: provider.maxZoom,
+                              onChanged: provider.setMaxZoom,
+                            ),
+                          ),
+                        ],
+                      ),
+                      const SizedBox(height: 8),
+                      // Tile estimate
+                      Text(
+                        provider.hasPolygons
+                            ? '~${_formatNumber(provider.estimatedTileCount)} tiles'
+                            : 'Draw an area to download',
+                        style: Theme.of(context).textTheme.bodySmall,
+                        textAlign: TextAlign.center,
+                      ),
+                      const SizedBox(height: 4),
+                      Text(
+                        'Cache: ${_formatBytes(provider.cacheSizeBytes)}',
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                              color: Theme.of(context)
+                                  .colorScheme
+                                  .onSurface
+                                  .withValues(alpha: 0.6),
+                            ),
+                        textAlign: TextAlign.center,
+                      ),
+                    ],
+
+                    // Progress
+                    if (provider.isDownloading) ...[
+                      LinearProgressIndicator(
+                        value: provider.progress.percent,
+                      ),
+                      const SizedBox(height: 8),
+                      Text(
+                        '${(provider.progress.percent * 100).toStringAsFixed(1)}% — '
+                        'Downloaded: ${provider.progress.downloaded}, '
+                        'Cached: ${provider.progress.skipped}, '
+                        'Failed: ${provider.progress.failed} / '
+                        '${provider.progress.total}',
+                        style: Theme.of(context).textTheme.bodySmall,
+                        textAlign: TextAlign.center,
+                      ),
+                    ],
+
+                    // Download complete summary
+                    if (!provider.isDownloading &&
+                        provider.progress.isComplete) ...[
+                      const SizedBox(height: 4),
+                      Text(
+                        'Done! ${provider.progress.downloaded} downloaded, '
+                        '${provider.progress.skipped} cached, '
+                        '${provider.progress.failed} failed',
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                              color: Colors.green,
+                            ),
+                        textAlign: TextAlign.center,
+                      ),
+                    ],
+
+                    const SizedBox(height: 12),
+
+                    // Action buttons
+                    Row(
+                      children: [
+                        if (!provider.isDownloading) ...[
+                          Expanded(
+                            child: FilledButton.icon(
+                              onPressed: provider.hasPolygons
+                                  ? () => provider.startDownload()
+                                  : null,
+                              icon: const Icon(Icons.download),
+                              label: Text(AppLocalizations.of(context)!.download),
+                            ),
+                          ),
+                          if (provider.tileOverlays.isNotEmpty) ...[
+                            const SizedBox(width: 8),
+                            IconButton(
+                              onPressed: provider.clearOverlays,
+                              icon: const Icon(Icons.layers_clear),
+                              tooltip: AppLocalizations.of(context)!.clearOverlay,
+                            ),
+                          ],
+                          if (provider.cacheSizeBytes > 0) ...[
+                            const SizedBox(width: 8),
+                            IconButton(
+                              onPressed: () => _confirmClearCache(provider),
+                              icon: const Icon(Icons.delete_forever),
+                              tooltip: AppLocalizations.of(context)!.clearCache,
+                            ),
+                          ],
+                        ],
+                        if (provider.isDownloading) ...[
+                          Expanded(
+                            child: OutlinedButton.icon(
+                              onPressed: () => provider.cancelDownload(),
+                              icon: const Icon(Icons.cancel),
+                              label: Text(AppLocalizations.of(context)!.cancel),
+                              style: OutlinedButton.styleFrom(
+                                foregroundColor: Colors.red,
+                              ),
+                            ),
+                          ),
+                        ],
+                      ],
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  void _showSharingSheet(BuildContext context, OfflineTilesProvider provider) {
+    // Refresh catalogs and local styles when opening
+    provider.refreshPeerCatalogs();
+    provider.refreshLocalStyles();
+
+    showModalBottomSheet(
+      context: context,
+      isScrollControlled: true,
+      builder: (sheetContext) {
+        return DraggableScrollableSheet(
+          initialChildSize: 0.65,
+          minChildSize: 0.3,
+          maxChildSize: 0.9,
+          expand: false,
+          builder: (context, scrollController) {
+            return Consumer<OfflineTilesProvider>(
+              builder: (context, provider, _) {
+                return ListView(
+                  controller: scrollController,
+                  padding: const EdgeInsets.all(16),
+                  children: [
+                    // Header
+                    Center(
+                      child: Container(
+                        width: 32,
+                        height: 4,
+                        margin: const EdgeInsets.only(bottom: 16),
+                        decoration: BoxDecoration(
+                          color: Colors.grey[400],
+                          borderRadius: BorderRadius.circular(2),
+                        ),
+                      ),
+                    ),
+                    Text(
+                      'Tile Sharing',
+                      style: Theme.of(context).textTheme.titleMedium,
+                    ),
+                    const SizedBox(height: 12),
+
+                    // Server toggle
+                    SwitchListTile(
+                      title: Text(AppLocalizations.of(context)!.shareMyTiles),
+                      subtitle: Text(
+                        provider.isServerRunning
+                            ? 'Other devices can fetch tiles from this device'
+                            : 'Start serving cached tiles to nearby devices',
+                      ),
+                      secondary: Icon(
+                        provider.isServerRunning
+                            ? Icons.wifi_tethering
+                            : Icons.wifi_tethering_off,
+                      ),
+                      value: provider.isServerRunning,
+                      onChanged: (_) => provider.toggleServer(),
+                    ),
+
+                    // My cached maps
+                    if (provider.localStyles.isNotEmpty) ...[
+                      const Divider(),
+                      Padding(
+                        padding: const EdgeInsets.symmetric(vertical: 8),
+                        child: Text(
+                          'My Cached Maps',
+                          style: Theme.of(context).textTheme.titleSmall,
+                        ),
+                      ),
+                      ...provider.localStyles.map((style) {
+                        final isShowing =
+                            provider.coverageStyle?.hash == style.hash;
+                        return ListTile(
+                          dense: true,
+                          leading: const Icon(Icons.map, size: 20),
+                          title: Text(style.displayName),
+                          subtitle: Text(
+                            '${_formatNumber(style.tileCount)} tiles, '
+                            '${_formatBytes(style.sizeBytes)}',
+                          ),
+                          trailing: Row(
+                            mainAxisSize: MainAxisSize.min,
+                            children: [
+                              IconButton(
+                                icon: Icon(
+                                  isShowing
+                                      ? Icons.visibility
+                                      : Icons.visibility_off,
+                                  size: 20,
+                                  color: isShowing
+                                      ? Colors.blue
+                                      : null,
+                                ),
+                                tooltip: isShowing
+                                    ? 'Hide on map'
+                                    : 'Show on map',
+                                onPressed: () {
+                                  provider.showCoverage(style);
+                                },
+                              ),
+                              IconButton(
+                                icon: const Icon(Icons.delete_outline,
+                                    size: 20),
+                                tooltip: AppLocalizations.of(context)!.delete,
+                                onPressed: () => _confirmDeleteStyle(
+                                    context, provider, style),
+                              ),
+                            ],
+                          ),
+                        );
+                      }),
+                    ],
+
+                    // Peers section
+                    const Divider(),
+                    Padding(
+                      padding: const EdgeInsets.symmetric(vertical: 8),
+                      child: Row(
+                        children: [
+                          Expanded(
+                            child: Text(
+                              'Nearby Devices',
+                              style: Theme.of(context).textTheme.titleSmall,
+                            ),
+                          ),
+                          if (provider.isFetchingCatalogs)
+                            const SizedBox(
+                              width: 16,
+                              height: 16,
+                              child:
+                                  CircularProgressIndicator(strokeWidth: 2),
+                            )
+                          else
+                            IconButton(
+                              icon: const Icon(Icons.refresh, size: 20),
+                              tooltip: AppLocalizations.of(context)!.refresh,
+                              onPressed: () =>
+                                  provider.refreshPeerCatalogs(),
+                            ),
+                          IconButton(
+                            icon: const Icon(Icons.add, size: 20),
+                            tooltip: AppLocalizations.of(context)!.addPeerManually,
+                            onPressed: () =>
+                                _showAddPeerDialog(context, provider),
+                          ),
+                        ],
+                      ),
+                    ),
+
+                    if (provider.discoveredPeers.isEmpty)
+                      Padding(
+                        padding: const EdgeInsets.symmetric(vertical: 8),
+                        child: Text(
+                          'No peers found on the local network.\n'
+                          'Make sure other devices have tile sharing enabled.',
+                          style: Theme.of(context)
+                              .textTheme
+                              .bodySmall
+                              ?.copyWith(
+                                color: Theme.of(context)
+                                    .colorScheme
+                                    .onSurface
+                                    .withValues(alpha: 0.6),
+                              ),
+                        ),
+                      ),
+
+                    // Peer catalogs — show each peer and their available styles
+                    ...provider.peerCatalogs.map((catalog) => _buildPeerCard(
+                          context, provider, catalog)),
+
+                    // Peers without catalogs yet (just discovered, not queried)
+                    ...provider.discoveredPeers
+                        .where((peer) => !provider.peerCatalogs
+                            .any((c) => c.peer == peer))
+                        .map((peer) => ListTile(
+                              leading: const Icon(Icons.devices),
+                              title: Text(peer.ipAddress),
+                              subtitle: Text(AppLocalizations.of(context)!.fetchingCatalog),
+                              trailing: IconButton(
+                                icon: const Icon(
+                                    Icons.remove_circle_outline,
+                                    size: 20),
+                                onPressed: () =>
+                                    provider.removePeer(peer),
+                              ),
+                            )),
+
+                    // Sync progress
+                    if (provider.isSyncing || provider.syncStatus.isNotEmpty) ...[
+                      const Divider(),
+                      if (provider.isSyncing)
+                        LinearProgressIndicator(
+                          value: provider.syncProgress > 0
+                              ? provider.syncProgress
+                              : null,
+                        ),
+                      Padding(
+                        padding: const EdgeInsets.symmetric(vertical: 8),
+                        child: Row(
+                          children: [
+                            Expanded(
+                              child: Text(
+                                provider.syncStatus,
+                                style: Theme.of(context).textTheme.bodySmall,
+                              ),
+                            ),
+                            if (provider.isSyncing)
+                              TextButton(
+                                onPressed: () => provider.cancelSync(),
+                                child: Text(AppLocalizations.of(context)!.cancel),
+                              ),
+                          ],
+                        ),
+                      ),
+                    ],
+                  ],
+                );
+              },
+            );
+          },
+        );
+      },
+    );
+  }
+
+  Widget _buildPeerCard(
+    BuildContext context,
+    OfflineTilesProvider provider,
+    PeerCatalog catalog,
+  ) {
+    return Card(
+      margin: const EdgeInsets.symmetric(vertical: 4),
+      child: Padding(
+        padding: const EdgeInsets.all(12),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                const Icon(Icons.devices, size: 18),
+                const SizedBox(width: 8),
+                Expanded(
+                  child: Text(
+                    catalog.peer.ipAddress,
+                    style: Theme.of(context).textTheme.titleSmall,
+                  ),
+                ),
+                IconButton(
+                  icon: const Icon(Icons.remove_circle_outline, size: 18),
+                  onPressed: () => provider.removePeer(catalog.peer),
+                  visualDensity: VisualDensity.compact,
+                ),
+              ],
+            ),
+            if (catalog.styles.isEmpty)
+              Padding(
+                padding: const EdgeInsets.only(top: 4),
+                child: Text(
+                  'No cached tiles on this device',
+                  style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                        color: Theme.of(context)
+                            .colorScheme
+                            .onSurface
+                            .withValues(alpha: 0.6),
+                      ),
+                ),
+              ),
+            ...catalog.styles.map((style) {
+              // Check if we already have this style locally
+              final localMatch = provider.localStyles
+                  .where((s) => s.hash == style.hash);
+              final localCount =
+                  localMatch.isNotEmpty ? localMatch.first.tileCount : 0;
+              final missingTiles = style.tileCount - localCount;
+
+              return ListTile(
+                dense: true,
+                contentPadding: EdgeInsets.zero,
+                leading: const Icon(Icons.map_outlined, size: 20),
+                title: Text(style.displayName),
+                subtitle: Text(
+                  '${_formatNumber(style.tileCount)} tiles, '
+                  '${_formatBytes(style.sizeBytes)}'
+                  '${localCount > 0 ? ' (you have ${_formatNumberInline(localCount)})' : ''}',
+                ),
+                trailing: missingTiles > 0
+                    ? TextButton.icon(
+                        onPressed: provider.isSyncing
+                            ? null
+                            : () => provider.syncStyleFromPeers(style),
+                        icon: const Icon(Icons.download, size: 16),
+                        label: Text(
+                          missingTiles == style.tileCount
+                              ? 'Get all'
+                              : '+${_formatNumber(missingTiles)}',
+                        ),
+                      )
+                    : const Icon(Icons.check_circle,
+                        color: Colors.green, size: 20),
+              );
+            }),
+          ],
+        ),
+      ),
+    );
+  }
+
+  String _formatNumberInline(int n) {
+    if (n < 1000) return '$n';
+    if (n < 1000000) return '${(n / 1000).toStringAsFixed(1)}K';
+    return '${(n / 1000000).toStringAsFixed(1)}M';
+  }
+
+  void _fitMapToPolygons(OfflineTilesProvider provider) {
+    if (provider.polygons.isEmpty) return;
+
+    var minLat = 90.0, maxLat = -90.0;
+    var minLng = 180.0, maxLng = -180.0;
+    for (final poly in provider.polygons) {
+      for (final p in poly) {
+        if (p.latitude < minLat) minLat = p.latitude;
+        if (p.latitude > maxLat) maxLat = p.latitude;
+        if (p.longitude < minLng) minLng = p.longitude;
+        if (p.longitude > maxLng) maxLng = p.longitude;
+      }
+    }
+
+    _mapController.fitCamera(
+      CameraFit.bounds(
+        bounds: LatLngBounds(
+          LatLng(minLat, minLng),
+          LatLng(maxLat, maxLng),
+        ),
+        padding: const EdgeInsets.all(50),
+      ),
+    );
+  }
+
+  void _showAddPeerDialog(
+      BuildContext context, OfflineTilesProvider provider) {
+    final controller = TextEditingController();
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.addPeer),
+        content: TextField(
+          controller: controller,
+          decoration: const InputDecoration(
+            labelText: 'IP Address',
+            hintText: '192.168.1.100',
+          ),
+          keyboardType: TextInputType.number,
+          autofocus: true,
+          onSubmitted: (value) {
+            if (value.trim().isNotEmpty) {
+              provider.addManualPeer(value.trim());
+              Navigator.pop(context);
+            }
+          },
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () {
+              final ip = controller.text.trim();
+              if (ip.isNotEmpty) {
+                provider.addManualPeer(ip);
+                Navigator.pop(context);
+              }
+            },
+            child: Text(AppLocalizations.of(context)!.add),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _confirmDeleteStyle(
+    BuildContext context,
+    OfflineTilesProvider provider,
+    StyleInfo style,
+  ) {
+    showDialog(
+      context: context,
+      builder: (dialogContext) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.deleteStyleConfirm(style.displayName)),
+        content: Text(
+          '${_formatNumber(style.tileCount)} tiles, '
+          '${_formatBytes(style.sizeBytes)} will be deleted.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(dialogContext),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () {
+              provider.deleteStyle(style);
+              Navigator.pop(dialogContext);
+            },
+            child:
+                Text(AppLocalizations.of(context)!.delete, style: const TextStyle(color: Colors.red)),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _confirmClearCache(OfflineTilesProvider provider) {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.clearOfflineCache),
+        content: Text(
+            'This will delete ${_formatBytes(provider.cacheSizeBytes)} of cached tiles.'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () {
+              provider.clearCache();
+              Navigator.pop(context);
+            },
+            child:
+                Text(AppLocalizations.of(context)!.delete, style: const TextStyle(color: Colors.red)),
+          ),
+        ],
+      ),
+    );
+  }
+
+  String _formatBytes(int bytes) {
+    if (bytes < 1024) return '$bytes B';
+    if (bytes < 1024 * 1024) return '${(bytes / 1024).toStringAsFixed(1)} KB';
+    if (bytes < 1024 * 1024 * 1024) {
+      return '${(bytes / (1024 * 1024)).toStringAsFixed(1)} MB';
+    }
+    return '${(bytes / (1024 * 1024 * 1024)).toStringAsFixed(1)} GB';
+  }
+
+  String _formatNumber(int n) {
+    if (n < 1000) return '$n';
+    if (n < 1000000) return '${(n / 1000).toStringAsFixed(1)}K';
+    return '${(n / 1000000).toStringAsFixed(1)}M';
+  }
+}
+
+class _ZoomSelector extends StatelessWidget {
+  final String label;
+  final int value;
+  final ValueChanged<int> onChanged;
+
+  const _ZoomSelector({
+    required this.label,
+    required this.value,
+    required this.onChanged,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      children: [
+        Text(label, style: Theme.of(context).textTheme.bodySmall),
+        const SizedBox(width: 8),
+        Expanded(
+          child: Slider(
+            value: value.toDouble(),
+            min: 0,
+            max: 19,
+            divisions: 19,
+            label: '$value',
+            onChanged: (v) => onChanged(v.round()),
+          ),
+        ),
+        SizedBox(
+          width: 24,
+          child: Text(
+            '$value',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                  fontWeight: FontWeight.bold,
+                ),
+            textAlign: TextAlign.center,
+          ),
+        ),
+      ],
+    );
+  }
+}

lib/screens/profiles_screen.dart

@@ -0,0 +1,310 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+
+import '../models/config_profile.dart';
+import '../services/profile_manager.dart';
+import '../services/profile_workspace_coordinator.dart';
+import '../l10n/app_localizations.dart';
+
+class ProfilesScreen extends StatelessWidget {
+  const ProfilesScreen({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Consumer<ProfileManager>(
+      builder: (context, profileManager, child) {
+        final profiles = profileManager.visibleProfiles;
+        return Scaffold(
+          appBar: AppBar(
+            title: Text(AppLocalizations.of(context)!.profiles),
+            actions: [
+              IconButton(
+                onPressed: () => _importProfile(context),
+                icon: const Icon(Icons.file_open),
+                tooltip: AppLocalizations.of(context)!.importProfile,
+              ),
+            ],
+          ),
+          floatingActionButton: FloatingActionButton.extended(
+            onPressed: () => _createProfile(context),
+            icon: Icon(Icons.add),
+            label: Text(AppLocalizations.of(context)!.newProfile),
+          ),
+          body: profiles.isEmpty
+              ? Center(
+                  child: Text(AppLocalizations.of(context)!.enableProfilesToStartManagingThem),
+                )
+              : ListView.builder(
+                  padding: const EdgeInsets.all(16),
+                  itemCount: profiles.length,
+                  itemBuilder: (context, index) {
+                    final profile = profiles[index];
+                    final isActive =
+                        profileManager.activeProfileId == profile.id;
+                    return Card(
+                      margin: const EdgeInsets.only(bottom: 12),
+                      child: Padding(
+                        padding: const EdgeInsets.all(16),
+                        child: Column(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          children: [
+                            Row(
+                              children: [
+                                Expanded(
+                                  child: Text(
+                                    profile.name,
+                                    style: Theme.of(
+                                      context,
+                                    ).textTheme.titleMedium,
+                                  ),
+                                ),
+                                if (isActive)
+                                  Container(
+                                    padding: const EdgeInsets.symmetric(
+                                      horizontal: 8,
+                                      vertical: 4,
+                                    ),
+                                    decoration: BoxDecoration(
+                                      color: Theme.of(
+                                        context,
+                                      ).colorScheme.primaryContainer,
+                                      borderRadius: BorderRadius.circular(999),
+                                    ),
+                                    child: Text(AppLocalizations.of(context)!.active),
+                                  ),
+                              ],
+                            ),
+                            const SizedBox(height: 8),
+                            Text(_summary(profile)),
+                            const SizedBox(height: 12),
+                            Wrap(
+                              spacing: 8,
+                              runSpacing: 8,
+                              children: [
+                                OutlinedButton(
+                                  onPressed: () async {
+                                    await context
+                                        .read<ProfileWorkspaceCoordinator>()
+                                        .openProfile(profile.id);
+                                  },
+                                  child: Text(AppLocalizations.of(context)!.open),
+                                ),
+                                OutlinedButton(
+                                  onPressed: () async {
+                                    final resolved =
+                                        profile.id ==
+                                            ConfigProfile.defaultProfileId
+                                        ? await context
+                                              .read<
+                                                ProfileWorkspaceCoordinator
+                                              >()
+                                              .snapshotCurrentProfile(
+                                                id: profile.id,
+                                                name: profile.name,
+                                              )
+                                        : profile;
+                                    if (!context.mounted) return;
+                                    await context
+                                        .read<ProfileWorkspaceCoordinator>()
+                                        .exportProfile(resolved);
+                                  },
+                                  child: Text(AppLocalizations.of(context)!.share),
+                                ),
+                                PopupMenuButton<String>(
+                                  onSelected: (value) async {
+                                    switch (value) {
+                                      case 'duplicate':
+                                        await context
+                                            .read<ProfileWorkspaceCoordinator>()
+                                            .duplicateProfile(profile);
+                                        break;
+                                      case 'rename':
+                                        await _renameProfile(context, profile);
+                                        break;
+                                      case 'delete':
+                                        await _deleteProfile(
+                                          context,
+                                          profile,
+                                          isActive: isActive,
+                                        );
+                                        break;
+                                    }
+                                  },
+                                  itemBuilder: (context) => [
+                                    PopupMenuItem(
+                                      value: 'duplicate',
+                                      child: Text(AppLocalizations.of(context)!.duplicate),
+                                    ),
+                                    if (!profile.isDefault)
+                                      PopupMenuItem(
+                                        value: 'rename',
+                                        child: Text(AppLocalizations.of(context)!.rename),
+                                      ),
+                                    if (!profile.isDefault)
+                                      PopupMenuItem(
+                                        value: 'delete',
+                                        child: Text(AppLocalizations.of(context)!.delete),
+                                      ),
+                                  ],
+                                ),
+                              ],
+                            ),
+                          ],
+                        ),
+                      ),
+                    );
+                  },
+                ),
+        );
+      },
+    );
+  }
+
+  String _summary(ConfigProfile profile) {
+    if (profile.isDefault) {
+      return 'Current app state and history.';
+    }
+
+    final sections = <String>[];
+    if (profile.sections.deviceConfig?.isEmpty == false) {
+      sections.add('Device');
+    }
+    if (profile.sections.channels.isNotEmpty) {
+      sections.add('${profile.sections.channels.length} channels');
+    }
+    if (profile.sections.appSettings?.isEmpty == false) {
+      sections.add('App settings');
+    }
+    if (profile.sections.mapWorkspace?.isEmpty == false) {
+      sections.add('Map workspace');
+    }
+    return sections.isEmpty ? 'Empty profile' : sections.join(' | ');
+  }
+
+  Future<void> _importProfile(BuildContext context) async {
+    final messenger = ScaffoldMessenger.of(context);
+    final errorColor = Theme.of(context).colorScheme.error;
+    final coordinator = context.read<ProfileWorkspaceCoordinator>();
+    try {
+      final imported = await coordinator.importProfileFromFile();
+      if (imported == null) {
+        messenger.showSnackBar(
+          SnackBar(
+            content: const Text('Could not import profile — invalid file'),
+            backgroundColor: errorColor,
+          ),
+        );
+        return;
+      }
+      messenger.showSnackBar(
+        SnackBar(content: Text('Imported profile "${imported.name}"')),
+      );
+    } catch (_) {
+      messenger.showSnackBar(
+        SnackBar(
+          content: const Text('Could not import profile — invalid file'),
+          backgroundColor: errorColor,
+        ),
+      );
+    }
+  }
+
+  Future<void> _deleteProfile(
+    BuildContext context,
+    ConfigProfile profile, {
+    required bool isActive,
+  }) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Delete Profile'),
+        content: Text(
+          'Delete "${profile.name}"? Its messages and contacts will be '
+          'permanently erased.'
+          '${isActive ? '\n\nThis profile is currently active. The app will switch to the Default profile.' : ''}',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(true),
+            style: TextButton.styleFrom(foregroundColor: Colors.red),
+            child: Text(AppLocalizations.of(context)!.delete),
+          ),
+        ],
+      ),
+    );
+    if (confirmed != true || !context.mounted) {
+      return;
+    }
+    await context.read<ProfileWorkspaceCoordinator>().deleteProfile(profile);
+  }
+
+  Future<void> _createProfile(BuildContext context) async {
+    final controller = TextEditingController();
+    final name = await showDialog<String>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.createProfile),
+        content: TextField(
+          controller: controller,
+          autofocus: true,
+          decoration: const InputDecoration(labelText: 'Profile name'),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          FilledButton(
+            onPressed: () => Navigator.of(context).pop(controller.text.trim()),
+            child: Text(AppLocalizations.of(context)!.create),
+          ),
+        ],
+      ),
+    );
+    if (name == null || name.isEmpty || !context.mounted) {
+      return;
+    }
+    await context.read<ProfileWorkspaceCoordinator>().createProfileFromCurrent(
+      name: name,
+    );
+  }
+
+  Future<void> _renameProfile(
+    BuildContext context,
+    ConfigProfile profile,
+  ) async {
+    final controller = TextEditingController(text: profile.name);
+    final name = await showDialog<String>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.renameProfile),
+        content: TextField(
+          controller: controller,
+          autofocus: true,
+          decoration: const InputDecoration(labelText: 'Profile name'),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          FilledButton(
+            onPressed: () => Navigator.of(context).pop(controller.text.trim()),
+            child: Text(AppLocalizations.of(context)!.save),
+          ),
+        ],
+      ),
+    );
+    if (name == null || name.isEmpty || !context.mounted) {
+      return;
+    }
+    await context.read<ProfileWorkspaceCoordinator>().renameProfile(
+      profile,
+      name,
+    );
+  }
+}

lib/screens/repeaters_map_screen.dart

@@ -0,0 +1,776 @@
+import 'dart:typed_data';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_map/flutter_map.dart' as flutter_map;
+import 'package:geolocator/geolocator.dart';
+import 'package:latlong2/latlong.dart';
+import 'package:provider/provider.dart';
+
+import '../models/contact.dart';
+import '../providers/connection_provider.dart';
+import '../providers/contacts_provider.dart';
+import '../services/mesh_map_nodes_service.dart';
+import '../l10n/app_localizations.dart';
+
+class RepeatersMapScreen extends StatefulWidget {
+  const RepeatersMapScreen({super.key});
+
+  @override
+  State<RepeatersMapScreen> createState() => _RepeatersMapScreenState();
+}
+
+class _RepeatersMapScreenState extends State<RepeatersMapScreen> {
+  static const LatLng _fallbackCenter = LatLng(46.0569, 14.5058);
+  static const double _fallbackZoom = 7;
+  static const double _myLocationZoom = 14;
+
+  final flutter_map.MapController _mapController = flutter_map.MapController();
+
+  List<MeshMapNode> _onlineRepeaters = const [];
+  bool _isLoading = true;
+  bool _didFitCamera = false;
+  String? _error;
+  double _currentZoom = _fallbackZoom;
+  LatLng? _myLocation;
+  final Set<String> _addingRepeaters = <String>{};
+
+  @override
+  void initState() {
+    super.initState();
+    _loadRepeaters();
+  }
+
+  Future<void> _loadRepeaters({bool forceRefresh = false}) async {
+    setState(() {
+      _isLoading = true;
+      _error = null;
+      if (forceRefresh) {
+        _didFitCamera = false;
+      }
+    });
+
+    try {
+      final nodes = await MeshMapNodesService.fetchNodes(
+        forceRefresh: forceRefresh,
+      );
+      final repeaters = nodes.where(MeshMapNodesService.isRepeater).toList();
+
+      if (!mounted) return;
+      setState(() {
+        _onlineRepeaters = repeaters;
+        _isLoading = false;
+      });
+      _refreshMyLocation();
+    } catch (error) {
+      final cached = await MeshMapNodesService.loadCachedNodes();
+      final repeaters = cached.where(MeshMapNodesService.isRepeater).toList();
+
+      if (!mounted) return;
+      setState(() {
+        _onlineRepeaters = repeaters;
+        _isLoading = false;
+        _error = repeaters.isEmpty
+            ? 'Unable to load repeaters right now.'
+            : 'Showing cached repeaters. Pull to retry.';
+      });
+      _refreshMyLocation();
+    }
+  }
+
+  List<_MapRepeater> _mergeRepeaters({
+    required List<MeshMapNode> onlineNodes,
+    required List<Contact> contactRepeaters,
+  }) {
+    final merged = <String, _MapRepeater>{};
+
+    for (final node in onlineNodes) {
+      merged[node.publicKey] = _MapRepeater(
+        publicKey: node.publicKey,
+        name: node.name,
+        latitude: node.latitude,
+        longitude: node.longitude,
+        isFromContacts: false,
+        isFromOnline: true,
+      );
+    }
+
+    for (final contact in contactRepeaters) {
+      final location = contact.displayLocation;
+      if (location == null) {
+        continue;
+      }
+
+      final key = contact.publicKeyHex.toLowerCase();
+      final existing = merged[key];
+      merged[key] = _MapRepeater(
+        publicKey: key,
+        name: contact.displayName.isNotEmpty
+            ? contact.displayName
+            : existing?.name ?? 'Unknown repeater',
+        latitude: existing?.latitude ?? location.latitude,
+        longitude: existing?.longitude ?? location.longitude,
+        isFromContacts: true,
+        isFromOnline: existing?.isFromOnline ?? false,
+      );
+    }
+
+    final repeaters = merged.values.toList()
+      ..sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+    return repeaters;
+  }
+
+  Future<void> _refreshMyLocation() async {
+    try {
+      final position = await Geolocator.getCurrentPosition(
+        locationSettings: const LocationSettings(
+          accuracy: LocationAccuracy.best,
+          distanceFilter: 0,
+        ),
+      );
+      if (!mounted) return;
+      setState(() {
+        _myLocation = LatLng(position.latitude, position.longitude);
+      });
+    } catch (_) {
+      // Best effort only.
+    }
+  }
+
+  void _fitCameraIfNeeded(List<_MapRepeater> repeaters) {
+    if (_didFitCamera || repeaters.isEmpty || !mounted) {
+      return;
+    }
+
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!mounted || _didFitCamera || repeaters.isEmpty) {
+        return;
+      }
+
+      if (repeaters.length == 1) {
+        final repeater = repeaters.first;
+        _mapController.move(LatLng(repeater.latitude, repeater.longitude), 13);
+        _currentZoom = 13;
+      } else {
+        final bounds = flutter_map.LatLngBounds.fromPoints(
+          repeaters
+              .map((node) => LatLng(node.latitude, node.longitude))
+              .toList(),
+        );
+        _mapController.fitCamera(
+          flutter_map.CameraFit.bounds(
+            bounds: bounds,
+            padding: const EdgeInsets.all(48),
+          ),
+        );
+      }
+
+      _didFitCamera = true;
+    });
+  }
+
+  void _showRepeaterDetails(_MapRepeater repeater) {
+    final isAdding = _addingRepeaters.contains(repeater.publicKey);
+    final canAdd = !repeater.isFromContacts;
+    final isConnected = context
+        .read<ConnectionProvider>()
+        .deviceInfo
+        .isConnected;
+
+    showModalBottomSheet<void>(
+      context: context,
+      showDragHandle: true,
+      builder: (context) => SafeArea(
+        child: Padding(
+          padding: const EdgeInsets.fromLTRB(20, 0, 20, 24),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(
+                repeater.name,
+                style: Theme.of(
+                  context,
+                ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.w700),
+              ),
+              SizedBox(height: 12),
+              _InfoLine(
+                label: AppLocalizations.of(context)!.publicKeyLabel,
+                value: repeater.publicKey,
+                monospace: true,
+              ),
+              _InfoLine(
+                label: AppLocalizations.of(context)!.coordinates,
+                value:
+                    '${repeater.latitude.toStringAsFixed(5)}, ${repeater.longitude.toStringAsFixed(5)}',
+              ),
+              _InfoLine(label: AppLocalizations.of(context)!.source, value: repeater.sourceLabel),
+              const SizedBox(height: 12),
+              if (canAdd)
+                SizedBox(
+                  width: double.infinity,
+                  child: FilledButton.icon(
+                    onPressed: !isConnected || isAdding
+                        ? null
+                        : () async {
+                            Navigator.of(context).pop();
+                            await _addRepeaterToContacts(repeater);
+                          },
+                    icon: isAdding
+                        ? const SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(strokeWidth: 2),
+                          )
+                        : const Icon(Icons.person_add_alt_1),
+                    label: Text(
+                      !isConnected
+                          ? 'Connect device to add'
+                          : 'Add to contacts',
+                    ),
+                  ),
+                )
+              else
+                SizedBox(
+                  width: double.infinity,
+                  child: FilledButton.icon(
+                    onPressed: null,
+                    icon: Icon(Icons.check_circle),
+                    label: Text(AppLocalizations.of(context)!.alreadyInContacts),
+                  ),
+                ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+
+  Future<void> _addRepeaterToContacts(_MapRepeater repeater) async {
+    if (_addingRepeaters.contains(repeater.publicKey)) {
+      return;
+    }
+
+    final connectionProvider = context.read<ConnectionProvider>();
+    if (!connectionProvider.deviceInfo.isConnected) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(AppLocalizations.of(context)!.connectToADeviceBeforeAddingContacts),
+        ),
+      );
+      return;
+    }
+
+    setState(() {
+      _addingRepeaters.add(repeater.publicKey);
+    });
+
+    try {
+      await connectionProvider.getContact(_hexToBytes(repeater.publicKey));
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(AppLocalizations.of(context)!.addedToContacts(repeater.name))),
+      );
+    } catch (error) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(AppLocalizations.of(context)!.failedToAddName(repeater.name, error.toString()))),
+      );
+    } finally {
+      if (mounted) {
+        setState(() {
+          _addingRepeaters.remove(repeater.publicKey);
+        });
+      }
+    }
+  }
+
+  Uint8List _hexToBytes(String hex) {
+    final normalized = hex.replaceAll(':', '').trim().toLowerCase();
+    return Uint8List.fromList(
+      List<int>.generate(
+        normalized.length ~/ 2,
+        (index) => int.parse(
+          normalized.substring(index * 2, index * 2 + 2),
+          radix: 16,
+        ),
+      ),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final contactsProvider = context.watch<ContactsProvider>();
+    final repeaters = _mergeRepeaters(
+      onlineNodes: _onlineRepeaters,
+      contactRepeaters: contactsProvider.repeaters,
+    );
+    _fitCameraIfNeeded(repeaters);
+    final clusters = _buildClusters(repeaters);
+    final markers = clusters.map((cluster) {
+      final markerColor = switch (cluster.status) {
+        _ClusterStatus.contactsOnly => const Color(0xFF7C3AED),
+        _ClusterStatus.onlineOnly => const Color(0xFFE8681D),
+        _ClusterStatus.both => const Color(0xFF1B8F4F),
+        _ClusterStatus.mixed => const Color(0xFF2563EB),
+      };
+
+      if (cluster.members.length == 1) {
+        final repeater = cluster.members.first;
+        return flutter_map.Marker(
+          point: cluster.center,
+          width: 80,
+          height: 100,
+          child: GestureDetector(
+            onTap: () => _showRepeaterDetails(repeater),
+            child: _RepeaterMarker(color: markerColor, label: repeater.name),
+          ),
+        );
+      }
+
+      return flutter_map.Marker(
+        point: cluster.center,
+        width: 48,
+        height: 48,
+        child: GestureDetector(
+          onTap: () => _zoomToCluster(cluster),
+          child: _ClusterMarker(
+            color: markerColor,
+            count: cluster.members.length,
+          ),
+        ),
+      );
+    }).toList();
+    final allMarkers = <flutter_map.Marker>[
+      ...markers,
+      if (_myLocation != null)
+        flutter_map.Marker(
+          point: _myLocation!,
+          width: 24,
+          height: 24,
+          child: Container(
+            decoration: BoxDecoration(
+              color: const Color(0xFF2563EB),
+              shape: BoxShape.circle,
+              border: Border.all(color: Colors.white, width: 3),
+              boxShadow: [
+                BoxShadow(
+                  color: Colors.black.withValues(alpha: 0.18),
+                  blurRadius: 12,
+                  offset: const Offset(0, 4),
+                ),
+              ],
+            ),
+          ),
+        ),
+    ];
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(AppLocalizations.of(context)!.repeatersMap),
+        actions: [
+          IconButton(
+            onPressed: _isLoading
+                ? null
+                : () => _loadRepeaters(forceRefresh: true),
+            icon: const Icon(Icons.refresh),
+            tooltip: AppLocalizations.of(context)!.refresh,
+          ),
+        ],
+      ),
+      body: Stack(
+        children: [
+          flutter_map.FlutterMap(
+            mapController: _mapController,
+            options: flutter_map.MapOptions(
+              initialCenter: _fallbackCenter,
+              initialZoom: _fallbackZoom,
+              onPositionChanged: (camera, hasGesture) {
+                final nextZoom = camera.zoom;
+                if (nextZoom != _currentZoom && mounted) {
+                  setState(() {
+                    _currentZoom = nextZoom;
+                  });
+                }
+              },
+            ),
+            children: [
+              flutter_map.TileLayer(
+                urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
+                userAgentPackageName: 'app.meshcore.sar',
+              ),
+              flutter_map.MarkerLayer(markers: allMarkers),
+            ],
+          ),
+          if (_error != null)
+            Positioned(
+              top: 16,
+              left: 16,
+              right: 16,
+              child: Material(
+                elevation: 2,
+                borderRadius: BorderRadius.circular(14),
+                color: Theme.of(context).colorScheme.surface,
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(
+                    horizontal: 16,
+                    vertical: 12,
+                  ),
+                  child: Text(_error!),
+                ),
+              ),
+            ),
+          if (_isLoading) const Center(child: CircularProgressIndicator()),
+          if (!_isLoading && repeaters.isEmpty)
+            Center(
+              child: Padding(
+                padding: const EdgeInsets.all(24),
+                child: Text(
+                  _error ?? 'No repeaters available.',
+                  textAlign: TextAlign.center,
+                ),
+              ),
+            ),
+          if (repeaters.isNotEmpty)
+            Positioned(
+              left: 16,
+              top: _error == null ? 16 : 72,
+              child: Material(
+                elevation: 2,
+                borderRadius: BorderRadius.circular(14),
+                color: Theme.of(context).colorScheme.surface,
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(
+                    horizontal: 14,
+                    vertical: 10,
+                  ),
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      _LegendRow(
+                        color: const Color(0xFF7C3AED),
+                        label: AppLocalizations.of(context)!.fromContacts,
+                      ),
+                      const SizedBox(height: 8),
+                      _LegendRow(
+                        color: const Color(0xFFE8681D),
+                        label: AppLocalizations.of(context)!.onlineOnly,
+                      ),
+                      const SizedBox(height: 8),
+                      _LegendRow(color: const Color(0xFF1B8F4F), label: AppLocalizations.of(context)!.inBoth),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          if (repeaters.isNotEmpty)
+            Positioned(
+              left: 16,
+              right: 16,
+              bottom: 16,
+              child: Material(
+                elevation: 3,
+                borderRadius: BorderRadius.circular(16),
+                color: Theme.of(context).colorScheme.surface,
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(
+                    horizontal: 16,
+                    vertical: 12,
+                  ),
+                  child: Text(
+                    '${repeaters.length} repeaters',
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.w700,
+                    ),
+                  ),
+                ),
+              ),
+            ),
+        ],
+      ),
+      floatingActionButton: FloatingActionButton(
+        onPressed: _jumpToMyLocation,
+        tooltip: AppLocalizations.of(context)!.myLocation,
+        child: const Icon(Icons.my_location),
+      ),
+    );
+  }
+
+  Future<void> _jumpToMyLocation() async {
+    await _refreshMyLocation();
+    final myLocation = _myLocation;
+    if (!mounted || myLocation == null) {
+      return;
+    }
+
+    _mapController.move(myLocation, _myLocationZoom);
+    setState(() {
+      _currentZoom = _myLocationZoom;
+    });
+  }
+
+  List<_RepeaterCluster> _buildClusters(List<_MapRepeater> repeaters) {
+    if (repeaters.isEmpty) {
+      return const [];
+    }
+
+    if (_currentZoom >= 11.5) {
+      return repeaters
+          .map(
+            (repeater) => _RepeaterCluster(
+              members: [repeater],
+              center: LatLng(repeater.latitude, repeater.longitude),
+              status: repeater.clusterStatus,
+            ),
+          )
+          .toList();
+    }
+
+    final cellSize = _gridSizeForZoom(_currentZoom);
+    final buckets = <String, List<_MapRepeater>>{};
+
+    for (final repeater in repeaters) {
+      final latBucket = (repeater.latitude / cellSize).floor();
+      final lonBucket = (repeater.longitude / cellSize).floor();
+      final key = '$latBucket:$lonBucket';
+      buckets.putIfAbsent(key, () => <_MapRepeater>[]).add(repeater);
+    }
+
+    return buckets.values.map((members) {
+      final centerLat =
+          members.map((node) => node.latitude).reduce((a, b) => a + b) /
+          members.length;
+      final centerLon =
+          members.map((node) => node.longitude).reduce((a, b) => a + b) /
+          members.length;
+      final statuses = members.map((node) => node.clusterStatus).toSet();
+      return _RepeaterCluster(
+        members: members,
+        center: LatLng(centerLat, centerLon),
+        status: statuses.length == 1 ? statuses.first : _ClusterStatus.mixed,
+      );
+    }).toList();
+  }
+
+  double _gridSizeForZoom(double zoom) {
+    if (zoom < 5) return 3.0;
+    if (zoom < 7) return 1.5;
+    if (zoom < 9) return 0.7;
+    if (zoom < 10.5) return 0.28;
+    return 0.12;
+  }
+
+  void _zoomToCluster(_RepeaterCluster cluster) {
+    if (cluster.members.isEmpty) {
+      return;
+    }
+
+    final bounds = flutter_map.LatLngBounds.fromPoints(
+      cluster.members
+          .map((node) => LatLng(node.latitude, node.longitude))
+          .toList(),
+    );
+    _mapController.fitCamera(
+      flutter_map.CameraFit.bounds(
+        bounds: bounds,
+        padding: const EdgeInsets.all(64),
+        maxZoom: (_currentZoom + 2).clamp(8, 14),
+      ),
+    );
+  }
+}
+
+class _InfoLine extends StatelessWidget {
+  final String label;
+  final String value;
+  final bool monospace;
+
+  const _InfoLine({
+    required this.label,
+    required this.value,
+    this.monospace = false,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: const EdgeInsets.only(bottom: 8),
+      child: Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          SizedBox(
+            width: 92,
+            child: Text(
+              label,
+              style: Theme.of(
+                context,
+              ).textTheme.bodyMedium?.copyWith(fontWeight: FontWeight.w600),
+            ),
+          ),
+          Expanded(
+            child: Text(
+              value,
+              style: monospace
+                  ? const TextStyle(fontFamily: 'monospace')
+                  : null,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+class _LegendRow extends StatelessWidget {
+  final Color color;
+  final String label;
+
+  const _LegendRow({required this.color, required this.label});
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Container(
+          width: 12,
+          height: 12,
+          decoration: BoxDecoration(color: color, shape: BoxShape.circle),
+        ),
+        const SizedBox(width: 8),
+        Text(label),
+      ],
+    );
+  }
+}
+
+class _RepeaterMarker extends StatelessWidget {
+  final Color color;
+  final String label;
+
+  const _RepeaterMarker({required this.color, required this.label});
+
+  @override
+  Widget build(BuildContext context) {
+    return Column(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Container(
+          decoration: BoxDecoration(
+            color: color,
+            shape: BoxShape.circle,
+            border: Border.all(color: Colors.white, width: 2),
+            boxShadow: [
+              BoxShadow(
+                color: Colors.black.withValues(alpha: 0.3),
+                blurRadius: 4,
+                offset: const Offset(0, 2),
+              ),
+            ],
+          ),
+          padding: const EdgeInsets.all(6),
+          child: const Icon(Icons.router, color: Colors.white, size: 18),
+        ),
+        const SizedBox(height: 2),
+        Container(
+          constraints: const BoxConstraints(maxWidth: 80),
+          padding: const EdgeInsets.symmetric(horizontal: 4, vertical: 1),
+          decoration: BoxDecoration(
+            color: Colors.black.withValues(alpha: 0.7),
+            borderRadius: BorderRadius.circular(3),
+          ),
+          child: Text(
+            label,
+            style: const TextStyle(
+              color: Colors.white,
+              fontSize: 9,
+              fontWeight: FontWeight.bold,
+            ),
+            overflow: TextOverflow.ellipsis,
+            maxLines: 1,
+            textAlign: TextAlign.center,
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _ClusterMarker extends StatelessWidget {
+  final Color color;
+  final int count;
+
+  const _ClusterMarker({required this.color, required this.count});
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      decoration: BoxDecoration(
+        color: color,
+        shape: BoxShape.circle,
+        border: Border.all(color: Colors.white, width: 2),
+        boxShadow: [
+          BoxShadow(
+            color: Colors.black.withValues(alpha: 0.22),
+            blurRadius: 10,
+            offset: const Offset(0, 3),
+          ),
+        ],
+      ),
+      alignment: Alignment.center,
+      child: Text(
+        '$count',
+        style: const TextStyle(
+          color: Colors.white,
+          fontWeight: FontWeight.w800,
+          fontSize: 14,
+        ),
+      ),
+    );
+  }
+}
+
+enum _ClusterStatus { contactsOnly, onlineOnly, both, mixed }
+
+class _RepeaterCluster {
+  final List<_MapRepeater> members;
+  final LatLng center;
+  final _ClusterStatus status;
+
+  const _RepeaterCluster({
+    required this.members,
+    required this.center,
+    required this.status,
+  });
+}
+
+class _MapRepeater {
+  final String publicKey;
+  final String name;
+  final double latitude;
+  final double longitude;
+  final bool isFromContacts;
+  final bool isFromOnline;
+
+  const _MapRepeater({
+    required this.publicKey,
+    required this.name,
+    required this.latitude,
+    required this.longitude,
+    required this.isFromContacts,
+    required this.isFromOnline,
+  });
+
+  String get sourceLabel {
+    if (isFromContacts && isFromOnline) return 'Contacts and online';
+    if (isFromContacts) return 'Contacts';
+    return 'Online';
+  }
+
+  _ClusterStatus get clusterStatus {
+    if (isFromContacts && isFromOnline) return _ClusterStatus.both;
+    if (isFromContacts) return _ClusterStatus.contactsOnly;
+    return _ClusterStatus.onlineOnly;
+  }
+}

lib/screens/sar_template_management_screen.dart

@@ -0,0 +1,456 @@
+import 'package:flutter/material.dart';
+import '../models/sar_template.dart';
+import '../services/sar_template_service.dart';
+import '../widgets/sar/sar_template_edit_dialog.dart';
+import '../l10n/app_localizations.dart';
+
+/// Screen for managing SAR templates
+class SarTemplateManagementScreen extends StatefulWidget {
+  const SarTemplateManagementScreen({super.key});
+
+  @override
+  State<SarTemplateManagementScreen> createState() => _SarTemplateManagementScreenState();
+}
+
+class _SarTemplateManagementScreenState extends State<SarTemplateManagementScreen> {
+  final SarTemplateService _templateService = SarTemplateService();
+  bool _isLoading = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _initializeService();
+  }
+
+  Future<void> _initializeService() async {
+    if (!_templateService.isInitialized) {
+      if (!mounted) return;
+      setState(() => _isLoading = true);
+      await _templateService.initialize();
+      if (mounted) {
+        setState(() => _isLoading = false);
+      }
+    }
+  }
+
+  Future<void> _addTemplate() async {
+    await showModalBottomSheet(
+      context: context,
+      isScrollControlled: true,
+      backgroundColor: Colors.transparent,
+      builder: (context) => SarTemplateEditDialog(
+        onSave: (template) async {
+          final messenger = ScaffoldMessenger.of(context);
+          final l10n = AppLocalizations.of(context)!;
+          await _templateService.addTemplate(template);
+          if (mounted) {
+            messenger.showSnackBar(
+              SnackBar(
+                content: Text(l10n.templateAdded),
+                backgroundColor: Colors.green,
+              ),
+            );
+          }
+        },
+      ),
+    );
+  }
+
+  Future<void> _editTemplate(SarTemplate template) async {
+    await showModalBottomSheet(
+      context: context,
+      isScrollControlled: true,
+      backgroundColor: Colors.transparent,
+      builder: (context) => SarTemplateEditDialog(
+        template: template,
+        onSave: (updatedTemplate) async {
+          final messenger = ScaffoldMessenger.of(context);
+          final l10n = AppLocalizations.of(context)!;
+          await _templateService.updateTemplate(template.id, updatedTemplate);
+          if (mounted) {
+            messenger.showSnackBar(
+              SnackBar(
+                content: Text(l10n.templateUpdated),
+                backgroundColor: Colors.green,
+              ),
+            );
+          }
+        },
+      ),
+    );
+  }
+
+  Future<void> _deleteTemplate(SarTemplate template) async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.deleteTemplate),
+        content: Text(
+          AppLocalizations.of(context)!.deleteTemplateConfirmation(template.getLocalizedName(context)),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(true),
+            style: TextButton.styleFrom(foregroundColor: Colors.red),
+            child: Text(AppLocalizations.of(context)!.delete),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true) {
+      await _templateService.deleteTemplate(template.id);
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(AppLocalizations.of(context)!.templateDeleted),
+            backgroundColor: Colors.orange,
+          ),
+        );
+      }
+    }
+  }
+
+  Future<void> _importFromClipboard() async {
+    if (!mounted) return;
+    setState(() => _isLoading = true);
+
+    try {
+      final importedCount = await _templateService.importFromClipboard();
+
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(AppLocalizations.of(context)!.templatesImported(importedCount)),
+            backgroundColor: importedCount > 0 ? Colors.green : Colors.orange,
+          ),
+        );
+      }
+    } catch (e) {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(AppLocalizations.of(context)!.importFailed(e.toString())),
+            backgroundColor: Colors.red,
+          ),
+        );
+      }
+    } finally {
+      if (mounted) {
+        setState(() => _isLoading = false);
+      }
+    }
+  }
+
+  Future<void> _exportToClipboard() async {
+    try {
+      await _templateService.exportToClipboard();
+
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(
+              AppLocalizations.of(context)!.templatesExported(_templateService.templateCount),
+            ),
+            backgroundColor: Colors.green,
+            action: SnackBarAction(
+              label: AppLocalizations.of(context)!.ok,
+              textColor: Colors.white,
+              onPressed: () {},
+            ),
+          ),
+        );
+      }
+    } catch (e) {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(AppLocalizations.of(context)!.exportFailed(e.toString())),
+            backgroundColor: Colors.red,
+          ),
+        );
+      }
+    }
+  }
+
+  Future<void> _resetToDefaults() async {
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text(AppLocalizations.of(context)!.resetToDefaults),
+        content: Text(AppLocalizations.of(context)!.resetToDefaultsConfirmation),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(false),
+            child: Text(AppLocalizations.of(context)!.cancel),
+          ),
+          TextButton(
+            onPressed: () => Navigator.of(context).pop(true),
+            style: TextButton.styleFrom(foregroundColor: Colors.red),
+            child: Text(AppLocalizations.of(context)!.reset),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true) {
+      await _templateService.resetToDefaults();
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(AppLocalizations.of(context)!.resetComplete),
+            backgroundColor: Colors.green,
+          ),
+        );
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+    final l10n = AppLocalizations.of(context)!;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(l10n.sarTemplates),
+        actions: [
+          PopupMenuButton<String>(
+            icon: const Icon(Icons.more_vert),
+            tooltip: 'More options',
+            onSelected: (value) {
+              switch (value) {
+                case 'import':
+                  _importFromClipboard();
+                  break;
+                case 'export':
+                  _exportToClipboard();
+                  break;
+                case 'reset':
+                  _resetToDefaults();
+                  break;
+              }
+            },
+            itemBuilder: (context) => [
+              PopupMenuItem(
+                value: 'import',
+                child: ListTile(
+                  leading: Icon(Icons.download),
+                  title: Text(l10n.importFromClipboard),
+                  contentPadding: EdgeInsets.zero,
+                ),
+              ),
+              PopupMenuItem(
+                value: 'export',
+                child: ListTile(
+                  leading: Icon(Icons.upload),
+                  title: Text(l10n.exportToClipboard),
+                  contentPadding: EdgeInsets.zero,
+                ),
+              ),
+              const PopupMenuDivider(),
+              PopupMenuItem(
+                value: 'reset',
+                child: ListTile(
+                  leading: Icon(Icons.restart_alt),
+                  title: Text(l10n.resetToDefaults),
+                  contentPadding: EdgeInsets.zero,
+                ),
+              ),
+            ],
+          ),
+        ],
+      ),
+      body: _isLoading
+          ? const Center(child: CircularProgressIndicator())
+          : ListenableBuilder(
+              listenable: _templateService,
+              builder: (context, child) {
+                final templates = _templateService.templates;
+
+                if (templates.isEmpty) {
+                  return Center(
+                    child: Column(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      children: [
+                        Icon(
+                          Icons.location_searching,
+                          size: 64,
+                          color: colorScheme.onSurface.withValues(alpha: 0.3),
+                        ),
+                        SizedBox(height: 16),
+                        Text(
+                          l10n.noTemplates,
+                          style: theme.textTheme.titleMedium?.copyWith(
+                            color: colorScheme.onSurface.withValues(alpha: 0.6),
+                          ),
+                        ),
+                        SizedBox(height: 8),
+                        Text(
+                          l10n.tapAddToCreate,
+                          style: theme.textTheme.bodyMedium?.copyWith(
+                            color: colorScheme.onSurface.withValues(alpha: 0.5),
+                          ),
+                        ),
+                      ],
+                    ),
+                  );
+                }
+
+                return ListView.builder(
+                  itemCount: templates.length,
+                  itemBuilder: (context, index) {
+                    final template = templates[index];
+                    return _TemplateListItem(
+                      template: template,
+                      onTap: () => _editTemplate(template),
+                      onDelete: () => _deleteTemplate(template),
+                    );
+                  },
+                );
+              },
+            ),
+      floatingActionButton: FloatingActionButton.extended(
+        onPressed: _addTemplate,
+        icon: Icon(Icons.add),
+        label: Text(l10n.addTemplate),
+      ),
+    );
+  }
+}
+
+/// Template list item widget
+class _TemplateListItem extends StatelessWidget {
+  final SarTemplate template;
+  final VoidCallback onTap;
+  final VoidCallback onDelete;
+
+  const _TemplateListItem({
+    required this.template,
+    required this.onTap,
+    required this.onDelete,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Dismissible(
+      key: Key(template.id),
+      direction: DismissDirection.endToStart,
+      background: Container(
+        color: Colors.red,
+        alignment: Alignment.centerRight,
+        padding: const EdgeInsets.only(right: 20),
+        child: const Icon(Icons.delete, color: Colors.white),
+      ),
+      confirmDismiss: (direction) async {
+        // Show confirmation dialog
+        return await showDialog<bool>(
+          context: context,
+          builder: (context) => AlertDialog(
+            title: Text(AppLocalizations.of(context)!.deleteTemplate),
+            content: Text(
+              AppLocalizations.of(context)!.deleteTemplateConfirmation(template.getLocalizedName(context)),
+            ),
+            actions: [
+              TextButton(
+                onPressed: () => Navigator.of(context).pop(false),
+                child: Text(AppLocalizations.of(context)!.cancel),
+              ),
+              TextButton(
+                onPressed: () => Navigator.of(context).pop(true),
+                style: TextButton.styleFrom(foregroundColor: Colors.red),
+                child: Text(AppLocalizations.of(context)!.delete),
+              ),
+            ],
+          ),
+        );
+      },
+      onDismissed: (direction) => onDelete(),
+      child: ListTile(
+        onTap: onTap,
+        leading: Container(
+          width: 48,
+          height: 48,
+          decoration: BoxDecoration(
+            color: template.color,
+            shape: BoxShape.circle,
+            boxShadow: [
+              BoxShadow(
+                color: template.color.withValues(alpha: 0.3),
+                blurRadius: 4,
+                spreadRadius: 1,
+              ),
+            ],
+          ),
+          child: Center(
+            child: Text(
+              template.emoji,
+              style: const TextStyle(fontSize: 24),
+            ),
+          ),
+        ),
+        title: Row(
+          children: [
+            Text(
+              template.getLocalizedName(context),
+              style: theme.textTheme.titleMedium?.copyWith(
+                fontWeight: FontWeight.w600,
+              ),
+            ),
+            if (template.isDefault) ...[
+              const SizedBox(width: 8),
+              Container(
+                padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+                decoration: BoxDecoration(
+                  color: Colors.blue.withValues(alpha: 0.2),
+                  borderRadius: BorderRadius.circular(4),
+                  border: Border.all(
+                    color: Colors.blue.withValues(alpha: 0.5),
+                  ),
+                ),
+                child: Text(
+                  'DEFAULT',
+                  style: TextStyle(
+                    fontSize: 10,
+                    fontWeight: FontWeight.bold,
+                    color: Colors.blue.shade700,
+                  ),
+                ),
+              ),
+            ],
+          ],
+        ),
+        subtitle: template.description.isNotEmpty
+            ? Text(
+                template.description,
+                maxLines: 1,
+                overflow: TextOverflow.ellipsis,
+                style: theme.textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurface.withValues(alpha: 0.6),
+                ),
+              )
+            : Text(
+                template.toSarMessage(),
+                style: TextStyle(
+                  fontFamily: 'monospace',
+                  fontSize: 12,
+                  color: colorScheme.onSurface.withValues(alpha: 0.5),
+                ),
+              ),
+        trailing: IconButton(
+          icon: const Icon(Icons.delete_outline),
+          color: Colors.red,
+          onPressed: onDelete,
+        ),
+      ),
+    );
+  }
+}